En samling ANSI -terminaler: 10 trinn

2024 Forfatter: John Day | [email protected]. Sist endret: 2024-01-30 11:22

Dette prosjektet startet som en måte å vise 80 kolonne tekst på en LCD-skjerm som er egnet for å kjøre en gammeldags tekstbehandler som Wordstar. Ulike andre skjermer ble lagt til, alt fra 0,96 til 6 tommer. Displayene bruker en enkelt PCB samt en Arduino skisse/program.

Det er en seriell RS232 -tilkobling for tilkobling til en datamaskin og en PS/2 -kontakt for et tastatur. Skjermene ble valgt for å representere de som vanligvis er tilgjengelige til rimelige priser. Avhengig av minnet som trengs, bruker skjermene en Arduino Nano, Uno eller Mega.

Trinn 1: Sammendrag av skjermer

Det finnes forskjellige skjermer med 480x320 oppløsning. Dette tillater en 9x5 skrift og 80 kolonne tekst. Det er forskjellige tavler med 320x240 oppløsning, med 9x5 fonter og også en veldig liten 7x3 skrift for å tillate 80 kolonnetekst. Det er også mindre tavler med 160x120 og 128x64 piksler. Også 20x4 og 16x2 tekstdisplayer, og til slutt et 12x2 fjorten segment starburst displaykort.

Noen skjermer bruker I2C, noen er SPI og for de større skjermer, en 16 -biters databuss for raskere oppdateringshastigheter.

Mindre skjermer bruker Arduino Uno. Større brett trenger mer minne, så bruk en Mega. Starburst -skjermkortet bruker en Nano.

På dette tidspunktet kan jeg nevne at bildene ikke gir rettferdighet til mange av skjermene. Den lille hvite oled -skjermen er veldig skarp og lys, noe som gjorde det vanskeligere for kameraet å fokusere, og starburst -LED -skjermen ser mye skarpere ut i virkeligheten.

Trinn 2: Maskinvare

Kretskortet er designet for å fungere med så mange skjermer som mulig. Det er enkelt å bytte mellom en Mega og Uno ved å bruke fire hoppere. Det er spenningsdelermotstander for skjermer som kjører på 3V. I2C -pinner blir hentet ut i en gruppe, slik at skjermer kan plugges inn direkte. Terminalen kjører på 9600 baud, og mens denne kan økes, vil mange av de større skjermene ikke tegne mye raskere enn dette. PS2 -tastaturet kobles til en DIN6 -kontakt. USB -tastaturer vil også fungere med en billig adapterplugg. Du kan gjøre en enkel tilbakekoblingstest ved å koble pin 2 og 3 på D9, og deretter vises tegn skrevet på tastaturet på displayet.

I noen tilfeller er det ikke nødvendig med en PCB, og det er mulig å få ting som fungerer med ferdiglagde moduler tilgjengelig på ebay, f.eks. PS2-adaptere, RS232-adapterkort og skjermer som kobles direkte til arduino-kort.

Det er også et eget bord for starburst led -displayet - se senere i denne instruksjonsboken.

Trinn 3: Programvare

Nedenfor er en fil som heter Package.txt Dette er faktisk en.zip -fil, så last ned og gi den nytt navn (Instructables tillater ikke zip -filer). Inkludert er Arduino -skissen/programmet, og dette er et enkelt program som brukes av alle displayene. Det er også alle.zip -filene for hver av skjermene.

I begynnelsen av programmet er en serie #define utsagn. Ikke kommenter den som tilsvarer displayet. Bruk Tools/Board for å velge Uno, Mega eller Nano. Å bytte brett er like enkelt som å endre en linje i koden.

