Sensor URM + Servo II

En el ejemplo anterior ya controlábamos el servomotor para poder orientar el sensor URM. En el siguiente ejemplo recogemos las distancias según la orientación del sensor URM.

Podremos manejar nuestro robot a través de infrarrojos con un mando a distancia. Tiene dos modos, manual (como vimos anteriormente), y automático, que es el modo en el que escaneamos las distancias y tomamos una decisión de movimiento según ese mapa.


Conexiones
-------------
Pines 1, 9 y 16 a +5V
Pin 8 a +9-24V
Pines 2, 7 10 y 15 a la placa Arduino
Pines 4, 5, 12 y 13 a ground (Dos de ellos a la placa y dos a la fuente de alimentación)
Pines 3, 6 11 y 14 conectados a los motores

pin 7 URM --> pin 42 arduino
pin 6 URM --> pin 40 arduino
pin 4 URM --> pin 38 arduino
pin 2 URM --> ground arduino
pin 1 URM --> pin 36 arduino

3V3 al lado positivo del servo
ground al lado negativo del servo
pin 47 al pin de control del servo






Código .pde



#include "WProgram.h"
#include "NECIRrcv.h"
#include "Servo.h"
#define IRPIN 12
NECIRrcv ir(IRPIN);
unsigned long ircode;

Servo servo; //Objeto Servo proporcionado por la librería
int position=0;//Posicion del servo

typedef struct
{
int posicion;
int distancia;
}Angulo;

Angulo angulo[7];
int j=0;
int auxiliar=0;
boolean intercambio=false;

const int pin1=7;
const int pin2=13;
const int pin3=6;
const int pin4=2;
const int pin5=5;

unsigned long a1=2;
unsigned long a2=2;
unsigned long a3=2;
unsigned long a4=2;
unsigned long a5=2;
int duracion1=600;
int duracion2=1000;
boolean aux=true;

int ultraData=38;
int ultraTrigger=40;
int ultraEnable=42;
int ultraPower=36;
int val=0;
int ultraValue=0;
int timecount=0;

bool State=true;
long previousMillis = 0;
long interval = 8000;

const int input1=10;
const int input2=11;
const int input3=9;
const int input4=8;

