Arduino pekskärmskalkylator med TFT LCD

Arduino har alltid hjälpt till att enkelt bygga projekt och få dem att se mer attraktiva ut. Att programmera en LCD-skärm med pekskärmsalternativ kan låta som en komplicerad uppgift, men Arduino-biblioteken och sköldarna hade gjort det väldigt enkelt. I det här projektet kommer vi att använda en 2,4 ”Arduino TFT LCD- skärm för att bygga vår egen Arduino pekskärmskalkylator som kan utföra alla grundläggande beräkningar som Addition, Subtraction, Division och Multiplication.

Material som krävs:

1. Arduino Uno
2. 2,4 ”TFT LCD-skärm
3. 9V batteri.

Lär känna TFT LCD-skärmmodul:

Innan vi faktiskt dyker in i projektet är det viktigt att veta, hur denna 2,4 ”TFT LCD-modul fungerar och vilka typer som finns i den. Låt oss ta en titt på pinouts för denna 2,4 ”TFT LCD-skärmmodul.

Som du kan se finns det 28 stift som passar perfekt i alla Arduino Uno / Arduino Mega Board. En liten klassificering av dessa stift ges i tabellen nedan.

Som ni kan se stiften kan delas in i fyra huvud klassificeringar som LCD Command Pins, LCD Data Pins, SD Pins och Power Pins, behöver vi inte vet mycket om den detaljerade bearbetning av dessa stift, eftersom de kommer att ta hand av vårt Arduino-bibliotek.

Du kan också hitta en SD-kortplats längst ner på modulen som visas ovan, som kan användas för att ladda ett SD-kort med bmp-bildfiler, och dessa bilder kan visas på vår TFT LCD-skärm med Arduino-programmet.

En annan viktig sak att notera är din Interface IC. Det finns många typer av TFT-moduler tillgängliga på marknaden, från den ursprungliga Adafruit TFT LCD-modulen till billiga kinesiska kloner. Ett program som fungerar perfekt för din Adafruit-sköld kanske inte fungerar detsamma för kinesiska breakout-styrelser. Så det är mycket viktigt att veta vilka typer av LCD-skärmar du håller i handen. Denna detalj måste erhållas från leverantören. Om du har en billig klon som min använder den troligen ICI-drivrutinen ili9341. Du kan följa detta TFT LCD-gränssnitt med Arduino-handledning för att prova några grundläggande exempelprogram och bli bekväm med LCD-skärmen. Kolla även in våra andra TFT LCD-projekt med Arduino här:

• Hur man använder NeoPixel LED Strip med Arduino och TFT LCD
• Smarttelefonstyrt digitalt kodlås med Arduino

Kalibrera TFT LCD-skärm för pekskärm:

Om du planerar att använda pekskärmsfunktionen på din TFT LCD-modul måste du kalibrera den för att få den att fungera ordentligt. En LCD-skärm utan kalibrering kan fungera osannolikt, till exempel kan du röra vid ett ställe och TFT kan svara för en beröring någon annanstans. Dessa kalibreringsresultat kommer inte att vara lika för alla brädor och därför är du ensam kvar att göra detta.

Det bästa sättet att kalibrera är att använda kalibreringsexempelprogrammet (medföljer bibliotek) eller använda den seriella bildskärmen för att upptäcka ditt fel. Men för detta projekt eftersom storleken på knapparna är stor bör kalibrering inte vara ett stort problem och jag kommer också att förklara hur du kan kalibrera din skärm under programmeringsavsnittet nedan.

TFT LCD-anslutningar med Arduino:

2,4 ”TFT LCD-skärmen är en perfekt Arduino Shield. Du kan trycka direkt på LCD-skärmen ovanpå Arduino Uno så att den passar perfekt med stiften och glider in genom. När det gäller säkerhet täcker du dock din Arduino UNO: s programmeringsterminal med ett litet isoleringstejp, bara om terminalen kommer i kontakt med din TFT LCD-skärm. LCD-skärmen monterad på UNO kommer att se ut så här nedan.

Programmera din Arduino för TFT LCD:

Vi använder SPFD5408-biblioteket för att få den här arduino-kalkylatorkoden att fungera. Detta är ett modifierat bibliotek av Adafruit och kan fungera sömlöst med vår LCD TFT-modul. Du kan kontrollera hela programmet i slutet av denna artikel.

