Displays. Alles wat je kunt zien...

Tekst displays

Displays geschikt voor het tonen van tekst en getallen, maar geen tekeningen.

Grafische zwart-wit of tweekleuren displays

Displays geschikt voor het weergeven van tekst en plaatjes.
Oled displays
- gebruiken heel weinig energie
- hebben een grote kijkhoek (tot wel 170°)
- reageren snel
- hebben geen achtergrondverlichting nodig
 

Grafische kleurendisplays

Waarschuwingen en tips:

Losse kleuren displays

 

Kleuren display shields

Het scherm in landschap stand, met bewegende tekstbalk.
Het display "shield" op een Arduino mega.
Ik heb enkele 2,4 en 3,5 inch "MCUFRIEND" compatibele display shields getest. Vooral de 3,5 inch uitvoering is erg mooi. Ze zijn gemakkelijk aan te sluiten: gewoon voorzichtig op een Arduino Uno of Arduino Mega drukken. Bij de bibliotheek MCUFRIEND_kbv.h zitten verschillende demo programma's. Maak je geen zorgen als je een foutmelding op het display krijgt zoals "broken display" of "unknown" display. Je weet dan dat je scherm werkt. Probeer dan een ander demo programma. Een van deze programma's is graphictest_kbv.ino. Dit programma laat zien wat allemaal mogelijk is met de bibliotheek: indrukwekkend! Op de foto's zie je een van de voorbeelden uit dit programma. Als je een aanraakdisplay hebt dan zou je het programma "UTouch_Calibr_kbv.uno" (met de bibliotheken UTFTGLUE.h en TouchScreen.h) kunnen gebruiken om het display te ijken. Dat lukt alleen als je een puntig aanwijsvoorwerp gebruikt en niet een vinger. Hoewel mijn display wel op aanraken reageert krijg ik de calibratie niet voor elkaar.
Er zijn ook uitvoeringen met een slot voor een SD kaartje aan de onderkant. Als je plaatjes wil weergeven is dat een 'must'.

Shield voor de Lolin/WeMos D1 mini

2,4" shield voor D1 mini
WeMos heet tegenwoordig Lolin, maar de naam WeMos kom je nog overal tegen. De D1 mini is een op de esp2866 of esp32 gebaseerde Arduino-compatible module. Inmiddels is de ondersteuning vanuit de Arduino Ide zo goed dat er nauwelijks redenen zijn om deze zeer goedkope module niet te gebruiken. De Lolin/WeMos modules werken zonder uitzondering erg goed, is mijn ervaring. Het grote voordeel is natuurlijk dat je ze kunt gebruiken met internet. Daarom is het ook erg fijn dat er een display shield voor de WeMos D1 mini is. Je kunt dan bijvoorbeeld het weer vanuit buienradar.nl of een via internet gesynchroniseerde klok weergegeven. Ik testte het 2.4" Lolin scherm-shield voor de mini D1. Dit display heeft een resolutie van 320 bij 240 pixels. Er is een werkende demo te vinden op internet. Ik vind dit een bijzonder mooi schermpje. Dit shield heeft geen sleuf voor SD kaartje, maar je kunt plaatjes vanuit het flash geheugen van de D1 mini gebruiken. Hoe, dat moet ik nog uitzoeken. Het scherm kan overigens ook via SPI worden aangesloten op bijvoorbeeld een Arduino, of via een (bij te kopen) TFT kabeltje. Hieronder zie je een voorbeeld van een weergave van actuele gegevens (elke 5 minuten ververst) van weerstation Schiphol. Je ziet dat hij los van de computer werkt (in dit geval gevoed door een powerbank). De code is gebaseerd op een eerder in Computer!Totaal gepubliceerd programma.
Dit station kan lang werken op deze goedkope powerbank...
Houd er rekening mee dat veel powerbanks zichzelf vrij snel uitzetten
omdat ze zo weinig stroom hoeven te leveren.

Klein shield voor de Lolin/WeMos D1 mini

1,44inch displayHet 1.44″ display shield
Het 1,44″ display shield werkt ook erg goed met de voorbeeldprogramma's die je vindt op sites waar dit display wordt verkocht. Het past op een WeMos D1 mini waar vrouwelijke connectors op zitten..
Klik hier om een testprogramma te zien
 

Numeriek display

Alleen geschikt voor het weergeven van getallen en tijden.
 

14-segment display met HT16K13 interface

Het display in actie
Naast de numerieke displays met 7 segmenten zijn er ook displays met meer dan 7 segmenten. Deze kunnen mooiere cijfers weergeven, maar zijn ook meer geschikt voor het weergeven van tekst. Displays met 14 segmenten zijn erg populair. Ik testte de I²C versie, met 4 cijfers in rood, oranje of groen. Vooral het groene display is erg mooi en super helder. Het display heeft vijf pinnen, waarvan twee voor I²C en twee voor de voeding. De vijfde pin "Vi2c" moet je op VCC aansluiten. Als deze pin wordt aangesloten op 3,3 V dan vindt de communicatie ook met 3,3 V plaats en als hij wordt aangesloten op 5 V dan vindt de communicatie plaats met 5 V. Zo kan er niets mis gaan als je het display op een ESP aansluit. Er bestaan diverse bibliotheken voor deze displays. Ik gebruikte de uitstekende bibliotheek NoiascaHt16k33.h. Je kunt deze op internet vinden in een zip bestand. Je kunt dit installeren via het IDE menu (Schets → Bibliotheek gebruiken → Voeg .ZIP bestand toe...). Nadat je het zip bestand hebt gekozen en geïnstalleerd kun je in het menu voorbeelden allerlei voorbeeldprogramma's vinden. Ik gebruikte Bestand → Voorbeelden → NoiascaHt16k33 → 11_HelloWorld_14segment. Hierin zie je de vele mogelijkheden van het display.
Standaard gebruikt het display adres 0x70, maar je kunt dit verhogen tot maximaal 0x77 door aan de achterkant een paar punten aan elkaar te solderen. Zo kun je tot maximaal 8 displays tegelijk gebruiken. De intensiteit van het display kan in 16 stappen geregeld worden. Op de foto is helderheid 3 gebruikt, maar het lukt niet om goed te laten zien hoe mooi dit display in werkelijkheid is.
Er bestaan ook displays die geen I²C gebruiken, maar die kun je alleen gebruiken als je minimaal 16 pinnen vrij hebt.  

8x8 led matrix (MAX 7219)

Dit zijn displays die je goed kunt gebruiken voor speciale effecten. Je kunt ze met elkaar doorverbinden, tot maximaal 8. Je krijgt dan een nogal groot display, waarmee je bijvoorbeeld een lichtkrant kunt maken. Er zijn maar drie signaaldraadjes vanaf de Arduino nodig. Je kunt per pixel bepalen of deze brandt of niet en je kunt de totale helderheid instellen.
Tip: als je een kit koopt om zelf te solderen bekijk dan de tutorial op https://www.youtube.com/watch?v=41hN4MXJBRo. Zorg er in ieder geval voor dat het display via een paar vrouwelijke "pin headers" met de printplaat verbonden wordt. Op de condensator zie je een dikke witte streep. Het pootje dat hierbij zit moet in het onderste gaatje worden gesoldeerd. Let ook op dat je de IC-voet in de goede richting monteert. Het inzetten van het IC moet voorzichtig gebeuren!
Je kunt bij dit display de bibliotheek LedControl.h gebruiken. De sketch voor twee (of meer) aan elkaar geschakelde displays hieronder laat de tekst Arduino op verschillende wijze op beide displays zien. Je kiest hier voor AantalDisplays = 2, ook als je meer displays hebt doorgeschakeld. Als je een ongeldige waarde voor AantalDiplays kiest dan wordt deze automatisch op 8 gezet. Ik heb gekozen voor liggende displays. Als jij ze rechtop zet, dan kun je lc.setRow overal vervangen door lc.setColumn.
In plaats van LedControl.h kun je het display zelf programmeren of je kunt SPI gebruiken. Dit alles werkt ongeveer even goed. Ik geef alleen de voorbeeldcode voor de LedControl.h versie.

 Klik hier om testprogramma te zien 
Een paar dingen om op te letten: er zijn diverse varianten van deze displays in omloop. Dat kan betekenen dat de nummering van de lijnen omgekeerd is. Dat kun je in de software gemakkelijk oplossen. Als ook de kolommen zijn omgewisseld dan moet je mogelijk andere bitmaps gebruiken. Dan zijn er ook nog displays die je aan de andere kant van de chip moet solderen...
WarningNegen displays kan ook

Als je meer dan 8 displays gebruikt dan wordt de tekst van het begin af gewoon herhaald. Je kunt hiervan gebruik maken, zoals je hieronder ziet. In werkelijkheid zijn de ledjes mooi helder rood. Hier zie je ook dat het eerste display een ander type is. Dat maakt niet uit, maar dit is wel een display dat op zijn kop gezet moet worden ten opzichte van het andere type...

Met mijn eigen bibliotheek kun je de letters dichter bij elkaar zetten, zodat er meer tekst op past.
AngeliqueProportionele letters

Tenslotte: als je nog langere displays wilt maken of een aantal onder elkaar dan kan dat ook: definieer gewoon een tweede LedControl variabele in de software, en gebruik voor de tweede set displays andere aansluitpinnen. Een andere manier is om de hieronder beschreven bibliotheek te gebruiken.

Een super bibliotheek voor panelen met deze displays

Inmiddels is er een goede bibliotheek voor panelen van deze 8 bij 8 displays: Max72xxPanel.h; je hebt hierbij ook Adafruit_GFX.h nodig. Het grote voordeel van deze bibliotheek is dat je een makkelijke manier hebt om rekening te houden met configuratie van de displays. Je kunt opgeven hoe je de displays hebt opgesteld (bijvoorbeeld 4 kolommen van 2 rijen) EN voor elk display of en hoe de tekst geroteerd moet worden. Hierdoor kun je displays van verschillende types door elkaar gebruiken. Dit werkt fantastisch, al moet je natuurlijk de instellingen aanpassen als je andere displays gaat gebruiken. Maar dat kan nu eenmaal niet anders omdat alle fabrikanten de displays anders produceren.
Het is met deze bibliotheek mogelijk om meer dan 8 displays aan elkaar te koppelen en afzonderlijk te besturen. Ik heb een goed werkende lichtkrant van 16 displays gemaakt. Meer dan 16 displays lukte niet. We lukte het twee rijen van 12 displays te maken (24 displays in totaal dus). Dat werkt erg goed en met de Arduino Uno had ik zelfs geen extra stroombron nodig.  

Staafdiagram display (batterij display)

Een staafdiagram display (ook batterijdisplay genoemd) is een display dat bestaat uit vijf tot tien staafjes of segmenten, meestal in verschillende kleuren. De kleuren zijn vast, bijvoorbeeld eerst één blauwe, dan drie groene, twee gele en twee rode. Dit kun je uitstekend gebruiken om aan te geven hoever een batterij nog vol is of om een ruwe indicatie van de temperatuur te geven. Bij de goedkoopste uitvoering van het display zijn er aan de achterkant per staafje twee pinnen. Daarmee kun je het display aansluiten alsof het allemaal losse leds zijn (en dat zijn het trouwens ook). Dat betekent ook dat je per led een weerstand moet aansluiten. Bij een 5 volt Arduino is 220 Ω een geschikte waarde. Er zijn ook displays met een maar vier draden, waarvan er twee gebruikt worden voor de aansturing van het display. Daarover verderop meer. Als je het display op een breadboard wil aansluiten dan is het het eenvoudigst om de weerstanden aan de negatieve kant van de leds aan te sluiten (naar aarde toe). Je kunt de andere kant dan op de pinnen van de Arduino aansluiten. Als je een 10 segment display hebt dan kun je de pinnen 0 t/m 9 gebruiken. Het gebruik van de pinnen 0 en 1 geeft in dit geval bij het uploaden geen problemen. Bij mijn display is de positieve kant van de leds de kant waar de tekst op staat. Hieronder zie je een voorbeeld van een simpel testprogramma. Dit loopt van koud naar warm (dat wil zeggen van blauw naar rood) of van warm naar koud afhankelijk van hoe je pootjes van het display hebt aangesloten (van links naar rechts of van rechts naar links). Zoals het in de figuur is aangesloten gaat hij van warm naar koud (ofwel van leeg naar vol, dus geschikt om een batterijspanning weer te geven). Als je de schakelingen van de pro micro of de nano maakt, laat de lussen in het programma dan niet bij 0, maar bij 2 beginnen. Waar de lus moet stoppen hangt af van het aantal staafjes op je display.
void setup() {
  for (int i = 0; i < 10; i++) pinMode(i, OUTPUT);
}

void loop() {
  for (int i = 0; i < 10; i++) {
    digitalWrite(i, HIGH);
    delay(400);
  }
  for (int i = 0; i < 10; i++) digitalWrite(i, LOW);
}

Hier zie je drie eenvoudige manieren om een staafdiagram display aan te sluiten: op een Arduino Uno (of Leonardo of Mega) op een pro mini of op een Arduino nano
Display in werking
(met de Leonardo)
Display in werking
(met de nano)
Links en rechts zie je foto's van twee van deze schakelingen die ik maakte met een 10 segment display. Zoals altijd als je ledjes fotografeert: de kleuren zijn in werkelijkheid veel briljanter.Je kunt op de pro mini op deze manier gemakkelijk een 8-segments display aansluiten. Met een 10-segments display zul je minimaal twee gewone kabeltjes moeten gebruiken.

Voor de module met de twee-draden interface gebruikte ik een op de TM1651 gebaseerd model. Hiervoor bestaat een bibliotheek (TM1651.h) met een demo programma. De displays hebben vaak schuine staafjes wat iets mooier is dan de rechte, maar er is wel een probleem met het 10-segments display want als je goed kijkt dan zie je dat niet alle staafjes afzonderlijk aan te zetten zijn. Omdat de TM1651 een 8 bits leddriver is, kunnen hooguit 8 staafjes afzonderlijk worden aangezet.

Hoewel het niet gebruikelijk is, kun je de staafjes in een willekeurig patroon laten oplichten. Bij het display zonder TM1651 doe je dat gewoon in je Arduino programma, door de juiste pin hoog te zetten; bij het TM1651 display moet je dat veranderen in de bibliotheek. Als je voor het 10-segments display hebt gekozen dan ben je veel pinnen kwijt, maar het is mogelijk dit op te lossen. Een mogelijkheid die goed werkt, is met twee shiftregisters. Je kunt dan elk patroon creĆ«ren met slechts twee signaalpinnen. Op de Arduino website https://www.arduino.cc/en/Tutorial/ShiftOut kun je precies zien hoe je twee shiftregisters kunt gebruiken.  

14 bij 9 monochroom LoL-display shield

In werkelijkheid is display veel mooier dan op de foto.
Dit shield past alleen op de Arduino Uno, Leonardo en Mega. Meestal koop je het als bouwdoos en dan ben je wel even bezig met het solderen. De ledjes zijn in allerlei kleuren te krijgen, maar de leds van één display moeten allemaal identiek zijn. Om met weinig pinnen veel leds te kunnen aansturen wordt bij dit display gebruik gemaakt van een bijzondere techniek: Charlieplexing. Met n pinnen kun je dan n·(n-1) leds aansturen. Voor het LoL ("Lots of Leds") display zijn dus 12 pinnen nodig, en die heeft de Arduino Uno. Als je dit display wil gebruiken download dan de bibliotheek LoLshield-master.zip van het Internet. Na installatie kun je dan via het menu voorbeelden enkele programma's testen. Dit is een leuk display voor speciale doeleinden, maar meestal zijn de 8 bij 8 Max7219 displays handiger, omdat je die op verschillende manieren kunt samenvoegen tot grote displays die met slechts enkele pinnen bestuurd kunnen worden. Tip: Charlieplexing is uiterst ingewikkeld en heeft veel nadelen. Als je zelf toepassingen hebt met veel leds, gebruik dan shift registers of de Max7219 chip.  

VGA scherm

Je hebt gezien dat de Arduino met gemak een display met een resolutie van 480 bij 320 kan aansturen. Je zou dus kunnen denken dat het ook geen probleem is een VGA scherm aan te sturen. Maar het tegendeel is waar! De Arduino heeft te weinig geheugen en is te traag om een volledig VGA signaal te kunnen leveren. Toch kun je een VGA scherm gebruiken, maar dan met een matige resolutie en weinig kleuren. Dus als je weinig tekst wilt laten zien, of ruwe grafieken dan kan het. Je zult wel een beetje moeten knutselen. Als je dat leuk vindt dan is het de moeite waard om het te proberen... De programma's die ik hier beschrijf werken alleen met de Arduino Uno, niet met bijvoorbeeld de Mega.
VGA connector
Omdat VGA geleidelijk verdwijnt kun je vrij gemakkelijk aan oude VGA kabeltjes komen, misschien heb je er zelfs wel een paar liggen. Je kunt zo'n kabel geschikt maken voor gebruik met de Arduino. Makkelijker is het om een vrouwtjes connector te gebruiken, maar die moet je wellicht kopen. Met de kabel gaat het als volgt: knip een connector van de kabel af. Als de kabel een verdikking heeft vlak voor de connector dan mag je die er ook afknippen. Strip nu de kabel over enkele centimeters. Je ziet allerlei draden met daartussen veel aarde. Het is nog niet zo makkelijk om te voorkomen dat de gestripte draden kortsluiting met aarde maken, dus daar moet je goed op letten. Van alle draden zijn er maar vijf van belang: de draden voor het rood, groen en blauw signaal. Bij de veel gebruikte donkerblauwe VGA kabels zijn dit de dikste draden, die ook de kleuren rood groen en blauw van hun isolatie hebben. Er zijn ook nog dunne draden, met allerlei kleuren. Twee van die dunne draden zijn erg belangrijk: zij verzorgen het horizontale en vertical sync signaal. Bij de genoemde kabel zijn deze draadjes erg dun en breken makkelijk af. Je kunt deze draadjes vinden door met een Ohm-meter na te gaan met welke draadjes verbonden zijn met pootje 13 en 14 van de connector. Je moet de draden aansluiten op de Arduino, met een weerstand ertussen. Het werkt erg makkelijk als je de weerstanden al aan de kabeltjes soldeert en eventueel met een stukje krimpkous beschermt. Voor de kleurenkabels moet je precies 470 Ω gebruiken, voor de sync komt het minder nauw, alles tussen 50 Ω en 120 Ω is goed, misschien mag het ook wel zonder weerstand. De overige draden kun je met elkaar verbinden en aan aarde leggen, maar ook als je deze draden laat zweven zal alles nog wel werken.
VGA tekst
VGA palet
Je kunt nu de voorbeelprogramma's gebruiken die je op internet onder de naam Nick Gammon vindt. Daarbij staat ook hoe je de draden moet aansluiten. Bij de programma's van Nick Gammon is het bijna altijd VSync op pin 10, HSync op pin 3 en R, G en B op de pinnen 4, 5 en 6 (in deze volgorde - als je geen kleur wilt kun je ze samen aansluiten op pin 4). Bij programma's van andere mensen is dat vaak heel anders! Ik heb bijna alle programma's van Nick Gammon getest. Ze werken tamelijk goed. Je ziet links en soort testbeeld met alle kleuren die mogelijk zijn. Daarnaast testte ik alle voorbeelden bij de bibliotheek VGA-master van Sandro Maffiodo. Hierbij sluit je maar twee maar twee van de drie kleurenkabels aan. Als je de kleuren niet goed vindt, dan kun je gewoon de kabels omwisselen. De kans dat je VGA monitor kapot gaat als je dat doet terwijl deze aanstaat is erg klein. Ik heb de voorbeeld programma's bij deze bibliotheek allemaal uitgeprobeerd en ze zien er bijzonder goed uit. De rechter foto is van een aangepaste versie van bitfont.uno; daarbij heb ik de lichtkrant stilgezet zodat een mooi rustig beeld ontstaat.
Houd er rekening mee dat de Arduino processor niet veel andere dingen kan doen tijdens het weergeven van het beeld. Voor serieuze programma's kun je daarom het beste een tweede Arduino aansluiten (mag elk type zijn), die het rekenwerk doet. Deze stuurt de gewenste tekst door via een seriële lijn naar de eerste Arduino.  

TV scherm (zwart-wit via composiet ingang)

De foto is iets overbelicht, in werkelijkheid is het beeld haarscherp.
Snoertje met ingebouwde weerstanden
Als je nog een TV hebt met een composiet ingang dan kun je die prima gebruiken als eenvoudig scherm bij je Arduino. Op marktplaats worden oude TV's soms gratis aangeboden (vooral loeizware exemplaren 😉). Sommige TV's hebben een zogenaamde component video ingang. Die gebruikt dezelfde tulpstekkertjes, maar toch kun je deze meestal niet gebruiken. Als een ingang wèl geschikt is voor composiet; dat staat dat meestal bij die ingang vermeld. Het composiet signaal stelt niet overdreven veel eisen aan de Arduino en daarom kun je ook andere Arduino's dan de Uno gebruiken.
Als eerste moet je een composiet kabeltje geschikt maken voor je Arduino. De tulpstekker van het composiet video signaal is geel, maar als je een snoertje hebt met een andere kleur, bijvoorbeeld voor geluid, dan is dat ook goed. Aan een kant blijft de tulpstekker zitten, aan de andere kant knip je de stekker eraf. Als je het einde stript, dan zie je een enkele kabel met daar een afscherming om (aarde). Het beste is als je nu gaat solderen, maar als je dat liever niet doet: het lukt ook met krokodillenklemmen en een breadboard. Je hebt een weerstand nodig van 1 kΩ en een van 470 Ω. Beide maak je vast aan de middelste draad. Aan de aarde en aan de twee weerstanden bevestig je een half dupont kabeltje. Zoals je op de foto ziet heb ik de weerstanden verstopt in een stukje krimpkous om alles wat steviger te maken, maar noodzakelijk is dat niet. Het hangt van je Arduino af welke twee ingangen je moet gebruiken. Bij de Arduino Uno moet de weerstand van 1 kΩ naar pin 9 en die van 470 Ω naar pin 7. Op internet kun je lijstjes vinden van de andere Arduino's. Download nu de bibliotheek TVout.h. Deze bibliotheek bevat enkele demo's. Als je TVout hebt geïstalleerd (via library manager of zelf), dan zullen de demo's niet werken. Eerst moet je de map "TVoutfonts" verplaatsen naar je library map en daarna de Arduino opnieuw opstarten. Er zijn verschillende versies van TVout in omloop, dus misschien zijn sommige versies beter dan de door mij gebruikte versie 1.0.1. Er is ook een versie die geluid ondersteunt, maar dat heb ik niet getest. Als je te werk gaat volgens de demo "DemoPAL" dan kun je maximaal 11 korte regels tekst laten zien (met klein font 15 regels). Er zit echter een klein foutje in deze demo: de breedte wordt ingesteld op 120 in plaats van 128 pixels. Hierdoor zie je bij weergave van bitmaps soms kleine foutjes. Je moet dat dus even aanpassen. Het blijkt echter dat bij mij een grotere horizontale resolutie ook stabiel werkt. Ik weet niet of dat komt door mijn TV, of de Arduino of iets anders, maar het is zeker de moeite waard om dit uit te proberen. Plot hiertoe even een rechthoek om het scherm. Je kunt nu de horizontale resolutie in stappen van 8 pixels groter maken en steeds kijken of je de volledige rechthoek ziet. Zet dit in de setup() functie:
  TV.begin(PAL, 144, 96); // Test vanaf 128 met stappen van 8 of het programma blijft werken...
  TV.draw_rect(0, 0, TV.hres() - 1, TV.vres() - 1, 1); // Test dat met deze regels
  delay(4000); 
De dikke en de dunne op mijn TV (144 pixels breed)
Bij mij zag ik tot 144 pixels een perfecte rechthoek, daarboven viel het beeld weg. Met 144 pixels heb je een scherm dat veel beter is dan het vierregelig display dat boven aan deze bladzijde is beschreven.
De tekst en grafiekmogelijkheden zijn met "DemoPAL" al goed te zien. Daarom geef ik hier alleen een demo die bitmaps laat zien. Hierbij heb je de font bibliotheek niet nodig. Je moet er rekening mee houden dat als je een grote bitmap hebt, je de beginpositie links op 0 moet zetten, want de bitmap functie in de bibliotheek maakt fouten als de bitmap aan de rechterkant buiten het scherm komt. Ik heb hieronder het voorbeeldprogramma voor zowel de 128 versie als de 144 versie neergezet, omdat ik niet weet of de laatste bij iedereen werkt. Laat het me gerust weten!
De bitmaps maak ik met een hulpprogramma, nadat ik met een beeldverwerkingsprogramma de beelden heb verkleind en teruggebracht naar zwartwit.
Hieronder zie je enkele van de gebruikte bitmaps (128 pixels of minder), gefotografeerd van het scherm. Het demoprogramma laat ze achter elkaar zien.
(Rechter plaatje: bitmap, geen foto)
En hieronder de foto's van de bredere bitmaps tot 144 pixels (de foto van de Dikke en de Dunne staat al elders op deze pagina):
(deze is niet opgenomen in de demo, maar geeft een goed beeld van de leesbaarheid)
Je kunt - afhankelijk van de gebruikte Arduino - behoorlijk veel bitmaps opslaan. Ze worden opgeslagen in program memory, zodat je nog veel ruimte overhoudt voor lokale variabelen. Tenslotte dit: wij gebruiken in Europa het PAL videosysteem, maar je kunt ook voor NTSC kiezen. Mijn TV werkt ook met NTSC, maar maakt de pixels dan iets groter...
TV_bitmaps.ino heb ik met succes getest met de Uno, de Mega (pinnen 11 en 29) en de nano met ATmega328 processor. Met een nano met ATmega168 kreeg ik geen beeld.
De programma's zijn erg lang door de vele bitmaps, daarom is het niet handig ze te kopiëren via je scherm. Je kunt wel de volledige versie downloaden via onderstaande knoppen. Als je toch het programma wilt zien dan kan dat. Alleen heb ik de meeste regels van de bitmaps weggelaten. Zo wordt de structuur van het programma goed zichtbaar. Maar van je scherm af kopiëren en runnen gaat dus niet.

Structuur van de demo-programma's:
#include <TVout.h>
TVout TV;
PROGMEM const byte Anu[] = {
  128, 96,
  0xff, 0xff, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x1f, 0xff, 0xff,
  // ..
  // hier moeten nog 95 rijen met getallen staan. Download het volledige programma van deze site
  // ..
};

PROGMEM const byte Hert[] =
{
  128, 96,
  0xf7, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  // ..
  // hier moeten nog 94 rijen met getallen staan. Download het volledige programma van deze site
  // ..
  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xaa, 0xff, 0xff, 0xef, 0xff, 0xff, 0xff, 0xea,
};

PROGMEM const byte Einstein[] = {
  96, 96,
  0x00, 0x00, 0x00, 0x00, 0x00, 0x2c, 0x02, 0x40, 0x00, 0x00, 0x00, 0x00,
  // ..
  // hier moeten nog 95 rijen met getallen staan. Download het volledige programma van deze site
  // ..
};


PROGMEM const byte LenH[] = { // Laurel en Hardy
  128, 93,
  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
  // ..
  // hier moeten 92 rijen met getallen staan. Download het volledige programma van deze site
  // ..
};

PROGMEM const byte Olifant[] = { // Olifant
  124, 96,
  0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfd, 0x10, 0x1f, 0xff, 0xff, 0x57, 0xff, 0xf0,
  // ..
  // hier moeten nog 95 rijen met getallen staan. Download het volledige programma van deze site
  // ..
};

void setup() {
  TV.begin(PAL); // is hetzelfde als TV.begin(PAL, 128, 96)
}

void loop() {
  TV.bitmap(0, 0, Anu); // Moet beginnen op x = 0!
  TV.delay(4000);
  TV.bitmap(0, 0, Hert);
  TV.delay(4000);
  TV.clear_screen();
  TV.bitmap(16, 0, Einstein);
  TV.delay(4000);
  TV.clear_screen();
  TV.bitmap(0, 0, Olifant);
  TV.delay(4000);
  TV.clear_screen();
  TV.bitmap(0, 0, LenH);
  TV.delay(4000);
  TV.clear_screen();
}
 

e-Paper displays

e-PaperEen 1,54″ e-Paper display
e-Paper displays zijn displays die op papier lijken: ze geven zelf geen licht, maar ze zijn goed leesbaar bij daglicht of kunstlicht. De afbeeldingen op een e-Paper display kunnen wel twee jaar zichtbaar blijven, ook zonder voedingsspanning. De meeste displays zijn zwart-wit, of kennen 4 of 16 grijstinten, maar er zijn er ook met drie kleuren (zwart en wit met daarbij rood of geel). Ze zijn in allerlei afmetingen en resoluties te krijgen, maar de grotere worden al snel erg duur. Omdat de displays alleen stroom gebruiken als het plaatje erop veranderd wordt, zijn ze erg geschikt voor batterij toepassingen. Voor gaming zijn ze totaal niet geschikt want de verversfrequentie is erg laag, vooral bij de meerkleuren displays (tot 10 seconde). Kijk voor je zo'n display koopt of ze "partial refresh" ondersteunen dan kun je alleen het deel dat wijzigt in het displaygeheugen laden. Dat is dan snel genoeg voor bijvoorbeeld een secondenteller (maar niet voor een stopwatch met tienden van een seconde). Helaas is partial refresh bij grote displays nog niet mogelijk.
e-Paperpasfoto van Cindy.
Het display is goed te gebruiken voor situaties waarbij de gegevens niet vaak hoeven te worden ververst. Te denken valt aan een bordje dat aangeeft of je aan- of afwezig bent. Met een knop gaat de Arduino even aan en wordt de toestand veranderd. Daarna kan de Arduino weer helemaal van de stroom af. Uiteraard heb je een foto van jezelf erin geprogrammeerd.
Voor grotere displays is het geheugen van de Arduino Uno te klein, zodat het display in delen moet worden geladen. Op zich geen groot probleem, maar handiger is het als dit niet nodig is. De grootste fabrikant van deze displays, Waveshare, heeft dan ook demo's voor gebruik met andere bordjes dan de Arduino. Omdat met name op de esp2866 of esp32 gebaseerde bordjes, zoals de nodeMCU en Wemos D1 mini, erg veel voordelen hebben, beschrijf ik dat verderop onder een apart kopje.
De meeste e-Paper displays hebben een SPI interface met drie of vier draden, maar er moeten in totaal acht draden worden aangesloten op de Arduino.
Helaas zijn de demo's van Waveshare niet erg goed. Sommige geven al foutmeldingen als je ze compileert. Je moet dan zelf het nodige aanpassen. Als ze wel werken zijn ze niet erg instructief. Waveshare heeft wel een programma om afbeeldingen om te zetten in C-code. Het uiteindelijke resultaat is erg mooi (zie de "pasfoto" hiernaast van Cindy, die ik op deze manier maakte). Als je tekst wilt kunnen gebruiken dan kun je een bibliotheek als GxEPD.h gebruiken. Het voordeel van deze bibliotheek is dat diverse displays kunnen worden gebruikt. Kijk wel goed naar de aansluitingen want die zijn net iets anders dan bij de Waveshare bibliotheek. Ook moet je nog een Adafruit font bibliotheek laden als je die nog niet hebt. Een andere software bibliotheek is SparkFun_ePaper_Arduino_Library. Deze bibliotheek heeft een (Python) programma om BMP plaatjes om te zetten naar txt formaat dat je dan weer kunt gebruiken in de programma's. Helaas gaf deze bibliotheek bij mij foutmeldingen die ik niet meteen kon oplossen. Als ik meer info heb kom ik hierop terug.
Als je een zogenaamd "raw" display koopt, dan kun je een driver board kopen. Dit kan voordelig zijn als je meerdere displays koopt die je niet tegelijk aansluit.
Tip: vooral met raw displays lukt het soms niet om ze werkend te krijgen. Dat komt omdat Waveshare steeds nieuwe versies maakt en de software loopt dan achter. Het is de moeite waard om het na een half jaar nog eens te proberen met geüpgradede bibliotheken.

e-Paper displays met WeMos of nodeMCU module

Een van de voordelen van deze modules is, dat ze contact kunnen maken met internet. Een ander voordeel is dat ze in een energiezuinige toestand kunnen worden gezet. Als je een weerstation maakt, zoals hierboven weergegeven, maar dan met een e-Paper scherm dat je niet al te vaak ververst dan kan de batterij wel een jaar meegaan!

Deze modules hebben behoorlijk veel flash geheugen (meestal 4MB). Daarin kun je op een betrekkelijk eenvoudige manier plaatjes opslaan (klik hier voor een uitleg). Inmiddels is er een voorbeeldsketch bij de allernieuwste GxEPD2 bibliotheek. Helaas moet je vrij veel veranderen in twee bestanden om alles in orde te krijgen voor jouw display en andere hardware. Ook moet je ofwel de plaatjes van de bobliotheek in het flash geheugen zien te krijgen of de namen van de bestanden veranderen. Het zou te ver voeren dit alles hier te bespreken. Als je uiteindelijk alles goed hebt ingesteld werkt dit wel heel goed. Het is niet moeilijk om het voorbeeldprogramma van de GxEPD (dus niet GxEPD2) bibliotheek aan te passen. Dit komt er voornamelijk op neer dat je SD.read() vervangt door SPIFFS.read() en nog enkele kleine wijzigingen doorvoert. Dit werkt echt perfect. Je moet de plaatjes in bmp formaat opslaan. Als je display alleen zwart en wit kan weergeven dan zijn er drie soorten plaatjes die goed werken: silhouetten, plaatjes die gedithered zijn (d.w.z. die uit losse puntjes bestaan) en lijntekeningen. Silhouetten en lijntekeningen kun je genoeg vinden op internet. Plaatjes ditheren kun je het best zelf doen. Op deze manier kun je een portret zelfs op een klein scherm zeer herkenbaar weergeven. Als je er niet uit komt, stuur me dan per e-mail een portret van jezelf (bestandsformaat maakt niet uit) met een rustige achtergrond en schrijf erbij wat de uiteindelijke afmeting in pixels moet zijn (bijvoorbeeld 200x200). Ik zal dan kijken of ik het plaatje in een goede bitmap kan omzetten en retour sturen. Als je een drie kleuren e-Paper scherm hebt en de derde kleur wilt gebruiken dan is dat een stuk moeilijker. Het lukt alleen goed met sommige portretten. Ik maak daarom meestal handmatig een deel van het portret rood. Ik zet hier vast een preview voor het 264×176 display nog zonder programma, zodat je kunt zien hoe goed een en ander er op het display uit ziet.
 Klik hier om de foto's te zien 

Ik testte al mijn e-Paper displays, waaronder het Lolin 2.13″ display "shield" (ik begrijp niet waarom men die een shield noemt, want hij moet gewoon met kabeltjes worden aangesloten), met de WeMos D1 mini en alles ging goed. De Lolin gebruikt de Lolin.h bibliotheek, samen met nog enkele andere bibliotheken. De bibliotheek werkt goed, maar het is lastig om de juiste aansluitingen te vinden. Omdat de bibliotheek zelf gebruik maakt van de ILI9341 bibliotheek kun je functies als drawCircle e.d. gebruiken. Ook kun je bitmaps afbeelden, maar het is vrij onduidelijk hoe dat precies moet als het grote plaatjes zijn. Zie verderop voor een handiger bibliotheek.
Er bestaat er een versie van de WeMos D1 mini, waar een connector voor een e-Paper display op zit. Erg handig, maar deze ESP is een stuk duurder dan de gewone uitvoering. Bij dit bordje zit een voorbeeldprogramma dat verbinding maakt met het internet. Je kunt dan je plaatjes via wifi uploaden naar de esp. Dat is eenvoudig omdat je ter plekke kunt kiezen uit een lijst met displays. Dus als je niet zeker weet welke uitvoering je hebt kun je het gewoon uitproberen. Helaas is het programma niet geheel foutvrij en missen veel e-Papers. Het png formaat werkt niet altijd. Hiernaast zie je mijn plaatje op een 2,13″, type d display, dat werkte wel goed.
Via wifi op het display gezet..

Een van de beste bibliotheken is GxEPD.h en de uitgebreidere GxEPD2.h. Deze werkt ook goed met de WeMos D1 mini. Je kunt deze in de Arduino IDE, via menu-optie bibliotheken beheren binnenhalen. In de bijbehorende demo programma's wordt prima beschreven hoe je het scherm moet aansluiten. Ik moet wel zeggen dan als je een nodeMCU gebruikt die afwijkende pinnen voor SPI heeft, het erg lastig is om dit aan de praat te krijgen, maar met de WeMos D1 mini en enkele andere nodeMCU's is dat geen probleem. Je kunt na installatie via menu-optie voorbeelden onder andere het programma GxEPD_WiFi_Example.ino inladen. Je moet hierin de naam van de internetverbinding en je wachtwoord invoeren. Houd er rekening mee dat iedereen die bij deze sketch kan komen dit kan zien en daarom moet je als je zo'n sketch verspreidt deze gegevens verwijderen. Een ander heeft er immers niets aan, maar kwaadwillenden wel. Je moet in de sketch aangeven welk display je hebt. Boven in de sketch vind je een hele lijst. Bij elke nieuwe versie wordt de lijst met ondersteunde displays uitgebreid. Je moet bij het juiste scherm de commentaarstrepen weghalen. Als je niet precies weet welk display je hebt: het kan geen kwaad als je de verkeerde keuze maakt: gewoon opnieuw proberen met de andere. Als alles goed werkt, dan zie je in de seriële monitor dat het programma contact zoekt met het internet. Er worden dan een serie plaatjes opgehaald en weergegeven op het scherm. Erg goed! Bij kleine schermpjes valt soms een deel van de afbeelding buiten het scherm, maar dat is nauwelijks storend. Ik kon met dit programma bijna al mijn displays voorzien van een plaatje, wat met een andere bibliotheek nog niet gelukt was. Een probleem kan zijn dat de WeMos niet herkend wordt bij het uploaden. Dat komt omdat pin D8 gebruikt wordt. Ik heb dit probleem in de laatste versie niet meer gehad. Er zijn twee oplossingen voor dit probleem:
  1. het display (of alleen pin 8) even loskoppelen en zodra de WeMos bezig is met de internetverbinding weer aansluiten.
  2. in het programma onder #include <GxEPD.h> de tekst #define SS D1 zetten en pin CS aansluiten op pin D1 van de WeMos D1 mini.
Ik heb al mijn schermen naast elkaar gelegd en dan valt meteen het verschil in kwaliteit op: sommige schermen hebben een duidelijk beter contrast. Het scherm rechts-boven kost ongeveer een tientje, maar is toch bijzonder goed.
Tip: update deze bibliotheek regelmatig, want er worden constant nieuwe schermdefinities aan toegevoegd.
alle e-papers
Al mijn displays met een plaatje via de GxEPD bibliotheek

4-grijstinten UART e-Paper

Er zijn diverse e-Papers die vier kleuren grijstinten kunnen weergeven, zoals het flexibele 2.13″ e-Paper, maar het is lastig daar goede software voor te vinden. Het 4,3″ 800 × 600 UART diplay is een vreemde eend in de bijt. In tegenstelling tot alle andere displays kan deze via een seriële verbinding worden geprogrammeerd. Dat kan ook met de Arduino. Het display heeft aan de achterkant een micro-SD kaartlezer. Hierop kun je lettertype bestanden zetten, maar vooral plaatjes. Ook zonder micro SD-kaartje zijn er standaard lettertypes beschikbaar. Het display heeft een eigen geheugen van 128 MB, waarin lettertypes en de opgegeven instructies worden bewaard. Zo kan alles wat je op het display zet bewaard blijven tot je het scherm wist. Overigens wordt het scherm automatisch gewist als je het op een stroombron aansluit.
De microcard lezer is erg gemakkelijk. Hij vergt geen extra draden. Als je plaatjes wilt laten zien moet je op het volgende letten: het moeten bmp-bestanden zijn met twee kleuren per bit, of vier kleuren in twee bits. Verder moet de bestandsnaam geheel in hoofdletters zijn en maximaal vijf letters (voor .BMP) hebben. Het kaartje moet FAT32 geformatteerd zijn.
Je kunt je display testen met de software die je op WaveShare.com kunt downloaden: EPSCOMM_EN.exe en uC-GUI-BitmapConvert.exe. Eerst moet je MSCOMM32.OCX registreren en dat wil nog weleens mislukken. In het filmpje op de Waveshare site wordt uitgelegd hoe je dit kunt oplossen. Zolang dit niet is geregistreerd wil EPSCOMM_EN niet opstarten.
ProgrammerEen goedkope programmer
Ik raad sowieso aan eerst deze programma's te gebruiken om dit display te verkennen. Je hebt een usb naar UART module (kortweg "programmer") nodig: de goedkoopste is goed genoeg. Sluit DIN aan op TX en DOUT op RX. Bij sommige programmers staat nog een letter achter TX en RX. VCC mag op 3,3V, maar 5V is beter. GND gaat naar GND; de andere twee draden sluit je niet aan. Als je niet weet oe je de juiste poort kunt vinden, dan kun je de lijst afgaan tot het lukt de poort te openen. Bij mij en ook op de site is het poort COM6. Hoe het onder Linux moet weet ik niet.

Vier grijstinten zijn niet genoeg om natuurgetrouwe foto's weer te geven, maar het kan er wel artistiek uitzien. Het plaatje wat je op de foto ziet heb ik gedithered in vier tinten en vervolgens omgezet naar twee bits per kleur. Mede door de hoge resolutie van het display ziet dit er erg goed uit. Ik heb hiervoor een Python programma geschreven, want de omweg via uC-GUI-BitmapConvert.exe vind ik erg omslachtig.
e-PaperUART
De informatiepagina van Waveshare geeft uitgebreide instructies over dit display, inclusief een lijst met alle codes voor de vele mogelijkheden die het heeft. In het filmpje op de waveshare pagina wordt alles nog eens uitgelegd.
Ik heb ook een Python bibliotheek geschreven dat de meeste mogelijkheden worden ondersteunt. Je kunt het Python ditherprogramme en de bibliotheek hier vinden.
Waveshare heeft ook een Arduino bibliotheek gemaakt, maar deze werkt maar op enkele type Arduino's. Waarschijnlijk is het makkelijker om je eigen programma te maken.
Al met al vind ik dit een goede ontwikkeling en ik hoop dat er snel meer e-Paper displays komen die op deze manier werken.

7-kleuren e-Paper

Het 5,65″ ACeP 7-kleuren display van Waveshare
Ze zijn best prijzig: 7-kleuren e-Paper displays. Ik heb er twee getest. Het lukte direct met de GxEPD2 bibliotheek samen met een ESP8266 (WeMos D1 mini). Ik nam als uitgangspunt het SPIFFS voorbeeld. Ik heb de bestandsnamen aangepast aan de namen van de plaatjes die ik in het flash geheugen had gezet. Dit is een bijzonder mooi display, maar 7 kleuren (waaronder zwart en wit) is niet veel. Om toch een mooi plaatje te krijgen moet je ofwel een tekening hebben met felle kleuren die het scherm kan weergeven. Als je een foto mooi wil weergeven dan moet je de foto "ditheren". Dit kun je doen met Photoshop of met mijn Python programma, dat je hier kunt vinden. Het zal je verbazen hoe goed de foto's er in 7 kleuren uitzien. Je ziet hieronder hoe zo'n foto dan op het e-Paper display wordt weergegeven.


Nextion smart displays

