Displays. Alles wat je kunt zien...

Tekst displays

• LCD display met twee of vier regels. Prijs ca. 3 euro.
  Dit display werkt erg goed. Nadeel: er worden veel pinnen van de Arduino gebruikt. Backlight moet worden aangesloten en ingesteld anders bestaat de kans dat je niets ziet.
• LCD display met twee of vier regels met I2C interface. Prijs ca. 4 euro.
  Het 4-regelig display
  
  Hetzelfde display als hierboven, maar dan met een I2C interface. De aansluiting is door de I2C interface veel simpeler en je hebt maar twee signaaldraden nodig. Deze gaan naar A4 en A5 van de Arduino UNO (Arduino Mega 20 en 21). Je houdt dus al je digitale pinnen over!
  Het regelen van de helderheid doe je met een knop op de achterkant van het display: wel zo handig. Als het display niet werkt dan kan dat komen omdat het een ander adres gebruikt dan het standaardadres dat je in veel voorbeelden terugvindt. Met een simpel programmaatje op je Arduino heb je dat adres zo gevonden. Meestal is het adres 0x27 of 0x3F (0x betekent dat wat er na komt een hexadecimaal getal is). Klik voor meer uitleg over het 2-regelig display of het 4-regelig display.
  Inmiddels is er ook een mooi tekstdisplay met twee regels van 24 symbolen verkrijgbaar.
• Display met los I2C interface.
  Boven het scherm zie je
  de losse I2C interface
  
  Als je al een display hebt zonder I2C interface, dan is het een goed idee om een losse interface aan te schaffen. Je kunt deze vrij eenvoudig op het display solderen, maar als het display al pinnen heeft dan is het nog eenvoudiger om het display naast de interface in een breadboard te prikken (zie het plaatje hiernaast). Je hebt geen extra draden nodig. Wel even het adres opzoeken (bij mij 0x27). Je kunt dezelfde software gebruiken als bij de displays hier direct boven. Werkt fantastisch! Tip: de interface heeft vaak drie paren soldeerpuntjes met bijschrijft A0 A1 en A2. Als je een of meer paren puntjes bij met elkaar verbindt kun je het adres veranderen (+1 t/m +7). Zo kun je meerdere displays tegelijk aansluiten!

Grafische zwart-wit of tweekleuren displays

• 84 x 48 Nokia display (hergebruikt schermpje van oude telefoons). Prijs: ca. 2 euro.
  Twee in alles verschillende Nokia displays
  
  Het is nogal lastig om uit te vinden hoe de draden moeten worden aangesloten, omdat er meerdere versies van de printplaat bestaan. De twee displays hiernaast lijken hetzelfde, maar moeten anders worden aangesloten en ook het contrast moet anders worden ingesteld. Ik heb het display in eerste instantie getest met de sketches die op internet te vinden zijn en waarbij geen extra bibliotheek nodig is. Dat werkt goed, maar er zijn weinig functies. Veel beter is het om de u8lib bibliotheek te gebruiken. Deze bibliotheek bevat veel functies en lettertypes. Een groot voordeel is ook dat deze bibliotheek bij veel andere displays gebruikt kan worden, waardoor je programma's met minimale wijzigingen voor een ander scherm geschikt kunt maken. Zie het voorbeeld zonder u8lib bibliotheek en zie het voorbeeld "Ik hou van..." met de u8lib bibliotheek.
  Als je dit display al hebt, dan kun je er aardige dingen mee doen. Ik raad dit display niet aan als je het nog moet kopen. Inmiddels zijn kleurendisplays betaalbaar en deze hebben veel meer mogelijkheden.
• 128×64 monochrome display type HJ12864ZW.
  Het pijltje gaat van links naar rechts.
  
  Je kunt dit display op twee manieren aansluiten: parallel via SPI en seriëel. Parallel kost zoveel poorten van je Arduino, dat ik dat alleen aanraad als het display supersnel moet werken. Een goede, universele bibliotheek is u8glib. Deze kun je rechtstreeks vanuit de Arduino IDE downloaden. Ga naar menu Schets → Bibliotheek gebruiken → Bibliotheken beheren. Type dan in het zoekveld u8lib in en je krijgt de bibliotheek te zien. Klikken en installeren. In de bibliotheek kun je functies vinden en voorbeelden. Bij elk voorbeeld moet je het juiste display kiezen en de gebruikte aansluitingen kiezen. Een erg goed begin is om vanuit het menu Bestand→Voorbeelden→u8g2→full_buffer GraphicsTest te laden. Dan kun je zien hoe goed dit display is. Je sluit het display als volgt aan: VCC → 5 V, GND → GND, RS → 10, R/W → 11, E → 13, RST → 8 (bij mij bleek deze verbinding niet nodig), PSB → GND, BLA (= BackLight Anode) naar 3,3 of 5 V, BLK (= BackLight Kathode) → GND.
  
  Weerstation
  In de lijst displays moet je deze regel opzoeken: U8G2_ST7920_128X64_F_HW_SPI //u8g2(U8G2_R0, /* CS=*/ 10, /* reset=*/ 8); en als er commentaarstrepen // voor staan, deze weghalen. De bibliotheek bevat veel lettertypes en functies voor het tekenen van lijnen, cirkels, enzovoorts. Werkt perfect!
  Als je het display nu nieuw koopt, dan kun je de intensiteit regelen met een draaiknopje aan de achterkant.
  Hier zie je nog een toepassing van dit display.
  Klik hier om de beschrijving van het weerstation te zien.
  
  

  Voor dit weerstation heb je een DHT11 (of DHT22) temperatuur- en vochtigheidssensor nodig (zie hier voor een beschrijving). Sluit de datapin hiervan aan op pin 7 van de Arduino en laad onderstaande sketch in je Arduino:

  // Gebaseerd op een sketch van Nick van educ8s.tv
  #include <DHT.h>
  #include <U8g2lib.h>
  
  #define DHTTYPE DHT11 // Kan bijvoorbeeld ook DHT22 zijn
  DHT dht(7, DHTTYPE);  // Data van de DHT11 -> pin 7
  
  char temperatuur[5];
  char vochtigheid[5];
  const char GRADEN[] = { 0xB0, '\0' };
  
  U8G2_ST7920_128X64_1_HW_SPI u8g2(U8G2_R0, 10, 8); // -> 8
  
  void setup() {
    dht.begin();
    u8g2.begin();
    u8g2.enableUTF8Print();
    u8g2.setFont(u8g2_font_helvB10_tf);
    u8g2.setColorIndex(1);
  }
  
  void loop() {
    u8g2.firstPage();
    do
      draw();
    while ( u8g2.nextPage() );
  }
  
  void draw() {
    float t = dht.readTemperature();
    dtostrf(t, 3, 1, temperatuur);
    float h = dht.readHumidity();
    dtostrf(h, 3, 1, vochtigheid);
  
    u8g2.drawFrame(0,  0, 128, 31); // maak een rechthoek boven scherm
    u8g2.drawFrame(0, 33, 128, 31); // maak een rechthoek onder scherm
  
    u8g2.drawStr( 18, 13, "Temperatuur");
    u8g2.drawStr( 35, 28, temperatuur);
    u8g2.drawUTF8(70, 28, GRADEN);
    u8g2.drawUTF8(76, 28, "C");
  
    u8g2.drawStr(23, 46, "Vochtigheid");
    u8g2.drawStr(37, 61, vochtigheid);
    u8g2.drawStr(75, 61, "%");
  }
  

Oled displays

- gebruiken heel weinig energie

- hebben een grote kijkhoek (tot wel 170°)

- reageren snel

- hebben geen achtergrondverlichting nodig

• 128×64 klein geel en blauw oled display (of display met één kleur: geel, blauw of wit) type ssd1306.
  
  
  Het geel en blauw display.
  In het geel en blauw display zijn de bovenste 16 lijnen geel en de onderste 48 blauw. Je kunt dit niet veranderen. Hier zie je de I²C uitvoering, maar hij is er ook met een SPI interface. De universele bibliotheek u8glib werkt niet geweldig met dit display. Je kunt de speciaal voor dit display aangepaste bibliotheek Adafruit_SSD1306 gebruiken. Wat je eventueel nog moet veranderen staat goed beschreven in de Readme file bij deze bibliotheek. Het voorbeeldprogramma dat erbij zit werkt erg goed en laat de vele mogelijkheden van het scherm zien. Als je geen beeld ziet kijk dan eerst of het adres niet op 0x3D staat en verander dat in 0x3C. Als dat nog niet werkt geef OLED_RESET dan de waarde -1. De betreffende regel verander je dus in: #define OLED_RESET -1 // Reset pin # (or -1 if sharing Arduino reset pin)
  Soms nodig: Als je een foutmelding krijgt dat Height incorrect is dan moet je in Adafruit_SSD1306.h bij de instructie #define SSD1306_128_64 de commentaarstrepen (//) weghalen en de twee definities daaronder commentaar maken. Logisch, want de software moet weten welke uitvoering je hebt.
  Zelden nodig: Je kunt het I²C adres veranderen, maar daarvoor moet je nauwkeurig kunnen solderen. De adressen die op de achterkant van het device gedrukt zijn kloppen niet: het adres is standaard 0x3c en dat kun je veranderen in 0x3d. Als je het adres veranderd hebt moet je dat ook in Adafruit_SSD1306.h veranderen).
  De SPI uitvoering
  Al met al een mooi, klein display.
  Ik heb ook twee SPI uitvoeringen getest. Er waren twee pinnen met het bijschrift D0 en D1. D0 is de klok (SCK) en D1 is MISO. Je kunt het aansluiten zoals in het demoprogramma dat bij de bibliotheek zit (ssd1306_128x64_spi.ino) is aangegeven. Dit werkte bij mij direct zonder problemen (zie de schermafdruk hiernaast).
• 128×32 klein blauw oled display
  
  Dit display werkt precies hetzelfde als het display hierboven. Je kunt dezelfde software gebruiken, maar je moet in Adafruit_SSD1306.h het juiste display kiezen. Dit moet er dan als volgt uitzien:
  
  // #define SSD1306_128_64
  #define SSD1306_128_32
  // #define SSD1306_96_16
  
  Klik hier om het programma van de video te zien
  

  #include <Adafruit_SSD1306.h> // Bevat ook Adafruit_GFX.h
  
  Adafruit_SSD1306 display(-1); // -1 = geen reset pin; als je een reset hebt op bijvoorbeeld pin 4, type dan display(4)
  
  const byte hartje[] =
  { B00011000, B00011000,
    B00111100, B00111100,
    B01111110, B01111110,
    B11111111, B11111111,
    B11111111, B11111111,
    B01111111, B11111110,
    B01111110, B11111110,
    B00110011, B11111100,
    B00011111, B11111100,
    B00001111, B11111000,
    B00000111, B11110000,
    B00000111, B11100000,
    B00000011, B11000000,
    B00000001, B11000000,
    B00000000, B10000000,
    B00000000, B10000000
  };
  
  void setup() {
    display.begin(SSD1306_SWITCHCAPVCC, 0x3C); // Gebruik I2C adres 0x3C
    display.clearDisplay();
    scrolltext("I love ...");
    delay(1000);
    display.clearDisplay();
  
    display.setTextSize(3);
    display.setCursor(24, 3);
    display.println("Irene");
    display.display();
    delay(2000);
    display.invertDisplay(true);
    delay(1000);
    display.invertDisplay(false);
    delay(1000);
    display.clearDisplay();
    hartjes(hartje, 16, 16, 4); // Laat vier hartjes van 16 x 16 pixels vallen
  }
  
  void loop() { // Doe niets
  }
  
  struct hart {
    byte x, y, delta_y;
  };
  
  void hartjes(byte bitmap[], byte b, byte h, byte AantalHartjes) {
    hart icons[AantalHartjes];
    for (byte f = 0; f < AantalHartjes; f++) {
      icons[f].x = random(display.width()); // Kies willekeurige beginposities
      icons[f].y = 0; // Alle hartjes starten aan de bovenkant van het display
      icons[f].delta_y = random(5) + 1; // Kies willekeurige stapgrootte
    }
  
    while (true) { // Lus duurt tot de Arduino opnieuw opgestart wordt
      for (byte f = 0; f < AantalHartjes; f++)  // Teken elk hartje
        display.drawBitmap(icons[f].x, icons[f].y, bitmap, b, h, WHITE);
      display.display();
      delay(200);
      for (byte f = 0; f < AantalHartjes; f++) { // Wis elk hartje
        display.drawBitmap(icons[f].x, icons[f].y, bitmap, b, h, BLACK);
        icons[f].y += icons[f].delta_y; // Verplaats ze enkele pixels naar beneden
        if (icons[f].y > display.height()) { // Als ze onder het display zijn gezakt...
          icons[f].x = random(display.width()); // ... stel ze dan opnieuw in
          icons[f].y = 0; // Hartje start altijd boven
          icons[f].delta_y = random(5) + 1;
        }
      }
    }
  }
  
  void scrolltext(String Tekst) {
    display.setTextSize(2);
    display.setTextColor(WHITE);
    display.clearDisplay();
    display.println(Tekst);
    display.display();
    delay(1);
    display.startscrollright(0x00, 0x0F);
    delay(1000);
    display.stopscroll();
    delay(1000);
    display.startscrollleft(0x00, 0x0F);
    delay(1000);
    display.stopscroll();
    delay(1000);
    display.startscrolldiagright(0x00, 0x07);
    delay(1000);
    display.startscrolldiagleft(0x00, 0x07);
    delay(1000);
    display.stopscroll();
  }
  

• 2,3″ 128×64 oled display, type SSD1309
  
  Uit het testprogramma
  Dit fraaie display is in veel soorten verkrijgbaar. Ik testte een tweetal zwart-witte displays. Er zijn ook andere kleuren beschikbaar. Standaard heeft deze uitvoering een SPI interface, maar als je handig bent met de soldeerbout kun je dit veranderen in I²C. Doordat dit display met SPI erg snel is, wordt het veel gebruikt bij Arduino games. Hoewel dit display al enkele jaren op de markt is, houdt de ondersteuning niet over. Gelukkig kun je wel de eerder genoemde bibliotheek U8glib.h gebruiken. Zoek in het Graphic's Test-programma de regel op met 1309 erin en haal de commentaarstrepen weg. Als je deze bibliotheek geïstalleerd hebt kun je dit voorbeeld vinden via menu Bestand→Voorbeelden→U8glib →Graphic's Test. Nu moet je nog wat veranderen, want je moet ook de reset pin gebruiken. Dit kun je doen door een parameter toe te voegen, zoals je in de volgende regel ziet:

  U8GLIB_SSD1309_128X64 u8g(13, 11, 10, 9, 8); // SCL = 13, SDA = MOSI = 11, CS = 10, DC = 9, RES = 8. Zonder Res werken sommige displays niet
  

  
  
  Hieronder ziet u een voorbeeld van hoe een T-rex game er op dit display uitziet. Je moet dit echt in werkelijkheid zien, dan zie je pas hoe goed en snel dit scherm is.
  Het programma dat ik hiervoor gebruikt heb is te downloaden op github.com/AlexIII/t-rex-duino. Dit programma is te ingewikkeld om het geschikt te maken voor alle schermen, maar sinds kort is het programma ook geschikt gemaakt voor SSD1306 (zie boven) displays en op SH1106 displays.

Grafische kleurendisplays

• Sommige goedkope schermpjes moeten nog gesoldeerd worden met een microsoldeertechniek. Dit is erg moeilijk. Als je een breakout board koopt dan zit je goed.
• Sommige displays werken op 3,3 volt en gaan kapot als je ze aansluit op 5 volt. Sluit in dat geval alle pinnen aan via weerstanden of een level converter. Als je niet weet of dat voor jouw display geldt, sluit dan alles op 3,3 volt aan. Als het display dan erg flets of donker is, probeer dan kort 5 volt.
• Elk type display gebruikt een eigen bibliotheek om het display te laten werken. Daarnaast wordt een standaard bibliotheek gebruikt om alle grafische effecten mogelijk te maken, dat is altijd Adafruit_GFX.h. Als je een SD kaartje wilt gebruiken heb je nog SD.h nodig.
• Als je een display koopt zit er ter bescherming een stukje plactic op. Als dat een groen of zwart uitsteeksel heeft dan zegt dat iets over het type display. Je initialiseert dat schem dan met een van de constantes, waarin het woord GREENTAB of BLACKTAB voorkomt.

Losse kleuren displays

• 1,44″ 128 × 128 pixels, full color TFT LCD display module type ST7735.
  128 × 128 display
  
  Dit scherm geeft een erg mooi beeld met heldere kleuren. Het heeft een SPI interface, maar door de bijschriften zou je kunnen denken dat het een I²C interface is. Je kunt de Adafruit_ST7735.h/Adafruit_ST7789.h bibliotheek gebruiken. Daarnaast heb je de Adafruit_GFX.h bibliotheek nodig. In de eerste bibliotheek is een goed voorbeeldprogramma dat alle mogelijkheden laat zien. Als je problemen krijgt met het compileren dan moet je de nieuwste versies van deze bibliotheken ophalen, want is sommige oudere versies zitten fouten. Bij de meeste Arduino's kun je dit display als volgt aansluiten: SCL op pin 13, SDA op pin 11, RES op pin 9. DC op pin 8 en CS op pin 10. Pin BL kun je gebruiken om de achtergrondverlichting te regelen (via PWM), maar anders hoef je deze pin niet aan te sluiten.
  Dit display heeft een beschermplastic waaraan een groene tab zit. De kleur geeft het type aan. Je initialiseert deze met tft.initR(INITR_144GREENTAB); Als deze instructie in het voorbeeldprogramma commentaar is, haal dan de commentaarstrepen weg en voeg deze bij de andere initialisatie toe. Het kan zijn dat je wel een mooi beeld krijgt, maar dat het aan de randen net niet helemaal klopt.
  Klik hier om te zien hoe je dit oplost
  
  Neem de volgende code op in de set-up van het voorbeeldprogramma:

    tft.fillScreen(ST77XX_BLACK);
    tft.drawLine(0, tft.height() - 1, tft.width() - 1, tft.height() - 1, ST77XX_WHITE);
    tft.drawLine(0, 0, tft.width() - 1, 0, ST77XX_WHITE);
    tft.drawLine(0, 0, 0, tft.height() - 1, ST77XX_WHITE);
    tft.drawLine(tft.width() - 1, 0, tft.width() - 1, tft.height() - 1, ST77XX_WHITE); 
    delay(4000); // of zoveel tijd als je nodig hebt om het diplay te controleren
  

  Als je niet een perfecte rechthoek ziet (maar bijvoorbeeld slechts drie zijden) dan moet je in de code van de bibliotheek duiken. Dat is wel de moeite waard. Zoek in het bestand Adafruit_ST7735.cpp de volgende code op en verander zo nodig de waardes van _colstart en _rowstart tot het scherm perfect is:

     } else if(options == INITR_144GREENTAB) {
      _height = ST7735_TFTHEIGHT_128;
      _width = ST7735_TFTWIDTH_128;
      displayInit(Rcmd2green144);
      _colstart = 2;
      _rowstart = 3; // Verander de waardes van _colstart en _rowstart totdat het display klopt!
                     // Bij twee (heel verschillende) displays bleken deze twee waardes nodig

• 1,8″ 128 × 160 pixels van Sainsmart.
  128 × 160 display
  
  Dit scherm heeft aan de achterkant een micro-SD slot. Als je het zonder SD kaart wil gebruiken dan kun je dit display hetzelfde aansluiten als het 1,44″ scherm hierboven en dezelfde software gebruiken. In het voorbeeldprogramma moet je dan tft.initR(INITR_BLACKTAB); gebruiken (door de commentaarstrepen ervoor weg te halen en bij de andere initialisaties terug te zetten). Een mooi display, waar net iets meer op past dan op het vorige scherm (zie foto). De SD kaart heeft zijn eigen SPI aansluiting en werkt als elke SD-kaartlezer. Het dekseltje van het SD station gaat gauw los: indien nodig iets buigen en gewoon terugduwen (al dan niet met het kaartje erin). Bij de bibliotheek zit ook een voorbeeldprogramma hoe je een plaatje van een SD kaartje kunt weergeven op het scherm.
• 1,14″, 1,3″ 1,54″ of 2,0″ 240 × 240 IPS display met ST7789 driver.
  
  Display met de Mario's van het voorbeeldprogramma
  Deze zeer goedkope displays zijn erg populair omdat ze snel zijn en veel pixels hebben. IPS displays zijn meestal duur. Ze hebben een grotere kijkhoek dan andere displays; dat is bij deze kleine displays ook duidelijk waarneembaar. Ik kreeg 7 exemplaren niet aan de praat met de Adafruit bibliotheek. Met de bibliotheek van Pawel A. Hernik, genaamd Arduino_ST7789_Fast.h lukte het uiteindelijk wel. Deze bibliotheek is geoptimaliseerd om supersnel te zijn, maar hij is alleen te gebruiken met een Arduino. Bij dit display wordt gewaarschuwd dat je het beslist niet moet aansluiten op 5V. In de documentatie van Pawel staat uitdrukkelijk dat je VCC op 3,3V moet aansluiten, maar de rest zou gewoon op de aangegeven pinnen kunnen worden aangesloten. Bij mij en anderen werkte dat niet. Al mijn displays werkten met deze bibliotheek wel goed op 5V. Ik heb een van mijn displays 8 uur laten werken op 5V, zonder enig probleem. Dat is geen garantie dat dit bij andere displays ook zo is, dus als je jouw display aansluit op 5V is dat voor je eigen verantwoordelijkheid.
  Ik ga later uitzoeken mijn displays wel werken als ik alle spanningen terugbreng tot 3,3V.
  Hieronder staat een programma dat een aantal van de mogelijkheden van de bibliotheek va Pawel laat zien. Je moet Adafruit.gfx bibliotheek geïnstalleerd hebben, anders zal dit niet werken.
  Klik hier om het programma te zien
  

  // ST7789 library example
  // (c) 2019-20 Pawel A. Hernik
  // Aangepast door Th.M. Hupkens (2021)
  /*
    ST7789 240x240 IPS (zonder CS pin) (slechts 6 draden nodig):
    #01 GND -> GND
    #02 VCC -> VCC (3.3V only!) Als niets werkt: probeer kort 5V
    #03 SCL -> D13/SCK          Arduino Uno, Mega of Nano en enkele andere
    #04 SDA -> D11/MOSI
    #05 RES -> D8 of een andere pin // Verander dan verderop #define TFT_DC  7
    #06 DC  -> D7 of een andere pin // Verander dan verderop #define TFT_RST 8
    #07 BLK -> Niet aansluiten
  */
  #define SCR_WD 240
  #define SCR_HT 240
  #define TFT_DC  7
  #define TFT_RST 8
  #include <Arduino_ST7789_Fast.h>
  Arduino_ST7789 lcd = Arduino_ST7789(TFT_DC, TFT_RST);
  
  void setup()
  {
    Serial.begin(9600);
    lcd.init();
  }
  
  void loop(void)
  {
    for (uint8_t rot = 0; rot < 4; rot++) {
      Text(rot);
      delay(2000);
    }
  }
  
  unsigned long Text(int rot)
  {
    lcd.setRotation(rot);
    lcd.fillScreen(BLACK);
    lcd.setCursor(0, 0);
    lcd.setTextColor(BLUE);
    lcd.setTextSize(1);
    lcd.println("Hallo allemaal!\n");
    lcd.setTextColor(WHITE);
    lcd.print("Rotatie = "); lcd.println(rot);
    lcd.setTextColor(YELLOW);
    lcd.setTextSize(2); lcd.println();
    lcd.println((long)1234567890); lcd.println();
    lcd.setTextColor(RED);
    lcd.setTextSize(3);
    lcd.println(200268461, HEX); lcd.println();
    lcd.setTextColor(GREEN);
    lcd.setTextSize(4);
    lcd.print("Hallo");
  }
  

• 2,2″ 240 × 320 Adafruit compatible display met groot SD-station.
  
  Plaatje van SD kaart
  Tekstvoorbeeld
  Als je een kloon van de originele Adafruit hebt, dan kan dat een uitvoering zijn die alleen op 3 à 3,3 volt werkt. Dat betekent dat je bij elke pin (behalve voor de voeding en led-verlichting: daarvoor gebruik je de 3,3V van de Arduino) een spanningsdeler moet zetten. Gebruik de Adafruit ILI9340-bibliotheek. Als je de Arduino Uno gebruikt, sluit deze dan als volgt aan (via een 5.0 to 3.3 level converter als je een display hebt dat niet tegen 5 volt kan): CS op pin 10; DC op pin 9; RST op pin 8; MOSI op 11, MISO op 12 en SCK op 13. LED kun je desgewent aansluiten op 3,3 volt. Probeer het voorbeeld programma dat bij de bibliotheek zit te runnen.
  Als alles werkt dan heb je een mooi display met software voor allerlei meetkundige figuren en teksten. Om een SD kaart te kunnen gebruiken moet je de pinnen SD_MOSI, SD_MISO en SD_SCK verbinden met de overeenkomstige pinnen van het display en de pin SD_CS op pin 4 aansluiten. Soms hebben deze pinnen andere namen. Als er meer pinnen zijn dan sluit je die niet aan. De bibliotheek heeft een voorbeeldprogramma genaamd "spitftbitmap.ino" waarmee je een plaatje kunt inlezen en weergeven (zie ook de foto).
  
  De meeste displays gebruiken 16 bits kleuren, 5 bits voor rood, 5 bits voor blauw en 6 bits voor groen. Een aantal belangrijke kleuren hebben een naam gekregen in de bibliotheken, maar als je een andere kleur nodig hebt dan is het handig om gewoon de rood, groen en blauw waarde op te kunnen geven. Dat kan met de volgende functie:

  unsigned int kleur(unsigned int R, unsigned int G, unsigned int B){
    unsigned int Kleur = ((R >> 3) << 11) + ((G >> 2) << 5) + (B >> 3);
    return Kleur;
  }
  

Kleuren display shields

Het scherm in landschap stand, met bewegende tekstbalk.

Het display "shield" op een Arduino mega.

Shield voor de Lolin/WeMos D1 mini

2,4" shield voor D1 mini

Klein shield voor de Lolin/WeMos D1 mini

Het 1.44″ display shield

// Voorbeeldschets, alleen bruikbaar voor het TFT 1.4 Shield V1.0.0 en later
#include <Adafruit_GFX.h>    // Core graphics library
#include <Adafruit_ST7735.h> // Hardware-specific library
#include <SPI.h>

#define TFT_RST -1
#define TFT_CS D4
#define TFT_DC D3

Adafruit_ST7735 tft = Adafruit_ST7735(TFT_CS, TFT_DC, TFT_RST);

void setup(void)
{
  tft.initR(INITR_144GREENTAB);
  tft.setTextWrap(false); // Te lange tekst mag rechts van het scherm verdwijnen
  tft.fillScreen(ST7735_BLACK);
}

void loop(void)
{
  tft.fillScreen(ST7735_BLACK);
  tft.setCursor(0, 0);
  tft.setTextColor(ST7735_BLUE);
  tft.setTextSize(3);
  tft.println("HALLO");
  tft.setTextSize(2);
  tft.setTextColor(ST7735_YELLOW);
  tft.println("allemaal");
  tft.setTextSize(1);
  tft.setCursor(18, 80);
  tft.setTextColor(ST7735_GREEN);
  tft.println("TFT 1.4\" shield");
  tft.setRotation(tft.getRotation() + 1); // Draai de tekst een kwartslag verder
  delay(3000);
}

Numeriek display

• 7 segment 4 cijfers displays met twee draden voor de interface.
  
  Ook tekst is mogelijk... ;-)
  Ik testte type 3642BH. Dit display heeft grote cijfers en een dubbele punt tussen het tweede en derde getal, zodat het goed bruikbaar is om tijden weer te geven. Je kunt er bijvoorbeeld een stopwatch mee maken. Het display is gemonteerd op een TM1637 driver bord. Hierdoor kun je het display (met pin CLK en DIO) aansluiten op twee willekeurige pinnen van je Arduino. Als je meerdere displays hebt kun je voor elk display twee andere pinnen gebruiken. Er zijn verschillende mogelijkheden om dit display te programmeren. Gebruik bijvoorbeeld de TM1637Display bibliotheek. Deze heeft een voorbeeldprogramma waarin ook de helderheid van het display wordt gevarieerd. Dit werkt allemaal prima.
  Ik heb inmiddels ook type D4056A getest. Hiervoor kun je dezelfde software gebruiken. Dit display heeft nog grotere en zeer scherpe letters. Een voordeel is dat de aansluitingen eronder zitten, zodat dit display makkelijk ingebouwd kan worden.
• 7 segment 4 cijfers displays met 12 pootjes.
  Deze displays gebruiken
  erg veel pinnenmaar als je twee schuifregisters gebruikt dan zijn maar twee pinnen nodig
  van je Arduino.
  De HS420361K in actie
  Er zijn twee types: met gemeenschappelijke kathode en met gemeenschappelijke anode. Ik testte de HS420361K-32; deze heeft een gemeenschappelijke kathode. Dit display heeft geen dubbele punt, maar wel een programmeerbare punt achter elk cijfer. Om dit display te gebruiken raad ik aan om de bibliotheek SevSeg-3.3.0.zip te downloaden en te gebruiken. Deze bibliotheek hoeft niet uitgepakt te worden. Deze bibliotheek heeft ook een functie om de helderheid van het display in te stellen. Het is belangrijk om alle draden correct aan te sluiten en waar nodig weerstanden te gebruiken (aan het einde van de paragraaf kunt u het aansluitschema zichtbaar maken). De waarde van de weerstanden moet ergens tussen 330 en 1000 Ω liggen. In het programma moet het type display worden opgeven:

  byte hardwareConfig = COMMON_ANODE;

  of

  byte hardwareConfig = COMMON_CATHODE;

  Mijn display werkte met deze bibliotheek perfect. Omdat alle segmenten hun voeding krijgen via de digitale pinnen, heb je verder geen voedingsspanning nodig. Dit display heeft mooie heldere en scherpe cijfers.
  
   Klik hier om het aansluitschema te zien 

  Pinnen display: 1 = linksboven; 12 = rechtsonder
  Pin van het display	Pin van de Arduino
  1	2 via weerstand
  2	6
  3	11
  4	3 via weerstand
  5	4 via weerstand
  6	7
  7	10
  8	9
  9	13
  10	8
  11	12
  12	5 via weerstand

