Étiquette : brick

Dépannage EEPROM RTL-SDR

Genèse de cet article

Cet article vient en complément de l’article précédent : Dé-bricker une clé RTL-SDR. Je vous recommande ainsi vivement sa lecture, il fixe le contexte de celui-ci.

Je vais ainsi détailler dans cet article le cheminement que j’ai suivi pour résoudre cette panne en détaillant chaque étape, chaque échec, chaque avancée.

Cet article me sert également de mémento avec la liste des outils utilisés, programmes …

Contexte : Déclaration de la panne

Lors de l’utilisation de la clé je remarque que dans le bandeau de démarrage de rtl-sdr (rtl_test, rtl_fm, rtl_eeprom…) le nom affiché ne correspond pas exactement à ce que j’avais précédemment défini dans l’EEPROM plus d’un an plus tôt. Il y a un problème, peu grave et simplement esthétique visiblement. Ça me perturbe suffisamment pour me tenter de réécrire l’EEPROM afin de corriger ce problème. Lourde erreur.

J’aurais bien aimé pouvoir illustrer cela, cependant je ne m’attendais pas à devoir dépanner ma clé qui ne répondait plus 30 secondes plus tard …

J’exécute donc la commande suivant visant à modifier le nom de la clé RTL-SDR :

rtl_eeprom -d 0 -p "RTL-SDR of F4IIL"

Lors du résumé précédent la réécrite le soft nous présente la configuration actuelle et la future configuration. La configuration actuelle est bien complètement buguée mais la future est correcte. Je valide la réécriture. Aucune erreur n’apparaît et le soft me confirme que tout s’est bien passé, au rebranchement de la clé les changements devraient apparaître.

Passé cet instant la clé ne sera désormais plus reconnue par rtl-sdr sous linux. Sous Windows Zadig la reconnaîtra mais malgré plusieurs tentatives de réinstallation des drivers SDR# ne reconnaît plus la clé.
C’est le « drame ».

Première étape : Identifier l’EEPROM

Au vu du déroulé des évènements, il ne serait pas choquant que la réécriture de l’EEPROM effectuée précédemment soit à l’origine du problème (l’inverse serait choquant même …).

Je commence d’abord par inspecter le PCB de la clé RTL-SDR. Se dégage de ce circuit trois boitiers dont deux ayant une fonction purement RF. Le troisième à contrario après quelques recherches s’avère être une EEPROM : parfait, c’est ce que je cherche !
Le boitier de l’EEPROM est un SO-8, soit le seul boitier du circuit qui est facile à extraire sans trop de matériel.

Détail des composants de la clé SDR

Le schematic des clé RTL-SDR est trouvable en quelques clics sur internet et après passage sous la caméra loupe je confirme bien la référence de l’EEPROM : 24C02.

En poursuivant mes recherches, je trouve deux datasheet correspondant à la référence du composant : le premier de chez STMicroelectronics et le second de chez Microchip. La comparaison entre l’observation du circuit et le pinout décrit par le datasheet correspond.

Il s’agit donc d’une EEPROM de 2Kbits et fonctionnant grâce au bus
I2C. Ce type de mémoire étant assez répandu, il ne devrait pas être trop
dur de trouver des programmes Arduino déjà existant qui l’utilise.

Seconde étape : Lecture de l’EEPROM

Je trouve rapidement ce programme permettant la lecture et écriture d’EEPROM similaires grâce à une carte Arduino. (Internet est quand même un outil formidable quand on y pense. Comment s’en passer de nos jours ? Fin de parenthèse philosophique).

Je m’empresse d’extraire l’EEPROM et de la connecter à une carte Arduino trouvée au fond du tiroir à côté du bureau.

Je modifie le programme afin qu’il affiche dans le moniteur série un dump de la mémoire au format hexadécimal.

Le résultat obtenu ? Un bloc de 0xFF … J’ai donc deux possibilités, soit l’EEPROM a été complètement formatée avec des 1 de partout lors de l’utilisation de rtl_eeprom, soit le programme ne fonctionne pas.

HexDump obtenu au premier essai de lecture

Je modifie donc la ligne suivante avec une autre valeur :

