Een verzameling ANSI-terminals: 10 stappen

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:15

Dit project begon als een manier om 80 kolomtekst weer te geven op een LCD-scherm dat geschikt is voor het draaien van een ouderwetse tekstverwerker zoals Wordstar. Verschillende andere displays werden toegevoegd, variërend in grootte van 0,96 tot 6 inch. De displays gebruiken een enkele PCB en een Arduino-schets/programma.

Er is een seriële RS232 aansluiting voor aansluiting op een computer en een PS/2 aansluiting voor een toetsenbord. De displays zijn zo gekozen dat ze representatief zijn voor degenen die algemeen verkrijgbaar zijn tegen redelijke prijzen. Afhankelijk van het benodigde geheugen gebruiken de displays een Arduino Nano, Uno of Mega.

Stap 1: Overzicht van weergaven

Er zijn verschillende beeldschermen met een resolutie van 480x320. Dit maakt een 9x5-lettertype en 80-kolomtekst mogelijk. Er zijn verschillende borden met een resolutie van 320x240, met 9x5-lettertypen en ook een heel klein 7x3-lettertype om 80 kolomtekst toe te staan. Er zijn ook kleinere borden met 160x120 en 128x64 pixels. Ook 20x4 en 16x2 tekstdisplays, en tot slot een 12x2 veertien segment starburst displaybord.

Sommige schermen gebruiken I2C, sommige zijn SPI en voor de grotere schermen een 16-bits databus voor hogere updatesnelheden.

Kleinere schermen gebruiken de Arduino Uno. Grotere borden hebben meer geheugen nodig en gebruiken daarom een Mega. Het starburst-displaybord maakt gebruik van een Nano.

Op dit punt zou ik kunnen zeggen dat de foto's geen recht doen aan veel van de displays. Het kleine witte oled-display is erg helder en helder, waardoor het moeilijker is voor de camera om scherp te stellen, en het starburst led-display ziet er in het echt een stuk scherper uit.

Stap 2: Hardware

De PCB is ontworpen om met zoveel mogelijk displays te werken. Wisselen tussen een Mega en Uno is eenvoudig met vier jumpers. Er zijn spanningsdelerweerstanden voor displays die op 3V werken. I2C-pinnen worden in een groep naar buiten gebracht, zodat displays direct kunnen worden aangesloten. De terminal werkt op 9600 baud, en hoewel dit kan worden verhoogd, zullen veel van de grotere schermen niet veel sneller opnieuw worden getekend. Het PS2-toetsenbord wordt aangesloten op een DIN6-aansluiting. USB-toetsenborden werken ook met een goedkope adapterstekker. U kunt een eenvoudige loopback-test doen door pin 2 en 3 op de D9 samen te voegen en vervolgens verschijnen de tekens die op het toetsenbord zijn getypt op het display.

In sommige gevallen is een PCB niet nodig en is het mogelijk om dingen werkend te krijgen met vooraf gemaakte modules die beschikbaar zijn op ebay, bijv. PS2-adapters, RS232-adapterkaarten en displays die rechtstreeks op Arduino-kaarten kunnen worden aangesloten.

Er is ook een apart bord voor het starburst led-display - zie verderop in deze Instructable.

Stap 3: Software

Hieronder staat een bestand met de naam Package.txt. Dit is eigenlijk een.zip-bestand, dus download en hernoem het (Instructables staat geen zip-bestanden toe). Inbegrepen is de Arduino-schets/het programma en dit is een enkel programma dat door alle displays wordt gebruikt. Er zijn ook alle.zip-bestanden voor elk van de schermen.

Aan het begin van het programma staan een reeks #define-statements. Verwijder de opmerking die overeenkomt met het scherm. Gebruik Tools/Board om Uno, Mega of Nano te selecteren. Het wisselen van borden is net zo eenvoudig als het veranderen van één regel in de code.

Een van de uitdagingen bij het werken met veel beeldschermen is dat ze allemaal hun eigen softwarestuurprogramma's nodig lijken te hebben. Deze zitten allemaal in het pakket. Testen omvatte het nemen van het pakket en het volledig opnieuw installeren op een nieuwe machine. U kunt ook broncode van Github en Adafruit en LCDWiki gebruiken. Er zijn een paar gevallen waarin nieuwere versies niet werken, dus alle werkende versies zijn opgenomen in de zip. Af en toe waren er gevallen waarin een stuurprogramma een ander blokkeerde omdat ze dezelfde bestandsnaam maar verschillende versies gebruikten. Er is een beschrijving in de opmerkingen bovenaan het programma die laat zien hoe elk stuurprogramma moet worden geïnstalleerd. De meeste worden geïnstalleerd vanuit de Arduino IDE met Sketch/Include Library/Add ZIP-bibliotheek en dit neemt het zip-bestand en plaatst het in c:\users\computername\mydocuments\arduino\libraries.

