Problema lettura e scrittura su EEPROM i2c 24LC256

International Italiano Software
1

Salve a tutti !

Prima di porvi il problema:

PS: Vi avviso che mi presento qua perchè sono stato mezz'ora a cercare la sezione per presentarsi ma non ho trovato nulla che mi facesse fare tale cosa...

Mi chiamo Samuele e sono un appassionato di elettronica, sono perito elettrico e lavoro come elettricista in una azienda che costruisce organi a canne.
Lavoro nel settore degli strumenti a gestione elettronica e la cosa bella è che vengono usati proprio i microcontrollori che sono utilizzati nelle schede Arduino... usiamo anche MCU STM32 e altri modelli...

Ho iniziato ad usare Arduino nel 2016 finita la scuola e avendo studiato PLC mi ha aperto un mondo... a breve vorrei condividere con voi il sistema del flipper che ho fatto, magari a qualcuno interessa... e niente, adesso sapete un po' chi sono :smiley:

PROBLEMA:

Sto avendo problemi sul salvataggio o la scrittura dei dati sulla eeprom i2c 24lc256

In pratica devo scrivere 4 array di byte da 100 indirizzi quindi 400 byte totali.

Ho creato una funzione che mi scrive i byte in sequenza per utilizzare il metodo della scrittura a pagina. Sul datasheet viene avvisato che quando si scrivono più byte è meglio scriverli in catena dando l'indirizzo di partenza e poi la scrittura sequenziale di ognuno.
Con questo metodo dovrei andare a sovrascrivere le celle solo una volta.

Il codice che vi mando è tecnicamente sbagliato perchè vengono scritti 100 byte in catena quando la librerira Wire, da quello che so, può scrivere 30 byte di dati al colpo... non ho capito bene in che senso poichè avevo fatto un codice che mi divide i 100 byte in blocchi da 20 ma comunque non mi funziona.

Varibili da leggere e scrivere:

#define Num_Cell 100
byte DATA_DTA[Num_Cell];
byte DATA_DTB[Num_Cell];
byte DATA_ADR[Num_Cell];
byte DATA_VAL[Num_Cell];

Codice della scrittura dei byte sulla eeprom:

//Scrittura su EEPROM (ESTERNA)
void EEPROM_Write(byte DATA[], byte DATA_ADR, int ADR) {

  Wire.beginTransmission(EEPROM_I2C_ADDRESS);

  Wire.write((int)(ADR >> 8));    // MSB
  Wire.write((int)(ADR & 0xFF));  // LSB

  for (byte i = 0; i < DATA_ADR; i++) {
    Wire.write(DATA[i]);
  }
  
  Wire.endTransmission();

  delay(10);

}

Codice che dovrebbe scrivere le 4 variabili byte in array da 100 in catena (quindi 400 totali):

 if (Message == "WRITE") {

        //Sezione non funzionante
        
        EEPROM_Write(DATA_DTA, Num_Cell, 0);
        EEPROM_Write(DATA_DTB, Num_Cell, Num_Cell);
        EEPROM_Write(DATA_ADR, Num_Cell, (Num_Cell * 2));
        EEPROM_Write(DATA_VAL, Num_Cell, (Num_Cell * 3));

        Serial.println("ROM OK");

      }

Codice che legge i byte dalla eeprom:

for (byte i = 0; i < Num_Cell; i++) {
    DATA_DTA[i] = EEPROM_Read(i);
    DATA_DTB[i] = EEPROM_Read(i + Num_Cell);
    DATA_ADR[i] = EEPROM_Read(i + (Num_Cell * 2));
    DATA_VAL[i] = EEPROM_Read(i + (Num_Cell * 3));
  }

Ho provato a fare il progetto utilizzando la EEPROM interna del microcontrollore e funziona bene... non ho trovato bug rispetto alle EEPROM esterna.

Ho provato anche a vedere se la mia EEPROM 24LC256 comunica e scrive e legge i byte su programma a parte e funziona molto bene...

quindi dovrebbe essere un problema di programmazione... qualche consiglio?

Grazie a tutti dell'aiuto in anticipo :smiley:

Scopo del progetto:

(Il progetto completo è un programma che mi emula le fuzioni logiche AND, OR, NOT ecc ecc come un PLC che salva i dati poi, finito di programmarlo tramite seriale, sulla eeprom)

Vorrei allegare i file V2 e V3 del progetto dove il V2 non va con eeprom esterna e V3 con eeprom interna funzionante ma mi avvisa che i nuovi utenti non possono condividere file.

3

Allego il codice V2 e V3:

V2 codice con bug e eeprom esterna
V3 codice funzionante con eeprom interna

File A V2:

#include "Wire.h"
#define EEPROM_I2C_ADDRESS 0x50

#define Num_In 8
#define Num_Out 6
#define Debug_Led 13
byte Pin_In[] = { 2, 3, 4, 5, 6, 7, 8, 9 };
byte Pin_Out[] = { 11, 12, A0, A1, A2, A3};

bool In[Num_In], Out[Num_Out];

#define Num_Mem 32
#define Num_Timer 32
#define Num_Counter 16
#define Num_Edge 32

bool Mem[Num_Mem];

bool Timer_Out[Num_Timer];
int Timer_Data[Num_Timer];

bool Counter_Out[Num_Counter], Counter_Mem[Num_Counter];
byte Counter_Data[Num_Counter];

bool Edge_Out[Num_Edge], Edge_Mem[Num_Edge];

#define Num_Cell 150
bool Cell_Mem[Num_Cell];

//DATA_DTA
// 1 ST, 2 AND, 3 OR, 4 OUT

//DATA_DTB
// 1 IN, 2 OUT, 3 MEM, 4 TM, 5 CT, 6 CR, 7 EG

//NOT (VALUE)
// 0 BUF, 1 NOT

byte DATA_DTA[Num_Cell];
byte DATA_DTB[Num_Cell];
byte DATA_ADR[Num_Cell];
byte DATA_VAL[Num_Cell];

String Message;
int Message_Int;
byte MCell_ADR, Selector;

#define Counter_Led_Value 20
int Counter_Led;

