You are on page 1of 48

Arduino Digital: Deteccin de cambio de

estado (deteccin de bordes)

Una vez que se tiene un pulsador funcionando, a menudo se quiere hacer algo de accin basado en las veces que se pulsa el botn. Para ello, es necesario saber que el botn cambia
el estado de apagado a encendido, y contar el nmero de veces que ocurre este cambio de estado. Esto se conoce como deteccin de cambio de estado o deteccin de bordes.
El IDE del Arduino nos proporciona una herramienta que nos permite enviar y visualizar los datos que se manejan a travs del puerto Serial. Dicha herramienta se conoce como
Monitor Serial y se puede encontrar en el men de herramientas, en la opcin Monitor Serial. En el presente proyecto se usara dicha herramienta para visualizar nuestros datos.

Hardware Requerido

Tarjeta Arduino
Pulsador
Resistencia (10K ohm)
Protoboard
LED
Resistencia (220 ohm)

Circuito

Conectar los tres cables a la tarjeta Arduino. Los dos primeros cables, rojo y negro, se conectan hacia las filas verticales en un lado del protoboard para proporcionar una fuente de 5
voltios y tierra. El tercer cable se conecta desde el pin digital 2 hacia una pata del pulsador. La otra pata del pulsador se conecta hacia hacia la fuente de 5 voltios y la resistencia,
donde esta ultima se conecta a tierra. Al presionar el pulsador se conectan los dos puntos. Cuando el pulsador esta abierto (no presionado) no hay conexin entre sus 2 patas. As que
el pin es conectado hacia tierra y lo lee como LOW, o 0. Cuando el pulsador esta cerrado (presionado), esto crea una conexin entre sus dos patas, conectando el pin a 5 voltios, as
que el pin lo lee como HIGH, o 1.
Tambin conectamos una resistencia de 220-ohm al pin 13. Despus conectamos la pata larga de un LED (la pata positiva, llamada nodo) a la resistencia. Mientras que la pata corta
(la pata negativa, llamada ctodo) a tierra.

Esquemtico

Cdigo:
/*
Deteccin de cambio de estado (deteccin de bordes)
A menudo, no es necesario conocer el estado de una entrada digital todo el tiempo, pero usted slo
tiene que saber cuando la entrada
cambia de un estado
a otro. Por ejemplo, usted quiere saber cuando un botn pasa de OFF a ON. Esto se conoce como deteccin de cambio de
estado, o la deteccin de bordes.
Este ejemplo muestra como detectar cuando un pulsador cambia de OFF a ON y de OFF a ON
*/
// las constantes no cambiaran su valor.
const int buttonPin = 2;
// el nmero del pin, entrada del pulsador
const int ledPin = 13;
// el nmero del pin, salida al LED
// declaracion de variables
int buttonPushCounter = 0;
int buttonState = 0;
int lastButtonState = 0;

// contador para el numero de pulsadas


// estado actual del pulsador
// estado anterior del pulsador

