TRABAJANDO CON LEDs.

Haz "clic" en los enlaces para visualizar el vídeo de su funcionamiento.

INTERMITENCIA LED.

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

void loop(){
digitalWrite(13, HIGH);
delay(200);
digitalWrite(13, LOW);
delay(200);
}


INTERMITENCIA ALTERNATIVA DE DOS LEDS.

int led1=4;
int led2=5;

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

void loop(){
digitalWrite(led1, HIGH);
digitalWrite(led2, LOW);
delay(200);
digitalWrite(led1, LOW);
digitalWrite(led2, HIHG);
delay(200);
}

INTERMITENCIA SIMULTÁNEA LED-ZUMBADOR.

int LED=4;

int beep=5;

void setup(){
pinMode(LED, OUTPUT);
pinMode(beep,OUTPUT);
}

void loop(){
digitalWrite(LED, HIGH);
digitalWrite(beep, HIGH);
delay(1000);
digitalWrite(LED, LOW);
digitalWrite(beep, LOW);
delay(1000);
}


CONTROL DE LA INTENSIDAD DE BRILLO DE UN LED.

int LED=9;
int brightness=0;
int fadesteps=5;

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

void loop(){
analogWrite(LED, brightness);
brightness = brightness + fadesteps;
delay(25);
if (brightness == 0 || brightness == 255) {
fadesteps = - fadesteps ;
}
}


CONTROL DE UN LED MEDIANTE UN PULSADOR.

int LEDblue=6;
int pushbutton=7;
int buttonstate=0;

void setup(){
pinMode(LEDblue, OUTPUT);
pinMode(pushbutton, INPUT);
}

void loop(){
buttonstate =digitalRead(pushbutton);
if (pushbutton == HIGH){
digitalWrite(LEDblue, HIGH);
delay (5000);
digitalWrite(LEDblue, LOW);
}
else{
digitalWrite(LEDblue, LOW);
}
}


CONTROL DE TRES LEDS CON DOS PULSADORES.

int pulsadorderecho = 0;
int pulsadorizquierdo = 0;

void setup(){
pinMode(2,OUTPUT);
pinMode(3,OUTPUT);
pinMode(4,OUTPUT);
pinMode(7,INPUT);
pinMode(8,INPUT);
Serial.begin(9600);
}

void loop(){
pulsadorderecho = digitalRead(7);
pulsadorizquierdo = digitalRead(8);
  if (pulsadorderecho == HIGH) {
    digitalWrite(2, HIGH);
    }
  else {
    digitalWrite(2, LOW);
  }
  if (pulsadorizquierdo == HIGH) {
    digitalWrite(4, HIGH);
  }
  else {
    digitalWrite(4, LOW);
  }
  if (pulsadorderecho == HIGH && pulsadorizquierdo == HIGH) {
        digitalWrite(2, HIGH);
        digitalWrite(3, HIGH);
        digitalWrite(4, HIGH);
        delay(250);
        digitalWrite(2, LOW);
        digitalWrite(3, LOW);
        digitalWrite(4, LOW);
        delay(250);
  }
  else {
    digitalWrite(3, LOW);    
  }
}


LED PULSANTE CON DESVANECIMIENTO.

int ledPin = 3;

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

void loop (){
for (int x=0; x<180; x++){
float sinVal = sin(x*3.1412/180);
int ledVal = int(sinVal*255);
analogWrite(ledPin, ledVal);
delay(50);
}
}


SECUENCIA DE UN SEMÁFORO.

const int redLedPin = 2;       // pin del led
const int orangeLedPin = 3; // pin del led
const int greenLedPin = 4;   // pin del led

void setup() {

// configuramos los tres pines de salida
pinMode(redLedPin, OUTPUT);
pinMode(orangeLedPin, OUTPUT);
pinMode(greenLedPin, OUTPUT);
}

void loop() {

//ciclo en rojo
digitalWrite(orangeLedPin, LOW);  //apagamos el naranja
digitalWrite(redLedPin, HIGH);      //encendemos el rojo
delay(9000);//está en rojo 9s

//ciclo en verde
digitalWrite(redLedPin, LOW);       //apagamos el rojo
digitalWrite(greenLedPin, HIGH);  //encendemos el verde
delay(8000);//está en dverde 8s

//ciclo en naranja
digitalWrite(greenLedPin, LOW);    //apagamos el verde
digitalWrite(orangeLedPin, HIGH); //encendemos el naranja
delay(1000);                                      //está en naranja 1s
}


CONTROL DE SEMÁFORO CON PULSADOR.

const int redLedPin = 2;                    // pin del led
const int orangeLedPin = 3;              // pin del led
const int greenLedPin = 4;                // pin del led
const int buttonPin = 5;                     // pin del botón
int lightStatus =0;                              //led que se debe encender en cada momento

void setup() {

// configuramos los tres pines de salida
pinMode(redLedPin, OUTPUT);
pinMode(orangeLedPin, OUTPUT);
pinMode(greenLedPin, OUTPUT);

//Configuramos el botón de entrada
pinMode(buttonPin, INPUT);
digitalWrite(buttonPin, HIGH);         // se activa la resistencia de pull-up
}

void loop() {
if (!digitalRead(buttonPin)){              // si se pulsa
lightStatus = 1;                                    //se fuerza a verde
}

//dependiendo de la luz que se debe mostrar tiene distintos parámetros la llamada
switch (lightStatus){
case 0:                                                 //red
showLight(redLedPin,3000);
break;
case 1:                                                 // green
showLight(greenLedPin,2000);
break;
case 2:                                                 // orange
showLight(orangeLedPin,1000);
break;
}
}

