/*
Ejercicio 1.1
Realiza un programa para controlar el parpadeo de dos diodos LED (led1 en pin2)
y (led2 en pin 3)que funcionen de forma complementaria el uno del otro, es decir,
que cuando uno de ellos esté encendido, el otro permanezca apagado,
y viceversa.
Autor del enunciado: Gonzalo Penalva
Autor de la resolución: Francisco Ortiz
*/
//PORTB comprende los bits 13,12,10,11,9,8 (solo 6 bits)
//PORTC comprende los bits A5,A4,A3,A2,A1,A0 (solo 6 bits)
//PORTD comprende los bits 7,6,5,4,3,2 (solo 6 bits) los bits 
//0 y 1 son de comunicación y es mejor no usarlos ya que se interrumpe
//la comunicaación.

//DDRx (donde x es B, C, D) configura si un bit es entrada
//(fijandolo en 0) o de salida (fijandolo en 1)
//PORTx controla si el pin est en nivel ALTO (HIGH) o BAJO (LOW)
//PINx permite leer el estado de los pines de un puerto (solo es para lectura)
//PORx en binario (B10101000). Hadecimal (0XA8). Octal (0250). Decimal (168)

/*
void setup()
{
DDRD=B00001100;//Configura los leds conectados al pin 2 al 3
}
void loop()
{
PORTD=B00000100;//Decimal 4; Hexadecimal 0X4; Octal 04
delay(1000);
PORTD=B00001000;//Decimal 8; Hexadecimal 0X8; Octal 010
delay(1000);
}
*/
// Vamos ahora a sustituir los delay por la instrucción mills
//Led intermitente Ortiz
/*
#define ledVerde 2 // En el pin 2 se conecta el ledVerde
#define ledAmarillo 3 // En el pin 3 se conecta el ledAmarillo
	int ton = 1000; // Tiempo de On del ledVerde
 	int toff = 1000; // Tiempo de Off del ledVerde
	unsigned long ta = 0; // Tiempo transcurrido total con la función millis() 
	                     // para el tiempo en ON. millis()>=ton + ta
	unsigned long tb = 0; // Tiempo transcurrido total con la función millis() 
	                     // para el tiempo en OFF. millis()>=toff + tb
	bool estado = true;   // Estado del ledVerde en ON
	
	void setup(){
		DDRD=B00001100;//Se configura el puerto con todas las salidas
		PORTD=B00000100;//Se indica que led estará encendido
	  //pinMode(ledVerde, OUTPUT);
	  //digitalWrite(ledVerde,HIGH);
		//pinMode(ledAmarillo, OUTPUT);
	  //digitalWrite(ledAmarillo,LOW);
	} 
	
	void loop(){
	
 /*Ponemos Arduino a ON, el leVerde se enciende y en ese momento 
	 ta = 0  y millis() = 0 pero millis() se va incrementando con los 
	 milisegundos que pasan hasta que se desconecte Arduino. 
	 Como ton = 1.000 ms cuando mills()sea >=1.000 y  como el 
	 estado del ledVerde es verdadero, se ejecutarán las instrucciones
 que hay dentro de las llaves de la función if.
	 Em el siguiente ciclo se escribira en ta el valor de 2000 ms y como ton =
	 1000 ms cuando mills() sea igual a 3000 ms se repetirá lo anterior
	 pero con el nuevo valor.
	 */
	/*
	if(millis()>=ton + ta && estado == true){ 
	estado = false;//pasará el estadoa del ledVerde a estado falso. 
	PORTD=B00000100; // El ledVerde se apagará
	//digitalWrite(ledVerde,0); //pero no se apagará el ledVerde hasta 
	                          // que no termine de leer todas las instrucciones
	tb = millis(); // se escribira en la variable tb el valor 1000 ms
	}
	/* El leVerde se encenderá y en ese momento 
	 tb = 1000 ms  y millis() = 1000 pero millis() se va incrementando con los 
 milisegundos que pasan hasta que se desconecte Arduino. 
 Como toff = 1.000 ms cuando mills()sea >=2000 ms y  como el 
	 estado del ledVerde es falso, se ejecutarán las instrucciones
	 que hay dentro de las llaves de la función if
	 Em el siguiente ciclo se escribira en tb el valor de 4000 ms y como toff =
	 1000 ms cuando mills() sea igual a 4000 ms se repetirá lo anterior
	 pero con el nuevo valor.
	 */
	
	/*
	if(millis()>=toff + tb && estado == false){
	estado = true; //pasará el estadoa del ledVerde a estado true.
	PORTD=B00001000; //El ledVerde se apagará y el amarillo se encenderá
	//digitalWrite(ledVerde,1); //pero no se encenderá el ledVerde hasta 
                          // que no termine de leer todas las instrucciones
	ta = millis(); //se escrivira en la variable ta el valor 2000 ms
	}
	}
	//************************************************************************
//************************************************************************

/*
Ejercicio 1.2
Realiza un programa para que el microcontrolador genere una secuencia 
de encendido de 8 LEDs de derecha a izquierda, con una velocidad de 
encendido de cada LED de 100ms. Inicialmente, se encenderá el LED 
situado en el extremo derecho. Tras 100ms,se encenderá el LED siguiente, 
manteniendo en anterior encendido,y así sucesivamente hasta que todos 
los LEDS queden encendidos.Cuando se termine la secuencia, volverá a 
empezar automáticamente desde el principio.
Autor: Gonzalo Penalva
Autor de la resolución: Francisco Ortiz
*/
/*
void setup() {
	DDRB=B111111;//Se configura el puerto como salidas. El bit mas significativo
						  // se refiere al pin 13 y así sucesivamente. Solo se pueden
							//utilizar 6 bits del puerto B. Se puedec configurar en binario, 
							//decimal,hexadecimal o octal. Las salidas se escriben con un 1
							//y las entradas con un 0
	DDRD=B11000000;//Lo mismo que el puerto anterior. Los pines 0 y 1, no deben
								//utilizarse ya que son de comunicación
}

void loop() {
//Secuencia inicial:todos los LEDs apagados
PORTB=B000000;//Se indica que los led estan apagados
PORTD=B00000000;//Se indica que los led estan apagados
delay(100);
//Comenzamos a encender cada LED secuencialmente
PORTB=100000;//Led conectado en el pin 13 del puerto B
delay(100);// Espera 100 msegundos
PORTB=110000;//Leds conectados en los pines 13 y 12 del puerto B
delay(100);
PORTB=111000;//Leds conectados en los pines 13, 12 y 11 del puerto B
delay(100);
PORTB=B111100;//Leds conectados en los pines 13, 12, 11 y 10 del puerto B
delay(100);
PORTB=B111110;//Leds conectados en los pines 13, 12, 11, 10 y 9 del puerto B
delay(100);
PORTB=B111111;//Leds conectados en los pines 13, 12, 11, 10, 9 y 8 del puerto B
delay(100);
PORTD=B10000000;//Led conectado en el pin 7 del puerto D
delay(100);
PORTD=B11000000;//Leds conectados en los pine&& PORTB==B00000000s 7 y 6 del puerto B
delay(100);
}
*/

