» Elektronika » Arduino »„ Arduino “pradedantiesiems

„Arduino“ pradedantiesiems


Arduino yra mikrovaldiklio plokštė, kurią galite užprogramuoti išorinių įrenginių valdymui. Su jutikliais, varikliais, šviesos diodais, garsiakalbiais ... ir net internetu jis sąveikauja su išoriniu pasauliu, todėl yra lanksti įvairių projektų platforma. Mikrokontrolerių yra nemažai, tačiau „Arduino“ yra populiarus dėl to, kad įvairūs projektai labai aktyviai išdėstomi ir aptariami internete. Jei ieškosite „Google“ ar „YouTube“, rasite milijonų idėjų ir informacijos, kad galėtumėte patys pradėti tyrinėti Arduino.
Net jei neturite patirties programuojant mikrovaldiklius - naudodami „Arduino“ greitai sužinosite ir sužinosite apie ką nors elektronika naudojant eksperimentus.

Ko reikia norint pradėti?
Arduino Uno- 1vnt
USB kabelis - 1vnt
Džemperiai 1vnt
1vnt vystymo lenta
Raudonas LED 4 vnt
220 omų rezistorius 4vnt
Rezistorius 10 kambarių 1 vnt
Mygtukas be tvirtinimo
Potenciometras
RGB LED su bendru katodu

Visa tai galima nusipirkti vietinėje radijo parduotuvėje arba užsisakyti internetu.

Elektros grandinėms demonstruoti ir modeliuoti buvo naudojamas internetinis simuliatorius.

Šis treniruoklis geriausiai veikia „Chrome“ naršyklėje.
Pažvelkime atidžiau į Arduino.

„Arduino“ nėra didelis kompiuteris, prie kurio gali jungtis išorinės grandinės. „Arduino Uno“ naudoja „Atmega 328P“
Tai yra didžiausias lustas plokštėje. Ši mikroschema vykdo programas, kurios saugomos jo atmintyje. Programą galite atsisiųsti per usb naudodamiesi „Arduino IDE“. „USB“ prievadas taip pat teikia arduino galią.

Yra atskira maitinimo jungtis. Lentelėje yra du išėjimai, pažymėti 5v ir 3,3v, kurie reikalingi įvairiems įrenginiams maitinti. Taip pat rasite kaiščių, pažymėtų kaip GND, tai yra įžeminimo laidai (įžeminimas lygus 0V). „Arduino“ platformoje taip pat yra 14 skaitmeninių išėjimų (kaiščių), pažymėtų skaičiais nuo 0 iki 13, kurie yra prijungti prie išorinių mazgų ir turi dvi būsenas - aukštą arba žemą (įjungta arba išjungta). Šie kontaktai gali veikti kaip išėjimai arba kaip įėjimai, t. jie gali perduoti kai kuriuos duomenis ir valdyti išorinius įrenginius arba priimti duomenis iš įrenginių. Šios išvados lentoje yra pažymėtos A0-A5. Tai yra analoginiai įėjimai, galintys priimti duomenis iš įvairių jutiklių. Tai ypač patogu, kai reikia matuoti diapazoną, pavyzdžiui, temperatūrą. Analoginiai įėjimai turi papildomų funkcijų, kurias galima suaktyvinti atskirai.


Kaip naudoti duonos lentą.

Duomenų lentelė reikalinga tam, kad laikinai sujungtumėte dalis ir patikrintumėte, kaip veikia įrenginys, prieš tai viską sudedant.
Visi šie pavyzdžiai yra surinkti ant lentos, kad galėtumėte greitai pakeisti grandinę ir pakartotinai naudoti dalis, nesivargindami su litavimu.

Duonos lentoje yra eilių skylių, į kurias galite įstatyti dalis ir laidus. Kai kurios iš šių skylių yra elektriškai sujungtos viena su kita.

Dvi viršutinės ir apatinės eilės yra sujungtos nuosekliai per visą plokštę. Šios eilutės naudojamos grandinei maitinti. Tai gali būti 5v arba 3,3v, tačiau bet kokiu atveju pirmas dalykas, kurį jums reikia padaryti, yra 5v ir GND prijungimas prie lentos, kaip parodyta paveikslėlyje. Kartais šios eilutės jungtys gali būti nutrauktos plokštės viduryje, tada, jei reikia, galite jas sujungti, kaip parodyta.




