Encender Leds con pulsadores

Hola

Mi pregunta es bastante simple, necesito prender 6 leds, cada uno con si respectivo interruptor (adjunto imágenes), no tomen en cuenta el botón blanco, luego, cuando pueda encender los leds le daré un uso adecuado.

Las conexiones de los leds están a la derecha...

Aquí están las pistas del circuito, para los leds se comparte la salida negativa de corriente, para los interruptores se comparte la alimentación de 5V, hice pruebas de continuidad con el tester y no hay nada fuera de los normal, también los interruptores abren el circuito al ser presionados y eventualmente lo cierran al no estar presionados.

Los leds están en HIGH, para probar de que funcionan.

La idea es esta: Se presiona el sensor shk1 y debe prenderse el Led1, y así sucesivamente hasta llegar al shk6;Led6.

Tenía otros interruptores de tres contactos, pero el tamaño de la placa era de difícil cuidado, me muevo mucho con mis cosas y se podía dañar, no sé que error estoy cometiendo al programar, por favor necesito ayuda, gracias

//Declaración de Leds
int Led1=8; //Led delantero Izquierdo
int Led2=9; //Led delantero Derecho
int Led3=10; //Led central Izquierdo
int Led4=11; //Led central Derecho
int Led5=12; //Led trasero Izquierdo
int Led6=13; //Led trasero Derecho

//Declaración de sensores de impacto

int shk1=2; //Sensor delantero Izquierdo
int shk2=3; //Sensor delantero Derecho
int shk3=4; //Sensor central Izquierdo
int shk4=5; //Sensor central Derecho
int shk5=6; //Sensor trasero Izquierdo
int shk6=7; //Sensor trasero Derecho

int val;

void setup() {
  //Leds como salidas
pinMode(Led1,OUTPUT);
pinMode(Led2,OUTPUT);
pinMode(Led3,OUTPUT);
pinMode(Led4,OUTPUT);
pinMode(Led5,OUTPUT);
pinMode(Led6,OUTPUT);
//Sensores como entrada
pinMode(shk1,INPUT);
pinMode(shk2,INPUT);
pinMode(shk3,INPUT);
pinMode(shk4,INPUT);
pinMode(shk5,INPUT);
pinMode(shk6,INPUT);
}

void loop() {
digitalWrite(Led1,LOW);
digitalWrite(Led2,LOW);
digitalWrite(Led3,LOW);
digitalWrite(Led4,LOW);
digitalWrite(Led5,LOW);
digitalWrite(Led6,LOW);
digitalRead(shk1);
digitalRead(shk2);
digitalRead(shk3);
digitalRead(shk4);
digitalRead(shk5);
digitalRead(shk6);

 val=digitalRead(shk1);
 if(shk1==HIGH)
   {
    digitalWrite(Led1,HIGH);
   }
 else
  {
    digitalWrite(Led1,LOW);
  }
} //Cierre loop

Uffff, tantas líneas de código me inspiraron a crear esta gigantesca optimización: :o

void setup() {
  for (byte i = 0; i < 6; i++)
    pinMode(i + 8, OUTPUT);
  // Creelo o no, esto pone a los 6 pines LED como salida (del 8 al 13)

  // Declarar inputs es redundante, ya que por defecto todos los pines están configurados para ser entradas.

}

void loop() {
 for (byte i = 0; i < 6; i++)
    digitalWrite(i + 8, digitalRead(i + 2)); 
}

Creelo o no, estas pocas líneas de código hacen exactamente lo que necesitas (y aún sin tener que mover las conexiones de lugar); garantizado! :wink:

Hola, gracias por tu comentario, te cuento porque decidí escribir mi código así y no de otra forma:

  1. Estoy aprendiendo a programar, necesito ver lo que escriboy me es mas facil por ahora.
  2. Como estoy aprendiendo a programar, necesito diferenciar entre los pines (sé que es latero, pero de alguna forma tengo que aprender). Cuano logra hacer funcionar el codigo tendré que ocupar los pines de los leds, este codigo es la base de lo que necesito
  3. El propósito de prender los led asociados a cada switch es simular un choque, ademas, una vez que compruebe que funciona el código eliminaré los leds (físicamente) y me quedaré con el código, para enviar por un caracter asociado a cada sensor mediante un SMS.

