Une collection de terminaux ANSI : 10 étapes

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:06

Ce projet a commencé comme un moyen d'afficher du texte de 80 colonnes sur un écran LCD adapté à l'exécution d'un traitement de texte à l'ancienne tel que Wordstar. Divers autres écrans ont été ajoutés, allant de 0,96 à 6 pouces. Les écrans utilisent un seul PCB ainsi qu'un sketch/programme Arduino.

Il y a une connexion série RS232 pour la connexion à un ordinateur et une prise PS/2 pour un clavier. Les présentoirs ont été choisis pour représenter ceux couramment disponibles à des prix raisonnables. Selon la mémoire nécessaire, les écrans utilisent un Arduino Nano, Uno ou Mega.

Étape 1: Résumé des affichages

Il existe différents écrans avec une résolution de 480x320. Cela permet une police de 9x5 et un texte de 80 colonnes. Il existe différentes cartes avec une résolution de 320x240, avec des polices 9x5 et également une très petite police 7x3 pour permettre un texte de 80 colonnes. Il existe également des cartes plus petites avec 160x120 et 128x64 pixels. Également des affichages de texte 20x4 et 16x2, et enfin un tableau d'affichage en étoile à quatorze segments 12x2.

Certains écrans utilisent I2C, certains sont SPI et pour les écrans plus grands, un bus de données 16 bits pour des vitesses de mise à jour plus rapides.

Les écrans plus petits utilisent l'Arduino Uno. Les cartes plus grandes ont besoin de plus de mémoire et utilisent donc un Mega. Le tableau d'affichage Starburst utilise un Nano.

À ce stade, je pourrais mentionner que les photos ne rendent pas justice à la plupart des écrans. Le petit écran oled blanc est très net et lumineux, ce qui complique la mise au point de l'appareil photo, et l'écran à LED Starburst semble beaucoup plus net dans la vraie vie.

Étape 2: Matériel

Le PCB a été conçu pour fonctionner avec autant d'écrans que possible. Il est facile de basculer entre un Mega et Uno à l'aide de quatre cavaliers. Il existe des résistances diviseurs de tension pour les écrans fonctionnant sur 3V. Les broches I2C sont sorties en groupe afin que les écrans puissent être branchés directement. Le terminal fonctionne à 9600 bauds, et bien que cela puisse être augmenté, la plupart des écrans plus grands ne seront pas redessinés beaucoup plus rapidement que cela. Le clavier PS2 se branche sur une prise DIN6. Les claviers USB fonctionneront également avec un adaptateur bon marché. Vous pouvez faire un simple test de bouclage en joignant les broches 2 et 3 sur le D9, puis les caractères tapés sur le clavier apparaîtront à l'écran.

Dans certains cas, un PCB n'est pas nécessaire et il est possible de faire fonctionner les choses avec des modules préfabriqués disponibles sur ebay, par exemple des adaptateurs PS2, des cartes adaptateurs RS232 et des écrans qui se branchent directement sur des cartes arduino.

Il existe également un tableau séparé pour l'affichage led starburst - voir plus loin dans ce Instructable.

Étape 3: Logiciel

