Arduino uno r3 -projektit aloittelijoille. Arduino: mitä sille voidaan tehdä. Projekteja tulevaisuutta varten

Tämä simulaattori toimii parhaiten Chrome-selaimessa
Katsotaanpa Arduinoa tarkemmin.

Arduino ei ole iso tietokone, johon voidaan liittää ulkoisia piirejä. Arduino Uno käyttää Atmega 328P:tä
Tämä on levyn suurin siru. Tämä siru suorittaa ohjelmia, jotka on tallennettu sen muistiin. Voit ladata ohjelman usb:n kautta käyttämällä Arduino IDE:tä. USB-portti antaa virtaa myös arduinolle.

On erillinen pistorasia. Kortilla on kaksi lähtöä, 5v ja 3,3v, joita tarvitaan eri laitteiden virransyöttöön. Löydät myös nastat, jotka on merkitty GND, nämä ovat maadoitusnastat (maa on 0V). Arduino-alustalla on myös 14 digitaalista nastaa (nastat), jotka on merkitty numeroilla 0-13, jotka yhdistetään ulkoisiin solmuihin ja joilla on kaksi tilaa, korkea tai matala (päällä tai pois päältä). Nämä koskettimet voivat toimia lähtöinä tai tuloina, ts. ne voivat joko lähettää tietoja ja ohjata ulkoisia laitteita tai vastaanottaa tietoja laitteista. Seuraavat taulun nastat on merkitty A0-A5. Nämä ovat analogisia tuloja, jotka voivat vastaanottaa tietoja eri antureilta. Tämä on erityisen hyödyllistä, kun sinun on mitattava tietty alue, kuten lämpötila. Analogisissa tuloissa on lisätoimintoja, jotka voidaan aktivoida erikseen.

Kuinka käyttää leipälautaa.

Leipälevy on tarkoitettu osien väliaikaiseen yhdistämiseen, laitteen toiminnan testaamiseen ennen kuin juotat kaiken yhteen.
Kaikki seuraavat esimerkit on koottu leipälevylle, jotta voit nopeasti tehdä muutoksia piiriin ja käyttää osia uudelleen ilman juottamisen vaivaa.

Leipälaudassa on riviä reikiä, joihin voit laittaa osia ja johtimia. Jotkut näistä rei'istä on kytketty sähköisesti toisiinsa.

Kaksi ylä- ja alariviä on kytketty sarjaan koko levyä pitkin. Näitä rivejä käytetään virran syöttämiseen piiriin. Se voi olla 5v tai 3,3v, mutta joka tapauksessa, ensimmäinen asia, joka sinun on tehtävä, on kytkeä 5v ja GND leipälevyyn kuvan osoittamalla tavalla. Joskus nämä riviliitännät voidaan keskeyttää laudan keskeltä, sitten voit tarvittaessa yhdistää ne kuvan osoittamalla tavalla.

Loput laudan keskellä olevat reiät on ryhmitelty viiden reiän mukaan. Niitä käytetään kytkemään piirin osia.

Ensimmäinen asia, jonka yhdistämme mikrokontrolleriimme, on LED. Kytkentäkaavio näkyy kuvassa.

Mikä on vastuksen tarkoitus piirissä? Tässä tapauksessa se rajoittaa LEDin läpi kulkevaa virtaa. Jokainen LED on suunniteltu tietylle virralle, ja jos tämä virta on suurempi, LED epäonnistuu. Ohmin lain avulla voit selvittää, mikä arvo vastuksen tulisi olla. Niille, jotka eivät tiedä tai ovat unohtaneet, Ohmin laki sanoo, että virran ja jännitteen välillä on lineaarinen suhde. Eli mitä enemmän syötämme jännitettä vastukseen, sitä enemmän virtaa virtaa sen läpi.
V=I*R
Missä V- jännite vastuksen yli
minä- virta vastuksen läpi
R on löydettävä vastus.
Ensin meidän on selvitettävä vastuksen yli oleva jännite. Useimmissa käyttämissäsi 3 mm tai 5 mm LED-valoissa on 3 voltin käyttöjännite. Joten vastuksesta meidän on maksettava pois 5-3 \u003d 2v.

Laskemme sitten vastuksen läpi kulkevan virran.
Useimmat 3 ja 5 mm:n LEDit hehkuvat täydellä kirkkaudella 20 mA:lla. Tätä suurempi virta voi tuhota ne, ja pienempi virta vähentää niiden kirkkautta aiheuttamatta mitään haittaa.

Joten haluamme kytkeä LEDin päälle 5 V piirissä niin, että sen virta on 20 mA. Koska kaikki osat ovat samassa piirissä, vastuksen virta on myös 20 mA.
Saamme
2V = 20mA*R
2V = 0,02A*R
R = 100 ohmia
100 ohmia on pienin vastus, on parempi käyttää hieman enemmän, koska LED-valoilla on jonkin verran vaihtelua ominaisuuksissa.
Tässä esimerkissä käytetään 220 ohmin vastusta. Vain siksi, että kirjoittajalla on niitä paljon :wink: .

Työnnä LED levyn keskellä oleviin reikiin niin, että sen pitkä johdin on kytketty johonkin vastuksen johtimista. Kytke vastuksen toinen pää 5V:iin ja LEDin toinen pää GND:hen. LEDin pitäisi syttyä.

Huomaa, että LED-valon kytkemisessä on eroja. Virta kulkee pidemmästä johdosta lyhyempään johtimeen. Kaaviossa voidaan kuvitella, että virta kulkee kolmion suunnassa. Yritä kääntää LED-valoa ja huomaat, että se ei hehku.

Mutta miten vastus kytketään, ei ole mitään eroa. Voit kääntää sen tai yrittää kytkeä sen toiseen LED-lähtöön, tämä ei vaikuta piirin toimintaan. Se rajoittaa silti LEDin kautta kulkevaa virtaa.

Arduino-luonnoksen anatomia.

Arduinon ohjelmia kutsutaan sketchiksi. Niillä on kaksi päätehtävää. Toiminto perustaa ja toimivuus silmukka
Tämän toiminnon sisällä määrität kaikki perusasetukset. Mitkä lähdöt toimivat tulona tai lähtönä, mitkä kirjastot liitetään, alustetaan muuttujat. Toiminto Perustaa() suoritetaan vain kerran luonnoksen aikana, kun ohjelman suoritus alkaa.
tämä on päätoiminto, joka suoritetaan sen jälkeen perustaa(). Itse asiassa se on itse ohjelma. Tämä toiminto toimii toistaiseksi, kunnes katkaiset virran.

Arduino vilkkuva LED

Tässä esimerkissä yhdistämme LED-piirin yhteen Arduinon digitaalisista nastaista ja kytkemme sen päälle ja pois ohjelman avulla sekä opimme muutamia hyödyllisiä toimintoja.

Tätä ominaisuutta käytetään mm perustaa() osa ohjelmaa ja sen avulla alustetaan nastat, joita käytät tulona (INPUT) tai poistu (OUTPUT). Et voi lukea tai kirjoittaa tietoja nastasta ennen kuin asetat sen vastaavasti pinMode. Tällä funktiolla on kaksi argumenttia: pin koodi on käyttämäsi PIN-koodi.

tila- määrittää kuinka pin toimii. Sisäänkäynnillä (INPUT) tai poistu (OUTPUT). LED-valon sytyttämiseksi meidän on annettava signaali FROM Arduino. Tätä varten määritämme PIN-koodin poistumaan.
- tätä toimintoa käytetään tilan asettamiseen (osavaltio) pina (pin koodi). Päätiloja on kaksi (yleensä niitä on 3), yksi on KORKEA, nastassa on 5v, toinen on Matala ja pinni on 0v. Joten LEDin sytyttämiseksi meidän on asetettava korkea taso LEDiin kytketylle nastalle KORKEA.

Viive. Viivästyttää ohjelmaa ms:ssä määritellyn ajan.
Alla on koodi, joka saa LEDin vilkkumaan.
//LED Blink int ledPin = 7;//Arduino-nasta, johon LED on kytketty void setup() ( pinMode(ledPin, OUTPUT);// aseta pin OUTPUT:ksi ) void loop() ( digitalWrite(ledPin, HIGH);/ / laita LED-viive (1000) päälle;// viive 1000 ms (1 s) digitalWrite(ledPin, LOW);// Sammuta LED-viive (1000);// odota 1 sek )

Pienet selitykset koodiin.
"//"-alkuiset rivit ovat kommentteja, joita Arduino jättää huomiotta.
Kaikki komennot päättyvät puolipisteeseen, jos unohdat ne, saat virheilmoituksen.

ledPin on muuttuja. Muuttujia käytetään ohjelmissa arvojen tallentamiseen. Tässä esimerkissä muuttuja ledPin arvo 7 on määritetty, tämä on Arduinon pin-numero. Kun ohjelman Arduino kohtaa rivin, jossa on muuttuja ledPin, se käyttää aiemmin määrittämäämme arvoa.
Ennätys siis pinMode(ledPin, OUTPUT) samanlainen kuin merkintä pinMode(7, OUTPUT).
Mutta ensimmäisessä tapauksessa sinun tarvitsee vain muuttaa muuttuja ja se muuttuu jokaisella rivillä, jolla sitä käytetään, ja toisessa tapauksessa, jotta voit muuttaa muuttujaa, sinun on tehtävä muutoksia kahvoilla jokaisessa komennossa.