Bueno bueno :sweat_smile: ; a tu manera, la solución sería:

void loop() {
  if (digitalRead(shk1) == HIGH) {
    digitalWrite(Led1, HIGH);
  } else {
    digitalWrite(Led1, LOW);
  }

  // Y así sucesivamente con el 2, 3, 4, 5 y 6
}

Satisfecho?

Acabo de cargar el código, pero el Led1 queda permanentemente en estado "HIGH", sin importar que presione o no el pulsador,¿crees que sea el tipo de pulsador?

Este es el tipo de pulsador que estoy usando.

Mide continuidad entre los puntos del pulsador; si hay paso aún sin pulsar, entonces o está defectuoso o es "normalmente cerrado".

También verifica que no se hayan formado "puentes" entre los puntos de soldadura.

Bueno yo veo en el pcb 3 resistencias y 6 leds.
Tambien veo 6 interruptores pero no veo resistencias PULL DOWN de modo que esto

pinMode(shk1,INPUT);

Esta mal.
Debería ser asi

pinMode(shk1,INPUT_PULLUP);

Siempre estas viendo LOW y cuando presionas lees HIGH tal como tu programa esta hecho.
Cambia la definición de tus pines.

En este momento estoy en el trabajo y no puedo realizar las pruebas, pero que opinas de esto:

http://www.luisllamas.es/2014/09/leer-un-pulsador-con-arduino/

Yo tengo conectado cada pulsador directamente a la Arduino con 5V, intentaré probar de esta forma...

surbyte:
Bueno yo veo en el pcb 3 resistencias y 6 leds.
Tambien veo 6 interruptores pero no veo resistencias PULL DOWN de modo que esto

pinMode(shk1,INPUT);

Esta mal.
Debería ser asi

pinMode(shk1,INPUT_PULLUP);

Siempre estas viendo LOW y cuando presionas lees HIGH tal como tu programa esta hecho.
Cambia la definición de tus pines.

Gracias, de hecho me acabo de dar cuenta del detalle de las resistencias "pullup/down", por lo tanto el programa queda así (juntando la condición y el PULLUP):

 //Declaración de Leds
int Led1=8; //Led delantero Izquierdo
int Led2=9; //Led delantero Derecho
int Led3=10; //Led central Izquierdo
int Led4=11; //Led central Derecho
int Led5=12; //Led trasero Izquierdo
int Led6=13; //Led trasero Derecho

//Declaración de sensores de impacto

int shk1=2; //Sensor delantero Izquierdo
int shk2=3; //Sensor delantero derecho
int shk3=4; //Sensor central Izquierdo
int shk4=5; //Sensor central derecho
int shk5=6; //Sensor trasero Izquierdo
int shk6=7; //Sensor trasero Izquierdo

int val;


void setup() {
  //Leds como salidas
pinMode(Led1,OUTPUT);
pinMode(Led2,OUTPUT);
pinMode(Led3,OUTPUT);
pinMode(Led4,OUTPUT);
pinMode(Led5,OUTPUT);
pinMode(Led6,OUTPUT);
//Sensores como entrada
pinMode(shk1,INPUT_PULLUP);
pinMode(shk2,INPUT_PULLUP);
pinMode(shk3,INPUT_PULLUP);
pinMode(shk4,INPUT_PULLUP);
pinMode(shk5,INPUT_PULLUP);
pinMode(shk6,INPUT_PULLUP);
}

void loop() {
digitalWrite(Led1,LOW);
digitalWrite(Led2,LOW);
digitalWrite(Led3,LOW);
digitalWrite(Led4,LOW);
digitalWrite(Led5,LOW);
digitalWrite(Led6,LOW);
digitalRead(shk1);
digitalRead(shk2);
digitalRead(shk3);
digitalRead(shk4);
digitalRead(shk5);
digitalRead(shk6);

  if (digitalRead(shk1) == HIGH) {
    digitalWrite(Led1, HIGH);
  } else {
    digitalWrite(Led1, LOW);
  }
  // Y así sucesivamente con el 2, 3, 4, 5 y 6
} //Cierre loop

Veo que el punto común de los botones es voltaje positivo, así que INPUT_PULLUP no serviría de nada.

Lo que necesitas es una resistencia "pull-down" (de 10k, entre + y tierra)

