Problema reset inesperado

Hola gente soy nuevo en el mundo de Arduino pero viejo en electrónica, vengo de otras épocas y otras formas de hacer las cosas. Yendo al grano ya le tome bastante el gusto a estos bichitos y me puse a fabricar un control que tenía en mente con un plc y una terminal, dado los costos usé un mega2560 en lugar del plc y una pc vieja con un programita en VB 6. Anda bastante prolijo el tema es que tiene que trabajar 8 hs sin parar una vez dada la orden de arranque desde el pc y cada 1 hora más o menos se reinicia solo y aún no encontré el motivo momentáneamente genere una variable en VB que me lo arranca de nuevo si no hay datos en x tiempo funciona pero es un parche y además por más corto que sea el lapsus yo se que existe. E leído e buscado por todos lados y lo único que e encontrado es que parece que las sentencias Serial.sprint generan un desborde de memoria cuando uno las usa muy seguido ( mi sistema utiliza comunicación full dúplex por medio de adaptadores rs485) y esta constantemente enviando Strings a Vb para que este haga cosas en pantalla. Si voy bien rumbiado y existe algún buen samaritano que me pueda guiar para saber como vaciar el serial de alguna forma si es esto lo que me está pasando tendrá un amigo Uruguayo dispuesto a pagar el asado y a asar también. Muchas gracias

Tienes que postear tu codigo

Aqui estan la reglas del foro

Prueba con serial.flush() :slight_smile:

Hola gente pongo el código completo antes se reseteaba ahora escribe caracteres extraños por el puerto serie cada tanto tiempo (1 hora o menos) no importa si uso los adaptadores RS485 o si conecto el arduino directo al PC.
Este es el código:

const int SeguroRele=13; // Pata que uso para desabilitar las salidas de relé por si hay alguna falla tener un nivel más de seguridad
const int Congelado=22; //Salida Congelado
const int Descongelado=23; //Salida Descongelado
const int VT1=24;// Entrada señal VT1 
const int VT2=25;// Entrada señal VT2 
const int VT3=26;// Entrada señal VT3 
const int CON1=27;// Entrada señal Solenoide Congelado1 
const int CON3=28;// Entrada señal Solenoide Congelado3 
const int DES2=29;// Entrada señal Solenoide Descongelado2
const int DES4=30;// Entrada señal Solenoide Descongelado4
const int MAN=31;// Entrada señal Manual
const int AUT=32;// Entrada señal Automatico
int v1=0;
int v2=0;
int v3=0;
int c1=0;
int c3=0;
int d2=0;
int d4=0; 
int Manual;// Variable Manual
int Automatico;// Variable Automático
int cong;
int des;
 //Declaro una variable byte llamada valor que luego uso para encender o apagar Congelado o Decongelado
byte valor1=0;
int ConOK;
int ConOFF;
int ConERR;
int DesOK;
int DesOFF;
int DesERR;


void setup() {

Serial.begin(9600);// Seteo la velocidad de Puerto a 9600 Puerto RS485
pinMode(SeguroRele,OUTPUT);//Pin de seguro como salida
pinMode(Congelado,OUTPUT);//Digo que el pin del rele de congelado es de salida
pinMode(Descongelado,OUTPUT);//Digo que el pin del rele de descongelado es de salida 
pinMode(VT1,INPUT);// Declaro pines de entradas para usar su estado
pinMode(VT2,INPUT);
pinMode(VT3,INPUT);
pinMode(CON1,INPUT);
pinMode(CON3,INPUT);
pinMode(DES2,INPUT);
pinMode(DES4,INPUT);
pinMode(MAN,INPUT);
pinMode(AUT,INPUT);
digitalWrite (Congelado, HIGH); // APAGO LAS SALIDAS EN EL INICIO MÓDULOS DE RELES TRABAJAN POR LOW
digitalWrite (Descongelado, HIGH);
digitalWrite (SeguroRele,LOW); //APAGO LOS RELES CON UN SEGURO EXTRA
}