Ensimmäinen rivi osoittaa muuttujan tyypin. Arduinoa ohjelmoitaessa on tärkeää ilmoittaa aina muuttujien tyyppi. Kunhan tiedät sen INT ilmoittaa negatiiviset ja positiiviset luvut.
Alla on luonnossimulaatio. Paina Start nähdäksesi kuinka piiri toimii.

Kuten odotettiin, LED sammuu ja syttyy sekunnin kuluttua. Kokeile muuttaa viivettä nähdäksesi, miten se toimii.

Useiden LEDien ohjaus.

Tässä esimerkissä opit ohjaamaan useita LEDejä. Voit tehdä tämän asentamalla 3 muuta LED-valoa levylle ja liittämällä ne Arduino-vastuksiin ja nastoihin alla olevan kuvan mukaisesti.

Jotta voit kytkeä LED-valot päälle ja pois päältä vuorotellen, sinun on kirjoitettava tämän kaltainen ohjelma:
//Multi LED Blink int led1Pin = 4; int led2Pin = 5; intled3Pin = 6; int led4Pin = 7; void setup() ( //asettaa nastat OUTPUT:ksi pinMode(led1Pin, OUTPUT); pinMode(led2Pin, OUTPUT); pinMode(led3Pin, OUTPUT); pinMode(led4Pin, OUTPUT); ) void loop() ( digitalWrite(led1Pin, HIGH) );//valon LED-viive (1000);//viive 1 s digitalWrite(led1Pin, LOW);//sammuta LED-viive (1000);//viive 1 s //tee sama muille 3 LEDille digitalWrite( led2Pin , HIGH); // laita LED-viive (1000) päälle ;// kytke LED-viive (1000) päälle LED-viive (1000);// viive 1 s digitalWrite (led4Pin, LOW);//sammuta LED-viive (1000);//viive 1 s

Tämä ohjelma toimii hyvin, mutta se ei ole älykkäin ratkaisu. Koodi on vaihdettava. Jotta ohjelma toimisi yhä uudelleen ja uudelleen, käytämme konstruktiota nimeltä .
Silmukat ovat hyödyllisiä, kun sinun on toistettava sama toiminto useita kertoja. Yllä olevassa koodissa toistamme rivit

DigitalWrite (led4Pin, KORKEA); viive (1000); digitalWrite(led4Pin, LOW); viive (1000);
täydellinen luonnoskoodi liitteenä (lataukset: 1260)

LED-kirkkauden säätö

Joskus joudut muuttamaan ohjelman LEDien kirkkautta. Tämä voidaan tehdä komennolla analogWrite() . Tämä komento sytyttää ja sammuttaa LEDin niin nopeasti, että silmä ei näe tätä välkkymistä. Jos LED palaa puolet ajasta ja sammuu puolet ajasta, näyttää visuaalisesti siltä, että se hehkuu puolet kirkkaudestaan. Tätä kutsutaan pulssin leveysmodulaatioksi (PWM tai PWM englanniksi). PWM:ää käytetään melko usein, koska sillä voidaan ohjata "analogista" komponenttia digitaalisella koodilla. Kaikki Arduino-nastat eivät sovellu tähän tarkoitukseen. Vain ne johtopäätökset, joiden lähellä tällainen nimitys tehdään " ~ ". Näet sen nastojen 3,5,6,9,10,11 vieressä.
Liitä yksi LED-valoistasi yhteen PWM-nastasta (kirjoittajan nasta on 9). Suorita nyt LED-vilkkuva luonnos, mutta muuta ensin komento digitalWrite() päällä analogWrite(). analogWrite() on kaksi argumenttia: ensimmäinen on pin-numero ja toinen on PWM-arvo (0-255), suhteessa LEDeihin tämä on niiden kirkkaus ja sähkömoottoreille pyörimisnopeus. Alla on esimerkkikoodi eri LED-kirkkauksille.
//Muuta LEDin kirkkautta int ledPin = 9;//tähän pinoon on kytketty LED void setup() ( pinMode(ledPin, OUTPUT);// nastan alustus lähtöön ) void loop() ( analogWrite (ledPin, 255);// täysi kirkkaus (255/255 = 1) viive (1000);// tauko 1 s digitalWrite(ledPin, LOW);// sammuta LED-viive (1000);// tauko 1 s analogWrite (ledPin, 191) tauko 1 s analogWrite(ledPin, 127); //puoli kirkkautta (127/255 ~= 0.5) viive(1000);//tauko 1s digitalWrite(ledPin, LOW);//sammuta LED-viive(1000);// tauko 1 s analogWrite(ledPin, 63); // neljänneskirkkaus (63/255 ~= 0,25) viive(1000);// tauko 1 s digitalWrite(ledPin, LOW);// sammuta LED-viive(1000);// tauko 1 s)

Yritä muuttaa komennon PWM-arvoa analogWrite() nähdäksesi kuinka tämä vaikuttaa kirkkauteen.
Seuraavaksi opit säätämään kirkkautta sujuvasti täydestä nollaan. Voit tietysti kopioida koodinpätkän 255 kertaa
analogWrite(ledPin, kirkkaus); viive(5);//lyhyt viive kirkkaus = kirkkaus + 1;
Mutta ymmärräthän - se ei ole käytännöllistä. Paras tapa tehdä tämä on käyttää aiemmin käyttämäämme FOR-silmukkaa.
Seuraavassa esimerkissä käytetään kahta silmukkaa, joista toinen pienentää kirkkautta arvosta 255 arvoon 0
for (int kirkkaus=0;kirkkaus=0;kirkkaus-)( analogWrite(ledPin,kirkkaus); viive(5); )
viive (5) käytetään hidastamaan sisään- ja poistumisnopeutta 5*256=1280ms=1.28s.)
Ensimmäisellä rivillä käytetään " kirkkaus-" pienentää kirkkausarvoa yhdellä joka kerta, kun silmukka toistetaan. Huomaa, että silmukka jatkuu, kunnes kirkkaus >=0.Kyltin vaihtaminen > merkin päällä >= olemme sisällyttäneet 0 kirkkausalueeseen. Tämä luonnos on mallinnettu alla. //muuta kirkkautta pehmeästi int ledPin = 9;//tähän pinoon on kytketty LED void setup() ( pinMode(ledPin, OUTPUT);// lähtönastan alustus ) void loop() ( //lisää tasaisesti kirkkaus (0 - 255 ) kohteelle (int kirkkaus=0;kirkkaus=0;kirkkaus-)( analogWrite(ledPin,kirkkaus); viive(5); ) delay(1000);//odota 1 s //pienennä kirkkautta hitaasti (255 - 0) kohteelle (int kirkkaus=255;kirkkaus>=0;kirkkaus-)( analogWrite(ledPin,kirkkaus); viive(5); ) viive (1000);//odota 1 sekunti ) )
Se ei näytä kovin hyvältä, mutta idea on selvä.

RGB LED ja Arduino

RGB-LED on itse asiassa kolme eriväristä LEDiä yhdessä paketissa.

Kytkemällä päälle erilaisia LEDejä eri kirkkaudella voit yhdistää ja saada erilaisia värejä. Arduinolle, jossa on 256 sävyä, saat 256^3=16581375 mahdollista väriä. Todellisuudessa niitä tulee tietysti olemaan vähemmän.
LED, jota käytämme yhteisenä katodina. Nuo. kaikki kolme LEDiä on rakenteellisesti yhdistetty katodeilla yhteen lähtöön. Yhdistämme tämän nastan GND-nastaan. Loput lähdöt, rajoittavien vastusten kautta, on kytkettävä PWM-lähtöihin. Kirjoittaja käytti nastat 9-11, joten jokaista LEDiä voidaan ohjata erikseen. Ensimmäinen luonnos näyttää, kuinka jokainen LED kytketään päälle erikseen.

//RGB LED - testaa //pin liitännät int red = 9; int vihreä = 10; int sininen = 11; void setup()( pinMode(punainen, OUTPUT); pinMode(sininen, OUTPUT); pinMode(vihreä, OUTPUT); ) void loop()( //sytytä/poista punainen LED digitalWrite(punainen, HIGH); viive( 500) ; digitalWrite(punainen, LOW); viive(500); //vihreän LEDin kytkeminen päälle/pois digitalWrite(vihreä, HIGH); viive(500); digitalWrite(vihreä, LOW); viive(500); // kytke päälle/pois sininen LED digitalWrite (sininen, HIGH); viive (500); digitalWrite (sininen, LOW); viive (500); )

Seuraava esimerkki käyttää komentoja analogWrite() ja saada erilaisia satunnaisia kirkkausarvoja LEDeille. Näet eri värit muuttuvan satunnaisesti.
//RGB LED - satunnaiset värit //pin liitännät int red = 9; int vihreä = 10; int sininen = 11; void setup()( pinMode(punainen, OUTPUT); pinMode(sininen, OUTPUT); pinMode(vihreä, OUTPUT); ) void loop()( //valitse satunnainen väri analogWrite(punainen, satunnainen(256)); analogWrite( sininen, satunnainen(256)); analogWrite(vihreä, satunnainen(256)); viive (1000);//odota sekunti )

