recreos microcontroladores

CUADERNO DE PRCTICAS MICROCONTROLADORES EN EL RECREO

Curso 2014-15

IES CIUDAD JARDN BADAJOZ

1

ndice de prcticas

1. Encender un led con un pulsador 2. Lectura de Entrada analgica 3. Variacin de la luminosidad de un LED por entrada analgica 4.Pantalla LCD

Error en ejemplos de la librera de LCD Liquidcrystal Hola mundo! Comandos de la librera

5. Semforo 6. Arranque estrella-tringulo

Mdulo de rels 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 Garca)

2

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 Mecatrnica y Tienda de Robtica */ //------------------------------------ //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 {

3

38 39 40 41

//Pulsador NO oprimido digitalWrite(led,LOW); //Apaga el LED } }

Notas:

Lnea 25, la funcin digitalRead(pin) va a devolver un 0 o 1 segn el nivel presente en el pin. Los dos signos == significan operador de igualdad, un solo = asigna un valor a una variable.

Operadores de comparacin == Comparacin de igualdad

!= Comparacin de diferencia > Comparacin de mayor que

>= Comparacin de mayor o igual que < Comparacin de menor que

4

2. Lectura de Entrada analgica http://rduinostar.com/tutoriales/tutorial-3-entradas-analogicas/

Leer entrada analgica 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 Espaol **** Tutorial 3.- Estradas analgicas Lectura de un valor de tensin en un pin analgico y escritura en puerto serie del valor recogido. Uso pblico citando el autor o procedencia, bajo licencia: Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0) */ // Pin analgico 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 analgica A0 y se lo asignamos a // valorDatos valorDatos = analogRead(entradaDatos); // Imprimimos el valor por el puerto serie Serial.println(valorDatos); }

Notas: Lnea 25, la funcin analogRead(entradaDatos) va a devolver un nmero entero

comprendido en el rango de valores 0-1023, ambos inclusive. Como vers, al abrir el monitor serie las medidas pasan muy rpido. Ejercicio: Aade un retraso con la funcin delay para que se muestre una medida cada 3 segundos. Cmo y dnde lo deberas aadir? En el siguiente sketch reducimos las seales de ruido dando un umbral a la medida para que no muestre pequeas variaciones

Leer entrada analgica y ver valor por el monitor serie con reduccin de ruido

1 2

/* ***********************************************************

5

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 Espaol **** *********************************************************** Tutorial 3.- Entradas analgicas Lectura de un valor de tensin en un pin analgico y escritura en puerto serie del valor recogido. Uso pblico citando el autor o procedencia, bajo licencia: Attribution-NonCommercial-ShareAlike 3.0 Unported (CC BY-NC-SA 3.0) */ // Pin analgico 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 analgica 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: Lnea 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. Lnea 35, if (condicin){instrucciones si se cumple} else{instrucciones si no se cumple}.

abs, devuelve el valor absoluto del nmero que puede ser entero o decimal Lnea 40, actualiza valorAnterior con la lectura analgica para compararla con la

siguiente Ejercicio:

6

Si conectamos un potencimetro a la entrada A0 y queremos que nos encienda el led 13 cuando el potencimetro cambie en ms de un cuarto de giro cmo tendramos que modificar la lnea 34?, Cmo y dnde tendramos que aadir las lneas para encender el led 13?

3. Variacin de la luminosidad de un LED por entrada analgica http://rduinostar.com/tutoriales/tutorial-4-salidas-digitales-pwm-led/