Lucario448:
Veo que el punto común de los botones es voltaje positivo, así que INPUT_PULLUP no serviría de nada.

Lo que necesitas es una resistencia "pull-down" (de 10k, entre + y tierra)

Hola, estoy de viaje, pero me llevé mi caja llena de cosas y en la madrugada me puse a trabajar en el código y diseño del circuito, añadiendo una resistencia de 220ohm a tierra(en este momento es la única que tengo disponible) entre los pin de salida del pulsador hacia la Arduino, funcionó perfectamente, el esquema responde a mis necesidades. Mi tema ahora en con la tensión aplicada al circuito, ya que tengo que alimentar otras futuras placas, tendré que buscar información acerca de esto.

MaestroLopez:
añadiendo una resistencia de 220ohm a tierra(en este momento es la única que tengo disponible) entre los pin de salida del pulsador hacia la Arduino, funcionó perfectamente, el esquema responde a mis necesidades. Mi tema ahora en con la tensión aplicada al circuito, ya que tengo que alimentar otras futuras placas, tendré que buscar información acerca de esto.

Espero que en serio sea temporal; porque 220 ohms entre positivo y tierra crea un consumo innecesario de 22 mA.

A menor resistencia "pull-up/down", mayor resistencia al ruido (estabilidad del estado lógico); pero disminuye la eficiencia del circuito por el consumo (en forma de calor) no deseado, generado por esa resistencia.

Para un balance adecuado entre ambas cosas, yo recomiendo entre 4.7k y 10k.

Que ponga un esquema, responder a ciegas no vale la pena.

surbyte:
Que ponga un esquema, responder a ciegas no vale la pena.

Hola, mira, he rediseñado el circuito (sobre papel me es más fácil trabajar), una vez que este correcto lo llevaré a una placa.

Este es el esquema mejorado de los pulsadores (lo de la izquierda lo explicaré luego)

Lo de la izquierda es lo que necesito aplicar, al presionar dos pulsadores al mismo tiempo logré prender un tercer led, pude hacer la comparación entre los dos estados:

 //Combinatorios    
    if(digitalRead(SHK_1)&& digitalRead(SHK_2)==HIGH){
        digitalWrite(A0,HIGH);
         }
    if(digitalRead(SHK_2)&& digitalRead(SHK_4)==HIGH){
         digitalWrite(A1,HIGH);     
         }
    if(digitalRead(SHK_4)&& digitalRead(SHK_6)==HIGH){
         digitalWrite(A2,HIGH);
         }
    if(digitalRead(SHK_6)&& digitalRead(SHK_5)==HIGH){
         digitalWrite(A3,HIGH);
         }
    if(digitalRead(SHK_3)&& digitalRead(SHK_5)==HIGH){
         digitalWrite(A4,HIGH);
         }
    if(digitalRead(SHK_1)&& digitalRead(SHK_3)==HIGH){
         digitalWrite(A5,HIGH);
         }

Lo que no pude hacer fue que, por ejemplo, al presionar SHK_1 Y SHK_2 al mismo tiempo los leds LED_1 Y LED_2 se apagasen y solamente se encendiera A0.

Este es el esquema original de los leds que necesito utilizar para empezar mi proyecto, me he encontrado con la sorpresa de que me acabe con todos los pines disponibles de la Arduino Uno, ¿No existe algún shield de expansion para añadir pines?, sé qué hay un modelo de Arduino que posee muchos pines...

P.D: Modifiqué el código para hacerlo más comprensible:

//Cristopher López, Año 2016

//Declaración de Leds
int Led_1=8; //Led delantero Izquierdo
int Led_2=9; //Led delantero Derecho
int Led_3=10; //Led central Izquierdo
int Led_4=11; //Led central Derecho
int Led_5=12; //Led trasero Izquierdo
int Led_6=13; //Led trasero Derecho

//Declaración de sensores de impacto

int SHK_1=2; //Sensor delantero Izquierdo
int SHK_2=3; //Sensor delantero derecho
int SHK_3=4; //Sensor central Izquierdo
int SHK_4=5; //Sensor central derecho
int SHK_5=6; //Sensor trasero Izquierdo
int SHK_6=7; //Sensor trasero Izquierdo

int val;


