Archivo de la categoría: raspberry pi

Chromium en la Raspberry Pi 2 (debian Jessie)

 

Primero habremos de actualizar la raspberry a debian jessie (aquí instrucciones) y luego:

wget http://launchpadlibrarian.net/185065105/chromium-browser_37.0.2062.120-0ubuntu0.12.04.1~pkg917_armhf.deb

wget http://launchpadlibrarian.net/185065117/chromium-codecs-ffmpeg-extra_37.0.2062.120-0ubuntu0.12.04.1~pkg917_armhf.deb

sudo dpkg -i chromium-codecs-ffmpeg-extra_37.0.2062.120-0ubuntu0.12.04.1~pkg917_armhf.deb chromium-browser_37.0.2062.120-0ubuntu0.12.04.1~pkg917_armhf.deb

Resumidas de aquí:
http://blog.valitov.me/2014/06/installing-google-chromium-on-arm.html?m=1

Actualizar Raspberry Pi 2 a Debian Jessie

Debian Jessie lleva ya un rato en los repositorios de raspbian así que aprovechando que ha salido hacer un par de días la versión estable (y que nos hacen falta algunas librerías que solo están en Jessie :/ ) vamos a actualizar la Raspberry Pi fácilmente:

Nos logueamos como habitualmente y ejecutamos:

pi@raspberrypi ~ $ sudo nano /etc/apt/sources.list

para poder editar el fichero con las fuentes de los paquetes.

Cambiamos todas las apariciones de wheezy:

deb http://mirrordirector.raspbian.org/raspbian/ wheezy main contrib non-free rpi

por jessie:

deb http://mirrordirector.raspbian.org/raspbian/ jessie main contrib non-free rpi

y actualizamos…

pi@raspberrypi ~ $ sudo apt-get update
pi@raspberrypi ~ $ sudo apt-get upgrade

NOTA IMPORTANTE: La actualización lleva unas cuantas horas (8-10 a mi) y rompe algunas cosas (o todo) personalmente di preferencia a los archivos del instalador sobre los que había en la pi.
Y con un poco de suerte, tras reiniciarla, la pi debería volver a la vida con Debian Jessie y la posibilidad de instalar algunas cosas mas, como chromium v37.

 

 

Fuentes:

http://sjoerd.luon.net/posts/2015/02/debian-jessie-on-rpi2/

 

Comunicación I2C Raspberry Pi -> Arduino

Vamos a ver si podemos comunicar una Arduino y una Raspberry Pi mediante I2C. Empezaremos por lo básico: una sola dirección, con la Raspberry Pi como “master” y el arduino como “esclavo”.

Raspi+Arduino

No complicaremos mucho de momento… copia y pega de los ejemplos de Arduino para hacer una recepción de datos por I2C, con alguna pequeña modificación para que las cadenas salgan mejor por pantalla y que pite el buzzer:RasPi Arduino I2C

#include <Wire.h>

int led = 13;
int buzz = 4;

int direccion=31;

void setup() {
  pinMode(led, OUTPUT);
  pinMode(buzz, OUTPUT);
  Wire.begin(direccion);        // nos unimos al bus i2c bus con la dirección #direccion
  Wire.onReceive(receiveEvent); // registramos el evento de recepción de datos
  Serial.begin(9600);
  beep(); // Pos eso... beep... xD
}

void loop() {
  // Ponemos a la placa a hacer algo...
  digitalWrite(led, HIGH);   // Encendemos el led de la placa
  delay(100);               // Esperamos un poco
  digitalWrite(led, LOW);    // Apagamos el led de la placa
  delay(100);               // Esperamos un poco
}

void receiveEvent(int howMany) {
  beep();
  Serial.print("RX:");
  while(Wire.available()>0) // Mientras tengamos caracteres en el buffer
  {
    char c = Wire.read(); // Leemos uno
    Serial.print(c);  // Imprimimos
  }
  Serial.println('|'); // Para que veamos por pantalla cuando acaba
}

void beep() {
  digitalWrite(buzz, HIGH);
  delay(50);
  digitalWrite(buzz, LOW);
}

Y en la parte de la Raspberry Pi algo también muy simple (hay que configurar primero el I2C en la Raspberry Pi)

import smbus
import time
bus = smbus.SMBus(0)

DEVICE_ADDRESS = 0x1F # La misma con la que configuramos el arduino
DEVICE_MODE1 = 0x00
DEVICE_COM0 = 0x48 # 'H'

cadena= [0x48, 0x6f, 0x6c, 0x61] #'H' 'o' 'l' 'a'
#Bucle principal
while True:
    try:
        #bus.write_byte_data(0x1f,DEVICE_MODE1 , DEVICE_COM0 ) #Con esto enviamos un byte
        bus.write_i2c_block_data(DEVICE_ADDRESS, DEVICE_COM0 , cadena) # Con esto enviamos un array de bytes
        time.sleep(0.1)
    except IOError as e:
        print e