Likusios skylės, esančios lentos viduryje, yra sugrupuotos į penkias skyles. Jie naudojami grandinės dalims sujungti.

Pirmas dalykas, kurį mes prijungiame prie savo mikrovaldiklio, yra šviesos diodas. Elektros prijungimo schema parodyta paveikslėlyje.


Kodėl grandinėje reikia rezistoriaus? Tokiu atveju jis riboja srovę, praeinančią per LED. Kiekvienas šviesos diodas yra skirtas konkrečiai srovei, o jei ši srovė yra didesnė, šviesos diodas suges. Sužinokite, kokią vertę rezistorius turėtų naudoti pagal Ohmo įstatymą. Tiems, kurie nežino ar pamiršo, Ohmo įstatymas sako, kad yra tiesinė srovės priklausomybė nuo įtampos. Tai yra, kuo daugiau mes pritaikysime įtampą rezistoriui, tuo daugiau srovės tekės per jį.
V = I * R
Kur V-tampa visoje rezistoriuje
- srovė per rezistorių
R- atsparumas turi būti rastas.
Pirmiausia turime sužinoti įtampą visame rezistoriuje. Dauguma 3 mm arba 5 mm šviesos diodų, kuriuos naudosite, turi 3 V darbinę įtampą. Taigi, ant rezistoriaus turime atsipirkti 5-3 = 2v.

Tada mes apskaičiuojame srovę, einančią per rezistorių.
Dauguma 3 ir 5 mm šviesos diodų šviečia visu ryškumu, esant 20 mA srovei. Didesnė srovė gali juos išjungti, o mažesnio stiprumo srovė sumažins jų ryškumą nepadarydama jokios žalos.

Taigi, mes norime įjungti LED 5v grandinėje taip, kad jo srovė būtų 20mA. Kadangi visos dalys yra įtrauktos į vieną grandinę, rezistoriaus srovė taip pat bus 20 mA.
Mes gauname
2V = 20 mA * R
2V = 0,02A * R
R = 100 omų

100 omų yra mažiausias pasipriešinimas, geriau naudoti šiek tiek daugiau, nes šviesos diodų charakteristikos skiriasi.
Šiame pavyzdyje naudojamas 220 omų rezistorius. Vien todėl, kad autorius jų turi labai daug: mirkteli:.

Įstatykite šviesos diodą į skylutes plokštės viduryje taip, kad jo ilgasis gnybtas būtų prijungtas prie vieno iš rezistoriaus gnybtų. Prijunkite antrąjį rezistoriaus galą prie 5 V, o antrąjį šviesos diodo išėjimą - prie GND. Šviesos diodas turėtų užsidegti.

Atkreipkite dėmesį, kad yra skirtumas, kaip prijungti šviesos diodą. Srovė teka iš ilgesnio terminalo į trumpesnį. Diagramoje galima įsivaizduoti, kad srovė teka ta kryptimi, kur nukreiptas trikampis. Pabandykite apversti šviesos diodą ir pamatysite, kad jis neužsidegs.

Bet kaip jūs prijungiate rezistorių, visiškai nėra skirtumo. Galite jį apversti arba pabandyti prijungti prie kito šviesos diodo išvesties, tai neturės įtakos grandinės veikimui. Tai vis tiek apribos srovę per LED.

Arduino eskizo anatomija.

Arduino programos vadinamos eskizu. Jie susideda iš dviejų pagrindinių funkcijų. Funkcija sąranka ir funkcija kilpa
šios funkcijos viduje nustatysite visus pagrindinius nustatymus. Kokias išvadas veiks įvestis ar išvestis, kurias bibliotekas sujungti, inicijuoti kintamuosius. Funkcija Sąranka () Jis prasideda tik vieną kartą per eskizą, kai programa paleidžiama.
tai yra pagrindinė funkcija, kuri vykdoma po sąranka (). Tiesą sakant, tai yra pati programa. Ši funkcija veiks neribotą laiką, kol išjungsite maitinimą.

