Entradas Digitales

[Ruco]

Saludos amigos del foro Todopic.

Se que me pueden orientar en en código que estoy intentando con pic18Fxxxx. Aquí comento mi problemas ya que se que mas de alguno sabe la respuesta y me pudiera ser el gran favor de ayudarme, después de tanto paso al tema.


Tengo 4 entradas digitales que apago y enciendo de la siguiente manera...

Código: C

1. if (!input(pin_c1)){ delay_ms(100); output_high(pin_d1); } else output_low(pin_d1);
2.          
3.          if (!input(pin_c2)){ delay_ms(100); output_high(pin_d2); } else output_low(pin_d2);
4.          
5.          if (!input(pin_c3)){ delay_ms(100); output_high(pin_d3); } else output_low(pin_d3);
6.          
7.          if (!input(pin_c4)){ delay_ms(100); output_high(pin_d4); } else output_low(pin_d4);

Ahora bien, lo que quiero hacer es que mientras yo tenga presionado un pulsador (cualquiera de los 4 pulsadores), ningún otro pueda activar su salida, es decir, que en ningún caso haya dos salidas encendidas.

Por ejemplo para ser mas especifico.

Mantengo presionado el (!input(pin_c1)) (encendio led d1 ) y ahora sin soltar este pulsador !input(pin_c1) presiono el pulsador !input(pin_c3), entonces !input(pin_c3) no debe hacer nada hasta que yo haya soltado !input(pin_c1) y entonces ya puedo presionar !input(pin_c3) y este ya puede encender ese otro led.

Rayos no se si me di a entender espero haber coordinado bien mi manera de preguntar.

Gracias por su ayuda.

[Eduardo2]

Código: C

1. unsigned char estado = 0 ; // inicializo el estado
2.    
3.     ....
4.     ....
5.     ....
6.     ....
7.     ....
8.     ....
9.    
10.        
11.     switch(estado){
12.         case 1:
13.             if (input(pin_c1)){  estado=0;  output_low(pin_d1); } break;
14.         case 2:
15.             if (input(pin_c2)){  estado=0;  output_low(pin_d2); } break;
16.         case 3:
17.             if (input(pin_c3)){  estado=0;  output_low(pin_d3); } break;
18.         case 4:
19.             if (input(pin_c4)){  estado=0;  output_low(pin_d4); } break;
20.         default:
21.             if (!input(pin_c1)){ delay_ms(100); output_high(pin_d1); estado=1; } ;
22.             if (!input(pin_c2)){ delay_ms(100); output_high(pin_d2); estado=2; } ;
23.             if (!input(pin_c3)){ delay_ms(100); output_high(pin_d3); estado=3; } ;
24.             if (!input(pin_c4)){ delay_ms(100); output_high(pin_d4); estado=4; } ;
25.     }

[Ruco]

 

Funciono perfecto Eduardo2. Gracias hermano.

La lógica que utilizaste me la podrías explicar un poco para comprenderla y no llevármela solo como receta de cocina?.

[DominusDRR]

Funciono perfecto Eduardo2. Gracias hermano.

La lógica que utilizaste me la podrías explicar un poco para comprenderla y no llevármela solo como receta de cocina?.

Creo que hay muchas soluciones, la de Eduardo2 es muy buena y elegante. Una buena solución generalmente es la experiencia como programador que te permite rápidamente crear un algoritmo o proceso correcto para que solucione tu problema. La de Eduardo2 me recuerda a los procesos de maquina de estados, donde existe una variable (estado) que va cambiando su valor dentro de un switch. Cada 'case' hace un subproceso y dependiendo de dichos subprocesos, podría cambiar o no la variable estado para que ejecute una nueva tarea.


Podrías entenderla mejor si la escribiera así:

Código: C

