Leren van basis Arduino-programmering - Tutorial voor de nieuwkomers

Leren van basis Arduino-programmering - Tutorial voor de nieuwkomers

In deze tutorial leren we hoe we basis Arduino-programmering kunnen doen door middel van voorbeeldcodes en voorbeeldprogramma's. Deze tutorial kan een buitengewoon waardevolle cursus zijn voor alle nieuwkomers die de basis willen leren door middel van gemakkelijke, begrijpelijke taal.



Invoering

Volgens wikipedia een microcontroller is gelijk aan een minicomputer die in een enkele IC-chip is ingebouwd, met een eigen kernprocessor, programmeerbare ingangen, geheugen en uitgangsrandapparatuur.

Een microcontroller wordt zo handig voor een gebruiker omdat deze een ingebouwde processor, geheugen en invoer- / uitvoerpoorten biedt (ook wel GPIO of invoer- / uitvoerpinnen voor algemene doeleinden genoemd) die we door de gebruiker kunnen bedienen volgens de gewenste specificaties.





In deze tutorial zullen we werken met een Arduino Uno-bord om de programma's te leren en te testen. Voor het testen en integreren van hardware-assemblage zullen we een breadboard gebruiken.

Laten we nu snel gaan en leren hoe we aan de slag kunnen gaan met Arduino-programmering.



1.2 De software installeren (Windows)

Hiervoor heeft u toegang tot internet nodig, wat u uiteraard op uw computer zou hebben. Ga naar de volgende link en download de IDE-software:

Windows ZIP-bestand voor installatie zonder beheerdersrechten

Na het downloaden vindt u het Arduino-setup-pictogram in de downloadmap, dat er als volgt uitziet:

arduino downloadpictogram

Zodra u dit heeft, dubbelklikt u erop en installeert u de Arduino, de Integrated Development Environment (IDE) op uw computer. Het volledige proces kan worden gevisualiseerd in de volgende video:

https://youtu.be/x7AMn1paCeU

1.4 Beginnen met ons eerste circuit

Voordat we beginnen met het leren van de eigenlijke programmeertechnieken, zou het voor elke nieuweling handig zijn om te beginnen met een basiscomponent zoals een LED, en te begrijpen hoe deze met een Arduino te verbinden.

Zoals we weten is een LED een lichtgevende diode die een polariteit heeft en niet oplicht als deze niet is aangesloten op de juiste voedingspolen.

Een ander aspect van LED's is dat deze apparaten met een lage stroomsterkte werken en onmiddellijk beschadigd kunnen raken als een correct berekende weerstand niet in serie wordt gezet met een van de pinnen.

Als vuistregel is een 330 ohm 1/4 watt best ideaal voor elke 5V stijging van de voedingsingang om de stroom te beperken tot een vereist veilig niveau. Daarom kan het voor 5V 330 ohm zijn, voor 10V kan het 680 ohm zijn, enzovoort.

Breadboard gebruiken voor de montage

Zorg ervoor dat u weet hoe u een broodplank voordat we de tutorial uitproberen die in dit hoofdstuk wordt uitgelegd, omdat we een breadboard zouden gebruiken voor alle experimenten hier.

De basisinstelling van de LED-verbinding is hieronder te zien:

LED met Arduino

U kunt hierboven 3 basiscomponenten zien:

  1. Een 5 mm, 20mA LED
  2. een weerstand van 330 ohm 1/4 watt
  3. Een Arduino-bord

Monteer het systeem gewoon volgens het diagram.

Sluit vervolgens de 5V van de computer USB aan op de Arduino. Zodra je dit doet, zie je de LED oplichten.

Ik weet dat dat vrij eenvoudig is, maar het is altijd goed om helemaal opnieuw te beginnen. Wees gerust, dingen zullen steeds interessanter worden naarmate we verder gaan.

1.5 Controlerende LED met Arduino

Nu zullen we leren hoe we een LED kunnen besturen met een Arduino-programma.

Om een ​​programma te schrijven, moeten we in elk programma minimaal 2 functies hebben.

Een functie kan worden opgevat als een reeks programmeerinstructies waaraan een naam kan worden toegekend, zoals hieronder weergegeven:

  1. opstelling() dit wordt aangeroepen of uitgevoerd tijdens de start van het programma.
  2. lus() dit wordt herhaaldelijk aangeroepen of uitgevoerd gedurende de gehele operationele periode van de Arduino.

Daarom, hoewel het misschien geen praktische functionaliteit heeft, kan technisch gezien een kortst legitiem Arduino-programma worden geschreven als:

Eenvoudigste programma

Het is je misschien opgevallen dat het systeem in veel van de programmeertalen begint met het tonen van een eenvoudige afdruk, 'Hallo, wereld' op het scherm

Het elektronische equivalent voor deze zin bij de interpretatie van microcontrollers is om een ​​LED AAN en UIT te laten knipperen.

Dit is het meest basale programma dat men kan schrijven en implementeren om een ​​correcte werking van het systeem aan te geven.

We zullen proberen de procedure te implementeren en te begrijpen via het volgende stuk code:

Listing 1.2: led1 / led1.pde

OK, laten we nu begrijpen wat elke regel van de code betekent en hoe het werkt om de functie uit te voeren:

Dit werkt als een constante waardoor we het tijdens de volledige programmeercursus kunnen gebruiken, zonder dat we de werkelijke waarde hoeven te gebruiken die eraan wordt afgezet.

Volgens de standaardregels worden dergelijke constanten herkend met de beginletter naar ​Hoewel dit niet verplicht is, maakt het de dingen duidelijker en begrijpelijker wanneer u de codedetails wilt doornemen.

Deze code configureert de specifieke pin waarop onze LED is aangesloten. Met andere woorden, de code vertelt de Arduino om het 'schrijf'-aspect op deze pin te besturen, in plaats van het te' lezen '.

De bovenstaande regels geven de daadwerkelijke uitvoering van de applicatie weer. De code begint met het schrijven en weergeven van een HOOG op de relevante LED-verbinding, waarbij de LED wordt ingeschakeld.

Hier betekent de term HOOG simpelweg + 5V op de betreffende pin van de Arduino krijgen. De complementaire term LAAG geeft eenvoudig een nul of 0V op de aangewezen pin aan.

Vervolgens bellen we void setup()
{
}
void loop()
{
}
waarvan de functie is om een ​​vertraging van milliseconden te creëren (1 / 1000ste van een seconde). Aangezien het getal 500 is ingevoerd, duurt de geïmplementeerde vertraging een halve seconde.

Zodra deze 1/2 seconde is verstreken, wordt de volgende regel uitgevoerd die de LED UIT zet met de LOW-term op dezelfde pin.

De volgende regel genereert opnieuw de vertraging van 1/2 seconde, zodat de LED 1/2 seconde UIT blijft.

En het proces gaat oneindig door door de uitvoering van de regels code, zolang de Arduino van stroom wordt gehouden.

Voordat u doorgaat naar het volgende niveau, raad ik u aan om de bovenstaande code te programmeren en te controleren of u de LED AAN / UIT-reeks correct kunt implementeren of niet.

Omdat de standaard LED in Arduino is verbonden met pin # 13, moet deze onmiddellijk reageren op het bovenstaande programma en beginnen te knipperen. Als u echter merkt dat uw externe LED niet knippert, kan er een verbindingsfout zijn met uw LED, u kunt proberen de polariteit van uw LED om te keren en hopelijk ook zien knipperen.

Je kunt spelen met de vertragingstijd door het '500'-cijfer te veranderen in een andere waarde en de LED te' luisteren 'naar de commando's en deze te laten knipperen volgens de gespecificeerde vertragingswaarden.

