lynchlab
@aoife_l22 · Membre depuis avril 2025
Engineering student · university
- Sujets
- 15
- Réponses
- 79
- Points
- 0
Toutes mes réponses sur les forums
Traduit de English par IA ·
Le verrouillage de version permet de remettre l’alarme en service aujourd’hui. La vraie correction tient en deux lignes. paho 2.x attend la version de l’API de callback comme premier argument, et votre script y passe l’identifiant client, donc « chiller-pi » est interprété comme une version d’API. Modifiez le constructeur et la signature de on_connect :
import paho.mqtt.client as mqtt
def on_connect(client, userdata, flags, reason_code, properties):
print("connected:", reason_code)
client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="chiller-pi")
client.on_connect = on_connect
client.username_pw_set("<ACCESS_TOKEN>") # token as username, empty password
client.tls_set()
client.connect("<device host>", 8883, keepalive=60)
client.loop_start()
...
client.publish("v1/telemetry", json.dumps({"chiller_temp_c": t}), qos=1)
Ne passez pas le protocole en MQTT 5 pendant que vous y êtes. Hermetry utilise la version 3.1.1 et refuse un CONNECT MQTT 5 avec le code de retour 1. paho utilise toujours 3.1.1 par défaut, donc le laisser tel quel est la bonne décision.Si le technicien utilisait d’autres callbacks (on_disconnect, on_publish), leur signature a également changé en 2.x ; consultez les notes de migration pour chacun d’eux.
Pinning works to get the alarm back today. The proper fix is two lines. paho 2.x wants the callback API version as the first argument, and your script passes the client id there, so « chiller-pi » gets read as an API version. Change the constructor and the on_connect signature:
import paho.mqtt.client as mqtt
def on_connect(client, userdata, flags, reason_code, properties):
print("connected:", reason_code)
client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="chiller-pi")
client.on_connect = on_connect
client.username_pw_set("<ACCESS_TOKEN>") # token as username, empty password
client.tls_set()
client.connect("<device host>", 8883, keepalive=60)
client.loop_start()
...
client.publish("v1/telemetry", json.dumps({"chiller_temp_c": t}), qos=1)
Don’t switch the protocol to MQTT 5 while you’re in there. Hermetry speaks 3.1.1 and refuses an MQTT 5 CONNECT with return code 1. paho still defaults to 3.1.1, so leaving it alone is right.
If the tech had other callbacks (on_disconnect, on_publish), they changed signature in 2.x as well, check the migration notes for each one.
Traduit de English par IA ·
Que devient le total cumulé quand le Wemos redémarre ? Des coupures de courant quand les agents d’entretien le débranchent, je parie.
What happens to the running total when the Wemos reboots? Power cuts when the cleaners unplug it, I’d bet.
Traduit de English par IA ·
Ensuite, les 2 registres forment un float 32 bits. Je reprends ta réponse point par point :
01 slave address
03 function (read holding registers)
04 byte count, 4 bytes follow
43 66 99 9A data: register 0 = 0x4366, register 1 = 0x999A
3A 1E CRC
Si on assemble les quatre octets de données en 0x4366999A et qu’on les lit comme un float IEEE 754 : signe 0, l’exposant donne 2^7 = 128, la mantisse vaut environ 1,8016, et 128 x 1,8016 = 230,6. Donc le 0x4366 de Wilson n’est que la première moitié du float, ce qui explique pourquoi la division ne donne jamais le bon résultat.Sur l’Uno, les octets arrivent en commençant par le poids fort, mais l’AVR est little endian : il faut donc les inverser avant de les copier dans un float :
uint8_t b[4] = { rx[6], rx[5], rx[4], rx[3] }; // 9A 99 66 43
float v;
memcpy(&v, b, 4);
Serial.print("{"l1.voltage":");
Serial.print(v, 1);
Serial.println("}");
Certains compteurs envoient les deux registres dans l’ordre inverse (word swap). Si tu obtiens quelque chose comme 1.2e-23 au lieu d’une tension, échange rx[3..4] avec rx[5..6]. Vérifie aussi le CRC avant de faire confiance à une réponse.
Then the 2 registers are one 32-bit float. Splitting your reply:
01 slave address
03 function (read holding registers)
04 byte count, 4 bytes follow
43 66 99 9A data: register 0 = 0x4366, register 1 = 0x999A
3A 1E CRC
Put the four data bytes together as 0x4366999A and read them as an IEEE 754 float: sign 0, exponent gives 2^7 = 128, mantissa about 1.8016, and 128 x 1.8016 = 230.6. So Wilson’s 0x4366 is the first half of the float, which is why dividing never comes out right.
On the Uno the bytes arrive most significant first but the AVR is little endian, so reverse them before copying into a float:
uint8_t b[4] = { rx[6], rx[5], rx[4], rx[3] }; // 9A 99 66 43
float v;
memcpy(&v, b, 4);
Serial.print("{"l1.voltage":");
Serial.print(v, 1);
Serial.println("}");
Some meters send the two registers the other way round (word swapped). If you ever get something like 1.2e-23 instead of a voltage, swap rx[3..4] with rx[5..6]. Check the CRC before trusting a reply too.
Traduit de English par IA ·
Le problème vient du timing autour de DE, j’ai eu exactement la même chose sur un banc de test avec un F103.HAL_UART_Transmit rend la main dès que le dernier octet est entré dans le registre de données, et non quand il a quitté le registre à décalage. Ensuite, on attend en plus 5 ms. À 9600 bauds, un octet dure environ 1 ms, et un compteur rapide commence à répondre en quelques ms. Pendant que DE est à l’état haut, /RE est aussi à l’état haut, donc le récepteur est désactivé et les premiers octets de la réponse sont perdus. Et comme HAL_UART_Receive n’est appelée qu’après, tout ce qui arrive entre-temps est perdu ou reste à moitié dans le registre de données.L’écho vient de l’ordre inverse : si la réception est déjà armée pendant l’émission et que /RE passe brièvement à l’état bas, vous relisez votre propre requête.Relâchez DE dès que le drapeau de fin d’émission (TC) est levé, puis armez la réception juste après :
__HAL_UART_CLEAR_FLAG(&huart2, UART_FLAG_TC);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
HAL_UART_Transmit(&huart2, req, 8, 100);
while (!__HAL_UART_GET_FLAG(&huart2, UART_FLAG_TC)) {}
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
__HAL_UART_FLUSH_DRREGISTER(&huart2);
HAL_UART_Receive(&huart2, rx, 9, 200);
Mieux encore, utilisez une réception par interruption ou DMA avec l’interruption idle line : un silence de 3,5 caractères termine alors la trame, et vous n’avez pas besoin de connaître la longueur à l’avance. Le F103 n’a pas de broche DE matérielle pour le RS-485, les familles plus récentes en ont une, ce qui évite tout ce travail.
It’s the timing around DE, I had the exact same thing on a lab rig with an F103.
HAL_UART_Transmit returns when the last byte has gone into the data register, not when it has left the shift register. Then you wait 5 ms on top. At 9600 one byte is about 1 ms, and a fast meter starts answering within a few ms. While DE is high, /RE is high too, so the receiver is off and the first bytes of the reply are gone. And because HAL_UART_Receive is only called after that, anything that came in meanwhile is lost or sits half in the data register.
The echo comes from the other order: if the receive is already armed while you transmit and /RE is low for a moment, you read back your own request.
Drop DE the moment the transmit complete flag (TC) is set, and arm the receive right after:
__HAL_UART_CLEAR_FLAG(&huart2, UART_FLAG_TC);
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_SET);
HAL_UART_Transmit(&huart2, req, 8, 100);
while (!__HAL_UART_GET_FLAG(&huart2, UART_FLAG_TC)) {}
HAL_GPIO_WritePin(GPIOA, GPIO_PIN_8, GPIO_PIN_RESET);
__HAL_UART_FLUSH_DRREGISTER(&huart2);
HAL_UART_Receive(&huart2, rx, 9, 200);
Better still, use interrupt or DMA receive with the idle line interrupt, then a 3.5 character gap ends the frame and you don’t need to know the length in advance. The F103 has no hardware DE pin for RS-485, newer families do, which saves all of this.
Traduit de English par IA ·
J’ai opté pour 100 m de Cat6 sur un enrouleur pour la vidéo et la conduite, et pour du LoRa point à point à 868 MHz pour la télémétrie et l’arrêt d’urgence. Le portable de base transmet les données à Hermetry. J’ai volontairement arraché le câble lors d’un test, et l’arrêt d’urgence a tout de même fonctionné via LoRa. Le jury a aimé le graphique des gaz.
Went with 100 m of Cat6 on a reel for video and driving, and 868 MHz point-to-point LoRa for telemetry and the e-stop. The base laptop forwards to Hermetry. Pulled the tether out in a test on purpose and the e-stop still worked over LoRa. Judges liked the gas chart.
Traduit de English par IA ·
Kevin est plus proche de la vérité. Bluetooth 4.0 est la version de la spécification qui a introduit Low Energy, donc « BLE » fait partie de la 4.0 et de toutes les versions suivantes. Un appareil « Bluetooth 4.0 » peut être en Bluetooth classique, en BLE, ou les deux. Pour les capteurs sur batterie, c’est presque toujours du BLE en pratique. Demande au premier fournisseur de le confirmer par écrit.La question la plus importante concerne le second. Hermetry reçoit les données via MQTT, HTTPS ou LoRaWAN, donc aucun des deux capteurs ne communique directement avec lui. Il vous faudra une passerelle près des moteurs qui écoute les capteurs et remonte chacun comme appareil enfant dans Hermetry (une seule connexion à la passerelle, chaque capteur apparaît comme son propre appareil avec son historique et ses alarmes). Cela ne fonctionne que si le fournisseur documente ce que le capteur envoie : le format des trames d’advertising, ou les caractéristiques BLE à lire. Si les données ne sortent que dans leur application mobile et qu’ils refusent de communiquer le format, elles n’arriveront pas dans Hermetry, quelle que soit la version.Donc la question à poser aux deux fournisseurs : « Le format des données est-il documenté pour qu’une passerelle BLE tierce puisse les lire ? »
Kevin is closer. Bluetooth 4.0 is the version of the spec that introduced Low Energy, so « BLE » is part of 4.0 and every version after it. A « Bluetooth 4.0 » device can be classic Bluetooth, BLE, or both. For battery sensors it’s almost always BLE in practice. Ask the first vendor to confirm in writing.
The bigger question is your second one. Hermetry takes data over MQTT, HTTPS or LoRaWAN, so neither sensor talks to it directly. You’d need a gateway near the motors that listens to the sensors and reports each one as a child device in Hermetry (one gateway login, each sensor shows up as its own device with its own history and alarms). That only works if the vendor documents what the sensor sends: the advertising format, or the BLE characteristics to read. If the data only ever goes into their phone app and they won’t tell you the format, it’s not getting into Hermetry, whatever version it is.
So the question to send both vendors: « Is the data format documented so a third-party BLE gateway can read it? »
Traduit de English par IA ·
J’ai eu le même problème en première année, la sonde a fonctionné par la suite, mais j’ai eu de la chance. Liste de contrôle complète :Câblage : rouge sur 3V3 (broche 1), noir sur GND (broche 6), jaune sur GPIO4 (broche 7), et une résistance de 4,7 k entre le jaune et 3V3. Ajoutez dtoverlay=w1-gpio dans /boot/firmware/config.txt (ou /boot/config.txt sur les anciennes images), puis redémarrez. Vous devriez voir un dossier 28-xxxxxxxxxxxx.Ensuite, le script, avec le code paho que vous avez déjà :
import glob, json, time
import paho.mqtt.client as mqtt
dev = glob.glob('/sys/bus/w1/devices/28-*/w1_slave')[0]
def read_c():
lines = open(dev).read().splitlines()
if not lines[0].endswith('YES'):
return None # CRC failed, skip this one
return int(lines[1].split('t=')[1]) / 1000.0
c = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="basement-pi")
c.username_pw_set("YOUR_ACCESS_TOKEN") # token as username, no password
c.tls_set()
c.connect("YOUR_BROKER_HOST", 8883, keepalive=60)
c.loop_start()
while True:
t = read_c()
if t is not None:
c.publish("v1/telemetry", json.dumps({"temp_c": round(t, 2)}), qos=1)
time.sleep(60)
Utilisez un nouveau nom de clé comme temp_c pour que les relevés du CPU ne se mélangent pas dans le même graphique. L’hôte du broker figure sur la carte Connection details de l’appareil.
Did the same thing in first year, the probe was fine afterwards but I was lucky. Full checklist:
Wiring: red to 3V3 (pin 1), black to GND (pin 6), yellow to GPIO4 (pin 7), and a 4.7k resistor from yellow to 3V3. Add dtoverlay=w1-gpio to /boot/firmware/config.txt (or /boot/config.txt on older images) and reboot. You should see a 28-xxxxxxxxxxxx folder.
Then the script, on the same paho code you have:
import glob, json, time
import paho.mqtt.client as mqtt
dev = glob.glob('/sys/bus/w1/devices/28-*/w1_slave')[0]
def read_c():
lines = open(dev).read().splitlines()
if not lines[0].endswith('YES'):
return None # CRC failed, skip this one
return int(lines[1].split('t=')[1]) / 1000.0
c = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="basement-pi")
c.username_pw_set("YOUR_ACCESS_TOKEN") # token as username, no password
c.tls_set()
c.connect("YOUR_BROKER_HOST", 8883, keepalive=60)
c.loop_start()
while True:
t = read_c()
if t is not None:
c.publish("v1/telemetry", json.dumps({"temp_c": round(t, 2)}), qos=1)
time.sleep(60)
Use a new key name like temp_c so the CPU readings don’t mix into the same chart. Broker host is on the device’s Connection details card.
Traduit de English par IA ·
IPAddress possède fromString(), donc aucune découpe n’est nécessaire :
IPAddress ip;
if (ip.fromString(brokerStr)) {
client.setServer(ip, 1883);
}
Mais le point de Ciaran : pour Hermetry, vous ne voulez pas d’IP du tout. Son broker utilise TLS sur le port 8883 et nécessite SNI, il faut donc vous connecter par nom d’hôte. setServer() existe en version acceptant un nom d’hôte, ce qui fonctionne aussi pour votre Pi si vous saisissez son nom ou son IP en texte :
char brokerHost[64]; // global, lives as long as the program
void applyConfig(const String &s) {
s.toCharArray(brokerHost, sizeof(brokerHost));
client.setServer(brokerHost, 8883);
}
Le tampon global est l’élément important. PubSubClient conserve le pointeur que vous lui passez, il ne copie pas le texte. Si vous passez brokerStr.c_str() depuis une String qui sort de portée à la fin de setup(), le pointeur devient invalide et la carte tentera plus tard de se connecter à une adresse erronée. J’ai perdu un après-midi là-dessus dans mon projet de fin d’études : la carte se connectait au premier démarrage, puis plus jamais après une reconnexion.Rendez le paramètre assez long pour l’hôte Hermetry indiqué sur la carte « Détails de connexion » de votre appareil, 64 caractères suffisent largement.
IPAddress has fromString(), so no splitting needed:
IPAddress ip;
if (ip.fromString(brokerStr)) {
client.setServer(ip, 1883);
}
But Ciaran’s point: for Hermetry you don’t want an IP at all. Its broker is TLS on 8883 and needs SNI, so you must connect by host name. setServer() has a version that takes a host name, which works for your Pi too if you type its name or IP as text:
char brokerHost[64]; // global, lives as long as the program
void applyConfig(const String &s) {
s.toCharArray(brokerHost, sizeof(brokerHost));
client.setServer(brokerHost, 8883);
}
The global buffer is the important bit. PubSubClient keeps the pointer you pass, it doesn’t copy the text. If you pass brokerStr.c_str() from a String that goes out of scope at the end of setup(), the pointer dangles and it’ll try to connect to garbage later. I lost an afternoon to that in my final year project, the board connected on first boot and then never again after a reconnect.
Make the parameter long enough for the Hermetry host on your device’s Connection details card, 64 characters is plenty.
Traduit de English par IA ·
« cmd » est une appellation SMBus. Dans une écriture par blocs SMBus, le premier octet après l’adresse s’appelle l’octet de commande, et pour les circuits basés sur des registres comme l’ADS1115, cet octet est le pointeur de registre. Votre première ligne place donc le pointeur sur le registre Config (0x01) et y écrit 0xC3 puis 0x83. Sur le bus : start, 0x90, 0x01, 0xC3, 0x83, stop.0xC383 signifie : lancer une conversion unique, AIN0 par rapport à GND, plage ±4,096 V, mode single-shot, 128 échantillons/s. La lecture place le pointeur sur 0x00 (registre de conversion) et lit deux octets.Votre bug vient de l’ordre des octets. L’ADS1115 envoie d’abord l’octet de poids fort, et le résultat est signé :
data = bus.read_i2c_block_data(0x48, 0x00, 2)
raw = (data[0] << 8) | data[1]
if raw > 0x7FFF:
raw -= 0x10000
volts = raw * 4.096 / 32768
Avec les octets inversés, une petite variation dans l’octet de poids faible devient un énorme saut, ce qui explique vos 900 contre 52 000. Pour AIN1, modifiez les bits MUX : [0xD3, 0x83]. Et 10 ms suffisent à 128 SPS (une conversion dure environ 8 ms), donc la temporisation convient.
« cmd » is SMBus naming. In an SMBus block write the first byte after the address is called the command byte, and for register-based chips like the ADS1115 that byte is the register pointer. So your first line puts the pointer on the Config register (0x01) and writes 0xC3 then 0x83 into it. On the wire: start, 0x90, 0x01, 0xC3, 0x83, stop.
0xC383 means: start a single conversion, AIN0 against GND, ±4.096 V range, single-shot mode, 128 samples/s. The read sets the pointer to 0x00 (Conversion register) and reads two bytes.
Your bug is the byte order. The ADS1115 sends the most significant byte first, and the result is signed:
data = bus.read_i2c_block_data(0x48, 0x00, 2)
raw = (data[0] << 8) | data[1]
if raw > 0x7FFF:
raw -= 0x10000
volts = raw * 4.096 / 32768
With the bytes swapped, a small change in the low byte becomes a huge jump, which is your 900 vs 52,000. For AIN1 change the MUX bits: [0xD3, 0x83]. And 10 ms is enough at 128 SPS (one conversion is about 8 ms), so the sleep is fine.
Traduit de English par IA ·
J’ai réalisé une carte de traceur pour mon module RF l’an dernier et j’ai obtenu le même résultat « fix lent, moitié de portée » sur la révision A, donc c’est surtout ce que mon enseignant a disséqué sur celle-ci.Garde le remplissage supérieur, mais fais-en une vraie masse : relie-le au plan de la couche 2 avec des vias de couture partout, surtout le long de chaque piste RF et autour de chaque section RF. Espace-les d’environ 3 à 5 mm, plus serrés près des parties RF. Un remplissage avec quelques vias épars forme une plaque flottante qui résonne, et cela seul peut te coûter de la sensibilité.Ne coupe pas la masse. Isole les sections par le placement (chaque radio dans son propre coin, l’étage d’alimentation LTE bruyant loin du GNSS) et, si besoin, par une clôture de vias cousus, mais garde un plan continu en dessous.Sous et autour de l’antenne puce et de l’antenne patch : respecte exactement la zone d’exclusion (keep-out) de la fiche technique de chaque antenne. Aucun cuivre sur aucune couche dans la zone d’exclusion de l’antenne puce, et l’antenne patch exige sa surface de masse spécifiée en dessous. Michael a aussi raison : donne aux deux antennes des bords différents et, idéalement, des coins opposés.Route tes pistes RF en guide d’ondes coplanaire à masse à 50 ohms (calcule-le avec ton empilement, les vias des deux côtés en font partie) et prévois un pied de réseau en pi à chaque alimentation d’antenne pour pouvoir l’accorder plus tard.Puis mesure : envoie le RSSI et le SNR LoRa ainsi que le nombre de satellites GNSS et le temps de fix comme mesures avec chaque message, et compare la révision A et la révision B sur un même graphique. C’est le test A/B le plus simple que tu puisses obtenir.
I did a tracker board for my RF module last year and got the same « slow fix, half range » result on rev A, so this is mostly what my lecturer took apart on it.
Keep the top pour, but make it a real ground: connected to the layer 2 plane with stitching vias everywhere, especially along every RF trace and around each RF section. Space them about 3 to 5 mm apart, tighter near the RF parts. A pour with a few random vias is a floating patch that resonates, and that alone can cost you sensitivity.
Do not split the ground. Isolate the sections by placement (each radio in its own corner, the noisy LTE power stuff away from GNSS) and, if needed, by a stitched fence of vias, but keep one continuous plane underneath.
Under and around the chip antenna and the patch: follow each antenna’s datasheet keep-out exactly. No copper on any layer in the chip antenna’s keep-out, and the patch wants its specified ground area under it. Michael is right too: give the two antennas different edges and ideally opposite corners.
Run your RF traces as grounded coplanar waveguide at 50 ohms (calculate with your stack-up, the vias on both sides are part of it) and leave a pi-network footprint at each antenna feed so you can tune later.
Then measure: send the LoRa RSSI and SNR and the GNSS satellite count and time to fix as readings with every message, and compare rev A against rev B on one chart. That’s the easiest A/B test you’ll get.
Traduit de English par IA ·
Et pour les 12 prises, regroupez-les aussi côté passerelle. Un seul message v1/gw/telemetry peut contenir toutes ces prises, identifiées par le nom de l’enfant.
And for the 12 plugs, batch them on the gateway side too. One v1/gw/telemetry message can carry all of them, keyed by child name.
Traduit de English par IA ·
Oui. Ce blog concerne un broker sur votre propre réseau domestique, d’où l’adresse 192.168. Pour Hermetry, vous ne devez utiliser aucune IP : connectez-vous avec le nom d’hôte de la carte Connection details, TLS sur le port 8883. TLS nécessite le nom (SNI), donc l’IP testée par ping échoue, et le port 1883 non chiffré est refusé, sauf si le profil autorise le MQTT en clair, ce qui n’est pas le cas par défaut. rc=5 signifie « not authorised », et la raison réelle apparaît dans l’onglet Log de l’appareil, ça vaut le coup d’y jeter un œil.
import ssl, json, paho.mqtt.client as mqtt
HOST = "<host from Connection details>"
TOKEN = "<access token>"
c = mqtt.Client(client_id="reefer-01")
c.username_pw_set(TOKEN) # token as username, no password
c.tls_set(cert_reqs=ssl.CERT_REQUIRED) # normal public CA bundle
c.connect(HOST, 8883, keepalive=60)
c.loop_start()
c.publish("v1/telemetry", json.dumps({"temperature": -18.2}), qos=1)
Avec paho 2.x, il faut plutôt utiliser mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="reefer-01").
Yes. That blog is for a broker on your own home network, that’s why it has a 192.168 address. For Hermetry there’s no IP you should use at all: connect by the host name from the Connection details card, TLS on 8883. TLS needs the name (SNI), so the pinged IP fails, and plain 1883 is refused unless the profile allows plain MQTT, which it doesn’t by default. rc=5 is « not authorised », and the actual reason ends up on the device’s Log tab, worth a look.
import ssl, json, paho.mqtt.client as mqtt
HOST = "<host from Connection details>"
TOKEN = "<access token>"
c = mqtt.Client(client_id="reefer-01")
c.username_pw_set(TOKEN) # token as username, no password
c.tls_set(cert_reqs=ssl.CERT_REQUIRED) # normal public CA bundle
c.connect(HOST, 8883, keepalive=60)
c.loop_start()
c.publish("v1/telemetry", json.dumps({"temperature": -18.2}), qos=1)
With paho 2.x you need mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id="reefer-01") instead.
Traduit de English par IA ·
Ça a marché, les 12 sont opérationnels. J’ai tout de suite rencontré le problème device_exists car j’avais effacé la flash du nœud 3 pendant le débogage ; il était déjà enregistré sous aq-3c84a1. J’ai supprimé cet appareil dans la console et il a été reprovisionné sans problème. Je les ai tous activés depuis la quarantaine ce matin. Il a aussi fallu que j’échappe correctement les guillemets : ma première version envoyait du JSON invalide et je ne recevais rien en retour.
That worked, all 12 are up. I did hit the device_exists thing straight away because I’d erased flash on node 3 while debugging, it had already registered as aq-3c84a1. Deleted that device in the console and it provisioned again fine. Activated them all from quarantine this morning. Also had to escape the quotes properly, my first version sent broken JSON and just got nothing back.
Traduit de English par IA ·
Cœur Arduino 2.0.14 dans PlatformIO. Je veux bien rester sur WiFiManager pour la partie Wi-Fi, c’est le jeton Hermetry qui me bloque. Je ne veux pas non plus ouvrir la console pour créer 12 appareils et copier 12 jetons dans 12 portails, si je peux l’éviter.
Arduino core 2.0.14 in PlatformIO. Happy to stay with WiFiManager for the Wi-Fi bit, it’s the Hermetry token I’m stuck on. I don’t want to open the console and create 12 devices and copy 12 tokens into 12 portals either if I can avoid it.
Traduit de English par IA ·
C’était ça, la ligne disable-bt du projet imprimante. Embarrassant. Mise en commentaire, hciuart activé, hci0 est de retour et les six tags apparaissent dans le scan. Ils apparaissent maintenant comme enfants dans Hermetry.
That was it, the disable-bt line from the printer project. Embarrassing. Commented out, hciuart enabled, hci0 is back and all six tags show up in the scan. They’re appearing as children in Hermetry now.

