Post on 11-Jul-2016
description
CUADERNO DE PRÁCTICAS RECREOS ARDUINO
Curso 2014‐15
IES CIUDAD JARDÍN BADAJOZ
Índice de prácticas
1. Encender un led con un pulsador 2. Lectura de Entrada analógica 3. Variación de la luminosidad de un LED por entrada analógica 4.Pantalla LCD
Error en ejemplos de la librería de LCD Liquidcrystal Hola mundo! Comandos de la librería <LiquidCrystal_I2C.h>
5. Semáforo 6. Arranque estrellatriángulo
Módulo de relés 7. Funcionamiento de un motor con pulsador de marcha y paro 8. Sensor de aparcamiento por ultrasonidos con zumbador (Angel Reyes Nieto) 9. SENSOR DE APARCAMIENTO CON LEDS ( Jorge Delgado García)
1
RECREOS ARDUINO
1. Encender un led con un pulsador
Encender LED con un pulsador
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37
/* Encender LED con un pulsador Oprimir un pulsador y mientras este se mantenga accionado un LED se enciende Cosas de Mecatrónica y Tienda de Robótica */ // //Declara puertos de entradas y salidas // int pulsador=2; //Pin donde se encuentra el pulsador, entrada int led=13; //Pin donde se encuentra el LED, salida // //Funcion principal // void setup() // Se ejecuta cada vez que el Arduino se inicia pinMode(pulsador, INPUT); //Configurar el pulsador como una entrada pinMode(led,OUTPUT); //Configurar el LED como una salida // //Funcion ciclicla // void loop() // Esta funcion se mantiene ejecutando // cuando este energizado el Arduino //Condicional para saber estado del pulsador if (digitalRead(pulsador)==HIGH) //Pulsador oprimido digitalWrite(led,HIGH); //Enciende el LED else //Pulsador NO oprimido
2
38 39 40 41
digitalWrite(led,LOW); //Apaga el LED
Notas:
Línea 25, la función digitalRead(pin) va a devolver un 0 o 1 según el nivel presente en el pin. Los dos signos == significan operador de igualdad, un solo = asigna un valor a una variable.
Operadores de comparación == Comparación de igualdad
!= Comparación de diferencia > Comparación de mayor que
>= Comparación de mayor o igual que < Comparación de menor que
<= Comparación de menor o igual que
La conexión de la entrada digital como se representa en la siguiente figura se llama pulldown y asegura que la tensión de entrada sea 0 cuando el pulsador está abierto.
Líneas 3039, if (condición)instrucciones si se cumple elseinstrucciones si no se cumple
Ejercicio:
Si la señal de entrada se conecta como la figura anterior (en pullup), ¿cómo cambiarías el sketch para que funcione igual?, ¿se te ocurre otra forma?
3
2. Lectura de Entrada analógica http://rduinostar.com/tutoriales/tutorial3entradasanalogicas/
Leer entrada analógica y ver valor por el monitor serie
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27
/* **** rDuinoStar.com Comunidad Arduino en Español **** Tutorial 3. Estradas analógicas Lectura de un valor de tensión en un pin analógico y escritura en puerto serie del valor recogido. Uso público citando el autor o procedencia, bajo licencia: AttributionNonCommercialShareAlike 3.0 Unported (CC BYNCSA 3.0) */ // Pin analógico que utilizaremos como entrada de datos int entradaDatos = A0; // Variable que recogerá las lecturas de A0 int valorDatos = 0; void setup() // Establecemos la velocidad para transmitir datos en serie a // 9600 baudios Serial.begin(9600); void loop() // Leemos el valor en la entrada analógica A0 y se lo asignamos a // valorDatos valorDatos = analogRead(entradaDatos); // Imprimimos el valor por el puerto serie Serial.println(valorDatos);
Notas: Línea 25, la función analogRead(entradaDatos) va a devolver un número entero
comprendido en el rango de valores 01023, ambos inclusive. Como verás, al abrir el monitor serie las medidas pasan muy rápido. Ejercicio: Añade un retraso con la función delay para que se muestre una medida cada 3 segundos. ¿Cómo y dónde lo deberías añadir? En el siguiente sketch reducimos las señales de ruido dando un umbral a la medida para que no muestre pequeñas variaciones
Leer entrada analógica y ver valor por el monitor serie con reducción de ruido
4
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
/* *********************************************************** **** rDuinoStar.com Comunidad Arduino en Español **** *********************************************************** Tutorial 3. Entradas analógicas Lectura de un valor de tensión en un pin analógico y escritura en puerto serie del valor recogido. Uso público citando el autor o procedencia, bajo licencia: AttributionNonCommercialShareAlike 3.0 Unported (CC BYNCSA 3.0) */ // Pin analógico que utilizaremos como entrada de datos int entradaDatos = A0; // Variable que recogerá las lecturas de A0 int valorDatos = 0; // Variable que almacenará el valor anterior en A0 int valorAnterior = 1; void setup() // Establecemos la velocidad para transmitir datos en serie a // 9600 baudios Serial.begin(9600); void loop() // Leemos el valor en la entrada analógica A0 y se lo asignamos a // valorDatos valorDatos = analogRead(entradaDatos); // Comprobamos si el valor es distinto al anterior +2 para no imprimir // varias veces el mismo valor if (abs(valorDatos valorAnterior) > 2)
// Imprimirmos el valor por el puerto serie Serial.println(valorDatos); // Actualizamos el valor anterior al actual valorAnterior = valorDatos;
Notas: Línea 19, los enteros pueden valer entre 32.768 y 32.767 (65.535 valores). Es
necesario inicializar esta variable a un valor distinto de 0. Línea 35, if (condición)instrucciones si se cumple elseinstrucciones si no se cumple.
abs, devuelve el valor absoluto del número que puede ser entero o decimal
5
Línea 40, actualiza valorAnterior con la lectura analógica para compararla con la siguiente
Ejercicio: Si conectamos un potenciómetro a la entrada A0 y queremos que nos encienda el led 13 cuando el potenciómetro cambie en más de un cuarto de giro ¿cómo tendríamos que modificar la línea 34?, ¿Cómo y dónde tendríamos que añadir las líneas para encender el led 13?
3. Variación de la luminosidad de un LED por entrada analógica http://rduinostar.com/tutoriales/tutorial4salidasdigitalespwmled/
/*
***********************************************************
**** rDuinoStar.com Comunidad Arduino en Español **** ***********************************************************
Tutorial 4. Salidas Digitales PWM
Lectura de entrada analógica y variación en la intensidad de iluminación de un LED utilizando salidas digitales con modulación en ancho del pulso.
Uso público citando el autor o procedencia, bajo licencia: AttributionNonCommercialShareAlike 3.0 Unported (CC BYNCSA 3.0)
*/
// Pin digital PWM que utilizaremos para alimentar el LED
int pinLed = 10; // Pin analógico que utilizaremos como entrada de datos
int entradaDatos = A0; // Variable que recogerá las lecturas de A0
int valorDatos = 0;
void setup()
// Configuramos el pin del LED como salida, aunque no es necesario pinMode(pinLed, OUTPUT);
void loop()
// Leemos el valor en la entrada analógica A0 y se lo asignamos a // valorDatos
6
valorDatos = analogRead(entradaDatos); // Determinamos el nivel de salida analogWrite(pinLed, valorDatos / 4);
http://www.tr3sdland.com/2011/11/tutorialarduino0003entradaanalogicaysalidapwm/
4.Pantalla LCD La librería para usar los LCD 16x2 es la de fmalpartida (https://bitbucket.org/fmalpartida/newliquidcrystal/downloads). Para usarla hay que descomprimirla en la carpeta libraries del IDE, borrando previamente la carpeta “Liquidcrystal” existente. Para determinar la dirección de la tarjeta IC2 usamos el sketch de la web: http://playground.arduino.cc/Main/I2cScanner
Error en ejemplos de la librería de LCD Liquidcrystal En algunos ejemplos que vienen con la librería dan error: HelloWorld_4bit:8: error: 'BACKLIGH_PIN' was not declared in this scope. Para resolverlo basta con borrar la variable BACKLIGHT_PIN de la declaración : LiquidCrystal lcd(12, 11, 5, 4, 3, 2, BACKLIGH_PIN, POSITIVE ); En cuanto a la conexión de la tarjeta I2C al Arduino tenemos que distinguir entre el Arduino Mega y el resto:
I2C Arduino Arduino Mega
VCC 5V 5V
GND GND GND
SCL A5 D21
SDA A4 D20
Quedando en un Arduino Uno así:
7
Esta pequeña tarjeta viene provista de un conector de 4 pines (ver foto), de arriba a abajo:
GND = GND o masa < Negro >.
VCC = +Vcc de 5 Voltios < Rojo >.
SDA = Pin analógico 4 de Arduino o TX, línea de datos < Blanco > .
SCL = Pin analógico 5 de Arduino o RX, línea de reloj < Amarillo >.
Nota. Para recordar con facilidad, asocie SDA con el 4, es decir SDA = pin4, el otro pin (pin5) se corresponde con SCL. Para configurar nuestra tarjeta y que funcione hay que cambiar la asignación de los pines en los sketches. Tenemos dos formas:
1. Sustituir o comentar las línea de configuración del LCD que empiezan por LiquidCrystal_I2C lcd(xxx) por:
LiquidCrystal_I2C lcd(0x27, 2, 1, 0, 4, 5, 6, 7, 3, POSITIVE); // Set the LCD I2C address
2. Sustituir o comentar las línea de configuración del LCD que empiezan por
LiquidCrystal_I2C lcd(xxx) por el siguiente código:
/*( Declaración de constantes )*/ // Dirección I2C del LCD #define I2C_ADDR 0x27
8
// Asignación de pines para el YwRobot LCM1602 IIC V1 (PCF8574T) #define BACKLIGHT_PIN 3 #define En_pin 2 #define Rw_pin 1 #define Rs_pin 0 #define D4_pin 4 #define D5_pin 5 #define D6_pin 6 #define D7_pin 7
// Iluminación ON/OFF #define LIGHT_OFF LOW #define LIGHT_ON HIGH
/* Configurar LCD */
LiquidCrystal_I2C
lcd(I2C_ADDR,En_pin,Rw_pin,Rs_pin,D4_pin,D5_pin,D6_pin,D7_pin);
Hola mundo! Siempre es bueno comenzar con un Hola mundo! o Hello world!. Primero debemos instalar la librería correspondiente LiquidCrystal_I2C.h y posteriormente buscar en los ejemplos que trae con ella el Hello world! y compilarlo.
9
Comandos de la librería <LiquidCrystal_I2C.h> Esta librería precisa de la librería <Wire.h>, por tanto deberá incluirse en el código las dos juntas. Las funciones son las siguientes: LiquidCrystal_I2C lcd(direccion,columnas,filas); // para especificar cual es nuestra LCD lcd.init(); // inicializa la LCD lcd.backlight(); // enciende la luz del display lcd.noBacklight(); // apaga la luz del display para ahorrar energía lcd.clear(); // borra la pantalla lcd.write(caracter); // escribe un caracter en pantalla lcd.print(texto para mostrar); // escribe texto en pantalla lcd.print(texto para mostrar, BASE); lcd.createChar(numero, nombre); // para crear emoticonos lcd.home(); // sitúa el cursor en la esquina superior derecha del display lcd.setCursor(columna, fila); //sitúa el cursor en la columna y fila especificadas lcd.printByte(número); // escribe el emoticono guardado en ese “número” lcd.blink(); // muestra el cursor con forma de bloque parpadeante lcd.noBlink(); // deja de mostrar el cursor parpadeante lcd.cursor(); // muestra el cursor como barra baja _
lcd.noCursor(); // deja de mostrar el cursor barra baja
lcd.display(); // muestra los caracteres
lcd.noDisplay(); // deja de mostrar los caracteres sin perder la información lcd.leftToRight(); // cuando se escribe, las letras aparecen a la izquierda del cursor lcd.rightToLeft(); // letras aparecen a la derecha del cursor lcd.autoscroll(); // mueve todo el texto un espacio a la izquierda cada vez que se añade una // letra. lcd.noAutoscroll(); // apaga el desplazamiento lcd.scrollDisplayLeft(); // desplaza el texto hacia la izquierda. lcd.scrollDisplayRight(); // desplaza el texto hacia la derecha.
El sensor de temperatura LM35
10
El LM35 es un sensor de temperatura con una precisión calibrada de 1ºC. Su rango de
medición abarca desde 55°C hasta 150°C. La salida es lineal y cada grado centígrado equivale
a 10mV, por lo tanto:
150ºC = 1500mV
55ºC = 550mV1
Características[editar]
Sus características más relevantes son:
Está calibrado directamente en grados Celsius.
La tensión de salida es proporcional a la temperatura.
Tiene una precisión garantizada de 0.5°C a 25°C.
11
Baja impedancia de salida.
Baja corriente de alimentación (60uA).
Bajo coste.
________________________________________________________________
5. Semáforo Materiales ∙ 1 Arduino Uno R3(puede ser cualquier otra placa de arduino) ∙ 3 leds, uno verde, uno amarillo y uno rojo. ∙ 1 Resistencia de 220 ohms o superior. ∙ 1 Cable usb de transferencia de datos.
CODIGO DE FUNCIONAMIENTO
void setup()
pinMode(8,OUTPUT);//Declaramos los pines a usar y la acción que realizarán pinMode(9,OUTPUT); pinMode(10,OUTPUT);
12
void loop()
digitalWrite(10,HIGH); //Escribimos en el pin 10 "HIGH" un uno lógico para encender LED VERDE
delay(5000); //ESPERAMOS 5 SEGUNDOS digitalWrite(10,LOW); //ESCRIBIMOS EN EL PIN 10 "BAJO" para aapagar el LED VERDE delay(500); //Esperamos medio segundo digitalWrite(10,HIGH); // ESTE ES LA PARTE DONDE SE EJECUTA EL PARPADEO DEL LED,ESCRIBIMOS "HIGH"
delay(500); //ESPERAMOS MEDIO SEGUNDO digitalWrite(10,LOW); // APAGAMOS EL LED delay(500); //ESPERAMOS MEDIO SEGUNDO digitalWrite(10,HIGH); //ESTE PARTE ES LA MISMA QUE LA ANTERIOR, ESTE ES EL SEGUNDO PARPADEO DE NUESTRO LED
delay(500); digitalWrite(10,LOW); delay(500); digitalWrite(10,HIGH); //ESTE PARTE ES LA MISMA QUE LA ANTERIOR, ESTE ES EL SEGUNDO PARPADEO DE NUESTRO LED
delay(500); digitalWrite(10,LOW); delay(500); digitalWrite(9,HIGH); //AHORA ESCRIBIMOS UN "1" LOGICO EN LE PIN 9, QUE CORRESPONDE A NUESTRO LED AMARILLO
delay(3000); //ESPERAMOS 3 SEGUNDOS digitalWrite(9,LOW); //APAGAMOS EL LED AMARILLO digitalWrite(9,HIGH); // ESTE ES LA PARTE DONDE SE EJECUTA EL PARPADEO DEL LED,ESCRIBIMOS "HIGH"
delay(500); //ESPERAMOS MEDIO SEGUNDO digitalWrite(9,LOW); // APAGAMOS EL LED delay(500); //ESPERAMOS MEDIO SEGUNDO digitalWrite(9,HIGH); //ESTE PARTE ES LA MISMA QUE LA ANTERIOR, ESTE ES EL SEGUNDO PARPADEO DE NUESTRO LED
delay(500); digitalWrite(9,LOW); delay(500); digitalWrite(9,HIGH); //ESTE PARTE ES LA MISMA QUE LA ANTERIOR, ESTE ES EL SEGUNDO PARPADEO DE NUESTRO LED
delay(500);
digitalWrite(9,LOW); delay(500); digitalWrite(8,HIGH); //ESCRIBIMOS UN "1" LOGICO EN EL PIN 8, QUE CORRESPONDE AL LED ROJO delay(5000); //ESPERAMOS 5 SEGUNDOS digitalWrite(8,LOW); //ESCRIBIMOS UN "0" LOGICO EN EL PIN 8, APAGANDO EL LED ROJO
OS DEJO EL FUNCIONAMIENTO DE UNA LÁMPARA COMO UN TELERRUPTOR
13
//I.E.S EXTREMADURA
int ledPin1 = 13; int ButtonPin1 = 7; boolean primerPulso = false; void setup()
pinMode(ledPin1, OUTPUT); pinMode(ButtonPin1, INPUT);
void loop()
if (digitalRead(ButtonPin1)==HIGH) primerPulso=!primerPulso; delay (10);
digitalWrite(ledPin1,primerPulso);
OTRO ESQUEMA PARA HACER EL TELERRUPTOR Al accionar el pulsador el Led se enciende y al volver a pulsar el Led se apaga
//Telerruptor. un pulsador controla un led. pulsas led= on vuelves a pulsar led=off.
//Lógica positiva.
//se ha montado un circuito rc para evitar el rebote del pulsador
int pulsador=6; int led=12; int cnt_etapa=0; //contador de etapas y estado// void setup() pinMode(pulsador,INPUT); pinMode(led,OUTPUT); Serial.begin(9600);
void loop() if(digitalRead(pulsador)==HIGH&&cnt_etapa==0) digitalWrite(led,HIGH);
14
cnt_etapa=1;
if(digitalRead(pulsador)==LOW&&cnt_etapa==1) cnt_etapa=2;
if(digitalRead(pulsador)==HIGH && cnt_etapa==2) digitalWrite(led,LOW); cnt_etapa=3;
if(digitalRead(pulsador)==LOW && cnt_etapa==3) cnt_etapa=0;
Serial.println(cnt_etapa); //puedes dónde está el programa viendo en qué etapa está
6. Arranque estrella‐triángulo Este programa lo he realizado para poder ir visualizándolo por el puerto serie. Hay otras formas de realizarlo más simples,
15
//José Cerrato
//ARRANQUE ESTRELLA TRIÁNGULO
int pulsador=6; //PULSADOR DE MARCHA Y PARADA int led=12; // RELÉ PARA CONTACTOR DE LINEA int led1=11; // RELÉ PARA CONTACTOR DE ESTRELLA int led2=10; // RELÉ PARA CONTACTOR DE TRIÁNGULO int cnt_etapa=0; //contador de etapas y estado// void setup() pinMode(pulsador,INPUT); pinMode(led,OUTPUT); pinMode(led1,OUTPUT); pinMode(led2,OUTPUT); Serial.begin(9600);
void loop()
16
if(digitalRead(pulsador)==HIGH&&cnt_etapa==0) digitalWrite(led,HIGH); // ENTRA RELÉ DE LÍNEA digitalWrite(led1,HIGH); // ENTRA RELÉ DE ESTRELLA delay(1000); // TIEMPO DE CAMBIO digitalWrite(led1,LOW); // DESCONEXIÓN DE ESTRELLA delay(100); // TIEMPO DE SEGURIDAD
digitalWrite(led2,HIGH); // ENTRA EL RELÉ DE TRIÁNGULO
cnt_etapa=1;
if(digitalRead(pulsador)==LOW&&cnt_etapa==1) cnt_etapa=2; // PARADA TOTAL
if(digitalRead(pulsador)==HIGH && cnt_etapa==2) digitalWrite(led,LOW); digitalWrite(led1,LOW); digitalWrite(led2,LOW); cnt_etapa=3;
if(digitalRead(pulsador)==LOW && cnt_etapa==3) cnt_etapa=0;
Serial.println(cnt_etapa); //puedes ver en qué etapa está el programa
//ARRANQUE ESTRELLA TRIÁNGULO SIMULADO CON LEDS.
//Este ejemplo contiene dos pulsadores conectados a entradas digitales y tres leds
//El paso de Estrella a Triángulo se realiza de modo temporizado, es decir, tras pulsar
marcha entra K1 y K3 modo estrella y tras 5 segundos comienza la secuencia
//Triángulo apagando K3 y dejando encendidos K1 y K2.
/*
17
P1 marcha ............. Pin Digital 3
P2 paro ............... Pin Digital 2
K1 contactor .......... Pin Digital 10
K2 contactor .......... Pin Digital 11
K3 contactor .......... Pin Digital 12
*/
//
// Definimos los numeros de pin:
const int buttonP1 = 3; // Numero de Pin del pulsador Marcha
const int buttonP2 = 2; // Numero de Pin del pulsador Paro
const int ledPinK1 = 10; // Numero del pin de led para K1
const int ledPinK2 = 11; // Numero del pin de led para K2
const int ledPinK3 = 12; // Numero del pin de led para K3
// variables:
int estrella =0; // Varible de apoyo para secuencia estrella
int triangulo =0; // Varible de apoyo para la secuencia triangulo
int buttonStateP1 = 0; // variable para leer el estado del pulsador marcha
int buttonStateP2 = 0; // variable para leer el estado del pulsador Paro
void(* resetFunc) (void) = 0; // Funcion reseteo
18
void paro ()// funcion parada
// apaga todas las secuencias:
digitalWrite(ledPinK1, LOW);
digitalWrite(ledPinK2, LOW);
digitalWrite(ledPinK3, LOW);
// inicialia tdos los indicadores
estrella = 0; // Inicializamos estado estrella
triangulo = 0; // Inicializamos estado tiangulo
resetFunc(); // llamada a reseteo
void setup()
// initializamos el pin del LED K1 como salida:
pinMode(ledPinK1, OUTPUT);
// initializamos el pin del LED K2 como salida:
pinMode(ledPinK2, OUTPUT);
// initializamos el pin del LED K3 como salida:
pinMode(ledPinK3, OUTPUT);
// inicializamos el pin del pulsador de marcha como entrada:
pinMode(buttonP1, INPUT);
// inicializamos el pin del pulsador de paro como entrada:
19
pinMode(buttonP2, INPUT);
digitalWrite(ledPinK1, LOW);
digitalWrite(ledPinK2, LOW);
digitalWrite(ledPinK3, LOW);
void loop()
attachInterrupt(0, paro, CHANGE); // Interrupción de paro.
// leemos el estado del pulsador de marcha:
buttonStateP1 = digitalRead(buttonP1);
// leemos el estado del pulsador de paro:
buttonStateP2 = digitalRead(buttonP2);
if (buttonStateP1 == HIGH) // comprobamos si el pulsador de marcha ha sido pulsado.
estrella = 1; // Indicador estado estrella
delay (200); //retardo para micro señales de retorno pulsador
if ( (estrella == 1) && (triangulo ==0)) // si no esta triangulo en marcha comienza
secuencia estrella triangulo
// enciende la secuencia Estrella K1 y K3 encendido:
digitalWrite(ledPinK1, HIGH);
digitalWrite(ledPinK3, HIGH);
20
delay (5000); // retardo entre estrella y triangulo
// enciende la secuencia Triangunlo Apaga K3 y enciende K2 dejando a K1 encendido:
estrella = 0; // Inicializamos indicador estrella para impedir funcionamiento conjunto
triangulo = 1; // Indicador estado tiangulo
digitalWrite(ledPinK3, LOW);
digitalWrite(ledPinK1, HIGH);
digitalWrite(ledPinK2, HIGH);
Otro ejemplo de arranque estrellatriángulo
// // Arranque estrellatriangulo // // Made by pedrovjm // License: CCBYSA 3.0 // Downloaded from: http://123d.circuits.io/circuits/69877arranqueestrellatriangulo // Declaracion de variables int alimentacionPin = 6; int estrellaPin = 4; int trianguloPin = 2; int pmarchaPin = 12; int pparoPin = 8; int lastSTATE = LOW; int pmarchaSTATE = LOW; int pparoSTATE = LOW; int secuenciaArranque = LOW; // debounce we are using buttons to toggle and this turns over fast //long time = 0; // the last time the output pin was toggled //long debounce = 200; // the debounce time, increase if the output flickers
21
// el setup corre solo una vez cada vez que se reinicializa el programa void setup() // declaramos las variables como entradas o salidas pinMode(alimentacionPin, OUTPUT); pinMode(estrellaPin, OUTPUT); pinMode(trianguloPin, OUTPUT); pinMode(pmarchaPin, INPUT); pinMode(pparoPin, INPUT); // El loop se repite ciclicamente void loop() // comprobamos el estado de los pulsadores pmarchaSTATE = digitalRead(pmarchaPin); pparoSTATE = digitalRead(pparoPin); // compruebo si se ha pulsado pparo if(pparoSTATE == HIGH) digitalWrite(alimentacionPin, LOW); digitalWrite(estrellaPin, LOW); digitalWrite(trianguloPin, LOW); if(pmarchaSTATE == HIGH) digitalWrite(alimentacionPin, HIGH); digitalWrite(estrellaPin, HIGH); digitalWrite(trianguloPin, HIGH); // digitalWrite(lastSTATE, LOW); // digitalWrite(secuenciaArranque, LOW); // // compruebo si se ha pulsado pmarcha //if(pmarchaSTATE == HIGH && pparoPin == LOW && lastSTATE == LOW) // digitalWrite(lastSTATE, HIGH); // // Secuencia de arranque //if(lastSTATE == HIGH && secuenciaArranque == LOW) // digitalWrite(secuenciaArranque, HIGH); // digitalWrite(alimentacionPin, HIGH); // digitalWrite(estrellaPin, HIGH); // hacemos esperar al programa 10s // delay(10000); // digitalWrite(estrellaPin, LOW); // delay(20);
22
// digitalWrite(trianguloPin, HIGH); //
Módulo de relés El manejo de un módulo relé o es muy sencillo y nos permite controlar el encendido y apagado de cualquier aparato que se conecte a una fuente de alimentación eléctrica externa. El relé hace de interruptor y se activa y desactiva mediante una entrada de datos. Gracias a esto podemos controlar el encendido de cualquier aparato.
attachInterrupt(interrupción, función, modo)
23
Descripción Especifica la función a la que invocar cuando se produce una interrupción externa. Reemplaza cualquier función previa que estuviera enlazada a la interrupción. La mayoría de las placas Arduino tienen dos interrupciones externas: Las número 0 (en el pin digital 2) y la 1 (en el pin digital 3). La Arduino Mega tiene otras cuatro: Las número 2 (pin 21), 3 (pin 20), 4 (pin 19) y 5 (pin 18). Parámetros interrupción: el número de la interrupción (int) función: la función a la que invocar cuando la interrupción tiene lugar; esta función no debe tener parámetros ni devolver nada. Esta función es a veces referenciada como rutina de interrupción de servicio modo define cuando la interrupción debe ser disparada. Hay cuatro constantes predefinidas como valores válidos:
LOW para disparar la interrupción en cualquier momento que el pin se encuentre a valor bajo(LOW). CHANGE para disparar la interrupción en cualquier momento que el pin cambie de valor. RISING para disparar la interrupción cuando el pin pase de valor alto (HIGH) a bajo (LOW). FALLING para cuando el pin cambie de valor alto (HIGH) a bajo (LOW)
Retorno Ninguno Nota Dentro de la función enlazada, la función delay() no funciona y el valor devuelto por la función millis() no se incrementará. Los datos serie recibidos en el transcurso de esta interrupción pueden perderse. No deberías declarar como volátil cualquier variable que modifiques dentro de la función. Usando las interrupciones Las interrupciones son útiles para hacer que las cosas sucedan automáticamente en programas para microcontroladores, y puedan ayudar a resolver problemas de temporización. Una buena tarea en la que utilizar interrupciones podría ser leer un encoder rotacional, monitorizando la entrada del usuario. Si quisieras asegurarte de que un programa siempre captura los pulsos de un encoder rotacional, sin perder nunca un pulso, sería muy complicado escribir un programa que haga otra cosa, puesto que el programa debería estar constantemente consultando las líneas del sensor del encoder, de forma que capture los pulsos cuando tienen lugar. Otros sensores tienen un interfaz dinámico similar, como intentar leer un sensor de sonido que intenta capturar un click, o un sensor de ranuras por infrarrojos (fotointerruptor) tratando de capturar el paso de una moneda. En todas estas situaciones, usar una interrupción, libera al microcontrolador de realizar otras tareas sin echar en falta el "timbre".
24
7. Funcionamiento de un motor con pulsador de marcha y paro //FUNCIONAMIENTO DE UN MOTOR MEDIANTE PULSADOR DE MARCHA Y PULSADOR DE PARO josé Cerrato
int led = 12; // motor int Pulsador_Set = 4; //puesta en marcha del motor int Pulsador_Reset = 5; //parada del motor int Estado_Pulsador_S; int Estado_Pulsador_R;
// Rutina de instalación
void setup() // iniciar el pin como salida digital
pinMode(led, OUTPUT); pinMode(Pulsador_Set, INPUT); pinMode(Pulsador_Reset, INPUT);
// Rutina ciclica
void loop() Estado_Pulsador_S = digitalRead(Pulsador_Set); Estado_Pulsador_R = digitalRead(Pulsador_Reset);
if (Estado_Pulsador_S == 1)
digitalWrite(led, 1); // Encender LED
if (Estado_Pulsador_R == 1)
digitalWrite(led, 0); // Pagado LED
8. Sensor de aparcamiento por ultrasonidos con zumbador (Angel Reyes Nieto)
25
/* Este programa usa un sensor ultrasónico para
hacer parpadear un led y un zumbador dependiendo
de la distancia que detecte el sensor */
#include <Ping.h> // Importar libreria Ping
const int sensor = 4; // Pin de señal conectado al pin 4 const int zumbador = 6; // Zumbador conectado al pin 6 const int led = 8; // LED conectado al pin 8
int distancia; // Guardamos la distancia que detecte el sensor int pausa; // Guarda el tiempo de espera entre parpadeo
Ping ping = Ping (sensor); // Creamos el objeto ping
void setup() pinMode(zumbador, OUTPUT); // Declaramos el zumbador como salida pinMode(led, OUTPUT); // Declaramos el LED como salida
26
void loop() ping.fire(); // Inicia el sensor distancia = ping.centimeters(); // Devuelve la distancia en cm
if(distancia < 100) // Si el objeto está a menos de 100cm pausa = distancia * 10; // Calculamos la distancia digitalWrite(zumbador, HIGH); // Encendemos el zumbador digitalWrite(led, HIGH); // Encendemos el led delay(pausa); // Esperamos el tiempo de pausa
digitalWrite(zumbador, LOW); // Apagamos el zumbador digitalWrite(led, LOW); // Apagamos el led delay(pausa); // Esperamos el tiempo de pausa
9. SENSOR DE APARCAMIENTO CON LEDS ( Jorge Delgado García)
// Jorge Delgado
const int PIN_TRIGGER = 12; const int PIN_ECHO = 13; const int NUM_LEDS = 10;
float distancia; float tiempo; int pinsLed[] = 11, 10, 9, 8, 7, 6; boolean encendidos = true;
void setup() // Serial.begin(9600);
pinMode(PIN_TRIGGER, OUTPUT); /*activación del pin 9 como salida: para el pulso ultrasónico*/
pinMode(PIN_ECHO, INPUT); /*activación del pin 8 como entrada: tiempo del rebote del ultrasonido*/
for (byte led = 0; led < NUM_LEDS; led++) pinMode(pinsLed[led], OUTPUT);
void loop() digitalWrite(PIN_TRIGGER, HIGH); /* envío del pulso ultrasónico*/ delayMicroseconds(10); digitalWrite(PIN_TRIGGER, LOW); tiempo = pulseIn(PIN_ECHO, HIGH); /* Función para medir la longitud del pulso entrante. Mide el tiempo que transcurrido entre el envío
27
del pulso ultrasónico y cuando el sensor recibe el rebote, es decir: desde que el pin 12 empieza a recibir el rebote, HIGH, hasta que deja de hacerlo, LOW, la longitud del pulso entrante*/
distancia = (((tiempo / 1000000) / 2) * 343) * 100; // Serial.println(distancia);
int valorLED = map(distancia, 2.5, 60, 1, NUM_LEDS);
for (int led = 0; led < NUM_LEDS; led++) if (led < valorLED) digitalWrite(pinsLed[led], LOW); else digitalWrite(pinsLed[led], HIGH);
if (valorLED == 1) if (encendidos) for (byte n = 0; n < NUM_LEDS; n++) digitalWrite(pinsLed[n], LOW);
encendidos = false; else for (byte n = 0; n < NUM_LEDS; n++) digitalWrite(pinsLed[n], HIGH);
encendidos = true;
delay(80);
28