Referencias:
http://razzpisampler.oreilly.com/ch10.html

http://wiki.erazor-zone.de/wiki:linux:python:smbus:doc

http://nullege.com/codes/search/smbus.SMBus.read_byte_data

Configurar I2C en la Raspberry Pi

En las Raspberry no viene configurado por defecto el I2C, primero tenemos que activar los modulos:

Editamos:

sudo nano /etc/modules

y añadimos las líneas:

i2c-bcm2708
i2c-dev

Ademas tendremos que instalar esto para disponer de las herramientas de línea de comandos:

sudo apt-get install i2c-tools

Y esto si queremos usar el bus I2C desde python:

sudo apt-get install python-smbus

Ademas tendremos que comprobar que en /etc/modprobe.d/raspi-blacklist.conf no aparecen los mismos módulos de antes. Si aparecen, habrá que comentarlos:

sudo nano /etc/modprobe.d/raspi-blacklist.conf

Y… ¡reiniciamos!

sudo reboot

Con suerte a la vuelta usando el comando i2cdetect (con el valor 1 para la Resumen de la configuración del bus I2C en la Raspberry Pi B 512Mb, 0 para la antigua) podremos detectar los dispositivos que tengamos colgados del bus i2c:

sudo i2cdetect -y 1

Referencias:
https://learn.adafruit.com/adafruits-raspberry-pi-lesson-4-gpio-setup/configuring-i2c
Imagen: http://opensource.com/life/14/3/favorite-raspberry-pi-projects

Mini #smartSantander

Iberobotics

Con el objetivo de escenificar un pequeño #smartSantander para echar un cable a Iberobotics en el Nautilus Lab nos hemos puesto manos a la obra, hemos hecho un sensor bastante simple que mide la intensidad lumínica con una LDR y una Arduino Ethernet, un “servidor” con una Raspberry Pi B y Node.js  y un demostrador básico con otra Arduino Ethernet y un servo que hace las veces de indicador.

No nos hemos complicado mucho: cada 100mS el sensor mide la intensidad y envía al servidor un comando “guardar sensor 0 valor”.
A su vez nuestro indicador envía también cada 100mS al servidor una solicitud “recoger sensor 0” por la que el servidor le devuelve el valor de la intensidad, que adapta al recorrido del servo y muestra.

Aquí abajo os dejamos el código de las 3 aplicaciones, por si queréis echar un vistazo 🙂

-Sensor de luminosidad:

Sensor de luminosidad mini #smartSantander

#include <SPI.h>
#include <Ethernet.h>

byte mac[] = {  0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x01 };
IPAddress ip(192,168,1,21);

// initialize the library instance:
EthernetClient cliente;

char serverName[] = "192.168.1.37";

void setup() {
  Serial.begin(9600);
  pinMode(9, OUTPUT);

  Serial.println("Pidiendo IP por DHCP...");
  if (!Ethernet.begin(mac)) {
    Serial.println("Falló, la ponemos por defecto.");
    Ethernet.begin(mac, ip);
  }
  Serial.print("IP Local:");
  Serial.println(Ethernet.localIP());
  connectToServer();
}

int nSensor=0; // Que sensor tenemos
void loop() {
  int sensorValue;
  sensorValue = analogRead(A0); // Leemos el valor
  Serial.println(sensorValue);
  analogWrite(9, sensorValue*2); // Representamos el valor en la intensidad de un led

  if (cliente.connected()) { // Si estamos conectados al servidor
    cliente.print('g'); // Enviamos el comando de guardar
    cliente.print(nSensor); // Enviamos el número de sensor
    cliente.println(sensorValue); // Enviamos el valor que hemos leído del sensor
    cliente.stop(); // Desconectamos
  } else { // Si no estamos conectados
    connectToServer();
  }
  delay(100);
}

void connectToServer() {
  Serial.println("Conectamos con el servidor");
  if (cliente.connect(servidor, puertoServidor)) {
      Serial.println("conectados...");
  } else {
    delay(1500);
    Serial.println("esperamos...");
  }
}

 

-Servidor “nube” de mini #smartSantander:

Servidor "nube" mini #smartSantander

 

// Load the TCP Library
var net = require('net');

var datos=[0,0,0,0,0];