void setup() {

  delay(10);

  for (byte i = 0; i < Num_In; i++) {
    pinMode(Pin_In[i], INPUT);
  }

  for (byte i = 0; i < Num_Out; i++) {
    pinMode(Pin_Out[i], OUTPUT);
  }

  pinMode(Debug_Led, OUTPUT);

  Wire.begin();
  Serial.begin(115200);

  for (byte i = 0; i < Num_Cell; i++) {
    DATA_DTA[i] = EEPROM_Read(i);
    DATA_DTB[i] = EEPROM_Read(i + Num_Cell);
    DATA_ADR[i] = EEPROM_Read(i + (Num_Cell * 2));
    DATA_VAL[i] = EEPROM_Read(i + (Num_Cell * 3));
  }

  delay(100);
}

void loop() {

  delay(1);

  Read_Input();

  if (Serial.available() > 0) {

    while (Serial.available() > 0) {

      Message = Serial.readStringUntil('x');

      Message_Int = Message.toInt();

      //Serial.print(Message_Int);

      if (Selector == 1) {
        DATA_DTA[MCell_ADR] = Message_Int;
        //Serial.print("DATA A -> ");
        //Serial.println(DATA_DTA[MCell_ADR]);
        Selector = 0;
      } else if (Selector == 2) {
        DATA_DTB[MCell_ADR] = Message_Int;
        //Serial.print("DATA B -> ");
        //Serial.println(DATA_DTB[MCell_ADR]);
        Selector = 0;
      } else if (Selector == 3) {
        DATA_ADR[MCell_ADR] = Message_Int;
        //Serial.print("DATA A -> ");
        //Serial.println(DATA_ADR[MCell_ADR]);
        Selector = 0;
      } else if (Selector == 4) {
        DATA_VAL[MCell_ADR] = Message_Int;
        //Serial.print("DATA A -> ");
        //Serial.println(DATA_VAL[MCell_ADR]);
        Selector = 0;
      } else if (Selector == 5) {
        MCell_ADR = Message_Int;
        //Serial.print("CELL -> ");
        //Serial.println(MCell_ADR);
        Selector = 0;
      }

      if (Selector == 6) {
        //ST
        DATA_DTA[MCell_ADR] = 1;
        Selector = 0;
      } else if (Selector == 7) {
        //AND
        DATA_DTA[MCell_ADR] = 2;
        Selector = 0;
      } else if (Selector == 8) {
        //OR
        DATA_DTA[MCell_ADR] = 3;
        Selector = 0;
      } else if (Selector == 9) {
        //OUT
        DATA_DTA[MCell_ADR] = 4;
        Selector = 0;
      }

      if (Selector == 10) {
        //IN
        DATA_DTB[MCell_ADR] = 1;
        Selector = 0;
      } else if (Selector == 11) {
        //Q
        DATA_DTB[MCell_ADR] = 2;
        Selector = 0;
      } else if (Selector == 12) {
        //MEM
        DATA_DTB[MCell_ADR] = 3;
        Selector = 0;
      } else if (Selector == 13) {
        //TM
        DATA_DTB[MCell_ADR] = 4;
        Selector = 0;
      } else if (Selector == 14) {
        //CT
        DATA_DTB[MCell_ADR] = 5;
        Selector = 0;
      } else if (Selector == 15) {
        //CR
        DATA_DTB[MCell_ADR] = 6;
        Selector = 0;
      } else if (Selector == 16) {
        //ET
        DATA_DTB[MCell_ADR] = 7;
        Selector = 0;
      }

      if (Message == "DA") {
        Selector = 1;
      } else if (Message == "DB") {
        Selector = 2;
      } else if (Message == "AD") {
        Selector = 3;
      } else if (Message == "VA") {
        Selector = 4;
      } else if (Message == "CL") {
        Selector = 5;
      } else if (Message == "ST") {
        Selector = 6;
      } else if (Message == "AN") {
        Selector = 7;
      } else if (Message == "OR") {
        Selector = 8;
      } else if (Message == "OT") {
        Selector = 9;
      } else if (Message == "IN") {
        Selector = 10;
      } else if (Message == "QT") {
        Selector = 11;
      } else if (Message == "ME") {
        Selector = 12;
      } else if (Message == "TM") {
        Selector = 13;
      } else if (Message == "CT") {
        Selector = 14;
      } else if (Message == "CR") {
        Selector = 15;
      } else if (Message == "ET") {
        Selector = 16;
      }

      if (Message == "WRITE") {

        //Sezione non funzionante
        
        EEPROM_Write(DATA_DTA, Num_Cell, 0);
        EEPROM_Write(DATA_DTB, Num_Cell, Num_Cell);
        EEPROM_Write(DATA_ADR, Num_Cell, (Num_Cell * 2));
        EEPROM_Write(DATA_VAL, Num_Cell, (Num_Cell * 3));

        Serial.println("ROM OK");

      }

    }

  }
  //   S  I  O  M  T  C  CR AN OR NT V  AD CI CADR
  //Cell(1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
  //Cell(3, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, Cell_Mem[0], 1);
  //Cell(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Cell_Mem[1], 2);
  //Cell(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Cell_Mem[2], 3);
  //Cell(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Cell_Mem[3], 4);
  //Cell(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Cell_Mem[4], 5);

  //Cell_PRG(1, 1, 0, 0, 0, 0, 0);
  //Cell_PRG(4, 2, 0, 0, 0, Cell_Mem[0], 1);
  //Cell_PRG(0, 0, 0, 0, 0, Cell_Mem[1], 2);
  //Cell_PRG(0, 0, 0, 0, 0, Cell_Mem[2], 3);
  //Cell_PRG(0, 0, 0, 0, 0, Cell_Mem[3], 4);
  //Cell_PRG(0, 0, 0, 0, 0, Cell_Mem[4], 5);

  for (byte i = 0; i < Num_Cell; i++) {

    if (i < 1) {
      Cell_PRG(DATA_DTA[0], DATA_DTB[0], DATA_ADR[0], DATA_VAL[0], 0, 0);
    } else {
      Cell_PRG(DATA_DTA[i], DATA_DTB[i], DATA_ADR[i], DATA_VAL[i], Cell_Mem[i - 1], i);
    }
  }

  Write_Output();

  if (Counter_Led < Counter_Led_Value) {
    Counter_Led++;
  } else {
    Counter_Led = 0;
    digitalWrite(Debug_Led, !digitalRead(Debug_Led));
  }

}

File B V2 (Funzioni):

