DESAFIO ARCOIRIS

/*** Declaramos pines RGB en modo PWM**/

int red = 11;
int green = 9;
int blue = 10;

/***Variables de control de brillo***/

int redBrightness = 0;
int greenBrightness = 0;
int blueBrightness = 0;

void setup() {

Serial.begin(9600); //Inicializacion de monitor en pantalla

/***Declaramos el modo del pin***/

pinMode (red, OUTPUT);
pinMode (green, OUTPUT);
pinMode (blue, OUTPUT);

void loop () {
Serial.println ("Bienvenido");
Serial.println ("");
Serial.println ("Listado de codigos de pines, favor visualizar:");
Serial.println ("Rojo: 255,0,0");
Serial.println ("Verde: 0,255,0");
Serial.println ("Azul: 0,0,255");
Serial.println ("Blanco: 255,255,255");
Serial.println ("Amarillo: 255,255,0");
Serial.println ("Cian: 0,255,255");
Serial.println ("Magenta: 255,0,255");
Serial.println ("");
Serial.println ("Ingrese el codigo del color que desea visualizar
(Separado por comas):");

while(Serial.available()==0){
}
redBrightness = Serial.parseInt();
Serial.println(redBrightness);

while(Serial.available()==0){
}
greenBrightness = Serial.parseInt();
Serial.println(greenBrightness);

while(Serial.available()==0){
}
 blueBrightness = Serial.parseInt();
Serial.println(blueBrightness);

Serial.println(" ");

/***Enviando voltajes variables a led RGB***/

analogWrite(red, redBrightness);
analogWrite(green, greenBrightness);
analogWrite(blue, blueBrightness);
delay(3000);
}

ActivarDigito(digito);
digitalWrite(dp; 1);

//7 segmentos
int a = 12;
int b = 8;
int c = 4;
int d = 6;
int e = 7;
int f = 11;
int g = 3;

//dígitos del display

int dg1 = 2;
int dg2 = 9;
int dg3 = 10;
int dg4 = 13;

int dp = 5;
int vel = 1; //velocidad

int mil, cien, dec, uni;

byte segmentos[7] = {a,b,c,d,e,f,g};

byte orden_digitos[4] = {dg1,dg2,dg3,dg4};
byte digitos[4][4] = {{0,0,0,1},
{0,0,1,0},
{0,1,0,0},
{1,0,0,0}
};
byte siete_segmentos_digitos[10][7] = {{1,1,1,1,1,1,0},//0
{0,1,1,0,0,0,0},//1
{1,1,0,1,1,0,1},//2
{1,1,1,1,0,0,1},//3
{0,1,1,0,0,1,1},//4
{1,0,1,1,0,1,1},//5
{1,0,1,1,1,1,1},//6
{1,1,1,0,0,0,0},//7
{1,1,1,1,1,1,1},//8
{1,1,1,0,0,1,1} //9
}

void EscribeDigito(byte digito, byte numero)

{
int secuencia =0;
//Activar numero
ActivarDigito(digito),
digitalWrite(dp,1);
//Escribe numero
for (byte i=0; i<7; i++)
{
digitalWrite (segmentos[secuencia], siete_digitos[numero][i]);
++secuencia;
}
}

void ActivarDigito(int x)
{
digitalWrite(dg1, HIGH);
digitalWrite(dg2, HIGH);
digitalWrite(dg3, HIGH);
digitalWrite(dg4, HIGH);
switch(x)
{
 case 1:
digitalWrite(dg1, LOW);
break;

case 2:
digitalWrite(dg2, LOW);
break;

case 3:
digitalWrite(dg3, LOW);
break;

case 4:
digitalWrite(dg4, LOW);
break;
}
}

void setup ()
{
int i;

//Inicializar pines
for (i=2; i<=13; i++)
pinMode (i, OUTPUT);
}

// Funcion de 0 a 999

void start ()
{
for(mil=0; mil<=9; mil++){
for(cien=0; cien<=9; cien++){
for(dec=0; dec<=9; dec++){
for(uni=0; uni<=9; uni++){
EscribeDigito(1, uni);
delay(vel);
EscribeDigito(2, dec);
delay(vel);
EscribeDigito(3, cien);
delay(vel);
EscribeDigito(4, mil);
delay(vel);
}
}
}
}
}
byte segA[] = {8, 9, 10, 11};
byte valor[][4] = {
{0, 0, 0, 0},
{1, 0, 0, 0},
{0, 1, 0, 0},
{1, 1, 0, 0},
{0, 0, 1, 0},
{1, 0, 1, 0},
{0, 1, 1, 0},
{1, 1, 1, 0},
{0, 0, 0, 1},
{1, 0, 0, 1}};
byte habilita1 = 5;
byte habilita2 = 4;
byte habilita3 = 3;
byte pinosLT = 7;
byte pinosBL = 6;
byte pinosCL = 2;
void setup()
{
for (int i = 0; i<4 ;i++)
{
pinMode(segA[i], OUTPUT);
}
pinMode(habilita1, OUTPUT);

pinMode(habilita2, OUTPUT);
pinMode(pinosLT, OUTPUT);
pinMode(pinosBL, OUTPUT);
pinMode(pinosCL, OUTPUT);
}
void loop()
{
digitalWrite(pinosLT, HIGH);
digitalWrite(pinosBL, HIGH);
digitalWrite(pinosCL, HIGH);

for (int c=1; c<100; c++)

{
for(int d=1; d<10;d++)
{
digitalWrite(habilita1, HIGH);
for(int u=0;u<10;u++)
{
for (int i = 0; i<4 ;i++)
{
digitalWrite(segA[i], valor [c][u][i]);
digitalWrite(habilita2, LOW);
digitalWrite(habilita3, LOW);
}
}
delay(1000);
}
digitalWrite(habilita2, HIGH);
for (int i = 0; i<4 ;i++)
{
digitalWrite(habilita3, LOW);
digitalWrite(segA[i], valor[c][d][i]);

delay(1000);
}
digitalWrite(habilita3, HIGH);
for (int i = 0; i<4 ;i++)
{
digitalWrite(segA[i], valor[c][d][i]);
}
}
delay(1000);
}