Combinaciones con botones

En este ejemplo tenemos 3 botones, y cada uno activa o desactiva una combinación de LEDs. Existen 3 combinaciones distintas, las cuales se pueden mezclar si pulsamos mas de un botón de los 3. Si tenemos activados dos botones, las combinaciones relacionadas con esos botones se activarán, primero una y luego otra.

El circuito lo montaremos de la siguiente manera:
LEDs conectados a los pines (digitales) 3, 5, 6, 9, 10 y 11
Botones conectados a los pines (digitales) 2, 8 y 12





//Pulsando los tres botones los LED se encenderán formando combinaciones diferentes

const int vectorLED[]={3,5,6,9,10,11};
const int boton1=2;
const int boton2=8;
const int boton3=12;

int contadorA=0;
int contadorB=0;
int contadorC=0;

int state1=0;
int state2=0;
int state3=0;
int lastState1=0;
int lastState2=0;
int lastState3=0;

int i=0;
int j=0;
int k=0;
int ultimoTiempo=0;
int tiempo=100;

void setup()
{
pinMode(boton1, INPUT);
pinMode(boton2, INPUT);
pinMode(boton3, INPUT);
for(i=0; i<6; i++)
{
pinMode(vectorLED[i], OUTPUT);
}
Serial.begin(9600);
}

void loop()
{
state3=digitalRead(boton3);
if(state3!=lastState3)
{
if(state3==HIGH)
{
contadorC++;
}
lastState3=state3;
}
state1=digitalRead(boton1);
if(state1!=lastState1)
{
if(state1==HIGH)
{
contadorA++;
}
lastState1=state1;
}
state2=digitalRead(boton2);
if(state2!=lastState2)
{
if(state2==HIGH)
{
contadorB++;
}
lastState2=state2;
}
if((contadorC%2)==0)
{
for(i=0; i<6; i++)
{
state3=digitalRead(boton3);
if(state3!=lastState3)
{
if(state3==HIGH)
{
contadorC++;
}
lastState3=state3;
}
if(millis()-ultimoTiempo>tiempo)
{
ultimoTiempo=millis();
analogWrite(vectorLED[i], 20);
delay(100);
}
}
for(i=0; i<6; i++)
{
state3=digitalRead(boton3);
if(state3!=lastState3)
{
if(state3==HIGH)
{
contadorC++;
}
lastState3=state3;
}
if(millis()-ultimoTiempo>tiempo)
{
ultimoTiempo=millis();
digitalWrite(vectorLED[i], LOW);;
delay(100);
}
}
}
else
{
for(i=0; i<6; i++)
{
digitalWrite(vectorLED[i], LOW);
}
}
if((contadorB%2)==0)
{
j=5;
for(i=0; i<3; i++)
{
state2=digitalRead(boton2);
if(state2!=lastState2)
{
if(state2==HIGH)
{
contadorB++;
}
lastState2=state2;
}
if(millis()-ultimoTiempo>tiempo)
{
ultimoTiempo=millis();
analogWrite(vectorLED[i], 20);
analogWrite(vectorLED[j], 20);
j--;
delay(100);
}
}
j=3;
for(i=2; i>=0; i--)
{
state2=digitalRead(boton2);
if(state2!=lastState2)
{
if(state2==HIGH)
{
contadorB++;
}
lastState2=state2;
}
if(millis()-ultimoTiempo>tiempo)
{
ultimoTiempo=millis();
digitalWrite(vectorLED[i], LOW);
digitalWrite(vectorLED[j], LOW);
j++;
delay(100);
}
}
}
else
{
for(i=0; i<6; i++)
{
digitalWrite(vectorLED[i], LOW);
}
}
if((contadorA%2)==0)
{
for(i=0; i<6; i++)
{
state1=digitalRead(boton1);
if(state1!=lastState1)
{
if(state1==HIGH)
{
contadorA++;
}
lastState1=state1;
}
if(millis()-ultimoTiempo>tiempo)
{
ultimoTiempo=millis();
analogWrite(vectorLED[i], 20);
if(i==2)
{
delay(500);
}
}
}
for(i=0; i<6; i++)
{
state1=digitalRead(boton1);
if(state1!=lastState1)
{
if(state1==HIGH)
{
contadorA++;
}
lastState1=state1;
}
if(millis()-ultimoTiempo>tiempo)
{
ultimoTiempo=millis();
analogWrite(vectorLED[i], 0);
if(i==2)
{
delay(500);
}
}
}
}
else
{
for(i=0; i<6; i++)
{
digitalWrite(vectorLED[i], LOW);
}
}
}

Receptor IR III

El siguiente programa controlará un timbre, un conjunto de LEDs y un LED RGB. Cada uno de estos tres 'módulos' será activado con un botón del mando a distancia.

Colocando el receptor IR mirando hacia nosotros:
1º pin del IR al pin 12 (digital)
2º pin del IR a ground
3º pin del IR a +5V

Los pines de la placa del 2 al 8 y el 13controlarán 6 LEDs
Los pines 9 y 10 serán para el LED tricolor
El timbre lo conectamos al pin 11





//Con un boton del mando activaremos el modo "coche fantastico"
//Con otro boton activaremos el LED tricolor, cada vez con tres colores diferentes
//Con otro activaremos una melodia en el timbre

#include "wprogram.h"
#include "necirrcv.h"
#define IRPIN 12
unsigned long ircode;

const int pinesLED[]={13,2,3,4,5,6,7,8};
const int pinRed=9;
const int pinGreen=10;
const int timbre=11;

int length=19;
char notes[]="cdegcdefCefgCabCebC";
int tempo=10;

