Encender y apagar leds con el mando a distancia.

Er coneho ataca de nuevo: Acabo de hacer mi primer experimento con el mando a distancia y arduino… yupy, funciona… mi hija chispillas y yo to felices. le damos al uno y se enciende el led rojo…jajajaja dominaremos er mundo, Al dos y er naranha, er tré y er verde, er 4 y er amarillo limon. Le damos ar boton de off der mando y se apagan tos. ole ole y ole.
Pero somos más exigentes… y nos gustaria pulsar el uno otra ves y que solo se apague er roho… que los demas se queden ensendidos. que le damo ar dos… pos solo se apague er naranha.
o sea que con er mismo numero se apague o ensienda er led correspondiente.
El codigo usado es el siguiente.
// Sketch para controlar un led RGB con un
// mando a distancia IR con protocolo NEC

#include <WProgram.h>
#include <NECIRrcv.h> //Libreria del protocolo NEC
#define IRPIN 8 // Pin del receptor IR

NECIRrcv ir(IRPIN);

int rojo = 9; //Pin del color ROJO del led RGB
int verde = 10; //Pin del color VERDE del led RGB
int azul = 11; //Pin del color AZUL del led RGB
int amarillo = 12; // pin nuevo

long power = 0xFF00BF00; //Codigo correspondiente al boton POWER del mando a distancia
long butrojo = 0xEF10BF00; //Codigo correspondiente al boton 1 del mando a distancia
long butverde = 0xEE11BF00; //Codigo correspondiente al boton 2 del mando a distancia
long butazul = 0xED12BF00; //Codigo correspondiente al boton 3 del mando a distancia
long butamarillo = 0xEB14BF00; // codigo boton 4

void setup()
{
Serial.begin(9600); //Iniciamos comunicacion serie
Serial.println(“NEC IR code reception”) ;
ir.begin(); //Iniciamos la recepcion IR

pinMode(rojo, OUTPUT);
pinMode(verde,OUTPUT);
pinMode(azul, OUTPUT);
pinMode(amarillo,OUTPUT);
}

void loop()
{
unsigned long ircode; //Variable que contendra el codigo decimal del boton pulsado

while (ir.available())
{
ircode = ir.read(); //Leemos el codigo del boton pulsado
Serial.print(“got code: 0x”) ;
Serial.println(ircode,HEX) ;
if (ircode == power) //Si el boton de power… apagamos el led
{
digitalWrite(rojo, LOW);
digitalWrite(verde, LOW);
digitalWrite(azul, LOW);
digitalWrite(amarillo, LOW);
}
else if (ircode == butrojo) digitalWrite(rojo,HIGH); //Si boton 1, encendemos color rojo
else if (ircode == butverde) digitalWrite(verde,HIGH); //Si boton 2, encendemos color verde
else if (ircode == butazul) digitalWrite(azul,HIGH); //Si boton 3, encendemos color azul
else if (ircode == butamarillo) digitalWrite(amarillo,HIGH); //si boton 4 enciende amarillo
}
}
Muchas grasias por adelantao… Er ficus y la chispillas

Hola, no lo he podido probar aún, pero creo que esto podría funcionar. Se puede mejorar aún más para evitar que el código tome un click como que fué 2 clicks, por eso el Delay.

Lo armé para el rojo, de ahí habría que armar los demás. El de prender todos o apagar todos creo que sería similar.

PD: Explico, la idea es un “booleano” que puede ser cierto o falso, y que cambia cada vez que se presiona el boton correspondiente al color, entonces mandamos el write y en cada ciclo le invertimos su valor, por eso, una vez prende, a la siguiente apagaría.

// Sketch para controlar un led RGB con un
// mando a distancia IR con protocolo NEC

#include <WProgram.h>
#include <NECIRrcv.h> //Libreria del protocolo NEC
#define IRPIN 8 // Pin del receptor IR

NECIRrcv ir(IRPIN);

int rojo = 9;  //Pin del color ROJO del led RGB
int verde = 10; //Pin del color VERDE del led RGB
int azul = 11; //Pin del color AZUL del led RGB
int amarillo = 12; // pin nuevo

boolean estadorojo = false;

long power = 0xFF00BF00;  //Codigo correspondiente al boton POWER del mando a distancia
long butrojo = 0xEF10BF00; //Codigo correspondiente al boton 1 del mando a distancia
long butverde = 0xEE11BF00; //Codigo correspondiente al boton 2 del mando a distancia
long butazul = 0xED12BF00; //Codigo correspondiente al boton 3 del mando a distancia
long butamarillo = 0xEB14BF00; // codigo boton 4