Mirksi „Arduino“ šviesos diodas




Šiame pavyzdyje mes sujungsime grandinę su šviesos diodu prie vieno iš „Arduino“ skaitmeninių kaiščių ir įjungsime bei išjungsime naudodami programą, taip pat sužinosite keletą naudingų funkcijų.



- ši funkcija naudojama sąranka () programos dalis ir naudojama išvadoms, kurias naudosite kaip įvestį, inicijuoti (INPUT) arba išeiti (REZULTATAI). Negalite skaityti ar rašyti duomenų iš kaiščio, kol to tinkamai nenustatėte pinMode. Ši funkcija turi du argumentus: pinNumber- Tai yra PIN kodas, kurį naudosite.

Režimas- nustato, kaip smeigtukas veiks. Prie įėjimo (INPUT) arba išeiti (REZULTATAI). Norėdami uždegti šviesos diodą, turime duoti signalą Arduino Norėdami tai padaryti, mes sukonfigūruojame kaištį, kad jis išeitų.
- ši funkcija skirta nustatyti būseną (valstija) pina (pinNumber). Yra dvi pagrindinės būsenos (paprastai yra 3), viena yra Aukštas, kaištis bus 5v, kitas yra Žemas o kaištis bus 0v. Taigi, norėdami uždegti LED, mes turime nustatyti aukštą lygį, esantį kaiščiui, prijungtam prie LED Aukštas.

- delsimas. Tarnaujama tam tikram laikotarpiui programos atidėjimui (ms).
Žemiau yra kodas, dėl kurio šviesos diodas mirksi.
// LED mirksėjimas

int ledPin = 7; // Arduino kaištis, prie kurio prijungtas šviesos diodas

negaliojanti sąranka () {
  pinMode (ledPin, OUTPUT); // nustatykite kaištį kaip EXIT
}

tuščia kilpa () {
  „digitalWrite“ (ledPin, HIGH); // užsidega šviesos diodas
  vėlavimas (1000); // vėlavimas 1000 ms (1 sek.)
  „digitalWrite“ (ledPin, LOW); // Išjunkite šviesos diodą
  vėlavimas (1000); // palaukite 1 sek
}


Mažas paaiškinimas kode.
Linijos, prasidedančios raide "//", yra Arduino komentarai, kurios juos ignoruoja.
Visos komandos baigiasi kabliataškiu; jei jas pamiršite, gausite klaidos pranešimą.

ledpinyra kintamasis. Kintamieji yra naudojami programose vertybėms saugoti. Šiame pavyzdyje kintamasis ledpin priskirtą reikšmę 7, tai yra Arduino PIN kodas. Kai Arduino programoje susiduria su kintama eilute ledpin , bus naudojama vertė, kurią mes nurodėme anksčiau.
Taigi įrašykite pinMode (ledPin, OUTPUT) panašus į įrašą „pinMode“ (7, OUTPUT).
Bet pirmuoju atveju jums pakanka pakeisti kintamąjį ir jis pasikeis kiekvienoje eilutėje, kur jis naudojamas, o antruoju atveju, norėdami pakeisti kintamąjį, turite pakeisti rašiklius kiekvienoje komandoje.

pirmoje eilutėje nurodo kintamojo tipą. Programuojant „Arduino“, svarbu visada nurodyti kintamųjų tipą. Kol kas reikia tik tai žinoti INT skelbia neigiamus ir teigiamus skaičius.
Žemiau pateikiama modeliavimas eskizas. Norėdami pamatyti grandinės veikimą, paspauskite start.



Kaip ir tikėtasi, šviesos diodas išsijungia ir užsidega po vienos sekundės. Pabandykite pakeisti vėlavimą, kad pamatytumėte, kaip tai veikia.

Kelių šviesos diodų valdymas.

Šiame pavyzdyje sužinosite, kaip valdyti kelis šviesos diodus. Norėdami tai padaryti, įdiekite dar 3 šviesos diodus ant plokštės ir prijunkite juos prie „Arduino“ varžų ir kaiščių, kaip parodyta žemiau.



