RPI ++

Participación en las VII Jornadas de Innovación Docente e Investigación Educativa y entrevista en Radio María

2013-09-13T18:29:00.001+01:00

Ayer participamos en las VII Jornadas de Innovación Docente e Investigación Educativa (J.I.I.E. 2013) de la Universidad de Zaragoza. En primer lugar desde aquí, dar la enhorabuena y gracias a las personas que las organizaron, me parecieron muy útiles y considero que es un formato que deberíamos exportar a Secundaria y F.P., ya que creo que podemos aprender, en general, más del compañero que está a pie de aula que de alguien que está alejado de nuestro entorno y no conoce nuestra problemática e idiosincrasia. Además, es increíble la cantidad de sinergias que confluyen y grupos de investigación multidisciplinares que pueden surgir.

La ponencia consideramos que fue bien (ver póster) y la orientamos más a contar la metodología y cómo habíamos distribuido los resultados del trabajo porque había profesores de múltiples disciplinas y sólo teníamos diez minutos para exponer nuestra contribución, para que luego se abriera un turno de preguntas. Cual fue nuestra sorpresa cuando nos empezaron a hacer preguntas técnicas sobre la Raspberry Pi y se quedaron muy sorprendidos de su tamaño, potencia y precio.

Foto gentileza de la gran fotógrafa Piedad

Por casualidades de la vida, estaba entre los asistentes el profesor Javier Ángel Ramírez y nos propuso hablar en directo en el programa "Diálogos con la Ciencia" de Radio María, que se emite para toda España y accedimos encantados, aunque finalmente hablé sólo yo. Si queréis escuchar el programa debéis registraros en la web, ir a la sección del programa y buscarlo por la fecha de hoy (13/09/13).

Ya sólo me queda volver a agradecer a Javier Ángel la posibilidad que nos ha ofrecido de hablar por la radio y me acabo de percatar que mi gran debut en la radio ha sido en un VIERNES 13, para los que sean supersticiosos.

Blog interesante de otro Proyecto Final de Carrera

2013-07-03T18:53:00.000+01:00

Paradojas de la vida, encontré no hace mucho otro blog que tiene bastantes entradas interesantes, de otra Proyecto Final de Carrera "cuyo objetivo era usar la cabecera de pines GPIO que trae consigo la Raspberry Pi y poder controlar las E/S desde un dispositivo móvil". Recomiendo que le echéis un vistazo (http://muyraspi.blogspot.com.es/?view=flipcard).

Los dos blogs que voy a recomendar son de dos tiendas, el primero de ellos de la tienda Electroensaimada bastante completo, agrupadas las experiencias por niveles (http://www.electroensaimada.com/raspberry-pi.html) y el otro de la tienda Meya, pinta bastante bien, aunque de momento sólo tiene dos entradas (http://www.blog.meya.es/).

Agradecimientos a la Comunidad en Español de Raspberry Pi, en concreto a Andrés Álvarez, por la entrada en la que recomienda el blog y la página del proyecto.

Ya para concluir comentaros que casí lleva 1200 visitas el blog y que a corto-medio plazo espero programar algún dispositivo más.

Un saludo y feliz verano!

DEFENSA DEL TRABAJO FINAL DE CARRERA

2013-06-22T20:21:00.004+01:00

Bueno, pues al final, he defendido el proyecto, acompañado de mi mujer y con Paulita, que nacerá en breve. Todo fue muy bien y me pusieron una excelente nota. Si bien, debo agradecer la ayuda y correcciones que me ha prestado a lo largo de mi trabajo el director del mismo, Francisco J. Martínez Domínguez. También quiero agradecer la atención que me prestó el tribunal y un profesor de electrónica que acudió, por sus correcciones y además, lo que me enseñaron. Así aprendí que el "Regulador de voltaje" del que hablo en mi trabajo se denomina potenciómetro, :D (ahora corrijo el blog).

La defensa la había ideado con un resumen del trabajo realizado (Presentación pptx) y por otra parte, una pequeña demostración sobre una placa con un botón y un led. Lamentablemente, ésta no la pude hacer porque la red de la Universidad no me dejó conectarme mediante el nombre del equipo a la Raspberry Pi y además, no encontramos una pantalla que admitiera HDMI.

Después de la defensa, gracias a los profes del tribunal y eficientes administrativos, pude solicitar el título y nos marchamos a comer a "El milagro". Es un sitio recurrente al que he acudido las dos veces que he tenido oposiciones y del que guardo un grato recuerdo por los resultados obtenidos. Ya en Zaragoza, celebración con la familia y vuelta a casa, Tardienta, exhaustos después de haber hecho más de 400 km en un día.

Resumiendo, un gran día de mucha alegría que culminó varios meses de trabajo y que pude compartir con las personas que más quiero.

PANTALLA LCD

2013-06-15T11:33:00.000+01:00

OBJETIVOS

Crear un programa en C que pida al usuario texto y lo muestre por la pantalla LCD, pantalla a pantalla, mediante la librería WiringPi.

CONSTRUCCIÓN DEL CIRCUITO

Para trabajar con el circuito, podremos optar por trabajar con 4 u 8 pines de datos, permitiendo estos últimos lograr un mayor control de la pantalla.

Debido a que no hay gran diferencia de concepto entre una forma de trabajar y otra, se ha optado por 4 pines de datos ya que así queda el circuito más limpio.

A fin de simplificar el circuito, se ha seguido el convenio de colores rojo cuando se conecta el cable a la línea de + de 5v ( VDD y LED+ ) y azul, cuando se conecta a la línea – de tierra (VSS, LED-, V0, RW). Se han empleado los cables blandos para conectar las líneas de datos con pines programables (D4 a D7) y naranja para conectar a los pines CE0 y CE1 (E y RS). Además, tal y como se muestra en la figura la entrada V0 está puenteada al potenciómetro, aunque no es necesario para que funcione y directivamente se puede conectar a tierra.

DESCARGAR TODO EL CÓDIGO

https://sourceforge.net/projects/rpiplus/files/LCD/

Programa lcd.c

/****************************************************************
**                                                             **
** lcd.c                                                       **
**                                                             **
** Este programa captura un texto introducido por el usuario   **
** y se muestra por pantalla, de tal manera que se ven dos     **
** lineas del mismo y el usuario debe apretar una tecla para   **
** ver las dos siguientes. Para la ejecución del mismo es      **
** necesario que sea ejecutado como root                       **
**                                                             **
** Autor: M.Alvarez (miguelwarez@gmail.com) 2013               **
** Más ejemplos en http://rpiplus.sourceforge.net              **
**                                                             **
** License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      **
**                                                             **
** Para compilar:                                              **
** gcc -o lcd -l wiringPi lcd.c                                **
**                                                             **
** Para ejecutar:                                              **
** sudo ./lcd                                                  **
**                                                             **
****************************************************************/
#include <stdio.h>
#include <stdlib.h>
#include <wiringPi.h>
#include <string.h> main(){
      char cadena[200], letra, linea1[17],linea2[17];
      int lon, pos, i, pant=0;
      printf("Introduce la cadena para mostrar en pantalla LCD\n");
      printf("pulsa cualquier tecla para avanzar\n");
      gets(cadena);
      lon=strlen(cadena);
      pos=0;
      if (wiringPiSetup () == -1)
            exit (1) ;
     //describir la pantalla
      int fd1 = lcdInit (2, 16, 4, 11, 10, 6,5,4,1,0,0,0,0) ;

     //limpiar pantalla
      sleep (1) ;
      lcdClear(fd1);
      while(pos < lon){
            i=0;
            while(i<16 && pos < lon){
                  linea1[i]=cadena[pos];
                  i++;
                  pos++;
            }
            linea1[i]='\0';
            i=0;
            while(i<16 && pos < lon){
                  linea2[i]=cadena[pos];
                  i++;
                  pos++;
            }
            linea2[i]='\0';
            printf("Pantalla %d\n",++pant);
            printf("%s\n",linea1);
            printf("%s\n",linea2);
            sleep(1);
          //sacamos la salida por la pantalla LCD
          lcdPosition (fd1, 0, 0) ;
            lcdPuts (fd1, linea1) ;
            lcdPosition(fd1,0,1);
            lcdPuts(fd1,linea2);
          //esperamos a que el usuario pulse una tecla
            fflush(stdin);
            getchar();
      }
      printf("Saliendo\n");
     //limpiar pantalla
      sleep(1);
      lcdClear(fd1); }

TECLADO HEXADECIMAL 4X4

2013-06-14T19:56:00.000+01:00

OBJETIVOS

Crear un programa Shell que capture y muestre todas las teclas que son pulsadas en un teclado numérico hexadecimal 4x4 hasta que se pulsa # mediante el comando gpio de la librería WiringPi
Crear un programa en C que capture y muestre todas las teclas que son pulsadas en un teclado numérico hexadecimal 4x4 hasta que se pulsa # mediante la librería WiringPi.

CONSTRUCCIÓN DEL CIRCUITO

Para poder realizar el programa, primero debemos atender al diseño del teclado, que cuenta con 8 líneas, 4 de ellas de entrada y 4 de salida.

Comentar que los pines 1 a 4 llevarán asociados pines GPIO de salida y los pines de 5 a 8 serán asociados a pines de entrada, siendo recomendable la utilización de resistencias para evitar dañar la placa.

Atendiendo a la imagen vemos que los pines del teclado que van del 1 a 4, están asociadas a las columnas que van de 1 a 4. Mientras que los pines asociados a los pines 5 a 8 están asociados a las filas 1 a 4, pero en orden contrario, o sea, el 5 pin está asociado a la 4 columna, el 3 a la 3,…

Se ha procedido a conectar las 8 líneas del teclado a pines programables, insertando resistencias en el caso de los pines de entrada.

El funcionamiento del algoritmo es relativamente sencillo. Cuando comienza el programa el primer pin de salida, que controla primera columna vale 1, o sea, emite corriente y los otros tres pines de salida que controlan las columnas restantes valen 0, no emiten corriente. En este momento, se comprueba el valor del primer pin de entrada, si vale 0 es que no ha sido pulsada la tecla, en caso contrario, si ha sido pulsada. A continuación se va realizando la comprobación con las siguientes filas. Una vez comprobada la primera columna, se repite el proceso con las siguientes columnas, volviendo a realizar la comprobación hasta la última, en cuyo caso, se vuelve a realizar la comprobación cíclicamente desde la primera.

PROGRAMA tecladogpio.sh

#!/bin/bash
#################################################################
##                                                             ##
## tecladogpio.sh                                              ##
##                                                             ##
## Este script captura cuando un botón es pulsado mediante     ##
## el comando gpio facilitado por la libreria wiring PI        ##
##                                                             ##
## Autor: M.Alvarez (miguelwarez@gmail.com) 2013              ##
## Más ejemplos en http://rpiplus.sourceforge.net              ##
##                                                             ##
## License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      ##
##                                                             ##
## Para ejecutar ./botongpio.sh                                ##
##                                                             ##
#################################################################
#pines de salida
OUTPUT[0]="25"
OUTPUT[1]="24"
OUTPUT[2]="23"
OUTPUT[3]="18"
#pines de entrada
INPUT[0]="7"
INPUT[1]="22"
INPUT[2]="4"
INPUT[3]="17"
#teclado
TECLA[0]="1"
TECLA[1]="2"
TECLA[2]="3"
TECLA[3]="A"
TECLA[4]="4"
TECLA[5]="5"
TECLA[6]="6"
TECLA[7]="B"
TECLA[8]="7"
TECLA[9]="8"
TECLA[10]="9"
TECLA[11]="C"
TECLA[12]="*"
TECLA[13]="0"
TECLA[14]="#"
TECLA[15]="D"
#configurar los pines como entrada conexión a tierra y salida
for I in 0 1 2 3
do
      gpio -g mode ${OUTPUT[$I]} out
      gpio -g write ${OUTPUT[$I]} 0
      gpio -g mode ${INPUT[$I]} in
      gpio -g mode ${INPUT[$I]} down

done
echo "Capturando teclas para salir pulsar #"
#bucle infinito que captura y muestra teclas hasta que se pulsa #
while ((1));
do
      for I in 0 1 2 3
      do
          #poner el pin de salida a 1 (el resto están a 0)
            gpio -g write ${OUTPUT[$I]} 1
          #comprobar pines de entrada si no valen 0 =>tecla pulsada
            for J in 0 1 2 3
            do
                  READ=`gpio -g read ${INPUT[$J]}`
                  sleep 0.01
                  if [ $READ -ne "0" ]
                  then
                        POS=`expr 4 "*" $I + $J`
                        echo "Pulsado el boton ${TECLA[$POS]}"
                        if [ "${TECLA[$POS]}" = "#" ]
                        then
                            exit
                        fi
                  fi
            done
            gpio -g write ${OUTPUT[$I]} 0
      done

done

PROGRAMA teclado.c

/****************************************************************
**                                                             **
** teclado.c                                                   **
**                                                             **
** Este programa permite controlar un teclado 4 x 4, recoge   **
** teclas hasta que se pulsa #                                 **
**                                                             **
** Autor: M.Alvarez (miguelwarez@gmail.com) 2013               **
** Más ejemplos en http://rpiplus.sourceforge.net              **
**                                                             **
** License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      **
**                                                             **
** Para compilar:                                              **
** gcc -o teclado -l wiringPi teclado.c                        **
**                                                             **
** Para ejecutar:                                              **
** sudo ./teclado                                              **
**                                                             **
****************************************************************/

#include <wiringPi.h>
#include <stdio.h>
#include <stdlib.h>
//pines asociados a las columnas de tipo output
int outputs[]={25,24,23,18};
//pines asociados a las filas de tipo input con resistencias 10 K
int inputs[]={7,22,4,17};//controlan filas
//la función pone a 0 atodas las filas a excepcion de la que
//se va a controlar
void columnaCero(int valor){
      int i;
      for(i=0;i<4;i++)
            if(i==valor)
                  digitalWrite(outputs[i],1);
            else
                  digitalWrite(outputs[i],0);
}
//vector que contendrá el teclado
int teclado[4][4]={{'1','2','3','A'},
                     {'4','5','6','B'},
                     {'7','8','9','C'},
                     {'*','0','#','D'}};
main(){
      int i, col, fil,valor;
      //inializamos la libreria
      if (wiringPiSetupGpio() == -1){
            perror("Error de inicializacion\n");
            exit (1) ;
      }
      //ponemos los pines como input y output, además
      //de inicializarlos
      for(i=0;i<4;i++){
            pinMode(inputs[i],INPUT);
            digitalWrite(inputs[i],0);
            pullUpDnControl(inputs[i],PUD_DOWN);
            pinMode(outputs[i],OUTPUT);
            digitalWrite(outputs[i],0);
      }
      //empezamos un bucle infinito del que se sale sólo
      //cuando se pulsa #
      printf("Capturando teclas y mostrando por pantalla\n");
      printf("Para salir pulsa #");
      while(1){
            for(col=0;col<4;col++){
                  columnaCero(col);
                  for(fil=0;fil<4;fil++){
                        valor=digitalRead(inputs[fil]);
                        delay(10);
                        if(valor!=0){
                             printf("Tecla %c\n", teclado[col][fil]);
                              digitalWrite(outputs[col],1);
                             digitalWrite(inputs[fil],0);
                             if(teclado[col][fil]=='#'){
                                   printf("Saliendo\n");
                                   exit(0);
                             }
                        }
                  }
            }
      }
}

PROGRAMANDO UN 7 SEGMENTOS DE 4 BIT

2013-06-13T11:08:00.000+01:00

OBJETIVOS

Crear un programa shell que realice un contador de 1 digito mediante gpio de la librería WiringPi.
Crear un programa en C que es un contador de 4 dígitos mediante la librería WiringPi.

CONSTRUCCIÓN DEL CIRCUITO

La pantalla sobre la que se ha trabajado posee 4 dígitos y se programa sobre 12 pines, 6 en la parte superior y 6 en la inferior.

De los 12 pines, 7 sirven para programar cada uno de los segmentos, otro sirve para controlar los :, que serán cátodos (-) y 4 pines para cada uno de los dos dígitos, que serán ánodos (+).

La información facilitada por el fabricante es la siguiente

Cada uno de los pines de empleados para los dígitos es positivo, sobre ellos habrá que utilizar resistencias de 220 o 330 Ω y el resto de los pines son negativos. Para identificar si un pin es dígito o sirve para controlar un segmento, utilizaremos la corriente continua de 3.3v, conectaremos una resistencia al pin candidato a dígito y probaremos en varios pines con la conexión a tierra, si se ilumina algún segmento es dígito y podremos identificar de qué digito se trata y que segmento está asociado al otro pin, si no se ilumina nada después de haber probado varios pines habrá que buscar otro candidato a dígito.

La numeración de los pines va en la parte inferior de 1 a 6 y en la parte superior de 12 a 7.

12 D1	11 A	10 F	9 D2	8 D3	7 B
1 E	2 D	3 :	4 C	5 G	6 D4

A los pines positivos se les han asociado los pines MOSI, MISO, CE0 y CE1, insertando una resistencia de 330 Ω en cada uno de ellos. Para los siete segmentos a, b, c, d, e, f, g se han utilizado los pines programables 17, 18, 4, 22 ,23 ,24 , 25.

Para que se ilumine un segmento de un dígito, el pin asociado al digito deberá estar a 1 y el pin asociado al segmento deberá valer 0, así se consigue que fluya la corriente. En ambos casos se configurarán como pines de salida o output.

El resultado final del circuito ha sido

DESCARGAR TODO EL CÓDIGO

http://sourceforge.net/projects/rpiplus/files/7SEGMENTOS/

Programa contador7segmentos.sh

#!/bin/bash
#################################################################
##                                                             ##
## contador7segmentos.sh                                       ##
##                                                             ##
## Este script sirve para realizar un contador de 7            ##
## segmentos de 1 digito                                       ##
##                                                             ##
## Autor: M.Alvarez (miguelwarez@gmail.com) 2013               ##
## Más ejemplos en http://rpiplus.sourceforge.net              ##
##                                                             ##
## License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      ##
##                                                             ##
## Para ejecutar hay que ser root (sudo su) y escribir         ##
## ./contador7segmentos.sh                                     ##
##                                                             ##
#################################################################
#la función limpia la salida del display de 7 segmentos
function limpia() {
      #la pantalla display controla los cuatro digitos con los
      #pines 9 10 8 7
      for I in 9 10 8 7
      do
            gpio -g mode $I out
            gpio -g write $I 0
      done
      #los pines asociados a los segmentos son los que se muestran
      #el 17 al segmento a, 18 al b,...
      for I in 17 18 4 22 23 24 25
      do
            gpio -g mode $I out
            gpio -g write $I 1
      done
}
#la función recibe como argumento la letra, por ejemplo,para mostrar 0
#indicamos representa 1 1 1 1 1 1 1 0 0 y ya va mostrando o no cada uno function representa() {
      for I in 17 18 4 22 23 24 25
      do
            if [ $1 -eq 0 ]
            then
                  gpio -g write $I 1
            else
                  gpio -g write $I 0
            fi
            shift
      done
}
           # a b c d e f g p