Maar vergeet niet dat als u de LED niet met een constante snelheid van 1 seconde ziet knipperen, ongeacht uw wijziging in de vertragingstijd, dit erop kan wijzen dat de code niet werkt vanwege een fout. Omdat de Arduino standaard wordt geprogrammeerd met een knipperfrequentie van 1 seconde. Daarom moet dit tarief worden gevarieerd door uw code om te bevestigen dat het correct werkt.

1.7 Opmerkingen

De regels codes die we hierboven begrepen, zijn specifiek geschreven voor de computersoftware.

Om er echter voor te zorgen dat de gebruiker de betekenis van de regels kan raadplegen en begrijpen, kan het vaak nuttig en verstandig zijn om de uitleg naast de gewenste regels codes te schrijven.

Deze worden genoemd opmerkingen die alleen zijn geschreven voor menselijke of gebruikersreferentie en zijn gecodeerd zodat de computers deze veilig kunnen negeren.

De taal van deze commentaren is geschreven met een aantal formaten:

  1. De blokstijl van commentaar, waarbij de commentaarbeschrijving tussen het startsymbool / * en het eindsymbool * / staat
  2. Dit hoeft niet op één regel te worden beperkt, maar kan worden uitgebreid naar de volgende volgende regels, afhankelijk van de lengte van de opmerking of de beschrijving, zoals in het volgende voorbeeld wordt getoond:

/ * Dit is een opmerking * /

/ * Dus is dit * /

/ * En
* dit
* zoals
* goed */

Voor het schrijven van een snelle beschrijving van één regel voor een opmerking is twee schuine streep // symbolen aan het begin voldoende. Dit vertelt de computer dat deze regel niets te maken heeft met de eigenlijke code en genegeerd moet worden. Bijvoorbeeld:

// Dit is een opmerking die computers zullen negeren.

Hier is een voorbeeld ter referentie:

1.8 Probleemoplossing

Als u merkt dat uw programma een 'fout' vertoont tijdens het compileren, of een ander probleem, zullen de volgende tips u waarschijnlijk helpen om uw code opnieuw te controleren en de hindernis te verwijderen.

  1. Uw programmeertaal is hoofdlettergevoelig. Bijvoorbeeld de uitdrukking myVar kan niet worden geschreven als MyVar.
  2. Alle soorten witruimtes die kunnen worden uitgevoerd door het typen op het toetsenbord, worden uiteindelijk weergegeven als een enkele spatie, en het is alleen zichtbaar of begrepen door u, de computer houdt hier geen rekening mee. Simpel gezegd, vrije spaties van welke aard dan ook hebben geen enkel effect op de coderesultaten.
  3. Elk codeblok moet tussen accolades links en rechts staan, en
  4. Cijfercijfers mogen niet worden gescheiden door komma's. 1000 mag bijvoorbeeld niet worden geschreven als 1000.
  5. Elke coderegel tussen de accolades moet eindigen met een puntkomma

Interessante LED-lichtsequentie creëren met Arduino

In ons vorige hoofdstuk hebben we geleerd hoe je een LED continu AAN / UIT kunt laten knipperen met een constante vertraging.

Nu zullen we leren hoe verschillende vertragingspatronen op dezelfde LED kunnen worden uitgevoerd door de programmacode te upgraden.

We zullen geen externe LED gebruiken, maar de standaard LED die in het Arduino-bord is ingebouwd op pin # 13. Je vindt deze kleine SMD-led net achter de USB-connector.

2.2 Inzicht in IF-verklaringen

In deze sectie zullen we leren hoe controlestructuren ons in staat stellen om individuele codes uit te voeren, en soms zelfs herhaaldelijk, zoals vereist.

De verklaring als wordt de 1e controlestructuur. De volgende implementatie laat zien hoe het wordt gebruikt:

We zullen proberen de bovenstaande code stapsgewijs te begrijpen en leren hoe deze kan worden gebruikt voor andere soortgelijke uitvoeringen.

De codes tussen de 1e en de 7e regel zijn exact gelijk aan ons oorspronkelijke programma.

De eerste wijziging gebeurt feitelijk op de 8e regel.

U kunt zien dat dit vergelijkbaar is met de code op de eerste regel, behalve dat de term ontbreekt const.

Dit komt simpelweg omdat deze code geen constante is. In plaats daarvan wordt dit gedefinieerd als een variabele , die de eigenschap heeft van een variabele waarde tijdens het programmeren.

In het bovenstaande voorbeeld kunt u zien dat deze variabele de waarde 1000 heeft. Onthoud dat dergelijke variabelen die tussen accolades staan, strikt tussen accoladesparen moeten worden geschreven en dat ze 'lokale' variabelen worden genoemd.

Als alternatief worden variabelen die geacht worden buiten accolades te staan, zoals degene die we nu bespreken, herkend als 'globaal' en kunnen ze vrijwel overal binnen een programmacode worden uitgevoerd.

Als je verder gaat, kun je zien dat codes tussen regel 9 en 11 ook vergelijkbaar zijn met het eerste programma, maar het begint na regel 11 interessant te worden. Laten we eens kijken hoe!

In deze code zien we dat de standaardwaarde van de vertragingstijd wordt gewijzigd door er 100 van af te trekken.

Dit betekent dat 100 wordt afgetrokken van de oorspronkelijke waarde van 1000, op voorwaarde dat het een nieuwe waarde van 900 krijgt.

Aan de hand van de volgende afbeelding zullen we proberen een paar van de wiskundige operatoren te begrijpen die in de Arduino-taal worden gebruikt.

Arduino Math Operator-symbolen

Laten we nu de codes tussen regel 13 en 15 beoordelen.

Het belangrijkste doel van het bovenstaande stuk code is om ervoor te zorgen dat de LED ononderbroken blijft knipperen.

Vanwege het feit dat 100 wordt afgetrokken van het origineel vertragingstijd , het voorkomt dat het knipperen van de LED nul bereikt en laat het knipperen continu doorgaan.

De volgende afbeelding toont een paar vergelijkingsoperatoren die we in onze codes zouden gebruiken:

vergelijkingsoperator voor arduino-codes

In onze bovenstaande code hadden we kunnen testen of de code const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}
is.

Omdat een negatief cijfer echter even slecht kan zijn, zijn we er niet voor gegaan, en dit is een aanbevolen praktijk.

Bedenk wat de uitkomst had kunnen zijn als we hadden geprobeerd 300 in plaats van 100 af te trekken van const int kPinLed = 13?

Dus nu heb je je misschien gerealiseerd dat als de void setup()
{
pinMode(kPinLed, OUTPUT)
}
wordt geschreven als kleiner of gelijk aan nul, dan wordt de vertragingstijd teruggezet op het oorspronkelijke getal 1000.

De laatste 4 regels van de code, zoals hierboven weergegeven, worden verantwoordelijk voor het continu AAN / UIT, AAN / UIT zetten van de LED.

Hier kun je duidelijk zien dat we in plaats van een aantal cijfers te gebruiken, een variabele hebben gebruikt voor het toewijzen van de vertragingstijd zodat we deze kunnen aanpassen zoals we willen tijdens de operationele periode van de code. Dat is cool, toch?

2.3 ANDERE verklaringen

Hier zullen we leren waarom en hoe een als term kan een clausule hebben anders zodat het de situatie beslist voor het geval als verklaring is niet waar.

Het spijt me als dat te verwarrend klinkt, maak je geen zorgen, we zullen proberen het te begrijpen met het volgende voorbeeld:

In het bovenstaande kun je goed zien dat in de 10e regel code alleen wordt uitgevoerd als de void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}
is kleiner of gelijk aan 100, zo niet, dan wordt de code in de 13e regel uitgevoerd, maar beide samen kunnen nooit gebeuren, ofwel de 10e regel of de 13e regel code zal worden geïmplementeerd, nooit beide.

