Auteur Sujet: Protocole MFX : Retour d'information des décodeurs  (Lu 6436 fois)

bobyAndCo

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1135
  • HO avec DCC++
    • Voir le profil
Re : Protocole MFX : Retour d'information des décodeurs
« Réponse #90 le: décembre 23, 2024, 05:03:03 pm »
Bon, maintenant que la centrale MFX est terminée je m'étais lancé au décodage des signaux de retour des décodeurs vers la centrale. Mais OH malheur, le composant LC72725 est plus petit que petit !!! Même mes fils les plus fins paraissent de gigantesques câbles au regard des pattes microscopiques.

Du coup, je me suis résolu à commander des composants chinois en DIP. Le principal problème est que je ne serai livré au mieux qu'entre la fin janvier et la mi février.

J'en ai profité pour m'intéresser plus en détail au fonctionnement et je pense avoir compris l'essentiel. Y a plus qu'à attendre.

Christophe

bk4nt

  • Full Member
  • ***
  • Messages: 133
    • Voir le profil
Re : Protocole MFX : Retour d'information des décodeurs
« Réponse #91 le: décembre 23, 2024, 07:18:01 pm »
Quand c'est trop petit, un composant peut être monté quand même. C'est l'astuce du dead bug:



Sur cette vidéo, vu ce composant, il utilise à mon avis des fils beaucoup trop gros. En plus, il les plie très courts...

Les QFN sont fragiles. Si on insiste trop au fer sur une broche, ou si on exerce trop de contraintes mécaniques avec un fil trop gros/rigide, on fini par arracher une broche; tout est alors à recommencer.

J'ai fini par trouver une technique assez simple et rapide (mais ça prend du temps):

- pour l’immobiliser, coller le composant sur un bout de plaque à proto, étamer rapidement ses broches
- trouver un bout de fil multi brins, en utiliser des brins de 0.2 à 0.3 mm... les étamer un peu à une extrémité (doser la quantité de soudure)
- chauffer le fil, seulement le fil; sur de petits QFN, la chaleur du fer transmise via ce fil de cuivre suffit à le coller/souder sur la broche du QFN (c'est plus précis et facile que de chauffer à la fois la broche et le fil; on ne risque pas de faire chauffer les broches d'à côté, ni de faire baver)
- puis souder l'autre extrémité du fil sur une pastille de la plaque à proto (en conservant une longueur, pour de la souplesse, pour exercer moins de contraintes mécaniques sur la puce après montage)

Pour certains composants, il n'existe que des versions QFN ou plus petits, ce qui ne laisse pas le choix. Des modèles type SOIC ou TSSOP ont les broches moins fragiles. On peut alors tenter des fils un peu plus gros que 0,3mm pour transmettre plus facilement la chaleur via le fil qui est à souder.

On peut être audacieux avec cette technique. On peut ajouter une capa de découplage au format CMS à même la puce, avec deux bouts de fils. On pourrait même ajouter un quartz au format CMS à ce LC72725. Ou encore faire un petit montage en l'air avec des CMS autour de la puce. Mais ça prend du temps.


Pour des SOIC ou des TSSOP, ça peut sinon être tout simple, avec un breakout. Une version courte, avec un gros fer, sans se poser de questions:

https://www.youtube.com/shorts/thCHK7kKb0E

Il y a là aussi une astuce. En procédant ainsi, il reste souvent des excédents de soudure, des courts-circuits entre les pattes (on en voit sur cette version courte). Si on insiste au fer seul, les excédents disparaissent d'un côté mais réapparaissent de l'autre... L'astuce consiste à répartir et à éliminer les excédents de soudure à la tresse à dé-souder. En une minute ou deux, la puce est soudée proprement.


Des exemples, du net. On peut tout faire, mais c'est plus ou moins long selon la taille des CMS:
« Modifié: décembre 23, 2024, 07:41:00 pm par bk4nt »

bk4nt

  • Full Member
  • ***
  • Messages: 133
    • Voir le profil
Re : Re : Protocole MFX : Retour d'information des décodeurs
« Réponse #92 le: décembre 23, 2024, 08:22:41 pm »
Mais OH malheur, le composant LC72725 est plus petit que petit !!! Même mes fils les plus fins paraissent de gigantesques câbles au regard des pattes microscopiques.

A ta prochaine commande, n'oublies pas:
- des breakouts, faciles à souder,
- des quartz au format CMS, il seront installables à proximité immédiate de la puce,
- une bonne loupe pour vérifier les soudures  :)

Ca prend son temps (avec les plus petits CMS qui tendent à rester collés au fer), mais si j'ai pu le faire, c'est réalisable par tous :)

