Arduino datalogger: 8 stappen (met afbeeldingen)

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

In deze tutorial gaan we een eenvoudige datalogger maken met Arduino. Het punt is om de basis te leren van het gebruik van Arduino om informatie vast te leggen en af te drukken naar de terminal. We kunnen deze basisconfiguratie gebruiken om een reeks taken uit te voeren.

Starten:

Je hebt een Tinkercad (www.tinkercad.com) account nodig. Ga naar en meld u aan met uw e-mail of sociale media-account.

Als u inlogt, gaat u naar het Tinkercad-dashboard. Klik links op "Circuits" en selecteer "Create new Circuit". Laten we beginnen!

Je kunt het volledige bestand vinden op TInkercad Circuits - Bedankt voor het bekijken!

Stap 1: enkele componenten toevoegen

Je hebt een aantal basiscomponenten nodig. Waaronder:

• Arduino-bord
• Breadboard

Voeg deze toe door ernaar te zoeken en klik en sleep ze naar het middelste gebied.

Plaats het breadboard over de Arduino. Het maakt het gemakkelijker om de verbindingen later te bekijken.

Stap 2: Een opmerking over breadboards

Een breadboard is een super handig apparaat voor rapid prototyping. We gebruiken het om componenten aan te sluiten. Enkele dingen om op te merken.

1. De punten zijn verticaal verbonden, maar de lijn in het midden scheidt deze verbinding van de bovenste en onderste kolommen.
2. Kolommen zijn niet van links naar rechts verbonden, zoals in de rij. Dit betekent dat alle componenten over de kolommen moeten worden aangesloten in plaats van verticaal naar beneden.
3. Als je knoppen of schakelaars moet gebruiken, sluit ze dan aan op de pauze in het midden. We zullen dit in een latere tutorial bezoeken.

Stap 3: Voeg twee sensoren toe

De twee sensoren die we gebruiken zijn een lichtgevoelige sensor en temperatuursensor.

Deze sensoren evalueren licht en temperatuur. We gebruiken Arduino om de waarde te lezen en weer te geven in de seriële monitor op de Arduino.

Zoek naar de twee sensoren en voeg ze toe. Zorg ervoor dat ze over de kolommen op het breadboard zijn geplaatst. Zorg ervoor dat er voldoende ruimte tussen hen is om ze gemakkelijker te kunnen zien.

Stap 4: Lichtgevoelige sensor

1. Voeg voor de lichtgevoelige sensor een draad toe van de 5V-pin op de Arduino naar dezelfde kolom als het rechterbeen op het onderdeel in het breadboard. Verander de draadkleur in rood.
2. Verbind het linkerbeen via de pin in dezelfde kolom met de A0 (A-zero) pin op de Arduino. Dit is de analoge pin, die we zullen gebruiken om de waarde van de sensor af te lezen. Kleur deze draad geel of iets anders dan rood of zwart.

3. Plaats een weerstand (zoek en klik-sleep) op het bord. Dit voltooit het circuit en beschermt de sensor en pin.

   • Draai het om zodat het over de kolommen gaat.
   • Verbind een been met de rechter beenkolom op het breadboard

   • Plaats een draad van het andere uiteinde van de weerstand naar de grond

     Verander de draadkleur in zwart

4. Controleer alle verbindingen dubbel. Als er iets niet op de goede plek staat, werkt dit niet goed.

Stap 5: Start de code

Laten we eens kijken naar de code voor dit onderdeel.

Kijk eerst naar de derde afbeelding in deze stap. Het bevat een code met twee functies:

ongeldige setup()

lege lus()

In C++ geven alle functies hun retourtype, dan de naam, dan de twee ronde accolades die kunnen worden gebruikt om argumenten door te geven, meestal als variabelen. In dit geval is het retourtype void of niets. De naam is ingesteld en de functie heeft geen argumenten.

De setup-functie wordt één keer uitgevoerd wanneer Arduino opstart (wanneer u hem aansluit of batterijen bevestigt).

De lusfunctie loopt in een constante lus vanaf de milliseconde die de instellingsfunctie voltooit.

Alles wat u in de loop-functie plaatst, wordt uitgevoerd wanneer Arduino wordt uitgevoerd. Alles daarbuiten dat alleen werkt als er wordt gebeld. Alsof we een andere functie buiten de lus hebben gedefinieerd en aangeroepen.

Taak

Open het codepaneel met de knop in Tinkercad. Wijzig de vervolgkeuzelijst Blokken in Tekst. Ga akkoord met het waarschuwingsvenster dat verschijnt. Verwijder nu alles wat u ziet, behalve de tekst in de derde afbeelding in deze stap.

Variabelen

