Décoder CAN & OBD-II avec Navixy IoT Logic: un guide des opérations au niveau des bits

Points clés :

• Navixy IoT Logic prend désormais en charge les opérations au niveau des bits et des octets pour le décodage direct des données de bus CAN et OBD-II.
• Les expressions JEXL vous permettent de créer de nouveaux attributs ou de construire des règles conditionnelles IF/THEN basées sur des bits ou indicateurs spécifiques.
• Navixy IoT Logic prend désormais en charge les opérations au niveau des bits et des octets pour le décodage direct des données de bus CAN et OBD-II.
• Les expressions JEXL vous permettent de créer de nouveaux attributs ou de construire des règles conditionnelles IF/THEN basées sur des bits ou indicateurs spécifiques.
• Les opérateurs de manipulation de bits et de décalage permettent l'extraction et la combinaison précises de valeurs multi-octets.
• Les cas d'usage courants incluent le diagnostic véhicule, le décodage de données CAN et les protocoles de capteurs personnalisés.
• Cette amélioration fournit des informations en temps réel sans codage, réduisant les coûts généraux et renforçant l'avantage concurrentiel.

Si vous avez déjà fixé un message de bus CAN en vous demandant comment extraire cet état de transmission enfoui dans le bit 3, ou si vous avez eu besoin de décoder des codes de défaut OBD-II à partir de données hexadécimales brutes, vous connaissez la difficulté. Jusqu'à présent, traiter ces données télématiques codées en binaire signifiait écrire des analyseurs personnalisés, maintenir des scripts externes, ou se contenter d'une interprétation incomplète des données.

Cela change aujourd'hui.

Navixy IoT Logic vient de recevoir une mise à jour majeure avec des opérations au niveau des bits et au niveau des octets complètes, transformant la façon dont les professionnels de la télématique gèrent les données véhicule complexes. Explorons ce que cela signifie pour vos opérations télématiques et pourquoi c'est un changement radical pour les fournisseurs de services télématiques (FST) travaillant avec des données de flotte sophistiquées.

Utilisation des expressions JEXL dans les nœuds IoT Logic

