Arduino, 3 entradas 1 salida

Soy un novato total con arduino y me he propuesto sacar un micro proyecto adelante. OJO, he seguido tutoriales desde cero pero no tengo ni idea, así que no creo que yo pueda ayudar mucho, iré aprendiendo conforme me vais ayudando.

Tengo 3 entradas, de momento lo voy hacer con pulsadores, mas tarde a la espera de que me presten dos barreras ópticas harán de señales, que funcionan de la siguiente manera:
IMG_20210415_081414.jpg
Es una plataforma donde caben dos carros (E1 y E2) y pueden subirse entre dos personas o una sola, así como un carro solo o los dos.
En el momento que la plataforma (E3) se activa, hasta que no llega arriba no se debería desactivar, en ese momento la salida del arduino me mandará una señal nivel alto al GPS.
E1 y E2 detecta la presencia (carros), comienza a subir la plataforma E3, E1 y E2 aunque se activen o desactiven ( por movimientos encima de la plataforma) no se tendrá en cuenta hasta que E3 vuelva a nivel bajo (plataforma abajo), entonces la salida se activará a nivel alto, en la siguiente carga E1 y E2 siempre deben de pasar por nivel bajo, que sucederá cuando se eliminen los carros del sensor de presencia.

Tal vez luego salgan problemas, espero me comprendáis .
Un saludo.
 
La verdad es que no entiendo muy bien por qué vas a conseguir esas entradas y no otras; en los cronogramas se suelen representar salidas y una entrada porque que las entradas sigan esa secuencia y no otra es una cosa que no está en tu man depende de que hagan los que pulsen los pulsadores.
 
@Scooter tal vez me he explicado mal, o no te he entendido.
Las E son los valores, que creo, saldrán de los sensores de presencia y plataforma y que de momento los voy a simular con y los identificó como E de entrada al Arduino.
Me dejo asesorar y más por ti.
 
Creo que te falta una entrada, la de la plataforma "E3" cuando llegue al final, o cómo pretendes saber si alcanzó el punto maximo?.

A menos que sea obligatorio el Arduino, ese circuito lo puedes montar hasta con solo reles, los sensores de movimiento y un final de carreras. Osea, totalmente simple y muuuy barato
 
Creo que te falta una entrada, la de la plataforma "E3" cuando llegue al final, o cómo pretendes saber si alcanzó el punto maximo?.

A menos que sea obligatorio el Arduino, ese circuito lo puedes montar hasta con solo reles, los sensores de movimiento y un final de carreras. Osea, totalmente simple y muuuy barato
La plataforma cuando llega arriba dejará de entregar la tensión por eso no necesito la entrada.
En Arduino es algo nuevo para mi, quiero hacer pruebas.
 
Bueno, después de leer, releer, visionar y probar, este es mi primer programa,
falta decir que no es exactamente lo que quería hacer porque no se como añadirle un antirrebote a la "presencia_1"
¿me echáis una mano?

Un saludo.


Código:
/* Este programa solo emite una señal de salida siempre y cuando se cumpla:
La presencia y el pison hallan sido activados mas de 2 segundos, ademas
de estar posteriormente los dos desactivados
*/


//presencia
int presencia_1 = 2;            // sensor de presencia a la entrada 2
int salida_presencia_1 = 3;         // salida de sensor presencia a led
int estado_presencia_1;           // variable de la presencia
int variable_control_1 = 0;         // Al principio no ha sido activado.
int variable_encendido_1 = 0;         // Al principio no ha sido encendido.
long iniciopr1, finalpr1, actualpr1;    // variables para temporizador

//pison   
int pison = 4;                // sensor de cierre a la entrada 2
int salida_pison = 5;           // salida de sensor cierre a led 
int estado_pison;             // variable de la cierre
int variable_control_2 = 0;         // Al principio no ha sido activado.
int variable_encendido_2 = 0;         // Al principio no ha sido encendido.
long iniciopi1, finalpi1, actualpi1;    // variables para temporizador

//gps
int salida_gps = 7;             // asigno salida 7 hacia el guarda
int variable_gps = 0;           // cambiará cuando la presencia y el pison esten en 1
int estado_anterior_variable_gps = LOW;   // variable utilizo para comparativa
int contador = 0;             // contador de envios a gps

