2 arduino connessi RX-TX e scrittura su microSD

ruug · May 7, 2024, 9:51am

Buongiorno a tutti, sono nuovo della community e provo a spiegarvi brevemente il problema a cui non riesco a trovare soluzione.
Per ora ipotizzo sia software in quanto, sostituendo modulo per SD e microSD il problema rimane lo stesso.

Ho 2 arduino nano che comunicano tra di loro attraverso le porte RX-TX ed attraverso i monitor verifico che si passano i dati correttamente.
In particolare lo slave, trasmette data ed ora (DS3231) irraggiamento (GY-49) e misure ambientali (BME280) tutti connessi alle porte A4 e A5.
I dati vengono stampati su un display oled anch'esso connesso alle stesse porte.

Avendo finito lo spazio sul primo nano, sono costretto ad eseguire il salvataggio dei dati con un altro arduino, che una volta ricevuti i dati dallo slave, suddivide la stringa e bufferizza i dati in un array struttura. Infine scrive su microSD.
Il modulo connesso ai pin 10,11,12,13 supera il check di inizializzazione sul pin 10, ma restituisce l'errore in fase di apertura file.

Questo è l'output del monitor seriale di arduino-ide:
microSD - OK!
d:2024/05/07 t:13:48:02 R:0.09 T:22.74 H:67.48 p:997.51 A:131.88 0 bytes
d:2024/05/07 t:13:48:07 R:0.09 T:22.75 H:67.48 p:997.51 A:131.90 0 bytes
d:2024/05/07 t:13:48:12 R:0.09 T:22.74 H:67.52 p:997.51 A:131.86 0 bytes
d:2024/05/07 t:13:48:18 R:0.09 T:22.72 H:67.56 p:997.50 A:131.94 0 bytes
d:2024/05/07 t:13:48:23 R:0.09 T:22.69 H:67.57 p:997.50 A:131.98 0 bytes
d:2024/05/07 t:13:48:28 R:0.09 T:22.70 H:67.62 p:997.49 A:132.05 0 bytes
d:2024/05/07 t:13:48:33 R:0.09 T:22.71 H:67.63 p:997.49 A:132.07 0 bytes
d:2024/05/07 t:13:48:38 R:0.09 T:22.71 H:67.63 p:997.50 A:131.96 0 bytes
d:2024/05/07 t:13:48:43 R:0.09 T:22.70 H:67.63 p:997.47 A:132.25 0 bytes
d:2024/05/07 t:13:48:48 R:0.09 T:22.70 H:67.64 p:997.50 A:131.94 0 bytes
d:2024/05/07 t:13:48:53 R:0.09 T:22.69 H:67.65 p:997.47 A:132.20 0 bytes
d:2024/05/07 t:13:48:58 R:0.09 T:22.70 H:67.67 p:997.47 A:131.99 0 bytes
d: t: R:0.00 T:0.00 H:0.00 p:0.00 A:-0.00 0 bytes
Errore apertura file dati.
d:2024/05/07 t:13:49:08 R:0.09 T:22.70 H:67.70 p:997.46 A:132.33 0 bytes
d:2024/05/07 t:13:49:13 R:0.09 T:22.69 H:67.71 p:997.47 A:132.17 0 bytes
...
Come si vede dai secondi, il master passa da 13:48:58 a 13:49:08 quindi ha perso i dati delle 13:49:03 (che lo slave ha acquisito) perché in quell'istante deve anche scrivere (è arrivato a 12 righe).
Potrebbe essere questa la causa?

Vi ringrazio intanto per i consigli che mi fornirete.
Resto in ascolto.

ruug · May 7, 2024, 11:37am

Allego il file del master:

//#include <Adafruit_GFX.h>
#include <Wire.h>
//#include <Adafruit_SSD1306.h>
#include <SPI.h>
#include <SD.h>


int counter=1;
int i=0;
File dataFile;
char fileName[30];


