Eeprom__rd_buffer_size buffer_length

Products & Technology XIAO
#1

Hello Everyone,
I’m trying to load a sketch that works fine on a nano, that writes an EEprom memory.
But I get this error:

C:\Users\focam\Documents\Arduino\libraries\Eeprom24C01_02-master\Eeprom24C01_02.cpp: In member function 'void Eeprom24C01_02::readBytes(byte, byte, byte*)':
C:\Users\focam\Documents\Arduino\libraries\Eeprom24C01_02-master\Eeprom24C01_02.cpp:52:35: error: 'BUFFER_LENGTH' was not declared in this scope
 #define EEPROM__RD_BUFFER_SIZE    BUFFER_LENGTH
                                   ^
C:\Users\focam\Documents\Arduino\libraries\Eeprom24C01_02-master\Eeprom24C01_02.cpp:219:33: note: in expansion of macro 'EEPROM__RD_BUFFER_SIZE'
     byte bufferCount = length / EEPROM__RD_BUFFER_SIZE;
                                 ^~~~~~~~~~~~~~~~~~~~~~
C:\Users\focam\Documents\Arduino\libraries\Eeprom24C01_02-master\Eeprom24C01_02.cpp:52:35: note: suggested alternative: 'REG_DSU_LENGTH'
 #define EEPROM__RD_BUFFER_SIZE    BUFFER_LENGTH
                                   ^
C:\Users\focam\Documents\Arduino\libraries\Eeprom24C01_02-master\Eeprom24C01_02.cpp:219:33: note: in expansion of macro 'EEPROM__RD_BUFFER_SIZE'
     byte bufferCount = length / EEPROM__RD_BUFFER_SIZE;
                                 ^~~~~~~~~~~~~~~~~~~~~~
C:\Users\focam\Documents\Arduino\libraries\Eeprom24C01_02-master\Eeprom24C01_02.cpp: In member function 'void Eeprom24C01_02::writePage(byte, byte, byte*)':
C:\Users\focam\Documents\Arduino\libraries\Eeprom24C01_02-master\Eeprom24C01_02.cpp:59:36: error: 'BUFFER_LENGTH' was not declared in this scope
 #define EEPROM__WR_BUFFER_SIZE    (BUFFER_LENGTH - 1)
                                    ^
C:\Users\focam\Documents\Arduino\libraries\Eeprom24C01_02-master\Eeprom24C01_02.cpp:255:33: note: in expansion of macro 'EEPROM__WR_BUFFER_SIZE'
     byte bufferCount = length / EEPROM__WR_BUFFER_SIZE;
                                 ^~~~~~~~~~~~~~~~~~~~~~
C:\Users\focam\Documents\Arduino\libraries\Eeprom24C01_02-master\Eeprom24C01_02.cpp:59:36: note: suggested alternative: 'REG_DSU_LENGTH'
 #define EEPROM__WR_BUFFER_SIZE    (BUFFER_LENGTH - 1)
                                    ^
C:\Users\focam\Documents\Arduino\libraries\Eeprom24C01_02-master\Eeprom24C01_02.cpp:255:33: note: in expansion of macro 'EEPROM__WR_BUFFER_SIZE'
     byte bufferCount = length / EEPROM__WR_BUFFER_SIZE;
                                 ^~~~~~~~~~~~~~~~~~~~~~
exit status 1
Errore durante la compilazione per la scheda Seeeduino XIAO.

Can anyone help me?

#2

The error message is clearer and indicates that the BUFFER_LENGTH variable is not defined.

#3

DO I have to declare it on Library or on code?

#4

That library assumes that BUFFER_LENGTH has been #defined in Wire.h, which works for avr boards like the nano.
However…
The software tools developers for the Seeed XIAO boards did not define such a thing.

Next-to-bottom line: There is no way to define BUFFER_LENGTH in your sketch in a way that these library functions can compile.

You could try putting something like the following in the library file Eeprom24C01_02.h

 #define BUFFER_LENGTH 32

But, personally, I wouldn’t do this.

I would use Arduino’s Library Manager to install a more flexible library such as Rob Tillart’s excellent I2C_EEPROM library.

Bottom line: I have used this library for large and small I2C devices with a number of different CPUs (XIAO and oodles of other devices).

Regards,

Dave

I2C_EEPROM
I2C_EEPROM810×451 11.2 KB

#5

But using a new library implies to completely change the code, or not?

#6

Well, adding the string into the library worked, but now I’m getting this error:

processing.app.debug.RunnerException
	at cc.arduino.packages.uploaders.SerialUploader.uploadUsingPreferences(SerialUploader.java:152)
	at cc.arduino.UploaderUtils.upload(UploaderUtils.java:77)
	at processing.app.SketchController.upload(SketchController.java:732)
	at processing.app.SketchController.exportApplet(SketchController.java:703)
	at processing.app.Editor$UploadHandler.run(Editor.java:2061)
	at java.lang.Thread.run(Thread.java:748)