void setup() {
  //Salidas analogas
pinMode(A0,OUTPUT);
pinMode(A1,OUTPUT);
pinMode(A2,OUTPUT);
pinMode(A3,OUTPUT);
pinMode(A4,OUTPUT);
pinMode(A5,OUTPUT);
  //Leds como salidas
pinMode(Led_1,OUTPUT);
pinMode(Led_2,OUTPUT);
pinMode(Led_3,OUTPUT);
pinMode(Led_4,OUTPUT);
pinMode(Led_5,OUTPUT);
pinMode(Led_6,OUTPUT);
//Sensores como entrada
pinMode(SHK_1,INPUT_PULLUP);
pinMode(SHK_2,INPUT_PULLUP);
pinMode(SHK_3,INPUT_PULLUP);
pinMode(SHK_4,INPUT_PULLUP);
pinMode(SHK_5,INPUT_PULLUP);
pinMode(SHK_6,INPUT_PULLUP);
}

void loop() {
  //Salidas analogas
digitalWrite(A0,LOW);
digitalWrite(A1,LOW);
digitalWrite(A2,LOW);
digitalWrite(A3,LOW);
digitalWrite(A4,LOW);
digitalWrite(A5,LOW);
   //Salidas digitales
digitalWrite(Led_1,LOW);
digitalWrite(Led_2,LOW);
digitalWrite(Led_3,LOW);
digitalWrite(Led_4,LOW);
digitalWrite(Led_5,LOW);
digitalWrite(Led_6,LOW);
digitalRead(SHK_1);
digitalRead(SHK_2);
digitalRead(SHK_3);
digitalRead(SHK_4);
digitalRead(SHK_5);
digitalRead(SHK_6);

  if (digitalRead(SHK_1) == HIGH) { //Led 1
         digitalWrite(Led_1, HIGH);
           }else{
            digitalWrite(Led_1, LOW);
            }                       //Cierre Led 1
  if (digitalRead(SHK_2)==HIGH){     //Led 2
          digitalWrite(Led_2,HIGH);
           }else{
            digitalWrite(Led_2,LOW);
            }                       //Cierre Led 2
  if (digitalRead(SHK_3)==HIGH){     //Led 3
          digitalWrite(Led_3,HIGH);
           }else{
            digitalWrite(Led_3,LOW);
           }                       //Cierre Led 3
   if (digitalRead(SHK_4)==HIGH){   //Led 4
           digitalWrite(Led_4,HIGH);
           }else{
            digitalWrite(Led_4,LOW);
           }                       //Cierre Led 4
   if (digitalRead(SHK_5)==HIGH){   //Led 5
           digitalWrite(Led_5,HIGH);
           }else{
            digitalWrite(Led_5,LOW);
           }                      //Cierre Led 5
   if (digitalRead(SHK_6)==HIGH){   //Led 6
           digitalWrite(Led_6,HIGH);
           }else{
            digitalWrite(Led_6,LOW);
           }                       //Cierre Led 6
//**************************************************************
       //Combinatorios    
    if(digitalRead(SHK_1)&& digitalRead(SHK_2)==HIGH){
        digitalWrite(A0,HIGH);
         }
    if(digitalRead(SHK_2)&& digitalRead(SHK_4)==HIGH){
         digitalWrite(A1,HIGH);     
         }
    if(digitalRead(SHK_4)&& digitalRead(SHK_6)==HIGH){
         digitalWrite(A2,HIGH);
         }
    if(digitalRead(SHK_6)&& digitalRead(SHK_5)==HIGH){
         digitalWrite(A3,HIGH);
         }
    if(digitalRead(SHK_3)&& digitalRead(SHK_5)==HIGH){
         digitalWrite(A4,HIGH);
         }
    if(digitalRead(SHK_1)&& digitalRead(SHK_3)==HIGH){
         digitalWrite(A5,HIGH);
         }
//***************************************************************          
} //Cierre loop

MaestroLopez:
Lo que no pude hacer fue que, por ejemplo, al presionar SHK_1 Y SHK_2 al mismo tiempo los leds LED_1 Y LED_2 se apagasen y solamente se encendiera A0.

Se podría realizar a nivel de bits; pero como estás empezando con esto de la programación, entonces hagámoslo a nivel de variables:

  • Primero almacenar el estado de cada botón en seis variables boolean.
  • Luego comparar las variables, en pares como primera prioridad, individualmente en segunda prioridad.