//Start a TCP Server
net.createServer(function (socket) {
	// Identify this client
	socket.name = socket.remoteAddress + ":" + socket.remotePort ;
	console.log(getDateTime() + ">" + socket.name+" <Hola>");
	socket.on('data', function (data) {
		try {
			data=''+data;
			var orden=data.substr(0,1);
			var nSensor=parseInt(data.substr(1, 1));
			var valor=parseInt(data.substr(2));
			switch (orden) {
				case '?':
					console.log(getDateTime() + ">" + socket.name+" >> Nos piden datos del sensor " + nSensor);
					socket.write(String.fromCharCode(datos[nSensor]+32));
					break;
				case 'g':
					console.log(getDateTime() + ">" + socket.name+" >> Nos envian datos del sensor " + nSensor + ": "+ valor);
					datos[nSensor]=valor;
					break;
				default:
					console.log(getDateTime() + ">" + socket.name+" >> Comando desconocido: " + data);
					break;
			}
		} catch (e) {
			console.log(getDateTime() + ">> Error");
			console.log(e);
		}
		//socket.end();
	});

	socket.on('end', function () {
		console.log(getDateTime() + ">" + socket.name+" <Adios>");
	});
}).listen(8081);

console.log(getDateTime() + ">" + "Escuchando...");

function getDateTime() {

    var date = new Date();

    var hour = date.getHours();
    hour = (hour < 10 ? "0" : "") + hour;

    var min  = date.getMinutes();
    min = (min < 10 ? "0" : "") + min;

    var sec  = date.getSeconds();
    sec = (sec < 10 ? "0" : "") + sec;

    var year = date.getFullYear();

    var month = date.getMonth() + 1;
    month = (month < 10 ? "0" : "") + month;

    var day  = date.getDate();
    day = (day < 10 ? "0" : "") + day;

    return day+'/'+month+'/'+year + " " + hour + ":" + min + ":" + sec;

}

-Demostrador:

Demostrador mini #smartSantander

#include <SPI.h>
#include <Ethernet.h>
#include <Servo.h>

Servo servo;

byte mac[] = {  0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x01 };
IPAddress ip(192,168,1,20);

// initialize the library instance:
EthernetClient cliente;

char servidor[] = "192.168.1.37";
int puertoServidor=8081;

void setup() {
  // put your setup code here, to run once:
  Serial.begin(9600);
  servo.attach(9);

  // attempt a DHCP connection:
  Serial.println("Pidiendo IP por DHCP...");
  if (!Ethernet.begin(mac)) {
    // if DHCP fails, start with a hard-coded address:
    Serial.println("Falló, la ponemos por defecto.");
    Ethernet.begin(mac, ip);
  }
  Serial.print("IP Local:");
  Serial.println(Ethernet.localIP());
  connectToServer();
  servo.write(180);
}

int nSensor=0; // Que número de sensor nos interesa
void loop() {
  if (cliente.connected()) { // Si estamos conectados
    Serial.println("Pedimos datos...");
    cliente.print('?'); // Comando para pedir datos
    cliente.print(nSensor); // Enviamos el número de sensor del que queremos los datos
    delay(100); // Esperamos un poco
    if (cliente.available()) { // Comprobamos si hay datos disponibles
      // leemos el dato
      int inChar = cliente.read();
      int valor=(inChar-32)*4; // Adaptamos el dato (0-40) al rango de nuestro servo (0-180)
      Serial.print("Valor:");
      Serial.println(valor);
      servo.write(180-valor); // Lo mandamos al servo
    }
    cliente.stop(); // Cerramos la conexión
  } else { // No estamos conectados
    connectToServer(); // Nos conectamos
  }
  delay(100);
}

void connectToServer() {
  Serial.println("Conectamos con el servidor");
  if (cliente.connect(servidor, puertoServidor)) {
      Serial.println("conectados...");
  } else {
    delay(1500);
    Serial.println("esperamos...");
  }
}

Servidor http+php en la Raspberry Pi

Ejecutar en este orden para evitar que se configure de manera incorrecta:

El servidor:

sudo apt-get install lighttpd

El intérprete de PHP y la interfaz con el servidor http:

sudo apt-get install php5-common php5-cgi php5

Activación de los scripts php en lighthttpd:

sudo lighty-enable-mod fastcgi-php
sudo service lighttpd force-reload

Damos permisos a www-data en el directorio que tendrá la web:

sudo chown www-data:www-data /var/www/
sudo chmod 775 /var/www/

Y permitimos que el usuario por defecto (pi) pueda escribir en la carpeta agregándolo al grupo www-data:

sudo usermod -a -G www-data pi

 

¡Y listo!

(Basado en: http://www.diverteka.com/?p=1136)

 

Disco Ram

Personalmente lo uso para guardar las fotos que genero en la Raspberry Pi cuando se usa como “webcam” por red, de esta manera no agotamos los ciclos de lectura/escritura de la sd al guardar y leer las fotos de ram (no hay necesidad de guardarlas para después).

Paso a paso: (obviamente, como root o usando sudo)

Creamos un directorio donde montar el disco ram:

mkdir /tmp/ramdisk

Damos permisos totales

chmod 777 /tmp/ramdisk

Montamos un disco ram de 16mB en el directorio que teníamos para ello

mount -t tmpfs -o size=16M tmpfs /tmp/ramdisk/