void setup() {
  Serial.begin(9600);           // inicializo puerto serie
  //presencia
  pinMode(presencia_1, INPUT);          // El presencia_1 será entrada de sensor.
  pinMode(salida_presencia_1, OUTPUT);    // El salida_presencia_1 será salida hacia LED
  //pison 
  pinMode(pison, INPUT);            // El pison será entrada pulsador.
  pinMode(salida_pison, OUTPUT);        // El salida_pison será salida led.
  //gps
  pinMode(salida_gps, OUTPUT);          // El salida_gps será salida hacia gps
                }

void loop() {
  
  // tratado de la presencia//
   estado_presencia_1 = digitalRead(presencia_1);             // asigna el estado de la presencia a la variable
  if (estado_presencia_1 == HIGH && variable_control_1 == 0)        // compara si esta en 1 y la variable control sigue a 0
      {   
          variable_control_1 = 1;                                         // asigna 1 a la variable
          iniciopr1 = millis();                                 // asigna tiempo a la variable
          finalpr1 = iniciopr1 + 2000;}                                     // Tiempo finalpr1 es iniciopr1 más 2 segundos.                 
          actualpr1 = millis();                                         // Consulta el tiempo actualpr1. 
  if (variable_control_1 == 1 && (actualpr1 > finalpr1) ) {enciende_salida_presencia_1();}    // compara la v. control y han pasado 2 segundos activa salida gps
  if (variable_encendido_1 == 1 && (estado_presencia_1 == LOW) ) {apaga_salida_presencia_1();}  // compara la v. control este a 1 y la presencia desactivada desactiva salida gps
 
  //Tratado del pison//
    estado_pison = digitalRead(pison);                               // asigna el estado del sensor a la variable
  if (estado_pison == HIGH && variable_control_2 == 0) {                       // compara si esta en 1 y la variable control sigue a 0
          variable_control_2 = 1;                                          // asigna 1 a la variable
          iniciopi1 = millis();                                  // asigna tiempo a la variable
          finalpi1 = iniciopi1 + 2000;}                                  // Tiempo finalpi1 es iniciopi1 más 2 segundos.               
          actualpi1 = millis();                                          // Consulta el tiempo actualpi1. 
  if (variable_control_2 == 1 && (actualpi1 > finalpi1) ) {enciende_salida_pison();}       // compara la v. control y han pasado 2 segundos activa salida led
  if (variable_encendido_2 == 1 && (estado_pison == LOW) ) {apaga_salida_pison();}         // compara la v. control este a 1 y la presencia desactivada desactiva salida led

  //Tratado de la salida gps
  variable_gps = (variable_encendido_1 == 1 &&  variable_encendido_2 == 1);              // la variable_gps se pondrá a 1 cuando estén las entradas a 1
  if (variable_gps == 1) {estado_anterior_variable_gps = HIGH;}                    // asigna un 1 a la variable estado_anterior_variable_gps cuando la variable_gps este a 1
  if (  estado_presencia_1 == LOW & estado_pison == LOW & estado_anterior_variable_gps == HIGH  )  // activa salida si se cumplen las 3 condiciones y si no deja apagada la salida gps
     {salida_gps1();} else {digitalWrite(salida_gps, LOW);}   //   
      }


 // Subrutina variable_encendido_1.
void enciende_salida_presencia_1(){
  digitalWrite(salida_presencia_1, HIGH);
  variable_encendido_1 = 1;}
                                    
 // Subrutina apagado de presencia.
void apaga_salida_presencia_1(){
  digitalWrite(salida_presencia_1, LOW);
  variable_encendido_1 = 0;
  variable_control_1 = 0;}     
 
 // Subrutina variable_encendido_2.
void enciende_salida_pison(){
  digitalWrite(salida_pison, HIGH);
  variable_encendido_2 = 1;}

 // Subrutina apagado de pison.
void apaga_salida_pison(){
  digitalWrite(salida_pison, LOW);
  variable_encendido_2 = 0;
  variable_control_2 = 0;}     

