10 de octubre de 2014

Streaming Video con Java en Raspberry Pi

Streaming de Video con Java en Raspberry Pi


Hay dos modos de crear streming, uno es capturando las fotos (jpeg) que se toman con raspistill, el otro modo es capturando el vídeo (h264) generado con raspivid, como se observa en el tutorial de:   Streaming Video desde el Raspberry Pi, ahora se va generar este streaming con Java.

Como funciona?

Proyectos necesarios vía GitHub:


git clone https://github.com/andrexweb/raspberry-pi.git
Proyecto Maven: StreamingPi
git clone https://github.com/andrexweb/java.git
Proyecto Maven: H264J


El server, es un servidor de paquetes UDP (Datagrama) que esta en el proyecto StreamingPi, el cual solo recibe el flujo de datos, dependiendo de la opción que se incluya jpeg o h264 se activa el reproductor correspondiente, para el caso de h264, es un codec escrito en java que es un "port" de la libreria ffmpeg-libavcodec (pero solo la parte de h264). El proyecto original esta en Google Code h264j, pero copie el proyecto y agregue unas mínimas modificaciones para que reciba el streaming de forma directa, proyecto H264J.

Proyecto disponible en:
GitHub: https://github.com/andrexweb/java
Original: https://code.google.com/p/h264j/


En el momento el reproductor de fotos/vídeo (jpeg/h264) es básico, solo muestra imágenes, próximamente mas opciones.

Para el lado del cliente, es UDP, solo envía lo que genera los aplicativos raspistill y raspisvid, no se usa el modo normal de "pipe" (|), el api de Java cuenta con con una clase que permite la ejecución de comandos y obtener el "stdout" vía inputStreaming.

Ejemplo:


//command: lista de parametros, primero parametro es el comando a ejecutar.
ProcessBuilder  processBuilder = new ProcessBuilder(command);
//Se incia el proceso y se obtiene el inpuStream de la ejecucion, esto es lo que se envía por UDP.
Process process = processBuilder.start();
InputStream  inputStream = process.getInputStream();

Ver Clase para ver implementación completa: 
org.avpsoft.streaming.net.DatagramCommandClient.java

Uso



Opción con raspistill


Primero ejecutamos el servidor (en windows), quien recibe el streaming:

D:\GitHub\raspberry-pi\StreaminPi>java -cp ./target/StreamingPi-1.0-SNAPSHOT.jar org.avpsoft.streaming.main.Streaming 4445 jpeg

Esto nos abre una ventana, donde se mostrara las imágenes.

Ahora ejecutamos el servidor (Raspberry Pi):

pi@raspberrypi ~ $ java -cp ./StreamingPi-1.0-SNAPSHOT.jar org.avpsoft.streaming.main.Streaming 192.168.1.2 4445 raspistill -n -t 0 -tl 150 -th 0:0:0 -w 640 -h 480 -q 5 -o -

Las primeras dos opciones es la ip del servidor y el puerto son fijas, no puede cambiar el orden.




Ejemplo del "lag" (retraso generado) al usar este metodo, 4 segundos, el mejor tiempo que pude registrar estuvo en 3 segundos.


Opción con raspivid

Se requiere este jar adicional H264J-1.0-SNAPSHOT.jar, para el codec h264.
Primero ejecutamos el servidor (en windows), quien recibe el streaming:

D:\GitHub\raspberry-pi\StreaminPi>java -cp ./*.jar org.avpsoft.streaming.main.Streaming 4445 h264

Esto nos abre una ventana, donde se mostrara las imágenes.

Ahora ejecutamos el servidor (Raspberry Pi):

pi@raspberrypi ~ $ java -cp ./StreamingPi-1.0-SNAPSHOT.jar org.avpsoft.streaming.main.Streaming 192.168.1.2 4445  raspivid -n -t 0 -w 640 -h 480 -fps 10 -o -

Las primeras dos opciones es la ip del servidor y el puerto son fijas, no puede cambiar el orden.






Ejemplo del "lag" (retraso generado) al usar este método, es de menos de 1 segundo, mas o menos 300 milisegundos.

Problemas:

* Debido a que se usa UDP y no TCP, es posible que las imágenes se distorsionen, pero es causado por la fiabilidad de la red, si tiene mala señal WIFI eso pasara.
* Cuando se ejecuta el server con h264, es posible que salga errores, pero el streaming sigue funcionando.
* Para terminan la ejecución use Ctrl+C



2 de octubre de 2014

Streaming Video from the Raspberry Pi

Streaming Video desde el Raspberry Pi



A continuacion se menciona las cuatro formas mas usadas para streaming en el Raspberry Pi.


Para habilitar la cámara se debe abrir desde la terminal raspi-config y habilitarla.



Ver:  Enabling the camera

Streaming con VLC

Instalar VLC:  

pi@raspberrypi ~ $ sudo apt-get install vlc

Para su computador descargar la versión que corresponde a su sistema operativo: http://www.videolan.org/

Creando el Streaming

pi@raspberrypi ~ $ raspivid -o - -t 0 -n -w 600 -h 400 -fps 12 | cvlc -vvv stream:///dev/stdin --sout '#rtp{sdp=rtsp://:8554/}' :demux=h264

Para recibir el streaming, se usara VLC en Windows, al abrir VLC Archivo->"Abrir dispositivo de captura...", en la venta que nos abre, seleccionar la pestaña "Red" se ingresa la URL: rtsp://192.168.1.10:8554/ (cambiar por la ip que tenga su Raspberry Pi).



Resultado del Streaming.


El comando raspivid es el usado para capturar vídeo desde la cámara, opciones usadas:

  • "-o -" causa que la salida sea stdout
  • "-t 0" que grabe indefinidamente
  • "-n" que no muestre imagen por la conexión hdmi.
  • "-w xxx" xxx= ancho del video (64 a 1920)
  • "-h yyy" yyy= alto del video (64 a 1080)
  • "-fps nnn" nnn= Frame por segundos (2 a 90) 

Nota: La combinación de parámetros esta condicionada, video a 1080p30, 720p60 y 640x480p60/90.
Ver Opciones: Camera

Opciones usadas de VLC:

  • "-vvv" Verbose ouput (debug y otros).
  • "stream://"   Captura de vídeo.
  • "--sout "    Salida del stream.

Con esta opcion el retraso (lag) del video es mayor a 6 segundos.


Streaming con MJPG-Streamer


Instalación de MJPG-Streamer

pi@raspberrypi ~ $
pi@raspberrypi ~ $ sudo apt-get install libjpeg8-dev imagemagick libv4l-dev


pi@raspberrypi ~ $ mkdir  mjpg-streamer
pi@raspberrypi ~ $ cd mjpg-streamer
pi@raspberrypi ~/mjpg-streamer $ wget http://sourceforge.net/code-snapshots/svn/m/mj/mjpg-streamer/code/mjpg-streamer-code-182.zip

pi@raspberrypi ~/mjpg-streamer $ unzip mjpg-streamer-code-182.zip
pi@raspberrypi ~/mjpg-streamer $ cd mjpg-streamer-code-182/mjpg-streamer
pi@raspberrypi ~/mjpg-streamer/mjpg-streamer-code-182/mjpg-streamer $ sudo ln -s /usr/include/linux/videodev2.h /usr/include/linux/videodev.h
pi@raspberrypi ~/mjpg-streamer/mjpg-streamer-code-182/mjpg-streamer $ make

Uso:

Consola 2: (se abre otra consola)
pi@raspberrypi ~ $ mkdir /tmp/stream 
pi@raspberrypi ~ $ raspistill --nopreview -w 640 -h 480 -q 5 -o /tmp/stream/pic.jpg -tl 100 -t 9999999 -th 0:0:0

Consola 1: (donde se estaba trabjando)
pi@raspberrypi ~/mjpg-streamer/mjpg-streamer-code-182/mjpg-streamer $ ./mjpg_streamer -i "./input_file.so -f /tmp/stream -n pic.jpg" -o "./output_http.so -w ./www"


Abrir el Navegador con esta ruta: http://192.168.1.2:8080/  (La ip es la del Raspberry Pi).






Al lado derecho se tienen las diferentes opciones del Streaming.

Con esta opcion el retraso (lag) del video es mayor a 3 segundos.

Fuente: How to build and run MJPG-Streamer on the Raspberry Pi  y  Step 5: Get the webcam streamer for Raspberry Pi


Streaming con nc & mplayer


Instalación:

NC: NetCat es una herramienta sencilla que permite crear conexiones de red TCP/UDP, sea cliente o server para trasmitir mensajes, en la mayoria de los sistemas Linux trae este comando (hasta el momento no he visto un Linux que no lo traiga). Pero para windows el tema es otro, hay que descargarlo de una fuente fiable o descargar el fuente y compilarlo. He decido por la primera descargarlo de una fuente fiable, asi que me dirige a nmap y descargar nmap para windows, entre sus archivos tiene una version para windows de NetCat. La version usada es nmap-6.47-win32.zip, al descomprimir necesitamos solo tres archivos ncat.exe, libeay32.dll y ssleay32.dll.

mplayer: Es un reproductor multimedia libre, existe version para Windows. Se descarga de: mplayer para windows y el archivo mplayer-svn-37292-x86_64.7z 


Uso:

Primero en la consola cmd de windows no situamos donde se haya descomprimido el archivo de mplayer.
(a esta carpeta copiar los archivos de netcat).

En windows:

D:\mplayer-svn-37291-x86_64>ncat.exe -u -l 5001 | mplayer.exe -fps 60 -cache 1024 -

En el Raspberry Pi:

pi@raspberrypi ~ $ raspivid -n -t 0 -w 640 -h 480 -fps 10 -o - | nc -u 192.168.1.2 5001

La IP que se pone en el Raspberry Pi, es la IP de su computador, ya que el PC actua como server y el Rpi como server.

Al inicio tarda un poco mplayer en abrir la ventana del video, despues de abierta el straming es inmediato.






A diferencia de las otras opciones el retraso (lag) del video es menor a 300 milisegundos.


Fuente: What streaming solution for the Picam has the smallest lag?



Streaming con GSTREAMER


GStreamer: es un framework multimedia libre multiplataforma.

Instalacion:

En windows, se descarga directamente de Download GStreamer o ir directamente a windows y decargar la version que se necesita, para este caso gstreamer-1.0-x86_64-1.4.3.msi

En el Raspberry Pi,

pi@raspberrypi ~ $ sudo apt-get install gstreamer1.0

Algunos tutoriales dicen que hay que agregar un repositorio extra, en este caso no se hizo.

Uso:

En el Raspberry Pi:

pi@raspberrypi ~ $ raspivid -n -t 0 -h 720 -w 1080 -fps 25 -b 2000000 -o - | gst-launch-1.0 -v fdsrc ! h264parse !  rtph264pay config-interval=1 pt=96 ! gdppay ! tcpserversink host=192.168.0.200 port=5000

En Windows:

D:\gstreamer\1.0\x86_64\bin>gst-launch-1.0 -v tcpclientsrc host=192.168.0.200 port=5000  ! gdpdepay !  rtph264depay ! avdec_h264 ! videoconvert ! autovideosink sync=false

La ip que se ve en los comandos se cambia por la IP que tenga el Raspberry Pi.



Esta opcion como la anterior tienen un retraso (lag) del video menor de 300 milisegundos.


Fuente: Raspberry Pi camera board – Gstreamer


Artículos externos relacionados:




28 de septiembre de 2014

LCD+Keypad Kit for Raspberry Pi with Java

Kit LCD + teclado para Raspberry Pi con Java


Este Kit es vendido por Adafruit el cual trae los siguientes componentes:
  • Resistencias:
    • 2 de 220 ohm al 5%
    • 1 de 330 ohm al 5%
  • Un potenciometro ajustable de 10K
  • 5 pulsadores de 5x6mm
  • Expansor de puerto i2c: MCP23017
  • Una tira de 36 pines de conector macho
  • PCB kit
  • Bumper (Adhesibo grueso).
  • Character LCD 16x2 RGB (Positivo o Negativo). 
  • Header de 2x16

Imagen de Adafruit



Componentes adicionales que no vienen en el kit:
  • Raspberry Pi
  • Cinta aislante negra
  • Una base para chip integrado de 28 pines. (opcional).

 Armado


 Según el manual de Adafruit (assembly), se debe hacer en este orden:
  • Soldar la resistencia de 330 ohm en la etiqueta que dice GRN.
  • Soldar las otras dos resistencias.
  • Soldar los cinco pulsadores.
  • Soldar el potenciometro
  • Soldar el MCP23017, pero aquí un pequeño cambio, soldar la base de 28 pines, se recomienda esto para cuando no se sabe soldar muy bien y el exceso de calor no dañe el chip i2c, y también sirve cuando se requiere reutilizar MCP23017.
  • Soldar el "Header 2x16"
  • Soldar la tira de 18 pines al Display-LCD
  • Soldar (unir) el Diaply con el PCD-Kit.
  • Poner doble capa de cinta aislante negra en la pare de las resistencias, debido que al ponerlo sobre el Raspberry Pi  Model B+, los nuevos puertos USB hacen contantacto con las terminaciones de la resistencias.

El resultado es:





 Al conectar el LCD al Raspberry Pi tenga en cuenta la proteccion con la cinta adesiva.

Imagen de Adafruit

Para conectarlo se puede emsamblar directamente sobre el Raspberry Pi, o solo realizar las siguientes conexiones:
  • Conectar GND a GND del Kit Plate
  • Conectar 5V a 5V del Kit Plate
  • Conectar SDA a SDA del Kit Plate
  • Conectar SCL a SCL del Kit Plate
El Kit Plate tiene los mismos pin header de 26 pines del Raspberry PI Model A o B.



Controlador (Java)


El software esta disponible para descarga en:

git clone https://github.com/andrexweb/raspberry-pi.git

 Para saber como instalar el ambiente de desarrollo y otros usos ver:
Se necesita tener habilitado I2C:
Para usar el ejemplo en Python ver Adafruit: Usage - Character LCD+Keypad for Raspberry Pi

Uso

Cuando se ha descargado el código, se procede a abrir el proyecto con Netbeans, procedemos a abrir la clase rpi.main.Main, en esta clase observaremos los ejemplos que podemos correr, por defecto esta habilitado un ejemplo base, que para este caso NO Sirve, asi que cuando usemos el LCD+Keypad kit solo podemos usar el ejemplo que esta en la clase char_lcd_plate.java


//exampleCharLCD = new char_lcd();
//exampleCharLCD = new char_lcd_rgb();
//exampleCharLCD = new char_lcd_rgb_pwm();
//exampleCharLCD = new char_lcd_rgb_mcp();
exampleCharLCD = new char_lcd_plate();

Y se pueden usar todos lo metodos disponibles para "Character LCD con Raspberri Pi" menos las opciones del PWM, ya que el control del RGB se haciendo por el chip I2C MCP23017 y este no tiene PWM. La clase char_lcd_plate.java que tiene implementado los eventos de los pulsadores es basica: La configuracion, recibe el codigo del boton (pin del MCP23017), el nombre y la configuracion de color, el color usado en el ejemplo para cambiar el color cuando presionan un boton.

//Configuracion de los botones
buttons = new Button[]{
          new Button(SELECT, "Select", new int[]{1,1,1}),
          new Button(LEFT, "Left", new int[]{1,0,0}),
          new Button(UP, "Up", new int[]{0,0,1}),
          new Button(DOWN, "Down", new int[]{0,1,0}),
          new Button(RIGHT, "Right", new int[]{1,0,1})
        };

Ciclo para detectar que boton fue presionado.
//# Loop through each button and check if it is pressed.
        while(lcdPlate){
            for(Button button : this.buttons){
                if(lcd.is_pressed(button.getCode())){
                    try {
                        //# Button is pressed, change the message and backlight.
                        lcd.clear();
                        lcd.message(button.getName());
                        lcd.set_color(button.getRgb()[0],button.getRgb()[1],button.getRgb()[2]);
                    } catch (IOException ex) {
                        Logger.getLogger(char_lcd_plate.class.getName()).log(Level.SEVERE, null, ex);
                    }
                }
            }
            try {
                Thread.sleep(250);
            } catch (InterruptedException ex) {
                Logger.getLogger(char_lcd_plate.class.getName()).log(Level.SEVERE, null, ex);
            }
        }


Cuando  este ejecutando el ejemplo no olvide ajustar el potenciometro (contraste) para visualizar los caracteres.


Nota: Esta es una implementación en Java ME Embedded del código que esta disponible por parte de Adfruit, el código original esta escrito en Python. Para ver el tutorial y código en Python dirigirse a la pagina de Adafruit.



25 de septiembre de 2014

Java Device I/O


Java Device I/O o DIO es la librería que trae Java ME Embedded, que por el momento el JDK no lo trae, solo esta en el código del openJDK pero podemos descargar el código, compilarlo y usarlo.

Instalación

Instalamos la ultima versión jdk 8:

pi@raspberrypi ~ $ sudo apt-get install oracle-java8-jdk
pi@raspberrypi ~ $ java -version
java version "1.8.0"
Java(TM) SE Runtime Environment (build 1.8.0-b132)
Java HotSpot(TM) Client VM (build 25.0-b70, mixed mode)

pi@raspberrypi ~ $


 Descargamos DIO de OpenJDK: Device I/O Project

Primero instalar mercurial (repositorio)

pi@raspberrypi ~ $ sudo apt-get install mercurial
Prodemos a monstar el ambiente para generar DIO:
pi@raspberrypi ~ $ mkdir java-dio
pi@raspberrypi ~ $ cd java-dio/
pi@raspberrypi
~/java-dio $

pi@raspberrypi ~/java-dio $ cd dev/
pi@raspberrypi ~/java-dio/dev $ hg clone http://hg.openjdk.java.net/dio/dev 

pi@raspberrypi ~/java-dio/dev $ export PI_TOOLS=/usr
pi@raspberrypi ~/java-dio/dev $ export JAVA_HOME=/usr/lib/jvm/jdk-8-oracle-arm-vfp-hflt
pi@raspberrypi ~/java-dio/dev $ make

Después de compilar, nos genera una carepta build/ donde están las librerias y ejemplos que trae
  • build/so -> libdio.so  Librería nativa para Raspberry Pi
  • build/jar -> dio-samples.jar  dio.jar  Archivos Java compilados, ejemplos y librería dio.
En la carpeta  samples/gpio/ se encuentra un archivo llamo gpio.policy este archivo se necesita para cargar los permisos al momento de ejecutar los ejemplos. Para ejecutar un ejemplo que trae, se debe tener dio-samples.jar, dio.jar,  libdio.so y gpio.policy en una misma carpeta.

Si estamos parados en la carpeta que se creo java-dio hacemos los siguiente:

pi@raspberrypi ~/java-dio $
pi@raspberrypi ~/java-dio $ cp dev/build/jar/*.jar . 
pi@raspberrypi ~/java-dio $ cp dev/build/so/libdio.so .
pi@raspberrypi ~/java-dio $ cp dev/samples/gpio/gpio.policy .
pi@raspberrypi ~/java-dio $ ls
dev  dio-samples.jar  dio.jar  gpio.policy  libdio.so
pi@raspberrypi ~/java-dio $


Pruebas y Ejemplos

El ejemplo que nos proporciona la pagina de DIO: Getting Started

Prerequisites:
1 LED
1 resistor (540 ohm)
1 breadboard
1 Raspberry Pi
jumper wires

The dio.jar, dio.samples.jar and libdio.so should be in your current directory, and java should be in your path.

1. Connect the cathode of the LED to GND on the Raspberry Pi.
2. Connect the anode of the LED to a resistor (540 ohm pictured above).
3. Connect the other end of the resistor to GPIO18 on the Raspberry Pi


Y se ejecuta de esta forma:


sudo java -Djava.security.policy=./gpio.policy -classpath .:./dio.jar:dio-samples.jar -Djava.library.path=. -Djdk.dio.registry=./dio.properties dio.gpio.GPIOLEDSample


Ahora vamos a ejecutar los ejemplos (ver al final los enlaces) que se han realizado para Java ME Embeddded y los ejecutamos de manera normal (jdk).

Se ha agregado una clase al proyecto rpi.main.DIOMain.java que tiene main para ser ejecutado, en esta clase hacemos lo mismo que en los anteriores ejemplos, comentar o descomentar el ejemplo que se requiera ejecutar:

public class DIOMain {

    public static void main(String args[]) throws IOException, InterruptedException {
      
        ExampleCharLCD exampleCharLCD = null;
      
        exampleCharLCD = new char_lcd();

        //exampleCharLCD = new char_lcd_rgb();

        //exampleCharLCD = new char_lcd_rgb_pwm();

        //exampleCharLCD = new char_lcd_mcp();
      
      
      
        exampleCharLCD.init();
        exampleCharLCD.stop();
    }

}


Para ejecutar el demo en el Raspberry Pi procedemos a copiar el jar que se encuentra en la carpeta del proyecto dist/  el nombre del jar es JavaMECharLCD.jar  lo copiamos en /home/pi/java-dio/ , antes de ejecutar configuramos un archivo java.policy con los permisos para la prueba.


grant {
        permission jdk.dio.gpio.GPIOPinPermission "*:*", "open,setdirection";
        permission jdk.dio.DeviceMgmtPermission "*:*", "open";
        permission jdk.dio.i2cbus.I2CPermission "*:*", "open";
};

Y procedemos a ejecutar:

sudo java -Djava.security.policy=./java.policy -classpath .:./dio.jar:JavaMECharLCD.jar -Djava.library.path=. -Djdk.dio.registry=./dio.properties rpi.main.DIOMain

pi@raspberrypi ~/java-dio $ sudo java -Djava.security.policy=./java.policy -classpath .:./dio.jar:JavaMECharLCD.jar -Djava.library.path=. -Djdk.dio.registry=./dio.properties rpi.main.DIOMain

De esta forma no estamos limitados a las API de JMEE, sino que tenemos todo el JDK, pero se recuerda que el consumo de memoria y procesamiento aumenta.

Ejemplos anteriores:

Nota: El proyecto no requiere cambios, se puede usar el mismo proyecto que es para Java ME Embedded, solo requiere una clase con un main para ser ejecutado.

23 de septiembre de 2014

Custom Glyphs Character LCD Raspberry Pi

Con el Character LCD que se ha usado en los ejemplos, nos permite crear hasta ocho(8) glifos (símbolos) que podemos mostrar en el LCD.

El character LCD que vende adafruit RGB backlight positive LCD 16x2 + extras solo muestra texto en Ingles/Japones como se muestra en la siguiente tabla:


La segunda tabla que se muestra en el datasheets del HD44780 es de otra versión de este LCD. Asi que, si queremos mostrar un carácter que no este en la tabla A00 hay que crearlo. Para esto el LCD nos da la opción de crear un simbolo con el "Character Generator RAM (CGRAM)", en esta memoria podemos crear los nuevos caracteres, para una matriz de 5x8 hasta 8 caracteres y la matriz 5x10 hasta 4 caracteres, nos centraremos en la creación de caracteres de 5x8 puntos.

Para realizar esto nos basamos en lo que nos dice el datasheets del LCD.


En resumen:
  • Se necesitan 8 lineas de 5 bits, para generar un carácter, los otros tres bits no se usan.
  • Para mostrarlo en pantalla se usa la representación del carácter 0x0 hasta 0x7 (solo 3 bits).
  • En el data datasheets indica que la dirección de escritura  0x40  con dirección inicial 0, es decir 0x40 + 0 hasta 0x40 + 0x7 iría el primer carácter.  Si escribimos los 8 caracteres no tenemos que especificar la dirección de cada uno sino que esta se autoincrementa.

En el código que se ha  usado se adiciono una función para guardar (solo mientras el lcd esta prendido, cuando se apague se pierden los datos, es una ram) el nuevo carcater en el codigo especifico, solo hay que enviarle el numero de carácter y un array con los 8 bytes que representan el carácter.

Archivo: Adafruit_CharLCD.java
public void customGlyphs(int characterCode,int[] customGlyphs) throws IOException{
       
        int cgramaddr = LCD_SETCGRAMADDR;
        if( (displayfunction & LCD_5x8DOTS) == LCD_5x8DOTS){
            cgramaddr |= characterCode * 8;
            if(characterCode > 8){
                throw new RuntimeException("Character code invalid, only [0,7] not"+characterCode);
            }
        }else if((displayfunction & LCD_5x10DOTS) == LCD_5x10DOTS){
            cgramaddr |= characterCode * 10;
            if(characterCode > 4){
                throw new RuntimeException("Character code invalid, only [0,4] not"+characterCode);
            }
        }
        write8(cgramaddr);
        for(int cg : customGlyphs){
            write8(cg,true);
        }
    }

Ejemplo:

int[] customGlyphs_smile = {0x00,0x00,0x0a,0x00,0x11,0x0e,0x00,0x00}; // :)
lcd.customGlyphs(2,customGlyphs_smile);



Para generar un carácter podemos usar el siguiente script:



#43210binariohexadecimaldecimal



Nos permite generar los caracteres, de forma visual y obtener el código para nuestro programa, solo seleccionamos la cantidad de puntos (5x8), y este nos genera una tabla donde podemos dibujar el glifo que necesitamos.

Generamos el array con el glifo, y procedemos a usarlo en el LCD.

Ejemplo:


int[] customGlyphs_smile = {0x00,0x00,0x0a,0x00,0x11,0x0e,0x00,0x00}; // :)
lcd.customGlyphs(2,customGlyphs_smile); 
....
lcd.message("Mi smile "+ (char)2 );
....



Codigo fuente:

https://github.com/andrexweb/raspberry-pi


Fuente:

19 de septiembre de 2014

I2C Character LCD con Raspberry Pi


Basados en la entra anterior Character LCD con Raspberry Pi, vemos que se han usados muchos GPIO para realizar la conexión, asi que para reducir el uso uso de GPIO usaremos el bus I2C para la conexión. Pero el Character  LCD no tiene I2C, entonces agregamos un chip expansor que tiene este soporte, como el MCP23017, es un chip I2C que tiene 16 pins de múltiple propósito (Input/Output).

Materiales:

*Este demo esta construido con los productos que venden directamente Adafruit o sus distribuidores, ver nota al final de la pagina.



Armado (Cableado)


Comenzaremos colocando los dispositivos en la protoboard como se muestra en la siguiente imagen:


Para realizar las conexiones hay que tener en cuenta el nombre/numero de los pines del chip MCP23017:



Y procedemos a conectar:

  • Conecte el RPi 3.3V a la linea (Vcc) de la protoboard, y de este conecte:
    • Un cable al pin   9 del MCP (VDD).
    • Un cable al pin 18 del MCP (RESET).
  • Conecte el RPi GND a linea de tierra de la protoboard, y de este conecte:
    • Un cable al pin 10 del MCP (VSS).
    • Un cable al pin 15 del MCP (A0).
    • Un cable al pin 16 del MCP (A1).
    • Un cable al pin 17 del MCP (A2).
    • Un cable al lado izquierdo del potenciometro.
    • Un cable al pin 1 del LCD (VSS).
    • Un cable al pin 5 del LCD (R/W).
  • Conecte el RPi 5.0V a lado derecho del potenciometro, y:
    • Un cable al pin   2 del LCD (VDD).
    • Un cable al pin 15 del LCD (LED+).
  • Conecte el pin del medio del potenciometro al pin 3 del LCD (V0/Contrast).
  • Conecte el RPi I2C SCL al pin 12 del MCP (SCL).
  • Conecte el RPi I2C SDA al pin 13 del MCP (SDA).
  • Conecte el pin 21 del MCP (GPIOA0) al pin 4 del LCD (RS).
  • Conecte el pin 22 del MCP (GPIOA1) al pin 6 del LCD (E/clock enable).
  • Conecte el pin 23 del MCP (GPIOA2) al pin 11 del LCD (DB4).
  • Conecte el pin 24 del MCP (GPIOA3) al pin 12 del LCD (DB5).
  • Conecte el pin 25 del MCP (GPIOA4) al pin 13 del LCD (DB6).
  • Conecte el pin 26 del MCP (GPIOA5) al pin 14 del LCD (DB7).
  • Conecte el pin 27 del MCP (GPIOA6) al pin 16 del LCD (-R/red).
  • Conecte el pin 28 del MCP (GPIOA7) al pin 17 del LCD (-G/green).
  • Conecte el pin   1 del MCP (GPIOB0) al pin 18 del LCD (-B/blue).
La conexión solo usa 4 bits para la transferencia de datos DB4 a DB7. Por tal motivo queda 4 pines del LCD sin conectar. Y de esta forma podemos usar los otros GPIO del MCP para otros usos. Poner mucho cuidado, algunos pasos usan 5.0V y otros 3.3V no confundir.


En el prototipo se ve así:

 



En la realidad se ve así:








Nota: Cuando este realizando la prueba de funcionamiento no olvide ajustar el potenciometro para ajustar el contraste del LCD, de lo contrario es posible que la luz de fondo se encienda y no vean caracteres en la pantalla.

Antes de probar, hay que habilitar el I2C en el Raspberry Pi ver: Configurando I2C en Raspberry Pi


Controlador (Software JMEE)


Instalación

Se necesita tener instalado el ambiente de desarrollo para Java Micro Edition Embedded; para saber como se instala ver este entrada: Instalación Java ME Embedded


Luego de la instalación del ambiente podemos descargar el código del repositorio:

git clone https://github.com/andrexweb/raspberry-pi.git


Uso

Cuando se ha descargado el código, se procede a abrir el proyecto con Netbeans, procedemos a abrir la clase rpi.main.Main, en esta clase observaremos los ejemplos que podemos correr, pero este ejemplo solo podemos usar la clase char_lcd_mcp. Asi que solo habilitaremos ese ejemplo cuando usamos el MCP23017.

//exampleCharLCD = new char_lcd();
//exampleCharLCD = new char_lcd_rgb();
//exampleCharLCD = new char_lcd_rgb_pwm();
exampleCharLCD = new char_lcd_mcp();

Recuerde que antes de probar, hay que habilitar el I2C en el Raspberry Pi ver: Configurando I2C en Raspberry Pi

Si se ha seguido el manual al pie de la letra, los ejemplos han de funcionar bien, en caso de no usar los GPIO del MCP23017 como se indico anteriormente, se debe abrir la clase del  ejemplo y cambiar los parámetros, es decir indicar cuales GPIO fueron usados. Se debe reemplazar los usados.

Archivo: char_lcd_mcp.java
//# Raspberry Pi configuration:
int lcd_rs = 0; //# Pin MCP GPIOA0  
int lcd_en = 1; //# Pin MCP GPIOA1  
int lcd_d4 = 2; //# Pin MCP GPIOA2
int lcd_d5 = 3; //# Pin MCP GPIOA3
int lcd_d6 = 4; //# Pin MCP GPIOA4
int lcd_d7 = 5; //# Pin MCP GPIOA5
int lcd_red = 6; //# Pin MCP GPIOA6
int lcd_green = 7; //# Pin MCP GPIOA7
int lcd_blue = 8; //# Pin MCP GPIOB0


Esta clase usa un controlador para que el I2C se comporte como una extensión del Raspberry Pi, entonces solo es cambiar el uso de GPIO, es decir, que el aplicativo ya no use los GPIO del Raspberry Pi sino que uso los GPIO del chip conectado por I2C. La clase encargada para esto es: MCP23017.java


Archivo: char_lcd_mcp.java
baseGPIO = new MCP23017();
//# Se inicializa el constructor con los GPIO a usar.
lcd = new Adafruit_RGBCharLCD(lcd_rs, lcd_en, lcd_d4, lcd_d5, lcd_d6, lcd_d7,
lcd_columns, lcd_rows, lcd_red, lcd_green, lcd_blue,baseGPIO);


Para configurar la cantidad de lineas que soporta el LCD se debe de cambiar los parámetros por uno de estas opciones:  16x1, 16x2 y 16x4

Archivo: char_lcd_mcp.java
//# Define LCD column and row size for 16x2 LCD.
int lcd_columns = 16;
int lcd_rows = 2;

Para visualizar un mensaje con luz de fondo rojo seria de la siguiente forma:

//# El color esta en RGB, pero debido a la falta de PWM, solo funciona 1.0f o 0.0f en cada color.
lcd.set_color(1.0f, 0.0f, 0.0f);
lcd.clear();
lcd.message("Linea 1\nLinea 2");

*PWM: modulación por ancho de pulsos (pulse-width modulation).


La clase que hace de controlador es Adafruit_RGBCharLCD (hereda de Adafruit_CharLCD), en esta clase están los métodos con los cuales es posible realizar la comunicación entre el Raspberry Pi y el Character LCD, el LCD debe ser compatible con Hitachi HD44780 LCD controller, en caso de que no sea compatible hay que escribir un nuevo controlador.

La clase principal proporciona los siguientes métodos:
  • home(): posiciona el cursor al inicio.
  • clear(): limpia el LCD
  • set_cursos(col,row): posiciona el cursor en la columna y linea indicada.
  • show_cursos(show): muestra el cursor en pantalla.
  • move_left() y move_right(): mueve el texto en el LCD, a la izquierda o a la derecha.
  • message(text): el mensaje a mostrar.
  • set_backlight(backlight) para el caso de la clase Adafruit_CharLCD.java activa o desactiva la luz de fondo, para mostrar un color particular usar la clase Adafruit_RGBCharLCD.java y usar el método set_color(R,G,B).
Nota: Esta es una implementación en Java ME Embedded del código que esta disponible por parte de Adfruit, el código original esta escrito en Python. Para ver el tutorial y código en Python dirigirse a la pagina de Adafruit.
El código es Open Source.




Raspberry Pi is a trademark of the Raspberry Pi Foundation, http://www.raspberrypi.org

Adafruit, http://www.adafruit.com

Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners. http://www.oracle.com

17 de septiembre de 2014

Character LCD con Raspberry Pi


Un "Character LCD" es una matriz de puntos en una pantalla de cristal liquido (dot matrix liquid crystal display). Estos LCD permiten mostrar caracteres alfanuméricos con una simple interfase la cual se puede conectar a un microcontrolador (para este caso un Raspberry Pi).

En esta demo se van a usar un Character LCD 16x2, Raspberry Pi y un controlador escrito en Java Micro Edition Embedded, mas algunos accesorios.

Lista completa de Componentes*:
*Este demo esta construido con los productos que venden directamente Adafruit o sus distribuidores, ver nota al final de la pagina.

Armado (Cableado)


Primero se empezara colocando los dispositivos en la protoboard como se muestra en la siguiente imagen:


Luego se realizara el cableado de la siguiente forma:
  • Conecte el RPi 5.0V  a la linea (vcc) de la protoboard, y de este conecte:
    • Un cable al pin derecho del potenciometro.
    • Un cable al pin 2 del LCD (VDD).
    • Un cable al pin 15 del LCD (LED+).
  • Conecte el RPi GND a linea de tierra de la protoboard, y de este conecte:
    • Un cable al pin izquierdo del potenciometro.
    • Un cable al pin 1 del LCD (VSS).
    • Un cable al pin 5 del LCD (R/W).
  • Conecte el pin del medio del potenciometro al pin 3 del LCD (V0/contrast).
  • Conecte el pin 27 del RPi al pin   4 del LCD (RS).
  • Conecte el pin 22 del RPi al pin   6 del LCD (E/clock enable).
  • Conecte el pin 25 del RPi al pin 11 del LCD (DB4).
  • Conecte el pin 24 del RPi al pin 12 del LCD (DB5).
  • Conecte el pin 23 del RPi al pin 13 del LCD (DB6).
  • Conecte el pin 18 del RPi al pin 14 del LCD (DB7).
  • Conecte el pin   4 del RPi al pin 16 del LCD (-R/red).
  • Conecte el pin 17 del RPi al pin 17 del LCD (-G/green).
  • Conecte el pin 7 / CE1 del RPi al pin 18 del LCD (-B/blue).
La conexion solo usa 4 bits para la transferencia de datos DB4 a DB7. Por tal motivo queda 4 pines del LCD sin conectar. No se esta conectando directamente el Raspberry Pi, sino que se hace por medio de T-Cobbler y su respectivo cable de 40 pin.

En el prototipo se ve así:


En la realidad se ve así:





Nota: Cuando este realizando la prueba de funcionamiento no olvide ajustar el potenciometro para ajustar el contraste del LCD, de lo contrario es posible que la luz de fondo se encienda y no vean caracteres en la pantalla.

 

Controlador (Sotfware JMEE)


Instalación

Se necesita tener instalado el ambiente de desarrollo para Java Micro Edition Embedded; para saber como se instala ver este entrada: Instalación Java ME Embedded


Luego de la instalación del ambiente podemos descargar el código del repositorio:

git clone https://github.com/andrexweb/raspberry-pi.git


Uso

Cuando se ha descargado el código, se procede a abrir el proyecto con Netbeans, procedemos a abrir la clase rpi.main.Main, en esta clase observaremos los ejemplos que podemos correr, por defecto esta habilitado un ejemplo base:


exampleCharLCD = new char_lcd();
//exampleCharLCD = new char_lcd_rgb();
//exampleCharLCD = new char_lcd_rgb_pwm();

Si usamos el ejemplo "char_lcd_rgb()" con el Character LCD 16x2 RGB backlight, podemos variar la luz de fondo del LCD; El ejemplo char_lcd_pwm(),  deberia de mostrar una amplia gama de colores pero no es posible en un Raspberry Pi, no tiene GPIO con PWM, y la emulación por código en Java no es muy eficiente además de un alto consumo de CPU.

Si se ha seguido el manual al pie de la letra, los ejemplos han de funcionar bien, en caso de no usar los GPIO del Raspberry Pi como se indico anteriormente, se debe abrir la clase de cada ejemplo y cambiar los parámetros, es decir indicar cuales GPIO fueron usados. Se debe reemplazar los usados.

Archivo: char_lcd_rgb.java o char_lcd.java
//# Raspberry Pi configuration:
int lcd_rs = 27; //# Change this to pin 21 on older revision Raspberry Pi's
int lcd_en = 22;
int lcd_d4 = 25;
int lcd_d5 = 24;
int lcd_d6 = 23;
int lcd_d7 = 18;
int lcd_red = 4;
int lcd_green = 17;
int lcd_blue = 7; //# Pin 7 is CE1

Para configurar la cantidad de lineas que soporta el LCD se debe de cambiar los parámetros por uno de estas opciones:  16x1, 16x2 y 16x4

Archivo: char_lcd_rgb.java
//# Define LCD column and row size for 16x2 LCD.
int lcd_columns = 16;
int lcd_rows = 2;

Para visualizar un mensaje con luz de fondo rojo seria de la siguiente forma:

//# El color esta en RGB, pero debido a la falta de PWM, solo funciona 1.0f o 0.0f en cada color.
lcd.set_color(1.0f, 0.0f, 0.0f);
lcd.clear();
lcd.message("Linea 1\nLinea 2");

*PWM: modulación por ancho de pulsos (pulse-width modulation).


La clase que hace de controlador es Adafruit_CharLCD, en esta clase están los métodos con los cuales es posible realizar la comunicación entre el Raspberry Pi y el Character LCD, el LCD debe ser compatible con Hitachi HD44780 LCD controller, en caso de que no sea compatible hay que escribir un nuevo controlador.

La clase principal proporciona los siguientes métodos:
  • home(): posiciona el cursor al inicio.
  • clear(): limpia el LCD
  • set_cursos(col,row): posiciona el cursor en la columna y linea indicada.
  • show_cursos(show): muestra el cursor en pantalla.
  • move_left() y move_right(): mueve el texto en el LCD, a la izquierda o a la derecha.
  • message(text): el mensaje a mostrar.
  • set_backlight(backlight) para el caso de la clase Adafruit_CharLCD.java activa o desactiva la luz de fondo, para mostrar un color particular usar la clase Adafruit_RGBCharLCD.java y usar el método set_color(R,G,B).

Nota: Esta es una implementación en Java ME Embedded del código que esta disponible por parte de Adfruit, el código original esta escrito en Python. Para ver el tutorial y código en Python dirigirse a la pagina de Adafruit.
El código es Open Source.




Raspberry Pi is a trademark of the Raspberry Pi Foundation, http://www.raspberrypi.org

Adafruit, http://www.adafruit.com

Oracle and Java are registered trademarks of Oracle and/or its affiliates. Other names may be trademarks of their respective owners. http://www.oracle.com

14 de septiembre de 2014

Configurando I2C en Raspberry Pi


I2C: Es un bus de comunicaciones en serie, muy usado en dispositivos embebidos, solo utiliza tres lineas, SDA=datos,SCL=reloj y GND=Tierra.

Para habilitar el I2C se requieren cargar dos modulos i2c-bcm2708 y i2c-dev, pasos:

Paso 1: Ingresar por SSH (putty) al raspberry pi
Paso 2: Editar el archivo modules
pi@raspberrypi ~ $ sudo nano /etc/modules
Paso 3: Agregar dos lineas al archivo
i2c-bcm2708
i2c-dev



Paso 4: Guardamos y reiniciamos.
pi@raspberrypi ~ $ sudo reboot

Por defecto estos módulos vienen deshabilitados se procede a habilitarlos.
Paso 5: Editar raspi-blacklist.conf, comentamos las lineas con #
pi@raspberrypi ~ $ sudo nano /etc/modprobe.d/raspi-blacklist.conf



Paso 6: Guardamos y reiniciamos
pi@raspberrypi ~ $ sudo reboot
Paso 7: Si tenemos un dispositivos conectado al I2C lo veremos con el siguiente comando
pi@raspberrypi ~ $ sudo i2cdetect -y 1
Usar port 0 cuando es un raspberry pi con 256 Mb de Ram. Versiones viejas.



Nota: Pasos aplicados a a versión SO: 2014-06-20-wheezy-raspbian, Raspberry Pi Model B+