Caused by: processing.app.SerialException: Errore durante l'esecuzione del comando touch sulla porta seriale 'COM12'
	at processing.app.Serial.touchForCDCReset(Serial.java:107)
	at cc.arduino.packages.uploaders.SerialUploader.uploadUsingPreferences(SerialUploader.java:136)
	... 5 more
Caused by: jssc.SerialPortException: Port name - COM12; Method name - openPort(); Exception type - Port busy.
	at jssc.SerialPort.openPort(SerialPort.java:164)
	at processing.app.Serial.touchForCDCReset(Serial.java:101)
	... 6 more
#7

Note that I did not actually recommend adding that definition to the existing library. I meant to imply that it might be worth a try, but I personally would not and did not test it.

Since I have no idea what your code is, I can’t know what might need to be changed.

I know that I can read and write small and large I2C EEPROM devices using the library I suggested. I have used this library for a number of different CPUs, including the Seeed XIAO, which is the subject of this sub-forum.

Regards,

Dave

#8

Definitely gonna try!

In case you’d like to see here’s the code

#include <Wire.h>
#include <serialEEPROM.h>
#include <Eeprom24C01_02.h>
#define EEPROM_ADDRESS  0x50
#include "ClickButton.h"


//const byte btnPinV = 5;
//const byte btnPinS = 6;
const byte btnPinTS = 7;
const byte ledPin = 13; //13 su arduino nano originale
int LEDfunction = 0;
int LEDfunction2 = 0;

//ClickButton button1(btnPinS, LOW, CLICKBTN_PULLUP);
ClickButton button12(btnPinTS, LOW, CLICKBTN_PULLUP);

static Eeprom24C01_02 eeprom(EEPROM_ADDRESS);
    byte address = 0;
    
    byte add0 = 0; 
    byte add1 = 1;
    byte add2 = 2;
    byte add3 = 3;
    byte add4 = 4;
    byte add5 = 5;
    byte add6 = 6;
    byte add7 = 7;
    byte add8 = 8;
    byte add9 = 9;
    byte add10 = 10;
    byte add11 = 11;
    byte add12 = 12;
    byte add13 = 13;
    byte add14 = 14;
    byte add15 = 15;
    byte add16 = 16;
    byte add17 = 17;
    byte add18 = 18;
    byte add19 = 19;
    byte add20 = 20;
    byte add21 = 21;
    byte add22 = 22;
    byte add23 = 23;
    byte add24 = 24;
    byte add25 = 25;
    byte add26 = 26;
    byte add27 = 27;
    byte add28 = 28;
    byte add29 = 29;
    byte add30 = 30;
    byte add31 = 31;
    byte add32 = 32;
    byte add33 = 33;
    byte add34 = 34;
    byte add35 = 35;
    byte add36 = 36;
    byte add37 = 37;
    byte add38 = 38;
    byte add39 = 39;
    byte add40 = 40;
    byte add41 = 41;
    byte add42 = 42;
    byte add43 = 43;
    byte add44 = 44;
    byte add45 = 45;
    byte add46 = 46;
    byte add47 = 47;
    byte add48 = 48;
    byte add49 = 49;
    byte add50 = 50;
    byte add51 = 51;
    byte add52 = 52;
    byte add53 = 53;
    byte add54 = 54;
    byte add55 = 55;
    byte add56 = 56;
    byte add57 = 57;
    byte add58 = 58;
    byte add59 = 59;
    byte add60 = 60;
    byte add61 = 61;
    byte add62 = 62;
    byte add63 = 63;
    byte add64 = 64;
    byte add65 = 65;
    byte add66 = 66;
    byte add67 = 67;
    byte add68 = 68;
    byte add69 = 69;
    byte add70 = 70;
    byte add71 = 71;
    byte add72 = 72;
    byte add73 = 73;
    byte add74 = 74;
    byte add75 = 75;
    byte add76 = 76;
    byte add77 = 77;
    byte add78 = 78;
    byte add79 = 79;
    byte add80 = 80;
    byte add81 = 81;
    byte add82 = 82;
    byte add83 = 83;
    byte add84 = 84;
    byte add85 = 85;
    byte add86 = 86;
    byte add87 = 87;
    byte add88 = 88;
    byte add89 = 89;
    byte add90 = 90;
    byte add91 = 91;
    byte add92 = 92;
    byte add93 = 93;
    byte add94 = 94;
    byte add95 = 95;