Norėdami įjungti ir išjungti šviesos diodus savo ruožtu, turite parašyti tokią programą:
// Daugialypis LED mirksėjimas

int led1Pin = 4;
int led2Pin = 5;
int led3Pin = 6;
int led4Pin = 7;

negaliojanti sąranka () {
  // nustatykite kaiščius kaip EXIT
  pinMode (led1Pin, OUTPUT);
  pinMode (led2Pin, OUTPUT);
  pinMode (led3Pin, OUTPUT);
  pinMode (led4Pin, OUTPUT);
}

tuščia kilpa () {
  „digitalWrite“ (led1Pin, HIGH); // užsidega šviesos diodas
  vėlavimas (1000); // vėlavimas 1 sek
  „digitalWrite“ (led1Pin, LOW); // užgesino šviesos diodą
  vėlavimas (1000); // vėlavimas 1 sek

  // Atlikite tą patį su kitais 3 šviesos diodais
  „digitalWrite“ (led2Pin, HIGH); // užsidega šviesos diodas
  vėlavimas (1000); // vėlavimas 1 sek
  „digitalWrite“ (led2Pin, LOW); // užgesino šviesos diodą
  vėlavimas (1000); // vėlavimas 1 sek

  „digitalWrite“ (led3Pin, HIGH); // užsidega šviesos diodas
  vėlavimas (1000); // vėlavimas 1 sek
  „digitalWrite“ (led3Pin, LOW); // užgesino šviesos diodą
  vėlavimas (1000); // vėlavimas 1 sek

  „digitalWrite“ (led4Pin, HIGH); // užsidega šviesos diodas
  vėlavimas (1000); // vėlavimas 1 sek
  „digitalWrite“ (led4Pin, LOW); // užgesino šviesos diodą
  vėlavimas (1000); // vėlavimas 1 sek
}


Ši programa veiks gerai, tačiau tai nėra pats racionaliausias sprendimas. Kodas turi būti pakeistas. Norėdami, kad programa veiktų vėl ir vėl, naudosime vadinamą konstrukciją.
Ciklai yra patogūs, kai reikia kelis kartus pakartoti tą patį veiksmą. Aukščiau esančiame kode pakartojame eilutes

„digitalWrite“ (led4Pin, HIGH);
vėlavimas (1000);
„digitalWrite“ (led4Pin, LOW);
vėlavimas (1000); 

visas eskizo kodas priede už.zip [720 b] (atsisiuntimai: 1410)

LED ryškumo reguliavimas

Kartais programoje turėsite pakeisti šviesos diodų ryškumą. Tai galima padaryti naudojant komandą analoWrite (). Ši komanda taip greitai įjungia ir išjungia šviesos diodą, kad akis nemato šio mirgėjimo. Jei šviesos diodas bus įjungtas pusę laiko ir pusę išjungtas, vizualiai atrodys, kad jis šviečia per pusę savo ryškumo. Tai vadinama impulsų pločio moduliacija (angliškai PWM arba PWM). PWM naudojamas gana dažnai, nes jis gali būti naudojamas valdyti „analoginį“ komponentą naudojant skaitmeninį kodą. Ne visi Arduino kaiščiai yra tinkami šiems tikslams. Tik tos išvados, kuriomis remiantis padarytas toks paskyrimas "~"Pamatysite tai šalia kaiščių 3,5,6,9,10,11.
Prijunkite vieną iš savo šviesos diodų prie vieno iš PWM išėjimų (autoriui tai yra 9 kaištis). Dabar paleiskite mirksintį eskizą LED, bet pirmiausia pakeiskite komandą „digitalWrite“ () apie analoWrite (). analoWrite () Jis turi du argumentus: pirmasis yra kaiščio numeris, o antrasis yra PWM vertė (0–255), šviesos diodų atžvilgiu tai bus jų ryškumas, o elektriniams varikliams - sukimosi greitis. Žemiau pateiktas skirtingo LED ryškumo kodo pavyzdys.
// Pakeiskite šviesos diodo ryškumą

int ledPin = 9; // prie šio kaiščio prijungtas šviesos diodas
negaliojanti sąranka () {
  pinMode (ledPin, OUTPUT); // inicializuoja smeigtuką, kad jis būtų išvestas
}