DIGITOS[0]="1 1 1 1 1 1 0 0"
DIGITOS[1]="0 1 1 0 0 0 0 0"
DIGITOS[2]="1 1 0 1 1 0 1 0"
DIGITOS[3]="1 1 1 1 0 0 1 0"
DIGITOS[4]="0 1 1 0 0 1 1 0"
DIGITOS[5]="1 0 1 1 0 1 1 0"
DIGITOS[6]="1 0 1 1 1 1 1 0"
DIGITOS[7]="1 1 1 0 0 0 0 0"
DIGITOS[8]="1 1 1 1 1 1 1 0"
DIGITOS[9]="1 1 1 1 0 1 1 0"
DIGITOS[10]="1 1 1 0 1 1 1 0"
DIGITOS[11]="0 0 1 1 1 1 1 0"
DIGITOS[12]="1 0 0 1 1 1 0 0"
DIGITOS[13]="0 1 1 1 1 0 1 0"
DIGITOS[14]="1 0 0 1 1 1 1 0"
DIGITOS[15]="1 0 0 0 1 1 1 0"
DIGITOS[16]="0 0 0 0 0 0 0 0"
#limpiamos la salida por pantalla
limpia
#habilitamos el digito y lo ponemos en modo salida
gpio -g mode 7 out
gpio -g write 7 1
echo "Contador Hexadecimal"
#hacemos el contador recorriendo el vector de digitos
I=0
while [ $I -le 16 ]
do
      CONT=$I
      representa ${DIGITOS[$I]}
      sleep 1
      I=`expr $CONT + 1`
done
#desconectamos el pin
gpio -g write 7 0

Programa contador7segmentos.c

/****************************************************************
**                                                             **
** contador7segmentos.c                                        **
**                                                             **
** Este programa sirve para realizar un contador de 7          **
** segmentos de 4 digitos                                      **
**                                                             **
** Autor: M.Alvarez (miguelwarez@gmail.com) 2013              **
** Más ejemplos en http://rpiplus.sourceforge.net              **
**                                                             **
** License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      **
**                                                             **
** Para compilar:                                              **
** gcc -o contador7segmentos contador7segmentos.c -l wiringPi **
**                                                             **
** Para ejecutar:                                              **
** sudo ./contador7segmentos                                   **
**                                                             **
****************************************************************/
#include <wiringPi.h>
#include <stdio.h>
#define MISO 9
#define MOSI 10
#define CE0 8
#define CE1 7
/* Pines utilizados para definir los segmentos a,b,...
*   --a--
*   |     |
*   f     b
*   |     |
*   --g--
*   |     |
*   e     c
*   |     |
*   --d-- p
*/
static int GPIO[]={17,18,4,22,23,24,25};
//Pines asociados a cada pin, en la misma posición en la que
//se muestran
static int POS[]={CE0,MOSI,MISO,CE1};
void ponValorNegado(int pin,int valor){
      pinMode(pin,OUTPUT);
      digitalWrite(pin,!valor);
}
void limpia(){
      int i;
      for(i=0;i<4;i++)
            ponValorNegado(POS[i],HIGH);
      for(i=0;i<8;i++)
            ponValorNegado(GPIO[i],LOW);
}

static const int digitos[]=
{
// a b c d e f g p    Segments
   1, 1, 1, 1, 1, 1, 0, 0,   // 0
   0, 1, 1, 0, 0, 0, 0, 0,   // 1
   1, 1, 0, 1, 1, 0, 1, 0,   // 2
   1, 1, 1, 1, 0, 0, 1, 0,   // 3
   0, 1, 1, 0, 0, 1, 1, 0,   // 4
   1, 0, 1, 1, 0, 1, 1, 0,   // 5
   1, 0, 1, 1, 1, 1, 1, 0,   // 6
   1, 1, 1, 0, 0, 0, 0, 0,   // 7
   1, 1, 1, 1, 1, 1, 1, 0,   // 8
   1, 1, 1, 1, 0, 1, 1, 0,   // 9
   1, 1, 1, 0, 1, 1, 1, 0,   // A
   0, 0, 1, 1, 1, 1, 1, 0,   // b
   1, 0, 0, 1, 1, 1, 0, 0,   // C
   0, 1, 1, 1, 1, 0, 1, 0,   // d
   1, 0, 0, 1, 1, 1, 1, 0,   // E
   1, 0, 0, 0, 1, 1, 1, 0,   // F
   0, 0, 0, 0, 0, 0, 0, 0,   // blank
} ;void representa(int valor){
      int i;
      for(i=0;i<7;i++){
            ponValorNegado(GPIO[i],digitos[8*valor+i]);
      }
}
void caracterPin(char a, int pin){
      if(a>='a')
            representa(10 + a -'a');
      else
            representa(a-'0');
}
void pinta(int pin, int num, int tiempo){
      ponValorNegado(pin,LOW);
      representa(num);
      delayMicroseconds(tiempo);
      ponValorNegado(pin,HIGH);
}
main(){
      int i,j,k,l,cien=100;
      if (wiringPiSetupGpio() == -1){
            perror("Error de inicializacion\n");
            exit (1) ;
      }
      limpia();
      for(;;){
      for(i=0;i<10;i++)
      for(j=0;j<10;j++)
        for(k=0;k<10;k++)
          for(l=0;l<100;l++){
            pinta(POS[0],i,5000);
            pinta(POS[1],j,5000);
            pinta(POS[2],k,5000);
            pinta(POS[3],l/10,5000);
         }
      }
}