int i=0;
int j=0;
int aux=0;
int contador1=0;

NECIRrcv ir(IRPIN);

void playTone(int tone, int duration)
{
for (long j=0; j<8; i++)
{
if (names[i] == note)
{
playTone(tones[i], duration);
}
}
}

void setup()
{
pinMode(IRPIN, INPUT);
for(i=0; i<8; i++)
{
pinMode(pinesLED[i], OUTPUT);
}
pinMode(pinRed, OUTPUT);
pinMode(pinGreen, OUTPUT);
pinMode(timbre, OUTPUT);
ir.begin();
}

void loop()
{
while (ir.available())
{
ircode=ir.read();
if(ircode==2724069120)
{
contador1++;
aux++;
}
}

if(ircode==2707357440)
{
for(i=0; i<8; i++)
{
digitalWrite(pinesLED[i], HIGH);
delay(100);
}
for(i=0; i<8; i++)
{
digitalWrite(pinesLED[i], LOW);
delay(100);
}
}
if(ircode==2724069120 && contador1%2==1)
{
if(aux%3==0)
{
analogWrite(pinGreen, 5);
analogWrite(pinRed, 20);
}
if(aux%3==1)
{
analogWrite(pinGreen, 25);
analogWrite(pinRed, 1);
}
if(aux%3==2)
{
analogWrite(pinGreen, 15);
analogWrite(pinRed, 15);
}
}
else
{
analogWrite(pinGreen, 0);
analogWrite(pinRed, 0);
}
if(ircode==3776904960)
{
playNote(notes[j], 50);
j++;
if(j==19)
{
j=0;
ircode=ir.read();
}
}
}

Receptor IR II

Cada LED corresponderá a un valor de los botones del mando a distancia numerados del 1 al 10. A cada pulsación se encenderá un único LED y se apagará el anterior.

El circuito lo implementaremos de la siguiente manera
Colocando el receptor IR mirando hacia nosotros:
1º pin del IR al pin 8 (digital)
2º pin del IR a ground
3º pin del IR a +5V

Los pines de la placa del 3 al 8 controlarán 6 LEDs
Los pines 9,10 y 11 serán para el LED tricolor




//Vamos a crear una serie de directivas cada vez que pulsemos alguna tecla de nuestro mando a distancia

#include "WProgram.h"
#include "NECIRrcv.h"
#define IRPIN 2//Pin de control del receptor IR
unsigned long ircode;
unsigned long a1=2;
unsigned long a2=2;
unsigned long a3=2;
unsigned long a4=2;
unsigned long a5=2;
unsigned long a6=2;
unsigned long a7=2;
unsigned long a8=2;
unsigned long a9=2;
unsigned long a10=2;

const int pinesLED[]={3,4,5,6,7,8};
const int pinRed=9;
const int pinGreen=10;
const int pinBlue=11;

int i=0;

NECIRrcv ir(IRPIN);

void setup()
{
pinMode(IRPIN, INPUT);
for(i=0; i<6; i++)
{
pinMode(pinesLED[i], OUTPUT);
}
pinMode(pinRed, OUTPUT);
pinMode(pinGreen, OUTPUT);
pinMode(pinBlue, OUTPUT);
ir.begin();
Serial.begin(9600);
}

void loop()
{
while (ir.available())
{
ircode=ir.read();
if(ircode==2707357440)
{
a1++;
}
if(ircode==2724069120)
{
a2++;
}
if(ircode==3776904960)
{
a3++;
}
if(ircode==3041591040)
{
a4++;
}
if(ircode==3058302720)
{
a5++;
}
if(ircode==4111138560)
{
a6++;
}
if(ircode==2774204160)
{
a7++;
}
if(ircode==2790915840)
{
a8++;
}
if(ircode==3843751680)
{
a9++;
}
if(ircode==2974744320)
{
a10++;
}
}

if((ircode==2707357440) && ((a1%2)==1))
{
analogWrite(pinRed, 10);
}
else
{
analogWrite(pinRed, 0);
}
if((ircode==2724069120) && ((a2%2)==1))
{
analogWrite(pinGreen, 10);
}
else
{
analogWrite(pinGreen, 0);
}
if((ircode==3776904960) && ((a3%2)==1))
{
digitalWrite(pinBlue, HIGH);
}
else
{
digitalWrite(pinBlue, LOW);
}
if((ircode==3041591040) && ((a4%2)==1))
{
digitalWrite(pinesLED[0], HIGH);
}
else
{
digitalWrite(pinesLED[0], LOW);
}
if((ircode==3058302720) && ((a5%2)==1))
{
digitalWrite(pinesLED[1], HIGH);
}
else
{
digitalWrite(pinesLED[1], LOW);
}
if((ircode==4111138560) && ((a6%2)==1))
{
digitalWrite(pinesLED[2], HIGH);
}
else
{
digitalWrite(pinesLED[2], LOW);
}
if((ircode==2774204160) && ((a7%2)==1))
{
digitalWrite(pinesLED[3], HIGH);
}
else
{
digitalWrite(pinesLED[3], LOW);
}
if((ircode==2790915840) && ((a8%2)==1))
{
digitalWrite(pinesLED[4], HIGH);
}
else
{
digitalWrite(pinesLED[4], LOW);
}
if((ircode==3843751680) && ((a9%2)==1))
{
digitalWrite(pinesLED[5], HIGH);
}
else
{
digitalWrite(pinesLED[5], LOW);
}
if((ircode==2974744320) && ((a10%2)==1))
{
digitalWrite(pinesLED[6], HIGH);
}
else
{
digitalWrite(pinesLED[6], LOW);
}
}

Receptor IR

