Cuestiones previas Vcc es la alimentación (es el positivo). GND es la masa (también se denomina tierra o negativo). OJO: Muy importante, nunca juntar el positivo con el negativo se generaría un cortocircuito. Un PIN es una patita de un chip, o una entrada / salida del Arduino. Una salida digital puede tener dos estados: 0 / 1; Encendido /Apagado; Verdadero / Falso. Un led es un diodo que emite luz cuando circula por él una corriente eléctrica. Un led tiene dos patitas llamadas Ánodo (+) y Cátodo (-)

El led necesita una resistencia en serie que limite la corriente que circula.

Una resistencia es un componente eléctrico que presenta una oposición al paso de la corriente eléctrica.

Para saber el valor de las resistencias se utilizan los códigos de colores

El brillo que emite un LED es directamente proporcional a la corriente que lo atraviesa, por lo que podemos controlar su luminosidad simplemente ajustando la cantidad de corriente, pero siempre sin exceder la cantidad máxima de corriente que puede admitir (Imáx). Para asegurarnos de no exceder dicho valor de corriente máxima, se coloca en serie con el LED una resistencia fija de protección, cuyo valor de Ohms puede calcularse fácilmente tal y como muestra el siguiente ejemplo:

siendo VT el voltaje total que suministramos al conjunto LED-Resistencia, VL el voltaje nominal de funcionamiento del LED y VR el voltaje que asume la resistencia, deducimos que: VR = VT - VL Como lo que nos interesa es el valor en Ohms de la resistencia R que provocará la caída de tensión VR, aplicando a Lei de Ohm obtemos que: VR = Imáx • R Combinando las dos expresiones deducimos que: VT - VL = Imáx • R es dicir: R =(VT - VL) / Imáx Deducimos finalmente que para el cálculo de la resistencia de protección, además del voltaje que suministremos, serán determinantes el valor del voltaje nominal del LED y la corriente máxima que puede asumir. Estos valores variarán, como veremos, en función do tipo de LED que consideremos

Tabla resumen de características básicas para los LEDs de formato mas común:

TIPO DE LED VOLTAJE NOMINAL DE

TRABAJO CORRIENTE MÁXIMA

rojo 1,8V - 2,2V

10mA - 20mA verde 2,0V - 2,1V

amarillo 2,1V - 2,2V

azul 3,2V - 3,8V 20mA - 25mA

blanco 3,6V

Las placas de prototipos o protoboards Las placas de prototipos o protoboards (en inglés, breadboard) son uno de los elementos fundamentales en la creación de circuítos electrónicos. Existen varios modelos pero es habitual que dispongan de:

Dos pares de líneas horizontales de puntos de conexión, situadas en los extremos de la placa, que es donde se conectan los polos de la fuente de alimentación.

Una parte central donde se encuentran dos zonas simétricas donde conectar los componentes del circuito. Cada zona está compuesta de multitud de líneas verticales de 5 puntos cada una.

Para un correcto uso de la protoboard tenemos que tener en cuenta como están conectadas entre ellos los puntos de conexión.

Como ejemplos básicos de uso de las placas protoboard vamos a simular las conexiones de unos circuitos como los siguientes formados por un interruptor simple, un motor de CC y una lámpara, alimentados por una pila de 9V. Observar que en el circuito de la izquierda motor e lámpara están en paralelo y en el de la derecha están en serie:

VARIABLE

Una variable es un espacio de memoria donde se guarda un dato. Es como si fuera una caja donde vamos a guardar cosas. Dependiendo de lo que queramos guardar en la caja (una canica, una impresora, un coche) necesitamos una caja más o menos grande, pues con los datos pasa lo mismo. Dependiendo de lo que queramos guardar en ese espacio de memoria tendremos que utilizar un tipo de datos u otro.

