Arduino TFT -ritprogram: 4 steg

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

Denna instruerbara beskriver koden som går till att göra ett ritprogram för en Arduino TFT -skärm. Detta program är dock unikt eftersom det gör det möjligt att spara en ritning till SD -kortet och ladda det senare för att göra fler redigeringar!

Tillbehör

1. Arduino Uno - original eller en kompatibel klon
2. TFT -pekskärm - Jag använde en Elegoo -skärm, vilket betyder att jag behövde Elegoo -drivrutiner.
3. Micro SD -läsarkort - används för att lagra ritningsdata till SD -kort. Min skärm hade en inbyggd läsare under skärmen.
4. Stylus - min skärm kom med en. Naglar fungerar också bra.
5. Micro SD -kort - högst 32 GB, på grund av exFAT -formateringsbegränsningar (Arduino kan läsa FAT32 -formaterade kort men INTE exFAT. De flesta större kort formateras med exFAT.). Detta är den typ som du skulle sätta i en telefon med utbyggbart lagringsutrymme.
6. Dator med Arduino IDE
7. Programmeringskabel - USB A till USB B. Min Arduino följde med en.
8. SD -kortadapter - används för att konvertera Micro SD -kortet till ett normalt SD -kort för att sätta i SD -kort ELLER ett som ansluter ett SD -kort till ett USB -kort.

Steg 1: Formatera SD -kortet

1. Ta Micro SD -kortet och anslut det till din dator med din SD -kortläsare
2. Öppna File Explorer och hitta SD -kortet.
3. Högerklicka på den och välj Format.
4. Ange alternativen baserat på skärmdumpen.
5. Klicka på Start.
6. Mata ut kortet när processen är klar.

Om du inte kör Windows kan du prova att använda SD Formatter från SD -föreningen.

Steg 2: Förbered Arduino

1. Tryck ner skärmskyddet på Arduino, var noga med att ställa in stiften.
2. Sätt in SD -kortet i läsaren under skärmen.

Steg 3: Arduino Sketch

Även om listan med delar var ganska enkel, finns det massor av kod. Jag går igenom det steg för steg här.

#omfatta

#include #include #include #include

Elegoo_GFX, _TFTLCD och TouchScreen är alla hårdvaruspecifika. Om du använder en annan skärm använder du de bibliotek som tillhandahålls av tillverkaren.

SPI och SD används för att kommunicera med SD -kortet. SPI är det protokoll som används av SD -kortkontrollanten.

#if definierad (_ SAM3X8E _) #undef _FlashStringHelper:: F (string_literal) #define F (string_literal) string_literal #endif

Detta är också hårdvaruspecifikt.

#define YP A3 // måste vara en analog pin #definiera XM A2 // måste vara en analog pin #define YM 9 #define XP 8

// Tryck för ny ILI9341 TP

#definiera TS_MINX 120 #definiera TS_MAXX 900 #definiera TS_MINY 70 #definiera TS_MAXY 920

#define CSPIN 10

#definiera LCD_CS A3

#definiera LCD_CD A2 #definiera LCD_WR A1 #definiera LCD_RD A0 #definiera LCD_RESET A4

Var och en av dessa #define -satser får IDE att ersätta namnet med värdet. Här ställer de in LCD- och SD I/O -stiften.

// Tilldela namn till några 16-bitars färgvärden: #define BLACK 0x0000 #define WHITE 0xFFFF #define RED 0xF800 #define BLUE 0x001F #define GREEN 0x07E0

Det här är några av de färger som används i koden. #att definiera dem gör det lättare att läsa koden.

#define PENRADIUS 3

Detta definierar ritpennans storlek.

#define MINPRESSURE 10#definiera MAXPRESSURE 1000

// För bättre tryckprecision måste vi känna till motståndet

// mellan X+ och X- Använd valfri multimeter för att läsa den // För den jag använder är dess 300 ohm över X-plattan TouchScreen ts = TouchScreen (XP, YP, XM, YM, 300);

Elegoo_TFTLCD tft (LCD_CS, LCD_CD, LCD_WR, LCD_RD, LCD_RESET);

Dessa uttalanden definierar trycket som behövs för att registrera en touch, initiera touch -funktionen och starta skärmen.

Fillagring; int storageSize; int stoX = 1; int stoY = 1;

Dessa är variabler för lagringsdelen av programmet.

void setup (void) {Serial.begin (9600); Serial.println ("Paint -program");

tft.reset ();

uint16_t identifierare = tft.readID ();

om (identifierare == 0x0101) {identifierare = 0x9341; Serial.println (F ("Hittade 0x9341 LCD -drivrutin")); }

// Starta skärmen

tft.begin (identifierare); tft.setRotation (2);

pinMode (13, OUTPUT);

// Starta SD -kort

if (! SD.begin (CSPIN)) {Serial.println ("SD -initialisering misslyckades"); lämna tillbaka; } Serial.println ("SD initialiserad");

// Rita bakgrunden

drawBackground (); }

Installationsfunktionen startar Serial om den är tillgänglig, återställer skärmen, upptäcker TFT -drivrutinen, startar skärmen, startar kortet och ringer en funktion för att rita bakgrunden.

