Hola @victorjam, solo se me ocurre una idea, que empiece a hacer el código y tal vez es mas fácil que me explique que es lo que deseo que haga Arduino.
Saludos.
Hola @victorjam, tal vez sea mas fácil que te des una idea con bosquejo de código, solo puse filtro para no crear enredos.
Saludos.
Nota: Nunca un switch case echo por a funcionado a un que copile.
#include<Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20 , 4);
const unsigned long intervalfiltro = 1000; //intervalo ebtre lecturas
const unsigned long intervalventilador = 1000;
const unsigned long intervalvalvula = 1000;
const unsigned long intervalcombustion = 1000;
const unsigned long intervalEspera = 300;
const unsigned long horacicloR1filtro = 2000; // tiempo inicio rele filtro
const unsigned long horacicloR2ventilador = 2000;
const unsigned long horacicloR3valvula = 2000;
const unsigned long horacicloR4combustion = 2000;
const unsigned long cicloR1, cicloR2, cicloR3, cicloR4 = 600;
#define R1filtro 8
#define R2ventilador 9
#define R3valvula 10
#define R4combustion 11
#define sensorfiltro 22
#define sensorventilador 24
#define sensorvalvula 26
#define sensorcombustion 28
enum estado {INICIO, ERROR, FILTRO, VENTILADOR, VALVULA, COMBUSTION};
estado estados;
unsigned long tiempoinicio;
unsigned long tiempofiltro;
unsigned long tiempoventilador;
unsigned long tiempovalvula;
unsigned long tiempocombustion;
unsigned long tiemponuevointento;
unsigned long errorfiltro;
unsigned long intervalolecturas = 2500UL;
unsigned long cicloinicio;
unsigned long cicloR1filtro;
unsigned long cicloR2ventilador;
unsigned long cicloR3valvula;
unsigned long cicloR4combustion;
unsigned long error;
bool estadoinicio;
bool estadosensorfiltro;
bool estadosensorventilador;
bool estadosensorvalvula;
bool estadosensorcombustion;
void setup() {
Serial.begin(9600);
lcd.init();
lcd.backlight();
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(" applied air");
lcd.setCursor(0, 1);
lcd.print(" MAU-01-04 ");
pinMode(R1filtro, OUTPUT);
pinMode(R2ventilador, OUTPUT);
pinMode(R3valvula, OUTPUT);
pinMode(R4combustion, OUTPUT);
pinMode(sensorfiltro, INPUT_PULLUP);
pinMode(sensorventilador, INPUT_PULLUP);
pinMode(sensorvalvula, INPUT_PULLUP);
pinMode(sensorcombustion, INPUT_PULLUP);
digitalWrite(R1filtro, HIGH);
digitalWrite(R2ventilador, HIGH);
digitalWrite(R3valvula, HIGH);
digitalWrite(R4combustion, HIGH);
}
void loop() {
switch (INICIO) {
case R1filtro: //estado que tendra el rele
if (millis() - tiempofiltro >= intervalfiltro) {
bool estadosensorfiltro = digitalRead (sensorfiltro); //lectura sensor
if (estadosensorfiltro == HIGH) {
digitalWrite(R1filtro, LOW);
} else {
digitalWrite(R1filtro, HIGH);
tiempofiltro = millis(); //cierra tiempo lecturas
}
break;
case sensorfiltro:
if (millis() - errorfiltro >= errorfiltro) { //tiempo lecturas errorfiltro
if (digitalRead (errorfiltro)); // lee si hay error de sensor
for (int tiempoerrorfiltro = 3; tiempoerrorfiltro < 3; tiempoerrorfiltro++) { // si arduino lee tres veces segun sus millis declara error
digitalWrite(R1filtro, HIGH); //apaga relé R1filtro de forma indefinida hasta nuevo reinicio
lcd.print("errorfiltro"); //imprime en LCD que filtro tiene error
cicloR1filtro = millis();
errorfiltro = millis();
break;
}
}
}
}
}
void ventilador() {
//solo funciona ventilador
}
void calefaccion() {
// funciona ventilador y calefacción
}
Hola @victorjam, espero que entre el código de arriba y el de abajo, y mis demás explicaciones te puedas dar una idea de lo que quiero hacer.
Saludos desde MX.
#define R1filtro 8
#define R2turbina 9
#define R3honywell 10
#define R4flama 11
#define sensorR1filtro 22
#define sensorR2turbina 24
#define sensorR3honywell 26
#define sensorR4flama 28
#define ventilar 12
#define calefaccion 13
const unsigned long lecturafiltro = 1000;
const unsigned long lecturaturbina = 1000;
const unsigned long lecturavalvula = 1000;
const unsigned long lecturahonywell = 1000;
const unsigned long lecturaflama = 1000;
const unsigned long lecturaerror = 1000;
const unsigned long lecturareleR1filtro;
const unsigned long lecturareleR2turbina;
const unsigned long lecturareleR3honeywell;
const unsigned long lecturareleR4flama;
enum {
INICIO,
FILTRO,
TURBINA,
VALVULA,
HONYWELL,
FLAMA,
SENSORFILTRO,
SENSORTURBINA,
SENSORVALVULA,
SENSORFLAMA,
VENTILAR,
CALEFACCION
} estado;
int filtro;
int turbina;
int valvula;
int honywell;
int flama;
int sensorfiltro;
int sensorturbina;
int sensorvalvula;
int sensorhonywell;
int sensorflama;
int errorfiltro;
int errorturbina;
int errorvalvula;
int errorhonywell;
int errorflama;
void setup() {
Serial.begin(9600);
lcd.init();
lcd.backlight();
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(" advenn air");
lcd.setCursor(0, 1);
lcd.print(" MAU-01-04 ");
delay(3000);
pinMode(R1filtro, OUTPUT);
pinMode(R2turbina, OUTPUT);
pinMode(R3honywell, OUTPUT);
pinMode(R4flama, OUTPUT);
pinMode(sensorfiltro, INPUT_PULLUP);
pinMode(sensorturbina, INPUT_PULLUP);
pinMode(sensorhonywell, INPUT_PULLUP);
pinMode(sensorflama, INPUT_PULLUP);
digitalWrite(R1filtro, HIGH);
digitalWrite(R2turbina, HIGH);
digitalWrite(R3honywell, HIGH);
digitalWrite(R4flama, HIGH);
}
void loop() {
switch (estado) {
case INICIO:
case FILTRO:
case TURBINA:
case VALVULA:
case HONYWELL:
case FLAMA:
case SENSORFILTRO:
case SENSORTURBINA:
case SENSORVALVULA:
case SENSORFLAMA:
case VENTILAR:
case CALEFACCION:
default: break;
};
}
void inicio() {
if (SENSORFILTRO)
estado = HIGH;
if (R1filtro)
estado = LOW;
if (SENSORTURBINA)
estado = HIGH;
if (R2turbina)
estado = LOW;
if (SENSORVALVULA)
estado = HIGH;
if (R3honywell)
estado = LOW;
if (SENSORFLAMA)
estado = HIGH;
if (R4flama)
estado = LOW;
}
void ventilacion() {
if (VENTILAR)
estado = HIGH;
if (sensorfiltro == HIGH){
estado = HIGH;
digitalWrite (R1filtro, LOW);
}
if (sensorturbina == HIGH)
estado = HIGH;
digitalWrite (R2turbina, LOW);
}
void calefactor(){
if (VENTILAR)
estado = HIGH;
if (sensorfiltro == HIGH){
estado = HIGH;
digitalWrite (R1filtro, LOW);
}
if (sensorturbina == HIGH)
estado = HIGH;
digitalWrite (R2turbina, LOW);
if (VENTILAR)
estado = HIGH;
if (sensorhonywell == HIGH){
estado = HIGH;
digitalWrite (R3honywell, LOW);
}
if (sensorflama == HIGH)
estado = HIGH;
digitalWrite (R4flama, LOW);
}
Creo que si no es posible que se entienda lo que deseo, tendré que tomar un curso de redacción, otro de diagramas de flujo de maquinas fintas.
He visto el código de ambos y veo que mezclas cosas como salidas con entrada y estados, lo cual hace que el código sea ilegible.
Voy a darte una serie de recomendaciones, además en plan sermón...
El nombre de los pines conviene diferenciarlos de las variables a los que asocies su valor. Por ejemplo si tienes una variable llamada "sensorfiltro" que te dice en que estado está la entrada digital 22; por un lado deberás declarar con una macro define o usando una constante el pin asociado a esa variable. No es necesario pero si le pones delante "pin" se entenderá mejor:
// Esto declara el número del pin.
#define pinSensorFiltro 22
// También lo puedes declarar como una constante.
const int pinSensorFiltro=22;
// sensorFiltro es donde vas a guardar el estado del pin.
int sensorFiltro;
void setup() {
...
// El pin lo pones en modo entrada.
pinMode(pinSensorFiltro, INPUT);
...
}
void loop() {
// Lees el pin y lo guardas en la variable.
sensorFiltro = digitalRead(pinSensorFiltro);
Utiliza nombres de variables que identifiquen lo que realmente es esa variable. "sensorFiltro" Te dice que es el sensor de filtro y es correcto. No es una norma escrita, pero generalmente al poner nombres de variables se suele poner todas las primeras letras de cada palabra en mayúscula, menos la de la primera. Por ejemplo la anterior "sensorFiltro": s minuscula, F mayúscula; "valvulaProporcional", v minuscula, P mayuscula.
Tampoco está escrito, pero es casi una norma que el nombre de constantes se declare todo en mayuscula.
Sobre el enum. Un enum es una forma elegante de declarar constantes. Entre las llaves escribes una serie de nombres de constantes separados por comas. Internamente el compilador les asigna un número a cada constante, sin entrar en mucho detalle la primera constante vale 0, la siguiente 1, etc.
enum {
CONSTANTE0, // Vale 0
CONSTANTE1, // Vale 1
CONSTANTE2 // Vale 2
};
También se podria haber hecho:
#define CONSTANTE0 0
#define CONSTANTE1 1
#define CONSTANTE2 2
O usando const, pero la forma mas elegante es usar enum. Simplemente no deja una manera de llamar a un número.
Si las constantes definidas en el enum representan "estados" este nombre debería identificar a dicho estado: ABRIENDO, CERRANDO, ESPERANDO, etc. Generalmente un estado será un gerundio de un verbo que representa la acción a realizar.
Si utilizas la forma:
enum {
CONSTANTE0,
CONSTANTE1,
CONSTATEN2
};
Solo estas definiendo las constantes. Se puede declarar un tipo de enum, como si fuera otro tipo de dato estilo bool, char, int, long. Tan solo hay que añadir el nombre del tipo de dato despues de enum:
enum TIPO {
CONSTANTE0,
CONSTANTE1,
CONSTANTE2,
};
Con eso has declarado un nuevo tipo de dato que luego puedes utilizar en otras variables:
// Con creas un nuevo tipo de dato llamado TIPO.
enum TIPO {
CONSTANTE0,
CONSTANTE1,
CONSTANTE2,
};
// Ahora creas una variable de tipo TIPO, es como declarar un entero.
TIPO variable;
Otra forma de hacerlo es añadiendo la variable al final, es lo que mas vas a ver en el foro:
enum {
CONSTANTE0,
CONSTANTE1,
CONSTANTE2
} variable;
En teoría "varaible" solo puede valer los valores definidos en el enum, pero como el compilador los trata como enteros se pueden hacer cosas raras.
Ahora en cuanto a las explicaciones. Todos los idiomas tienen una cosa que se llama punto que sirve para hacer una separación entre textos. Sobte todo el punto y aparte que es muy válido. También tiene comas que hacen una separación más pequeña. El uso de () para etiquetar algo concreto también es mas útil.
Veamos tu explicación:
Si pin digital D7 esta en HIGH
Se verifica estado de sensores pin digital D22 si sensor filtro esta HIGH Arduino enciende relé RE57 desde el pin digital D2 esperar a que final de carrera indique que servomotor ha terminado de abrir persiana de filtro pin digital 8 está en HIGH Arduino verifica apertura en HIGH sino y sigue en LOW declara error si se indica HIGH Arduino enciende relé RE34 desde pin digital D3 para iniciar funcionamiento de ventilador 30 segundos sin importar el estado de sensores de presión verificando el estado de sensores de presión pin digital D9 primero 0.4 PSI y después 1.25 PSI si sensores indican LOW declara error y si indican HIGH Arduino encenderá el relé RE28 desde su pin digital D4 que pone en marcha Modulo 7800 si no consigue encender la combustión LOW declara error si consigue activar la combustión HIGH Arduino inicia la lectura de sensor de límite máximo pin digital D10 y si esta en HIGH continua con la operación sino declara error si esta en HIGH le termostato pin digital D7 si indica LOW apaga el equipo.
Te lo lees de una tacada y no te enteras de nada, y más teniendo en cuenta que no sabemos lo que tenemos, por que no estamos delante.
Empiezas con si pin digital 7 esta en HIGH, y no se que es el pin digital 7, solo hasta que llego al final que es una salida del termostato que has puesto en lugar de la pantalla.
Luego casi logro ver la secuencia pero mezclas sensores de un lado a otro...
Se lee el sensor del filtro (pin 22) que si esta en HIGH enciende el relé 57 (pin 2). Se tiene que esperar a que se abra la persiana que se indica en el pin 8 con un valor HIGH. Si transcurrido un tiempo desde que activamos el rele 57 y el pin 8 sigue LOW debemos de dar error. Si, por el contrario, esta en nivel HIGH debemos encender el rele 34 (pin 3) para iniciar el ventilador. Durante 30 segundos esperaremos y luego leeremos el estado de los sensores de presión.
Los sensores de presión tienen contactos que se cerraran o abriran al alcanzar 0.4PSI y 1.25 PSI y se utilizan dos entradas del arduino, una es la 9 la otra no se especifica en tu texto. Al llegar a la presión se pondrán HIGH y si no estarán en valor LOW. Si transcurridos los 30 segundos desde que inicamos el ventilador siguen estando a LOW daremos error, y si estan a HIGH debemos encender el rele 28 (pin 4). Este rele pondrá en marcha el modulo 7800. Aqui no indicas nada de que pin, ni tiempo debemos usar. Solo dices que si no consigue encender la combustión sera LOW y si lo consigue será HIGH. Una vez resolvamos lo anterior (saber que pin es), se empieza la lectura del sensor de limite máximo en el pin 10, que no sé de donde sale, pero que si está en HIGH continua, si está en LOW hay que dar un error...
Por ultimo si el termostato (pin 7) indica LOW se apaga el equipo...
No se. He intentado exclarecer un poco mas el texto que has puesto, pero ves que sin usar comas y puntos, separando secuencias es muy díficil de lograr...
Para intentar ayudarte voy a hacer una serie de preguntas, solo responde breve, sin dar explicaciones.
Las entradas d7 y d10 van conectadas al termostato.
¿Que significa que d7 está en HIGH? ¿y en LOW?
¿Que significa que 10 está en HIGH? ¿y en LOW?
Hola @victorjam, hoy ha sido domingo de sermones, vengo de misa, el sermón fue aburrido, casi me duermo, tu sermón me quito el sueño. Lo de separar los relés de los sensores, con diferentes nombres me quedo bien claro. lo de enum mas o menos, lo que si me quedo muy claro es lo mal que me explico, cuando intentas explicarme mi propia explicación, hasta mi me resulta incomprensible, mi explicación. Si las comas puntos me las como cuando escribo aprisa. Me tomo un te de tila y regreso al código, que analizando mi historial en el foro siempre inicio el hilo, con un código que elaboro con calma, y cuando surgen las preguntas me es mas fácil responder, al principio eran los millis mi problema, ahora que me inicio con las maquinas de estado, me cuesta hacer que el código sea legible, operativo, funcional y demás hierbas. Tu Sermón ha sido de lo mas constructivo y seguro y notara cuando vuelva a subir el código corregido espero y las preguntas que surjan de el poder darles una respuesta clara.
Saludos.
Hola @victorjam, ya corregí la gramática del código, hasta donde pude, hice 2 enum una para reles, otro para sensores. El código copila, no lo e subido al mega, tampoco lo he comentado, que opinas ya se entiende mejor, para seguir programa"ndo" en España son la 1: 25 AM de lunes, usted tendrá trabajo, así que seguiré trabajando con la gramática del código, mientra espero tu opinión.
Saludos.
#include <max6675.h>
#include<Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20 , 4);
#define pinFiltro 8
#define pinTurbina 9
#define pinHonywell 10
#define pinFlama 11
#define pinsensorFiltro 22
#define pinsensorTurbina 24
#define pinsensorHonywell 26
#define pinsensorFlama 28
#define Ventilar 12
#define Calefaccion 13
const unsigned long pinlecturaFiltro = 1000;
const unsigned long pinlecturaTurbina = 1000;
const unsigned long pinlecturaValvula = 1000;
const unsigned long pinlecturaHonywell = 1000;
const unsigned long pinlecturaFlama = 1000;
const unsigned long pinlecturaError = 1000;
int reles;
enum RELES {
INICIO,
FILTRO,
TURBINA,
VALVULA,
HONYWELL,
FLAMA
} estado;
enum SENSANDO {
SENSANDOFILTRO,
SENSANDOTURBINA,
SENSANDOVALVULA,
SENSANDOFLAMA,
VENTILANDO,
CALENTANDO
} variables;
int Filtro;
int Turbina;
int Valvula;
int Honywell;
int Flama;
int pinSensorFiltro;
int pinSensorTurbina;
int pinSensorValvula;
int pinSensorHonywell;
int pinSensorFlama;
int errorFiltro;
int errorTurbina;
int errorValvula;
int errorHonywell;
int errorFlama;
void setup() {
Serial.begin(9600);
lcd.init();
lcd.backlight();
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(" advenn air");
lcd.setCursor(0, 1);
lcd.print(" MAU-01-04 ");
delay(3000);
pinMode(pinFiltro, OUTPUT);
pinMode(pinTurbina, OUTPUT);
pinMode(pinHonywell, OUTPUT);
pinMode(pinFlama, OUTPUT);
pinMode(pinSensorFiltro, INPUT_PULLUP);
pinMode(pinSensorTurbina, INPUT_PULLUP);
pinMode(pinSensorHonywell, INPUT_PULLUP);
pinMode(pinSensorFlama, INPUT_PULLUP);
digitalWrite(pinFiltro, HIGH);
digitalWrite(pinTurbina, HIGH);
digitalWrite(pinHonywell, HIGH);
digitalWrite(pinFlama, HIGH);
}
void loop() {
switch (reles) {
case INICIO:
case FILTRO:
case TURBINA:
case VALVULA:
case HONYWELL:
case FLAMA:
default: break;
};
switch (variables) {
case SENSANDOFILTRO:
case SENSANDOTURBINA:
case SENSANDOVALVULA:
case SENSANDOFLAMA:
case VENTILANDO:
case CALENTANDO:
default: break;
};
}
void inicio() {
if (SENSANDOFILTRO)
estado = HIGH;
if (pinFiltro)
estado = LOW;
if (SENSANDOTURBINA)
estado = HIGH;
if (pinTurbina)
estado = LOW;
if (SENSANDOVALVULA)
estado = HIGH;
if (pinHonywell)
estado = LOW;
if (SENSANDOFLAMA)
estado = HIGH;
if (pinFlama)
estado = LOW;
}
void ventilacion() {
if (VENTILANDO)
estado = HIGH;
if (pinSensorFiltro == HIGH){
estado = HIGH;
digitalWrite (pinFiltro, LOW);
}
if (pinsensorTurbina == HIGH)
estado = HIGH;
digitalWrite (pinTurbina, LOW);
}
void calefaccion(){
if (CALENTANDO)
estado = HIGH;
if (pinsensorFiltro == HIGH){
estado = HIGH;
digitalWrite (pinFiltro, LOW);
}
if (pinsensorTurbina == HIGH)
estado = HIGH;
digitalWrite (pinTurbina, LOW);
if (VENTILANDO)
estado = HIGH;
if (pinsensorHonywell == HIGH){
estado = HIGH;
digitalWrite (pinHonywell, LOW);
}
if (pinFlama == HIGH)
estado = HIGH;
digitalWrite (pinFlama, LOW);
}
hay muchos detalles que no entiendo el mas relevantepara mi curiosidad tuve que declara "int reles;" para que copilara, pero variables no me dio error y no lo declare por que sera.
#include <max6675.h>
#include<Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20 , 4);
#define pinFiltro 7
#define pinTurbina 8
#define pinValvula 9
#define pinHonywell 10
#define pinFlama 11
#define pinSensorFiltro 22
#define pinSensorTurbina 24
#define pinSensorValvula 26
#define pinSensorHonywell 28
#define pinSensorFlama 30
#define pinVentilar 12
#define pinCalefactor 13
const unsigned long pinlecturaFiltro = 1000;
const unsigned long pinlecturaTurbina = 1000;
const unsigned long pinlecturaValvula = 1000;
const unsigned long pinlecturaHonywell = 1000;
const unsigned long pinlecturaFlama = 1000;
const unsigned long pinlecturaError = 1000;
int reles;
enum RELES {
INICIO,
FILTRO,
TURBINA,
VALVULA,
HONYWELL,
FLAMA,
} estado;
enum SENSANDO {
SENSANDOFILTRO,
SENSANDOTURBINA,
SENSANDOVALVULA,
SENSANDOHONYWELL,
SENSANDOFLAMA,
SENSANDOERROR,
SENSANDOVENTILANDO,
SENSANDOCALENTANDO
} variables;
int Filtro;
int Turbina;
int Valvula;
int Honywell;
int Flama;
int sensorFiltro;
int sensorTurbina;
int sensorValvula;
int sensorHonywell;
int sensorFlama;
int errorFiltro;
int errorTurbina;
int errorValvula;
int errorHonywell;
int errorFlama;
void setup() {
Serial.begin(9600);
lcd.init();
lcd.backlight();
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(" advenn air");
lcd.setCursor(0, 1);
lcd.print(" MAU-01-04 ");
delay(3000);
pinMode(pinFiltro, OUTPUT);
pinMode(pinTurbina, OUTPUT);
pinMode(pinHonywell, OUTPUT);
pinMode(pinFlama, OUTPUT);
pinMode(pinSensorFiltro, INPUT_PULLUP);
pinMode(pinSensorTurbina, INPUT_PULLUP);
pinMode(pinSensorHonywell, INPUT_PULLUP);
pinMode(pinSensorFlama, INPUT_PULLUP);
digitalWrite(pinFiltro, HIGH);
digitalWrite(pinTurbina, HIGH);
digitalWrite(pinValvula, HIGH);
digitalWrite(pinHonywell, HIGH);
digitalWrite(pinFlama, HIGH);
}
void loop() {
switch (reles) {
case INICIO:
case FILTRO:
case TURBINA:
case VALVULA:
case HONYWELL:
case FLAMA:
default: break;
};
switch (variables) {
case SENSANDOFILTRO:
case SENSANDOTURBINA:
case SENSANDOVALVULA:
case SENSANDOFLAMA:
case SENSANDOERROR:
case SENSANDOVENTILANDO:
case SENSANDOCALENTANDO:
default: break;
};
}
void inicio() {
if (SENSANDOFILTRO)
estado = HIGH;
if (pinFiltro)
estado = 1;
if (SENSANDOTURBINA)
estado = HIGH;
if (pinTurbina)
estado = 1;
if (SENSANDOVALVULA)
estado = HIGH;
if (pinValvula)
estado = 1;
if (SENSANDOHONYWELL)
estado = HIGH;
if (pinHonywell)
estado = 1;
if (SENSANDOFLAMA)
estado = HIGH;
if (pinFlama)
estado = 1;
}
void ventilacion() {
sensorFiltro = digitalRead(pinSensorFiltro);
if (SENSANDOVENTILANDO)
estado = HIGH;
if (sensorFiltro == HIGH) {
estado = HIGH;
digitalWrite (pinFiltro, LOW);
}
sensorTurbina = digitalRead(pinSensorTurbina);
if (SENSANDOVENTILANDO)
estado = HIGH;
if (pinSensorTurbina == HIGH) {
estado = HIGH;
digitalWrite (pinTurbina, LOW);
}
}
void calefaccion() {
sensorFiltro = digitalRead(pinSensorFiltro);
if (SENSANDOCALENTANDO)
estado = HIGH;
if (sensorFiltro == HIGH) {
estado = HIGH;
digitalWrite (pinFiltro, LOW);
}
sensorTurbina = digitalRead(pinSensorTurbina);
if (SENSANDOCALENTANDO)
estado = HIGH;
if (pinSensorTurbina == HIGH) {
digitalWrite (pinTurbina, LOW);
}
sensorValvula = digitalRead(pinSensorValvula);
if (SENSANDOCALENTANDO)
estado = HIGH;
if (pinSensorValvula == HIGH) {
estado = HIGH;
digitalWrite (pinValvula, LOW);
}
sensorHonywell = digitalRead(pinSensorHonywell);
if (SENSANDOCALENTANDO)
estado = HIGH;
if (pinSensorHonywell == HIGH) {
estado = HIGH;
digitalWrite (pinHonywell, LOW);
}
sensorFlama = digitalRead(pinSensorFlama);
if (SENSANDOCALENTANDO)
estado = HIGH;
if (pinSensorFlama == HIGH) {
estado = HIGH;
digitalWrite (pinFlama, LOW);
}
}
Hola @victorjam, según yo, ahora esta mas claro, creo que hay ordenes repetidas, que confundo con lecturas de reles y o sensores, ahora intentare agregar los errores, para paros por falla, también un pin que genere señal PWM para alimentar con ese PWM a modulo conversor de PWM a señal 0-10 volts analógico, que a su vez controla el modulo( imagen post #14) que controla válvula proporcional.
Serial.print(pinSensorFlama);
Le pedí a monitor Serial que imprimiese esto (renglón 232) y nada así que este código toda vía no hace nada.
Ese codigo no va a hacer nada. Las funciones "inicio", "ventilación" y "calefaccion" no se llaman en ningún sitio del
loop principal.
En el loop no necesitas dos enum para entradas y salidas. Solo necesitas leer las entradas y ejecutar la máquina de
estados.
En las tres funciones haces una cosa que no tiene sentido...
estado = HIGH;
El loop debería parecerse a esto:
enum {
ESTADO1,
ESTADO2,
ESTADON
}
int estado;
void loop() {
entrada1 = digitalRead(pinEntrada1);
entrada2 = digitalRead(pinEntrada2);
entradaN = digitalRead(pinEntradaN);
switch ( estado ) {
case ESTADO1: funcionEstado1():
case ESTADO2: funcionEtado2();
case ESTADON: funcionEstado3();
default;
}
}
Luego tienes que crear las funcion según el estado en el que estes, por ejemplo, en el estado ESTADO1 if la entrada1 está activa enciendes un relé y pasas al siguiente estado ESTADO2;
void funcionEstado1() {
if ( entradaX ) {
digitalWrite(rele, LOW);
estado = ESTADO2;
}
}
Hola @victorjam, no me queda claro, me podrías poner un ejemplo que incluya los términos que uso en el código, creo que solo con filtro seria suficiente, la forma en que me lo explicas es muy genérico,
#include <max6675.h>
#include<Wire.h>
#include <LiquidCrystal_I2C.h>
LiquidCrystal_I2C lcd(0x27, 20 , 4);
#define pinFiltro 7
#define pinTurbina 8
#define pinValvula 9
#define pinHonywell 10
#define pinFlama 11
#define pinSensorFiltro 22
#define pinSensorTurbina 24
#define pinSensorValvula 26
#define pinSensorHonywell 28
#define pinSensorFlama 30
#define pinVentilar 12
#define pinCalefactor 13
const unsigned long pinlecturaFiltro = 1000;
const unsigned long pinlecturaTurbina = 1000;
const unsigned long pinlecturaValvula = 1000;
const unsigned long pinlecturaHonywell = 1000;
const unsigned long pinlecturaFlama = 1000;
const unsigned long pinlecturaError = 1000;
int reles;
enum RELES {
INICIO,
VENTILACION,
CALEFACCION,
FILTRO,
TURBINA,
VALVULA,
HONYWELL,
FLAMA,
SENSANDOFILTRO,
SENSANDOTURBINA,
SENSANDOVALVULA,
SENSANDOHONYWELL,
SENSANDOFLAMA,
SENSANDOERROR,
SENSANDOVENTILANDO,
SENSANDOCALENTANDO
} estado;
int Filtro;
int Turbina;
int Valvula;
int Honywell;
int Flama;
int estados;
int sensorFiltro;
int sensorTurbina;
int sensorValvula;
int sensorHonywell;
int sensorFlama;
int errorFiltro;
int errorTurbina;
int errorValvula;
int errorHonywell;
int errorFlama;
void setup() {
Serial.begin(9600);
lcd.init();
lcd.backlight();
lcd.clear();
lcd.setCursor(0, 0);
lcd.print(" advenn air");
lcd.setCursor(0, 1);
lcd.print(" MAU-01-04 ");
Serial.print(" MAU-01-04 ");
delay(3000);
pinMode(pinFiltro, OUTPUT);
pinMode(pinTurbina, OUTPUT);
pinMode(pinValvula, OUTPUT);
pinMode(pinHonywell, OUTPUT);
pinMode(pinFlama, OUTPUT);
pinMode(pinSensorFiltro, INPUT_PULLUP);
pinMode(pinSensorTurbina, INPUT_PULLUP);
pinMode(pinSensorValvula, INPUT_PULLUP);
pinMode(pinSensorHonywell, INPUT_PULLUP);
pinMode(pinSensorFlama, INPUT_PULLUP);
digitalWrite(pinFiltro, HIGH);
digitalWrite(pinTurbina, HIGH);
digitalWrite(pinValvula, HIGH);
digitalWrite(pinHonywell, HIGH);
digitalWrite(pinFlama, HIGH);
}
void loop() {
sensorFiltro = digitalRead (pinSensorFiltro);
sensorTurbina = digitalRead (pinSensorTurbina);
sensorValvula = digitalRead (pinSensorValvula);
sensorHonywell = digitalRead (pinSensorHonywell);
sensorFlama = digitalRead (pinSensorFlama);
switch (estados) {
case INICIO:
case VENTILACION:
case CALEFACCION:
case FILTRO:
case TURBINA:
case VALVULA:
case HONYWELL:
case FLAMA:
default: break;
};
}
void ventilacion() {
if (INICIO){
if (VENTILACION){
if (millis() - pinlecturaFiltro >= sensorFiltro) {
if (millis() - errorFiltro >= sensorFiltro) {
sensorFiltro = digitalRead(pinSensorFiltro);
if (sensorFiltro == HIGH) {
digitalWrite (pinFiltro, LOW);
Serial.print(pinSensorFiltro);
estado = Filtro;
}
sensorFiltro = millis ();
}
errorFiltro = millis();
}
}
if (millis() - pinlecturaTurbina >= sensorTurbina) {
if (millis() - errorTurbina >= sensorTurbina) {
sensorTurbina = digitalRead(pinSensorTurbina);
if (VENTILACION)
if (pinSensorTurbina == HIGH) {
digitalWrite (pinTurbina, LOW);
}
sensorTurbina = millis ();
}
errorTurbina = millis();
}
}
}
void calefaccion() {
if(INICIO){
if (millis() - pinlecturaFiltro >= sensorFiltro) {
if (millis() - errorFiltro >= sensorFiltro) {
sensorFiltro = digitalRead(pinSensorFiltro);
if (SENSANDOCALENTANDO)
estado = HIGH;
if (sensorFiltro == HIGH) {
estado = HIGH;
digitalWrite (pinFiltro, LOW);
}
sensorFiltro = millis ();
}
errorFiltro = millis();
}
if (millis() - pinlecturaTurbina >= sensorTurbina) {
if (millis() - errorTurbina >= sensorTurbina) {
sensorTurbina = digitalRead(pinSensorTurbina);
if (SENSANDOCALENTANDO)
estado = HIGH;
if (pinSensorTurbina == HIGH) {
digitalWrite (pinTurbina, LOW);
}
sensorTurbina = millis ();
}
errorTurbina = millis();
}
if (millis() - pinlecturaValvula >= sensorValvula) {
if (millis() - errorValvula >= sensorValvula) {
sensorValvula = digitalRead(pinSensorValvula);
if (SENSANDOCALENTANDO)
if (pinSensorValvula == HIGH) {
digitalWrite (pinValvula, LOW);
}
sensorTurbina = millis ();
}
errorTurbina = millis();
}
if (millis() - pinlecturaHonywell >= sensorHonywell) {
if (millis() - errorHonywell >= sensorHonywell) {
sensorHonywell = digitalRead(pinSensorHonywell);
if (SENSANDOCALENTANDO)
if (pinSensorHonywell == HIGH) {
digitalWrite (pinHonywell, LOW);
}
sensorTurbina = millis ();
}
errorTurbina = millis();
}
if (millis() - pinlecturaFlama >= sensorFlama) {
if (millis() - errorFlama >= sensorFlama) {
sensorFlama = digitalRead(pinSensorFlama);
Serial.print(pinSensorFlama);
if (SENSANDOCALENTANDO)
Serial.print(errorFlama);
Serial.print(pinlecturaFlama);
if (pinSensorFlama == HIGH) {
digitalWrite (pinFlama, LOW);
}
sensorFlama = millis ();
}
errorFlama = millis();
}
}
}
Creo que el principal problema de entendimiento, entre nosotros, es que presupones que se mas de lo que en realidad se.
Nota ya quite todo lo que no tenia sentido, en los tres loop, solo deje un enum sigue sin enviar información el monitor Serie.
Saludos
Voy a poner un ejemplo a partir de está traducción que hice:
Empiezas con si pin digital 7 esta en HIGH, y no se que es el pin digital 7, solo hasta que llego al final que es una salida del termostato que has puesto en lugar de la pantalla.
Luego casi logro ver la secuencia pero mezclas sensores de un lado a otro...
Se lee el sensor del filtro (pin 22) que si esta en HIGH enciende el relé 57 (pin 2). Se tiene que esperar a que se abra la persiana que se indica en el pin 8 con un valor HIGH. Si transcurrido un tiempo desde que activamos el rele 57 y el pin 8 sigue LOW debemos de dar error. Si, por el contrario, esta en nivel HIGH debemos encender el rele 34 (pin 3) para iniciar el ventilador. Durante 30 segundos esperaremos y luego leeremos el estado de los sensores de presión.
Identifico las entradas:
- pin 7 sin nombre.
- pin 22 sensor de filtro.
- pin 8 persianaAbierta.
Como aun no me has respondido a la pregunta que te hice sobre el pin 7 y 10, lo llamaré sinNombre por ahora.
Identifico las salidas:
- pin 2 relé 57 (abre la persiana).
- pin 3 rele 34 (encender ventilador).
Tengo que identificar los estados:
- INICIO: Aquí debo esperar a que el pin 7 sea HIGH.
- ABRIENDO_PERSIANA: Se tiene que abrir la persiana.
- ENCENDIENDO_VENTILADOR: Se tiene que enceder el ventilador.
- ERROR: Un estado de error.
Declaro las constantes donde voy a poner el pin y el nombre de este:
#define pinSinNombre 7
#define pinSensorFiltro 22
#define pinPersianaAbierta 8
#define pinSensorPresion 9
#define pinRele57 2
#define pinRele34 3
Declaro unas variables para guardar el estado de las entradas:
int sinNombre;
int sensorFiltro;
int persianaAbierta;
int sensorPresion;
Creo las constantes con los nombre de estado usando un enum y una variable entera donde se guardará el estado actual del sistema.
enum {
INICIO,
ABRIENDO_PERSIANA,
ENCENDIENDO_VENTILADOR,
ERROR
};
int estado = INICIO;
Voy a necesitar un temporizador por lo tanto creo la variable de tiempo:
unsigned long temporizador;
En el setup pongo los pines de entrada y de salida en sus respectivos modos:
void setup() {
pinMode(pinSinNombre, INPUT_PULLUP);
pinMode(pinSensorFiltro, INPUT_PULLUP);
pinMode(pinPersianaAbierta, INPUT_PULLUP);
pinMode(pinSensorPresion, INPUT_PULLUP);
pinMode(pinRele57, OUTPUT); digitalWrite(pinRele57, HIGH);
pinMode(pinRele34, OUTPUT); digitalWrite(pinRele34, HIGH);
}
Ahora en el loop, tengo que leer el estado de las entradas y ejecutar la máquina de estados, no voy a usar funciones a ver si asi lo ves mejor.
void loop() {
// Leo las entradas.
sinNombre = digitalRead(pinSinNombre);
sensorFiltro = digitalRead(pinSensorFiltro);
persianaAbierta = digitalRead(pinPersianaAbierta);
sensorPresion = digitalRead(pinSensorPresion);
switch ( estado ) {
case INICIO:
// Si el pin 7 esta HIGH se debe leer el sensor de filtro que si esta en HIGH debe encender el rele 57 y esperar a que abra la persiana.
if ( sinNombre==HIGH ) {
if ( digitalRead(sensorFiltro)==HIGH ) {
digitalWrite(pinRele57, LOW);
temporizador = millis();
estado = ABRIENDO_PERSIANA;
}
}
break;
case ABRIENDO_PERSIANA:
// Ya se encendio el rele 57 y tenemos que esperar a que abra la persiana.
// Si la persiana esta abierta debemos encender el rele 34 guardar el tiempo y cambiar al estado de ENCENDIENDO_VENTILADOR.
if ( persianaAbierta == HIGH ) {
digitalWrite(rele34, LOW);
temporizador = millis();
estado = ENCENDIENDO_VENTILADOR;
}
else {
// La persinana no esta abierta y vale LOW. Hemos de comprobar el tiempo.
if ( millis()-temporizador>=30000UL ) {
// Si han transcurrido 30 segundos debemos dar error y hacer alguna que otra cosa.
estado = ERROR;
}
}
break;
case ENCENDIENDO_VENTILADOR:
// El ventilador está encendido
if ( sensorPresion==HIGH ) {
// Aqui seguirá la secuencia al siguiente estado que aun no hemos identificado.
}
else {
if ( millis()-temporizador > TIEMPO ) {
estado = ERROR;
}
}
break;
}
}
Si observas el código no se parece en nada a lo que tu escribes. La descripción del sistema es lo mas importante, si sabes identificar la entradas, salidas, lo que se está haciendo en cada momento y las condiciones que hacen que pase de un estado a otro, la escritura de la máquina de estados se vuelve automática. Por eso no puedo ayudarte a escribir la máquina de estados, ya que no tengo claro que son entrada, que son salida, ni siquiera la secuencia de pasos y mucho menos las condiciones para cambiar de secuencia o estado.
#define pinThermoRemoto 7
#define pinSensorFiltro 22
#define pinPersianaAbierta 8
#define pinSensorPresion 9
#define pinRele57 2
#define pinRele34 3
int TIEMPO;
int temporizador;
int ThermoRemoto;
int sensorFiltro;
int persianaAbierta;
int sensorPresion;
enum {
INICIO,
ABRIENDO_PERSIANA,
ENCENDIENDO_VENTILADOR,
ERROR
};
int estado = INICIO;
void setup() {
pinMode(pinThermoRemoto, INPUT_PULLUP);
pinMode(pinSensorFiltro, INPUT_PULLUP);
pinMode(pinPersianaAbierta, INPUT_PULLUP);
pinMode(pinSensorPresion, INPUT_PULLUP);
pinMode(pinRele57, OUTPUT); digitalWrite(pinRele57, HIGH);
pinMode(pinRele34, OUTPUT); digitalWrite(pinRele34, HIGH);
}
void loop() {
// Leo las entradas.
ThermoRemoto = digitalRead(pinThermoRemoto);
sensorFiltro = digitalRead(pinSensorFiltro);
persianaAbierta = digitalRead(pinPersianaAbierta);
sensorPresion = digitalRead(pinSensorPresion);
switch ( estado ) {
case INICIO:
// Si el pin 7 esta HIGH se debe leer el sensor de filtro que si esta en HIGH debe encender el rele 57 y esperar a que abra la persiana.
if ( ThermoRemoto==HIGH ) {
if ( digitalRead(sensorFiltro)==HIGH ) {
digitalWrite(pinRele57, LOW);
temporizador = millis();
estado = ABRIENDO_PERSIANA;
}
}
break;
case ABRIENDO_PERSIANA:
// Ya se encendio el rele 57 y tenemos que esperar a que abra la persiana.
// Si la persiana esta abierta debemos encender el rele 34 guardar el tiempo y cambiar al estado de ENCENDIENDO_VENTILADOR.
if ( persianaAbierta == HIGH ) {
digitalWrite(pinRele34, LOW);
temporizador = millis();
estado = ENCENDIENDO_VENTILADOR;
}
else {
// La persinana no esta abierta y vale LOW. Hemos de comprobar el tiempo.
if ( millis()-temporizador>=30000UL ) {
// Si han transcurrido 30 segundos debemos dar error y hacer alguna que otra cosa.
estado = ERROR;
}
}
break;
case ENCENDIENDO_VENTILADOR:
// El ventilador está encendido
if ( sensorPresion==HIGH ) {
// Aqui seguirá la secuencia al siguiente estado que aun no hemos identificado.
}
else {
if ( millis()-temporizador > TIEMPO ) {
estado = ERROR;
}
}
break;
}
}
Hola @victorjam, este código no se parece en lo absoluto a el que yo hice, ya le puse nombre al sinNombre; que es la señal que viene de termostato del post#17 que es el que inicia el proceso y el que lo termina, en relación al setpoint que se le programe, y que su señal llega al pin digital 7 de Arduino 24v o 0v ahora tengo que agregarle el el relé RE28 que es el que inicia la combustión. Creo poder hacerlo, lo que no tengo idea es de como apagar el equipo con la secuencia inversa cuando pin digital 7 entre en LOW primero hay que apagar el RE28 despues el RE34 y por ultimo el RE57.
Saludos.
#define pinThermoRemoto 7
#define pinSensorFiltro 22
#define pinPersianaAbierta 8
#define pinSensorPresion 9
#define pinSensorFlama 10
#define pinRele57 2
#define pinRele34 3
#define pinRele28 4
int TIEMPO;
int temporizador;
int ThermoRemoto;
int sensorFiltro;
int persianaAbierta;
int sensorPresion;
int sensorFlama;
enum {
INICIO,
ABRIENDO_PERSIANA,
ENCENDIENDO_VENTILADOR,
ENCENDIENDO_FLAMA,
ERROR
};
int estado = INICIO;
void setup() {
pinMode(pinThermoRemoto, INPUT_PULLUP);
pinMode(pinSensorFiltro, INPUT_PULLUP);
pinMode(pinPersianaAbierta, INPUT_PULLUP);
pinMode(pinSensorPresion, INPUT_PULLUP);
pinMode(pinSensorFlama, INPUT_PULLUP);
pinMode(pinRele57, OUTPUT); digitalWrite(pinRele57, HIGH);
pinMode(pinRele34, OUTPUT); digitalWrite(pinRele34, HIGH);
pinMode(pinRele28, OUTPUT); digitalWrite(pinRele28, HIGH);
}
void loop() {
// Leo las entradas.
ThermoRemoto = digitalRead(pinThermoRemoto);
sensorFiltro = digitalRead(pinSensorFiltro);
persianaAbierta = digitalRead(pinPersianaAbierta);
sensorPresion = digitalRead(pinSensorPresion);
sensorFlama = digitalRead(pinSensorFlama);
switch ( estado ) {
case INICIO:
// Si el pin 7 esta HIGH se debe leer el sensor de filtro que si esta en HIGH debe encender el rele 57 y esperar a que abra la persiana.
if ( ThermoRemoto == HIGH ) {
if ( digitalRead(sensorFiltro) == HIGH ) {
digitalWrite(pinRele57, LOW);
temporizador = millis();
estado = ABRIENDO_PERSIANA;
}
}
break;
case ABRIENDO_PERSIANA:
// Ya se encendio el rele 57 y tenemos que esperar a que abra la persiana.
// Si la persiana esta abierta debemos encender el rele 34 guardar el tiempo y cambiar al estado de ENCENDIENDO_VENTILADOR.
if ( persianaAbierta == HIGH ) {
digitalWrite(pinRele34, LOW);
temporizador = millis();
estado = ENCENDIENDO_VENTILADOR;
}
else {
// La persinana no esta abierta y vale LOW. Hemos de comprobar el tiempo.
if ( millis() - temporizador >= 30000UL ) {
// Si han transcurrido 30 segundos debemos dar error y hacer alguna que otra cosa.
estado = ERROR;
}
}
break;
case ENCENDIENDO_VENTILADOR:
// El ventilador está encendido
if ( sensorPresion == HIGH ) {
digitalWrite(pinRele28, LOW); // Aqui seguirá la secuencia al siguiente estado que aun no hemos identificado.
}
else {
if ( millis() - temporizador > TIEMPO ) {
estado = ERROR;
}
}
break;
case ENCENDIENDO_FLAMA:
//la flama esta encendida
if (sensorFlama == LOW) {
digitalWrite(pinRele28, HIGH);
}
else {
if (millis() - temporizador > TIEMPO) {
estado = ERROR;
}
}
break;
}
}
Hola @victorjam, solo reiniciando el Arduino cambia el estado, del pin digital 7 las resistencias PULLUP están cumpliendo su función si inicio el Arduino con el pin 7 conectado a gnd no se encienden los reles, al momento de desconectar lo de gnd, inmediata mente se prenden los tres relés, conecto nueva mente el pin 7 a gnd ya no se apagan los reles solo reiniciando Arduino.
Saludos.
Hola @victorjam, te adjunto esquema de shields PLC, tengo las entras funcionando con 5vdc, la lógica de sus reles se activan en HIGH lo contrario a modulo relé de 4 canales que se activan con LOW. Ya estamos cerca le agregue al código, apagando_equipo, para tener una secuencia de apagado lo mas extraño es que si pongo todos los sensores y pin7 en gnd se encienden los 3 relés al mismo tiempo y si pongo todos en 5 volts no enciende nada, si pongo SOLO pin 7 en HIGH no enciende nada si pongo pin7 en gnd y todos los demás en 5 volts enciende pinRele57 30 segundos después enciende pinRele34 y pinRele28 no enciende, sera que la lógica de sus octoacopladores también es inversa.
Saludos.
Hola @victorjam, es te código con Arduino mega solo, son una locura los sensores, para que cambien su estado hay que reiniciar Arduino, otros no hacen nada, lo mismo el termostato remoto pin 7, lo mismo pasa con el shields plc solo que sus reles se activan en high.
#define pinThermoRemoto 7
#define pinSensorFiltro 8
#define pinPersianaAbierta 9
#define pinSensorPresion 10
#define pinSensorFlama 11
#define pinRele57 2
#define pinRele34 3
#define pinRele28 4
int TIEMPO;
int temporizador;
int ThermoRemoto;
int sensorFiltro;
int persianaAbierta;
int sensorPresion;
int sensorFlama;
int apagandoEquipo;
enum {
INICIO,
ABRIENDO_PERSIANA,
ENCENDIENDO_VENTILADOR,
ENCENDIENDO_FLAMA,
APAGANDO_EQUIPO,
ERROR
};
int estado = INICIO;
void setup() {
pinMode(pinThermoRemoto, INPUT_PULLUP);
pinMode(pinSensorFiltro, INPUT_PULLUP);
pinMode(pinPersianaAbierta, INPUT_PULLUP);
pinMode(pinSensorPresion, INPUT_PULLUP);
pinMode(pinSensorFlama, INPUT_PULLUP);
pinMode(pinRele57, OUTPUT); digitalWrite(pinRele57, HIGH);
pinMode(pinRele34, OUTPUT); digitalWrite(pinRele34, HIGH);
pinMode(pinRele28, OUTPUT); digitalWrite(pinRele28, HIGH);
//delay(3000);
}
void loop() {
// Leo las entradas.
ThermoRemoto = digitalRead(pinThermoRemoto);
sensorFiltro = digitalRead(pinSensorFiltro);
persianaAbierta = digitalRead(pinPersianaAbierta);
sensorPresion = digitalRead(pinSensorPresion);
sensorFlama = digitalRead(pinSensorFlama);
switch ( estado ) {
case INICIO:
// Si el pin 7 esta HIGH se debe leer el sensor de filtro que si esta en HIGH debe encender el rele 57 y esperar a que abra la persiana.
if ( ThermoRemoto == HIGH ) { // solo cambia su estado reiniciando Arduino,
if ( digitalRead(pinSensorFiltro) == HIGH ) {
digitalWrite(pinRele57, LOW);
temporizador = millis();
estado = ENCENDIENDO_VENTILADOR;
}
// Si han transcurrido 30 segundos debemos dar error y hacer alguna que otra cosa.
}
break;
case ABRIENDO_PERSIANA:
// Ya se encendio el rele 57 y tenemos que esperar a que abra la persiana.
// Si la persiana esta abierta debemos encender el rele 34 guardar el tiempo y cambiar al estado de ENCENDIENDO_VENTILADOR.
if ( persianaAbierta == HIGH ) { // solo cambia su estado reiniciando
if ( digitalRead(pinPersianaAbierta) == HIGH ) {
digitalWrite(pinRele34, LOW);
temporizador = millis();
estado = ENCENDIENDO_FLAMA;
}
}
else {
// La persinana no esta abierta y vale LOW. Hemos de comprobar el tiempo.
if ( millis() - temporizador >= 30000UL ) {
// Si han transcurrido 30 segundos debemos dar error y hacer alguna que otra cosa.
estado = ERROR;
}
}
break;
case ENCENDIENDO_VENTILADOR:
// El ventilador está encendido
if ( sensorPresion == HIGH ) { // no cambia su estado
if ( digitalRead(pinSensorPresion) == HIGH ) {
digitalWrite(pinRele34, LOW); // Aqui seguirá la secuencia al siguiente estado que aun no hemos identificado.
estado = ENCENDIENDO_FLAMA;
}
else {
if ( millis() - temporizador > TIEMPO ) {
estado = ERROR;
}
}
}
break;
case ENCENDIENDO_FLAMA:
//la flama esta encendida
if (sensorFlama == HIGH) { //no cambia su estado ni en 0 volts ni en 5 volts
if ( digitalRead(pinSensorFlama) == HIGH ) {
digitalWrite(pinRele28, LOW);
estado = APAGANDO_EQUIPO;
}
else {
estado = ERROR;
}
}
break;
case APAGANDO_EQUIPO:
if (pinThermoRemoto == LOW) {
if ( digitalRead(pinThermoRemoto) == LOW ) {
digitalWrite (pinRele28, HIGH);
//delay (2000);
digitalWrite (pinRele34, HIGH);
//delay (2000);
digitalWrite (pinRele57, HIGH);
}
break;
}
}
}
Este código esta cargado en shelds PLC solo cambia la logica de los reles y creo que entre los dos se puede dar una idea de lo que hay que quitar o poner al código final, el pinTermoRemoto es el que va conectado al termostato honeywell que esta situado a 40 metros del equipo por eso remoto en apagando equipo puse //delay(2000); para representar un tiempo entre cada operación.
Saludos.
Nota: solo tengo hasta el jueves para entregarlo sino lo van ha remplazar por PLC marca x
Vale, un detalle importante es que si estamos usando la entrada PULL_UP significa que al "aire" sin conectar o con el interruptor de la entrada abierto las entradas valen HIGH, es decir, una entrada activa será cuando el pin valga LOW. Cambia la lectura de las entradas a este código.
ThermoRemoto = digitalRead(pinThermoRemoto)==LOW;
sensorFiltro = digitalRead(pinSensorFiltro)==LOW;
persianaAbierta = digitalRead(pinPersianaAbierta)==LOW;
sensorPresion = digitalRead(pinSensorPresion)==LOW;
sensorFlama = digitalRead(pinSensorFlama)==LOW;
Básicamente lo que haces es leer el pin y compararlo con LOW, y el resutado se lo asignas al valor de la variable de la entrada. Si el pinThermoRemoto vale HIGH, al compararlo con LOW dará false y ese valor se lo asignamos a la variable thermoRemoto, es decir, thermoRemoto es false con lo que la entrada no está activada. Si por el contrario el pinThermoRemoto vale LOW la comparación será true indicando en la variable thermoRemoto que es true y por lo tanto que está activada.
Por otro lado, si el esqueme del shieldPLC no usa optos para la salida y solo enciende el relé mediante transistor significa que para activar cada rele hay que escribir un valor HIGH en el pin correspondiente.
digitalWrite(rele, HIGH); // <-- se enciende el relé.
digitalWrite(rele, LOW); // <-- se apaga el relé.
En el código que te he ido poniendo los relés los activaba con LOW que es lo normal cuando usas un módulo de relés optoacoplado, basta con cambiar la lógica y poner HIGH cada vez que se quiera activar el relé.
Ok lo intento y te comento.
Hoy es jueves, supongo que te refieres al jueves de la semana que viene. ¿Quién lo va a reemplazar? Veo el mismo problema que con Arduino, si no hay programa el PLC no sirve tampoco de nada. A no ser que me digas que hay código del PLC hecho.
no me refiero al jueves 23 de febrero