Het is je misschien opgevallen dat, in tegenstelling tot wat we deden in onze vorige paragraaf 2.2, we hier niet vergeleken met 0, eerder vergeleken met 100. Dit komt omdat in dit voorbeeld vergeleken VOORDAT we 100 hebben afgetrokken, in tegenstelling tot in paragraaf 2.2, we vergeleken afgetrokken. Kun je zien wat er had kunnen gebeuren als we 0 hadden vergeleken in plaats van 100?

2.4 WHILE verklaringen

NAAR terwijl verklaring lijkt veel op als verklaring, behalve de waarheid dat het herhaalde uitvoering van een codeblok veroorzaakt (dat tussen accolades kan staan) zolang de voorwaarden van toepassing zijn, en dit werkt zonder een anders uitspraak.

Het volgende voorbeeld zal u helpen dit beter te begrijpen

Kunt u raden waarvoor de bovenstaande code is geprogrammeerd? Welnu, het is ontworpen om de LED sneller en dan langzamer te laten knipperen.

2.5 Wat is waar en wat is niet waar?

In programmeertaal, false verwijst naar nul (0). Eigenlijk wordt 'true' niet gebruikt, in plaats daarvan wordt aangenomen dat als niets onwaar is, alles wat is opgenomen waar is.

Het ziet er een beetje vreemd uit, maar het doet zijn werk behoorlijk goed.

We zullen proberen de situatie te begrijpen aan de hand van het volgende voorbeeld.

U kunt soms een code tegenkomen zoals hieronder weergegeven:

Dit is gecodeerd en het lijkt erop dat de LED-uitvoering voor altijd zal blijven fietsen, zolang er stroom beschikbaar is.

Een nadeel van dit type code kan echter ontstaan ​​wanneer de gebruiker per ongeluk a = in plaats van == toepast.

Ik weet zeker dat je al weet dat = een toewijzing betekent, wat betekent dat het wordt gebruikt om een ​​geselecteerde waarde aan een variabele toe te wijzen, terwijl a == wordt gebruikt om een ​​test af te dwingen als de waarde hetzelfde was.

Stel dat u bijvoorbeeld een LED nodig heeft om te knipperen met een opeenvolgend snelheidspatroon en herhaaldelijk, maar onjuist gebruikt een = in plaats van ==.

De code zou dan als volgt verschijnen:

De fout wijst 0 toe aan delay(), en leidt tot de als verklaring om te controleren of 0 waar was of niet. Aangezien 0 naar false verwijst, zal het denken dat het niet waar is, en zal het het afdwingen van de /*
* Program Name: Blink
* Author: Alan Smith
* Description:
* Turns an LED on for one half second, then off for one half second repeatedly.
*/
stoppen, maar in plaats daarvan de functie /* Pin Definitions */
const int kPinLed = 13
/*
* Function Name: setup
* Purpose: Run once when the system powers up.
*/
void setup()
{
pinMode(kPinLed, OUTPUT)
}
/*
* Function name: loop
* Purpose: Runs over and over again, as long as the Arduino has power
*/
void loop()
{
digitalWrite(kPinLed, HIGH)
delay(500)
digitalWrite(kPinLed, LOW)
delay(500)
}
wordt tijdens de lus () op 0 gehouden.

Dit ziet er erg ongewenst uit !!

Controleer dus altijd je programma om er zeker van te zijn dat je niet zulke dwaze fouten hebt gemaakt.

2.6 Combinaties

Soms heb je misschien de behoefte om meerdere dingen samen te testen. Misschien wilt u onderzoeken of een variabele tussen twee getallen staat. Hoewel dit meerdere keren kan worden geïmplementeerd door de if-instructie meerdere keren te gebruiken, kan het handiger zijn om logische combinaties te gebruiken voor beter en gemakkelijker lezen.

Combinaties op logische termen kunnen worden geïmplementeerd met 3 methoden, zoals weergegeven in de volgende tabel:

tabel met Arduino-combinatiemethoden

Het zou interessant zijn om te weten dat de NOT-operator kan werken als een switcher voor een variabele die als een van beide kan worden aangewezen waar of false (of LAAG of HOOG).

Het volgende voorbeeld illustreert de toestand:

Hier de const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
delayTime = delayTime - 100
if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
wordt LAAG, en vervolgens zodra int delayTime = 1000, wordt het HOOG. De volgende lus veroorzaakt delayTime = delayTime - 100 HOOG te zijn wanneer if(delayTime <= 0){ // If the delay time is zero or less, reset it.
delayTime = 1000
}
is laag.

2.7 VOOR verklaringen

Nu zullen we proberen te begrijpen wat een andere controlestructuur is, namelijk een voor lus. Dit kan erg handig zijn als u iets meerdere keren wilt implementeren.

Laten we dit begrijpen met het volgende voorbeeld:

Je kunt iets unieks vinden in de lijn met voor.

Het is de code ik ++? ​Dit is handig voor programmeurs die nogal lui zijn en codering willen implementeren via handige snelkoppelingen

De bovenstaande term staat bekend als samengestelde operatoren, omdat ze de ene toewijzingsoperator combineren met een andere toewijzingsoperator. De meest populaire hiervan kunnen in de volgende tabel worden weergegeven:

arduino samengestelde operators

U zult zien dat er 3 sub-statements zijn in een for-statement. Het is gestructureerd zoals hieronder weergegeven:

De instructie # 1 komt precies aan het begin voor en slechts één keer. De conditie wordt elke keer tijdens de lus getest. Wanneer het ook is waar binnen de accolades, wordt de daaropvolgende instructie # 2 afgedwongen. In het geval van een vals, het systeem springt naar het volgende codeblok.

Meer LED's aansluiten

OK, nu zullen we zien hoe we meer LEds kunnen verbinden om meer interessante effecten te krijgen.

Verbind de LED's en de Arduino zoals hieronder weergegeven. De rode draad is eigenlijk niet nodig, maar aangezien het altijd een goed idee is om beide toevoerrails in het breadboard te hebben, is de opstelling logisch.

Arduino meerdere LED-aansluitingen

Laten we nu een programma repareren waarmee we kunnen controleren of onze hardware correct is geconfigureerd of niet.

Het wordt altijd aanbevolen om kleine stukjes programma stapsgewijs te coderen en uit te voeren om te controleren of de respectievelijke hardware correct is bedraad of niet.

Dit helpt bij het snel oplossen van een mogelijke fout.

Onderstaand codevoorbeeld geeft LED 2 t / m 5 een specifiek patroon door ze cyclisch achter elkaar te draaien.

Zoals u wellicht zult opmerken, is er niets mis met de code, behalve dat deze lang lijkt en daardoor foutgevoelig is.

Er zijn natuurlijk betere manieren om de bovenstaande code te schrijven, de volgende sectie zal het onthullen.

2.9 Introductie van arrays

Arrays kunnen een groep variabelen zijn die kunnen worden geïndexeerd met indexnummers. Het volgende voorbeeld zal ons helpen het beter te begrijpen.

OK, laten we nu elke sectie doornemen en begrijpen hoe ze echt werken.

De bovenstaande code definieert hoeveel elementen we maximaal in de array zouden moeten hebben. Deze code helpt ons in de volgende secties om ervoor te zorgen dat alles in een array wordt geschreven en niets als de array eindigt.

In deze volgende regel zetten we de array-structuur op. De cijfers tussen de haakjes geven het aantal elementen in de array aan. Hoewel de werkelijke hoeveelheid had kunnen worden geschreven, werkt schrijven als constanten beter. De waarden zijn normaal gezien tussen de haakjes te zien met komma's en duiden de waarden aan de array aan.