Als u slechts één beeldscherm gebruikt, hoeven sommige van deze bibliotheken niet te worden geïnstalleerd. Je hebt minimaal de twee toetsenbordbestanden nodig en die voor het specifieke scherm. Sommige schermen delen code. Er zijn meer gedetailleerde instructies in de opmerkingen bovenaan het programma, inclusief het verkrijgen van de gfx-bibliotheek van Adafruit.

Omdat alle displays dezelfde Arduino-schets gebruiken, is het veranderen van displays slechts een kwestie van het verwijderen van commentaar op een van de onderstaande regels:

// Verschillende beeldschermen, laat een van de volgende onbecommentarieerd#define DISPLAY_480X320_LCDWIKI_ILI9486 // 3.5", 480x320, tekst 80x32, mega, 16 bit, pluggen in mega 36 pins (en 2 power pins).https://www.lcdwiki.com /3.5inch_Arduino_Display-Mega2560. Langzamer dan sommige van de onderstaande opties, maar een beter leesbaar lettertype en groter scherm, 5 seconden opstarten //#define DISPLAY_480X320_MCUFRIEND_ILI9486 // 3.5", 480x320, tekst 80x32, mega, 5x9 lettertype, alleen voor mega maar gebruikt slechts de uno pins, power, D0-D14, A0-A5, mooier lettertype dan de ssd1289 40 pin module maar een stuk langzamer https://www.arduinolibraries.info/libraries/mcufriend_kbv https://github.com/adafruit/Adafruit -GFX-Bibliotheek //#define DISPLAY_320X240_MCUFRIEND_ILI9341 // 2,4", 320x240, tekst 53x24, mega //#define DISPLAY_320X240_SSD1289_40COL // 3,5", 320x240, tekst 40x20, mega, UTFT-bibliotheek (geen lettertypen kleiner dan 8x12). Snel //#define DISPLAY_320X240_SSD1289_53COL // 3.5", 320x240, text 53x24, mega, 9x5 font, can edit font. Snel //#define DISPLAY_320X240_SSD1289_80COL // 3.5", 320x240, text 80x30, mega, tiny 7x3 font, can edit font, snellere driver dan de twee hierboven, snelste van al deze als 16 bit directe drive naar het scherm in plaats van spi/i2c //#define DISPLAY_160X128_ST7735 // 1.8", 160x128, tekst 26x12, uno (ILI9341) SPI 128x160 //#define DISPLAY_128X64_OLED_WHITE // 0.96", 128x64, tekst 21x6, mega, I2C, oled wit op zwart (de tft-bibliotheek voor dit bord plus alle code plus het toetsenbord heeft geen programmageheugen meer, hoewel de ram-behoeften erg klein zijn, dus alleen draait op een mega) //#define DISPLAY_20X4 // text 20x4, uno, LCD met I2C, text LCD https://www.arduino.cc/en/Reference/LiquidCrystal //#define DISPLAY_16X2 // text 16x2, uno, kan worden aangesloten op uno, gebruikt pinnen 4 tot 10 //#define DISPLAY_STARBURST // tekst 12x2, nano, starburst-display met nano-controller //#define DISPLAY_320X240_QVGA_SPI_ILI9341 / / 2.2", 320x240, tekst 11x8, uno, groot lettertype, uno, 3v-signalen, 9-pins SPI-display zie Bodmer's Instructables - uno https://www.instructables.com/id/Arduino-TFT-display-and-font- bibliotheek / pak de zip onderaan en plaats de gfx en 9341 handmatig in de arduino-bibliotheekmap

Stap 4: De ANSI-standaard

ANSI maakt eenvoudige opdrachten mogelijk om het scherm leeg te maken, de cursor te verplaatsen en van kleur te veranderen. Op een paar van de foto's staat een demo die alle voor- en achtergrondkleuren laat zien. Dit zijn rood, geel, groen, blauw, cyaan, magenta, zwart, wit, donkergrijs, lichtgrijs en de kleuren kunnen helder of zwak zijn, dus er zijn 16 voorgrond- en 16 achtergrondkleuren.

