Arduino touchscreen-rekenmachine - Ajarnpa

2024 Auteur: John Day | [email protected]. Laatst gewijzigd: 2024-01-30 11:16

Hallo! Dit is een project om een touchscreen-calculator te maken met behulp van een Arduino Uno en een TFT LCD-schild. Ik bedacht het concept voor mijn homeschool-programmeerklas en de ervaring bij het bouwen van dit project was erg interessant. Deze rekenmachine kan de vier eenvoudige wiskundige bewerkingen uitvoeren (optellen, aftrekken, vermenigvuldigen en delen). Het geeft ook maximaal twee decimalen weer voor de deelantwoorden die ze hebben. Laten we er meteen in duiken! Hieronder vindt u de benodigdheden voor dit project.

Benodigdheden

- Arduino Uno

- 2.4 TFT LCD Shield (hier heb ik het gekocht:

- USB A naar B kabel (snoer om Arduino op computer aan te sluiten)

- Computer met Arduino IDE geïnstalleerd

- U moet ook twee bibliotheken downloaden: MCUFRIEND_kbv en Touchscreen. De eerste kun je vinden op github (link: https://github.com/prenticedavid/MCUFRIEND_kbv) of je kunt het bibliotheek-zipbestand gebruiken dat ik hieronder heb toegevoegd. De tweede bevindt zich in de Arduino Library-manager voor installatie.

Stap 1: Hardwareverbindingen

De aansluiting van het touchscreen shield op de Arduino Uno is eenvoudig en snel. Het enige wat u hoeft te doen is de laagste pinnen op het schild uitlijnen met de laagste pinnen op de Arduino en het schild in de pinnen duwen. De bovenste 5V-pin en de niet-gelabelde pin aan de voedingszijde mogen geen pinnen van het schild bevatten, waarbij dezelfde parameters gelden voor de pinnen met het label SCL en SDA aan de andere kant van het bord. Nu zijn we klaar om te coderen!

Stap 2: De code: algemene definities en instellingen

#erbij betrekken

MCUFRIEND_kbv tft; // hoe dan ook hard-wired voor UNO-schilden

#erbij betrekken

#define YP A3

#define XM A2

#definieer YM 9

#define XP 8

TouchScreen ts = TouchScreen (XP, YP, XM, YM, 300);

#define MINDRUK 10

Dit is het begin van de code, waarin we bibliotheken (MCUFRIEND_kbv & Touchscreen) opnemen, de X- en Y-pinnen definiëren, de touchscreen-parameters instellen en de minimale druk definiëren die de Arduino nodig heeft om een gebruikerspers te registreren.

int-ID;

int gebruiker_selectie;

float opgeslagen_nummer = 0;

vlotter term1;

int op_num;

float resultaat;

int cursorLocX = 5;

int cursorLocY = 20;

Vlak voor de installatie moeten we enkele globale variabelen instellen. ID helpt bij het opstarten van het touchscreen. user_selection bevat een nummer dat overeenkomt met de toets die de gebruiker selecteert bij het indrukken van het touchscreen. opgeslagen_nummer is de variabele die we op het scherm afdrukken na een gebruikersinvoer (meer hierover in de loop). Het is een float, dus het kan zowel decimale getallen als gehele getallen bevatten. term1 is de variabele waarin het eerste getal van de vergelijking wordt opgeslagen nadat een operand is geselecteerd. op_num slaat de operand op als een getal (1 voor optellen, 2 voor aftrekken, 3 voor vermenigvuldigen en 4 voor delen). resultaat is de variabele die op het scherm wordt afgedrukt nadat de gebruiker op het gelijkteken heeft gedrukt. Het is ook een vlotter. cursorLocX en cursorLocY zijn de toewijzingspunten op het touchscreen waarop de cursor meerdere keren is ingesteld (deze bevindt zich in de grijze balk bovenaan, ook wel het resultatenveld genoemd).

ongeldige setup(){

tft.reset();

ID = tft.readID();

tft.begin(ID);

tft.setRotatie(0);

tft.fillScreen(TFT_DARKGREY);

vierkanten();

getallen();

tft.setTextSize(3);

tft.setTextColor(TFT_BLUE, TFT_DARKGREY);

}

Onze setup-functie bevat eerst de initialisatie voor het touchscreen-schild (regels 1-3). De oriëntatie van het schild wordt ingesteld met de opdracht tft.setRotation(), waarbij 0 rechtop staat. Het hele scherm is donkergrijs gekleurd met de opdracht tft.fillScreen(), die we bovenaan zullen schrijven (behalve het resultatenveld). De functies squares() en numbers() tekenen de vierkanten van de rekenmachine, kleuren de vierkanten zwart en wit in een dambordpatroon en schrijven getallen/operanden op de vierkanten in blauw. Die komen we in de volgende stap tegen. De opdracht tft.setTextSize() stelt de tekstgrootte van het resultatenveld in op 3, wat een gemiddeld lettertype is. De opdracht tft.setTextColor() stelt de tekstkleur van het resultatenveld in op blauw, dat over het donkergrijze veld wordt geschreven.

Stap 3: De code: lus

void loop() { numberSelect();

vertraging (100);

if (user_selection == 16){

;

}anders{

if (user_selection < 10){

opgeslagen_nummer = opgeslagen_nummer * 10 + gebruiker_selectie;

tft.setCursor(cursorLocX, cursorLocY);

tft.print (opgeslagen_nummer);

}else if (user_selection > 10){

schakelaar (user_selection){

geval 11:

op_num = 1;

tft.setCursor(cursorLocX, cursorLocY);

tft.print("+ ");

term1 = opgeslagen_nummer;

opgeslagen_nummer = 0;

pauze;

geval 12:

op_num = 2;

tft.setCursor(cursorLocX, cursorLocY);

tft.print("- ");

term1 = opgeslagen_nummer;

opgeslagen_nummer = 0;

pauze;

geval 13:

op_num = 3;

tft.setCursor(cursorLocX, cursorLocY);

tft.print("X");

term1 = opgeslagen_nummer;

opgeslagen_nummer = 0;

pauze;

geval 14:

op_num = 4;

tft.setCursor(cursorLocX, cursorLocY);

tft.print("/ ");

term1 = opgeslagen_nummer;

opgeslagen_nummer = 0;

pauze;

geval 15:

opgeslagen_nummer = 0;

term1 = 0;

op_num = 0;

tft.setCursor(cursorLocX, cursorLocY);

tft.print(" ");

pauze;

}

tft.setCursor(cursorLocX, cursorLocY);

Dit is veel om op te kauwen, dus ik zal uitleggen wat hierboven staat. We beginnen met het aanroepen van de functie numberSelect(), die een nummer toewijst aan elk vierkant op het touchscreen. Wanneer een gebruiker op een van die vierkanten drukt, stelt de functie de variabele user_selection in op het nummer van het vierkant. De eerste if-instructie is om alleen door de lus te lopen als er een geldige gebruikersselectie is gemaakt. Als dat zo is, vraagt de volgende if-opdracht of user_selection een getal van minder dan 10 bevat (de getallen 0-9). Als dit het geval is, wordt opgeslagen_nummer vermenigvuldigd met 10 en wordt het nummer in gebruiker_selectie toegevoegd aan opgeslagen_nummer, dat wordt afgedrukt in het resultatenveld op het touchscreen. Als dat niet het geval is, vraagt de volgende if-opdracht of user_selection een getal groter dan 10 heeft opgeslagen (de operandnummers: 11 voor +, 12 voor -, 13 voor X, 14 voor / en 15 voor het lege schermvierkant). Een schakelfunctie zorgt voor elk geval (bepaald door user_selection). De variabele op_num krijgt een nummer dat overeenkomt met de geselecteerde operand (1 voor +, 2 voor -, 3 voor X en 4 voor /). De waarde in opgeslagen_nummer wordt opgeslagen in de variabele term1 zodat de variabele opgeslagen_nummer kan worden gebruikt voor de tweede helft van de vergelijking. Het operandsymbool wordt op het scherm afgedrukt en alle getallen in het resultatenveld worden gewist. De enige uitzondering is het duidelijke schermvierkant, dat alle berekeningsvariabelen reset en het resultatenveld wist van alles erop.

}anders{

schakelaar(op_num){

zaak 1:

resultaat = term1 + opgeslagen_nummer;

tft.setCursor(cursorLocX, cursorLocY);

tft.print(dubbel(resultaat));

pauze;

geval 2:

resultaat = term1 - opgeslagen_nummer;

tft.setCursor(cursorLocX, cursorLocY);

tft.print(dubbel(resultaat));

pauze;

geval 3:

resultaat = term1 * opgeslagen_nummer;

tft.setCursor(cursorLocX, cursorLocY);

tft.print(dubbel(resultaat));

pauze;

geval 4:

resultaat = float(term1) / float(saved_number);

tft.setCursor(cursorLocX, cursorLocY);

tft.print(resultaat);

pauze;

}

tft.setCursor(cursorLocX, cursorLocY);

opgeslagen_nummer = resultaat;

term1 = 0;

op_num = 0;

vertraging (1000);

}

}

}

Het laatste deel van de lus gaat over de gebeurtenis waarbij de gebruiker het isgelijkteken selecteert (user_selection == 10). Een andere schakelfunctie werkt via de vier wiskundige functies (bepaald door op_num). Het optellingsgeval (geval 1) telt term1 en opgeslagen_nummer bij elkaar op en slaat het getal op in de resultaatvariabele. Het resultaat wordt als een dubbele in het resultatenveld afgedrukt. Het geval van aftrekken (geval 2) trekt opgeslagen_getal af van term1 en slaat het getal op in de resultaatvariabele. Het resultaat wordt dubbel afgedrukt naar het resultatenveld. Het geval van vermenigvuldiging (geval 3) vermenigvuldigt term1 met opgeslagen_getal en slaat het getal op in de resultaatvariabele. Het resultaat wordt als een dubbele in het resultatenveld afgedrukt. Het delingsgeval (geval 4) verdeelt term1 door opgeslagen_getal samen en slaat het getal op in de resultaatvariabele. Het resultaat wordt als een float in het resultatenveld afgedrukt (omdat de delingsantwoorden decimale getallen kunnen zijn). Nadat een getal, operand of resultaat op het scherm wordt afgedrukt, wordt de cursor opnieuw ingesteld, wordt opgeslagen_nummer ingesteld op het vorige resultaat en worden term1 en op_num opnieuw ingesteld.

Een paar opmerkingen: de gebruiker kan geen decimale getallen in de rekenmachine invoeren vanwege het ontbreken van een decimaalteken. Ook kan de gebruiker slechts één vergelijking tegelijk uitvoeren. U kunt geen resultaat berekenen en dat resultaat vervolgens optellen/aftrekken/vermenigvuldigen/delen. In de functie numberSelect() is er een functie die het scherm wist nadat een resultaat is afgedrukt als een gebruiker op een ander vierkantje heeft gedrukt.

Stap 4: De code: Squares-functie

lege vierkanten (){

// zwarte en witte vierkanten wisselen elkaar af op elke rij en de eerste en derde rij hebben een tegenovergesteld patroon dan de tweede en vierde rij

tft.fillRect(0, 60, 60, 65, TFT_BLACK); // eerste rij vierkanten begint, zwart naar wit tft.fillRect (60, 60, 60, 65, TFT_WHITE);

tft.fillRect(120, 60, 60, 65, TFT_BLACK);

tft.fillRect(180, 60, 60, 65, TFT_WHITE); // eerste rij vierkanten eindigt

tft.fillRect(0, 125, 60, 65, TFT_WHITE); // tweede rij vierkanten begint, wit tot zwart tft.fillRect(60, 125, 60, 65, TFT_BLACK);

tft.fillRect(120, 125, 60, 65, TFT_WHITE);

tft.fillRect(180, 125, 60, 65, TFT_BLACK); // tweede rij vierkanten eindigt

tft.fillRect(0, 190, 60, 65, TFT_BLACK); // derde rij vierkanten begint, zwart naar wit tft.fillRect(60, 190, 60, 65, TFT_WHITE);

tft.fillRect(120, 190, 60, 65, TFT_BLACK);

tft.fillRect(180, 190, 60, 65, TFT_WHITE); // derde rij vierkanten eindigt

tft.fillRect(0, 255, 60, 65, TFT_WHITE); // vierde rij vierkanten begint, wit naar zwart tft.fillRect (60, 255, 60, 65, TFT_BLACK);

tft.fillRect(120, 255, 60, 65, TFT_WHITE);

tft.fillRect(180, 255, 60, 65, TFT_BLACK); // vierde rij vierkanten eindigt

}

De functie squares() is vrij eenvoudig. De opdracht tft.fillRect(X1, Y1, X2, Y2, TFT_COLOR) tekent een rechthoek volgens de parameters die eraan zijn doorgegeven, namelijk de eerste posities van x en y, de tweede posities van x en y, en de kleur waarmee de rechthoek is gevuld. Deze functie tekent alle vier rijen vierkanten (technisch gezien rechthoeken) en vult elk vierkant met de kleur die eraan wordt doorgegeven.

Stap 5: De Code: Nummers Functie

ongeldige nummers (){

tft.setTextColor(TFT_BLUE); // zet nummer/tekenkleur op blauw

tft.setTextSize(5); // stelt nummer/tekengrootte in op 5

tft.setCursor (18, 75); // zet cursor voor eerste regel met cijfers/tekens

tft.print("7 8 9 /"); // drukt de eerste regel met cijfers/tekens af

tft.setCursor (18, 140); // zet cursor voor tweede regel met cijfers/tekens

tft.print("4 5 6 X"); // drukt tweede regel met cijfers/tekens af

tft.setCursor (18, 205); // zet cursor voor derde regel met cijfers/tekens

tft.print("1 2 3 -"); // drukt de derde regel met cijfers/tekens af

tft.setCursor (18, 270); // zet cursor voor vierde regel met cijfers/tekens

tft.print("C 0 = +"); // drukt de vierde regel met cijfers/tekens af

}

De functie numbers() is ook eenvoudig. De eerste twee regels stellen de tekstgrootte groter en de kleur in op blauw. De opdracht tft.setCursor() zet de cursor op de positie op elke rij waar het schrijven van de getallen begint. Vervolgens drukt de opdracht tft.print() de cijfers/tekens over de vierkanten af.

Stap 6: De Code: NummerSelecteer Functie

ongeldig nummerSelecteer(){

TSPoint p = ts.getPoint();

pinMode (XM, UITGANG);

pinMode (YP, UITGANG);

if (p.z > MINDRUK){

p.x = kaart (p.x, 250, 845, 0, 239);

p.y = kaart (py, 245, 860, 0, 319);

if (resultaat != 0){

resultaat = 0;

opgeslagen_nummer = 0;

tft.print("WAARDEN WISSEN ");

vertraging (500);

tft.setCursor(cursorLocX, cursorLocY);

tft.print(" ");

tft.setCursor(cursorLocX, cursorLocY);

}

Om de functie numberSelect() te starten, vragen we gebruikersinvoer vanaf het touchscreen met de opdracht ts.getPoint(). Zodra die gegevens zijn verzameld, controleren we of de minimale druk is overschreden (of met andere woorden, of de gebruiker ergens op het touchscreen heeft gedrukt). Als dit het geval is, worden de x- en y-coördinaten toegewezen van cartesiaanse coördinaten naar touchscreen-specifieke coördinaten. (0, 0) is de linkerbovenhoek van het touchscreen, met de x-as over en de y-as naar beneden. Het volgende deel controleert of er een nummer is opgeslagen in resultaat. Als dit het geval is, worden resultaat en opgeslagen_nummer teruggezet naar 0. Het bericht "WAARDEN WISSEN" wordt afgedrukt over het resultatenveld en het scherm wordt gewist met de cursor terug naar de beginpositie.

if (py 60) { // eerste rij vierkanten

als (p.x < 60)

gebruiker_selectie = 7;

anders als (p.x < 120)

user_selection = 8;

anders als (p.x < 180)

user_selection = 9;

anders user_selection = 14;

}else if (p.y 125){ // tweede rij vierkanten

als (p.x < 60)

user_selection = 4;

anders als (p.x < 120)

user_selection = 5;

anders als (p.x < 180)

gebruiker_selectie = 6;

anders user_selection = 13;

}else if (p.y 190){ // derde rij vierkanten

als (p.x < 60)

user_selection = 1;

anders als (p.x < 120)

user_selection = 2;

anders als (p.x < 180)

user_selection = 3;

anders user_selection = 12;

}else if (p.y > 255){ // vierde rij vierkanten

als (p.x < 60)

gebruikersselectie = 15;

anders als (p.x < 120)

gebruikersselectie = 0;

anders als (p.x < 180)

gebruikersselectie = 10;

anders user_selection = 11;

}

}anders{

user_selection = 16; // user_selection is ingesteld op 16 (niets variabel)

}

}

Dit is het gedeelte dat bepaalt welke knop is geselecteerd. Beginnend met de bovenste rij vierkanten en eindigend met de onderste rij, zoekt de Arduino naar waar het scherm daadwerkelijk werd ingedrukt. Het wijst vervolgens het vierkant een nummer toe en slaat dat nummer op in user_selection. De cijfers 0-9 komen overeen met de cijfervierkanten, de cijfers 11-15 komen overeen met de operandvierkanten en het duidelijke vierkant, en het cijfer 10 komt overeen met het gelijktekenvierkant. Als er geen vierkant is geselecteerd, wordt user_selection op 16 gezet, waardoor de lus opnieuw begint (zie lusfunctie).

Stap 7: Geniet van je voltooide project

Daar heb je het! Je hebt nu een touchscreen-calculator die optellen, aftrekken, vermenigvuldigen en delen kan doen. Dit project veranderde de hele manier waarop ik dacht dat een rekenmachine werkte. Terwijl ik aan dit project werkte, herinner ik me dat ik tijdens de les tegen mijn instructeur zei: "Ik zal nooit meer op dezelfde manier naar een rekenmachine kijken!" De functies waarvan jij als gebruiker denkt dat ze makkelijk zijn, zijn wat lastig als je achter de computer zit en je idee probeert na te bootsen. Ik hoop dat je het project leuk vond, en ik hoop dat je manier van denken over hoe een rekenmachine werkt ook is veranderd!

Hier is de volledige code voor uw gemak. Het staat vol met opmerkingen, dus als je problemen hebt, moeten ze je laten zien wat elke regel doet.