Arduino Datalogger: 8 stappe (met foto's)

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:26

In hierdie handleiding gaan ons 'n eenvoudige datalogger maak met behulp van Arduino. Die punt is om die basiese beginsels van die gebruik van Arduino te leer om inligting op te vang en na die terminale af te druk. Ons kan hierdie basiese opstelling gebruik om 'n reeks take te voltooi.

Om te begin:

U benodig 'n Tinkercad -rekening (www.tinkercad.com). Gaan oor en meld aan met u e -pos of sosiale media -rekening.

As u aanmeld, word u na die Tinkercad Dashboard geneem. Klik op "Kringe" links en kies "Skep nuwe stroombaan". Laat ons begin!

U kan die volledige lêer op TInkercad Circuits vind - dankie dat u dit nagegaan het!

Stap 1: Voeg 'n paar komponente by

U benodig 'n paar basiese komponente. Dit sluit in:

• Arduino bord
• Broodbord

Voeg dit by deur dit te soek en te sleep en na die middelste gebied te sleep.

Plaas die broodbord oor die Arduino. Dit maak dit makliker om die verbindings later te sien.

Stap 2: 'n Opmerking oor broodborde

'N Broodplank is 'n uitstekende hulpmiddel vir vinnige prototipering. Ons gebruik dit om komponente aan te sluit. 'N Paar dinge om op te let.

1. Die kolletjies word vertikaal verbind, maar die lyn in die middel skei hierdie verbinding van die boonste en onderste kolom.
2. Kolomme word nie van links na regs verbind nie, soos in die ry. Dit beteken dat alle komponente oor die kolomme gekoppel moet wees eerder as om dit vertikaal af te laai.
3. As u knoppies of skakelaars moet gebruik, koppel dit dan in die middel van die breek. Ons sal dit in 'n latere tutoriaal besoek.

Stap 3: Voeg twee sensors by

Die twee sensors wat ons gebruik, is 'n fotosensitiewe sensor en temperatuursensor.

Hierdie sensors evalueer lig en temperatuur. Ons gebruik Arduino om die waarde te lees en dit in die seriële monitor op die Arduino te vertoon.

Soek en voeg die twee sensors by. Maak seker dat hulle oor die kolomme op die broodbord geplaas is. Plaas genoeg spasie tussen hulle sodat dit makliker is om dit te sien.

Stap 4: Fotosensitiewe sensor

1. Vir die fotosensitiewe sensor, voeg 'n draad van die 5V -pen op die Arduino by dieselfde kolom as die regterbeen op die deel in die broodbord. Verander die draadkleur na rooi.
2. Verbind die linkerbeen via die pen in dieselfde kolom met die A0 (A-zero) pen op die Arduino. Dit is die analoog pen, wat ons sal gebruik om die waarde van die sensor te lees. Kleur hierdie draad geel of iets anders as rooi of swart.

3. Plaas 'n weerstand (soek en klik-sleep) op die bord. Dit voltooi die kring en beskerm die sensor en pen.

   • Draai dit om sodat dit oor die kolomme gaan.
   • Koppel een been aan die regterbeenskolom op die broodbord

   • Plaas 'n draad van die ander kant van die weerstand na die grond

     Verander die draadkleur na swart

4. Kontroleer alle verbindings dubbel. As iets nie op die regte plek is nie, werk dit nie reg nie.

Stap 5: Begin die kode

Kom ons kyk na die kode vir hierdie komponent.

Kyk eers na die derde beeld in hierdie stap. Dit bevat 'n kode met twee funksies:

leemte opstelling ()

leemte lus ()

In C ++ bied alle funksies hul terugvoertipe, dan die naam, dan die twee ronde hakies wat gebruik kan word om in argumente deur te gee, gewoonlik as veranderlikes. In hierdie geval is die terugvoertipe ongeldig, of niks. Die naam is opgestel en die funksie neem geen argumente nie.

Die opstelfunksie werk een keer wanneer Arduino opstart (as u dit aansluit of batterye aanbring).

Die lusfunksie loop in 'n konstante lus vanaf die millisekonde wat die opstelfunksie voltooi.

Alles wat u in die lusfunksie plaas, loop wanneer Arduino werk. Alles buite dit sal slegs werk as dit geroep word. Soos as ons 'n ander funksie buite die lus definieer en noem.

Taak

Maak die kodepaneel oop met die knoppie in Tinkercad. Verander die keuselys Blokke in teks. Stem in met die waarskuwingsblokkie wat verskyn. Verwyder nou alles wat u sien, behalwe die teks in die derde prent in hierdie stap.

Veranderlikes

Om aan die gang te kom, moet ons 'n paar veranderlikes toewys sodat ons ons kode regtig doeltreffend kan maak.

Veranderlikes is soos emmers wat slegs een voorwerp kan bevat (C ++ is wat ons objekgeoriënteerd noem). Ja, ons het skikkings, maar dit is spesiale veranderlikes en ons sal later daaroor praat. As ons 'n veranderlike toewys, moet ons dit vertel watter tipe dit is en dit dan 'n waarde gee. Dit lyk so:

int someVar = A0;

Ons het dus 'n veranderlike toegewys en die tipe int gegee. 'N Int is 'n heelgetal of 'n heelgetal.

'Maar u het nie 'n heelgetal gebruik nie!', Hoor ek u sê. Dis waar.

Arduino doen iets spesiaals vir ons, sodat ons A0 as 'n heelgetal kan gebruik, want in 'n ander lêer definieer dit A0 as 'n heelgetal, sodat ons die A0 -konstante kan gebruik om na hierdie heelgetal te verwys sonder om te weet wat dit is. As ons net 0 tik, verwys ons na die digitale pen op posisie 0, wat nie sou werk nie.

Dus, vir ons kode, skryf ons 'n veranderlike vir die sensor wat ons aangeheg het. Alhoewel ek aanbeveel om dit 'n eenvoudige naam te gee, is dit aan u.

Jou kode moet so lyk:

int lightSensor = A0;

leemte -opstelling () {} leemte -lus () {}

Laat ons nou vir Arduino vertel hoe om die sensor op die pen te hanteer. Ons sal 'n funksie in die opstelling uitvoer om die pin -modus in te stel en vir Arduino sê waar om dit te soek.

int lightSensor = A0;

ongeldige opstelling () {pinMode (lightSensor, INPUT); } leemte lus () {}

die pinMode -funksie vertel Arduino dat die pen (A0) as 'n INPUT -pen gebruik sal word. Let op die camelCaseUsed (sien elke eerste letter is 'n hoofletter, aangesien dit bultjies het, vandaar … kameel …!) Vir die veranderlikes en funksiename. Dit is 'n konvensie en goed om aan gewoond te raak.

