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ása 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.
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).
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.
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.
/**************************************************************** ** ** ** 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) ;
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);
}
}
}
}
}
}
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.
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.
#!/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);
}
}
}