byte add128 = 128;
byte add129 = 129;
byte add130 = 130;
byte add131 = 131;
byte add132 = 132;
byte add133 = 133;
byte add134 = 134;
byte add135 = 135;
byte add136 = 136;
byte add137 = 137;
byte add138 = 138;
byte add139 = 139;
byte add140 = 140;
byte add141 = 141;
byte add142 = 142;
byte add143 = 143;
byte add144 = 144;
byte add145 = 145;
byte add146 = 146;
byte add147 = 147;
byte add148 = 148;
byte add149 = 149;
byte add150 = 150;
byte add151 = 151;
byte add152 = 152;
byte add153 = 153;
byte add154 = 154;
byte add155 = 155;
byte add156 = 156;
byte add157 = 157;
byte add158 = 158;
byte add159 = 159;
byte add160 = 160;
byte add161 = 161;
byte add162 = 162;
byte add163 = 163;
byte add164 = 164;
byte add165 = 165;
byte add166 = 166;
byte add167 = 167;
byte add168 = 168;
byte add169 = 169;
byte add170 = 170;
byte add171 = 171;
byte add172 = 172;
byte add173 = 173;
byte add174 = 174;
byte add175 = 175;
byte add176 = 176;
byte add177 = 177;
byte add178 = 178;
byte add179 = 179;
byte add180 = 180;
byte add181 = 181;
byte add182 = 182;
byte add183 = 183;
byte add184 = 184;
byte add185 = 185;
byte add186 = 186;
byte add187 = 187;
byte add188 = 188;
byte add189 = 189;
byte add190 = 190;
byte add191 = 191;
byte add192 = 192;
byte add193 = 193;
byte add194 = 194;
byte add195 = 195;
byte add196 = 196;
byte add197 = 197;
byte add198 = 198;
byte add199 = 199;
byte add200 = 200;
byte add201 = 201;
byte add202 = 202;
byte add203 = 203;
byte add204 = 204;
byte add205 = 205;
byte add206 = 206;
byte add207 = 207;
byte add208 = 208;
byte add209 = 209;
byte add210 = 210;
byte add211 = 211;
byte add212 = 212;
byte add213 = 213;
byte add214 = 214;
byte add215 = 215;
byte add216 = 216;
byte add217 = 217;
byte add218 = 218;
byte add219 = 219;
byte add220 = 220;
byte add221 = 221;
byte add222 = 222;
byte add223 = 223;


//int buttonStateS = digitalRead(btnPinS);
//int buttonStateV = digitalRead(btnPinV);
int buttonStateTS = digitalRead(btnPinTS);

void setup()
{
    // Initialize serial communication.
    Serial.begin(9600);
    

   // pinMode(btnPinV, INPUT);
  //  pinMode(btnPinS, INPUT);
    pinMode(btnPinTS, INPUT);
  // Enable internal pull-up resistor.
 // digitalWrite(btnPinV, HIGH);
  //digitalWrite(btnPinS, HIGH);
  digitalWrite(btnPinTS, HIGH);
  pinMode(ledPin, OUTPUT);
        
    // Initialize EEPROM library.
    eeprom.initialize();

//  button1.debounceTime   = 20;   // Debounce timer in ms
//  button1.multiclickTime = 250;  // Time limit for multi clicks
//  button1.longClickTime  = 1000; // time until "held-down clicks" register

  button12.debounceTime   = 20;   // Debounce timer in ms
  button12.multiclickTime = 250;  // Time limit for multi clicks
  button12.longClickTime  = 1000; // time until "held-down clicks" register

}

