Les floats deviennent n'importe quoi quand mon Uno lit un Nano via I2C
Traduit de English par IA ·
Contrôleur de serre, deux cartes : un Nano lit des sondes de sol et un DS18B20 et fonctionne en esclave I2C à 0x08 ; un Uno est maître, collecte les données du Nano et transmet le tout par liaison série à un ESP32 qui publie sur Hermetry. Les entiers (humidité brute, 0-1023) passent correctement. Le float de température arrive sous forme de valeurs absurdes comme -2.3e-38 ou nan, et Hermetry refuse la clé dès qu’elle vaut NaN, ce qui crée des trous dans le graphique.Côté esclave :
void onRequest() {
Wire.write(moisture1 >> 8); Wire.write(moisture1 & 0xFF);
Wire.write(moisture2 >> 8); Wire.write(moisture2 & 0xFF);
Wire.write((byte)tempC); // tried this first, lost decimals
Wire.write((byte*)&tempC, 4);
}
Le maître fait Wire.requestFrom(8, 9) et relit les octets dans les mêmes variables.
Greenhouse controller, two boards: a Nano reads soil probes and a DS18B20 and acts as I2C slave at 0x08; an Uno is master, collects from the Nano and passes everything over serial to an ESP32 that publishes to Hermetry. The ints (moisture raw, 0-1023) come through fine. The temperature float arrives as nonsense like -2.3e-38 or nan, and Hermetry refuses the key whenever it’s NaN, so the chart has holes.
Slave side:
void onRequest() {
Wire.write(moisture1 >> 8); Wire.write(moisture1 & 0xFF);
Wire.write(moisture2 >> 8); Wire.write(moisture2 & 0xFF);
Wire.write((byte)tempC); // tried this first, lost decimals
Wire.write((byte*)&tempC, 4);
}
Master does Wire.requestFrom(8, 9) and reads bytes back into the same variables.
Traduit de English par IA ·
Pourrais-tu l’envoyer sous forme de chaîne et la parser de l’autre côté ? C’est ce que j’ai fait pour le série.
Could you send it as a string and parse it on the other end? That’s what I did for serial.
Traduit de English par IA ·
Les chaînes de caractères sur I2C gaspillent des octets et tu n’en récupères que 32 par transfert. Montre le côté maître, je parie que c’est là que ça casse.
Strings over I2C waste bytes and you only get 32 per transfer. Show the master side, I bet that’s where it breaks.
Traduit de English par IA ·
Côté master, désolé, j’aurais dû l’inclure :
Wire.requestFrom(8, 9);
m1 = (Wire.read() << 8) | Wire.read();
m2 = (Wire.read() << 8) | Wire.read();
Wire.read(); // the old byte
for (int i = 0; i < 4; i++) ((byte*)&t)[i] = Wire.read();
master side, sorry, should have included it:
Wire.requestFrom(8, 9);
m1 = (Wire.read() << 8) | Wire.read();
m2 = (Wire.read() << 8) | Wire.read();
Wire.read(); // the old byte
for (int i = 0; i < 4; i++) ((byte*)&t)[i] = Wire.read();
Traduit de English par IA ·
Je suis le sujet : j’ai une configuration similaire prévue pour la serre de notre hôtel.
Following, I have a similar setup planned for our hotel greenhouse.
Traduit de English par IA ·
Deux bugs, et un troisième qui n’attend que de se produire. J’ai fait presque exactement la même chose il y a des années sur un banc d’essai.1. Côté esclave, chaque Wire.write() dans onRequest sur AVR remplace le tampon au lieu de l’compléter dans certaines versions de la bibliothèque, et l’ordre d’évaluation de (Wire.read() << 8) | Wire.read() côté maître n’est pas défini en C++, donc les octets peuvent arriver inversés.2. Un octet parasite décale tout si les nombres ne concordent jamais.Faites-le avec une seule structure des deux côtés et une seule écriture :
struct __attribute__((packed)) Packet {
uint16_t m1, m2;
int16_t t_x100; // 23.47 C -> 2347, no float on the wire
uint8_t seq;
};
// slave
void onRequest() { Wire.write((uint8_t*)&pkt, sizeof(pkt)); }
// master
Packet p;
if (Wire.requestFrom(8, sizeof(p)) == sizeof(p))
Wire.readBytes((uint8_t*)&p, sizeof(p));
float t = p.t_x100 / 100.0;
Les entiers mis à l’échelle évitent toute question de disposition des flottants si l’esclave devient un ESP ou un STM32. L’octet seq vous indique si vous lisez un paquet périmé. Et côté ESP32, omettez simplement la clé si une mesure est invalide au lieu d’envoyer NaN, car NaN n’est de toute façon pas du JSON valide.
Two bugs, and a third waiting to happen. I did nearly this exact thing on a test rig years ago.
1. On the slave, each Wire.write() inside onRequest on AVR replaces the buffer instead of adding to it in some library versions, and the order of evaluation in (Wire.read() << 8) | Wire.read() on the master isn’t defined in C++, so the bytes can come out swapped.
2. The stray single byte shifts everything if the counts ever disagree.
Do it with one struct on both sides and one write:
struct __attribute__((packed)) Packet {
uint16_t m1, m2;
int16_t t_x100; // 23.47 C -> 2347, no float on the wire
uint8_t seq;
};
// slave
void onRequest() { Wire.write((uint8_t*)&pkt, sizeof(pkt)); }
// master
Packet p;
if (Wire.requestFrom(8, sizeof(p)) == sizeof(p))
Wire.readBytes((uint8_t*)&p, sizeof(p));
float t = p.t_x100 / 100.0;
Scaled integers avoid any float layout question if the slave ever becomes an ESP or an STM32. The seq byte tells you if you’re reading a stale packet. And on the ESP32 side, skip the key entirely if a reading is invalid instead of sending NaN, NaN isn’t valid JSON anyway.
Traduit de English par IA ·
Une struct avec un int mis à l’échelle a réglé le problème. La température est propre depuis hier après-midi, aucun trou sur le graphique. L’histoire de l’ordre d’évaluation, c’était nouveau pour moi.
Struct with scaled int fixed it. Temperature has been clean since yesterday afternoon, no gaps on the chart. The evaluation order thing was news to me.
- Vous devez être connecté pour répondre à ce sujet.
Rejoignez la discussion
Connectez-vous pour poser et répondre à des questions, aimer les messages utiles et marquer la réponse qui a résolu votre problème. Chaque contribution rapporte des points et des niveaux.