tuščia kilpa () {
  analoWrite (ledPin, 255); // visas ryškumas (255/255 = 1)
  delsimas (1000); // pauzė 1 sek
  „digitalWrite“ (ledPin, LOW); // išjunkite šviesos diodą
  delsimas (1000); // pauzė 1 sek

  „analogWrite“ (ledPin, 191); // ryškumas esant 3/4 (191/255 ~ = 0,75)
  delsimas (1000); // pauzė 1 sek
  „digitalWrite“ (ledPin, LOW); // išjunkite šviesos diodą
  delsimas (1000); // pauzė 1 sek

  „analogWrite“ („ledPin“, 127); // pusės ryškumas (127/255 ~ = 0,5)
  delsimas (1000); // pauzė 1 sek
  „digitalWrite“ (ledPin, LOW); // išjunkite šviesos diodą
  delsimas (1000); // pauzė 1 sek

  „analogWrite“ („ledPin“, 63); // ketvirčio ryškumas (63/255 ~ = 0,25)
  delsimas (1000); // pauzė 1 sek
  „digitalWrite“ (ledPin, LOW); // išjunkite šviesos diodą
  delsimas (1000); // pauzė 1 sek
}


Pabandykite komandoje pakeisti PWM reikšmę analoWrite ()pamatyti, kaip tai veikia ryškumą.
Toliau sužinosite, kaip sklandžiai koreguoti ryškumą nuo visiško iki nulio. Žinoma, kodą galite nukopijuoti 255 kartus
analoWrite (ledPin, ryškumas);
uždelsimas (5); // trumpas uždelsimas
ryškumas = ryškumas + 1;

Bet, suprantate - tai nebus praktiška. Norėdami tai padaryti, geriausia naudoti FOR kilpą, kuri buvo naudojama anksčiau.
Šiame pavyzdyje naudojami du ciklai, vienas - ryškumui sumažinti nuo 255 iki 0
skirtas (vidinis ryškumas = 0; ryškumas = 0; ryškumas -) {

analoWrite (ledPin, ryškumas);
vėlavimas (5);

}

vėlavimas (5) naudojamas sulėtinti ryškumo pakilimo ir kritimo greitį 5 * 256 = 1280 ms = 1,28 sek.)
Pirmoje eilutėje naudojamas „ryškumas-"kad ryškumo vertė sumažėtų 1, kiekvieną kartą, kai ciklas kartojasi. Atminkite, kad ciklas veiks tol, kol ryškumas> = 0Ženklo pakeitimas > ant ženklo >= į ryškumo diapazoną įtraukėme 0. Šis eskizas modeliuojamas žemiau.
// sklandžiai keiskite ryškumą

int ledPin = 9; // LED yra prijungtas prie šio kaiščio

negaliojanti sąranka () {
  pinMode (ledPin, OUTPUT); // inicijuokite PIN kodą, kad išeitumėte
}

tuščia kilpa () {
  // palaipsniui didinkite ryškumą (nuo 0 iki 255)
  skirtas (vidinis ryškumas = 0; ryškumas = 0; ryškumas -) {
    analoWrite (ledPin, ryškumas);
    vėlavimas (5);
  }

  vėlavimas (1000); // palaukite 1 sek
 // sklandžiai sumažinkite ryškumą (nuo 255 iki 0)
  skirtas (vidinis ryškumas = 255; ryškumas> = 0; ryškumas -) {
    analoWrite (ledPin, ryškumas);
    vėlavimas (5);
  }

  vėlavimas (1000); // palaukite 1 sek
}
}

Tai nelabai matoma, tačiau idėja aiški.



RGB LED ir „Arduino“

RGB LED iš tikrųjų yra trys skirtingų spalvų šviesos diodai viename korpuse.



