Arduino är ett mikrokontrollkort som du kan programmera för att styra externa enheter. Det interagerar med omvärlden genom sensorer, motorer, lysdioder, högtalare ... och till och med Internet, vilket gör det till en flexibel plattform för olika projekt. Det finns ganska många mikrokontroller, men Arduino är populärt på grund av att olika projekt är mycket aktivt utformade och diskuterade på Internet. Om du söker på google eller youtube hittar du miljontals idéer och information för att börja utforska Arduino själv.
Även om du inte har erfarenhet av att programmera mikrokontroller - med Arduino kommer du snabbt att lära och lära dig något om elektronik med hjälp av experiment.
Vad behöver du för att komma igång?
Arduino Uno - 1 st
USB-kabel-1st
Hoppare 1 st
1 st utvecklingskort
Röd LED 4 st
220 ohm motstånd 4st
Motstånd 10 rum 1 st
Knapp utan fixering
potentiometer
RGB LED med gemensam katod
Allt detta kan köpas i en lokal radiobutik eller beställas på Internet.
En onlinesimulator användes för att demonstrera och simulera elektriska kretsar.
Den här simulatorn fungerar bäst i Chrome-webbläsaren.
Låt oss titta närmare på Arduino.
Arduino är inte en stor dator som externa kretsar kan ansluta till. Arduino Uno använder Atmega 328P
Detta är det största chipet på brädet. Detta chip kör program som är lagrade i dess minne. Du kan ladda ner programmet via usb med Arduino IDE. USB-porten ger också kraft till arduino.
Det finns ett separat strömkontakt. Det finns två utgångar på kortet, betecknade 5v och 3.3v, som behövs för att driva olika enheter. Du hittar också stift markerade som GND, dessa är jordledningar (jord är 0V). Arduino-plattformen har också 14 digitala utgångar (stift), markerade med siffror från 0 till 13, som är anslutna till externa noder och har två tillstånd, hög eller låg (på eller av). Dessa kontakter kan fungera som utgångar eller som ingångar, dvs de kan antingen överföra vissa data och kontrollera externa enheter, eller ta emot data från enheter. Följande slutsatser i styrelsen betecknas A0-A5. Dessa är analoga ingångar som kan ta emot data från olika sensorer. Detta är särskilt bekvämt när du behöver mäta ett intervall, till exempel temperatur. De analoga ingångarna har ytterligare funktioner som kan aktiveras separat.
Hur man använder en brödskiva.
En brödskiva behövs för att tillfälligt ansluta delarna, för att kontrollera hur enheten fungerar innan du lödar allt tillsammans.
Alla följande exempel är samlade på en brädskiva så att du snabbt kan göra ändringar i kretsen och återanvända delar utan att bry dig om lödning.
Brädskivan har rader med hål i vilka du kan sätta in delar och ledningar. Vissa av dessa hål är elektriskt anslutna till varandra.
De två övre och nedre raderna är seriekopplade längs hela brädet. Dessa rader används för att driva kretsen. Det kan vara 5v eller 3.3v, men i alla fall är det första du behöver göra att ansluta 5v och GND till brädskivan, som visas på figuren. Ibland kan dessa radanslutningar avbrytas på mitten av brädet, om du behöver, kan du ansluta dem, som visas på figuren.
De återstående hålen som finns i mitten av brädet är grupperade i fem hål. De används för att ansluta kretsdelar.
Det första vi ansluter till vår mikrokontroller är lysdioden. Kretsschemat visas på bilden.
Varför behöver jag ett motstånd i kretsen? I detta fall begränsar den strömmen som går igenom lysdioden. Varje lysdiode är utformad för en specifik ström, och om denna ström är större, kommer lysdioden att misslyckas. Ta reda på vilket värde motståndet ska använda Ohm-lagen. För dem som inte vet eller har glömt, säger Ohms lag att det finns ett linjärt beroende av ström på spänning. Det vill säga, ju mer vi applicerar spänning på motståndet, desto mer ström flyter genom det.
V = I * R
var V-spänning över motståndet
jag- ström genom motståndet
R- motstånd att hitta.
Först måste vi ta reda på spänningen över motståndet. De flesta av 3 mm eller 5 mm lysdioder som du använder har en 3V driftspänning. Så på motståndet måste vi betala 5-3 = 2v.
Sedan beräknar vi strömmen som går igenom motståndet.
De flesta 3 och 5 mm lysdioder lyser med full ljusstyrka vid en ström på 20 mA. En ström mer än detta kan inaktivera dem, och en ström med mindre styrka minskar deras ljusstyrka, utan att orsaka någon skada.
Så vi vill slå på lysdioden i 5v-kretsen så att den har en ström på 20 mA. Eftersom alla delar ingår i en krets kommer motståndet också att ha en ström på 20 mA.
Vi får
2V = 20 mA * R
2V = 0,02A * R
R = 100 ohm
100 Ohms är det minsta motståndet, det är bättre att använda lite mer, eftersom lysdioderna har viss variation i egenskaper.
I detta exempel används ett 220 ohm-motstånd. Bara för att författaren har många av dem: blinka:.
Sätt in lysdioden i hålen i mitten av kortet så att dess långa anslutning är ansluten till en av motståndets plintar. Anslut motståndets andra ände till 5V och anslut den andra utgången från lysdioden till GND. Lysdioden ska tändas.
Observera att det finns en skillnad i hur du ansluter lysdioden. Ström flyter från en längre terminal till en kortare terminal. I diagrammet kan man föreställa sig att strömmen flyter i den riktning där triangeln riktas. Försök att vända lysdioden så ser du att den inte tänds.
Men hur du ansluter motståndet, det är ingen skillnad alls. Du kan vända den eller försöka ansluta den till den andra utgången på lysdioden. Detta påverkar inte kretsens funktion. Det kommer fortfarande att begränsa strömmen genom lysdioden.
Anatomy of an Arduino Sketch.
Program för Arduino kallas skiss. De består av två huvudfunktioner. funktion inställning och funktion loop
inuti denna funktion ställer du in alla grundinställningar. Vilka slutsatser kommer att fungera på input eller output, vilka bibliotek att ansluta, initialisera variabler. funktion Inställning () Det börjar bara en gång under skissen, när programmet startar.
detta är huvudfunktionen som körs efter installation (). I själva verket är detta själva programmet. Denna funktion körs på obestämd tid tills du stänger av strömmen.
Arduino blinkande LED
I det här exemplet kommer vi att ansluta en krets med en LED till en av Arduino digitala stift och slå på och av den med programmet, och du kommer också att lära dig flera användbara funktioner.
- den här funktionen används i installation () delar av programmet och tjänar till att initialisera slutsatserna som du kommer att använda som input (INPUT) eller avsluta (OUTPUT). Du kan inte läsa eller skriva data från stiftet förrän du ställer in dem till pinMode. Den här funktionen har två argument: pinNumber- Detta är pin-numret som du kommer att använda.
läge- anger hur stiftet ska fungera. Vid ingången (INPUT) eller avsluta (OUTPUT). För att tända lysdioden måste vi ge en signal FRÅN Arduino. För att göra detta konfigurerar vi stiftet för att avsluta.
- denna funktion tjänar till att ställa in tillståndet (Stat) nål (PinNumber). Det finns två huvudtillstånd (i allmänhet finns det 3), en är HÖG, stiftet kommer att vara 5v, en annan är låg och stiftet kommer att vara 0v. Så för att tända lysdioden måste vi ställa in en hög nivå på stiftet som är anslutet till lysdioden HÖG.
- försening. Serverar för att fördröja programmet under en viss period i ms.
Nedan är koden som får lysdioden att blinka.
// LED blinkar
int ledPin = 7; // Arduino-stift till vilken lysdioden är ansluten
ogiltig installation () {
pinMode (ledPin, OUTPUT); // Ställ in stiftet som EXIT
}
void loop () {
digitalWrite (ledPin, HIGH); // tända lysdioden
fördröjning (1000); // fördröjning 1000 ms (1 sek)
digitalWrite (ledPin, LOW); // Stäng av lysdioden
fördröjning (1000); // vänta 1 sek
}
En liten förklaring till koden.
Linjer som börjar med "//" är kommentarer från Arduino som ignorerar dem.
Alla kommandon slutar med en semikolon; om du glömmer dem får du ett felmeddelande.
ledPinär en variabel. Variabler används i program för att lagra värden. I det här exemplet variabeln ledPin tilldelade ett värde av 7, detta är Arduino-stiftnumret. När Arduino i programmet möter en sträng med en variabel ledPin , kommer det att använda det värde som vi angav tidigare.
Så spela in pinMode (ledPin, OUTPUT) liknar posten pinMode (7, OUTPUT).
Men i det första fallet räcker det för dig att ändra variabeln och den kommer att ändras i varje rad där den används, och i det andra fallet, för att ändra variabeln, måste du göra ändringar i pennorna i varje kommando.
i den första raden anger typen av variabel. När du programmerar Arduino är det viktigt att alltid ange typen av variabler. För tillfället behöver du bara veta det INT tillkännager negativa och positiva siffror.
Nedan presenteras modellering skiss. Tryck på start för att se kretsens funktion.
Som förväntat slocknar lysdioden och tänds efter en sekund. Försök ändra fördröjningen för att se hur det fungerar.
Hantering av flera lysdioder.
I det här exemplet lär du dig att styra flera lysdioder. För att göra detta, installera ytterligare 3 lysdioder på kortet och anslut dem till Arduino-motstånd och stift, som visas nedan.
För att slå på och stänga av lysdioderna i sin tur måste du skriva ett program som detta:
// Multi LED-blink
int led1Pin = 4;
int led2Pin = 5;
int led3Pin = 6;
int led4Pin = 7;
ogiltig installation () {
// Ställ in stift som EXIT
pinMode (led1Pin, OUTPUT);
pinMode (led2Pin, OUTPUT);
pinMode (led3Pin, OUTPUT);
pinMode (led4Pin, OUTPUT);
}
void loop () {
digitalWrite (led1Pin, HIGH); // tända lysdioden
fördröjning (1000); // fördröjning 1 sek
digitalWrite (led1Pin, LOW); // släcka lysdioden
fördröjning (1000); // fördröjning 1 sek
// gör samma sak för de andra 3 lysdioderna
digitalWrite (led2Pin, HIGH); // tända lysdioden
fördröjning (1000); // fördröjning 1 sek
digitalWrite (led2Pin, LOW); // släcka lysdioden
fördröjning (1000); // fördröjning 1 sek
digitalWrite (led3Pin, HIGH); // tända lysdioden
fördröjning (1000); // fördröjning 1 sek
digitalWrite (led3Pin, LOW); // släcka lysdioden
fördröjning (1000); // fördröjning 1 sek
digitalWrite (led4Pin, HIGH); // tända lysdioden
fördröjning (1000); // fördröjning 1 sek
digitalWrite (led4Pin, LOW); // släcka lysdioden
fördröjning (1000); // fördröjning 1 sek
}
Detta program kommer att fungera bra, men detta är inte den mest rationella lösningen. Koden måste ändras. För att programmet ska fungera om och om igen kommer vi att använda den konstruktion som heter.
Cykler är praktiska när du behöver upprepa samma åtgärd flera gånger. I koden ovan upprepar vi raderna
digitalWrite (led4Pin, HIGH);
fördröjning (1000);
digitalWrite (led4Pin, LOW);
fördröjning (1000);
full skisskod i bilagan
LED-ljusstyrkajustering
Ibland måste du ändra ljusstyrkan på lysdioderna i programmet. Detta kan göras med kommandot analogWrite (). Detta kommando slår på och stänger av LED så snabbt att ögat inte ser denna flimmer. Om lysdioden slås på halva tiden och halvtiden kommer det att se visuellt ut att tändas vid halva ljusstyrkan. Detta kallas pulsbreddmodulering (PWM eller PWM på engelska). PWM används ganska ofta eftersom det kan användas för att styra den "analoga" komponenten med en digital kod. Inte alla Arduino-stift är lämpliga för dessa ändamål. Endast de slutsatser som en sådan beteckning dras "~".Du kommer att se det bredvid stift 3,5,6,9,10,11.
Anslut en av dina lysdioder till en av PWM-utgångarna (för författaren är detta pin 9). Kör nu skissen blinkande LED, men ändra först kommandot digitalWrite () på analogWrite (). analogWrite () Det har två argument: det första är stiftnumret, och det andra är PWM-värdet (0-255), i förhållande till lysdioder är det deras ljusstyrka, och för elmotorer rotationshastigheten. Nedan följer en exempelkod för olika LED-ljusstyrkor.
// Ändra lysstyrkan på lysdioden
int ledPin = 9; // LED ansluten till denna stift
ogiltig installation () {
pinMode (ledPin, OUTPUT); // initiera stiftet för att mata ut
}
void loop () {
analogWrite (ledPin, 255); // full ljusstyrka (255/255 = 1)
fördröjning (1000); // paus 1 sek
digitalWrite (ledPin, LOW); // stäng av lysdioden
fördröjning (1000); // paus 1 sek
analogWrite (ledPin, 191); // ljusstyrka vid 3/4 (191/255 ~ = 0,75)
fördröjning (1000); // paus 1 sek
digitalWrite (ledPin, LOW); // stäng av lysdioden
fördröjning (1000); // paus 1 sek
analogWrite (ledPin, 127); // halv ljusstyrka (127/255 ~ = 0,5)
fördröjning (1000); // paus 1 sek
digitalWrite (ledPin, LOW); // stäng av lysdioden
fördröjning (1000); // paus 1 sek
analogWrite (ledPin, 63); // kvartal ljusstyrka (63/255 ~ = 0,25)
fördröjning (1000); // paus 1 sek
digitalWrite (ledPin, LOW); // stäng av lysdioden
fördröjning (1000); // paus 1 sek
}
Försök ändra PWM-värdet i kommandot analogWrite ()för att se hur det påverkar ljusstyrkan.
Därefter lär du dig att justera ljusstyrkan smidigt från full till noll. Du kan naturligtvis kopiera ett kodstycke 255 gånger
analogWrite (ledPin, ljusstyrka);
fördröjning (5); // kort fördröjning
ljusstyrka = ljusstyrka + 1;
Men du förstår - det kommer inte att vara praktiskt. För detta är det bäst att använda FOR-slingan som användes tidigare.
Följande exempel använder två cykler, en för att minska ljusstyrkan från 255 till 0
för (int ljusstyrka = 0; ljusstyrka = 0; ljusstyrka -) {
analogWrite (ledPin, ljusstyrka);
fördröjning (5);
}
fördröjning (5) används för att bromsa hastigheten på stigning och fall av ljusstyrka 5 * 256 = 1280 ms = 1,28 sek.)
Den första raden använder "Ljusstyrka-"så att ljusstyrkan minskar med 1, varje gång cykeln upprepas. Observera att cykeln fungerar så länge som ljusstyrka> = 0Byt ut skylten > på skylten >= vi inkluderade 0 i ljusstyrkan. Denna skiss är modellerad nedan.
// ändra ljusstyrkan smidigt
int ledPin = 9; // LED är ansluten till denna stift
ogiltig installation () {
pinMode (ledPin, OUTPUT); // initiera stiftet för att avsluta
}
void loop () {
// öka gradvis ljusstyrkan (0 till 255)
för (int ljusstyrka = 0; ljusstyrka = 0; ljusstyrka -) {
analogWrite (ledPin, ljusstyrka);
fördröjning (5);
}
fördröjning (1000); // vänta 1 sek
// minska ljusstyrkan (255 till 0)
för (int ljusstyrka = 255; ljusstyrka> = 0; ljusstyrka -) {
analogWrite (ledPin, ljusstyrka);
fördröjning (5);
}
fördröjning (1000); // vänta 1 sek
}
}
Detta är inte särskilt synligt, men idén är klar.
RGB LED och Arduino
RGB-LED är faktiskt tre lysdioder i olika färger i ett hus.
Inklusive olika lysdioder med olika ljusstyrka kan du kombinera och få olika färger. För Arduino, där antalet ljusstyrka är 256, får du 256 ^ 3 = 16581375 möjliga färger. I verkligheten kommer naturligtvis färre av dem.
Lysdioden som vi kommer att använda är den vanliga katoden. dvs alla tre lysdioder är strukturellt anslutna med katoder till en terminal. Vi kommer att ansluta denna stift till GND-stiftet. De återstående terminalerna, genom begränsningsmotståndet, måste anslutas till PWM-terminalerna. Författaren använde slutsatser 9-11. Därmed kommer det att vara möjligt att styra varje lysdiod separat. Den första skissen visar hur du slår på varje lysdiod separat.
// RGB LED - test
// stiftanslutningar
int röd = 9;
int grön = 10;
int blå = 11;
ogiltig installation () {
pinMode (röd, UTGÅNG);
pinMode (blå, UTGÅNG);
pinMode (grön, UTGÅNG);
}
void loop () {
// slå på / stänga av den röda lysdioden
digitalWrite (röd, HÖG);
fördröjning (500);
digitalWrite (röd, LÅG);
fördröjning (500);
// slå på / av den gröna lysdioden
digitalWrite (grön, HÖG);
fördröjning (500);
digitalWrite (grön, LÅG);
fördröjning (500);
// slå på / av den blå lysdioden
digitalWrite (blå, HÖG);
fördröjning (500);
digitalWrite (blå, LÅG);
fördröjning (500);
}
Följande exempel använder kommandona analogWrite () och för att få olika slumpmässiga ljusstyrkor för lysdioder. Du kommer att se olika färger förändras slumpmässigt.
// RGB LED - slumpmässiga färger
// stiftanslutningar
int röd = 9;
int grön = 10;
int blå = 11;
ogiltig installation () {
pinMode (röd, UTGÅNG);
pinMode (blå, UTGÅNG);
pinMode (grön, UTGÅNG);
}
void loop () {
// välj en slumpmässig färg
analogWrite (röd, slumpmässig (256));
analogWrite (blå, slumpmässig (256));
analogWrite (grön, slumpmässig (256));
fördröjning (1000); // vänta en sekund
}
Slumpmässigt (256)-Sätter tillbaka ett slumpmässigt nummer i intervallet från 0 till 255.
I den bifogade filen finns en skiss som visar smidiga övergångar av färger från rött till grönt, sedan till blått, rött, grönt, etc.
Ett exempel skiss fungerar, men det finns mycket duplikatkod. Du kan förenkla koden genom att skriva din egen hjälpfunktion, som smidigt ändrar en färg till en annan.
Så här kommer det att se ut:
Låt oss titta på definitionen av en funktion i delar. Funktion kallas fader och har två argument. Varje argument separeras av ett komma och har en typ som deklareras i den första raden i funktionsdefinitionen: void fader (int color1, int color2). Du ser att båda argumenten förklaras som intoch de får namn color1 och Color2 som villkorliga variabler för att definiera en funktion. Void betyder att funktionen inte returnerar några värden, den kör helt enkelt kommandon. Om det var nödvändigt att skriva en funktion som returnerade resultatet av multiplikationen, så skulle det se ut så här:
int multiplikator (int nummer1, int nummer2) {
int produkt = nummer 1 * nummer2;
returprodukt;
}
Lägg märke till hur vi förklarade typ int som returtyp istället
void.
Inuti funktionen finns kommandon som du redan använde i föregående skiss, bara pin-numren ersattes av color1 och Color2. Funktion kallas fader, dess argument beräknas som färg1 = röd och färg2 = grön. Arkivets fullständiga skiss med funktioner
knapp
I nästa skiss används en knapp med normalt öppna kontakter, utan fixering.
Detta innebär att medan knappen inte trycks ner strömmar inte strömmen genom den, och efter att den släppts återgår knappen till sitt ursprungliga läge.
I kretsen, förutom knappen, används ett motstånd. I detta fall begränsar den inte strömmen, utan "drar" knappen till 0v (GND). dvs tills knappen trycks in på stiftet på den Arduino som den är ansluten till kommer nivån att vara låg. Motståndet som används i 10 kΩ-kretsen.
// definiera knappen klicka
int-knappPin = 7;
ogiltig installation () {
pinMode (buttonPin, INPUT); // initiera ingångsstiftet
Serial.begin (9600); // initiera seriell port
}
void loop () {
if (digitalRead (knappPin) == HÖG) {// om knappen trycks in
Serial.println ("pressat"); // skriva ut "tryckt"
} annat {
Serial.println ("unpressed"); // annars "unpressed"
}
}
Det finns flera nya lag i denna skiss.
-Det här kommandot tar värdet Hög (hög nivå) och låg (låg nivå) på den utgång som vi kontrollerar. Tidigare i installationen () måste denna utgång konfigureras för inmatning.
; // där buttonPin är stiftnumret där knappen är ansluten.
Den seriella porten låter dig skicka Arduino-meddelanden till datorn, medan styrenheten själv kör programmet. Detta är användbart för att felsöka ett program, skicka meddelanden till andra enheter eller applikationer. För att aktivera dataöverföring via den seriella porten (även känd som UART eller USART) måste du initiera den i installationen ()
Serial.begin () har bara ett argument är dataöverföringshastigheten mellan Arduino och datorn.
skiss används ett kommando för att visa ett meddelande på skärmen i Arduino IDE (Tools >> Serial Monitor).
- designen låter dig styra programmets framsteg genom att kombinera flera kontroller på ett ställe.
Om (om) digitalRead returnerar HÖG visas ordet "tryckt" på monitorn. Annars (annars) visas ordet "pressad" på monitorn. Nu kan du försöka slå på och stänga av lysdioden med en knapptryckning.
// knapptryckdetektering med LED-utgång
int-knappPin = 7;
int ledPin = 8;
ogiltig installation () {
pinMode (buttonPin, INPUT); // den här gången kommer vi att ställa in knappen pin som INPUT
pinMode (ledPin, OUTPUT);
Serial.begin (9600);
}
void loop () {
if (digitalRead (buttonPin) == HÖG) {
digitalWrite (ledPin, HIGH);
Serial.println ("pressat");
} annat {
digitalWrite (ledPin, LOW);
Serial.println ("otryckt");
}
}
Analog ingång.
analogRead låter dig läsa data från en av Arduino-analoga stift och visar ett värde i området från 0 (0V) till 1023 (5V). Om spänningen vid den analoga ingången är 2,5V, kommer 2,5 / 5 * 1023 = 512 att skrivas ut
analogRead har bara ett argument- Detta är det analoga ingångsnumret (A0-A5). Följande skiss ger en kod för lässpänning från en potentiometer. För att göra detta, anslut ett variabelt motstånd, de extrema stiften till stiften 5V och GND, och den mittersta stiftet till ingången A0.
Kör följande kod och titta på seriemonitorn hur värdena förändras beroende på motståndsknappens rotation.
// analog ingång
int potPin = A0; // potentiometerns centrala utgång är ansluten till denna stift
ogiltig installation () {
// den analoga stiftet aktiveras som standard genom att mata in, så initialisering behövs inte
Serial.begin (9600);
}
void loop () {
int potVal = analogRead (potPin); // potVal är ett tal mellan 0 och 1023
Serial.println (potVal);
}
Nästa skiss kombinerar en knappklickskiss och en LED-ljusstyrka-skiss. Lysdioden tänds från knappen och potentiometern styr glödets ljusstyrka.
// knapptryckdetektering med LED-utgång och variabel intensitet
int-knappPin = 7;
int ledPin = 9;
int potPin = A0;
ogiltig installation () {
pinMode (buttonPin, INPUT);
pinMode (ledPin, OUTPUT);
Serial.begin (9600);
}
void loop () {
if (digitalRead (knappPin) == HÖG) {// om knappen trycks in
int analogVal = analogRead (potPin);
int skaladVal = karta (analogVal, 0, 1023, 0, 255);
analogWrite (ledPin, scaledVal); // slå på led med intensitet inställd av potten
Serial.println ("pressat");
} annat {
digitalWrite (ledPin, LOW); // stäng av om knappen inte trycks in
Serial.println ("otryckt");
}
}