void setup()
{
  Serial.begin(9600); //Iniciamos comunicacion serie
  Serial.println("NEC IR code reception") ;
  ir.begin(); //Iniciamos la recepcion IR
 
  pinMode(rojo, OUTPUT);
  pinMode(verde,OUTPUT);
  pinMode(azul, OUTPUT);
  pinMode(amarillo,OUTPUT);
}

void loop()
{
  unsigned long ircode; //Variable que contendra el codigo decimal del boton pulsado
 
  while (ir.available())
  {
    ircode = ir.read(); //Leemos el codigo del boton pulsado
     Serial.print("got code: 0x") ;
    Serial.println(ircode,HEX) ;
     if (ircode == power) //Si el boton de power... apagamos el led
     {
       digitalWrite(rojo, LOW);
       digitalWrite(verde, LOW);
       digitalWrite(azul, LOW);
       digitalWrite(amarillo, LOW);
     }
     else if (ircode == butrojo){
     delay(100);
     estadorojo = !estadorojo;
     digitalWrite(rojo,estadorojo);
     }

     else if (ircode == butverde) digitalWrite(verde,HIGH);
     else if (ircode == butazul) digitalWrite(azul,HIGH);
     else if (ircode == butamarillo) digitalWrite(amarillo,HIGH);
  }
}

Joe que gusto da.... todo resuelto en un dia. Gracias American2020 por tu ayuda que ha resuelto totalmente mi problema. Tras tostar mi receptor de infrarojos por invertirle la polaridad (jejeje, por eso somos chispas y chispillas) y comprar unos nuevos, integro el codigo con boolean en todos los leds y funcionaaaaaa...jajajaja... dominaremos el mundo... jajajjajajaa. Quiero agradecer de nuevo a American2020 su desinteresada ayuda que se vera recompensada con una cerveza bien fria si viene por pamplona a correr los sanfermines. Y a todos los demas que seguis teniendo paciencia con este coneho... Ficus y chispillas

ops… y para todos aquellos que quieran repetir mi experimento el codigo es:
// Sketch para controlar un led RGB con un
// mando a distancia IR con protocolo NEC

#include <WProgram.h>
#include <NECIRrcv.h> //Libreria del protocolo NEC
#define IRPIN 8 // Pin del receptor IR

NECIRrcv ir(IRPIN);

int rojo = 9; //Pin del color ROJO del led RGB
int verde = 10; //Pin del color VERDE del led RGB
int azul = 11; //Pin del color AZUL del led RGB
int amarillo = 12; // pin nuevo

boolean estadorojo = false;
boolean estadoverde = false;
boolean estadoazul = false;
boolean estadoamarillo = false;

long power = 0xFF00BF00; //Codigo correspondiente al boton POWER del mando a distancia
long butrojo = 0xEF10BF00; //Codigo correspondiente al boton 1 del mando a distancia
long butverde = 0xEE11BF00; //Codigo correspondiente al boton 2 del mando a distancia
long butazul = 0xED12BF00; //Codigo correspondiente al boton 3 del mando a distancia
long butamarillo = 0xEB14BF00; // codigo boton 4

void setup()
{
Serial.begin(9600); //Iniciamos comunicacion serie
Serial.println(“NEC IR code reception”) ;
ir.begin(); //Iniciamos la recepcion IR

pinMode(rojo, OUTPUT);
pinMode(verde,OUTPUT);
pinMode(azul, OUTPUT);
pinMode(amarillo,OUTPUT);
}

void loop()
{
unsigned long ircode; //Variable que contendra el codigo decimal del boton pulsado

while (ir.available())
{
ircode = ir.read(); //Leemos el codigo del boton pulsado
Serial.print(“got code: 0x”) ;
Serial.println(ircode,HEX) ;
if (ircode == power) //Si el boton de power… apagamos el led
{
digitalWrite(rojo, LOW);
digitalWrite(verde, LOW);
digitalWrite(azul, LOW);
digitalWrite(amarillo, LOW);
}
else if (ircode == butrojo){
delay(100);
estadorojo = !estadorojo;
digitalWrite(rojo,estadorojo);
}

else if (ircode == butverde){
delay (100);
estadoverde = !estadoverde;
digitalWrite(verde,estadoverde);
}
else if (ircode == butazul){
delay (100);
estadoazul = !estadoazul;
digitalWrite(azul,estadoazul);
}
else if (ircode == butamarillo){
delay (100);
estadoamarillo = !estadoamarillo;
digitalWrite(amarillo,estadoamarillo);
}
}
}

