S4A con leds: http://www.prometec.net/semaforo/
LuisLlamas: https://www.luisllamas.es/encender-un-led-con-arduino/
LED
0.- TEORÍA.
1.- UN LED PARPADEANTE EN EL PIN13.
2.- UN LED EN EL PIN8.
3.- UN SEMÁFORO.
4.- EL COCHE FANTÁSTICO.
5.- EL REGISTRO PORT( ).
0.- TEORÍA.
LA ELECTRÓNICA DIGITAL
- Magnitudes ANALÓGICAS: Tienen un número infinito de valores, por ejemplo, todas las magnitudes físicas como: TEMPERATURA, VELOCIDAD, ELECTRICIDAD, ETC.
- Magnitudes DIGITALES: Consideraremos señales digitales binarias que son las que sólo toman dos valores discretos o estados: UNO/CERO. Representarán estados “activados” o “desactivados” Por ejemplo UN LED ENCENDIO/APAGADO, SI/NO, 5V/0V, ON/OFF, HIGH/LOW, 1/0, CERRADO/ABIERTO, CONECTADO/DESCONECTADO, VERDADERO/FALSO, POSITIVO/NEGATIVO, TENSIÓN/TIERRA.
Para poder trabajar con datos binarios, el matemático inglés George BOOLE (1815-1864) creó una estructura algebraica que consta únicamente de 2 elementos (bits).
Una álgebra que seguro conoces y utilizas a diario es la del SISTEMA DECIMAL (números arábigos), basado en la aritmética decimal que consta de 10 elementos (números), operaciones (suma, resta, ....) y propiedades (conmutativa...).
Toda álgebra consta de esos 3 apartados: elementos, operaciones y propiedades. El álgebra de boole comprende:
- Elementos: 0 y 1.
- Operaciones: multiplicación, suma, negación.
- Propiedades: conmutativa, asociativa, distributiva, elemento negado.
ELECTRÓNICA DIGITAL CON ARDUINO
En este apartado aprenderemos el funcionamiento básico de las
entradas y salidas digitales de la placa Arduino. Si observamos bien la
placa, vemos que ARDUINO TIENE HASTA 13 PINES DIGITALES.
En este caso
la señal digital no es más que un valor discreto de entre dos posibles,
que si en rigor se asocian a tensiones, nosotros por sencillez los
asociaremos a dos valores que serán , ENCENDIDO/APAGADO o lo que es lo mismo HIGH/LOW.
Así si asignamos un 0 al pin
digital 4, es lo mismo que decir que ese pin, o mejor dicho, lo que esté
conectado a ese pin estará apagado si le asignamos un 1, estamos
diciendo que estárá encendido.
Entonces, ¿Con los 13
pines digitales de Arduino , podríamos actuar para controlar 13 LEDES? .
(Aunque Arduino es aún más potente ya que aún podemos
usar los 5 pines analógicos también como salidas digitales).
LAS INSTRUCCIONES BÁSICAS DIGITALES EN ARDUINO:
- pinMode(pin,OUTPUT);
- digitalWrite(pin,HIGH);
En arduino los pines de entrada y salida son los mimos (del 1 al 13) por
lo que deberán ser declarados al principio dentro de la función SEUPU( ) como entradas o como salidas.
Pudiendo ser INPUT
(entrada) u OUTPUT (salida).
pinMode(pin, OUTPUT);
Los
terminales de Arduino, por defecto, están configurados como entradas,
por lo tanto no es necesario definirlos (aunque es coveniente hacerlo siempre) en el caso de que vayan a
trabajar como entradas. Los pines configurados como entrada quedan, bajo
el punto de vista eléctrico, como entradas en estado de alta
impedancia.
Estos pines tienen a nivel interno una
resistencia de 20 KΩ a las que se puede acceder mediante software. Estas
resistencias se accede de la siguiente manera:
pinMode(pin, INPUT); // configura el ‘pin’ como entrada
digitalWrite(pin, HIGH); // activa las resistencias internas
Las
resistencias internas normalmente se utilizan para conectar las
entradas a interruptores. En el ejemplo anterior no se trata de
convertir un pin en salida, es simplemente un método para activar las
resistencias interiores.
Los pins configurado como OUTPUT (salida)
se dice que están en un estado de baja impedancia y pueden
proporcionar 40 mA (miliamperios) de corriente a otros dispositivos y
circuitos. Esta corriente es suficiente para alimentar un diodo LED (no
olvidando poner una resistencia en serie), pero no es lo suficiente
grande como para alimentar cargas de mayor consumo como relés,
solenoides, o motores.
Un cortocircuito en las patillas Arduino
provocará una corriente elevada que puede dañar o destruir el chip
Atmega. A menudo es una buena idea conectar en la OUTPUT (salida) una
resistencia externa de 470 o de 1000 Ω.
Ahora analicemos la siguiente instrucción:
digitalWrite(pin, HIGH);
Esta envía
al ´pin´ definido previamente como OUTPUT el valor HIGH o LOW (poniendo
en 1 o 0 la salida). El pin se puede especificar ya sea como una
variable o como una constante (0-13).
digitalWrite(13, HIGH);
Ahora veamos la siguiente instrucción:
valor = digitalRead(Pin);
En esta ocasión, se lee
el valor de un pin (definido como digital) dando un resultado HIGH
(alto) o LOW (bajo). El pin se puede especificar ya sea como una
variable o una constante (0-13):
valor = digitalRead(13);
Seguro que has oído hablar de los diodos LED (Light-Emitting Diode) pues están muy de moda. Un diodo led no es más que un diodo que emite luz cuando está polarizado correctamente con una corriente no mayor de 20mA.
Un diodo (del griego "dos caminos") es un dispositivo semiconductor que permite el paso de la corriente eléctrica en una única dirección con características similares a un interruptor.
Recodemos que diferenciamos entre dispositivos eléctricos y electrónicos. Los dispositivos eléctricos engloban resistencias, condensadores y bobinas, e integran el campo de electricidad. Los dispositivos electrónicos, surgen del uso de materiales semiconductores, y dan lugar al campo de la electrónica.
Veamos si sabes como polarizar un diodo...
Un diodo se dice polarizado directamente cuando su cátodo está a un potencial inferior al ánodo. Los diodos por tanto deben especificar cual es el ánodo y el cátodo. En la foto puedes ver como un diodo led identifica su cátodo con una patilla recortada.
En otro tipo de diodos se puede identificar el cátodo gracias a una raya dibujada sobre el componente.
1.- LED BLINKING
Vamos a relizar la primera práctica típica de arduino, este ejemplo se llama "BLINK" en el IDE de Arduino. Éste primer programa es el típico "HOLA MUNDO" en el argot de programación computacional.
En este caso, montaremos el arduino con un LED en el pin13 para que parpadee a intervalos de 1 segundo.
A PARTIR DE AHORA TENDRÁS QUE RECORDAR QUE LA PATITA MÁS LARGA DEL LED SE DEBE SIEMPRE DE CONECTAR AL POSITIVO (5V) Y LA CORTA AL NEGATIVO (GND).
El pin13 tiene asociado un led en la placa justo debajo de el y así nos evitamos tener que montarlo.
Si pusiéramos un pin polarizado correctamente entre el pin13 y GND también funcionaría. El pin13 tiene también una resistencia interna que hace posible conectarle un led directamente, si hacemos el montaje con otro pin debemos añadir esta resistencia de unos 220Ohm entre el led y el pin.
Antes de probar tu programa, comprueba que el puerto de comunicaciones de tu ARDUINO_UNO está convenientemente seleccionado en el IDE de tu ordenador, por ejemplo: ARDUINO_UNO y COM4.
Asegurate de conectar el LED con el CATODO POSITIVO (+) en el PIN13 y el CÁTODO NEGATIVO (-) a tierra (GND), intercalando una resistencia de 220 ohmios primero.
void setup( ) {
2.- REALIZA UNA SECUENCIA DEL LED QUE INDIQUE UN SOS: ...---...
3.- LED13 parpadea en un intervalo de tiempo variable que depende del número de veces que se ejecuta el programa (función: loop)
LAS RESISTENCIAS COMO COMPONENTES ELÉCTRICOS.
Los componentes electrónicos llamados resistencias se utilizan en los circuitos para variar los valores de intensidad y voltaje. A veces tenemos que alimentar un dispositivo y sólo disponemos de una fuente de voltaje que puede dañarlo si se conecta directamente, como ocurre por ejemplo con los LEDES. Al conectarlos directamente a un pin digital de Arduino (+5V), la corriente que circula es demasiado alta para el led y una exposición prolongada puede provocar que se queme.
Para evitar esto conectamos en serie con el led una resistencia eléctrica (220 ohmios por ejemplo) que hace que el valor de la intensidad sea menor. El led lucirá algo menos que si lo conectamos directamente pero alargará su vida útil.
El valor de una resistencia se suele identificar mediante unas bandas de colores impresas en su superficie. La interpretación del código de colores la puedes obtener en http://es.wikipedia.org/wiki/Resistor aunque suele ser recomendable, a la hora de realizar prácticas con circuitos electrónicos, utilizar un polímetro que nos permitirá, entre otras cosas, medir la resistencia eléctrica en ohmios de estos componentes.
LOS LEDES
Los LEDES que vamos a usar con Arduino son los conocidos como LED de baja potencia encapsulados en 3mm y 5mm. (Los utilizados en las bombillas de iluminación son de mayor consumo y nuestro Arduino no tiene potencia para iluminarlos por si mismo, requeriría de drivers intermedios).
Hemos dicho que lo principal para hacer funcionar un LED es calcular el valor de la resistencia necesaria. Para calcular el valor de tensión necesaria para alimentar un LED necesitamos conectar 3 parámetros
Calcula el valor de la resistencia es sencillo. Como hemos dicho, la tensión que soporta el LED es la diferencia entre la tensión aplicada y la tensión de polarización directa del LED.
Aplicando la ley de Ohm, con el valor de la intensidad nominal del LED
Por lo que lo que el valor de la resistencia resulta
Dado que las resistencias comerciales tienen valores normalizados, no encontraréis una resistencia con el valor exacto que hayáis calculado. En este caso, elegiremos la resistencia normalizada inmediatamente superior al valor calculado, para garantizar que la corriente es inferior a la nominal.
La tensión de alimentación Vcc es conocida para nosotros. En caso de aplicar una fuente de alimentación o una batería, Vcc es la tensión nominal de la misma. En el caso de una salida digital o analógica de Arduino, Vcc dependerá del modelo que estemos usando (5V o 3.3V) pero también es conocido.
Respecto a la tensión de polarización y la corriente nominal dependen de los materiales y constitución interna del diodo. En el caso de diodos LED convencionales de 3mm y 5mm, dependen principalmente del color y luminosidad
No obstante, en la mayoría de las ocasiones el propio vendedor facilita estos valores en el anuncio. En caso de duda deberemos acudir al Datasheet del LED para consultar los valores nominales.
En la siguiente tabla os adjuntamos unos valores generales de la tensión de polarización Vd típica para cada color. También os figura el valor de la resistencia necesaria, en Ohmios, para distintos valores de tensión de alimentación Vcc.
PRÁCTICA
Ahora vamos a realizar la misma práctica que el led en el pin13 pero esta vez utilizando otros pines. El código podrías descargardo directamente del ejemplo llamado "Blink" de la librería que incluye el IDE de Arduino. En este caso el LED deberá estar conectado en el pin 8.
3.- EL SEMÁFORO
Recerda que los LEDES deben siempre ir conectados con una resistencia en serie para protegerlos de una corriente de más de 20mA.
CÓDIGO:
int PINROJO= 13;
int PINAMARILLO = 12;
int PINVERDE = 11;
void setup() {
pinMode(PINVERDE, OUTPUT);
pinMode(PINAMARILLO, OUTPUT);
pinMode(PINROJO, OUTPUT);
Serial.begin(9600); //inicializa la comunicación Serial
}
void loop(){
digitalWrite(PINVERDE, HIGH);
Serial.println("Semaforo - Verde"); //Escribe el texto
delay(5000); //espera 5 segundos
digitalWrite(PINVERDE, LOW);
digitalWrite(PINAMARILLO, HIGH);
Serial.println("Semaforo - Amarillo"); //Escribe texto
delay(2000);
digitalWrite(PINAMARILLO, LOW);
digitalWrite(PINROJO, HIGH);
Serial.println("Semaforo - Rojo"); //Escribe el texto
delay(5000);
digitalWrite(PINROJO, LOW);
}
Aparece un nuevo comando: Serial.print.
4.- EL COCHE FANTÁSTICO.
Haremos que varios ledes se enciendan secuencialmente como en el coche fantástico de kit.
Y por último para los más avanzados, un ejemplo del coche fantástico con bucles y arrays.
Abrimos en el IDE de arduino el código de: ejemplos/control/ARRAYS:
CÓDIGO para 5 ledes con un FOR.
void setup() {
pinMode (13,OUTPUT);
pinMode (12,OUTPUT);
pinMode (11,OUTPUT);
pinMode (10,OUTPUT);
pinMode (9,OUTPUT);
}
void loop(){
for (int i=9;i<15;i++){
digitalWrite(i,HIGH); //enciende el led_i
digitalWrite(i-1,LOW); //apaga el led anterior
}
}
CÓDIGO con bucles y arrays:
int timer = 100; // Variable para controlar el retardo del loop (100 milisegundos)
int ledPins[] = { 2, 7, 4, 6, 5, 3 }; // Array de los pines donde conectaremos los LEDs
int pinCount = 6; // Longitud de la Array
void setup() {
int thisPin; // Variable temporal
// La Array está numerada desde 0 hasta (pinCount – 1), es decir de 0 a 5
// Usamos un bucle FOR para inicializar cada pin como SALIDA
for (int thisPin = 0; thisPin < pinCount; thisPin++) {
pinMode(ledPins[thisPin], OUTPUT);
}
}
void loop() {
/* Bucle FOR para ir encendiendo de uno en uno los leds. Funciona así:
Para el PRIMER led...lo enciendo durante los milisegundos que he indicado con la variable timer...y lo apago...enciendo el SEGUNDO led, etc...
*/
for (int thisPin = 0; thisPin < pinCount; thisPin++) {
digitalWrite(ledPins[thisPin], HIGH);
delay(timer);
digitalWrite(ledPins[thisPin], LOW);
}
/* Bucle FOR para ir encendiendo de uno en uno los leds. Funciona así:
Para el ÚLTIMO led...lo enciendo durante los milisegundos que he indicado con la variable timer...y lo apago...enciendo el PENÚLTIMO led, etc...
*/
for (int thisPin = pinCount - 1; thisPin >= 0; thisPin--) {
// Encendemos el LED digitalWrite(ledPins[thisPin], HIGH); delay(timer);
// Apagamos el LED
digitalWrite(ledPins[thisPin], LOW);
}
}
5.- el registro port().
NOTAS:
El pin13 tiene asociado un led en la placa justo debajo de el y así nos evitamos tener que montarlo.
Si pusiéramos un pin polarizado correctamente entre el pin13 y GND también funcionaría. El pin13 tiene también una resistencia interna que hace posible conectarle un led directamente, si hacemos el montaje con otro pin debemos añadir esta resistencia de unos 220Ohm entre el led y el pin.
Asegurate de conectar el LED con el CATODO POSITIVO (+) en el PIN13 y el CÁTODO NEGATIVO (-) a tierra (GND), intercalando una resistencia de 220 ohmios primero.
EL CÓDIGO DE "BLINK":
pinMode(13, OUTPUT);
}
void loop() {
digitalWrite(13, HIGH);
delay(1000);
digitalWrite(13, LOW);
delay(1000);
}
A la hora de escribir este código recuerda unas NORMAS SINTÁCTICAS de programación en el IDE de arduino:
- Las funciones comienzan con una definición void cuando no reportan nada.
- Los parámetros de dichas funciones van entre paréntesis SEPUP( )
- Los bloques de instrucciones se colocan entre las llaves { }
- Cáda línea de código termina con un ;
ACTIVIDADES:
1.- VARÍA LA FRECUENCIA DE PARPADEO.
Para probar este código, conecta tu arduino (ARDUINO_UNO), asegúrate de que el puerto esté correctamente configurado (por ejemplo COM3), verifica el código (COMPILA) y luego cárgalo.
Verás como el LED integrado a la arduino comienza a parpadear cada un segundo.
Puedes cambiar la frecuencia de parpadeo cambiando el número en la función siguiente, por el número que desees.
delay(1000)
Cabe señalar que con un retardo menor a 5[ms] el ojo humano no alcanza a percibir el parpadeo y se ve como si estuviera siempre prendido. Esta característica es muy usada para ahorrar energía ya que es mejor tener el LED apagado la mitad del tiempo, que siempre encendido.
2.- REALIZA UNA SECUENCIA DEL LED QUE INDIQUE UN SOS: ...---...
3.- LED13 parpadea en un intervalo de tiempo variable que depende del número de veces que se ejecuta el programa (función: loop)
int ledPin=13;
int n=0;
void setup() {
pinMode(ledPin,OUTPUT);
}
void loop() {
digitalWrite(ledPin, HIGH);
delay(1000);
digitalWrite(ledPin,LOW);
n++;
delay(n*100);
}
LAS RESISTENCIAS COMO COMPONENTES ELÉCTRICOS.
Los componentes electrónicos llamados resistencias se utilizan en los circuitos para variar los valores de intensidad y voltaje. A veces tenemos que alimentar un dispositivo y sólo disponemos de una fuente de voltaje que puede dañarlo si se conecta directamente, como ocurre por ejemplo con los LEDES. Al conectarlos directamente a un pin digital de Arduino (+5V), la corriente que circula es demasiado alta para el led y una exposición prolongada puede provocar que se queme.
Para evitar esto conectamos en serie con el led una resistencia eléctrica (220 ohmios por ejemplo) que hace que el valor de la intensidad sea menor. El led lucirá algo menos que si lo conectamos directamente pero alargará su vida útil.
El valor de una resistencia se suele identificar mediante unas bandas de colores impresas en su superficie. La interpretación del código de colores la puedes obtener en http://es.wikipedia.org/wiki/Resistor aunque suele ser recomendable, a la hora de realizar prácticas con circuitos electrónicos, utilizar un polímetro que nos permitirá, entre otras cosas, medir la resistencia eléctrica en ohmios de estos componentes.
LOS LEDES
Los LEDES que vamos a usar con Arduino son los conocidos como LED de baja potencia encapsulados en 3mm y 5mm. (Los utilizados en las bombillas de iluminación son de mayor consumo y nuestro Arduino no tiene potencia para iluminarlos por si mismo, requeriría de drivers intermedios).
Hemos dicho que lo principal para hacer funcionar un LED es calcular el valor de la resistencia necesaria. Para calcular el valor de tensión necesaria para alimentar un LED necesitamos conectar 3 parámetros
- La tensión de alimentación (Vcc)
- La tensión de polarización directa del LED (Vd)
- La corriente nominal del LED (In)
Calcula el valor de la resistencia es sencillo. Como hemos dicho, la tensión que soporta el LED es la diferencia entre la tensión aplicada y la tensión de polarización directa del LED.
Aplicando la ley de Ohm, con el valor de la intensidad nominal del LED
V= Vcc-Vdd= I nominal * R
Por lo que lo que el valor de la resistencia resulta
R= I nominal / (Vcc-Vd)
Dado que las resistencias comerciales tienen valores normalizados, no encontraréis una resistencia con el valor exacto que hayáis calculado. En este caso, elegiremos la resistencia normalizada inmediatamente superior al valor calculado, para garantizar que la corriente es inferior a la nominal.
La tensión de alimentación Vcc es conocida para nosotros. En caso de aplicar una fuente de alimentación o una batería, Vcc es la tensión nominal de la misma. En el caso de una salida digital o analógica de Arduino, Vcc dependerá del modelo que estemos usando (5V o 3.3V) pero también es conocido.
Respecto a la tensión de polarización y la corriente nominal dependen de los materiales y constitución interna del diodo. En el caso de diodos LED convencionales de 3mm y 5mm, dependen principalmente del color y luminosidad
No obstante, en la mayoría de las ocasiones el propio vendedor facilita estos valores en el anuncio. En caso de duda deberemos acudir al Datasheet del LED para consultar los valores nominales.
En la siguiente tabla os adjuntamos unos valores generales de la tensión de polarización Vd típica para cada color. También os figura el valor de la resistencia necesaria, en Ohmios, para distintos valores de tensión de alimentación Vcc.
Color LED
|
Vdd
|
Resistencia (Ohmios)
|
|||
3.3V
|
5V
|
9V
|
12V
|
||
Infrarrojo
|
1.4V
|
150
|
270
|
510
|
680
|
Rojo
|
1.8V
|
100
|
220
|
470
|
680
|
Naranja
|
2.1V
|
100
|
200
|
470
|
680
|
Amarillo
|
2.2V
|
100
|
200
|
470
|
680
|
Verde
|
3.2V
|
10
|
150
|
330
|
560
|
Azul
|
3.5V
|
–
|
100
|
330
|
560
|
Violeta
|
3.6V
|
–
|
100
|
330
|
560
|
Blanco
|
3.8V
|
–
|
100
|
330
|
560
|
PRÁCTICA
Ahora vamos a realizar la misma práctica que el led en el pin13 pero esta vez utilizando otros pines. El código podrías descargardo directamente del ejemplo llamado "Blink" de la librería que incluye el IDE de Arduino. En este caso el LED deberá estar conectado en el pin 8.
CÓDIGO DEL LED EN EL PIN8:
void setup( ) {
pinMode(8, OUTPUT);
}
void loop( ) {
digitalWrite(8, HIGH);
delay(1000);
digitalWrite(8, LOW);
delay(1000);
}
void setup( ) {
pinMode(8, OUTPUT);
}
void loop( ) {
digitalWrite(8, HIGH);
delay(1000);
digitalWrite(8, LOW);
delay(1000);
}
También podría ponerse el siguiente código:
#define pinLED 8 //en este caso se declara como constante y no lleva ";"
void setup() {
pinMode(pinLED, OUTPUT);
}
void loop() {
digitalWrite(pinLED, HIGH);
delay(500);
digitalWrite(pinLED, LOW);
delay(500);
}
#define pinLED 8 //en este caso se declara como constante y no lleva ";"
void setup() {
pinMode(pinLED, OUTPUT);
}
void loop() {
digitalWrite(pinLED, HIGH);
delay(500);
digitalWrite(pinLED, LOW);
delay(500);
}
3.- EL SEMÁFORO
Montaremos
un semáforo con los tres leds sobre una protoboard. Necesitamos
añadir una resistencia a cada LED (entre el pin y el led), para evitar que el led se
funda.
CÓDIGO:
int PINROJO= 13;
int PINAMARILLO = 12;
int PINVERDE = 11;
void setup() {
pinMode(PINVERDE, OUTPUT);
pinMode(PINAMARILLO, OUTPUT);
pinMode(PINROJO, OUTPUT);
Serial.begin(9600); //inicializa la comunicación Serial
}
void loop(){
digitalWrite(PINVERDE, HIGH);
Serial.println("Semaforo - Verde"); //Escribe el texto
delay(5000); //espera 5 segundos
digitalWrite(PINVERDE, LOW);
digitalWrite(PINAMARILLO, HIGH);
Serial.println("Semaforo - Amarillo"); //Escribe texto
delay(2000);
digitalWrite(PINAMARILLO, LOW);
digitalWrite(PINROJO, HIGH);
Serial.println("Semaforo - Rojo"); //Escribe el texto
delay(5000);
digitalWrite(PINROJO, LOW);
}
Aparece un nuevo comando: Serial.print.
Este
comando nos manda un texto al puesto serial por el que nos comunicamos
con Arduino. De esta manera podemos depurar un programa sabiendo siempre
por que línea está.
Para que funcione debemos tener en cuenta que:
- Hay que inicializar Serial. Esto se hace poniendo Serial.begin(9600) dentro de la rutina de setup(). 9600 se refiere a la velocidad que se comunicará.
- Serial.print(“xxx”) escribe lo que ponemos entre comillas tal cual.
- Serial.print(x) escribe el valor que contenga la variable x.
- Serial.println() es similar a lo anterior pero después añade un salto de línea.
Para ver lo que nuestro Arduino nos comunica por Serial, abrimos el monitor Serial que tenemos en el programa Arduino
Puedes incluir en el código tres constantes en vez de las variables PINVERDE,etc. para definir los pines donde conectar cada LED. Estas líneas de código no llevan el punto y coma final de cada instrucción (;), ni tampoco se pueden añadir tíldes a los nombres. (Se puee escribir el símbolo # con el juego de tecasl ALT+3)
#define PINVERDE 4
#define PINAMARILLO 5
#define PINVERDE 4
#define PINAMARILLO 5
#define PINROJO 6
ACTIVIDADES:
1.-Ahora te toca a ti mejorar el programa poniendo los tiempos de encendido de cada LED con los tiempos que tu creas más oportunos.
Otras prácticas con el video tutorial de: http://elprofegarcia.com/
ACTIVIDADES:
1.-Ahora te toca a ti mejorar el programa poniendo los tiempos de encendido de cada LED con los tiempos que tu creas más oportunos.
Otras prácticas con el video tutorial de: http://elprofegarcia.com/
2.- Modifica el programa para que el semáforo muestre también la luz ámbar (amarillo) al pasar de rojo al verde.
4.- EL COCHE FANTÁSTICO.
Haremos que varios ledes se enciendan secuencialmente como en el coche fantástico de kit.
Y por último para los más avanzados, un ejemplo del coche fantástico con bucles y arrays.
Abrimos en el IDE de arduino el código de: ejemplos/control/ARRAYS:
CÓDIGO para 5 ledes con un FOR.
void setup() {
pinMode (13,OUTPUT);
pinMode (12,OUTPUT);
pinMode (11,OUTPUT);
pinMode (10,OUTPUT);
pinMode (9,OUTPUT);
}
void loop(){
for (int i=9;i<15;i++){
digitalWrite(i,HIGH); //enciende el led_i
digitalWrite(i-1,LOW); //apaga el led anterior
}
}
CÓDIGO con bucles y arrays:
int timer = 100; // Variable para controlar el retardo del loop (100 milisegundos)
int ledPins[] = { 2, 7, 4, 6, 5, 3 }; // Array de los pines donde conectaremos los LEDs
int pinCount = 6; // Longitud de la Array
void setup() {
int thisPin; // Variable temporal
// La Array está numerada desde 0 hasta (pinCount – 1), es decir de 0 a 5
// Usamos un bucle FOR para inicializar cada pin como SALIDA
for (int thisPin = 0; thisPin < pinCount; thisPin++) {
pinMode(ledPins[thisPin], OUTPUT);
}
}
void loop() {
/* Bucle FOR para ir encendiendo de uno en uno los leds. Funciona así:
Para el PRIMER led...lo enciendo durante los milisegundos que he indicado con la variable timer...y lo apago...enciendo el SEGUNDO led, etc...
*/
for (int thisPin = 0; thisPin < pinCount; thisPin++) {
digitalWrite(ledPins[thisPin], HIGH);
delay(timer);
digitalWrite(ledPins[thisPin], LOW);
}
/* Bucle FOR para ir encendiendo de uno en uno los leds. Funciona así:
Para el ÚLTIMO led...lo enciendo durante los milisegundos que he indicado con la variable timer...y lo apago...enciendo el PENÚLTIMO led, etc...
*/
for (int thisPin = pinCount - 1; thisPin >= 0; thisPin--) {
// Encendemos el LED digitalWrite(ledPins[thisPin], HIGH); delay(timer);
// Apagamos el LED
digitalWrite(ledPins[thisPin], LOW);
}
}
5.- el registro port().
Los pines usados en la placa ARDUINO UNO poseen tres TIPOS de PUERTOS:
- PORTB: pines digitales del 8 al 13.
- PORTC: entradas analógicas A0 al A7.
- PORTD: pines digitales del 0 al 7.
Cada puerto es controlado por TRES REGISTROS, los cuales también están definidos como variables en el lenguaje del Arduino.
- DDRX: configura los pines como ENTRADAS/SALIDAS sobre el puerto X (B,C o D). Esto se hace bajo la función SETUP(). Por ejemplo, para configurar los pines digitales del 7,6,5,4,3,2,1,0. utilizaríamos la siguiente instrucción donde dejamos los pines RX y TX sin activar para no tener problemas con esta vía de comunicación.
DDRD = B11111100;
- PORTX: escribe/lee el estado HIGH/LOW dentro de la función LOOP() en los pines del puerto B,C o D:
PORTD = B11111111; // pines 7....0 en HIGH
- PINX: lectura del estado de los pines del puerto B/C/D configurados previamente como tales con la función pinMode(pin,INPUT).
NOTAS:
- Los bits altos (6 & 7) están mapeados a los pines del cristal de cuarzo y no pueden ser usados. Estos son solamente accesibles en el Arduino Mini.
- Cada bit de estos registros corresponden con un solo pin; por ejemplo el bit menos significativo de los registros DDRB, PORTB, y PINB hace referencia al pin PB0 (pin digital 8)
- Los pines 0 y 1 son la transmisión serial (RX y TX respectivamente). Si utilizas “Serial.begin” en alguno de esos 2 puertos; no tendrás comunicación serial. Cuidado con eso.
- Trabajar con PORT() reporta ventajas de velocidad, memoria, etc. pero hay que tener cuidado en especial con la configuración de los pines RX y TX que podemos dejar bloqueados y luego depurar los errores resultaría más complicado.
- Para leer un puerto en una sóla instrucción se debe declarar una variable como: byte readPortD = PIND
Normalmente antes para declarar un pin lo hacíamos de la siguiente manera:
void setup(){
Serial.begin(9600);
pinMode(2,INPUT);
pinMode(3,OUTPUT);
}
Entonces si quisiéramos declarar 7 pines (desde el digital 0 al digital 7), tendríamos que repetir pinMode 7 veces. Al igual que escribir tendríamos que poner digitalWrite(pin,HIGH).
Al utilizar Registros PORT (Puerto) tenemos la ventaja de que con solo una instrucción podemos declarar el pin como entrada o salida y también podemos escribir, si lo queremos, como estado HIGH o LOW.
EJEMPLO CON EL PUERTO B:
int contador=0;
void setup(){
DDRB= B11111111;
}
void loop(){
for (contador=0; contador <3; contador ++){ //solo son 3 casos.
switch(contador){
case 0:
PORTB= B11111111;//aquí encenderemos todos los leds
delay(2000);
case 1:
PORTB= B10101010;//aquí encenderemos solo los impares.
delay(2000);
case 2:
PORTB= B00000000;//aquí los apagaremos todos.
delay(2000);
}
}
}
EJEMPLO CON EL PUERTO D:
int contador=0;//declaramos variable interna como contador.
void setup(){
DDRD= B11111100;//del 0 al 7 y B porque es Binario.
//En este ejemplo no utilicé los pines 0 y 1 del Arduino.
}
void loop(){
for (contador=0; contador <3; contador ++){ //solo son 3 casos.
switch(contador){
case 0:
PORTD= B11111111;//aquí encenderemos todos los leds
delay(2000);
case 1:
PORTD= B10101010;//aquí encenderemos solo los impares.
delay(2000);
case 2:
PORTD= B00000000;//aquí los apagaremos todos.
delay(2000);
}
}
}
int contador=0;
void setup(){
DDRB= B11111111;
}
void loop(){
for (contador=0; contador <3; contador ++){ //solo son 3 casos.
switch(contador){
case 0:
PORTB= B11111111;//aquí encenderemos todos los leds
delay(2000);
case 1:
PORTB= B10101010;//aquí encenderemos solo los impares.
delay(2000);
case 2:
PORTB= B00000000;//aquí los apagaremos todos.
delay(2000);
}
}
}
EJEMPLO CON EL PUERTO D:
int contador=0;//declaramos variable interna como contador.
void setup(){
DDRD= B11111100;//del 0 al 7 y B porque es Binario.
//En este ejemplo no utilicé los pines 0 y 1 del Arduino.
}
void loop(){
for (contador=0; contador <3; contador ++){ //solo son 3 casos.
switch(contador){
case 0:
PORTD= B11111111;//aquí encenderemos todos los leds
delay(2000);
case 1:
PORTD= B10101010;//aquí encenderemos solo los impares.
delay(2000);
case 2:
PORTD= B00000000;//aquí los apagaremos todos.
delay(2000);
}
}
}
