Recreos Arduino. Prácticas

29
CUADERNO DE PRÁCTICAS RECREOS ARDUINO Curso 2014‐15 IES CIUDAD JARDÍN BADAJOZ

description

Resumen del proyecto en el curso 2014/2015

Transcript of Recreos Arduino. Prácticas

Page 1: Recreos Arduino. Prácticas

CUADERNO DE PRÁCTICAS RECREOS ARDUINO

Curso 2014‐15

IES CIUDAD JARDÍN BADAJOZ

Page 2: Recreos Arduino. Prácticas

Í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 estrella­triá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

Page 3: Recreos Arduino. Prácticas

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

Page 4: Recreos Arduino. Prácticas

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 pull­down y asegura que la tensión de entrada sea 0 cuando el pulsador está abierto.

Líneas 30­39, 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 pull­up), ¿cómo cambiarías el sketch para que funcione igual?, ¿se te ocurre otra forma?

3

Page 5: Recreos Arduino. Prácticas

2. Lectura de Entrada analógica http://rduinostar.com/tutoriales/tutorial­3­entradas­analogicas/

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: Attribution­NonCommercial­ShareAlike 3.0 Unported (CC BY­NC­SA 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 0­1023, 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

Page 6: Recreos Arduino. Prácticas

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: Attribution­NonCommercial­ShareAlike 3.0 Unported (CC BY­NC­SA 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

Page 7: Recreos Arduino. Prácticas

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/tutorial­4­salidas­digitales­pwm­led/

/*

***********************************************************

**** 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: Attribution­NonCommercial­ShareAlike 3.0 Unported (CC BY­NC­SA 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

Page 8: Recreos Arduino. Prácticas

valorDatos = analogRead(entradaDatos); // Determinamos el nivel de salida analogWrite(pinLed, valorDatos / 4);

http://www.tr3sdland.com/2011/11/tutorial­arduino­0003­entrada­analogica­y­salida­pwm/

4.Pantalla LCD La librería para usar los LCD 16x2 es la de fmalpartida (https://bitbucket.org/fmalpartida/new­liquidcrystal/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

Page 9: Recreos Arduino. Prácticas

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

Page 10: Recreos Arduino. Prácticas

// 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

Page 11: Recreos Arduino. Prácticas

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

Page 12: Recreos Arduino. Prácticas

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

Page 13: Recreos Arduino. Prácticas

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

Page 14: Recreos Arduino. Prácticas

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

Page 15: Recreos Arduino. Prácticas

//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

Page 16: Recreos Arduino. Prácticas

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

Page 17: Recreos Arduino. Prácticas

//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

Page 18: Recreos Arduino. Prácticas

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

Page 19: Recreos Arduino. Prácticas

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

Page 20: Recreos Arduino. Prácticas

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

Page 21: Recreos Arduino. Prácticas

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

Page 22: Recreos Arduino. Prácticas

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 estrella­triángulo

// // Arranque estrella­triangulo // // Made by pedrovjm // License: CC­BY­SA 3.0 // Downloaded from: http://123d.circuits.io/circuits/69877­arranque­estrella­triangulo // 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

Page 23: Recreos Arduino. Prácticas

// 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

Page 24: Recreos Arduino. Prácticas

// 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

Page 25: Recreos Arduino. Prácticas

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

Page 26: Recreos Arduino. Prácticas

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

Page 27: Recreos Arduino. Prácticas

/* 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

Page 28: Recreos Arduino. Prácticas

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

Page 29: Recreos Arduino. Prácticas

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