Satunnainen (256)- palauttaa satunnaisluvun väliltä 0 - 255.
Liitteenä olevassa tiedostossa luonnos, joka näyttää värien sujuvat siirtymät punaisesta vihreään, sitten siniseen, punaiseen, vihreään jne. (lataukset: 348)
Luonnosesimerkki toimii, mutta siinä on paljon toistuvaa koodia. Voit yksinkertaistaa koodia kirjoittamalla oman aputoiminnon, joka vaihtuu sujuvasti väristä toiseen.
Tältä se näyttää: (lataukset: 385)
Katsotaanpa funktion määritelmää pala palalta. Funktiota kutsutaan häivytin ja sillä on kaksi argumenttia. Jokainen argumentti erotetaan pilkulla, ja sen tyyppi on ilmoitettu funktion määritelmän ensimmäisellä rivillä: void fader(int color1, int color2). Voit nähdä, että molemmat argumentit on ilmoitettu muodossa int, ja ne on nimetty väri 1 Ja väri 2 ehtomuuttujina funktion määrittelemiseksi. Tyhjä tarkoittaa, että funktio ei palauta arvoja, se vain suorittaa komentoja. Jos sinun pitäisi kirjoittaa funktio, joka palauttaa kertolaskutuloksen, se näyttäisi tältä:
int kerroin(int numero1, int luku2)( int tuote = numero1*luku2; palautustulos; )
Huomaa, kuinka määritimme tyypin int palautustyypin sijaan
mitätön.
Toiminnon sisällä on komentoja, joita käytit jo edellisessä luonnoksessa, vain pin-numerot korvattiin väri 1 Ja väri 2. Funktiota kutsutaan häivytin, sen argumentit lasketaan seuraavasti väri1 = punainen Ja väri2 = vihreä. Arkisto sisältää täydellisen luonnoksen funktioiden avulla (lataukset: 288)

Painike

Seuraavassa luonnoksessa käytetään painiketta, jossa on normaalisti avoimet koskettimet ilman lukitusta.

Tämä tarkoittaa, että kun painiketta ei paineta, sen läpi ei kulje virtaa, ja vapauttamisen jälkeen painike palaa alkuperäiseen asentoonsa.
Piirissä käytetään painikkeen lisäksi vastusta. Tässä tapauksessa se ei rajoita virtaa, vaan "vetää" painikkeen 0v:iin (GND). Nuo. kunnes painiketta painetaan, Arduino-nasta, johon se on kytketty, on alhainen. 10 kΩ piirissä käytetty vastus.

//määritä painikkeen painallus int buttonPin = 7; void setup()( pinMode(buttonPin, INPUT);//alustaa pin input Serial.begin(9600);//alustaa sarjaportti ) void loop()( if (digitalRead(buttonPin)==HIGH)(//if painiketta painetaan Serial.println("pressed"); // tulosta "painattu" ) else ( Serial.println("painamaton");// muuten "painamaton" ) )
Tässä luonnoksessa on useita uusia komentoja.
- Tämä komento hyväksyy tarkistettavan lähdön arvon High (korkea taso) ja matala (matala). Aikaisemmin setup()-toiminnossa tämä lähtö on määritettävä tuloksi.
; //jossa buttonPin on PIN-koodi, johon painike on liitetty.
Sarjaportin avulla Arduino voi lähettää viestejä tietokoneelle, kun ohjain itse suorittaa ohjelmaa. Tästä on hyötyä ohjelman virheenkorjauksessa, viestien lähettämisessä muihin laitteisiin tai sovelluksiin. Jotta tiedonsiirto voidaan ottaa käyttöön sarjaportin kautta (toinen nimi UART:lle tai USART:lle), sinun on alustettava se asennuksessa ()

Serial.begin() on vain yksi argumentti - tämä on tiedonsiirtonopeus Arduinon ja tietokoneen välillä.
Luonnos käyttää komentoa, joka näyttää viestin näytöllä Arduino IDE:ssä (Tools >> Serial Monitor).
- suunnittelun avulla voit hallita ohjelman etenemistä yhdistämällä useita tarkastuksia yhteen paikkaan.
Jos(if) digitalRead palauttaa HIGH:n, sana "pressed" näkyy näytössä. Muussa tapauksessa (muuten) sana "painattu" näkyy näytössä. Nyt voit yrittää kytkeä LED-valon päälle ja pois päältä napin painalluksella.
//painikkeen painalluksen tunnistus LED-lähdöllä int buttonPin = 7; int ledPin = 8; void setup()( pinMode(buttonPin, INPUT);//tällä kertaa asetamme painikkeen nastaksi INPUT pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop()( if (digitalRead(buttonPin)= =KORKEA)( digitalWrite(ledPin,HIGH); Serial.println("painattu"); ) else ( digitalWrite(ledPin,LOW); Serial.println("painaamaton"); ) )

Analoginen tulo.

analoginen Read voit lukea tietoja yhdestä Arduinon analogisista nastaista ja antaa arvon välillä 0 (0 V) - 1023 (5 V). Jos jännite analogisessa sisääntulossa on 2,5 V, tulostetaan 2,5 / 5 * 1023 = 512
analoginen Read on vain yksi argumentti - Tämä on analogisen tulon numero (A0-A5). Seuraava piirros näyttää koodin jännitteen lukemiseksi potentiometristä. Liitä tätä varten säädettävä vastus, jonka ääripäätteet ovat 5V- ja GND-nastoissa ja keskimmäinen liitin A0-tuloon.

Suorita seuraava koodi ja katso sarjanäytöstä, kuinka arvot muuttuvat vastuksen nupin käännöksen mukaan.
//analoginen tulo int potPin = A0;//potentiometrin keskinasta on kytketty tähän nastaan void setup()( //analoginen nasta on oletusarvoisesti käytössä, joten alustusta ei tarvita Serial.begin(9600); ) void loop()( int potVal = analogRead(potPin);//potVal on numero välillä 0 ja 1023 Serial.println(potVal); )
Seuraava luonnos yhdistää painikkeen painalluksen luonnoksen ja LED-kirkkauden säätöluonnoksen. LED syttyy painikkeesta ja potentiometri ohjaa hehkun kirkkautta.
//painikkeen painalluksen tunnistus LED-lähdöllä ja vaihtelevalla intensiteetillä int buttonPin = 7; int ledPin = 9; int potPin = A0; void setup()( pinMode(buttonPin, INPUT); pinMode(ledPin, OUTPUT); Serial.begin(9600); ) void loop()( if (digitalRead(buttonPin)==HIGH)(//jos painiketta painetaan int analogVal = analogRead(potPin); int skaalattuVal = map(analogVal, 0, 1023, 0, 255); analogWrite(ledPin, skaalattuVal); // kytke LED päälle pottin asettaman intensiteetin Serial. println("pressed"); ) else ( digitalWrite(ledPin, LOW);//sammuta, jos painiketta ei paineta Serial.println("painamaton"); ) )

Uusien kotitekoisten tuotteiden toimitus postiin

Saat valikoiman uusia kotitekoisia tuotteita postitse. Ei roskapostia, vain hyödyllisiä ideoita!

Tässä artikkelissa päätin koota täydellisen vaiheittaisen oppaan Arduino-aloittelijoille. Analysoimme, mikä arduino on, mitä tarvitset oppimisen aloittamiseen, mistä ladata ja kuinka ohjelmointiympäristö asennetaan ja konfiguroidaan, kuinka se toimii ja kuinka ohjelmointikieltä käytetään, ja paljon muuta, mitä tarvitaan täysimittaisen luomiseen monimutkaisia laitteita, jotka perustuvat näiden mikro-ohjainten perheeseen.

Yritän tässä antaa lyhyen minimin, jotta ymmärrät Arduinon kanssa työskentelyn periaatteet. Jos haluat uppoutua täydellisemmin ohjelmoitavien mikro-ohjainten maailmaan, kiinnitä huomiota tämän sivuston muihin osiin ja artikkeleihin. Jätän linkkejä muihin tämän sivuston materiaaleihin joidenkin näkökohtien yksityiskohtaisempaa tutkimista varten.

Mikä Arduino on ja mihin se on tarkoitettu?

Arduino on elektroninen sarja, jonka avulla kuka tahansa voi luoda erilaisia sähkömekaanisia laitteita. Arduino koostuu ohjelmistoista ja laitteistoista. Ohjelmisto-osa sisältää kehitysympäristön (ohjelmiston kirjoitus- ja virheenkorjausohjelma), paljon valmiita ja käteviä kirjastoja sekä yksinkertaistetun ohjelmointikielen. Laitteisto-osa sisältää suuren valikoiman mikrokontrollereita ja valmiita moduuleja niitä varten. Tämän ansiosta työskentely Arduinon kanssa on erittäin helppoa!

Arduinon avulla voit oppia ohjelmointia, sähkötekniikkaa ja mekaniikkaa. Mutta tämä ei ole vain koulutuksen rakentaja. Sen perusteella voit tehdä todella hyödyllisiä laitteita.
Alkaen yksinkertaisista vilkkuvista valoista, sääasemista, automaatiojärjestelmistä ja päättyen älykkään kodin järjestelmiin, CNC-koneisiin ja miehittämättömiin lentokoneisiin. Mahdollisuuksia ei rajoita edes mielikuvituksesi, koska toteutusohjeita ja ideoita on valtava määrä.

