Så här lägger du till en E-Ink-display i ditt projekt: 12 steg (med bilder)

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

Många projekt innebär övervakning av någon form av data, till exempel miljödata, ofta med hjälp av en Arduino för kontroll. I mitt fall ville jag övervaka saltnivån i min vattenavhärdare. Du kanske vill komma åt data via ditt hemnätverk, men du kanske också vill visa den där den mäts. Eller så kan du ha en fjärransluten skärm som alltid är på på en mer bekväm plats.

Det finns nu flera typer av skärmar du kan använda, alla ganska billiga, men med olika fördelar och nackdelar:

• En alfanumerisk LCD -skärm är den billigaste men också den mest begränsade.
• En OLED -skärm kan visa grafik men de billiga är väldigt små. Det andra fotot visar en 128 x 64 pixlar OLED-skärm bredvid en E-Ink.
• En E-Ink (eller E-Paper) display är något större och därmed lättare att läsa, och har fördelen att displayen behålls även när den är avstängd! Men det tar flera sekunder att rita om displayen.

E-Ink-skärmen verkade perfekt för min applikation eftersom jag kunde programmera Arduino för att vakna bara några timmar, ta en läsning och visa den innan jag somnade om. Det är då utan konsekvens att det tar flera sekunder att rita om displayen.

I en sådan applikation kan den genomsnittliga strömförbrukningen vara så låg att ett 9V litiumrökdetektorbatteri kan göras för att hålla i 10 år! Några av dessa skärmar visar dessutom tre färger: vitt, svart och rött (eller gult). Perfekt om du vill visa en varning eller varning i rött.

Tillbehör

De billigaste E-Ink-skärmarna jag hittat säljs av BuyDisplay, även tillgängliga från många eBay-säljare. Tyvärr lämnar dokumentationen ganska mycket att önska så jag tog på mig att skriva en handledning - läs vidare!

Beroende på dina krav och din budget kan du välja mellan olika storlekar:

• 1,54 "(152x152 = 23, 104 pixlar)
• 2.13 "(212x104 = 22, 048 pixlar)
• 2,6 tum (296 x 152 = 44, 992 pixlar)
• 2,7 tum (176x264 = 46, 464 pixlar)
• 2,9 "(296x128 = 37, 888 pixlar)
• 4,2 tum (400x300 = 120 000 pixlar)
• 5,83 "(640x480 = 307, 200 pixlar)
• 7,5 tum (880x528 = 464, 640 pixlar)

(Utbudet har utökats sedan förra gången jag tittade så kan ha expanderat ytterligare när du läser detta.)

De finns antingen i 2-färg (svart/vit) eller 3-färg (svart/röd/vit eller svart/gul/vit). Denna instruktion förutsätter att du använder den röda, men om du har valt den gula versionen, läs helt enkelt "gul" för "röd" hela tiden.

Välj en SPI-version (4-tråds). Jag använde 1,54 modellen, vilket är en mycket fin storlek.

Steg 1: Anslut din bildskärm

Dessa skärmar har en 2x4 -stifts rubrik. Stiftnumren är tydligt märkta, stift 7, 5, 3 och 1 (från vänster till höger) längs den översta raden och 8, 6, 4, 2 längs botten.