// Subrutina salida gps.
void salida_gps1(){
  digitalWrite(salida_gps, HIGH);
   if (digitalRead(salida_gps) == HIGH){   // comprueba que la salida este en alto
      contador++;                          // aumenta 1 si salida en alto
    Serial.println(contador); }            // muestra el número de envios                                       
   delay(100);                             // para poder ver el encendido
  estado_anterior_variable_gps = LOW;      // mando estado_anterior_variable_gps a bajo 
    }
 
no es exactamente lo que quería hacer
Mientras trato de verlo en el PC al codigo, que no me gusta mucho, responde qué tendria que hacer? Tendria que ser lo explicado en el primer post?
Qué es "pison" y "GPS"? Y qué tipo de señales trabajan?

añadirle un antirrebote a la "presencia_1
Puedes quitar peso del software y retardos, y agregar un capacitor de bajo valor en paralelo a la salida del dispositivo
 
@DJ T3 gracias por contestar.
Conforme me he metido en este mundo, me he dado cuenta que es más que apasionante y haces algo y busca un poco más allá, si que mi idea primaria ha variado un poco, pero básicamente es lo mismo.
De momento con un sensor de presencia, cuando lo tenga controlado meteré 1 o 2 sensores más de presencia para conteo de carros.
Ahora mismo hace exactamente lo que necesito, tal vez halla que depurarlo mucho pero me doy con un canto en los dientes con lo hecho.
El pisón es la plataforma y lo que he ido más allá es meterlo a una entrada de un gps que me enviará esa señal a una plataforma donde poder visionar cada vez que haga una carga/descarga del carrito o carritos.
Pero aún voy más allá, ese gps me ha tiene un pero serie que le pedí mandar más datos por el, por eso pongo un contador de salidas, pero creo que eso será más adelante a no ser que sea tan sencillo que me vayáis asesorando o leyendo como estoy haciendo.
Vuelvo a decir que es un no parar, porque cada vez buscar ir un pasa más adelante, este aparatito da mucho mucho de sí.
Gracias de nuevo.
 
Soy un novato total con arduino y me he propuesto sacar un micro proyecto adelante. OJO, he seguido tutoriales desde cero pero no tengo ni idea, así que no creo que yo pueda ayudar mucho, iré aprendiendo conforme me vais ayudando.

Tengo 3 entradas, de momento lo voy hacer con pulsadores, mas tarde a la espera de que me presten dos barreras ópticas harán de señales, que funcionan de la siguiente manera:
Ver el archivo adjunto 265928
Es una plataforma donde caben dos carros (E1 y E2) y pueden subirse entre dos personas o una sola, así como un carro solo o los dos.
Ese cronograma no nos indica qué pasa cuando las señales E1 y E2 o son posteriores a E3. Tal como está basta un monostable que dispare en el flanco de bajada de E3 ...
 
@Gasparv te agradezco la sugerencia.
Ahora mismo el programa me funciona tal y como deseo, solo necesito saber cómo poner un antirrebote por soft para los pulsadores, quiero aprender y no se dónde me falla.
 
@Gasparv te agradezco la sugerencia.
Ahora mismo el programa me funciona tal y como deseo, solo necesito saber cómo poner un antirrebote por soft para los pulsadores, quiero aprender y no se dónde me falla.
El anti rebote lo tienes en muchos proyectos que hay en MICROCHIP. Se basa en entrar en un bucle con el primer cero, un retardo razonable, y salir cuando es uno. Muy sencillo.
 
1619802787669.png

Ahí manejo tres pulsadores que hacen algo en un contador.

Mira esta sencilla rutina para leer un botón

;*********************************************************
; Comprueba los pulsadores de Marcha y Paro
; si la pulsación es válida devuelve WREG=1
;*********************************************************

TEST_PARO
btfsc PULSADOR_P ;está pulsado?
retlw 0 ;no pulsado
TA01 call DELAY20 ;retardo
btfsc PULSADOR_P ;verifica la pulsación
btfss PULSADOR_P ;pulsador liberado
goto TA01
retlw 1

;*********************************************************
; Retardo para gestión de pulsadores
;*********************************************************

DELAY20
clrf DLY
DLY01 nop
nop
nop
decfsz DLY,f ;salta si es cero
goto DLY01
return
 
Última edición:
Arriba