void loop()
{
//  button1.Update();
  button12.Update();
 /* if (button1.clicks != 0){ 
    LEDfunction = button1.clicks;
  }*/
  if (button12.clicks != 0){ 
    LEDfunction2 = button12.clicks;
  }
 /*if (digitalRead(btnPinV) == LOW) {
   int buttonState = digitalRead(btnPinV); 
      // Wrlnite a byte at address 0 in EEPROM memory.
    Serial.println("Scrivo codice vergine");

 
    
 }

 
if(button1.clicks == 1){

    Serial.println("Carico 3.5€ ");
    eeprom.writeByte(add68, 0x81);
    delay(50);
    eeprom.writeByte(add69, 0x81);
    delay(50);
    eeprom.writeByte(add70, 0x43);
    delay(50);
    eeprom.writeByte(add71, 0xC6);
    delay(50);
    eeprom.writeByte(add84, 0x81);
    delay(50);
    eeprom.writeByte(add85, 0x41);
    delay(50);
    eeprom.writeByte(add86, 0x43);
    delay(50);
    eeprom.writeByte(add87, 0xC6);
    delay(50);
      digitalWrite(ledPin,HIGH);
      delay(300);
      digitalWrite(ledPin,LOW);  
      delay(100);   
      LEDfunction = 0;

    }
    

if(LEDfunction == 2){
   
    }

if(LEDfunction == 3){
   

    }*/
 
 
 if(button12.clicks == 1){

    Serial.println("Scrivo vergine");
    eeprom.writeByte(add0, 0xDE);
    delay(50);
    eeprom.writeByte(add1, 0x08);
    delay(50);
    eeprom.writeByte(add2, 0x35);
    delay(50);
    eeprom.writeByte(add3, 0x89);
    delay(50);
    eeprom.writeByte(add4, 0xDB);
    delay(50);
    eeprom.writeByte(add5, 0x15);
    delay(50);
    eeprom.writeByte(add6, 0x29);
    delay(50);
    eeprom.writeByte(add7, 0x96);
    delay(50);
    eeprom.writeByte(add8, 0xF0);
    delay(50);
    eeprom.writeByte(add9, 0x00);
    delay(50);
    eeprom.writeByte(add10, 0x00);
    delay(50);
    eeprom.writeByte(add11, 0x43);
    delay(50);
    eeprom.writeByte(add12, 0xED);
    delay(50);
    eeprom.writeByte(add13, 0x02);
    delay(50);
    eeprom.writeByte(add14, 0x00);
    delay(50);
    eeprom.writeByte(add15, 0x13);
    delay(50);
    eeprom.writeByte(add16, 0xCE);
    delay(50);
    eeprom.writeByte(add17, 0x08);
    delay(50);
    eeprom.writeByte(add18, 0x35);
    delay(50);
    eeprom.writeByte(add19, 0x89);
    delay(50);
    eeprom.writeByte(add20, 0xCB);
      digitalWrite(ledPin,HIGH);
      delay(100);
      digitalWrite(ledPin,LOW);  
      delay(100);  
    delay(50);
    eeprom.writeByte(add21, 0x15);
    delay(50);
    eeprom.writeByte(add22, 0x29);
    delay(50);
    eeprom.writeByte(add23, 0x96);
    delay(50);
    eeprom.writeByte(add24, 0xE0);
    delay(50);
    eeprom.writeByte(add25, 0x00);
    delay(50);
    eeprom.writeByte(add26, 0x00);
    delay(50);
    eeprom.writeByte(add27, 0x43);
    delay(50);
    eeprom.writeByte(add28, 0xDD);
    delay(50);
    eeprom.writeByte(add29, 0x02);
    delay(50);
    eeprom.writeByte(add30, 0x00);
    delay(50);
    eeprom.writeByte(add31, 0x13);
    delay(50);
    eeprom.writeByte(add32, 0x8F);// INIZIA CODICE VERGINE
    delay(50);
    eeprom.writeByte(add33, 0x8D);
    delay(50);
    eeprom.writeByte(add34, 0x8F);
    delay(50);
    eeprom.writeByte(add35, 0x48);
    delay(50);
    eeprom.writeByte(add36, 0xC0);
    delay(50);
    eeprom.writeByte(add37, 0x42);
    delay(50);
    eeprom.writeByte(add38, 0x40);
    delay(50);
    eeprom.writeByte(add39, 0x47);
    delay(50); // FINISCE CODICE E INIZIA MISTICANZA
        eeprom.writeByte(add40, 0xC0);
    delay(50);
        eeprom.writeByte(add41, 0x40);
    delay(50);
        eeprom.writeByte(add42, 0x40);
    delay(50);
          digitalWrite(ledPin,HIGH);
      delay(100);
      digitalWrite(ledPin,LOW);  
      delay(100);  
        eeprom.writeByte(add43, 0xC0);
    delay(50);
        eeprom.writeByte(add44, 0xC0);
    delay(50);
          digitalWrite(ledPin,HIGH);
      delay(100);
      digitalWrite(ledPin,LOW);  
      delay(100);  
        eeprom.writeByte(add45, 0x40);
    delay(50);
        eeprom.writeByte(add46, 0x00);
    delay(50);
        eeprom.writeByte(add47, 0xC0);
    delay(50);
    eeprom.writeByte(add48, 0x8F);// INIZIA CODICE VERGINE
    delay(50);
    eeprom.writeByte(add49, 0x4D);
    delay(50);
    eeprom.writeByte(add50, 0x8F);
    delay(50);
    eeprom.writeByte(add51, 0x48);
    delay(50);
    eeprom.writeByte(add52, 0xC0);
    delay(50);
    eeprom.writeByte(add53, 0x02);
    delay(50);
    eeprom.writeByte(add54, 0x40);
    delay(50);
    eeprom.writeByte(add55, 0x47);
    delay(50);
        eeprom.writeByte(add56, 0xC0);
    delay(50);
        eeprom.writeByte(add57, 0x00);
    delay(50);
        eeprom.writeByte(add58, 0x40);
    delay(50);
        eeprom.writeByte(add59, 0xC0);
    delay(50);
        eeprom.writeByte(add60, 0xC0);
    delay(50);
        eeprom.writeByte(add61, 0x00);
    delay(50);
        eeprom.writeByte(add62, 0x00);
    delay(50);
        eeprom.writeByte(add63, 0xC0);
    delay(50);
        eeprom.writeByte(add64, 0x80);
    delay(50);
        eeprom.writeByte(add65, 0xC0);
    delay(50);
        eeprom.writeByte(add66, 0xC0);
    delay(50);
        eeprom.writeByte(add67, 0x90);
    delay(50);// FINISCE CODICE E INIZIA MISTICANZA
    eeprom.writeByte(add68, 0x80);// INIZIA CODICE VERGINE
    delay(50);
    eeprom.writeByte(add69, 0xC0);
    delay(50);
    eeprom.writeByte(add70, 0x80);
    delay(50);
          digitalWrite(ledPin,HIGH);
      delay(100);
      digitalWrite(ledPin,LOW);  
      delay(100);  
    eeprom.writeByte(add71, 0xC0);
    delay(50);// FINISCE CODICE E INIZIA MISTICANZA
    eeprom.writeByte(add72, 0x80);
    delay(50);
    eeprom.writeByte(add73, 0x86);
    delay(50);
    eeprom.writeByte(add74, 0x52);
    delay(50);
    eeprom.writeByte(add75, 0xC1);
    delay(50);
    eeprom.writeByte(add76, 0x80);// INIZIA CODICE VERGINE
    delay(50);
    eeprom.writeByte(add77, 0xC0);
    delay(50);
    eeprom.writeByte(add78, 0x00);
    delay(50);
    eeprom.writeByte(add79, 0xC0);
    delay(50);// FINISCE CODICE E INIZIA MISTICANZA
    eeprom.writeByte(add80, 0x80);
    delay(50);
    eeprom.writeByte(add81, 0x80);
    delay(50);
    eeprom.writeByte(add82, 0xC0);
    delay(50);
    eeprom.writeByte(add83, 0x90);
    delay(50);
    eeprom.writeByte(add84, 0x80);// INIZIA CODICE VERGINE
    delay(50);
    eeprom.writeByte(add85, 0x80);
    delay(50);
    eeprom.writeByte(add86, 0x80);
    delay(50);
    eeprom.writeByte(add87, 0xC0);
    delay(50);
    eeprom.writeByte(add88, 0x80);
    delay(50);
    eeprom.writeByte(add89, 0x46);
    delay(50);
    eeprom.writeByte(add90, 0x52);
    delay(50);
    eeprom.writeByte(add91, 0xC1);
    delay(50);// FINISCE CODICE E INIZIA MISTICANZA
    eeprom.writeByte(add92, 0x80);// INIZIA CODICE VERGINE
    delay(50);
    eeprom.writeByte(add93, 0x80);
    delay(50);
    eeprom.writeByte(add94, 0x00);
    delay(50);
    eeprom.writeByte(add95, 0xC0);
    delay(50);// FINISCE CODICE E INIZIA MISTICANZA
 
    eeprom.writeByte(add128, 0x5E);
    delay(50);
    eeprom.writeByte(add129, 0x08);
    delay(50);
          digitalWrite(ledPin,HIGH);
      delay(100);
      digitalWrite(ledPin,LOW);  
      delay(100);  
    eeprom.writeByte(add130, 0x35);
    delay(50);
    eeprom.writeByte(add131, 0x89);
    delay(50);
    eeprom.writeByte(add132, 0x5B);
    delay(50);
    eeprom.writeByte(add133, 0x15);
    delay(50);
    eeprom.writeByte(add134, 0x29);
    delay(50);
    eeprom.writeByte(add135, 0x96);
    delay(50);
    eeprom.writeByte(add136, 0x00);
    delay(50);
    eeprom.writeByte(add137, 0x00);
    delay(50);
    eeprom.writeByte(add138, 0x00);
    delay(50);
    eeprom.writeByte(add139, 0x00);
    delay(50);
    eeprom.writeByte(add140, 0x6D);
    delay(50);
    eeprom.writeByte(add141, 0x02);
    delay(50);
    eeprom.writeByte(add142, 0x00);
    delay(50);
    eeprom.writeByte(add143, 0x13);
    delay(50);
    eeprom.writeByte(add144, 0x4E);
          digitalWrite(ledPin,HIGH);
      delay(100);
      digitalWrite(ledPin,LOW);  
      delay(100);  
    delay(50);
    eeprom.writeByte(add145, 0x08);
    delay(50);
    eeprom.writeByte(add146, 0x35);
    delay(50);
    eeprom.writeByte(add147, 0x89);
    delay(50);
    eeprom.writeByte(add148, 0x4B);
    delay(50);
    eeprom.writeByte(add149, 0x15);
    delay(50);
    eeprom.writeByte(add150, 0x29);//
    delay(50);//
    eeprom.writeByte(add151, 0x96);
    delay(50);
    eeprom.writeByte(add152, 0x67);
    delay(50);
    eeprom.writeByte(add153, 0x00);
    delay(50);
    eeprom.writeByte(add154, 0x00);
    delay(50);
    eeprom.writeByte(add155, 0x00);
    delay(50);
    eeprom.writeByte(add156, 0x5D);
    delay(50);
          digitalWrite(ledPin,HIGH);
      delay(100);
      digitalWrite(ledPin,LOW);  
      delay(100);  
    eeprom.writeByte(add157, 0x02);
    delay(50);
    eeprom.writeByte(add158, 0x00);
    delay(50);
    eeprom.writeByte(add159, 0x13);
    delay(50);
    eeprom.writeByte(add160, 0x0F);
    delay(50);
    eeprom.writeByte(add161, 0x8D);
    delay(50);
    eeprom.writeByte(add162, 0x8F);
    delay(50);
    eeprom.writeByte(add163, 0x48);
    delay(50);
    eeprom.writeByte(add164, 0x40);
    delay(50);
    eeprom.writeByte(add165, 0x42);
    delay(50);
    eeprom.writeByte(add166, 0x40);
    delay(50);
    eeprom.writeByte(add167, 0x47);
    delay(50);
    eeprom.writeByte(add168, 0x40);
    delay(50);
    eeprom.writeByte(add169, 0x40);
    delay(50);
    eeprom.writeByte(add170, 0x40);
    delay(50);
    eeprom.writeByte(add171, 0xC0);
    delay(50);
    eeprom.writeByte(add172, 0x40);
    delay(50);
    eeprom.writeByte(add173, 0x40);
    delay(50);
    eeprom.writeByte(add174, 0x00);
    delay(50);
    eeprom.writeByte(add175, 0xC0);
    delay(50);
    eeprom.writeByte(add176, 0x0F);
    delay(50);
    eeprom.writeByte(add177, 0x4D);
    delay(50);
          digitalWrite(ledPin,HIGH);
      delay(100);
      digitalWrite(ledPin,LOW);  
      delay(100);  
    eeprom.writeByte(add178, 0x8F);
    delay(50);
    eeprom.writeByte(add179, 0x48);
    delay(50);
    eeprom.writeByte(add180, 0x40);
    delay(50);
    eeprom.writeByte(add181, 0x02);
    delay(50);
    eeprom.writeByte(add182, 0x40);
    delay(50);
    eeprom.writeByte(add183, 0x47);
    delay(50);
    eeprom.writeByte(add184, 0x40);
    delay(50);
    eeprom.writeByte(add185, 0x00);
    delay(50);
    eeprom.writeByte(add186, 0x40);
    delay(50);
    eeprom.writeByte(add187, 0xC0);
    delay(50);
    eeprom.writeByte(add188, 0x40);
    delay(50);
    eeprom.writeByte(add189, 0x00);
    delay(50);
    eeprom.writeByte(add190, 0x00);
    delay(50);
    eeprom.writeByte(add191, 0xC0);
    delay(50);
    eeprom.writeByte(add192, 0x00);//
    delay(50);
    eeprom.writeByte(add193, 0xC0);
    delay(50);
    eeprom.writeByte(add194, 0xC0);
    delay(50);
    eeprom.writeByte(add195, 0x90);
    delay(50);
    eeprom.writeByte(add196, 0x00);
    delay(50);
    eeprom.writeByte(add197, 0xC0);
    delay(50);
    eeprom.writeByte(add198, 0x80);
    delay(50);
    eeprom.writeByte(add199, 0xC0);
    delay(50);
    eeprom.writeByte(add200, 0x00);
          digitalWrite(ledPin,HIGH);
      delay(100);
      digitalWrite(ledPin,LOW);  
      delay(100);  
    delay(50);
    eeprom.writeByte(add201, 0x86);
    delay(50);
    eeprom.writeByte(add202, 0x52);
    delay(50);
    eeprom.writeByte(add203, 0xC1);
    delay(50);
    eeprom.writeByte(add204, 0x00);
    delay(50);
    eeprom.writeByte(add205, 0xC0);
    delay(50);
    eeprom.writeByte(add206, 0x00);
    delay(50);
    eeprom.writeByte(add207, 0xC0);
    delay(50);
    eeprom.writeByte(add208, 0x00);
    delay(50);
    eeprom.writeByte(add209, 0x80);
    delay(50);
    eeprom.writeByte(add210, 0xC0);
    delay(50);
    eeprom.writeByte(add211, 0x90);
    delay(50);
    eeprom.writeByte(add212, 0x00);
    delay(50);
    eeprom.writeByte(add213, 0x80);
    delay(50);
    eeprom.writeByte(add214, 0x80);
    delay(50);
    eeprom.writeByte(add215, 0xC0);
    delay(50);
    eeprom.writeByte(add216, 0x00);
    delay(50);      
    digitalWrite(ledPin,HIGH);
      delay(100);
      digitalWrite(ledPin,LOW);  
      delay(100);  
    eeprom.writeByte(add217, 0x46);
    delay(50);
    eeprom.writeByte(add218, 0x52);
    delay(50);
    eeprom.writeByte(add219, 0xC1);
    delay(50);
    eeprom.writeByte(add220, 0x00);
    delay(50);
    eeprom.writeByte(add221, 0x80);
    delay(50);
    eeprom.writeByte(add222, 0x00);
    delay(50);
    eeprom.writeByte(add223, 0xC0);
    delay(50);

      digitalWrite(ledPin,HIGH);
      delay(500);
      digitalWrite(ledPin,LOW);  
      delay(110);   
      digitalWrite(ledPin,HIGH);
      delay(500);
      digitalWrite(ledPin,LOW);  
      delay(110);
      digitalWrite(ledPin,HIGH);
      delay(500);
      digitalWrite(ledPin,LOW);  
      delay(100); 
      LEDfunction2 = 0;

    }
    

if(LEDfunction2 == 2){
    Serial.println("Carico 5.7€");
    eeprom.writeByte(add68, 0x80);
    delay(50);
    eeprom.writeByte(add69, 0x83);
    delay(50);
    eeprom.writeByte(add70, 0xC2);
    delay(50);
    eeprom.writeByte(add71, 0x0A);
    delay(50);
    eeprom.writeByte(add84, 0x80);
    delay(50);
    eeprom.writeByte(add85, 0x43);
    delay(50);
    eeprom.writeByte(add86, 0xC2);
    delay(50);
    eeprom.writeByte(add87, 0x0A);
    delay(50);
      digitalWrite(ledPin,HIGH);
      delay(300);
      digitalWrite(ledPin,LOW);  
      delay(250);   
      digitalWrite(ledPin,HIGH);
      delay(300);
      digitalWrite(ledPin,LOW);  
      delay(100);

      LEDfunction2 = 0;


    }

if(LEDfunction2 == 3){
    Serial.println("Carico 13€");
    eeprom.writeByte(add68, 0x80);
    delay(50);
    eeprom.writeByte(add69, 0xC1);
    delay(50);
    eeprom.writeByte(add70, 0x05);
    delay(50);
    eeprom.writeByte(add71, 0x44);
    delay(50);
    eeprom.writeByte(add84, 0x80);
    delay(50);
    eeprom.writeByte(add85, 0x81);
    delay(50);
    eeprom.writeByte(add86, 0x05);
    delay(50);
    eeprom.writeByte(add87, 0x44);
    delay(50);
      digitalWrite(ledPin,HIGH);
      delay(300);
      digitalWrite(ledPin,LOW);  
      delay(250);   
      digitalWrite(ledPin,HIGH);
      delay(300);
      digitalWrite(ledPin,LOW);  
      delay(250);
      digitalWrite(ledPin,HIGH);
      delay(300);
      digitalWrite(ledPin,LOW);  
      delay(100);  
      LEDfunction2 = 0;
    }
   
if(LEDfunction2 == 4){
       Serial.println("Carico 77€");
    eeprom.writeByte(add68, 0x80);
    delay(50);
    eeprom.writeByte(add69, 0x85);
    delay(50);
    eeprom.writeByte(add70, 0x4D);
    delay(50);
    eeprom.writeByte(add71, 0xC8);
    delay(50);
    eeprom.writeByte(add84, 0x80);
    delay(50);
    eeprom.writeByte(add85, 0x45);
    delay(50);
    eeprom.writeByte(add86, 0x4D);
    delay(50);
    eeprom.writeByte(add87, 0xC8);
    delay(50);
      digitalWrite(ledPin,HIGH);
      delay(500);
      digitalWrite(ledPin,LOW);  
      delay(250);   
      digitalWrite(ledPin,HIGH);
      delay(500);
      digitalWrite(ledPin,LOW);  
      delay(100);
            digitalWrite(ledPin,HIGH);
      delay(500);
      digitalWrite(ledPin,LOW);  
      delay(100);
            digitalWrite(ledPin,HIGH);
      delay(500);
      digitalWrite(ledPin,LOW);  
      delay(100);

      LEDfunction2 = 0;

    }
  }