// Definizione della struttura per una singola riga di dati
struct Dati {
  char date[11]; // Array di caratteri per memorizzare la data (10 caratteri + terminatore null)
  char time[9]; // Array di caratteri per memorizzare l'orario (8 caratteri + terminatore null)
  float radi; // Irraggiamento
  float temp; // Temperatura
  float humi; // Umidità
  float pres; // Pressione
  float alti; // Altitudine stimata
};
const int nRow=12; // Numero di righe dell'array
Dati data[nRow]; // Dichiarazione dell'array di strutture

void setup() {
  Serial.begin(9600);
  //display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  Wire.begin();

  if (!SD.begin(10)) {
    Serial.println("Errore inizializzazione scheda SD!");
    return;
  } else {
    Serial.println("microSD - OK!"); 
  }
}

void loop() {
  if (Serial.available() > 0) {
    String receivedData = Serial.readStringUntil('\n');
    if (receivedData.indexOf(' ') > 0) {
      int dateIndex = receivedData.indexOf('d');
      int timeIndex = receivedData.indexOf('t');
      int radiIndex = receivedData.indexOf('R');
      int tempIndex = receivedData.indexOf('T');
      int humiIndex = receivedData.indexOf('H');
      int presIndex = receivedData.indexOf('p');
      int altiIndex = receivedData.indexOf('A');
      if (dateIndex >= 0 && timeIndex >= 0 && radiIndex >= 0 && tempIndex >= 0 && humiIndex >= 0 && presIndex >= 0 && altiIndex >=0) {
        // Estrarre la sottostringa dalla stringa fornita da slave
        String dateStr = receivedData.substring(dateIndex + 2, timeIndex - 1);
        String timeStr = receivedData.substring(timeIndex + 2, radiIndex - 1);
        float radi = receivedData.substring(radiIndex + 2, tempIndex - 1).toFloat();
        float temp = receivedData.substring(tempIndex + 2, humiIndex - 1).toFloat();
        float humi = receivedData.substring(humiIndex + 2, presIndex - 1).toFloat();
        float pres = receivedData.substring(presIndex + 2, altiIndex - 1).toFloat();
        float alti = receivedData.substring(altiIndex + 2).toFloat();
        // Converti e scrivi nell'array struttura
        dateStr.toCharArray(data[i].date, sizeof(data[i].date));
        timeStr.toCharArray(data[i].time, sizeof(data[i].time));
        data[i].radi = radi;
        data[i].temp = temp;
        data[i].humi = humi;
        data[i].pres = pres;
        data[i].alti = alti;
        //Stampa a video per controllo allocazione nella struttura
        Serial.print("d:");
        Serial.print(data[i].date);
        Serial.print(" ");
        Serial.print("t:");
        Serial.print(data[i].time);
        Serial.print(" ");
        Serial.print("R:");
        Serial.print(data[i].radi);
        Serial.print(" ");
        Serial.print("T:");
        Serial.print(data[i].temp);
        Serial.print(" ");
        Serial.print("H:");
        Serial.print(data[i].humi);
        Serial.print(" ");
        Serial.print("p:");
        Serial.print(data[i].pres);
        Serial.print(" ");
        Serial.print("A:");
        Serial.print(data[i].alti);

        // Genera il nome del file
        /*if (counter=3) {
          char ext[] = ".dat";
          char a[] = "_";
          strcpy(fileName, data[i].date);
          strcat(fileName, a);
          strcat(fileName, data[i].time);
          strcat(fileName, ext);
          //Serial.println(fileName);
        }*/

        // controlla la dimensione del file salvato
        dataFile = SD.open("data.txt", FILE_READ);
        //dataFile = SD.open(fileName, FILE_READ);
        Serial.print(" ");
        Serial.print(dataFile.size());
        Serial.println(" bytes");
        dataFile.close();

        //scrivi su file ogni minuto (12 righe, dt=5")
        if (i>=nRow) {
          dataFile = SD.open("data.txt", FILE_WRITE);
          //dataFile = SD.open(fileName, FILE_WRITE);
          if (!dataFile) {
            Serial.println("Errore apertura file dati.");
            //return;
          } else {
            Serial.println("Scrittura dati su microSD");
          }
          /*for (int j = 0; j < nRow; j++) {
            dataFile.print(data[j].date);
            dataFile.print("\t");
            dataFile.print(data[j].time);
            dataFile.print("\t");
            dataFile.print(data[j].radi);
            dataFile.print("\t");
            dataFile.print(data[j].temp);
            dataFile.print("\t");
            dataFile.print(data[j].humi);
            dataFile.print("\t");
            dataFile.print(data[j].pres);
            dataFile.print("\t");
            dataFile.println(data[j].alti);
          }*/
          dataFile.flush();
          dataFile.close();
          i=0;
          //Serial.begin(9600);
        }
        i++;
        counter++;
        delay(5000);
      }
    }
  }
}

