Clone DIY d’un sharp CE-125

Mon fils, pour qui j’avais construit un petit tank lorsqu’il avait 5 ans pour apprendre à programmer des séquences de déplacement, a bien grandi 😉 Maintenant du haut des ses 11 ans, il souhaite apprendre à programmer en BASIC sur mes vieux pocket-pc Sharp des années 80. Pour éviter de tripoter mes précieuses vieilleries, je lui ai trouvé sur ebay un pc-1262 ainsi que son périphérique « tout en un » un superbe ce-125 qui à l’époque était une sorte de mini rolls-royce avec son lecteur/enregistreur de microcassettes pour charger/sauvegarder les programmes et cerise sur le gâteau: son imprimante thermique non graphique affichant 24 caractères par ligne (la classe !!).
Toutefois, si le CE-125 est une belle petite bête qui vieilli bien, il souffre de plusieurs petits soucis: la sauvegarde magnétique peut rapidement devenir inopérante (courroies des vieux lecteurs de cassette, encrassement,) et surtout aucune conversion vers un format textuel quelconque pour modifier (sur un mac ou un pc) puis pour ré-injecter dans la pocket pc. Idem pour l’imprimante dont il est quasi impossible de trouver des pièces, sauf à en vampiriser une autre… mais bon les prix commencent à grimper….

L’idée a donc germé de pouvoir réaliser un clone maison pour a minima imprimer et sauvegarder les programmes en wave ou mp3.
Après de longues recherches, car il y a peu de prose sur le sujet,  j’ai pu trouver de concevoir et mettre en oeuvre mon projet. En l’occurence il s’agit du site http://pocket.free.fr qui m’a permis de découvrir la suite d’outils PocketTools (avec les sources) qui sont désormais maintenu sur une site allemand https://www.peil-partner.de/ifhe.de/sharp/. Cette suite est totalement bluffante, puisque qu’elle permet via un ensemble de binaires et de scripts d’enregistrer via le port Sharp pour magneto-cassette en format wav puis de convertir le fichier en texte. Elle permet également de faire l’inverse et de diffuser toujours via ce port d’interface sharp un fichier texte convertit en wav. Donc bien au delà de mes espérances !!! Et comme les sources sont en C Ansi, il est possible de tout compiler sous linux, donc sur un raspberry PI,en y ajoutant une carte carte son usb à pas cher 😉
En ajoutant un petit shield LCD 2×16 caractères comme celui-ci, il y a de quoi réfléchir une IHM minimaliste en python ….
La partie sauvegarde/chargement des programmes étant faite, il ne restait plus qu’à trouver comment imprimer….. J’ai pu trouver mon bonheur sur le site de Walter Fischer et en l’occurence de quoi connecter un Arduino, toujours à ce même port Sharp à 11 pins, afin sortir le le port USB/série de l’arduino. A partir de là rien de plus simple que d’utiliser une petite imprimante thermique comme celle d’adafruit qui fournit une bibliothèque simple d’emploi.

donc si l’on résume voila ce que cela donne sur le papier:

 

 

 

 

 

 

 

Pour l’arduino, je suis reparti du code de Walter Fischer en l’adaptant à mes besoins. C’est à dire, de faire en sorte que quelque soit le modele le pocket pc (hors série PC-1500 et hors série 1211) l’arduino puisque interpréter correctement la trame de synchro d’avant impression (de plus les pin utilisés diffèrent selon le modèle de pocket-pc) puis celle d’impression (qui utilise toujours les deux mêmes pin Dout pour la réception et ACK qui acquitte chaque bit reçu)

le code est dispo sur github comme à l’accoutumée:
https://github.com/Chnalex/arduino/blob/master/sharp_imp.ino

voici un premier test sans imprimante avec un script python coté raspberry pour écouter la sortie série de l’arduino:

Pour réaliser quelque chose de correct, j’ai fait l’acquisition d’un câble Sharp EA-129C (câble avec deux connecteur mâle 11-pin Sharp) et j’ai bricolé une plaque de test pour à la  fois sortir vers la carte son du raspberry (mic et ligne) et vers les pins de l’arduino. Pour la partie son je me suis inspiré de ce schéma