1. #define ESPERAR_QUE_ALGUNA_ENTRADA_CAMBIE_A_CERO 0
2. #define ESPERAR_QUE_ENTRADA_C1_REGRESE_A_1 1
3. #define ESPERAR_QUE_ENTRADA_C2_REGRESE_A_1 2
4. #define ESPERAR_QUE_ENTRADA_C3_REGRESE_A_1 3
5. #define ESPERAR_QUE_ENTRADA_C4_REGRESE_A_1 4
6.  
7. estado = ESPERAR_QUE_ALGUNA_ENTRADA_CAMBIE_A_CERO ;
8.  
9.  switch(estado)
10. {
11.         case ESPERAR_QUE_ALGUNA_ENTRADA_CAMBIE_A_CERO:
12.         {
13.             if (!input(pin_c1)){ delay_ms(100); output_high(pin_d1); estado=ESPERAR_QUE_ENTRADA_C1_REGRESE_A_1; } ;
14.             if (!input(pin_c2)){ delay_ms(100); output_high(pin_d2); estado=ESPERAR_QUE_ENTRADA_C2_REGRESE_A_1; } ;
15.             if (!input(pin_c3)){ delay_ms(100); output_high(pin_d3); estado=ESPERAR_QUE_ENTRADA_C3_REGRESE_A_1; } ;
16.             if (!input(pin_c4)){ delay_ms(100); output_high(pin_d4); estado=ESPERAR_QUE_ENTRADA_C4_REGRESE_A_1; } ;
17.             break;
18.         }
19.         case ESPERAR_QUE_ENTRADA_C1_REGRESE_A_1:
20.         {
21.              if (input(pin_c1)){  estado=ESPERAR_QUE_ALGUNA_ENTRADA_CAMBIE_A_CERO;  output_low(pin_d1); }
22.            break;
23.         }        
24.         case ESPERAR_QUE_ENTRADA_C2_REGRESE_A_1:
25.         {
26.              if (input(pin_c2)){  estado=ESPERAR_QUE_ALGUNA_ENTRADA_CAMBIE_A_CERO;  output_low(pin_d2); }  
27.            break;
28.         }
29.        case ESPERAR_QUE_ENTRADA_C3_REGRESE_A_1:
30.         {
31.             if (input(pin_c3)){  estado=ESPERAR_QUE_ALGUNA_ENTRADA_CAMBIE_A_CERO;  output_low(pin_d3); }
32.            break;
33.         }
34.         default:
35.         {
36.                if (input(pin_c4)){  estado=ESPERAR_QUE_ALGUNA_ENTRADA_CAMBIE_A_CERO;  output_low(pin_d4); }
37.          }
38.  
39.    }

[Eduardo2]

...
La lógica que utilizaste me la podrías explicar un poco para comprenderla y no llevármela solo como receta de cocina?.

Es como te dijo DominusDRR,  guardás el estado: 
1: Pulsador 1 pulsado.
2:.....
3:.....
4:.....
0 o mayor de 4: Ninguno pulsado.

Con el switch vas ejecutando la acción correspondiente y elegís el estado siguiente.

En problemas como este lo más "directo" y "legible" es guardando el estado, pero no es la única forma.  Acá por ejemplo se puede aprovechar el orden de las entradas y salidas y hacer:

Código: C

1. int8 pulsadores;
2.  
3.     while(1){                    
4.         pulsadores = ~input_c()&0b00011110 ;  // leo solo los 4 pulsadores
5.         if(!(pulsadores&(pulsadores-1)))      // TRUE si hay 1 o ninguno pulsado
6.             output_d(pulsadores) ;  
7.        
8.         // resto de codigo del bucle
9.         // ...............  
10.     }

Resulta más corto pero mucho más críptico, aunque no tanto como las de IOCCC 

[DominusDRR]

    int8 pulsadores;

    while(1){                     
        pulsadores = ~input_c()&0b00011110 ;  // leo solo los 4 pulsadores
        if(!(pulsadores&(pulsadores-1)))      // TRUE si hay 1 o ninguno pulsado
            output_d(pulsadores) ; 
       
        // resto de codigo del bucle
        // ...............   
    } [/code]

El problema de este código es que es una tarea apropiativa, el CPU del microcontrolador no puede hacer nada más que leer las entradas y activar las salidas. Obviamente si sólo se debe hacer eso el microcontrolador esta correcto, pero si deseas hacer otros procesos estás ahí 'colgado'.

Aunque también las instrucciones delay_ms también se apropian del CPU temporalmente y reducen la latencia del sistema y existieran otros procesos necesarios.

[Eduardo2]

...
El problema de este código es que es una tarea apropiativa, el CPU del microcontrolador no puede hacer nada más que leer las entradas y activar las salidas. Obviamente si sólo se debe hacer eso el microcontrolador esta correcto, pero si deseas hacer otros procesos estás ahí 'colgado'.
...

Nada que ver.
- El while(1) representa  el bucle principal. 
- Si el if es falso se continúa con el resto de las tareas del bucle. 
- Si es verdadero, activa/desactiva las salidas y continúa.

[DominusDRR]

ah.. si el while(1) es lo que se denomina el supelazo en la función main, puede ser. Y si necesitas realizar más procesos irían dentro de ese mismo lazo. Y mucho mejor si no recurre a la famosa función  delay_ms

[Ruco]

Gracias por su ayuda, al final de cuentas lo implemente como lo comento inicialmente Eduardo2, DominusDRR tambien gracias por la ayuda y comentarios.

Son unos genios. 