// Ahora con la función mills
/*
	int intervalo1 =150; // Tiempo de intervalo
	
	
 	
	unsigned long actual = 0; // Tiempo transcurrido total con la función millis() 
	                     // para el tiempo en ON. millis()>=ton + ta
	unsigned long anterior1 = 0;
	unsigned long anterior2 = 0;
	unsigned long anterior3 = 0;
	unsigned long anterior4 = 0;
	unsigned long anterior5 = 0;
  unsigned long anterior6 = 0;
	unsigned long anterior7 = 0;
	unsigned long anterior8 = 0;
	unsigned long anterior9 = 0;
	unsigned long anterior10 = 0;
		

void setup() 
{
	actual = millis();
	DDRB=B111111;//Se configura el puerto como salidas. El bit mas significativo
						  // se refiere al pin 13 y así sucesivamente. Solo se pueden
							//utilizar 6 bits del puerto B. Se puedec configurar en binario, 
							//decimal,hexadecimal o octal. Las salidas se escriben con un 1
							//y las entradas con un 0
	DDRD=B11000000;						
	
PORTB=B000000;//Se indica que los led estan apagados
PORTD=B00000000;
}
void loop()
{
actual = millis();


// LED1 ENDENDIDO

	if(actual - anterior1 - anterior10>= intervalo1  && PORTB==B000000 && PORTD==B00000000 ) //
{ 
			//Comenzamos a encender cada LED secuencialmente
	PORTB = B100000;//Led conectado en el pin 13 del puerto B
	PORTD=B00000000;
	anterior2 = millis();
}

// LEDS 1 y 2 ENCENDIDOS
if(actual - anterior2 >= intervalo1 && PORTB == B100000 && PORTD==B00000000)
{ 
		PORTB=B110000;//Leds conectados en los pines 13, 12 del puerto B
		PORTD=B00000000;
		anterior3 = millis();
		}
// LEDS 1, 2 y 3 ENCENDIDOS

if(actual - anterior3 >= intervalo1 && PORTB==B110000 && PORTD==B00000000)
{ 
		PORTB=B111000;//Leds conectados en los pines 13, 12, 11 del puerto B
		PORTD=B00000000;
		anterior4 = millis();
		}

// LEDS 1, 2, 3 y 4 ENCENDIDOS

if(actual - anterior4 >= intervalo1 && PORTB==B111000 && PORTD==B00000000)
{ 
		PORTB=B111100;//Leds conectados en los pines 13,12,11,10 del puerto B
		PORTD=B00000000;
		anterior5 = millis();
		}
		// LEDS 1, 2, 3, 4 y 5 ENCENDIDOS
		if(actual - anterior5 >= intervalo1 && PORTB==B111100 && PORTD==B00000000)
{ 
		PORTB=B111110;//Leds conectados en los pines 13,12,11,10,9 del puerto B
		PORTD=B00000000;
		anterior6 = millis();
		}
		// LEDS 1, 2, 3, 4, 5 y 6 ENCENDIDOS
	if(actual - anterior6 >= intervalo1 && PORTB==B111110 && PORTD==B00000000)
{ 
		PORTB=B111111;//Leds conectados en los pines 13,12,11,10,9,8 del puerto B
		PORTD=B00000000;
		anterior7 = millis();
		}
		// LEDS 1, 2, 3, 4, 5, 6 y 7 ENCENDIDOS
		if(actual - anterior7 >= intervalo1 && PORTB==B111111 && PORTD==B00000000)
{ 		
		PORTB=B111111;//Leds conectados en los pines 13,12,11,10,9,8 del puerto B
		PORTD=B10000000;//Led conectado en el pin 7 del puerto D
		anterior8 = millis();
		}
		// LEDS 1, 2, 3, 4, 5, 6, 7 y 8 ENCENDIDOS
		if(actual - anterior8 >= intervalo1 && PORTB==B111111 && PORTD==B10000000)
{   PORTB=B111111;//Leds conectados en los pines 13,12,11,10,9,8 del puerto B
		PORTD=B11000000;//Leds conectado en el pin 7,6 del puerto D
		anterior9 = millis();
		}
		// LEDS 1, 2, 3, 4, 5, 6, 7 y 8 APAGADOS
		if(actual - anterior9 >= intervalo1 && PORTB==B111111 && PORTD==B11000000)
{ 	PORTB=000000; //0X00;//Leds conectados en los pines 13,12,11,10,9,8 del puerto B. Valor en hexadecimal
		PORTD=00000000; //0X00;//Leds conectado en el pin 7,6 del puerto D. Valor en hexadecimal
		anterior10 = millis();
		}
		}
		//*************************************************************************************
		//*************************************************************************************
*/
		/*
Ejercicio 1.3
Modifica el programa del ejercicio 1.2. para que la secuencia de encendidode los LEDs vaya de 
derecha a izquierda y, una vez estén todos los LEDs encendidos, vayan apagandose de izquierda 
a derecha, hasta que queden todos apagados, repitiéndose la secuencia de forma indefinida.
Autor: Gonzalo Penalva
Autor de la resolución: Francisco Ortiz
*/
/*
int Tiempo_ON_OFF = 100;

void setup() {
	DDRB=B111111;//Se configura el puerto como salidas. El bit mas significativo
						  // se refiere al pin 13 y así sucesivamente. Solo se pueden
							//utilizar 6 bits del puerto B. Se puedec configurar en binario, 
							//decimal,hexadecimal o octal. Las salidas se escriben con un 1
							//y las entradas con un 0
	DDRD=B11000000;//Lo mismo que el puerto anterior. Los pines 0 y 1, no deben
								//utilizarse ya que son de comunicación
int retardo = 1000;
}

void loop(){
	ledsderecha();
	ledsizquierda(); 
}

void ledsderecha() {
//Secuencia inicial:todos los LEDs apagados
PORTB=B000000;//Se indica que los led estan apagados
PORTD=B00000000;//Se indica que los led estan apagados
delay(Tiempo_ON_OFF);										
//Comenzamos a encender cada LED secuencialmente
PORTB=100000;//Led conectado en el pin 13 del puerto B
PORTD=B00000000;
delay(Tiempo_ON_OFF);// Espera 100 msegundos
PORTB=B110000;//Leds conectados en los pines 13 y 12 del puerto B
PORTD=B00000000;
delay(Tiempo_ON_OFF);
PORTB=B111000;//Leds conectados en los pines 13, 12 y 11 del puerto B
PORTD=B00000000;
delay(Tiempo_ON_OFF);
PORTB=B111100;//Leds conectados en los pines 13, 12, 11 y 10 del puerto B
PORTD=B00000000;
delay(Tiempo_ON_OFF);
PORTB=B111110;//Leds conectados en los pines 13, 12, 11, 10 y 9 del puerto 
PORTD=B00000000;
delay(Tiempo_ON_OFF);
PORTB=B111111;//Leds conectados en los pines 13, 12, 11, 10, 9 y 8 del puerto B
PORTD=B00000000;
delay(Tiempo_ON_OFF);
PORTB=B111111;
PORTD=B10000000;//Led conectado en el pin 7 del puerto D
delay(Tiempo_ON_OFF);
PORTB=B111111;
PORTD=B11000000;//Leds conectados en los pine&& PORTB==B00000000s 7 y 6 del puerto B
delay(Tiempo_ON_OFF);
}



void ledsizquierda()
{
// Apagado de leds de derecha a izquierda

PORTB=0X3F;//B111111
PORTD=0X80;//B10000000
delay(Tiempo_ON_OFF);
PORTB=0X3F;//B111111
PORTD=0;//B01000000
delay(Tiempo_ON_OFF);
PORTB=0X3E;//111110
PORTD=0;
delay(Tiempo_ON_OFF);
PORTB=0X3C;//Leds conectados en los pines 13, 12 y 11 del puerto B
PORTD=0;
delay(Tiempo_ON_OFF);
PORTB=0X38;//Leds conectados en los pines 13, 12, 11 y 10 del puerto B
PORTD=0;
delay(Tiempo_ON_OFF);
PORTB=0x30;//Leds conectados en los pines 13, 12, 11, 10 y 9 del puerto 
PORTD=0;
delay(Tiempo_ON_OFF);
PORTB=0X20;//Leds conectados en los pines 13, 12, 11, 10, 9 y 8 del puerto B
PORTD=0;
delay(Tiempo_ON_OFF);
PORTB=0;//Leds conectados en los pines 13, 12, 11, 10, 9 y 8 del puerto B
PORTD=0;
delay(Tiempo_ON_OFF);
}
*/