byte rdata = 0x26; //0xFF par défaut

Compilation, téléversement … Paf un bloc de 0x26 …

Le programme a donc bien un problème. L’utilisation d’un scanner I2C écartera la possibilité d’une défaillance dans la communication avec la mémoire : la mémoire est reconnue et répond bien à l’adresse 0x50.

Après analyse du programme et des datasheet, j’en déduis que l’adresse des octets du programme exemple est codée sur 16 bits là où la mémoire de la clé RTL-SDR n’est codée que sur 8 bits. Modification du programme faite, la lecture et l’écriture de la mémoire fonctionne désormais.

Dans un premier temps pour analyser ce dump avec un interpréteur ASCII, je copie colle le contenu du moniteur série dans un fichier dump.hex. J’utilise ensuite la commande xxd afin de le transformer en fichier binaire me permettant d’utiliser hexdump pour l’analyser :

xxd -rp dump.hex dump.bin
hexdump -Cv dump.bin

On peut d’ailleurs simplifier ceci de la manière suivant, le résultat est identique :

xxd -rp dump.hex | xxd -

Ici c’est clairement du bricolage mais ça fonctionne donc … Je modifie juste après le programme afin qu’il effectue directement l’hexdump dans le moniteur série.

Troisième étape : Récupération d’un dump vierge

Et c’est à cet instant que je découvre que rtl_eeprom permet de réécrire l’EEPROM d’usine pour les clé RTL-SDR. Je tente alors de modifier le fichier source rtl_eeprom.c en le dissociant de la lib rtl-sdr. Un fois distinct, je peux le recompiler facilement avec gcc. Je le modifie pour qu’il m’affiche le contenu d’un dump vierge comme si on exécutait :

rtl_eeprom -g realtek_oem

Après ça, un peu de python pour mettre en forme le résultat obtenu et pouvoir l’insérer dans le programme Arduino. J’écris l’EEPROM avec ce dump. Je la ressoude temporairement à sa place : les pins 1 à 4 sont soudés ensemble avec un fil et relié à la masse, les 4 autres sont soudés sur leurs pastilles d’origine. Le laisser à moitié volant permet de le redessouder facilement au besoin (besoin il y aura).

Après avoir connecté la clé une première fois, j’ai des erreurs.
Après l’avoir connecté une seconde fois il m’indique se remettre à zéro, soit.
Après l’avoir connecté une troisième fois, ça marche !

Ça marche mais elle fonctionne sans EEPROM … Après avoir dessoudé l’EEPROM de nouveau, j’observe le même fonctionnement. Ceci donnera donc lieu à la première méthode de réparation dans le premier article. Cependant ceci pose quelques problèmes comme l’impossibilité de l’utiliser avec d’autres clés notamment.

Capture d’écran montrant le résultat de rtl_eeprom et rtl_test

J’aurais à ce moment voulu obtenir d’un autre possesseur de ce modèle
de clé un dump vierge mais étant trop impatient je décide de tester une
autre méthode : reflasher le dump à moitié corrompu que j’avais
soigneusement sauvegardé avant de vouloir remodifier le nom du produit
comme indiqué au début de cet article.

Second essai, ça refonctionne comme avant donc j’ai enfin fait un
retour à la case départ. Je procède ensuite au reflashage par défaut de
l’EEPROM grâce à l’option -g de rtl_eeprom. Voici ma clé RTL-SDR comme neuve !

Suite à cela j’enregistrerai un dump vierge qui m’a servi à insérer dans l’article précédent.

Conclusion

  • Coût : absolument rien, pas besoin d’acheter une nouvelle clé, un programmateur d’EEPROM plus ou moins cher ou d’autres composants
  • Durée : un peu plus de 2h30
  • Utilitaires utilisés : lib rtl-sdr, hexdump, xxd, gcc, python3 et Arduino
  • Matériel : Arduino UNO, 2 résistances, 3 fils et … c’est tout !

Ressources complémentaires :

Dé-bricker une clé RTL-SDR

Présentation de la panne

