CUADERNO DE PRCTICAS

MICROCONTROLADORES EN EL RECREO

Curso 2014-15

IES CIUDAD JARDN

BADAJOZ

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 <LiquidCrystal_I2C.h>
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)

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
{

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
<= Comparacin de menor o igual que

La conexin de la entrada digital como se representa en la siguiente figura se llama pulldown y asegura que la tensin de entrada sea 0 cuando el pulsador est abierto.
Lneas 30-39, if (condicin){instrucciones si se cumple} else{instrucciones si no se
cumple}

Ejercicio:

Si la seal de entrada se conecta como la figura anterior (en pull-up), cmo cambiaras el sketch para
que funcione igual?, se te ocurre otra forma?

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

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:

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

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

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

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 <LiquidCrystal_I2C.h>

Esta librera precisa de la librera <Wire.h>, 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
9

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

10

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.

11

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

12

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()
{

13

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
}

14

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

15

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

16

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

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

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

22

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

23

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

24

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)

25

/* Este programa usa un sensor ultrasnico 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 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
}

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

27

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

28