Cas réel · essai 55a44d094f0af392

Un CRC-32 et un filtre FIR testés sur un vrai STM32F429, sans carte sur le bureau

Le 16 novembre 2026, un agent IA a compilé un firmware de 412 octets, l'a envoyé à Cloudhil par une requête HTTPS et a reçu 86 secondes plus tard le résultat mesuré sur une vraie NUCLEO-F429ZI. Les deux calculs sont justes, et le CRC-32 de 8 Ko a pris 507 926 cycles.

L'essai en chiffres

CarteNUCLEO-F429ZI, STM32F429ZI (Cortex-M4 r0p1)
Essai55a44d094f0af392, 16 novembre 2026 à 12:04:15 UTC
Firmware412 octets de code, C sans bibliothèque, arm-none-eabi-gcc 13.2.1 en -O2
De l'envoi au résultat86 secondes, effacement de la carte compris. 28,6 secondes au second essai, le 18 novembre.
VerdictRéussi : nn_pass 1, nn_fail 0, mot NNOK présent
CRC-32, 8 192 octets507 926 cycles, soit 62 cycles par octet et environ 31,7 ms à 16 MHz. Valeur 0x9de0db3e, identique au calcul sur PC.
Filtre FIR, 64 coefficients4 033 échantillons de sortie en virgule fixe Q15. Somme de contrôle 0xcf11850c, identique au calcul sur PC. Durée non mesurée dans cet essai. Second essai : 1 851 173 cycles, environ 115,7 ms à 16 MHz (voir plus bas).
Même source sur un STM32H735Troisième essai, le 19 novembre, sur un Cortex-M7 : mêmes résultats de calcul, CRC-32 en 491 668 cycles, FIR en 6 581 985 cycles, soit 3,6 fois plus que sur le F429 (voir plus bas).

L'essai a été lancé par l'équipe Cloudhil, avec l'API publique, une clé d'agent et un bon obtenus comme n'importe quel utilisateur.

Ce que fait le firmware

  • Il active le timer matériel TIM2 (32 bits, sans prédiviseur) pour compter le temps.
  • Il filtre 4 096 échantillons avec un FIR de 64 coefficients en Q15.
  • Il calcule un CRC-32 bit à bit (polynôme 0xEDB88320) sur 8 192 octets.
  • Il compare les deux résultats aux valeurs calculées sur PC à partir du même fichier, puis écrit le verdict dans la mailbox.

Le source exact qui a tourné : bench.c. Le script d'édition de liens est celui du démarrage rapide : f4.ld. Empreinte SHA-256 de l'ELF envoyé : 42daf689…c9daa533.

Les commandes

sur votre machine
curl -fsSL -o bench.c https://cloudhil.com/static/cases/stm32f429-crc32-fir/bench.c
curl -fsSL -o f4.ld https://cloudhil.com/hello/src/f4.ld
cc -O2 -DHOST -o host bench.c && EXP=$(./host)
arm-none-eabi-gcc -mthumb -ffreestanding -nostdlib -fno-builtin \
  -fno-tree-loop-distribute-patterns -O2 -mcpu=cortex-m4 $EXP \
  -T f4.ld -DMAILBOX=0x2002FF00 -DRCC_TIM2EN_REG=0x40023840u \
  -o f4.elf bench.c
curl -sS -X POST https://cloudhil.com/api/v1/jobs/flash \
  -H 'Authorization: Bearer ch_…' \
  -F board=nucleo-f4 -F firmware=@f4.elf -F voucher=pwpv_… -F uart_seconds=2

La clé ch_… et le bon pwpv_… s'obtiennent comme dans le démarrage rapide.

La réponse du banc

job 55a44d094f0af392
{
  "ok": true,
  "job": "55a44d094f0af392",
  "board": "nucleo-f4",
  "result": {
    "mailbox": {
      "base": "0x2002ff00",
      "nn_magic": "0x4e4e4f4b",
      "nn_pass": 1,
      "nn_fail": 0,
      "nn_out": ["0x00000003", "0xcf11850c", "0x0007c016", "0x9de0db3e"],
      "ok": true
    },
    "uart": {"device": true, "bytes": 0, "text": ""},
    "halted": true,
    "guard": true,
    "erased": true
  }
}
  • nn_out[1] est la somme de contrôle du FIR, nn_out[3] le CRC-32.
  • nn_out[2] = 0x0007c016 = 507 926 ticks de TIM2 pour le CRC-32.
  • erased confirme que la carte a été effacée après la lecture.

Après un redémarrage, le STM32F429 tourne sur son oscillateur interne à 16 MHz et le timer reçoit la même horloge que le processeur : un tick vaut un cycle.

