Arduino Datalogger: 8 steg (med bilder)

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:45

I den här självstudien ska vi göra en enkel datalogger med Arduino. Poängen är att lära sig själva grunderna för att använda Arduino för att fånga information och skriva ut till terminalen. Vi kan använda denna grundläggande installation för att slutföra en rad uppgifter.

För att starta:

Du behöver ett Tinkercad -konto (www.tinkercad.com). Gå över och registrera dig med ditt e -post- eller sociala mediekonto.

Om du loggar in tar du dig till Tinkercad Dashboard. Klicka på "Kretsar" till vänster och välj "Skapa ny krets". Låt oss börja!

Du hittar hela filen på TInkercad Circuits - Tack för att du kollade in den!

Steg 1: Lägg till några komponenter

Du behöver några grundläggande komponenter. Dessa inkluderar:

• Arduino -bräda
• Bakbord

Lägg till dem genom att söka efter dem och klicka och dra dem till mittområdet.

Placera brödbrädan över Arduino. Det gör det lättare att se anslutningarna senare.

Steg 2: En anmärkning om brödbrädor

En brödbräda är en superhjälpsam enhet för snabba prototyper. Vi använder den för att ansluta komponenter. Några saker att notera.

1. Prickarna är anslutna vertikalt, men linjen i mitten skiljer denna anslutning från de övre och nedre kolumnerna.
2. Kolumner är inte anslutna från vänster till höger, som i tvärs över raden. Detta innebär att alla komponenter ska vara anslutna över kolumnerna snarare än nedåt dem vertikalt.
3. Om du behöver använda knappar eller omkopplare, anslut dem över rasten i mitten. Vi besöker detta i en senare handledning.

Steg 3: Lägg till två sensorer

De två sensorerna vi använder är en ljuskänslig sensor och temperatursensor.

Dessa sensorer utvärderar ljus och temperatur. Vi använder Arduino för att läsa värdet och visa det i den seriella bildskärmen på Arduino.

Sök efter och lägg till de två sensorerna. Se till att de är placerade tvärs över kolumnerna på panelen. Lägg tillräckligt med utrymme mellan dem för att göra det lättare att se dem.

Steg 4: Fotokänslig sensor

1. För den ljuskänsliga sensorn, lägg till en kabel från 5V -stiftet på Arduino till samma kolumn som det högra benet på delen i brödbrädan. Ändra trådfärgen till röd.
2. Anslut vänster ben via stiftet i samma kolumn till A0 (A-noll) stift på Arduino. Detta är den analoga stiftet, som vi kommer att använda för att läsa värdet från sensorn. Färg denna tråd gul eller något annat än rött eller svart.

3. Placera ett motstånd (sök och klicka-dra) på tavlan. Detta slutför kretsen och skyddar sensorn och stiftet.

   • Vänd den så att den går över kolumnerna.
   • Anslut ett ben till höger benkolumn på panelen

   • Placera en tråd från den andra änden av motståndet till marken

     Ändra trådfärgen till svart

4. Dubbelkolla alla anslutningar. Om något inte är på rätt plats fungerar det inte korrekt.

Steg 5: Starta koden

Låt oss titta på koden för denna komponent.

Titta först på den tredje bilden i detta steg. Den innehåller lite kod med två funktioner:

void setup ()

void loop ()

I C ++ tillhandahåller alla funktioner sin returtyp, sedan namnet, sedan de två runda hängslen som kan användas för att skicka in argument, vanligtvis som variabler. I det här fallet är returtypen ogiltig eller ingenting. Namnet är inställt och funktionen tar inga argument.

Installationsfunktionen körs en gång när Arduino startar (när du sätter i den eller sätter i batterier).

Slingfunktionen körs i en konstant slinga från den millisekund som installationsfunktionen slutför.

Allt du lägger i loop -funktionen körs när Arduino körs. Allt utanför som bara körs när det kallas. Som om vi definierade och kallade en annan funktion utanför slingan.

Uppgift

Öppna kodpanelen med knappen i Tinkercad. Ändra rullgardinsmenyn Block till Text. Godkänn varningsrutan som dyker upp. Ta nu bort allt du ser utom texten i den tredje bilden i det här steget.

Variabler