Om te beginnen, moeten we enkele variabelen toewijzen, zodat we onze code echt efficiënt maken.

Variabelen zijn als emmers die maar één object kunnen bevatten (C++ is wat we objectgeoriënteerd noemen). Ja, we hebben arrays, maar dit zijn speciale variabelen en we zullen er later over praten. Wanneer we een variabele toewijzen, moeten we hem vertellen welk type het is, en hem dan een waarde geven. Het ziet er zo uit:

int eenVar = A0;

We hebben dus een variabele toegewezen en deze het type int gegeven. Een int is een geheel getal of een geheel getal.

"Maar je hebt geen geheel getal gebruikt!", hoor ik je zeggen. Dat is waar.

Arduino doet iets speciaals voor ons, zodat we A0 als een geheel getal kunnen gebruiken, omdat het in een ander bestand A0 als een geheel getal definieert, dus we kunnen de constante A0 gebruiken om naar dit geheel getal te verwijzen zonder dat we hoeven te weten wat het is. Als we zojuist 0 hadden getypt, zouden we verwijzen naar de digitale pin op positie 0, wat niet zou werken.

Dus voor onze code zullen we een variabele schrijven voor de sensor die we hebben bijgevoegd. Hoewel ik aanraad om het een eenvoudige naam te geven, is dat aan jou.

Uw code zou er als volgt uit moeten zien:

int lichtSensor = A0;

void setup() { } void loop() { }

Laten we Arduino nu vertellen hoe de sensor op die pin moet worden gebruikt. We zullen een functie in de setup uitvoeren om de pin-modus in te stellen en Arduino te vertellen waar hij moet zoeken.

int lichtSensor = A0;

void setup () { pinMode (lichtsensor, INPUT); } lege lus() { }

de pinMode-functie vertelt Arduino dat de pin (A0) zal worden gebruikt als een INPUT-pin. Let op de camelCaseUsed (zie elke eerste letter is een hoofdletter, omdat er bulten in staan, vandaar… camel…!) voor de variabelen en functienamen. Dit is een conventie en goed om aan te wennen.

Laten we tot slot de functie analogRead gebruiken om wat gegevens op te halen.

int lichtSensor = A0;

void setup () { pinMode (lichtsensor, INPUT); } void loop () {int lezen = analogRead (lightSensor); }

U zult zien dat we de meting in een variabele hebben opgeslagen. Dit is belangrijk omdat we het moeten afdrukken. Laten we de seriële bibliotheek gebruiken (een bibliotheek is code die we aan onze code kunnen toevoegen om dingen sneller voor ons te schrijven, gewoon door het per definitie te noemen) om dit naar de seriële monitor af te drukken.

int lichtSensor = A0;