Les expressions Navixy IoT Logic (basées sur Apache JEXL, Java Expression Language) peuvent être utilisées dans deux types de nœuds de flux : les nœuds Initialiser un attribut et les nœuds Logique. Le nœud Initialiser un attribut vous permet de créer ou transformer des attributs de données en utilisant des expressions personnalisées (par exemple, calculer de nouvelles valeurs à partir de données brutes d'appareil). Le nœud Logique évalue une expression booléenne pour diviser le flux de données basé sur des conditions (logique IF/THEN).

En d'autres termes, vous utilisez les expressions pour soit calculer de nouvelles valeurs soit pour définir des règles conditionnelles dans le flux de travail IoT Logic. Par exemple, vous pourriez calculer un nouveau paramètre en combinant des bits à partir de données entrantes, ou configurer une règle qui se déclenche uniquement lorsque des indicateurs de bits spécifiques sont présents dans les données.

• Nœud initialiser un attribut : Ce nœud vous permet de dériver de nouveaux attributs en écrivant des expressions JEXL qui opèrent sur les champs de données entrantes. Ici, vous pouvez utiliser les mathématiques au niveau des bits pour interpréter les valeurs brutes. Par exemple, si un appareil envoie un octet d'état combiné, vous pourriez créer des attributs séparés pour chaque bit d'état en utilisant des expressions (voir les exemples ci-dessous).

• Nœud logique : Ce nœud introduit une ramification if-then basée sur une expression booléenne. Toutes les expressions de nœud logique doivent évaluer à vrai ou faux. Les opérations sur bits sont souvent utilisées ici pour vérifier les indicateurs dans un masque de bits — par exemple, vous pouvez acheminer les données vers le chemin « Vrai » si un certain bit est défini dans une valeur d'état. Cela permet de configurer des alertes et actions conditionnelles (comme déclencher une alarme si un bit de défaut moteur est à 1) de manière low-code. Le nœud Logique implémente essentiellement la logique IF/ELSE côté serveur : si une condition binaire dans les données est remplie, alors faire X, sinon faire Y.

Opérateurs de manipulation de bits essentiels pour le traitement des données télématiques

Le langage d'expression de Navixy prend en charge l'ensemble standard d'opérateurs de manipulation de bits fournis par JEXL. Ceux-ci opèrent au niveau des bits binaires des valeurs entières. Vous pouvez les utiliser dans des expressions pour manipuler les bits dans les données numériques (par exemple, masquer ou basculer des bits spécifiques). Les opérateurs de manipulation de bits pris en charge incluent :

• ET au niveau des bits (&) — Produit un 1 dans chaque position de bit où les deux opérandes ont un 1. Utilisez ceci pour masquer les bits (ne garder que les bits qui remplissent une condition).

Exemple :
33 & 4 évalue à 0 car en binaire 33 est 0010 0001 et 4 est 0000 0100 ; aucune position de bit ne se chevauche avec 1, donc le résultat est 0000 0000. Dans la logique IoT, io_status & 0x08 isolerait le bit 3 de l'attribut io_status (puisque 0x08 en binaire est 0000 1000). Si cette expression est non-nulle, cela signifie que ce bit spécifique était à 1.

• OU au niveau des bits (|) — Produit un 1 dans chaque position de bit où l'un des opérandes a un 1. Utilisez ceci pour combiner les bits.

Exemple :
33 | 4 donne 37 car 0010 0001 | 0000 0100 = 0010 0101 (binaire pour 37). Cela pourrait fusionner des indicateurs de deux valeurs, bien qu'en télématique vous ferez souvent un OU d'une valeur avec un masque pour définir un certain bit à 1.

• OU exclusif au niveau des bits (^) — Produit un 1 dans chaque position de bit où exactement un opérande a un 1 (ou exclusif).

Exemple :
33 ^ 4 donne également 37 (0010 0001 ^ 0000 0100 = 0010 0101) car le bit qui était défini dans 4 bascule dans 33, résultant en 37. (XOR est utile pour basculer les bits (inverser 0 ↔ 1) ou vérifier la différence dans les modèles de bits.

• NON au niveau des bits (~) — Opérateur de complément qui inverse chaque bit de l'opérande (transforme 0 en 1 et 1 en 0).

Exemple :
~ 33 résulte en -34 dans un système 32 bits. C'est parce que 33 (0010 0001 en 8-bit pour illustration) devient 1101 1110 qui représente -34 sous forme de complément à deux. En pratique, ~x peut être utilisé pour inverser un masque (par exemple, x & ~0x0F effacerait les 4 bits inférieurs de x).

Ces opérateurs permettent un contrôle fin des données binaires. Par exemple, si un appareil envoie un entier unique où chaque bit représente un état de capteur différent (un masque de bits), vous pouvez utiliser & pour tester des bits spécifiques ou extraire des sous-ensembles de bits. La plateforme Navixy anticipe explicitement ce cas d'usage, car la capacité d'appliquer le masquage de bits fait partie de sa boîte à outils d'amélioration des données.

Décalage de bits : Travailler avec des données véhicule multi-octets

En plus de la logique de manipulation de bits de base, vous pouvez décaler les bits vers la gauche ou la droite dans JEXL. Les décalages de bits sont cruciaux pour combiner ou découper des valeurs multi-octets. Les opérateurs de décalage pris en charge sont :

• Décalage à gauche (<<) — Déplace tous les bits de l'opérande de gauche vers la gauche du nombre de positions spécifié par l'opérande de droite. Décaler à gauche de n bits équivaut à multiplier par 2^n (en supposant aucun débordement).

Exemple :
1 << 2 donne 4 (binaire 0001 devient 0100). Dans IoT Logic, si vous avez un octet haut et voulez former une valeur 16-bit, vous pourriez faire high_byte << 8 (le décaler vers les positions 8-bit supérieures).

• Décalage à droite (>>) — Déplace les bits vers la droite, préservant le signe (c'est un décalage à droite arithmétique). Le bit le plus à gauche (bit de signe) est répliqué pour remplir les nouvelles positions les plus à gauche pour les nombres signés.

Exemple : 4 >> 2 donne 1 (0100 >> 2 = 0001). Si la valeur était négative, >> la garderait négative en étendant les 1s. Les décalages à droite sont utiles pour extraire des bits d'ordre inférieur en poussant les bits non désirés vers la droite. Par exemple, pour supprimer les 3 bits les plus bas d'une valeur (en gardant le reste), vous pourriez faire value >> 3.

• Décalage à droite non signé (>>>) — Déplace les bits vers la droite avec remplissage de zéros (un décalage logique). Cela signifie qu'il ne préserve pas le bit de signe ; au lieu de cela, il insère toujours des 0s à gauche. Le résultat est toujours un entier non négatif, traitant effectivement le nombre comme non signé pour cette opération. Le décalage à droite non signé est utile lors du travail avec des données binaires brutes où vous ne voulez pas étendre le signe. Dans de nombreux scénarios télématiques, vous utiliserez probablement le >> normal pour l'extraction de bits, mais >>> peut être pertinent si vous traitez avec des valeurs 32-bit où la distinction importe (par exemple, traiter la plage complète 32-bit comme non signée).

L'utilisation des décalages en combinaison avec des masques de bits vous permet de cibler des octets ou bits spécifiques dans un nombre.

Exemple : Supposons que vous ayez une valeur 16-bit et que vous ayez besoin des 8 bits hauts et des 8 bits bas séparément : vous pouvez obtenir l'octet haut avec (value>> 8) & 0xFF et l'octet bas avec value & 0xFF. Ici, >> 8 décale l'octet haut dans la position d'octet la plus basse, et 0xFF (255 en décimal) est un masque pour isoler 8 bits.

Dans JEXL, vous pouvez écrire des littéraux numériques en hexadécimal (préfixe avec 0x) pour plus de commodité lors de la définition de tels masques. Par exemple, 0xFF est le masque pour 8 bits, 0xF pour 4 bits, etc.

Combiner et extraire des octets à partir de charges utiles complexes

De nombreux paramètres IoT et de bus CAN s'étendent sur plusieurs octets ou empaquettent plusieurs champs dans un nombre. Navixy IoT Logic vous permet de les gérer avec des opérations de bits et de décalage, traitant essentiellement les octets dans des entiers plus grands. Voici quelques techniques courantes pour la manipulation au niveau des octets :

• Combiner plusieurs octets. Si un appareil fournit deux ou plusieurs valeurs d'octets séparées qui forment une mesure unique, vous pouvez les combiner en utilisant des décalages et des OU. Par exemple, supposons qu'un message CAN donne engine_rpm_high et engine_rpm_low (chacun 1 octet, représentant une valeur RPM 16-bit). Vous pouvez reconstruire le RPM complet avec une expression pour un nouvel attribut « engine_rpm » :

(engine_rpm_high << 8) | engine_rpm_low

 

Cela décale l'octet haut dans les 8 bits supérieurs et le fusionne avec l'octet bas via un OU au niveau des bits. Le résultat engine_rpm est un nouvel attribut entier 16-bit. De même, vous pourriez combiner 4 valeurs d'un octet en un entier 32-bit en décalant de 24, 16, 8 et 0 bits et en les combinant avec un OU. Ceci est utile pour assembler des IDs ou des lectures de capteurs composites qui arrivent divisées en octets.

• Extraire des octets d'un mot. À l'inverse, vous pourriez recevoir une valeur 32-bit unique d'un appareil mais avoir besoin d'extraire des octets spécifiques (par exemple, codes d'état ou octets de capteurs individuels à l'intérieur). En utilisant des masques et des décalages :

  • Octet le plus bas : value & 0xFF donne les 8 bits les plus bas.

  • Octet suivant : (value >> 8) & 0xFF donne les bits 8-15.

  • Et ainsi de suite : (value >> 16) & 0xFF pour les bits 16-23, (value >> 24) & 0xFF pour les bits 24-31.

    Chaque fois, nous décalons à droite l'octet désiré dans la position 8-bit la plus basse, puis masquons. De cette façon, vous pouvez décomposer un champ multi-octet en composants séparés si nécessaire pour l'analyse ou les rapports.

• Isoler et interpréter les champs de bits. Supposons qu'à l'intérieur d'un octet, différents bits ou groupes de bits portent différentes significations (un scénario courant avec les octets d'état de bus CAN). Par exemple, imaginez un octet unique d'un message OBD-II où : bit0 = MIL (témoin d'avertissement moteur) on/off, bits1-3 = état du système carburant (0—7), bit4 = quelque indicateur, etc. En utilisant IoT Logic, vous pouvez isoler ceux-ci :

  • mil_on = (status_byte & 0x1) == 1 — ceci vérifie le bit le moins significatif. Si égal à 1, l'indicateur MIL est allumé. Ou en utilisant l'extension util: util:checkBit(status_byte, 0).

  • fuel_system_status = (status_byte >> 1) & 0x7 — ceci décale l'octet à droite de 1 (donc bit1 devient le nouveau LSB) et masque avec 0x7 (0b111) pour extraire les trois bits suivants comme un nombre 0—7. Ou en utilisant l'extension util: util:bits(status_byte, 1, 3).

  • flag = (status_byte & 0x10) != 0 — masque bit4 (0x10 est binaire 00010000) et vérifie s'il est non-nul, résultant en un booléen vrai si ce bit était à 1. Ou en utilisant l'extension util: util:checkBit(status_byte, 4).

En utilisant ces techniques, vous pouvez dériver de nouveaux attributs qui représentent des états ou valeurs significatifs, au lieu de traiter avec un champ de bits opaque. Navixy IoT Logic vous permet essentiellement de créer des capteurs virtuels ou des champs calculés pour tout détail au niveau des bits dont vous avez besoin, le tout à travers des expressions.

Utilisation d'opérations de bits dans la logique conditionnelle (règles IF/THEN)

L'un des aspects les plus puissants d'avoir des opérations de bits et d'octets dans IoT Logic est la capacité de piloter des flux de travail conditionnels basés sur des signaux binaires. Dans le nœud Logique, vous écrivez une expression qui doit retourner vrai/faux — et les expressions au niveau des bits s'intègrent parfaitement, tant que vous les comparez pour produire un résultat booléen. Voici quelques exemples d'utilisation d'opérations de bits dans des conditions :

• Détecter un bit spécifique (indicateur). Si un appareil envoie un entier où chaque bit est un indicateur (par exemple, un masque de bits de code d'erreur), vous pouvez déclencher une logique quand un certain indicateur est actif. Par exemple, imaginez que can_status est un entier dont le bit 2 indique surchauffe moteur.

Une condition de nœud Logique pourrait être :

(can_status & 0x4) != 0

ou en utilisant l'extension util :

util:checkBit(can_status, 2)

 

Cette expression utilise & 0x4 (masque 0100 binaire) pour isoler le bit 2, et vérifie si le résultat est non-nul (signifiant que le bit 2 était à 1). Si vrai, le flux de travail suivra la branche THEN — peut-être lever une alerte ou enregistrer un événement de surchauffe moteur. Si faux, il suit la branche ELSE ou ne fait simplement rien si aucun chemin ELSE n'est configuré. C'est une condition classique de test de bit.

• Critères de bits multiples. Vous pouvez également vérifier des combinaisons de bits ou des conditions multiples. Par exemple, supposons que vous vouliez vous assurer que les deux bit 0 et bit 1 sont définis dans un octet io_flags (disons, indiquant que les capteurs de portes avant et arrière sont tous deux actifs).

Vous pourriez écrire :

(io_flags & 0x03) == 0x03

ou en utilisant l'extension util :

util:bits(io_flags, 0, 1) == 0x03

 

Ici 0x03 (binaire 00000011) masque les deux bits les plus bas et l'expression compare le résultat à 0x03. Il sera vrai seulement si les bits 0 et 1 étaient tous deux à 1. Ce genre de vérification produit un booléen approprié pour le nœud Logique (true = les deux conditions remplies). Autre exemple : utiliser un OU au niveau des bits dans une condition — peut-être voulez-vous déclencher une action si l'un de plusieurs bits est défini. Vous pourriez combiner des tests de bits avec un OU logique (||), ou simplement masquer et comparer à zéro. Par exemple (errors & 0xF0) != 0 vérifierait si _l'un_ des 4 bits supérieurs d'errors est actif (non-nul). Cette condition unique signifie effectivement « au moins un de ces indicateurs d'erreur est présent. » Si cela évalue à vrai, vous pourriez bifurquer pour envoyer un rapport de diagnostic.

• Cas limites — Bit au niveau du bit dans un contexte booléen. Rappelez-vous qu'en JEXL, une expression au niveau des bits comme A & B par elle-même résulte en un nombre, pas un booléen. Donc dans un nœud Logique, n'écrivez pas juste x & 0x10 seul — cela produirait un résultat numérique (par exemple 16 ou 0), qui n'est pas explicitement vrai/faux. Comparez-le toujours à quelque chose (par exemple != 0 ou == someMask) pour obtenir un résultat booléen. De même, si vous utilisez des décalages de bits, assurez-vous que le résultat final de l'expression est un booléen. Vous pouvez également envelopper les conditions entre parenthèses et combiner avec &&/|| selon les besoins pour une logique complexe.

Dans l'ensemble, l'utilisation d'opérations au niveau des bits dans les conditions débloque une capacité puissante : vous pouvez créer des règles IF-THEN basées sur des données brutes au niveau des bits provenant de véhicules ou de capteurs. La documentation de Navixy note que JEXL peut gérer de l'arithmétique de base aux expressions logiques complexes, et effectivement l'inclusion de la logique de masquage de bits signifie que même la télémétrie binaire de bas niveau peut piloter des actions de haut niveau. Les fournisseurs de services télématiques peuvent configurer des règles comme « Si un indicateur de capteur de pression de pneu est bas (à partir d'un champ de bits) ou si le bit du bouton d'urgence est pressé, alors envoyer une alerte » — le tout configuré à travers une expression plutôt qu'en écrivant un programme personnalisé.

Fonctions utilitaires pour les formules

En plus des opérateurs au niveau des bits, les formules Navixy prennent également en charge un ensemble de fonctions utilitaires (util) qui facilitent le travail avec les nombres au niveau des bits et des octets :

• util:signed(Number n, int bytesAmount) [Long] — convertit un nombre non signé n de taille bytesAmount octets en une valeur signée. Par exemple, util:signed(65535, 2) retourne -1.

• util:checkBit(Number n, int bitIndex) [Boolean] — vérifie si le bit à la position bitIndex dans n est défini. Retourne true ou false. Par exemple, util:checkBit(4, 2) retourne true.

• util:bit(Number n, int bitIndex) [Integer] — retourne la valeur du bit à la position bitIndex (soit 1 soit 0). Par exemple, util:bit(4, 0) retourne 0.

• util:bits(Number n, int firstBit, int lastBitInclusive) [Long] — extrait une plage de bits de firstBit à lastBitInclusive (inclus). Si lastBitInclusive est inférieur à firstBit, les bits sont lus dans l'ordre inverse. Par exemple, util:bits(1321678, 0, 3) retourne 14, tandis que util:bits(1321678, 3, 0) retourne 7.

• util:bytes(Number n, int firstByte, int lastByteInclusive) [Long] — extrait une plage d'octets defirstByte à lastByteInclusive (inclus). Si lastByteInclusive est inférieur à firstByte, les octets sont lus dans l'ordre inverse. Par exemple, util:bytes(1321678, 0, 1) retourne 10958, et util:bytes(1321678, 1, 0) retourne 52778.

Ces fonctions complètent les opérateurs au niveau des bits et sont particulièrement utiles pour analyser les protocoles d'appareils personnalisés ou travailler avec des valeurs de télémétrie brutes.

Contexte du monde réel et cas d'usage

Les opérations de bits et d'octets dans IoT Logic sont particulièrement précieuses dans les scénarios télématiques et IoT avancés, où les appareils sortent des données encodées. Voici quelques contextes où vous appliquerez ces opérations :

• Décodage de données de bus CAN. Les traceurs GPS modernes avec des interfaces de bus CAN récupèrent souvent des données véhicule riches (niveau de carburant, régime moteur, état des portes, codes de diagnostic, etc.). Beaucoup de ces données viennent comme des valeurs binaires empaquetées. Par exemple, un message CAN pourrait contenir plusieurs indicateurs d'état dans un octet ou une valeur 16-bit où chaque bit signifie une condition différente (ceinture attachée, porte ouverte, ABS actif, etc.). En utilisant Navixy IoT Logic, vous pouvez décoder de telles données à la volée. Le blog officiel Navixy souligne qu'avec des opérations au niveau des bits intégrées, les intégrateurs peuvent « décoder les états de transmission, détecter les indicateurs d'erreur, ou identifier les événements véhicule encodés en signaux binaires » directement via des expressions. Cela signifie que vous pourriez prendre un can_status_word brut et, dans votre flux IoT Logic, le diviser en pièces lisibles par l'homme (comme seatbelt_fastened = vrai/faux, gear_position = N, etc.) sans outils externes. Ces informations dérivées peuvent ensuite être alimentées aux alertes, rapports, ou traitement ultérieur dans la plateforme.

• OBD-II et diagnostic véhicule. Les données OBD-II incluent souvent des Codes de Problème de Diagnostic (DTC) et des octets d'état pour divers tests embarqués. Par exemple, il y a un PID OBD-II standard qui retourne un champ de bits de tests de surveillance complétés/incomplets pour les émissions. En appliquant des masques de bits, vous pourriez interpréter quels tests sont faits ou quels sous-systèmes ont rapporté des défauts. De plus, les codes DTC eux-mêmes sont encodés (le premier octet contient un mélange de bits pour le système et un code numérique). Un utilisateur avancé pourrait utiliser des décalages et des masques pour décoder un format DTC s'il envoie des octets bruts. En pratique, beaucoup d'appareils analysent les DTC pour vous, mais IoT Logic vous donne la flexibilité de gérer toute information binaire personnalisée ou propriétaire des appareils OBD.

• Protocoles de capteurs personnalisés. Au-delà des véhicules, tout capteur IoT qui envoie des données binaires (par exemple, un paquet d'entrées numériques dans un nombre, ou des appareils IoT qui envoient un masque de bits d'alarmes actives) peut être analysé avec ces opérations. Par exemple, si vous avez un capteur de température qui rapporte un état 8-bit où chaque bit correspond à une alarme de seuil, vous pouvez isoler quels seuils ont été dépassés. Ceci est crucial pour les fournisseurs télématiques qui intègrent du matériel divers — IoT Logic agit comme une couche de normalisation où vous pouvez interpréter les formats binaires spécifiques aux appareils en paramètres unifiés et significatifs.

• Performance et sans codage. Toutes ces manipulations de bits/octets se produisent dans la logique côté serveur de Navixy en temps réel, sans besoin de déployer du code personnalisé ou des changements de firmware. Les expressions sont évaluées sur les flux de données entrants au fur et à mesure qu'ils arrivent, et vous pouvez enchaîner plusieurs opérations. Par exemple, vous pourriez calculer une valeur à partir de bits en utilisant un nœud Initialiser un attribut, puis immédiatement utiliser cette nouvelle valeur dans une condition de nœud Logique. Ceci est fait en quelques millisecondes lorsque les données arrivent, permettant des flux de travail réactifs (comme des alertes instantanées ou le filtrage de données) basés sur des signaux de bas niveau. Navixy souligne que cette approche ne nécessite « aucun codage complexe » et est semblable à écrire des formules dans une feuille de calcul — rendant le traitement de données puissant accessible aux ingénieurs télématiques et analystes qui peuvent ne pas être des programmeurs à temps plein.

Conclusion : Traitement de données amélioré sans la surcharge de développement

Avec Navixy IoT Logic amélioré, vous avez maintenant accès direct au battement binaire de vos opérations de flotte. Les opérateurs au niveau des bits (&, |, ^, ~) et les décalages de bits (<<, >>, >>>) qui nécessitaient autrefois une expertise en codage spécialisée font maintenant partie de votre boîte à outils quotidienne. Que vous décodiez des trames de bus CAN, interprétez des protocoles de capteurs personnalisés, ou extrayez des indicateurs de diagnostic à partir de données véhicule brutes, tout se passe dans votre flux de travail de plateforme existant.

Ceci n'est pas seulement une commodité technique — c'est un avantage concurrentiel. Pendant que d'autres maintiennent des pipelines de traitement externes complexes, vous construisez des règles de traitement de données réactives et low-code qui transforment les signaux binaires en intelligence d'affaires en temps réel. Diagnostic moteur, états de capteurs, détection de défauts, tout extrait du matériel existant sans écrire une seule ligne de logiciel externe.

L'industrie télématique a évolué au point où la gestion des octets et bits détermine combien de valeur vous pouvez extraire des données IoT. L'engagement de Navixy envers les opérations binaires avancées assure que vous ne faites pas que suivre cette évolution — vous la menez. _ Prêt à faire passer votre traitement de données télématiques au niveau supérieur ? Contactez les Ventes et voyez comment Navixy IoT Logic peut transformer vos flux de travail IoT._