Con el siguiente programa vamos a recoger el número decimal asociado a cada botón de un mando a distancia (TV). Dicho número lo veremos por el monitor serie cada vez que pulsemos un botón del mando a distancia.

Colocando el receptor IR mirando hacia nosotros:
1º pin del IR al pin 8 (digital)
2º pin del IR a ground
3º pin del IR a +5V



Es necesario incluir las librerías WPorgram y NECIRrvc. Esta segunda la podéis encontrar por la red, solo tenéis que copiar el código y meterlo a la carpeta libaries, si el IDE de arduino cuelga del disco C estará en el siguiente directorio:
C:\arduino-0017\hardware\libraries


//Pintamos por monitor serie los codigos en decimal
#include "WProgram.h"
#include "NECIRrcv.h"
#define IRPIN 8//Pin de control del receptor IR

NECIRrcv ir(IRPIN) ;
void setup()
{
pinMode(IRPIN, INPUT);
Serial.begin(9600) ;
Serial.println("NEC IR code reception") ;
ir.begin() ;
}

void loop()
{
unsigned long ircode ;
while (ir.available())
{
ircode = ir.read() ;
Serial.print("got code: ") ;
Serial.println(ircode) ;
}
}

Sensores IR III

En el siguiente programa tenemos 3 sensores infrarojos, y cada uno de ellos tiene control sobre dos LEDs. Cuando pasemos un objeto por delante de los sensores IR se encenderán los LEDs correspondientes.

El sistema lo implementaremos así:

Conectamos el emisor IR al pin 2
Conectamos el receptor IR a la entrada del pin analogico 3
Conectamos +5V al emisor IR
Conectamos -Ground al receptor

Conectamos el emisor IR al pin 3
Conectamos el receptor IR a la entrada del pin analogico 2
Conectamos +5V al emisor IR
Conectamos -Ground al receptor

Conectamos el emisor IR al pin 4
Conectamos el receptor IR a la entrada del pin analogico 1
Conectamos +5V al emisor IR
Conectamos -Ground al receptor

Conectamos pin 9 a los lados positivos de dos LEDs
Conectamos pin 10 a los lados positivos de dos LEDs
Conectamos pin 11 a los lados positivos de dos LEDs
Conectamos lado negativo de todos los LEDs a -Ground






const int sensorInfrarojo1=3;
const int sensorInfrarojo2=2;
const int sensorInfrarojo3=1;

const int pinLed1=9;
const int pinLed2=10;
const int pinLed3=11;

const int emisor1=2;
const int emisor2=3;
const int emisor3=4;

int sensorValorA=0;
int sensorValorB=0;
int sensorValorC=0;

void setup()
{
Serial.begin(9600);
pinMode(sensorInfrarojo1, INPUT);
pinMode(sensorInfrarojo2, INPUT);
pinMode(sensorInfrarojo3, INPUT);
pinMode(pinLed2, OUTPUT);
pinMode(pinLed3, OUTPUT);
pinMode(pinLed1, OUTPUT);
pinMode(emisor1, OUTPUT);
pinMode(emisor2, OUTPUT);
pinMode(emisor3, OUTPUT);
digitalWrite(emisor1, HIGH);//El emisor del sensor IR ha de estar siempre activo
digitalWrite(emisor2, HIGH);//El emisor del sensor IR ha de estar siempre activo
digitalWrite(emisor3, HIGH);//El emisor del sensor IR ha de estar siempre activo
}
//Los valores para calibrar la distancia del sensor IR dependen de cada sensor, siendo todos del mismo modelo cambian sus valores
//Segun trabajemos con luz natural o no las calibraciones son diferentes por la contaminacion de cualquier fuente de luz en el IR.
void loop()
{
sensorValorA=analogRead(sensorInfrarojo1);
sensorValorB=analogRead(sensorInfrarojo2);
sensorValorC=analogRead(sensorInfrarojo3);
Serial.print("1.- ");
Serial.print(sensorValorA);//Sacamos por el monitor serie los valores que recibimos del sensor IR
Serial.print("\n");//Hemos llegado a la conclusion que 912 es el valor crítico para el sensor con luz ambiente
Serial.print("2.- ");
Serial.print(sensorValorB);//Sacamos por el monitor serie los valores que recibimos del sensor IR
Serial.print("\n");//Hemos llegado a la conclusion que 895 es el valor crítico para el sensor con luz ambiente
Serial.print("3.- ");
Serial.print(sensorValorC);//Sacamos por el monitor serie los valores que recibimos del sensor IR
Serial.print("\n");//Hemos llegado a la conclusion que 877 es el valor crítico para el sensor con luz ambiente

if((sensorValorC)<877)
{
digitalWrite(pinLed3, HIGH);
}
else
{
digitalWrite(pinLed3, LOW);
}
if((sensorValorA)<912)
{
digitalWrite(pinLed1, HIGH);
}
else
{
digitalWrite(pinLed1, LOW);
}
if((sensorValorB)<895)
{
digitalWrite(pinLed2, HIGH);
}
else
{
digitalWrite(pinLed2, LOW);
}
}

Simulación coche fantástico

Vamos a crear una simulación del coche fantástico. Para ello utilizaremos diez LEDs colocados en linea, un timbre y un botón.
El programa comenzará a encender LEDs en orden y el timbre sonará cada vez que se enciendan y apaguen los 10 LEDs.
Con el botón haremos que se encienda y apague el sistema a como si de un interruptor se tratara.

El circuito lo implementaremos así:

Lado + de cada LED a los pines del 4 al 13 (digital)
Lado - de cada LED a ground