14-segment display met HT16K13 interface

Het display in actie

8x8 led matrix (MAX 7219)

#include "LedControl.h"
#define DataIn 12 // DIN (DataIn) gaat naar pin 12
#define CLK 11 // De klok gaat naar pin 11
#define CS  10 // Chip Select gaat naar pin 10
#define AantalDisplays 2 // Zet liever te hoog dan te laag
#define WachtTijd 100 // Aantal milliseconden; verander naar eigen smaak

LedControl lc = LedControl(DataIn, CLK, CS, AantalDisplays); 

void setup() {
  lc.shutdown(0, false); lc.shutdown(1, false); // Haal het scherm uit de ruststand
  lc.setIntensity(0, 9); lc.setIntensity(1, 9); // Zet de helderheid niet te hoog
  lc.clearDisplay(0); lc.clearDisplay(1);  // Maak het scherm schoon
}

void schrijfArduino()  { // Schrijf het woord Arduino op de schermen. 
  byte A[] = {B11000, B111100, B1100110, B11000011, B11111111, B11000011, B11000011, B11000011};
  byte r[] = {0, 0, B1011000, B1100100, B1000000, B1000000, B1000000, 0};
  byte d[] = {B100, B100, B110100, B1001100, B1000100, B1001100, B110100, 0};
  byte u[] = {0, 0, B1000100,  B1000100,  B1000100, B1001100, B110100, 0};
  byte i[] = {B10000, 0, B110000, B10000, B10000, B10000, B111000, 0};
  byte n[] = {0, 0, B1011000, B1100100, B1000100, B1000100, B1000100, 0};
  byte o[] = {0, 0, B111000, B1000100, B1000100, B1000100, B111000, 0};
  for ( int i = 0; i < 8; i++ ) lc.setRow(0, i, A[i]);
  for ( int i = 0; i < 8; i++ ) lc.setRow(1, i, o[i]);
  delay(WachtTijd);
  lc.clearDisplay(0);
  for ( int i = 0; i < 8; i++ ) lc.setRow(0, i, r[i]); 
  for ( int i = 0; i < 8; i++ ) lc.setRow(1, i, n[i]);
  delay(WachtTijd);
  for ( int i = 0; i < 8; i++ ) lc.setRow(0, i, d[i]);
  for ( int j = 0; j < 8; j++ ) lc.setRow(1, j, i[j]);
  delay(WachtTijd);
  for ( int i = 0; i < 8; i++ ) lc.setRow(0, i, u[i]);
  for ( int i = 0; i < 8; i++ ) lc.setRow(1, i, u[i]);
  delay(WachtTijd);
  for ( int j = 0; j < 8; j++ ) lc.setRow(0, j, i[j]);
  for ( int i = 0; i < 8; i++ ) lc.setRow(1, i, d[i]);
  delay(WachtTijd);
  for ( int i = 0; i < 8; i++ ) lc.setRow(0, i, n[i]);
  for ( int i = 0; i < 8; i++ ) lc.setRow(1, i, r[i]);
  delay(WachtTijd);
  for ( int i = 0; i < 8; i++ ) lc.setRow(0, i, o[i]);
  for ( int i = 0; i < 8; i++ ) lc.setRow(1, i, A[i]);
  delay(WachtTijd);
  lc.clearDisplay(0); lc.clearDisplay(1);
}