Įtraukdami skirtingus šviesos diodus su skirtingu ryškumu, galite derinti ir gauti skirtingas spalvas. Arduino, kur ryškumo gradacijų skaičius yra 256, gaunamos 256 ^ 3 = 16581375 galimos spalvos. Realybėje, žinoma, jų bus mažiau.
Šviesos diodas, kurį naudosime, yra įprastas katodas. T. y. visi trys šviesos diodai yra struktūriškai sujungti katodais į vieną gnybtą. Mes prijungsime šį kaištį prie GND kaiščio. Likę gnybtai per ribojančius varžus turi būti prijungti prie PWM gnybtų. Autorius pasinaudojo išvadomis 9-11, taigi bus galima valdyti kiekvieną šviesos diodą atskirai. Pirmasis eskizas parodo, kaip įjungti kiekvieną šviesos diodą atskirai.



// RGB LED - testas

// kaištinės jungtys
int raudona = 9;
int žalia = 10;
int mėlyna = 11;

negaliojanti sąranka () {
  pinMode (raudona, OUTPUT);
  pinMode (mėlyna, IŠORĖ);
  pinMode (žalia, OUTPUT);
}

tuščia kilpa () {
  // raudono šviesos diodo įjungimas / išjungimas
  „digitalWrite“ (raudona, AUKŠTA);
  vėlavimas (500);
  „digitalWrite“ (raudona, maža);
  vėlavimas (500);
  
  // žalios šviesos diodo įjungimas / išjungimas
  „digitalWrite“ (žalia, AUKŠTA);
  vėlavimas (500);
  „digitalWrite“ (žalia, LOW);
  vėlavimas (500);

  // įjungti / išjungti mėlyną šviesos diodą
  „digitalWrite“ (mėlyna, AUKŠTA);
  vėlavimas (500);
  „digitalWrite“ (mėlyna, maža);
  vėlavimas (500);
}


Šiame pavyzdyje naudojamos komandos analoWrite () ir gauti įvairias atsitiktines šviesos diodų ryškumo vertes. Pamatysite, kad skirtingos spalvos keičiasi atsitiktinai.
// RGB LED - atsitiktinės spalvos

// kaištinės jungtys
int raudona = 9;
int žalia = 10;
int mėlyna = 11;
negaliojanti sąranka () {
  pinMode (raudona, OUTPUT);
  pinMode (mėlyna, IŠORĖ);
  pinMode (žalia, OUTPUT);
}
tuščia kilpa () {
  // pasirinkti atsitiktinę spalvą
  analoWrite (raudona, atsitiktinė (256));
  analoWrite (mėlyna, atsitiktinė (256));
  analoWrite (žalia, atsitiktinė (256));
  vėlavimas (1000); // palaukite vieną sekundę
}


Atsitiktinis (256)-Grąžina atsitiktinį skaičių nuo 0 iki 255.
Pridedamame faile yra eskizas, parodantis sklandų spalvų perėjimą iš raudonos į žalią, tada į mėlyną, raudoną, žalią ir kt. perėjimai.zip [373 b] (atsisiuntimai: 386)
Pavyzdinis eskizas veikia, tačiau yra daugybė kodo. Kodą galite supaprastinti parašydami savo pagalbininko funkciją, kuri sklandžiai pakeis spalvą kita.
Štai kaip tai atrodys: funkcija.zip [263 b] (atsisiuntimai: 420)
Pažvelkime į funkcijos apibrėžimą dalimis. Funkcija iškviečiama faderis ir turi du argumentus. Kiekvienas argumentas yra atskirtas kableliu ir jo tipas nurodomas pirmoje funkcijos apibrėžimo eilutėje: tuščias faderis (1 spalva, 2 spalva). Matote, kad abu argumentai yra deklaruojami kaip int, ir jiems suteikiami vardai spalva1 ir spalva2 kaip sąlyginiai kintamieji funkcijai apibrėžti. Negalioja reiškia, kad funkcija negrąžina jokių reikšmių, ji tiesiog vykdo komandas. Jei reiktų parašyti funkciją, kuri grąžina daugybos rezultatą, ji atrodytų taip:
int daugiklis (int skaičius1, int skaičius2) {

int produktas = skaičius1 * skaičius2;
grąžinti prekę;

} 

