Control Analógico

Vamos a implementar un programa muy sencillo para observar como controlar las salidas PWM de nuestro arduino. Los pines 3,5,6,9,10 y 11 tienen la posibilidad de funcionar como salidas analógicas.
El programa encenderá un LED poco a poco, subiendo su intensidad, mientras que otro LED se irá apagando reduciendo su intensidad.

El circuito lo montaremos de la siguiente manera:

+ LED1 al pin 3
+ LED2 al pin 5
- LED1 y 2 a ground







//Control Analogico de dos LED's

int potencia=0;
const int led1=3;
const int led2=5;

void setup()
{
pinMode(led1, OUTPUT);
pinMode(led2, OUTPUT);
}

void loop()
{
digitalWrite(led1, LOW);
for(potencia=0; potencia<255; potencia++)
{
analogWrite(led1, potencia);
delay(20);
}
digitalWrite(led1, LOW);
digitalWrite(led2, HIGH);
for(potencia=255; potencia>0; potencia--)
{
analogWrite(led2, potencia);
delay(20);
}
digitalWrite(led2, LOW);
}

Control de LEDs con un botón

Vamos a utilizar un botón para encender y apagar LEDs según deseemos. Tendremos 5 posibles opciones que se irán repitiendo cada vez que pulsemos el botón. La primera los dos LEDs simples y el tricolor apagados.
La segunda, un LED simple encendido. La tercera, el otro LED simple encendido. La cuarta, encenderemos únicamente el LED tricolor y la quinta y última opción tendremos los tres LEDs encendidos.


El circuito físico lo implementaremos 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)

+ LED1 al pin 1 (digital)
- LED1 a ground
+ LED2 al pin 2 (digital)
- LED2 a ground

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






//Controla los LED's en funcion del pulsador

int rojo=11;
int verde=10;
int azul=9;
const int LED1=1;
const int LED2=2;
int pulsador=3;
int contadorPulsador=0;
int last_time=0;
int estado=0;
int aux=1;

void setup()
{
pinMode(rojo, OUTPUT);
pinMode(verde, OUTPUT);
pinMode(azul, OUTPUT);
pinMode(LED1, OUTPUT);
pinMode(LED2, OUTPUT);
pinMode(pulsador, INPUT);
}

void loop()
{
estado=digitalRead(pulsador);
if(estado!=last_time)
{
if(estado==HIGH)
{
contadorPulsador++;
aux+=1;
}
last_time=estado;
}

if(contadorPulsador%5==2)
{
digitalWrite(LED1, HIGH);
digitalWrite(LED2, LOW);
analogWrite(rojo,0);
analogWrite(verde,0);
analogWrite(azul,0);
}
if(contadorPulsador%5==3)
{
digitalWrite(LED1, LOW);
digitalWrite(LED2, HIGH);
analogWrite(rojo,0);
analogWrite(verde,0);
analogWrite(azul,0);
}
if(contadorPulsador%5==4)
{
digitalWrite(LED1, LOW);
digitalWrite(LED2, LOW);
if(aux%4==0)
{
analogWrite(rojo,0);
analogWrite(verde,255);
analogWrite(azul,0);
}
if(aux%4==1)
{
analogWrite(rojo,0);
analogWrite(verde,255);
analogWrite(azul,0);
}
if(aux%4==2)
{
analogWrite(rojo,255);
analogWrite(verde,255);
analogWrite(azul,0);
}
if(aux%4==3)
{
analogWrite(rojo,128);
analogWrite(verde,0);
analogWrite(azul,128);
}
}
if(contadorPulsador%5==0)
{
digitalWrite(LED1, HIGH);
digitalWrite(LED2, HIGH);
if(aux%4==0)
{
analogWrite(rojo,0);
analogWrite(verde,255);
analogWrite(azul,0);
}
if(aux%4==1)
{
analogWrite(rojo,0);
analogWrite(verde,255);
analogWrite(azul,0);
}
if(aux%4==2)
{
analogWrite(rojo,255);
analogWrite(verde,255);
analogWrite(azul,0);
}
if(aux%4==3)
{
analogWrite(rojo,128);
analogWrite(verde,0);
analogWrite(azul,128);
}
}
if(contadorPulsador%5==1)
{
digitalWrite(LED1, LOW);
digitalWrite(LED2, LOW);
analogWrite(rojo,0);
analogWrite(verde,0);
analogWrite(azul,0);
}
aux++;
}

Generar colores con un LED tricolor

Vamos a utilizar un LED tricolor. Generaremos una serie de colores predeterminados y algunos aleatorios. El LED esta compuesto por 4 patillas, 3 de control de color y una toma a tierra. EL pin más largo es el segundo, toma a tierra, el primer pin controla la intensidad del rojo, el tercer pin controla la intensidad del verde y el cuarto pin controla la intensidad del azul.



El circuito físico lo implementaremos de la siguiente manera:
+ 1º pin LED al pin 9 (digital)
- 2º pin LED al pin a ground
+ 3º pin LED al pin 10 (digital)
+ 4º pin LED al pin 11 (digital)






//Cambia de color un LED tricolor

int redPin=9;
int greenPin=10;
int bluePin=11;
int color1=0;
int color2=0;
int color3=0;
int aux=0;