En av utfordringene ved å jobbe med mange skjermer er at alle ser ut til å trenge sine egne programvaredrivere. Disse er alle inkludert i pakken. Testing inkluderte å ta pakken og installere den på en ny maskin helt fra bunnen av. Du kan også kilde koden fra Github og Adafruit og LCDWiki. Det er et par tilfeller der nyere versjoner ikke fungerer, så alle arbeidsversjonene er inkludert i glidelåsen. Noen ganger var det tilfeller der en sjåfør stoppet en annen mens de brukte det samme filnavnet, men forskjellige versjoner. Det er en beskrivelse i kommentarene øverst i programmet som viser hvordan du installerer hver driver. De fleste er installert fra Arduino IDE med Sketch/Include Library/Add ZIP -bibliotek, og dette tar zip -filen og legger den i c: / users / computername / mydocuments / arduino / libraries.

Hvis du bare bruker én skjerm, trenger noen av disse biblioaryene ikke å være installert. I det minste trenger du de to tastaturfilene og den ene for den spesifikke skjermen. Noen skjermer deler kode. Det er mer detaljerte instruksjoner i kommentarene øverst i programmet, inkludert å få gfx -biblioteket fra Adafruit.

Ettersom alle skjermene bruker den samme Arduino -skissen, er det bare å bytte ut en av linjene nedenfor:

// Ulike skjermer, la en av følgende ukommenterte#definere DISPLAY_480X320_LCDWIKI_ILI9486 // 3,5 ", 480x320, tekst 80x32, mega, 16 bit, plugge til mega 36 -pinners (og 2 strømpinner). Http://www.lcdwiki.com /3.5inch_Arduino_Display-Mega2560. Saktere enn noen av alternativene nedenfor, men en mer lesbar skrift og større skjerm, 5sek oppstart //#definere DISPLAY_480X320_MCUFRIEND_ILI9486 // 3,5 ", 480x320, tekst 80x32, mega, 5x9 skrift, bare for mega, men bruker bare uno-pinnene, power, D0-D14, A0-A5, finere skrift enn ssd1289 40-pinners modul, men mye tregere https://www.arduinolibraries.info/libraries/mcufriend_kbv https://github.com/adafruit/Adafruit -GFX-bibliotek //#definere DISPLAY_320X240_MCUFRIEND_ILI9341 // 2,4 ", 320x240, tekst 53x24, mega //#definere DISPLAY_320X240_SSD1289_40COL // 3,5", 320x240, tekst 40x20, mega, UTFT-bibliotek (ingen skrifttyper mindre enn 8x12) Rask //#definere DISPLAY_320X240_SSD1289_53COL // 3,5 ", 320x240, tekst 53x24, mega, 9x5 skrift, kan redigere skrift. Rask //#definere DISPLAY_320X240_SSD1289_80COL // 3,5", 320x240, tekst 80x30, mega, liten 7x3 skrift, kan redigere, raskere driver enn de to ovenfor, raskeste av alle disse som 16 -bits direkte stasjon til skjermen i stedet for 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 white on black (tft -biblioteket for dette brettet pluss all koden pluss tastaturet går tom for programlagring, selv om rambehovet er veldig lite, så bare kjører på en mega) //#definere DISPLAY_20X4 // tekst 20x4, uno, LCD med I2C, tekst LCD https://www.arduino.cc/en/Reference/LiquidCrystal //#definere DISPLAY_16X2 // tekst 16x2, uno, kobles til uno, bruker pinne 4 til 10 //#definere DISPLAY_STARBURST // tekst 12x2, nano, starburst -skjerm med nano -kontroller //#definere DISPLAY_320X240_QVGA_SPI_ILI9341 / /2,2 ", 320x240, tekst 11x8, uno, stor skrift, uno, 3v signaler, 9-pinners SPI-display se Bodmers instrukser-uno https://www.instructables.com/id/Arduino-TFT-display-and-font- bibliotek/ få glidelåsen nederst og legg gfx og 9341 manuelt i arduino bibliotekmappen

Trinn 4: ANSI -standarden

ANSI tillater enkle kommandoer for å fjerne skjermen, flytte markøren rundt og endre farger. På noen av bildene er det en demo som viser alle forgrunns- og bakgrunnsfargene. Disse er rød, gul, grønn, blå, cyan, magenta, svart, hvit, mørk grå, lys grå, og fargene kan være lyse eller svake, så det er 16 forgrunns- og 16 bakgrunnsfarger.

