En samling ANSI -terminaler: 10 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:40

Detta projekt startade som ett sätt att visa 80 kolumntext på en LCD-skärm som är lämplig för att köra en gammaldags ordbehandlare som Wordstar. Olika andra skärmar har lagts till från 0,96 till 6 tum. Skärmarna använder en enda kretskort samt en Arduino -skiss/program.

Det finns en seriell RS232 -anslutning för anslutning till en dator och ett PS/2 -uttag för ett tangentbord. Skärmarna valdes för att representera sådana som är allmänt tillgängliga till rimliga priser. Beroende på vilket minne som behövs använder skärmarna en Arduino Nano, Uno eller Mega.

Steg 1: Sammanfattning av displayer

Det finns olika skärmar med 480x320 upplösning. Detta tillåter ett 9x5 teckensnitt och 80 kolumntext. Det finns olika kort med 320x240 upplösning, med 9x5 teckensnitt och också ett mycket litet 7x3 teckensnitt för att tillåta 80 kolumntext. Det finns också mindre kort med 160x120 och 128x64 pixlar. Också 20x4 och 16x2 textdisplayer, och slutligen ett 12x2 fjorton segment starburst display board.

Vissa skärmar använder I2C, vissa är SPI och för de större bildskärmarna en 16 -bitars databuss för snabbare uppdateringshastigheter.

Mindre skärmar använder Arduino Uno. Större brädor behöver mer minne och använd därför en Mega. Starburst -displaykortet använder en Nano.

Vid denna tidpunkt kan jag nämna att bilderna inte ger rättvisa åt många av skärmarna. Den lilla vita oled -skärmen är mycket skarp och ljus vilket gjorde det svårare för kameran att fokusera, och starburst -LED -skärmen ser mycket skarpare ut i verkligheten.

Steg 2: Hårdvara

Kretskortet har utformats för att fungera med så många skärmar som möjligt. Det är lätt att växla mellan en Mega och Uno med fyra hoppare. Det finns spänningsdelare motstånd för skärmar som körs på 3V. I2C -stift tas ut i en grupp så att bildskärmar kan anslutas direkt. Terminalen körs med 9600 baud, och även om detta kan ökas, kommer många av de större skärmarna inte att rita om mycket snabbare än så här. PS2 -tangentbordet ansluts till ett DIN6 -uttag. USB -tangentbord fungerar också med en billig adapterplugg. Du kan göra ett enkelt loopback -test genom att ansluta stift 2 och 3 på D9 och sedan visas tecken som skrivs in på tangentbordet på displayen.

I vissa fall behövs inget kretskort och det är möjligt att få saker som fungerar med färdiga moduler tillgängliga på ebay, t.ex. PS2-adaptrar, RS232-adapterkort och skärmar som ansluts direkt till arduino-kort.

Det finns också en separat tavla för starburst leddisplayen - se senare i denna instruktionsbok.

Steg 3: Programvara

Nedan finns en fil som heter Package.txt Detta är faktiskt en.zip -fil så ladda ner och byt namn på den (Instructables tillåter inte zip -filer). Inkluderat är Arduino -skissen/programmet och detta är ett enda program som används av alla skärmar. Det finns också alla.zip -filer för var och en av skärmarna.

I början av programmet finns en serie #define uttalanden. Avmarkera den som motsvarar displayen. Använd Tools/Board för att välja Uno, Mega eller Nano. Att byta bräda är lika enkelt som att ändra en rad i koden.

En av utmaningarna med att arbeta med många skärmar är att de alla verkar behöva sina egna programvarudrivrutiner. Dessa ingår alla i paketet. Testning inkluderade att ta paketet och installera om det på en ny maskin helt från grunden. Du kan också källa från Github och Adafruit och LCDWiki. Det finns ett par fall där nyare versioner inte fungerar så alla arbetsversioner ingår i zip -filen. Ibland fanns det fall där en förare stoppade en annan eftersom de använde samma filnamn men olika versioner. Det finns en beskrivning i kommentarerna högst upp i programmet som visar hur du installerar varje drivrutin. De flesta installeras från Arduino IDE med Sketch/Include Library/Add ZIP -bibliotek och detta tar zip -filen och lägger den i c: / users / computername / mydocuments / arduino / libraries.

Om du bara använder en bildskärm behöver några av dessa libaries inte installeras. Åtminstone behöver du de två tangentbordsfilerna och den för den specifika skärmen. Vissa skärmar delar kod. Det finns mer detaljerade instruktioner i kommentarerna högst upp i programmet, inklusive att hämta gfx -biblioteket från Adafruit.

Eftersom alla bildskärmar använder samma Arduino -skiss, är det bara att byta bildskärm från en av raderna nedan:

// Olika skärmar, lämna en av följande okommenterade#definiera DISPLAY_480X320_LCDWIKI_ILI9486 // 3,5 ", 480x320, text 80x32, mega, 16 bitar, ansluts till mega 36 -stift (och 2 stift). Http://www.lcdwiki.com /3.5inch_Arduino_Display-Mega2560. Långsammare än några av alternativen nedan men ett mer läsbart teckensnitt och större skärm, 5 sek uppstart //#definiera DISPLAY_480X320_MCUFRIEND_ILI9486 // 3,5 ", 480x320, text 80x32, mega, 5x9 teckensnitt, bara för mega men använder bara uno-stiften, power, D0-D14, A0-A5, trevligare typsnitt än ssd1289 40-stifts modulen men mycket långsammare https://www.arduinolibraries.info/libraries/mcufriend_kbv https://github.com/adafruit/Adafruit -GFX-bibliotek //#definiera DISPLAY_320X240_MCUFRIEND_ILI9341 // 2,4 ", 320x240, text 53x24, mega //#definiera DISPLAY_320X240_SSD1289_40COL // 3,5", 320x240, text 40x20, mega, UTFT-bibliotek (inga teckensnitt mindre än 8x12) Snabb //#definiera DISPLAY_320X240_SSD1289_53COL // 3,5 ", 320x240, text 53x24, mega, 9x5 teckensnitt, kan redigera teckensnitt. Snabb //#definiera DISPLAY_320X240_SSD1289_80COL // 3,5", 320x240, text 80x30, mega, liten 7x3 typsnitt, kan redigera, snabbare drivrutin än de två ovan, snabbaste av alla dessa som 16 -bitars direktdrift till displayen snarare än 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 (tft -biblioteket för detta kort plus all kod plus tangentbordet tar slut på programlagring, även om rambehovet är mycket små, så bara körs på en mega) //#definiera DISPLAY_20X4 // text 20x4, uno, LCD med I2C, text LCD https://www.arduino.cc/en/Reference/LiquidCrystal //#define DISPLAY_16X2 // text 16x2, uno, ansluts till uno, använder stiften 4 till 10 //#definiera DISPLAY_STARBURST // text 12x2, nano, starburst -display med nano -styrenhet //#definiera DISPLAY_320X240_QVGA_SPI_ILI9341 / /2,2 ", 320x240, text 11x8, uno, stort teckensnitt, uno, 3v-signaler, 9-stifts SPI-display se Bodmers instruktioner-uno https://www.instructables.com/id/Arduino-TFT-display-and-font- bibliotek/ få zip längst ner och lägg manuellt gfx och 9341 i mappen arduino bibliotek

Steg 4: ANSI -standarden

ANSI möjliggör enkla kommandon för att rensa skärmen, flytta markören och ändra färger. På några av bilderna finns en demo som visar alla för- och bakgrundsfärger. Dessa är röda, gula, gröna, blå, cyan, magenta, svarta, vita, mörkgråa, ljusgråa och färgerna kan vara ljusa eller svaga så det finns 16 förgrunds- och 16 bakgrundsfärger.

Det är fullt möjligt att tänka på att lägga till i ett "grafik" -läge där du kan rita bilder med mycket högre upplösning på pixelnivå och med 256 eller fler färger. De främsta begränsningarna är Arduinos interna minne och den tid det tar att skicka en bild ner till en seriell länk vid 9600 baud.

Koden behöver en byte för att lagra tecknet och en byte för att lagra färgerna (3 bitar i förgrunden, 3 för bakgrunden, en för ljus/dim och en för fet stil). Så en 80x30 -skärm behöver 2400x2 = 4800 byte, som passar i en Mega men inte en Uno.

Steg 5: Visar

Ovan är bilder på varje enskild display. Det finns foton från framsidan och baksidan av varje display och de representerar många av de märken som finns tillgängliga på ebay eller liknande. Vissa är I2C, vissa är parallella, vissa har större teckensnitt, vissa kan visa hela 80 kolumner lämpliga för Wordstar och andra gamla ordbehandlingsprogram. Det finns mer detaljer i texten i arduino -koden.

Steg 6: Schematisk

Nedan finns två filer. De heter som.txt eftersom Instructables inte hanterar.zip -filer. Ladda ner dem och byt namn på dem som.zip.

Det finns schemat och tavlan som pdf -filer. Det finns också ett paket för Seeed PCB. Det här är gerberna och om du går till Seeed och laddar upp detta ska det visa gerberna och du kan sedan få PCB gjorda. 14 -segmentskortet är stort och kostar en hel del mer, men det mindre passar i det föredragna 10x10cm -formatet Seeed, vilket är ganska rimligt för 5 eller 10 brädor - i själva verket kostar frakten mer än brädorna.

Det är fullt möjligt att använda många av skärmarna utan att behöva ett kretskort. Det finns PS2 -uttagsmoduler, RS232 -sköldar/moduler alla tillgängliga på ebay eller liknande. Vissa skärmar som I2C kan bara använda några anslutningskablar. Vissa som SSD1289 -skärmarna levereras med adapterkort och kan anslutas direkt till en Mega.

Steg 7: Starburst Display

