Faire parler un Sharp PC-G850VS à Linux : interface Arduino Leonardo et application C#/Avalonia

Le Sharp PC-G850VS est un « pocket computer » du milieu des années 1990 : un petit ordinateur de poche programmable en BASIC, en assembleur Z80 et même en C, avec un afficheur de 24 caractères et un connecteur série 11 broches. Trente ans plus tard, l’envie reste la même : écrire un programme confortablement sur un PC moderne, puis l’envoyer dans le pocket — et récupérer ceux qu’on tape dessus. Voici comment je l’ai fait, d’abord en ligne de commande, puis avec une petite application de bureau en C#/Avalonia.

Le problème : un port série « à l’envers » en 5 V

Le connecteur du G850 n’est pas un port série standard. Il travaille en logique TTL inversée (le repos est à l’état bas) et en 5 V. Impossible de le brancher tel quel sur un adaptateur USB‑série classique sans inverser les signaux. Plutôt qu’un FT232 configuré via FTProg, j’ai choisi un pont très simple à reproduire : une carte Arduino Leonardo.

Pourquoi la Leonardo ? Parce que son microcontrôleur (ATmega32U4) gère l’USB nativement (port CDC, vu comme /dev/ttyACM0 sous Linux), et parce qu’elle est en 5 V, exactement comme le G850 — pas de diviseur de tension nécessaire. Un sketch minimaliste basé sur SoftwareSerial se charge de l’inversion de logique.

Le câblage

Trois fils de données suffisent, plus un petit pontage pour le contrôle de flux :

Enfin, les broches 4 (RTS) et 9 (CTS) du G850 sont reliées entre elles et tirées au +5 V via une résistance de 10 kΩ (n’importe quelle valeur entre 4,7 kΩ et 47 kΩ convient). Sans ce pontage, le Sharp attend indéfiniment un « prêt à recevoir » qui ne vient jamais.

Côté pocket, pas de connecteur propriétaire à dénicher : on soude les fils sur une barrette sécable de 11 broches au pas 2,54 mm (coupée à 11 contacts), qui s’enfiche directement dans le port du G850. On y câble RX, TX, GND et le pont RTS/CTS, la résistance de pull‑up du pont étant ramenée au +5 V (VCC) de l’Arduino Leonardo. L’ensemble se réalise en quelques points de soudure.

Côté firmware, tout tient en quelques lignes — la clé est le troisième paramètre true qui active la logique inversée :

#include <SoftwareSerial.h>
#define RX_PIN 8   // <- broche 7 du G850 (TXD)
#define TX_PIN 9   // -> broche 6 du G850 (RXD)

SoftwareSerial G850Serial(RX_PIN, TX_PIN, true); // inverse_logic = true

void setup() {
  Serial.begin(9600);       // port USB vers le PC
  G850Serial.begin(9600);   // port inversé vers le G850
}

void loop() {
  if (Serial.available())     G850Serial.write(Serial.read());   // PC -> G850
  if (G850Serial.available()) Serial.write(G850Serial.read());   // G850 -> PC
}

La liaison est en 9600 bauds, 8N1. La LED de la carte clignote à chaque octet qui transite : un indicateur bien pratique.

Premier test : en ligne de commande

Avant d’écrire la moindre interface, on valide le lien avec deux commandes Linux. On règle le port, puis on envoie un fichier :

stty -F /dev/ttyACM0 9600 cs8 -cstopb -parenb raw -echo
cat mon_programme.bas > /dev/ttyACM0

Et pour recevoir un programme que l’on sauvegarde depuis le Sharp :

cat /dev/ttyACM0 > capture.txt

Un détail compte : le G850 attend des fins de ligne en retour chariot seul (CR), là où Linux utilise un saut de ligne (LF). Un simple tr '\n' '\r' fait la conversion avant l’envoi.

Côté pocket, le transfert passe par l’éditeur de texte intégré, qui est une mémoire distincte de la mémoire BASIC. La manœuvre complète pour charger et exécuter un programme :

1. Sur le G850 : mode TEXT, éditeur vide, menu SIO → Load (il attend).
2. Sur le PC : la commande cat … > /dev/ttyACM0. Le texte se remplit dans l’éditeur.
3. Mode BASIC : NEW pour vider la mémoire BASIC de l’ancien programme.
4. Retour à l’éditeur, menu basic → « Basic ← text » : le texte est alors converti en programme BASIC.
5. Mode BASIC : RUN.

L’ordre compte : on fait NEW avant la conversion. En effet, « Basic ← text » ne remplace pas la mémoire BASIC : il la fusionne ligne à ligne. Si on convertit sans avoir vidé au préalable, le nouveau programme vient se superposer à l’ancien et les deux se mélangent.

Au premier RUN réussi — un petit programme qui demande un nom, compte jusqu’à cinq et fait biper le buzzer — on sait que toute la chaîne fonctionne, dans les deux sens.

L’étape confortable : une appli C#/Avalonia

Taper des commandes stty et cat à chaque transfert, convertir les fins de ligne à la main… ça va cinq minutes. J’ai donc développé un petit Sharp PC Connectivity Kit en C# avec Avalonia (le framework d’interface multiplateforme de .NET), qui tourne aussi bien sous Linux que Windows.

Ses fonctions :

• détection des ports série, connexion en un clic (9600 8N1) ;
• un éditeur central avec une bibliothèque rangée par langage (BASIC, C, assembleur Z80, texte) ;
• Envoyer ↑ / Recevoir ↓ vers et depuis le G850 ;
• surtout, la conversion des fins de ligne automatique : LF à l’écran et sur le disque, CR sur le câble. Fini les fichiers « _cr » en double — un seul fichier par programme sert aux deux sens.

Techniquement, l’application s’appuie sur System.IO.Ports pour le port série, encode les octets en Latin1 (correspondance 1:1 octet/caractère), et envoie par blocs de 64 octets avec une petite pause pour ne pas saturer le pocket. La normalisation des fins de ligne gère même le cas d’un CR/LF coupé entre deux paquets série.

Et ensuite ?

Le pont Arduino est parfait pour prototyper, mais l’étape suivante est un petit circuit imprimé dédié (USB‑C + inverseur matériel) pour se passer de la carte Leonardo et obtenir un adaptateur compact. En attendant, n’importe qui possédant un Sharp PC‑G850 et une Arduino Leonardo peut reproduire ce montage en une soirée — et redonner vie aux programmes de sa jeunesse.

Montage et logiciel testés sous Ubuntu ; le code de l’application est en C#/.NET 8 avec Avalonia.