Algo así:

void loop() {
  boolean estado1 = digitalRead(SHK_1);
  // Lo mismo hasta el 6

  // ************************************************************
  if (estado1 && estado2) { // HIGH = true; así que no te preocupes

    digitalWrite(A0, HIGH);
    digitalWrite(Led_1, estado1);
    digitalWrite(Led_2, estado2);
    // Suponiendo que se encienda A0, así también los querrás con los LEDs

  } else {

    digitalWrite(A0, LOW);
    digitalWrite(Led_1, estado1);
    digitalWrite(Led_2, estado2);

    // Si no están los botones juntos, apagar lo que se hubiera prendido;
    // y encender los LEDs según el estado individual de cada botón
  }
  // ************************************************************

  // Lo que está entre los asteriscos, es lo que debes aplicar también al resto de pares

}

MaestroLopez:
me he encontrado con la sorpresa de que me acabe con todos los pines disponibles de la Arduino Uno, ¿No existe algún shield de expansion para añadir pines?

De hecho sí (también se vende en Amazon)

Yo más bien utilizaría otro método para ahorrar la memoria de las variables globales, y sería hacer las mismas combinaciones pero "negativamente".. Es decir:

Si tengo:

       //Combinatorios   
    if(digitalRead(SHK_1)&& digitalRead(SHK_2)==HIGH){
        digitalWrite(A0,HIGH);
         }

Entonces en el encendido/apagado del led1 y led2:

  if (digitalRead(SHK_1) == HIGH && digitalRead(SHK_2) == LOW) { //Led 1
         digitalWrite(Led_1, HIGH);
           }else{
            digitalWrite(Led_1, LOW);
            }                       //Cierre Led 1
  if (digitalRead(SHK_2)==HIGH && digitalRead(SHK_1) == LOW){     //Led 2
          digitalWrite(Led_2,HIGH);
           }else{
            digitalWrite(Led_2,LOW);
            }                       //Cierre Led 2

Por otro lado, no comprendo porqué los primeros 6 digitalRead del loop:

digitalRead(SHK_1);
digitalRead(SHK_2);
digitalRead(SHK_3);
digitalRead(SHK_4);
digitalRead(SHK_5);
digitalRead(SHK_6);

Solo sirven para hacerle perder tiempo al procesamiento del arduino.. Al igual que las líneas que apagan todas las salidas del arduino, ya que en los condicionales las estas apagando al no estar presionadas:

  //Salidas analogas
digitalWrite(A0,LOW);
digitalWrite(A1,LOW);
digitalWrite(A2,LOW);
digitalWrite(A3,LOW);
digitalWrite(A4,LOW);
digitalWrite(A5,LOW);
   //Salidas digitales
digitalWrite(Led_1,LOW);
digitalWrite(Led_2,LOW);
digitalWrite(Led_3,LOW);
digitalWrite(Led_4,LOW);
digitalWrite(Led_5,LOW);
digitalWrite(Led_6,LOW);

Si dejas todas estas digitalWrite en LOW, todos los else{digitalWrite(xx, LOW)} de cada condicional, está de sobra!

Utilizando ambas cosas pierdes procesamiento y memoria, además de prolijidad en el sketch! :stuck_out_tongue:

Saludos! Y espero haberte ayudado y haberme explicado correctamente

Lucario448:
Se podría realizar a nivel de bits; pero como estás empezando con esto de la programación, entonces hagámoslo a nivel de variables:

  • Primero almacenar el estado de cada botón en seis variables boolean.
  • Luego comparar las variables, en pares como primera prioridad, individualmente en segunda prioridad.

Algo así:

void loop() {

boolean estado1 = digitalRead(SHK_1);
 // Lo mismo hasta el 6

// ************************************************************
 if (estado1 && estado2) { // HIGH = true; así que no te preocupes

digitalWrite(A0, HIGH);
   digitalWrite(Led_1, estado1);
   digitalWrite(Led_2, estado2);
   // Suponiendo que se encienda A0, así también los querrás con los LEDs

} else {

digitalWrite(A0, LOW);
   digitalWrite(Led_1, estado1);
   digitalWrite(Led_2, estado2);

// Si no están los botones juntos, apagar lo que se hubiera prendido;
   // y encender los LEDs según el estado individual de cada botón
 }
 // ************************************************************

// Lo que está entre los asteriscos, es lo que debes aplicar también al resto de pares

}