Laastens, laat ons die analogRead -funksie gebruik om data te kry.

int lightSensor = A0;

ongeldige opstelling () {pinMode (lightSensor, INPUT); } leemte lus () {int lees = analogRead (lightSensor); }

U sal sien dat ons die lesing in 'n veranderlike gestoor het. Dit is belangrik, aangesien ons dit moet druk. Kom ons gebruik die seriële biblioteek ('n biblioteek is 'n kode wat ons by ons kode kan voeg om dinge vinniger te maak om te skryf, net deur dit volgens die definisie daarvan te noem) om dit op die seriële monitor te druk.

int lightSensor = A0;

ongeldige opstelling () {// Stel penmodusse in pinMode (lightSensor, INPUT); // Voeg die reeksbiblioteek Serial.begin (9600) by; } leemte -lus () {// Lees die sensor int reading = analogRead (lightSensor); // Druk die waarde af op die monitor Serial.print ("Light:"); Serial.println (lees); // vertraag die volgende lus met 3 sekondes vertraging (3000); }

'N Paar nuwe dinge! Eerstens sien jy hierdie:

// Dit is 'n opmerking

Ons gebruik opmerkings om ander mense te vertel wat ons kode doen. U moet dit gereeld gebruik. Die samesteller sal dit nie lees nie en dit in kode omskakel.

Nou het ons ook die reeksbiblioteek met die reël bygevoeg

Reeks.begin (9600)

Dit is 'n voorbeeld van 'n funksie wat 'n argument neem. U het die biblioteek Serial genoem, en dan 'n funksie uitgevoer (ons weet dat dit 'n funksie is as gevolg van die ronde hakies) en 'n heelgetal as 'n argument deurgegee, wat die seriële funksie op 9600baud stel. Moenie bekommerd wees nie, maar weet dit werk vir eers.

Die volgende ding wat ons gedoen het, was om na die seriële monitor te druk. Ons het twee funksies gebruik:

// Hierdie een druk op die reeks sonder reëlonderbreking ('n invoer aan die einde)

Serial.print ("Lig:"); // Hierdie een plaas die reëlbreuk, so elke keer as ons lees en skryf, gaan dit op 'n nuwe reël Serial.println (lees);

Wat belangrik is om te sien, is dat elkeen 'n aparte doel het. Maak seker dat u snare dubbele aanhalingstekens gebruik en dat u die spasie na die dubbelpunt verlaat. Dit help leesbaarheid vir die gebruiker.

Uiteindelik het ons die vertragingsfunksie gebruik om ons lus te vertraag en dit slegs elke drie sekondes te laat lees. Dit word in duisende sekondes geskryf. Verander dit om slegs elke 5 sekondes te lees.

Puik! Ons gaan!

Stap 6: Simulasie

Kyk altyd of dinge werk deur die simulasie uit te voer. Vir hierdie kring moet u ook die simulator oopmaak om te kontroleer of dit werk en u waardes nagaan.

Begin die simulasie en kyk na die seriële monitor. Verander die waarde van die ligsensor deur daarop te klik en die waarde met die skuifknop te verander. U moet ook die waardeverandering in die seriële monitor sien. As dit nie die geval is nie, of as u op die Start Simulation -knoppie druk, kry u foute, gaan dan sorgvuldig terug en kontroleer al u kode.

• Konsentreer op die lyne wat in die rooi ontfoutingsvenster aangedui word.
• Kontroleer u bedrading as u kode reg is en die simulasie steeds nie werk nie.
• Herlaai die bladsy - daar is moontlik 'n onverwante stelsel-/bedienerfout.
• Skud jou vuis na die rekenaar en kyk weer. Alle programmeerders doen dit. Almal. Die. Tyd.

Stap 7: Draai die tempsensor op

Ek gaan nou aanneem dat u op die regte pad is. Draai die temperatuursensor op soos die prentjie voorstel. Let op die plasing van die 5V- en GND -drade in dieselfde ruimte as die vir die lig. Dit is ok. Dit is soos 'n parallelle stroombaan en veroorsaak nie probleme in die simulator nie. In 'n werklike stroombaan moet u 'n uitbreekbord of skild gebruik om beter kragbestuur en verbindings te bied.

Laat ons nou die kode opdateer.

Die temp sensor kode

Dit is 'n bietjie meer ingewikkeld, maar net omdat ons wiskunde moet doen om die lesing om te skakel. Dit is nie te erg nie.

int lightSensor = A0;

int tempSensor = A1; ongeldige opstelling () {// Stel penmodusse in pinMode (lightSensor, INPUT); // Voeg die reeksbiblioteek Serial.begin (9600) by; } leemte -lus () {// Die tempsensor // Skep twee veranderlikes op een reël - o doeltreffendheid! // Float var om 'n desimale vlotspanning, gradeC; // Lees die waarde van die pen en omskep dit in 'n lesing van 0 - 5 // In wese spanning = (5/1023 = 0.004882814); spanning = (analogRead (tempSensor) * 0.004882814); // Skakel om na grade C grade C = (spanning - 0,5) * 100; // Druk op die seriële monitor Serial.print ("Temp:"); Reeks.afdruk (gradeC); Serial.println ("oC"); // Lees die sensor int reading = analogRead (lightSensor); // Druk die waarde af op die monitor Serial.print ("Light:"); Serial.println (lees); // vertraag die volgende lus met 3 sekondes vertraging (3000); }

Ek het 'n paar opdaterings aan die kode aangebring. Kom ons loop individueel deur hulle.

Eerstens het ek die reël bygevoeg

int tempSensor = A1;

Net soos die lightSensor, moet ek die waarde in 'n veranderlike stoor om dit later makliker te maak. As ek die ligging van hierdie sensor moes verander (soos om die bord weer te bedraad), hoef ek net die een reël kode te verander, nie deur die hele kodebasis te soek om die A0 of A1, ens.

Toe voeg ons 'n reël by om die lesing en die temperatuur in 'n vlot te stoor. Let op twee veranderlikes op een reël.

dryfspanning, gradeC;

Dit is baie nuttig omdat dit die aantal reëls wat ek moet skryf, verminder en die kode bespoedig. Dit kan egter moeiliker wees om foute op te spoor.

Nou sal ons die lesing doen en dit stoor, en dit dan omskakel na ons uitvoerwaarde.

spanning = (analogRead (tempSensor) * 0.004882814);

grade C = (spanning - 0,5) * 100;

Die twee reëls lyk moeilik, maar in die eerste neem ons die lesing en vermenigvuldig dit met 0,004 … omdat dit 1023 (die analooglesing gee hierdie waarde terug) in 'n lesing uit 5.

Die tweede reël daar vermenigvuldig die lesing met 100 om die desimale punt te skuif. Dit gee ons die temperatuur. Netjies!

Stap 8: Toets en kontroleer

As u alles beplan, moet u 'n werkende kring hê. Toets deur die simulasie uit te voer en die seriële monitor te gebruik. As u foute ondervind, kyk, kyk weer en skud u vuis.

Het jy dit reggekry? Deel en vertel ons jou storie!

Dit is die finale kring wat vir u ingebed is, sodat u die finale skepping kan speel/toets. Dankie dat u die tutoriaal voltooi het!