int pinArray[] = {2, 3, 4, 5, 6, 7,8,9,10,11,12,13};// PIN-es 
int pinArray1[] = {13, 12, 11, 10, 9, 8,7,6,5,4,3,2};
int pinArray2[] = {12,10,8,6,4,2};

int count = 0;// Contador 
int timer = 200;// Temporizador
int timer1 = 0;
int timer2 = 500;
void setup()
{ 
  for (count=0;count<=13;count++) { // Configuramos todas los PIN-es de golpe 
  pinMode(pinArray[count], OUTPUT); } 
  }
  
  
  void loop() 
   {
    for (count=0;count<=13;count++){  // Enciende los LED creando una estela visual
   digitalWrite(pinArray[count], HIGH); 
   delay(timer1); 
   }

   for (count<=13;count>0;count--) { 
    
   digitalWrite(pinArray[count], HIGH);
     delay(timer); 
     digitalWrite(pinArray[count - 1], HIGH); 
     delay(timer);
      digitalWrite(pinArray[count], LOW); 
      delay(timer*2);
       } 

			 for (count=0;count<=13;count++){  // Enciende los LED creando una estela visual
   digitalWrite(pinArray1[count], HIGH); 
   delay(timer1); 
   }

   for (count<=13;count>0;count--) { 
    
   digitalWrite(pinArray1[count], HIGH);
     delay(timer); 
     digitalWrite(pinArray1[count - 1], HIGH); 
     delay(timer);
      digitalWrite(pinArray1[count], LOW); 
      delay(timer*2);
       } 
for (count=0;count<=13;count++){  // Enciende los LED creando una estela visual
   digitalWrite(pinArray2[count], HIGH); 
   delay(timer1); 
   }

   for (count<=13;count>0;count--) { 
    
   digitalWrite(pinArray2[count], HIGH);
     delay(timer); 
     digitalWrite(pinArray2[count - 1], HIGH); 
     delay(timer);
      digitalWrite(pinArray2[count], LOW); 
      delay(timer*2);
       } 
			  
       }