Lado + botón a +5V
Lado + botón al pin 2 (digital)
Lado - boton a ground

Lado + timbre a pin 3
Lado - timbre a ground





//Simularemos las luces del coche fantástico con 10 LEDs colocados en línea, mientras los LEDs estén encendidos haremos sonar el timbre.
const int pinesLed[]={4,5,6,7,8,9,10,11,12,13};
const int pinBoton=2;
const int speakerPin=3;

int aux=0;
int i=0;
int j=0;
int contadorBoton=0;
int lastState=0;
int state=0;

int ultimoTiempo=0;
int tiempo=690;
int ultimoTiempo2=0;
int tiempo2=40;

int length=19;
char notes[]="cdegcdefCefgCabCebC";

void playTone(int tone, int duration)
{
for (long j=0; j {
digitalWrite(speakerPin, HIGH);
delayMicroseconds(tone);
digitalWrite(speakerPin, LOW);
delayMicroseconds(tone);
}
}

void playNote(char note, int duration)
{
char names[]={ 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
int tones[]={1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };
for (i=0; i<8; i++)
{
if (names[i] == note)
{
playTone(tones[i], duration);
}
}
}

void setup()
{
for(i=0; i<10; i++)
{
pinMode(pinesLed[i], OUTPUT);
}
pinMode(pinBoton, INPUT);
pinMode(speakerPin, OUTPUT);
}

void loop()
{
if(contadorBoton%2==1)
{
while(contadorBoton%2==1)
{
j=0;
for(i=0; i<10; i++)
{
state=digitalRead(pinBoton);
if(state!=lastState)
{
if(state==HIGH)
{
contadorBoton++;
}
lastState=state;
}
if(millis()-ultimoTiempo>tiempo)//Cada 'tiempo' controlamos el valor del sensor
{
ultimoTiempo=millis();
playNote(notes[i], 10);
}
digitalWrite(pinesLed[j], HIGH);
j+=1;
delay(30);
}
j=0;
i=10;
for(i=10; i>=0; i--)
{
state=digitalRead(pinBoton);
if(state!=lastState)
{
if(state==HIGH)
{
contadorBoton++;
}
lastState=state;
}
if(millis()-ultimoTiempo>tiempo)//Cada 'tiempo' controlamos el valor del sensor
{
ultimoTiempo=millis();
playNote(notes[i], 10);
}
digitalWrite(pinesLed[j], LOW);
j+=1;
delay(30);
}
}
}
if(contadorBoton%2==0)
{
for(i=10; i>=0; i--)
{
digitalWrite(pinesLed[i], LOW);
}
}
}

Sensor IR II

Vamos a utilizar un único sensor de rayos infrarrojos para detectar objetos. Cuando el sistema solo está compuesto por un sensor de este tipo podemos calibrarlo y decidir a que 'distancia' queremos realizar una acción determinada. En el siguiente ejemplo el sensor esta calibrado con luz ambiente. (Cambian los valores según la incidencia de luz sobre el sensor IR)

El circuito lo implementaremos de la siguiente manera:

Conectamos el emisor IR al pin 2 (digital)
Conectamos el receptor IR a la entrada del pin 3 (analógico)
Conectamos +3V al emisor IR
Conectamos -Ground al receptor

Conectamos la parte positiva del LED al pin 9 (digital)
Conectamos el negativo del LED a ground





//A una distancia de 5cm encenderemos el LED

const int sensorInfrarojo=3;
const int pinLed=9;
const int emisor=2;

int sensorValor=0;

void setup()
{
Serial.begin(9600);
pinMode(sensorInfrarojo, INPUT);
pinMode(pinLed, OUTPUT);
pinMode(emisor, OUTPUT);
digitalWrite(emisor, HIGH);//El emisor del sensor IR ha de estar siempre activo
}

void loop()
{
sensorValor=analogRead(sensorInfrarojo);
Serial.print(sensorValor);//Sacamos por el monitor serie los valores que recibimos del sensor IR
Serial.print("\n");//Hemos llegado a la conclusion que 918 es el valor crítico para el sensor con luz ambiente
if((sensorValor)<918)//Aproximando un objeto a una distancia de 5 cm del sensor IR encendemos el LED
{
digitalWrite(pinLed, HIGH);
}
else
{
digitalWrite(pinLed, LOW);
}
}

Sensor IR

En el siguiente ejemplo vamos a comprobar el funcionamiento de un sensor de proximidad por infrarrojos (photo-reflective sensor). Está compuesto por un emisor y un receptor IR.

La intensidad del LED aumentará mientras mas próximo se encuentre un objeto del sensor IR. Este tipo de sensores solo nos dicen si hay un objeto presente o no. Cuando en el sistema solo tenemos un sensor de este tipo no hay problema, pero si lo habrá cuando el sistema se componga de varios sensores. Lo veremos más adelante..



Conectamos el emisor IR al pin 2 (digital)
Conectamos el receptor IR a la entrada del pin 3 (analógico)
Conectamos +5V al emisor IR
Conectamos -Ground al receptor

Conectamos la parte positiva del LED al pin 13 (digital)
Conectamos el negativo del LED a ground





//Regulamos la intesidad que emite un LED en funcion del rango que reciba el sensor IR

const int sensorInfrarojo=3;
const int pinLed=13;
const int emisor=2;

int sensorValor=0;
int contador=0;

void setup()
{
pinMode(sensorInfrarojo, INPUT);
pinMode(pinLed, OUTPUT);
pinMode(emisor, OUTPUT);
digitalWrite(emisor, HIGH);//El emisor del sensor IR ha de estar siempre activo
}

void loop()
{
sensorValor=analogRead(sensorInfrarojo);
analogWrite(pinLed, sensorValor/4);
}

Uso de vectores

En el siguiente ejemplo utilizaremos 10 LEDs y un botón. El conjunto de los 10 LEDs formarán parte de un vector que nos crearemos para poder controlarlos de forma mas cómoda.
El programa encenderá y apagará un LED por cada intervalo de tiempo. Cada vez que presionemos el botón los LEDs se encenderán o apagarán hasta el último, si en el momento que se están encendiendo volvemos a presionar el botón los LEDs que han quedado encendidos comenzarán a apagarse.

+ Botón al pin 2 (digital)
+ 5V al lado positivo del botón
- Boton a ground

+ Lado positivo LEDs a los pines 4,7,6,9,10,11,12,13,8 (digitales)
- Lado negativo LEDs a ground






const int pinesLed[10]={4,7,6,9,10,11,12,13,8};
const int pinBoton=2;

int aux=0;
int i=0;
int contadorBoton=0;
int lastState=0;
int state=0;

int ultimoTiempo=0;//Auxiliar para la comprobacion de tiempo
int tiempo=100;//Tiempo que hace cada comprobacion iterativamente

void setup()
{
for(i=0; i<10; i++)
{
pinMode(pinesLed[i], OUTPUT);
}
pinMode(pinBoton, INPUT);
}

void loop()
{
state=digitalRead(pinBoton);
if(state!=lastState)
{
if(state==HIGH)
{
contadorBoton++;
}
lastState=state;
}
if(contadorBoton%2==1)
{
for(i=0; i<10; i++)
{
if(millis()-ultimoTiempo>tiempo)//Cada 'tiempo' controlamos el valor del sensor
{
ultimoTiempo=millis();
digitalWrite(pinesLed[i], HIGH);
}
}
}
if(contadorBoton%2==0)
{
for(i=0; i<10; i++)
{
if(millis()-ultimoTiempo>tiempo)//Cada 'tiempo' controlamos el valor del sensor
{
ultimoTiempo=millis();
digitalWrite(pinesLed[i], LOW);
}
}
}
}

Control analógico con sensor de luz

El siguiente programa controla analógicamente la intensidad de un LED tricolor. Mientras menos luz ambiente detecte el sensor la intensidad del LED será mayor. Cuando haya mucha luz ambiente apagaremos el LED.
Con un botón podremos ir cambiando el color que generará el LED

El circuito lo implementaremos de la siguiente forma:

+ 1º pin LED tricolor al pin 9 (digital)
- 2º pin LED tricolor al pin a ground
+ 3º pin LED tricolor al pin 10 (digital)
+ 4º pin LED tricolor al pin 11 (digital)

+ Botón al pin 2 (digital)
+ 5V al lado positivo del botón
- Boton a ground

+ Sensor luz al pin 0 (analógico)
+ Sensor luz al +5V
- Sensor luz a ground






const int rojo=9;
const int verde=10;
const int azul=11;

const int boton=2;
int contadorBoton=0;
int state=0;
int lastState=0;

const int sensorLuz=0;
int sensorValor=0;
int sensorMax=0;
int sensorMin=1026;

void setup()
{
pinMode(boton,INPUT);
pinMode(sensorLuz,INPUT);
pinMode(rojo,OUTPUT);
pinMode(verde,OUTPUT);
pinMode(azul,OUTPUT);
digitalWrite(13, HIGH);//Durante los 5 primeros segundos encendemos el LED de la placa mientras hace operaciones
while(millis()<5000)//Da valores maximos y minimos a al sensor de luz
{
sensorValor=analogRead(sensorLuz);
if(sensorValor>sensorMax)
{
sensorMax=sensorValor;
}
if (sensorValor {
sensorMin=sensorValor;
}
}
digitalWrite(13, LOW);//Apagamos el LED de la placa
}

void loop()
{
state=digitalRead(boton);
if(state!=lastState)
{
if(state==HIGH)
{
contadorBoton++;
}
lastState=state;
}
sensorValor=analogRead(sensorLuz);
sensorValor=map(sensorValor, sensorMin, sensorMax, 0, 255);
sensorValor=constrain(sensorValor, 0, 255);
if(contadorBoton%5==1)
{
analogWrite(rojo, sensorValor);
analogWrite(verde, 0);
analogWrite(azul, 0);
}
if(contadorBoton%5==2)
{
analogWrite(rojo, 0);
analogWrite(verde, 0);
analogWrite(azul, sensorValor);
}
if(contadorBoton%5==3)
{
analogWrite(rojo, 0);
analogWrite(verde, 12);
analogWrite(azul, sensorValor);
}
if(contadorBoton%5==4)
{
analogWrite(rojo, 0);
analogWrite(verde, sensorValor);
analogWrite(azul, 0);
}
if(contadorBoton%5==0)
{
analogWrite(rojo, sensorValor/2);
analogWrite(verde, sensorValor);
analogWrite(azul, sensorValor);
}
}

Sensor Piezoeléctrico II

Con el siguiente programa cambiaremos el color de un LED tricolor a cada golpe que sea recibido por el sensor piezoeléctrico.
La intensidad del LED será controlada por un botón.

El circuito lo implementaremos de la siguiente forma:

+ 1º pin LED tricolor al pin 11 (digital)
- 2º pin LED tricolor al pin a ground
+ 3º pin LED tricolor al pin 10 (digital)
+ 4º pin LED tricolor al pin 9 (digital)

+ Piezo a través de resistencia (33O-990 Ohmios) al pin 0 (analógico)
- Piezo a ground

+ Boton al pin 2 (digital)
+ 5V al lado positivo del botón
- Boton a Ground







//Cambiaremos de color el LED a cada 'golpe' que reciba el sensor piezo.
//Aumentaremos la intensidad del LED pulsando el botón repetidamente.

const int pinBoton=2;
int contadorBoton=0;
int estadoBoton=0;
int lastEstadoBoton=0;

const int pinPiezo=0;
int umbral=75;
int valorPiezo=0;

int aux=0;

const int rojo=9;
const int verde=10;
const int azul=11;

void setup()
{
pinMode(pinBoton, INPUT);
pinMode(pinPiezo, INPUT);
pinMode(rojo, OUTPUT);
pinMode(verde, OUTPUT);
pinMode(azul, OUTPUT);
}

void loop()
{
estadoBoton=digitalRead(pinBoton);
if(estadoBoton!=lastEstadoBoton)
{
if(estadoBoton==HIGH)
{
contadorBoton++;
}
lastEstadoBoton=estadoBoton;
}
valorPiezo=analogRead(pinPiezo);
if(valorPiezo<=umbral)
{
aux++;
if(aux%3==0)
{
analogWrite(rojo, ((contadorBoton*25)%125));
analogWrite(verde, 0);
analogWrite(azul, 0);
}
if(aux%3==1)
{
analogWrite(rojo, 0);
analogWrite(verde, ((contadorBoton*25)%125));
analogWrite(azul, 0);
}
if(aux%3==2)
{
analogWrite(rojo, 0);
analogWrite(verde, 0);
analogWrite(azul, ((contadorBoton*25)%125));
}
}
}

Sensor Piezoeléctrico

A continuación mostraremos un pequeño ejemplo para utilizar un sensor piezoeléctrico.
Este tipo de sensores detectan golpes, vibraciones, etc. Nos servirá cuando nuestro robot este en contacto con otro objeto o simplemente para detectar que se golpea la superficie sobre la que se encuentra colocado el sensor.



El programa encenderá el LED a cada golpe que reciba el sensor. Cambiaremos el color para ir contabilizando los golpes.

Implementaremos el sistema de la siguiente manera

+ 1º pin LED tricolor al pin 11 (digital)
- 2º pin LED tricolor al pin a ground
+ 3º pin LED tricolor al pin 10 (digital)
+ 4º pin LED tricolor al pin 9 (digital)

+ Piezo a través de resistencia (33O-990 Ohmios) al pin 0 (analógico)
- Piezo a ground






//Encenderemos el LED, rojo, verde o azul mientras que el sensor reciba señal de golpe.
//Por el monitor serie imprimiremos Golpe! cada vez que el piezo reciba señal.

const int rojo=11;
const int verde=10;
const int azul=9;

const int knockSensor=0;
const int umbral=50;

int sensorReading=0;
int aux=0;

void setup()
{
pinMode(knockSensor, INPUT);
pinMode(rojo, OUTPUT);
pinMode(verde, OUTPUT);
pinMode(azul, OUTPUT);
Serial.begin(9600);
}

void loop()
{
sensorReading=analogRead(knockSensor);
if (sensorReading<=umbral)
{
Serial.println("Golpe!");
if(aux%3==0)
{
analogWrite(rojo,0);
analogWrite(verde,0);
analogWrite(azul,1);
}
if(aux%3==1)
{
analogWrite(rojo,1);
analogWrite(verde,0);
analogWrite(azul,0);
}
if(aux%3==2)
{
analogWrite(rojo,0);
analogWrite(verde,1);
analogWrite(azul,0);
}
delay(200);
}
else
{
analogWrite(rojo,0);
analogWrite(verde,0);
analogWrite(azul,0);
aux+=1;
}
}

Sensor de luz, botón y dos LEDs

El siguiente programa encenderá el LED1 o el LED2 dependiendo de lo que reciba el sensor de luz. Controlaremos analógicamente el brillo de los LEDs con un botón.

Implementaremos el sistema de la siguiente manera

+ Lado positivo sensor de luz a +5V
+ Lado positivo sensor de luz al pin 1 (analógico)
- Lado negativo sensor de luz a ground

+ Lado positivo LED1 y 2 a los pines 9 y 10 (digital)
- Lado negativo LED1 y 2 a ground

+ Lado positivo botón a +5V.
+ Lado positivo botón al pin 7 (digital)
- Lado negativo botón a ground







const int pinLed1=9;
const int pinLed2=10;

int boton=7;
int contadorBoton=0;
int lastState=0;
int state=0;

int sensorLuz=1;
int sensorValor=0;
int sensorMax=0;
int sensorMin=1023;

int ultimoTiempo=0;//Auxiliar para la comprobacion de tiempo
int tiempo=100;//Tiempo que hace cada comprobacion iterativamente

void setup()
{
pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(boton, INPUT);
pinMode(sensorLuz, INPUT);
digitalWrite(13, HIGH);//Durante los 5 primeros segundos encendemos el LED de la placa mientras hace operaciones
while(millis()<5000)//Da valores maximos y minimos a al sensor de luz
{
sensorValor=analogRead(sensorLuz);
if(sensorValor>sensorMax)
{
sensorMax=sensorValor;
}
if (sensorValor {
sensorMin=sensorValor;
}
}
digitalWrite(13, LOW);//Apagamos el LED de la placa
}

void loop ()
{
state=digitalRead(boton);
if(state!=lastState)
{
if(state==HIGH)
{
contadorBoton++;
}
lastState=state;
}
sensorValor=analogRead(sensorLuz);//Leemos la señal del sensor de LUZ
sensorValor=map(sensorValor, sensorMin, sensorMax, 0, 255);//Se mapea la señal del sensor de Luz, se le da los valores maximos y minimos y el rango
sensorValor=constrain(sensorValor, 0, 255);//Limitamos el valor al rango que queremos 0-255
if(millis()-ultimoTiempo>tiempo)//Cada 'tiempo' controlamos el valor del sensor
{
ultimoTiempo=millis();
if(sensorValor>100)
{
if(((25*contadorBoton)%256)<26)
{
digitalWrite(pinLed1,LOW);
}
else
{
analogWrite(pinLed1, ((25*contadorBoton)%256));
digitalWrite(pinLed2,LOW);
}
}
else
{
if(((25*contadorBoton)%256)<26)
{
digitalWrite(pinLed2,LOW);
}
else
{
analogWrite(pinLed2, ((25*contadorBoton)%256));
digitalWrite(pinLed1,LOW);
}
}
}
}

LED (RGB) sensor luz, timbre y botón.

En este pequeño programa vamos a utilizar un sensor de luz, cuando este no reciba la suficiente luz hará que suene el timbre. El color del LED tricolor lo controlaremos con un botón que irá cambiando los colores en cada pulsación hasta que se apague.
Durante los primeros 5 segundos calibramos el sensor de luz.

El circuito lo implementaremos de la siguiente manera:

+ Lado positivo sensor de luz a +5V
+ Lado positivo sensor de luz al pin 0 (analógico)
- Lado negativo sensor de luz a ground

+ 1º pin LED al pin 11 (digital)
- 2º pin LED al pin a ground
+ 3º pin LED al pin 10 (digital)
+ 4º pin LED al pin 9 (digital)

+ Lado positivo altavoz al pin 5 (digital)
- Lado negativo altavoz a ground

+ Lado positivo botón a +5V.
+ Lado positivo botón al pin 3 (digital)
- Lado negativo botón a ground






int rojo=11;
int verde=10;
int azul=9;

int pulsador=3;
int contadorPulsador=0;
int last_timePulsador=0;
int estadoPulsador=0;

int altavoz=5;//Pin del altavoz
int length=15; //Numero de notas
char notes[]="abcffeabffccaba";//Notas
int beats[]= {1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1, 2, 1, 1, 1};//Duracion de cada nota
int intervalo=200;//Intervalo de duracion de cada nota (argumento de la duncion PlayNote

int sensorLuz=0;
int valorLuz=0;
int sensorMax=0;
int sensorMin=1000;

int i=0;

void playTone(int tone, int duration)
{
for (long i = 0; i {
digitalWrite(altavoz, HIGH);
delayMicroseconds(tone);
digitalWrite(altavoz, LOW);
delayMicroseconds(tone);
}
}

void playNote(char note, int duration)
{
char names[] = { 'c', 'd', 'e', 'f', 'g', 'a', 'b', 'C' };
int tones[] = { 1915, 1700, 1519, 1432, 1275, 1136, 1014, 956 };
for (int i=0; i<8; i++)
{
if (names[i]==note)
{
playTone(tones[i], duration);//Toca la nota correspondiente a las notas introducidas en la declaracion del array notes[]
}
}
}

void setup()
{
pinMode(rojo, OUTPUT);
pinMode(verde, OUTPUT);
pinMode(azul, OUTPUT);
pinMode(sensorLuz, INPUT);
pinMode(pulsador, INPUT);
pinMode(altavoz, OUTPUT);
digitalWrite(13, HIGH);//Durante los 5 primeros segundos encendemos el LED de la placa mientras hace operaciones
while(millis()<5000)//Da valores maximos y minimos a al sensor de luz
{
valorLuz=analogRead(sensorLuz);
if(valorLuz>sensorMax)
{
sensorMax=valorLuz;
}
if (valorLuz {
sensorMin=valorLuz;
}
}
digitalWrite(13, LOW);//Apagamos el LED de la placa
}

void loop()
{
estadoPulsador=digitalRead(pulsador);
if(estadoPulsador!=last_timePulsador)
{
if(estadoPulsador==HIGH)
{
contadorPulsador++;
}
last_timePulsador=estadoPulsador;
}
if(contadorPulsador%4==1)
{
analogWrite(rojo, 25);
analogWrite(verde, 0);
analogWrite(azul, 0);
}
if(contadorPulsador%4==2)
{
analogWrite(rojo, 0);
analogWrite(verde, 25);
analogWrite(azul, 0);
}
if(contadorPulsador%4==3)
{
analogWrite(rojo, 0);
analogWrite(verde, 0);
analogWrite(azul, 25);
}
if(contadorPulsador%4==0)
{
analogWrite(rojo, 0);
analogWrite(verde, 0);
analogWrite(azul, 0);
}

valorLuz=analogRead(sensorLuz);
valorLuz=map(valorLuz, sensorMin, sensorMax, 0, 255);//Se mapea la señal del sensor de Luz, se le da los valores maximos y minimos y el rango
valorLuz=constrain(valorLuz, 0, 255);//Limitamos el valor al rango que queremos 0-255
if(valorLuz>123)
{
for(i=0; i {
playNote(notes[i], intervalo);
}
}
}

Sensor de Temperatura

Vamos a utilizar un sensor de temperatura. Dependiendo del valor que reciba el sensor encenderemos un LED u otro. Durante los 8 primeros segundos calibramos el sensor para que adquiera valor máximo y mínimo.

El circuito lo implementaremos de la siguiente manera:

+ pin LED1 y 2 a los pines 5 y 6 de la placa (digital)
- pin LED1 y 2 a ground

1º pin sensor temperatura a +5V
2º pin sensor temperatura al pin 0 (analógico)
3º pin sensor temperatura a ground







//Vamos a encender un LED u otro dependiendo de la lectura del sensor de temperatura

int sensorValor=0;
int sensorMax=0;
int sensorMin=0;

int pinLed1=5;
int pinLed2=6;
int sensorTemperatura=0;

void setup()
{
pinMode(pinLed1, OUTPUT);
pinMode(pinLed2, OUTPUT);
pinMode(sensorTemperatura, INPUT);
digitalWrite(13, HIGH);//Durante los 8 primeros segundos encendemos el LED de la placa mientras hace operaciones
while(millis()<8000)//Da valores maximos y minimos a al sensor de luz
{
sensorValor=analogRead(sensorTemperatura);
if(sensorValor>sensorMax)
{
sensorMax=sensorValor;
}
if (sensorValor {
sensorMin=sensorValor;
}
}
digitalWrite(13, LOW);//Apagamos el LED de la placa
}

void loop ()
{
sensorValor=analogRead(sensorTemperatura);//Leemos la señal del sensor de LUZ
sensorValor=map(sensorValor, sensorMin, sensorMax, 0, 255);//Se mapea la señal del sensor de Luz, se le da los valores maximos y minimos y el rango
sensorValor=constrain(sensorValor, 0, 255);//Limitamos el valor al rango que queremos 0-255
if (sensorValor>253)
{
digitalWrite(pinLed1, HIGH);
digitalWrite(pinLed2, LOW);
}
else
{
digitalWrite(pinLed1,LOW);
digitalWrite(pinLed2, HIGH);
}
}

Sensor de Luz

Vamos a utilizar un sensor de Luz para controlar el color de un LED y la melodía de un timbre. Cada vez que el sistema compruebe que el nivel de luz es bajo sonara el timbre y cambiará de color el LED.
Cuando el programa se comienza a ejecutar, le damos 5 segundos de tiempo para calibrar el sensor. Es recomendable cambiar la intensidad de la luz a la que está expuesto el sensor, de otro modo los valores que recoja como máximos y mínimos serán muy próximos y no funcionará como deseamos.

El circuito lo implementaremos de la siguiente manera:
+ Timbre al pin 3 (digital)
- Timbre a ground

+ 1º pin LED a 9 (digital)
- 2º pin LED a ground
+ 3º pin LED a 10 (digital)
+ 4º pin LED a 11 (digital)

+ sensor luz al pin 1 (analogico)
+ sensor luz a +5V (utilizar resistencia 333 - 1000 Ohm)
- sensor luz a ground






//Control del color del LED y de un timbre a partir de un sensor de Luz.
int ultimoTiempo=0;//Auxiliar para la comprobacion de tiempo
int tiempo=100;//Tiempo que hace cada comprobacion iterativamente

int rojo=9;
int verde=10;
int azul=11;
int cambioColor=1;

int sensorPin=1;//Pin del sensor de luz
int sensorValor=0;//Valor devuelto por el sensor
int sensorMax=0;//Valor maximo del sensor
int sensorMin=1000;//Valor minimo del sensor

int altavoz=3;//Pin del altavoz
int length=15; //Numero de notas
char notes[]="ccffffffeeaacac";//Notas
int beats[]= {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1};//Duracion de cada nota
int intervalo=100;//Intervalo de duracion de cada nota (argumento de la duncion PlayNote

void playTone(int tone, int duration)
{
for (long i = 0; i<8; i++)
{
if (names[i]==note)
{
playTone(tones[i], duration);//Toca la nota correspondiente a las notas introducidas en la declaracion del array notes[]
}
}
}

void setup()
{
pinMode(rojo, OUTPUT);
pinMode(verde, OUTPUT);
pinMode(azul, OUTPUT);
pinMode(sensorPin, INPUT);
pinMode(altavoz, OUTPUT);
digitalWrite(13, HIGH);//Durante los 5 primeros segundos encendemos el LED de la placa mientras hace operaciones
while(millis()<5000)//Da valores maximos y minimos a al sensor de luz
{
sensorValor=analogRead(sensorPin);
if(sensorValor>sensorMax)
{
sensorMax=sensorValor;
}
if (sensorValor {
sensorMin=sensorValor;
}
}
digitalWrite(13, LOW);//Apagamos el LED de la placa
}

void loop ()
{
sensorValor=analogRead(sensorPin);//Leemos la señal del sensor de LUZ
sensorValor=map(sensorValor, sensorMin, sensorMax, 0, 255);//Se mapea la señal del sensor de Luz, se le da los valores maximos y minimos y el rango
sensorValor=constrain(sensorValor, 0, 255);//Limitamos el valor al rango que queremos 0-255
if(millis()-ultimoTiempo>tiempo)//Cada 'tiempo' controlamos el valor del sensor
{
ultimoTiempo=millis();
if(sensorValor>135)
if(sensorValor>135)
{
if(cambioColor%3==0)//Cambiamos el color cada vez que el sensor de LUZ Sobrepasa el rango 135
{
analogWrite(rojo,0);
analogWrite(verde,0);
analogWrite(azul,255);
}
if(cambioColor%3==1)
{
analogWrite(rojo,200);
analogWrite(verde,0);
analogWrite(azul,0);
}
if(cambioColor%3==2)
{
analogWrite(rojo,0);
analogWrite(verde,200);
analogWrite(azul,150);
}
cambioColor++;//Incrementamos la variable para hacer que cambie cada vez que el sensor de LUZ varie
for (int i = 0; i {
playNote(notes[i], intervalo);
}
}
else
{
analogWrite(rojo,0);
analogWrite(verde,255);
analogWrite(azul,0);
}
}
}