SALIDAS DIGITALES EN ARDUINO

OBJETIVOS

- Conocer que es una señal digital

PRODUCTOS

- Circuito según la gráfica de la practica

CONTENIDO

Recordaremos que una señal digital puede variar únicamente entre dos valores, que denominamos -Vcc y +Vcc.
Una salida digital es un dispositivo que permite variar su tensión a uno de estos dos valores mediante
programación, y por tanto nos permite realizar acciones con el entorno.

En Arduino, en general, los voltajes -Vcc y +Vcc corresponden con 0V (GND) y 5V. Sin embargo, algunos modelos
de Arduino operan a 3.3V, como por ejemplo algunos Mini, Nano, y las placas basadas en procesadores ARM como
Arduino Due.

Todos los pines digitales de Arduino pueden actuar como salidas digitales (por ello se denominan I/O, input y
output). Pero conviene destacar que los pines analógicos también pueden usarse como entradas y salidas
digitales.

El número exacto de salidas digitales depende del modelo de placa que estemos usando, en resumen, Arduino
Uno y Nano tienen 22 pines que podemos usar como salidas digitales, Arduino Mini tiene 20, y tenemos hasta 70
salidas digitales en el modelo Mega. Esto son cifras más que respetables, superiores a la mayoría de automatismos
de tipo industrial.

INTENSIDAD MÁXIMA DE UNA SALIDA DIGITAL

En general las salidas digitales de autómatas no están pensadas para proporcionar potencia, si no para interactuar
con electrónica u otros autómatas. La intensidad máxima que puede dar un pin es de 40 mA, si bien el valor
recomendado es de 20mA. Además hay restricciones adicionales en cuanto a la potencia, como que la suma total
de todas las salidas debe ser inferior a 300 mA, y a su vez no pueden superar 150 mA por puerto.

Esta potencia es suficiente para encender un led, un pequeño servomotor de 9g, o encender algún sensor, pero
no es suficiente para alimentar cargas mayores. Si queremos mover una carga superior, como un motor de
corriente continua, un servo, o incluso un relé, tendremos que emplear una etapa de amplificación, como un
transistor BJT.

No es conveniente forzar los límites de potencia de forma prolongada, la placa podría calentarse y dañarse. El
límite de 20 mA por salida significa que, para un voltaje de 5V, la resistencia del dispositivo que queramos
alimentar no debe ser inferior a 200 ohmios.

Como norma general, salvo que sepamos lo que estamos haciendo, siempre que vayamos a conectar un
dispositivo a cualquier salida lo haremos a través de una resistencia de al menos 300 ohmios.
CÓDIGO

Así el siguiente código enciende y apaga una salida digital, dicha salida digital tiene un led y una resistencia para
poder observar la transición entre encendido y apagado.

Las primeras líneas son las siguientes:

En ellas encontramos primero una línea que comienza con // y un texto que parece un comentario. En efecto
comenzar con // nos permite luego poner cualquier comentario de referencia que será ignorado por Arduino,
pero puede ser útil para recordar cuestiones relativas a ese especifico lugar donde el comentario fue agregado.
Esta manera de comentar en el código solo permite comentarios de 1 línea (si queremos más de una línea con
este estilo de comentario deberemos repetir el símbolo // en cada línea que agreguemos).
La segunda línea corresponde a la definición de una constante. Las constantes son útiles para referirnos a un dato
que no cambiará, y que repetiremos a lo largo de nuestro programa. En este caso el nombre de la constante es
LED_PIN y su valor 8. Si quisiéramos cambiar el led parpadeante y conectarlo a otro pin en nuestro Arduino, gracias
a la constante solo deberíamos cambiar esta línea por el número de pin correspondiente al led parpadeante.
En la función setup() {…} tenemos:

pinMode(LED_PIN, OUTPUT); // Iniciamos el pin del led como salida

digitalWrite(LED_PIN, LOW); // Apagar led (queremos comenzar con el led apagado)

He agregado comentarios para explicar un poco lo que hacemos línea por línea. En este caso cada vez que vamos
a usar un pin en un proyecto Arduino, deberemos avisarle si el mismo será usado como salida o entrada. En este
caso salida (OUTPUT en Inglés). El pin 8 que usamos es un pin de entrada y salida digital. Estos pines pueden tomar
2 valores que son HIGH y LOW (alto y bajo) que corresponden a los voltajes eléctricos 0v y 5v aprox. La segunda
línea le dice a Arduino que ponga el pin 8 en LOW que para nosotros significa apagado.
Luego en la función loop() {…} tenemos:

digitalWrite(LED_PIN, HIGH); // Prender led

delay(1000); // Esperar 1s (1000 milisegundos = 1 segundo)

digitalWrite(LED_PIN, LOW); // Apagar led

delay(1000); // Esperar 1s (1000 milisegundos = 1 segundo)

Siguiendo el mismo esquema y explicaciones, lo que haremos es prender el led, esperar, apagarlo y esperar. La
función delay() se usa para pedirle a Arduino que espere un tiempo. El tiempo a esperar se le pasa a la función a
modo de número que representa la cantidad de milisegundos (milésimas de segundo) a esperar. Un valor de 1000
equivale a 1 segundo.
MONTAJE
TRABAJANDO CON

SECUENCIA DE LED´s
Ahora vamos a activar secuencialmente 8 salidas digitales, cada una de ellas con un led indicador. Los puertos que
se usaran serán los puertos digitales del 2 al 10, la primera secuencia será ascendente del pin 2 al pin 9.
#define LED_1 2 // Colocamos el pin del led en una constante delay(100); // Esperar (100 milisegundos = 0.1 segundo)
#define LED_2 3 digitalWrite(LED_1, LOW); // Otros Led´s apagados
#define LED_3 4 digitalWrite(LED_2, HIGH); // Led 2 encendido
#define LED_4 5 delay(100); // Esperar (100 milisegundos = 0.1 segundo)
#define LED_5 6 digitalWrite(LED_2, LOW); // Otros Led´s apagados
#define LED_6 7 digitalWrite(LED_3, HIGH); // Led 3 encendido
#define LED_7 8 delay(100); // Esperar (100 milisegundos = 0.1 segundo)
#define LED_8 9 digitalWrite(LED_3, LOW); // Otros Led´s apagados
void setup() { digitalWrite(LED_4, HIGH); // Led 4 encendido
pinMode(LED_1, OUTPUT); // Iniciamos el pin del led como salida delay(100); // Esperar (100 milisegundos = 0.1 segundo)
pinMode(LED_2, OUTPUT); digitalWrite(LED_4, LOW); // Otros Led´s apagados
pinMode(LED_3, OUTPUT); digitalWrite(LED_5, HIGH); // Led 5 encendido
pinMode(LED_4, OUTPUT); delay(100); // Esperar (100 milisegundos = 0.1 segundo)
pinMode(LED_5, OUTPUT); digitalWrite(LED_5, LOW); // Otros Led´s apagados
pinMode(LED_6, OUTPUT); digitalWrite(LED_6, HIGH); // Led 6 encendido
pinMode(LED_7, OUTPUT); delay(100); // Esperar (100 milisegundos = 0.1 segundo)
pinMode(LED_8, OUTPUT); digitalWrite(LED_6, LOW); // Otros Led´s apagados
digitalWrite(LED_1, LOW); // Apagar led (comenzar con led apagado) digitalWrite(LED_7, HIGH); // Led 7 encendido
digitalWrite(LED_2, LOW); delay(100); // Esperar (100 milisegundos = 0.1 segundo)
digitalWrite(LED_3, LOW); digitalWrite(LED_7, LOW); // Otros Led´s apagados
digitalWrite(LED_4, LOW); digitalWrite(LED_8, HIGH); // Led 8 encendido
digitalWrite(LED_5, LOW); delay(100); // Esperar (100 milisegundos = 0.1 segundo)
digitalWrite(LED_6, LOW); }
digitalWrite(LED_7, LOW);
digitalWrite(LED_8, LOW);
}

void loop() {
digitalWrite(LED_8, LOW); // Otros Led´s apagados
digitalWrite(LED_1, HIGH); // Led 1 encendido