Als u een array vindt die is geïndexeerd met het nummer 0, geeft dit het allereerste element in de array aan, zoals weergegeven in de if(delayTime == 0).

Evenzo wordt het laatste element weergegeven als delayTime, aangezien de telling van 0 tot 3 4 is.

De bovenstaande code toont het gebruik van een lus om door elk array-element te gaan en om ze in te stellen als OUTPUTS. We implementeren vierkante haken samen met de index om elk van de elementen in de array te bereiken.

als je je afvraagt ​​of het mogelijk is om pin # 2 te gebruiken op pin # 5 zonder arrays, dan is het antwoord ja, het is mogelijk. Maar in dit voorbeeld is het niet gedaan omdat we het niet op die manier hebben gedaan. In de volgende secties kunt u de arraybenadering elimineren als de geselecteerde uitgangspennen niet in lijn zijn.

Laten we verder kijken wat het volgende codeblok doet:

Hier gaat de code door elk van de LED's om ze opeenvolgend in te schakelen met een interval of vertraging van 100 milliseconde.

Het gebruik van de bovenstaande code laat zien hoe de toepassing van for loop kan worden gebruikt om door de lus te gaan, zelfs in omgekeerde volgorde.

Het begint met delayTime omdat arrays nul zijn geïndexeerd. We beginnen niet vanaf digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
omdat dat zou resulteren in het overschrijden van de finish van de array.

De code gebruikt> = 0 om te controleren, zodat het eerste element op index 0 niet wordt gemist of genegeerd.

Hoofdstuk 3

Wat is een input

Zo hebben we geleerd hoe we dingen moeten bedienen met Arduino. In dit hoofdstuk zullen we bespreken hoe we de echte wereld kunnen voelen door input van externe parameters te koppelen.

3.1 Gebruik van drukknoppen

We weten allemaal wat een drukknop is en hoe hij werkt. Het is een soort schakelaar of knop die een signaal van de ene circuitfase naar de andere kortstondig verbindt terwijl deze zich in de ingedrukte toestand bevindt, en het signaal verbreekt wanneer het wordt losgelaten.

3.1.1 Een knop en een LED

interface drukknop met Arduino

We verbinden de Arduino met een drukknop met Arduino volgens de hierboven getoonde details en leren de basiswerking en implementatie van de set-up.

De aangegeven drukknop die ook wel microschakelaar-drukknop wordt genoemd, heeft in totaal 4 pinnen (2 paar aan elke kant). Wanneer erop gedrukt, wordt elk paar pinnen intern verbonden en maakt een verbinding of geleiding erover mogelijk.

In dit voorbeeld gebruiken we slechts één paar van deze pinnen of contacten, het andere paar is niet relevant en wordt daarom genegeerd.

Laten we doorgaan met het toepassen van de volgende code en kijken of het werkt!

Misschien vindt u hier een paar dingen die er ongebruikelijk uitzien. Laten we ze stapsgewijs uitzoeken.

Het eerste dat we doen, is het knopPin als de INVOER. Nou, dat is vrij eenvoudig, ik weet het.

Vervolgens wijzen we toe HOOG naar de INVOER pin. Vraagt ​​u zich af, hoe het mogelijk is om iets aan de ingang te schrijven? Dit kan natuurlijk interessant zijn.

Door een HIGH toe te wijzen aan een Arduino-ingang, wordt een interne 20k Ohm pull-up-weerstand ingeschakeld (een LOW op deze pin schakelt deze UIT).

Een andere vraag die u mogelijk kunt stellen, is wat een pull-up-weerstand is. Ik heb een uitgebreid bericht over pull-up-weerstanden behandeld die u leer het hier

OK, laten we nu eens kijken naar de hoofdluscode:

Wanneer u op de drukknop drukt, wordt de bedrade pin verbonden met aarde, wat een LAAG op die pin. En terwijl in de niet-geperste toestand dezelfde pin wordt vastgehouden HOOG of + 5V via de 20K interne pull-up weerstand.

Hier willen we dat de Arduino de LED laat oplichten als de drukknop wordt ingedrukt (LAAG), daarom schrijven we HOOG voor de output voor elke reactie van een LAAG van de drukknop, terwijl deze wordt ingedrukt.

3.1.2 Twee knoppen en een LED

Je vraagt ​​je misschien af ​​dat de hierboven getoonde actie ook zonder Arduino had kunnen worden uitgevoerd. Ik begrijp echter dat dit een steile steen is om te leren hoe de drukknop kan worden gebruikt met Arduno.

Tot nu toe hebben we het schrijven van codes bestudeerd om een ​​LED AAN (HIGH) of UIT (LAAG) te schakelen.

Laten we nu eens kijken hoe de helderheid van LED kan worden geregeld met een Arduino.

Het kan op twee manieren worden gedaan:

  1. Door de hoeveelheid stroom naar de LED te beperken
  2. Door het gebruiken van PWM of pulsbreedtemodulatie, waarbij de toevoer naar de LED zeer snel AAN / UIT wordt geschakeld met een gewenste snelheid, waardoor een gemiddelde verlichting wordt geproduceerd waarvan de intensiteit zou afhangen van de PWM.

Op een Arduino-bord is PWM-ondersteuning beschikbaar op pinnen gemarkeerd met een tilde (~), dit zijn pinnen 3, 4,5,9,10 en 11) op 500Hz (500 keer per seconde). De gebruiker kan elke waarde tussen 0 en 255 opgeven, waarbij 0 verwijst naar geen HIGH of geen + 5V, en 255 vertelt Arduino om altijd een HIGH of + 5V te krijgen. Om deze opdrachten te starten, moet u de analogWrite () openen met de gewenste waarde.

