Struct limit on the ESP8266?
adbensi opened this issue · 5 comments
Hello!
Nice job, congradulations!
I have one issue on the ESP8266, I receive only 32 chars..
Debug
ProductID 0x510
Density code 0x5
Density 256K
Device identfied automatically
...... ...... ......
...... ...... ......
...... ...... ......
mydata :
7
7
8
9
9
10
10
10
11
12
13
13
14
15
15
16
16
16
17
18
18
18
19
19
20
20
20
21
22
22
Init Done - array loaded
...... ...... ......
Calculated address 0x50
Write Done - array loaded in FRAM chip
...... ...... ......
Calculated address 0x50
Read Done - array loaded with read data
...... ...... ......
7
7
8
9
9
10
10
0
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
255
Read Write test done - check data if successfull
...... ...... ......
did You can try this sample?
code
/**************************************************************************/
/*!
@file FRAM_I2C_store_anything.ino
@author SOSAndroid (E. Ha.)
@license BSD (see license.txt)
Example sketch that stores and retreive any kind of data.
@section HISTORY
v1.0 - First release
v1.0.1 - fix constructor call error
*/
/**************************************************************************/
#include <Wire.h>
#include <math.h>
#include "C:\Users\Alexandre\OneDrive\PID\FRAM_MB85RC_I2C.h"
#include "C:\Users\Alexandre\OneDrive\PID\FRAM_MB85RC_I2C.cpp"
//define a struct of various data types
typedef struct MYDATA_t {
char SSOM;
char var0;
char var1;
char S1H;
char S1M;
char S1P;
char S1T;
char S2H;
char S2M;
char S2P;
char S2T;
char S3H;
char S3M;
char S3P;
char S3T;
char S4H;
char S4M;
char S4P;
char S4T;
char S5H;
char S5M;
char S5P;
char S5T;
char S6H;
char S6M;
char S6P;
char S6T;
char S7H;
char S7M;
char S7P;
char S7T;
char S8H;
char S8M;
char S8P;
char S8T;
char S9H;
char S9M;
char S9P;
char S9T;
char S10H;
char S10M;
char S10P;
char S10T;
char S11H;
char S11M;
char S11P;
char S11T;
char S12H;
char S12M;
char S12P;
char S12T;
char S13H;
char S13M;
char S13P;
char S13T;
char S14H;
char S14M;
char S14P;
char S14T;
char S15H;
char S15M;
char S15P;
char S15T;
char S16H;
char S16M;
char S16P;
char S16T;
char S17H;
char S17M;
char S17P;
char S17T;
char S18H;
char S18M;
char S18P;
char S18T;
char S19H;
char S19M;
char S19P;
char S19T;
char S20H;
char S20M;
char S20P;
char S20T;
char S21H;
char S21M;
char S21P;
char S21T;
char S22H;
char S22M;
char S22P;
char S22T;
char S23H;
char S23M;
char S23P;
char S23T;
char S24H;
char S24M;
char S24P;
char S24T;
char S25H;
char S25M;
char S25P;
char S25T;
char S26H;
char S26M;
char S26P;
char S26T;
char S27H;
char S27M;
char S27P;
char S27T;
char S28H;
char S28M;
char S28P;
char S28T;
char S29H;
char S29M;
char S29P;
char S29T;
char S30H;
char S30M;
char S30P;
char S30T;
char S31H;
char S31M;
char S31P;
char S31T;
char S32H;
char S32M;
char S32P;
char S32T;
char S33H;
char S33M;
char S33P;
char S33T;
char S34H;
char S34M;
char S34P;
char S34T;
char S35H;
char S35M;
char S35P;
char S35T;
char A1H;
char A1M;
char A1P;
char A1T;
char A2H;
char A2M;
char A2P;
char A2T;
char A3H;
char A3M;
char A3P;
char A3T;
char A4H;
char A4M;
char A4P;
char A4T;
char A5H;
char A5M;
char A5P;
char A5T;
char A6H;
char A6M;
char A6P;
char A6T;
char A7H;
char A7M;
char A7P;
char A7T;
char A8H;
char A8M;
char A8P;
char A8T;
char A9H;
char A9M;
char A9P;
char A9T;
char A10H;
char A10M;
char A10P;
char A10T;
};
//define a struct joining MYDATA_t to an array of bytes to be stored
typedef union MYDATA4I2C_t {
MYDATA_t datastruct;
uint8_t I2CPacket[sizeof(MYDATA_t)];
};
MYDATA4I2C_t mydata; //data to be written in memory
MYDATA4I2C_t readdata; //data read from memory
//random address to write from
uint16_t writeaddress = 0x025;
//Example for mamual mode
uint8_t chipaddress = 0x50;
boolean wp = false; //Allows memory write
int pin = 13;
uint16_t chipDensity = 256; //Just change that value to the density you want : 4, 16, 64, 128, 256, 512 or 1024
//Creating object for FRAM chip
FRAM_MB85RC_I2C mymemory(chipaddress, wp, pin, chipDensity);
void setup() {
Serial.begin(115200);
while (!Serial) ; //wait until Serial ready
Wire.begin();
byte arraySize = sizeof(MYDATA_t);
Serial.println("Starting...");
mymemory.begin();
//---------init data - load array
mydata.datastruct.SSOM = 1;
mydata.datastruct.var0 = 30;
mydata.datastruct.var1 = 30;
mydata.datastruct.S1H = 7;
mydata.datastruct.S1M = 20;
mydata.datastruct.S1P = 48;
mydata.datastruct.S1T = 1;
mydata.datastruct.S2H = 7;
mydata.datastruct.S2M = 30;
mydata.datastruct.S2P = 48;
mydata.datastruct.S2T = 0;
mydata.datastruct.S3H = 8;
mydata.datastruct.S3M = 15;
mydata.datastruct.S3P = 48;
mydata.datastruct.S3T = 0;
mydata.datastruct.S4H = 9;
mydata.datastruct.S4M = 0;
mydata.datastruct.S4P = 48;
mydata.datastruct.S4T = 0;
mydata.datastruct.S5H = 9;
mydata.datastruct.S5M = 45;
mydata.datastruct.S5P = 48;
mydata.datastruct.S5T = 0;
mydata.datastruct.S6H = 10;
mydata.datastruct.S6M = 0;
mydata.datastruct.S6P = 48;
mydata.datastruct.S6T = 0;
mydata.datastruct.S7H = 10;
mydata.datastruct.S7M = 5;
mydata.datastruct.S7P = 48;
mydata.datastruct.S7T = 0;
mydata.datastruct.S8H = 10;
mydata.datastruct.S8M = 50;
mydata.datastruct.S8P = 48;
mydata.datastruct.S8T = 0;
mydata.datastruct.S9H = 11;
mydata.datastruct.S9M = 35;
mydata.datastruct.S9P = 48;
mydata.datastruct.S9T = 0;
mydata.datastruct.S10H = 12;
mydata.datastruct.S10M = 20;
mydata.datastruct.S10P = 48;
mydata.datastruct.S10T = 0;
mydata.datastruct.S11H = 13;
mydata.datastruct.S11M = 25;
mydata.datastruct.S11P = 48;
mydata.datastruct.S11T = 0;
mydata.datastruct.S12H = 13;
mydata.datastruct.S12M = 30;
mydata.datastruct.S12P = 48;
mydata.datastruct.S12T = 0;
mydata.datastruct.S13H = 14;
mydata.datastruct.S13M = 15;
mydata.datastruct.S13P = 48;
mydata.datastruct.S13T = 0;
mydata.datastruct.S14H = 15;
mydata.datastruct.S14M = 0;
mydata.datastruct.S14P = 48;
mydata.datastruct.S14T = 0;
mydata.datastruct.S15H = 15;
mydata.datastruct.S15M = 45;
mydata.datastruct.S15P = 48;
mydata.datastruct.S15T = 0;
mydata.datastruct.S16H = 16;
mydata.datastruct.S16M = 0;
mydata.datastruct.S16P = 48;
mydata.datastruct.S16T = 0;
mydata.datastruct.S17H = 16;
mydata.datastruct.S17M = 5;
mydata.datastruct.S17P = 48;
mydata.datastruct.S17T = 0;
mydata.datastruct.S18H = 16;
mydata.datastruct.S18M = 50;
mydata.datastruct.S18P = 48;
mydata.datastruct.S18T = 0;
mydata.datastruct.S19H = 17;
mydata.datastruct.S19M = 35;
mydata.datastruct.S19P = 48;
mydata.datastruct.S19T = 0;
mydata.datastruct.S20H = 18;
mydata.datastruct.S20M = 20;
mydata.datastruct.S20P = 48;
mydata.datastruct.S20T = 0;
mydata.datastruct.S21H = 18;
mydata.datastruct.S21M = 25;
mydata.datastruct.S21P = 48;
mydata.datastruct.S21T = 0;
mydata.datastruct.S22H = 18;
mydata.datastruct.S22M = 30;
mydata.datastruct.S22P = 48;
mydata.datastruct.S22T = 0;
mydata.datastruct.S23H = 19;
mydata.datastruct.S23M = 10;
mydata.datastruct.S23P = 48;
mydata.datastruct.S23T = 0;
mydata.datastruct.S24H = 19;
mydata.datastruct.S24M = 50;
mydata.datastruct.S24P = 48;
mydata.datastruct.S24T = 0;
mydata.datastruct.S25H = 20;
mydata.datastruct.S25M = 30;
mydata.datastruct.S25P = 48;
mydata.datastruct.S25T = 0;
mydata.datastruct.S26H = 20;
mydata.datastruct.S26M = 45;
mydata.datastruct.S26P = 48;
mydata.datastruct.S26T = 0;
mydata.datastruct.S27H = 20;
mydata.datastruct.S27M = 50;
mydata.datastruct.S27P = 48;
mydata.datastruct.S27T = 0;
mydata.datastruct.S28H = 21;
mydata.datastruct.S28M = 30;
mydata.datastruct.S28P = 48;
mydata.datastruct.S28T = 0;
mydata.datastruct.S29H = 22;
mydata.datastruct.S29M = 10;
mydata.datastruct.S29P = 48;
mydata.datastruct.S29T = 0;
mydata.datastruct.S30H = 22;
mydata.datastruct.S30M = 30;
mydata.datastruct.S30P = 48;
mydata.datastruct.S30T = 0;
mydata.datastruct.S31H = 0;
mydata.datastruct.S31M = 0;
mydata.datastruct.S31P = 48;
mydata.datastruct.S31T = 0;
mydata.datastruct.S32H = 0;
mydata.datastruct.S32M = 0;
mydata.datastruct.S32P = 48;
mydata.datastruct.S32T = 0;
mydata.datastruct.S33H = 0;
mydata.datastruct.S33M = 0;
mydata.datastruct.S33P = 48;
mydata.datastruct.S33T = 0;
mydata.datastruct.S34H = 0;
mydata.datastruct.S34M = 0;
mydata.datastruct.S34P = 48;
mydata.datastruct.S34T = 0;
mydata.datastruct.S35H = 0;
mydata.datastruct.S35M = 0;
mydata.datastruct.S35P = 48;
mydata.datastruct.S35T = 0;
mydata.datastruct.A1H = 7;
mydata.datastruct.A1M = 20;
mydata.datastruct.A1P = 48;
mydata.datastruct.A1T = 0;
mydata.datastruct.A2H = 7;
mydata.datastruct.A2M = 30;
mydata.datastruct.A2P = 48;
mydata.datastruct.A2T = 0;
mydata.datastruct.A3H = 8;
mydata.datastruct.A3M = 15;
mydata.datastruct.A3P = 48;
mydata.datastruct.A3T = 0;
mydata.datastruct.A4H = 9;
mydata.datastruct.A4M = 0;
mydata.datastruct.A4P = 48;
mydata.datastruct.A4T = 0;
mydata.datastruct.A5H = 9;
mydata.datastruct.A5M = 45;
mydata.datastruct.A5P = 48;
mydata.datastruct.A5T = 0;
mydata.datastruct.A6H = 10;
mydata.datastruct.A6M = 0;
mydata.datastruct.A6P = 48;
mydata.datastruct.A6T = 0;
mydata.datastruct.A7H = 10;
mydata.datastruct.A7M = 5;
mydata.datastruct.A7P = 48;
mydata.datastruct.A7T = 0;
mydata.datastruct.A8H = 10;
mydata.datastruct.A8M = 50;
mydata.datastruct.A8P = 48;
mydata.datastruct.A8T = 0;
mydata.datastruct.A9H = 11;
mydata.datastruct.A9M = 35;
mydata.datastruct.A9P = 48;
mydata.datastruct.A9T = 0;
mydata.datastruct.A10H = 12;
mydata.datastruct.A10M = 20;
mydata.datastruct.A10P = 48;
mydata.datastruct.A10T = 0;
Serial.println("...... ...... ......");
Serial.println(" mydata :");
Serial.println(mydata.datastruct.S1H,DEC);
Serial.println(mydata.datastruct.S2H,DEC);
Serial.println(mydata.datastruct.S3H,DEC);
Serial.println(mydata.datastruct.S4H,DEC);
Serial.println(mydata.datastruct.S5H,DEC);
Serial.println(mydata.datastruct.S6H,DEC);
Serial.println(mydata.datastruct.S7H,DEC);
Serial.println(mydata.datastruct.S8H,DEC);
Serial.println(mydata.datastruct.S9H,DEC);
Serial.println(mydata.datastruct.S10H,DEC);
Serial.println(mydata.datastruct.S11H,DEC);
Serial.println(mydata.datastruct.S12H,DEC);
Serial.println(mydata.datastruct.S13H,DEC);
Serial.println(mydata.datastruct.S14H,DEC);
Serial.println(mydata.datastruct.S15H,DEC);
Serial.println(mydata.datastruct.S16H,DEC);
Serial.println(mydata.datastruct.S17H,DEC);
Serial.println(mydata.datastruct.S18H,DEC);
Serial.println(mydata.datastruct.S19H,DEC);
Serial.println(mydata.datastruct.S20H,DEC);
Serial.println(mydata.datastruct.S21H,DEC);
Serial.println(mydata.datastruct.S22H,DEC);
Serial.println(mydata.datastruct.S23H,DEC);
Serial.println(mydata.datastruct.S24H,DEC);
Serial.println(mydata.datastruct.S25H,DEC);
Serial.println(mydata.datastruct.S26H,DEC);
Serial.println(mydata.datastruct.S27H,DEC);
Serial.println(mydata.datastruct.S28H,DEC);
Serial.println(mydata.datastruct.S29H,DEC);
Serial.println(mydata.datastruct.S30H,DEC);
Serial.println("Init Done - array loaded");
Serial.println("...... ...... ......");
//----------write to FRAM chip
byte result = mymemory.writeArray(writeaddress, arraySize, mydata.I2CPacket);
if (result == 0) Serial.println("Write Done - array loaded in FRAM chip");
if (result != 0) Serial.println("Write failed");
Serial.println("...... ...... ......");
//---------read data from memory chip
result = mymemory.readArray(writeaddress, arraySize, readdata.I2CPacket);
if (result == 0) Serial.println("Read Done - array loaded with read data");
if (result != 0) Serial.println("Read failed");
Serial.println("...... ...... ......");
//---------Send data to serial
Serial.println(readdata.datastruct.S1H,DEC);
Serial.println(readdata.datastruct.S2H,DEC);
Serial.println(readdata.datastruct.S3H,DEC);
Serial.println(readdata.datastruct.S4H,DEC);
Serial.println(readdata.datastruct.S5H,DEC);
Serial.println(readdata.datastruct.S6H,DEC);
Serial.println(readdata.datastruct.S7H,DEC);
Serial.println(readdata.datastruct.S8H,DEC);
Serial.println(readdata.datastruct.S9H,DEC);
Serial.println(readdata.datastruct.S10H,DEC);
Serial.println(readdata.datastruct.S11H,DEC);
Serial.println(readdata.datastruct.S12H,DEC);
Serial.println(readdata.datastruct.S13H,DEC);
Serial.println(readdata.datastruct.S14H,DEC);
Serial.println(readdata.datastruct.S15H,DEC);
Serial.println(readdata.datastruct.S16H,DEC);
Serial.println(readdata.datastruct.S17H,DEC);
Serial.println(readdata.datastruct.S18H,DEC);
Serial.println(readdata.datastruct.S19H,DEC);
Serial.println(readdata.datastruct.S20H,DEC);
Serial.println(readdata.datastruct.S21H,DEC);
Serial.println(readdata.datastruct.S22H,DEC);
Serial.println(readdata.datastruct.S23H,DEC);
Serial.println(readdata.datastruct.S24H,DEC);
Serial.println(readdata.datastruct.S25H,DEC);
Serial.println(readdata.datastruct.S26H,DEC);
Serial.println(readdata.datastruct.S27H,DEC);
Serial.println(readdata.datastruct.S28H,DEC);
Serial.println(readdata.datastruct.S29H,DEC);
Serial.println(readdata.datastruct.S30H,DEC);
Serial.println("Read Write test done - check data if successfull");
Serial.println("...... ...... ......");
}
void loop() {
// nothing to do
}
TWI buffer is limitted to 32 bytes. same on AVR.
I managed to solve the problem by breaking the reads / writes:
#include <utility/twi.h>
void _readBytes(FRAM_MB85RC_I2C & fram, uint16_t addr, uint8_t length, uint8_t * buffer) {
while (length != 0) {
uint8_t bytes_to_read = min(length, TWI_BUFFER_LENGTH);
fram.readArray(addr, bytes_to_read, buffer);
addr += bytes_to_read;
buffer += bytes_to_read;
length -= bytes_to_read;
}
}
void _writeBytes(FRAM_MB85RC_I2C & fram, uint16_t addr, uint8_t length, uint8_t *buffer) {
while (length != 0) {
uint8_t bytes_to_write = min(length, TWI_BUFFER_LENGTH);
fram.writeArray(addr, bytes_to_write, buffer);
addr += bytes_to_write;
buffer += bytes_to_write;
length -= bytes_to_write;
}
}
Thanks a lot! I test 1Mbit memory and 256Kbit memory,
1Mbit memory works when I change the Product ID
/* 0x758 = 1M and 0x510 = 256K*/
if ((prodID != 0x758)&&(prodID != 0x510))
{
Serial.print("Unexpected Product ID: 0x");
Serial.println(prodID, HEX);
return false;
}
May be it was usefull to you,
Thanks a lot again,
Best Regards!
Alexandre
Hey, I am also having these issues, and due to my lack of experience with C I'm having some issues getting Palatis' script that iterates through chunks of it working...
Any tips would be greatly appreciated:)
I got a FM24CL16 (connected to a ESP8266), from Aliexpress, to work using Palati's approach with a fixed chunk size of 16 bytes.
"TWI_BUFFER_LENGTH" seems to be not declared on ESP8266.
Using a size of 32 bytes results in one lost byte.
Here is my modified "store_anything"example:
/**************************************************************************/
/*!
@file FRAM_I2C_store_anything.ino
@author SOSAndroid (E. Ha.)
@license BSD (see license.txt)
Example sketch that stores and retreive any kind of data.
@section HISTORY
v1.0 - First release
v1.0.1 - fix constructor call error
*/
/**************************************************************************/
#include <Wire.h>
#include <math.h>
#include <FRAM_MB85RC_I2C.h>
//define a struct of various data types
typedef struct MYDATA_t {
bool data_0;
float data_1;
long data_2;
int data_3;
byte data_4;
char data_5[64];
};
//define a struct joining MYDATA_t to an array of bytes to be stored
typedef union MYDATA4I2C_t {
MYDATA_t datastruct;
uint8_t I2CPacket[sizeof(MYDATA_t)];
};
MYDATA4I2C_t mydata; //data to be written in memory
MYDATA4I2C_t readdata; //data read from memory
//random address to write from
uint16_t writeaddress = 0x01;
//Creating object for FRAM chip
FRAM_MB85RC_I2C mymemory(MB85RC_ADDRESS_A000, false,D3,16);
byte _readBytes(FRAM_MB85RC_I2C & fram, uint16_t addr, uint8_t length, uint8_t * buffer) {
byte result=0;
while (length != 0) {
uint8_t bytes_to_read = min(length, 16);
result = fram.readArray(addr, bytes_to_read, buffer);
if(result>0) return result;
addr += bytes_to_read;
buffer += bytes_to_read;
length -= bytes_to_read;
}
return result;
}
byte _writeBytes(FRAM_MB85RC_I2C & fram, uint16_t addr, uint8_t length, uint8_t *buffer) {
byte result=0;
while (length != 0) {
uint8_t bytes_to_write = min(length, 16);
result = fram.writeArray(addr, bytes_to_write, buffer);
if(result>0) return result;
addr += bytes_to_write;
buffer += bytes_to_write;
length -= bytes_to_write;
}
return result;
}
void setup() {
Serial.begin(115200);
while (!Serial) ; //wait until Serial ready
Wire.begin();
byte arraySize = sizeof(MYDATA_t);
Serial.println("Starting...");
mymemory.begin();
//---------init data - load array
mydata.datastruct.data_0 = true;
Serial.print("Data_0: ");
if (mydata.datastruct.data_0) Serial.println("true");
if (!mydata.datastruct.data_0) Serial.println("false");
mydata.datastruct.data_1 = 1.3575;
Serial.print("Data_1: ");
Serial.println(mydata.datastruct.data_1, DEC);
mydata.datastruct.data_2 = 314159L;
Serial.print("Data_2: ");
Serial.println(mydata.datastruct.data_2, DEC);
mydata.datastruct.data_3 = 142;
Serial.print("Data_3: ");
Serial.println(mydata.datastruct.data_3, DEC);
mydata.datastruct.data_4 = 0x50;
Serial.print("Data_4: 0x");
Serial.println(mydata.datastruct.data_4, HEX);
String str = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
str.toCharArray(mydata.datastruct.data_5, 64);
Serial.print("Data_5: ");
Serial.println(mydata.datastruct.data_5);
Serial.println("...... ...... ......");
Serial.println("Init Done - array loaded");
Serial.println("...... ...... ......");
//----------write to FRAM chip
byte result = _writeBytes(mymemory,writeaddress, arraySize, mydata.I2CPacket);
Serial.print("Array Size=");
Serial.println(arraySize);
if (result == 0) Serial.println("Write Done - array loaded in FRAM chip");
if (result != 0) Serial.println("Write failed");
Serial.println("...... ...... ......");
//---------read data from memory chip
result = _readBytes(mymemory,writeaddress, arraySize, readdata.I2CPacket);
if (result == 0) Serial.println("Read Done - array loaded with read data");
if (result != 0) Serial.println("Read failed");
Serial.println("...... ...... ......");
//---------Send data to serial
Serial.print("Data_0: ");
if (readdata.datastruct.data_0) Serial.println("true");
if (!readdata.datastruct.data_0) Serial.println("false");
Serial.print("Data_1: ");
Serial.println(readdata.datastruct.data_1, DEC);
Serial.print("Data_2: ");
Serial.println(readdata.datastruct.data_2, DEC);
Serial.print("Data_3: ");
Serial.println(readdata.datastruct.data_3, DEC);
Serial.print("Data_4: 0x");
Serial.println(readdata.datastruct.data_4, HEX);
Serial.print("Data_5: ");
Serial.println(readdata.datastruct.data_5);
Serial.println("...... ...... ......");
Serial.println("Read Write test done - check data if successfull");
Serial.println("...... ...... ......");
}
void loop() {
// nothing to do
}
"TWI_BUFFER_LENGTH" seems to be not declared on ESP8266.
https://github.com/esp8266/Arduino/blob/master/libraries/Wire/Wire.h#L32