#9

When I am migrating a program to a new platform, I pretend it’s a brand-new project and I implement/debug a step at a time. Your program has two libraries: a switch debouncer and some EEPROM stuff. (By the way, how the heck would you test your several hundreds of lines of code? You do beaucoup writes to EEPROM but never verify what was written, let alone do anything with it?)

Anyhow: Here’s my test program that starts with seeing if the switch press sequences do what I want. I also attached the zipped project, since copying from a browser sometimes screws up UTF-8 stuff. I also show the output from a test run where I pressed a few times.

The next step is, maybe, to write a single byte to EEPROM address 0 (a different value to location 0 for each of your cases). Then read it back and print it.
Once you get that going, then you are ready for a larger test where you actually write all of your stuff and do something with it.

You can keep the main loop() clean and easy to debug if you make each case call an appropriate function instead of putting long sequences in the main loop. But that’s just the way I would do it. You can implement it any way you want.

// Note that you don't need all of that bytexxx = xxx.  Just
// use the address value in the call to eeprom.write() and eeprom.read().

#include <Wire.h>
#include <I2C_eeprom.h>
#include <ClickButton.h>


// The library header file I2C_eeprom.h has definitions for the number of bytes
// for EEPROMs 24C01 through 24C512.  Use the appropriate definition here
// 
#define DEVICE_SIZE     I2C_DEVICESIZE_24LC04
#define EEPROM_ADDRESS  0x50