[De hecho sí](http://numato.com/digital-and-analog-io-expander-shield/) (también se vende en Amazon)

Gracias, he estado leyendo sobre la funcion bool, no mentiré, me cuesta entender el funcionamiento y aplicación del comando (lo estudiaré de igual forma, desde cierto punto de vista siento curiosidad por esto de la programación), he decidido no aplicar esta función, ya que cuando demuestre que se activaron los leds Led_1 Y Led_2 necesitaré que las personas puedan entender la idea, muchas gracias por tu tiempo, de verdad que agradezco la información que me han entregado, gracias!

P.D: Para solucionar el problema de los pines, me he comprado una Arduino Mega, me costó un poco de dinero, pero lo veo como una inversión, me gusta aprender cosas nuevas :smiley:

Inrovero:
Yo más bien utilizaría otro método para ahorrar la memoria de las variables globales, y sería hacer las mismas combinaciones pero "negativamente".. Es decir:

Si tengo:

       //Combinatorios   

if(digitalRead(SHK_1)&& digitalRead(SHK_2)==HIGH){
        digitalWrite(A0,HIGH);
        }




Entonces en el encendido/apagado del led1 y led2:



if (digitalRead(SHK_1) == HIGH && digitalRead(SHK_2) == LOW) { //Led 1
        digitalWrite(Led_1, HIGH);
          }else{
            digitalWrite(Led_1, LOW);
            }                      //Cierre Led 1
  if (digitalRead(SHK_2)==HIGH && digitalRead(SHK_1) == LOW){    //Led 2
          digitalWrite(Led_2,HIGH);
          }else{
            digitalWrite(Led_2,LOW);
            }                      //Cierre Led 2





Por otro lado, no comprendo porqué los primeros 6 digitalRead del loop:



digitalRead(SHK_1);
digitalRead(SHK_2);
digitalRead(SHK_3);
digitalRead(SHK_4);
digitalRead(SHK_5);
digitalRead(SHK_6);




Solo sirven para hacerle perder tiempo al procesamiento del arduino.. Al igual que las líneas que apagan todas las salidas del arduino, ya que en los condicionales las estas apagando al no estar presionadas:



//Salidas analogas
digitalWrite(A0,LOW);
digitalWrite(A1,LOW);
digitalWrite(A2,LOW);
digitalWrite(A3,LOW);
digitalWrite(A4,LOW);
digitalWrite(A5,LOW);
  //Salidas digitales
digitalWrite(Led_1,LOW);
digitalWrite(Led_2,LOW);
digitalWrite(Led_3,LOW);
digitalWrite(Led_4,LOW);
digitalWrite(Led_5,LOW);
digitalWrite(Led_6,LOW);




Si dejas todas estas digitalWrite en LOW, todos los `else{digitalWrite(xx, LOW)}` de cada condicional, está de sobra!

Utilizando ambas cosas pierdes procesamiento y memoria, además de prolijidad en el sketch! :stuck_out_tongue: 

Saludos! Y espero haberte ayudado y haberme explicado correctamente

Hola, he entendido tu mensaje, imprimí tu lo que escribiste y cuando iba saliendo del trabajo guarde el papel en la mochila y me devolví al trabajo pensado que se me habia quedado ajajja....

Pero volviendo al tema, tienes razón, hoy me compré una Arduino Mega, he hice una "limpieza" de mi código, no se que tanto impacto tendrá en el funcionamieto de circuito, pero había muchas líneas inutiles, así es como quedó:

//                 Ingenieria en Telecomunicaciones, conectividad y redes     

//                            Proyecto Smart Life Protector
//                                  Cristopher López
//                                    Inacap 2016

//Declaración de Leds
int Led_1=2;  //Led delantero Izquierdo
int Led_2=3;  //Led delantero Derecho
int Led_3=4; //Led central Izquierdo
int Led_4=5; //Led central Derecho
int Led_5=6; //Led trasero Izquierdo
int Led_6=7; //Led trasero Derecho

//Combinatorios

int Led_7=8;  //SHK_1 + SHK_2
int Led_8=9;  //SHK_2 + SHK_4
int Led_9=10;  //SHK_4 + SHK_6
int Led_10=11; //SHK_6 + SHK_5
int Led_11=12; //SHK_5 + SHK_3
int Led_12=13; //SHK_3 + SHK_1

//Declaración de sensores de impacto

int SHK_1=21; //Sensor delantero Izquierdo
int SHK_2=20; //Sensor delantero derecho
int SHK_3=19; //Sensor central Izquierdo
int SHK_4=18; //Sensor central derecho
int SHK_5=17; //Sensor trasero Izquierdo
int SHK_6=16; //Sensor trasero Izquierdo

int val;

void setup() {
  //Leds como salidas
pinMode(Led_1,OUTPUT);
pinMode(Led_2,OUTPUT);
pinMode(Led_3,OUTPUT);
pinMode(Led_4,OUTPUT);
pinMode(Led_5,OUTPUT);
pinMode(Led_6,OUTPUT);
pinMode(Led_7,OUTPUT);
pinMode(Led_8,OUTPUT);
pinMode(Led_9,OUTPUT);
pinMode(Led_10,OUTPUT);
pinMode(Led_11,OUTPUT);
pinMode(Led_12,OUTPUT);
//Sensores como entrada
pinMode(SHK_1,INPUT_PULLUP);
pinMode(SHK_2,INPUT_PULLUP);
pinMode(SHK_3,INPUT_PULLUP);
pinMode(SHK_4,INPUT_PULLUP);
pinMode(SHK_5,INPUT_PULLUP);
pinMode(SHK_6,INPUT_PULLUP);
}
void loop() {
  
      //Led directos
  if (digitalRead(SHK_1) == HIGH) { //Led 1
         digitalWrite(Led_1, HIGH);
           }else{
            digitalWrite(Led_1, LOW);
            }                       //Cierre Led 1
  if (digitalRead(SHK_2)==HIGH){     //Led 2
          digitalWrite(Led_2,HIGH);
           }else{
            digitalWrite(Led_2,LOW);
            }                       //Cierre Led 2
  if (digitalRead(SHK_3)==HIGH){     //Led 3
          digitalWrite(Led_3,HIGH);
           }else{
            digitalWrite(Led_3,LOW);
           }                       //Cierre Led 3
   if (digitalRead(SHK_4)==HIGH){   //Led 4
           digitalWrite(Led_4,HIGH);
           }else{
            digitalWrite(Led_4,LOW);
           }                       //Cierre Led 4
   if (digitalRead(SHK_5)==HIGH){   //Led 5
           digitalWrite(Led_5,HIGH);
           }else{
            digitalWrite(Led_5,LOW);
           }                      //Cierre Led 5
   if (digitalRead(SHK_6)==HIGH){   //Led 6
           digitalWrite(Led_6,HIGH);
           }else{
            digitalWrite(Led_6,LOW);
           }                       //Cierre Led 6
//**************************************************************
       //Combinatorios    
    if(digitalRead(SHK_1)&& digitalRead(SHK_2)==HIGH){
        digitalWrite(Led_7,HIGH);
         }else{
          digitalWrite(Led_7,LOW);
         }
    if(digitalRead(SHK_2)&& digitalRead(SHK_4)==HIGH){
         digitalWrite(Led_8,HIGH);     
         }else{
          digitalWrite(Led_8,LOW);
         }
    if(digitalRead(SHK_4)&& digitalRead(SHK_6)==HIGH){
         digitalWrite(Led_9,HIGH);
         }else{
          digitalWrite(Led_9,LOW);
         }
    if(digitalRead(SHK_6)&& digitalRead(SHK_5)==HIGH){
         digitalWrite(Led_10,HIGH);
         }else{
          digitalWrite(Led_10,LOW);
         }
    if(digitalRead(SHK_3)&& digitalRead(SHK_5)==HIGH){
         digitalWrite(Led_11,HIGH);
         }else{
          digitalWrite(Led_11,LOW);
         }
    if(digitalRead(SHK_1)&& digitalRead(SHK_3)==HIGH){
         digitalWrite(Led_12,HIGH);
         }else{
          digitalWrite(Led_12,LOW);
         }
//***************************************************************          
} //Cierre loop

Gracias :smiley:

Hey si quieres "limpiar" aún más tu código, podría verse así:

//Combinatorios

const byte Led_7 = 8; //SHK_1 + SHK_2
const byte Led_8 = 9; //SHK_2 + SHK_4
const byte Led_9 = 10; //SHK_4 + SHK_6
const byte Led_10 = 11; //SHK_6 + SHK_5
const byte Led_11 = 12; //SHK_5 + SHK_3
const byte Led_12 = 13; //SHK_3 + SHK_1

boolean SHK[7]; // Guarda el estado de los seis sensores. Se declara de longitud 7 para que se pueda iniciar en el índice 1

void setup() {
  //Leds como salidas
  for (byte i = 2; i < 14; i++) // Salidas: pines 2-13
    pinMode(i, OUTPUT);
  // Incluso se podría condensar aún más, manipulando puertos.

  //Sensores como entrada
  for (byte i = 16; i < 22; i++) // Entradas: pines 16-21
    pinMode(i, INPUT_PULLUP);

}

void loop() {
  for (byte i = 1, j = 21; i < 7; i++, j--) // Leer sensores
    SHK[i] = digitalRead(j);

  //Led directos
  for (byte i = 1; i < 7; i++)
    digitalWrite(i + 1, SHK[i]);

  //**************************************************************
  //Combinatorios
  digitalWrite(Led_7, SHK[1] && SHK[2]); // Se enciende solo si el par de SHK están en HIGH o true.
  digitalWrite(Led_8, SHK[2] && SHK[4]);
  digitalWrite(Led_9, SHK[4] && SHK[6]);
  digitalWrite(Led_10, SHK[6] && SHK[5]);
  digitalWrite(Led_11, SHK[3] && SHK[5]);
  digitalWrite(Led_12, SHK[1] && SHK[3]);

  //***************************************************************
} //Cierre loop

Claro que por estar tan "condensado", muy probablemente no lo comprenderás a la primera.

Tu código y el mio producen el mismo efecto, así que tómalo o déjalo.

Lucario448:
Hey si quieres "limpiar" aún más tu código, podría verse así:

//Combinatorios

const byte Led_7 = 8; //SHK_1 + SHK_2
const byte Led_8 = 9; //SHK_2 + SHK_4
const byte Led_9 = 10; //SHK_4 + SHK_6
const byte Led_10 = 11; //SHK_6 + SHK_5
const byte Led_11 = 12; //SHK_5 + SHK_3
const byte Led_12 = 13; //SHK_3 + SHK_1

boolean SHK[7]; // Guarda el estado de los seis sensores. Se declara de longitud 7 para que se pueda iniciar en el índice 1

void setup() {
  //Leds como salidas
  for (byte i = 2; i < 14; i++) // Salidas: pines 2-13
    pinMode(i, OUTPUT);
  // Incluso se podría condensar aún más, manipulando puertos.

//Sensores como entrada
  for (byte i = 16; i < 22; i++) // Entradas: pines 16-21
    pinMode(i, INPUT_PULLUP);

}

void loop() {
  for (byte i = 1, j = 21; i < 7; i++, j--) // Leer sensores
    SHK[i] = digitalRead(j);

//Led directos
  for (byte i = 1; i < 7; i++)
    digitalWrite(i + 1, SHK[i]);

//**************************************************************
  //Combinatorios
  digitalWrite(Led_7, SHK[1] && SHK[2]); // Se enciende solo si el par de SHK están en HIGH o true.
  digitalWrite(Led_8, SHK[2] && SHK[4]);
  digitalWrite(Led_9, SHK[4] && SHK[6]);
  digitalWrite(Led_10, SHK[6] && SHK[5]);
  digitalWrite(Led_11, SHK[3] && SHK[5]);
  digitalWrite(Led_12, SHK[1] && SHK[3]);

//***************************************************************
} //Cierre loop



Claro que por estar tan "condensado", muy probablemente no lo comprenderás a la primera.

Tu código y el mio producen el mismo efecto, así que tómalo o déjalo.

Me acabas de dar una patada en la entrepierna jajajaja.... Leí sobre el comando for, honestamente no me siento preparado para utilizarlo, prefiero por ahora dejar el código tal cual está, así lo entiendo con mayor facilidad y lo puedo explicar, muchas gracias por tu tiempo :smiley: