Array I2C da Wemos ad Arduino Mega (RISOLTO)

Ciao a tutti, dopo ore passate al Pc son riuscito a fare un piccolo codice per trasferire un array da Wemos D1 ad Arduino Mega via I2C.
Purtroppo mi passa tutto l’array e si ferma, non è ciclico, in pratica non continua a rilanciare l’array.
Vi posto sia il Master che lo Slave, magari qualcuno è cosi gentile da dargli un occhiata, grazie.

//MASTER
#include <Wire.h>
byte x[]= {1,2,3,4};


void setup()
        {
      Wire.begin();//inizializzo la libreria Wire come Master
      Serial.begin(115200);
        }

void loop()
        {
      Wire.beginTransmission(0x04);

      for (int i=0; i <= 4; i++)
        {
      Wire.write(x[i]);
          }
      Wire.endTransmission();
      delayMicroseconds(50);

        }
//SLAVE
#include <Wire.h>

int ricevuto[3];

void setup()
         {
      Wire.begin(0x04);//inizializzo la libreria imposto l’indirizzo dello slave
      Serial.begin(9600);
      Wire.onReceive(receiveEvent);   //eventi per la ricezione del dato
          }

void loop()
          {
      delay(1000);
          }

void receiveEvent(int data) //ricevo eventi se inviati da Wire.beginTransmission(0x04);
          {
                            //questo evento viene generato quando sul bus
                            //è presente un dato da leggere
                            //eseguo la lettura
       for (int i=0; i <= 3; i++){
       ricevuto[i] = Wire.read();
       Serial.print("Lo slave ha scritto;  recevuti");
       Serial.println(ricevuto[i]);
          }
          }

Secondo me basta spostare la funzione

Wire.onReceive(receiveEvent);

nel void loop :slight_smile:

Prova e fammi sapere :slight_smile:

PS dalla tua presentazione:

praticamente mi ha affascinato per tutte le sue potenzialità ad un costo accessibile, ora mi sto prodigando per cercare di controllare l'impianto elettrico della casa.

se leggi bene il regolamento non è permesso fare questo tipo di operazioni, in quanto non siamo più nel range della bassissima tensione di sicurezza, ma bensì a 230 V AC...

MD

Grazie Matteo, ho provato mi da lo stesso problema

ecco cosa compare

Schermata 2018-11-30 alle 20.17.28 (1).png

sbagliero', ma tu trasmetti 4 byte ma ne ricevi solo a gruppi di tre
quindi il primo receiveEvent viene lanciato dalla presenza del primo byte da leggere, e ne legge 3
terminato il primo, la presenza del 4° byte scatena il secondo receveEvent, che legge il 4° come se fosse il primo, ma NON trova altro da leggere e NON termina
poco dopo il tramettitore ricomincia, ma a questo punto sono io che non so come si comporta il tutto con una routine di ricezione già attiva

Grazie per la risposta, ho riletto mille volte quello che scrivo ma non capisco, come in foto la prima trasmissione è corretta, addirittura a volte ne fa due, ma è casuale. il problema penso che non si sia la chiusura di ricezione

Ci ho ragionato su e cercando sul Web ho provato con questo codice di lettura dell’Array, funziona se non metto “ln” a capo su (Serial.print(ricevuto[howMany - 1]):wink: , misteri, se metto a capo con Serial.println mi fa una picola serie e poi si ferma…

//SLAVE arduino mega
#include <Wire.h>
int ricevuto[8];
void setup()
         {
      Wire.begin(3);//inizializzo la libreria imposto l’indirizzo dello slave
      Serial.begin(115200);
      Wire.onReceive(receiveEvent);//eventi per la ricezione del dato
          }

void loop()
          {
            
      delayMicroseconds(50);
          }

void receiveEvent(int howMany){
  for(howMany; howMany > 0; howMany--){
    ricevuto[howMany - 1] = Wire.read();
    Serial.print("Il MASTER ha inviato:  ");
    Serial.print(ricevuto[howMany - 1]);
    if(howMany != 1){
      Serial.print(",");
    }
    else{
      Serial.println();
    }
  }
}

mah, piccolo dubbio....
i programmi di esempio ti vanno, chiaramente...
hai provato a usare in trasmissione il tuo e in ricezione quello dell'esempio "arduino MasterWriter"?
se non hai provato, prova e dimmi cosa succede....

Standardoil, si certo che ho provato sono partito da li, però dovevo trasferire un Array e cercando sul web ho implementato quel codice.
Ora provando mille soluzione funziona, ho scoperto che mettendo un delay(10) sul master prima di Wire.beginTransmission(3); funziona a ripetizione, se diminuisco il tempo di delay( a 8) mi trasferisce solo un Array e non lo fa a ripeizione, si impianta…

Poi ho modificato il master con un FOR…, ho notato che il valore che restituisce la variabile iterna al void receiveEvent(int howMany) ha un valore di 20 (onstamente non so cosa sia, sono i Bite trasmessi?)

Onestamente per il programma che ho in mente non dovrà trasferire array in continuo ma a chiamata, comunque mi chiedo il perche c’è bisgno di un ritardo…!!!

Posto il codice funzionante.

//MASTER wemos
#include <Wire.h>
byte x[]= {1,2,3,4};

void setup()
          {
      Wire.begin();
      Serial.begin(115200);
          }
        
void loop()
          { 
      delay(10);
      Wire.beginTransmission(3);
      for (int i=0; i <= 3; i++){
      Wire.write(x[i]);
          }
      Wire.endTransmission(3);
          }
//SLAVE arduino mega
#include <Wire.h>
int ricevuto[8];
void setup()
         {
      Wire.begin(3);
      Serial.begin(115200);
      Wire.onReceive(receiveEvent);
          }
void loop() {}
          
void receiveEvent(int howMany){
      for(howMany; howMany > 0; howMany--)
          {
      ricevuto[howMany - 1] = Wire.read();
      Serial.print("Il MASTER ha inviato:  ");
      Serial.println(ricevuto[howMany - 1]);
          }
          }

Se a qualcuno può interessare vi posto il codice funzionante per trasferire array da slave a master sempre via I2C.

 // MASTER WEMOS
#include <Wire.h>     
int arrayritorno[3];

void setup()    {
        Wire.begin();           
        Serial.begin(230400);
                }
    void loop() {
        Wire.requestFrom(3,4);        
        for (int i=0; i <= 3; i++)
                {
        arrayritorno[i] = Wire.read();
        Serial.print("Il Master ha ricevuto: ");
        Serial.println(arrayritorno[i]);
                 }
                 }
//SLAVE  arduino mega

#include <Wire.h>
byte Array[] = {1, 2, 3, 4};

void setup() {

  Wire.begin(3);     // indirizzo slave, inizializzo la libreria
  Wire.onRequest(manda);//event per la richiesta del dato
             }

void loop() {
  //delay(10);
            }
void manda() {
for (int i=0; i <= 3; i++){
Wire.write(Array[i]);
            }
             }