Smart displays zijn displays die een ingebouwde processor hebben, die veel van het grafische werk doet. Hierdoor hoeft de Arduino veel minder werk te doen. Ook kun je heel gemakkelijk mooie grafische toepassingen en user interfaces maken.
Ik ken alleen smart displays van het merk Nextion. Deze displays hebben bijna allemaal een aanraakgevoelig scherm. Je kunt het gratis programma Nextion Editor downloaden, waarmee je allerlei grafische elementen op het scherm kunt plaatsen, zoals knoppen, schakelaars, schuifbalken, plaatjes en filmpjes. Als je een nieuw Nextion display aanzet, dan staat daar een programma op dat veel van de mogelijkheden van het scherm laat zien. Als je een aanraakscherm hebt dan kun je zelfs zonder de Arduino de mooiste spelletjes programmeren. De taal die je hiervoor gebruikt lijkt wel wat op dat van de Arduino, maar alles is net een beetje anders. Op internet kun je dergelijk spelletjes vinden, bijvoorbeeld kruisje-nulletje. Voor ons is natuurlijk vooral het gebruik samen met de Arduino van belang!
Je kunt vanuit de Arduino allerlei dingen op het scherm veranderen. Dat kunnen getallen zijn, maar ook teksten of de kleur van bepaalde elementen.
Je kunt nu achtergrondplaatje op het scherm zetten, met daarop informatie, zoals de tijd of de temperatuur. Als je de getallen verandert, dan blijft de achtergrond intact. Probeer dat maar eens met een Arduino en een gewoon kleurenscherm. Ik denk dat het niet lukt. De displays zijn niet goedkoop, maar dat geldt ook voor andere displays van dezelfde afmetingen met een aanraakscherm. Nextion heeft drie soorten displays, elk in verschillende formaten. De meest eenvoudige is de basic uitvoering, die voor veel toepassingen al goed werkt (prijs vanaf ca. 20 euro). Dan de enhanced versie, met als extra een ingebouwde real time klok met batterij back-up en minimaal 16 MByte RAM. De duurste en meest geavanceerde versie is de intelligent versie. Deze is minstens 4,3 inch groot en heeft minimaal 128 MByte RAM.
Zo sluit je deze programmer aan.
Ook kan het transparante bitmaps correct weergeven. Alle displays hebben een mini SD-kaart slot op de achterkant, maar die kun je uitsluitend gebruiken om eenmalig per toepassing de layout e.d. te laden. Het is overigens niet nodig om een SD kaartje hiervoor te gebruiken. Ik vind het handiger om de lay-out te uploaden met een programmer. Het maakt niet zoveel uit welke programmer je gebruikt, als hij maar een 5 volt uitgangsspanning geeft. De Nextion Editor zal zelf de correcte poort ontdekken en anders kun je dat zelf opgeven. Ook ontdekt de Nextion Editor het als je het verkeerde scherm hebt opgegeven. De kleurcode van het kabeltje dat je bij de Nextion krijgt is als volgt: Rood = 5 volt; Zwart = GND; Geel = RX (deze gaat naar TX van de programmer of van de Arduino); Blauw = TX (gaat na RX).
De Nextion Editor heeft geweldige mogelijkheden, zoals een ingebouwde debugger. Je kunt meerdere pagina's instellen die je vanuit het scherm zelf of vanuit een Arduino programma kunt kiezen. En wat je ziet krijg je ook ;-)
Tot zover het goede nieuws, maar er is ook minder goed nieuws:
De documentatie is tamelijk slecht en loopt vaak achter op nieuwe ontwikkelingen van de schermen. De Nextion Editor is voor beginners lastig, maar al snel ontdek je de logica, zeker als je op Internet wat filmpjes met uitleg bekijkt. Een van de dingen die je moet weten is dat de Editor geen standaard font laadt. Je moet zelf altijd een font laden als je tekst gebruikt. De eerste keer gebruik je hiervoor de font generator, waarmee je het font kiest uit alle lettertypes die op je computer staan en daarbij o.a. de grootte opgeeft. Een opgeslagen font kun je bij andere projecten direct laden. Ook het invoegen van plaatjes ligt in eerste instantie niet voor de hand.
Veel erger is dat er van alles mis is met de bibliotheken die je nodig hebt bij de Arduino. In eerste instantie waren de bibliotheken ingericht voor gebruik met de Arduino Mega (wegens twee seriële poorten) en voor alleen de basic modellen. Omdat er daarom allerlei mensen aan de bibliotheken zijn gaan sleutelen heb je je nu verschillende versies, die allemaal verschillend werken. De originele bibliotheek ITEADLIB_Arduino_Nextion-master kun je niet via het bibliotheken menu van de IDE laden. Daarvoor moet je naar de github site. Het is storend dat de meeste voorbeeldprogramma's van deze bibliotheek niet direct werken. Je moet vaak in het C++ bestand van de bibliotheek nog wat dingetjes aanpassen. Daarnaast is voor sommige displays de baudrate van 115200 te hoog, dit moet dan 9600 zijn.
Voor eenvoudige toepassingen is geen bibliotheek nodig en kun je gewoon instructies naar de Nextion sturen via een seriële verbinding. Als ik tijd heb dan zal ik uitzoeken hoe dat gaat. Als je wilt weten hoe het met Python gaat dan kun je op de nieuwe Python pagina kijken.
Het scherm trekt veel stroom en er wordt op diverse plaatsen voor gewaarschuwd het display meteen uit te zetten als er niet genoeg stroom is (dat merkt je als het scherm niet stabiel is). Je zou dus denken dat het display niet te gebruiken is met de nodeMCU want die werkt op 3,3 V, maar dat is niet zo. Het display is uitstekend te gebruiken met een nodeMCU (of WeMos D1 mini) als je de 5 volt uitgang neemt, of als je het bijgeleverde USB hulpstukje gebruikt om direct 5 volt uit een telefoonoplader of een USB poort te halen.
Als alle moeilijkheden overwonnen zijn, dan zie je pas echt wat een voordelen deze displays hebben.

De lay-out van dit scherm is gebaseerd op een voorbeeld van Marcelo Vilar.
Hiernaast zie je een voorbeeld van een programma. De temperatuur en vochtigheid worden hier weergegeven. Als de temperatuur hoger wordt dan stijgt de kwikkolom mee. Als de temperatuur lager wordt dan 16 graden dan verandert het getal in blauw. In plaats van een vast plaatje met druppels zou je ook een filmpje kunnen afspelen, waardoor de druppels steeds bewegen. Maar omdat ik - als altijd - de voorbeelden simpel wil houden heb ik dat niet gedaan.
Als je een programma voor een ander display geschikt wil maken, dan kun je gewoon in de Nextion Editor het gewenste scherm opgeven. Eventuele elementen die daarna buiten het scherm gaan vallen moet je herplaatsen. Als je verder niets verandert, dan hoef je ook het Arduino programma niet te veranderen.
Klik hier om het programma en meer voor de Arduino te zien