PROGRAMANDO UN BOTÓN

2013-06-11T20:02:00.000+01:00

OBJETIVOS

Crear un programa Shell que capture cuando ha sido pulsado un botón mediante sysfs.
Crear un programa Shell que capture cuando ha sido pulsado un botón mediante el comando gpio de la librería WiringPi.
Crear un programa en C que capture cuando ha sido pulsado un botón mediante la librería WiringPi

CONSTRUCCIÓN DEL CIRCUITO

Para comprender el circuito, primero hay que analizar que el botón que tiene dos patillas y cuando se aprieta, deja pasar la corriente. Cada una de estas patillas irá a parar a una línea diferente de la protoboard, luego, una de ellas irá conectada a un pin programable y otra se podrá conectar al pin de tierra o al pin de 3.3v.
Para proteger Raspberry Pi de sobretensiones se recomienda la utilización de resistencias, por ello, ha sido utilizado una resistencia de 1 KΩ.

Cuando se desea capturar si ha sido pulsado habrá que tener muy en cuenta si una de las patillas está conectada a tierra o a 3.3v, ya que esto se deberá especificar en el programa, mediante pull down ó pull up. El pin programable se deberá definir de entrada y su valor será 0 hasta que sea pulsado el botón. Por tanto, para crear un programa que capture cuando un botón es pulsado deberá entrar en un bucle infinito hasta que el valor del pin programable input valga 1.

DESCARGAR TODO EL CÓDIGO

https://sourceforge.net/projects/rpiplus/files/BOTON/

Programa botonsysfs.sh

#!/bin/bash
#################################################################
##                                                             ##
## botonsysfs.sh                                               ##
##                                                             ##
## Este script controla el botón que indica el usuario         ##
## mediante sysfs, una patilla debe estar a la linea continua ##
## de 3.3v y la otra al pin programable, insertando una        ##
## resistencia de 1Kohm                                        ##
##                                                             ##
## Autor: M.Alvarez (miguelwarez@gmail.com) 2013               ##
## Más ejemplos en http://rpiplus.sourceforge.net              ##
##                                                             ##
## License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      ##
##                                                             ##
## Para ejecutar hay que ser root (sudo su) y escribir         ##
## ./botonsysfs.sh                                             ##
##                                                             ##
#################################################################
#obtener numero de pin al que se conecta el boton
read -p "Introduce el boton que deseas controlar con numeracion BCM " BOTON
echo "Controlando el BOTON $BOTON"
#comprobar que el boton no se esta utilizando
if [ -e /sys/class/gpio/gpio$BOTON ]
then
      TIPO=`cat /sys/class/gpio/gpio$BOTON/direction`
      echo "Esta siendo utilizado el pin en una operacion $TIPO"
      VALOR=`cat /sys/class/gpio/gpio$BOTON/value`
      echo "El valor actual del pin es $VALOR"
      exit
fi
#esperar a obtener 1 en el fichero valor
`echo $BOTON >/sys/class/gpio/export`
`echo in >/sys/class/gpio/gpio$BOTON/direction`
READ=0
while [ $READ -eq 0 ]
do
      READ=`cat /sys/class/gpio/gpio$BOTON/value`
done
echo "El boton ha sido pulsado"
`echo $BOTON >/sys/class/gpio/unexport`

Programa botongpio.sh

#!/bin/bash
#################################################################
##                                                             ##
## botongpio.sh                                                ##
##                                                             ##
## Este script captura cuando un botón es pulsado mediante     ##
## el comando gpio facilitado por la libreria wiring PI        ##
##                                                             ##
## Autor: M.Alvarez (miguelwarez@gmail.com) 2013               ##
## Más ejemplos en http://rpiplus.sourceforge.net              ##
##                                                             ##
## License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      ##
##                                                             ##
## Para ejecutar ./botongpio.sh                                ##
##                                                             ##
#################################################################
#obtener numero de pin al que se conecta el boton
read -p "Introduce el boton que deseas controlar con numeracion BCM " BOTON
gpio -g mode $BOTON in
gpio -g mode $BOTON down #conectado a 3.3v
#gpio -g mode $BOTON up #conectado a tierra
echo "Controlando el BOTON $BOTON"
while ((1));
do
     READ=`gpio -g read $BOTON`
     if [ $READ -ne "0" ] #conectado a 3.3v
     #if [ $READ -eq "0" ] #conectado a tierra
     then
            echo "Pulsado el boton"
           break
     fi
done

Programa boton.c

/****************************************************************
**                                                             **
** boton.c                                                     **
**                                                             **
** Este programa captura cuando un botón es pulsado            **
** mediante la libreria Wiring Pi. Para la ejecución del       **
** programa es necesario que sea ejecutado como root           **
**                                                             **
** Autor: M.Alvarez (miguelwarez@gmail.com) 2013               **
** Más ejemplos en http://rpiplus.sourceforge.net              **
**                                                             **
** License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      **
**                                                             **
** Para compilar:                                              **
** gcc -o boton -l wiringPi boton.c                            **
**                                                             **
** Para ejecutar:                                              **
** sudo ./boton                                                **
**                                                             **
****************************************************************/
#include <wiringPi.h>
#include<stdio.h>
#include<stdlib.h>
main(){
      int boton;
      printf("Introduce el botón que deseas controlar\n");
      scanf("%d",&boton);
      printf("Controlando el boton %d\n",boton);
      if (wiringPiSetupGpio() == -1){
            perror("Error de inicializacion\n");
            exit (1) ;
      }
      pinMode (boton, INPUT) ;
      pullUpDnControl(boton,PUD_DOWN); //conectado a 3.3v
//    pullUpDnControl(boton,PUD_UP); //conectado a tierra
      while(1){
            if(digitalRead(boton)!=0){ //conectado a 3.3v
            //if(digitalRead(boton)==0){ //conectado a tierra
                  printf("Boton pulsado\n");
                  exit(0);
            }
      }
}

PROGRAMANDO LED

2013-06-11T15:34:00.000+01:00

OBJETIVOS

Crear un programa Shell que encienda un LED, introducido por el usuario, mediante sysfs.
Crear un programa Shell que apague un LED, introducido por el usuario, mediante sysfs.
Crear un programa Shell que encienda un LED, introducido por el usuario, mediante el comando gpio de la librería WiringPi.
Crear un programa Shell que apague un LED, introducido por el usuario, mediante el comando gpio de la librería WiringPi.
Crear un programa en C que encienda un LED, introducido por el usuario, mediante la librería WiringPi.
Crear un programa en C que apague un LED, introducido por el usuario, mediante la librería WiringPi.

CONSTRUCCIÓN DEL CIRCUITO

Para construir el circuito, se va a montar primero el circuito con el pin que da voltaje de manera continua de 3.3v (PIN 1), de esta modo, cuando luzca el led, se tendrá la certeza de que el circuito está bien montado y por tanto, sólo habrá que cambiar el cable que está conectado del pin 1 al pin que se desee programar.

Debido al excesivo voltaje suministrado por el pin, será necesario incorporar una resistencia, en caso contrario se fundiría. Para determinar el valor de la resistencia, se debe tener en cuenta la “Ley de Ohm” que relaciona voltaje, intensidad y resistencia. La Ley de Ohm dice que el voltaje que circula en un circuito cerrado es directamente proporcional a la intensidad que lo atraviesa y la resistencia del material.</

Según la fuente consultada, los valores de voltajes de los LED varían y finalmente se ha tomado como referencia la tabla de valores de Wikipedia.

LED	VOLTAJE
Rojo	1,8 a 2,2 voltios.
Anaranjado	2,1 a 2,2 voltios.
Amarillo	2,1 a 2,4 voltios.
Verde	2 a 3,5 voltios.
Azul	3,5 a 3,8 voltios.
Blanco	3,6 voltios.

El Circuito que se va a utilizar en los ejemplos es bastante sencillo, con un único LED. En este circuito intervendrán el pin 1 de 3.3v, el pin 6 Tierra (GND), el led y una resistencia de 220 o 330 Ω. Especialmente importante será conectar bien el LED ya que en caso contrario no lucirá, para ello, la corriente deberá entrar por la parte más larga (línea de pin 1) y salir por la pata más corta (línea tierra).

Una vez ya comprobado el correcto funcionamiento del circuito, quitaremos el extremo del cable que está conectado al pin de 3.3 v y se conectará a uno de los pines programables.

El algoritmo para encender un led es bastante sencillo. Una vez construido el circuito, al poner un pin programable de tipo output o salida a 1, este genera corriente continua y por tanto se enciende el led, y cuando está a 0 no, no encendiéndose el led en este caso.

DESCARGAR TODO EL CÓDIGO

https://sourceforge.net/projects/rpiplus/files/LED/

Programa enciendeLEDsysfs.sh

##!/bin/bash
#################################################################
##                                                             ##
## enciendeLEDsysfs.sh                                         ##
##                                                             ##
## Este script enciende el led que indica el usuario           ##
## mediante sysfs                                              ##
##                                                             ##
## Autor: M.Alvarez (miguelwarez@gmail.com) 2013               ##
## Más ejemplos en http://rpiplus.sourceforge.net              ##
##                                                             ##
## License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      ##
##                                                             ##
## Para ejecutar hay que ser root (sudo su) y escribir         ##
## ./enciendeLEDsysfs.sh                                       ##
##                                                             ##
#################################################################
#obtener led a encender
read -p "Introduce el led que deseas encender siguiendo la numeracion BCM" LED
echo "Encendiendo el LED $LED"
#comprobar que el led no se esta utilizando
if [ -e /sys/class/gpio/gpio$LED ]
then
      TIPO=`cat /sys/class/gpio/gpio$LED/direction`
      echo "Esta siendo utilizado el pin en una operacion $TIPO"
      VALOR=`cat /sys/class/gpio/gpio$LED/value`
      echo "El valor actual del pin es $VALOR"
      exit
fi
#encender el led
`echo $LED >/sys/class/gpio/export`
`echo out >/sys/class/gpio/gpio$LED/direction`
`echo 1 >/sys/class/gpio/gpio$LED/value`
`echo $LED >/sys/class/gpio/unexport`

Programa apagaLEDsysfs.sh

#!/bin/bash
#################################################################
##                                                             ##
## apagaLEDsysfs.sh                                            ##
##                                                             ##
## Este script apaga el led que indica el usuario              ##
## mediante sysfs                                              ##
##                                                             ##
## Autor: M.Alvarez (miguelwarez@gmail.com) 2013              ##
## Más ejemplos en http://rpiplus.sourceforge.net              ##
##                                                             ##
## License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      ##
##                                                             ##
## Para ejecutar hay que ser root (sudo su) y ejecutar         ##
## ./apagaLEDsysfs                                             ##
##                                                             ##
#################################################################
#obtener led a encender
read -p "Introduce el led que deseas encender segun numeracion BCM " LED
echo "Apagando el LED $LED"
#comprobar que el led se esta utilizando
if [ -e /sys/class/gpio/gpio$LED ]
then
        TIPO=`cat /sys/class/gpio/gpio$LED/direction`
        echo "Esta siendo utilizado el pin en una operacion $TIPO"
        VALOR=`cat /sys/class/gpio/gpio$LED/value`
        echo "El valor actual del pin es $VALOR"
        exit
fi
#apagar el led
`echo $LED >/sys/class/gpio/export`
`echo out >/sys/class/gpio/gpio$LED/direction`
`echo 0 >/sys/class/gpio/gpio$LED/value`
`echo $LED >/sys/class/gpio/unexport`

Programa enciendeLEDgpio.sh

#!/bin/bash
#################################################################
##                                                             ##
## enciendeLEDgpio.sh                                          ##
##                                                             ##
## Este script enciende el led que indica el usuario           ##
## mediante el comando gpio facilitado por la libreria         ##
## wiring PI                                                   ##
##                                                             ##
## Autor: M.Alvarez (miguelwarez@gmail.com) 2013               ##
## Más ejemplos en http://rpiplus.sourceforge.net              ##
##                                                             ##
## License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      ##
##                                                             ##
## Para ejecutar ./enciendeLEDgpio.sh                          ##
##                                                             ##
#################################################################
#obtener led a encender
read -p "Introduce el led que deseas encender siguiendo la numeracion BCM " LED
echo "Encendiendo el LED $LED"
#comprobar que el led no estuviera encendido
READ=`gpio -g read $LED`
if [ $READ -eq 1 ]
then
      echo "El LED ya estaba encendido"