La grosse puce a été soudée comme expliqué plus haut, fini à la tresse à dé-souder, c'est assez propre.

Le quartz, c'était presque simple. Les capas sont au format 0201. Puis j'ai coupé les pistes inutiles sur le breakout.

Monter l'alim et ses 4-5 composants sur un DIP 8 m'avait pris plusieurs heures... Une première tentative avait foiré: j'avais exercé trop de contraintes sur le uDFN 6, une broche avait finie arrachée. J'ai donc rallongé les fils pour plus de souplesse/élasticité, pour moins de contraintes mécaniques. Pour ce genre de montage "en l'air": d'abord souder le fil sur la plaque à proto, ensuite plier le fil pour qu'il soit au plus près de la broche, puis souder le fil à la broche (en chauffant juste le fil préétamé, du cuivre, qui va répartir la chaleur).

En tous cas, ça doit pouvoir donner des idées pour exploiter des composants "trop petits".

Au début, on imagine que c'est irréalisable. Mais non, finalement.
« Modifié: décembre 23, 2024, 09:27:09 pm par bk4nt »

bk4nt

  • Full Member
  • ***
  • Messages: 133
    • Voir le profil
Re : Re : Protocole MFX : Retour d'information des décodeurs
« Réponse #93 le: décembre 23, 2024, 09:54:25 pm »
le composant LC72725 est plus petit que petit !!!

Ce composant a un pitch de 0,65mm... ce qui est encore gros. Je dois avoir des breakouts quelque part mais je ne retrouve plus ma tresse à déssouder pour t'en envoyer un bout.

Les vidéos à ce sujet sont rares, ce ne sont pas des techniques dites "professionnelles". Ces derniers utilisent du flux et des pannes appropriées, ce dont on peut se passer.

Ici, ils suggèrent de souder simplement à la tresse; ce qui pourrait faire chauffer inutilement la puce et le PCB. Je fais autrement, je soude grossièrement, puis j'élimine les excédents à la tresse:






Cette technique est préférable et simple. Il applique un gros excès de soudure, je suppose que c'est pour la vidéo, pour la démo. En pratique, on a pas à en appliquer autant. Puis hop, on retire les excès à la tresse à déssouder:



Il te manquerait 3 choses pour utiliser tes puces:
- un breakout au bon pitch/dimension
- de la tresse à déssouder
- une loupe pour vérifier la qualité des soudures
« Modifié: décembre 23, 2024, 10:06:53 pm par bk4nt »

bobyAndCo

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1135
  • HO avec DCC++
    • Voir le profil
Re : Protocole MFX : Retour d'information des décodeurs
« Réponse #94 le: décembre 24, 2024, 07:33:58 am »
Merci à nouveau pour toutes ces infos,

La loupe, j'ai
La tresse à dessouder, j'ai aussi
La panne appropriée, j'ai encore

Mais pas de breakout à 20 broches !

Pour ce genre de choses, j'utilise de la soudure liquide.

Christophe

bobyAndCo

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1135
  • HO avec DCC++
    • Voir le profil
Re : Protocole MFX : Retour d'information des décodeurs
« Réponse #95 le: décembre 24, 2024, 03:56:19 pm »
bk4nt,

J'ai commencé les tests à l'intérieur de "la boite"

Je confirme que le rapport cyclique de l'horloge est parfaitement de 50% (écran 23) avec une fréquence de 52,9kHz. On devrait plutôt lire 52,63kHz. C'est le quartz 4Mhz / 76

L'image 24 est la superposition de la sortie pin 15 (T57) et de la broche QUAL

Je vais chercher sur la carte des points de tests pus pratiques car ici je me plug directement sur le composant ce qui est fort peu pratique et un nid à courts-circuits

bk4nt

  • Full Member
  • ***
  • Messages: 133
    • Voir le profil
Re : Re : Protocole MFX : Retour d'information des décodeurs
« Réponse #96 le: décembre 24, 2024, 04:41:51 pm »
l'horloge est parfaitement de 50% (écran 23) avec une fréquence de 52,9kHz. On devrait plutôt lire 52,63kHz. C'est le quartz 4Mhz / 76

C'est plutôt l'imprécision du scope, dont à quelques pixels près. Il faut changer la base de temps pour qu'un cycle clock occupe toute la largeur d'écran (ou plus, avec le zoom, et en utilisant les marqueurs temporels), ça pourrait être plus juste. Sinon, il faut un fréquence mètre (dont on peut se passer pour ce projet).