Het is heel goed mogelijk om te denken aan het toevoegen van een 'grafische' modus waarin je afbeeldingen met een veel hogere resolutie op pixelniveau en met 256 of meer kleuren kunt tekenen. De belangrijkste beperkingen zijn het interne geheugen van de Arduino en de tijd die nodig is om een afbeelding via een seriële link met 9600 baud te verzenden.

De code heeft één byte nodig om het teken op te slaan en één byte om de kleuren op te slaan (3 bits voor voorgrond, 3 voor achtergrond, één voor helder/dim en één voor vet). Dus een 80x30-scherm heeft 2400x2=4800 bytes nodig, wat in een Mega past, maar niet in een Uno.

Stap 5: Beeldschermen

Hierboven staan foto's van elk afzonderlijk scherm. Er zijn foto's van de voor- en achterkant van elk scherm en ze vertegenwoordigen veel van de merken die beschikbaar zijn op ebay of iets dergelijks. Sommige zijn I2C, sommige zijn parallel, sommige hebben grotere lettertypen, sommige kunnen 80 kolommen weergeven die geschikt zijn voor Wordstar en andere oude tekstverwerkingsprogramma's. Er is meer detail in de tekst van de Arduino-code.

Stap 6: Schematisch

Hieronder staan twee bestanden. Ze worden genoemd als.txt omdat Instructables geen.zip-bestanden verwerkt. Download ze en hernoem ze als.zip.

Er is het schema en de lay-out van het bord als pdf-bestanden. Er is ook een pakket voor Seeed PCB. Dit zijn de gerbers en als je naar Seeed gaat en dit uploadt, zouden de gerbers moeten worden weergegeven en kun je PCB's laten maken. Het 14-segmentsbord is groot en kost nogal wat meer, maar de kleinere past in het Seeed-voorkeursformaat van 10x10cm, dus redelijk voor 5 of 10 borden - in feite kost de verzending meer dan de planken.

Het is heel goed mogelijk om veel van de displays te gebruiken zonder een printplaat. Er zijn PS2-socketmodules, RS232-afschermingen/modules die allemaal beschikbaar zijn op ebay of iets dergelijks. Sommige schermen, zoals de I2C-schermen, kunnen slechts een paar aansluitdraden gebruiken. Sommige, zoals de SSD1289-schermen, worden geleverd met adapterkaarten en kunnen rechtstreeks op een Mega worden aangesloten.

Stap 7: Starburst-weergave

Het starburst-display is een groter bord en gebruikt een Nano en een aantal 74xx-chips om het multiplexen te doen. Er waren veel experimenten om te bepalen hoeveel schermen je kon multiplexen voordat ze te zwak werden of de flikkering te opvallend werd. De displays zijn afkomstig van Futurlec https://www.futurlec.com/LEDDisp.shtml De displays met 14 segmenten kunnen ook kleine letters gebruiken en deze kunnen indien nodig in de code worden aangepast. Hernoem deze bestanden van.txt naar.zip

Stap 8: Code toevoegen voor andere schermen

Het is mogelijk om code toe te voegen voor andere displays. De eerste stap is om iets, wat dan ook, te laten zien. Het kan een pixel of een letter zijn. Dit houdt voornamelijk in: zoeken naar stuurprogramma's, er een downloaden, testen, ontdekken dat het niet compileert, het verwijderen van dat stuurprogramma zodat het later geen verwarring veroorzaakt, en dan een nieuw proberen. De volgende stap is om een letter in de juiste kleur weer te geven, aangezien sommige schermen die er identiek uitzien, de kleuren zullen omkeren. Gelukkig lost slechts één nummer in de opstartcode dit meestal op. De volgende stap is het schrijven van een paar regels om te bepalen of u een uno of mega wilt gebruiken, de breedte, hoogte, lettergrootte, toetsenbordpinnen en welke driverbestanden u wilt gebruiken. Deze beginnen bij regel 39 in de code en u kunt het formaat van de bestaande displays kopiëren.

Vervolgens gaat u naar regel 451 en voegt u de opstartcode toe. Hier stelt u de achtergrondkleur en de rotatie in en start u de weergave.