Starburst -skärmen är ett större kort och använder en Nano och ett antal 74xx -chips för att göra multiplexen. Det fanns många experiment för att avgöra hur många skärmar du kunde multiplexa innan de blev för svaga eller flimmern blev för märkbar. Displayerna kom från Futurlec https://www.futurlec.com/LEDDisp.shtml De 14 segmentdisplayerna kan också göra små bokstäver och dessa kan ändras i koden om det behövs. Byt namn på dessa filer från.txt till.zip

Steg 8: Lägga till kod för andra skärmar

Det är möjligt att lägga till kod för andra skärmar. Det första steget är att få något, vad som helst, att visa. Det kan vara en pixel eller en bokstav. Detta handlar främst om att söka efter drivrutiner, ladda ner en, testa den, hitta den kommer inte att kompilera, sedan avinstallera den drivrutinen så att den inte orsakar förvirring senare och sedan prova en ny. Nästa steg är att få en bokstav att visas i rätt färg, eftersom vissa skärmar som ser identiska faktiskt kommer att invertera färgerna. Lyckligtvis brukar bara ett nummer i startkoden fixa detta. Nästa steg är att skriva några rader för att definiera om du vill använda en uno eller mega, bildskärmens bredd, höjd, teckenstorlek, tangentbordsstift och vilka drivrutinsfiler som ska användas. Dessa börjar på rad 39 i koden och du kan kopiera formatet på de befintliga bildskärmarna.

Nästa är att gå ner till rad 451 och lägga till startkoden. Det är här du ställer in bakgrundsfärgen och rotationen och initierar visningen.

Nästa är att gå till rad 544 och lägga till koden för att visa ett tecken. I vissa fall är detta bara en rad, t.ex.

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

Nästa är att gå till rad 664 och lägga till koden för att rita en pixel. Igen, ibland är detta bara en rad, t.ex.

tft.drawPixel (xPixel, yPixel, tftForecolor);

Slutligen gå till rad 727 och lägg till koden för att rita en vertikal linje för markören, till exempel

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

Programmet sorterar ut saker som hur mycket minne som ska tilldelas för skärmbufferten baserat på skärmbredd och teckensnittsstorlek.

Steg 9: Demonstration av Wordstar

Detta gjordes med en CP/M -dator, och det finns många alternativ tillgängliga här. Jag behövde något snabbt att konfigurera, så använde en emulering på en ESP32 (Google ESP32 CP/M). Det finns många andra retrodatorer tillgängliga, till exempel Grant Searles FPGA -emulering och RC2014 för dem som föredrar att använda en riktig Z80. Många retrodatorer tenderar att använda ett terminalprogram på en dator som display, t.ex. Teraterm. Mycket felsökning av detta ANSI -projekt involverade att köra ett terminalprogram och ANSI -programmet parallellt och se till att skärmarna såg identiska ut.

Steg 10: Ytterligare tankar

När skärmarna blir större blir de långsammare och långsammare. Att rita om ett tecken innebär att man ritar om varje pixel i det tecknet eftersom bakgrundsfärgen också måste ritas, så allt beror på hur snabbt du kan rita en pixel. Det finns några tweaks, till exempel om en bildskärm inte kan hänga med i att data kommer in, lagra bara texten i skärmbufferten och gör sedan om en helskärm om när ingen mer text kommer in. Många skärmar som du ser för försäljning visar en vacker bild på skärmen, men vad de kanske inte visar är hur lång tid det tog att visa bilden, och i vissa fall kan det vara 5 sekunder eller mer. I2C och SPI är bra för de mindre skärmarna men allt över cirka 50 kolumner behöver en 8 eller 16 bitars databuss.

Wordstar är lite otympligt att använda vid 9600 baud och 19200 är mycket mer användbart för att rulla text, men skärmarna kan verkligen inte hänga med.

Den snabbaste skärmen jag har använt var på Propeller -chipet med två 8 -bitars externa 512k ramchips, för att skapa en 16 -bitars parallell databuss. Varje typsnitt var förinstallerat i ram. En kaskad av 74xx motchips användes för att klocka ut data i displayen. Detta innebar att det inte fanns någon intern behandling i CPU: n som hämtade och matade ut data, och uppdateringsfrekvensen var så snabb som Propeller -chipet kunde växla en stift. Överraskande nog kunde skärmarna hänga med i detta, även vid 20Mhz, så det var möjligt att göra en helskärmsuppdatering på bara 30 millisekunder. Den typen av hastighet är tillräckligt snabb för att rulla smidigt, som du ser på mobiltelefoner.

Propellerchipet var banbrytande för över tio år sedan, och det finns fler alternativ nu inklusive ESP8266 och ESP32 som har stora mängder intern ram. Dessa marker har dock fortfarande inte ett stort antal stift, så det kan fortfarande vara meriterande att använda det gamla skolans sätt för ett externt ramchip som är urklockat till displayen.

För större skärmar kan det vara billigare att använda en LCD -TV -skärm eller VGA -skärm och titta på några av de ANSI -emulatorer som har kodats, t.ex. ESP32, som driver VGA direkt.

Jag hoppas att du tycker att det här projektet är användbart.

James Moxham

Adelaide, Australien