ruug · May 7, 2024, 1:26pm

Ho modificato questa parte di codice per evitare la sovrapposizione della scrittura con il passaggio dati.

        if (i<nRow) {
          delay(5000);
        } else {
          delay(1000);

Ora non perde la stringa, ma da comunque errore di apertura file.
L'errore lo da solo in modalità WRITE, perchè con READ restituisce il size del file "data.txt"

i:11 c:23 d:2024/05/07 t:15:24:50 R:0.13 T:23.10 H:67.57 p:997.61 A:131.00 0 bytes
i:12 c:24 d:2024/05/07 t:15:24:55 R:0.13 T:23.12 H:67.56 p:997.64 A:130.78 0 bytes
Errore apertura file dati.
i:1 c:25 d:2024/05/07 t:15:25:00 R:0.13 T:23.12 H:67.54 p:997.61 A:131.05 0 bytes
i:2 c:26 d:2024/05/07 t:15:25:05 R:0.13 T:23.12 H:67.52 p:997.63 A:130.87 0 bytes
i:3 c:27 d:2024/05/07 t:15:25:10 R:0.13 T:23.13 H:67.51 p:997.62 A:130.98 0 bytes

Salvorhardin · May 7, 2024, 7:19pm

Il programma non è scritto male e anche ben indentato
Complimenti

Però usi oggetti String, che è sempre sbagliato
Anche la gestione della ricezione è strana, troppi delay()

Qui hanno scritto molto (e secondo noi anche bene) sulla ricezione asincrona di dati

Non è roba mia, non mi permetto di far finta di appropriarmi

Però la ricerca non è difficile

Casomai se non trovi chiederai

Comunque secondo me il problema principale non è li

Prova a ricaricare gli esempi della libreria e vediamo come va

ruug · May 7, 2024, 7:38pm

Grazie della risposta.

Non ho idea del motivo per cui gli oggetti stringa sono sbagliati.
Magari se hai voglia, puoi spiegarmi il motivo o darmi dei link su cui apprendere.

Per esempi della libreria, a cosa ti riferisci ?

Se può aiutare a comprendere, il problema della scrittura è iniziato quando ho iniziato a bufferizzare i dati nell'array struttura.
Quando scrivevo su microSD ad ogni ciclo, tutto andava liscio.

Intanto vedo di capire qualcosa sulla ricezione asincrona di dati.

Salvorhardin · May 7, 2024, 7:50pm

Gli oggetti String usano l'allocazione dinamica
Che su Arduino ha problemi di stabilità

Non sono sicuro che si possa aprire due volte lo stesso oggetto file nella stesssa funzione. Pur avendolo chiuso

Prova e non leggere la dimensione file

ruug · May 7, 2024, 8:03pm

Se tolgo la parte del READ, questo è l'output:
microSD - OK!
i:1 c:1 d: t: R:0.00 T:0.00 H:0.00 p:0.00 A:0.00 s:bytes
i:2 c:2 d: t: R:0.00 T:0.00 H:0.00 p:0.00 A:0.00 s:bytes
i:3 c:3 d: t: R:0.00 T:0.00 H:0.00 p:0.00 A:0.00 s:bytes

Sinceramente non capisco il perché....
Farò qualche tentativo per capire.

Intanto grazie.

Salvorhardin · May 7, 2024, 8:06pm

Ma scrive?

ruug · May 7, 2024, 8:11pm

No.

Salvorhardin · May 7, 2024, 8:14pm

Strano

Metti il programma aggiornato che ci penso su

ruug · May 7, 2024, 8:21pm

Questo è l'output se scrivo diretto senza allocare il dato nella array struttura:
microSD - OK!
i:1 c:1 d:2024/05/07 t:22:19:37 R:0.06 T:22.79 H:72.62 p:998.46 A:123.87 s:156bytes
Scrittura dati su microSD
i:2 c:2 d:2024/05/07 t:22:19:42 R:0.06 T:22.79 H:72.62 p:998.41 A:124.20 s:208bytes
Scrittura dati su microSD
i:3 c:3 d:2024/05/07 t:22:19:47 R:0.06 T:22.79 H:72.60 p:998.45 A:123.90 s:260bytes
Scrittura dati su microSD

apro il file per leggere
apro il file per scrivere (sempre nello stesso loop)
scrive

ruug · May 7, 2024, 8:31pm

Per quanto riguarda il programma aggiornato, cioè quando mi chiedevi ti togliere la parte in cui legge per calcolare da dimensione del file, ho semplicemente commentato queste righe:

digita o incolla il codice qui        // controlla la dimensione del file salvato
        //dataFile = SD.open("data.txt", FILE_READ);
        //dataFile = SD.open(fileName, FILE_READ);
        Serial.print(" ");
        Serial.print("s:");
        //Serial.print(dataFile.size());
        Serial.println("bytes");
        //dataFile.close();

Salvorhardin · May 7, 2024, 8:33pm

E non hai decommentato la scrittura?

Comunque i programmi si esaminano al completo

A pezzi sembrano sempre giusti

ruug · May 7, 2024, 8:35pm

Non l'ho postato perché è identico a quello all'inizio, solo con tre righe commentate.
Comunque te lo metto di seguito:

//#include <Adafruit_GFX.h>
#include <Wire.h>
//#include <Adafruit_SSD1306.h>
#include <SPI.h>
#include <SD.h>


int counter=1;
int i=0;
File dataFile;
char fileName[30];


// Definizione della struttura per una singola riga di dati
struct Dati {
  char date[11]; // Array di caratteri per memorizzare la data (10 caratteri + terminatore null)
  char time[9]; // Array di caratteri per memorizzare l'orario (8 caratteri + terminatore null)
  float radi; // Valore numerico
  float temp; // Temperatura
  float humi; // Umidità
  float pres; // Pressione
  float alti; // Extimated altitude sea level
};
const int nRow=12; // Numero di righe dell'array
Dati data[nRow]; // Dichiarazione dell'array di strutture

void setup() {
  Serial.begin(9600);
  //display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  Wire.begin();

  if (!SD.begin(10)) {
    Serial.println("Errore inizializzazione scheda SD!");
    //return;
  } else {
    Serial.println("microSD - OK!"); 
  }
}

void loop() {
  if (Serial.available() > 0) {
    String receivedData = Serial.readStringUntil('\n');
    if (receivedData.indexOf(' ') > 0) {
      int dateIndex = receivedData.indexOf('d');
      int timeIndex = receivedData.indexOf('t');
      int radiIndex = receivedData.indexOf('R');
      int tempIndex = receivedData.indexOf('T');
      int humiIndex = receivedData.indexOf('H');
      int presIndex = receivedData.indexOf('p');
      int altiIndex = receivedData.indexOf('A');
      if (dateIndex >= 0 && timeIndex >= 0 && radiIndex >= 0 && tempIndex >= 0 && humiIndex >= 0 && presIndex >= 0 && altiIndex >=0) {
        // Estrarre la sottostringa dalla stringa fornita da slave
        String dateStr = receivedData.substring(dateIndex + 2, timeIndex - 1);
        String timeStr = receivedData.substring(timeIndex + 2, radiIndex - 1);
        float radi = receivedData.substring(radiIndex + 2, tempIndex - 1).toFloat();
        float temp = receivedData.substring(tempIndex + 2, humiIndex - 1).toFloat();
        float humi = receivedData.substring(humiIndex + 2, presIndex - 1).toFloat();
        float pres = receivedData.substring(presIndex + 2, altiIndex - 1).toFloat();
        float alti = receivedData.substring(altiIndex + 2).toFloat();
        // Converti e scrivi nell'array struttura
        dateStr.toCharArray(data[i].date, sizeof(data[i].date));
        timeStr.toCharArray(data[i].time, sizeof(data[i].time));
        data[i].radi = radi;
        data[i].temp = temp;
        data[i].humi = humi;
        data[i].pres = pres;
        data[i].alti = alti;
        //Stampa a video per controllo scrittura
        Serial.print("i:");
        Serial.print(i+1);
        Serial.print(" ");
        Serial.print("c:");
        Serial.print(counter);
        Serial.print(" ");
        Serial.print("d:");
        Serial.print(data[i].date);
        Serial.print(" ");
        Serial.print("t:");
        Serial.print(data[i].time);
        Serial.print(" ");
        Serial.print("R:");
        Serial.print(data[i].radi);
        Serial.print(" ");
        Serial.print("T:");
        Serial.print(data[i].temp);
        Serial.print(" ");
        Serial.print("H:");
        Serial.print(data[i].humi);
        Serial.print(" ");
        Serial.print("p:");
        Serial.print(data[i].pres);
        Serial.print(" ");
        Serial.print("A:");
        Serial.print(data[i].alti);

        /*if (counter=3) {
          char ext[] = ".dat";
          char a[] = "_"; // Assicurati che l'array di destinazione sia abbastanza grande
          strcpy(fileName, data[i].date); // Copia la prima stringa in risultato
          strcat(fileName, a);
          strcat(fileName, data[i].time);
          strcat(fileName, ext); // Concatena la seconda stringa a risultato
          //Serial.println(fileName);
        }*/

        // controlla la dimensione del file salvato
        //dataFile = SD.open("data.txt", FILE_READ);
        //dataFile = SD.open(fileName, FILE_READ);
        Serial.print(" ");
        Serial.print("s:");
        //Serial.print(dataFile.size());
        Serial.println("bytes");
        //dataFile.close();

        //scrivi su file
        if (i>=nRow-1) {
          //Serial.end();
          dataFile = SD.open("data.txt", FILE_WRITE);
          //dataFile = SD.open(fileName, FILE_WRITE);
          if (!dataFile) {
            Serial.println("Errore apertura file dati.");
            return;
          } else {
            Serial.println("Scrittura dati su microSD");
          }
          for (int j = 0; j < nRow; j++) {
            dataFile.print(data[j].date);
            dataFile.print("\t");
            dataFile.print(data[j].time);
            dataFile.print("\t");
            dataFile.print(data[j].radi);
            dataFile.print("\t");
            dataFile.print(data[j].temp);
            dataFile.print("\t");
            dataFile.print(data[j].humi);
            dataFile.print("\t");
            dataFile.print(data[j].pres);
            dataFile.print("\t");
            dataFile.println(data[j].alti);
          }
          dataFile.flush();
          dataFile.close();
          i=-1;
          //Serial.begin(9600);
        }
        i++;
        counter++;
        if (i<nRow) {
          delay(5000);
        } else {
          delay(1000);
        }
      }
    }
  }
}

ruug · May 7, 2024, 8:36pm

questo invece invece è quello che scrive ad ogni loop, senza allocare nella struttura, e funziona.

//#include <Adafruit_GFX.h>
#include <Wire.h>
//#include <Adafruit_SSD1306.h>
#include <SPI.h>
#include <SD.h>


int counter=1;
int i=0;
File dataFile;
char fileName[30];



void setup() {
  Serial.begin(9600);
  //display.begin(SSD1306_SWITCHCAPVCC, 0x3C);
  Wire.begin();

  if (!SD.begin(10)) {
    Serial.println("Errore inizializzazione scheda SD!");
    //return;
  } else {
    Serial.println("microSD - OK!"); 
  }
}

void loop() {
  if (Serial.available() > 0) {
    String receivedData = Serial.readStringUntil('\n');
    if (receivedData.indexOf(' ') > 0) {
      int dateIndex = receivedData.indexOf('d');
      int timeIndex = receivedData.indexOf('t');
      int radiIndex = receivedData.indexOf('R');
      int tempIndex = receivedData.indexOf('T');
      int humiIndex = receivedData.indexOf('H');
      int presIndex = receivedData.indexOf('p');
      int altiIndex = receivedData.indexOf('A');
      if (dateIndex >= 0 && timeIndex >= 0 && radiIndex >= 0 && tempIndex >= 0 && humiIndex >= 0 && presIndex >= 0 && altiIndex >=0) {
        // Estrarre la sottostringa dalla stringa fornita da slave
        String dateStr = receivedData.substring(dateIndex + 2, timeIndex - 1);
        String timeStr = receivedData.substring(timeIndex + 2, radiIndex - 1);
        float radi = receivedData.substring(radiIndex + 2, tempIndex - 1).toFloat();
        float temp = receivedData.substring(tempIndex + 2, humiIndex - 1).toFloat();
        float humi = receivedData.substring(humiIndex + 2, presIndex - 1).toFloat();
        float pres = receivedData.substring(presIndex + 2, altiIndex - 1).toFloat();
        float alti = receivedData.substring(altiIndex + 2).toFloat();
        // Converti e scrivi nell'array struttura
        //dateStr.toCharArray(data[i].date, sizeof(data[i].date));
        //timeStr.toCharArray(data[i].time, sizeof(data[i].time));
        //Stampa a video per controllo scrittura
        Serial.print("i:");
        Serial.print(i+1);
        Serial.print(" ");
        Serial.print("c:");
        Serial.print(counter);
        Serial.print(" ");
        Serial.print("d:");
        Serial.print(dateStr);
        Serial.print(" ");
        Serial.print("t:");
        Serial.print(timeStr);
        Serial.print(" ");
        Serial.print("R:");
        Serial.print(radi);
        Serial.print(" ");
        Serial.print("T:");
        Serial.print(temp);
        Serial.print(" ");
        Serial.print("H:");
        Serial.print(humi);
        Serial.print(" ");
        Serial.print("p:");
        Serial.print(pres);
        Serial.print(" ");
        Serial.print("A:");
        Serial.print(alti);

        /*if (counter=3) {
          char ext[] = ".dat";
          char a[] = "_"; // Assicurati che l'array di destinazione sia abbastanza grande
          strcpy(fileName, data[i].date); // Copia la prima stringa in risultato
          strcat(fileName, a);
          strcat(fileName, data[i].time);
          strcat(fileName, ext); // Concatena la seconda stringa a risultato
          //Serial.println(fileName);
        }*/

        // controlla la dimensione del file salvato
        dataFile = SD.open("data.txt", FILE_READ);
        //dataFile = SD.open(fileName, FILE_READ);
        Serial.print(" ");
        Serial.print("s:");
        Serial.print(dataFile.size());
        Serial.println("bytes");
        dataFile.close();

        //scrivi su file
          dataFile = SD.open("data.txt", FILE_WRITE);
          //dataFile = SD.open(fileName, FILE_WRITE);
          if (!dataFile) {
            Serial.println("Errore apertura file dati.");
            return;
          } else {
            Serial.println("Scrittura dati su microSD");
          }
            dataFile.print(dateStr);
            dataFile.print("\t");
            dataFile.print(timeStr);
            dataFile.print("\t");
            dataFile.print(radi);
            dataFile.print("\t");
            dataFile.print(temp);
            dataFile.print("\t");
            dataFile.print(humi);
            dataFile.print("\t");
            dataFile.print(pres);
            dataFile.print("\t");
            dataFile.println(alti);
          
          dataFile.flush();
          dataFile.close();
          
          //Serial.begin(9600);
      
        i++;
        counter++;

          delay(5000);

      }
    }
  }
}

Maurotec · May 7, 2024, 9:08pm

11 + 9 + (4 x 5) = 40 byte x 12 = 480 byte

Più la ram che si prende la libreria SD forse arrivi a superare i 2048 byte, tieni conto che c'è anche lo stack che si riempie con quelle variabili locali.

Così per prova anziché nRow = 12, nRow = 2.
Se funziona prova ad aumentarlo fino a che smette di funzionare.

Ciao.

ruug · May 7, 2024, 9:16pm

Con nRow=2 funziona. Ecco dove era il problema.
Grazie.

Per ora funziona e ringrazio tutti.
Se poi qualcuno vuole darmi lezioni di stile su come andrebbe fatta una comunicazione "canonica" io sono pronto ad ascoltare.

Grazie di nuovo a tutti.

ruug · June 10, 2024, 4:02pm

Buongiorno a tutti,
torno nuovamente sulla questione discussa, precedentemente.
Provo a spiegare brevemente la mia esigenza:

arduino slave legge i dati dai sensori e li passa al master
Serial.print(...); sullo slave -> String receivedData = Serial.readStringUntil('\n'); sul master
il master li scrive su un file txt e controlla la dimensione del file (lo uso per verificare l'avvenuta scrittura dei dati)
a questo punto vorrei chi la dimensione del file, venga passato allo slave che lo stampa sul display oled.

Se uso la stessa sintassi del punto 1. non visualizzo i dati.
Serial.println(...); sul master -> String receivedData = Serial.readStringUntil('\n'); sullo slave

Quindi ricapitolando:

slave passa i dati a master
master li elabora
master li ripassa a slave
Come si fa il punto 3? Grazie.

P.S. I codici sono già sopra.

Maurotec · June 10, 2024, 9:39pm

Dovrebbe funzionare in ambo i due sensi, forse può essere che dimentichi di aggiungere un serial.print('\n') alla fine, ma mi pare strano. Vedi se puoi scrivere uno sketch separato inserendo l'essenziale per la comunicazione (due sketch).

Ciao.

ruug · June 10, 2024, 10:06pm

Serial.println(); credo sia equivalente a Serial.print('\n');
Proverò comunque uno sketch separato.

Se può aiutare, ho provato anche SoftwareSerial sui pin D2 e D3, ma senza risultati positivi.

SoftwareSerial mySerial(2, 3); // RX, TX
mySerial.begin(9600);
while (mySerial.available() == 0) {
    // Attendi
  }
// Leggi la stringa ricevuta
String receivedData = mySerial.readStringUntil('\n');
int sizeIndex = receivedData.indexOf("s:");
  if (sizeIndex >= 0) {
    // Estrarre la temperatura e convertirla in float
    String sizeStr = receivedData.substring(sizeIndex + 2);
    int size = sizeStr.toInt)

    // Invia il dato elaborato ad Arduino 1
    mySerial.println(size);

Topic		Replies	Views
Difficoltà nello scrivere su SD Generale	49	1385	May 21, 2024
Trasmissione di file immagini tra due arduino Software	26	282	September 8, 2025
Esp8266 e SD che sovrascrive Software	81	2634	September 2, 2022
[Risolto] Gestire errore di scrittura su micro SD. Software	37	4550	May 7, 2021
Mancata scrittura su SD Software	25	460	August 1, 2024

2 arduino connessi RX-TX e scrittura su microSD

Related topics