Voici l’ensemble, dans un boitier que j’ai fait découper au laser dans de l’acrylique comme j’en ai l’habitude chez formulor.de.
On y retrouve donc, la plaque « à trous », l’imprimante, l’arduino et le rasberry pi muni de son shield lcd (mais que l’on ne voit pas, car il est face contre terre

Le programme en python est plutôt simple, il ne sert qu’à gérer la sauvegarde et le chargement via le truchement de deux scripts mis en oeuvre lors de la compilation de PicketTools (csave et cload -> à l’identique des commendes lancées sur le pocket pc) et qui sont appelés par la commande python os.system(commande).
L’ihm permet de naviguer entre les menu, choisir le modèle de pocket pc, saisir un nom pour le fichier au sauvegardé ou lister les fichiers présents sur la clé usb montée sur /media/usb0. Afin d’éviter d’avoir à gérer le montage démontage des clés depuis le scripts python, j’ai installé usbmount qui gère cela très et de manière automatique

le code du script:
https://github.com/Chnalex/arduino/blob/master/sharp_lcd.py

et hop, une petite video de sauvegarde

une autre d’un chargement

et une petite dernière de l’impression

Pedalboard midi avec un arduino Uno

Ayant investi dans un soft de modélisation d’amplis et d’effets sur mon mac pour ma guitare (Bias FX2 <- que je recommande vivement), je me suis vite confronté à un problème… comment, sans me faire greffer une troisième main, pour activer un effet ou interagir avec (comme avec une wahwah par exemple) ? Avec un pédalier d’effet, on ne se pose pas la question, puisque l’on se sert des ses pieds!!

Et bien, c’est simple, une seule réponse le protocole MIDI ! Ce protocole inventé au mitan des années 80 a permis de décorréler l’instrument sur lequel on joue, du son qui est produit (Cf clavier/séquenceur). Pour les pédaliers des guitares le même principe s’applique. Celui-ci devient une sorte l’élément passif qui envoie des commandes d’activation/désactivation ou de modulation à l’équipement qui peut les traiter (ampli à modélisation avec entrée midi, soft).
Après avoir fait le tour des produits du marché j’ai considéré que le cout d’un pédalier MIDI était plutôt disproportionné par rapport au prix de mon soft (plus de 300 euros le pédalier contre un peu moins de 100 pour mon soft….). Et puis, j’avais dans mes cartons une pédale wahwah Jim Dunlop JH-1 dont j’avais fait l’acquisition vers 1994 (hum hum cela ne me rajeuni pas) et dont le son (même après changement du potentiomètre interne)  était un peu cracra (trop de souffle et crachoteuse -> bof). Donc pourquoi ne pas tenter l’aventure avec un arduino, en partant du postulat qu’il y avait bien un fêlé quelque part sur cette terre qui avait eu l’idée de créer un bibliothèque midi pour cette plateforme (j’y reviendrai après). La réponse est oui, c’est possible !!! 

 

 

J’ai donc désossé le contenu de la wah pour ne garder que le potentiomètre et interrupteur on/off.

 

 

 

 

 

Et puis quitte à faire un truc sympa, j’ai voulu accoupler à la pédale un boitier pour y accueillir des boutons poussoirs robustes (j’ai des gros pieds) et quelques leds. Le tout m’est revenu à moins de 40 euros en comptant l’arduino (un vrai pas une copie). Comme la place à l’intérieur de la pédale est relativement comptée, j’ai choisi de placer l’arduino dans le boitier alu.

 

 

 

 

fixation à l’allemande ! 🙂

comme ça je peu appuyer bien fort avec les pieds !

 

 

 

 

 

 

 

 

Oh le beau paquet de nouilles 🙂

bon ok, j’aurai pu faire plus esthétique. Mais au final c’est fonctionnel et robuste 

 

 

 


De manière schématique, voila ce que cela donne

Sur le fond, la programmation est plutôt simple. On capte chaque appui sur un bouton poussoir pour changer l’état d’une variable de 0 vers 1 ou de 1 vers 0. En fonction de l’état de cette variable on allume ou non la led correspondante. Dans la pratique : j’appuie sur un bouton poussoir, la led s’allume, je ré-appuie, la led s’éteint. Du point de vue du potentiomètre, le principe est simple également. On l’utilise comme pont diviseur de tension et on capte la valeur de la tension correspondant à la position de celui-ci.
Dans la foulée, on envoie un signal midi sur le port usb pour indiquer le changement d’état.
Du point de vue du protocole midi, il y a en gros deux grandes catégories: les notes et les commandes (control change). Dans le cas d’un pédalier pour guitare, le plus logique est d’envoyer une commande. Celle-ci fait référence à un canal (un par appareil midi pour faire très simple), un contrôleur (un bouton, un switch, un potentiomètre) et une valeur (0=off, 127=on ou toute valeur entre 0 et 127 pour moduler la valeur -> volume, pitch, wah, etc).
Pour ce pédalier il y a donc 6 contrôleurs (4 boutons poussoirs mais vu comme des inters -> Cf plus haut, 1 inter-> celui d’origine de la wah et le potentiomètre de position de pédale). 

Pour la bibliothèque  midi, le mieux est d’utiliser celle-ci qui est plutôt récente.

Jusque là tout va bien…. mais c’était trop beau 🙂 

Sorti de l’ombre, arrive le problème du port USB….
Et oui sur un arduino Uno récent, le port USB se comporte comme une émulation de port série grâce au chip annexe fourni par ATMEL -> microcontroleur atmega16u2. Les plus vieux modèles, équipés de ftdi ou les copies chinois sur base CH340G, ne peuvent d’ailleurs pas faire autre chose que du serie sur USB hardware, alors que le 16u2 possède un firmware (donc reflashable) pour faire le job. Sur les Arduino micro et le léonardo, c’est different, mais le principe reste le même : c’est le microcontroleur principal (ATmega32u4) qui gère le port USB.
Bref, tout cela pour dire qu’il faut sortir du mode « port série » sur l’USB pour passer en mode HID (human inerface device) pour faire de l’USB-MIDI.
Si sur le micro ou leonardo, il n’y a rien à faire que d’utiliser la bibliothèque USB-MIDI qui va bien. Pour le Uno l’opération est un peu plus compliquée….. il va falloir flasher le 16u2 avec un firmware qui permet ce mode. 

Dans les faits ce n’est pas très compliqué, il suffit sur le port ISCP2 du Uno de mettre le pin RST à la masse puis d’utiliser un programme comme dfu-programmer pour pousser le nouveau firmware (d’abord erase puis ensuite flash).

Le firmware HIDUINO est le plus connu, mais il à un gros défaut… il ne sait gérer que le mode HID et ne possède pas de double boot pour passer en mode série. Résultat des courses : s’il l’on souhaite modifier son code sur l’arduino, il faut reseter le16u2, effacer le firmware, reflasher le firmware port série, pousser le programme corrigé avec l’IDE, reseter le 16u2, refsher le firmware HIDUINO et finalement tester les modifs…. de quoi devenir fou rapidement…….
Le plus simple a été de compiler un firmware avec double boot via le site « pimp my mocoLUFA » (le firmware est dispo sur mon espace github). Avec ce firmware, il suffit de mettre le pin4 de l’ISCP2 à la masse pour que le 16u2 boot en mode série et d’enlever cette mise à la masse pour qu’il boot en mode HID 🙂

Le code Arduino est dispo comme toujours sur github, il est très compact et tient en moins de 180 lignes:

https://github.com/Chnalex/arduino/blob/master/pedalboard_alex.ino

Voila ce que la donne dans la vraie vie (bon avec les mains pour la video, mais en principe c’est aux pieds…)

 

retrofit radio 70’s – DAB+

img_2196

Avec l’arrivée imminente du DAB+ dans ma région, ainsi qu’après le coup de jeune de l’agencement de notre cuisine (merci ikea), il est état temps de revoir le concept de ma radio DIY.

Comme j’avais envie de quelque chose qui ressemble à une vraie radio, mais qui devait avoir un peu de style (sans faire trop industriel ni trop plastique), je me suis mis à la recherche d’une radio ancienne. Après de longues recherches sur Ebay + Leboncoin et plusieurs hypothèses d’aspect (40’s, 50’s, 60’s, 70’s ou 80’s) mon choix s’est porté sur une radio typée 70’s pour trois raisons: c’est la dernière décennie où il était possible de trouver un boitier bâti avec des matériaux un peu nobles (bois, acier chromé), la généralisation du transistor depuis le milieu des années 60 faisait que les boitiers n’étaient pas trop volumineux (pas envie d’un truc de la taille d’un demi lave-vaisselle au milieu de la cuisine) et enfin, les formes de la hifi au sens large de cette décennie (70’s) était plutôt anguleuses et moins extravagantes que dans les 60’s où l’arrivée des moulages plastiques avait généré de nombreuses formes façon bio-design que l’on retrouva dans le monde de l’automobile des 90’s (bof bof).
C’est donc pour une poignée d’euros (une quarantaine) que j’ai pu acquérir via un vendeur belge (ebay) un magnifique poste KOYO 1661 qui marchait encore.
Mais il m’a fallu le désosser…..Argh !!!

img_2195

 

img_2194

img_2200

Je lui ai offert ensuite une nouvelle jeunesse !

 

 

 

 

ponçage des bois au grain 400 pour enlever le vernis hors d’âge, puis à la paille de fer pour l’aspect.
Passage au vernis nitrocellulosique en bombe + paille de fer + nouvelle couche de vernis pour redonner un fini bien lisse et satiné (façon bois ciré).

 

Pour les parties noires… un petit coup de peinture en bombe « noir mat » avec masquage du reste.

 

 

 

 

 

 

 

Certes, l’aspect extérieur cimg_2197ompte beaucoup dans cette opération, mais ce n’est pas l’essentiel. Le but reste quand même de capter le DAB+ dans ma cuisine !
Pour ce faire, je me suis tourné vers une solution pré-packagée, enfin presque…
Il s’agit en l’occurence d’un shield pour arduino baptisé dab shield et dialoguant via un port spi. Celui-ci est vraiment de bonne facture et possède deux gros avantages: il est livré avec une bibliothèque (ce qui est bien pratique) et son tuner embarqué est comptable DAB+ et FM ! Par contre, la bibliothèque est plutôt gourmande et j’ai du utiliser un arduino uno rev2 (basé sur un ATmega4809) que j’avais sous la main et qui offre une capacité de stockage 50% supérieur à un arduino uno classique. Ce n’est pas non plus folichon, on passe de 32kB à 48 kB, mais c’est suffisant pour héberger le programme qui dépasse les 30kB. Cerise sur le gâteau, la connectivité wifi permettra par la suite de potentiellement prendre le contrôle de l’arduino à distance (changer de station radio par exemple)

Bon recevoir la radio c’est bien, mais encore faut-il choisir une station, afficher ses caractéristiques (fréquence, nom etc..) et le principal: l’entendre. Pour réaliser ces trois opérations, l’idée était donc d’utiliser un encoder rotatif pour réaliser les opérations de navigation et de validation, un afficheur LCD  et enfin un ampli class D mono pour le son.

 

img_2192

Je m’attarde un peu plus sur l’écran LCD. J’ai voulu tester (et franchement, ça vaut le coup) un écran dit « intelligent » piloté par un port série. J’ai choisi un nextion NX4827T043 pour ce faire.

Alors comment cela fonctionne ? C’est plutôt simple: via un soft propriétaire sous windows (merci vmware sur mon mac) on conçoit un ensemble d’écrans avec différents types de zones (image, texte, texte défilant, barre de progression, vu-mètre…). Chaque écran (frame) possède son propre agencement de composants. Une fois l’ensemble conçu, il est compilé dans le soft puis transmis via le port série dans l’afficheur. Une fois cette opération faite, le port série permet d’interagir avec l’afficheur (changement d’écran, affichage de données dans les zones définies, etc..). coté Arduino la bibliothèque EasyNextionLibrary permet de simplifier au maximum ces opérations.

NB: pour le look, j’ai voulu reproduire l’aspect des vieux magnétoscopes avec leurs afficheurs VFD

Voila ce que cela donne en récupérant des données FM-RDS depuis le shield DAB et en les injectant dans l’afficheur via le port série.

img_2210Début de l’intégration de l’ensemble dans le  boitier :

vue de l’arrière:

img_2208

Voici le résultat final :-)) en situation dans la cuisine