Vervolgens gaat u naar regel 544 en voegt u de code toe om een teken weer te geven. In sommige gevallen is dit slechts één regel, bijv

my_lcd. Draw_Char (xPixel, yPixel, c, tftForecolor, tftBackcolor, 1, 0); // x, y, char, fore, back, size, mode

Het volgende is om naar regel 664 te gaan en de code toe te voegen om een pixel te tekenen. Nogmaals, soms is dit slechts één regel, bijvoorbeeld:

tft.drawPixel(xPixel, yPixel, tftForecolor);

Ga ten slotte naar regel 727 en voeg de code toe om bijvoorbeeld een verticale lijn voor de cursor te tekenen

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

Het programma regelt zaken zoals hoeveel geheugen moet worden toegewezen aan de schermbuffer op basis van de schermbreedte en de lettergrootte.

Stap 9: Wordstar-demonstratie

Dit is gedaan met behulp van een CP/M-computer en er zijn hier veel opties beschikbaar. Ik had iets snel nodig om in te stellen, dus gebruikte ik een emulatie op een ESP32 (Google ESP32 CP/M). Er zijn veel andere retro-computers beschikbaar, bijvoorbeeld Grant Searle's FPGA-emulatie en de RC2014 voor degenen die liever een echte Z80 gebruiken. Veel retrocomputers hebben de neiging om een terminalprogramma op een pc als beeldscherm te gebruiken, bijvoorbeeld Teraterm. Veel debuggen van dit ANSI-project omvatte het parallel draaien van een terminalprogramma en het ANSI-programma en ervoor zorgen dat de schermen er identiek uitzagen.

Stap 10: Verdere gedachten

Naarmate displays groter worden, worden ze langzamer en langzamer. Bij het opnieuw tekenen van een teken moet elke pixel in dat teken opnieuw worden getekend, aangezien ook de achtergrondkleur moet worden getekend, dus alles komt neer op hoe snel je een pixel kunt tekenen. Er zijn enkele aanpassingen, bijvoorbeeld als een display de binnenkomende gegevens niet kan bijhouden, sla de tekst gewoon op in de schermbuffer en voer vervolgens een volledig scherm opnieuw uit wanneer er geen tekst meer binnenkomt. Veel displays die u ziet voor sale laten een mooie afbeelding op het scherm zien, maar wat ze misschien niet laten zien, is hoe lang het duurde om die afbeelding weer te geven, en in sommige gevallen kan het 5 seconden of meer zijn. I2C en SPI zijn geweldig voor de kleinere schermen, maar alles met meer dan 50 kolommen heeft een 8- of 16-bits databus nodig.

Wordstar is een beetje onpraktisch om te gebruiken met 9600 baud en 19200 is veel beter bruikbaar voor het scrollen van tekst, maar de displays kunnen het echt niet bijbenen.

Het snelste scherm dat ik heb gebruikt was op de Propeller-chip met twee 8-bits externe 512k ram-chips, om een 16-bits parallelle databus te creëren. Elk lettertype was vooraf in de ram geladen. Een cascade van 74xx-tellerchips werd gebruikt om de gegevens naar het display te klokken. Dit betekende dat er geen interne verwerking was binnen de CPU die gegevens ophaalde en uitvoerde, en de verversingssnelheid was zo snel als de Propeller-chip een pin kon wisselen. Verrassend genoeg konden de schermen dit bijbenen, zelfs op 20 Mhz, en dus was het mogelijk om een update op het volledige scherm in slechts 30 milliseconden uit te voeren. Dat soort snelheid is snel genoeg om soepel te scrollen, zoals je op mobiele telefoons ziet.

De Propeller-chip was meer dan tien jaar geleden baanbrekend en er zijn nu meer opties, waaronder de ESP8266 en ESP32 die grote hoeveelheden interne ram hebben. Die chips hebben echter nog steeds geen enorm aantal pinnen, dus het kan nog steeds nuttig zijn om de old-skool-manier van een externe ram-chip te gebruiken die naar het scherm wordt geklokt.

Voor grotere schermen kan het goedkoper zijn om een LCD TV-scherm of VGA-scherm te gebruiken en te kijken naar enkele van de gecodeerde ANSI-emulators, bijvoorbeeld de ESP32, die VGA rechtstreeks aansturen.

Ik hoop dat je dit project nuttig vindt.

James Moxham

Adelaide, Australië