void Cell_PRG(byte CODE_A, byte CODE_B, byte PADR, byte PVALUE, bool PCELL_IN, byte PCELL_ADR) {

  bool PEN_In = 0, PEN_Out = 0, PEN_Mem = 0, PEN_Timer = 0, PEN_Counter = 0, PEN_Counter_R = 0, PEN_Edge = 0, PEN_And_Or = 0, PEN_Not_MM = 0;
  byte PSTRT = 0;

  if (CODE_A == 1) {
    //START
    PSTRT = 1;
  } else if (CODE_A == 2) {
    //AND
    PSTRT = 2;
    PEN_And_Or = 1;
  } else if (CODE_A == 3) {
    //OR
    PSTRT = 2;
    PEN_And_Or = 0;
  } else if (CODE_A == 4) {
    //OUT
    PSTRT = 3;
  }

  if (CODE_B == 1) {
    //IN
    PEN_In = 1;
  } else if (CODE_B == 2) {
    //OUT
    PEN_Out = 1;
  } else if (CODE_B == 3) {
    //MEM
    PEN_Mem = 1;
  } else if (CODE_B == 4) {
    //TM
    PEN_Timer = 1;
  } else if (CODE_B == 5) {
    //CT
    PEN_Counter = 1;
  } else if (CODE_B == 6) {
    //CR
    PEN_Counter_R = 1;
  } else if (CODE_B == 7) {
    //EG
    PEN_Edge = 1;
  }

  Cell(PSTRT, PEN_In, PEN_Out, PEN_Mem, PEN_Timer, PEN_Counter, PEN_Counter_R, PEN_Edge, PEN_And_Or, PVALUE, PADR, PCELL_IN, PCELL_ADR);

}

void Cell(byte STRT, bool EN_In, bool EN_Out, bool EN_Mem, bool EN_Timer, bool EN_Counter, bool EN_Counter_R, bool EN_Edge, bool EN_And_Or, byte VALUE, byte ADR, bool CELL_IN, byte CELL_ADR) {

  bool SEL_OUT = 0, SEL_AND = 0, SEL_OR = 0, SEL_NOT = 0;

  if (STRT == 1) {

    //START
    SEL_OUT = (In[ADR] and EN_In) or (Out[ADR] and EN_Out) or (Mem[ADR] and EN_Mem) or (Timer_Out[ADR] and EN_Timer) or (Counter_Out[ADR] and EN_Counter) or (Edge_Out[ADR] and EN_Edge);

    if (VALUE == 0) {

      Cell_Mem[CELL_ADR] = SEL_OUT;

    } else if (VALUE == 1) {

      Cell_Mem[CELL_ADR] = !SEL_OUT;
    }

  } else if (STRT == 2) {

    //LOGIC OPERTOR AND - OR
    SEL_OUT = (In[ADR] and EN_In) or (Out[ADR] and EN_Out) or (Mem[ADR] and EN_Mem) or (Timer_Out[ADR] and EN_Timer) or (Counter_Out[ADR] and EN_Counter) or (Edge_Out[ADR] and EN_Edge);

    if (VALUE == 0) {

      SEL_NOT = SEL_OUT;

    } else if (VALUE == 1) {

      SEL_NOT = !SEL_OUT;
    }

    SEL_AND = (SEL_NOT and CELL_IN);
    SEL_OR = (SEL_NOT or CELL_IN);

    Cell_Mem[CELL_ADR] = ((SEL_AND and EN_And_Or) or (SEL_OR and !EN_And_Or));

  } else if (STRT == 3) {

    //OUTPUT LOGIC
    if (EN_Out == 1) {
      Out[ADR] = CELL_IN;
    }

    if (EN_Mem == 1) {
      Mem[ADR] = CELL_IN;
    }

    if (EN_Timer == 1) {
      Timer(CELL_IN, VALUE, ADR);
    }

    if (EN_Counter == 1) {
      Counter(CELL_IN, VALUE, ADR);
    }

    if (EN_Counter_R == 1) {
      Counter_Reset(CELL_IN, ADR);
    }

    if (EN_Edge == 1) {
      Edge(CELL_IN, VALUE, ADR);
    }

    Cell_Mem[CELL_ADR] = CELL_IN;
  }
}

void Timer(bool SET, byte VALUE, byte ADR) {

  if (SET == 1) {

    if (Timer_Data[ADR] < VALUE * 10) {
      Timer_Data[ADR]++;
    } else {
      Timer_Out[ADR] = 1;
    }

  } else {

    Timer_Out[ADR] = 0;
    Timer_Data[ADR] = 0;
  }
}

void Counter(bool SET, byte VALUE, byte ADR) {

  if (SET != Counter_Mem[ADR]) {

    if (SET == 1) {

      if (Counter_Data[ADR] < VALUE) {
        Counter_Data[ADR]++;
      }

      if (Counter_Data[ADR] >= VALUE) {
        Counter_Out[ADR] = 1;
      }
    }

    Counter_Mem[ADR] = SET;
  }
}

void Counter_Reset(bool RESET, byte ADR) {

  if (RESET == 1) {
    Counter_Out[ADR] = 0;
    Counter_Data[ADR] = 0;
  }
}

void Edge(bool IN_EDGE, int FUC, byte ADR) {

  bool Rising_Edge = 0, Falling_Edge = 0;

  if (FUC == 0 or FUC == 0) {
    Rising_Edge = 1;
    Falling_Edge = 0;
  } else if (FUC == 1 or FUC == 1) {
    Rising_Edge = 0;
    Falling_Edge = 1;
  } else if (FUC == 2 or FUC == 2) {
    Rising_Edge = 1;
    Falling_Edge = 1;
  }

  Edge_Out[ADR] = (IN_EDGE and !Edge_Mem[ADR] and Rising_Edge) or (!IN_EDGE and Edge_Mem[ADR] and Falling_Edge);
  Edge_Mem[ADR] = IN_EDGE;

  return Edge_Out;
}

//Lettura su EEPROM (ESTERNA)
byte EEPROM_Read(int ADR) {

  byte rData = 0xFF;

  Wire.beginTransmission(EEPROM_I2C_ADDRESS);

  Wire.write((int)(ADR >> 8));    // MSB
  Wire.write((int)(ADR & 0xFF));  // LSB

  Wire.endTransmission();

  Wire.requestFrom(EEPROM_I2C_ADDRESS, 1);

  rData = Wire.read();

  return rData;
}

//Scrittura su EEPROM (ESTERNA)
void EEPROM_Write(byte DATA[], byte DATA_ADR, int ADR) {

  Wire.beginTransmission(EEPROM_I2C_ADDRESS);

  Wire.write((int)(ADR >> 8));    // MSB
  Wire.write((int)(ADR & 0xFF));  // LSB

  for (byte i = 0; i < DATA_ADR; i++) {
    Wire.write(DATA[i]);
  }
  
  Wire.endTransmission();

  delay(10);

}