I2C_eeprom eeprom(EEPROM_ADDRESS, DEVICE_SIZE);
// Note that devices from I2C_eeprom.h have single-byte eeprom.read() and
// eeprom.write() functions and a lot of other stuff.


// My breadboard uses pin D1 for the switch
const byte btnPinTS = 1; //7; // Your code used pin 7
ClickButton button12(btnPinTS, LOW, CLICKBTN_PULLUP);

// Use LED_BUILTIN rather than a specific "magic number" since
// different boards might use different pins
const byte ledPin = LED_BUILTIN; //13 su arduino nano originale

// I don't think you really need this except, maybe to confirm
// its initial state.
int buttonStateTS;

void setup()
{

  Serial.begin(9600);
  // Boards like the XIAO have "native" serial connection, and you
  // must wait until the startup stuff is finished before you
  // print the output.  It doesn't hurt to do this even for boards like
  // the Uno or nano, which have external USB-to-logic converters.
  // So I almost always put this here.
  while (!Serial) ;
  
  Serial.println("Test program compiled on " __DATE__ " at " __TIME__);
  
  buttonStateTS = digitalRead(btnPinTS);
  Serial.print("Initial button state = "); Serial.println(buttonStateTS);
  pinMode(ledPin, OUTPUT);
        
 
  // Set time parameters for the switch debouncer
  // Note that you do not have to do anything with pinMode for the switch input.
  // It was taken care of when you created the button12 object.
  button12.debounceTime   = 20;   // Debounce timer in ms
  button12.multiclickTime = 250;  // Time limit for multi clicks
  button12.longClickTime  = 1000; // time until "held-down clicks" register
}