void schaakbord() { // schaakbord patroon
  for ( int Aantal = 0; Aantal < 3; Aantal++ ) {
    for ( int row = 0; row < 8; row++ ) {
      if (row & 1) lc.setRow(0, row, B10101010);
      else lc.setRow(0, row, B01010101);
      if (row & 10) lc.setRow(1, row, B00110011); 
      else lc.setRow(1, row, B11001100); 
      if (Aantal == 0) delay(300);
    }
    delay(WachtTijd);
    for ( int row = 0; row < 8; row++ ) {
      if (row & 1) lc.setRow(0, row, B01010101);
      else lc.setRow(0, row, B10101010);
      if (row & 10) lc.setRow(1, row, B11001100); 
      else lc.setRow(1, row, B00110011);    
    }
    delay(WachtTijd);
  }
}

void loop() {
  schrijfArduino();
  schaakbord();
}

Negen displays kan ook

Proportionele letters

Een super bibliotheek voor panelen met deze displays

Staafdiagram display (batterij 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);
}

Display in werking
(met de Leonardo)

Display in werking
(met de nano)

14 bij 9 monochroom LoL-display shield

In werkelijkheid is display veel mooier dan op de foto.

VGA scherm

VGA connector

VGA tekst

VGA palet

TV scherm (zwart-wit via composiet ingang)