Gracias por el agradecimiento...

Ahora yo te dejo un desafío. Has lo mismo con el botón Power.

boolean estadopower = false;

if (ircode == power) //Si el boton de power... apagamos el led { delay (100); estadopower != estadopower; digitalWrite(rojo, estadopower); digitalWrite(verde, estadopower); digitalWrite(azul, estadopower); digitalWrite(amarillo, estadopower); }

Y si querés, aunque no se de que serviría, pero estaría bueno, y para implementarlo en el botón power, u otros que tengas en el control, hacer que al presionar ese botón, los 4 leds inviertan su estado, osea, prender los que estaban apagados y apagar los que estaban prendidos. ;)

PD: Aún no tengo un control remoto de esos, pero me podrías decir que pasa con este código, si te quedás presionando el botón por largo tiempo. ¿El led empieza a prender y apagar cada 100ms? Si eso pasa es lo que te decía que el código se puede mejorar :)

Estimado American 2020... he probado a mantener pulsado el boton... nada... solo reconoce una pulsacion con lo que deja el led como estaba. no empieza una intermitencia. Ahora voy a integrar el codigo para el boton power... te dire que me sirve esa idea, ya que me dedico al tren miniatura. Esto lo he hecho para controlar luces en la ciudad. Con una inversion de los leds el efecto queda muy chulo. Muchas gracias por la nueva aportacion. Ahora te pongo en otra idea que tengo. Aunque no se si deberia abrir otro post. Gracias de parte de estos dos conejos de Pamplona.

He probado a añadir lo del boton power... y no funciona como pensabamos. Enciende todos o apaga todos. No hace un cambio de estado en general de todos los leds... uyyyyy ... que pena...sonaba muy bien. Gracias de nuevo

Es porque no te pasé las "Solución" a esa idea :P esa era para que la desarrolles vos. Sería así.

     if (ircode == power) //Si el boton de power o un sexto botón
     {
       delay (50); //Prueba bajarlo entonces si no hay interfencias y hace las cosas 2 veces
       
       //Invertimos todos los estados
     estadorojo = !estadorojo;
     estadoverde = !estadoverde;
     estadoazul = !estadoazul;
     estadoamarillo = !estadoamarillo;
     
       //Los mandamos
     digitalWrite(rojo,estadorojo);
     digitalWrite(verde,estadoverde);
     digitalWrite(azul,estadoazul);
     digitalWrite(amarillo,estadoamarillo);
     }

Decime que con ese código si funciona :P Al menos en la teoría debería...

Tienes razón, porque si lo haces en maquetas de trenes está muy bueno invertir señales con este código, por ejemplo para los semáforos y demás en las vías.

Lo que aún no se, y no he investigado, es que pasa si quiero hacer que un led quede titilando mientras aún sea capaz de seguir controlando los demás :P

Jijiji no pense que se trataba de mi primer examen.... y lo habría suspendido. Ahora ya esta todo el codigo integrado y la cosa va que arde. los leds cambian a apagado los que estan encendidos y al reves. También he añadido la función de stop para apagar todo. Muchisimas gracias American 2020. Ahora puedo poner ya reles al invento y hacer que se iluminen casas, faroles en las calles y un parque de atracciones. ole ole y ole... como había dicho...jajajajajaja dominaremos el mundo (aunque sea en miniatura escala n) Ficus y chispillas

:) Cuando lo tengas armado quiero fotos!!!

PD: Hoy viendo más videos en YouTube, aprendí un método "nuevo"

digitalWrite(rojo, !digitalRead(rojo));

Osea, sin tenes que usar variables declaradas antes, se puede leer en ese momento el estado de ese PIN y decirle que invierta su estado, me pareció bueno compartir esta variante, ya que evita el tener que declarar variables y demás.

American2020: :) Cuando lo tengas armado quiero fotos!!!

PD: Hoy viendo más videos en YouTube, aprendí un método "nuevo"

digitalWrite(rojo, !digitalRead(rojo));