Los nombres de variables pueden tener letras, números y el símbolo’_’. Pueden llevar mayúsculas y minúsculas. Es conveniente usar las mismas reglas dentro del código para el nombramiento de variables, ya sea en minúscula con palabras separadas con guiones bajos, tantos como sea necesario para mejorar la legibilidad o utilizar la convención “CapWords” (palabras que comienzan con mayúsculas), aunque generalmente la primera palabra se pone en minúsculas. Declaración de variables. Una variable tiene un nombre, un valor y un tipo. Todas las variables deben ser declaradas antes de su uso. Al declarar una variable se debe indicar primero el tipo de variable y luego su nombre, opcionalmente se le puede dar un valor, lo que se llama inicializar la variable. La declaración consta de un tipo de variable y una lista de variables separadas por coma. int i,j; float x,pi; unsigned long longitud, contador; Las variables pueden inicializarse en la declaración

float pi=3.1416;

unsigned long contador=0;

Puedes encontrar mas información y explicación en: http://arduino.cc/en/Tutorial/Variables y http://arduino.cc/en/Reference/VariableDeclaration

Algunos tipos de variables:

char byte int unsigned int long unsigned long float double

1. Parpadeo de un led (salidas digitales)

Veamos nuestro primer sketch (nombre que usa el IDE de Arduino para los programas)

/* Parpadeo de un LED . */ int led = 13; // asigna a la variable led el valor 13 // la rutina de setup se ejecuta solo una vez al ppio del programa void setup() { pinMode(led, OUTPUT); // configura el pin 13 como pin de salida } // la rutina loop se ejecuta constantemente void loop() { digitalWrite(led, HIGH); // enciende el LED (HIGH es el nivel de voltaje) delay(1000); // espera un segundo digitalWrite(led, LOW); // apaga el LED poniendo el voltaje a LOW delay(1000); // espera por un segundo } Contestar a las siguientes preguntas:

¿Qué diferencia hay entre la función “setup” y la función “loop”? ¿Qué hace la instrucción? pinMode(8,OUTPUT) ¿Cuál es la instrucción que enciende el led? ¿Y cuál la apaga? ¿Qué hace la instrucción? delay(500) ¿En qué terminan todas las instrucciones?

Modificaciones: 1. El encendido y apagado sea el doble de rápido. 2. El led esté 2 segundos encendido y 1 apagado. 3. Conectar el led al pin 10

2. Semáforo

/* SEMÁFORO */ //** Variables **// int rojo=2; //definimos el valor del pin para el led rojo int amarillo=4; //definimos el valor del pin para el led amarillo int verde=7; //definimos el valor del pin para el led verde //** Configuración de salidas **// void setup() { pinMode(verde,OUTPUT); //declaramos el pin verde como salida pinMode(amarillo,OUTPUT); //declaramos el pin amarillo como salida pinMode(rojo,OUTPUT); //declaramos el pin rojo como salida } void loop() { digitalWrite(rojo,HIGH); //encendemos el led rojo delay(2000); //esperamos 2 segundos digitalWrite(rojo,LOW); //apagamos el led rojo digitalWrite(amarillo,HIGH); //encendemos el led amarillo delay(2000); //esperamos 2 segundos digitalWrite(amarillo,LOW); //apagamos el led amarillo digitalWrite(verde,HIGH); //encendemos el led verde delay(2000); //esperamos 2 segundos digitalWrite(verde,LOW); //apagamos el led verde }

3. ENTRADAS DIGITALES Va a montar un panel de control con un pulsador y luces que se encienden cuando presiona el pulsador. Un diodo LED verde permanecerá encendido hasta que pulse el botón. Cuando Arduino reciba la señal del botón pulsado, la luz verde se apaga y se encienden otras dos luces que comienzan a parpadear. Los pins digitales de Arduino pueden trabajar como entradas o como salidas. En cada sketch, los configuramos dependiendo de cual sea su función dentro del circuito. Cuando los pins se configuran como salidas, entonces podrá encender componentes como los diodos LEDs. Si se configuran como entradas, podrá verificar si un pulsador está siendo presionado o no. Ya que los pins 0 y 1 son usados para comunicación con el ordenador, es mejor comenzar con el pin 2. Colocar el pulsador sobre la placa de pruebas. Conectar un extremo a la alimentación y el otro terminal del pulsador al 2 de Arduino. También necesita añadir una resistencia de 10K ohmios desde masa al pin del pulsador que va conectado a Arduino. Esta resistencia de puesta a cero conecta el pin a masa cuando el pulsador está abierto, así que Arduino lee LOW cuando no hay tensión en ese pin del pulsador.