img_2230

comme toujours, le code est dispo sur github:

https://github.com/Chnalex/arduino/blob/master/radioduino2.ino

domotique -> rationalisation !

img_0391

Après une coupure de courant à la maison, mon précédent montage de domotique à connu… un petit soucis.
En oui, quand l’arduino qui pilotait les registres à décalage qui étaient en cascade (et suivi d’un ensemble de relais) a subi quelques bagots d’alimentation, il s’est produit un phénomène plutôt gênant que je m’explique encore mal dans les détails. Pour faire simple, la coupure à remis mes volets en mode apprentissage (procédure normale chez somfy) et s’est combinée à des activations intempestives des relais qui ont fait pedre l’ensemble des appairages aux volets (argh !!!). La piste, que je retiens, est liée à l’état indéfini des pins de l’arduino au moment du boot, suivi d’un effet de logique inversée sur les relais (+5v= relais « off » et 0v= relais « on »). Bref j’ai perdu beaucoup de temps à tout faire rentrer dans l’ordre, volet par volet.
Ce fut donc le coup de grâce de mes 27 relais (9 volets + 3 fonction par volets -> 9×3 >27 relais). L’idée maitresse était de trouver de quoi hacker une télécommande usine ou trouver un émetteur 433,42mhz (<- spécialité somfy puisque habituellement on trouve plutôt des émetteurs en 433,92mhz) afin de faire simuler par l’aduino: l’ID de chaque volet ainsi que son rolling code (simple incrément d’un nombre à chaque appui sur un la télécommande -> chiffre en mémoire à la fois sur le volet et sur le télécommande qui permet d’offrir une petite sécurité supplémentaire si l’ID de la télécommande venait à être copiée). Après de multiples et longues recherches sur le net, j’ai pu trouver un post sur le forum Arduino  et qui offrait une bibliothèque ainsi que de quoi se débrouiller avec une télécommande d’origine (by pass du microcontroleur à bord et interfaçage direct d’un pin de arduino sur l’émetteur). Le graal était trouvé !!!!!!