Osea, sin tenes que usar variables declaradas antes, se puede leer en ese momento el estado de ese PIN y decirle que invierta su estado, me pareció bueno compartir esta variante, ya que evita el tener que declarar variables y demás.

Gracias por compartir, porque tenía en mi agenda mental probar exactamente eso. Estaba casi seguro de que funcionaba leer un pin de salida, pero no quería meter la pata. (Nota mental: ¿se puede leer igualmente el pwm enviado a una salida analógica?)

No se como sería, porque tampoco esto, que entiendo me debería devolver algo, me está mandando nada hacia el Serial

int ledPin = 9;


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

void loop()
{
    digitalWrite(ledPin, HIGH);
    
    int pinState = digitalRead(ledPin);
    
    Serial.println(pinState);
    
    delay (100);
}

Acá algo explican de esto en inglés, pero no entendí bien :P

http://playground.arduino.cc/Learning/AnalogPins

The analogRead command will not work correctly if a pin has been previously set to an output, so if this is the case, set it back to an input before using analogRead. Similarly if the pin has been set to HIGH as an output.

Al parecer debo establecerlo como INPUT antes de querer hacer la lectura, pero buscaré ejemplos de esto, que no quiero meter la pata :P Imagino que será que se puede hacer dentro del loop esto, ahora me toca ver como, si es de la manera "obvia" o si hay que considerar algo primero.

CUIDADO

The Atmega168 datasheet also cautions against switching digital pins in close temporal proximity to making A/D readings (analogRead) on other analog pins. This can cause electrical noise and introduce jitter in the analog system. It may be desirable, after manipulating analog pins (in digital mode), to add a short delay before using analogRead() to read other analog pins.

Que gusto da encontrar que hay personas dispuestas a ayudarte a encontrar la solucion a los problemas... chispillas y yo sacaremos foto en cuanto el sistema este en funcionamiento. Ahora tambien me gustaria proponer mi siguiente dilema. Tengo una feria o parque de atracciones que controlar. Para ello tengo varios reles. Los actuo via transistor y con un diodo para evitar el efecto rebote de la bobina. Funcionan genial. Pero ahora viene mi deseo... quiero algo que sea una sorpresa, de chocolate y un regalo.... y me trajeron un kinderegg. Noooooooooooooo eso es broma. Me gustaria poder poner un programa en arduino para que las atracciones se vayan conectando de manera aleatoria... y por tiempo aleatorio. Y todo ello sin contratar a un feriante. Gracias por adelantado Ficus y Chispillas.

Sep, ahí ya es "más difícil" eso, osea, sabría como plantearlo, pero no bien como hacerlo.

Imagino que cada "atracción" podría ser una función y que haya un "Random" en el código que las vaya ejecutando aleatoriamente durante X tiempo y Y cantidad al mismo tiempo, y así apagarlas y encender otras, etc etc.

Creo que sería bueno si me pongo a armar algo de código, creo que es mi posibilidad de aprender como es esto de ejecutar las cosas por un tiempo definido, sin usar delays :)

Al final American 2020 me vas a llegar a odiar por explotador... jajajajaja... te agradezco que me hayas prestado toda tu ayuda. Gracias Ficus y chispillas

ficusrex:
Al final American 2020 me vas a llegar a odiar por explotador… jajajajaja… te agradezco que me hayas prestado toda tu ayuda.
Gracias
Ficus y chispillas

De nada :wink:

No, me gusta ayudar, porque también estoy empezando en Arduino y todo esto también me ayuda a practicar

Te dejo mi código, al menos parte de él. Ya tiene salida por el “Monitor Serial” para ver que es lo que está haciendo. De momento lo que hace y sin usar “delay” en lo absoluto, es esperar un tiempo “Random”

En fin, enciendo 2 atracciones y luego simplemente se queda esperando tiempos al azar sin hacer nada más, porque aún no se como controlar cuando se deben apagar las atracciones.

const int pinAtraccUNO = 12;
const int pinAtraccDOS = 11;
const int pinAtraccTRES = 10;
const int pinAtraccCUATRO = 9;
const int pinAtraccCINCO = 8;

boolean setAtraccUNO = LOW;
boolean setAtraccDOS = LOW;
boolean setAtraccTRES = LOW;
boolean setAtraccCUATRO = LOW;
boolean setAtraccCINCO = LOW;

boolean randomEsperando = 0;

int atraccionesON =  0;

int timeON = 0;
int waitFOR = 0;

int numAtraccSimul = 2;
int numAtraccTotal = 5;

