I2C gestione stringhe

Salve a tutti, ho due arduino collegati tramite protocollo I2C, uno settato come master e l'altro come slave. Il master è collegato al pc e svolge il compito di analizzare dei dati trasmessi tramite comunicazione seriale con un programmino scritto in processing. Riesco a gestire le uscite dello slave, ho provato a far accendere dei led. Adesso il prossimo passo è quello di inviare delle stringhe dal master allo slave ma fin'ora non ho trovato informazioni a riguardo, non so nemeno se sia possibile. Sul secondo arduino (slave) vorrei collegare un display lcd e fin qui ci siamo, ma poi come posso fare per inviare il messaggio da visualizzare sull'lcd dall'arduino master? Esempio pratico: il software invia al master la stringa "pippo" e vorrei visualizzarla sull'lcd. E' possibile farlo in qualche modo? Saluti.

Scusa ma come fai a comandare le uscite dello slave? Gli manderai dei comandi immagino no? Anche solo un mero intero che indica il PIN sul quale c'è il LED da accendere o spegnere... Ebbene se vuoi fare qualcosa di più complicato devi, secondo me, crearti un piccolo protocollino del tipo:

STX-PIN-COMANDO

dove: STX = numero ad esempio 10 = inizio comunicazioni PIN = è il pin sul quale lavorare (se digitale accende o spenge, se è lcd scive quello che gli mandi COMANDO = ON/OFF alias 1/0 sui digitali; un testo se è il PIN del LCD.

Spero di averti risposto.

devi mandare un'array di caratteri di una dimensione fissa, ad esempio se il tuo lcd è 16x2 mandi sempre un'array da 32 caratteri, il secondo arduino in lettura ogni 32 bit ricevuti flusha la porta e ricomincia da capo

Intanto grazie per i consigli che mi avete gentilmente suggerito. Sto facendo delle prove e qualche progresso l’ho ottenuto, infatti modificando uno script che ho trovato in rete riesco a passare una stringa di 16 caratteri dal master allo slave e per il display sono a posto. Siccome sono partito proprio in quinta, infatti non sono ne programmatore ne esperto in elettronica, a volte mi rimane difficile capire cosa fanno gli script. Adesso qui sotto inserisco gli script, sia per il master e per lo slave; in pratica ogni secondo dal master invio la stringa “Arduino” allo slave che provvederà a scriverla sul display:

////////////////// MASTER ///////////////////

#include <Wire.h>
char* message = "Arduino";
void setup()
{
  Wire.begin(); // join i2c bus (address optional for master)
}

void loop()
{
  Wire.beginTransmission(4); // transmit to device #4
  Wire.send(message);  // sends one byte 
  Wire.endTransmission();    // stop transmitting
  delay(1000);
}


////////////////// SLAVE ///////////////////

#include <Wire.h>
#include <LiquidCrystal.h>
LiquidCrystal lcd(2, 3, 4, 5, 6, 7, 8);
char buffer[17];
bool msgRicevuto = false;

void setup() 
{
  lcd.begin(16,2);
  Wire.begin(4);                // join i2c bus with address #4
  Wire.onReceive(receiveEvent); // register event
  delay(200);
}

void loop() 
{
  if (msgRicevuto == true)
    {
      lcd.setCursor(0,0);
      lcd.print(buffer);
      msgRicevuto = false;
    }
}

void receiveEvent(int howMany)
// function that executes whenever data is received from master
// this function is registered as an event, see setup()
{
  byte buf_pos = 0;
//  memset(buffer, 0, sizeof(char) * 17); // clear out our previous buffer
  while(Wire.available()) // loop through all but the last
    {
     char ricezione = Wire.receive(); // receive byte as a character
     buffer[buf_pos] = ricezione;  // put into buffer
     buf_pos++; //increment buffer position
    }
  msgRicevuto = true;
}

Secondo voi è giusto il metodo adottato per inviare la stringa dal master allo slave? Mi sono accorto che non è possibile inviare una stringa maggiore di 16 caratteri, almeno da quel poco che ho sperimentato. Un’altra cosa, non capisco cosa fa la funzione memset, nell’esempio originale che ho trovato c’era ma lo script funziona anche se commentata:

memset(buffer, 0, sizeof(char) * 17); // clear out our previous buffer

dal commento dice che svuota il buffer, ora mi vengono dei dubbi:

  • il buffer non dovrebbe svuotarsi appena inizia la trasmissione dei dati visto che quando inizia a trasmettere buf_pos va a 0?
  • buffer sarebbe un array di 17 caratteri, perchè ricevo stringhe solo fino a 16 caratteri?
  • cosa succede se lascio lo script con memset commentato, rischio di esaurire in qualche modo la memoria disponibile e provocare dei malfunzionamenti a tutto il progetto?

So che le domande sono molte e per quello che devo fare mi bastano 16 caratteri, chiedo giusto per capire e imparare qualcosa di nuovo.
Saluti.

memset(buffer, 0, sizeof(char) * 17); // clear out our previous buffer

dal commento dice che svuota il buffer, ora mi vengono dei dubbi:

No, PULISCE il buffer non svuota. memset riempe il buffer di caratteri 0

  • il buffer non dovrebbe svuotarsi appena inizia la trasmissione dei dati visto che quando inizia a trasmettere buf_pos va a 0?

QUando il buffer viene creato in memoria e' pieno di caratteri casuali per questo viene riempito di 0

  • buffer sarebbe un array di 17 caratteri, perchè ricevo stringhe solo fino a 16 caratteri?

Perche le stringhe devono terminare con il carattere \0 altrimenti il C non sa quanto sono lunghe

  • cosa succede se lascio lo script con memset commentato, rischio di esaurire in qualche modo la memoria disponibile e provocare dei malfunzionamenti a tutto il progetto?

Potersti avere dei malfunzionamenti casuali solo in situazioni particolari e impazzire non capendo dove il tuo codice si intoppa per un buffer overflow ad esempio se trasmetti una stringa di 18 caratteri lo slave ne riceve solo 16 e non avresti il teminatore di stringa, se operi con funzioni che usano il terminatore per funzionare ( esempio strcat() strcpy() ecc.. ) non funzionerebbero come tu vuoi.

Ho riesumato questo mio vecchio post per avere un chiarimento sulla trasmissione di dati via I2C. Ho due arduino collegati e sto provando a inviare una stringa (un array di char) dal master allo slave soltanto che il messaggio viene trasmesso soltanto fino a 32 caratteri anche se l'array ed il buffer ne contengono fino a 100. Per caso i 32 caratteri sono un limite del protocollo I2C ed oltre non si può andare? Il codice sembra esatto, non vedo nulla che riporta a 32... Saluti.

mi sembrava che il limite fosse di 27 byte o è una cavolata e 27 era l'array che dovevo mandare cmq è possibilie che sia 32 il limite massiomo di byte che supporta il protocollo. sul fatto che ci sia il limite son sicuro

Grazie per la conferma del limite, comunque fino a 32 caratteri riesco a trasmettere ma non di più. Proverò a rimediare dividendo il messaggio e ad inviarlo in più volte, speriamo bene. Ciao.