/* CONTROL DE LUCES CON PULSADOR */ //** Variables **// int rojo=5; //definimos el valor del pin para el led rojo int amarillo=4; //definimos el valor del pin para el led amarillo int verde=3; //definimos el valor del pin para el led verde int pulsador=2; //definimos el valor del pin para el pulsador int estadopulsador=0; //asignamos “no pulsado” como estado inicial //** Configuración de salidas y entrada **// void setup() { pinMode(verde,OUTPUT); //declaramos el pin verde como salida pinMode(amarillo,OUTPUT); //declaramos el pin amarillo como salida pinMode(rojo,OUTPUT); //declaramos el pin rojo como salida pinMode(pulsador,INPUT); // declaramos el pin del pulsador como entrada } void loop() { estadopulsador=digitalRead(pulsador); // el programa lee el estado del pulsador if (estadopulsador==LOW) // Si no está pulsado solo enciende el verde { digitalWrite(rojo,LOW); //apagamos el led rojo digitalWrite(amarillo,LOW); //apagamos el led amarillo digitalWrite(verde,HIGH); //encendemos el led verde } else //si está pulsado apaga el verde y activa intermitencia {

digitalWrite(rojo,HIGH); digitalWrite(amarillo,LOW); digitalWrite(verde,LOW);

delay (250); digitalWrite(rojo,LOW);

digitalWrite(amarillo,HIGH); delay(250);

} }

¿Cómo podría conseguir que los diodos LEDs comiencen a parpadear cuando el programa comienza?

¿Qué cambios tenemos que realizar en el código si intercambiamos las posiciones del pulsador y la resistencia de 10K?

4. LED RGB En su interior combinan tres LEDs correspondientes a los tres colores primarios de la luz: rojo (Red), verde (Green) y azul (Blue). A partir de la intensidad de la corriente aplicada a cada LED de color primaria se crea una mezcla aditiva de colores que pueden proporcionarnos un abanico muy amplio de colores, incluso el blanco. Poséen cuatro patas de conexión: una correspondiente a cada LED de color y una cuarta (la mas larga) que puede corresponder, según el tipo de LED RGB que usemos, al cátodo o al ánodo común que comparten.

Vamos a montar un pequeño circuito que nos permita gobernar el color que emite uno de éstos LEDs de RGB.

El montaje supone sencillamente conectar el negativo (el pin más largo) a Ground, y luego identificar los pines de colores conectados a tres salidas de Arduino: -El pin más largo en estos LED es el GND. -Al lado de GND hay dos pines a un lado y uno solitario al otro. Por lo normal el solitario es el rojo R. -Así pues el pin out (patillaje) de un RGB LED suele ser R, GND, G, B. Otra forma para identificarlos es conectar el GND a nuestro Arduino e ir probando cada una de las patas independientemente para ver qué color producen. Ejercicio: Realizar un sketch que muestre en intervalos de 1 segundo los colores siguientes rojo, verde, azul cuando pulsamos un pulsador. ¿Qué cambios de conexión tenemos que hacer si el LED RGB es de ánodo común?

5. SALIDAS ANALÓGICAS Hasta ahora hemos visto como activar las salidas digitales de Arduino, para encender y apagar un LED por ejemplo. Pero no hemos visto como modificar la intensidad del brillo de ese LED. Para ello, tenemos que modificar la tensión de salida de nuestro Arduino, o en otras palabras tenemos que poder presentar un valor analógico de salida. Para empezar tenemos que dejar claro que nuestro Arduino carece de salidas analógicas puras que puedan hacer esto. Pero como los chicos de Arduino son listos, decidieron emplear un truco, para que con una salida digital podamos conseguir que casi parezca una salida analógica. A este truco se le llama PWM, siglas de Pulse Width Modulation, o modulación de ancho de pulsos. La idea básica es poner salidas digitales que varían de forma muy rápida de modo que el valor eficaz de la señal de salida sea equivalente a una señal analógica de menor voltaje.