Parenthèse vocabulaire : j’utilise le terme « brick » pour désigner le problème parce qu’il est relativement bien approprié. Dans ce cas là, la clé SDR est comme morte, elle est inutilisable et ne répond plus. Il s’agit dans ce cas précis d’un brick de bas niveau.
Plus de détails : brick informatique.

Symptômes de la panne :

  • Sur Linux : la clé SDR n’est plus reconnue par aucun des outils comme rtl_test et retourne l’erreur suivante : « No supported devices found ».
  • Sur Windows : Malgré une réinstallation des drivers avec Zadig, la clé est absente des listes de périphériques compatibles dans les logiciels comme SDR#

Dans tous les cas la clé SDR fonctionnait avant l’incident. Cette panne est liée à une erreur lors de l’écriture de l’EEPROM avec rtl_eeprom par exemple.
Cependant dans mon cas, le contenu de la mémoire a été à moitié corrompu sans même que je n’ai fais quelque action bizarre … Vouloir réécrire l’EEPROM sans le bon outil a complètement brické ma clé SDR : cf l’article à venir sur les démarches concernant la réparation de cette panne, cet article n’est que la version tuto / synthèse de ces travaux.

Nous allons désormais voir comment réparer cette panne. Ici, nous allons distinguer 2 méthodes : la méthode simple pour la remettre en fonction mais qui éliminera la possibilité de stocker la configuration dans l’EEPROM, la seconde méthode restaure une configuration par défaut grâce à un programmateur externe.

Première méthode : la simplicité

La première méthode est assez radicale et se base sur le fait que la clé SDR n’a pas besoin de l’EEPROM pour fonctionner. Elle intègre dans son programme une configuration par défaut qu’elle utilise en cas de défaut de l’EEPROM.

Matériel nécessaire :

  • La clé SDR brickée
  • Un fer à braser avec ses accessoires (étain, flux…)
  • Petit outillage : pincettes, cutter, support de fixation …

Compétence nécessaire :

  • Brasure de composants CMS

Marche à suivre :

L’opération est simple, elle consiste à retirer l’EEPROM du circuit de la clé SDR.

Détail des composants de la clé SDR

L’EEPROM utilisée par les clé SDR de ce type est une mémoire I2C de référence 24C02 de 2Kbits.

Je vous laisse procéder comme bon vous semble pour retirer ce composant. Cela va de soit qu’il faut faire ça proprement, ne rien casser ou détériorer autour. Une fois le composant retiré, vous pourrez passer un petit coup de tresse à dessouder puis d’alcool pour rendre la clé comme neuve.

Quand je dis neuve, c’est comme si ! Vous pouvez maintenant la reconnecter à votre ordinateur et devriez obtenir le résultat suivant :

Capture d’écran montrant le résultat de rtl_eeprom et rtl_test

La clé SDR fonctionne de manière nominale, excepté les fonctionnalités de l’EEPROM. Cela a pour conséquence cet étrange numéro de série. On peut évidemment tester avec GQRX par exemple :

Catpure d’écran de GQRX avec la clé SDR sans EEPROM

Il vous faudra peut-être sous Windows remettre à jour les drivers avec Zadig (simple supposition, je n’ai pas essayé).
Et voilà, vous pouvez réutiliser votre clé SDR comme bon vous semble !

Seconde méthode : la plus complète

La seconde méthode aura pour objectif de restaurer l’EEPROM dans sa configuration par défaut, sortie d’usine. Pour cela il va falloir la reprogrammer manuellement.

Matériel nécessaire :

  • La clé SDR corrompue
  • Un fer à braser avec ses accessoires (étain, flux…)
  • Petit outillage : pincettes, cutter, support de fixation …
  • Un Arduino (qu’importe le modèle)
  • Du fil fin ou un système permettant de connecter le boitier SO-8 de l’EEPROM à une breadboard par exemple
  • Un ordinateur avec l’IDE Arduino installé
  • Les sources avec les dumps et programmes téléchargeable à l’adresse suivante : dépôt GitLab

Compétences nécessaires :

  • Brasure de composants CMS
  • Programmation de cartes Arduino

Marche à suivre :

Tout d’abord la démarche est très similaire à la première méthode, il va falloir extraire l’EEPROM du circuit afin de pouvoir la connecter à l’Arduino.