void adelante()
{
digitalWrite(input1, LOW);
digitalWrite(input2, HIGH);
digitalWrite(input3, LOW);
digitalWrite(input4, HIGH);
digitalWrite(pin1, HIGH);
digitalWrite(pin2, HIGH);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void izquierda()
{
digitalWrite(input1, HIGH);
digitalWrite(input2, LOW);
digitalWrite(input3, LOW);
digitalWrite(input4, HIGH);
digitalWrite(pin1, HIGH);
digitalWrite(pin2, LOW);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void derecha()
{
digitalWrite(input1, LOW);
digitalWrite(input2, HIGH);
digitalWrite(input3, HIGH);
digitalWrite(input4, LOW);
digitalWrite(pin1, LOW);
digitalWrite(pin2, HIGH);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void atras()
{
digitalWrite(input1, HIGH);
digitalWrite(input2, LOW);
digitalWrite(input3, HIGH);
digitalWrite(input4, LOW);
digitalWrite(pin1, LOW);
digitalWrite(pin2, LOW);
digitalWrite(pin3, HIGH);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void parar()
{
digitalWrite(input1, LOW);
digitalWrite(input2, LOW);
digitalWrite(input3, LOW);
digitalWrite(input4, LOW);
digitalWrite(pin1, LOW);
digitalWrite(pin2, LOW);
digitalWrite(pin3, LOW);
luzPosicion();
}
void luzPosicion()
{
if(aux)
{
digitalWrite(pin4, HIGH);
digitalWrite(pin5, LOW);
aux=false;
}
else
{
digitalWrite(pin4, LOW);
digitalWrite(pin5, HIGH);
aux=true;
}
}

void setup()
{
servo.attach(47);
pinMode(input1, OUTPUT);
pinMode(input2, OUTPUT);
pinMode(input3, OUTPUT);
pinMode(input4, OUTPUT);
pinMode(pin1, OUTPUT);
pinMode(pin2, OUTPUT);
pinMode(pin3, OUTPUT);
pinMode(pin4, OUTPUT);
pinMode(pin5, OUTPUT);
pinMode(IRPIN, INPUT);
ir.begin();
Serial.begin(9600);
pinMode(ultraPower, OUTPUT);
pinMode(ultraEnable, OUTPUT);
digitalWrite(ultraPower, HIGH);
digitalWrite(ultraEnable, HIGH);
delay(200);
}

void loop()
{
while (ir.available())
{
ircode=ir.read();
if(ircode==4194696960)
{
while(true)
{
j=0;
for(position=-30; position<=210; position+=40)//Movemos el servo de 0º a 180º
{
servo.write(position);
delay(500);
ultraValue = 0;
timecount = 0;
val = 0;
pinMode(ultraTrigger, OUTPUT);
digitalWrite(ultraTrigger, HIGH);
delayMicroseconds(500);
digitalWrite(ultraTrigger, LOW);
delayMicroseconds(200);
digitalWrite(ultraTrigger, HIGH);
delayMicroseconds(200);
pinMode(ultraData, INPUT);

do
{
val=digitalRead(ultraData);
}while(val==HIGH);

do
{
val=digitalRead(ultraData);
timecount++;
delayMicroseconds(50);
}while(val==LOW);

ultraValue=timecount;
Serial.println(ultraValue);

servo.write(position);
angulo[j].posicion=j;//Almacenamos los datos en las estructuras
angulo[j].distancia=ultraValue;
j++;
}

do{//Bubble sort (Ordenamos los datos del mapeo)
intercambio=false;
for(int i=0; i<6; i++)
{
if(angulo[i].distancia>angulo[i+1].distancia)
{
auxiliar=angulo[i].distancia;
angulo[i].distancia=angulo[i+1].distancia;
angulo[i+1].distancia=auxiliar;
auxiliar=angulo[i].posicion;
angulo[i].posicion=angulo[i+1].posicion;
angulo[i+1].posicion=auxiliar;
intercambio=true;
}
}
}while(intercambio);

if(angulo[6].posicion==3 || angulo[6].posicion==4)//Hacia delante la mayor distancia con un objeto
{
adelante();
delay(angulo[6].distancia*7);
parar();
}

if(angulo[0].posicion==2 || angulo[0].posicion==1 || angulo[0].posicion==0)//Si a la derecha tenemos un objeto proximo
{
if(angulo[0].distancia<35)
{
izquierda();//Giramos a la izquierda
delay(420);
parar();
}
}
if(angulo[0].posicion==5 || angulo[0].posicion==6)//Si a la izquierda tenemos un objeto próximo
{
if(angulo[0].distancia<35)
{
derecha();//Giramos a la derecha
delay(420);
parar();
}
}
if(angulo[0].posicion==3 || angulo[0].posicion==4)//Si de frente tenemos la distancia mas corta
{
if(angulo[6].posicion==0 || angulo[6].posicion==1 || angulo[6].posicion==2)//Comprobamos el lado derecho
{
derecha();//Giramos a la derecha
delay(420);
parar();
}
if(angulo[6].posicion==5 || angulo[6].posicion==6)//Comprobamos el lado izquierdo
{
izquierda();//Giramos a la izquierda
delay(420);
parar();
}
}
}
}
else
{
if(2707357440==ircode)
{
duracion1=300;
duracion2=1000;
}
if(2724069120==ircode)
{
duracion1=500;
duracion2=3000;
}
if(3776904960==ircode)
{
duracion1=800;
duracion2=5000;
}
if(ircode==3810328320)//HACIA DELANTE
{
adelante();
delay(duracion2);
parar();
ircode=0;
}
if(ircode==3877175040)//HACIA ATRAS
{
atras();
delay(duracion2);
parar();
ircode=0;
}
if(ircode==3893886720)//DERECHA
{
derecha();
delay(duracion1);
parar();
ircode=0;
}
if(ircode==2824339200)//IZQUIERDA
{
izquierda();
delay(duracion1);
parar();
ircode=0;
}
}
}
}

Sensor URM + Servo

En el siguiente ejemplo vamos a introducir un servomotor para poder orientar el sensor URM. En este ejemplo almacenaremos las distancias existentes entre en sensor URM y lo que le rodea.
En este ejemplo tendremos control sobre los motores del coche a través del receptor IR. Gracias al sensor URM sólo almacenamos las distancias del coche con los objetos que le rodean para un futuro uso.


Conexiones
-------------
Pines 1, 9 y 16 a +5V
Pin 8 a +9-24V
Pines 2, 7 10 y 15 a la placa Arduino
Pines 4, 5, 12 y 13 a ground (Dos de ellos a la placa y dos a la fuente de alimentación)
Pines 3, 6 11 y 14 conectados a los motores

pin 7 URM --> pin 42 arduino
pin 6 URM --> pin 40 arduino
pin 4 URM --> pin 38 arduino
pin 2 URM --> ground arduino
pin 1 URM --> pin 36 arduino

3V3 al lado positivo del servo
ground al lado negativo del servo
pin 47 al pin de control del servo




#include "WProgram.h"
#include "NECIRrcv.h"
#include "Servo.h"
#define IRPIN 12
NECIRrcv ir(IRPIN);
unsigned long ircode;

Servo servo; //Objeto Servo proporcionado por la librería
int position=0;//Posicion del servo

typedef struct
{
int posicion;
int distancia;
}Angulo;

Angulo angulo[9];
int j=0;

const int pin1=7;
const int pin2=13;
const int pin3=6;
const int pin4=2;
const int pin5=5;

unsigned long a1=2;
unsigned long a2=2;
unsigned long a3=2;
unsigned long a4=2;
unsigned long a5=2;
int duracion1=600;
int duracion2=1000;
boolean aux=true;

int ultraData=38;
int ultraTrigger=40;
int ultraEnable=42;
int ultraPower=36;
int val=0;
int ultraValue=0;
int timecount=0;

bool State=true;
long previousMillis = 0;
long interval = 8000;

const int input1=10;
const int input2=11;
const int input3=9;
const int input4=8;

void adelante()
{
digitalWrite(input1, LOW);
digitalWrite(input2, HIGH);
digitalWrite(input3, LOW);
digitalWrite(input4, HIGH);
digitalWrite(pin1, HIGH);
digitalWrite(pin2, HIGH);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void izquierda()
{
digitalWrite(input1, HIGH);
digitalWrite(input2, LOW);
digitalWrite(input3, LOW);
digitalWrite(input4, HIGH);
digitalWrite(pin1, HIGH);
digitalWrite(pin2, LOW);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void derecha()
{
digitalWrite(input1, LOW);
digitalWrite(input2, HIGH);
digitalWrite(input3, HIGH);
digitalWrite(input4, LOW);
digitalWrite(pin1, LOW);
digitalWrite(pin2, HIGH);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void atras()
{
digitalWrite(input1, HIGH);
digitalWrite(input2, LOW);
digitalWrite(input3, HIGH);
digitalWrite(input4, LOW);
digitalWrite(pin1, LOW);
digitalWrite(pin2, LOW);
digitalWrite(pin3, HIGH);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void parar()
{
digitalWrite(input1, LOW);
digitalWrite(input2, LOW);
digitalWrite(input3, LOW);
digitalWrite(input4, LOW);
digitalWrite(pin1, LOW);
digitalWrite(pin2, LOW);
digitalWrite(pin3, LOW);
luzPosicion();
}
void luzPosicion()
{
if(aux)
{
digitalWrite(pin4, HIGH);
digitalWrite(pin5, LOW);
aux=false;
}
else
{
digitalWrite(pin4, LOW);
digitalWrite(pin5, HIGH);
aux=true;
}
}

void setup()
{
servo.attach(47);
pinMode(input1, OUTPUT);
pinMode(input2, OUTPUT);
pinMode(input3, OUTPUT);
pinMode(input4, OUTPUT);
pinMode(pin1, OUTPUT);
pinMode(pin2, OUTPUT);
pinMode(pin3, OUTPUT);
pinMode(pin4, OUTPUT);
pinMode(pin5, OUTPUT);
pinMode(IRPIN, INPUT);
ir.begin();
Serial.begin(9600);
pinMode(ultraPower, OUTPUT);
pinMode(ultraEnable, OUTPUT);
digitalWrite(ultraPower, HIGH);
digitalWrite(ultraEnable, HIGH);
delay(200);
}

void loop()
{
while (ir.available())
{
ircode=ir.read();
if(ircode==4194696960)
{
j=0;
for(position=-30; position<=210; position+=30)//Movemos el servo de 0º a 180º
{
servo.write(position);
delay(500);
ultraValue = 0;
timecount = 0;
val = 0;
pinMode(ultraTrigger, OUTPUT);
digitalWrite(ultraTrigger, HIGH);
delayMicroseconds(500);
digitalWrite(ultraTrigger, LOW);
delayMicroseconds(200);
digitalWrite(ultraTrigger, HIGH);
delayMicroseconds(200);
pinMode(ultraData, INPUT);

do
{
val=digitalRead(ultraData);
}while(val==HIGH);

do
{
val=digitalRead(ultraData);
timecount++;
delayMicroseconds(50);
}while(val==LOW);

ultraValue=timecount;
Serial.println(ultraValue);
angulo[j].posicion=position;//Almacenamos los datos en las estructuras
angulo[j].distancia=ultraValue;
j++;
}
ircode=0;
}
else
{
if(2707357440==ircode)
{
duracion1=300;
duracion2=1000;
}
if(2724069120==ircode)
{
duracion1=500;
duracion2=3000;
}
if(3776904960==ircode)
{
duracion1=800;
duracion2=5000;
}
if(ircode==3810328320)//HACIA DELANTE
{
adelante();
delay(duracion2);
parar();
ircode=0;
}
if(ircode==3877175040)//HACIA ATRAS
{
atras();
delay(duracion2);
parar();
ircode=0;
}
if(ircode==3893886720)//DERECHA
{
derecha();
delay(duracion1);
parar();
ircode=0;
}
if(ircode==2824339200)//IZQUIERDA
{
izquierda();
delay(duracion1);
parar();
ircode=0;
}
}
}
}

Control básico Servomotor

Vamos a ver un ejemplo muy sencillo de como manejar un servomotor. Para ello necesitaremos incluir la libreria Servo.h
Esta librería implementa la clase Servo, que es la que vamos a utilizar. Si se tienen conocimientos básicos de la programación orientada a objetos nos será muy fácil comprender el código. Para enviar la señal al motor para que gire debemos llamar al método write(int) de la clase Servo. Llamamos a dicho método a partir del objeto o referencia. Para asociar el pin del arduino al pin de control del servo debemos llamar al método attach(int).


Conexiones
-------------
3V3 al lado positivo del servo (rojo)
ground al lado negativo del servo (negro)
pin 13 al pin de control del servo




Código .pde


//Control Servomotor
//Giramos el servo de 0º a 180º y a la inversa consecutivamente

#include "Servo.h"

Servo servo; //Objeto Servo proporcionado por la librería
int position=0;//Posicion del servo

void setup()
{
servo.attach(13); //Pin 13 asociado al pin de control del sero
}


void loop()
{
for(position=0; position<180; position++)//Movemos el servo de 0º a 180º
{
servo.write(position); //Llamamos al método de la clase (POO)
}
delay(1000);
for(position=180; position>=0; position--)
{
servo.write(position);
}
delay(1000);
}

Modo Automático/Manual

Vamos a manejar un coche de dos modos diferentes, aútomatico y manual.
En el modo manual enviaremos las instrucciones por infrarrojos.
El modo automático será controlado por la señal que recibe el sensor de ultrasonidos URM V3.2. En este ejemplo juntamos las funcionalidades de las últimas dos entradas del blog.


Conexiones
----------
Tutorial SN754410NE
Integrado SN754410NE, driver para manejar motores. Sustito de la familia L293
Pines 1, 9 y 16 a +5V
Pin 8 a +9-24V
Pines 2, 7 10 y 15 a la placa Arduino
Pines 4, 5, 12 y 13 a ground (Dos de ellos a la placa y dos a la fuente de alimentación)
Pines 3, 6 11 y 14 conectados a los motores

Tutorial URM V3.2
pin 7 URM --> pin 42 arduino
pin 6 URM --> pin 40 arduino
pin 4 URM --> pin 38 arduino
pin 2 URM --> ground arduino
pin 1 URM --> pin 36 arduino






#include "WProgram.h"
#include "NECIRrcv.h"
#define IRPIN 12
unsigned long ircode;

const int pin1=7;
const int pin2=13;
const int pin3=6;
const int pin4=2;
const int pin5=5;

unsigned long a1=2;
unsigned long a2=2;
unsigned long a3=2;
unsigned long a4=2;
unsigned long a5=2;
int duracion1=600;
int duracion2=1000;
boolean aux=true;

int ultraData=38;
int ultraTrigger=40;
int ultraEnable=42;
int ultraPower=36;
int val=0;
int ultraValue=0;
int timecount=0;

bool State=true;
long previousMillis = 0;
long interval = 8000;

NECIRrcv ir(IRPIN);

const int input1=10;
const int input2=11;
const int input3=9;
const int input4=8;

void adelante()
{
digitalWrite(input1, LOW);
digitalWrite(input2, HIGH);
digitalWrite(input3, LOW);
digitalWrite(input4, HIGH);
digitalWrite(pin1, HIGH);
digitalWrite(pin2, HIGH);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void izquierda()
{
digitalWrite(input1, HIGH);
digitalWrite(input2, LOW);
digitalWrite(input3, LOW);
digitalWrite(input4, HIGH);
digitalWrite(pin1, HIGH);
digitalWrite(pin2, LOW);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void derecha()
{
digitalWrite(input1, LOW);
digitalWrite(input2, HIGH);
digitalWrite(input3, HIGH);
digitalWrite(input4, LOW);
digitalWrite(pin1, LOW);
digitalWrite(pin2, HIGH);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void atras()
{
digitalWrite(input1, HIGH);
digitalWrite(input2, LOW);
digitalWrite(input3, HIGH);
digitalWrite(input4, LOW);
digitalWrite(pin1, LOW);
digitalWrite(pin2, LOW);
digitalWrite(pin3, HIGH);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void parar()
{
digitalWrite(input1, LOW);
digitalWrite(input2, LOW);
digitalWrite(input3, LOW);
digitalWrite(input4, LOW);
digitalWrite(pin1, LOW);
digitalWrite(pin2, LOW);
digitalWrite(pin3, LOW);
luzPosicion();
}
void luzPosicion()
{
if(aux)
{
digitalWrite(pin4, HIGH);
digitalWrite(pin5, LOW);
aux=false;
}
else
{
digitalWrite(pin4, LOW);
digitalWrite(pin5, HIGH);
aux=true;
}
}

void setup()
{
pinMode(input1, OUTPUT);
pinMode(input2, OUTPUT);
pinMode(input3, OUTPUT);
pinMode(input4, OUTPUT);
pinMode(pin1, OUTPUT);
pinMode(pin2, OUTPUT);
pinMode(pin3, OUTPUT);
pinMode(pin4, OUTPUT);
pinMode(pin5, OUTPUT);
pinMode(IRPIN, INPUT);
ir.begin();
Serial.begin(9600);
pinMode(ultraPower, OUTPUT);
pinMode(ultraEnable, OUTPUT);
digitalWrite(ultraPower, HIGH);
digitalWrite(ultraEnable, HIGH);
delay(200);
}

void loop()
{
while (ir.available())
{
ircode=ir.read();
if(ircode==4194696960)
{
do{
ultraValue = 0;
timecount = 0;
val = 0;
pinMode(ultraTrigger, OUTPUT);
digitalWrite(ultraTrigger, HIGH);
delayMicroseconds(500);
digitalWrite(ultraTrigger, LOW);
delayMicroseconds(200);
digitalWrite(ultraTrigger, HIGH);
delayMicroseconds(200);
pinMode(ultraData, INPUT);

do
{
val=digitalRead(ultraData);
}while(val==HIGH);

do
{
val=digitalRead(ultraData);
timecount++;
delayMicroseconds(50);
}while(val==LOW);

ultraValue=timecount;
Serial.println(ultraValue);

if(ultraValue>=28)
{
adelante();
}
else
{
derecha();
}
Serial.flush();
delay(70);
}while(State);

if (millis() - previousMillis > interval)
{
previousMillis = millis();
if (State == false)
State = true;
else
State = false;
}
ircode=0;
}
else
{
if(2707357440==ircode)
{
duracion1=300;
duracion2=1000;
}
if(2724069120==ircode)
{
duracion1=500;
duracion2=3000;
}
if(3776904960==ircode)
{
duracion1=800;
duracion2=5000;
}
if(ircode==3810328320)//HACIA DELANTE
{
adelante();
delay(duracion2);
parar();
ircode=0;
}
if(ircode==3877175040)//HACIA ATRAS
{
atras();
delay(duracion2);
parar();
ircode=0;
}
if(ircode==3893886720)//DERECHA
{
derecha();
delay(duracion1);
parar();
ircode=0;
}
if(ircode==2824339200)//IZQUIERDA
{
izquierda();
delay(duracion1);
parar();
ircode=0;
}
Serial.println(ircode);
}
}
}

Robot autónomo URM V3.2

En el siguiente programa queremos implementar la automatización de nuestro robot a partir de un sensor URM V3.2. Cada vez que el sensor reciba señal de que se encuentra cercano a un objeto este girará, hasta que ya no se encuentre nada en su camino y siga hacia delante.








El circuito lo implementaremos de la siguiente manera:
Pines 1, 9 y 16 a +5V
Pin 8 a +9-24V
Pines 2, 7 10 y 15 a la placa Arduino
Pines 4, 5, 12 y 13 a ground (Dos de ellos a la placa y dos a la fuente de alimentación)
Pines 3, 6 11 y 14 conectados a los motores

Tutorial URM
pin 7 URM --> pin 42 arduino
pin 6 URM --> pin 40 arduino
pin 4 URM --> pin 38 arduino
pin 2 URM --> ground arduino
pin 1 URM --> pin 36 arduino



autonomo.pde


//Coche automatico, cuando el URM recibe señal de que existe un objeto proximo el coche gira
//Tutorial
//Integrado SN754410NE, driver para manejar motores. Sustito de la familia L293

#include "WProgram.h"
#include "NECIRrcv.h"
#define IRPIN 12
unsigned long ircode;

const int pin1=7;
const int pin2=13;
const int pin3=6;
const int pin4=2;
const int pin5=5;
boolean aux=true;

int ultraData=38;
int ultraTrigger=40;
int ultraEnable=42;
int ultraPower=36;
int val=0;
int ultraValue=0;
int timecount=0;

int State = LOW;
long previousMillis = 0;
long interval = 18000;

NECIRrcv ir(IRPIN);

const int input1=10;
const int input2=11;
const int input3=9;
const int input4=8;

void adelante()
{
digitalWrite(input1, LOW);
digitalWrite(input2, HIGH);
digitalWrite(input3, LOW);
digitalWrite(input4, HIGH);
digitalWrite(pin1, HIGH);
digitalWrite(pin2, HIGH);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void izquierda()
{
digitalWrite(input1, HIGH);
digitalWrite(input2, LOW);
digitalWrite(input3, LOW);
digitalWrite(input4, HIGH);
digitalWrite(pin1, HIGH);
digitalWrite(pin2, LOW);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void derecha()
{
digitalWrite(input1, LOW);
digitalWrite(input2, HIGH);
digitalWrite(input3, HIGH);
digitalWrite(input4, LOW);
digitalWrite(pin1, LOW);
digitalWrite(pin2, HIGH);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void atras()
{
digitalWrite(input1, HIGH);
digitalWrite(input2, LOW);
digitalWrite(input3, HIGH);
digitalWrite(input4, LOW);
digitalWrite(pin1, LOW);
digitalWrite(pin2, LOW);
digitalWrite(pin3, HIGH);
digitalWrite(pin4, LOW);
digitalWrite(pin5, LOW);
}
void parar()
{
digitalWrite(input1, LOW);
digitalWrite(input2, LOW);
digitalWrite(input3, LOW);
digitalWrite(input4, LOW);
digitalWrite(pin1, LOW);
digitalWrite(pin2, LOW);
digitalWrite(pin3, LOW);
luzPosicion();
}
void luzPosicion()
{
if(aux)
{
digitalWrite(pin4, HIGH);
digitalWrite(pin5, LOW);
aux=false;
}
else
{
digitalWrite(pin4, LOW);
digitalWrite(pin5, HIGH);
aux=true;
}
}

void setup()
{
pinMode(input1, OUTPUT);
pinMode(input2, OUTPUT);
pinMode(input3, OUTPUT);
pinMode(input4, OUTPUT);
pinMode(pin1, OUTPUT);
pinMode(pin2, OUTPUT);
pinMode(pin3, OUTPUT);
pinMode(pin4, OUTPUT);
pinMode(pin5, OUTPUT);
pinMode(IRPIN, INPUT);
ir.begin();
Serial.begin(9600);
pinMode(ultraPower, OUTPUT);
pinMode(ultraEnable, OUTPUT);
digitalWrite(ultraPower, HIGH);
digitalWrite(ultraEnable, HIGH);
delay(200);
}

void loop()
{
ultraValue = 0;
timecount = 0;
val = 0;
pinMode(ultraTrigger, OUTPUT);
digitalWrite(ultraTrigger, HIGH);
delayMicroseconds(500);
digitalWrite(ultraTrigger, LOW);
delayMicroseconds(200);
digitalWrite(ultraTrigger, HIGH);
delayMicroseconds(200);
pinMode(ultraData, INPUT);

do
{
val=digitalRead(ultraData);
}while(val==HIGH);

do
{
val=digitalRead(ultraData);
timecount++;
delayMicroseconds(50);
}while(val==LOW);

ultraValue=timecount;
Serial.println(ultraValue);
if(ultraValue>=28)
{
adelante();
}
else
{
if(State==false)
{
derecha();
}
else
{
izquierda();
}
}
Serial.flush();
delay(70);

if (millis() - previousMillis > interval)
{
previousMillis = millis();
if (State == LOW)
State = HIGH;
else
State = LOW;
}
}

URM V3.2 Ultrasonic Sensor

En el siguiente ejemplo vamos a utilizar un sensor de ultrasonidos, el URM V3.2



Este sensor nos devuelve la distancia a la que se encuentra un objeto.
Encenderemos un LED rojo cuando un objeto se encuentre muy próximo, un LED azul cuando se encuentre a una distancia media, y un LED verde cuando el objeto se encuentre lejano.
Este sensor tiene un rango de 5-5000 cm

El circuito lo implementaremos de la siguiente manera:

URM V3.2 Ultrasonic Sensor
--------------------------
pin 7 URM --> pin 9 arduino
pin 6 URM --> pin 10 arduino
pin 4 URM --> pin 11 arduino
pin 2 URM --> ground arduino
pin 1 URM --> pin 12 arduino

URM V3.2



URM.pde


//Comprobamos la distancia de un objeto al sensor URM V3.2
//Utilizaremos un LED tricolor para representar la distancia de un objeto al sensor
int ultraData = 11;
int ultraTrigger = 10;
int ultraEnable=9;
int ultraPower=12;
int val = 0;
int ultraValue = 0;
int timecount = 0;

const int rojo=2;
const int verde=3;
const int azul=4;

void setup()
{
Serial.begin(9600);
pinMode(ultraPower, OUTPUT);
pinMode(ultraEnable, OUTPUT);
pinMode(rojo, OUTPUT);
pinMode(verde, OUTPUT);
pinMode(azul, OUTPUT);
digitalWrite(ultraPower, HIGH);
digitalWrite(ultraEnable, HIGH);
delay(200);
}

void loop()
{
ultraValue = 0;
timecount = 0;
val = 0;
pinMode(ultraTrigger, OUTPUT);
digitalWrite(ultraTrigger, HIGH);
delayMicroseconds(500);
digitalWrite(ultraTrigger, LOW);
delayMicroseconds(200);
digitalWrite(ultraTrigger, HIGH);
delayMicroseconds(200);
pinMode(ultraData, INPUT);

do
{
val=digitalRead(ultraData);
}while(val==HIGH);

do
{
val=digitalRead(ultraData);
timecount++;
delayMicroseconds(50);
}while(val==LOW);

ultraValue=timecount;
Serial.println(ultraValue);

if(ultraValue<40)
{
analogWrite(rojo, 50);
}
else
{
digitalWrite(rojo, LOW);
}
if(ultraValue>=40 && ultraValue<100)
{
analogWrite(azul, 50);
}
else
{
digitalWrite(azul, LOW);
}
if(ultraValue>=100)
{
analogWrite(verde, 50);
}
else
{
digitalWrite(verde, LOW);
}
Serial.flush();
delay(50);
}

Robot controlado por Infrarrojos II

El siguiente ejemplo es igual al que hemos visto anteriormente, pero le hemos incluido unos LEDs para marcar el estado del robot.
Cuando avance hacia delante encenderemos los dos LEDs, cuando gire hacia un lado solo encenderemos uno, y cuando gire hacia el otro lado, encenderemos el otro LED.

El circuito lo implementaremos de la siguiente manera:

Integrado SN754410NE
--------------------
Pines 1, 9 y 16 a +5V
Pin 8 a +9-24V
Pines 2, 7 10 y 15 a la placa Arduino
Pines 4, 5, 12 y 13 a ground (Dos de ellos a la placa y dos a la fuente de alimentación)
Pines 3, 6 11 y 14 conectados a los motores

Receptor IR
-----------
1º pin receptor IR al 12 (digital)
2º pin receptor IR a ground
3º pin receptor IR a +5V

Tutorial SN754410NE




//Control de dos motores
//Robot controlado a partir de un mando a distancia.
//Se encenderán dos LEDs cuando avanze, el de la izquierda cuando gire en esa dirección y el de la derecha cuando gire en esa dirección

#include "WProgram.h"
#include "NECIRrcv.h"
#define IRPIN 12

unsigned long ircode;
NECIRrcv ir(IRPIN);

const int input1=10;
const int input2=11;
const int input3=9;
const int input4=8;

const int Led1=7;
const int Led2=13;

int duracion=0;
unsigned long accion;

void setup()
{
Serial.begin(9600) ;
pinMode(input1, OUTPUT);
pinMode(input2, OUTPUT);
pinMode(input3, OUTPUT);
pinMode(input4, OUTPUT);
pinMode(IRPIN, INPUT);
ir.begin();
pinMode(Led1, OUTPUT);
pinMode(Led2, OUTPUT);
digitalWrite(input1, HIGH);
digitalWrite(input2, HIGH);
digitalWrite(input3, LOW);
digitalWrite(input4, LOW);
}

void loop()
{
while (ir.available())
{
ircode=ir.read();
accion=ircode;
Serial.println(ircode);
if(accion==2707357440)//Si se pulsa el 1 el tiempo de cada movimiento será de 2 sg
{
duracion=2000;
accion=0;
}
if(accion==2724069120)//Si se pulsa el 2 el tiempo de cada movimiento será de 3'4 sg
{
duracion=3400;
accion=0;
}
if(accion==3776904960)//Si se pulsa el 3 el tiempo de cada movimiento será de 6'5 sg
{
duracion=6500;
accion=0;
}
if(accion==3041591040)
{
//Giro sobre si mismo hacia la izquierda
digitalWrite(input1, LOW);//HACIA DELANTE LADO IZQUIERDO
digitalWrite(input2, HIGH);
digitalWrite(input3, HIGH);//HACIA ATRAS LADO DERECHO
digitalWrite(input4, LOW);
digitalWrite(Led1, HIGH);
delay(duracion);
accion=0;
}
if(accion==3058302720)
{
digitalWrite(input1, LOW);//HACIA DELANTE LADO IZQUIERDO
digitalWrite(input2, HIGH);
digitalWrite(input3, LOW);//HACIA DELANTE LADO DERECHO
digitalWrite(input4, HIGH);
digitalWrite(Led1, HIGH);
digitalWrite(Led2, HIGH);
delay(duracion);
accion=0;
}
if(accion==4111138560)
{
//Giro derecha
digitalWrite(input1, HIGH);//PARADO LADO IZQUIERDO
digitalWrite(input2, LOW);
digitalWrite(input3, HIGH);//HACIA ATRAS LADO DERECHO
digitalWrite(input4, LOW);
digitalWrite(Led2, HIGH);
delay(duracion);
accion=0;
}
//Despues de pulsar cada botón la acción durará un tiempo determinado y el robot volverá a pararse
digitalWrite(input1, HIGH);//PARADO LADO IZQUIERDO
digitalWrite(input2, HIGH);
digitalWrite(input3, LOW);//PARADO LADO DERECHO
digitalWrite(input4, LOW);
digitalWrite(Led1, LOW);
digitalWrite(Led2, LOW);
}
}

Robot controlado por Infrarrojos

El siguiente programa nos servirá para poder controlar nuestro robot a partir de un mando a distancia. Asociaremos acciones del robot a diferentes botones. Estas acciones serán girar y avanzar.

Tutorial SN754410NE

Circuito físico:

Integrado SN754410NE
--------------------
Pines 1, 9 y 16 a +5V
Pin 8 a +9-24V
Pines 2, 7 10 y 15 a la placa Arduino
Pines 4, 5, 12 y 13 a ground (Dos de ellos a la placa y dos a la fuente de alimentación)
Pines 3, 6 11 y 14 conectados a los motores

Receptor IR
-----------
1º pin receptor IR al 12 (digital)
2º pin receptor IR a ground
3º pin receptor IR a +5V



Código .pde


//Control de dos motores
//Nuestro robot se mueve segun pulsemos las teclas asociadas en el mando a distancia
#include "WProgram.h"
#include "NECIRrcv.h"
#define IRPIN 12

unsigned long ircode;
NECIRrcv ir(IRPIN);

const int input1=10;
const int input2=11;
const int input3=9;
const int input4=8;

unsigned long accion;

void setup()
{
Serial.begin(9600) ;
pinMode(input1, OUTPUT);
pinMode(input2, OUTPUT);
pinMode(input3, OUTPUT);
pinMode(input4, OUTPUT);
pinMode(IRPIN, INPUT);
ir.begin();
digitalWrite(input1, HIGH);
digitalWrite(input2, HIGH);
digitalWrite(input3, LOW);
digitalWrite(input4, LOW);
}

void loop()
{
while (ir.available())
{
ircode=ir.read();
accion=ircode;
Serial.println(ircode);
if(accion==2724069120)
{
//Giro sobre si mismo hacia la izquierda
digitalWrite(input1, LOW);//HACIA DELANTE LADO IZQUIERDO
digitalWrite(input2, HIGH);
digitalWrite(input3, HIGH);//HACIA ATRAS LADO DERECHO
digitalWrite(input4, LOW);
delay(1100);
accion=0;
}
if(accion==3776904960)
{
digitalWrite(input1, LOW);//HACIA DELANTE LADO IZQUIERDO
digitalWrite(input2, HIGH);
digitalWrite(input3, LOW);//HACIA DELANTE LADO DERECHO
digitalWrite(input4, HIGH);
delay(2500);
accion=0;
}
//Despues de pulsar cada botón la acción durará un tiempo determinado y el robot volverá a pararse
digitalWrite(input1, HIGH);//PARADO LADO IZQUIERDO
digitalWrite(input2, HIGH);
digitalWrite(input3, LOW);//PARADO LADO DERECHO
digitalWrite(input4, LOW);
}
}

Motor driver SN754410

Vamos a realizar un pequeño programa para comenzar a mover dos motores utilizando el integrado SN754410. Para ello tendremos que montar el circuito formando un puente-H para poder controlar el sentido de la corriente al alimentar los motores.

Conexiones para el driver SN754410 (H-bridge):
Pines 1, 9 y 16 a +5V
Pin 8 a +9-24V
Pines 2, 7 10 y 15 a la placa Arduino
Pines 4, 5, 12 y 13 a ground (Dos de ellos a la placa y dos a la fuente de alimentación)
Pines 3, 6 11 y 14 conectados a los motores

Aquí dejo el hipervínculo a un tutorial muy adecuado de como hacer las conexiones con este driver: Tutorial SN754410NE



Código .pde


//Control de dos motores
//Nuestro robot se mueve hacia delante y gira dibujando un pentagono
//Integrado SN754410NE, driver para manejar motores. Sustito de la familia L293

const int input1=10;
const int input2=11;
const int input3=9;
const int input4=8;

void setup()
{
pinMode(input1, OUTPUT);
pinMode(input2, OUTPUT);
pinMode(input3, OUTPUT);
pinMode(input4, OUTPUT);
}

void loop()
{
digitalWrite(input1, LOW);//HACIA DELANTE LADO IZQUIERDO
digitalWrite(input2, HIGH);
digitalWrite(input3, LOW);//HACIA DELANTE LADO DERECHO
digitalWrite(input4, HIGH);
delay(1000);

digitalWrite(input1, HIGH);//PARADO LADO IZQUIERDO
digitalWrite(input2, HIGH);
digitalWrite(input3, LOW);//PARADO LADO DERECHO
digitalWrite(input4, LOW);
delay(200);

//Giro sobre si mismo hacia la izquierda
digitalWrite(input1, LOW);//HACIA DELANTE LADO IZQUIERDO
digitalWrite(input2, HIGH);
digitalWrite(input3, HIGH);//HACIA ATRAS LADO DERECHO
digitalWrite(input4, LOW);
delay(900);

digitalWrite(input1, HIGH);//PARADO LADO IZQUIERDO
digitalWrite(input2, HIGH);
digitalWrite(input3, LOW);//PARADO LADO DERECHO
digitalWrite(input4, LOW);
delay(200);
}

LED 7-segments

Vamos a utilizar un LED de 7-segmentos de ánodo común. Eso significa que la alimentación es común, solo podemos encender y apagar todos los segmentos que deseemos a la vez.
Cada pin que conectemos a tierra será un segmento que se encenderá o apagará en función de la alimentación del 7 segmentos.





//LED 7-segment Common Anode
//Control de un LED 7-segmentos de anodo comúm
//Con este tipo de LEDs tenemos que dejar fijo el caracter que deseemos mostrar
//Varía según se hangan o no las conexiones a tierra de los pines 2-9
//1ºo 10º Pin del LED es el de alimentación
//Pines del 2 al 9 son tomas de tierra, cada una corresponde a un segmento del LED

const int segment7=3;

void setup()
{
pinMode(pin, OUTPUT);
}

void loop()
{
digitalWrite(segment7, HIGH);
delay(1000);
digitalWrite(segment7, LOW);
delay(300);
}

Juegos de luces

Tenemos diez LEDs, que forman seis juegos de luces diferentes. Cada juego está asociado a una tecla del mando a distancia. Luego controlaremos la intensidad de los pines PWM. Otras tres teclas del mando a distancia controlarán la intensidad del brillo de los LEDs PWM.

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

Pines PWM a 6 LEDs
Pines 4, 7, 8, 12 a 4 LEDs
Lados negativos de los LEDS a ground



Código .pde


//En el siguiente programa tendremos 6 juegos de luces, asociados a 6 teclas del mando a distancia
//Podremos elegir la intensidad de las salidas PWM con otros 3 botones (+, - y Enter)

#include "WProgram.h"
#include "NECIRrcv.h"
#define IRPIN 8
unsigned long ircode;
NECIRrcv ir(IRPIN);
const int pinesPWM[]={5,6,9,10};
const int pinesDigitales[]={3,4,7,2,12,11};
int intensidad=1;
int i=0;

void setup()
{
pinMode(IRPIN, INPUT);
for(i=0; i<6; i++)
{
pinMode(pinesDigitales[i], OUTPUT);
if(i<=3)
{
pinMode(pinesPWM[i], OUTPUT);
}
}
ir.begin();
}

void loop ()
{
while (ir.available())
{
ircode=ir.read();
}

if(ircode==3977445120)
{
intensidad=10;
}
if(ircode==3944021760)
{
intensidad=60;
}
if(ircode==3994156800)
{
intensidad=255;
}
//Primer juego de luces
if(ircode==2707357440)
{
for(i=0; i<6; i++)
{
if(i%2==0)
{
analogWrite(pinesPWM[0], intensidad);
analogWrite(pinesPWM[1], intensidad);
analogWrite(pinesPWM[2], 0);
analogWrite(pinesPWM[3], 0);
}
else
{
analogWrite(pinesPWM[0], 0);
analogWrite(pinesPWM[1], 0);
analogWrite(pinesPWM[2], intensidad);
analogWrite(pinesPWM[3], intensidad);
}
digitalWrite(pinesDigitales[i], HIGH);
delay(480);
digitalWrite(pinesDigitales[i], LOW);
}
analogWrite(pinesPWM[0], 0);
analogWrite(pinesPWM[1], 0);
analogWrite(pinesPWM[2], 0);
analogWrite(pinesPWM[3], 0);
}
//Segundo juego de luces
if(ircode==2724069120)
{
for(i=0; i<6; i++)
{
if(i%2==0)
{
analogWrite(pinesPWM[0], intensidad);
analogWrite(pinesPWM[2], intensidad);
analogWrite(pinesPWM[1], 0);
analogWrite(pinesPWM[3], 0);
}
else
{
analogWrite(pinesPWM[0], 0);
analogWrite(pinesPWM[2], 0);
analogWrite(pinesPWM[1], intensidad);
analogWrite(pinesPWM[3], intensidad);
}
digitalWrite(pinesDigitales[i], HIGH);
delay(300);
}
for(i=5; i>=0; i--)
{
if(i%2==0)
{
analogWrite(pinesPWM[0], intensidad);
analogWrite(pinesPWM[2], intensidad);
analogWrite(pinesPWM[1], 0);
analogWrite(pinesPWM[3], 0);
}
else
{
analogWrite(pinesPWM[0], 0);
analogWrite(pinesPWM[2], 0);
analogWrite(pinesPWM[1], intensidad);
analogWrite(pinesPWM[3], intensidad);
}
digitalWrite(pinesDigitales[i], LOW);
delay(300);
}
analogWrite(pinesPWM[0], 0);
analogWrite(pinesPWM[2], 0);
analogWrite(pinesPWM[1], 0);
analogWrite(pinesPWM[3], 0);
}
//Tercer juego de luces
if(ircode==3776904960)
{
digitalWrite(pinesDigitales[2], HIGH);
digitalWrite(pinesDigitales[3], HIGH);
delay(280);
digitalWrite(pinesDigitales[1], HIGH);
digitalWrite(pinesDigitales[4], HIGH);
delay(280);
digitalWrite(pinesDigitales[0], HIGH);
digitalWrite(pinesDigitales[5], HIGH);
delay(280);
analogWrite(pinesPWM[1], intensidad);
analogWrite(pinesPWM[2], intensidad);
delay(280);
analogWrite(pinesPWM[0], intensidad);
analogWrite(pinesPWM[3], intensidad);
delay(280);
for(i=0; i<6; i++)
{
digitalWrite(pinesDigitales[i], LOW);
}
for(i=0; i<4; i++)
{
analogWrite(pinesPWM[i], 0);
}
delay(180);
}
//Cuarto juego de luces
if(ircode==3041591040)
{
digitalWrite(pinesDigitales[2], HIGH);
digitalWrite(pinesDigitales[3], LOW);
digitalWrite(pinesDigitales[1], LOW);
digitalWrite(pinesDigitales[4], HIGH);
digitalWrite(pinesDigitales[0], HIGH);
digitalWrite(pinesDigitales[5], LOW);
analogWrite(pinesPWM[0], intensidad);
analogWrite(pinesPWM[2], intensidad);
analogWrite(pinesPWM[1], 0);
analogWrite(pinesPWM[3], 0);
delay(220);
digitalWrite(pinesDigitales[2], LOW);
digitalWrite(pinesDigitales[3], HIGH);
digitalWrite(pinesDigitales[1], HIGH);
digitalWrite(pinesDigitales[4], LOW);
digitalWrite(pinesDigitales[0], LOW);
digitalWrite(pinesDigitales[5], HIGH);
analogWrite(pinesPWM[0], 0);
analogWrite(pinesPWM[2], 0);
analogWrite(pinesPWM[1], intensidad);
analogWrite(pinesPWM[3], intensidad);
delay(220);
for(i=0; i<6; i++)
{
digitalWrite(pinesDigitales[i], LOW);
}
for(i=0; i<4; i++)
{
analogWrite(pinesPWM[i], 0);
}
}
//Quinto juego de luces
if(ircode==3058302720)
{
digitalWrite(pinesDigitales[2], HIGH);
analogWrite(pinesPWM[3], intensidad);
delay(280);
digitalWrite(pinesDigitales[1], HIGH);
analogWrite(pinesPWM[2], intensidad);
delay(280);
digitalWrite(pinesDigitales[0], HIGH);
digitalWrite(pinesDigitales[5], HIGH);
delay(280);
analogWrite(pinesPWM[1], intensidad);
digitalWrite(pinesDigitales[4], HIGH);
delay(280);
analogWrite(pinesPWM[0], intensidad);
digitalWrite(pinesDigitales[3], HIGH);
delay(280);
for(i=0; i<6; i++)
{
digitalWrite(pinesDigitales[i], LOW);
}
for(i=0; i<4; i++)
{
analogWrite(pinesPWM[i], 0);
}
delay(180);
}
//Sexto juego de luces
if(ircode==4111138560)
{
digitalWrite(pinesDigitales[0], HIGH);
delay(180);
digitalWrite(pinesDigitales[1], HIGH);
analogWrite(pinesPWM[1], intensidad);
delay(180);
digitalWrite(pinesDigitales[2], HIGH);
analogWrite(pinesPWM[0], intensidad);
delay(180);
analogWrite(pinesPWM[3], intensidad);
digitalWrite(pinesDigitales[3], HIGH);
delay(180);
analogWrite(pinesPWM[2], intensidad);
digitalWrite(pinesDigitales[4], HIGH);
delay(180);
digitalWrite(pinesDigitales[5], HIGH);
delay(180);
digitalWrite(pinesDigitales[5], LOW);
delay(180);
analogWrite(pinesPWM[2], 0);
digitalWrite(pinesDigitales[4], LOW);
delay(180);
analogWrite(pinesPWM[3], 0);
digitalWrite(pinesDigitales[3], LOW);
delay(180);
digitalWrite(pinesDigitales[2], LOW);
analogWrite(pinesPWM[0], 0);
delay(180);
digitalWrite(pinesDigitales[1], LOW);
analogWrite(pinesPWM[1], 0);
delay(180);
digitalWrite(pinesDigitales[0], LOW);
delay(180);
}
}

L293E

En el siguiente montaje moveremos un motor en ambas direcciones. Para el manejo de las corrientes se utiliza un driver L293E. Consultar datasheet para el montaje del circuito. Los diodos son necesarios, ya que no están integrados en el driver.


Datasheet L293E



//Control de un motor en ambos sentidos
//Integrado L293E son necesarios los diosos rectificadores (No están integrados en el chip). Consultar datasheet.

const int input1=10;
const int input2=11;

void setup()
{
pinMode(input1, OUTPUT);
pinMode(input2, OUTPUT);
}

void loop()
{
digitalWrite(input1, LOW);//HACIA DELANTE LADO IZQUIERDO
digitalWrite(input2, HIGH);
delay(1000);

digitalWrite(input1, HIGH);//HACIA ATRAS LADO IZQUIERDO
digitalWrite(input2, LOW);
delay(1000);

digitalWrite(input1, HIGH);//PARADO LADO IZQUIERDO
digitalWrite(input2, HIGH);
delay(1000);
}

Sensor Luz & Piezo

Vamos a controlar una serie de LEDs a partir de un sensor de luz y un sensor piezoeléctrico. Cuando haya poca luz ambiente los LEDs generarán un juego de luces. Este juego de luces irá cambiando a cada golpe recibido por el sensor piezoeléctrico.

El circuito lo implementaremos de la siguiente manera:
8 LEDs númerados desde el pin 6 al 13 (digitales)
8 LEDs a ground

+ Lado positivo sensor Luz a +5V
+ Lado positivo sensor Luz a pin 4 (analógico)
- Lado negativo sensor Luz a ground

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



Código .pde


//El siguiente circuito generará diferentes juegos de luces según los golpes que reciba el sensor piezoeléctrico.
//Los LEDs se activarán cuando no haya casi luz ambiente.

const int vectorLED[]={6,7,8,9,10,11,12,13};
const int sensorLuz=5;
const int sensorPiezo=4;
int valorPiezo=0;
int valorLuz=0;
int sensorMax=0;
int sensorMin=1022;
int contadorPiezo=0;
int i=0;

void setup()
{
Serial.begin(9600);
pinMode(sensorPiezo,INPUT);
pinMode(sensorLuz,INPUT);
for(i=0; i<8; i++)
{
pinMode(vectorLED[i], OUTPUT);
}
digitalWrite(13, HIGH);
while(millis()<5000)
{
valorLuz=analogRead(sensorLuz);
if(valorLuz>sensorMax)
{
sensorMax=valorLuz;
}
if (valorLuz {
sensorMin=valorLuz;
}
}
digitalWrite(13, LOW);
}

void loop()
{
valorLuz=analogRead(sensorLuz);
valorLuz=map(valorLuz, sensorMin, sensorMax, 0, 255);
valorLuz=constrain(valorLuz, 0, 255);
valorPiezo=analogRead(sensorPiezo);
if(valorPiezo<40)
{
contadorPiezo++;
}
if(valorLuz>200 && (contadorPiezo%5)==1)
{
do{
for(i=0; i<8; i++)
{
digitalWrite(vectorLED[i], HIGH);
delay(120);
}
for(i=7; i>=0; i--)
{
delay(120);
digitalWrite(vectorLED[i], LOW);
}
valorLuz=analogRead(sensorLuz);
valorLuz=map(valorLuz, sensorMin, sensorMax, 0, 255);
valorLuz=constrain(valorLuz, 0, 255);
}while(valorLuz>200);
}
if(valorLuz>200 && (contadorPiezo%5)==2)
{
do{
for(i=0; i<8; i+=2)
{
digitalWrite(vectorLED[i], HIGH);
delay(120);
}
for(i=1; i<8; i+=2)
{
digitalWrite(vectorLED[i], HIGH);
delay(120);
}
for(i=7; i>=0; i--)
{
digitalWrite(vectorLED[i], LOW);
}
valorLuz=analogRead(sensorLuz);
valorLuz=map(valorLuz, sensorMin, sensorMax, 0, 255);
valorLuz=constrain(valorLuz, 0, 255);
}while(valorLuz>200);
}
if(valorLuz>200 && (contadorPiezo%5)==3)
{
delay(300);
digitalWrite(vectorLED[0], HIGH);
digitalWrite(vectorLED[1], HIGH);
delay(300);
digitalWrite(vectorLED[4], HIGH);
digitalWrite(vectorLED[5], HIGH);
digitalWrite(vectorLED[0], LOW);
digitalWrite(vectorLED[1], LOW);
delay(300);
digitalWrite(vectorLED[2], HIGH);
digitalWrite(vectorLED[3], HIGH);
digitalWrite(vectorLED[4], LOW);
digitalWrite(vectorLED[5], LOW);
delay(300);
digitalWrite(vectorLED[6], HIGH);
digitalWrite(vectorLED[7], HIGH);
digitalWrite(vectorLED[2], LOW);
digitalWrite(vectorLED[3], LOW);
delay(300);
digitalWrite(vectorLED[6], LOW);
digitalWrite(vectorLED[7], LOW);
}
if(valorLuz>200 && (contadorPiezo%5)==4)
{
for(i=0; i<8; i++)
{
digitalWrite(vectorLED[i], HIGH);
delay(60);
digitalWrite(vectorLED[i-1], LOW);
delay(60);
}
digitalWrite(vectorLED[7], LOW);
}
if(valorLuz>200 && (contadorPiezo%5)==0)
{
for(i=0; i<8; i++)
{
valorPiezo=analogRead(sensorPiezo);
if(valorPiezo<40)
{
contadorPiezo++;
}
digitalWrite(vectorLED[i], LOW);
}
}
}

Drivers para motores CC

Aquí dejo un pequeño ejemplo de como utilizar un integrado L293E. Este circuito es un driver que nos servirá para poder controlar motores de corriente continua. Ante cualquier duda, consultar datasheet. El único integrado de la familia L293 que no necesita los diodos rectificadores es el D. Todos los demas, incluido el de este ejemplo es necesario incluir los diodos.

L293E

El circuito lo implementaremos de la siguiente manera:

1º pin enable al pin 2 (digital)
2º pin input al pin 3 (digital)
3º pin output a +Motor
4º pin resistor a ground (-Alimentacion)
5º pin ground a ground (-Alimentacion)
6º pin ground a ground (-Alimentacion)
7º pin resistor a ground (-Alimentacion)
10º pin power supply a + Alimentacion
11º pin enable al pin 5 (digital)
12º pin input al pin 6 (digital)
13º pin output a +Motor
14º pin resistor a ground (-Alimentacion)
15º pin ground a ground (-Alimentacion)
16º pin ground a ground (-Alimentacion)
17º pin resistor a ground (-Alimentacion)
20º pin a +5V

Esta es una forma muy sencilla para comenzar a utilizar el integrado L293E. Más adelante veremos como controlar dos motores en ambos sentidos, este diseño nos permitirá cualquier clase de movimiento para nuestro robot.







//Control de Motores una direccion

const int enable1=2;
const int enable2=5;
const int motor1=3;
const int motor2=6;

void setup()
{
pinMode(motor1, OUTPUT);
pinMode(motor2, OUTPUT);
pinMode(enable1, OUTPUT);
pinMode(enable2, OUTPUT);
}

void loop()
{
digitalWrite(enable2, HIGH);
digitalWrite(enable1, HIGH);
digitalWrite(motor1, HIGH);
digitalWrite(motor2, LOW);//PARADO
delay(100);
digitalWrite(enable2, HIGH);
digitalWrite(enable1, HIGH);
digitalWrite(motor1, LOW);
digitalWrite(motor2, HIGH);//GIRO IZQUIERDA
delay(4000);

digitalWrite(enable2, HIGH);
digitalWrite(enable1, HIGH);
digitalWrite(motor1, HIGH);
digitalWrite(motor2, LOW);//PARADO
delay(100);
digitalWrite(enable1, HIGH);
digitalWrite(enable2, LOW);
digitalWrite(motor1, LOW);
digitalWrite(motor2, LOW);//HACIA DELANTE
delay(2000);

digitalWrite(enable2, HIGH);
digitalWrite(enable1, HIGH);
digitalWrite(motor1, HIGH);
digitalWrite(motor2, LOW);//PARADO
delay(100);
digitalWrite(enable2, HIGH);
digitalWrite(enable1, HIGH);
digitalWrite(motor1, LOW);
digitalWrite(motor2, HIGH);//GIRO IZQUIERDA
delay(5000);
}

Sensores IR IV

Encenderemos o apagaremos los LEDs en función de lo que reciban los sensores IR. Si se encuentra algún objeto en su campo de visión los LEDs se encenderán.

El circuito lo montaremos de la siguiente manera:
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 4
Conectamos el receptor IR a la entrada del pin analogico 4
Conectamos +5V al emisor IR
Conectamos -Ground al receptor

Conectamos los LEDs a los pines 12 y 13 (digital)
Conectamos lado negativo de los LEDs a ground





//Encendemos el LED cuando uno de los dos sensores recibe presencia de un objeto
//Dará problemas utilizando dos de estos sensores si utilizamos la toma de tierra del ordenador si lo alimentamos por el puerto USB.
//Sino conectamos el ordenador a un enchufe con toma de tierra funcionará como ***'deseamos'
//Es recomendable no utilizar mas de dos sensores IR en el mismo circuito

const int sensorInfrarojo1=3;
const int azul=13;
const int emisor1=2;

const int sensorInfrarojo2=4;
const int verde=12;
const int emisor2=3;

int sensorValor1=0;
int sensorValor2=0;

void setup()
{
pinMode(sensorInfrarojo1, INPUT);
pinMode(azul, OUTPUT);
pinMode(emisor1, OUTPUT);
pinMode(sensorInfrarojo2, INPUT);
pinMode(verde, OUTPUT);
pinMode(emisor2, 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
}

void loop()
{
sensorValor1=analogRead(sensorInfrarojo1);//Leemos los dos valores de los sensores
sensorValor2=analogRead(sensorInfrarojo2);//Un valor no lo evaluamos en el if ***(Interferencias en el circuito por falta de toma de tierra)
if((sensorValor1/5)>130)//De esta manera encendemos el LED cuando hay algo cerca de ambos sensores
{
digitalWrite(azul, HIGH);
digitalWrite(verde, HIGH);
}
else
{
digitalWrite(azul, LOW);
digitalWrite(verde, LOW);
}
}

Matriz de LEDs

El siguiente programa simula una matriz de LEDs controlada remotamente por un receptor infrarrojo. Cada LED que forma la matriz será controlado por un único botón del mando a distancia. Cada LED puede ser encendido o apagado independientemente del resto.

El circuito lo implementaremos de la siguiente manera:
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

Pines del 2 al 11 formarán un vector de LEDs, simularán una matriz 2x5 en nuestra protoboard
Lado negativo de los LEDs a ground





//Cada LED numerado del 1 al 10 se encenderá y apagará cuando marquemos su número en el mando a distancia.
//Cada LED se enciende y apaga independientemente del resto con su propio botón del mando a distancia.

#include "WProgram.h"
#include "NECIRrcv.h"
#define IRPIN 12
unsigned long ircode;

const int pinesLED[]={2,3,4,5,6,7,8,9,10,11};
int i=0;
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;

NECIRrcv ir(IRPIN);

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

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((a1%2)==1)
{
digitalWrite(pinesLED[0], HIGH);
}
else
{
digitalWrite(pinesLED[0], LOW);
}
if((a2%2)==1)
{
digitalWrite(pinesLED[1], HIGH);
}
else
{
digitalWrite(pinesLED[1], LOW);
}
if((a3%2)==1)
{
digitalWrite(pinesLED[2], HIGH);
}
else
{
digitalWrite(pinesLED[2], LOW);
}
if((a4%2)==1)
{
digitalWrite(pinesLED[3], HIGH);
}
else
{
digitalWrite(pinesLED[3], LOW);
}
if((a5%2)==1)
{
digitalWrite(pinesLED[4], HIGH);
}
else
{
digitalWrite(pinesLED[4], LOW);
}
if((a6%2)==1)
{
digitalWrite(pinesLED[5], HIGH);
}
else
{
digitalWrite(pinesLED[5], LOW);
}
if((a7%2)==1)
{
digitalWrite(pinesLED[6], HIGH);
}
else
{
digitalWrite(pinesLED[6], LOW);
}
if((a8%2)==1)
{
digitalWrite(pinesLED[7], HIGH);
}
else
{
digitalWrite(pinesLED[7], LOW);
}
if((a9%2)==1)
{
digitalWrite(pinesLED[8], HIGH);
}
else
{
digitalWrite(pinesLED[8], LOW);
}
if((a10%2)==1)
{
digitalWrite(pinesLED[9], HIGH);
}
else
{
digitalWrite(pinesLED[9], LOW);
}
}

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