else
      gpio -g mode $LED out
      gpio -g write $LED 1
fi

Programa apagaLEDgpio.sh

#!/bin/bash
#################################################################
##                                                             ##
## apagaLEDgpio.sh                                             ##
##                                                             ##
## Este script apaga el led que indica el usuario              ##
## mediante el comando gpio facilitado por la libreria         ##
## wiring PI                                                   ##
##                                                             ##
## Autor: M.Alvarez (miguelwarez@gmail.com) 2013               ##
## Más ejemplos en http://rpiplus.sourceforge.net              ##
##                                                             ##
## License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      ##
##                                                             ##
## Para ejecutar ./apagaLEDgpio.sh                             ##
##                                                             ##
#################################################################
#obtener led a encender
read -p "Introduce el led que deseas apagar siguiendo la numeracion BCM " LED
echo "Apagando el LED $LED"
#comprobar que el led no estuviera encendido
READ=`gpio -g read $LED`
if [ $READ -eq 0 ]
then
      echo "El LED ya estaba apagado"
else
      gpio -g write $LED 0
fi

Programa enciendeLED.c

/****************************************************************
**                                                             **
** enciendeLED.c                                               **
**                                                             **
** Este programa enciende el led que indica el usuario         **
** mediante la libreria Wiring Pi. Para la ejecución del       **
** es necesario que sea ejecutado como root                    **
**                                                             **
** Autor: M.Alvarez (miguelwarez@gmail.com) 2013               **
** Más ejemplos en http://rpiplus.sourceforge.net              **
**                                                             **
** License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      **
**                                                             **
** Para compilar:                                              **
** gcc -o enciendeLED -l wiringPi enciendeLED.c                **
**                                                             **
** Para ejecutar:                                              **
** sudo ./enciendeLED                                          **
**                                                             **
****************************************************************/
#include <wiringPi.h>
#include<stdio.h>
main(){
      int led;
      printf("Introduce el led que deseas encender\n");
      scanf("%d",&led);
      printf("Encendiendo el led %d\n",led);
      if (wiringPiSetupGpio() == -1){
            perror("Error de inicializacion\n");
            exit (1) ;
      }
      pinMode (led, OUTPUT) ;
      if(digitalRead(led)!=0)
            printf("El led ya estaba encendido\n");
      else
            digitalWrite(led,1);
}

PROGRAMA apagaLED.c

/****************************************************************
**                                                             **
** apagaLED.c                                                  **
**                                                             **
** Este programa apaga el led que indica el usuario            **
** mediante la libreria Wiring Pi. Para ello es necesario      **
** que sea ejecutada con una cuenta root                       **
**                                                             **
** Autor: M.Alvarez (miguelwarez@gmail.com) 2013               **
** Más ejemplos en http://rpiplus.sourceforge.net              **
**                                                             **
** License GPLv3 http://www.gnu.org/licenses/gpl-3.0.html      **
**                                                             **
** Para compilar:                                              **
** gcc -o apagaLED -l wiringPi apagaLED.c                      **
**                                                             **
** Para ejecutar:                                              **
** sudo ./apagaLED                                             **
**                                                             **
****************************************************************/
#include <wiringPi.h>
#include<stdio.h>
main(){
      int led;
      printf("Introduce el led que deseas apagar\n");
      scanf("%d",&led);
      printf("Apagando el led %d\n",led);
      if (wiringPiSetupGpio() == -1){
            perror("Error de inicializacion\n");
            exit (1) ;
      }
      pinMode (led, OUTPUT) ;
      if(digitalRead(led)!=1)
            printf("El led ya estaba apagado\n");
      else
            digitalWrite(led,0);
}

MATERIALES DE BRICO HARDWARE

2013-06-11T14:00:00.000+01:00

Hay una serie de materiales bastante útiles cuando comenzamos a trabajar con la GPIO de la Raspberry Pi, en esta entrada, voy a comentar algunos de ellos.

PLACA DE PRUEBAS, PROTOBOARD O BREADBOARD

La placa de pruebas permite la construcción de prototipos electrónicos, ya que su forma, tablero lleno de orificios conectados en línea, facilita la conexión de cables y dispositivos.

En particular, la placa con la que se ha trabajado tiene dos líneas verticales, positiva y negativa en cada extremo. A la línea positiva se conectará la línea de 3v3 o 5v de la Raspberry Pi y a la negativa la línea de tierra o ground (gnd), a estas líneas se conectarán otras cables para realizar circuitos.

Además hay en el medio dos bancadas de 63 líneas verticales, cuyos orificios quedan identificados por una columna, que tiene asignada una letra y una fila, que tiene asociado un número. Cada una de las filas está conectada entre sí, hasta que llega al salto que se encuentra entre las columnas e y f. Por ejemplo, todos los dispositivos que se conectan en la cuarta línea entre las columnas a y e están conectados.

CABLEADO

El cableado utilizado en la protoboard tiene la particularidad de que no es necesario soldar nada (solderless), hay de varias longitudes.

CINTA PARA LA GPIO

La opción más cómoda para trabajar es llevar toda la GPIO a la protoboard, para ello es necesario utilizar una cinta que conecte los pines de la GPIO.

CONECTOR GPIO A LA PROTOBARD

En el punto anterior, al analizar la cinta GPIO, se ha observado que los conectores son hembra, por tanto, es necesario utilizar un adaptador para conectar la cinta a la protoboard. El conector que se ha utilizado es bastante cómodo ya que aparece la descripción de cada uno de los pines GPIO.

MULTÍMETRO

Se ha utilizado un multímetro para estudiar si los voltajes proporcionados por la Raspberry Pi son correctos.

RESISTENCIAS

Las resistencias son necesarias para evitar fundir algunos componentes, tales como LED ó 7 segmentos. Las magnitudes que identifican a las resistencias son la resistencia eléctrica, disipación máxima y precisión, dicha información, se puede obtener de los colores que están presentes en el encapsulado. La unidad empleada en medir resistencias son los ohmios (Ω).

A continuación, se mostrará una tabla en la que se identifican colores y sus valores respectivos, las tres primeras bandas hacen referencia al valor de la resistencia y la cuarta la tolerancia.

Color	Valor	Tolerancia
Negro	0	-
Marrón	1	±1%
Rojo	2	±2%
Naranja	3	-
Amarillo	4	±4%
Verde	5	±0,5%
Azul	6	±0,25%
Morado	7	±0,1%
Gris	8	±0.05%
Blanco	9	-
Dorado	-	±5%
Plateado	-	±10%

Si se considera una resistencia que presenta los siguientes colores Marrón (1) - Negro (0) –Naranja (3) –Dorado( ±5% ), el valor de la resistencia es 10.000 Ω = 10 k Ω

POTENCIÓMETRO

Este componente se ha utilizado básicamente con la pantalla LCD, ya que permite regular la intensidad del voltaje. La parte superior “gira” de tal manera que deja pasar más o menos voltaje. La conexión a la protoboard debe realizarse de tal manera que dos patas inferiores caigan en una línea y la pata superior caiga en otra línea.

PROGRAMANDO GPIO

2013-06-11T12:22:00.000+01:00

Se han programado los pines de la GPIO básicamente de tres maneras, por una parte, mediante sysfs, por otra mediante el comando gpio que procede de la librería wiringPi y hasta que no la instalemos no está disponible y la tercera manera es a través de la librería wiringPi, que ya ha sido comentada en una entrada anterior.

Comando gpio

Este comando está operativo a partir de la instalación de la librería wiringPi.

Se pueden realizar la mayor parte de las operaciones que se han especificado en la librería de C directamente en línea de comandos, mediante la herramienta gpio.

-v muestra la versión
–g especifica que la numeración de pines es BCM GPIO
mode n [ in| out | pwm ] establece pin n en modo entrada, salida o pwm, respectivamente.
mode n [ up | down |tri ] configura las resistencias del pin n en modo subida, bajada o ninguno.
read n lee el valor del pin n.
readall lee todos los valores posibles y los muestra por pantalla.
write n [ 1 | 0 ] escribe en el pin n un valor 1 (HIGH) o 0 (DOWN).
pwm n value establece en el pin n el valor value.
edge n [ rising | falling | both | none ] permite configurar las interrupciones sobre el pin n como flanco de subida, bajada, ambos o ninguno.
export n [ in| out ] exporta el pin n para que pueda ser utilizado por otros programas que no son lanzados por root.
exports muestra una lista de todos los pines que han sido exportados.
unexport n el pin n deja de estar disponible para programas que no han sido ejecutados por root.
unexportall idéntico al anterior pero para todos los pines.
load spi [buffer size ] Carga los módulos SPI en el kernel y establece opcionalmente un buffer definido en KB, yo valor por defecto es 4 KB.
load i2c [baud rate] Carga los módulos I2C en el kernel y establece opcionalmente la proporción en baudios en KB/s, cuyo valor por defecto es 100Kb/sec.

Interfaz sysfs

El sistema operativo Raspbian tiene mapados los pins de la GPIO en /sys/class/gpio, para poderlos gestionar a través de los ficheros que se encuentran en dicho directorio, export, unexport y el enlace simbólico a ../../devices/virtual/gpio/gpiochip0.

Para poder utilizar un pin, se debe escribir en el fichero export, su número. Hay que tener en cuenta que sólo root puede realizarlo (sudo su), para ello normalmente se utiliza el comando echo (echo n > /sys/class/gpio/export , donde n es el pin). A continuación se crea automáticamente un enlace simbólico en el mismo directorio al dispositivo virtual (../../devices/virtual/gpio/gpion). El pin se deberá establecer como de entrada o salida (echo out | in > /sys/class/gpio/gpion/direction). En el caso de ser de salida, se puede establecer la salida a 1 o 0 (echo 1 | 0 > /sys/class/gpio/gpion/value). En el caso de ser de entrada, se podría comprobar su valor en un fichero ( cat /sys/class/gpio/gpion/value ).

Finalmente, hay que dejar accesibles estos ficheros para otras aplicaciones, ya que cuando exportamos, los estamos bloqueando.

A continuación, se expone como se podría enceder un led asociado al pin n.

echo n > /sys/class/gpio/export
echo out > /sys/class/gpio/gpion/direction
echo 1 > /sys/class/gpio/gpion/value
echo n > /sys/class/gpio/unexport

VOLTAJES EN LA RASPBERRY PI

2013-06-11T11:50:00.000+01:00

La alimentación en la Raspberry Pi se realiza mediante una conexión micro USB, similar al que utilizan la mayor parte de los cargadores de los Smartphones actuales.

Para comprobar si el suministro eléctrico es correcto, dentro de la placa se encuentran dos puntos TP1 (Positivo) y TP2, (Negativo). Cuando se mide la corriente con un multímetro en posición de Corriente Continua y escala de 20V, debe ofrecer un resultado similar a 5V.

MEDICIÓN TP1 y TP2

Dentro de los pines GPIO hay dos que dan de manera continua 5V y 3.3V, que son especialmente útiles para probar circuitos. En la imagen inferior, los localizamos en las posiciones 1 y 2, mientras que tierra es el 6.

PINES GPIO RASPBERRY PI V 2.0.

MEDICIÓN DE LOS PINES DE 3.3V

MEDICIÓN DE 5V

Si que habrá que tener en cuenta en futuras experienias, que hay que tener especial cuidado con el consumo de los dispositivos que se conectan a través de GPIO, en concreto, la máxima intensidad demandada por los dispositivos puede ser de 300 mA (1000mA - 700mA). En caso de sobrepasar esos límites, seguramente estropearemos la placa.

CONFIGURANDO ACCESO REMOTO

2013-06-10T13:37:00.000+01:00

Para facilitar el trabajo sobre Raspberry Pi y poder trabajar directamente sobre ella desde otro equipo, veremos diferentes opciones y herramientas, concretamente, SSH para trabajar en línea de comandos, un cliente de Escritorio Remoto como TightVNC y Samba, para poder dejar en una carpeta compartida nuestros programas y scripts.

