Buonasera a tutti!!!. Pongo un quesito relativo al blocco della stampa su monitor seriale.
Vi descrivo il lato hardware e software cosi da avere una panoramica di tutto.
Sto utilizzando arduino uno con il datalogger az delivery, un HC12, un LCD 20x4. Arduino uno comunica con Elego nano dove a sua volta sono collegati quattro igrometri e un HC12.
L'elego invia i valori letti ad arduino uno che esegue dei calcoli e stampa il risultato su monitor seriale e SD del datalogger.
Problema: dopo 1-2 ore la stampa si blocca
Mi potete aiutare a risolvere?
Grazie ragazzi!!!!
Allego il codice di arduino uno cosi che possiate valutarlo
/*
SD card datalogger
This example shows how to log data from three analog sensors
to an SD card using the SD library.
The circuit:
analog sensors on analog ins 0, 1, and 2
SD card attached to SPI bus as follows:
** MOSI - pin 11
** MISO - pin 12
** CLK - pin 13
** CS - pin 4 (for MKRZero SD: SDCARD_SS_PIN)
created 24 Nov 2010
modified 9 Apr 2012
by Tom Igoe
This example code is in the public domain.
*/
//Nome file:dati1.txt
#include <SPI.h>
#include <SD.h>
#include <Wire.h>
#include <LiquidCrystal_I2C.h> //Libreria LCD con I2C
LiquidCrystal_I2C lcd(0x27, 4, 20); // set the LCD address to 0x27 for a 16 chars and 2 line display
byte successi;
byte fallimenti;
File dataFile ;
char codice;
int lettura;
byte stato;
#include <SoftwareSerial.h>
SoftwareSerial nano (5, 6); //TX, RX
#define chipSelect 10
#define NOMEFILE "dati13.txt"
#define NUM_SENSORI 4
#define NUM_LETTURE 2
#define MAX_TEMPO 60000//Millisecondi limite massimo tra due ricezioni dello stesso sensore
#define ORE_GIORNO 24
typedef struct
{
byte conto;
int media;
byte letture [NUM_LETTURE];
//unsigned long ultimo_tempo;
//byte pronto;
// byte scarico;
} sensore_t;
sensore_t sensori [NUM_SENSORI];
byte media_medie [ORE_GIORNO];
byte conto_giorno;
void setup() {
// Open serial communications and wait for port to open:
Serial.begin(9600);
lcd.init(); // initialize the lcd
lcd.init();
lcd.backlight();
Serial.print("Initializing SD card...");
// see if the card is present and can be initialized:
if (!SD.begin(chipSelect)) {
Serial.println(F("Card failed, or not present"));
// don't do anything more:
return;
}
nano.begin (9600);
}
void loop() {
if (LeggiNano())
{
if (!Esiste (codice))
{
Serial.print (F("Sensore "));
Serial.print (codice);
Serial.println (F("Non riconosciuto"));
}
else
{
codice--;
//sensori[codice].scarico = 0;
//sensori[codice].ultimo_tempo = millis();
sensori[codice].conto %= NUM_LETTURE;
sensori[codice].letture[sensori[codice].conto] = map (lettura, 0, 1023, 100,0);
sensori[codice].conto++;
if (sensori[codice].conto == NUM_LETTURE)
{
Calcola_Media(codice);
}
}
}
}
bool Esiste (int codice)
{
return (codice <= NUM_SENSORI);
}
bool LeggiNano()
{
char ingresso = 0;
while (nano.available())
{
ingresso = 0;
if (nano.available())
{
ingresso = nano.read();
if (stato == 0)
{
stato = 1;
codice = lettura = 0;
}
}
if (ingresso == 0)
{
return 0;
}
if (ingresso == '\n')
{
stato = 0;
return 0;
}
if (isDigit (ingresso))
{
if (stato == 1)
{
codice = codice * 10 + (ingresso - '0');
continue;
}
else if (stato == 2)
{
lettura = lettura * 10 + (ingresso - '0');
continue;
}
return 0;
}
if (ingresso == ' ')
{
if (stato == 1)
{
stato = 2;
continue;
}
else
{
Serial.println (F("Ricevuto spazio"));
stato = 0;
}
return 0;
}
if (ingresso == 13)
{
if (stato == 2)
{
return (1);
Serial.print (F("Il sensore "));
Serial.print (codice);
Serial.print (F(" ha letto "));
Serial.println (lettura);
stato = 0;
return (1);
}
else
{
Serial.println (F("Termine imprevisto messaggio"));
stato = 0;
return 0;
}
}
Serial.print (F("Ricevuto valore non voluto:"));
Serial.println ((byte)ingresso);
}
return (0);
}
#define SA sensori[codice].
static byte mm_ex = 0;
static byte sp_ex = 0;
void Calcola_Media (int codice)
{
SA media = 0;
for (byte i = 0; i < NUM_LETTURE; i++)
{
SA media += SA letture [i];
}
SA media /= NUM_LETTURE;
Serial.print (F("La media oraria del sensore "));
Serial.print (codice + 1);
Serial.print (" è: ");
Serial.println (SA media);
/*
Serial.print (F("Le letture del sensore sono; "));
for (byte i = 0; i < NUM_LETTURE; i++)
{
Serial.print (SA letture[i]);
Serial.print (", ");
}
Serial.println ('.');
*/
Scrivi_Media (codice + 1, 'O', SA media);
{
byte sensori_pronti = 0;
int mm = 0;
for (int i = 0; i < NUM_SENSORI; i++)
{
if (sensori[i].conto == NUM_LETTURE)
{
mm += sensori[i].media;
sensori_pronti++;
}
}
mm /= sensori_pronti;
if (sensori_pronti < sp_ex)
{
//Se ho calcolato la media su meno sensori della volta scorsa allora la media della volta scorsa è la media effettiva
media_medie [conto_giorno] = mm_ex;
Serial.print (F("La media delle medie orarie è: "));
Serial.println (media_medie[conto_giorno]);
Scrivi_Media (0, 'O', media_medie[conto_giorno]);
lcd.setCursor (0, 3);
lcd.print (F("Med sett="));
lcd.print (media_medie[conto_giorno]);
lcd.print ('%');
conto_giorno++;
}
//Comunque sia aggiorno le medie della volta scorsa con quelle attuali
mm_ex = mm;
sp_ex = sensori_pronti;
}
if (conto_giorno == 23)
{
int media_giorno = 0;
Serial.println (F("Calcolo media giornaliera"));
for (byte i = 0; i < ORE_GIORNO; i++)
{
media_giorno += media_medie[i];
}
Serial.print (F("Media giornaliera: "));
media_giorno /= ORE_GIORNO;
Serial.println (media_giorno);
Scrivi_Media (codice + 1, 'G', media_giorno);
conto_giorno = 0;
}
}
void Scrivi_Media(int codice, char carattere, int media)
{
dataFile = SD.open(NOMEFILE, FILE_WRITE);
if (dataFile) {
dataFile.print(codice);
dataFile.print (',');
dataFile.print (carattere);
dataFile.print (',');
dataFile.println (media);
dataFile.close();
}
}