void loop() {
    
    valor1 = Serial.read();
    Manual = digitalRead(MAN);                                                                                                                                                                                                                                                                                                                      
    Automatico = digitalRead(AUT);
    v1 = digitalRead(VT1);
    v2 = digitalRead(VT2);
    v3 = digitalRead(VT3);
    c1 = digitalRead(CON1);
    c3 = digitalRead(CON3);
    d2 = digitalRead(DES2);
    d4 = digitalRead(DES4);

   


 //************************************************************************************************************************************************//    
///////////////////////////////////////////CONGELADO DESCONGELADO ON OFF////////////////////////////////////////////////////////////////////////////
//************************************************************************************************************************************************//

//********************************************CONGELADO ON***DESCONGELADO OFF*********************************************************************//    
    if (valor1 == 11){
  digitalWrite (Congelado, LOW);//LOW por que los módulos de relés trabajan al reves
  digitalWrite (Descongelado, HIGH);
  digitalWrite (SeguroRele,HIGH); //Habilito a que funcionen los reles
 
  cong=1;
  des=0;
  congon();
    }

 //********************************************DESCONGELADO ON***CONGELADO OFF********************************************************************//
 if (valor1 == 12){
  digitalWrite (Congelado, HIGH);
  digitalWrite (Descongelado, LOW);
  digitalWrite (SeguroRele,HIGH);

  des=1;
  cong=0;
   deson();
  }
 
  //*********************************************APAGADO TOTAL************************************************************************************//
   if (valor1 == 13){
  digitalWrite (Congelado, HIGH);
  digitalWrite (Descongelado, HIGH);
  digitalWrite (SeguroRele,LOW);
  
  cong=0;
  des=0;
  apagado();
 }


 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 //******************************************** CONTROL DE PROCESOS******************************************************************************//
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

 //********************************************CONGELADO*****************************************************************************************//
 
 ConOK=v1+v2+v3+c1+c3;
if (ConOK==5&cong==1){
  conok();
}

 
 
 ConERR=v1+v2+v3+c1+c3;
if (ConERR<5&cong==1){
  errorcongelado();
}

//********************************************DESCONGELADO****************************************************************************************//

DesOK=d2+d4;
if (DesOK==2&des==1){
  desok();
}


 
 DesERR=d2+d4;
if (DesERR<2&des==1){
  errordescongelado();
}

if (cong==0&des==0){
ConOFF=v1+v2+v3+c1+c3;
DesOFF=d2+d4;  
 if (ConOFF==0&DesOFF==0){
  off();
 }
   }  
     }
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//****************************************************************************************************************************************************//
//                                          RETORNOS FILTRADOS EVITO FALLOS                                                                           //
//****************************************************************************************************************************************************//   
////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

/////////////////////////////////////////////CONGELADO//////////////////////////////////////////////////////////////////////////////////////////////////   
//*****************ENCENDI CONGELADO Y TODOS LOS SWITCHS SE HICIERON ASI QUE ENVIO CONG OK Y PARA DESCONGELADO SE APAGUE ENVIO OFF********************//

void conok(){
 Serial.print("CON OK");
 delay(100);
 Serial.print("DESC OFF");
 delay(100);
 loop(); 
}

/////////////////////////////////////////////DESCONGELADO/////////////////////////////////////////////////////////////////////////////////////////////////
//*****************ENCENDI CONGELADO Y TODOS LOS SWITCHS SE HICIERON ASI QUE ENVIO CONG OK Y PARA QUE CONGELADO SE APAGUE MANDO OFF******************//

void desok(){
 Serial.print("DES OK");
 delay(100);
 Serial.print("CONG OFF");
 delay(100);
  loop(); 
}

//**************SI FUE APAGADO CONGELADO O DESCONGELADO LOS SWITCH SE ABREN POR ESO ENVIO CONG OFF  Y DESC OFF ASÍ EVITO ERROR POR SWITCS ABIERTOS AL APAGAR****************//
void off(){
  Serial.print("CONG OFF");
  delay(100);
  Serial.print("DESC OFF");
  delay(100);
  loop();
}

///////////////////////////////////////MANUAL AUTOMATICO///////////////////////////////////////////////////////////////////////////////////////////////
//***********************MANUAL ON AUTOMATICO OF*****************************************************************************************************//