// Do you really need this?
int LEDfunction2 = 0;

void loop()
{
  // This sets the "clicks" value to whatever happened since the
  // last Update().  The "clicks" value won't be updated until the
  // switch is released, and won't change until the button is pressed
  // and released again.  (Well, if you hold it pressed for a "long
  // time" it will be -1.)
  button12.Update();
  
  if (button12.clicks != 0){
    // While debugging, give a clue as to what the program is seeing 
    Serial.print("\nbutton12.clicks = "); Serial.println(button12.clicks);
    // Do whatever else you might need here.  (Maybe nothing)
  } 

 // Use the "clicks" value to determine the action
 
 if(button12.clicks == 1){
    Serial.println("Scrivo vergine");

    // Do all of the stuff for 1 click

  } // End of 1-click stuff
    

  if(button12.clicks == 2){
    Serial.println("Carico 5.7€");

    // Do all of the stuff for 2 clicks
    
  } // End of 2-click stuff

  if(button12.clicks == 3){
    Serial.println("Carico 13€");

    // Do all of the stuff for 3 clicks
    
  } // End of 3-click stuff
   
  if(button12.clicks == 4){
    Serial.println("Carico 77€");

    // Do all of the stuff for 4 clicks
    
  } // End of 4-click stuff

  // If 1 <= button12.clicks <= 4
  // Maybe do something here to verify EEPROM contents
  
} // End of loop()

Regards,

Dave
forum_eeprom_test.zip (10.2 KB)

output
output604×536 5.15 KB