Hello community!
I have a problem with my project.
I have a laser machine, I created a project with mega arduino, ethernet network card and raspberry pi… The project is based on monitoring the machine from a distance, working time, measuring sensors, etc… It turns out that by Sometimes when my machine is turned on by me, or turned off by arduino, it goes offline reconnecting again.
The device is always online, but it is offline only when the arduino detects that the machine is on, or when the machine is turned off.
I have the empty loop as the rule says, where the rest of my code is in a big function where it is executed every second “timer.setinterval(1000L,xxx)”
Can someone help me? Thanks.
At the beginning I thought that they were noise from the electrical network that could influence the normal functioning of the arduino, because the board with 8 output relays activate 1 contactor with the 24Vdc coil…
Will I have to put more “timer. set” to other functions that are called inside my big monitoring function?
I don’t really understand your description of the problem. Sentences like …
Seem contradictory.
Have you done any tests to work-out how long this function takes to execute in a worst-case scenario?
Pete.
I have never seen how long it takes for the function to work. What was the part you didn’t notice?
I assume you are using Blynk legacy.
You have to provide your code and serial monitor.
I suspect that your MCU didn’t reconnect to Blynk server.
Right now I’m writing on my phone, I don’t have the code here with me… But yes, it’s a long code. It’s just what I need for you to do what I want…
//Monitorização por Smartphone de controladora RUIDA (laser CO2) Através da app BLYNK
//Local Server em Raspberry Pi
// Caso o comando Blynk.syncVirtual (V12, V13, V18, V25, V26, V27, V28); não esteja escrito, é...
//IMPORTANTE: É OBRIGATÓRIO fazer atualização dos estados dos botões e parâmetros na app, sempre se seja feito um upload do codigo!
//para voltar a desarmar o contactor/rele, utilizo a porta v26 de 1 para 0 na app fazendo push, ligado ao rele em modo NC.
//Aguardar que o led V4 da app acenda
//Por sua vez volta ao inicio.
//Produzido e desenvolvido por BRUNO SANTOS. Cortes e Gravações.
//WWW.CORTESEGRAVACOES.PT
//OUT saida de arduino para app
//IN entrada no arduino
// v0 - estado maquina - OUT
// v1 - Hora - OUT
// v2 - Data - OUT
// v3 - tempo de ficheiro em minutos (m) - OUT
// v4 - Led Refresh - OUT
// v5 - Humidade do ar - OUT
// v6 - Temperatura ambiente - OUT
// v7 - LED Desligado - OUT
// v8 - LED Aguardar Fich - OUT
// v9 - LED Exec Fich. - OUT
// v10 - LED Standby - OUT
// v11 - LED Chiller/Refrigeração - OUT
// v12 - controle temperatura - IN
// v13 - controle Tempo ficheiro - IN
// v14 - tempo aguardar ficheiro minutos (m3) - OUT
// v15 - Led temperatura excesso - OUT
// v16 - hora de ficheiro (h) - OUT
// v17 - tempo aguardar ficheirosegundos (s3) - OUT
// v18 - Controlo de tempo standBy /desligar - IN
// v19 - Tempo de ficheiro segundos (s) - OUT
// v20 - tempo standby segundos (s2) - OUT
// v21 - tempo stanby minutos (m2) - OUT
// v22 - Temperatura Sonda água - OUT
// v23 - Botão Push Reset - IN
// v24 - LED Temperatura normal - OUT
// v25 - controlo tempo Aguardar Ficheiro - IN
// v26 - Ligar Flurescente - IN
// v27 - Ligar Led - IN
// v28 - Botão de emergencia - IN
// v29 - Tempo de actividade segundos (s4) - IN
// v30 - Tempo de actividade minutos (m4) - IN
// v31 - Tempo de actividade horas (h4) - IN
// v32 - Tempo de actividade dias (diasdecontagem)- IN
// v33 - LED Água OK - OUT
// v34 - Estado da Água - OUT
// v35 - LED Água NOK - OUT
// v36 - Ventoimha 1 - OUT
// v37 - Ventoimha 2 - OUT
// v38 - Limiar Ventoimha 1 - IN
// v39 - Limiar Ventoimha 2 - IN
//declaracao das Bibliotecas
#define BLYNK_PRINT Serial
#include <SPI.h>
#include <Ethernet.h>
#include <BlynkSimpleEthernet.h>
#include <DHT.h>
#include <TimeLib.h>
#include <WidgetRTC.h>
#include <OneWire.h>
#include <DallasTemperature.h>
//declaracao das variaveis para as contagens
unsigned long overficheiro;
unsigned long overDesligar;
unsigned long overaguardarficheiro;
unsigned long overactividade;
unsigned long tempodeactividade, inicioactividade, fimactividade;
unsigned long inicioficheiro, fimficheiro, decorridoficheiro;
unsigned long inicioDesligar, fimDesligar, decorridoDesligar;
unsigned long inicioaguardarficheiro, fimaguardarficheiro, decorridoaguardarficheiro;
float msficheiro, msDesligar, msaguardarficheiro, msactividade;
int hficheiro, mficheiro, sficheiro;
int hDesligar, mDesligar, sDesligar;
int haguardarficheiro, maguardarficheiro, saguardarficheiro;
int hactividade, mactividade, sactividade;
float Temperaturaquadro = 0;
int contagemtempofinal = 0;
int diasdecontagem = 0;
int offaguardarficheirotemperaturaalta = 0;
int offaguardarficheiro = 0;
int temperatura = 0;
int controlotemperatura = 0;
int controlotempotempofinal;
int controlotempoDesligar;
int controloaguardarficheiro;
int Limiartemperatura1 = 0;
int Limiartemperatura2 = 0;
bool controloAgua;
bool Lampada;
bool led;
bool emergencia;
bool refresh;
bool chiller;
bool pinocontrolo;
bool pinoficheiro;
bool introducao = false;
bool fluxoAgua = false;
bool vent1 = false;
bool vent2 = false;
//declaracao de pinos
#define Agua 3 //IN
#define resett 26 //OUT
#define ventoinha1 34 //OUT
#define ventoinha2 32 //OUT
#define botaoemergencia 28 //OUT
#define leds 36 //OUT
#define flurescente 22 //OUT
#define desligar 24 //OUT
#define controlo 7 //IN
#define ficheiro 12 //IN
#define pinochiller 9 //IN
#define W5100_CS 10 //pino placa de rede OUT
#define SDCARD_CS 4 // pino sd card IN
#define DHTPIN 6 //pino do sensor IN
#define DHTTYPE DHT22 //tipo de sensor
#define ONE_WIRE_BUS 2 // pino da sonda de agua IN
//declaracao da Comunicacao com local server
char auth[] = "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx";
char server[] = "192.168.1.78";
int port = 8080;
byte mac[] = { 0xXX, 0xXX, 0xXX, 0xXX, 0xXX, 0xXX };// Mac Address placa de rede
IPAddress ip(192, 168, 1, 220); // Ip estatico da placa de rede
IPAddress mask (255, 255, 255, 0);
//declaracao da atualizaçao dos widgets da app com arduino, sempre que seja reconectado
BLYNK_CONNECTED() {
Blynk.syncAll();
inicioactividade = millis();
}
//declaracao da Escrita dos leds na app nas portas virtuais
WidgetLED leddesligado(V7);
WidgetLED ledaguardarficheiro(V8);
WidgetLED leddexecutarficheiro(V9);
WidgetLED ledstanby(V10);
WidgetLED ledtemperatura(V24);
WidgetLED ledtemperaturaexcesso(V15);
WidgetLED ledchiller(V11);
WidgetLED ledrefresh(V4);
WidgetLED ledAguaLigado(V33);
WidgetLED ledAguaDesligado(V35);
WidgetLED vento1(V36);
WidgetLED vento2(V37);
//declaracao da Escrita dos parametros da app para arduino
BLYNK_WRITE(V12) {
controlotemperatura = param.asInt();
}
BLYNK_WRITE(V13) {
controlotempotempofinal = param.asInt();
}
BLYNK_WRITE(V18) {
controlotempoDesligar = param.asInt();
}
BLYNK_WRITE(V23) {
refresh = param.asInt();
}
BLYNK_WRITE(V25) {
controloaguardarficheiro = param.asInt();
}
BLYNK_WRITE(V26) {
Lampada = param.asInt();
}
BLYNK_WRITE(V27) {
led = param.asInt();
}
BLYNK_WRITE(V28) {
emergencia = param.asInt();
}
BLYNK_WRITE(V38) {
Limiartemperatura1 = param.asInt();
}
BLYNK_WRITE(V39) {
Limiartemperatura2 = param.asInt();
}
//setup sensores, relogio e timer
DHT dht(DHTPIN, DHTTYPE);
BlynkTimer timer;
WidgetRTC rtc;
OneWire oneWire(ONE_WIRE_BUS);
DallasTemperature sensors(&oneWire);
void setup() {
Serial.begin(9600);
pinMode(SDCARD_CS, OUTPUT);
digitalWrite(SDCARD_CS, HIGH); // select the SD card
pinMode(controlo, INPUT_PULLUP);
pinMode(ficheiro, INPUT_PULLUP);
pinMode(pinochiller, INPUT_PULLUP);
pinMode(desligar, OUTPUT);
pinMode(ventoinha1, OUTPUT);
pinMode(ventoinha2, OUTPUT);
pinMode(flurescente, OUTPUT);
pinMode(leds, OUTPUT);
pinMode(botaoemergencia, OUTPUT);
pinMode(resett, OUTPUT);
pinMode(Agua, INPUT_PULLUP);
delay(10);
Blynk.begin(auth, server, port, ip, mask);// entrada home server raspberry pi blynk
sensors.begin();
dht.begin();
rtc.begin();
timer.setInterval(1500L, sendSensor);
timer.setInterval(60000L, clockDisplay);
timer.setInterval(35000L, termometro);
timer.setInterval(1000L, geral);
}
void geral() {
int travaodossegundos = 0;
int c = 0;
int b = 0;
fimactividade = millis();
contagemdeatividade();
pinocontrolo = digitalRead(controlo);
pinoficheiro = digitalRead(ficheiro);
chiller = digitalRead(pinochiller);
temperatura = sensors.getTempCByIndex(0);
fluxoAgua = digitalRead(Agua);
Serial.println(Temperaturaquadro);
//VENTOINHAS
if (Temperaturaquadro >= Limiartemperatura1)
{
digitalWrite(ventoinha1, LOW);
vento1.on();
} else {
digitalWrite(ventoinha1, HIGH);
vento1.off();
}
if (Temperaturaquadro >= Limiartemperatura2)
{
digitalWrite(ventoinha2, LOW);
vento2.on();
} else {
digitalWrite(ventoinha2, HIGH);
vento2.off();
}
//condicao para Agua
if (fluxoAgua == false)
{
ledAguaLigado.on();
ledAguaDesligado.off();
Blynk.virtualWrite(V34, "Ligado");
} else {
ledAguaLigado.off();
ledAguaDesligado.on();
Blynk.virtualWrite(V34, "Desligado");
}
//condicao para refresh
if (refresh == true) {
digitalWrite(resett, LOW);
} else {
digitalWrite(resett, HIGH);
}
//condicao para ligar Emergencia
if (emergencia == true) {
digitalWrite(botaoemergencia, HIGH);
} else {
digitalWrite(botaoemergencia, LOW);
}
//condicao para ligar flurescente e LED
if (Lampada == true) {
digitalWrite(flurescente, HIGH);
} else {
digitalWrite(flurescente, LOW);
}
if (led == 1) {
digitalWrite(leds, HIGH);
} else {
digitalWrite(leds, LOW);
}
//condicao de bloqueio do standBy 1 em 59 seg
if ( sficheiro == 59) {
travaodossegundos = 59;
}
if (contagemtempofinal < 115) {
contagemtempofinal = sficheiro + travaodossegundos;
}
// ligar led de refrigeracao na app
if (chiller == LOW) {
ledchiller.on();
}
else
{
ledchiller.off();
}
// ligar led de temperatura na app
if ( temperatura <= controlotemperatura) {
ledtemperaturaexcesso.off();
ledtemperatura.on();
}
if ( temperatura > controlotemperatura) {
ledtemperaturaexcesso.on();
ledtemperatura.off();
}
// Inicio
//Desligado/StandBy
if ( pinocontrolo == HIGH && pinoficheiro == HIGH) {
maguardarficheiro = 0;
sficheiro = 0;
fimaguardarficheiro = millis();
travaodossegundos = 0;
contagemtempofinal = 0;
Serial.println("Desligado");
Blynk.virtualWrite(V0, "Desligado");
leddesligado.on();
ledaguardarficheiro.off();
leddexecutarficheiro.off();
ledstanby.off();
ledrefresh.off();
}
// Aguardar Ficheiro
if (pinocontrolo == LOW && pinoficheiro == HIGH && contagemtempofinal <= controlotempotempofinal) {
ligarluzesautomaticas();
inicioaguardarficheiro = millis();
fimficheiro = millis();
contagem3();
digitalWrite(desligar, LOW);
Serial.println("Ag. Ficheiro");
Blynk.virtualWrite(V0, "Ag.Ficheiro");
ledrefresh.on();
leddesligado.off();
ledaguardarficheiro.on();
leddexecutarficheiro.off();
ledstanby.off();
introducao = true;
if (fluxoAgua == true)
{
Blynk.virtualWrite(V34, "ATENÇÂO!");
c = c + 1;
if ( c > 0 && c < 10)
{
Blynk.notify("Agua Desligada.");
}
}
// Detector falta Agua
if (fluxoAgua == false) //Logica contraria
{
c = 0;
}
}
//condicao para desligar automatico em aguardar ficheiro
if (introducao == true && maguardarficheiro >= controloaguardarficheiro && temperatura <= controlotemperatura) {
desligarluzesautomaticas();
digitalWrite(desligar, HIGH);
Blynk.virtualWrite(V0, "Desligado");
return;
}
if (introducao == true && maguardarficheiro >= controloaguardarficheiro && temperatura > controlotemperatura) {
Blynk.virtualWrite(V0, "Ag.Temperatura");
}
// Executar Ficheiro
if ( pinocontrolo == LOW && pinoficheiro == LOW) {
inicioficheiro = millis();
fimDesligar = millis();
fimaguardarficheiro = millis();
contagem1();
Serial.println("Executar Ficheiro");
Blynk.virtualWrite(V0, "Executar Ficheiro");
ledrefresh.on();
leddexecutarficheiro.on();
leddesligado.off();
ledaguardarficheiro.off();
ledstanby.off();
if (fluxoAgua == true)
{
Blynk.virtualWrite(V34, "ATENÇÂO!");
b = b + 1;
if ( b > 0 && b < 10)
{
Blynk.notify("Agua Desligada.");
}
}
if (fluxoAgua == false)
{
b = 0;
}
}
// Tempo de espera para desligar automatico
if (pinocontrolo == LOW && pinoficheiro == HIGH && contagemtempofinal > controlotempotempofinal) {
fimficheiro = millis();
inicioDesligar = millis();
contagem2();
Serial.println("Stand by");
Blynk.virtualWrite(V0, "Stand by");
Serial.println(sDesligar);
ledrefresh.on();
ledstanby.on();
leddexecutarficheiro.off();
leddesligado.off();
ledaguardarficheiro.off();
if (sDesligar < 3 && mDesligar < 1 && temperatura <= controlotemperatura)
{
Blynk.notify("StandBy, Temperatura Normal.");
}
if (sDesligar < 3 && mDesligar < 1 && temperatura > controlotemperatura)
{
Blynk.notify("StandBy, Temperatura Excesso.");
Serial.println("Stand by, Temperatura Excesso.");
}
}
// Tempo de espera e aguardar temperatura para desligar automatico
//standby 2
if (pinocontrolo == LOW && pinoficheiro == HIGH && contagemtempofinal >= controlotempotempofinal && mDesligar >= controlotempoDesligar && temperatura > controlotemperatura) {
Serial.println("Aguardar Temperatura");
Blynk.virtualWrite(V0, "Ag.Temperatura");
ledtemperaturaexcesso.on();
ledtemperatura.off();
ledrefresh.on();
ledstanby.on();
leddexecutarficheiro.off();
leddesligado.off();
ledaguardarficheiro.off();
if ( mDesligar >= controlotempoDesligar && sDesligar < 3 && mDesligar == 1 && temperatura > controlotemperatura)
{
Blynk.notify("StandBy Concluido, Aguardar temperatura.");
}
}
// Desligar automatico
//para voltar a desarmar o contactor/rele, utilizo a porta v26 de 1 para 0 na app fazendo push, ligado ao rele em modo NC.
//Aguardar que o led V4 da app acenda
//Por sua vez volta ao inicio.
if (pinocontrolo == LOW && pinoficheiro == HIGH && contagemtempofinal >= controlotempotempofinal && temperatura <= controlotemperatura && mDesligar >= controlotempoDesligar) {
desligarluzesautomaticas();
fimDesligar = millis();
Serial.println("Desligado");
Blynk.virtualWrite(V0, "Desligado");
digitalWrite(desligar, HIGH);
Blynk.notify("Desligado.");
}
}
//Sensor de Humidade e de temperatura do ar
void sendSensor() {
float h = dht.readHumidity();
float t = dht.readTemperature(); // or dht.readTemperature(true) for Fahrenheit
Temperaturaquadro = dht.readTemperature();
if (isnan(h) || isnan(t)) {
Serial.println("Failed to read from DHT sensor!");
return;
}
// You can send any value at any time.
// Please don't send more that 10 values per second.
Blynk.virtualWrite(V5, h);
Blynk.virtualWrite(V6, t);
}
//Contagem de ficheiro
void contagem1() {
decorridoficheiro = inicioficheiro - fimficheiro;
hficheiro = decorridoficheiro / 3600000;
overficheiro = decorridoficheiro % 3600000;
mficheiro = overficheiro / 60000;
overficheiro = overficheiro % 60000;
sficheiro = overficheiro / 1000;
msficheiro = overficheiro % 1000;
Serial.print(hficheiro, 0);
Serial.print("h ");
Serial.print(mficheiro, 0);
Serial.print("m ");
Serial.print(sficheiro, 0);
Serial.print("s ");
Serial.println();
Blynk.virtualWrite(V19, sficheiro);
Blynk.virtualWrite(V3, mficheiro);
Blynk.virtualWrite(V16, hficheiro);
}
//Contagem de tempo de stanby
void contagem2() {
decorridoDesligar = inicioDesligar - fimDesligar;
hDesligar = decorridoDesligar / 3600000;
overDesligar = decorridoDesligar % 3600000;
mDesligar = overDesligar / 60000;
overDesligar = overDesligar % 60000;
sDesligar = overDesligar / 1000;
msDesligar = overDesligar % 1000;
Serial.print(hDesligar, 0);
Serial.print("h2 ");
Serial.print(mDesligar, 0);
Serial.print("m2 ");
Serial.print(sDesligar, 0);
Serial.print("s2 ");
Serial.println();
Blynk.virtualWrite(V20, sDesligar);
Blynk.virtualWrite(V21, mDesligar);
}
//Contagem de tempo de aguardar ficheiro
void contagem3() {
decorridoaguardarficheiro = inicioaguardarficheiro - fimaguardarficheiro;
haguardarficheiro = decorridoaguardarficheiro / 3600000;
overaguardarficheiro = decorridoaguardarficheiro % 3600000;
maguardarficheiro = overaguardarficheiro / 60000;
overaguardarficheiro = overaguardarficheiro % 60000;
saguardarficheiro = overaguardarficheiro / 1000;
msaguardarficheiro = overaguardarficheiro % 1000;
Serial.print(haguardarficheiro, 0);
Serial.print("h3 ");
Serial.print(maguardarficheiro, 0);
Serial.print("m3 ");
Serial.print(saguardarficheiro, 0);
Serial.print("s3 ");
Serial.println();
Blynk.virtualWrite(V17, saguardarficheiro);
Blynk.virtualWrite(V14, maguardarficheiro);
}
//Contagem de tempo desde que esta online
void contagemdeatividade() {
bool estadoDias = false;
tempodeactividade = fimactividade - inicioactividade;
hactividade = tempodeactividade / 3600000;
overactividade = tempodeactividade % 3600000;
mactividade = overactividade / 60000;
overactividade = overactividade % 60000;
sactividade = overactividade / 1000;
msactividade = overactividade % 1000;
if ( hactividade == 24) {
diasdecontagem++;
estadoDias = true;
}
if ( hactividade == 24 && estadoDias == true) {
hactividade = 0;
estadoDias = false;
}
Serial.print(hactividade, 0);
Serial.print("h4 ");
Serial.print(mactividade, 0);
Serial.print("m4 ");
Serial.print(sactividade, 0);
Serial.print("s4 ");
Serial.println();
Blynk.virtualWrite(V29, sactividade);
Blynk.virtualWrite(V30, mactividade);
Blynk.virtualWrite(V31, hactividade);
Blynk.virtualWrite(V32, diasdecontagem);
}
//Sonda da Agua
void termometro() {
sensors.requestTemperatures();
Serial.print("Celsius temperature: ");
Serial.print(sensors.getTempCByIndex(0) + 3);
Blynk.virtualWrite(V22, sensors.getTempCByIndex(0)); //1 é acerto de temperatura com o chiller
}
//Relogio Blynk
void clockDisplay() {
String currentTime = String(hour()) + ":" + minute();
String currentDate = String(day()) + "/" + month() + "/" + year();
Serial.print("Current time: ");
Serial.print(currentTime);
Serial.print(" ");
Serial.print(currentDate);
Serial.println();
// escrita da hora e data no blynk
Blynk.virtualWrite(V1, currentTime);
Blynk.virtualWrite(V2, currentDate);
}
void desligarluzesautomaticas() {
Blynk.virtualWrite(V26, HIGH);// Contrario,desliga
Blynk.syncVirtual(V26);
Blynk.virtualWrite(V27, HIGH);// Contrario,desliga
Blynk.syncVirtual(V27);
}
void ligarluzesautomaticas() {
Blynk.virtualWrite(V26, HIGH);// Contrario,liga
Blynk.syncVirtual(V26);
}
void loop() {
if (!Blynk.connected()) { //reconecta sempre que ficar offline
Blynk.connect();
}
Blynk.run();
timer.run();
}
You’re using Blynk.begin, which is a blocking function. Youre then using Blynk.connect…
and I’m not sure that this works in the way you expect when the Blynk connection was initiated using Blynk.begin.
That should be first thing you check. If it takes longer than 1 second then you’ll run into problems.
Also, as you’re using a DHT22 sensor, attempting to read it once every second isn’t a good idea. They don’t like being read more than once every 2 seconds minimum, and I’d recommend every 5 seconds.
I don’t understand the question.
Pete.
What is the difference between blynk.begin(), and blynk.connected()?
How can I improve the code?
Is it a reason for me to go offline whenever I change the state of pin7 and 24 ?
I’d suggest that you re-read my previous post.
Pete.
Sorry, I didn’t realize