img_0393

 

Au passage, j’en ai profité pour changer le raspberry pi 1 qui servait à gerer l’IHM (python pygame et serveur apache/php) par un raspberry pi zero muni d’un petit hub micro-usb offrant un port ethernet 10/100.
Au final et comme les volets somfy RTS sont conçus pour accepter plusieurs télécommandes en parallèle, la domotique gère désormais un pool de 9 télécommandes virtuelles avec chacune une ID et un rolling code qui bouge (stockés dans l’EEPROM de l’arduino)

 

img_0392

Toutefois, il ne m’est pas possible de me passer de relais physiques, ne serait-ce que pour piloter mon poêle à granulés. Mais chat échaudé… j’ai pu trouver un petit module I2C spécifique pour gérer un bloc standard de 8 relais…. donc fini les relais qui claquent sans raisons !!!

 

 

 

 

 

 

le code de cette nouvelle version est disponible sur github:

https://github.com/Chnalex/arduino/blob/master/nouvelle_domotiquev2.ino

 

img_0395

 

Radio-réveil en bois…

20171230_174605

Mon radio-réveil ayant presque rendu l’âme, j’ai voulu construire moi-même le nouveau, mais en bois !!! Enfin presque ….
Je suis parti d’une base de boite à bijou, en bois brut, trouvée au rayon « loisirs créatifs » d’une grande chaine.