void setup()
{
pinMode(redPin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(bluePin, OUTPUT);
}

void loop()
{
color1++;
color2++;
color3++;
aux++;
if(color1>255)
{
color1=0;
}
color2+=4;
color3+=8;
if(color2>255)
{
color2=0;
}
color3+=5;
if(color3>255)
{
color3=0;
}
analogWrite(redPin,color1);
analogWrite(greenPin,color2);
analogWrite(bluePin,color3);
delay(500);
if(aux%4==0)
{
analogWrite(redPin,0);
analogWrite(greenPin,255);
analogWrite(bluePin,0);
}
if(aux%4==1)
{
analogWrite(redPin,0);
analogWrite(greenPin,255);
analogWrite(bluePin,0);
}
if(aux%4==2)
{
analogWrite(redPin,255);
analogWrite(greenPin,255);
analogWrite(bluePin,0);
}
if(aux%4==3)
{
analogWrite(redPin,128);
analogWrite(greenPin,0);
analogWrite(bluePin,128);
}
delay(500);
}

Encendido/apagado de LEDs con un botón

El siguiente código encenderá un par de LEDs cuando pulsemos el botón, y los apagará cuando volvamos a pulsar el botón.
Básicamente es un interruptor como puedes encontrar en tu casa.

El circuito físico lo implementaremos de la siguiente manera:
+ LED1 al pin 13 (digital)
+ LED2 al pin 3 (digital)
- LED1 y 2 a Ground
+ Boton al pin 2 (digital)
+ 5V al lado positivo del botón
- Boton a Ground
Es recomendable utilizar resistencias para los LEDs y para la alimentación del botón.







//El programa enciende y apaga los LED's cuando presionamos el boton/interruptor

const int pinLed=13;
const int pinBoton=2;
const int pinLed2=3;

int estadoBoton=0;
int ultimoEstadoBoton=0;
int contadorBoton=0;

void setup()
{
pinMode(pinLed, OUTPUT);
pinMode(pinBoton, INPUT);
pinMode(pinLed2, OUTPUT);
}

void loop()
{
estadoBoton=digitalRead(pinBoton);
if(estadoBoton!=ultimoEstadoBoton)
{
if(estadoBoton==HIGH)
{
contadorBoton++;
}
ultimoEstadoBoton=estadoBoton;
}
if(contadorBoton%2==1)
{
digitalWrite(pinLed, LOW);
digitalWrite(pinLed2, LOW);
}
else
{
digitalWrite(pinLed, HIGH);
digitalWrite(pinLed2, HIGH);
}
}

Crear melodías con un timbre

Vamos a utilizar un par de funciones para tocar una melodía, modificando los valores de las variables siguientes podemos modificar la melodía tocada.
length representa el número de notas, notes[] hace referencia a la frecuencia de cada nota, y
beats[] que representa la duración de cada nota.


El circuito físico lo implementaremos de la siguiente manera:
+ Lado positivo del timbre al pin 9 (digital)
- Lado negativo a ground





Aquí está el código:


const int speakerPin = 9;
int length = 19; // the number of notes
char notes[] = "cde cdef efg abC bC"; // a space represents a rest
int beats[] = { 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1, 1, 2, 4, 1, 2, 3, 4 };
int tempo = 300;
int i=0;

void playTone(int tone, int duration)
{
for (long i=0; i < (duration*1000L) ; i+=tone*2)
{
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 };
// play the tone corresponding to the note name
for (int i=0; i<8; i++)
{
if (names[i] == note)
{
playTone(tones[i], duration);
}
}
}

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

void loop()
{
for (i=0; i<(length); i++)
{
if (notes[i] == ' ')
{
delay(beats[i]*tempo); // rest
}
else
{
playNote(notes[i], beats[i]*tempo);
}
// pause between notes
delay(70);
}
}

Toma de contacto con un botón

El siguiente código encenderá un LED cuando mantengamos presionado un botón.

El circuito físico lo implementaremos de la siguiente manera:
+ LED al pin 13 (digital)
- LED a Ground
+ Boton al pin 2 (digital)
+ 5V al pin positivo del botón
- Boton a Ground
Es recomendable utilizar dos resistencias, una para el LED y otra para la entrada de +5V del botón.






//LED controlado con la presión de un botón.

const int pinLed=13;
const int pinBoton=2;
int estadoBoton=0;
int aux=0;

void setup()
{
pinMode(pinLed, OUTPUT);
pinMode(pinBoton, INPUT);
}

void loop()
{
estadoBoton=digitalRead(pinBoton);
while(estadoBoton==aux)
{
digitalWrite(pinLed, HIGH);
estadoBoton=digitalRead(pinBoton);
}
while(estadoBoton!=aux)
{
digitalWrite(pinLed, LOW);
estadoBoton=digitalRead(pinBoton);
}
}

Primera prueba

Nada mas adquirir un Arduino vamos a comprobar el correcto funcionamiento de la placa.
Este miniprograma enciende y apaga un par de LEDs simultaneamente.

El circuito físico lo vamos a implementar de la siguiente manera:
Lado + LED1 conectado al pin 13 (digital)
Lado + LED2 conectado al pin 2 (digital)
Lado - LED 1 y 2 conectado al pin ground (toma de tierra)

Es recomendable utilizar una resistencia antes de alimentar un LED ya que podríamos reventarlo si nos pasamos de tensión (Consultar datasheet de tus LEDs y sistema de numeración para las resistencias).




//Encendemos dos LED's intermitentemente.

int ledPinA=13;
int ledPinB=2;

void setup()
{
pinMode(ledPinA, OUTPUT);
pinMode(ledPinB, OUTPUT);
}

void loop()
{
digitalWrite(ledPinA, HIGH);
digitalWrite(ledPinB, LOW);
delay(333);
digitalWrite(ledPinA, LOW);
digitalWrite(ledPinB, HIGH);
delay(1000);
}