För att komma igång måste vi tilldela några variabler så att vi gör vår kod riktigt effektiv.

Variabler är som skopor som bara kan rymma ett objekt (C ++ är vad vi kallar objektorienterade). Ja, vi har matriser, men det här är speciella variabler och vi kommer att prata om dem senare. När vi tilldelar en variabel måste vi berätta vilken typ det är och sedan ge den ett värde. Det ser ut så här:

int someVar = A0;

Så vi tilldelade en variabel och gav den typ int. Ett int är ett heltal eller ett heltal.

"Men du använde inte ett helt tal!", Hör jag dig säga. Det är sant.

Arduino gör något speciellt för oss så att vi kan använda A0 som ett heltal, eftersom det i en annan fil definierar A0 som ett heltal, så vi kan använda A0 -konstanten för att hänvisa till detta heltal utan att behöva veta vad det är. Om vi bara skrev 0 skulle vi hänvisa till den digitala stiftet i position 0, vilket inte skulle fungera.

Så för vår kod kommer vi att skriva en variabel för sensorn vi har kopplat. Medan jag rekommenderar att ge det ett enkelt namn, är det upp till dig.

Din kod ska se ut så här:

int lightSensor = A0;

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

Låt oss nu berätta för Arduino hur man hanterar sensorn på den stiftet. Vi kör en funktion i installationen för att ställa in stiftläget och berätta för Arduino var du ska leta efter det.

int lightSensor = A0;

void setup () {pinMode (lightSensor, INPUT); } void loop () {}

pinMode -funktionen berättar för Arduino att stiftet (A0) kommer att användas som en INPUT -stift. Notera camelCaseUsed (se varje första bokstav är en versal, eftersom den har pucklar, därav … kamel …!) För variablerna och funktionsnamnen. Detta är en konvention och bra att vänja sig vid.

Slutligen, låt oss använda analogRead -funktionen för att få lite data.

int lightSensor = A0;

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

Du ser att vi lagrade avläsningen i en variabel. Detta är viktigt eftersom vi behöver skriva ut det. Låt oss använda det seriella biblioteket (ett bibliotek är kod som vi kan lägga till i vår kod för att göra saker snabbare för oss att skriva, bara genom att kalla det enligt dess definition) för att skriva ut detta till den seriella bildskärmen.

int lightSensor = A0;