/* *********************************************************** **** rDuinoStar.com - Comunidad Arduino en Espaol **** *********************************************************** Tutorial 4.- Salidas Digitales PWM Lectura de entrada analgica y variacin en la intensidad de iluminacin de un LED utilizando salidas digitales con modulacin en ancho del pulso. Uso pblico 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 analgico 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 analgica A0 y se lo asignamos a // valorDatos valorDatos = analogRead(entradaDatos); // Determinamos el nivel de salida analogWrite(pinLed, valorDatos / 4); }

7

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

4.Pantalla LCD La librera 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 direccin de la tarjeta IC2 usamos el sketch de la web: http://playground.arduino.cc/Main/I2cScanner

Error en ejemplos de la librera de LCD Liquidcrystal En algunos ejemplos que vienen con la librera 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 declaracin : LiquidCrystal lcd(12, 11, 5, 4, 3, 2, BACKLIGH_PIN, POSITIVE ); En cuanto a la conexin 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:

Esta pequea tarjeta viene provista de un conector de 4 pines (ver foto), de arriba a abajo:

8

GND = GND o masa < Negro >.

VCC = +Vcc de 5 Voltios < Rojo >.

SDA = Pin analgico 4 de Arduino o TX, lnea de datos < Blanco > .

SCL = Pin analgico 5 de Arduino o RX, lnea 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 asignacin de los pines en los sketches. Tenemos dos formas:

1. Sustituir o comentar las lnea de configuracin 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 lnea de configuracin del LCD que empiezan por

LiquidCrystal_I2C lcd(xxx) por el siguiente cdigo:

/*-----( Declaracin de constantes )-----*/ // Direccin I2C del LCD #define I2C_ADDR 0x27 // Asignacin 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 // Iluminacin 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);

9

Hola mundo! Siempre es bueno comenzar con un Hola mundo! o Hello world!. Primero debemos instalar la librera correspondiente LiquidCrystal_I2C.h y posteriormente buscar en los ejemplos que trae con ella el Hello world! y compilarlo.

Comandos de la librera Esta librera precisa de la librera , por tanto deber incluirse en el cdigo 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 energa 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(); // sita el cursor en la esquina superior derecha del display lcd.setCursor(columna, fila); //sita el cursor en la columna y fila especificadas

10

lcd.printByte(nmero); // escribe el emoticono guardado en ese nmero 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 informacin 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 aade 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

11

El LM35 es un sensor de temperatura con una precisin calibrada de 1C. Su rango de

medicin abarca desde -55C hasta 150C. La salida es lineal y cada grado centgrado

equivale a 10mV, por lo tanto:

150C = 1500mV

-55C = -550mV1

Caractersticas[editar]

Sus caractersticas ms relevantes son:

Est calibrado directamente en grados Celsius.

La tensin de salida es proporcional a la temperatura.

Tiene una precisin garantizada de 0.5C a 25C.

Baja impedancia de salida.

Baja corriente de alimentacin (60uA).

Bajo coste.

________________________________________________________________

5. Semforo 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.

12

CODIGO DE FUNCIONAMIENTO

void setup() { pinMode(8,OUTPUT);//Declaramos los pines a usar y la accin que realizarn pinMode(9,OUTPUT); pinMode(10,OUTPUT); } void loop() { digitalWrite(10,HIGH); //Escribimos en el pin 10 "HIGH" un uno lgico 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);

13

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 LMPARA COMO UN TELERRUPTOR

//I.E.S EXTREMADURA int ledPin1 = 13; int ButtonPin1 = 7; boolean primerPulso = false; void setup() { pinMode(ledPin1, OUTPUT); pinMode(ButtonPin1, INPUT); } void loop() {

14

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. //Lgica 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); 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 dnde est el programa viendo en qu etapa est }

15

6. Arranque estrella-tringulo Este programa lo he realizado para poder ir visualizndolo por el puerto serie. Hay otras formas de realizarlo ms simples,

16

//Jos Cerrato----------------------------------- //ARRANQUE ESTRELLA TRINGULO 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 TRINGULO 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(){ if(digitalRead(pulsador)==HIGH&&cnt_etapa==0)

17

{ digitalWrite(led,HIGH); // ENTRA REL DE LNEA {digitalWrite(led1,HIGH); // ENTRA REL DE ESTRELLA delay(1000); // TIEMPO DE CAMBIO digitalWrite(led1,LOW); // DESCONEXIN DE ESTRELLA delay(100); // TIEMPO DE SEGURIDAD digitalWrite(led2,HIGH); // ENTRA EL REL DE TRINGULO } 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 TRINGULO SIMULADO CON LEDS.

//Este ejemplo contiene dos pulsadores conectados a entradas digitales y tres leds

//El paso de Estrella a Tringulo se realiza de modo temporizado, es decir, tras pulsar

marcha entra K1 y K3 modo estrella y tras 5 segundos comienza la secuencia

//Tringulo apagando K3 y dejando encendidos K1 y K2.

/*

18

P1 marcha ............. Pin Digital 3

P2 paro ............... Pin Digital 2

K1 contactor .......... Pin Digital 10



*/

//

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



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

19

void paro ()// funcion parada

{

// apaga todas las secuencias:

digitalWrite(ledPinK1, 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);





// inicializamos el pin del pulsador de marcha como entrada:

pinMode(buttonP1, INPUT);

// inicializamos el pin del pulsador de paro como entrada:

20

pinMode(buttonP2, INPUT);




}

void loop(){

attachInterrupt(0, paro, CHANGE); // Interrupcin 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 seales 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);


21

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




}

}

}