Det er fullt mulig å tenke på å legge til i en "grafikk" -modus hvor du kan tegne bilder med mye høyere oppløsning på pikselnivå og med 256 eller flere farger. De viktigste begrensningene er det interne minnet til Arduino og tiden det tar å sende et bilde ned en seriell lenke på 9600 baud.

Koden trenger en byte for å lagre tegnet og en byte for å lagre fargene (3 biter for forgrunnen, 3 for bakgrunnen, en for lys/svak og en for fet). Så en 80x30 -skjerm trenger 2400x2 = 4800 byte, som vil passe inn i en Mega, men ikke en Uno.

Trinn 5: Viser

Over er bilder av hver enkelt skjerm. Det er bilder fra forsiden og baksiden av hver skjerm, og de representerer mange av merkene som er tilgjengelige på ebay eller lignende. Noen er I2C, noen er parallelle, noen har større fonter, noen kan vise hele 80 kolonner egnet for Wordstar og andre gamle tekstbehandlingsprogrammer. Det er flere detaljer i teksten til arduino -koden.

Trinn 6: Skjematisk

Nedenfor er to filer. De er navngitt som.txt ettersom Instructables ikke håndterer.zip -filer. Last ned dem og gi dem nytt navn til.zip.

Det er skjematisk og tavleoppsettet som pdf -filer. Det er også en pakke for Seeed PCB. Dette er gerberne, og hvis du går til Seeed og laster opp dette, bør det vise gerberne, og du kan deretter lage PCB. Bordet med 14 segmenter er stort og koster ganske mye mer, men det mindre passer i Seeed foretrukne 10x10cm -format, så det er ganske rimelig for 5 eller 10 brett - faktisk koster frakt mer enn brettene.

Det er fullt mulig å bruke mange av skjermene uten at du trenger en PCB. Det er PS2 -sokkelmoduler, RS232 -skjold/moduler som alle er tilgjengelige på ebay eller lignende. Noen skjermer som I2C kan bare bruke noen få tilkoblingskabler. Noen som SSD1289 -skjermer kommer med adapterkort og kan plugges rett inn i en Mega.

Trinn 7: Starburst Display

Starburst -skjermen er et større brett og bruker en Nano og et antall 74xx -brikker for å gjøre multipleksingen. Det var mange eksperimenter for å avgjøre hvor mange skjermer du kunne multiplexere før de ble for svake eller flimringen ble for merkbar. Displayene kom fra Futurlec https://www.futurlec.com/LEDDisp.shtml De 14 segmentvisningene kan også gjøre små bokstaver, og disse kan endres i koden om nødvendig. Gi disse filene nytt navn fra.txt til.zip

Trinn 8: Legge til kode for andre skjermer

Det er mulig å legge inn kode for andre skjermer. Det første trinnet er å få noe, noe, til å vise. Det kan være en piksel eller en bokstav. Dette innebærer hovedsakelig å søke etter drivere, laste ned en, teste den, finne den ikke vil kompilere, deretter avinstallere den driveren slik at den ikke forårsaker forvirring senere, og deretter prøve en ny. Det neste trinnet er å få en bokstav til å vises i riktig farge, ettersom noen skjermer som ser identiske faktisk vil invertere fargene. Heldigvis vil vanligvis bare ett tall i oppstartskoden fikse dette. Neste trinn er å skrive noen få linjer for å definere om du vil bruke en uno eller mega, skjermbredden, høyden, skriftstørrelsen, tastaturpinner og hvilke driverfiler som skal brukes. Disse starter på linje 39 i koden, og du kan kopiere formatet til de eksisterende skjermene.

Neste er å gå ned til linje 451 og legge til oppstartskoden. Det er her du angir bakgrunnsfarge og rotasjon og starter visningen.