void setup() {
// inicializa el pin 2 como pin de entrada
pinMode(buttonPin, INPUT);
// inicializa el pin 13 como pin de salida
pinMode(ledPin, OUTPUT);
// inicializa la comunicacin serial
Serial.begin(9600);
}
void loop() {
// lee el estado del pulsador
buttonState = digitalRead(buttonPin);
// compara el estado del pulsador con el estado previo del mismo
if (buttonState != lastButtonState) {
// si el estado cambio, el contador incrementa
if (buttonState == HIGH) {
// si el estado actual es HIGH entonces el pulsador

// cambio de OFF a ON
buttonPushCounter++;
Serial.println("on");
Serial.print("numero de pulsadores presionados:
Serial.println(buttonPushCounter);

");

}
else {
// si el estado actual del pulsador es LOW entonces el pulsador

// cambio de ON a OFF
Serial.println("off");
}

}
// guarda el estado actual como el ultimo estado,
lastButtonState = buttonState;
// el LED se enciende cada cuatro pulsadas
if (buttonPushCounter % 4 == 0) {
digitalWrite(ledPin, HIGH);
} else {
digitalWrite(ledPin, LOW);
}
}

Arduino Analgico: Escritura analgica con


12 LED's

Este ejemplo atenua 12 LED's, uno por uno, usando la tarjeta Arduino Mega.

Hardware Requerido

Tarjeta Arduino Mega


Doce LED's
Doce resistencias (220 ohm)
Protoboard

Circuito

Conectar la pata ms larga (nodo) de los LED's a las resistencias, las cuales se conectarn a los pines digitales 2-13. Por ltimo, conectar la pata corta de los LED's a tierra.

Esquemtico

Cdigo:
/*
Prueba del comando analogWrite en Arduino Mega
El siguiente esquema fue escrito para Arduino Mega y no funcionar para
tarjetas previas.
Dentro de la funcin setup(), se usa la funcion loop(), la cual es usada para asignar a los pines digitales 2-13 como pines de salida.
A continuacin, en la funcin loop () del programa, un tro de anidado de for() se utilizan. El primero de estos bucles:
for (int thisPin =lowestPin; thisPin <= highestPin; thisPin++)
se mueve a travs de cada uno de los LEDS, uno por uno, desde el pin ms bajo al ms alto. Antes de permitir que se pase de un pin a otro,
dos cosas deben llevarse a cabo. En primer lugar, se aclara el LED a travs de estas lneas:
for (int brightness = 0; brightness < 255; brightness++) {
analogWrite(thisPin, brightness);
delay(2);
}
Con cada pasada a travs del bucle anterior, aumenta la variable brightness de uno en uno, y ese valor se escribe en el pin seleccionado
actualmente. Una vez que se alcanza el valor mximo(255), el siguiente bucle atenua el brillo del LED:
for (int brightness = 255; brightness >= 0; brightness--) {
analogWrite(thisPin, brightness);
delay(2);
}
Este bucle resta de uno en uno la variable de brightness. Una vez que se llega a cero, el loop() principal entra en accin, y el programa
pasa al siguiente pin y se repite todos los pasos mencionados anteriormente.
*/
// declaracion de constantes
const int lowestPin = 2;
const int highestPin = 13;
void setup() {
// se configura los pines 2-13 como pines de salida
for (int thisPin =lowestPin; thisPin <= highestPin; thisPin++) {
pinMode(thisPin, OUTPUT);
}
}
void loop() {
// iteracion sobre todos los pines
for (int thisPin =lowestPin; thisPin <= highestPin; thisPin++) {
// LED cambia desde apagado hasta brillo.
for (int brightness = 0; brightness < 255; brightness++) {
analogWrite(thisPin, brightness);
delay(2);
}
// LED cambia desde brillo hasta apagado
for (int brightness = 255; brightness >= 0; brightness--) {
analogWrite(thisPin, brightness);
delay(2);

}
// pausa
delay(100);
}
}

Secuencias de Luces

En ste tutorial reproducimos diferentes secuencias de luces. Para cambiar a la siguiente secuencia presionamos el pulsador.
El programa utiliza estructuras switch anidadas, la de ms afuera sirve para rotar entre las secuencias y las de adentro para rotar entre los estados de cada secuencia. Antes de eso
evaluamos si se ha presionado el pulsador y le dejamos de hacer caso dehabilitndolo por un rato. sto es porque de lo contrario las secuencias rotaran unas miles de veces entre
que presionamos y soltamos el pulsador. En ste caso no podemos poner un simple delay para esperar a soltarlo porque las secuencias tienen diferentes tiempos y se basan en que
todo el programa se va a repetir constantemente. Finalmente el cambio de estado dentro de la secuencia se evala al final del programa.

Hardware Requerido
Arduino Uno
Protoboard
5 LEDs
5 resistencias de 220
Resistencia de 10K
Pulsador

Circuito

Esquemtico

Cdigo:
/*
Secuencias de Luces
Con este programa rotamos diferentes secuencias de luces al presionar
un pulsador.
*/
// Le damos nombre a los pines del arduino para poder entender mejor
// su funcion en el programa:
int led1 = 3;
int led2 = 5;
int led3 = 6;
int led4 = 9;
int led5 = 10;
int pinPulsador = A0; // Pin donde leemos el valor del potenciometro
// Variables
int estado_pulsador = 0; // Almacena el valor del potenciometro
int secuencias = 5; // Cantidad de secuencias programadas
int espera_pulsador = 500; // Tiempo en milisegundos que se espera antes
// de hacer una nueva lectura al pulsador
int conteo_pulsador = 0; // Contador que se compara con espera pusador
int intensidad = 0; // Intensidad de iluminacion
boolean habilitar_pulsador = false; // Indica si el pulsador se debe leer
boolean aumentando_intensidad = true; // Indica si la intensidad esta aumentando
int tiempo = 100; // Tiempo base en milisegundos para cada iteracion
int secuencia = 1; // Secuencia actual en la que nos encontramos
int estado_secuencia = 1; // Estado de la secuencia actual en el que nos encontramos
int estados = 1; // Estados por secuencia
void setup() {
// Inicializamos los pines de los leds como salidas
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
pinMode(led5, OUTPUT);
// Asignamos los valores iniciales a los leds (apagados)
digitalWrite(led1, LOW);
digitalWrite(led2, LOW);
digitalWrite(led3, LOW);
digitalWrite(led4, LOW);
digitalWrite(led5, LOW);
}
void loop() {
// Leemos el estado del pulsador y lo alamacenamos
estado_pulsador = digitalRead(pinPulsador);
// Si el pulsador esta habilitado y lo presionamos, cambiamos de secuencia
if (habilitar_pulsador && estado_pulsador == HIGH) {
// Rotamos la secuencia.
if (secuencia == secuencias) {
secuencia = 1;
} else {
secuencia = secuencia + 1;
}
estado_secuencia = 1;
habilitar_pulsador = false;

}
// Si el pulsador esta deshabilitado, evaluaremos el conteo de espera antes de volver
// a habilitarlo.
if (habilitar_pulsador == false) {
// Si el conteo llega a espera_pulsador o se deja de presionar el pulsador, lo habilitamos
if (conteo_pulsador >= espera_pulsador || estado_pulsador == LOW) {
habilitar_pulsador = true;
conteo_pulsador = 0;
} else {
conteo_pulsador = conteo_pulsador + tiempo;
}
}
// Evaluamos la secuencia actual
switch(secuencia) {
case 1:
// Secuencia 1: alterna encendido de LEDs
tiempo = 100;
estados = 4;
switch(estado_secuencia) {
case 1:
digitalWrite(led1, LOW);
digitalWrite(led2, HIGH);
digitalWrite(led3, LOW);
digitalWrite(led4, HIGH);
digitalWrite(led5, LOW);
break;
case 3:
digitalWrite(led1, HIGH);
digitalWrite(led2, LOW);
digitalWrite(led3, HIGH);
digitalWrite(led4, LOW);
digitalWrite(led5, HIGH);
break;
}
break;
case 2:
// Secuencia 2: mantiene todos los LEDs encendidos
tiempo = 100;
estados = 1;
digitalWrite(led1, HIGH);
digitalWrite(led2, HIGH);
digitalWrite(led3, HIGH);
digitalWrite(led4, HIGH);
digitalWrite(led5, HIGH);
break;
case 3:
// Secuencia 3: enciende y apaga todos los LEDs
tiempo = 100;
estados = 2;
switch(estado_secuencia) {
case 1:
digitalWrite(led1, HIGH);
digitalWrite(led2, HIGH);
digitalWrite(led3, HIGH);
digitalWrite(led4, HIGH);
digitalWrite(led5, HIGH);
break;
case 9:
digitalWrite(led1, LOW);
digitalWrite(led2, LOW);
digitalWrite(led3, LOW);
digitalWrite(led4, LOW);
digitalWrite(led5, LOW);
break;
}
estados = 17;
break;
case 4:
// Secuencia 4: enciende y apaga todos los LEDs con atenuacion
estados = 15;
switch (estado_secuencia) {
case 1:
// Bajamos el tiempo a 5ms porque la atenuacion requiere
// que se incremente la intensidad de a pocos.
tiempo = 5;
if (aumentando_intensidad) {
intensidad = intensidad + 1;
if (intensidad >= 255) {
intensidad = 255;
aumentando_intensidad = false;
} else {
estado_secuencia = 0; // Para quedarnos en el estado 1
}
} else {
intensidad = intensidad - 1;
if (intensidad <= 0) {
intensidad = 0;
aumentando_intensidad = true;
} else {
estado_secuencia = 0; // Para quedarnos en el estado 1
}
}
analogWrite(led1, intensidad);
analogWrite(led2, intensidad);
analogWrite(led3, intensidad);
analogWrite(led4, intensidad);
analogWrite(led5, intensidad);
break;
case 2:
// Regresamos el tiempo a 100ms porque ya no necesitamos
//
tiempo = 100;
break;
}
break;
case 5:
// Secuencia 5: alterna encendido de LEDs con atenuacion
estados = 15;
switch (estado_secuencia) {
case 1:
// Bajamos el tiempo a 5ms porque la atenuacion requiere
// que se incremente la intensidad de a pocos
tiempo = 5;
if (aumentando_intensidad) {
intensidad = intensidad + 1;
if (intensidad >= 255) {
intensidad = 255;
aumentando_intensidad = false;
} else {
estado_secuencia = 0; // Para quedarnos en el estado 1
}
} else {

intensidad = intensidad - 1;
if (intensidad <= 0) {
intensidad = 0;
aumentando_intensidad = true;
} else {
estado_secuencia = 0; // Para quedarnos en el estado 1
}
}
analogWrite(led1,
analogWrite(led2,
analogWrite(led3,
analogWrite(led4,
analogWrite(led5,
break;
case 2:
tiempo = 100;
break;

intensidad);
255-intensidad);
intensidad);
255-intensidad);
intensidad);

}
break;
}
// Evaluamos si llegamos al estado final
if ( estado_secuencia == estados ) {
estado_secuencia = 1;
} else {
estado_secuencia = estado_secuencia + 1;
}
// Esperamos "tiempo" milisegundos
delay(tiempo);
}

Sentencia: Switch Case

Una sentencia if le permite elegir entre dos opciones diferenciadas, verdadero o falso. Cuando hay ms de dos opciones, puede utilizar mltiplessentencias if, o puede utilizar la
sentencia switch. la sentencia switch permite elegir entre varias opciones discretas. En este ejemplo se muestra cmo usarlo para cambiar entre cuatro estados deseados de una
fotoresistencia: muy
oscuro,
oscuro,
medio
y brillante.
Este programa lee primero la fotorresistencia. A continuacin, utiliza el mapa () para mapear su salida a uno de cuatro valores: 0, 1, 2, o 3. Por ltimo,se utiliza la sentencia
switch() para imprimir uno de los cuatro mensajes de vuelta al ordenador, dependiendo de cul de los cuatro valores se devuelve.

Hardware Requerido
Arduino UNO
Protoboard
Fotoresistencia
Resistencia de 10K

Circuito

Esquemtico

Cdigo:
/*
Sentencia Switch
Demuestra el uso de la sentencia Switch. La sentencia Switch
permite elegir entre un numero de valores discretos. Esto es como
una serie de sentencias if.
*/
// Declaracin de sentencias
// la mxima y mnima lectura que se obtiene del sensor:
const int sensorMin = 0;
const int sensorMax = 600;
void setup() {
// inicializa la comunicacin serial:
Serial.begin(9600);
}
void loop() {
// Lectura del sensor
int sensorReading = analogRead(A0);
int range = map(sensorReading, sensorMin, sensorMax, 0, 3);
// dependiendo del valor de range realiza una determinada accin
switch (range) {
case 0:
// una mano esta sobre el sensor
Serial.println("dark");
break;
case 1:
// una mano esta cerca del sensor
Serial.println("dim");
break;
case 2:
// una mano esta un poco alejada del sensor
Serial.println("medium");
break;
case 3:
// una mano no esta cersa del sensor
Serial.println("bright");
break;
}
delay(1);
// retraso entre lecturas para la estabilidad
}

Sentencia if

La sentencia if() es la sentencia ms bsica de entre todas las sentencias en la estructura de control. Esta permite que pase algo o no, dependiendo si la condicin dada es verdadera o
falsa.

if (condicin)
Realiza una accion si la condicion es verdadera
Existe una variacin, llamada if-else:
if (condicin)
Realiza
una
else
Realiza una accion si la condicion es falsa

accion

si

la

condicion

es

verdadera

Tambin existe la sentenca else-if, donde se puede verificar una segunda condici.
if (condicin)
Realiza una accion si la condicion es verdadera
else if (otra condicin)
Realiza una accion si la primera condicion es falsa
Vamos a usar lasentencia if todo el tiempo. En el ejemplo se enciende un LED en el pin 13 (el LED incorporado en muchas tarjetas Arduinos) si el valor ledo en una entrada
analgica* pasa por encima de un determinado umbral.

*NOTA:Entrada analgica es aquella en la que los valores de la tensin o voltaje varan constantemente.

Hardware Requerido

Tarjeta Arduino
Potencimetro
Resistencia (220 ohm)
Protoboard

Circuito

Esquemtico

Cdigo:
/*
Condicional- sentencia if
Este ejemplo demuestra el uso de la sentencia if().
Se lee el valor del potencimetro(una entrada analgica) y prende el LED
solo si el valor sobrepasa el nivel de umbral.
*/
const int analogPin = A0;
const int ledPin = 9;
const int threshold = 400;

// pin al cual se conectar el potencimetro


// pin al cual se conectar el LED
// un valor de umbral

void setup() {
// inicializa el pin del LED como pin de salida
pinMode(ledPin, OUTPUT);
// inicializacin de la comunicacin serial
Serial.begin(9600);
}
void loop() {
// lectura del valor del potencimetro
int analogValue = analogRead(analogPin);
// si el valor analgico es suficientemente alto se prende el LED:
if (analogValue > threshold) {
digitalWrite(ledPin, HIGH);
}
else {
digitalWrite(ledPin,LOW);
}
// imprime el valor analgico
Serial.println(analogValue);
delay(1);
// retraso entre lecturas para estabilizar
}

Piano usando Pulsadores

En este proyecto, se usa siete pulsadores que simulan el comportamiento de un piano en donde cada pulsador esta asociado a una nota musical bsica (DO, RE, MI, FA, SOL, LA, SI). Es
as que al presionan un pulsador se emite el sonido de la nota musical asociada a esa pulsador.

Hardware Requerido

Arduino UNO
Protoboard
7 Pulsadores
Parlante
7 resistencias de 10K

1 resistencia 100

Circuito

Reproduciremos los sonidos de las notas musicales bsicas, como se ve en la figura se tiene 7 pulsadores, los cuales corresponden a 7 "teclas", cada una asociada a una nota bsica.
El programa se encargar de revisar el estado de cada pulsador, si encuentra que el estado de algun pulsador esta activo(se presiono) entonces emitir la nota asociada al pulsador
presionado.
Se debe tener en cuenta que mientras se emite el sonido de alguna nota, el programa no realiza nada ms. As mismo, cuando se analisis el estado de los pulsadores, esto se realiza
de manera secuencial, con lo cual si se presiona dos o ms pulsadores al mismo tiempo, solo se emitira el sonido de una sola nota.
NOTA: Como se puede ver en la figura se hace uso del pin 0 o pin RX, dicho pin es usado por Arduino al momento de programar, por lo tanto si hacemos todas las conexiones y le
damos a programar, nos aparecer un error. Por tal motivo, al momento que se va programar se debera desconectar la conexion que tiene el pin 0(pin RX). Despues se conecta
normalmente.

Esquemtico

Cdigo:
/*
PIANO usando pulsadores
*/
// se
// se
const
const
const
const
const
const
const

definen las constantes


declaran las frecuencia de las notas bsicas
int NOTA_DO = 262;
int NOTA_RE = 294;
int NOTA_MI = 330;
int NOTA_FA = 349;
int NOTA_SOL = 392;
int NOTA_LA = 440;
int NOTA_SI = 494;

// se
const
const
const
const
const
const
const

declaran los pines


int pulsador_DO =
int pulsador_RE =
int pulsador_MI =
int pulsador_FA =
int pulsador_SOL =
int pulsador_LA =
int pulsador_SI =

asociados a las notas bsicas


8;
7;
6;
5;
4;
3;
2;

// se define las notas que se reproducirn


int notas_basicas[ ] = {NOTA_DO, NOTA_RE, NOTA_MI, NOTA_FA, NOTA_SOL, NOTA_LA, NOTA_SI};
int pulsadores
[ ] = {pulsador_DO, pulsador_RE, pulsador_MI, pulsador_FA,
pulsador_SOL, pulsador_LA, pulsador_SI};
int pulsador_activado = 0;
void setup() {
// se define los pines de entrada y salida
for(int pin=6; pin>0; pin--) {
pinMode(pulsadores[pin] , INPUT);
}
}
void loop() {
int pulsador_actual; // se declara como variable local
// el bucle analiza el estado de los 7 pulsadores
for (int pulsador=0; pulsador<7; pulsador++) {
pulsador_actual = digitalRead(pulsadores[pulsador]); // se lee el estado del pulsador
// si se presiono, se procede a reproducir la nota asociada
if (pulsador_actual == HIGH) {
tone(13, notas_basicas[pulsador]); // reproduce la nota
// grabamos el pulsador que ha sido apretado
pulsador_activado = pulsadores[pulsador];
break;

}
}
// su soltamos el pulsador activo apagamos cortamos el sonido
if (digitalRead(pulsador_activado) == LOW) {
noTone(13);
}
}

Sentencia for loop

A menudo se desea iterar sobre una serie de pines y hacer algo para cada uno. Por ejemplo, este ejemplo hace parpadear 5 LEDs conectados alArduino utilizando la sentencia: for
() loop para modificar la salida desde el pin 2 al pin 6. Los LED se enciende y se apaga, en secuencia, utilizando tanto las funciones de delay() y digitalWrite().

Hardware Requerido

Tarjeta Arduino
Cinco resistencias (220 ohm)
Seis LEDs
Protoboard

Circuito

Esquemtico

Cdigo:
/*
Bucle de iteracin
Muestra el uso de: for() loop.
Prende multiples LEDs en secuencia de una direccion a otra y viceversa
El siguiente cdigo utiliza un for () loop para asignar
los pines 2-6 como salida, las cuales iran conectadas a los 5 LEDs utilizados.
Una vez que se encendi el ultimo LED, este se apaga y se prende el LED anterior
esto continua de forma continua hasta llegar primer LED, donde se inicia el ciclo
*/
// define el tiempo entre el cambio de nivel de voltaje (ms)
int tiempo = 100;
void setup() {
// usa la sentencia loop para declarar los pines como pines de salida
for (int pin = 2; pin <= 6; pin++)
{
pinMode(pin, OUTPUT);
}
}
void loop()
{
// bucle
for (int pin = 2; pin <= 6; pin++)
{
// prende el LED:
digitalWrite(pin, HIGH);
delay(tiempo);
// apaga el LED:
digitalWrite(pin, LOW);
}
// bucle
for (int pin = 6; pin >= 2; pin--)
{
// prende LED
digitalWrite(pin, HIGH);
delay(tiempo);
// apaga el LED
digitalWrite(pin, LOW);
}
}

Arduino Analgico: Cambio de brillo en un


LED

Demuestra el uso de una salida analgica (PWM) para atenuar el brillo de un LED. PWM es una tcnica para conseguir un comportamiento similar a la analgica en una salida digital
apagndolo y prendindolo muy rpido.

Hardware Requerido

Tarjeta Arduino
LED
Resistencia (220 ohm)
Protoboard

Circuito

El primer paso es conectar el nodo (la pata mas larga, la pata positiva) del LED a la resistencia y del otro extremo de la resistencia hacia el pin 9 de la tarjeta Arduino. Luego conectar
el ctodo (la pata mas corta, la pata negativa) directamente a tierra.

Esquemtico

Cdigo:
/*
Atenuacin
Este ejemplo muestra como atenuar el brillo un LED usando la funcin analogWrite().
*/
int ledPin = 9;

// el LED conectado al pin digital 9

void setup() {
// nada pasa en la funcin setup()
}
void loop() {
// cambia el brillo desde el mnimo al mximo, incrementando de 5 en 5:
for(int fadeValue = 0 ; fadeValue <= 255; fadeValue +=5) {
analogWrite(ledPin, fadeValue);
// espera por 30 milisegundos para distingir el efecto de cambio
delay(30);
}
// cambia el brillo desde el mximo al mnimo, disminuyendo de 5 en 5:
for(int fadeValue = 255 ; fadeValue >= 0; fadeValue -=5) {
analogWrite(ledPin, fadeValue);
// espera por 30 milisegundos para distingir el efecto de cambio
delay(30);
}
}

Sentencia: Switch Case

Una sentencia if le permite elegir entre dos opciones diferenciadas, verdadero o falso. Cuando hay ms de dos opciones, puede utilizar mltiplessentencias if, o puede utilizar la
sentencia switch. la sentencia switch permite elegir entre varias opciones discretas. En este ejemplo se muestra cmo usarlo para cambiar entre cuatro estados deseados de una
fotoresistencia: muy
oscuro,
oscuro,
medio
y brillante.
Este programa lee primero la fotorresistencia. A continuacin, utiliza el mapa () para mapear su salida a uno de cuatro valores: 0, 1, 2, o 3. Por ltimo,se utiliza la sentencia
switch() para imprimir uno de los cuatro mensajes de vuelta al ordenador, dependiendo de cul de los cuatro valores se devuelve.

Hardware Requerido
Arduino UNO
Protoboard
Fotoresistencia
Resistencia de 10K

Circuito

Esquemtico

Cdigo:
/*
Sentencia Switch
Demuestra el uso de la sentencia Switch. La sentencia Switch
permite elegir entre un numero de valores discretos. Esto es como
una serie de sentencias if.
*/
// Declaracin de sentencias
// la mxima y mnima lectura que se obtiene del sensor:
const int sensorMin = 0;
const int sensorMax = 600;
void setup() {
// inicializa la comunicacin serial:
Serial.begin(9600);
}
void loop() {
// Lectura del sensor
int sensorReading = analogRead(A0);
int range = map(sensorReading, sensorMin, sensorMax, 0, 3);
// dependiendo del valor de range realiza una determinada accin
switch (range) {
case 0:
// una mano esta sobre el sensor
Serial.println("dark");
break;
case 1:
// una mano esta cerca del sensor
Serial.println("dim");
break;
case 2:
// una mano esta un poco alejada del sensor
Serial.println("medium");
break;
case 3:
// una mano no esta cersa del sensor
Serial.println("bright");
break;
}
delay(1);
// retraso entre lecturas para la estabilidad
}

Sentencia While Loop

A veces quieres que todo el programa se detenga mientras una condicin dada es verdadera. Usted puede hacer esto utilizando un while loop. En este ejemplo se muestra cmo
utilizar un while
loop para
calibrar el
valor
de un
sensor
analgico*.
En el loop principal, el siguiente esquema se lee el valor de una fotorresistencia el pin 0 analgico y lo utiliza para desaparecer un LED en el pin 9.Pero mientras se presiona un
botn conectado al pin digital 2, el programa se ejecuta un mtodo llamado calibrar () que busca los valores ms altos y ms bajos del sensor analgico. Al soltar el botn, el
dibujo contina
con el
bucle
principal.
Esta

tcnica le

permite

actualizar los

valores

mximos y

mnimos

de la fotorresistencia cuando las

condiciones

de

ilumina.

*NOTA: Un sensor analgico es aquel que, como salida, emite una seal comprendida por un campo de valores instantneos que varan en el tiempo, y son proporcionales a los
efectos que se estn midiendo.

Hardware Requerido

Tarjeta Arduino
Pulsador
Fotoresistencia
LED
Dos resistencias (10k ohm)
Resistencia (220 ohm)
Protoboard

Circuito

Esquemtico

Cdigo:
/*
Condicional - Sentencia While
Este ejemplo muestra el uso de la sentencia while()
Mientras el pulsador es presionado, la rutina de calibracin es corrida.
La lectura del sensor durante el while loop define el los valores mximo y
mnimos esperados de la fotoresistencia.
Esta es una variacin del ejemplo de calibracin
*/
const
const
const
const

int
int
int
int

sensorPin = A2;
//
ledPin = 9;
//
indicatorLedPin = 13; //
buttonPin = 2;
//

int sensorMin = 1023;


int sensorMax = 0;
int sensorValue = 0;

pin
pin
pin
pin

that
that
that
that

the
the
the
the

sensor is attached to
LED is attached to
built-in LED is attached to
button is attached to

// mnimo valor del sensor


// mximo valor del sensor
// el valor del sensor

void setup() {
// set the LED pins as outputs and the switch pin as input:
pinMode(indicatorLedPin, OUTPUT);
pinMode (ledPin, OUTPUT);
pinMode (buttonPin, INPUT);
}
void loop() {
// while the button is pressed, take calibration readings:
while (digitalRead(buttonPin) == HIGH) {
calibrate();
}
// seal de termino del periodo de calibracin
digitalWrite(indicatorLedPin, LOW);
// lectura del sensor:
sensorValue = analogRead(sensorPin);
// aplica la calibracin a la lectura del sensor
sensorValue = map(sensorValue, sensorMin, sensorMax, 0, 255);
sensorValue = constrain(sensorValue, 0, 255);
// Atenua el brillo del LED usando el valor de calibracin:
analogWrite(ledPin, sensorValue);
}
void calibrate() {
// prende el LED para indicar que la calibracin esta sucediendo:
digitalWrite(indicatorLedPin, HIGH);
// lectura del sensor:
sensorValue = analogRead(sensorPin);
// almacena el mximo valor del sensor
if (sensorValue > sensorMax) {
sensorMax = sensorValue;
}
// almacena el mnimo valor del sensor
if (sensorValue < sensorMin) {
sensorMin = sensorValue;
}
}

Deteccin de una Interrupcin usando


receptor LDR

En este proyecto se prende un LED cada vez que existe una interrupcin entre una fotoresistencia y un lser.

Hardware Requerido

Tarjeta Arduino
Fotoresistencia
Resistencia (10K ohm)
Resistencia (220 ohm)
LED
Lser
Protoboard

Circuito

El diodo lser es un dispositivo semiconductor que bajo condiciones adecuadas emite luz lser. La idea bsica de un diodo lser consiste en usar una cmara resonante con espejos
que refuerza la emisin de ondas luminosas a la misma frecuencia y fase. A causa de esta resonancia, un diodo lser produce un haz de luz estrecho que es muy intenso, enfocado y
puro.
Pero, cual es la diferencia entre un Diodo LED y un Diodo Lser?

LASER

LED

*Ms rpido

*Mayor estabilidad trmica

*Potencia de salida mayor

*Menor potencia de salida, mayor


tiempo de vida

*Emisin coherente de luz

*Emisin incoherente

*Construccin es ms
compleja

*Mas econmico

*Actan como fuente s


adecuadas en sistemas de
telecomunicaciones

*Se acoplan a fibras pticas en


distancias cortas de transmisin

*Modulacin a altas
velocidades, hasta GHz

*Velocidad de modulacin hasta


200MHz

Tambien en el lser, la emisin de luz es dirigida en una sola direccin.

Un LDR es un resistor que vara su valor de resistencia elctrica


dependiendo de la cantidad de luz que incide sobre l. Se le llama,
tambin, fotorresistor o fotorresistencia. El valor de resistencia
elctrica de un LDR es bajo cuando hay luz incidiendo en l (en
algunos casos puede descender a tan bajo como 50 ohms) y muy alto
cuando est a oscuras (puede ser de varios megaohms).
Para el correcto funcionamiento del proyecto, se recomienda tener el laser apuntando directamente a la fotoresistencia, antes de correr el programa. Despues de correr el programa,
tan solo basta con bloquear la luz proveniente del lser, en este caso el LED se prender, mientras el sensor infrarrojo recepcione la luz proveniente del diodo lser el LED permanece
apagado.

Esquemtico

Cdigo:
const int ledPin = 2;
float sensorValue = 0;

// se define el pin de salida(LED)


// variable que almacena el valor del sensor infrarrojo

void setup() {
Serial.begin(9600);
pinMode(ledPin, OUTPUT);
}
void loop(){
sensorValue = analogRead(A0); // se lee el valor del sensor
float voltaje = sensorValue * (5.0 / 1023.0); // se escala a un rango de 0-5V
Serial.println(voltaje);
// analiza si el laser se encuentra proyectado sobre el LDR
if (voltaje > 3.5) {
// Este valor(3.5) es referencial, dado que puede cambiar segun la distancia del laser al sensor LDR,
// se recomienda usar varia el valor, segun los datos del serial monitor
digitalWrite(ledPin, LOW); // de serlo asi se mantiene apagado el LED
}
else {
digitalWrite(ledPin, HIGH); // de lo contrario se prende el LED
}
}

Movimiento de Luces con control de


Velocidad

En ste tutorial podrs aprender cmo mover la luz entre varios leds al estilo del auto fantstico. La velocidad la podemos controlar con el potencimetro. Si giramos el
potencimetro en sentido horario la velocidad de desplazamiento aumentar y si lo giramos en sentido antihorario disminuir.
Para lograrlo utilizamos la estructura switch - case que circula por los diferentes estados en que cada led est encendido. Luego hacemos una pausa por un tiempo que depende de la
lectura del potencimetro. En ste caso estamos usando la frmula tiempo=(valorPot/2)+25 con la que obtenemos un rango de tiempo entre medio segundo y 25 milisengundos de
espera antes de pasar al siguiente estado.

Hardware Requerido
Arduino Uno
Protoboard
5 Leds
5 Resistencias de 220
1 Potencimetro de 5K

Circuito

Esquemtico

Cdigo:
/*
Movimiento de Luces con Control de Velocidad
Con este programa la luz se va moviendo por los leds al estilo del auto
fantastico. La velocidad del movimiento la podemos controlar girando el
potenciometro.
*/
// Le damos nombre a los pines del arduino para poder entender mejor
// su funcion en el programa:
int led1 = 3;
int led2 = 5;
int led3 = 6;
int led4 = 9;
int led5 = 10;
int pinPot = A0; // pin donde leemos el valor del potenciometro
// Variables
int valorPot = 0; // aca almacenamos el valor del potenciometro
int tiempo = 0;
int estado = 1;
void setup() {
// inicializamos los pines de los leds como salidas
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
pinMode(led5, OUTPUT);
// asignamos los valores iniciales a los leds (apagados)
digitalWrite(led1, LOW);
digitalWrite(led2, LOW);
digitalWrite(led3, LOW);
digitalWrite(led4, LOW);
digitalWrite(led5, LOW);
}
void loop() {
// Leemos el valor del potenciometro y lo alamacenamos
valorPot = analogRead(pinPot); // va de 0 a 1023
// Calculamos el tiempo en milisegundos en base al valor del
// potenciometro de modo que el tiempo entre estados sea como
// maximo alrededor de medio segundo y como minimo 25 milisegundos.
tiempo = ( valorPot / 2 ) + 25;
// Evaluamos el estado en el que nos encontramos (que led debe estar
// encendido)
switch(estado) {
case 1:
digitalWrite(led4, LOW);
digitalWrite(led5, HIGH);
break;

case 2:
digitalWrite(led4,
digitalWrite(led5,
break;
case 3:
digitalWrite(led3,
digitalWrite(led4,
break;
case 4:
digitalWrite(led2,
digitalWrite(led3,
break;
case 5:
digitalWrite(led1,
digitalWrite(led2,
break;
case 6:
digitalWrite(led1,
digitalWrite(led2,
break;
case 7:
digitalWrite(led2,
digitalWrite(led3,
break;
case 8:
digitalWrite(led3,
digitalWrite(led4,
break;

HIGH);
LOW);
HIGH);
LOW);
HIGH);
LOW);
HIGH);
LOW);
LOW);
HIGH);
LOW);
HIGH);
LOW);
HIGH);

}
// evaluamos si llegamos al estado final
if ( estado == 8 ) {
// pasamos al estado 1
estado = 1;
} else {
// pasamos al siguiente estado
estado = estado + 1;
}
// esperamos el tiempo que va a estar encendido un led
delay(tiempo);
}

Alarma de movimiento

En este tutorial se implementar una alarma de movimiento usando un


PIR(Sensor Infrarrojo Pasivo).
Usaremos tambin un led y un speaker que servirn como seal de una
deteccin y un botn de parada para detener la alarma.
Cuando el sensor detecte un objeto, se encender el led y sonar el speaker
para avisar que se ha detectado un objeto dentro de la zona de sensado. La
alarma seguir sonando hasta que se pulse el botn de parada.
Despus de pulsar el botn, se apagar el led y la alarma continuar con el
sensado.
Hardware Requerido

Un sensor PIR
Un pulsador
Una resistencia de 10K
Un led
Una resistencia de 220
Un speaker
Una resistencia de 100
Protoboard
Arduino UNO

Cables

Como se muestra en la figura, conectaremos el PIR en el pin digital 9, el pulsador en el pin 8, el led en el pin 7 y el speaker en el pin 6.

Circuito

Esquemtico

Cdigo:
int pirEstado = 0;
int
int
int
int

// estado del sensor

pinPir = 9;
// pin del sensor
botonPin = 8; // pin del pulsador
ledPin = 7;
// pin del LED
pinSpeaker = 6; //pin del speaker

int botonEstado = 0;

// estado del pulsador

void setup(){
Serial.begin(9600);
pinMode(pinPir, INPUT);
pinMode(ledPin, OUTPUT);
pinMode(botonPin, INPUT);
digitalWrite(pinPir, LOW); // se inicializa el PIR y el LED
digitalWrite(ledPin, LOW);
Serial.print("Calibrando sensor ");
for(int i = 0; i < 10; i++){
Serial.print(".");
// se espera aproximadamente 10
delay(1000);
// segundos para la calibracion
}
Serial.println(" Listo");
Serial.println("SENSOR ACTIVADO");
delay(50);
}
void loop(){
pirEstado = digitalRead(pinPir); //se lee el estado del pir
if (pirEstado == HIGH) {
// si el sensor detecto movimiento
digitalWrite(ledPin, HIGH); // se prende el led y se emite un
tone(6, 400);
// sonido por el speaker
}
botonEstado = digitalRead(botonPin);
if(botonEstado == HIGH){
// si se pulsa el boton
digitalWrite(ledPin, LOW); // se apaga el led y se deja de
noTone(6);
// emitir sonido por el speaker
}
}

Arduino Comunicacin: Comando switch

Una sentencia if le permite elegir entre dos opciones diferenciadas, verdadero o falso. Cuando hay ms de dos opciones, puede utilizar mltiplessentencias if, o puede utilizar la
sentencia
switch. La
sentencia
switch permite
elegir entre varias
opciones discretas.
En este tutorial se muestra cmo utilizar la sentencia switch para encender uno de varios LEDs diferentes basados en un byte de datos recibidos en serie.

Hardware Requerido

Tarjeta Arduino
Cinco LEDs
Cinco resistencias (220 ohm)
Protoboard

Circuito

Los cinco LEDs son conectados a los pines digitales 2, 3, 4, 5, y 6 en series con las resistencias.

Esquemtico

Cdigo:
/*
Comando Switch con entrada serial
Demuestra el uso del comando switch. El comando switch permite
escoger de un numero opciones el valor discreto de una variable.
Esto es como un serie de comandos if.
Para ver los resultados, abrir el Serial Monitor y enviar cualquier caracter.
Los caracteres a, b, c, d y e, prenderan los LEDs. Cualquier otro caracter
apagara los LEDs
*/
void setup() {
// inicializacion de comunicacion serial:
Serial.begin(9600);
// inicializa los pines de los LEDs:
for (int thisPin = 2; thisPin < 7; thisPin++) {
pinMode(thisPin, OUTPUT);
}
}
void loop() {
// lectura del sensor
if (Serial.available() > 0) {
int inByte = Serial.read();
switch (inByte) {
case 'a':
digitalWrite(2, HIGH);
break;
case 'b':
digitalWrite(3, HIGH);
break;
case 'c':
digitalWrite(4, HIGH);
break;
case 'd':
digitalWrite(5, HIGH);
break;
case 'e':
digitalWrite(6, HIGH);
break;
default:
// apaga los LEDs:
for (int thisPin = 2; thisPin < 7; thisPin++) {
digitalWrite(thisPin, LOW);
}
}
}
}

Arreglos

Una matriz o un arreglo es una variable con mltiples partes. Si se piensa en una variable como un vaso que contiene un cubo de hielo, es posiblepensar en una matriz como una
bandeja
de
cubitos de
hielo.
Este tutorial se muestra cmo se puede activar una secuencia de pines cuyos nmeros no son ni contiguos ni necesariamente secuencial. Para hacer esto es que usted puede poner
los nmeros de pin en una matriz y luego usar for loop para iterar sobre el conjunto. Usamos 5 LEDs conectados a los pines 2-6 en el tablero utilizando resistencias 220 Ohm, al igual
que
en el
for
loop. Sin
embargo, aqu el
orden de
los
LEDs se
determina por su
orden
en la
matriz, no
por
su orden
fsico.
Esta tcnica de poner los alfileres en una matriz es muy prctico. Usted no tiene que tener los pines secuenciales entre s, o incluso en el mismo orden. Puede reorganizar como
quieras.

Hardware Requerido
Arduino UNO
Protoboard
5 resistencia 220
6 LEDs

Circuito

Esquemtico

Cdigo:
/*
Arreglos
A diferencia de la sentencia for loop, donde los pines tienen que ser contiguos,
aqu los pines pueden estar en cualquier orden.
*/
int tiempo = 100;
int ledPines[] = { 2, 4, 6, 5, 3 };
int pin_contador = 5; // el numero de pines (el tamao del arreglo)
void setup() {
// los elementos del arreglo son nmeros desde 0 a (pin_contador - 1).
// usa el for loop para inicializar cada pin como pin de salida:
for (int pin = 0; pin < pin_contador; pin++) {
pinMode(ledPines[pin], OUTPUT);
}
}
void loop() {
// bucle desde el primer pin de la lista al ultimo
for (int pin = 0; pin < pin_contador; pin++) {
// prende el LED:
digitalWrite(ledPines[pin], HIGH);
delay(tiempo);
// apaga el LED:
digitalWrite(ledPines[pin], LOW);
}
// bucle desde el ultimo pin de la lista al primero
for (int pin = pin_contador - 1; pin >= 0; pin--) {
// prende el LED:
digitalWrite(ledPines[pin], HIGH);
delay(tiempo);
// apaga el LED:
digitalWrite(ledPines[pin], LOW);
}
}

Arduino Comunicacin: Mezcla virtual de


colores

Este ejemplo muestra cmo enviar mltiples valores de la tarjeta Arduino al ordenador. Las lecturas de tres potencimetros se utilizan para ajustarlos componentes rojo, verde y
azul del color de fondo de un dibujo de procesamiento o parche Max / MSP.

Hardware Requerido

Tarjeta Arduino
Tres potencimetros
Protoboard

Software Requerido

Processing o
Max/MSP verison 5

Circuito

Esquemtico

Cdigo:
/*
En este ejemplo se lee tres sensores analgicos (potencimetros)
y envia sus valores serialmente. El programa en processing toma los valores
y los usa para cambiar el color del fondo de la pantalla.
Los valores de los sensores se envan desde el Arduino al ordenador como nmeros decimales codificados en ASCII. Esto significa que cada
nmero se enva utilizando los caracteres ASCII "0" al "9". Para el valor "234", por ejemplo, se envan tres bytes: ASCII "2" (valor binario
50), ASCII "3" (valor binario 51) y ASCII "4" (valor binario 52).
*/
const int redPin = A0;
const int greenPin = A1;
const int bluePin = A2;

// sensor para controlar el color rojo


// sensor para controlar el color verde
// sensor para controlar el color azul

void setup()
{
Serial.begin(9600);
}
void loop()
{
Serial.print(analogRead(redPin));
Serial.print(",");
Serial.print(analogRead(greenPin));
Serial.print(",");
Serial.println(analogRead(bluePin));
}
//Cdigo en Processing
import processing.serial.*;
float redValue = 0;
float greenValue = 0;
float blueValue = 0;

// valor de color rojo


// valor de color verde
// valor de color azul

Serial myPort;
void setup() {
size(200, 200);
// Lista todo los puertos seriales disponibles
println(Serial.list());
myPort = new Serial(this, Serial.list()[0], 9600);
myPort.bufferUntil('\n');
}
void draw() {
// configura el color del fondo con los valores de los colores
background(redValue, greenValue, blueValue);
}
void serialEvent(Serial myPort) {
// obtiene una cadena ASCII:
String inString = myPort.readStringUntil('\n');
if (inString != null) {
// se quita los espacios en blanco
inString = trim(inString);

// Dividir la cadena en las comas y convertir el


// resultado subcadenas en una matriz de enteros:
float[] colors = float(split(inString, ","));
if (colors.length >=3) {
// mapea en un rango de 0-255:
redValue = map(colors[0], 0, 1023, 0, 255);
greenValue = map(colors[1], 0, 1023, 0, 255);
blueValue = map(colors[2], 0, 1023, 0, 255);
}
}
}

Mover Posicin de LED Encendido con


Potencimetro

Con este tutorial podrs cambiar el led encendido al girar un potenciometro que leemos por una entrada analgica. Cuando el potencimetro est completamente girado en sentido
horario, el led1 (que est al extremo derecho) estar encendido. Cuando el potencimetro est completamente girado en sentido antihorario, el led5 (que est al extremo izquierdo)
estat encendido. Del mismo modo en las posiciones intermedias del potencimetro los leds intermedios se encendern segn corresponda.
El rango de lectura de la entrada analgica es de 0 a 1023 por los que dividimos ese rango en cinco rangos que concidan con los leds segn su posicin. Entonces tendremos los
siguientes rangos:

Valor
Inicial

Valor
Final

LED

205

led1

206

409

led2

410

614

led3

615

818

led4

819

1023

led5

En el programa utilizaremos una estructura if - else para encender el led correspondiente en donde iremos comparando en base al valor final para diferenciar los rangos. cada valor
final define el rango inmediato superior. La comparacin se iniciar a partir del valor final del led4 y bajar hasta el del led1.

Hardware Requerido
Arduino Uno
Protoboard
5 Leds
5 Resistencias de 220
1 Potencimetro de 5K

Circuito

Esquemtico

Cdigo:
/*
Cambiar Posicion de Led Encendido con Potenciometro
Con este programa podras cambiar el led encendido segun el valor del
potenciometro que leemos por una entrada analogica. El rango de lectura
es de 0 a 1023 por los que dividimos ese rango en cinco rangos que concidan
con los leds segun su posicion.
*/
// Le damos nombre a los pines del arduino para poder entender mejor
// su funcion en el programa:
int led1 = 3;
int led2 = 5;
int led3 = 6;
int led4 = 9;
int led5 = 10;
int pinPot = A0; // pin donde leemos el valor del potenciometro
// Variables
int valorPot = 0; // aca almacenamos el valor del potenciometro
void setup() {
// inicializamos los pines de los leds como salidas
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
pinMode(led3, OUTPUT);
pinMode(led4, OUTPUT);
pinMode(led5, OUTPUT);
}
void loop() {
// Leemos el valor del potenciometro y lo alamacenamos para comparar
// el valor mas adelante
valorPot = analogRead(pinPot);
// comparamos con los valores de los rangos para cada led.
if( valorPot > 818 ){ // rango led5 : 819 - 1023
digitalWrite(led1, LOW);
digitalWrite(led2, LOW);
digitalWrite(led3, LOW);
digitalWrite(led4, LOW);
digitalWrite(led5, HIGH);
} else if( valorPot > 614 ){ // rango led4 : 615 - 818
digitalWrite(led1, LOW);
digitalWrite(led2, LOW);
digitalWrite(led3, LOW);
digitalWrite(led4, HIGH);
digitalWrite(led5, LOW);
} else if( valorPot > 409 ){ // rango led3 : 410 - 614
digitalWrite(led1, LOW);
digitalWrite(led2, LOW);
digitalWrite(led3, HIGH);

digitalWrite(led4, LOW);
digitalWrite(led5, LOW);
} else if( valorPot > 205 ){ // rango led2 : 206 - 409
digitalWrite(led1, LOW);
digitalWrite(led2, HIGH);
digitalWrite(led3, LOW);
digitalWrite(led4, LOW);
digitalWrite(led5, LOW);
} else { // rango led1 : 0 - 205
digitalWrite(led1, HIGH);
digitalWrite(led2, LOW);
digitalWrite(led3, LOW);
digitalWrite(led4, LOW);
digitalWrite(led5, LOW);
}
}

Deteccin de movimiento con PIR

En este tutorial se implementar un circuito detector de movimiento, en el


cual usaremos un sensor PIR(Sensor Infrarrojo Pasivo).
Los sensores de movimientos PIR no emiten ninguna seal, por eso se les
denomina sensor pasivo. Cuando un objeto tiene una temperatura diferente a
la del medio y se encuentra dentro del campo de captacin del sensor, la
radiacin calrica del objeto ser captada por los lentes del sensor e
inmediatamente este se acciona. Este sensor puede detectar todo cuerpo que
irradie calor. Los rayos infrarrojos que provienen de un objeto o un ser vivo
son detectados por el sensor mediante un sistema de lentes Fresnel o mediante
un espejo que contiene cristales piroelctricos.
Este sensor cuenta con dos potencimetros acoplados. El potencimetro Sx
nos sirve para ajustar el alcance de sensado y con el potencimetro Tx
podemos ajustar el tiempo de reaccin o tiempo de deteccin.
Estos sensores son empleados mayormente en alarmas, puertas automticas y
para el ahorro de energa.
Hardware Requerido

Un sensor PIR
Un led
Una resistencia de 220
Arduino UNO
Protoboard
Cables

Circuito

Esquemtico

En el uso de un PIR, se recomienda esperar un tiempo de 10 segundos antes


de empezar con el sensado para que se realice la calibracin del sensor.
Usaremos un led que nos indicar cuando se ha producido una deteccin. El
led se encender cuando se detecte algn objeto y se mostrar en el monitor
serial un mensaje de deteccin. Cuando el objeto se encuentre fuera de rango;
es decir, cuando ya no pueda ser detectado por el PIR, en el monitor serial se
mostrar un mensaje de fin de deteccin y se apagar el led.
Cdigo:
#include <Paruro7Seg.h>

// Libreria a usar para la visualizacion en display de 7 segmentos

// Se crea una instancia de la clase Paruro7Seg llamada Seg


// para llamar al constructor.
// El constructor usa la funcion configPin() por lo que pasamos los argumentos de esa funcion.
Paruro7Seg Seg(2, 3, 4); //
pines:
diplay de las unidades, decenas y centenas
int
int
int
int

pirEstado = 0;
pirEstadoAnterior = 0;
pinPir = 9;
// pin del sensor
botonPin = 8;

int botonEstado = 0;
float contador = 0;
void setup(){
Serial.begin(9600);

// cuenta el numero de detecciones, se inicia en cero

pinMode(pinPir, INPUT);
pinMode(botonPin, INPUT);
digitalWrite(pinPir, LOW); // se inicializa el PIR y el LED
Serial.print("Calibrando sensor ");
for(int i = 0; i < 10; i++){
Serial.print(".");
// se espera aproximadamente 10
delay(1000);
// segundos para la calibracion
}
Serial.println(" Listo");
Serial.println("SENSOR ACTIVADO");
}
void loop(){
pirEstado = digitalRead(pinPir);
// se lee el estado del PIR
if (pirEstado != pirEstadoAnterior) {
if (pirEstado == HIGH) {
// si el sensor detecto movimiento
contador = contador + 1;
// se incrementa la cuenta
pirEstadoAnterior = pirEstado;
// actualizo es estado del pir
}
else{
pirEstadoAnterior = pirEstado;
// actualizo es estado del pir
}
}
Seg.mostrar(contador);
// extrae los digitos del numero
Seg.refrescar();
// muestra los digitos en los 3 displays
// de 7 segmentos
botonEstado = digitalRead(botonPin);
if(botonEstado == HIGH){
// si se pulsa el boton, se inicializa
contador = 0;
// la cuenta de detecciones
}
}

You might also like