void setup () {// Ange pin -lägen pinMode (lightSensor, INPUT); // Lägg till seriebiblioteket Serial.begin (9600); } void loop () {// Läs sensorn int läsning = analogRead (lightSensor); // Skriv ut värdet till bildskärmen Serial.print ("Light:"); Serial.println (läsning); // fördröja nästa slinga med 3 sekunders fördröjning (3000); }

Några nya saker! Först ser du dessa:

// Detta är en kommentar

Vi använder kommentarer för att berätta för andra människor vad vår kod gör. Du bör använda dessa ofta. Kompilatorn läser inte dessa och konverterar dem till kod.

Nu har vi också lagt till det seriella biblioteket med raden

Serial.begin (9600)

Detta är ett exempel på en funktion som tar ett argument. Du kallade biblioteket Serial och körde sedan en funktion (vi vet att det är en funktion på grund av de runda hängslen) och skickade in ett heltal som ett argument och ställde in Serial -funktionen på 9600baud. Oroa dig inte varför - bara vet att det fungerar, för nu.

Nästa sak vi gjorde var att skriva ut till den seriella bildskärmen. Vi använde två funktioner:

// Den här skriver ut till serien utan radbrytning (en enter i slutet)

Serial.print ("Light:"); // Den här sätter in radbrytningen så varje gång vi läser och skriver går den på en ny rad Serial.println (läsning);

Vad som är viktigt att se är att var och en har ett separat syfte. Se till att dina strängar använder dubbla citattecken och att du lämnar utrymmet efter kolon. Det hjälper läsbarheten för användaren.

Slutligen använde vi fördröjningsfunktionen för att bromsa slingan och få den att bara läsas var tredje sekund. Detta skrivs i tusentals sekunder. Ändra den till att bara läsa var 5: e sekund.

Bra! Vi går!

Steg 6: Simulering

Kontrollera alltid att saker fungerar genom att köra simuleringen. För den här kretsen måste du också öppna simulatorn för att kontrollera att den fungerar och kontrollera dina värden.

Starta simuleringen och kontrollera den seriella bildskärmen. Ändra värdet på ljussensorn genom att klicka på den och ändra värdet med reglaget. Du bör också se värdeförändringen i den seriella bildskärmen. Om det inte gör det, eller om du får fel när du trycker på knappen Starta simulering, gå försiktigt tillbaka och kontrollera all din kod.

• Fokusera på de linjer som anges i det röda felsökningsfönstret som kommer att presenteras för dig.
• Om din kod är rätt och simuleringen fortfarande inte fungerar, kontrollera din ledning.
• Ladda om sidan - du kan ha ett system som inte är relaterat till systemet/servern.
• Skaka näven mot datorn och kontrollera igen. Alla programmerare gör detta. Allt. De. Tid.

Steg 7: Anslut tempsensorn

Jag antar att du är på rätt väg nu. Fortsätt och koppla upp temperatursensorn som bilden föreslår. Observera placeringen av 5V- och GND -trådarna i samma utrymme som de för ljuset. Det här är ok. Det är som en parallell krets och kommer inte att orsaka problem i simulatorn. I en faktisk krets bör du använda en brytskiva eller skärm för att ge bättre strömhantering och anslutningar.

Låt oss nu uppdatera koden.

Tempsensorkoden

Det här är lite mer knepigt, men bara för att vi måste räkna lite för att konvertera avläsningen. Det är inte så illa.

int lightSensor = A0;

int tempSensor = A1; void setup () {// Ange pin -lägen pinMode (lightSensor, INPUT); // Lägg till seriebiblioteket Serial.begin (9600); } void loop () {// Temp sensor // Skapa två variabler på en rad - oh effektivitet! // Float var för att lagra en decimal flottörspänning, graderC; // Läs värdet på stiftet och konvertera det till en avläsning från 0 - 5 // I huvudsak spänning = (5/1023 = 0,004882814); spänning = (analogRead (tempSensor) * 0,004882814); // Konvertera till grader C graderC = (spänning - 0,5) * 100; // Skriv ut till seriell bildskärm Serial.print ("Temp:"); Serial.print (graderC); Serial.println ("oC"); // Läs sensorn int läsning = analogRead (lightSensor); // Skriv ut värdet till bildskärmen Serial.print ("Light:"); Serial.println (läsning); // fördröja nästa slinga med 3 sekunders fördröjning (3000); }

Jag har gjort några uppdateringar av koden. Låt oss gå igenom dem individuellt.

Först lade jag till raden

int tempSensor = A1;

Precis som lightSensor måste jag lagra värdet i en variabel för att göra det lättare senare. Om jag var tvungen att ändra platsen för den här sensorn (som att koppla om kortet) behöver jag bara ändra en kodrad, inte söka igenom hela kodbasen för att ändra A0 eller A1, etc.

Sedan lade vi till en rad för att lagra avläsningen och tempen i en flottör. Notera två variabler på en rad.

flottörspänning, graderC;

Detta är verkligen användbart eftersom det minskar antalet rader jag måste skriva och påskyndar koden. Det kan dock vara svårare att hitta fel.

Nu ska vi läsa och lagra det och sedan konvertera det till vårt utgångsvärde.

spänning = (analogRead (tempSensor) * 0,004882814);

grader C = (spänning - 0,5) * 100;

Dessa två rader ser svåra ut, men i den första tar vi avläsningen och multiplicerar den med 0,004 … eftersom den omvandlar 1023 (den analoga avläsningen returnerar detta värde) till en avläsning av 5.

Den andra raden där multiplicerar läsningen med 100 för att flytta decimalpunkten. Det ger oss temperaturen. Propert!

Steg 8: Testning och kontroll

Allt som planeras, du bör ha en fungerande krets. Testa genom att köra simuleringen och använda den seriella bildskärmen. Om du har fel, kontrollera, kontrollera igen och skaka näven.

Klarade du det? Dela och berätta din historia!

Detta är den sista kretsen inbäddad för dig så att du kan spela/testa den sista skapelsen. Tack för att du slutförde handledningen!