void Read_Input() {

  for (byte i = 0; i < Num_In; i++) {
    In[i] = digitalRead(Pin_In[i]);
  }
}

void Write_Output() {

  for (byte i = 0; i < Num_Out; i++) {
    digitalWrite(Pin_Out[i], Out[i]);
  }
}

File A V3:

#include <EEPROM.h>

byte Pin_In[] = { 2, 3, 4, 5, 6, 7, 8, 9 };
byte Pin_Out[] = { 11, 12, A0, A1, A2, A3, A4, A5 };
#define Debug_Led 13

bool In[8], Out[8];

#define Num_Mem 32
#define Num_Timer 32
#define Num_Counter 16
#define Num_Edge 32

bool Mem[Num_Mem];

bool Timer_Out[Num_Timer];
int Timer_Data[Num_Timer];

bool Counter_Out[Num_Counter], Counter_Mem[Num_Counter];
byte Counter_Data[Num_Counter];

bool Edge_Out[Num_Edge], Edge_Mem[Num_Edge];

#define Num_Cell 100
bool Cell_Mem[Num_Cell];

//DATA_DTA
// 1 ST, 2 AND, 3 OR, 4 OUT

//DATA_DTB
// 1 IN, 2 OUT, 3 MEM, 4 TM, 5 CT, 6 CR, 7 EG

//NOT (VALUE)
// 0 BUF, 1 NOT

byte DATA_DTA[Num_Cell];
byte DATA_DTB[Num_Cell];
byte DATA_ADR[Num_Cell];
byte DATA_VAL[Num_Cell];

String Message;
int Message_Int;
byte MCell_ADR, Selector;

#define Counter_Led_Value 20
int Counter_Led;

void setup() {

  delay(10);

  for (byte i = 0; i < 8; i++) {
    pinMode(Pin_In[i], INPUT);
    pinMode(Pin_Out[i], OUTPUT);
  }

  pinMode(Debug_Led, OUTPUT);

  //Wire.begin();
  Serial.begin(115200);

  for (byte i = 0; i < Num_Cell; i++) {
    DATA_DTA[i] = EEPROM.read(i);
    DATA_DTB[i] = EEPROM.read(i + Num_Cell);
    DATA_ADR[i] = EEPROM.read(i + (Num_Cell * 2));
    DATA_VAL[i] = EEPROM.read(i + (Num_Cell * 3));
  }

  delay(100);
}

void loop() {

  delay(1);

  Read_Input();

  if (Serial.available() > 0) {

    while (Serial.available() > 0) {

      Message = Serial.readStringUntil('x');

      Message_Int = Message.toInt();

      //Serial.print(Message_Int);

      if (Selector == 1) {
        DATA_DTA[MCell_ADR] = Message_Int;
        //Serial.print("DATA A -> ");
        //Serial.println(DATA_DTA[MCell_ADR]);
        Selector = 0;
      } else if (Selector == 2) {
        DATA_DTB[MCell_ADR] = Message_Int;
        //Serial.print("DATA B -> ");
        //Serial.println(DATA_DTB[MCell_ADR]);
        Selector = 0;
      } else if (Selector == 3) {
        DATA_ADR[MCell_ADR] = Message_Int;
        //Serial.print("DATA A -> ");
        //Serial.println(DATA_ADR[MCell_ADR]);
        Selector = 0;
      } else if (Selector == 4) {
        DATA_VAL[MCell_ADR] = Message_Int;
        //Serial.print("DATA A -> ");
        //Serial.println(DATA_VAL[MCell_ADR]);
        Selector = 0;
      } else if (Selector == 5) {
        MCell_ADR = Message_Int;
        //Serial.print("CELL -> ");
        //Serial.println(MCell_ADR);
        Selector = 0;
      }

      if (Selector == 6) {
        //ST
        DATA_DTA[MCell_ADR] = 1;
        Selector = 0;
      } else if (Selector == 7) {
        //AND
        DATA_DTA[MCell_ADR] = 2;
        Selector = 0;
      } else if (Selector == 8) {
        //OR
        DATA_DTA[MCell_ADR] = 3;
        Selector = 0;
      } else if (Selector == 9) {
        //OUT
        DATA_DTA[MCell_ADR] = 4;
        Selector = 0;
      }

      if (Selector == 10) {
        //IN
        DATA_DTB[MCell_ADR] = 1;
        Selector = 0;
      } else if (Selector == 11) {
        //Q
        DATA_DTB[MCell_ADR] = 2;
        Selector = 0;
      } else if (Selector == 12) {
        //MEM
        DATA_DTB[MCell_ADR] = 3;
        Selector = 0;
      } else if (Selector == 13) {
        //TM
        DATA_DTB[MCell_ADR] = 4;
        Selector = 0;
      } else if (Selector == 14) {
        //CT
        DATA_DTB[MCell_ADR] = 5;
        Selector = 0;
      } else if (Selector == 15) {
        //CR
        DATA_DTB[MCell_ADR] = 6;
        Selector = 0;
      } else if (Selector == 16) {
        //ET
        DATA_DTB[MCell_ADR] = 7;
        Selector = 0;
      }

      if (Message == "DA") {
        Selector = 1;
      } else if (Message == "DB") {
        Selector = 2;
      } else if (Message == "AD") {
        Selector = 3;
      } else if (Message == "VA") {
        Selector = 4;
      } else if (Message == "CL") {
        Selector = 5;
      } else if (Message == "ST") {
        Selector = 6;
      } else if (Message == "AN") {
        Selector = 7;
      } else if (Message == "OR") {
        Selector = 8;
      } else if (Message == "OT") {
        Selector = 9;
      } else if (Message == "IN") {
        Selector = 10;
      } else if (Message == "QT") {
        Selector = 11;
      } else if (Message == "ME") {
        Selector = 12;
      } else if (Message == "TM") {
        Selector = 13;
      } else if (Message == "CT") {
        Selector = 14;
      } else if (Message == "CR") {
        Selector = 15;
      } else if (Message == "ET") {
        Selector = 16;
      }

      if (Message == "WRITE") {

        for (int i = 0; i < Num_Cell; i++) {
          EEPROM.write(i, DATA_DTA[i]);
          EEPROM.write(i + Num_Cell, DATA_DTB[i]);
          EEPROM.write(i + (Num_Cell * 2), DATA_ADR[i]);
          EEPROM.write(i + (Num_Cell * 3), DATA_VAL[i]);
        }

        Serial.println("ROM WRITE");

      } else if (Message == "CLEAR") {

        for (int i = 0 ; i < EEPROM.length() ; i++) {
          EEPROM.write(i, 0);
        }

        Serial.println("ROM CLEAR");

      }

    }

  }
  //   S  I  O  M  T  C  CR AN OR NT V  AD CI CADR
  //Cell(1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
  //Cell(3, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, Cell_Mem[0], 1);
  //Cell(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Cell_Mem[1], 2);
  //Cell(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Cell_Mem[2], 3);
  //Cell(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Cell_Mem[3], 4);
  //Cell(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, Cell_Mem[4], 5);

  //Cell_PRG(1, 1, 0, 0, 0, 0, 0);
  //Cell_PRG(4, 2, 0, 0, 0, Cell_Mem[0], 1);
  //Cell_PRG(0, 0, 0, 0, 0, Cell_Mem[1], 2);
  //Cell_PRG(0, 0, 0, 0, 0, Cell_Mem[2], 3);
  //Cell_PRG(0, 0, 0, 0, 0, Cell_Mem[3], 4);
  //Cell_PRG(0, 0, 0, 0, 0, Cell_Mem[4], 5);

  for (byte i = 0; i < Num_Cell; i++) {

    if (i < 1) {
      Cell_PRG(DATA_DTA[0], DATA_DTB[0], DATA_ADR[0], DATA_VAL[0], 0, 0);
    } else {
      Cell_PRG(DATA_DTA[i], DATA_DTB[i], DATA_ADR[i], DATA_VAL[i], Cell_Mem[i - 1], i);
    }
  }

  Write_Output();

  if (Counter_Led < Counter_Led_Value) {
    Counter_Led++;
  } else {
    Counter_Led = 0;
    digitalWrite(Debug_Led, !digitalRead(Debug_Led));
  }
}