Atkreipkite dėmesį, kaip mes paskelbėme tipą int kaip grąžinimo tipas
tuštuma.
Funkcijos viduje yra komandos, kurias jau naudojote ankstesniame eskize, tik PIN kodai buvo pakeisti spalva1 ir spalva2. Funkcija iškviečiama faderis, jos argumentai apskaičiuojami taip: spalva1 = raudona ir spalva2 = žalia. Visas archyvo eskizas naudojant funkcijas funkcijos.zip [392 b] (atsisiuntimai: 320)

Mygtukas

Kitame eskize bus naudojamas mygtukas su paprastai atidarytais kontaktais, be tvirtinimo.

„Arduino“ pradedantiesiems

Tai reiškia, kad kol mygtukas nespaudžiamas, srovė per jį netekėja, o atleidus mygtuką mygtukas grįžta į pradinę padėtį.
Grandinėje, be mygtuko, naudojamas rezistorius. Tokiu atveju jis neriboja srovės, bet „traukia“ mygtuką iki 0v (GND). T. y. kol mygtukas nebus paspaustas ant Arduino smeigtuko, prie kurio jis prijungtas, lygis bus žemas. Rezistorius, naudojamas 10 kΩ grandinėje.

// apibrėžkite mygtuko paspaudimą
int mygtukasPin = 7;
negaliojanti sąranka () {
  pinMode (buttonPin, INPUT); // inicializuoja įvesties kaištį
  Serial.begin (9600); // inicijuokite nuoseklųjį prievadą
}
tuščia kilpa () {
  if (digitalRead (buttonPin) == HIGH) {// jei paspaudžiamas mygtukas
    Serial.println („prispaustas“); // spausdinti "spausti"
  } dar {
    Serial.println („unpressed“); // kitaip „unpressed“
  }
}

Šiame eskize yra kelios naujos komandos.
-Ši komanda vertina aukštą (aukštą lygį) ir žemą (žemą lygį) išvesties, kurią mes tikriname. Pirmiausia, sąrankoje (), šis išėjimas turi būti sukonfigūruotas įėjimui.
; // kur mygtukasPin yra PIN kodas, prie kurio prijungtas mygtukas.
Serijinis prievadas leidžia siųsti „Arduino“ pranešimus į kompiuterį, o pats valdiklis vykdo programą. Tai naudinga derinant programą, siunčiant pranešimus į kitus įrenginius ar programas. Norėdami įjungti duomenų perdavimą per nuoseklųjį prievadą (dar vadinamą UART arba USART), turite jį inicijuoti sąrankoje ()

Serial.begin () turi tik vieną argumentą - duomenų perdavimo greitis tarp Arduino ir kompiuterio.
eskizas, komanda naudojama pranešimui ekrane parodyti „Arduino IDE“ (Įrankiai >> Serijos monitorius).
- dizainas leidžia kontroliuoti programos eigą derinant kelis patikrinimus vienoje vietoje.
Jei (jei) „digitalRead“ grįžta aukštai, tada monitoriuje rodomas žodis „paspaustas“. Kitu atveju monitoriuje rodomas žodis „išspaustas“. Dabar galite pabandyti įjungti ir išjungti šviesos diodą vienu mygtuko paspaudimu.
// mygtuko paspaudimo aptikimas su LED išvestimi
int mygtukasPin = 7;
int ledPin = 8;
negaliojanti sąranka () {
  pinMode (buttonPin, INPUT); // šį kartą mygtuko kaištį nustatysime kaip INPUT
  pinMode (ledPin, OUTPUT);
  „Serial.begin“ (9600);
}
tuščia kilpa () {
  if (digitalRead (buttonPin) == HIGH) {
    „digitalWrite“ (ledPin, HIGH);
    Serial.println („prispaustas“);
  } dar {
    „digitalWrite“ (ledPin, LOW);
    Serial.println („nespausdintas“);
  }
}


Analoginis įėjimas.

analoginis skaitymas leidžia nuskaityti duomenis iš vieno „Arduino“ analoginių kaiščių ir rodo vertę nuo 0 (0 V) iki 1023 (5 V). Jei įtampa ties analogine įvestimi yra 2,5 V, tada bus išspausdinta 2,5 / 5 * 1023 = 512
analoginis skaitymas turi tik vieną argumentą - tai yra analoginis įvesties numeris (A0-A5). Šis eskizas pateikia kodą, kurį naudojant galima nuskaityti įtampą iš potenciometro. Norėdami tai padaryti, prijunkite kintamą rezistorių, kraštutinius kaiščius prie 5 V ir GND kaiščių, o vidurinį kaištį - prie įvesties A0.