int minAtraccON = 5; //Segundos
int maxAtraccON = 30; //Segundos

int minEspera = 5; //Segundos
int maxEspera = 15; //Segundos

long timeActual = 0;
long timePrevio = 0;

long previousMillis = 0;        // will store last time LED was updated

void setup() {
Serial.begin(9600); //Para la prueba vemos las cosas en el serial

  // if analog input pin 0 is unconnected, random analog
  // noise will cause the call to randomSeed() to generate
  // different seed numbers each time the sketch runs.
  // randomSeed() will then shuffle the random function.
  randomSeed(analogRead(0)); //Al parecer esto hará que Random sea realmente Random
  
}

void loop() {
  
  if (randomEsperando == 0) { //Levantamos un número random
  //Espera Random sin usar delay
  waitFOR = random(minEspera,maxEspera+1); //Número random entre espera mínima y máxima, a máxima se le suma uno, para que lo incluya
  waitFOR = (waitFOR*1000); //Lo pasamos a milisegundos
  
  randomEsperando=1; //Esto indica que ya tenemos un número
  }
  
  else { //Si ya tenemos el número ejectuamos esto
  
  unsigned long timeActual = millis();
  
  if(timeActual - timePrevio > waitFOR) { //Vemos si se cumplió el tiempo de espera
  timePrevio = timeActual;   
    
  Serial.print("Espere por: ");
  waitFOR = (waitFOR/1000);
  Serial.print(waitFOR);
  Serial.println(" segundos...");

  randomEsperando=0; //Lo ponemos en 0 para que vaya a buscar otro número random
  
  //Se esperó X tiempo podemos pasar a lanzar atracciones al azar
  
  //Primero vemos si hemos alcanzado el máximo de atracciones ON
  
  if (atraccionesON <= (numAtraccSimul-1)) { //Tuve que poner ese -1 no se por qué :)

  int lanzarAtracc = random(1,numAtraccTotal+1); //Seleccionamos el número random de la atracción a lanzar, lo mismo, le sumamos 1
  
  timeON = random(minAtraccON,maxAtraccON+1); //Seleccionamos cuanto tiempo estará ON
  
  switch (lanzarAtracc) {
    case 1:
      atraccionesON++; //Sumamos 1 al total de atracciones ON
      atraccionUNO(timeON);
      break;
    case 2:
      atraccionesON++; //Sumamos 1 al total de atracciones ON
      atraccionDOS(timeON);
      break;
    case 3:
      atraccionesON++; //Sumamos 1 al total de atracciones ON
      atraccionTRES(timeON);
      break;
    case 4:
      atraccionesON++; //Sumamos 1 al total de atracciones ON
      atraccionCUATRO(timeON);
      break;
    case 5:
      atraccionesON++; //Sumamos 1 al total de atracciones ON
      atraccionCINCO(timeON);
      break;
    default:
      atraccionesON=0; //Indicamos que estan todas apagadas
      apagarTODAS(); //Acción por default, apagamos todas, en caso de que algo haya salido mal
      break;
  } //Fin del switch
  
  } //Fin de código lanza atraccionesON
  
  } //Fin del código ejecutado si se había alcanzado el tiempo de espera
  
  } //FIN código ejecutado al pasar X tiempo volverá a empezar
  
} //FIN loop
  

  
 
// Configuración de las atracciones

void atraccionUNO(int time) {
  
  Serial.print("Ok esto lanza la atraccion 1 por: ");
  Serial.print(time);
  Serial.println(" segundos...");
  
  // No se como controlar cuando pasó este tiempo, para proceder a apagarla
  // Imagino que un if, como el que está dentro del loop no serviría, ya que esta función se lanzó una sóla vez fuera del mismo
  
}

void atraccionDOS(int time) {
  
  Serial.print("Ok esto lanza la atraccion 2 por: ");
  Serial.print(time);
  Serial.println(" segundos...");
}

void atraccionTRES(int time) {
  
  Serial.print("Ok esto lanza la atraccion 3 por: ");
  Serial.print(time);
  Serial.println(" segundos...");
}

void atraccionCUATRO(int time) {
  
  Serial.print("Ok esto lanza la atraccion 4 por: ");
  Serial.print(time);
  Serial.println(" segundos...");
}

void atraccionCINCO(int time) {
  
  Serial.print("Ok esto lanza la atraccion 5 por: ");
  Serial.print(time);
  Serial.println(" segundos...");
}