Fijaros en la anchura del pulso cuadrado de arriba. Cuanto mas ancho es, mas tensión promedio hay presente entre los pines, y esto en el mundo exterior es equivalente a un valor analógico de tensión comprendido entre 0 y 5V. Al 50% es equivalente a una señal analogica del 50% de 5V, es decir 2,5. Si mantenemos los 5V un 75% del tiempo, será el equivalente a una señal analógica de 75% de 5V = 3,75 V. analogWrite escribe en el pin de salida un valor entre 0 y 5V, dependiendo de V (que debe estar entre 0 y 255). De este modo si conectamos un LED a una de estas salidas PWM podemos modificar su brillo sin más que variar el valor que escribimos en el pin. Pero hay una restricción. No todos los pines digitales de Arduino aceptan poner valores PWM en la salida. Solamente aquellos que tienen un símbolo ~ delante del número. Fijaros en la numeración de los pines de la imagen:

Solamente los pines 3, 5, 6, 9, 10 y 11 pueden hacer PWM y simular un valor analógico en su salida.

PALETA DE COLORES CON LED RGB

Usando las salidas analógicas podemos controlar la intesidad de cada uno de los colores (rojo, verde y azul) por separado, añadiendo las cantidades de color que necesitemos de cada uno de ellos para conseguir el color que estemos buscando. ¡Vamos a hacerlo!

int ledRojo = 11; // Pin al que está conectado el color rojo int ledVerde = 10; // Pin al que está conectado el color verde int ledAzul = 9; // Pin al que está conectado el color azul void setup() { pinMode(ledRojo, OUTPUT); pinMode(ledVerde, OUTPUT); pinMode(ledAzul, OUTPUT); } void loop() { analogWrite(ledRojo, 255); // Color rojo ON delay(1000); analogWrite(ledRojo, 0); // Color rojo OFF analogWrite(ledVerde, 255); // Color verde ON delay(1000); analogWrite(ledVerde, 0); //Color verde OFF analogWrite(ledAzul, 255); // Color azul ON delay(1000); analogWrite(ledAzul, 0); // Color azul OFF delay(1000); analogWrite(ledRojo,13); analogWrite(ledVerde,227); analogWrite(ledAzul,201); delay(1000); analogWrite(ledRojo,0); analogWrite(ledVerde,0); analogWrite(ledAzul,0); } Ahora cambia los valores de intensidad de cada color (desde 0 hasta 255) a tu gusto. Puedes saber la combinación que necesitas mirando la paleta de Paint

6. Encendido y apagado progresivo de un led Se trata aumentar y disminuir la luminosidad de un led usando la capacidad de ofrecer una tensión variable que da una salida analógica. Para ello se conecta un led al pin 11 y se provoca que su luminosidad pase de mínima a máxima, para luego ir de máxima a mínima. Los valores de salidas analógicas van del mínimo 0 al máximo 255.

int led = 11; // pin del led