File B V3 (Funzioni):

void Cell_PRG(byte CODE_A, byte CODE_B, byte PADR, byte PVALUE, bool PCELL_IN, byte PCELL_ADR) {

  bool PEN_In = 0, PEN_Out = 0, PEN_Mem = 0, PEN_Timer = 0, PEN_Counter = 0, PEN_Counter_R = 0, PEN_Edge = 0, PEN_And_Or = 0, PEN_Not_MM = 0;
  byte PSTRT = 0;

  if (CODE_A == 1) {
    //START
    PSTRT = 1;
  } else if (CODE_A == 2) {
    //AND
    PSTRT = 2;
    PEN_And_Or = 1;
  } else if (CODE_A == 3) {
    //OR
    PSTRT = 2;
    PEN_And_Or = 0;
  } else if (CODE_A == 4) {
    //OUT
    PSTRT = 3;
  }

  if (CODE_B == 1) {
    //IN
    PEN_In = 1;
  } else if (CODE_B == 2) {
    //OUT
    PEN_Out = 1;
  } else if (CODE_B == 3) {
    //MEM
    PEN_Mem = 1;
  } else if (CODE_B == 4) {
    //TM
    PEN_Timer = 1;
  } else if (CODE_B == 5) {
    //CT
    PEN_Counter = 1;
  } else if (CODE_B == 6) {
    //CR
    PEN_Counter_R = 1;
  } else if (CODE_B == 7) {
    //EG
    PEN_Edge = 1;
  }

  Cell(PSTRT, PEN_In, PEN_Out, PEN_Mem, PEN_Timer, PEN_Counter, PEN_Counter_R, PEN_Edge, PEN_And_Or, PVALUE, PADR, PCELL_IN, PCELL_ADR);

}

void Cell(byte STRT, bool EN_In, bool EN_Out, bool EN_Mem, bool EN_Timer, bool EN_Counter, bool EN_Counter_R, bool EN_Edge, bool EN_And_Or, byte VALUE, byte ADR, bool CELL_IN, byte CELL_ADR) {

  bool SEL_OUT = 0, SEL_AND = 0, SEL_OR = 0, SEL_NOT = 0;

  if (STRT == 1) {

    //START
    SEL_OUT = (In[ADR] and EN_In) or (Out[ADR] and EN_Out) or (Mem[ADR] and EN_Mem) or (Timer_Out[ADR] and EN_Timer) or (Counter_Out[ADR] and EN_Counter) or (Edge_Out[ADR] and EN_Edge);

    if (VALUE == 0) {

      Cell_Mem[CELL_ADR] = SEL_OUT;

    } else if (VALUE == 1) {

      Cell_Mem[CELL_ADR] = !SEL_OUT;
    }

  } else if (STRT == 2) {

    //LOGIC OPERTOR AND - OR
    SEL_OUT = (In[ADR] and EN_In) or (Out[ADR] and EN_Out) or (Mem[ADR] and EN_Mem) or (Timer_Out[ADR] and EN_Timer) or (Counter_Out[ADR] and EN_Counter) or (Edge_Out[ADR] and EN_Edge);

    if (VALUE == 0) {

      SEL_NOT = SEL_OUT;

    } else if (VALUE == 1) {

      SEL_NOT = !SEL_OUT;
    }

    SEL_AND = (SEL_NOT and CELL_IN);
    SEL_OR = (SEL_NOT or CELL_IN);

    Cell_Mem[CELL_ADR] = ((SEL_AND and EN_And_Or) or (SEL_OR and !EN_And_Or));

  } else if (STRT == 3) {

    //OUTPUT LOGIC
    if (EN_Out == 1) {
      Out[ADR] = CELL_IN;
    }

    if (EN_Mem == 1) {
      Mem[ADR] = CELL_IN;
    }

    if (EN_Timer == 1) {
      Timer(CELL_IN, VALUE, ADR);
    }

    if (EN_Counter == 1) {
      Counter(CELL_IN, VALUE, ADR);
    }

    if (EN_Counter_R == 1) {
      Counter_Reset(CELL_IN, ADR);
    }

    if (EN_Edge == 1) {
      Edge(CELL_IN, VALUE, ADR);
    }

    Cell_Mem[CELL_ADR] = CELL_IN;
  }
}

void Timer(bool SET, byte VALUE, byte ADR) {

  if (SET == 1) {

    if (Timer_Data[ADR] < VALUE * 10) {
      Timer_Data[ADR]++;
    } else {
      Timer_Out[ADR] = 1;
    }

  } else {

    Timer_Out[ADR] = 0;
    Timer_Data[ADR] = 0;
  }
}