Lo primero que deberíamos hacer si no lo hemos hecho ya es configurar una dirección IP fija, tal y como se ha mostrado en la entrada "INSTALANDO Y CONFIGURANDO RASPBIAN".

Para trabajar sobre SSH tenemos dos opciones, habilitar mediante "raspi-config" el equipo como servidor de SSH ó instalarlo en línea de comandos (sudo apt-get install openssh-server).

Una vez instalado el servidor de SSH el siguiente paso será conectarnos mediante un cliente, como puede ser Putty.

Para conectarse mediante Putty el primer paso será descargarlo (Download).

El siguiente paso será configurarlo y ejecutarlo. Para evitar tener que poner todos los datos cada vez que nos conectemos, pondremos los datos de la dirección IP y guardaremos la sesión (Save), en mi caso se he llamado "Raspberry Pi". Ahora ya nos podremos conectar (Open).

Alerta inicial la primera vez que nos conectamos

Introducimos el nombre de Usuario pi y contraseña raspberry

ESCRITORIO REMOTO (TIGHTVNC)

Con el objetivo de realizar conexiones de Escritorio desde múltiples Sistemas Operativos, se ha optado por el software gratuito y libre “TightVnc” .

El primer paso es instalar el programa en nuestra RPI, para ello, partiremos de que se puede realizar una conexión mediante SSH (no es necesario pero si solivianta estos pasos repetitivos), a continuación se deben actualizar los repositorios (sudo apt-get update) y proceder con la instalación (sudo apt-get install tightvncserver), aceptando el mensaje que muestra.

Una vez instalado el programa nuestro equipo será un "servidor" que aceptará conexiones de escritorio remoto. Ahora, para poder realizar una conexión habrá que realizar una instancia en el servidor para podernos conectar desde otro equipo. Un ejemplo de instancia podría ser vncserver :1 -geometry 1024x768 -depth 24, estamos configurando la instancia 1, con una resolución de 1024x768 y una profundidad de color de 24 bit. A continuación pedirá la contraseña de conexión para los clientes.

En mi caso la contraseña seleccionada ha sido raspberry, para acordarme posteriormente.

El principal problema es que cada vez que reiniciamos esta instancia se pierde.

En este punto, podemos conectarnos mediante clientes de VNC. En la página http://www.tightvnc.com/ podremos encontrar varios clientes, si bien el Viewer de Java ha presentado problemas debido a un bug de representación de caracteres, por ello, se ha trabajado principalmente con un portable que no ha dado problemas (http://www.tightvnc.com/download/1.3.10/tightvnc-1.3.10_x86_viewer.zip).

Para conectarnos debemos indicar la dirección ip y el puerto. El puerto por defecto es 5900 pero hay que sumar el número de conexión que es 1.

En este punto debemos indicar la conexión citada anteriormente

En este punto debemos indicar la conexión citada anteriormente y ya podemos trabajar en entorno gráfico.

Fácilmente se puede configurar una aplicación similar para Android denominada VNCAndroid y trabajar mediante el móvil, es decir, !tenemos totalmente contralada la Raspberry Pi con el móvil!.

En este punto habría que preguntarse, ¿no resulta demasiado pesado tener que crear la instancia antes de conectarse?. Existe una solución que es crear un demonio que arranque al principio.

En primer lugar hay que comentar que hay siete modos de ejecución, cada uno de estos modos de ejecución X ejecuta varios scripts. En los directorios/etc/rcX.d/ se encuentran los enlaces simbólicos que se ejecutarán en el modo de ejecución X y , generalmente, estos scripts se almacenan en el directorio /etc/init.d.

En Raspbian el nivel en el que se arranca por defecto es 2, para saberlo es tan sencillo como ejecutar el comando runlevel.

En es este punto donde se debe crear un fichero que contenga el contenido que va a ejecutar el demonio, que se denominará remoto (descargar) y contendrá la configuración.

#!/bin/bash
### BEGIN INIT INFO
# Provides: remoto
# Required-Start: $syslog
# Required-Stop: $syslog
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: vnc server
# Description: Demonio Servidor Escritorio Remoto VNC
#
### END INIT INFO
## Autor: M.Alvarez (miguelwarez@gmail.com) 2013
## Más ejemplos en http://rpiplus.sourceforge.net

PROG="Xtightvnc"

case "$1" in
start)
echo "Lanzando $PROG"
su pi -c '/usr/bin/vncserver';;
stop)
echo "Parando $PROG"
pkill -TERM $PROG;;
reload)
echo "Volviendo a cargar $PROG:"
pkill -HUP $PROG;;
restart)
echo "Reiniciando $PROG"
pkill -TERM $PROG
su pi -c '/usr/bin/vncserver';;
*)
echo "Uso: /etc/init.d/remoto {start|stop|reload|restart}"
exit 1;;
esac
exit 0

Definimos un demonio que se puede lanzar (start), parar(stop), reload (volver a cargar), restart (reiniciar), utilizando básicamente las señales disponibles de LINUX.

Ya sólo falta dar permisos de ejecución al fichero para todos los usuarios, para ello se ha utilizado el comando chmod.

A continuación se dejará el fichero en el directorio donde se encuentran los demonios que ejecuta Raspbian.

A continuación, se van a actualizar los scripts mediante el comando update-rc.d

Se va a comprobar el correcto funcionamiento, lanzando el demonio y parándolo.

Además para comprobar que se ha creado correctamente el enlace simbólico:

Ahora ya está configurada Raspberry Pi para que cada vez que se encienda nos podamos conectar mediante escritorio remoto.

INSTALACIÓN DE SAMBA

Especialmente útil resultará tener instalado samba para poder conectarnos a una carpeta compartida en la que dejemos los programas y scripts.

Para instalar samba y un cliente deberemos ejecutar sudo apt-get install samba smbclient.

Se va a definir una carpeta compartida publica que se encontrará en el home de pi y no será visible en la red. El primer paso es crear una carpeta denominada publica con todos los permisos: mkdir -m 777 publica.

Posteriormente, se editará el fichero /etc/samba/smb.conf y se añadirá al final:

[publica$]
path = /home/pi/publica
browseable = yes
writeable = yes
guest ok = yes

Para concluir se deberá reiniciar el servicio samba, para que cargue la nueva configuración sudo /etc/init.d/samba restart.

En este momento se podrá acceder desde cualquier equipo a esta carpeta escribiendo \\dirIP\publica$

Al trabajar con Sistemas Operativos Windows y Linux se han constado errores al ejecutar shell scripts del tipo:

bash: ./mifichero.sh: /bin/bash^M: bad interpreter: No existe el fichero o el directorio

Estos errores se deben a que en los Sistemas Operativos Windows, se insertan al final de cada línea retornos de carro y saltos de línea, mientras que en Linux se insertan sólo saltos de línea.

Para eliminar este tipo de errores se ha optado por el programa dos2unix, que elimina este tipo de problemas, convirtiendo de Dos a Unix como su nombre indica. La sintaxis es dos2unix mifichero.sh. Si tenemos problemas con el propietario, mediante el comando sudo chown pi mifichero.sh cambiaremos el propietario y ya podremos pasar el comando sin problemas.

EXPLORANDO EL HARDWARE DE RASPBERRY

2013-06-09T15:40:00.000+01:00

Esta entrada se va a realizar un análisis del hardware de la Raspberry Pi, partiendo de las especificaciones técnicas de la Raspberry Pi B modelo 2.0. Para realizar el estudio se partirán de herramientas incluidas en el Sistema Operativo y alguna otra que habrá que instalar.

La información sobre el Hardware del equipo se va a obtener del directorio /proc , sistema de ficheros virtual que el sistema crea en memoria y ofrece información relacionada con el sistema.

El primer fichero que se va a analizar es /proc/cpuinfo, que tiene información relativa al procesador. Una vez ejecutado cat /proc/cpuinfo obtenemos la siguiente información

Processor : ARMv6-compatible processor rev 7 (v6l)
BogoMIPS : 697.95
Features : swp half thumb fastmult vfp edsp java tls
CPU implementer : 0x41
CPU architecture: 7
CPU variant : 0x0
CPU part : 0xb76
CPU revision : 7
Hardware : BCM2708
Revision : 000f
Serial : 00000000c047d6ab

La información más importante que se puede observar es la versión de procesador ARM con la que es compatible con la versión 7, identificado por BCM2708 (procesador Broadcom 2708).

Mediante el comando lscpu se obtiene:

Architecture: armv6l
Byte Order: Little Endian
CPU(s): 1
On-line CPU(s) list: 0

Está indicando que solo hay una CPU y utiliza el sistema Little-Endian, es decir, el acceso a los bytes se realiza de manera incremental, de menos relevante a más relevante.

Para explorar la memoria se va a explorar el archivo /proc/meminfo, que contiene información del sistema de memoria. Para acceder a su contenido cat /proc/meminfo.

MemTotal: 448996 kB
MemFree: 251624 kB
Buffers: 38624 kB
Cached: 107892 kB
SwapCached: 0 kB
Active: 88828 kB
Inactive: 85020 kB
Active(anon): 27400 kB
Inactive(anon): 724 kB
Active(file): 61428 kB
Inactive(file): 84296 kB
Unevictable: 0 kB
Mlocked: 0 kB
SwapTotal: 102396 kB
SwapFree: 102396 kB
Dirty: 0 kB
Writeback: 0 kB
AnonPages: 27344 kB
Mapped: 17100 kB
Shmem: 796 kB
Slab: 18452 kB
SReclaimable: 14840 kB
SUnreclaim: 3612 kB
KernelStack: 1168 kB
PageTables: 1396 kB
NFS_Unstable: 0 kB
Bounce: 0 kB
WritebackTmp: 0 kB
CommitLimit: 326892 kB
Committed_AS: 153780 kB
VmallocTotal: 188416 kB
VmallocUsed: 884 kB
VmallocChunk: 186712 kB

Estos datos indican que la memoria RAM es de 438 MB, prácticamente la memoria del sistema está libre, unos 38 MB están siendo utilizados por buffers en este momento, unos 107 MB se están utilizando de memoria RAM como Caché, no hay Caché en al memoria virtual, se están utilizando 102 MB como memoria virtual (SWAP).

En este punto cabría preguntarse cómo puede ser que se comercialice la placa con 512 MB de RAM cuando el sistema muestra un valor bastante inferior cercano de unos 438 MB. Esto es debido a que a los 512 MB se les quita unos pocos bits reservados y espacio del kernel.

Información similar pero más resumida se obtiene mediante el comando free –m .

total

used

free

shared

buffers

cached

Mem:

438

116

321

-/+

buffers/cache:

402

Swap:

Para explorar la memoria dedicada a cada dispositivo físico se explora el fichero /proc/iomem.

00000000-1bffffff : System RAM
00008000-004c0e77 : Kernel text
004e2000-005b5127 : Kernel data
20000000-20000fff : bcm2708_vcio
20003000-20003fff : bcm2708_systemtimer
20006000-20006fff : bcm2708_usb
20006000-20006fff : dwc_otg
20007000-20007fff : bcm2708_dma.0
20007000-20007fff : bcm2708_dma
20100000-201000ff : bcm2708_powerman.0
20200000-20200fff : bcm2708_gpio
20201000-20201fff : dev:f1
20201000-20201fff : uart-pl011
20204000-202040ff : bcm2708_spi.0
20205000-202050ff : bcm2708_i2c.0
20300000-203000ff : bcm2708_sdhci.0
20300000-203000ff : mmc0
20804000-208040ff : bcm2708_i2c.1
20980000-2099ffff : bcm2708_usb
20980000-2099ffff : dwc_otg

En este punto se ven las zonas de memoria para la comunicación con dispositivos a través de la GPIO, USB, serie,...

Existe un fichero bastante interesante que se encuentra en /boot denominado config.txt, dicho fichero es leído por la GPU antes de que el núcleo ARM sea inicializado. La configuración de este fichero permite modificar la frecuencia del procesador ARM, de la GPU, de la SDRAM, suministrar más voltaje al núcleo de la Raspberry Pi,… .Por tanto se podría realizar “Overclocking” modificando el mismo. El contenido del fichero es:

# uncomment if you get no picture on HDMI for a default "safe" mode
#hdmi_safe=1
# uncomment this if your display has a black border of unused pixels visible
# and your display can output without overscan
disable_overscan=1
# uncomment the following to adjust overscan. Use positive numbers if console
# goes off screen, and negative if there is too much border
#overscan_left=16
#overscan_right=16
#overscan_top=16
#overscan_bottom=16
# uncomment to force a console size. By default it will be display's size minus
# overscan.
#framebuffer_width=1280
#framebuffer_height=720
# uncomment if hdmi display is not detected and composite is being output
#hdmi_force_hotplug=1
# uncomment to force a specific HDMI mode (this will force VGA)
#hdmi_group=1
#hdmi_mode=1
# uncomment to force a HDMI mode rather than DVI. This can make audio work in
# DMT (computer monitor) modes
#hdmi_drive=2
# uncomment to increase signal to HDMI, if you have interference, blanking, or
# no display
#config_hdmi_boost=4
# uncomment for composite PAL
#sdtv_mode=2
#uncomment to overclock the arm. 700 MHz is the default.
#arm_freq=800
# for more options see http://elinux.org/RPi_config.txt

Se ha instalado la herramienta hardinfo, que incorpora test a la CPU para ampliar la información obtenida hasta el momento.

Se ha generado un informe mediante la opción de Generate Report y la información que se ha considerado más útil, que amplía a la ya obtenida, es:

Memory 448MB (60MB used)
Audio Adapter
BRCM bcm2835 ALSbcm2835 ALSA - bcm2835 ALSA

MAPA EN MEMORIA
MODULO	COMIENZO HEX	FIN HEX	COMIENZO DEC	FIN DEC
SystemRAM	00000000	1bffffff	0	469762047
Kerneltext	00008000	004c0e77	32768	4984439
Kerneldata	004e2000	005b5127	5120000	5984551
bcm2708_vcio	20000000	20000fff	536870912[1]	536875007
bcm2708_systemtimer	20003000	20003fff	536883200	536887295
bcm2708_usb	20006000	20006fff	536895488	536899583
dwc_otg	20006000	20006fff	536895488	536899583
bcm2708_dma.0	20007000	20007fff	536899584	536903679
bcm2708_dma	20007000	20007fff	536899584	536903679
bcm2708_powerman.0	20100000	201000ff	537919488	537919743
bcm2708_gpio	20200000	20200fff	538968064	538972159
dev:f1	20201000	20201fff	538972160	538976255
uart-pl011	20201000	20201fff	538972160	538976255
bcm2708_spi.0	20204000	202040ff	538984448	538984703
bcm2708_i2c.0	20205000	202050ff	538988544	538988799
bcm2708_sdhci.0	20300000	203000ff	540016640	540016895
mmc0	20300000	203000ff	540016640	540016895
bcm2708_i2c.1	20804000	208040ff	545275904	545276159
bcm2708_usb	20980000	2099ffff	546832384	546963455
dwc_otg	20980000	2099ffff	546832384	546963455

[1] 536870912 = 512 MB RAM X 1024 KB/MB X 1024 B/KB

A través de la herramienta hardinfo también podemos testear la CPU, a través de diferentes pruebas. Puede ser un buen punto de partida comparar estos valores con los obtenidos cuando se realiza Overclocking sobre la CPU.

Otra herramienta que permite listar el hardware es lshw, que no viene instalada por defecto y la información que muestra no dista mucho de la vista hasta el momento, pero si indica que trabaja a 700MHz y el ancho de palabra es de 32 bit.

LIBRERIA WIRING PI

2013-06-07T22:02:00.000+01:00

WiringPi es una librería escrita en C y liberada baja licencia GNU LGPLv3, que puede ser empleada en varios lenguajes de programación, además de C y C++, con alguna pequeña modificación en forma de adaptación.

Su principal uso es en la programación de periféricos a través de los 26 pines de General Purpose Input Output (GPIO).

WiringPi, además, ofrece un comando que permite programar y configurar los pines de la GPIO, pudiendo efectuar la lectura y escritura de los pines desde la línea de comandos o incluso, incorporándola en un Shellscript.

Instalación utilizando GIT

Git es un software de control de versiones, libre y de código abierto, diseñado para manejar todo tipo de proyectos, desde pequeños a grandes con rapidez y eficiencia.

En caso de no estar instalado GIT se debería instalar. Para ello en primer lugar hay que actualizar los repositorios y posteriormente instalarlo.

sudo apt-get update sudo apt-get install git-core

Posteriormente hay que obtener la libreria mediante GIT

git clone git://git.drogon.net/wiringPi

Una vez descargado, hay que ir al directorio donde se encuentra y obtener una versión actualida.

cd wiringPi
git pull origin

A continuación, se debe ejecutar el script de creación e instalación en el directorio de WiringPi.

./build

El nuevo script se encarga de compilar y ejecutar todo, sin que sea necesaria la intervención del usuario.

Descargando la librería.

Se va a proceder a descargar la aplicación en el directorio temporal /tmp.

cd /tmp
wget http://project-downloads.drogon.net/files/wiringPi.tgz

A continuación hay que desempaquetar el fichero.

tar xfz wiringPi.tgz

En este momento, se va a proceder a instalar las librerías relacionadas con wiringPi.

cd wiringPi/wiringPi
make
sudo make install

A continuación, se va a instalar la herramienta gpio, que permite en línea de comandos trabajar con los pines.

cd ../gpio make sudo make install

Finalmente, se van a instalar los ejemplos.

cd ../examples
make

Utilización