Aunque aun no termino esto, si me detiene algo mas espero poder preguntar. Gracias nuevamente.

Código: C#

1. #define Entrada_1   input(pin_b4)
2.          #define Entrada_2   input(pin_b5)
3.          #define Entrada_3   input(pin_b6)
4.          #define Entrada_4   input(pin_b7)
5.          
6.          #define Salida_1_On     output_bit(pin_c2,1);
7.          #define Salida_1_Off    output_bit(pin_c2,0);      
8.          #define Salida_2_On     output_bit(pin_c3,1);
9.          #define Salida_2_Off    output_bit(pin_c3,0);        
10.          #define Salida_3_On     output_bit(pin_c4,1);
11.          #define Salida_3_Off    output_bit(pin_c4,0);        
12.          #define Salida_4_On     output_bit(pin_c5,1);
13.          #define Salida_4_Off    output_bit(pin_c5,0);

Y dentro del while(true)

Código: C#

1. switch(estado_led)
2.          {
3.          case 1:  if(Entrada_1){ estado_led=0; Salida_1_Off }
4.                   break;
5.                  
6.          case 2:  if(Entrada_2){ estado_led=0; Salida_2_Off }
7.                   break;
8.                  
9.          case 3:  if(Entrada_3){ estado_led=0; Salida_3_Off }
10.                   break;
11.                  
12.          case 4:  if(Entrada_4){ estado_led=0; Salida_4_Off }
13.                   break;
14.                  
15.          default:
16.                   if(!Entrada_1){ delay_ms(100); Salida_1_On; estado_led=1; } ;
17.                   if(!Entrada_2){ delay_ms(100); Salida_2_On; estado_led=2; } ;
18.                   if(!Entrada_3){ delay_ms(100); Salida_3_On; estado_led=3; } ;
19.                   if(!Entrada_4){ delay_ms(100); Salida_4_On; estado_led=4; } ;
20.          }

[Ruco]

Acerca del hardware tengo dudas si esta es la mejor manera de activar una salida digital. Verán, lo que pretendo activar es una electrovalvula a 12vcd y su consumo de corriente es aproximadamente ~ 150 mA.

Quizás una configuración Darlington para el transistor seria mejor que uno solo, que opinan (que le quito, que le pongo )?.

Bueno lo que pretendo es hacerlo lo mas robusto posible, gracias por sus comentarios.

[DominusDRR]

Acerca del hardware tengo dudas si esta es la mejor manera de activar una salida digital. Verán, lo que pretendo activar es una electrovalvula a 12vcd y su consumo de corriente es aproximadamente ~ 150 mA.

Quizás una configuración Darlington para el transistor seria mejor que uno solo, que opinan (que le quito, que le pongo )?.

Bueno lo que pretendo es hacerlo lo mas robusto posible, gracias por sus comentarios.

¿Darlington en donde? ¿En lugar del 2N2222? ¿Cuánto consume de corriente el relé?

Para mi esta bien, tal vez utilizando un opto que maneje directamente el relé podría ser una opción con menos elementos.

Tal vez necesites una snubber entre los terminales del relé que conectan y desconectan la carga, pero para 12V y 150 mA tal vez no sea necesario.

[Ruco]

En realidad consume 800mA, pero se que al activarse provoca un sobre impulso que podría provocar ruido al sistema. Como sería la red snubber?.

[DominusDRR]

En realidad consume 800mA, pero se que al activarse provoca un sobre impulso que podría provocar ruido al sistema. Como sería la red snubber?.

Con una carga tan pequeña no creo que el pulso generado sea tan grande para que se reinicie tu microcontrolador, eso suele pasar cuando manejas cargas como motores eléctricos de 110VVAC o más, o lámparas de iluminación enormes.

Has pruebas y ve si algo malo sucede, aunque no creo.

Respecto a la red snubber:

https://www.homemade-circuits.com/prevent-relay-arcing-using-rc-snubber-circuits/

[DominusDRR]

800mA.

¿En realidad consume tanto un relé de 12V?

Ahí si estarías ene límite de corriente del transistor 2N2222.
¿Estás seguro de eso?

[DominusDRR]

800mA.

¿En realidad consume tanto un relé de 12V?

Ahí si estarías ene límite de corriente del transistor 2N2222.
¿Estás seguro de eso?

Mira, yo compre estos relés para manejar unas lámparas de 120VAC de 100W.

https://www.mouser.ec/ProductDetail/769-LKG1AF-9V-16

Son de nueve voltios y la bobina consume 58.8 mA, los de 12V consumen menos corriente.

Si estás correcto en el valor de 800mA quiere decir que estás usando un relé enorme y creo que sería innecesario para la carga que vas a manejar.