Descamps Systems

Logiciel embarqué sur ARM, du driver noyau Linux au firmware bare-metal.

Je développe des drivers noyau Linux, du firmware pour microcontrôleurs et du code optimisé en SIMD pour les plateformes ARM. Je suis spécialisé dans le traitement vidéo temps réel.

Pour les entreprises qui conçoivent des cartes ou des produits à base de FPGA, et pour les sociétés de conseil en Linux qui cherchent un sous-traitant.

M’écrire au sujet de votre projet
Linux embarquéapplication · IHMtraitement SIMDbibliothèque userspacedriver noyauDevice TreeCortex-M · bare metalfirmwaretraitement SIMDdrivers · DMA · IRQpériphériquesuserspacenoyau/dev · ioctl · mmapvotre matériel : FPGA, capteur, carte spécifique

Services

Drivers noyau Linux

Votre FPGA ou votre capteur produit des images, mais Linux ne sait pas encore les lire ?

Je développe le driver de capture V4L2, je m’occupe de son intégration dans le Device Tree et j’écris le code applicatif qui l’exploite.

  • Drivers char, platform et V4L2 : écriture complète ou enrichissement de drivers existants
  • Interfaces entre noyau et userspace : ioctl, sysfs, mmap
  • Userspace : bibliothèques, outils et IHM qui s’appuient sur le driver

Réalisation

V4L2

écrit from scratch

Driver de capture Linux

Un driver de capture V4L2 pour une carte Raspberry Pi.

Sous-système
Video4Linux2 (V4L2)
Plateforme
Raspberry Pi
noyauuserspacematérielde capturedriver V4L2/dev/video0applicationV4L2 · Video4Linux2

Firmware bare-metal sur Cortex-M

Votre carte sur mesure a besoin d’un firmware bare-metal ?

J’écris les drivers au niveau des registres (DMA, interruptions, périphériques) et l’application qui s’appuie dessus.

  • Microcontrôleurs de la famille STM32 et autres Cortex-M
  • Isolation du code spécifique au matériel dans une couche dédiée, le reste étant portable tel quel d’un microcontrôleur à l’autre

Réalisation

< 0,5 image

de latence de bout en bout

Framework vidéo temps réel pour microcontrôleurs

Un framework de traitement vidéo pour microcontrôleurs Cortex-M, porté sur deux cœurs, qui prend en charge plusieurs résolutions jusqu’en SXGA à 60 fps.

Cortex-M55
Helium (MVE)
Cortex-M33
Instructions DSP Armv8-M
Résolution
Jusqu’à 1280 × 1024 @ 60 fps
entréesortieNNN+1N+1N+2N+2< 0,5 image

Optimisation des performances sur ARM

Votre traitement ne tient pas le temps réel ou dépasse son budget CPU ?

Je le profile, puis je réécris les étapes critiques avec les extensions SIMD de votre cœur, jusqu’à ce qu’il tienne l’objectif.

  • NEON (Advanced SIMD) sur Cortex-A
  • Helium (MVE) ou instructions DSP sur Cortex-M
  • La version en C portable reste dans le code : elle sert de référence pour valider la version optimisée, et de solution de repli sur les cœurs qui n’ont pas ces extensions

Réalisation

1280 × 1024 @ 60 fps

SXGA, en continu

Pipeline de traitement vidéo en ARM NEON

Un pipeline complet de traitement vidéo écrit from scratch en ARM NEON, qui tient les 60 images par seconde en SXGA sur Raspberry Pi 4.