De foto is iets overbelicht, in werkelijkheid is het beeld haarscherp.

Snoertje met ingebouwde weerstanden

  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)

#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

Een 1,54″ e-Paper display

pasfoto van Cindy.

e-Paper displays met WeMos of nodeMCU module

Albert, Avril, George en Charlie zijn gedithered; de rest zijn lijntekeningen of combinaties.
Het is de bedoeling dat je de bmp-files kunt downloaden, zodat je meteen kunt gaan testen met deze plaatjes. Op dit moment heb ik even geen tijd om dat af te maken.

Via wifi op het display gezet..

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.

4-grijstinten UART e-Paper

Een goedkope programmer

7-kleuren e-Paper

Het 5,65″ ACeP 7-kleuren display van Waveshare

Nextion smart displays

Zo sluit je deze programmer aan.

De lay-out van dit scherm is gebaseerd op een voorbeeld van Marcelo Vilar.

Getest met Arduino Uno en de displays NX3224T024_011 en NX4042K032_011
Naast een Arduino en een Nextion scherm heb je ook nog een DHT11 (of hoger nummer) nodig: zie hier voor meer informatie over deze sensor.

// Koppel voor het uploaden van deze sketch T0 (pin 0) los, en sluit hem na het uploaden weer aan
#include "Nextion.h"
#include "DHT.h"
// Aansluiting van de kabel van het Nextion display
// 5v  (rode draad)   -> VCC, 5 volt (niet 3,3 v!), gebruik zo nodig een externe voeding
// GND (zwarte draad) -> GND
// RX  (gele draad)   -> TX van de Arduino (Uno, nano: pin 1)
// TX  (blauwe draad) -> RX van de Arduino (Uno, nano: pin 0)

NexProgressBar kwik = NexProgressBar(0, 3, "j1"); // pagina nummer 0, ID 3, naam in Nextion Editor "j1"
NexNumber nex_temp  = NexNumber(0, 4, "n0");
NexNumber nex_vocht = NexNumber(0, 1, "n1");

#define DHTPIN 7 // nummer van de Arduino pin die naar de DHT11 datapin gaat  
#define DHTTYPE DHT11  // Als je bijvoorbeeld een DHT 22 hebt verander DHT11 dan in DHT22
DHT dht(DHTPIN, DHTTYPE);

void setup(void) {
  nexInit();
  dht.begin();
}

void loop(void) {
  float temp = dht.readTemperature();
  float vocht = dht.readHumidity();

  nex_temp.setValue(round(temp));
  if (temp > 0) kwik.setValue(round(2 * temp)); else kwik.setValue(0); // 50 graden komt overeen met 100%
  if (temp < 16) nex_temp.Set_font_color_pco(0xFF); // 0xFF is blauw
  else nex_temp.Set_font_color_pco(63488); // Waarde gekopieerd van Nextion Editor
  nex_vocht.setValue(round(vocht));
  delay(500);
}

Hier is de versie van het NewConfig.h bestand dat ik heb gebruikt, samen met een Arduino Uno. Dit bestand staat in de map ITEADLIB_Arduino_Nextion-master (of soortgelijke naam) onder de map libraries.

/**
 * @file NexConfig.h
 *
 * Options for user can be found here. 
 *
 * @author  Wu Pengfei (email:<pengfei.wu@itead.cc>)
 * @date    2015/8/13
 * @copyright 
 * Copyright (C) 2014-2015 ITEAD Intelligent Systems Co., Ltd. \n
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation; either version 2 of
 * the License, or (at your option) any later version.
 */
#ifndef __NEXCONFIG_H__
#define __NEXCONFIG_H__

/**
 * @addtogroup Configuration 
 * @{ 
 */

/** 
 * Define DEBUG_SERIAL_ENABLE to enable debug serial. 
 * Comment it to disable debug serial. 
 */
//#define DEBUG_SERIAL_ENABLE

/**
 * Define dbSerial for the output of debug messages. 
 */
//#define dbSerial Serial

/**
 * Define nexSerial for communicate with Nextion touch panel. 
 */
#define nexSerial Serial


#ifdef DEBUG_SERIAL_ENABLE
#define dbSerialPrint(a)    dbSerial.print(a)
#define dbSerialPrintln(a)  dbSerial.println(a)
#define dbSerialBegin(a)    dbSerial.begin(a)
#else
#define dbSerialPrint(a)    do{}while(0)
#define dbSerialPrintln(a)  do{}while(0)
#define dbSerialBegin(a)    do{}while(0)
#endif

/**
 * @}
 */

#endif /* #ifndef __NEXCONFIG_H__ */

Ik zou hier een download link naar het tft bestand kunnen zetten, maar het probleem is dat zo'n bestand alleen werkt bij bepaalde displays. Te doen: Nagaan of het nuttig is het HMI bestand met de plaatjes hier neer te zetten. Dan kunt u dat zelf downloaden naar uw scherm.