Ce que l'essai a révélé

nn_out[0] devait donner la durée du FIR. Il vaut 3 ticks, ce qui est impossible pour 258 000 multiplications. Le résultat du FIR est juste, c'est la mesure qui est fausse : en -O2, le compilateur a déplacé l'appel du filtre avant la première lecture du timer, parce que la fonction n'a aucun effet de bord.

Le correctif tient en un attribut (noipa) sur les deux fonctions mesurées. La mesure du CRC-32 n'est pas touchée : son appel est bien resté entre deux lectures du timer.

Second essai : la durée du FIR, mesurée

Le 18 novembre 2026 à 13:01:35 UTC, le même firmware a tourné de nouveau sur la même carte, avec l'attribut noipa pour seul changement. C'est l'essai a5ca8bee0e4858ce. Le code fait toujours 412 octets.

job a5ca8bee0e4858ce
"summary": {
  "verdict": "pass",
  "run_s": 2.0,
  "duration_s": 28.6,
  "erased": true
},
"result": {
  "mailbox": {
    "nn_pass": 1,
    "nn_fail": 0,
    "nn_out": ["0x001c3f25", "0xcf11850c",
               "0x0007c017", "0x9de0db3e"]
  },
  "erased": true,
  "timings": {
    "checks_and_voucher_s": 1.9,
    "copy_s": 12.1,
    "program_and_run_s": 5.3,
    "erase_s": 9.2
  }
}
  • nn_out[0] = 0x001c3f25 = 1 851 173 cycles pour le FIR, soit environ 115,7 ms à 16 MHz. Cela fait 459 cycles par échantillon de sortie, ou 7,2 cycles par multiplication-accumulation.
  • nn_out[2] = 0x0007c017 = 507 927 cycles pour le CRC-32 : un cycle d'écart avec le premier essai.
  • Les deux résultats, 0xcf11850c et 0x9de0db3e, sont les mêmes qu'au premier essai et que sur PC.
  • De l'envoi au résultat : 28,6 secondes, contre 86 au premier essai. Le détail est dans timings.

Le source de ce second essai : bench-noipa.c. Pour le refaire, reprenez les commandes plus haut avec ce fichier à la place de bench.c. Empreinte SHA-256 de l'ELF envoyé : e181c23f…12f94410.

Troisième essai : le même source sur un Cortex-M7

Le 19 novembre 2026 à 03:39:24 UTC, le même fichier bench-noipa.c a tourné sur une autre carte du banc, une STM32H735G-DK (STM32H735, Cortex-M7). C'est l'essai 2b6109821ec0cc32. Seules les options de compilation changent : le cœur visé, l'adresse de la mailbox et le registre qui active TIM2. Le code fait 404 octets.

sur votre machine
curl -fsSL -o bench.c https://cloudhil.com/static/cases/stm32f429-crc32-fir/bench-noipa.c
curl -fsSL -o h7.ld https://cloudhil.com/hello/src/h7.ld
cc -O2 -DHOST -o host bench.c && EXP=$(./host)
arm-none-eabi-gcc -mthumb -ffreestanding -nostdlib -fno-builtin \
  -fno-tree-loop-distribute-patterns -O2 -mcpu=cortex-m7 $EXP \
  -T h7.ld -DMAILBOX=0x2001FF00 -DRCC_TIM2EN_REG=0x580244E8u \
  -o h7.elf bench.c
curl -sS -X POST https://cloudhil.com/api/v1/jobs/flash \
  -H 'Authorization: Bearer ch_…' \
  -F board=disco-h7 -F firmware=@h7.elf -F voucher=pwpv_… -F uart_seconds=2
job 2b6109821ec0cc32
"summary": {
  "verdict": "pass",
  "run_s": 2.0,
  "duration_s": 25.0,
  "erased": true
},
"result": {
  "mailbox": {
    "nn_pass": 1,
    "nn_fail": 0,
    "nn_out": ["0x00646ee1", "0xcf11850c",
               "0x00078094", "0x9de0db3e"]
  },
  "erased": true,
  "timings": {
    "checks_and_voucher_s": 2.3,
    "copy_s": 11.3,
    "program_and_run_s": 4.3,
    "erase_s": 7.1
  }
}

Après un redémarrage, le STM32H735 tourne sur son oscillateur interne à 64 MHz, et le timer reçoit là aussi la même horloge que le processeur. Les deux résultats de calcul sont identiques à ceux du F429 et du PC.