Para poder utilizar esta librería es necesario indicar que se va a emplear, en la primera parte del programa se incorpora la cabecera de la librería (#include<wiringPi.h ) y en la compilación se especifica que utilice la misma (gcc –o pruebas -l wiringPi pruebas.c).

Principales constantes y funciones de la librería

Funciones constructoras

Hay tres funciones constructoras que permiten trabajar con la librería Wiring Pi, todas ellas devuelven -1 en caso de que se produzca un error.

int wiringPiSetup(void) : Inicializa Wiring Pi y emplea el convenio de numeración de Wiring Pi.

A continuación se muestra la tabla resumen de los pines GPIO para la versión 1.

Ping wiringPi	BCM GPIO	Name	Header	Name	BCM GPIO	Ping wiringPi
–	–	3.3v	1 \| 2	5v	–	–
8	R1:0/R2:2	SDA0	3 \| 4	DNC	–	–
9	R1:1/R2:3	SCL0	5 \| 6	0v	–	–
7	4	GPIO7	7 \| 8	TxD	14	15
–	–	DNC	9 \| 10	RxD	15	16
0	17	GPIO0	11 \| 12	GPIO1	18	1
2	R1:21/R2:27	GPIO2	13 \| 14	DNC	–	–
3	22	GPIO3	15 \| 16	GPIO4	23	4
–	–	DNC	17 \| 18	GPIO5	24	5
12	10	MOSI	19 \| 20	DNC	–	–
13	9	MISO	21 \| 22	GPIO6	25	6
14	11	SCLK	23 \| 24	CE0	8	10
–	–	DNC	25 \| 26	CE1	7	11

Para la revisión 2

Ping wiringPi	BCM GPIO	Name	Header	Name	BCM GPIO	Ping wiringPi
–	–	5v	1 \| 2	3.3v	–	–
17	28	GPIO8	3 \| 4	GPIO9	29	18
19	30	GPIO10	5 \| 6	GPIO11	31	20
–	–	0v	7 \| 8	0v	–	–

int wiringPiSetupGpio(void) : Idéntica a la anterior, pero utiliza la numeración de pines de Broadcom (BCM GPIO).
int wiringPiSetupSys(void) : En este caso utiliza la interfaz /sys/class/gpio, en vez de trabajar directamente sobre el Hardware.

Funciones generales

void pinMode(int pin, int mode) : Sirve para especificar el pin (primer argumento) y modo (segundo argumento), que puede ser entrada (INPUT), salida (OUTPUT) o salida PWM (PWM_OUTPUT).
void digitalWrite(int pin, int value) : Se utiliza para poner un pin, que previamente ha sido configurado como OUTPUT a dos posibles valores 1 (HIGH) o 0 (LOW).
void digitalWriteByte(int value) : Permite escribir en los 8 pines de la GPIO un valor.
void pwmWrite(int pin, int value) : Escribe el valor del registro PWM (segundo argumento) al pin indicado (primer argumento). El valor suministrado debe estar comprendido entre 0 y 1024, además, hay que tener en cuenta que sólo soporta PWM el pin BCM_GPIO 18.
int digitalRead(int pin) : devuelve el valor leído en el pin indicado (único argumento), que puede ser 1 (HIGH) o 0 (LOW).
void pullUpDnControl(int pin, int pud) : establece sobre el pin indicado (primer argumento) el modo de tensión o resistencia, elevar a 3v3 ( PUD_UP), tirar a tierra (PUD_DOWN) o ni elevar ni disminuir (PUD_OFF).

Funciones de control PWM

Las siglas PWM corresponden a pulse-width modulation, en castellano, Modulación por ancho de pulsos, consistente en cambiar el ciclo de una señal periódica. No se pueden utilizar cuando se trabaja en modo sistema (mode sys).

void pwmSetMode(int mode) : El generador puede trabajar en dos modos balanceado ( PWM_MODE_BAL ), que es el que utiliza por defecto Raspberry Pi o marca espacio (PWM_MODE_MS) .
void pwmSetRange(unsigned int range) : Establece el valor máximo del rango del registro PWM, establecido por defecto a 1024.
void pwmSetClock(int divisor) : Sirve para establecer el divisor del reloj PWM.

Funciones de tiempo

unsigned int millis(void) : Devuelve el numero de milisegundos que han transcurrido desde que se ha invocado a una función Wiring Pi.
void delay(unsigned int howLong) : Provoca la pausa del programa durante al menos howLong milisegundos.
void delayMicroseconds(unsigned int howLong) : Análogo al anterior, pero en este caso se estabecen microsegundos.

Program/Thread Priority

int piHiPri(int priority) : sirve para establecer la prioridad del programa o thread, que oscila entre 0 ,valor establecida por defecto y 99 valor máximo y permite la planificación en tiempo real. El valor devuelto es 0 en caso de éxito y -1 en caso de error. Sólo los programas ejecutados como root pueden cambiar su prioridad.

Funciones de interrupciones

int waitForInterrupt(int pin, int timeOut) : permite establecer un tiempo de espera en milisegundos (segundo argumento) para una interrupción definida sobre un pin ( primer argumento), en el caso de definir como timeOut -1 esperará indefinidamente. El valor devuelto es 0 en caso de éxito y -1 en caso de error. Esta función está obsoleta y se recomienda utilizar la que se presenta a continuación.
int wiringPiISR(int pin, int edgeType, void (*function)(void)) : mediante esta function se puede establecer un manejador sobre un pin, además se debe especificar si se detecta mediante un flanco de bajada (INT_EDGE_FALLING) , un flanco de subida (INT_EDGE_RISING ), en ambos flancos (INT_EDGE_BOTH) o el pin no ha sido inicializado (INT_EDGE_SETUP). El valor devuelto es 0 en caso de éxito y -1 en caso de error.

Funciones de programación concurrente

Wiring Pi permite la utilización de hilos POSIX, así como mecanismos de exclusión mutua (mutex).

int piThreadCreate(void * (* fn) (void *) : Crea un Thread de una función que ha sido declarada previamente mediante PI_THREAD. La declaración sería similar a PI_TREAD(miThread){ código } y posteriormente, esta función será el argumento de la función. El valor devuelto es 0 en caso de éxito y -1 en caso de error.
void piLock(int keyNum) : bloquea una clave (keyNum) cuyo valor va de 0 a 3, cuando otro thread intenta bloquear a la clave, queda a la espera de que sea liberado.
void piUnlock(int keyNum) : Permite desbloquear una clave definida como en la función anterior.

Otras funciones

int piBoardRev(void) : indica la versión de la placa sobre la que se está trabajando.
int wpiPinToGpio(int wPiPin) : transforma el número de pin según el convenio de Wiring Pi al convenio de BCM GPIO.
void setPadDrive(int group, int value) : establece la “fuerza” de los drivers para un grupo de pins.

COMPILAR ENSAMBLADOR ARM Y C

2013-06-06T15:36:00.000+01:00

En esta entrada se parte de unos conocimientos de programación básicos de ARM y C.

gcc

gcc (GNU Compiler Collection) es una colección de compiladores libres y a continuación se presentan sus principales argumentos:

-c Es utilizado para compilar o ensamblar los ficheros fuentes, pero sin enlazar.
-S Sirve para transformar un archivo que contiene un programa fuente en C en un archivo fuente en ensamblador.
-o archivo La salida del compilador se almacena en el archivo indicado.
-g Sirve para generar información de depuración, muy útil para poder utilizar posteriormente en programas de depuración.
-l librería Añade la libreria especificada en la compilación.

Para probar algunas opciones se va a partir del programa holamundo

#include<stdio.h>
main(){
printf("Hola Mundo\n");
}

Se va a compilar y ejecutar para ello

gcc -o holamundo holamundo.c
chmod +x holamundo
./holamundo

Si se desea generar el código en ensamblador

gcc -S holamundo.c

as (GNU Assembler) es un ensamblador del proyecto GNU, se van a citar aquellas que han sido más utilizadas.

-o archivo Sirve para que el archivo objeto generado se denomine archivo.
-g Sirve para generar información de depuración, muy útil para poder utilizar posteriormente en programas de depuración.

as –o holamundo.o holamundo.s

ld (GNU Linker) sirve para enlazar ficheros objeto y generar un ejecutable.

-l librería Añade la librería especificada en la compilación.
-m maquina Especifica la arquitectura a emplear cuando se desensamblen ficheros objeto.
-dynamic-linker Establece el enlazado dinámico
-T Permite definir donde comienzan las secciones
-o archivo Sirve para que el archivo objeto generado se denomine archivo.

ld -dynamic-linker /lib/ld-linux.so.3 -o p1a p1a.o copy.o -T ldscript.ld

objdump

Es una herramienta que forma parte de las GNU Binutils, es una herramienta que muestra información sobre los programas objeto.

Se proceden a mostrar las entradas que se han considerado más relevantes del manual

-d /--disassemble Muestra los mnemónicos de ensamblador para las instrucciones máquina de fichobj. Esta opción sólo desensambla aquellas secciones para las que se espera que contengan instrucciones.
-D / --disassemble-all Como -d, pero desensambla los contenidos de todas las secciones, no sólo aquéllas donde se espera que contengan instrucciones.
‐j / ‐‐section= nombre Seleccionar información sólo de la sección mencionada.
-S Intercala código fuente con desensamblado.
‐s / ‐‐full‐contents Mostrar contenidos completos de todas las secciones.
-t Muestra las entradas de la tabla de símbolos.

Como ejemplo se va a partir del programa holamundo.c definido anteriormente, a continuación se procederá a compilar el archivo con las opciones –g para que genere información de depuración y –o para indicar un fichero de salida.

gcc –g –o holamundo holamundo.c

A modo de ejemplo se va a proceder a utilizar la opción –S (desensambla e intercala código fuente)

objdump –S holamundo

holamundo: file format elf32-littlearm

Disassembly of section .init:

000082cc <_init>:
    82cc:       e92d4008        push    {r3, lr}
    82d0:       eb000020        bl      8358
    82d4:       e8bd8008        pop     {r3, pc}

Disassembly of section .plt:

000082d8 <.plt>:
    82d8:       e52de004        push    {lr}            ; (str lr, [sp, #-4]!)
    82dc:       e59fe004        ldr     lr, [pc, #4]    ; 82e8 <_init data-blogger-escaped-x1c="">
    82e0:       e08fe00e        add     lr, pc, lr
    82e4:       e5bef008        ldr     pc, [lr, #8]!
    82e8:       00008280        .word   0x00008280
    82ec:       e28fc600        add     ip, pc, #0
    82f0:       e28cca08        add     ip, ip, #32768 ; 0x8000
    82f4:       e5bcf280        ldr     pc, [ip, #640]! ; 0x280
    82f8:       e28fc600        add     ip, pc, #0
    82fc:       e28cca08        add    ip, ip, #32768 ; 0x8000
    8300:       e5bcf278        ldr     pc, [ip, #632]! ; 0x278
    8304:       e28fc600        add     ip, pc, #0
    8308:       e28cca08        add     ip, ip, #32768 ; 0x8000
    830c:       e5bcf270        ldr     pc, [ip, #624]! ; 0x270
    8310:       e28fc600        add     ip, pc, #0
    8314:       e28cca08        add     ip, ip, #32768 ; 0x8000
    8318:       e5bcf268        ldr     pc, [ip, #616]! ; 0x268

Disassembly of section .text:

0000831c <_start>:
    831c:       e3a0b000        mov     fp, #0
    8320:       e3a0e000        mov     lr, #0
    8324:       e49d1004        pop     {r1}            ; (ldr r1, [sp], #4)
    8328:       e1a0200d        mov     r2, sp
    832c:       e52d2004        push    {r2}            ; (str r2, [sp, #-4]!)
    8330:       e52d0004        push    {r0}            ; (str r0, [sp, #-4]!)
    8334:       e59fc010        ldr     ip, [pc, #16]   ; 834c <_start data-blogger-escaped-x30="">
    8338:       e52dc004        push    {ip}            ; (str ip, [sp, #-4]!)
    833c:       e59f000c        ldr     r0, [pc, #12]   ; 8350 <_start data-blogger-escaped-x34="">
    8340:       e59f300c        ldr     r3, [pc, #12]   ; 8354 <_start data-blogger-escaped-x38="">
    8344:       ebffffeb        bl      82f8 <_init data-blogger-escaped-x2c="">
    8348:       ebfffff0        bl      8310 <_init data-blogger-escaped-x44="">
    834c:       00008444        .word   0x00008444
    8350:       000083c8        .word   0x000083c8
    8354:       000083e4        .word   0x000083e4

00008358 :
    8358:       e59f3014        ldr     r3, [pc, #20]   ; 8374
    835c:       e59f2014        ldr     r2, [pc, #20]   ; 8378
    8360:       e08f3003        add     r3, pc, r3
    8364:       e7933002        ldr     r3, [r3, r2]
    8368:       e3530000        cmp     r3, #0
    836c:       012fff1e        bxeq    lr
    8370:       eaffffe3        b       8304 <_init data-blogger-escaped-x38="">
    8374:       00008200        .word   0x00008200
    8378:       0000001c        .word   0x0000001c

0000837c <__do_global_dtors_aux>:
    837c:       e59f3010        ldr     r3, [pc, #16]   ; 8394 <__do_global_dtors_aux data-blogger-escaped-x18="">
    8380:       e5d32000        ldrb    r2, [r3]
    8384:       e3520000        cmp     r2, #0
    8388:       03a02001        moveq   r2, #1
    838c:       05c32000        strbeq r2, [r3]
    8390:       e12fff1e        bx      lr
    8394:       00010590        .word   0x00010590

00008398 :
    8398:       e59f0020        ldr     r0, [pc, #32]   ; 83c0
    839c:       e92d4008        push    {r3, lr}
    83a0:       e5903000        ldr     r3, [r0]
    83a4:       e3530000        cmp     r3, #0
    83a8:       08bd8008        popeq   {r3, pc}
    83ac:       e59f3010        ldr     r3, [pc, #16]   ; 83c4
    83b0:       e3530000        cmp     r3, #0
    83b4:       08bd8008        popeq   {r3, pc}
    83b8:       e12fff33        blx     r3
    83bc:       e8bd8008        pop     {r3, pc}
    83c0:       00010474        .word   0x00010474
    83c4:       00000000        .word   0x00000000

000083c8 :
#include
main(){
    83c8:       e92d4800        push    {fp, lr}
    83cc:       e28db004        add     fp, sp, #4
        printf("Hola Mundo\n");
    83d0:       e59f0008        ldr     r0, [pc, #8]    ; 83e0
    83d4:       ebffffc4        bl      82ec <_init data-blogger-escaped-x20="">
}
    83d8:       e1a00003        mov     r0, r3
    83dc:       e8bd8800        pop     {fp, pc}
    83e0:       00008454        .word   0x00008454

000083e4 <__libc_csu_init>:
    83e4:       e92d45f8        push    {r3, r4, r5, r6, r7, r8, sl, lr}
    83e8:       e1a06000        mov     r6, r0
    83ec:       e59f5048        ldr     r5, [pc, #72]   ; 843c <__libc_csu_init data-blogger-escaped-x58="">
    83f0:       e59fa048        ldr     sl, [pc, #72]   ; 8440 <__libc_csu_init data-blogger-escaped-x5c="">
    83f4:       e08f5005        add     r5, pc, r5
    83f8:       e08fa00a        add     sl, pc, sl
    83fc:       e065a00a        rsb     sl, r5, sl
    8400:       e1a07001        mov     r7, r1
    8404:       e1a08002        mov     r8, r2
    8408:       ebffffaf        bl      82cc <_init>
    840c:       e1b0a14a        asrs    sl, sl, #2
    8410:       08bd85f8        popeq   {r3, r4, r5, r6, r7, r8, sl, pc}
    8414:       e3a04000        mov     r4, #0
    8418:       e4953004        ldr     r3, [r5], #4
    841c:       e1a00006        mov     r0, r6
    8420:       e1a01007        mov     r1, r7
    8424:       e1a02008        mov     r2, r8
    8428:       e2844001        add     r4, r4, #1
    842c:       e12fff33        blx     r3
    8430:       e154000a        cmp     r4, sl
    8434:       1afffff7        bne     8418 <__libc_csu_init data-blogger-escaped-x34="">
    8438:       e8bd85f8        pop     {r3, r4, r5, r6, r7, r8, sl, pc}
    843c:       00008070        .word   0x00008070
    8440:       00008070        .word   0x00008070

00008444 <__libc_csu_fini>:
    8444:       e12fff1e        bx      lr

Disassembly of section .fini:

00008448 <_fini>:
    8448:       e92d4008        push    {r3, lr}
    844c:       e8bd8008        pop     {r3, pc}

Muestra los símbolos con los que enlaza un programa.

nm holamundo

00010478 d _DYNAMIC
00010568 d _GLOBAL_OFFSET_TABLE_
00008450 R _IO_stdin_used
         w _Jv_RegisterClasses
00008468 r __FRAME_END__
00010474 d __JCR_END__
00010474 d __JCR_LIST__
00010594 A __bss_end__
00010590 A __bss_start
00010590 A __bss_start__
00010588 D __data_start
0000837c t __do_global_dtors_aux
00010470 t __do_global_dtors_aux_fini_array_entry
0001058c D __dso_handle
00010594 A __end__
0001046c t __frame_dummy_init_array_entry
         w __gmon_start__
00010470 t __init_array_end
0001046c t __init_array_start
00008444 T __libc_csu_fini
000083e4 T __libc_csu_init
         U __libc_start_main@@GLIBC_2.4
00010594 A _bss_end__
00010590 A _edata
00010594 A _end
00008448 T _fini
000082cc T _init
0000831c T _start
         U abort@@GLIBC_2.4
00008358 t call_gmon_start
00010590 b completed.5637
00010588 W data_start
00008398 t frame_dummy
000083c8 T main
         U puts@@GLIBC_2.4

C y ARM

A continuación se va a mostrar el siguiente ejemplo, la función en ensamblador es una suma almacenada en suma.s y es llamada desde el programa main.c.

main.c

#include<stdio.h>
extern int suma(int a, int b);
int main(int argc, char *argv[])
{
printf("== sum ==\n");
int a = 71;
int b = 29;
printf("%d + %d = %d\n", a, b, suma(a, b));
return 0;
}

suma.s

  .align 2
.arm
.global suma
suma:
add     r2, r0, r1 in r2
mov             r0, r2
mov             pc, lr

Pasos para tener este programa como ejecutable

gcc -c main.c
as -o suma.o suma.s
gcc -o main suma.o main.o
chmod a+x suma
./suma

ARM y C

En el siguiente ejemplo partimos de un fichero copy.c que copia de una cadena origen a una cadena destino n carácteres.

void __c_copy(char *orig, char *dest, int tam) {
int i;
for(i=0;i<tam;i++){

dest[i]=orig[i];
}
}

El siguiente programa en ensamblador contenido en el fichero main.s emplea la función anterior para copiar una cadena y mostrarla por pantalla.

.text
.global _start
_start:
       .extern __c_copy
       ldr r0, =.orig
       ldr r1, =.dest
       mov r2, #11
       bl    __c_copy
       ldr r0, =.dest
       bl _imprime
bl exit
.global _imprime
       _imprime:
             stmdb sp!, {r0,r1,lr}
             mov r1,r0
             ldr r0, =.string
             bl printf
             ldmia sp!, {r0,r1,pc}
.data
.string:
.asciz "%s\n"
.orig:
.asciz "Hola Mundo"
.dest:
.space 11
.end

Pasos para tener este programa como ejecutable

gcc -c copy.c
as -o main.o main.s
ld -dynamic-linker /lib/ld-linux.so.3 -lc -o main main.o copy.o
chmod a+x main
./main

DEPURADORES GDB Y DDD

2013-05-07T16:23:00.000+01:00

Las dos herramientas que se han estudiado para la depuración son gdb y ddd, el primero de ellos es en línea de comandos y el segundo en entorno gráfico. DDD utiliza gdb y lamentablemente, presenta algunos bugs ausentes en gdb y por tanto, resulta más interesante trabajar directamente sobre gdb.

gdb

gdb (GNU Debugger) es un depurador de programas escritos en cualquier lenguaje de programación y compilados con gcc.

El primer paso es compilar el programa en gcc con la opción –g , incorpora información para la depuración. Ídem si se obtienen los programas objeto mediante as con el argumento -gstabs y posteriormente habrá que hacer el enlazado mediante ld..

gcc –g –o holamundo holamundo.c

as –gstabs –o salida.o salida.s

En este momento, ya se puede emplear el depurador, para ello hay que invocar a gdb y pasar como argumento holamundo.

gdb holamundo

Principales opciones

backtrace Muestra la pila de llamadas

b función ó b fichero:línea Sirven para establecer puntos de ruptura o breakpoint en la posición indicada

c continua

frame n Muestra la llamada n

info b Muestra los breakpoints

info registers Muestra la información contenida en los registros

l función ó l fichero:línea listamos el código

n pasa a la línea siguiente sin entrar en la llamada.

print expresión muestra el valor de una expresión

q salir

r Ejecuta el programa.

s pasa a la línea siguiente entrando en la llamada.

x /nfu addr Examina la memoria (n unidades) en formato(f) string (s), hexadecimal (x) o machine (i) en tamaño u byte (b), halfword(h), word(w), giant word(g).

ddd

ddd (Data Display Debugger) es un depurador en entorno gráfico. Las posibilidades que ofrece son prácticamente las mismas que podemos realizar en gdb.

De igual manera que en el programa anterior, el primer paso sería compilar el programa incluyendo los símbolos para su posterior depuración.

gcc –g –o holamundo holamundo.c

En este momento, se debe abrir el fichero, tal y como se muestra en la imagen, utilizando la opción filter para abrir carpetas y open para abrir el fichero.

Una vez abierto el fichero, se presentan dos ventanas de especial interés, la primera, muestra el programa en C y la segunda, en la parte inferior, incorpora la herramienta gdb.

Para poner un breakpoint en una línea concreta del programa, hay que pinchar encima del número y en la parte superior se puede seleccionar Break.

En este punto ya se puede comenzar la ejecución del programa

En este momento, el programa ha comenzado su ejecución y se ha detenido en la línea 8. Aquí ya es posible mostrar el valor de una variable e incluso cambiarla.

Para mostrar una variable, se sebe seleccionar primero y mediante el botón derecho se muestra un menú que tiene varias opciones.

Para modificar el valor de la misma, otra vez se debe seleccionar y en la barra de iconos de la parte superior está la opción Set

En este momento, para retomar la ejecución del programa se deberá seleccionar la opción Cont, que aparece en la ventana de iconos de la derecha.

Si se desea conocer el contenido de la memoria, en el entorno gráfico se puede acceder mediante Data -> Memory. En este momento, se deberá elegir cuantas zonas de memoria se desean mostrar, en que formato y qué tipo de agrupación.

En el caso de que se desee conocer la información relativa a registros, hay que ir al menú Status -> Registers

INSTALANDO Y CONFIGURANDO RASPBIAN

2013-04-12T12:56:00.000+01:00

INSTALACIÓN DE RASPBIAN

Dentro de la página oficial de la Fundación Raspberry Pi, podemos descargar varios sistemas operativos (http://www.raspberrypi.org/downloads), aunque el más difundido y seguramente más práctico, es Raspbian, que es una distribución Debian adaptada para Raspberry Pi.

Para instalar Raspbian sobre una tarjeta SD, debemos emplear otro equipo, en el que hayamos descargado la imagen del Sistema Operativo y que tenga un lector de tarjetas SD, que son la mayor parte.

Si el equipo tiene Windows, lo más sencillo, es descargar el software gratuito “Win32 Disk Imager”. En Image File seleccionamos el fichero que contenga la imagen del Sistema Operativo, en Device debemos asegurarnos que escogemos la unidad correcta asociada a la tarjeta SD y mediante el botón Write realizamos el volcado.

Una vez finalizado este proceso , ya podemos insertar la tarjeta en Raspberry Pi y trabajar.

Si utilizamos Linux, una alternativa puede ser mediante el comando dd ejecutado como root, donde especificaremos mediante el argumento if la ubicación de la imagen y mediante of la tarjeta SD.

CONFIGURANDO RASPBIAN

El usuario por defecto de Raspbian es

pi y su contraseña raspberry, que es el que se deberá introducir la primera vez que se arranque la Raspberry Pi. Asimismo, el nombre por defecto es raspberrypi.

Una vez realizado el volcado del Sistema en la tarjeta SD, se debe proceder a su inserción en Raspberry Pi y conexión a la corriente para poder trabajar.

La primera pantalla que se presenta la primera vez que se enciende Raspberry Pi, permite configurar el Sistema Operativo. Esta configuración se puede realizar en este momento o más adelante, mediante el comando raspi-config (ejecutar mediante sudo).

Para movernos en este menú utilizaremos los cursores o la tecla tabulador y para aceptar enter. En este paso hay que advertir que en un menú en el que aparecen sólo corchetes ( [ ] ) no está seleccionado, mientras que cuando aparece un asterisco entre los corchetes si está seleccionado. La selección/deselección se realiza mediante el espacio.

En un primer paso vamos a “expandir” la partición de root a toda la tarjeta SD, con ello logramos utilizar toda la tarjeta SD.

A continuación se procederá a configurar el teclado, mediante la opción configure_keyboard. En nuestro caso se configuró, un Logitech genérico, ya que la versión de teclado con la que se ha trabajado, no estaba disponible. No se ha asociado una combinación de teclas al entorno gráfico, ya que directamente, se muestra si ejecutamos startx.

A continuación, se ha procedido a establecer la configuración regional de la máquina, mediante change_locale. Con la nueva configuración los menús aparecerán en castellano, elegimos zona horaria y , además, algunas datos como las fechas , números, moneda,... estarán adaptados.

Además se procederá a configurar correctamente la zona horaria

En este menú podemos configurar la Raspberry Pi para que arranque directamente en entorno gráfico, mediante boot_behaviour, habilitar SSH,...

Una vez realizadas estas operaciones cuando indiquemos que hemos terminado con las operaciones, habrá que reiniciar el equipo para que los cambios tengan efecto.

La interfaz gráfica una vez realizados los cambios debería ser como la imagen

CAMBIO DE NOMBRE DE EQUIPO

Dentro del menú ofrecido por raspi-config no tenemos la posibilidad de cambiar el nombre. Para proceder a cambiar el nombre del equipo, se debe modificar el fichero hostname, con una cuenta con privilegios suficientes, que se encuentra en /etc/hostname. El nombre que tiene la máquina por defecto es raspberrypi, que podremos obtener mediante el comando hostname o visualizando el fichero anterior (cat /etc/hostname).

CAMBIO DE DIRECCIÓN IP

Se recomienda establecer una dirección una dirección ip estática para la máquina, debido a que vamos a trabajar principalmente por control remoto. Para ello fichero se deberá modificar el fichero interfaces, que se encuentra en /etc/network/interfaces y cambiar la configuración de la tarjeta de red.

En nuestro vaso, se va a establecer, por ejemplo, la dirección ip 192.168.1.130, máscara de red 255.255.255.0 y puerta de enlace 192.168.1.1 para nuestra máquina. El primer paso es editar el fichero interfaces con suficientes privilegios, y cambiar la configuración de la tarjeta de red, por defecto eth0, sustituyendo la línea iface eth0 inet dhcp por

iface eth0 inet static
address 192.168.1.130
netmask 255.255.255.0
gateway 192.168.1.1

Además, es necesario configurar correctamente el archivo resolv.conf, que se ubica en /etc/resolv.conf para poder resolver los nombres de los servidores en Internet y es necesario especificar la dirección ip, al menos, de un servidor DNS. Aquí se muestra un ejemplo de configuración de este archivo:

domain Home
search Home
nameserver 192.168.1.1

DONDE COMPRAR RASPBERRY PI Y COMPONENTES

2013-04-05T17:26:00.000+01:00

El modelo B de Raspberry Pi se puede comprar en multitud de tiendas, si bien las recomendadas desde la página oficial de "Raspberry Pi" son Farnell (Element I4), Rs-Online y Think Allied, con un precio aproximado de 33 €. A este precio hay que sumarle los gastos de envío y algo que no tiene precio, el tiempo, sobre 2 ó 3 semanas.

Por motivos de urgencia tuve que buscar otras alternativas y en España costaba bastante encontrar vendedores, o que no vendieran a un precio desorbitado. Finalmente, adquirí dos placas en Ebay, en una tienda de Inglaterra, con un kit básico que incluía además de la Raspberry Pi, una tarjeta SD, cargador, cable HDMI y caja de metacrilato. El precio final fue de unos 55 € por cada una y unos 18 € de gastos de envío en total.

De las dos placas que compramos una salió mal y la tuvimos que devolver al vendedor, que no dio ningún problema, aunque hubo que pagar el envío hasta Inglaterra.

Actualmente, hay vendedores en España bastante competitivos y recomiendo realizar las compras aquí, por si surge algún problema. Lo que si que hay que fijarse es que sea el modelo de 512 mb de RAM y no el de 256.

La mayor parte de los componentes de Arduino valen para Raspberry Pi, aunque... !sin documentos de instrucciones ni información técnica!.

Cuando fui a comprar otras piezas, volvieron a surgir los mismos problemas que para la placa, pocos vendedores en España y bastante caros. Finalmente compré un "Super Starter Kit" por unos 25 €, que contenía varios leds, resistencias, cables, interruptores, una protoboard, un conector GPIO para conectar los pines de la Raspberry Pi y la protoboard. En el mismo pedido aproveché para comprar una pantalla LCD por unos 5 € y otros 5 € de gastos de envío.

Ahora que estoy más curtido, comentar que se puede comprar a buen precio aquí. Podemos mirar en alguna tienda de Inglaterra las piezas para Raspberry Pi y buscar las análogas aquí para Arduino, aunque en bastantes piezas, sale a cuenta pagar un poco más de gastos de envío e importarlas. En definitiva, a echar números y lo que más a cuenta nos salga.

Después de las dos compras iniciales, he realizado bastantes más y todas en Ebay, ya que es dónde más baratas he encontrado las piezas. Llevo gastados más de 150 € y la verdad que resulta adictivo comprar dispositivos, sobre todo cuando ves que aparece uno nuevo. También he comprobado que los precios han ido bajando, hay muchos más dispositivos y uno de los mayores problemas con los que me he encontrado, es la escasa documentación y ese ha sido uno de los motivos por los que he considerado útil este blog, contar las experiencias y experimentos realizados sobre Raspberry Pi, sirviendo de soporte.

BIENVENIDA A RPI++

2013-04-05T11:33:00.001+01:00

En este blog se expondrán información y experiencias relacionadas con la Raspberry Pi, en el ámbito del Proyecto Final de Carrera RPI++.

Logotipo del Proyecto

La página oficial del proyecto http://rpiplus.sourceforge.net y el proyecto en sourceforge http://sourceforge.net/projects/rpiplus/?source=directory.

Sí deseas seguir el proyecto en redes sociales, entra en la página Facebook ó Twitter. El canal de Youtube donde se colgarán los vídeos.

Los contenidos de este blog se distribuyen bajo licencia CopyLeft. Los materiales que se incluyen han llevado bastantes horas de trabajo y desarrollo, lo único que se pide es que si se van a utilizar se mencione la fuente.