Le quartz à 4Mhz et celui du scope ne sont pas si précis, ils ne sont chacun qu'à quelques ppm près. Donc une imprécision est normale.

50%, ca permettrait donc bien de recombiner clock et data, pour créer des symboles, qui pourraient être compatibles avec Rx RMT de l'esp32. On ne doit pas avoir tant de data feedback que ça. De temps en temps seulement quelques 2 à 4 octets à 1200 Baud. Une fois les symboles dans le buffer RMT, l'esp pourrait les décoder à son rythme.

Avec une particularité. Pour un certain type de feedback, un décodeur n'envoie qu'une porteuse à 52.63kHz, pas de data. Mais là encore, ça devrait générer un flux de symboles (clock  combiné avec la data qui reste à "0").

Avec la recombinaison pour des symboles, RMT devrait pouvoir rester synchro même quand la data est stable à 0 ou à 1. Reste à vérifier que RMT peut bien traiter du Manchester en Rx; pendant ce temps, l'esp serait libre pour d'autres tâches.

Image de source https://electronics.stackexchange.com/questions/246987/nrz-level-encoding-problems

J'en étais plus sûr; en IR, on utilise du Manchester aussi: https://civade.com/post/2021/05/02/IR-remote-1/4-%3A-Comprendre-et-analyser-les-signaux-d-une-t%C3%A9l%C3%A9commande-infrarouge "La transition d'un zéro à un un représente un 1 zéro logique, tandis que la transition d'un 1 à un zéro représente un 1 logique." Un symbole 00 ou 11 serait une violation du code Manchester, une erreur de transmission.
« Modifié: décembre 24, 2024, 05:14:49 pm par bk4nt »

bk4nt

  • Full Member
  • ***
  • Messages: 133
    • Voir le profil
Re : Protocole MFX : Retour d'information des décodeurs
« Réponse #97 le: décembre 24, 2024, 05:10:31 pm »
La solution serait donc toute simple. Après le démodulateur RDS, réencoder en Manchester.

Manifestement, on ne pourra pas se passer d'un démodulateur RDS, qui est un signal bi phase à 52kHz. Un signal qu'il faut filtrer pour éliminer le bruit, ce dont les puces spécialisées RDS s'occupent.

Les émetteurs IR fonctionnent autrement, envoient juste des bursts pour économiser les piles, ce n'est pas du bi phase (sauf fonctionnalité non documentée, l'esp ne devrait pas pouvoir filtrer/démoduler du biphase). Le filtre de l'esp sera aussi inutile; on ne devrait jamais en avoir à la sortie du démodulateur RDS.

https://docs.espressif.com/projects/esp-idf/en/stable/esp32/api-reference/peripherals/rmt.html "Note that, carrier modulation and demodulation are not supported on all ESP chips, please refer to [TRM] before configuring the carrier, or you might encounter a ESP_ERR_NOT_SUPPORTED error." Pas un soucis, puisque ça ne nous intéresse pas pour cette application.
« Modifié: décembre 24, 2024, 05:28:28 pm par bk4nt »

bobyAndCo

  • Global Moderator
  • Hero Member
  • *****
  • Messages: 1135
  • HO avec DCC++
    • Voir le profil
Re : Re : Protocole MFX : Retour d'information des décodeurs
« Réponse #98 le: décembre 24, 2024, 05:44:06 pm »
La solution serait donc toute simple. Après le démodulateur RDS, réencoder en Manchester.

Manifestement, on ne pourra pas se passer d'un démodulateur RDS, qui est un signal bi phase à 52kHz. Un signal qu'il faut filtrer pour éliminer le bruit, ce dont les puces spécialisées RDS s'occupent.

Chercher à se dispenser du composant RDS qui fait parfaitement le job serait assez idiot en effet !

Tu sembles confirmer ce que je présentais. Le RMT est probablement aussi la solution pour le retour d'information quand il s'agit d'octets. Ne pas oublier toute fois que l'on a à la fin de chaque message un CRC sur 8 bits qu'il faudra contrôler pour accepter ou rejeter le message.

Les retours de messages sur 1 ou plusieurs octets sont envoyés par series de 2 toutes les 500mS environ.

Il s'agit entre autres de la fameuse reconnaissance MFX si prisée des Marklinistes qui renvoie l'adresse UID (absolument unique pour chaque décodeur)

Christophe

bk4nt

  • Full Member
  • ***
  • Messages: 133
    • Voir le profil
Re : Protocole MFX : Retour d'information des décodeurs
« Réponse #99 le: décembre 24, 2024, 05:49:46 pm »
Je ne trouve pas d'exemple de code RMT Rx Manchester...

