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