Din skärm kan komma med en 8-vägs patchkabel, vilket gör anslutningen enkel. (Min patchkabel har 2 röda trådar och 2 bruna. De är inte utbytbara!

Följande tabell visar anslutningarna som gäller för de flesta typer av Arduino (inklusive Uno, Pro Mini, Pro Micro och Nano).

E-bläck modul		Arduino
Stift	namn	Stift	namn
1	VDD	Vcc	3.3/5V
2	VSS	Gnd	Gnd
3	Seriell data in	11	MOSI
4	Seriell klocka in	13	SCK
5	/Chip Select	10
6	Data/Instr	9
7	Återställa	8
8	Enhet upptagen	7

Steg 2: Ladda ner den medföljande programvaran

Du kan använda den medföljande programvaran enligt beskrivningen i det här steget, eller så kan du använda mitt förbättrade bibliotek i nästa steg, men ett.

Hitta din enhet på BuyDisplay.com. Längst ner på sidan hittar du en nedladdad ZIP-fil "Arduino-bibliotek och exempel för 4-tråds SPI". Klicka på detta för att ladda ner och öppna i Utforskaren.

Utforskaren visar att den innehåller en enda mapp på toppnivå "Libraries-Exempel_ER-EPM0154-1R". (Namnet kommer att vara något annorlunda om ditt inte är 1,54 "-modellen.)

Kopiera den här översta mappen till mappen Arduino bibliotek. Högerklicka för att byta namn på mappen och ta bort "Bibliotek-Exempel_" från namnet.

(För att hitta din Arduino biblioteksmapp, i Arduino IDE, klicka på Arkiv … Inställningar och notera Sketchbook Location. Navigare till detta, och du hittar Arduino "bibliotek" -mappen bland dina skissmappar.)

Öppna den här mappen och öppna mappen "Bibliotek" i den. Dra och släpp alla filer i den här mappen till den överordnade mappen en nivå högre ("ER-EPM0154-1R"). Ta bort mappen (nu tom) "Bibliotek".

Du har nu installerat filerna och en testskiss som ett Arduino -bibliotek. Observera att om din skärm inte är 1,54 , verkar den enda skillnaden vara två rader i ER-ERM*-1.h som definierar WIDTH och HEIGHT.

I Arduino IDE klickar du på File … Exampes och rullar ner till ER-EPM0154-1R för demoskissen, som du ska kunna kompilera och köra så snart du har anslutit din display till din Arduino.

Steg 3: Kör demo

I Arduino IDE klickar du på Arkiv … Exempel … ER-EPM0154-1R.

Anslut din Arduino till din dator med en USB -kabel, eller som du normalt gör.

Under Verktyg, ställ in styrelsen, processorn och porten.

Klicka på Ladda upp under Skiss.

Det kommer att bli en liten fördröjning när uppladdningen är klar, och tio förseningen kommer att blinka ett antal gånger när den målar den första bilden. Titta medan det går igenom demoen.

Steg 4: Använda det förbättrade biblioteket

Du kan ladda ner mitt förbättrade bibliotek från github på

N. B. Jag har en hög grad av förtroende för att mitt bibliotek fungerar med alla storlekar som är kompatibla, men jag har faktiskt testat det med 1,54 -modellen. Om du använder en annan, vänligen meddela mig i kommentarerna i slutet denna instruktion, för att bekräfta att den fungerar. Men om den inte gör det ska jag göra mitt bästa för att få dig att gå.

Ladda ner och spara zip -filen. I Arduino IDE klickar du på Sketch … Inkludera bibliotek … Lägg till. ZIP -bibliotek och välj den sparade zip -filen.

Mitt bibliotek innehåller flera mindre förbättringar:

• Det gör att olika Arduino -pinnummer kan användas (förutom MOSI).
• Samma bibliotek kan användas för alla enheter.
• En ny 50% skuggad fyllning och en fläckig fyllning (slumpmässiga pixlar är inställda) tillhandahålls.

Biblioteket kommer som en standard Arduino -komprimerad (zip) -fil. Ladda ner den till din nedladdningsmapp (eller där du föredrar) och klicka på Sketch … Inkludera bibliotek … Lägg till ZIP -bibliotek i Arduino IDE.

Under Exempel hittar du nu E-ink_ER-EPM. Det finns tre exempelskisser:

• ER_EPM154-1R-Test: Den ursprungliga demonstrationen från leverantören
• E-ink_demo: Skissen utvecklades i nästa steg
• E-ink_rotate: En demonstration av bildrotation.

Steg 5: Programmera det själv

Det finns tyvärr ingen dokumentation med den leverantörslevererade koden, inte heller kommenteras exempelkoden tillräckligt. Detta gör det svårare än det borde vara att använda, och huvudsyftet med denna instruktionsbok är att rätta till det.

Grundläggande koncept

Eftersom en Arduino är begränsad i mängden RAM -minne, kan biblioteket rita eller skriva i små delar av skärmen åt gången och ladda upp dem individuellt till enhetens interminne. Först när du har laddat upp alla delar du behöver säger du till den att den ska visa vad den har i minnet.

Dessa delar av skärmen är kända som "Paint" -objekt. Du behöver bara en, och för varje del av skärmen definierar du dess höjd, bredd och rotation. När du är klar laddar du upp den och definierar positionen på skärmen för att ladda den till och om den ska vara svartvitt eller rödvitt.

Skärmens övre vänstra hörn har horisontella (x) och vertikala (y) koordinater (0, 0), nedre vänstra är (0, 151) och uppe till höger är (151, 0).

Initiering

Öppna E-ink_demo-skissen i Arduino IDE och följ den när jag beskriver hur du använder biblioteket.

Högst upp på skissen ser du följande rader, som alltid behövs:

#include <SPI.h #include "ER-ERM0154-1.h" #include "imagedata.h" #include "epdpaint.h" #define COLORED 0 #define UNCOLORED 1 Epd epd;

#Include -linjerna drar in de nödvändiga biblioteken. SPI.h är ett vanligt Arduino-bibliotek men de andra utgör en del av e-ink-biblioteket.

Vi definierar namn för OFÄRGAD (vit) pixlar och FÄRGAD (svart eller röd). (Notera till mina medeuropéer: den amerikanska stavningen av FÄRG används.)

Epd epd; line skapar det elektroniska pappersobjektobjektet som vi kommer att visa. Detta måste finnas här i början av skissen för att göra det tillgängligt för funktionerna setup () och loop ().

Om du har en annan storlek kan du ersätta EPD -raden med:

Epd epd (WIDTH, HEIGHT);

(har tidigare definierat WIDTH och HEIGHT i #define -satser.)

På samma sätt kan du ange icke-standardnummer med:

Epd epd (WIDTH, HEIGHT, BUSY_PIN, RESET_PIN, DC_PIN, CS_PIN);

Inom setup () måste vi initialisera enheten enligt följande:

Serial.begin (9600)

if (epd. Init ()! = 0) {Serial.print ("e-Paper init failed"); lämna tillbaka; }

(Faktum är att epd. Init () aldrig returnerar ett fel, men en framtida förbättring kan upptäcka frånvaron av en display eller en som inte fungerar.)

Steg 6: Skriva text

I E-ink_demo vänder du din uppmärksamhet till loop (). Låt oss först rensa displayen:

epd. ClearFrame ()

(Detta är faktiskt inte nödvändigt om du ska visa din egen bild.)

Innan vi kan rita någonting (vare sig text eller grafik) måste vi skapa ett Paint -objekt att rita på:

osignerad rödbild [1024]

Måla färg (bild, 152, 18); // bredd ska vara multipeln av 8

Detta reserverar lite utrymme (1024 byte) och tilldelar det till Paint -objektet, avgränsat av den andra raden. Detta är provisoriskt konfigurerat som 152 pixlar brett och 18 pixlar djupt. Vi kan omkonfigurera det senare för återanvändning vid behov, men observera: bredden måste vara en multipel på 8 eftersom 8 pixlar lagras per byte och vi kan inte dela byte. (Det kommer faktiskt att runda upp det om det behövs, men det kan då vara förbryllande när din skärm inte ser ut som den ska.

Nu måste vi rensa färgobjektet till OFÄRGT (vitt), sedan vid position (x, y) = (22, 2) skriver vi "e-ink Demo" med ett 16 pixlar högt teckensnitt och FÄRGT (för att visa mot OFÄRGAD bakgrund.

lack. Clear (OFÄRGT)

paint. DrawStringAt (12, 2, "e-paper Demo" och Font16, COLORED);

Observera att koordinaterna (22, 2) är det övre vänstra hörnet av strängens första tecken och är 22 pixlar in och 2 pixlar ner i förhållande till det övre vänstra hörnet av färgobjektet, inte hela displayen. Text ser bäst ut minst en pixel ner från toppen av färgobjektet.

Följande typsnitt är tillgängliga:

Font8 - 5x8 pixlar Font12 - 7x12 pixlar Font16 - 11x16 pixlar Font20 - 14x20 pixlar Font24 - 17x24 pixlar

Vi måste nu bara skicka färgobjektet ("måla") till enheten ("epd"):

epd. SetPartialWindowBlack (paint. GetImage (), 0, 3, paint. GetWidth (), paint. GetHeight ());

SetPartialWindowBlack är en metod som vi tillämpar på epd -objektet, med hjälp av bilden och dess bredd och djupegenskaper för färgobjektet. Vi säger åt den att skriva den här bilden till enheten på (x, y) = (0, 3). Och vi säger att de FÄRGADE pixlarna ska vara svarta.

Det var inte för svårt, eller hur? Låt oss prova en annan.

måla. Rensa (FÄRGAD);

paint. DrawStringAt (20, 2, "(vit på färg)", & Font12, OFÄRGAD); epd. SetPartialWindowRed (paint. GetImage (), 0, 24, paint. GetWidth (), paint. GetHeight ());

Vi återanvänder samma färgobjekt och samma bredd och höjd, men den här gången, låt oss rensa det till FÄRGT och skriva en OFÄRGAD sträng till det. Och för en ändring gör vi de FÄRGDA pixlarna röda och skriver det till enheten på (0, 24), strax under den första.

Vi har skrivit de två färgobjekten till enhetens minne men ännu inte sagt åt dem att visa dem. Vi gör detta med följande uttalande:

epd. DisplayFrame ();

(I E-ink_demo-skissen lämnar vi faktiskt detta till slutet, efter att ha ritat några fler saker, men du kan infoga det här om du vill, följt av fördröjning (10000); för att ge dig tid att beundra ditt hantverk.

Steg 7: Rita linjer och rektanglar

Låt oss se hur vi ritar linjer och rektanglar. Vi kommer att använda samma färgobjekt, men vi måste omkonfigurera det som 40 pixlar brett och 36 pixlar högt. Vi kommer att rensa det till OFÄRGT.

paint. SetWidth (40);

paint. SetHeight (36); måla. Rensa (OFÄRGT);

Vi kommer att rita en (FÄRGAD) rektangel med övre vänstra hörnet (5, 3) och nedre högra (35, 33), relativt färgobjektet, som vanligt. Vi kommer också att rita dess diagonaler som linjer från (5, 3) till (35, 33) och från (35, 3) till (5, 33). Slutligen skriver vi hela färgobjektet (rött) till skärmen vid (32, 42).

//ÖVERSTA RADEN:

// Rektangulär färg. Klar (OFÄRGAD); paint. DrawRectangle (5, 3, 35, 33, COLORED;) paint. DrawLine (5, 3, 35, 33, COLORED); paint. DrawLine (35, 3, 5, 33, COLORED); epd. SetPartialWindowRed (paint. GetImage (), 32, 42, paint. GetWidth (), paint. GetHeight ());

Biblioteket, som det kom, gav också en fylld rektangel, men hej, jag ville ha en skuggad, så jag lade till en ny metod. Vi gör ytterligare två rektanglar, en skuggad och en fylld, och placerar dem till höger om den första och alternerar dem svarta och röda.

// Skuggad rektangulär färg. Klar (OFÄRGAD); paint. DrawShadedRectangle (5, 3, 35, 33); epd. SetPartialWindowBlack (paint. GetImage (), 72, 42, paint. GetWidth (), paint. GetHeight ()); // Fylld rektangelfärg. Klar (OFÄRGAD); paint. DrawFilledRectangle (5, 3, 35, 33, COLORED); epd. SetPartialWindowRed (paint. GetImage (), 112, 42, paint. GetWidth (), paint. GetHeight ());

Steg 8: Rita cirklar

Cirklar är lika enkla att rita. I stället för koordinaterna för två hörn måste vi ange koordinaterna för mitten och radien. Vi rensar färgobjektet och lägg sedan en cirkel vid (20, 15) (i förhållande till färgobjektet) och radie 15. Och upprepa för en skuggad och en fylld cirkel.

//ANDRA RADEN

// Cirkelfärg. Klar (OFÄRGAD); paint. DrawCircle (20, 18, 15, COLORED); epd. SetPartialWindowBlack (paint. GetImage (), 32, 78, paint. GetWidth (), paint. GetHeight ()); // Shaded Circle paint. Clear (OFÄRGAD); paint. DrawShadedCircle (20, 18, 15); epd. SetPartialWindowRed (paint. GetImage (), 72, 78, paint. GetWidth (), paint. GetHeight ()); // Fylld cirkelfärg. Klar (OFÄRGAD); paint. DrawFilledCircle (20, 18, 15, COLORED); epd. SetPartialWindowBlack (paint. GetImage (), 112, 78, paint. GetWidth (), paint. GetHeight ());

Steg 9: OFÄRGAD på en FÄRGAD Bakgrund

Vi fortsätter berömt här! Så medan vi är på rulle, låt oss göra ytterligare 3 cirklar på en rad nedanför, den här gången FÄRGAD på ett FÄRGT målarobjekt, som vi gjorde med den andra textraden.

// TREDJE RADEN

// Cirkelfärg. Klar (FÄRGAD); paint. DrawCircle (20, 18, 15, OFÄRGAD); epd. SetPartialWindowRed (paint. GetImage (), 32, 114, paint. GetWidth (), paint. GetHeight ()); // Shaded Circle paint. Clear (COLORED) paint. DrawShadedCircle (20, 18, 15); epd. SetPartialWindowBlack (paint. GetImage (), 72, 114, paint. GetWidth (), paint. GetHeight ()); // Fylld cirkelfärg. Klar (FÄRGAD); paint. DrawFilledCircle (20, 18, 15, OFÄRGAD); epd. SetPartialWindowRed (paint. GetImage (), 112, 114, paint. GetWidth (), paint. GetHeight ());

Förutom den skuggade fyllningen finns det också en fläckig fyllning som färgar slumpmässiga pixlar. Så istället för den skuggade cirkeln ovan hade vi kunnat sätta

paint. DrawSpeckledCircle (20, 18, 15, 25);

Den sista parametern (25) är densiteten, dvs procentandelen pixlar som ska färgas. Om den utelämnas antas 50%.

Det finns också en DrawSpeckledRectangle, med en extra parameter som specificerar densiteten.

Steg 10: Rotation

Allt vi kan rita kan vi rotera 90, 180 eller 270 grader. (Vi räknar varv medurs.)

Vi kan tillämpa en ROTATE -egenskap på ett färgobjekt, men det är viktigt att förstå att det inte är färgobjektet som roteras utan allt du skriver till det. Så om du vill ha vertikal text måste du konfigurera ditt färgobjekt så långt och tunt i vertikal riktning istället för horisontellt.

Så om du vill att din text ska roteras medurs 90 grader så att den läses uppifrån och ner (istället för från vänster till höger), kommer det övre högra hörnet av färgobjektet att vara (0, 0) för allt du skriver eller rita in det, med x avgränsat från det hörnet nedåt, och y från det hörnet mot vänster.

Du märkte förmodligen att vi lämnade ett utrymme på skärmens vänstra sida. Så låt oss skriva lite text där roterad 270 grader, det vill säga läsa nedifrån och upp. Detta kommer att sätta (0, 0) i nedre vänstra hörnet.

Observera att hur du än roterar ett färgobjekt gäller rotationen bara när du ritar pixlar på det. När du kommer att skriva det till enheten är det fortfarande koordinaterna i det övre vänstra hörnet som du måste ge till SetPartialWindow.

Så för att sammanfatta, låt oss konfigurera vårt färgobjekt att ha bredd 32 och höjd 110, så ger vi det en ROTATE_270 -egenskap. Inte för att vi måste göra allt detta innan vi skriver eller ritar något till det.

paint. SetWidth (32);

paint. SetHeight (110); paint. SetRotate (ROTATE_270);

Vi rensar den till FÄRGAD och skriver en OFÄRGEN sträng till den och placerar den sedan på (0, 42). (Det är det övre vänstra hörnet, kom ihåg. Glöm all rotation av pixlarna i den.)

måla. Rensa (FÄRGAD); paint. DrawStringAt (8, 8, "Sideways!", & Font16, OFÄRGT); epd. SetPartialWindowBlack (paint. GetImage (), 0, 42, paint. GetWidth (), paint. GetHeight ());

Slutligen måste vi berätta för enheten att visa alla pixlar vi har gett den. Och om vi inte kommer att vilja byta det ett tag och vill spara på batteriet kan vi lägga det i viloläge, och varför inte låta Arduino också sova, för att väckas när det är dags att ta och visa en annan mått.

epd. DisplayFrame ();

epd. Sleep ();

En andra exempelskiss visar rotation genom 90, 180 och 270 grader. Nu borde du kunna följa det själv.

Steg 11: Rita bitmappar

Leverantörens demo inkluderar visning av ett par bitmappsbilder. Dessa är enkla att skapa med ett verktyg som kan laddas ner från

www.buydisplay.com/image2lcd

Den kommer som en zip -fil som innehåller en.exe -installationsfil och en textfil som innehåller en licensnyckel. Expandera den och dubbelklicka sedan på.exe-filen för att installera den.

Det är uppenbarligen ganska allvarliga begränsningar för vad du kan visa eftersom E-bläckpixlar bara kan vara antingen på eller av och därför inte kan representera gråa nivåer. Men det är möjligt att lägga ett rektangulärt färgobjekt på en bild. Du kanske vill visa en logotyp, symboler eller fast text med ett fint teckensnitt, på vilket du kan överlagra variabel text eller grafik som ett stapel- eller cirkeldiagram, kanske som indikerar något som en vätskenivå.

Du kan skapa din bild med vilken ritprogram du än känner till, eller så kan du skanna in en skiss eller teckning, men i båda fallen måste du kunna reducera den till bara två nivåer. Spara den som.gif,-j.webp

Starta Image2Lcd. Längst ner ser du en flik Registrera. Klicka på detta och ange registreringskoden som kom i en textfil i zip -filen du laddade ner. Detta tar bort ett överlägg på bilden.

Öppna bildfilen i Image2Lcd. Se till att du har det i den vänstra rutan

• Utdatafiltyp: C -array
• Skanningsläge: Horisontell skanning
• BitsPixel: Monokrom
• Max bredd och höjd: storleken på din skärm och
• Inkludera huvuddata måste vara avmarkerad.

Klicka på knappen bredvid Max bredd och höjd att bearbeta. Resultatet av behandlingen kommer att visas. Du kan behöva justera reglagen för ljusstyrka och kontrast för att få bästa resultat.

Klicka på kryssrutan Omvänd färg ovanför reglaget Ljusstyrka, vilket gör det till en negativ bild, vilket av någon anledning är nödvändigt, klicka sedan på Spara för att spara den som imagedata.cpp i mappen som innehåller din Arduino -skiss. Nästa gång du öppnar skissen med Arduino IDE bör du se den som en ny flik.

Steg 12: Visa din bitmapp

I huvudfilen i din Arduino -skiss, omedelbart efter #include -raderna högst upp, sätter du in:

#inkludera "imagedata.h"

Skapa en ny flik (klicka på nedåtpilen i slutet av flikraden) och kalla den för imagedata.h. Sätt in följande 2 rader i den:

extern const osignerad char IMAGE_BLACK ;

extern const osignerad char IMAGE_RED ;

I din imagedata.cpp -fil börjar den första raden med

const unsigned char gImage_image [2888] = {

(Antalet inom hakparenteser kommer att vara annorlunda om du inte använder 1,54”-skärmen.) Ersätt detta med

const unsigned char IMAGE_BLACK PROGMEM = {

Detta är för en svartvit bild. Om du vill ha den röd och vit, ändra den till

const unsigned char IMAGE_RED PROGMEM = {

Precis före den här raden, lägg till

#omfatta

#inkludera "imagedata.h"

Du är nu redo att visa din bild. Lägg till i loop () i din huvudfil

epd. ClearFrame ();

epd. DisplayFrame (IMAGE_BLACK, NULL);

Eller, om det var en röd bild du hade skapat, borde den andra raden vara

epd. DisplayFrame (NULL, IMAGE_RED);

Faktum är att du kan skapa en kombinerad röd och svart bild genom att konvertera de röda och svarta delarna separat med Image2Lcd och visa dem båda med

epd. DisplayFrame (IMAGE_BLACK, IMAGE_RED);

Alla pixlar som är angivna både som svart i den svartvita bilden och röda i den röda och vita kommer dock att bli röda.

Slutligen kan du lägga över din bild med någon av de text- eller grafikfunktioner som vi lärt oss om tidigare. Jag ville lägga till mitt Twitterhandtag, så jag lade till

Måla färg (bild, 20, 152); // bredd ska vara multipeln av 8

paint. SetRotate (ROTATE_270); måla. Rensa (OFÄRGT); paint. DrawStringAt (20, 2, "@pleriche", & Font16, COLORED); epd. SetPartialWindowRed (paint. GetImage (), 0, 0, paint. GetWidth (), paint. GetHeight ()); epd. SetPartialWindowRed (paint. GetImage (), 0, 0, paint. GetWidth (), paint. GetHeight ()); epd. DisplayFrame ();