Une fois la mémoire extraite, connectez là à l’Arduino suivant le schéma suivant avec la technique de votre choix :

Schéma de câblage pour programmer l’EEPROM

Attention l’EEPROM s’alimente en 3,3V (même si il semblerait qu’elle supporte tout aussi bien une alimentation en 5V). Les résistances ont pour but de limiter le courant … Ici un levelshifter 3,3-5V bidirectionnel est peu-être plus adapté … Les pins 1 à 3 sont utilisés pour l’adresse I2C de la mémoire, tous à la masse nous donnera pour adresse 0x50. Les pins 4 et 8 sont l’alimentation. Le 5 et 6ème pins sont le port I2C donc SCL et SDA respectivement. Enfin, le 7ème est une protection à l’écriture des données. Cette entrée peut rester volante ou à défaut être tirée à la masse.

Pour ma part j’étais dans la recherche et l’expérimentation donc un montage volant à partir de fil monobrin très fin (récupéré d’un vieux câble téléphonique aérien abandonné salement par des techniciens près de chez moi …) et ça fait très bien l’affaire !

Ma réalisation artisanale, rapide et efficace …

Désormais nous pouvons charger le programme présent dans les sources dans l’IDE Arduino. Ce programme se divise en deux partie. La plus grosse concerne la lecture des données contenues dans l’EEPROM et son affichage dans le moniteur série sous le format équivalent à un « hexdump -Cv » afin de permettre la lecture facile. La seconde intègre la fonction d’écriture de données, une écriture sera toujours suivie d’une lecture afin de s’assurer que l’opération s’est bien déroulée.

Nous allons dans un premier temps laisser commenté la ligne suivante, en début de fichier, comme elle l’est par défaut :

//#define REWRITE

Nous compilons le programme et le téléversons sur l’Arduino. Nous ouvrons ensuite le moniteur série et observons le résultat obtenu.

Capture d’écran du dump obtenu avec ma clé SDR

Voici ci-dessus le résultat que j’obtiens. Il ne faut pas tenir compte de la première ligne qui avait au moment de la capture déjà fait l’objet de tests d’écriture. J’observe là que les 2 et 3èmes lignes n’ont absolument aucun rapport avec la configuration que j’avais entré, les données ont été altérées.

Si vous ne parvenez pas à lire les données de l’EEPROM, revérifiez votre câblage puis à l’aide d’un Scanner I2C vérifiez que la mémoire est bien reconnue. Vous devriez voir apparaître le résultat suivant :

Capture d’écran du résultat escompté du scanner I2C

Une fois ces constatations faites, nous allons pouvoir réécrire l’EEPROM avec un dump propre et vierge. Pour cela nous décommentons la ligne vue précédemment, téléversons notre programme et ouvrons le port série. Nous devrions obtenir le résultat suivant :

Capture d’écran montrant un dump vierge correctement écrit

Si vous possédez une clé RTL-SDR.COM V3, décommentez la ligne suivante pour flasher la dump la plus adapté à votre matériel.

// #define isRTLSDRV3

Si vous rencontrez des difficultés lors de l’écriture, mettez le pin 7 à la masse et retestez.

Voilà, notre EEPROM est comme neuve, il va désormais falloir la braser de nouveau sur notre clé SDR et tester le tout. L’exécution des commandes « rtl_eeprom » et « rtl_test » va nous permettre de vérifier que l’ensemble refonctionne correctement.

Dans mon cas tout est correct, l’EEPROM est correctement reconnue et les paramètres ne sont pas corrompus. Je me suis donc permis de rajouter ma touche perso à ma clé comme on le voit sur la capture ci-après.

Capture d’écran montrant le résultat de rtl_eeprom et rtl_test

Voilà, votre clé est tout neuve et à l’avenir vous ferez sûrement plus attention lors que la réécriture de ce type de mémoire qui peut bricker l’appareil assez facilement en cas de problème …

Je remercie James et Gilles de m’avoir fait parvenir le dump pour la clé RTL-SDR.COM V3 me permettant de l’ajouter à cet article.

Ressources complémentaires :