Wiring PI y Raspberry PI (2da. parte)

Standard

Feliz día a todos los lectores. Otra vez nos volvemos a encontrar y en esta ocasión les tengo la 2da parte de la versátil biblioteca WirginPi para nuestra Raspberry (La primera parte aqui)

En la primera parte hicimos una pequeña prueba creando un blink en nuestra Raspberry. Viendo como funciona, ya podríamos con la misma función (digital write) y  algo  de C  básico dasarrollar un ejercicio básico el cual son las luces del auto fantastico

el_coche_fantastico

Para esto utilizaremos  5 led, por el positivo del  led, tiraremos un jumper (cable) a el gpio que vayamos a utilizar como salida. No sin antes recordar que por default nuestra biblioteca tiene una numeración diferente:

gpio1

Ya teniendo en cuenta esto y conectado los led así:

auto fantastico

Donde el  cable amarillo irá al gio de cada led correspondiente y la negra a un gnd  común.

Ya después de haber conectado nuestra electrónica,

Código

		
	#include <wiringPi.h>;
			#include   <stdio.h>;


			wiringPiSetup () ;


			int espera = 70; // El tiempo que se esperara

			int main (void)

			{
			wiringPiSetup();
			pinMode(0, OUTPUT); // Configuración de los PIN como salida
			pinMode(1, OUTPUT);
			pinMode(2, OUTPUT);
			pinMode(3, OUTPUT);
			pinMode(4, OUTPUT);
			delay(1000);

			digitalWrite(0, HIGH); // Enciende y apaga secuencialmente los LEDs
			delay(espera);
			digitalWrite(0, LOW);
			delay(espera);
			digitalWrite(1, HIGH);
			delay(espera);
			digitalWrite(1, LOW);
			delay(espera);
			digitalWrite(2, HIGH);
			delay(espera);
			digitalWrite(2, LOW);
			delay(espera);
			digitalWrite(3, HIGH);
			delay(espera);
			digitalWrite(3, LOW);
			delay(espera);
			digitalWrite(4, HIGH);
			delay(espera);
			digitalWrite(4, LOW);
			delay(espera);
			digitalWrite(3, HIGH);
			delay(espera);
			digitalWrite(3, LOW);
			delay(espera);
			digitalWrite(2, HIGH);
			delay(espera);
			digitalWrite(2, LOW);
			delay(espera);
			digitalWrite(1, HIGH);
			delay(espera);
			digitalWrite(1, LOW);
			delay(espera);
			digitalWrite(0, HIGH);
			delay(espera);
			digitalWrite(0, LOW);
			delay(espera);
			}

Ese es el auto fantástico básico.

Ahora un ejercicio:  Llegar al mismo resultado  utilizando menos lineas de código. Utilizando el ciclo for, y array.

Solución

#include <wiringPi.h>
#include <stdio.h>
int pinArray[] = {0, 1, 2, 3, 4};
  int count = 0; // Contador 