Obs! Det är mycket viktigt för dig att installera det här biblioteket i din Arduino IDE eller detta program att kompilera utan något fel.

För att installera detta bibliotek kan du helt enkelt klicka på länken ovan som tar dig till en Github-sida. Klicka där på klon eller ladda ner och välj “Ladda ner ZIP”. En zip-fil laddas ner.

Öppna nu Arduino IDE och välj Skiss -> Inkludera bibliotek -> Lägg till.ZIP-bibliotek. Ett webbläsarfönster öppnas och navigerar till ZIP-filen och klickar på “OK”. Du bör lägga märke till "Bibliotek lagt till dina bibliotek" i det nedre vänstra hörnet av Arduino, om det lyckas. En detaljerad guide för att göra detsamma ges i gränssnittshandledningen.

Nu kan du använda koden nedan i din Arduino IDE och ladda upp den till din Arduino UNO för att pekskärmskalkylatorn ska fungera. Längre ner har jag förklarat koden i små segment.

Vi behöver tre bibliotek för att detta program ska fungera; alla dessa tre bibliotek gavs i ZIP-filen som du laddade ner från länken ovan. Jag har helt enkelt inkluderat dem i koden som visas nedan.

#omfatta // Kärngrafikbibliotek # inkludera // Maskinvaruspecifikt bibliotek # inkludera

Som sagt tidigare måste vi kalibrera LCD-skärmen för att få den att fungera som förväntat, men oroa dig inte om värdena här är nästan universella. Variablerna TS_MINX, TS_MINY, TS_MAXX och TS_MAXY bestämmer kalibreringen av skärmen. Du kan leka runt dem om du tycker att kalibreringen inte är tillfredsställande.

#define TS_MINX 125 #define TS_MINY 85 #define TS_MAXX 965 #define TS_MAXY 905

Som vi vet kan TFT LCD-skärmen visa många färger, alla dessa färger måste anges i hex-värde. För att göra det mer mänskligt läsbart tilldelar vi dessa värden till en variabel enligt nedan.

#define WHITE 0x0000 // Black-> White #define GUL 0x001F // Blue-> Yellow #define CYAN 0xF800 // Red-> Cyan #define PINK 0x07E0 // Green-> Pink #define RED 0x07FF // Cyan -> Red #define GREEN 0xF81F // Pink -> Green #define BLUE 0xFFE0 // Yellow-> Blue #define BLACK 0xFFFF // White-> Black

Okej nu, vi kan komma in i programmeringsdelen. Det finns tre avsnitt involverade i detta program. En är att skapa ett användargränssnitt för en miniräknare med knappar och display. Sedan, upptäcka knapparna baserat på användarna berör och slutligen beräkna resultaten och visa dem. Låt oss gå igenom dem en efter en.

1. Skapa ett användargränssnitt för miniräknare:

Det är här du kan använda mycket av din kreativitet för att utforma miniräknarens användargränssnitt. Jag har helt enkelt gjort en grundläggande layout för en miniräknare med 16 knappar och en displayenhet. Du måste konstruera designen precis som att du ritar något på MS-färg. Med de bibliotek som läggs till kan du rita linjer, rektangel, cirklar, tecken, strängar och mycket mer av valfri färg. Du kan förstå de tillgängliga funktionerna från den här artikeln.

Jag har använt linje- och rutritningsförmågan för att designa ett användargränssnitt som liknar 90-talets miniräknare. Varje ruta har en bredd och höjd på 60 pixlar.

// Rita resultatrutan tft.fillRect (0, 0, 240, 80, CYAN); // Rita första kolumn tft.fillRect (0,260,60,60, RÖDT); tft.fillRect (0,200,60,60, SVART); tft.fillRect (0,140,60,60, SVART); tft.fillRect (0,80,60,60, SVART); // Rita tredje kolumnen tft.fillRect (120,260,60,60, GRÖN); tft.fillRect (120,200,60,60, SVART); tft.fillRect (120,140,60,60, SVART); tft.fillRect (120,80,60,60, SVART); // Rita sekund och fjärde kolumnen för (int b = 260; b> = 80; b- = 60) {tft.fillRect (180, b, 60,60, BLÅ); tft.fillRect (60, b, 60,60, SVART);} // Rita horisontella linjer för (int h = 80; h <= 320; h + = 60) tft.drawFastHLine (0, h, 240, WHITE); // Rita vertikala linjer för (int v = 0; v <= 240; v + = 60) tft.drawFastVLine (v, 80, 240, WHITE); // Visa tangentbordslablar för (int j = 0; j <4; j ++) {för (int i = 0; i <4; i ++) {tft.setCursor (22 + (60 * i), 100 + (60 *) j)); tft.setTextSize (3); tft.setTextColor (WHITE); tft.println (symbol);