CRC-32, STM32F429507 927 cycles, 62 par octet, environ 31,7 ms à 16 MHz
CRC-32, STM32H735491 668 cycles, 60 par octet, environ 7,7 ms à 64 MHz
FIR, STM32F4291 851 173 cycles, 7,2 par multiplication-accumulation, environ 115,7 ms à 16 MHz
FIR, STM32H7356 581 985 cycles, 25,5 par multiplication-accumulation, environ 102,8 ms à 64 MHz
  • Le CRC-32 coûte presque le même nombre de cycles sur les deux cœurs. Avec une horloge quatre fois plus rapide, il est 4,1 fois plus rapide sur le H735.
  • Le FIR coûte 3,6 fois plus de cycles sur le Cortex-M7. Malgré l'horloge quatre fois plus rapide, il ne gagne que 11 % en durée.
  • Deux explications possibles, pas encore départagées par un essai. La première : ce firmware n'active pas les caches du Cortex-M7, éteints au démarrage, et ses tableaux sont en mémoire AXI SRAM (0x24000000). La seconde tient au banc : le code y tourne derrière une protection mémoire qui ne déclare pas cette zone comme de la mémoire ordinaire, ce qui peut ralentir les lectures d'un Cortex-M7. Dans les deux cas, le FIR est le plus touché : il lit deux valeurs en mémoire à chaque multiplication, le CRC-32 une seule par octet.
  • Un nombre de cycles mesuré sur un cœur ne se transpose donc pas à un autre, même avec le même source, et il dépend de la façon dont la mémoire est configurée.

Empreinte SHA-256 de l'ELF envoyé : d0b3df44…43731faf. Un premier envoi, six minutes plus tôt, avait été refusé avec HOST_UNREACHABLE : le banc ne répondait pas à cet instant, rien n'a été programmé et le bon n'a pas été dépensé. Le même bon a servi pour cet essai.

Limites de ces essais

  • Trois essais : deux sur la NUCLEO-F429ZI, un sur la STM32H735G-DK. Chaque mesure n'a été prise qu'une ou deux fois.
  • Horloges à leur valeur de démarrage, sans PLL : 16 MHz sur le F429, 64 MHz sur le H735. À pleine vitesse, les durées en millisecondes seraient différentes.
  • Sur ces deux cartes, le code tourne en mode non privilégié, derrière la protection mémoire du banc. Une durée mesurée ici peut donc différer de celle d'une carte nue.
  • L'oscillateur interne est précis à environ 1 % : les millisecondes sont une estimation, le nombre de cycles est exact.
  • Un essai Cloudhil dure 20 secondes au plus. C'est fait pour un test court ou une mesure, pas pour une longue initialisation.

Simulateur ou vraie carte ? Voir le guide Tester un firmware STM32 sans carte.

Questions fréquentes

Peut-on tester un firmware STM32 sans avoir la carte ?

Oui. Vous compilez sur votre machine, vous envoyez le fichier ELF à Cloudhil par une requête HTTPS, et il est programmé sur une vraie NUCLEO-F429ZI branchée à un banc. Le résultat revient en JSON, puis la carte est effacée. L'essai 55a44d094f0af392 décrit sur cette page a été fait ainsi.

Est-ce un simulateur ?

Non. La sonde de débogage a identifié un cœur Cortex-M4 r0p1 réel, a programmé puis vérifié la mémoire flash, et le temps a été compté par le timer matériel TIM2 de la puce.

Combien de temps prend un essai à distance ?

86 secondes pour cet essai, entre l'envoi du fichier et la réception du résultat : programmation, vérification, 2 secondes d'exécution, lecture du résultat et effacement compris. Depuis le 17 novembre 2026, le banc n'efface plus que ce qui a été écrit : un essai de 2 secondes revient en 10 à 35 secondes environ. Le second essai de cette page, le 18 novembre 2026, est revenu en 28,6 secondes.

Comment le firmware renvoie-t-il son résultat ?

Il écrit sept mots de 32 bits à une adresse fixe de la mémoire vive, la « mailbox » : quatre valeurs libres, un indicateur de réussite, un indicateur d'échec et le mot NNOK. Le banc lit cette zone après l'arrêt du cœur et la renvoie en JSON. La sortie série est renvoyée aussi.

Comment un firmware mesure-t-il son propre temps d'exécution sur Cloudhil ?

Avec un timer matériel. Le code tourne en mode non privilégié : ici il active TIM2, un compteur 32 bits, et lit sa valeur avant et après le calcul. Avec les horloges laissées à leur valeur de démarrage, un tick vaut un cycle d'horloge du processeur.

Refaire cet essai

Une clé d'agent, un bon, puis les commandes ci-dessus.

Démarrage rapide