I wasn't able to get my structure to pass correctly. I ended up not only changing the double to a float, but I also changed it to another uint16_t. There was still a 1 byte difference in the sizes of the structure (Nano was 13, M5Stack was 14). I added the "uint8_t pad1" to the Nano so it was then 14 also. The comms routines that I have now shows that they both return a 0 (successful) but the data doesn't come across like it does with the Nano to Nano testing.

I've decided to give up on sending the Structure and just assemble the data into a String Array and send that. I have it working as a String, but I'm changing it over to use a null terminated Character Array.

Thanks Anyway, it was fun trying!

Sir Michael

Thank you for the reply. This finally explains why I've been having so much trouble.

I don't need the precision of the double, so it's not a problem to change to a float. I have tried removing the double and inserted another uint16_t, but then I had a 1 byte difference. That was a close as I had gotten so far.

I'll have to study your response more and try to understand it to get it to work, hopefully today.
Again, my sincere thanks...

Sir Michael

Why the Size Differs

Data Alignment:

The ESP32 (Core2) aligns data to 4-byte boundaries by default for performance reasons, while the AVR (NANO) does not.
This causes the compiler to insert padding bytes between struct members to meet alignment requirements.

Double Precision (double):

On AVR, double is typically 4 bytes (same as float).
On ESP32, double is 8 bytes (true IEEE 754 double precision).
This alone explains part of the size difference.

Padding:

The ESP32 compiler may insert padding after uint16_t members to align the double to an 8-byte boundary.

How to Fix It
To ensure the struct has the same size and layout on both platforms, you can:

Use #pragma pack:

Force the compiler to use 1-byte alignment (no padding) for the struct:#pragma pack(push, 1) // Disable padding
struct AmpStruct {
uint8_t bMode;
uint16_t iBand;
float dVolts; // Use float instead of double for consistency
uint16_t iAmpTemp;
uint16_t iFanOutput;
uint16_t iFwdPower;
uint16_t iRefPower;
};
#pragma pack(pop) // Restore default alignment

Note: Replace double with float to ensure consistency (4 bytes on both platforms).

Manually Pad the Struct:

If you must use double, manually add padding to match the ESP32 layout:struct AmpStruct {
uint8_t bMode;
uint8_t _pad1; // Manual padding
uint16_t iBand;
double dVolts;
uint16_t iAmpTemp;
uint16_t iFanOutput;
uint16_t iFwdPower;
uint16_t iRefPower;
};

Use Serialization:

Instead of sending the raw struct, serialize it into a byte array with fixed sizes:uint8_t buffer[24]; // Adjust size as needed
buffer[0] = AmpData.bMode;
memcpy(&buffer[1], &AmpData.iBand, 2);
memcpy(&buffer[3], &AmpData.dVolts, 8); // Or use float
// ... repeat for other members
Serial.write(buffer, sizeof(buffer));

Key Takeaways

Use float instead of double unless you need the extra precision.
Force 1-byte alignment with #pragma pack to avoid padding.
Test the struct size on both platforms after changes:Serial.print("Size of AmpStruct: ");
Serial.println(sizeof(AmpStruct));

https://chat.m5stack.com/