Arduino Starter Kit

Jotta voit aloittaa Arduinon oppimisen, sinun on hankittava itse mikro-ohjainkortti ja lisätiedot. On parasta ostaa Arduino-aloituspakkaus, mutta voit myös noutaa kaiken tarvitsemasi itse. Suosittelen valitsemaan setin, koska se on helpompaa ja usein halvempaa. Tässä on linkkejä parhaisiin sarjoihin ja yksittäisiin osiin, joista on varmasti hyötyä opiskeluun:

Arduino-perussarja aloittelijoille:	Ostaa
Laaja sarja koulutusta ja ensimmäisiä projekteja varten:	Ostaa
Sarja lisäantureita ja moduuleja:	Ostaa
Arduino Uno on linjan yksinkertaisin ja kätevin malli:	Ostaa
Juoteton leipälauta helppoon oppimiseen ja prototyyppien luomiseen:	Ostaa
Joukko johtoja kätevillä liittimillä:	Ostaa
LED-sarja:	Ostaa
Vastussarja:	Ostaa
Painikkeet:	Ostaa
Potentiometrit:	Ostaa

Arduino IDE -kehitysympäristö

Jotta voit kirjoittaa, korjata ja ladata laiteohjelmiston, sinun on ladattava ja asennettava Arduino IDE. Tämä on erittäin yksinkertainen ja kätevä ohjelma. Sivustollani olen jo kuvaillut kehitysympäristön lataus-, asennus- ja konfigurointiprosessin. Siksi jätän tähän vain linkit ohjelman uusimpaan versioon ja

Versio	Windows	Mac-käyttöjärjestelmän kymmenes versio	Linux
1.8.2

Arduino ohjelmointikieli

Kun sinulla on mikro-ohjainkortti käsilläsi ja tietokoneellesi on asennettu kehitysympäristö, voit aloittaa ensimmäisten luonnosten (firmware) kirjoittamisen. Tätä varten sinun on perehdyttävä ohjelmointikieleen.

Arduino-ohjelmointi käyttää C++-kielen yksinkertaistettua versiota ennalta määritetyillä toiminnoilla. Kuten muissakin C:n kaltaisissa ohjelmointikielissä, koodin kirjoittamiseen on useita sääntöjä. Tässä alkeellisimmat:

Jokaisen lauseen jälkeen tulee olla puolipiste (;)
Ennen funktion ilmoittamista sinun on määritettävä funktion palauttama tietotyyppi tai void, jos funktio ei palauta arvoa.
Tietotyyppi on myös määritettävä ennen muuttujan ilmoittamista.
Kommentit on merkitty: // Inline ja /* block */

Sivulla voit oppia lisää tietotyypeistä, funktioista, muuttujista, operaattoreista ja kielirakenteista, sinun ei tarvitse muistaa ja muistaa kaikkia näitä tietoja. Voit aina mennä viitteeseen ja nähdä tietyn funktion syntaksin.

Kaikissa Arduinon laiteohjelmistoissa on oltava vähintään 2 toimintoa. Ne ovat setup() ja loop().

asetustoiminto

Jotta kaikki toimisi, meidän on kirjoitettava luonnos. Tehdään niin, että LED syttyy napin painalluksen jälkeen ja seuraavan painalluksen jälkeen sammuu. Tässä ensimmäinen luonnos:

// muuttujat liitettyjen laitteiden pinneillä int switchPin = 8; int ledPin = 11; // muuttujat painikkeen tilan ja LED-boolean tallentamiseen lastButton = LOW; boolean currentButton = LOW; boolean ledOn = false; void setup() ( pinMode(kytkinPin, INPUT); pinMode(ledPin, OUTPUT); ) // debounce-funktio boolean debounse(boolean last) ( boolean current = digitalRead(switchPin); if(viimeinen != nykyinen) ( viive (5) ); nykyinen = digitalRead(kytkinPin); ) paluuvirta (ledPin, ledOn);)

// muuttujat yhdistettyjen laitteiden pinneillä

int switchPin = 8;

int ledPin = 11;

// muuttujat painikkeen ja LEDin tilan tallentamiseen

boolean lastButton = LOW ;

boolean currentButton = LOW ;

boolean ledOn = false ;