Paleiskite šį kodą ir nuosekliajame monitoriuje pažiūrėkite, kaip vertės keičiasi priklausomai nuo rezistoriaus rankenėlės sukimosi.
// analoginis įėjimas

int potPin = A0; // centrinis potenciometro išėjimas yra prijungtas prie šio kaiščio

negaliojanti sąranka () {
  // analoginis kaištis įgalinamas įvedus pagal numatytuosius nustatymus, todėl inicializuoti nereikia
  „Serial.begin“ (9600);
}

tuščia kilpa () {
  int potVal = analogRead (potPin); // potVal yra skaičius nuo 0 iki 1023
  Serial.println (potVal);
}

Kitas eskizas apjungia mygtuko paspaudimo eskizą ir LED ryškumo valdymo eskizą. Šviesos diodas įsijungs nuo mygtuko, o potenciometras valdys švytėjimo ryškumą.
// mygtuko paspaudimo aptikimas su LED išvestimi ir kintamu intensyvumu
int mygtukasPin = 7;
int ledPin = 9;
int potPin = A0;
negaliojanti sąranka () {
  pinMode (buttonPin, INPUT);
  pinMode (ledPin, OUTPUT);
  „Serial.begin“ (9600);
}
tuščia kilpa () {
  if (digitalRead (buttonPin) == HIGH) {// jei paspaudžiamas mygtukas
    int analogVal = analogRead (potPin);
    int scaledVal = žemėlapis (analoginisVal, 0, 1023, 0, 255);
    analoWrite (ledPin, scaledVal); // įjunkite ledą su puodo nustatytu intensyvumu
    Serial.println („prispaustas“);
  } dar {
    „digitalWrite“ (ledPin, LOW); // išjunkite, jei mygtukas nėra paspaudžiamas
    Serial.println („nespausdintas“);
  }
}
8.7
9
9

Pridėti komentarą

    • šypsotisšypsosixaxagerainežiniaYahoonea
      viršininkassubraižytikvailystaiptaip-taipagresyvusslapta
      atsiprašaušoktišokis2šokis3atleiskpadėtigėrimai
      sustotidraugaigeraigerašvilpukassupyktiliežuvis
      rūkytiplojimaiklastingaspareikštiniokojantisdon-t_mentionatsisiųsti
      šilumanedrąsusjuoktis1mdasusitikimasmoskingneigiamas
      not_ipopkornasnubaustiskaitytigąsdintigąsdinapaieška
      gundytiačiūtaito_clueumnikūmussusitarti
      blogaibičiųjuoda akisblum3skaistalaipasigirtinuobodulys
      cenzūruotamalonumasslapta2grasintipergalėju„sun_bespectacled“
      šoktipagarbalolišlenktaslaukiamekrutojusya_za
      ya_dobryipagalbininkasne_huliganne_othodifludisuždraustiarti
4 komentaras
Štai kaip jis veikia, kaip turėtų - // palaipsniui didinkite ryškumą (nuo 0 iki 255)
skirtas (vidinis ryškumas = 0; ryškumas <= 255; ryškumas ++) {
analoWrite (ledPin, ryškumas);
vėlavimas (5);
kompiliavimo metu duoda klaidą Arduino: 1.6.5 („Windows 7“), lenta „Arduino Nano, ATmega328“

„sketch_sep20a: 25“: klaida: laukiama deklaracija prieš „}“ prieigos raktą
laukiama deklaracija prieš „}“ žetoną
Nukopijavau sklandaus uždegimo eskizą.
Mano LED lemputė ryškiai užsidega, tačiau ji užgęsta sklandžiai.

Paaiškink, prašau.
Nukopijavau sklandaus uždegimo eskizą.
Mano LED lemputė ryškiai užsidega, tačiau ji užgęsta sklandžiai.

Paaiškink, prašau.

Mes patariame perskaityti:

Perduokite jį išmaniajam telefonui ...