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