void Counter(bool SET, byte VALUE, byte ADR) {

  if (SET != Counter_Mem[ADR]) {

    if (SET == 1) {

      if (Counter_Data[ADR] < VALUE) {
        Counter_Data[ADR]++;
      }

      if (Counter_Data[ADR] >= VALUE) {
        Counter_Out[ADR] = 1;
      }
    }

    Counter_Mem[ADR] = SET;
  }
}

void Counter_Reset(bool RESET, byte ADR) {

  if (RESET == 1) {
    Counter_Out[ADR] = 0;
    Counter_Data[ADR] = 0;
  }
}

void Edge(bool IN_EDGE, int FUC, byte ADR) {

  bool Rising_Edge = 0, Falling_Edge = 0;

  if (FUC == 0 or FUC == 0) {
    Rising_Edge = 1;
    Falling_Edge = 0;
  } else if (FUC == 1 or FUC == 1) {
    Rising_Edge = 0;
    Falling_Edge = 1;
  } else if (FUC == 2 or FUC == 2) {
    Rising_Edge = 1;
    Falling_Edge = 1;
  }

  Edge_Out[ADR] = (IN_EDGE and !Edge_Mem[ADR] and Rising_Edge) or (!IN_EDGE and Edge_Mem[ADR] and Falling_Edge);
  Edge_Mem[ADR] = IN_EDGE;

  return Edge_Out;
}

void Read_Input() {

  for (byte i = 0; i < 8; i++) {
    In[i] = digitalRead(Pin_In[i]);
  }
}

void Write_Output() {

  for (byte i = 0; i < 8; i++) {
    digitalWrite(Pin_Out[i], Out[i]);
  }
}
4

Buonasera e benvenuto nella sezione Italiana del forum,

cortesemente, come prima cosa, leggi attentamente il REGOLAMENTO di detta sezione, (... e, per evitare future possibili discussioni/incomprensioni, prestando molta attenzione al punto 15), dopo di che, come da suddetto regolamento (punto 16.7), fai la tua presentazione NELL'APPOSITA DISCUSSIONE spiegando bene quali esperienze hai in elettronica e programmazione, affinché noi possiamo conoscere la tua esperienza ed esprimerci con termini adeguati.

Grazie,

Guglielmo

P.S.: Ti ricordo che, purtroppo, fino a quando non sarà fatta la presentazione nell’apposita discussione, nel rispetto del succitato regolamento nessuno ti risponderà (eventuali risposte o tuoi ulteriori post, verrebbero temporaneamente nascosti), quindi ti consiglio di farla al più presto. :wink:

1 Like
5

Grazie della risposta, mi sono presentato adesso nella apposita sezione :smiley:

6

Guarda, io mi studierei come è fatta QUESTA libreria che gestisce, correttamente (la uso spesso) le 32 e le 64 K e seguirei la loro linea per non avere problemi :wink:

Guglielmo

1 Like
7

... non solo, prova a guardare QUESTA che dovrebbe gestire anche le 256 :wink:

Guglielmo

1 Like
8

Bene, provo ad implementarla.

Mi sono accordo che la lettura a pagina della eeprom esterna non funziona.

Questo è il programma di prova che gestisce la eeprom e funziona se scrivo un byte alla volta.
Ma non funziona se scrivo i byte uno dietro l'altro minori di 32 byte che è il massimo per la librerira Wire.

#include "Wire.h"
#define EEPROM_I2C_ADDRESS 0x50

//Mappa I/O
//byte pinIn[] = {2, 3, 4, 5, 6, 7, 8, 9};
//byte pinOut[] = {10, 11, 12, 13, A0, A1, A2, A3};

//Variabili Globali
#define Num_Dati 8
byte Dati[Num_Dati] = {23, 32, 44, 55, 89, 100, 101, 20};

#define Num_Cell 100
String Message;

byte DATA_DTA[Num_Cell];
byte DATA_DTB[Num_Cell];
byte DATA_DTC[Num_Cell];
byte DATA_DTD[Num_Cell];

#define Debug_Led 13
#define Counter_Led_Value 100
int Counter_Led;

void setup() {

  delay(100);

  //Setup Serial
  Wire.begin();
  Serial.begin(115200);

  //Setup I/O
  for (byte i = 0; i < 8; i++) {
    //pinMode(pinIn[i], INPUT);
    //pinMode(pinOut[i], OUTPUT);
  }

  pinMode(Debug_Led, OUTPUT);

  //Codice che setta ogni variabile dell' array a +1 con differenza di 1
  //in ogni variabile +1 +2 +3
  for (byte i = 0; i < Num_Cell; i++) {
    DATA_DTA[i] = i;
    DATA_DTB[i] = i + 1;
    DATA_DTC[i] = i + 2;
    DATA_DTD[i] = i + 3;
  }

  //Codice non funzionante (scrittura a pagina)

  //EEPROM_Write_Page(0, DATA_DTA, 30);
  //EEPROM_Write_Page(30, DATA_DTA, 30);
  //EEPROM_Write_Page(60, DATA_DTA, 30);
  //EEPROM_Write_Page(90, DATA_DTA, 30);


  //Codice funzionante (scrittura a byte singolo)
  for (byte i = 0; i < Num_Cell; i++) {
    //EEPROM_Write(DATA_DTA[i], i);
  }

  for (byte i = 0; i < Num_Cell; i++) {
    //EEPROM_Write(DATA_DTB[i], i + Num_Cell);
  }

  for (byte i = 0; i < Num_Cell; i++) {
    //EEPROM_Write(DATA_DTC[i], i + (Num_Cell * 2));
  }

  for (byte i = 0; i < Num_Cell; i++) {
    //EEPROM_Write(DATA_DTD[i], i + (Num_Cell * 3));
  }

  delay(100);

}


void loop() {

  delay(1);

  Leggi(400);

}

//FUNZIONI
//--------------------------------------------
void Leggi(int DATI) {

  for (int i = 0; i < DATI; i++) {
    Serial.print("DATO ");
    Serial.print(i);
    Serial.print(" > ");
    Serial.println(EEPROM_Read(i));
  }
  Serial.println("--------------------");

  delay(10000);

}

void Ciclo() {
  if (Counter_Led < Counter_Led_Value) {
    Counter_Led++;
  } else {
    Counter_Led = 0;
    digitalWrite(Debug_Led, !digitalRead(Debug_Led));
  }
}