Otro ejemplo de arranque estrella-tringulo

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

22

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

23

// digitalWrite(estrellaPin, LOW); // delay(20); // digitalWrite(trianguloPin, HIGH); // } }

Mdulo de rels El manejo de un mdulo rel o es muy sencillo y nos permite controlar el encendido y apagado de cualquier aparato que se conecte a una fuente de alimentacin elctrica 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.

24

attachInterrupt(interrupcin, funcin, modo) Descripcin Especifica la funcin a la que invocar cuando se produce una interrupcin externa. Reemplaza cualquier funcin previa que estuviera enlazada a la interrupcin. La mayora de las placas Arduino tienen dos interrupciones externas: Las nmero 0 (en el pin digital 2) y la 1 (en el pin digital 3). La Arduino Mega tiene otras cuatro: Las nmero 2 (pin 21), 3 (pin 20), 4 (pin 19) y 5 (pin 18). Parmetros interrupcin: el nmero de la interrupcin (int) funcin: la funcin a la que invocar cuando la interrupcin tiene lugar; esta funcin no debe tener parmetros ni devolver nada. Esta funcin es a veces referenciada como rutina de interrupcin de servicio modo define cuando la interrupcin debe ser disparada. Hay cuatro constantes predefinidas como valores vlidos:

LOW para disparar la interrupcin en cualquier momento que el pin se encuentre a valor bajo(LOW).

CHANGE para disparar la interrupcin en cualquier momento que el pin cambie de valor. RISING para disparar la interrupcin 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 funcin enlazada, la funcin delay() no funciona y el valor devuelto por la funcin millis() no se incrementar. Los datos serie recibidos en el transcurso de esta interrupcin pueden perderse. No deberas declarar como voltil cualquier variable que modifiques dentro de la funcin. Usando las interrupciones Las interrupciones son tiles para hacer que las cosas sucedan automticamente en programas para microcontroladores, y puedan ayudar a resolver problemas de temporizacin. Una buena tarea en la que utilizar interrupciones podra 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, sera muy complicado escribir un programa que haga otra cosa, puesto que el programa debera estar constantemente consultando las lneas del sensor del encoder, de forma que capture los pulsos cuando tienen lugar. Otros sensores tienen un interfaz dinmico 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 interrupcin, libera al microcontrolador de realizar otras tareas sin echar en falta el "timbre".

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

25

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 instalacin 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)

26

/* Este programa usa un sensor ultrasnico para hacer parpadear un led y un zumbador dependiendo de la distancia que detecte el sensor */ #include // Importar libreria Ping const int sensor = 4; // Pin de seal 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 }

27

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 Garca)

// 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); /*activacin del pin 9 como salida: para el pulso ultrasnico*/ pinMode(PIN_ECHO, INPUT); /*activacin 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); /* envo del pulso ultrasnico*/ delayMicroseconds(10); digitalWrite(PIN_TRIGGER, LOW); tiempo = pulseIn(PIN_ECHO, HIGH); /* Funcin para medir la longitud del pulso entrante. Mide el tiempo que transcurrido entre el envo

28

del pulso ultrasnico 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); }

recreos microcontroladores

Documents