Jag hoppar över till huvuddelen av loop -funktionen. Allt annat används bara för att driva pekskärmen.

// Upptäck skärmtryck och lagra den i variabler om (p.z> MINPRESSURE && p.z <MAXPRESSURE) {// Skala p.x = map (p.x, TS_MINX, TS_MAXX, tft.width (), 0); p.y = (tft.height () - map (p.y, TS_MINY, TS_MAXY, tft.height (), 0));

//Dra

if (s.y> 21) {// Spara data på SD -kortlagring = SD.open ("storage.txt", FILE_WRITE); storage.print (s.x); storage.print (","); storage.println (s.y); storage.close ();

// Prick vid beröringspositionen

tft.fillCircle (p.x, p.y, PENRADIUS, WHITE); }

// Radera -knappen

if ((s. 198) && (s. x <219)) {deleteStorage (); }

// Ladda knappåtgärd

if ((s. 219)) {loadStorage (); }}

Om en tryckning upptäcks, ställ in variabler för pressens plats.

Om pressen befinner sig inom ritområdet, spara punkten till SD -kortet i storage.txt och rita en cirkel vid den nedtryckta punkten, med en definierad storlek och färg.

Kör sedan en funktion som tar bort den lagrade ritningen om pressen är på plats för raderingsknappen. Om du använder en skärm av annan storlek kan du prova att spela med knappens platsvärden.

Om sedan pressen är på platsen för laddningsknappen, kör en funktion som laddar den lagrade ritningen. Om du använder en skärm av annan storlek kan du prova att spela med knappens platsvärden.

Nu ska jag förklara funktionerna.

Den första funktionen kallas i setup för att rita bakgrunden och knapparna.

void drawBackground () {// Ställ in bakgrunden tft.fillScreen (SVART);

// Måla text

tft.setTextColor (VIT); tft.setTextSize (3); tft.setCursor (0, 0); tft.println ("Paint");

// Ladda knappen

tft.fillRect (219, 0, 21, 21, GRÖN);

// Rensa -knappen

tft.fillRect (198, 0, 21, 21, RÖD); }

Det fyller skärmen svart, skriver ordet Paint och ritar färgade rutor för knapparna. Om du använder en skärm av annan storlek kan du prova att spela med knappens platsvärden.

void deleteStorage () {// Radera filen SD.remove ("storage.txt");

// Ställ in bakgrunden

tft.fillScreen (SVART);

// Radera framgångstext

tft.setTextColor (VIT); tft.setTextSize (2); tft.setCursor (0, 0); tft.println ("storage.txt raderad");

// Låt användaren läsa den

fördröjning (2000);

// Fortsätt rita

drawBackground (); }

DeleteStorage -funktionen tar bort storage.txt, fyller skärmen svart och ger ett framgångsmeddelande för radering. Den kallar sedan drawBackground -funktionen så att du kan börja måla något annat.

void loadStorage () {// Undvik upprepningar från långsamma fingerfördröjning (250);

// Sök efter lagringsfil

if (! SD.exists ("storage.txt")) {Serial.println ("No storage.txt file"); lämna tillbaka; }

// Öppna filen i skrivskyddat läge

lagring = SD.open ("storage.txt", FILE_READ);

// Medan det finns data, medan (stoY> 0) {// Uppdatera positionsvariabler stoX = storage.parseInt (); stoY = storage.parseInt ();

// Rita från lagring

tft.fillCircle (stoX, stoY, PENRADIUS, WHITE); } // Stäng filen storage.close (); }

Slutligen söker loadStorage-funktionen efter en lagringsfil, öppnar den i skrivskyddat läge och upprepar sedan den här slingan:

Så länge det finns mer data,

1. Uppdatera positionsvariablerna med de analyserade data från storage.txt
2. Rita en cirkel vid den laddade punkten

När slingan är klar och det inte finns mer data stänger den lagringsfilen.

Koden för denna skiss hittar du nedan. Bara ladda ner den, öppna den i Arduino och ladda upp den till ditt bräde!

Steg 4: Använda detta program

Anslut bara din Arduino till en strömkälla - dator, batteri, väggvarta etc. och börja rita. För att radera din teckning och dess lagrade data, tryck på den röda knappen. Klicka på den gröna knappen för att ladda en ritning från lagringen och fortsätta arbeta med den. På detta sätt kan du iterera många gånger på en ritning!

Som en förlängning, försök att rita ritningen på din dator:

1. Anslut SD -kortet med data till din dator.
2. Öppna storage.txt i din favorittext-/kodredigerare.
3. Kopiera alla värden i storage.txt.
4. Följ den här länken till ett punktplottningsprogram.
5. Ta bort de två exempelpunkterna till vänster.
6. Klistra in dina data där exempelpunkterna fanns.

Detta är ett snyggt sätt att visa upp dina teckningar - kanske till och med försöka ändra punktfärgen på Arduino eller i punktplottern!

Ändringar välkomnas, och jag ser gärna några förslag i kommentarerna. Tack för att du tittade på detta och jag hoppas att du hittar snygga användningsområden för det i dina egna projekt!