void apagarTODAS() {
  Serial.println("Apagamos todas");
}

Bueno, te invito a probar este código, al parecer funciona 100% :slight_smile:

Aún no digo que tengo una maestría en “delays” sin usar delays, pero me acerco bastante.

Cargalo y abrí el Monitor Serial, para ir viendo lo que va pasando.

Ya luego si quieres, conecta algunos Leds a los pines asignados y escribes el código para prenderlos y apagarlos dentro de cada función.

Recuerda que si lo usarás en maquetas, tendrás que mandar la señal a unos Relay o algo, porque la potencia que mandará el Arduino no alcanzará creo yo.

Fijate de tratar de ir entendiendo paso a paso que está pasando en cada etapa del código, igual está lleno de comentarios, cualquier cosa que no entiendas me avisas y si puedo lo explico, porque hay cosas que ni yo estoy seguro de por qué están así :stuck_out_tongue:

Está en el archivo adjunto

Aleatorio.ino (9.22 KB)

Probado en el serial y va genial. aunque al poner los leds en los pines del 8 al 12 no encendian... vale ... me he quedado calvo y no he escrito ningun codigo, pero no es que sea newie...es que soy muy torpe y me esta costando entenderlo. Una pista porfa. La electronica ya se me da mejor. He construido unos reles activados por arduino a traves de transistores bc547 lo que evita que los pines de salida superen los 20mA mueven unos reles de 5 v y llevan un diodo 4007 pra evitar la corriente de rebote de las bobinas de los reles. Funcionan bien. Pero si, estimado amigo American 2020 soy un torpe de la informatica. asi que una pista de como prenderlos seria de muchisima ayuda... y mas teniendo en cuenta que te has molestado en escribir todo ese codigo. Gracias como siempre Rafa y chispillas

Ahhh bueno, si se te da mejor la electrónica, entonces ya te pediré consejos con un Cubo de Leds que armé, y en dónde uso algunos transistores Todo funciona, pero se que quizás podría hacer algo mejor.

Volviendo al código, no se encienden leds, porque nunca escribí los digitalWrite… HIGH o LOW simplemente puse las salidas Serial.

Simplemente sería agregar esas lineas. Hacia el final del código dónde dice:

  // ACA EL CODIGO PARA ENCENDER ESTA ATRACCION
  
  // LLENAR en este y en los demás casos.

habría que poner

digitalWrite(pinAtraccUNO, HIGH);

Y así en las 5. Y para apagarlas, abajo de donde dice

//Vemos que atracciones están ON para ver cuando es hora de apagarlas

...
...

//CODIGO QUE APAGA LA ATRACCION

Ahí pondríamos

digitalWrite(pinAtraccUNO, LOW);

En el adjunto te dejo el código con esas modificaciones. Acordate que ya luego de los testeos y ver que todo funciona, todas las salidas por el Serial podrían sacarse ya que no serían necesarias, podrías o borrarlas o dejarles un // delante de cada una para que queden como comentarios.

Aleatorio.ino (9.5 KB)

Te voy a tratar de amigo o de benefactor... Estimado amigo American 2020 te agradezco cada uno de tus post que me estan llevando a montar una ciudad en mi tren miniatura. Te quiero comentar que para poder manejar 64 leds de una manera bastante comoda existe un chip llamado Max 7219 que maneja matrices de 8x8. Ademas de tener la posibilidad de poder ponerlos en serie. Hay una cosa que se ha de tener en cuenta con ese chip. Si mantienes encendidos muchos leds continuamente el chip llega a quemarse. Pero hacer efectos en los que van brillando de manera alternativa es su funcion. Tienes informacion para hacer la circuiteria para este chip en el siguiente post. http://www.wayoda.org/arduino/ledcontrol/index.html tambien en: http://playground.arduino.cc/Main/LEDMatrix. Con la libreria correspondiente para trabajar con el. http://playground.arduino.cc/LEDMatrix/Max7219 http://modelrail.otenko.com/arduino/controlling-lots-of-leds-with-your-arduino Este ultimo es el que yo he montado. Espero que por primera vez te haya ayudado yo. Tambien te puedo decir donde conseguir ese chip. Yo he encontrado una tienda en polonia que lo tiene por unos 4,5€ eso serian aproximadamente unos 6 $ usa. Si en algo mas puedo ayudarte, cuenta con nosotros. Ficus y chispillas