2. Upptäcka knapparna:

En annan utmanande uppgift är att upptäcka användarens beröring. Varje gång användaren berör någonstans kommer vi att kunna hur X- och Y-positionen för pixeln han rörde vid. Detta värde kan visas på seriemonitorn med hjälp av println enligt nedan.

TSPoint p = waitTouch (); X = py; Y = px; Serial.print (X); Serial.print (','); Serial.println (Y); // + "" + Y);

Eftersom vi har utformat rutan med en bredd och höjd på 60 pixlar vardera och har fyra rader och för kolumner från (0,0). Positionen för varje ruta kan förutsägas enligt bilden nedan.

Men i praktiken blir detta inte resultatet. Det kommer att finnas en stor skillnad mellan det förväntade och det faktiska värdet på grund av kalibreringsproblemet.

Så, för att förutsäga rutans exakta position måste du klicka på raden och kontrollera dess motsvarande position på den seriella bildskärmen. Det här är kanske inte det mest professionella sättet att göra det, men ändå fungerar det perfekt. Jag mätte positionen för alla linjer och fick värdena nedan.

Nu, eftersom vi vet positionen för alla lådor. När en användare rör var som helst kan vi förutsäga var han har rört genom att jämföra sina (X, Y) värden med värdet för varje ruta som visas nedan.

if (X <105 && X> 50) // Upptäcka knappar i kolumn 2 {if (Y> 0 && Y <85) {Serial.println ("Button 0"); // Knapp 0 trycks ned om (Number == 0) Number = 0; annars Siffra = (Siffra * 10) + 0; // Tryckt två gånger} om (Y> 85 && Y <140) {Serial.println ("Knapp 2"); if (Number == 0) Number = 2; annars Antal = (Nummer * 10) + 2; // tryckt två gånger}

3. Visa nummer och beräkna resultatet:

Det sista steget är att beräkna resultatet och visa dem på TFT LCD-skärm. Denna arduino-kalkylator kan endast utföras med två nummer. Dessa två siffror benämns som variabler "Num1" och "Num2". Variabeln "Number" ger och tar värde från Num1 och Num2 och bär också resultatet.

När en användning trycker på en knapp läggs en siffra till siffran. När du trycker på en annan knapp multipliceras den sista siffran med 10 och det nya numret läggs till med det. Om vi ​​till exempel trycker på 8 och sedan trycker på 5 och sedan trycker på 7. Sedan håller variabeln först 8 och sedan (8 * 10) + 5 = 85 sedan (85 * 10) +7 = 857. Så äntligen kommer variabeln att ha värdet 857 med det.

if (Y> 192 && Y <245) {Serial.println ("Knapp 8"); if (Number == 0) Number = 8; annat tal = (nummer * 10) + 8; // tryckt igen}

När vi utför någon operation som tillägg, när användarna trycker på tilläggsknappen kommer värdet från Number att överföras till Num1 och sedan kommer Number att göras noll så att det blir redo att ta inmatningen för det andra numret.

När du trycker på Equal kommer värdet i Number att skickas till Num2 och sedan kommer respektive beräkning (i detta fall tillägg) att göras och resultatet lagras igen i variabeln "Number".

Slutligen kommer detta värde att visas på LCD-skärmen.

Arbetssätt:

Arbetet med denna Arduino Touch Screen Calculator är enkel. Du måste ladda upp nedanstående kod på din Arduino och skjuta upp den. Du får räknaren visas på din LCD-skärm.

Nu kan du ange valfritt nummer och utföra dina beräkningar. Det är begränsat till endast två operand och enda operatör för tillfället. Men du kan justera koden så att den har många alternativ.

Du måste trycka på "C" för att rensa värdet på skärmen varje gång efter en beräkning. Hoppas du förstod projektet och tyckte om att bygga något liknande. Om du är osäker kan du skicka dem på forum eller i kommentarsektionen nedan. Vi ses nästa gång med ett annat intressant projekt fram till dess happy computing !!

Kolla även demonstrationsvideon nedan.