/**
 * Enciende el led que se le indique.
 * Los parámetros son el led a encender y el tiempo que debe estar encendido
 */

void showLight(int ledPin, int maxTime){
static int lastPin = 0; //último led encendido
static unsigned long startTime =0;               //tiempo desde que se encendió el led

/* Si el led actualmente encendido no concuerda con el que se debe encender
* entonces apagar el led encendido, encender el nuevo y poner el contador de tiempo a 0 */

if (ledPin != lastPin){
startTime = millis();
digitalWrite(lastPin, LOW);
lastPin = ledPin;
digitalWrite(ledPin, HIGH);
delay(1);
}

unsigned long elapsedTime = millis()-startTime;   //tiempo pasado desde que se encendió el led
if ((elapsedTime)> maxTime ){                              // si es mayor que lo esperado, pasar al siguiente ciclo de led
lightStatus++;
if (lightStatus > 2) lightStatus =0;                           // sólo hay 3 led, comenzamos de nuevo por el 0
}
}


CONTADOR BINARIO DE 4 BITS.

const byte ledPin[] = {2,3,4,5};             //Leds a utilizar
int count=0;                                            //contador
unsigned long changeTime;                   //contador de tiempo

void setup() {
for (int x=0; x<10; x++) {
pinMode(ledPin[x], OUTPUT);             //los preparamos para salida
}
}

void loop() {
if ((millis() - changeTime) > 1000) {      //si ha pasado 1000 milisegundos contar uno mas
count ++;
setNumber();                                           //ponemos el numero en los leds
changeTime = millis();                            //inicia el condador de tiempo a 0
}
}

void setNumber (){
if (count>15) count = 0;                          //volver a empezar si es mayor de 4 bits
for (int i = 0; i<4;i++){                           //para cada bit mira si tiene que encender el led correspondiente
digitalWrite(ledPin[i], (count >> i) & 1);
}
}


SIMULACIÓN LEDS RGB.
float RGBfrom[3];                        //valores iniciales
float RGBto[3];                            //valores destino
float increment[3];                       // incrementos

// pines de salida pwm
int redPin = 3;
int greenPin = 5;
int bluePin = 6;

void setup(){
pinMode(redPin, OUTPUT);
pinMode(redPin, OUTPUT);
pinMode(redPin, OUTPUT);
pinMode(A0, INPUT);
randomSeed(analogRead(A0));    //inicializa el random

//comienzo en 0
RGBfrom[0] = 0;
RGBfrom[1] = 0;
RGBfrom[2] = 0;

//valores destino aleatorios
RGBto[0] = random(256);
RGBto[1] = random(256);
RGBto[2] = random(256);
}

void loop(){

//cálculo de incrementos a sumar en cada iteracción
for (int x=0; x<3; x++) {
increment[x] = (RGBfrom[x] - RGBto[x]) / 256;
}

//realizamos las salidas para los cálculos
setOutput();

//se han alcanzado los valores destino
//generamos nuevos valores destino
for (int x=0; x<3; x++) {
RGBto[x] = random(256);
}
}

/***
* Escribe en la salida el valor actual de cada led
* y ajusta el nuevo valor según el incremento calculado
***/

void setOutput(){
//256 iteraciones para llegar al valor destino
for (int x=0; x<256; x++) {
analogWrite (redPin, int(RGBfrom[0]));
analogWrite (greenPin, int(RGBfrom[1]));
analogWrite (bluePin, int(RGBfrom[2]));
delay(10); //ajustable según deseo

//se ajusta el valor desde según el incremento correspondiente
//a cada valor
for (int x=0; x<3; x++) {
RGBfrom[x] -= increment[x];
}
}
}


CONTROL BÁSICO DE UN LED RGB.

int pinRojo = 9;
int pinVerde = 10;
int pinAzul = 11;

void setup()
{
  pinMode(pinRojo, OUTPUT);
  pinMode(pinVerde, OUTPUT);
  pinMode(pinAzul, OUTPUT);
}

void loop()
{
  setColor(0, 255, 255);  // rojo
  delay(500);
  setColor(255, 0, 255);  // verde
  delay(500);
  setColor(255, 255, 0);  // azul
  delay(500);
  setColor(0, 0 , 255);  // amarillo
  delay(500);
  setColor(0, 255, 0);  // morado
  delay(500);
  setColor(255, 0, 150);  // aqua
  delay(500);
  setColor(0, 0, 0);      //blanco
  delay(500);
}

void setColor(int red, int green, int blue)
{
  analogWrite(pinRojo, red);
  analogWrite(pinVerde, green);
  analogWrite(pinAzul, blue);
}


CONTROL DE UN LED RGB CON POTENCIÓMETRO.

int pinRojo = 9;
int pinVerde = 10;
int pinAzul = 11;
int contador =0;

void setup(){
  pinMode(pinRojo, OUTPUT);
  pinMode(pinVerde, OUTPUT);
  pinMode(pinAzul, OUTPUT);
}

void loop(){
  int valor=analogRead(A0);
  valor=map(valor,0,1023,1,10);

  if(contador==0){
    for(int r=255; r>0 ; r--){
      setColor(r, 255,255);
      delay(valor);
    }
  contador++;
  }
  else if(contador==1){
    for(int g=255; g>0 ; g--){
      setColor(255, g,255);
      delay(valor);
    }
  contador++;
  }
  else{
    for(int b=255; b>0 ; b--){
      setColor(255, 255,b);
      delay(valor);
    }
  contador=0;
  }
}

void setColor( int red,  int green,  int blue){
  analogWrite(pinRojo, red);
  analogWrite(pinVerde, green);
  analogWrite(pinAzul, blue);
}