void setup()(

pinMode (switchPin , INPUT ) ;

pinMode (ledPin , OUTPUT );

// debounce-toiminto

boolean debounce (boolen viimeinen ) (

boolen nykyinen = digitalRead(kytkinPin) ;

jos (viimeinen != nykyinen ) (

viive(5) ;

nykyinen = digitaalinenLue(kytkinPin) ;

paluuvirta ;

void loop()(

currentButton = debounce(lastButton) ;

if (lastButton == LOW && currentButton == HIGH ) (

ledOn = ! ledOn ;

lastButton = currentButton ;

digitalWrite(ledPin , ledOn );

Tässä luonnoksessa loin ylimääräisen palautustoiminnon kontaktin pomppimisen estämiseksi. Tietoja kontaktien palautumisesta on verkkosivuillani. Muista tarkistaa tämä materiaali.

PWM Arduino

Pulse Width Modulation (PWM) on prosessi, jolla ohjataan jännitettä ottamalla signaalin toimintajakso. Eli PWM:n avulla voimme ohjata kuormaa sujuvasti. Voit esimerkiksi muuttaa LEDin kirkkautta sujuvasti, mutta tämä kirkkauden muutos ei saavuteta vähentämällä jännitettä, vaan lisäämällä matalan signaalin intervalleja. PWM:n toimintaperiaate näkyy tässä kaaviossa:

Kun käytämme PWM:ää LEDiin, se alkaa nopeasti syttyä ja sammua. Ihmissilmä ei näe tätä, koska taajuus on liian korkea. Mutta kun kuvaat videota, näet todennäköisesti hetkiä, jolloin LED ei pala. Näin tapahtuu, jos kameran kuvataajuus ei ole PWM-taajuuden kerrannainen.

Arduinossa on sisäänrakennettu pulssinleveysmodulaattori. Voit käyttää PWM:ää vain niissä nastoissa, joita mikro-ohjain tukee. Esimerkiksi Arduino Unolla ja Nanolla on 6 PWM-lähtöä: nämä ovat nastat D3, D5, D6, D9, D10 ja D11. Pinssit voivat vaihdella muilla levyillä. Löydät kuvauksen sinua kiinnostavasta taulusta

PWM:n käyttöä varten Arduinossa on funktio, joka ottaa argumenteiksi pin-numeron ja PWM-arvon välillä 0 - 255. 0 on 0% korkea signaalitäyttö ja 255 on 100%. Kirjoita esimerkkinä yksinkertainen luonnos. Annetaan LEDin sytyttää tasaisesti, odottaa sekunti ja sammua yhtä tasaisesti ja niin edelleen loputtomiin. Tässä on esimerkki tämän toiminnon käytöstä:

// LED kytketty nastan 11 int ledPin = 11; void setup() ( pinMode(ledPin, OUTPUT); ) void loop() ( for (int i = 0; i< 255; i++) { analogWrite(ledPin, i); delay(5); } delay(1000); for (int i = 255; i >0; i--) ( analogWrite(ledPin, i); viive(5); ) )

// LED kytketty nastan 11

int ledPin = 11;

void setup()(

pinMode (ledPin , OUTPUT );

void loop()(

for (int i = 0 ; i< 255 ; i ++ ) {

analogWrite (ledPin , i );

viive(5) ;

viive(1000) ;

for (int i = 255 ; i > 0 ; i -- ) (

Arduino on erittäin suosittu kaikkien tee-se-itse-harrastajien keskuudessa. Se tulisi esitellä heille ja niille, jotka eivät ole koskaan kuulleet hänestä.

Mikä on Arduino?

Kuinka voit kuvailla Arduinoa lyhyesti? Parhaat sanat olisivat: Arduino on työkalu, jolla voit luoda erilaisia elektronisia laitteita. Itse asiassa tämä on todellinen laitteiston laskenta-alusta yleiseen käyttöön. Sitä voidaan käyttää sekä yksinkertaisten piirien rakentamiseen että melko monimutkaisten projektien toteuttamiseen.

Konstruktori perustuu sen laitteistoon, joka on I / O-kortti. Levy on ohjelmoitu C/C++:aan perustuvilla kielillä. Ne nimettiin vastaavasti Processing/Wiring. Ryhmästä C he perivät äärimmäisen yksinkertaisuuden, jonka ansiosta kuka tahansa henkilö hallitsee ne erittäin nopeasti, eikä tiedon soveltaminen käytännössä ole varsin merkittävä ongelma. Jotta saat käsityksen siitä, kuinka helppoa työskentely on, usein sanotaan, että Arduino on aloitteleville velhoille. Jopa lapset voivat käsitellä Arduino-levyjä.

Mitä siihen voi kerätä?

Arduinon käyttö on varsin monipuolista, sitä voidaan käyttää sekä yksinkertaisimpiin esimerkkeihin, joita suositellaan artikkelin lopussa, että melko monimutkaisiin mekanismeihin, mukaan lukien manipulaattorit, robotit tai tuotantokoneet. Jotkut käsityöläiset onnistuvat valmistamaan tabletteja, puhelimia, kodin valvonta- ja turvajärjestelmiä, älykotijärjestelmiä tai vain tietokoneita sellaisiin järjestelmiin perustuen. Arduino-projektit aloittelijoille, joiden kanssa kokematonkin voi aloittaa, ovat artikkelin lopussa. Niitä voidaan jopa käyttää primitiivisten virtuaalitodellisuusjärjestelmien luomiseen. Kaikki kiitos varsin monipuolisen laitteiston ja Arduinon ohjelmoinnin tarjoamien mahdollisuuksien.

Mistä ostaa komponentteja?

Italiassa valmistettuja komponentteja pidetään alkuperäisinä. Mutta tällaisten sarjojen hinta ei ole alhainen. Siksi monet yritykset tai jopa yksityishenkilöt valmistavat käsityönä Arduino-yhteensopivia laitteita ja komponentteja, joita kutsutaan leikkimielisesti tuotantoklooneiksi. Tällaisia klooneja ostettaessa on mahdotonta sanoa varmasti, että ne toimivat, mutta halu säästää rahaa vaatii veronsa.

Komponentit voidaan ostaa joko osana sarjoja tai erikseen. Saatavilla on jopa valmiita sarjoja autojen, erityyppisillä ohjaimilla varustettujen helikopterien tai laivojen kokoamiseen. Yllä olevan kuvan kaltainen setti, valmistettu Kiinassa, maksaa 49 dollaria.

Lisää laitteistosta

Arduino-kortti on yksinkertainen AVR-mikro-ohjain, joka on flash-latattu käynnistyslataimella ja jossa on vaadittu vähimmäis USB-UART-portti. Tärkeitä komponentteja on edelleen, mutta artikkelin rajoissa on parempi pysähtyä vain näihin kahteen komponenttiin.

Ensinnäkin mikro-ohjaimesta, mekanismista, joka on rakennettu yhdelle piirille, jossa kehitetty ohjelma sijaitsee. Ohjelmaan voidaan vaikuttaa painamalla painikkeita, vastaanottamalla signaaleja luomisen komponenteilta (vastukset, transistorit, anturit jne.) jne. Lisäksi anturit voivat olla hyvin erilaisia käyttötarkoitukseltaan: valaistus, kiihtyvyys, lämpötila, etäisyys, paine, esteitä jne. Näyttölaitteina voidaan käyttää yksinkertaisia osia LED-valoista ja diskanttikaiuttimista monimutkaisiin laitteisiin, kuten graafisiin näyttöihin. Moottoreina pidetään venttiilejä, releitä, servoja, sähkömagneetteja ja monia muita, joita on listattu hyvin, hyvin pitkään. Jollakin näistä listoista MK toimii suoraan käyttämällä liitäntäjohtoja. Jotkut mekanismit vaativat sovittimia. Mutta jos aloitat suunnittelun, sinun on vaikea irtautua. Nyt puhutaan Arduino-ohjelmoinnista.

Lue lisää kortin ohjelmointiprosessista

Ohjelmaa, joka on jo valmis toimimaan mikro-ohjaimen kanssa, kutsutaan laiteohjelmistoksi. Projekteja voi olla sekä yksi että Arduino-projekteja, joten jokainen laiteohjelmisto kannattaa tallentaa erilliseen kansioon oikeiden tiedostojen löytämisen nopeuttamiseksi. Se on ommeltu MK-kiteeseen erikoislaitteiden avulla: ohjelmoijat. Ja tässä "Arduinolla" on yksi etu - se ei tarvitse ohjelmoijaa. Kaikki tehdään niin, että Arduinon ohjelmointi aloittelijoille ei ole vaikeaa. Kirjoitettu koodi voidaan ladata MK:hen USB-kaapelin kautta. Tätä etua ei saavuta joku jo etukäteen rakennettu ohjelmoija, vaan erityinen laiteohjelmisto - käynnistyslatain. Bootloader on erityinen ohjelma, joka käynnistyy välittömästi yhteyden jälkeen ja kuuntelee, onko olemassa komentoja, flash-muistia, onko Arduino-projekteja vai ei. Käynnistyslataimen käytöllä on useita erittäin houkuttelevia etuja:

Vain yhden viestintäkanavan käyttö, mikä ei vaadi ylimääräisiä aikakustannuksia. Joten Arduino-projektit eivät vaadi sinua yhdistämään monia eri johtoja, ja niitä käytettäessä oli hämmennystä. Yksi USB-kaapeli riittää onnistuneeseen toimintaan.
Suoja kieroilta käsiltä. Mikro-ohjaimen saattaminen tiilen tilaan suoralla laiteohjelmistolla on melko helppoa, sinun ei tarvitse rasittaa paljon. Kun työskentelet käynnistyslataimen kanssa, et pääse mahdollisesti vaarallisiin asetuksiin (tietysti kehitysohjelman avulla, muuten voit rikkoa kaiken). Siksi Arduino aloittelijoille ei ole tarkoitettu vain siksi, että se on ymmärrettävää ja kätevää, sen avulla voit myös välttää ei-toivotut taloudelliset kulut, jotka liittyvät heidän kanssaan työskentelevän henkilön kokemattomuuteen.

Projektit alkamassa

Kun olet hankkinut sarjan, juotosraudan, hartsin ja juotteen, sinun ei pitäisi heti veistää kovin monimutkaisia rakenteita. Tietysti voit sokeuttaa heidät, mutta aloittelijoille tarkoitettu menestys Arduinossa on melko pieni monimutkaisissa projekteissa. Harjoittelua ja käsien "täyttämistä" varten voit yrittää toteuttaa muutamia yksinkertaisempia ideoita, jotka auttavat sinua käsittelemään Arduinon vuorovaikutusta ja toimintaa. Tällaisina ensimmäisinä askelina työskennellessäsi Arduinon kanssa aloittelijoille voimme neuvoa sinua harkitsemaan:

Luo sellainen, joka toimii "Arduinon" ansiosta.
Erillisen painikkeen yhdistäminen Arduinoon. Tässä tapauksessa on mahdollista saada painike ohjaamaan LEDin hehkua kohdasta nro 1.
Potentiometrin liitäntä.
Servo ohjaus.
Kytkentä ja toiminta kolmivärisellä LEDillä.
Pietsosähköisen elementin liitäntä.
Valovastuksen liitäntä.
Liiketunnistimen liittäminen ja signaalit sen toiminnasta.
Kosteus- tai lämpötila-anturin liittäminen.

Projekteja tulevaisuutta varten

On epätodennäköistä, että olet kiinnostunut "Arduinosta" yksittäisten LEDien yhdistämiseksi. Todennäköisesti sinua houkuttelee mahdollisuus luoda oma auto tai lentävä levysoitin. Tällaisia projekteja on vaikea toteuttaa, ne vaativat paljon aikaa ja sinnikkyyttä, mutta toteuttamalla ne saat mitä halusit: arvokasta Arduino-suunnittelukokemusta aloittelijoille.

Sarja artikkeleita ja opetusohjelmia, joissa on radioamatöörikokeita Arduinossa aloittelijoille. Tämä on sellainen radioamatöörilelu-suunnittelija, josta ilman juotosraudaa, piirilevyjen etsausta ja vastaavia mikä tahansa elektroniikassa toimiva vedenkeitin voi koota täysimittaisen toimivan laitteen, joka sopii sekä ammattimaiseen prototyyppiin että amatöörikokeisiin, kun elektroniikan opiskelua.

Arduino board for on tarkoitettu ensisijaisesti aloitteleville radioamatööreille mikro-ohjainten ohjelmoinnin perusteiden opettamiseen ja mikro-ohjainlaitteiden luomiseen omin käsin ilman vakavaa teoreettista koulutusta. Arduino-kehitysympäristön avulla voit kääntää ja ladata valmiin ohjelmakoodin levyn muistiin. Lisäksi koodin lataaminen on erittäin helppoa.

Arduino mistä aloittaa aloittelijalle

Ensinnäkin Arduino-levyn kanssa työskennelläkseen aloittelevan elektroniikkainsinöörin on ladattava Arduino-kehitysohjelma, se koostuu sisäänrakennetusta tekstieditorista, jossa työskentelemme ohjelmakoodin kanssa, viestialue, tekstitulostusikkuna (konsoli ), työkalupalkki, jossa on painikkeita usein käytettyjä komentoja varten ja useita valikkoja. Ohjelman lataamista ja kommunikointia varten tämä ohjelma liitetään Arduino-korttiin tavallisella USB-kaapelilla.

Arduino-ympäristössä kirjoitettua koodia kutsutaan luonnos. Se on kirjoitettu tekstieditorissa, jossa on erikoistyökalut tekstin lisäämiseen / leikkaamiseen, korvaamiseen / etsimiseen. Tallennuksen ja viennin aikana viestialue (katso kuva ensimmäisessä aloittelijoille tarkoitetussa opetusohjelmassa, juuri alla) näyttää selitykset, ja myös virheitä saattaa näkyä. Konsoli näyttää Arduino-viestejä, mukaan lukien täydelliset virheraportit ja muuta hyödyllistä tietoa. Työkalupalkin painikkeilla voit tarkistaa ja tallentaa luonnoksen, avata, luoda ja tallentaa sen, avata sarjaväylän valvonnan ja paljon muuta.

Joten siirrytään ensimmäiseen Arduino-piirituntiin aloitteleville elektroniikkainsinööreille.

Aloittelijan mukavuuden vuoksi Arduino UNO -ohjaimessa on jo vastus ja LED kytketty liittimen nastaan 13, joten emme tarvitse ulkoisia radioelementtejä ensimmäisessä kokeessa.

Lataamalla koodin Arduino sallii ohjelmamme osallistua järjestelmän alustukseen. Tätä varten osoitamme mikro-ohjaimelle komennot, jotka se suorittaa ensimmäisen käynnistyksen yhteydessä, ja sitten unohdamme ne kokonaan (eli Arduino suorittaa nämä komennot vain kerran käynnistyksen yhteydessä). Ja tätä tarkoitusta varten koodissamme varaamme lohkon, johon nämä komennot on tallennettu. void setup(), tai pikemminkin tässä tilassa tämän toiminnon kiharoiden aaltosulkeiden sisällä, katso ohjelmointipiirros.

Älä unohda kiharat henkselit! Jopa yhden niistä menettäminen tekee koko luonnoksesta täysin käyttökelvottoman. Mutta älä myöskään laita ylimääräisiä sulkuja, koska myös virhe tapahtuu.

Koodin lataus:

Luonnos kommentteineen ja selityksineen tiedostossa 001-1_mig-led.ino

Toiminto void loop() tähän laitamme komennot, jotka toimivat niin kauan kuin Arduino on päällä. Alkaen suorituksen ensimmäisestä komennosta, Arduino saavuttaa aivan loppuun ja hyppää välittömästi alkuun toistaakseen saman sarjan. Ja niin äärettömän monta kertaa, kunhan lauta saa virtaa. Pohjimmiltaan tyhjä silmukka on päätoiminto, Arduinoon pääsykohta.

Toiminto viive(1000) viivästyttää ohjelman käsittelyä 1000 millisekuntia. Kaikki tämä kulkee ikuisessa kierrossa loop().

Pääjohtopäätös ensimmäisen Arduino-ohjelmamme käsityksen jälkeen: Void loop- ja void setup -toimintojen avulla välitämme ohjeemme mikro-ohjaimelle. Kaikki asetuslohkon sisällä suoritetaan vain kerran. Silmukkamoduulin sisältö toistetaan silmukassa niin kauan kuin Arduino on päällä.

Edellisessä ohjelmassa LED-valon syttymisen ja sammumisen välillä oli yhden sekunnin viive. Yllä käytetyssä noviisi arduinistin yksinkertaisimmassa koodissa oli yksi iso miinus. Otimme käyttöön toiminnon, jotta LED-valon syttymisen ja sammuttamisen välinen tauko pysyy sekunnissa viive() ja siksi ohjain ei tällä hetkellä pysty suorittamaan muita päätoiminnon komentoja loop(). Koodin korjaus funktiossa loop( alla esitetty ) ratkaisee tämän ongelman.

Sen sijaan, että asettaisimme arvoksi HIGH ja sitten LOW, saamme ledPin-arvon ja käännämme sen. Oletetaan, että jos se oli KORKEA, siitä tulee MATALA jne.

Toinen arduino-koodin muunnos ohjaamaan lediä Tässä:

Sitten voit korvata toiminnon viive(). Sen sijaan on parempi käyttää toimintoa millis(). Se palauttaa ohjelman käynnistymisestä kuluneiden millisekuntien määrän. Toiminto ylittyy noin 50 päivän kuluttua koodin suorittamisesta.

Samanlainen toiminto on micros(), joka palauttaa koodin suorittamisen jälkeen kuluneiden mikrosekuntien määrän. Toiminto palautuu nollaan 70 minuutin kuluttua ohjelman suorittamisesta.

Tietenkin tämä lisää luonnostamme muutaman rivin koodia, mutta se tekee sinusta ehdottomasti kokenemman ohjelmoijan ja lisää Arduinosi potentiaalia. Tätä varten sinun tarvitsee vain opetella käyttämään millis-toimintoa.

On ymmärrettävä selvästi, että yksinkertaisin viivetoiminto keskeyttää koko Arduino-ohjelman suorittamisen, jolloin se ei pysty suorittamaan tehtäviä tänä aikana. Sen sijaan, että keskeytämme koko ohjelmamme, voimme laskea, kuinka paljon aikaa on kulunut ennen toiminnon valmistumista. Tämä on hienosti toteutettu millis()-funktiolla. Jotta kaikki olisi helppo ymmärtää, harkitsemme seuraavaa vaihtoehtoa LED-valon vilkkumiseksi ilman viivettä.

Tämän ohjelman alku on sama kuin minkä tahansa muun tavallisen Arduino-luonnoksen.

Tässä esimerkissä käytetään kahta Arduinon digitaalista I/O:ta. LED on kytketty nastan 8, joka on konfiguroitu OUTPUT. Painike on kytketty 9 kautta, joka on konfiguroitu INPUT. Kun painamme painiketta, nasta 9 asettuu asentoon HIGH ja ohjelma vaihtaa nastan 8 asentoon HIGH, mikä sytyttää LEDin. Painikkeen vapauttaminen palauttaa yhdeksännen lähdön LOW-tilaan. Koodi vaihtaa sitten nastan 8 asentoon LOW ja sammuttaa merkkivalon.

Viiden LEDin ohjaamiseksi käytämme erilaisia käsittelyjä Arduino-porttien kanssa. Tätä varten kirjoitamme tiedot suoraan Arduino-portteihin, jolloin voit asettaa LED-arvot yhdellä toiminnolla.

Arduino UNO:ssa on kolme porttia: B(digitaaliset tulot/lähdöt 8-13); C(analogiset tulot); D(Digitaalinen I/O:t 0–7)

Jokainen portti ohjaa kolmea rekisteriä. Ensimmäinen DDR määrittää, onko nastainen tulo vai lähtö. Toisen PORT-rekisterin avulla voit asettaa nastan HIGH- tai LOW-tilaan. Kolmannen avulla voit lukea tietoa Arduino-jalkojen tilasta, jos ne toimivat tulona.

Piirin toimintaan käytämme porttia B. Tätä varten aseta kaikki portin nastat digitaalisiksi lähdöiksi. Portissa B on yhteensä 6 nastaa. DDRB-rekisteribitit on asetettava sisään "1" jos nastaa käytetään OUTPUT-na, ja sisään "0" jos aiomme käyttää nastaa tulona (INPUT). Porttibitit on numeroitu 0-7, mutta niissä ei aina ole kaikkia 8 nastaa

Sanokaamme: DDRB = B00111110;// aseta portin B nastat 1-5 lähdöiksi ja 0 tuloksi.

Ajovalopiirissämme käytämme viittä lähtöä: DDRB = B00011111; // aseta portin B nastat 0 - 4 lähdöiksi.

Jos haluat kirjoittaa tietoja porttiin B, sinun on käytettävä PORTB-rekisteriä. Voit sytyttää ensimmäisen LEDin ohjauskomennolla: PORTB = B00000001;, ensimmäinen ja neljäs LED: PORTB=B00001001 ja niin edelleen

Binäärisiirtooperaattoreita on kaksi: vasen ja oikea. Vasemmanpuoleinen siirtooperaattori saa kaikki databitit liikkumaan vastaavasti vasemmalle, oikea siirtooperaattori siirtää niitä oikealle.

Esimerkki:

varA = 1; // 00000001
varA = 1 varA = 1 varA = 1

Palataan nyt ohjelmamme lähdekoodiin. Meidän on esitettävä kaksi muuttujaa: ylös alas sisältää arvot, mihin siirretään - ylös tai alas, ja toinen cylon osoittaa, mikä led syttyy.

Rakenteellisesti tällaisella LEDillä on yksi yhteinen lähtö ja kolme lähtöä jokaiselle värille. Alla on kaavio RGB-LEDin liittämisestä Arduino-levyyn yhteisellä katodilla. Kaikkien kytkentäpiirissä käytettävien vastusten tulee olla samanarvoisia 220-270 ohmia.

Yhteiseen katodiin kytkemiseksi kolmivärisen ledin kytkentäkaavio on melkein sama, paitsi että yhteistä nastaa ei kytketä maahan (laitteessa gnd), vaan +5 voltin liittimeen. Lähdöt Punainen, vihreä ja sininen molemmissa tapauksissa on kytketty säätimen 9, 10 ja 11 digitaalisiin lähtöihin.

Liitä ulkoinen LED Arduino UNO:n yhdeksänteen nastaan 220 ohmin resistanssilla. Viimeksi mainitun kirkkauden säätämiseksi sujuvasti käytämme toimintoa analogWrite(). Se tarjoaa PWM-signaalin ulostulon ohjaimen jalkaan. Ja joukkue pinMode() soittaminen ei ole pakollista. Koska analogWrite(pin,arvo) sisältää kaksi parametria: pin - pin-numero ulostulolle, arvo - arvo 0 - 255.

Koodi:
/*
Harjoitusesimerkki aloittelijalle arduinolle, paljastaa analogWrite () -komennon mahdollisuudet toteuttaa LEDin häivytysvaikutus
*/
int kirkkaus = 0; // LED-kirkkaus
int fadeAmount = 5; // kirkkausaskel
allekirjoittamaton pitkä currentTime;
allekirjoittamaton pitkä loopTime;

Void setup() (
pinMode(9, OUTPUT); // aseta nasta 9 lähdöksi
nykyinenAika = millis();
loopTime = currentTime;
}

void loop() (
nykyinenAika = millis();
if(currentTime >= (loopTime + 20))(
analogWrite(9, kirkkaus); // aseta arvo nastalle 9

Kirkkaus = kirkkaus + fadeAmount; // lisää kirkkauden muuttamisvaihe, joka asetetaan seuraavassa jaksossa

// jos min. tai max. arvot, sitten mennään vastakkaiseen suuntaan (käänteinen):
if (kirkkaus == 0 || kirkkaus == 255) (
fadeAmount = -fadeAmount ;
}
loopTime = currentTime;
}
}

Toimii Arduino kooderin kanssa

Anturi on suunniteltu muuttamaan kiertokulma sähköiseksi signaaliksi. Siitä saamme kaksi signaalia (A ja B), jotka ovat vastakkaisessa vaiheessa. Tässä opetusohjelmassa käytämme SparkFun COM-09117 -kooderia, jossa on kaksitoista asentoa kierrosta kohti (jokainen asento on täsmälleen 30°). Alla olevasta kuvasta näkyy selvästi, kuinka lähtö A ja B ovat riippuvaisia toisistaan, kun anturi liikkuu myötä- tai vastapäivään.

Jos signaali A menee positiivisesta nollaan, luetaan lähdön B arvo. Jos lähtö B on tuolloin positiivisessa tilassa, niin kooderi liikkuu myötäpäivään, jos B antaa nollatason, niin kooderi siirtyy sisään. vastakkaiseen suuntaan. Lukemalla molemmat lähdöt pystymme laskemaan pyörimissuunnan mikrokontrollerin avulla ja laskemalla pulsseja kooderin A-lähdöstä, pyörimiskulman.

Tarvittaessa voit käyttää taajuuslaskentaa määrittääksesi, kuinka nopeasti kooderi pyörii.

Ohjaamme LEDin kirkkautta PWM-lähdön avulla käyttämällä opetusohjelmassamme olevaa kooderia. Tietojen lukemiseen kooderista käytämme ohjelmistoajastimiin perustuvaa menetelmää, josta olemme jo keskustelleet.

Ottaen huomioon, että nopeimmassa tapauksessa voimme kääntää kooderin nuppia 180° 1/10 sekunnissa, tämä on 6 pulssia 1/10 sekunnissa tai 60 pulssia sekunnissa.

Todellisuudessa ei ole mahdollista pyörittää nopeammin. Koska meidän on seurattava kaikkia puolijaksoja, taajuuden tulisi olla noin 120 hertsiä. Otetaan täysin varmuuden vuoksi 200 Hz.

Koska tässä tapauksessa käytämme mekaanista kooderia, kosketuspomppu on mahdollista, ja matala taajuus suodattaa täydellisesti tällaisen pomppimisen.

Ohjelmistoajastinsignaalien mukaan on jatkuvasti verrattava kooderin lähdön A nykyistä arvoa edelliseen arvoon. Jos tila muuttuu positiivisesta nollaan, pollaamme lähdön B tilan. Tilakyselyn tuloksesta riippuen lisäämme tai vähennämme LEDin kirkkausarvon laskuria. Ohjelmakoodi, jonka aikaväli on noin 5 ms (200 Hz), näkyy alla:

Arduinon aloittelijakoodi:
/*
** Enkooderi
** Sparkfunin kooderia käytetään LED-valon kirkkauden säätämiseen
*/

int kirkkaus = 120; // LED-kirkkaus, alkaen puolikkaasta
int fadeAmount = 10; // kirkkausaskel
allekirjoittamaton pitkä currentTime;
allekirjoittamaton pitkä loopTime;
const int pin_A = 12; // tappi 12
const int pin_B = 11; // tappi 11
unsigned char encoder_A;
unsigned char encoder_B;
unsigned char encoder_A_prev=0;
void setup()(
// julistaa nastan 9 ulostuloksi:
pinMode(9, OUTPUT); // aseta nasta 9 lähdöksi
pinMode(pin_A, INPUT);
pinMode(pin_B, INPUT);
nykyinenAika = millis();
loopTime = currentTime;
}
void loop() (
nykyinenAika = millis();
if(currentTime >= (loopTime + 5))( // tarkista tilat 5 ms:n välein (taajuus 200 Hz)
kooderi_A = digitaalinenLue(pin_A); // lue kooderin lähtö A tila
enkooderi_B = digitaalinenLue(pin_B); // kooderin lähtö B
if((!encoder_A) && (encoder_A_prev))( // jos tila muuttuu positiivisesta nollaan
if(kooderi_B) (
// Lähtö B on positiivinen, joten kierto on myötäpäivään
// lisää hehkun kirkkautta, enintään 255
if(kirkkaus + fadeAmount )
muu(
// lähtö B on nollatilassa, joten kierto on vastapäivään
// vähentää kirkkautta, mutta ei alle nollan
if(kirkkaus - fadeAmount >= 0) brightness -= fadeAmount;
}

}
kooderi_A_edellinen = enkooderi_A; // tallenna A:n arvo seuraavaa silmukkaa varten

analogWrite(9, kirkkaus); // aseta kirkkaus yhdeksänteen nastaan

LoopTime = nykyinen aika;
}
}

Tässä aloittelijaesimerkissä tarkastellaan työskentelyä pietsosummerilla äänien luomiseksi. Tätä varten ota pietsosähköinen muunnin, jonka avulla voit luoda ääniaaltoja taajuusalueella 20 Hz - 20 kHz.

Tämä on sellainen amatööriradiomuotoilu, jossa LEDit sijaitsevat koko äänenvoimakkuuden alueella. Tämän järjestelmän avulla voit luoda erilaisia valaistus- ja animaatiotehosteita. Monimutkaiset mallit voivat jopa näyttää erilaisia kolmiulotteisia sanoja. Toisin sanoen tämä on alkeellinen surround-näyttö

Servo on pääelementti erilaisten radio-ohjattujen mallien rakentamisessa, ja sen ohjaus ohjaimella on yksinkertaista ja kätevää.

Ohjausohjelma on yksinkertainen ja intuitiivinen. Se alkaa yhdistämällä tiedosto, joka sisältää kaikki tarvittavat komennot servon ohjaamiseen. Seuraavaksi luomme servo-objektin, kuten servoMain. Seuraava setup()-funktio, jossa määritetään, että servo on kytketty ohjaimen yhdeksänteen lähtöön.

Koodi:
/*
Arduino Servo
*/
#sisältää
Servo tärkein; // Servo-objekti

Virheellinen asetus ()
{
servoMain.attach(9); // Servo kytketty nastan 9
}

Tyhjä silmukka()
{
servoMain.write(45); // Kierrä servoa vasemmalle 45°
viive (2000); // Odota 2000 millisekuntia (2 sekuntia)
servoMain.write(0); // Kierrä servoa vasemmalle 0°
viive (1000); // Tauko 1s.

viive (1500); // Odota 1,5 s.
servoMain.write(135); // Kierrä servoa oikealle 135°
viive (3000); // Tauko 3 s.
servoMain.write(180); // Kierrä servoa oikealle 180°
viive (1000); // Odota 1s.
servoMain.write(90); // Kierrä servoa 90°. keskiasento
viive (5000); // Tauko 5 s.
}

Päätoiminnossa loop(), annamme servomoottorille komennot, joiden välillä on taukoja.

Arduino-laskuripiiri 7-segmenttisessä indikaattorissa

Tämä yksinkertainen Arduino-projekti aloittelijoille on luoda laskuripiiri yhteiselle katodiselle 7-segmenttiselle näytölle. Alla olevalla koodilla voit aloittaa laskemisen 0–9, kun painat painiketta.

Seitsemän segmentin ilmaisin - on 8 LEDin yhdistelmä (viimeinen vastaa pisteestä) yhteisellä katodilla, joka voidaan kytkeä päälle halutussa järjestyksessä niin, että ne luovat numeroita. On huomattava, että tässä piirissä, katso alla oleva kuva, nastat 3 ja 8 on varattu katodille.

Oikealla on taulukko, joka näyttää Arduinon nastat ja LED-merkkinastat.

Tämän projektin koodi:

tavunumerot = (
B11111100, B01100000, B11011010, B11110010, B01100110,
B10110110, B10111110, B11100000, B11111110, B11100110
};
void setup()(
for(int i = 2; i pinMode(i, OUTPUT);
}
pinMode(9, INPUT);
}
int laskuri = 0;
bool go_by_switch = tosi;
int viimeinen_syötearvo = MATALA;
void loop() (
if(go_by_switch) (
int kytkin_tulon_arvo = digitaalinenLue(9);
if(viimeinen_syötearvo == MATALA && kytkin_syötearvo == KORKEA) (

}
viimeinen_syötearvo = kytkin_syötteen_arvo;
) muu (
viive (500);
laskuri = (laskuri + 1) % 10;
}
kirjoittaaNumber(laskuri);
}

Void writeNumber(int number) (
jos(numero 9) (
palata;
}
bytemask = numerot;
byte currentPinMask = B10000000;
for(int i = 2; i if(mask & currentPinMask) digitalWrite(i,HIGH);
muuten digitalWrite(i,LOW);
currentPinMask = currentPinMask >> 1;
}
}

Voit laajentaa Arduino-levyjen potentiaalia merkittävästi lisämoduulien avulla, jotka voidaan liittää lähes minkä tahansa laitteen PIN-lähtöihin. Harkitse suosituimpia ja mielenkiintoisimpia laajennusmoduuleja tai, kuten niitä myös kutsutaan, suojat.

Latenssilla Arduinossa on erittäin tärkeä rooli. Ilman niitä yksinkertaisinkaan esimerkki Blinkistä, joka vilkkuu LEDiä tietyn ajan kuluttua, ei toimi. Mutta useimmat aloittelevat ohjelmoijat tietävät vähän aikaviiveistä ja käyttävät vain Arduino-viivettä tietämättä tämän komennon sivuvaikutuksia. Tässä artikkelissa puhun yksityiskohtaisesti väliaikaisista toiminnoista ja niiden käytön ominaisuuksista Arduino IDE -kehitysympäristössä.

Arduinossa on useita erilaisia komentoja, jotka vastaavat ajan ja taukojen työstämisestä:

viive()
viivemikrosekuntia()
millis()
micros()

Ne eroavat tarkkuudesta ja niillä on omat ominaisuutensa, jotka tulee ottaa huomioon koodia kirjoitettaessa.

Käytä arduino-viivetoimintoa

Syntaksi

Arduino-viive on yksinkertaisin komento, ja sitä käyttävät useimmiten aloittelijat. Itse asiassa se on viive, joka keskeyttää ohjelman suluissa ilmoitetuksi millisekunteiksi. (Yhdessä sekunnissa on 1000 millisekuntia.) Suurin arvo voi olla 4294967295 ms, mikä vastaa suunnilleen 50 päivää. Katsotaanpa yksinkertaista esimerkkiä, joka havainnollistaa tämän komennon toimintaa.

Void setup() ( pinMode(13, OUTPUT); ) void loop() ( digitalWrite(13, HIGH); // signaalinasta 13 suuri viive (10000); // tauko 10000 ms tai 10 sekuntia digitalWrite13, LOW); // lähettää matalan signaalin nastalle 13 delay(10000); // tauko 10 000 ms tai 10 sekuntia)

Menetelmässä perustaa määräämme, että nastaa 13 käytetään lähtönä. Ohjelman pääosassa syötetään ensin korkea signaali nastalle, sitten tehdään 10 sekunnin viive. Tällä hetkellä ohjelma näyttää olevan keskeytetty. Sitten annetaan matala signaali ja taas viive ja kaikki alkaa alusta. Tuloksena saamme, että nastaa syötetään vuorotellen, sitten 5 V, sitten 0.

Sinun on ymmärrettävä selvästi, että viiveen käytön tauon aikana ohjelma keskeytyy, sovellus ei vastaanota tietoja antureilta. Tämä on Arduinon viivetoiminnon käytön suurin haitta. Voit kiertää tämän rajoituksen käyttämällä keskeytyksiä, mutta puhumme tästä erillisessä artikkelissa.

Viiveesimerkki vilkkuvalla LEDillä

Esimerkkikaavio havainnollistaa, kuinka viivetoiminto toimii.
Voit rakentaa piirin LEDillä ja vastuksella. Sitten saamme vakioesimerkin - LEDin vilkkumisen. Tätä varten sinun on kytkettävä LED positiiviseen koskettimeen nastassa, jonka määritimme ulostuloksi. Yhdistämme LEDin vapaan haaran noin 220 ohmin (vähän enemmän) vastuksen kautta maahan. Voit määrittää napaisuuden katsomalla sen sisäosia. Sisällä oleva iso kuppi on yhdistetty miinukseen ja pieni jalka on kytketty plussaan. Jos LED on uusi, voit määrittää napaisuuden johtojen pituuden perusteella: pitkä jalka on plus, lyhyt jalka on miinus.

delayMicroseconds -toiminto

Tämä toiminto on täydellinen analogi viiveelle, paitsi että sen yksiköt eivät ole millisekunteja, vaan mikrosekunteja (1000000 mikrosekuntia 1 sekunnissa). Suurin arvo on 16383, mikä vastaa 16 millisekuntia. Resoluutio on 4, mikä tarkoittaa, että luku on aina neljän kerrannainen. Esimerkkikatkelma näyttäisi tältä:

DigitalWrite(2, KORKEA); // lähetä pin 2 suuri viiveMicroseconds(16383); // tauko 16383µs digitalWrite(2, LOW); // lähettää matalan signaalin nastalle 2 delayMicroseconds(16383); // tauko 16383µs

Ongelma delayMicrosecondsissa on täsmälleen sama kuin viiveen kanssa - nämä toiminnot "roikkuvat" ohjelman kokonaan ja se kirjaimellisesti jäätyy hetkeksi. Tällä hetkellä on mahdotonta työskennellä porttien kanssa, lukea tietoja antureista ja suorittaa matemaattisia operaatioita. Vilkuille tämä vaihtoehto on hyvä, mutta kokeneet käyttäjät eivät käytä sitä suuriin projekteihin, koska tällaisia vikoja ei tarvita. Siksi on paljon parempi käyttää alla kuvattuja toimintoja.

millis-toiminto viiveen sijaan

Millis()-funktion avulla voit suorittaa viiveen viivytyksettä arduinossa, mikä ohittaa aiempien menetelmien puutteet. Millis-parametrin maksimiarvo on sama kuin viivetoiminnolla (4294967295ms tai 50 päivää).

Millejä käyttämällä emme pysäytä koko luonnoksen suorittamista, vaan yksinkertaisesti osoitamme, kuinka kauan arduinon tulisi yksinkertaisesti "ohittaa" täsmälleen se koodilohko, jonka haluamme keskeyttää. Toisin kuin viive, millis ei itse pysäytä mitään. Tämä komento yksinkertaisesti palauttaa meille mikro-ohjaimen sisäänrakennetusta ajastimesta kuinka monta millisekuntia on kulunut käynnistyksestä. Jokaisella silmukan kutsulla Mittaamme itse ajan, joka on kulunut viimeisestä koodimme kutsusta, ja jos aikaero on pienempi kuin haluttu tauko, jätämme koodin huomiotta. Heti kun ero on suurempi kuin haluttu tauko, suoritamme koodin, saamme nykyisen ajan samoilla milliseillä ja muistamme sen - tämä aika on uusi vertailupiste. Seuraavalla jaksolla lähtölaskenta on jo uudesta pisteestä ja jätämme koodin taas huomiotta, kunnes uusi millin ja aiemmin tallennetun arvon välinen ero saavuttaa jälleen halutun tauon.

Viivyttäminen ilman viivettä millisilla vaatii enemmän koodia, mutta se voi vilkkua LED-valoa ja keskeyttää luonnoksen pysäyttämättä järjestelmää.

Tässä on esimerkki, joka havainnollistaa selkeästi komennon toimintaa:

allekirjoittamaton pitkäaikainen; // Muuttuja viitepisteen tallentamiseen void setup() ( Serial.begin(9600); ) void loop() ( /* Tästä alkaa viive()-analogian suoritus. Laske nykyisen hetken ja aikaisemman hetken välinen ero tallennettu viitepiste. Jos ero on suurempi kuin Jos ei, älä tee mitään */ if (millis() - ajoitus > 10000)( // Korvaa 10000:n sijaan tarvitsemasi taukoarvo timing = millis(); Serial. println ( "10 sekuntia") ; ) )

Ensin otamme käyttöön ajoitusmuuttujan, joka tallentaa millisekuntien lukumäärän. Oletusarvoisesti muuttujan arvo on 0. Ohjelman pääosassa tarkastetaan ehto: jos millisekuntien määrä mikrokontrollerin käynnistyksestä miinus ajoitusmuuttujaan kirjoitettu luku on suurempi kuin 10000, niin suoritetaan toiminto viestin lähettämiseksi porttivalvontaan ja nykyinen aika-arvo kirjoitetaan muuttujaan. Ohjelman toiminnan seurauksena porttinäytössä näkyy viesti 10 sekuntia 10 sekunnin välein. Tämän menetelmän avulla voit vilkkua LED-valoa ilman viivettä.

mikros-toiminto viiveen sijaan

Tämä toiminto voi myös viivyttää ilman viive-komentoa. Se toimii täsmälleen samalla tavalla kuin millit, mutta se ei laske millisekunteja, vaan mikrosekunteja 4 µs:n resoluutiolla. Sen enimmäisarvo on 4294967295 mikrosekuntia tai 70 minuuttia. Ylivuodon yhteydessä arvo nollataan yksinkertaisesti nollaan, älä unohda sitä.

Yhteenveto

Arduino-alusta tarjoaa meille useita tapoja toteuttaa viivästystä projektissamme. Viiveellä voit nopeasti keskeyttää luonnoksen suorittamisen, mutta samalla estää mikro-ohjaimen toiminnan. Millis-komennon avulla voit päästä eroon Arduinon viiveestä, mutta tämä vaatii hieman enemmän ohjelmointia. Valitse paras menetelmä projektisi monimutkaisuuden mukaan. Yleensä yksinkertaisissa luonnoksissa ja alle 10 sekunnin viiveellä käytetään viivettä. Jos toimintalogiikka on monimutkaisempi ja vaaditaan suurta viivettä, on parempi käyttää milliä viiveen sijaan.