Go Down

Topic: Il monitor seriale va in blocco (Read 68 times) previous topic - next topic

Francois88

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

Code: [Select]

/*
  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();
  }
}

Go Up