Vous trouverez ci-dessous un fichier appelé Package.txt. Il s'agit en fait d'un fichier.zip, alors téléchargez-le et renommez-le (Instructables n'autorise pas les fichiers zip). Le sketch/programme Arduino est inclus et il s'agit d'un programme unique utilisé par tous les écrans. Il existe également tous les fichiers.zip pour chacun des écrans.

Au début du programme se trouve une série d'instructions #define. Décommentez celui qui correspond à l'affichage. Utilisez Outils/Tableau pour sélectionner Uno, Mega ou Nano. Changer de carte est aussi simple que de changer une ligne dans le code.

L'un des défis liés à l'utilisation de nombreux écrans est qu'ils semblent tous avoir besoin de leurs propres pilotes logiciels. Ceux-ci sont tous inclus dans le package. Les tests comprenaient la prise du package et sa réinstallation sur une nouvelle machine à partir de zéro. Vous pouvez également sourcer du code à partir de Github et Adafruit et LCDWiki. Il y a quelques cas où les nouvelles versions ne fonctionnent pas, donc toutes les versions de travail sont incluses dans le zip. Parfois, il y avait des cas où un pilote en arrêtait un autre car ils utilisaient le même nom de fichier mais des versions différentes. Il y a une description dans les commentaires en haut du programme montrant comment installer chaque pilote. La plupart sont installés à partir de l'IDE Arduino avec Sketch/Include Library/Add ZIP Library et cela prend le fichier zip et le met dans c:\users\computername\mydocuments\arduino\libraries.

Si vous n'utilisez qu'un seul écran, certaines de ces bibliothèques n'auront pas besoin d'être installées. Au minimum, vous avez besoin des deux fichiers de clavier et de celui pour l'affichage particulier. Certains écrans partagent le code. Il y a des instructions plus détaillées dans les commentaires en haut du programme, y compris l'obtention de la bibliothèque gfx d'Adafruit.

Comme tous les écrans utilisent le même croquis Arduino, le changement d'écran consiste simplement à décommenter l'une des lignes ci-dessous:

// Différents affichages, laissez l'un des non-commentés suivants #define DISPLAY_480X320_LCDWIKI_ILI9486 // 3,5", 480x320, texte 80x32, méga, 16 bits, se branche sur méga 36 broches (et 2 broches d'alimentation).https://www.lcdwiki.com /3,5 pouces_Arduino_Display-Mega2560. Plus lent que certaines des options ci-dessous mais une police plus lisible et un écran plus grand, démarrage en 5 secondes //#define DISPLAY_480X320_MCUFRIEND_ILI9486 // 3,5", 480x320, texte 80x32, méga, police 5x9, uniquement pour méga mais utilise juste les broches uno, alimentation, D0-D14, A0-A5, police plus agréable que le module ssd1289 40 broches mais beaucoup plus lente https://www.arduinolibraries.info/libraries/mcufriend_kbv https://github.com/adafruit/Adafruit -GFX-Library //#define DISPLAY_320X240_MCUFRIEND_ILI9341 // 2.4", 320x240, text 53x24, mega //#define DISPLAY_320X240_SSD1289_40COL // 3.5", 320x240, text 40x20, mega, bibliothèque UTFT (pas de polices inférieures à 8x12). Rapide //#define DISPLAY_320X240_SSD1289_53COL // 3,5", 320x240, texte 53x24, police méga, 9x5, peut modifier la police. Rapide //#define DISPLAY_320X240_SSD1289_80COL // 3,5", 320x240, texte 80x30, méga, minuscule police 7x3, peut modifier la police, pilote plus rapide que les deux ci-dessus, le plus rapide de tous en tant que lecteur direct 16 bits vers l'écran plutôt que spi/i2c //#define DISPLAY_160X128_ST7735 // 1.8", 160x128, text 26x12, uno (ILI9341) SPI 128x160 //#define DISPLAY_128X64_OLED_WHITE // 0.96", 128x64, text 21x6, mega, I2C, oled white on black (la bibliothèque tft pour cette carte plus tout le code plus le clavier manque de stockage de programme, même si les besoins en RAM sont très petits, donc seulement fonctionne sur un méga) //#define DISPLAY_20X4 // texte 20x4, uno, LCD avec I2C, texte LCD https://www.arduino.cc/en/Reference/LiquidCrystal //#define DISPLAY_16X2 // texte 16x2, uno, se branche sur uno, utilise les broches 4 à 10 //#define DISPLAY_STARBURST // texte 12x2, nano, affichage starburst avec nano contrôleur //#define DISPLAY_320X240_QVGA_SPI_ILI9341 / / 2.2", 320x240, texte 11x8, uno, grande police, uno, signaux 3v, affichage SPI 9 broches voir Bodmer's Instructables - uno https://www.instructables.com/id/Arduino-TFT-display-and-font- bibliothèque/ récupérez le zip en bas et placez manuellement le gfx et 9341 dans le dossier de la bibliothèque arduino

Étape 4: La norme ANSI

ANSI permet des commandes simples pour effacer l'écran, déplacer le curseur et changer les couleurs. Sur quelques-unes des photos, il y a une démo montrant toutes les couleurs de premier plan et d'arrière-plan. Ce sont le rouge, le jaune, le vert, le bleu, le cyan, le magenta, le noir, le blanc, le gris foncé, le gris clair, et les couleurs peuvent être vives ou sombres, il y a donc 16 couleurs de premier plan et 16 couleurs d'arrière-plan.

Il est tout à fait possible de penser à ajouter un mode « graphique » où vous pouvez dessiner des images de résolution beaucoup plus élevée au niveau du pixel et avec 256 couleurs ou plus. Les principales limitations sont la mémoire interne de l'Arduino et le temps nécessaire pour envoyer une image sur une liaison série à 9600 bauds.

Le code a besoin d'un octet pour stocker le caractère et d'un octet pour stocker les couleurs (3 bits pour le premier plan, 3 pour l'arrière-plan, un pour clair/faible et un pour gras). Ainsi, un affichage 80x30 aura besoin de 2400x2=4800 octets, ce qui conviendra à un Mega mais pas à Uno.

Étape 5: Afficheurs

Ci-dessus, des photos de chaque affichage individuel. Il y a des photos de l'avant et de l'arrière de chaque écran et elles représentent de nombreuses marques disponibles sur ebay ou similaire. Certains sont I2C, certains sont parallèles, certains ont des polices plus grandes, certains peuvent afficher 80 colonnes complètes adaptées à Wordstar et à d'autres anciens programmes de traitement de texte. Il y a plus de détails dans le texte du code arduino.

Étape 6: Schéma

Ci-dessous, deux fichiers. Ils sont nommés.txt car Instructables ne gère pas les fichiers.zip. Téléchargez-les et renommez-les en.zip.

Il y a le schéma et la disposition de la carte sous forme de fichiers pdf. Il existe également un package pour Seeed PCB. Ce sont les gerbers et si vous allez sur Seeed et que vous le téléchargez, cela devrait afficher les gerbers et vous pouvez ensuite faire fabriquer des PCB. La planche à 14 segments est grande et coûte un peu plus cher, mais la plus petite convient au format 10x10cm préféré de Seeed, elle est donc tout à fait raisonnable pour 5 ou 10 planches - en fait, l'expédition coûte plus cher que les planches.

Il est tout à fait possible d'utiliser de nombreux écrans sans avoir besoin d'un PCB. Il existe des modules de socket PS2, des shields/modules RS232 tous disponibles sur ebay ou similaire. Certains écrans comme ceux I2C ne peuvent utiliser que quelques fils de connexion. Certains, comme les écrans SSD1289, sont livrés avec des cartes adaptatrices et peuvent se brancher directement sur un Mega.

Étape 7: Affichage Starburst

L'écran Starburst est une carte plus grande et utilise un Nano et un certain nombre de puces 74xx pour effectuer le multiplexage. Il y a eu de nombreuses expériences pour déterminer combien d'écrans vous pouvez multiplexer avant qu'ils ne deviennent trop sombres ou que le scintillement ne devienne trop perceptible. Les affichages proviennent de Futurlec https://www.futurlec.com/LEDDisp.shtml Les affichages à 14 segments peuvent également faire des lettres minuscules et celles-ci peuvent être modifiées dans le code si nécessaire. Renommez ces fichiers de.txt en.zip

Étape 8: Ajout de code pour d'autres affichages

Il est possible d'ajouter du code pour d'autres affichages. La première étape consiste à obtenir quelque chose, n'importe quoi, à afficher. Il peut s'agir d'un pixel ou d'une lettre. Cela implique principalement de rechercher des pilotes, d'en télécharger un, de le tester, de trouver qu'il ne sera pas compilé, puis de désinstaller ce pilote pour qu'il ne provoque pas de confusion plus tard, puis d'en essayer un nouveau. L'étape suivante consiste à afficher une lettre dans la bonne couleur, car certains affichages qui semblent identiques inverseront en fait les couleurs. Heureusement, généralement, un seul numéro dans le code de démarrage résoudra ce problème. L'étape suivante consiste à écrire quelques lignes pour définir s'il faut utiliser un uno ou un méga, la largeur d'affichage, la hauteur, la taille de la police, les broches du clavier et les fichiers de pilote à utiliser. Ceux-ci commencent à la ligne 39 du code et vous pouvez copier le format des affichages existants.

Ensuite, descendez à la ligne 451 et ajoutez le code de démarrage. C'est ici que vous définissez la couleur d'arrière-plan et la rotation et lancez l'affichage.

Ensuite, allez à la ligne 544 et ajoutez le code pour afficher un caractère. Dans certains cas, il ne s'agit que d'une seule ligne, par exemple

my_lcd. Draw_Char(xPixel, yPixel, c, tftForecolor, tftBackcolor, 1, 0); // x, y, char, avant, arrière, taille, mode

Ensuite, allez à la ligne 664 et ajoutez le code pour dessiner un pixel. Encore une fois, il ne s'agit parfois que d'une seule ligne, par exemple:

tft.drawPixel(xPixel, yPixel, tftForecolor);

Enfin allez à la ligne 727 et ajoutez le code pour tracer une ligne verticale pour le curseur, par exemple

tft.drawFastVLine(xPixel, yPixel, fontHeight, tftForecolor);

Le programme trie des choses comme la quantité de mémoire à allouer pour le tampon d'écran en fonction de la largeur de l'écran et de la taille de la police.

Étape 9: Démonstration de Wordstar

Cela a été fait à l'aide d'un ordinateur CP/M, et de nombreuses options sont disponibles ici. J'avais besoin de quelque chose de rapide à configurer, j'ai donc utilisé une émulation sur un ESP32 (Google ESP32 CP/M). Il existe de nombreux autres ordinateurs rétro disponibles, par exemple l'émulation FPGA de Grant Searle et le RC2014 pour ceux qui préfèrent utiliser un vrai Z80. De nombreux rétro-ordinateurs ont tendance à utiliser un programme de terminal sur un PC comme affichage, par exemple Teraterm. Une grande partie du débogage de ce projet ANSI impliquait d'exécuter un programme de terminal et le programme ANSI en parallèle et de s'assurer que les écrans semblaient identiques.

Étape 10: Réflexions complémentaires

À mesure que les écrans augmentent en taille, ils deviennent de plus en plus lents. Redessiner un personnage implique de redessiner chaque pixel de ce personnage car la couleur d'arrière-plan doit également être dessinée, donc tout se résume à la vitesse à laquelle vous pouvez dessiner un pixel. Il y a quelques ajustements, par exemple si un affichage ne peut pas suivre les données entrantes, stockez simplement le texte dans la mémoire tampon de l'écran, puis effectuez un rafraîchissement en plein écran lorsqu'il n'y a plus de texte. De nombreux affichages que vous voyez pour sale montrer une jolie image à l'écran, mais ce qu'ils pourraient ne pas montrer, c'est le temps qu'il a fallu pour afficher cette image, et dans certains cas, cela peut prendre 5 secondes ou plus. I2C et SPI sont parfaits pour les petits écrans, mais tout ce qui dépasse environ 50 colonnes nécessite un bus de données 8 ou 16 bits.

Wordstar est un peu difficile à utiliser à 9600 bauds et 19200 est beaucoup plus utilisable pour faire défiler du texte, mais les écrans ne peuvent vraiment pas suivre.

L'affichage le plus rapide que j'ai utilisé était sur la puce Propeller avec deux puces externes 8 bits de 512k RAM, pour créer un bus de données parallèle 16 bits. Chaque police a été préchargée dans le bélier. Une cascade de puces de compteur 74xx a été utilisée pour synchroniser les données à l'écran. Cela signifiait qu'il n'y avait pas de traitement interne dans la récupération et la sortie des données du processeur, et le taux de rafraîchissement était aussi rapide que la puce Propeller pouvait basculer une broche. Étonnamment, les écrans ont pu suivre cela, même à 20 MHz, et il était donc possible de faire une mise à jour en plein écran en seulement 30 millisecondes. Ce type de taux est suffisamment rapide pour faire défiler en douceur, comme vous le voyez sur les téléphones portables.

La puce Propeller était à la pointe de la technologie il y a plus de dix ans, et il existe maintenant plus d'options, notamment les ESP8266 et ESP32 qui ont de grandes quantités de RAM interne. Cependant, ces puces n'ont toujours pas un grand nombre de broches, il pourrait donc toujours être intéressant d'utiliser la méthode à l'ancienne d'une puce de RAM externe qui est cadencée à l'écran.

Pour les écrans plus grands, il peut être moins cher d'utiliser un écran de télévision LCD ou un écran VGA et de regarder certains des émulateurs ANSI qui ont été codés, par exemple l'ESP32, qui pilote directement le VGA.

J'espère que vous trouverez ce projet utile.

James Moxham

Adélaïde, Australie