Jolies boite certes.. mais un peu triste. Comme l’aspect extérieur devait être sympa (quasi la première chose que je vois le matin.. après ma femme bien évidement 🙂 ), j’ai profité de la possibilité offerte par formulor.de d’utiliser un contre-plaqué de bouleau de 0.8mm (Cf. mes autres réalisations avec un casing fabriqué à partir de plaques d’acrylique découpées sur CNC laser) afin de réaliser un plaquage avec découpe et gravures sur deux faces (dessus et frontale).

img_1275

 

Pour l’électronique, rien de révolutionnaire pour le coup. Je suis parti de mon expérience avec la « RadioDuino » de ma cuisine. Le hardware est donc bâti à partir d’un arduino (un nano cette fois), d’un afficheur lcd 4×20 piloté par bus I2C, d’un tuner FM si4703 vendu par Sparkun (piloté également par bus I2C) et un petit ampli mono classe D basé sur un TPA2005D1 qui délivre 1.4W sous 8ohms.

20171230_174059

 

 

 

 

 

 

 

Afin de minimiser le nombre de pins utilisés sur l’arduino j’ai utilisé le principe des boutons poussoirs en parallèles munis, en série, d’une résistance afin de créer une pont diviseur de tension. Au final un seul port analogique permet de mesurer une tension différente pour chacun des boutons.

img_1596

Le changement d’heure d’été/hiver est assuré comme sur la domotique par la lecture régulière (chaque jour pendant la nuit) d’une table de dates de passage d’un mode à l’autre (déjà utilisé sur la domotique).

Pour la partie soft, le plus dur a été de trouver une police de très grand taille (en réalité une police composé de 3×3 caractères). Je me suis inspiré de l’article suivant: https://forum.arduino.cc/t/lcd-bigfont-numbers-over-2-or-4-lines/44538/12
en utilisant cette possibilité offerte par les afficheurs (sur base de contrôleur Hitachi HD44780) de pouvoir définir jusqu’à 8 caractères personnalisés (stockés dans la table interne du contrôleur sur les caractères de 0 à 7). 

les 10 chiffres utilisés sont stockés au sein de 3 tableaux de 10×3 valeurs. Par exemple pour afficher le chiffre 4 selon l’extrait de code ci-dessous, il suffira d’envoyer les caractères suivants (3 par ligne):
255,16,255
4,2,255
16,16,2

 

 

Ici les caractères 2 et 4 font partie de ceux crées. 255 est un rectangle plein (symbole en bas à droite du tableau ci-dessous b11111111) et le 16 un espace (1 symbole de la 3ème colonne b10000).
table ascii interne du controleur:

hd44780_characters_map

 

 

 

 

L’intégralité du code est disponible comme pour mes autres projets sur GITHUB:

https://github.com/Chnalex/arduino/blob/master/radio_reveil.ino

img_1597