Cible
Raspberry Pi 4 · Cortex-A72
Budget par image
16,7 ms
Débit
78,6 Mpixel/s
RGB888 · 1280 × 1024NEON · 16 × u8vld3q_u8RGBvmull_u8 · vmlal_u8 · vrshrn_n_u16Yvst1q_u816 px / itération016,733,350,066,7 ms60 fps · 16,7 ms par image
rgb_to_y.cARM NEON · C99
#include <arm_neon.h>// RGB888 -> 8-bit luma: full-range BT.601 weights// 77/150/29 (sum 256), rounded. 16 pixels per NEON// iteration, then a plain C loop for the tail.void rgb_to_y(const uint8_t *rgb, uint8_t *y, size_t n){    const uint8x8_t kr = vdup_n_u8(77);    const uint8x8_t kg = vdup_n_u8(150);    const uint8x8_t kb = vdup_n_u8(29);    size_t i = 0;    for (; i + 16 <= n; i += 16) {        // Load 16 pixels and de-interleave R, G, B.        uint8x16x3_t px = vld3q_u8(rgb + 3 * i);        uint16x8_t lo = vmull_u8(vget_low_u8(px.val[0]), kr);        lo = vmlal_u8(lo, vget_low_u8(px.val[1]), kg);        lo = vmlal_u8(lo, vget_low_u8(px.val[2]), kb);        uint16x8_t hi = vmull_u8(vget_high_u8(px.val[0]), kr);        hi = vmlal_u8(hi, vget_high_u8(px.val[1]), kg);        hi = vmlal_u8(hi, vget_high_u8(px.val[2]), kb);        // Rounding narrow: (sum + 128) >> 8.        vst1q_u8(y + i, vcombine_u8(vrshrn_n_u16(lo, 8),                                    vrshrn_n_u16(hi, 8)));    }    // Remaining pixels: same arithmetic in plain C.    for (; i < n; i++) {        const uint8_t *p = rgb + 3 * i;        uint32_t s = 77 * p[0] + 150 * p[1] + 29 * p[2];        y[i] = (uint8_t)((s + 128) >> 8);    }}

Extrait à titre illustratif : conversion RGB888 en luminance (BT.601, avec arrondi), 16 pixels par itération, pixels restants en C pur.

Fonctionnement

  1. Périmètre et faisabilité

    Nous définissons ensemble le livrable et l’objectif chiffré à atteindre sur votre matériel : débit, latence, cadence ou empreinte mémoire. Quand rien ne garantit que cet objectif soit tenable, nous commençons par une courte étude de faisabilité payante. Son coût est déduit du projet. Si l’étude conclut que ce n’est pas réalisable, nous en restons là et vous gardez les résultats.

  2. Devis au forfait

    Je m’engage sur un prix ferme pour l’ensemble du livrable, sans facturation au temps passé.

  3. Livraison

    Vous recevez le code accompagné des performances mesurées sur votre matériel.

Conditions d’intervention

Durée type
3 à 8 semaines
Pour la plupart des livrables
Propriété intellectuelle
Cédée au paiement du solde
Code source et droits de propriété intellectuelle
Garantie
6 mois
Correction gratuite des anomalies du code livré
Confidentialité
NDA sur demande
Sous-traitance
Marque blanche
Possible pour les sociétés de conseil
Lieu
100 % à distance

Parcours

Je suis François Descamps. Venu au logiciel par l’électronique, je travaille toujours à la croisée des deux : drivers, firmware et code optimisé qui doit respecter ses contraintes temps réel sur le matériel cible.

Formation et expérience

  1. BTS électronique

    Brevet de technicien supérieur, niveau bac+2.

  2. Ingénieur systèmes embarqués indépendant

    Prototype de radio connectée sur Raspberry Pi : pilotage de puces de réception radio en I²C et I²S, flux audio en C avec JACK, transmission audio sur Ethernet over USB, installation et administration de Debian (réseau, clustering), et un PCB sur mesure conçu sous KiCad, puis soudé et débogué à la main.

  3. École 42

    Développement logiciel, dont une large part en C.

  4. Mines Saint-Étienne

    Diplôme d’ingénieur en systèmes électroniques embarqués, préparé en alternance chez Thales en parallèle de l’École 42.

  5. Traitement vidéo temps réel sur ARM

    Depuis 2025

Contact

Pour démarrer, le plus simple est de m’envoyer un e-mail qui décrit votre matériel et votre besoin logiciel.

E-mail
francois@descamps-systems.com
LinkedIn
Profil LinkedIn
Nouveau message
À
francois@descamps-systems.com
Objet
Demande de projet

Bonjour François,

Plateforme / cœur cible :

Ce qu’il faut développer :

Objectif de performance :

Échéance :