Transferring Data between Systems Using RF24
A simple guide to managing memory and variables in C++
Memory:
What it all comes down to is memory and how different devices store data in memory. This is very important to understand when transferring data between systems and ensuring that code is portable between various devices.
When using an 8-bit device, such as an ATMega 328 based MCU (Arduino Uno, Nano, etc) the smallest unit for storage in memory is 8bits or 1-byte. This means that even a boolean (true/false) variable will take up 8-bits of memory space. On a 32 bit system, (ESP32, ESP8266) the same boolean value will use 32-bits of memory space. Why does this matter? When transferring data between systems or creating code, certain variables will take up different amounts of space in memory depending on the architecture (8-bit, 32-bit etc) thus introducing inconsistencies and misinterpretation of data.
Examples:
char is equivalent to int8_t
byte is equivalent to uint8_t
int is equivalent to int16_t on an Arduino Uno (8-bit device) and int32_t on ESP32 (32-bit device)
unsigned int is equivalent to uint16_t on Arduino Uno (8-bit device) and uint32_t on ESP32 (32-bit device)
byte is equivalent to uint8_t
int is equivalent to int16_t on an Arduino Uno (8-bit device) and int32_t on ESP32 (32-bit device)
unsigned int is equivalent to uint16_t on Arduino Uno (8-bit device) and uint32_t on ESP32 (32-bit device)
As another example, see https://www.arduino.cc/reference/en/language/variables/data-types/int/
Using variables like int, long etc can cause confusion because they are interpreted differently on different devices. Sending a 2-byte integer from an 8-bit system to a 32-bit system works fine, as long as the size of the variable is specified on both systems such as int16_t, rather than trying to use 'int' on both systems.
Take for example the following data structure:
struct myStruct{
bool variable1;
uint32_t var2;
uint8_t var3;
int16_t var4;
}
On an 8-bit system, this data structure will use 8 bytes of memory space, but on a 32-bit system it will take up 12-bytes. This is because the minimum unit for storage on a 32-bit system is 32-bits, so 32-bit devices will need to add padding wherever the data does not align in chunks of 4-bytes (32-bits). When using data structures, devices will typically attempt to pack the data as efficiently as possible, so re-arranging the data structure properly will prevent the 32-bit system from adding padding and making the data structures incompatible.
struct myStruct{
uint32_t var2;
int16_t var4;
uint8_t var3;
bool variable1;
}
In the above example, the data is arranged in chunks of 4-bytes, starting with a 32-bit unsigned integer (4-bytes), followed by a 16-bit signed integer (2-bytes), an unsigned 8-bit integer (1-byte) and a boolean variable (1-byte), so the 32-bit system will pack the data into memory exactly the same as the 8-bit system, using only 8-bytes of memory space.
This is important, because when sending data between devices, users can just send the data structure as-is and if packed properly, the data will align regardless of whether it is a 32-bit, 64-bit or 8-bit system.
When developing code, specifying the size of all your variables and aligning data properly in your data structures will ensure that the code and communication is portable between devices.
https://www.gnu.org/software/libc/manual/html_node/Integers.html