void setup () {// Stel pin-modi in pinMode (lightSensor, INPUT); // Voeg de seriële bibliotheek Serial.begin (9600) toe; } void loop () {// Lees de sensor int lezen = analogRead (lightSensor); // Druk de waarde af op de monitor Serial.print ("Light: "); Serial.println (lezen); // vertraag de volgende lus met 3 seconden vertraging (3000); }

Een paar nieuwe dingen! Eerst zie je deze:

// Dit is een reactie

We gebruiken opmerkingen om andere mensen te vertellen wat onze code doet. Deze moet je vaak gebruiken. De compiler leest deze niet en zet ze om in code.

Nu hebben we ook de seriële bibliotheek toegevoegd met de regel

Serieel.begin(9600)

Dit is een voorbeeld van een functie waaraan een argument moet doorgegeven worden. U noemde de bibliotheek Serial en voerde vervolgens een functie uit (we weten dat het een functie is vanwege de ronde accolades) en gaf een geheel getal als argument door, waardoor de seriële functie werd ingesteld op 9600baud. Maak je geen zorgen waarom - weet gewoon dat het werkt, voor nu.

Het volgende dat we deden was afdrukken naar de seriële monitor. We gebruikten twee functies:

// Deze print naar de serie zonder regeleinde (een enter aan het einde)

Serial.print("Licht: "); // Deze plaatst het regeleinde, dus elke keer dat we lezen en schrijven, gaat het op een nieuwe regel Serial.println (lezen);

Wat belangrijk is om te zien, is dat elk een afzonderlijk doel heeft. Zorg ervoor dat uw strings dubbele aanhalingstekens gebruiken en dat u de spatie na de dubbele punt laat. Dat komt de leesbaarheid ten goede voor de gebruiker.

Ten slotte hebben we de vertragingsfunctie gebruikt om onze lus te vertragen en deze slechts één keer per drie seconden te laten lezen. Dit is geschreven in duizenden van een seconde. Wijzig het om slechts één keer per 5 seconden te lezen.

Super goed! Op we gaan!

Stap 6: Simulatie

Controleer altijd of alles werkt door de simulatie uit te voeren. Voor dit circuit moet u ook de simulator openen om te controleren of deze werkt en uw waarden te controleren.

Start de simulatie en controleer de seriële monitor. Wijzig de waarde van de lichtsensor door erop te klikken en de waarde te wijzigen met de schuifregelaar. U zou de waardeverandering ook in de seriële monitor moeten zien. Als dit niet het geval is, of als u fouten krijgt wanneer u op de knop Simulatie starten drukt, ga dan voorzichtig terug en controleer al uw code.

• Focus op de lijnen die worden aangegeven in het rode foutopsporingsvenster dat aan u wordt gepresenteerd.
• Als uw code juist is en de simulatie werkt nog steeds niet, controleer dan uw bedrading.
• Laad de pagina opnieuw - u heeft mogelijk een niet-gerelateerde systeem-/serverfout.
• Schud je vuist tegen de computer en controleer opnieuw. Alle programmeurs doen dit. Alle. De. Tijd.

Stap 7: Sluit de temperatuursensor aan

Ik ga ervan uit dat je nu op de goede weg bent. Ga je gang en sluit de temperatuursensor aan zoals de afbeelding suggereert. Let op de plaatsing van de 5V- en GND-draden in dezelfde ruimte als die voor het licht. Dit is oke. Het is als een parallelle schakeling en veroorzaakt geen problemen in de simulator. In een echt circuit moet u een breakout-bord of schild gebruiken voor een beter energiebeheer en betere verbindingen.

Laten we nu de code bijwerken.

De temperatuursensorcode:

Dit is een beetje lastiger, maar alleen omdat we wat wiskunde moeten doen om de meting om te zetten. Het valt wel mee.

int lichtSensor = A0;

int tempSensor = A1; void setup () {// Stel pin-modi in pinMode (lightSensor, INPUT); // Voeg de seriële bibliotheek Serial.begin (9600) toe; } void loop() { // De temperatuursensor // Twee variabelen op één regel maken - oh efficiëntie! // Float var om een decimale float-spanning, graden C, op te slaan; // Lees de waarde van de pin en converteer deze naar een waarde van 0 - 5 // In wezen spanning = (5/1023 = 0,004882814); spanning = (analogRead (tempSensor) * 0.004882814); // Converteren naar graden C gradenC = (spanning - 0,5) * 100; // Afdrukken naar de seriële monitor Serial.print ("Temp: "); Serial.print(gradenC); Serial.println("oC"); // Lees de sensor int lezen = analogRead (lightSensor); // Druk de waarde af op de monitor Serial.print ("Light: "); Serial.println (lezen); // vertraag de volgende lus met 3 seconden vertraging (3000); }

Ik heb enkele updates in de code gemaakt. Laten we ze afzonderlijk doornemen.

Eerst heb ik de regel toegevoegd

int tempSensor = A1;

Net als de lightSensor moet ik de waarde in een variabele opslaan om het later gemakkelijker te maken. Als ik de locatie van deze sensor zou moeten wijzigen (zoals het opnieuw bedraden van het bord), hoef ik alleen de ene regel code te wijzigen, niet door de hele codebase te zoeken om de A0 of A1 te wijzigen, enz.

Vervolgens hebben we een regel toegevoegd om de meting en de temperatuur in een float op te slaan. Noteer twee variabelen op één regel.

vlotterspanning, gradenC;

Dit is erg handig omdat het het aantal regels dat ik moet schrijven, vermindert en de code versnelt. Het kan echter moeilijker zijn om fouten te vinden.

Nu gaan we de meting doen en opslaan, en vervolgens converteren naar onze uitvoerwaarde.

spanning = (analogRead (tempSensor) * 0.004882814);

gradenC = (spanning - 0,5) * 100;

Die twee regels zien er moeilijk uit, maar in de eerste nemen we de uitlezing en vermenigvuldigen deze met 0,004 … omdat het 1023 omzet (de analoge uitlezing geeft deze waarde terug) in een uitlezing van 5.

De tweede regel daar vermenigvuldigt die waarde met 100 om de komma te verplaatsen. Dat geeft ons de temperatuur. Netjes!

Stap 8: Testen en controleren

Alle dingen gaan volgens plan, je zou een werkend circuit moeten hebben. Test door de simulatie uit te voeren en de seriële monitor te gebruiken. Als je fouten hebt, controleer, controleer opnieuw en schud je vuist.

Heb je het gehaald? Deel en vertel ons jouw verhaal!

Dit is het laatste circuit dat voor u is ingebed, zodat u de uiteindelijke creatie kunt spelen/testen. Bedankt voor het voltooien van de tutorial!