C'est peut-être enfui dans des librairies RMT RC5: https://www.st.com/resource/en/application_note/an4834-implementation-of-transmitters-and-receivers-for-infrared-remote-control-protocols-with-stm32cube-stmicroelectronics.pdf

Chez Expressif, le sujet Manchester Rx/Tx ne surprend pas: https://github.com/espressif/esp-idf/issues/5350 "The rmt is used to implement a bidirectional manchester encoded communication."

J'en déduis que c'est une solution "simple" à évaluer.


bk4nt

  • Full Member
  • ***
  • Messages: 133
    • Voir le profil
Re : Re : Re : Protocole MFX : Retour d'information des décodeurs
« Réponse #101 le: décembre 24, 2024, 06:18:04 pm »
Tu sembles confirmer ce que je présentais. Le RMT est probablement aussi la solution pour le retour d'information quand il s'agit d'octets.

Avec un réencodage Manchester, RMT devrait être performant pour recevoir le feedback MFX. L'esp et ses API ayant du être conçus pour, pour un traitement matériel et software optimal.

On pourrait quand même avoir envie de comparer la performance/temps CPU entre un shift in des bits avec interruptions via clock vs RMT avec des symboles puis le traitements bit à bits nécessaires ensuite...

Railcom Rx serait à mon avis plus efficacement traité par un UART de l'esp. Pour ne pas avoir à traiter/tester les bits start et stop par RMT puis par software, ce qui comparé à un UART, du matériel, fait perdre du temps CPU. Un UART mettant directement les octets reçus en RAM.

A vérifier, RMT ne doit avoir que "un fil" en entrée. S'il y a une entrée clock, ça pourrait aussi faire du shift in. Sinon, pour du shift in, il y aurait également à réencoder vers Manchester ou autres... puis à décoder dans la foulée, pour acquérir les bits. Ca pourrait consommer plus de temps CPU qu'un shift in plus classique...

Un shif in ou out plus classique avec un périphérique SPI devrait rester nettement plus performant que avec RMT qui a tout à traiter bit à bit.

bk4nt

  • Full Member
  • ***
  • Messages: 133
    • Voir le profil
Re : Re : Protocole MFX : Retour d'information des décodeurs
« Réponse #102 le: décembre 24, 2024, 06:30:29 pm »
Et là ? sans certitude cependant :

https://esp32.com/viewtopic.php?t=9234&utm_source=chatgpt.com

https://esp32.com/viewtopic.php?t=35178&utm_source=chatgpt.com

https://github.com/espressif/arduino-esp32/blob/master/libraries/ESP32/examples/RMT/RMTLoopback/RMTLoopback.ino?utm_source=chatgpt.com

Au premier lien, ça chute sur "Can you please share the you libraries or the references from where you got."