int espera = 100; 
int main (void) { 
wiringPisetup(); 
for (count=0;count<5;count++){ // Configuramos todos los PINs pinMode
(pinArray[count], OUTPUT); 
for (count=0;count<5;count++) { // utilizando la secuencia de control for(;;) 
digitalWrite(pinArray[count], HIGH); // Recorrido de ida 
delay(espera); 
digitalWrite(pinArray[count], LOW); 
delay(espera);
 } 
for (count=4;count>=0;count--) {
 digitalWrite(pinArray[count], HIGH); // Recorrido de vuelta
 delay(espera);
 digitalWrite(pinArray[count], LOW); 
delay(espera); 
}

Y listo, ya hemos trabajado un poco con pines de entrada y salida digitales, hablaremos de interrupcciones.  son una funcionalidad que nos da mucha versatilidad en nuestros sistemas.

En si, una interrupción es una señal que  bloquea o suspende temporalmente el proceso normal de nuestro dispositivo con lo que nuestro sistema tiene que atender esa interrupción, o ese evento “especial”. Hay tres eventos que pueden disparar una interrupción:

  • Una interrupción externa
  • Una incorrupción por Timer
  • Una llamada por software.

En esta primera parte, veremos lo que es la interrupción externa:

Esta interrupción es dada por un pin predefinido y único que está encargado de escuchar solamente o a la espera de esa señal, y cuando llega a ser detectada por el sistema para hacer su función pre-pogramada, casi siempre son funciones de emergencia o banderas de aviso  para algún proceso y no tener el procesador ocupado esperando el proceso.

Ahora lo básico para utilizar una interrupción en Raspberry, es saber que con nuestra biblioteca WirinPi, ya tenemos una función predeterminada la cual es “int wiringPiISR(int pin, int edgeType,  void (*function)(void))”  donde “int pin” será el pin que queramos utilizar como interrupción, “int edgeType” será que flanco queremos detectar.

Si recordamos una señal digital, es una onda cuadrada, por eso podemos detectar cuando su estado cambia de 1 (3.3 v) a 0 (0 v) “INT_EDGE_FALLING”,  o si  cambia de 0 (0 v) a 1 (3.3 v)  “UBT_ EDGE_RISING” o si cambia  en ambos flancos  “INT_EDGE_BOTH”  y por ultimo tenemos “void (*function)(void)” la cual es la función de la interrupción.

Ahora  a tener en cuenta, en una interrupción no se puede  utilizar otra interrupción, lo mas recomendable es hacer lo mínimo posible dentro de la interrupción, pues puedes estar interrumpiendo algún proceso básico de tu sistema y recordar que  las interrupciones se guarda en otra parte de la memoria, por lo que si se quiere accesar del main normal a alguna bandera  dada por la interrupción, la variable tendrá que ser de tipo “volatile”

Ahora seguiremos con un pequeño ejemplo:

gpio 6

Conectaremos nuestro Raspberry de forma parecida a la imagen anterior. Donde si nos damos cuenta el push botton y el led estan a pines diferentes ya una ves hecho esto,   tendremos nuestro código de ejemplo: 

Código

include <wiringPi.h>
include <stdio.h>
#define BUTTON_PIN 0
 #define LED_PIN 7 // the event counter 
volatile int estado = HIGH; 
// ------------------------------------------------------------------------- 
void myInterrupt(void) { 
estado= !estado;
 digitalwrite(7, estado); 
}
 // ------------------------------------------------------------------------- 
int main(void) { 
 wiringPiSetup (); 
pinMode (LED_PIN, OUTPUT);
 wiringPiISR (BUTTON_PIN, INT_EDGE_FALLING, &myInterrupt);
}

Ya hecho el código anterior, haremos otro ejercicio, esta vez  utilizaremos el código ya hecho del auto fantástico y le añadiremos otra función, que quiere decir, que cuando oprimas tu pin de interrupción, encenderá todos los leds a la vez, antes de mirar el código recomiendo intentar hacerlo:

Solución

#include
 #include 
int pinArray[] = {0, 1, 2, 3, 4}; // Define el array de pines 
int count = 0; // Contador int espera = 100; 
volatile estado= HIGH;
 // ------------------------------------------------------------------------- 
void myInterrupt(void) { 
digitalwrite(0, estado);
 digitalwrite(1, estado); 
digitalwrite(2, estado);
 digitalwrite(3, estado); 
digitalwrite(4, estado);
 } 
int main (void) {
 wiringPisetup();
 wiringPiISR (BUTTON_PIN, INT_EDGE_FALLING, &myInterrupt); 
for (count=0;count<5;count++){ // Configuramos todos los PINs 
pinMode(pinArray[count], OUTPUT); 
for (count=0;count<5;count++) { // utilizando la secuencia de control for(;;) 
digitalWrite(pinArray[count], HIGH); // Recorrido de ida 
delay(espera);
 digitalWrite(pinArray[count], LOW);
 delay(espera); 
} 
for (count=4;count>=0;count--)
 {
 digitalWrite(pinArray[count], HIGH);// Recorrido de vuelta
 delay(espera); 
digitalWrite(pinArray[count], LOW);
 delay(espera);
 }

Y  listo ya hemos podido comprobar  y probar las interrupciones externas, para un próximo post trabajaremos interrupciones interna y protocolos de comunicación en C.

Saludos y grandiosos días a todos 🙂

 

Leave a Reply

Your email address will not be published. Required fields are marked *