¡Bienvenidos!

¡Hola una vez más!. ¡Pasad!, ¡pasad!, ¡ponéos cómodos!. ¡Al fondo queda sitio!.

¡Muchas gracias por volver a visitarnos, de verdad!. Espero de corazón estar haciendo algo que os resulte util. Durante este artículo, trataré de llevaros por uno de los conceptos más importante a la hora de trabajar con cualquier dispositivo electrónico: distinguir entre entradas y salidas.

En el artículo anterior, trabajábamos con una única salida: el LED que conectábamos a la patilla 13 de Arduino (aprovechando que la mayoría de las placas llevan un built-in, o led integrado en la misma Arduino, asociado a dicho pin).  El objetivo de esas primeras prácticas no era tanto empezar a programar la Arduino como que os familiarizárais con su IDE y aprendiérais a conectar la placa al ordenador, asi como realizar la compilación y el volcado del código a su memoria.

Lo que vamos a hacer hoy no es mucho más complicado. Partimos del siguiente axioma:

• Un pin funciona como salida cuando puede encender/activar elementos electrónicos (mover un motor, encender un LED...)
• Un pin funciona como entrada cuando puede leer la información de un dispositivo (pulsador abierto/cerrado, presencia/ausencia de tension, etc...)

Así que vamos a conectar algunos diodos LED como salidas, mientras que utilizaremos varios elementos como entrada: potenciómetros, un pulsador y una resistencia LDR. Recordad siempre que todas las conexiones tienen que acabar en la patilla GND (tierra), que simboliza el polo negativo de la "pila virtual" que estamos utilizando para proporcionar energía eléctrica al circuito. Al fin y al cabo, la corriente eléctrica sólo puede fluir si le proporcionamos un camino cerrado mediante elementos conductores desde el polo positivo al polo negativo de la fuente de alimentación (lo cual, desde el punto de vista de la Física, también es falso, pero mira... de eso ya nos encargaremos en otra ocasión).

¡La impaciencia me corroe!. ¡Vamos allá!

Ok. Aquí tenéis el esquema de montaje que os propongo:

¡Tranquilos! No vamos a empezar con todo a la vez. Si sabéis conectar elementos en una protoboard (asumo que sí), veréis que el esquema no es tan complejo como puede parecer a primera vista:

1. Hemos conectado tres diodos LED(a través de la correspondiente resistencia de 100-220 Ω en serie para que no se quemen) a los pines 5, 6 y 7. Esto son tres salidas.
2. Hemos conectado un pulsador según la siguiente secuencia: de 5 V a pulsador, de pulsador a resistencia (1 kΩ o más), de resistencia a tierra, y en el punto en que se tocaban el pulsador y la resistencia, lo hemos conectado al pin 8. Esto constituirá una entrada digital.
3. Hemos conectado las patillas del potenciómetro de la derecha a 5 V, A0 y tierra (GND). Esto será una entrada analógica.
4. Por último, hemos conectado un segundo potenciómetro de modo que uno de sus extremos toca a 5 V, el pin central (el variable) va conectado a una resistencia LDR y, finalmente, el otro extremo de la LDR va a tierra. El tercer pin del potenciómetro no necesita ser conectado. Este último montaje nos permitirá utilizar una resistencia dependiente de la luz LDR como un sensor analógico de luz ambiental, en un intento de dar un uso real a lo que expliquemos en esta serie de artículos.

¡Bufff! ¡Cuánto cable! Pero ya está conectado. ¡Empieza a explicar!

No os preocupéis. Os he propuesto este montaje para que vayáis haciendo "dedos" pelando cable y aprendiendo a hacer conexiones, normalmente a base de equivocarnos. Lo que vamos a ir haciendo es utilizar sólo una parte del circuito cada vez, e ir combinando partes después para enriquecer nuestro resultado. De hecho, en diferentes partes de este conjunto de prácticas redibujaremos el circuito para que aparezca sólo la parte que nos interesa, con el fin de simplificar y mejorar la comprensión del funcionamiento de dicha parte.

Aprendiendo a trabajar con salidas

Ésta es la parte del circuito que vamos a utilizar ahora: tres diodos LED conectados (resistencia serie mediante) a las patillas 5, 6 y 7 de Arduino:

En primer lugar, vamos a familiarizarnos con el concepto de salida. Volcad este código en vuestra Arduino, tal y como aprendísteis en el anterior artículo:

int led1=5;
void setup(){
pinMode(led1,OUTPUT);
}
void loop(){
digitalWrite(led1,HIGH);
delay(1000);
digitalWrite(led1,LOW);
delay(1000);
}

Si haces la prueba, verás que en esta ocasión, el diodo conectado al pin 5 titilará como pasaba con el integrado en la placa (asociado al pin 13) en el artículo anterior. Este código tiene tres partes:

a) Declaración de variables: el código int led1=5; indica que hay una variable llamada led1, que queremos que valga 5 (el pin al que va conectado el led). La palabra int significa que la variable es de tipo integer, es decir, de tipo entero (no hay decimales).

b) Función setup: El término en inglés significa algo así como configuración. Todo lo que escribamos entre las dos llaves que lleva esa función se cumplirá en el orden en que las escribamos, y al cumplir el último comando pasará a ejecutar la función loop. En este caso, sólo hay una instrucción, pinMode(led1,OUTPUT); dicha instrucción indica que queremos poner el pin led1 (o sea, el 5) en modo OUTPUT, es decir, queremos que actúe como una salida.

c) Función loop: en inglés, este vocablo significa rizo o bucle. Pues eso. Cumplirá las órdenes que encuentre en el orden en el que estén escritas. Al llegar a la última orden, volverá al principio de la función y volverá a empezar. La rapidez del micro hará que normalmente este conjunto de ordenes se repita varias veces por segundo.

Las órdenes que se incluyen en este programa son:

• pinMode(numeroPin,INPUT/OUTPUT); pondrá al pin numeroPin en modo INPUT(entrada) o OUTPUT(salida).
• digitalWrite(numeroPIN, HIGH/LOW); escribe HIGH (encendido, o sea, 5 voltios) o LOW (apagado, 0 voltios) en el numeroPin especificado. Lo que haya conectado al pin (un LED, en nuestro caso) lucirá cuando escribamos HIGH, y se apagará en el caso de LOW.
• delay(x); espera durante x milisegundos. Es decir delay(1000); espera durante 1 segundo.

IMPORTANTE: EN CUALQUIER PROGRAMA EN PROCESSING, TODOS LOS COMANDOS FINALIZAN CON UN PUNTO Y COMA. SI SE TE OLVIDA ALGUNO, EL COMPILADOR TE SEÑALARÁ EL ERROR.

También hay que señalar que tanto setup como loop se escriben  normalmente con la palabra void delante y acaban con ambos paréntesis (), por razones que no vienen aún al caso. Como funciones que son, encierran entre llaves los conjuntos de comandos que incluyan. La falta de llaves también parara el compilador, indicándonos el tipo de error.

¡Bueno!. Seguro que ya comprendes el principio de las cuatro instrucciones que van en loop : encender el led conectado al pin 5 escribiendo un HIGH, esperar un segundo, apagarlo escribiendo un LOW, esperar otro segundo, y volver a empezar.

¿Cómo podríamos hacer ahora que se encendieran y apagaran los tres diodos al unísono?. La solución más sencilla sería conectarlos en paralelo al pin 5, pero como queremos hacer otras cosas más complicadas después, las asociaremos a los pines 6 y 7. ¿Cómo sería el código? Seguro que sabes hacerlo. De todos modos, te lo dejo aquí:

//Notad que las barras  de la tecla 7 me permiten escribir comentarios
//Declaro tres variables led1, led2, led3
int led1=5;
int led2=6;
int led3=7;
//en setup ponemos como OUTPUT los tres pines
void setup(){
pinMode(led1,OUTPUT);
pinMode(led1,OUTPUT);
pinMode(led1,OUTPUT);
}

void loop(){
//encendemos los tres pines
digitalWrite(led1,HIGH);
digitalWrite(led2,HIGH);
digitalWrite(led3,HIGH);
delay(1000);
//apagamos los tres pines
digitalWrite(led1,LOW);
digitalWrite(led2,LOW);
digitalWrite(led3,LOW);
delay(1000);
}

 ¡Lo pillo!. ¿Y si quisiera hacer, digamos, un semáforo?

Pues sólo tienes que experimentar tú solo con el código. Procura conseguir diodos de los tres colores (rojo, ámbar, verde), y piensa qué tiempos quieres asignar a cada parte de la secuencia. Pongamos, por ejemplo, que el rojo está en el pin 7, el ámbar en el 6 y el verde en el 5. Digamos, por otro lado, que queremos que tanto rojo como verde debería tener el mismo tiempo asignado, digamos 5 segundos, mientras que el ámbar necesita ajustarse a un plazo más corto, por ejemplo 1,5 segundos. El código sería algo así:

int verde=5;
int ambar=6;
int rojo=7;
//en setup ponemos como OUTPUT los tres pines
void setup(){
pinMode(rojo,OUTPUT);
pinMode(ambar,OUTPUT);
pinMode(verde,OUTPUT);
}

void loop(){
//empezamos en ROJO
digitalWrite(rojo,HIGH);
digitalWrite(ambar,LOW);
digitalWrite(verde,LOW);
delay(5000);
//toca VERDE
digitalWrite(rojo,LOW);
digitalWrite(ambar,LOW);
digitalWrite(verde,HIGH);
delay(5000);
//ahora AMBAR con menos tiempo

digitalWrite(rojo,LOW);
digitalWrite(ambar,HIGH);
digitalWrite(verde,LOW);
delay(1500);

}