U mag aannemen dat PWM x / 255 is, waarbij x de gewenste waarde is die u wilt verzenden via const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
if(delayTime <= 100){ // If it is less than or equal to 100, reset it
delayTime = 1000
}
else{
delayTime = delayTime - 100
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
.

Arduino PWM-besturing

Stel de Arduino en andere parameters in zoals hierboven weergegeven.

Mogelijk vindt u hier 3 regels die wat uitleg nodig hebben.

De regel: delayTime illustreert een unieke functie binnen Arduino die bekend staat als constrain ().

Deze interne functie bevat code die lijkt op de volgende:

int beperking (int waarde, int min, int max)

Met alle codes die hiervoor zijn besproken leegte , wat betekende dat er niets werd geretourneerd (ongeldig). Terwijl de bovenstaande code begint met int , wat aangeeft dat het een geheel getal retourneert. We zullen er meer over bespreken in de latere secties, onthoud op dit moment dat een geheel getal geen fractionele delen heeft.

Juist, dus dit impliceert, de code: const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
int delayTime = 1000
void loop()
{
while(delayTime > 0){ // while delayTime is greater than 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
while(delayTime <1000){ // while delayTime is less than 1000
delayTime = delayTime + 100 // do this first so we don’t have a loop with delayTime = 0
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
}
}
wijst de while (1){
digitalWrite(kPinLed, HIGH)
delay(100)
digitalWrite(kPinLed, LOW)
delay(100)
}
.

De volgende regel gebruikt int delayTime = 1000
void loop()
{
if(delayTime = 0){ // WRONG!!! the = should have been ==
delayTime = 1000
}
digitalWrite(kPinLed, HIGH)
delay(delayTime)
digitalWrite(kPinLed, LOW)
delay(delayTime)
delayTime = delayTime - 100
}
om Arduino opdracht te geven om PWM toe te passen op de geselecteerde pin met de gewenste waarde.

De volgende regel zorgt voor een vertraging van 20 milliseconden, dit om ervoor te zorgen dat we de aten niet sneller aanpassen dan 50 Hz of 50 keer per seconde. Dit komt omdat mensen veel langzamer kunnen zijn dan een Arduino. Dus als de vertraging niet wordt gemaakt, kan het programma ons het gevoel geven dat het indrukken van de eerste knop de LED uitschakelde en het indrukken van de tweede knop het aanzet (probeer het zelf om te bevestigen).

3.2 Potentiometers

Laten we verder gaan en leren gebruiken potmeters met Arduino.

Om te weten hoe een potmeter of een pot werkt, kun je dit aflezen artikel

Potentiometer gebruiken met Arduino

Verbind de getoonde parameters met uw Arduino zoals hierboven weergegeven.

Een pot heeft 3 aansluitingen. De middelste terminasl maakt verbinding met ANALOG IN 0 op de Arduino. De andere twee buitenste terminals kunnen worden aangesloten op + 5V en 0V voedingsrails.

Laten we programmeren en de resultaten bekijken:

U zult een aantal dingen vinden die er geheel nieuw uitzien en niet in een van onze eerdere codes zijn opgenomen.

  1. De constante delayTime wordt toegewezen als A0, waarbij A de snelkoppeling is om een ​​van de analoge pinnen te beschrijven. A0 verwijst echter ook naar pin # 14, A1 naar pin # 15 enzovoort, en deze maken het mogelijk om als digitale ingangen / uitgangen te worden gebruikt voor het geval je geen pinnen meer hebt voor een experiment. Maar vergeet niet dat u digitale pinnen niet als analoge pinnen kunt gebruiken.
  2. De regel: delayTime = 1000 presenteert een nieuwe interne functie in Arduino bekend als kaart(). Deze functie wordt opnieuw gekalibreerd van een bepaald bereik naar een ander bereik, genaamd map (waarde, fromLow, fromHigh, toLow, toHigh). Dit kan cruciaal worden sinds delayTime geeft een waarde binnen het bereik van 0-1023, maar analogWrite kan een waarde tussen 0-255 accepteren.

U denkt misschien dat aangezien het mogelijk is om de helderheid van een LED te regelen door middel van een veranderende weerstand, een potje voldoende had kunnen zijn voor het doel, waarom het gebruik van Arduino. Nou, nogmaals, het is slechts de basis om te laten zien hoe een pot kan worden geconfigureerd met een Arduino.

Geen problemen, nu gaan we iets doen wat niet mogelijk is zonder een Arduino.

In dit experiment zullen we zien hoe de variërende weerstand van een pot kan worden gebruikt om de knippersnelheid of snelheid van een LED te regelen.

Hier is het programma:

3.2.3 Vertraging vermijden ()

De bovenstaande code ziet er goed uit, maar de LED kan de potwaarde niet controleren totdat deze elke volledige cyclus heeft doorlopen. Voor langere vertragingen wordt dit proces langer, de gebruiker moet wachten om de pot-respons te zien terwijl hij deze verplaatst. Deze vertraging kan worden vermeden met een aantal intelligente programmering, zodat de gebruiker de waarde kan controleren zonder minimale vertragingen. Hier is de code.

Dus wat is dat anders in de bovenstaande code? Het is de volgende regel die het verschil maakt.

Tot deze sectie hebben we gesproken over de variabele int. Er kunnen echter nog veel meer typen variabelen zijn waartoe u toegang hebt. De lijst is hieronder te lezen:

Soorten Arduino-variabelen

Momenteel is het misschien alleen cruciaal om te weten dat voor het opslaan van relatief grote nummers voor het int variabele, zou je de term kunnen gebruiken lang of een lange int.

Hier kun je een andere interessante functie zien genaamd millis ().

Dit produceert de tijdspanne in milliseconden die de Arduino vanaf het begin heeft gewerkt tijdens zijn werking (deze wordt na elke 50 dagen gereset naar 0). Hier keert het lang terug, want als het terugkeerde int is tellen voor lange perioden wellicht niet mogelijk. Kunt u precies antwoorden hoe lang? Het antwoord is 32,767 seconden.

Daarom controleren we in plaats van delay () te gebruiken op millis (), en zodra het bepaalde aantal milliseconden verstrijkt, veranderen we de LED. Daarom slaan we de tijd op waarin we deze als laatste hebben gewijzigd laatste keer variabele, zodat we het op elk gewenst moment opnieuw kunnen controleren.

3.3 RGB-leds

Tot nu toe hebben we gespeeld met een enkelkleurige LED. Hoewel de LED-kleur kan worden gewijzigd door de LED te vervangen door een andere kleur, maar hoe zit het met het gebruik van RGB-LED's om LED-kleuren te veranderen zonder de leds te veranderen?

Een RGB-LED is in feite een LED met een rode, groene en blauwe LED ingebed en samengevoegd tot een enkele LED. Het heeft één gemeenschappelijke kabel die naar de grond of 0V-voedingsrail gaat, terwijl de andere 3 kabels worden gevoed met gediversifieerde PWM-positieve signalen voor het implementeren van de beoogde kleuren mengen

U kunt de installatie aansluiten zoals hieronder weergegeven:

Controle RGB met Arduino

Het ziet er misschien een beetje ingewikkeld uit, maar eigenlijk is het een replica van ons eerdere LED-besturingsontwerp met PWM.

Hier is een oefenprogramma-code:

Kijk na het uploaden van deze code eens hoe de potaanpassingen een interessant lichteffect op de RGB creëren, het kan heel leuk zijn.

U zult zien dat wanneer alle 3 de potten maximaal zijn verplaatst, u in plaats van een witte kleur rood ziet. Dit komt omdat rode kleur de meest prominente is van de 3 kleuren en daarom domineert in deze situatie. U kunt echter experimenteren met de functie kaart() , alvorens het uit te voeren naar het rode gedeelte van de LED, om een ​​meer verstandige balans te creëren.

Audio met Arduino

In deze sectie leren we hoe je basisgeluid en muziek toevoegt aan een Arduino-setup.

We zullen zien hoe je een signaal naar een aangesloten speaker met een gewenste frequentie schakelt.

Om preciezer te zijn, wordt een middelste A-noot geprobeerd, wat een 440 Hz frequentienoot is.

Om dit te doen, spelen we gewoon een middelste A-noot en optimaliseren we het sinusgolfsignaal met blokgolf.

We zullen ook berekenen hoe lang een luidspreker AAN kan blijven door de formule aan te klagen:

timeDelay = 1 seconde / 2 x toneFrequency.

timeDelay = 1 seconde / 2 x 440

timeDelay = 1136 microseconden

4.1 Laten we het Arduino-bord aansluiten

Geluidseffect gebruiken in Arduino

4.2 Een eenvoudige notitie toevoegen

We hebben al gesproken over de functie vertraging() waar de eenheid in milliseconden is (seconde / 1000), maar je zult nog een andere functie vinden int ledState = LOW
void loop()
{
ledState = !ledState // toggle value of ledState
digitalWrite(kPinLed, ledState)
delay(1000)
}
waarbij de eenheid in microseconden is, (milliseconde / 1000).

Voor de huidige opstelling programmeren we een code om + 5V AAN / UIT te schakelen op de geselecteerde pin die is verbonden met de luidspreker, met een snelheid van 440 pulsen per seconde.

Bedenk dat we in de laatste discussie de waarde van 1136 microseconde hebben bepaald voor de bedoelde audionotitie.

Dus hier is het programma hiervoor, waarmee je een audiotoon van 440 Hz kunt horen zodra je de Arduino programmeert met een aangesloten luidspreker.

Met de bovenstaande applicatie is het mogelijk om een ​​audionotitie te maken, wat ook betekent dat we naar eigen keuze muziek kunnen maken.

Uit de code begrijpen we dat Arduino een aantal geïntegreerde functies bevat die bovendien bijdragen aan het creëren van muziek.

De eerste is toon() die werkt met 2 elementen samen met een 3e optioneel element, aangeduid als toon (pin, frequentie, duur). of toon (pin, frequentie)

Beide zijn bedoeld om uit te voeren, respectievelijk van de door u toegewezen tijdsperiode.

Als er geen tijdsperiode is, blijft de muziek spelen tot het gesprek toon() wordt opnieuw uitgevoerd, of totdat u het uitvoert niet een ().

Dit moet worden gedaan met behulp van een vertragingsfunctie voor het geval het spelen van muziek het enige fundamentele is dat u implementeert.

De tijdsduur kan cruciaal zijn, aangezien het een tijd geeft voor hoe lang de muziek wordt afgespeeld, zodat u vrij bent om andere dingen te doen. Zodra de duur is verstreken, stopt de muziek.

De volgende functie niet een () verwerkt een enkele parameter en stopt de geselecteerde toon op een bepaalde toegewezen pin.

Een eigenaardige waarschuwing: wanneer dan ook toon() functie is geïmplementeerd, PWM-functie op pin 3 en 11 stopt met werken.

Zorg er daarom bij het gebruik van een luidsprekeropzetstuk in het programma voor dat u de genoemde pin niet voor de luidsprekers gebruikt, maar probeer in plaats daarvan een aantal andere pennen voor de luidsprekerbevestiging.

OK dus hier is een programma voor het implementeren van muziek op een luidspreker, hoewel het geen echte muziek is, maar eerder een C-noot op basisschaal.

In de bovenstaande code heb je misschien iets nieuws opgemerkt en dat is #bepalen

Deze term werkt als een zoek- en vervangopdracht voor de computer terwijl het compileren wordt gedaan.

Telkens wanneer het het eerste vindt vóór een spatie, wordt het vervangen door het resterende deel van de regel (macro's genoemd).

Dus binnen dit voorbeeld wanneer de computer ziet NOTE_E4 het vervangt het snel door de hoeveelheid 330.

Voor meer opmerkingen en aanpassingen kunt u verwijzen naar een bestand op uw USB-stick met de naam plaatsen. h , waar de meeste frequenties kunnen worden gevonden voor uw voorkeur.

4.4 Muziek met functies

De bovenstaande code ziet er goed uit, maar lijkt veel herhalingen te hebben, er zou een methode moeten zijn om deze herhalingen in te korten, toch?

Tot nu toe hebben we gewerkt met twee essentiële functies die bij Arduino zijn inbegrepen. Nu wordt het misschien tijd dat we onze eigen functies creëren.

Elke functie moet beginnen met het type variabele waarmee deze kan worden geassocieerd. Bijvoorbeeld de functie leegte verwijst naar type dat niets teruggeeft, vandaar de naam void. Let op, we hebben al een lijst met variabelen besproken in onze eerdere secties, misschien wilt u die verwijzen.

Bijgevolg krijgt de specifieke functienaam een ​​open haakje gevolgd door een lijst met door komma's gescheiden parameters.

Elke parameter verkrijgt zijn type samen met een naam en tenslotte een afsluiting haakje.

Deze parameters kunnen binnen de functie worden toegepast in de vorm van variabelen.

Laten we hieronder een voorbeeld bekijken waarin we een functie ontwikkelen met de naam onzeToon () ontworpen om het toon() met vertraging() lijnen, op een manier dat de functie stopt met terugkeren totdat de noot de toon heeft gespeeld.

We implementeren deze functies in onze vorige code en krijgen het onderstaande programma, zie de laatste regels:

Functies kunnen erg handig zijn om een ​​programma begrijpelijker te maken.

Het volgende is een voorbeeld waarin we de keuze van de toon die we willen spelen kunnen specificeren met behulp van twee arrays. Een array om de noten te behouden, de andere om de beats te behouden.

Op de eerste regel zie je duidelijk de introductie van #inclusief uitspraak. De taak van deze verklaring is om het hele bestand tussen de aanhalingstekens op te halen en op de positie van de #inclusief uitspraak. Volgens de standaardregels worden deze strikt aan het begin van het programma geplaatst.

hoofdstuk 5

Temperatuur meten

Onthoud, onthoud dat het in plaats van helemaal geen grote programma's te schrijven, altijd verstandig is om kleine delen van codes te schrijven en te analyseren, wat helpt bij het snel opsporen van fouten.

5.1 Seriële monitor

Tot nu toe lijken de codes die we hebben besproken niet zo eenvoudig om een ​​snelle probleemoplossing mogelijk te maken. Hier zullen we proberen dingen gemakkelijker te maken voor het bewaken en gemakkelijker oplossen van een mogelijk probleem.

De Arduino heeft een functie waarmee hij met de computer kan 'terug praten'. Het is u wellicht opgevallen dat pin0 en pin1 naast elkaar zijn gemarkeerd als RX en TX. Deze pinnen worden feitelijk gevolgd door een afzonderlijk IC binnen Arduino, dat ze upgradet om via de USB-kabel te lezen terwijl deze op de pc is aangesloten.

Het onderstaande gedeelte toont een volwaardig programma, ga er doorheen, we zullen daarna leren over de nieuwe vermeldingen in de code. Deze code is hetzelfde als uitgedrukt in paragraaf 2.2, behalve het feit dat het wat extra gegevens bevat om ons in staat te stellen te identificeren waarvoor het is gecodeerd.

U kunt hier twee nieuwe dingen identificeren, een nieuwe regel in de opstelling() functie.

Deze regel drukt eenvoudig de noodzaak uit om de Serieel 1 code om het af te dwingen met 9600 baud. (hier verwijst serie naar stukjes achter elkaar verzonden, en baud betekent de snelheid waarmee het wordt verzonden). Deze baud-waarde en die in de seriële monitor (we zullen dit later leren) moeten gelijk zijn, anders zullen de gegevens in de seriële monitor onzin vertonen. 9600 wordt als standaard handiger in gebruik.

Het tweede nieuwe item is als volgt

Hier suggereert de tweede regel dat het volgende dat uit de seriële poort komt, op de volgende regel zal beginnen. Dat is hoe de tweede regel verschilt van de eerste regel.

Een ander ding dat u kunt zien, zijn aanhalingstekens ('). Dit staat bekend als een string, die hier alleen als constanten zal worden gebruikt, omdat verdere discussie over dit onderwerp te uitgebreid en buiten het bereik kan zijn.

OK, we kunnen nu de bovenstaande code in Arduino uploaden en kijken wat er gebeurt.

Wat, oeps, er lijkt niets gebeurd te zijn, de Arduino pin # 13 LED knipperde en stopte, terwijl de Tx LED bleef knipperen.

Nou, dat komt omdat het Serial Monitor-venster nog niet is opgelost.

U moet op het vak Serial Monitor in uw IDE klikken, zoals hierboven weergegeven. Vergeet niet om de baudrate rechtsonder te controleren, deze moet standaard 9600 zijn, en komt overeen met de code. Als dit niet het geval is, selecteer dan 9600.

De volgende videoclip legt uit hoe het moet.

https://youtu.be/ENg8CUyXm10

Laten we nu verder gaan en leren hoe de bovenstaande Serial Monitor-functie kan helpen bij het verwerken van het meting van temperatuur met Arduino

We gebruiken de IC TMP36 als temperatuursensor, met een bereik van -40 tot 150 graden Celsius.

De opstelling is hieronder te zien:

TMP36 met Arduino voor temperatuurmeting

De volgende code start de temperatuurmeting door de output van de TMP36-sensor te lezen en door ze naar de seriële monitor van de ID te sturen.

Laten we de code van bovenaf begrijpen.

Hier kun je zien dat we het type variabele hebben opgenomen vlotter.

Dit is het enige type variabele waarmee alles behalve gehele getallen (getallen zonder decimale of fractionele delen) kan worden opgeslagen.

De nauwkeurigheid van een float-variabele kan oplopen tot 6 tot 7 cijfers.

De aangrenzende code ledState is onze eigen functie die het gemeten spanningsverschil van de TMP36-sensor wiskundig berekent en omzet in graden Celsius.

In de volgende sectie van de codes, aangezien de term ledState = !ledState wordt toegewezen om een ​​getal tussen 1 en 1023 te retourneren, wordt het voor ons mogelijk om de spanning van de sensor te beoordelen door onze aflezing te vermenigvuldigen met 5 en deze vervolgens te delen door 1024.

De sensor TMP36 is gespecificeerd om een ​​0,5V te genereren bij 0 graden Celsius, en genereert vervolgens 10mV voor elke stijging in graden Celsius.

Hier is de benadering die we kunnen genereren door de berekeningen:

Arduino temperatuurkalibratie

U kunt overwegen uw eerste functie te zijn die een bepaalde waarde retourneert (merk op dat alle resterende functies tot nu toe geen waarde hebben geretourneerd, omdat ze van het type zijn leegte

U kunt begrijpen dat u, om een ​​waarde uit een functie te halen, simpelweg moet toevoegen terugkeer gevolgd door het gewenste nummer dat u wilt retourneren.

Als we zeggen terugkeer het betekent dat de functie een antwoord of een antwoord retourneert wanneer het wordt aangeroepen, wat kan worden toegepast op een variabele.

Wanneer dit naar de seriële monitor wordt gestuurd, wordt de uitlezing door middel van conversie naar Fahrenheit convertToF ().

Deze functie pikt het bereik van Celsius op en converteert het naar Fahrenheit.

Voor het omrekenen van Fahrenheit naar Celsius implementeren we de formule Fahrenheit = 9 / 5 (Celsius) + 32.

5.3 Verbinding maken met een LCD

Laten we nu eens kijken hoe we een LCD scherm met Arduino voor een visuele weergave van de vereiste uitgangen.

In onze applicatie gaan we een 84x48 grafisch LCD-scherm gebruiken, met een 84 pixel of dots horizontaal en 48 pixels verticale resolutie. Aangezien een speciale controller noodzakelijk wordt voor alle LCD's, bevat het huidige apparaat er ook een in de vorm van een PCD8544-controller.

In deze tutorial verbinden we de hierboven gespecificeerde LCD-module met Arduino en passen we bepaalde routines toe om tekstberichten op het display te creëren.

In de volgende afbeelding vindt u details over de interfacing van het LCD-scherm, samen met een klein 3.3V spanningsregelaar ​Deze regelaar is nodig omdat het LCD-scherm is gespecificeerd om te werken met een 3.3V-voeding.

U kunt ook 8 pinouts van de LCD-module zien, de pinout-specificaties kunnen worden bestudeerd uit de volgende tabel:

LCD pinout-details

Laten we nu eens kijken hoe we het LCD-scherm en de relevante parameters kunnen verbinden met onze Arduino. De details kunnen worden gevisualiseerd in de onderstaande afbeelding:

Arduino basis leren

5.4 Communiceren met het LCD-scherm

Hoewel het mogelijk is om uitgebreide coeds te schrijven voor interactie met LCD van Arduino, zullen we liever leren hoe we hetzelfde kunnen doen met behulp van bibliotheken.

Bibliotheken bevatten een assortiment codes die snel kunnen worden toegepast voor een geselecteerd Arduino-programma.

Hierdoor kan de gebruiker moeiteloos een functie aanroepen zonder ingewikkeld codeerwerk te moeten doorlopen.

5.4.1 Hoe de bibliotheek te installeren

Hiervoor moet je een map met de naam bibliotheken maken in de Arduino IDE van je computer, zoals uitgelegd hier

5.4.2 Implementatie van de LCD-bewerkingen

Net als bij onze vorige benadering, zullen we eerst de hele code uitchecken en vervolgens proberen de details van de afzonderlijke regels te begrijpen.

De regel bevat de code ledState

De code #include instrueert de pc om het genoemde bestand op te halen en het #include-element te vervangen door de bestandsinhoud tijdens het compileren van het programma.

Het element #include kan punthaken bevatten die duiden op zoeken in de bibliotheekdirectory, of het kan ook aanhalingstekens bevatten die aangeven dat wordt gezocht in dezelfde directory waarin het programma zich bevindt.

De volgende regels code drukken de LCD-pinouts uit, en dan schrijven we een nieuwe vorm van variabele:

Hier drukken we een variabele uit met de naam lcd met het type PCD8544 en instrueren we de pc om de pinouts die aan de Arduino zijn gekoppeld, opnieuw te rangschikken.

In dit proces beschrijven we de variabele naar de pc door te instrueren hoe de pin clk, din, dc en reset zijn gekoppeld aan de Arduino.

De regel ledState = !ledState initialiseert de LCD-bediening. Zodra dit is uitgevoerd, dwingt de volgende regel een cursor naar de linkerbovenhoek van het scherm. En de volgende regel doet een poging om het bericht 'Hallo wereld' af te drukken.

Dit lijkt vrij identiek aan de techniek waarmee we berichten over de seriële monitor stuurden. Het enige verschil is het gebruik van de code const int kPinLed = 13
void setup()
{
pinMode(kPinLed, OUTPUT)
}
void loop()
{
for(int i = 0 i <4 i++){
digitalWrite(kPinLed, HIGH)
delay(200)
digitalWrite(kPinLed, LOW)
delay(200)
}
delay(1000) // 1 second
}
in plaats van serial.print.

Het volgende codeblok wordt eigenlijk herhaaldelijk aangeroepen.

Met behulp van deze regel for (statement1conditionstatement2){
// statements
}
we plaatsen de cursor op de 0e kolom helemaal links van de 1e rij, boven het LCD-scherm.

De volgende regel gebruikt een snelkoppeling: const int kPinLed1 = 2
const int kPinLed2 = 3
const int kPinLed3 = 4
const int kPinLed4 = 5
void setup()
{
pinMode(kPinLed1, OUTPUT)
pinMode(kPinLed2, OUTPUT)
pinMode(kPinLed3, OUTPUT)
pinMode(kPinLed4, OUTPUT)
}
void loop()
{
// turn on each of the LEDs in order
digitalWrite(kPinLed1, HIGH)
delay(100)
digitalWrite(kPinLed2, HIGH)
delay(100)
digitalWrite(kPinLed3, HIGH)
delay(100)
digitalWrite(kPinLed4, HIGH)
delay(100)
// turn off each of the LEDs in order
digitalWrite(kPinLed1, LOW)
delay(100)
digitalWrite(kPinLed2, LOW)
delay(100)
digitalWrite(kPinLed3, LOW)
delay(100)
digitalWrite(kPinLed4, LOW)
}

Als je je herinnert dat we hebben gewerkt met const int k_numLEDs = 4
const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5
void setup()
{
for(int i = 0 i pinMode(kPinLeds[i], OUTPUT)
}
}
void loop()
{
for(int i = 0 i digitalWrite(kPinLeds[i], HIGH)
delay(100)
}
for(int i = k_numLEDs - 1 i >= 0 i--){
digitalWrite(kPinLeds[i], LOW)
delay(100)
}
}
in onze eerdere codes hadden we hetzelfde hier ook kunnen toepassen via de codes:

Omdat hier echter geen tijdsperioden in milliseconden bij betrokken zijn, bereiken we dit door simpelweg const int k_numLEDs = 4 functie rechtstreeks naar const int kPinLeds[k_numLEDs] = {2,3,4,5} // LEDs connected to pins 2-5

5.5 Het hele ding combineren

OK, laten we nu alle codes combineren die we hierboven hebben geleerd voor het maken van het LCD-temperatuurcircuit, en laten we eens kijken hoe het eruit ziet:

Alles ziet er standaard uit in het bovenstaande programma, behalve het gebruik van de functie setCursor () ​Dit wordt gebruikt om de tekst zo ver mogelijk rond het midden van het scherm uit te lijnen.

Super goed! En gefeliciteerd, je hebt zojuist je eigen kleine LCD-temperatuurindicator geprogrammeerd met Arduino.

Praktische Arduino-toepassingen

Aangezien we op dit punt de verschillende programmeertechnieken uitvoerig in detail hebben behandeld, is het tijd om ze door te nemen door ze toe te passen voor een paar nuttige praktische implementaties.

We beginnen met sensoren en zien hoe sensorapparaten kunnen worden gebruikt met Arduino door een paar voorbeeldcodes uit te voeren.

7.1 Inleiding tot sensoren

In deze tutorial zullen we leren over de grote verscheidenheid aan sensoren die met Arduino kunnen worden gebruikt. Dit kunnen apparaten zijn zoals lichtsensor LDR, magnetische hall-effectsensor, hellingsensoren, trillingssensor, druksensor enz.

We beginnen met de interfacing van lichtsensor LDR met Arduino, zoals weergegeven in het volgende diagram:

gebruik LDR met Arduino

Zoals we allemaal weten, is LDR een lichtafhankelijk weerstandsapparaat waarvan de weerstand afhangt van de intensiteit van het omgevingsinval op het oppervlak.

De intensiteit van het licht is omgekeerd evenredig met de weerstandswaarde van de LDR.

Hier zullen we leren hoe deze eigenschap kan worden geïntegreerd met Arduino voor het uitvoeren van een nuttige applicatie:

De volledige programmacode kan worden gevisualiseerd zoals hieronder weergegeven:

Alle parameters die in de code worden gebruikt, zijn al besproken in onze cursus die we tot nu toe hebben geleerd. U kunt de regels controleren door naar de relevante secties te verwijzen.

De waarden zijn willekeurig gekozen, u kunt ze gemakkelijk wijzigen volgens uw eigen voorkeuren.

Kantel sensor

Een kantelsensor is een eenvoudig apparaat dat kan worden gebruikt om een ​​kantelactie te detecteren op elk object waarop het is geïnstalleerd. Het apparaat heeft in feite een metalen bal aan de binnenkant, die bij het kantelen over een paar contacten rolt en een geleiding over die contacten veroorzaakt. Deze contacten worden afgesloten als de draden van de kantelschakelaar en worden gebruikt met een extern circuit voor het detecteren van de geleiding als gevolg van een kantelactie en het activeren van de gewenste uitgangstoepassing.

Laten we nu eens kijken hoe a kantel sensor apparaat kan worden aangesloten. Onderstaande afbeelding geeft ons een idee van de complete configuratie:

intefacing tilt sensor met Arduino

In dit voorbeeld wordt de standaard pin # 13 LED gebruikt als de kantelindicator.

Je kunt hier duidelijk de opname van de pull-up-weerstand zien, vergelijkbaar met wat we deden in paragraaf 3.1. Daarom geeft de term LAAG aan dat de kantelfunctie niet is geactiveerd.

7.4 Reed-schakelaarrelais (miniatuur magneetgeactiveerd relais)

Laten we nu eens kijken hoe we een relaisschakelaar of een magneetveldsensor kunnen aansluiten op Arduino. Een reed-relais is een soort schakelaar die activeert of geleidt wanneer een magnetisch veld of een magneet er dichtbij wordt gebracht. In feite heeft het een paar ferromagnetische contacten in een miniatuurglazen behuizing die samenkomen of contact maken als gevolg van magnetische trekkracht wanneer een magneet zich in de buurt ervan bevindt. Wanneer dit gebeurt, vertonen de aansluitingen van de contacten geleiding door het sluiten van de contacten.

Ook hier gebruiken we de pin # 13 LED voor het aangeven van de respons. U kunt desgewenst een externe LED vanaf deze pin aansluiten volgens onze eerdere uitleg.

De codetermen moeten vertrouwd en voor zichzelf spreken.

7.5 Trillingssensor met piëzo-transducer

In het volgende voorbeeldprogramma zullen we zien hoe a piëzo-transducer kan worden gebruikt als trillingssensor om een ​​LED via Arduino te verlichten.

Een piëzo-element is eigenlijk een apparaat dat trillingen of oscillaties genereert wanneer een frequentie over zijn aansluitingen wordt aangelegd. Dezelfde piëzo kan echter in het omgekeerde proces worden gebruikt voor het genereren van elektrische pulsen als reactie op trillingen die op zijn lichaam worden uitgeoefend. Deze trilling kan de vorm hebben van een slag of slag op het oppervlak van de piëzo.

Stel de Arduino en een piëzo-element in zoals weergegeven in de volgende afbeelding

piëzo gebruiken als trillingssensor met Arduino

De drempelwaarde 100 is ingevoerd om er zeker van te zijn dat de Arduino alleen reageert op de echte trillingen door kloppen, en niet op andere kleinere trillingen zoals harde geluiden of hoorns.

De selectie van de A5-pin is niet verplicht, u kunt naar eigen voorkeur andere analoge ingangen selecteren en deze in de programmacode matchen.

Servomotor gebruiken met Arduino

Een servomotor is een type gelijkstroommotor die in precieze hoeken kan worden gedraaid volgens de vraag van een bepaalde toepassing. Dit kan worden gedaan door een berekend commando toe te passen op de relevante ingangen van de motor om een ​​nauwkeurige draai- of draaihoek te produceren binnen een bereik van 180 graden op de motor.

Typisch een servomotor heeft 3 draden of ingangen. De positieve draden zijn normaal rood van kleur, de negatieve of aardedraad is zwart, waarbij de commandodraad of de signaaldraad normaal wit of geel van kleur is.

Arduino vergemakkelijkt de besturing van servomotoren door middel van een ingebouwde ondersteunende taal, wat de besturing erg handig en ideaal maakt voor servomotoren.

Het volgende voorbeeld toont ons het basisinstallatieprogramma voor het implementeren van servomotorbesturing via Arduino:

Arduino servomotorbesturing

De code wordt hieronder gegeven:

We kunnen hier een aantal nieuwe inzendingen zien. Een die de bijgevoegde draad van de servo vertelt aan welke pin deze is toegewezen. De andere is de code die de pin een waarde tussen 0 en 180 geeft, voor het bepalen van de draaihoek op de servo.

Gevolgtrekking

Het Arduino-onderwerp kan oneindig lang zijn en valt daarom buiten het bestek van dit artikel. Ik hoop echter dat de bovenstaande tutorial je zeker had moeten helpen om de basisprincipes van Arduino te leren en belangrijke parameters te begrijpen via de verschillende voorbeeldtoepassingscodes.

Hopelijk kan hier van tijd tot tijd meer informatie worden bijgewerkt, wanneer deze beschikbaar is.

Geniet ondertussen van je programmeercursus, Happy Arduinoing voor jou !!




Vorige: Alcoholdetector-metercircuit met behulp van de MQ-3-sensormodule Volgende: Cellphone Controlled Dog Feeder Circuit