void setup() { // en el setup no hay que configurar nada } void loop() { for (int luz = 0 ; luz <= 255; luz=luz+3) // aumentamos luz (del mínimo a máximo) { analogWrite(led, luz); // ilumina el led con el valor de luz (de 0 a 255) delay(100); // espera 100 ms para que se vea el efecto } for (int luz = 255; luz >=0; luz=luz-3) // disminuimos luz (del máximo al mínimo) { analogWrite(led, luz); delay(100); } } El bucle for es una estructura que se utiliza cuando queremos que una serie de acciones se repita un número determinado de veces, para ello se necesita de una variable índice, una condición y un incrementador. Su sintaxis es la siguiente:

for (variable índice; condición; incrementador) { // comandos } Hay que tener en cuenta varios aspectos que hacen del bucle for una estructura peculiar: -necesita una variable índice que en el ejemplo hemos definido directamente como int luz = 0, esta variable índice es local y solo es accesible dentro del bucle for. -necesita de una condición y se ejecutara tantas veces como sea necesario mientras se cumpla la condición, en el ejemplo hemos hecho que el código se repita mientras que la variable “luz” sea menor o igual a 255. -necesita un incrementador de la variable “luz”. Cada vez que se evalúa la condición y se ejecuta el código se incrementa la variable, en nuestro caso el incrementador tiene la forma de luz = luz + 3 . -En el segundo ciclo for se produce el decremento de la variable que empieza en 255 y desciende hasta 0 mediante luz=luz-3 Haz cambios en la rapidez de incrementos y decrementos del ciclo for para comprobar lo que ocurre. Por ejempo, si ponemos luz=luz+50 veremos que se produce un salto brusco de nivel de luz en cada ciclo for

7. Secuencia de leds Se trata de encender y apagar 5 leds secuencialmente que están conectados a los pines 2, 3, 4, 5 y 6 con un tiempo de duración de encendido y apagado de 200 milisegundos.

Solución 1: int tiempo=200; //declara una variable tiempo de valor 200 void setup() { //comienza la configuracion pinMode(2,OUTPUT); pinMode(3,OUTPUT); pinMode(4,OUTPUT); pinMode(5,OUTPUT); pinMode(6,OUTPUT); } void loop() { //comienza el bucle principal del programa digitalWrite(2,HIGH); delay(tiempo); digitalWrite(2,LOW); delay(tiempo); digitalWrite(3,HIGH); delay(tiempo); digitalWrite(3,LOW); delay(tiempo); digitalWrite(4,HIGH); delay(tiempo); digitalWrite(4,LOW); delay(tiempo); digitalWrite(5,HIGH); delay(tiempo); digitalWrite(5,LOW); delay(tiempo); digitalWrite(6,HIGH); delay(tiempo); digitalWrite(6,LOW); delay(tiempo); }

Solución 2 (usando FOR): int tiempo=200; int n;

void setup() { //comienza la configuracion

for (n=2;n<7;n++) {pinMode (n, OUTPUT);}

}

void secuencia()

{

for (n=2;n<7;n++) {

digitalWrite (n, HIGH);

delay (tiempo);

digitalWrite (n, LOW);

delay (tiempo);

}

}

void loop() {

secuencia();

}

8. Coche fantástico Se trata de encender y apagar 6 leds secuencialmente. Los leds deben estar conectados a los pines 2, 3, 4, 5, 6 y 7. Se deben encender y apagar los leds desde el pin 2 al 7, con un tiempo de encendido y apagado de 50 ms, más tarde se deben encender y apagar los leds desde el pin 7 al 2, con un tiempo de encendido y apagado de 50 ms. La secuencia se debe repetir indefinidamente. El efecto del programa es el de las luces delanteras del "Coche fantástico".

Solución: int n=0; int tiempo=50; void setup() { //comienza la configuración for (n=2;n<8;n++) { pinMode(n,OUTPUT); } } void loop() { for (n=2;n<8;n++) { digitalWrite (n,HIGH); delay(tiempo); digitalWrite (n,LOW); delay(tiempo); } for (n=7;n>=2;n- -) { digitalWrite (n,HIGH); delay(tiempo); digitalWrite (n,LOW); delay(tiempo); } }

9. Simulación de la luz de una vela Se trata de simular el movimiento de la llama de una vela. Hacemos uso de la instrucción para generar un numero aleatorio que lo asignamos a una salida analógica PWM y otro número que lo asociamos a la variable de tiempo que esperamos para cambiar el valor de la salida.

/* Simula luz de vela*/ int ledPin = 9; // selecciona el puerto PWM int luz = 0; // define y pone a cero la variable "luz" int tiempoluz = 0; // define el tiempo que tarda en cambiar la luz void setup() { randomSeed(0); // inicializa el generador de números aleatorios pinMode(ledPin, OUTPUT); // declara el pin de SALIDA pin 9 } void loop() { luz = random(100,255); // nº aleatorio entre 100 y 255 que asigna a luz analogWrite(ledPin, luz); // envía ese valor a la salida pin 9 tiempoluz = random(50,150); // nº aleatorio entre 50 y 150 y lo asigna a tiempoluz delay(tiempoluz); // espera ese tiempo antes de cambiar la luz }

10. ENTRADAS ANALÓGICAS En muchas ocasiones los sensores que usamos para supervisar el mundo exterior, nos entregan una señal analógica. Es el caso de los sensores de luz, temperatura, distancia, de presión,de PH, de intensidad de corriente en un circuito o de caudal de agua en una tubería. Para leer este tipo de señales continuas necesitamos un convertidor analógico a digital (o ADC por sus siglas en ingles) y que nos permite leer el valor de una señal analógica en un momento dado. Estos convertidores toman una muestra del valor actual de la señal y nos entregan su valor instantáneo, medido en Voltios. Mediante la lectura repetida de muestras a lo largo del tiempo podemos reconstruir la señal original con mayor o menor precisión, dependiendo de la exactitud de nuestra medida y de la velocidad a la que pueda tomar esas muestras.

Arduino UNO dispone de seis convertidores analógico a digital, nominados de A0 hasta A5, rotuladas como ANALOG IN:

Veamos cómo usar las entradas analógicas con un circuito como este, en el que damos tensión a los extremos de un potenciómetro y conectamos el pin central (el variable) a la entrada de la puerta A5 de Arduino:

Potenciómetro – Una resistencia variable con tres terminales. Dos de estos terminales están

conectados a los extremos de una resistencia fija. El terminal central se puede mover a través de la superficie de la resistencia fija (dispone de un mando), consiguiendo de esta forma dos valores diferentes de resistencia según el terminal extremo que se tome como referencia. Cuando los terminales extremos del potenciómetro se conectan entre una tensión y masa, en el terminal central aparece una tensión que es proporcional al giro del mando central, entre cero (un extremo) y la máxima tensión (el otro extremo).

los convertidores ADC leen valores de tensión y no resistencia, por lo tanto, lo que vamos a leer es la caída de tensión en el potenciómetro a medida que giramos el ajuste. Los convertidores de Arduino UNO son de 10 bits de resolución por lo que nos devolverá valores entre 0 y 210 = 1.024 para tensiones de entrada entre 0 y 5V. El IDE de Arduino incorpora una herramienta llamada monitor serie el cual le proporciona información de lo que el microcontrolador está haciendo. Utilizando el monitor serie, se puede conseguir información acerca del estado de sensores, y así tener una idea de lo que sucede en un circuito y en el código cuando se esta ejecutando.

Veamos un ejemplo de lectura de una entrada analógica y visualizarla con el monitor del IDE de Arduino int valor; //definimos una variable para almacenar la medida void setup() {

// Las entradas analógicas no es necesario configurarlas Serial.begin(9600); //Inicializamos la comunicación entre Arduino y el PC a 9600 baudios } void loop() { valor=analogRead(5); //leemos el potenciómetro conectado a la entrada 5 Serial.print(“La medida es:”); //Enviamos frase al ordenador Serial.println(valor); //Serial.println envia valor y cambia de linea delay(100); //Espera un poco para dar tiempo al usuario a leer }

Al ejecutar el programa vemos en el monitor serial del IDE de Arduino el valor entre 0 y 1023 al girar el potenciómetro. Vamos a modificar el programa para que en pantalla nos aparezca el valor de la medida real en voltios. float valor_voltios; //definimos una variable para almacenar la medida que será decimal void setup() {

// Las entradas analógicas no es necesario configurarlas Serial.begin(9600); //Inicializamos la comunicación entre Arduino y el PC a 9600 baudios } void loop() { valor_voltios=(5.0/1024.0)*analogRead(5); //convertimos la lectura en voltios Serial.print(“La medida es:”); Serial.println(valor_voltios); delay(100); } Al poner 5.0 y 1024.0 estamos obligando al programa a tratar esos valores como decimales, así el resultado de la operación será decicmal.

Ejercicio:Controlar la frecuencia de parpadeo de un LED

Objetivo: El Led estará conectado al Pin 8 El Potenciómetro estará conectado al Pin A2 El Led parpadeé más rápido o más lento en función del valor del potenciómetro

Realizar el programa de acuerdo con el siguiente algoritmo: 1. Leer la entrada del potenciómetro y guardarla en una variable. 2. Encender y apagar el led según el intervalo tiempo que indique la variable del potenciómetro. Contestar a las siguientes preguntas:

¿Cuál es la instrucción que configura el pin como entrada analógica? ¿Cómo se declara en el código la variable? ¿De qué tipo (que es lo que se puede guardar) en la variable? ¿Dónde ha declarado el programa la variable?

Modificaciones: 1. Conseguir que el led parpadeé a intervalos entre 0 y 10’24 segundos