void Manualon(){
  Serial.print("MN");
  delay(100);
  Serial.print("AF");
  delay(100);
  loop();
}
//**********************AUTOMATICO ON MANUAL OFF*******************************************************************************************************// 

void Automaticoon(){
   Serial.print("AN");
   delay(100);
   Serial.print("MF");
   delay(100);
    loop();
}

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
//************************************************************************************************************************************************//
//                                                             ERRORES Y FALLOS                                                                   //
//************************************************************************************************************************************************//
/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// ////////////////

//*************************************************************FALLOS CONGELADO*******************************************************************// 
 
 void errorcongelado(){
  if (v1==0){
    fallav1();
  }
  if (v2==0){
    fallav2();
  }
   if (v3==0){
    fallav3();
  }
   if (c1==0){
    fallac1();
  }
   if (c3==0){
    fallac3();
  }
  loop();
 }

void fallav1(){
  Serial.print("FALLO VENT1");
  delay(100);
  loop();
}

void fallav2(){
 Serial.print("FALLO VENT2");
  delay(100);
  loop(); 
}

void fallav3(){
 Serial.print("FALLO VENT3");
  delay(100);
  loop(); 
}

void fallac1(){
 Serial.print("FALLO CONG1"); 
  delay(100);
  loop(); 
}

void fallac3(){
 Serial.print("FALLO CONG3");
  delay(100);
  loop(); 
}

//*********************************************************************FALLOS DESCONGELADO*********************************************************************//

 void errordescongelado(){
  
   if (d2==0){
    fallad2();
  }
   if (d4==0){
    fallad4();
  }
  loop();
 }

void fallad2(){
 Serial.print("FALLO DESC2");
  delay(100);
  loop(); 
}

void fallad4(){
 Serial.print("FALLO DESC4");
  delay(100);
  loop(); 
}

////////////////////////////////////////////////////////////////FIN POR AHORA (TO BE CONTINUED...///////////////////////////////////////////////////////////////////

Ya probé con Serial.flush() luego de cada Serial.print pero tampoco se resolvió. Leí bastante información pero todos los tutoriales que hay se quedan en como enviar o recibir pero no explican mucho acerca del uso de memoria por funciones o no hay una lista global de sentencias o soy yo que no las encuentro ja, y en estos casos de ciclos continuos hay muchas variables que se acumulan y me puede estar viniendo por ahí el drama, en este caso tendría que estar funcionando siempre. Cualquier enlace a Manuales completos o libros es bienvenido.
Saludos

GO_zalo:
Prueba con serial.flush() :slight_smile:

Gracias Señor ya descubrí cuales eran las fallas y una de esas se resolvía con Serial.flush().

1-Estaba en las variables donde las sumo para Filtrar fallos con igualarlas a 0 dentro de cada bloque if se fue unos de los problemas.

2-Estaba en los símbolos raros que me mandaba por el serial después de cierto tiempo y esta se fué con Serial.flush().

Asi que su aporte me ayudo mucho.

:frowning: >:( >:( Error sigue igual se sigue reseteando solo cada 10 minutos no se que pueda ser.

Bien, comienza usando FreeRAM (busca en google) a ver si te quedas sin RAM en algun momento.
Cambia esto
const int por esto const byte en todo lo que sea asignación de pines. Derroche de memoria.
Cambia

int Manual;// Variable Manual
int Automatico;// Variable Automático

por

bool Manual, Automatico

2do derroche de Memoria.

Todo lo que sean carteles fijos asi

Serial.print("CONG OFF");

cambia a modo no consumo RAM

Serial.print(F("CONG OFF"));

Qué es esto?

void Automaticoon(){
   Serial.print("AN");
   delay(100);
   Serial.print("MF");
   delay(100);
    loop();    <============= ERRORRRRRRRRRRRRR
}

Como no quieres que se te cuelgue?

Y esto esta mal tambien

 valor1 = Serial.read();

.
A secas? sin un if(Serial.available()>0) {

Tal vez funcione pero nadie asegure que no pierdas datos.