Neste er å gå til linje 544 og legge til koden for å vise et tegn. I noen tilfeller er dette bare en linje, f.eks

my_lcd. Draw_Char (xPixel, yPixel, c, tftForecolor, tftBackcolor, 1, 0); // x, y, røye, for, bak, størrelse, modus

Neste er å gå til linje 664 og legge til koden for å tegne en piksel. Igjen, noen ganger er dette bare en linje, for eksempel:

tft.drawPixel (xPixel, yPixel, tftForecolor);

Til slutt går du til linje 727 og legger til koden for å tegne en vertikal linje for for eksempel markøren

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

Programmet sorterer ut ting som hvor mye minne som skal tildeles for skjermbufferen basert på skjermbredden og skriftstørrelsen.

Trinn 9: Wordstar -demonstrasjon

Dette ble gjort ved hjelp av en CP/M -datamaskin, og det er mange alternativer tilgjengelig her. Jeg trengte noe raskt å sette opp, så brukte en emulering på en ESP32 (Google ESP32 CP/M). Det er mange andre retro -datamaskiner tilgjengelig, for eksempel Grant Searles FPGA -emulering og RC2014 for de som foretrekker å bruke en ekte Z80. Mange retrodatamaskiner pleier å bruke et terminalprogram på en PC som skjerm, f.eks. Teraterm. Mye feilsøking av dette ANSI -prosjektet innebar å kjøre et terminalprogram og ANSI -programmet parallelt og sørge for at skjermene så identiske ut.

Trinn 10: Ytterligere tanker

Etter hvert som skjermene blir større, blir de langsommere og langsommere. Å tegne et tegn på nytt innebærer å tegne hver piksel i det tegnet ettersom bakgrunnsfargen også må tegnes, så alt kommer an på hvor raskt du kan tegne en piksel. Det er noen justeringer, for eksempel hvis en skjerm ikke kan følge med dataene som kommer inn, bare lagre teksten i skjermbufferen og deretter tegne en fullskjerm på nytt når det ikke kommer mer tekst. Mange skjermer du ser for salg viser et pent bilde på skjermen, men det de kanskje ikke viser er hvor lang tid det tok å vise det bildet, og i noen tilfeller kan det være 5 sekunder eller mer. I2C og SPI er flotte for de mindre skjermene, men alt over omtrent 50 kolonner trenger en 8 eller 16 biters databuss.

Wordstar er litt uhåndterlig å bruke på 9600 baud og 19200 er mye mer brukbart for å rulle tekst, men skjermene kan virkelig ikke følge med.

Den raskeste skjermen jeg har brukt var på propellbrikken med to 8 -bits eksterne 512k ram -brikker, for å lage en 16 -biters parallell databuss. Hver skrifttype ble forhåndslastet i rammen. En kaskade med 74xx tellerchips ble brukt til å klokke ut dataene i displayet. Dette betydde at det ikke var noen intern prosessering i CPU -en som hentet og sendte ut data, og oppdateringsfrekvensen var så rask som propellbrikken kunne bytte en pin. Overraskende nok var skjermene i stand til å holde tritt med dette, selv ved 20Mhz, og det var derfor mulig å gjøre en fullskjermoppdatering på bare 30 millisekunder. Den typen hastighet er rask nok til å rulle jevnt, som du ser på mobiltelefoner.

Propellbrikken var banebrytende for over ti år siden, og det er flere alternativer nå, inkludert ESP8266 og ESP32 som har store mengder intern ram. Imidlertid har disse brikkene fremdeles ikke stort antall pinner, så det kan fortsatt være fortjeneste å bruke den gamle skolen-måten for en ekstern rambrikke som er klokket ut til skjermen.

For større skjermer kan det være billigere å bruke en LCD -TV eller VGA -skjerm og se på noen av ANSI -emulatorene som er kodet, f.eks. ESP32, som driver VGA direkte.

Jeg håper du synes dette prosjektet er nyttig.

James Moxham

Adelaide, Australia