//Lettura su EEPROM (ESTERNA)
byte EEPROM_Read(int ADR) {

  byte rData = 0xFF;

  Wire.beginTransmission(EEPROM_I2C_ADDRESS);

  Wire.write((int)(ADR >> 8));   // MSB
  Wire.write((int)(ADR & 0xFF)); // LSB

  Wire.endTransmission();

  Wire.requestFrom(EEPROM_I2C_ADDRESS, 1);

  rData =  Wire.read();
  return rData;
}

//Scrittura singolo Byte su EEPROM (ESTERNA)
void EEPROM_Write(byte DATA, int ADR) {

  Wire.beginTransmission(EEPROM_I2C_ADDRESS);

  Wire.write((int)(ADR >> 8));   // MSB
  Wire.write((int)(ADR & 0xFF)); // LSB

  Wire.write(DATA);

  Wire.endTransmission();

  delay(5);
}

/*
    WARNING: address is a page address, 6-bit end will wrap around
    also, data can be maximum of about 30 bytes,
    because the Wire library has a buffer of 32 bytes
*/

//Scrittura della pagina su EEPROM (ESTERNA)
//Codice baggato :(
void EEPROM_Write_Page(unsigned int ADR, byte* DATA, byte LENGHT) {

  Wire.beginTransmission(EEPROM_I2C_ADDRESS);

  Wire.write((int)(ADR >> 8));   // MSB
  Wire.write((int)(ADR & 0xFF)); // LSB

  byte c;

  for ( c = 0; c < LENGHT; c++) {
    Wire.write(DATA[c]);
  }

  Wire.endTransmission();

  delay(10);
}
9

io uso eeprom 24lc256 e 24lc512 quindi devo trovare una libreria che me le gestisca...

ho letto in altri post che è un po' inutile usare librerie per le eeprom i2c poichè il codice nativo è abbastanza semplice come quello che ho implementato nel mio progetto...

intanto provo a vedere quello che mi hai mandato tu... ma vorrei capire anche, se possibile, come farlo a livello nativo...

10

La seconda che ti ho indicato dovrebbe gestirle ... :roll_eyes:

... cioè reinventare l'acqua calda? ... perché le libreria Arduino altro non sono che ciò che potresti scrivere TU messo in una o più funzioni ... il tutto ottimizzato da compilatore e linker.
Comunque, basta studiarsi la libreria e vedere le chiamate che fa ...

Guglielmo

1 Like
11

Allora ho provato ora la libreria che gestisce le EEPROM che uso ma ci sono dei problemi

praticamente se stacco la eeprom i2c lui mi legge sempre i valori... com'è possibile?
e non dovrebbe... :frowning:

ho provato a leggere le chiamate che fa e ho creato questo codice di esempio perchè sugli esempi non c'è nulla su read e write...

#include <I2C_eeprom.h>

I2C_eeprom EE24LC(0x50, I2C_DEVICESIZE_24LC256);

void setup() {

  delay(10);
  
  Wire.begin();
  Serial.begin(115200);

  EE24LC.begin();

  delay(100);

  //EE24LC.writeByte(5, 120);

  delay(100);
}

void loop() {

  Serial.println(EE24LC.readByte(5));

  delay(1000);
  

}
12

La libreria è piena di esempi d'uso ... se li segui e ti studi i sorgenti della libreria vedi che vengono controllate varie condizioni e che ciascun metodo della libreria ritorna un valore che va controllato.

Buono studio e buon divertimento.

Guglielmo

13

Si ho capito gli sto leggendo ora ma sembra che non legga ne scrive sulla eeprom esterna... :frowning:

come ho detto mi sta leggendo valori che non risiedono sulla eeprom...

con il codice nativo funziona, infatti, leggo i valori vecchi prima che caricassi lo schizzo di esempio della libreria che mi hai consigliato.

Adesso provo e vedo se ho sbagliato qualcosa...

Qualcuno che ha già usato questa libreria ? (Parlo per tutti che leggono questo post)

14

Ciao Samuele
proprio in questi giorni sto utilizzando una 24LC256 e utilizzo questa libreria

mi trovo benissimo e non fallisce in bit, ho fatto diverse prove
di scrittura e di lettura di tutta la eeprom e non ho avuto alcun problema.
Provala e' anche molto leggera

15

Grazie dell'aiuto proverò a leggerla...

Adesso ho fatto varie prove e leggendo il datasheet della eeprom ho scoperto come far funzionare COL CODICE NATIVO la scrittura a pagina che è quello che voglio :smiley:

Praticamente l'errore in cui si inceppa è il ring loop della memoria: se scrivi più di 64 bytes al colpo succede che i bytes restanti vengono riscritti all'inizio della pagina e fa pasticci.

Quindi bisogna fare dei calcoli per far si che quando si raggiunge la 64esima cella (0 a 63) bisogna incrementare l'indirizzo master di tot celle quindi da 64 in poi ecc ecc

Visto che nel progetto corrente devo scrivere 4 variabili da array da 100 bytes ciascuna devo concatenarli sapendo che il massimo per pagina è di 64 bytes quindi devo dividere il tutto mettendo i primi 64 bytes dei 100 sulla prima pagina i rimanenti sulla seconda e poi via con gli altri 100 bytes che saranno sfalsati ovviamente...

è un processo che dovrei fare in automatico con una funzione che non ho ancora fatto ma allego il codice che funziona fatto con i calcoli a mano che scrive 300 bytes totali divisi in blocchi da 100 per variabile mandati in mandate da 20 bytes perchè il buffer della Wire è di massimo 32 bytes quindi mi sono tenuto basso.

Quindi così facendo vengono effetuate delle scritture ogni 20 byte più il resto per raggiungere il massimo limite per pagina (64 bytes).

#include "Wire.h"
#define EEPROM_I2C_ADDRESS 0x50

//Mappa I/O
//byte pinIn[] = {2, 3, 4, 5, 6, 7, 8, 9};
//byte pinOut[] = {10, 11, 12, 13, A0, A1, A2, A3};

//Variabili Globali
#define Num_Dati 8
byte Dati[Num_Dati] = {23, 32, 44, 55, 89, 100, 101, 20};

#define Num_Cell 100
String Message;

byte DATA_DTA[Num_Cell];
byte DATA_DTB[Num_Cell];
byte DATA_DTC[Num_Cell];
byte DATA_DTD[Num_Cell];