Au second, il y a du code... Au troisième, un loopback RMT, on a pas la moindre idée du temps CPU (nombre d'instructions) que prend ceci:

  // Start an async data read
  size_t rx_num_symbols = RMT_NUM_EXCHANGED_DATA;
  rmtReadAsync(RMT_RX_PIN, my_data, &rx_num_symbols);

  // Write blocking the data to the loopback
  rmtWrite(RMT_TX_PIN, data, RMT_NUM_EXCHANGED_DATA, RMT_WAIT_FOR_EVER);

  // Wait until data is read
  while (!rmtReceiveCompleted(RMT_RX_PIN));


Ca s'arrête sur un wait/while. Sauf avec un RTOS, à partir de là, la CPU ne fait plus que boucler et attendre  :)


Du shift  in/out par SPI étant instantané, géré par le hardware.

Mais avec MFX, vu le peu de feedback qu'on attend, quelques octets par seconde, le temps CPU avec un esp n'est peut-être pas si important que cela.

bk4nt

  • Full Member
  • ***
  • Messages: 133
    • Voir le profil
Re : Protocole MFX : Retour d'information des décodeurs
« Réponse #103 le: décembre 24, 2024, 06:58:23 pm »
Ca pourrait n'être que peu performant. RMT traitant la couche basse/physique. Le reste est à faire par software...

Dans cet exemple RMT RC5, je n'ai pas pris le temps de tout lire, le traitement des données reçues (peu d'octets, un code, d'une télécommande) semble être fastidieux:

typedef struct {
   uint16_t header_high;
   uint16_t header_low;
   uint16_t one_high;
   uint16_t one_low;
   uint16_t zero_high;
   uint16_t zero_low;
   uint16_t footer_high;
   uint8_t footer_low;
   uint16_t frequency;
   const char* name;
} ir_protocol_t;


uint32_t rc5_check(rmt_symbol_word_t *item, size_t &len){
   if(len < 13 || len > 30 ){
      return 0;
   }
   const uint16_t RC5_High = proto[RC5].one_high + proto[RC5].one_low;
   uint32_t code = 0; bool c = false;
   for(uint8_t i = 0; i < len; i++){
      uint32_t d0 = item.duration0;
      uint32_t d1 = item.duration1;
      if (rc5_bit(d0, proto[RC5].one_low)) {
         code = (code << 1) | c;
         c = rc5_bit(d1, RC5_High) ? !c : c;
      } else if (rc5_bit(d0, RC5_High)) {
         code = (code << 2) | (item.level0 << 1) | !item.level0;
         c = rc5_bit(d1, proto[RC5].one_low) ? !c : c;
      }else{
         //Serial.printf("BitError i:%d\n",i);
         return 0;
      }
   }
   return code;
}


https://github.com/junkfix/esp32-rmt-ir/blob/main/esp32-rmt-ir.cpp

bk4nt

  • Full Member
  • ***
  • Messages: 133
    • Voir le profil
Re : Protocole MFX : Retour d'information des décodeurs
« Réponse #104 le: décembre 24, 2024, 07:39:15 pm »
Un récepteur Manchester avec un nombre d'octets précis attendus par la centrale devrait être plus simple que ces récepteurs de télécommande. Ceux là traitent et testent bit à bit pour les valider, détecter les violations, et en extraire des codes, à peu de bits...

Si on attend 1, 2, 4 ou 8 octets, plus une checksum, on sait combien de bits RMT doit recevoir, avec le start bit.

Sauf timeout, dès que RMT a reçu tous les bits attendus, qu'ils sont en RAM,
on ignore le start bit, un bit à 1, inutile de le tester?
on décode les symboles bits, on écrit les octets puis la checksum dans une structure,
éventuellement, on teste au passage les violation Manchester, mais il ne devrait jamais en exister, ce serait du temps CPU perdu
on vérifie la checksum, si elle est invalide, on droppe le paquet...


Edit... ces 3 lignes sont encore trop courtes. Avant la data et le start bit, il y a un préambule. Il faudra donc aussi:
recevoir bits à bits le préambule (par symboles)
tester tous les bits de ce préambule, jusqu'à détection du start bit
ensuite seulement on commence à recevoir la data...

On est donc très éloigné de ce que peuvent faire des UART, périphériques SPI et CAN, en Rx, avec de gros flux de données, sans solliciter la CPU. Avec RMT Rx, la CPU doit tout traiter symboles par symboles, bit à bits, etc.

Si on disposait d'un périphérique hardware dédié à la Rx MFX, ou d'un Tiny dédié, on aurait:
- une interruption pour signifier qu'on a détecté rien qu'une porteuse 52k, jamais de start bit
- une interruption pour signaler que X octets valides sont en RAM (le hardware en aurait validé la checksum)
- une interruption pour signaler qu'il y a eu erreur de transmission (checksum invalide ou timeout, etc)


Reste l'intérêt de RMT Rx pour des messages courts et à bas débit, non susceptibles de trop charger la CPU. Avec du code plus ou moins compliqué, on doit pouvoir recevoir n'importe quel type de données encodées, reçues via un fil/GPIO Rx.

C'est ce qui semble avoir été fait pour la réception de codes IR, de télécommandes. RMT Rx passe les symboles à la CPU, la CPU décode les messages, qui restent courts et occasionnels.


Même dans la doc, je lis que ce n'est pas fait pour des choses trop évoluées ni trop rapides... En mode Tx/Rx, on ne pourrait faire que du half duplex; on aurait à faire du Tx sur un canal, du Rx sur un autre canal. Quand au buffer, il est limité aussi.

The RMT module contains eight channels. Each channel has both a transmitter and a receiver, but only one of them can be active in every channel. The eight channels share a 512x32-bit RAM block which can be read and written by the processor cores over the APB buss, read by the transmitters, and written by the receiver. https://www.espressif.com/sites/default/files/documentation/esp32_technical_reference_manual_en.pdf

The RMT RAM can be accessed via the APB bus. La doc ne semble pas parler de DMA pour de gros volumes à échanger.

Au départ, donc, une solution pour télécommandes IR (plus télécommandes ou messages courts via RF433MHz). Avec une souplesse, pour permettre toutes sortes d'encodages, à gérer par la CPU. Soit une souplesse pour étendre les capacités I/O de l'esp lorsque les performances vs charge CPU restent en adéquation.
« Modifié: décembre 25, 2024, 02:12:01 am par bk4nt »