#define Debug_Led 13
#define Counter_Led_Value 100
int Counter_Led;

void setup() {

  delay(100);

  //Setup Serial
  Wire.begin();
  Serial.begin(115200);

  //Setup I/O
  for (byte i = 0; i < 8; i++) {
    //pinMode(pinIn[i], INPUT);
    //pinMode(pinOut[i], OUTPUT);
  }

  pinMode(Debug_Led, OUTPUT);

  //Codice che setta ogni variabile dell' array a +1 con differenza di 1
  //in ogni variabile +1 +2 +3
  for (byte i = 0; i < Num_Cell; i++) {
    DATA_DTA[i] = i;
    DATA_DTB[i] = i;
    DATA_DTC[i] = i;
    DATA_DTD[i] = i;
  }

  //Codice funzionante (scrittura a pagina)
  //Da tenere in considerazione che le pagine della eeprom sono
  //formate da 64 bytes di dati che vengono divisi in blocchi da 20 bytes
  //per via del buffer seriale della librerira Wire (32 bytes max)
  //La somma del parametro della lunghezza dei bytes scritti deve sempre essere
  //uguale a 64 bytes; se si supera tale valore c'è un wrap della scrittura dei bytes
  //dove vengono riscritti, quelli rimanenti, dall'inizio della pagina selezionata.

  //Scrittura di 300 bytes divisi in array da 100 in pagine da 64 bytes
  
  //EEPROM_Write_Page(DATA_DTA, 0, 20, 0);
  //EEPROM_Write_Page(DATA_DTA, 20, 20, 20);
  //EEPROM_Write_Page(DATA_DTA, 40, 20, 40);
  //EEPROM_Write_Page(DATA_DTA, 60, 4, 60);

  //EEPROM_Write_Page(DATA_DTA, 64, 16, 64);
  //EEPROM_Write_Page(DATA_DTA, 80, 20, 80);
  //EEPROM_Write_Page(DATA_DTB, 0, 20, 100);
  //EEPROM_Write_Page(DATA_DTB, 20, 8, 120);

  //EEPROM_Write_Page(DATA_DTB, 28, 20, 128);
  //EEPROM_Write_Page(DATA_DTB, 48, 20, 148);
  //EEPROM_Write_Page(DATA_DTB, 68, 20, 168);
  //EEPROM_Write_Page(DATA_DTB, 88, 4, 188);

  //EEPROM_Write_Page(DATA_DTB, 92, 8, 192);
  //EEPROM_Write_Page(DATA_DTC, 0, 20, 200);
  //EEPROM_Write_Page(DATA_DTC, 20, 20, 220);
  //EEPROM_Write_Page(DATA_DTC, 40, 16, 240);

  //EEPROM_Write_Page(DATA_DTC, 56, 20, 256);
  //EEPROM_Write_Page(DATA_DTC, 76, 20, 276);
  //EEPROM_Write_Page(DATA_DTC, 96, 4, 296);

  //Codice funzionante (scrittura a byte singolo)
  for (byte i = 0; i < Num_Cell; i++) {
    //EEPROM_Write(DATA_DTA[i], i);
  }

  for (byte i = 0; i < Num_Cell; i++) {
    //EEPROM_Write(DATA_DTB[i], i + Num_Cell);
  }

  for (byte i = 0; i < Num_Cell; i++) {
    //EEPROM_Write(DATA_DTC[i], i + (Num_Cell * 2));
  }

  for (byte i = 0; i < Num_Cell; i++) {
    //EEPROM_Write(DATA_DTD[i], i + (Num_Cell * 3));
  }

  delay(100);

}


void loop() {

  delay(1);

  Leggi(200 , 300);

}

//FUNZIONI
//--------------------------------------------
void Leggi(int STR, int DATI) {

  for (int i = STR; i < DATI; i++) {
    Serial.print("DATO ");
    Serial.print(i);
    Serial.print(" > ");
    Serial.println(EEPROM_Read(i));
  }
  Serial.println("--------------------");

  delay(10000);

}

void Ciclo() {
  if (Counter_Led < Counter_Led_Value) {
    Counter_Led++;
  } else {
    Counter_Led = 0;
    digitalWrite(Debug_Led, !digitalRead(Debug_Led));
  }
}

//Lettura su EEPROM (ESTERNA)
byte EEPROM_Read(int ADR) {

  byte rData = 0xFF;

  Wire.beginTransmission(EEPROM_I2C_ADDRESS);

  Wire.write((int)(ADR >> 8));   // MSB
  Wire.write((int)(ADR & 0xFF)); // LSB

  Wire.endTransmission();

  Wire.requestFrom(EEPROM_I2C_ADDRESS, 1);

  rData =  Wire.read();
  return rData;
}

//Scrittura singolo Byte su EEPROM (ESTERNA)
void EEPROM_Write(byte DATA, int ADR) {

  Wire.beginTransmission(EEPROM_I2C_ADDRESS);

  Wire.write((int)(ADR >> 8));   // MSB
  Wire.write((int)(ADR & 0xFF)); // LSB

  Wire.write(DATA);

  Wire.endTransmission();

  delay(5);
}

/*
    WARNING: address is a page address, 6-bit end will wrap around
    also, data can be maximum of about 30 bytes,
    because the Wire library has a buffer of 32 bytes
*/

//Scrittura della pagina su EEPROM (ESTERNA)
void EEPROM_Write_Page(byte DATA[], byte OFFSET, byte LENGHT, unsigned int ADR) {

  Wire.beginTransmission(EEPROM_I2C_ADDRESS);

  Wire.write((int)(ADR >> 8));   // MSB
  Wire.write((int)(ADR & 0xFF)); // LSB

  for (byte i = 0; i < LENGHT; i++) {
    Wire.write(DATA[i + OFFSET]);
  }

  Wire.endTransmission();

  delay(10);
}
16

ciao,
di solito io scrivo sulla eeprom un byte alla volta, memorizzo l'indirizzo di partenza e poi scrivo i dati sempre nella stessa sequenza, in piu' scrivendo un byte alla volta puoi fare il confronto col byte gia' scritto, lo riscrivi solo se ' cambiato. potresti memorizzare lo start address nell'ultimo elemento dell'array, fai una semplice funzione che inizia a scrivere leggendo l'array, puoi lasciare uno spazio tra un'array e l'altro in modo che se dovessi aggiungere elementi ti rimane lo spazio disponibile.

1 Like
17

This topic was automatically closed 180 days after the last reply. New replies are no longer allowed.