Arduino programming para sa mga dummies. Mga wika sa programming
Kakailanganin mong
- Arduino UNO board;
- USB cable (USB A - USB B);
- Personal na computer;
- Light-emitting diode;
- isang pares ng pagkonekta ng mga wire na 5-10 cm ang haba;
- kung magagamit - breadboard.
I-download ang Arduino development environment (Arduino IDE) mula sa opisyal na website para sa iyong operating system (Windows, Mac OS X, Linux ay suportado). Maaari mong piliin ang installer ( installer), maaari mong i-archive ( ZIP file para sa hindi admin na pag-install). Sa pangalawang kaso, ang programa ay inilunsad lamang mula sa folder, nang walang pag-install. Ang na-download na file ay naglalaman, bilang karagdagan sa development environment, mga driver para sa mga board ng Arduino family.
I-download ang Arduino IDE mula sa opisyal na website
2 Koneksyon sa Arduino sa kompyuter
Ikonekta ang Arduino board gamit ang isang USB cable (USB-A hanggang USB-B type) sa computer. Dapat umilaw ang berdeng ON LED sa board.
Cable "USB-A - USB-B" para sa pagkonekta ng Arduino sa computer 3 Pag-install ng driver para sa Arduino
I-install ang driver para sa Arduino. Isaalang-alang ang opsyon sa pag-install sa operating system ng Windows. Upang gawin ito, maghintay hanggang i-prompt ka ng operating system na i-install ang driver. Tanggihan. Pindutin ang mga key Manalo+I-pause, tumakbo tagapamahala ng aparato. Maghanap ng isang seksyon "Mga Port (COM at LPT)". Makakakita ka ng port doon na may pangalan Arduino UNO (COMxx). I-right click ito at piliin I-update ang driver. Sabihin sa operating system ang lokasyon ng driver. Ito ay matatagpuan sa subdirectory mga driver sa folder na kakadownload lang namin.
Tandaan ang port kung saan nakakonekta ang Arduino board. Upang malaman ang numero ng port, ilunsad ang Device Manager at hanapin ang seksyong "Mga Port (COM at LPT)". Ipapahiwatig ang numero ng port sa mga panaklong pagkatapos ng pangalan ng board. Kung ang board ay wala sa listahan, subukang idiskonekta ito mula sa computer at maghintay ng ilang segundo, pagkatapos ay ikonekta itong muli.
Arduino sa Windows Device Manager 4 Mga setting Arduino IDE
Ituro ang development environment sa iyong board. Upang gawin ito sa menu Tools Board pumili Arduino UNO.
Piliin ang Arduino UNO board sa mga setting Tukuyin ang bilang ng COM port kung saan nakakonekta ang Arduino board: Port ng Mga Tool.
Itakda ang serial port kung saan nakakonekta ang Arduino board 5 Buksan ang halimbawa mga programa
Ang kapaligiran ng pag-unlad ay naglalaman na ng maraming halimbawa ng mga programa para sa pag-aaral ng pagpapatakbo ng lupon. Buksan ang halimbawang "Blink": Mga Sample ng File 01.Basics Blink.Sa pamamagitan ng paraan, ang mga programa para sa Arduino ay tinatawag na "mga sketch".
Magbukas ng isang halimbawang sketch para sa Arduino 6 Pagpupulong ng circuit may LED
Idiskonekta ang Arduino mula sa computer. Ipunin ang circuit tulad ng ipinapakita sa figure. Pakitandaan na ang maikling binti ng LED ay dapat na konektado sa GND pin, ang mahabang binti sa digital pin "13" ng Arduino board. Maginhawang gumamit ng breadboard, ngunit kung wala kang isa, ikonekta ang mga wire na may twist.
Ang digital pin na "13" ay may built-in na risistor sa board. Samakatuwid, kapag kumokonekta sa isang LED sa board, hindi kinakailangan na gumamit ng isang panlabas na kasalukuyang naglilimita sa risistor. Kapag ikinonekta ang isang LED sa anumang iba pang mga Arduino pin, kinakailangan na gumamit ng isang risistor, kung hindi, susunugin mo ang LED, at sa pinakamasamang kaso, ang Arduino port kung saan nakakonekta ang LED!
Diagram ng koneksyon ng LED sa Arduino sa memorya ng Arduino
Ngayon ay maaari mong i-load ang programa sa memorya ng board. Ikonekta ang board sa computer, maghintay ng ilang segundo habang nagsisimula ang board. I-click ang button I-download, at ang iyong sketch ay isusulat sa memorya ng Arduino board. Ang LED ay dapat magsimulang kumikislap nang masaya sa iyo bawat 2 segundo (1 segundo sa, 1 segundo off). Nasa ibaba ang code para sa aming unang Arduino program.
void setup() (// initialization block pinMode(13, OUTPUT); // itakda ang pin 13 bilang output. } void loop() (// loop na walang katapusang umuulit hangga't naka-on ang board: digitalWrite(13, HIGH); // maglapat ng mataas na antas sa pin 13 - sindihan ang LED delay(1000); // para sa 1000 ms = 1 segundo. digitalWrite(13, LOW); // ilapat ang isang mababang antas sa pin 13 - patayin ang pagkaantala ng LED (1000); // para sa 1 segundo. } // pagkatapos ay umuulit ang cycleBasahin ang mga komento sa teksto ng programa - sapat na ang mga ito upang maunawaan ang aming unang eksperimento. Una naming inilalarawan ang initialization block setup(), kung saan itinakda namin ang mga paunang halaga ng mga variable at ang mga pag-andar ng mga Arduino pin. Isang walang katapusang loop ang sumusunod loop(), na umuulit nang paulit-ulit hangga't may ibinibigay na kuryente sa board. Sa cycle na ito ginagawa namin ang lahat ng kinakailangang aksyon. Sa kasong ito, i-on at i-off namin ang LED. Operator pagkaantala() tumutukoy sa tagal ng pagpapatupad (sa millisecond) ng naunang pahayag. Operator digitalWrite() nagsasabi sa Arduino kung saang pin ilalapat ang boltahe, at kung ano mismo ang antas ng boltahe. Ang iyong unang sketch ay handa na!
Mayroong maraming mga site sa network na nakatuon sa pagtatrabaho sa mga board ng pamilya ng Arduino. Magbasa, master, huwag matakot na mag-eksperimento at matuto ng mga bagong bagay! Ito ay isang masaya at kapakipakinabang na aktibidad na magdadala sa iyo ng maraming kasiyahan.
tala
Mag-ingat kapag nagtatrabaho sa Arduino board - ito ay isang elektronikong produkto na nangangailangan ng maingat na paghawak. May mga nakalantad na conductor sa ilalim ng board, at kung ilalagay mo ang board sa isang conductive surface, may posibilidad na masunog ang board. Gayundin, huwag hawakan ang board na may basa o basang mga kamay at iwasan ang mga basang lugar kapag nagtatrabaho.
28 09.2016
Naisip mo na bang gawing mas madali ang iyong buhay sa bahay? Upang magkaroon ng mga bagay na makakalutas sa pang-araw-araw, nakagawiang mga gawain para sa iyo. Isang matalinong device na magsasagawa ng isang kapaki-pakinabang na function, halimbawa, pagdidilig sa hardin, paglilinis ng silid, o pagdadala ng kargada. Ang mga problemang ito ay maaaring malutas. Ngunit ang pagbili lamang nito ay hindi sapat. Ang anumang pang-industriyang logic controller o chip ay nangangailangan ng isang "utak" upang maisagawa ang isang tiyak na pagkakasunud-sunod ng mga aksyon. Upang magsagawa ng mga operasyon sa aming kaso, ang Arduino programming language ay angkop.
Mula sa artikulong ito matututunan mo ang:
Pagbati, mga kaibigan! Para sa mga hindi nakakakilala sa akin, ang pangalan ko ay Gridin Semyon. Maaari mong basahin ang tungkol sa akin. Ang artikulo ngayon ay ilalaan sa dalawang pangunahing programa, kung wala ito ay hindi tayo magkakaroon ng karagdagang paggalaw at pag-unawa sa isa't isa.
Pangkalahatang paglalarawan ng mga programming language
Tulad ng isinulat ko sa itaas, isasaalang-alang namin ang dalawang sikat na kapaligiran sa pag-unlad. Sa pamamagitan ng pagkakatulad sa, ay maaaring hatiin sa isang graphic editor at isang "smart notepad". Ito ang mga Arduino IDE at FLprog program.
Ang batayan ng development environment ay Processing/Wiring - ito ay regular na C++, na dinagdagan ng mga function at iba't ibang library. Mayroong ilang mga bersyon para sa Windows, Mac OS at Linux operating system.
Ano ang kanilang pangunahing pagkakaiba?? Ang Arduino IDE ay isang development environment na naglalarawan ng program code. At ang FLprog ay katulad ng CFC CoDeSyS, na nagpapahintulot sa iyo na gumuhit ng mga diagram. Aling kapaligiran ang mas mahusay? Parehong mahusay at maginhawa sa kanilang sariling paraan, ngunit kung gusto mong maging seryoso tungkol sa mga controllers, pinakamahusay na matuto ng mga wika na katulad ng SI. Ang kanilang pangunahing bentahe ay ang kakayahang umangkop at walang limitasyong katangian ng algorithm. Gusto ko talaga ang Arduino IDE.
Paglalarawan ng Arduino IDE
Maaaring i-download ang pamamahagi mula sa opisyal na website. I-download ang archive, ito ay tumatagal ng higit sa 100 MB. Ang pag-install ay karaniwan, tulad ng lahat ng mga application para sa Windows. Ang mga driver para sa lahat ng uri ng mga board ay dapat na naka-install sa package. At ito ang hitsura ng working window ng program.
Ang Arduino development environment ay binubuo ng:
- editor ng code ng programa;
- mga lugar ng mensahe;
- mga window ng output ng teksto;
- mga toolbar na may mga pindutan para sa madalas na ginagamit na mga utos;
- ilang mga menu
Mga Setting ng Arduino IDE
Ang isang program na nakasulat sa Arduino development environment ay tinatawagsketch. Ang sketch ay nakasulat sa isang text editor, na mayroong color highlighting ng ginawang program code. Isang halimbawa ng isang simpleng programa sa larawan sa ibaba.
Maaaring magdagdag ng karagdagang pag-andar gamit angmga aklatan,kumakatawan sa code na idinisenyo sa isang espesyal na paraan. Karaniwan, hindi ito naa-access sa developer. Ang kapaligiran ay karaniwang may kasamang karaniwang hanay, na maaaring unti-unting mapunan muli. Nasa subdirectory silamga aklatan Direktoryo ng Arduino.
Maraming mga aklatan ang may kasamang mga halimbawa na matatagpuan sa folderhalimbawa.Ang pagpili ng library sa menu ay magdaragdag ng sumusunod na linya sa source code:
Arduino
#isama
#isama |
Ito ay isang direktiba - isang uri ng pagtuturo, isang header file na naglalarawan ng mga bagay, function, at mga constant ng library. Maraming mga function ang na-develop na para sa karamihan ng mga karaniwang gawain. Maniwala ka sa akin, pinapadali nito ang buhay ng programmer.
Pagkatapos naming ikonekta ang electronic board sa computer. Ginagawa namin ang mga sumusunod na setting - piliin ang Arduino board at ang Com port kung saan kami magkokonekta.
Arduino
void setup() ( // simulan ang digital pin 13 bilang isang output. pinMode(13, OUTPUT); ) void loop() ( digitalWrite(13, HIGH); delay(1000); digitalWrite(13, LOW);delay(1000 );
void setup() ( // simulan ang digital pin 13 bilang isang output. pinMode(13, OUTPUT); void loop() ( digitalWrite(13, HIGH); pagkaantala(1000); digitalWrite(13, LOW); pagkaantala(1000); |
Kaya, sa pamamagitan ng paraan, ito ay maginhawa upang suriin ang pag-andar ng board na nagmula sa tindahan. Mabilis at madali.
May isa pang maginhawang bagay. Ang tawag ditoSerial Port Monitor (Serial Monitor). Ipinapakita ang data na ipinadala sa platformArduino.Karaniwan kong tinitingnan kung ano ang mga senyales na ibinibigay sa akin ng iba't ibang mga sensor na konektado sa board.
Pag-uugnay ng mga aklatan
Mayroong iba't ibang paraan upang magdagdag ng mga custom na feature. Maaari mong ikonekta ang mga aklatan sa tatlong paraan:
- Gamit ang Library Manager
- Sa pamamagitan ng pag-import bilang isang .zip file
- Manu-manong pag-install.
1. Gamit ang Library Manager.Sa gumaganang window ng programa, piliin ang tab na Sketch. Pagkatapos nito, mag-click sa pindutan ng Connect library. Magbubukas ang manager ng library sa harap namin. Ipapakita ng window ang naka-install na mga file na may pirmanaka-installat ang mga maaaring i-install.
2.Paggamit ng import bilang .zip file.Kadalasan sa Internet makikita mo ang mga file ng library na naka-pack sa mga archive na may extension ng zip. Naglalaman ito ng isang header file.h at isang code file.cpp. Hindi na kailangang i-unpack ang archive sa panahon ng pag-install. Pumunta lang sa Sketch menu - Connect library - Magdagdag ng .ZIP library
3.Manu-manong pag-install.Una, isara ang Arduino IDE program. Una naming i-unpack ang aming archive. At inilipat namin ang mga file na may extension na .h at .cpp sa isang folder na may parehong pangalan ng archive. Ilagay ang folder sa root directory.
Aking Mga Dokumento\Arduino\mga aklatan
Paglalarawan ng FLPprog
Ang FLprog ay isang libreng proyekto mula sa mga independiyenteng developer na nagbibigay-daan sa iyong magtrabaho sa mga bloke ng function o mga diagram ng hagdan. Ang kapaligiran na ito ay maginhawa para sa mga tao - hindi programmer. Pinapayagan ka nitong biswal at malinaw na makita ang algorithm gamit ang mga diagram at functional block. Maaari mong i-download ang pamamahagi sa opisyal na website.
Medyo matagal ko nang sinusubaybayan ang project. Ang mga lalaki ay umuunlad, patuloy na nagdaragdag ng mga bagong pag-andar at nagbabago ng mga luma. Nakikita ko ang pangako sa kapaligirang ito. Dahil gumaganap ito ng dalawang mahalagang pag-andar:pagiging simple at kadalian ng paggamit.
Subukan nating lumikha ng isang simpleng proyekto. Ililipat namin ang output 13 sa LED.
Gumawa tayo ng bagong proyekto. Sa itaas na window, idagdag ang kinakailangang bilang ng mga input at output, magtakda ng pangalan at magtalaga ng pisikal na input o output sa board.
Hinugot namin ang mga elemento na kailangan namin mula sa object tree at ang mga elemento na kailangan namin papunta sa canvas sa pag-edit. Sa aming kaso, maaari kaming gumamit ng simpleng RS trigger para i-on at i-off ito.
Matapos lumikha ng algorithm, mag-click sa pindutan ng compile, ang programa ay nagbibigay ng isang handa na sketch sa IDE.
Tiningnan namin ang mga kakayahan at kaginhawahan ng mga programa para sa pagbuo ng mga algorithm sa controller ng serye ng Arduino. Mayroon ding mga programa na nagpapahintulot sa iyo na lumikha ng mga structural diagram at visual na mga larawan. Ngunit inirerekumenda ko ang paggamit ng isang text editor dahil mas madali para sa iyo sa ibang pagkakataon. Sabihin mo sa akin, aling kapaligiran ang pinakakombenyente para sa iyo at bakit??
Noong Setyembre 22, lumahok ako sa isang seminar sa Krasnodar "Mga touch panel controllers OVEN SPK." Ang kumperensya ay ginanap sa sunod sa moda at magandang Bristol Hotel. Ito ay napaka-interesante at cool.
Sa unang bahagi ng seminar, sinabi sa amin ang tungkol sa mga kakayahan at pakinabang ng mga produkto ng OWEN. Pagkatapos ay nagkaroon ng coffee break na may mga donut. Kumuha ako ng mga bagay, donut, cookies, at candies, dahil gutom na gutom ako.
Sa ikalawang bahagi ng seminar, pagkatapos ng tanghalian, ipinakita sa amin. Marami silang sinabi sa amin tungkol sa Web visualization. Nagsisimula nang makakuha ng momentum ang trend na ito. Well, siyempre, kontrolin ang kagamitan sa pamamagitan ng anumang Internet browser. Ito ay talagang astig. Sa pamamagitan ng paraan, ang kagamitan mismo ay nasa maleta.
Maglalathala ako ng serye ng mga artikulo sa CoDeSyS 3.5 sa malapit na hinaharap. Kaya, kung may interesado, mag-subscribe o bumisita lang. Lagi akong matutuwa!!!
Sa pamamagitan ng paraan, halos nakalimutan ko, ang susunod na artikulo ay tungkol sa Arduino electronic board. Ito ay magiging kawili-wili, huwag palampasin ito.
Magkita-kita tayo sa susunod na mga artikulo.
Pagbati, Gridin Semyon.
Panimula
Ang Freeduino/Arduino ay naka-program sa isang espesyal na programming language - ito ay batay sa C/C++, at nagbibigay-daan sa iyong gamitin ang alinman sa mga function nito. Sa mahigpit na pagsasalita, walang hiwalay na wika ng Arduino, tulad ng walang Arduino compiler - ang mga nakasulat na programa ay kino-convert (na may kaunting pagbabago) sa isang programa sa C/C++, at pagkatapos ay pinagsama-sama ng AVR-GCC compiler. Kaya, sa katunayan, ginagamit ang isang variant ng C/C++ na dalubhasa para sa mga AVR microcontroller.
Ang pagkakaiba ay nakakakuha ka ng isang simpleng kapaligiran sa pag-unlad at isang hanay ng mga pangunahing aklatan na nagpapasimple ng pag-access sa mga peripheral na matatagpuan "nakasakay" sa microcontroller.
Sumang-ayon, napakaginhawa upang magsimulang magtrabaho kasama ang isang serial port sa bilis na 9600 bits bawat segundo, na tumatawag sa isang linya:
Serial.begin(9600);
At kapag gumagamit ng "hubad" na C/C++, kailangan mong harapin ang dokumentasyon para sa microcontroller at tumawag ng ganito:
UBRR0H = ((F_CPU / 16 + 9600 / 2) / 9600 - 1) >> 8;
UBRR0L = ((F_CPU / 16 + 9600 / 2) / 9600 - 1);
sbi(UCSR0B, RXEN0);
sbi(UCSR0B, TXEN0);
sbi(UCSR0B, RXCIE0);
Narito ang isang maikling pangkalahatang-ideya ng mga pangunahing pag-andar at tampok ng Arduino programming. Kung hindi ka pamilyar sa syntax ng mga C/C++ na wika, inirerekomenda namin na sumangguni ka sa anumang literatura sa isyung ito o mga mapagkukunan sa Internet.
Sa kabilang banda, ang lahat ng mga halimbawang ipinakita ay napaka-simple, at malamang na hindi ka magkakaroon ng anumang kahirapan sa pag-unawa sa mga pinagmulang teksto at pagsulat ng iyong sariling mga programa kahit na hindi nagbabasa ng karagdagang literatura.
Ang mas kumpletong dokumentasyon (sa Ingles) ay ipinakita sa opisyal na website ng proyekto - http://www.arduino.cc. Mayroon ding isang forum, mga link sa karagdagang mga aklatan at ang kanilang mga paglalarawan.
Sa pamamagitan ng pagkakatulad sa paglalarawan sa opisyal na website ng Arduino project, ang isang "port" ay tumutukoy sa isang microcontroller contact na konektado sa isang connector sa ilalim ng kaukulang numero. Bilang karagdagan, mayroong isang serial communication port (COM port).
Istraktura ng programa
Sa iyong programa dapat kang magdeklara ng dalawang pangunahing function: setup() at loop().
Ang setup() function ay tinatawag nang isang beses, pagkatapos ng bawat power-up o reset ng Freeduino board. Gamitin ito upang simulan ang mga variable, itakda ang mga operating mode ng mga digital port, atbp.
Ang loop() function ay sunud-sunod na nagpapatupad ng mga utos na inilarawan sa katawan nito nang paulit-ulit. Yung. Pagkatapos makumpleto ang function, tatawagin itong muli.
Tingnan natin ang isang simpleng halimbawa:
void setup() // mga paunang setting
{
beginSerial(9600); // pagtatakda ng bilis ng serial port sa 9600 bps
pinMode(3, INPUT); // pagtatakda ng 3rd port para sa input ng data
}
// Sinusuri ng program ang ika-3 port para sa pagkakaroon ng signal dito at nagpapadala ng tugon sa
// bilang isang text message sa serial port ng computer
void loop() // katawan ng programa
{
if (digitalRead(3) == HIGH) // kundisyon para sa pagboto sa ika-3 port
serialWrite("H"); // magpadala ng mensahe sa anyo ng letrang "H" sa COM port
iba pa
serialWrite("L"); // magpadala ng mensahe sa anyo ng letrang "L" sa COM port
pagkaantala(1000); // antala ng 1 seg.
}
pinMode(port, mode);
Paglalarawan:
Kino-configure ang tinukoy na port para mag-input o mag-output ng signal.
Mga Pagpipilian:
port – ang numero ng port na ang mode ay gusto mong itakda (isang integer na halaga mula 0 hanggang 13).
mode - alinman sa INPUT (input) o OUTPUT (output).
pinMode(13, OUTPUT); //13th pin ang magiging output
pinMode(12, INPUT); //at ang ika-12 ay ang input
Tandaan:
Maaaring gamitin ang mga analog input bilang mga digital input/output sa pamamagitan ng pag-access sa mga ito gamit ang mga numero 14 (analog input 0) hanggang 19 (analog input 5)
digitalWrite(port, halaga);
Paglalarawan:
Itinatakda ang antas ng boltahe sa mataas (HIGH) o mababa (LOW) sa tinukoy na port.
Mga Pagpipilian:
port: numero ng port
halaga: HIGH o LOW
digitalWrite(13, HIGH); // itakda ang pin 13 sa "mataas" na estado
halaga = digitalRead(port);
Paglalarawan:
Binabasa ang halaga sa tinukoy na port
Mga Pagpipilian:
port: polled port number
Return value: ibinabalik ang kasalukuyang value sa port (HIGH o LOW) ng uri na int
int val;
val = digitalRead(12); // poll ang ika-12 pin
Tandaan:
Kung walang konektado sa port na binabasa, kung gayon ang digitalRead() function ay maaaring magbalik ng HIGH o LOW na halaga nang mali.
Analog signal input/output
halaga = analogRead(port);
Paglalarawan:
Nagbabasa ng value mula sa tinukoy na analog port. Ang Freeduino ay naglalaman ng 6 na channel, analog-to-digital converter na 10 bit bawat isa. Nangangahulugan ito na ang input boltahe mula 0 hanggang 5V ay na-convert sa isang integer na halaga mula 0 hanggang 1023. Ang readout na resolution ay: 5V/1024 values = 0.004883 V/value (4.883 mV). Tumatagal ng humigit-kumulang 100 nS (0.0001 C) upang mabasa ang isang analog na halaga ng input, kaya ang maximum na rate ng pagbasa ay humigit-kumulang 10,000 beses bawat segundo.
Mga Pagpipilian:
Return Value: Nagbabalik ng int number sa hanay na 0 hanggang 1023 na nabasa mula sa tinukoy na port.
int val;
val = analogRead(0); // basahin ang halaga sa 0th analog input
Tandaan:
Ang mga analog port ay tinukoy bilang signal input bilang default at, hindi katulad ng mga digital port, hindi kailangang i-configure sa pamamagitan ng pagtawag sa pinMode function.
analogWrite(port, halaga);
Paglalarawan:
Naglalabas ng analog na halaga sa port. Gumagana ang function na ito sa: 3, 5, 6, 9, 10, at 11 na mga digital port ng Freeduino.
Maaaring gamitin upang baguhin ang liwanag ng isang LED, kontrolin ang isang motor, atbp. Pagkatapos tawagan ang analogWrite function, ang kaukulang port ay magsisimulang gumana sa boltahe pulse-width modulation mode hanggang sa may isa pang tawag sa analogWrite function (o digitalRead / digitalWrite function sa parehong port).
Mga Pagpipilian:
port: numero ng analog input na sinusuri
value: isang integer sa pagitan ng 0 at 255. Ang halaga ng 0 ay bumubuo ng 0 V sa tinukoy na port; ang isang halaga ng 255 ay bumubuo ng +5V sa tinukoy na port. Para sa mga halaga sa pagitan ng 0 at 255, ang port ay nagsisimulang mabilis na humalili sa pagitan ng 0 at +5 V na antas ng boltahe - kung mas mataas ang halaga, mas madalas ang port ay bumubuo ng HIGH (5 V) na antas.
analogWrite(9, 128); // itakda ang pin 9 sa isang halaga na katumbas ng 2.5V
Tandaan:
Hindi na kailangang tumawag sa pinMode upang itakda ang port sa mga output signal bago tumawag sa analogWrite.
Ang dalas ng pagbuo ng signal ay humigit-kumulang 490 Hz.
oras = millis();
Paglalarawan:
Ibinabalik ang bilang ng mga millisecond mula nang isagawa ng Freeduino ang kasalukuyang programa. Aapaw ang counter at magre-reset pagkatapos ng humigit-kumulang 9 na oras.
Ibinalik na halaga: nagbabalik ng hindi napirmahang mahabang halaga
matagal na hindi pinirmahan; // deklarasyon ng variable ng oras ng uri na hindi pinirmahan ang haba
oras = millis(); // ilipat ang bilang ng mga millisecond
pagkaantala(time_ms);
Paglalarawan:
Pino-pause ang program para sa tinukoy na bilang ng mga millisecond.
Mga Pagpipilian:
time_ms – oras ng pagkaantala ng programa sa mga millisecond
pagkaantala(1000); //pause ng 1 segundo
delayMicroseconds
delayMicroseconds(time_μs);
Paglalarawan:
Pino-pause ang program para sa tinukoy na bilang ng mga microsecond.
Mga Pagpipilian:
time_μs – oras ng pagkaantala ng programa sa microseconds
delayMicroseconds(500); //pause 500 microseconds
pulseIn(port, halaga);
Paglalarawan:
Nagbabasa ng pulso (mataas o mababa) mula sa isang digital port at ibinabalik ang tagal ng pulso sa microseconds.
Halimbawa, kung ang parameter na "value" ay nakatakda sa HIGH kapag tumatawag sa function, ang pulseIn() ay maghihintay para sa isang mataas na antas ng signal na dumating sa port. Mula sa sandaling ito ay dumating, ang countdown ay magsisimula hanggang sa isang mababang antas ng signal ay natanggap sa port. Ibinabalik ng function ang haba ng pulso (mataas na antas) sa microseconds. Gumagana sa mga pulso mula 10 microseconds hanggang 3 minuto. Tandaan na ang function na ito ay hindi magbabalik ng resulta hanggang sa may nakitang pulso.
Mga Pagpipilian:
port: numero ng port kung saan namin nabasa ang pulso
halaga: uri ng pulso HIGH o LOW
Return value: ibinabalik ang tagal ng pulso sa microseconds (type int)
int tagal; // deklarasyon ng variable ng tagal ng uri int
tagal = pulseIn(pin, HIGH); // sukatin ang tagal ng pulso
Serial na paglilipat ng data
Ang Freeduino ay may built-in na controller para sa serial data transmission, na maaaring magamit kapwa para sa komunikasyon sa pagitan ng mga Freeduino/Arduino device at para sa komunikasyon sa isang computer. Sa isang computer, ang kaukulang koneksyon ay kinakatawan ng isang USB COM port.
Nagaganap ang komunikasyon sa mga digital port 0 at 1, at samakatuwid ay hindi mo magagamit ang mga ito para sa digital I/O kung gumagamit ka ng mga serial function.
Serial.begin(baud_rate);
Paglalarawan:
Itinatakda ang COM port information transfer rate sa bits per second para sa serial data transmission. Upang makipag-usap sa isang computer, gamitin ang isa sa mga standardized na bilis na ito: 300, 1200, 2400, 4800, 9600, 14400, 19200, 28800, 38400, 57600, o 115200. Maaari mo ring tukuyin ang iba pang mga microcontroller sa pamamagitan ng iba pang bilis. port 0 at 1.
Mga Pagpipilian:
baud_rate: Rate ng daloy ng data sa mga bit bawat segundo.
Serial.begin(9600); //itakda ang bilis sa 9600 bps
Serial.available
bilang = Serial.available();
Paglalarawan:
Ang mga byte na natanggap sa pamamagitan ng serial port ay napupunta sa microcontroller buffer, kung saan mababasa ng iyong program ang mga ito. Ibinabalik ng function ang bilang ng mga byte na naipon sa buffer. Ang serial buffer ay maaaring mag-imbak ng hanggang 128 bytes.
Ibinalik na halaga:
Nagbabalik ng int value - ang bilang ng mga byte na magagamit para sa pagbabasa sa serial buffer, o 0 kung walang available.
if (Serial.available() > 0) ( // Kung may data sa buffer
// dapat mayroong pagtanggap at pagproseso ng data dito
}
char = Serial.read();
Paglalarawan:
Binabasa ang susunod na byte mula sa serial port buffer.
Ibinalik na halaga:
Ang unang magagamit na byte ng papasok na data mula sa serial port, o -1 kung walang papasok na data.
incomingByte = Serial.read(); // basahin ang byte
Paglalarawan:
Ni-clear ang serial port input buffer. Nawala ang data sa buffer, at ang karagdagang mga tawag sa Serial.read() o Serial.available() ay magkakaroon ng kahulugan para sa data na natanggap pagkatapos ng Serial.flush() na tawag.
Serial.flush(); // I-clear ang buffer - simulan ang pagtanggap ng data "mula sa simula"
Paglalarawan:
I-output ang data sa serial port.
Mga Pagpipilian:
Ang function ay may ilang mga form ng tawag depende sa uri at format ng output data.
Ang Serial.print(b, DEC) ay nagpi-print ng ASCII string - ang decimal na representasyon ng numero b.
int b = 79;
Ang Serial.print(b, HEX) ay nagpi-print ng ASCII string - ang hexadecimal na representasyon ng numero b.
int b = 79;
Ang Serial.print(b, OCT) ay nagpi-print ng ASCII string - ang octal na representasyon ng numero b.
int b = 79;
Serial.print(b, OCT); //ay maglalabas ng string na "117" sa port
Ang Serial.print(b, BIN) ay nagpi-print ng ASCII string - ang binary na representasyon ng numero b.
int b = 79;
Serial.print(b, BIN); //ay maglalabas ng string na "1001111" sa port
Ini-print ng Serial.print(b, BYTE) ang mababang byte ng b.
int b = 79;
Serial.print(b, BYTE); // ay magpapakita ng numero 79 (isang byte). Sa monitor
//mula sa serial port nakuha namin ang simbolo na "O" - nito
//code ay 79
Serial.print(str) kung ang str ay isang string o character array, inililipat ang str sa COM port byte byte.
char bytes = (79, 80, 81); // array ng 3 bytes na may mga halaga 79,80,81
Serial.print("Narito ang aming mga byte:"); //outputs ang linyang "Narito ang aming mga byte:"
Serial.print(bytes); //naglalabas ng 3 character na may mga code 79,80,81 –
//ito ang mga character na "OPQ"
Serial.print(b) kung ang b ay may uri ng byte o char, ipi-print ang numero b mismo sa port.
char b = 79;
Serial.print(b); //ay maglalabas ng character na "O" sa port
Serial.print(b) kung ang b ay uri ng integer, ipi-print ang decimal na representasyon ng b sa port.
int b = 79;
Serial.print(b); //ay maglalabas ng string na "79" sa port
Paglalarawan:
Ang Serial.println function ay katulad ng Serial.print function, at may parehong mga opsyon sa pagtawag. Ang pagkakaiba lang ay ang dalawang karagdagang character ay output pagkatapos ng data - isang carriage return character (ASCII 13, o "\r") at isang bagong line character (ASCII 10, o "\n").
Ang halimbawa 1 at halimbawa 2 ay maglalabas ng parehong bagay sa port:
int b = 79;
Serial.print(b, DEC); //ay maglalabas ng string na "79" sa port
Serial.print("\r\n"); //ay ipapakita ang mga character na "\r\n" – line feed
Serial.print(b, HEX); //ay maglalabas ng string na "4F" sa port
Serial.print("\r\n");//ay magpi-print ng mga character na "\r\n" – line feed
int b = 79;
Serial.println(b, DEC); //ay maglalabas ng string na "79\r\n" sa port
Serial.println(b, HEX); //ay maglalabas ng string na "4F\r\n" sa port
Sa serial port monitor nakukuha namin.
Ano ang binubuo ng programa?
Upang magsimula sa, ito ay nagkakahalaga ng pag-unawa na ang isang programa ay hindi maaaring basahin at isulat tulad ng isang libro: mula sa pabalat hanggang sa pabalat, sa itaas hanggang sa ibaba, linya sa linya. Ang anumang programa ay binubuo ng hiwalay na mga bloke. Ang simula ng isang bloke ng code sa C/C++ ay ipinahiwatig ng kaliwang kulot na brace ( , ang dulo nito sa kanang kulot na brace ) .
Mayroong iba't ibang uri ng mga bloke, at kung alin ang isasagawa kapag nakadepende sa mga panlabas na kondisyon. Sa minimal na halimbawa ng programa maaari mong makita ang 2 bloke. Sa halimbawang ito ang mga bloke ay tinatawag pagtukoy ng isang function. Ang isang function ay simpleng bloke ng code na may ibinigay na pangalan na magagamit ng isang tao mula sa labas.
Sa kasong ito, mayroon kaming 2 function na pinangalanang setup at loop. Ang kanilang presensya ay ipinag-uutos sa anumang C++ na programa para sa Arduino. Maaaring wala silang magawa, tulad ng sa ating kaso, ngunit dapat silang isulat. Kung hindi, makakakuha ka ng isang error sa yugto ng compilation.
Classic ng genre: kumikislap na LED
Dagdagan natin ngayon ang ating programa para at least may mangyari. Sa Arduino, ang isang LED ay konektado sa pin 13. Ito ay maaaring kontrolin, na kung ano ang gagawin namin.
void setup() ( pinMode(13 , OUTPUT) ; ) void loop() ( digitalWrite(13 , HIGH) ; delay(100); digitalWrite(13, LOW) ; delay(900); )I-compile at i-download ang program. Makikita mo na ang LED sa board ay kumukurap bawat segundo. Alamin natin kung bakit humahantong ang code na ito sa pagkislap bawat segundo.
Ang bawat expression ay isang utos sa processor na gumawa ng isang bagay. Ang mga ekspresyon sa loob ng isang bloke ay isa-isang isinasagawa, mahigpit na pagkakasunud-sunod, nang walang anumang paghinto o paglipat. Iyon ay, kung pinag-uusapan natin ang tungkol sa isang partikular na bloke ng code, maaari itong basahin mula sa itaas hanggang sa ibaba upang maunawaan kung ano ang ginagawa.
Ngayon maunawaan natin kung anong pagkakasunud-sunod ang mga bloke mismo ay naisakatuparan, i.e. setup at loop function. Huwag mag-alala tungkol sa kung ano ang ibig sabihin ng mga partikular na expression, obserbahan lang ang pagkakasunud-sunod.
Sa sandaling ang Arduino ay naka-on, nag-flash o ang pindutan ng RESET ay pinindot, "isang bagay" tumatawag sa isang function setup. Ibig sabihin, pinipilit nitong maisakatuparan ang mga expression sa loob nito.
Sa sandaling makumpleto ang pag-setup, agad na tatawag ng "something" ang loop function.
Sa sandaling makumpleto ang loop, agad na tatawagin ng "something" ang loop function at iba pa ang ad infinitum.
Kung binibilang namin ang mga expression sa pagkakasunud-sunod ng kung paano sila isinasagawa, makakakuha tayo ng:
void setup() ( pinMode(13 , OUTPUT) ; ❶ ) void loop() ( digitalWrite(13 , HIGH) ; ❷ ❻ ❿ delay(100); ❸ ❼ … digitalWrite(13 , LOW) ; ❹ ❽0 ) delay ; ❺ ❾ )Paalalahanan ka naming muli na hindi mo dapat subukang tingnan ang buong programa sa pamamagitan ng pagbabasa mula sa itaas hanggang sa ibaba. Ang mga nilalaman lamang ng mga bloke ay binabasa mula sa itaas hanggang sa ibaba. Sa pangkalahatan, maaari nating baguhin ang pagkakasunud-sunod ng mga deklarasyon ng pag-setup at loop.
void loop() ( digitalWrite(13 , HIGH) ; ❷ ❻ ❿ delay(100); ❸ ❼ … digitalWrite(13 , LOW) ; ❹ ❽ delay(900 ) ; ❺ ❾ ) void setup() 3 ( pin ); ❶ )Ang resulta ay hindi magbabago ng isang iota: pagkatapos ng compilation makakakuha ka ng isang ganap na katumbas na binary file.
Ano ang Ginagawa ng mga Ekspresyon
Ngayon subukan nating maunawaan kung bakit ang nakasulat na programa sa huli ay nagiging sanhi ng pagkislap ng LED.
Tulad ng alam mo, ang mga Arduino pin ay maaaring gumana bilang parehong mga output at input. Kapag gusto nating kontrolin ang isang bagay, iyon ay, mag-isyu ng signal, kailangan nating ilipat ang control pin sa output state. Sa aming halimbawa, kinokontrol namin ang LED sa ika-13 pin, kaya dapat gawing output ang ika-13 pin bago gamitin.
Ginagawa ito sa pamamagitan ng isang expression sa setup function:
PinMode(13 , OUTPUT) ;
Maaaring magkaiba ang mga expression: aritmetika, mga deklarasyon, mga kahulugan, mga kondisyon, atbp. Sa kasong ito, ipinapatupad namin sa expression function na tawag. Tandaan? Meron kami kanilang ang setup at loop function, na tinatawag ng isang bagay na tinatawag naming "something". At ngayon Kami tinatawag namin ang mga function na nakasulat na sa isang lugar.
Partikular sa aming setup tinatawag namin ang isang function na tinatawag na pinMode. Itinatakda nito ang pin na tinukoy ng numero sa tinukoy na mode: input o output. Ipinapahiwatig namin kung aling pin at aling mode ang pinag-uusapan natin sa mga panaklong, na pinaghihiwalay ng mga kuwit, kaagad pagkatapos ng pangalan ng function. Sa aming kaso, gusto namin ang ika-13 pin na kumilos bilang isang output. Ang OUTPUT ay nangangahulugan ng output, ang INPUT ay nangangahulugan ng input.
Ang mga kwalipikadong halaga tulad ng 13 at OUTPUT ay tinatawag mga argumento ng function. Hindi naman talaga kailangan na ang lahat ng function ay dapat may 2 argumento. Kung gaano karaming mga argumento ang mayroon ang isang function ay depende sa esensya ng function at kung paano ito isinulat ng may-akda. Maaaring may mga function na may isang argumento, tatlo, dalawampu; Ang mga function ay maaaring walang mga argumento. Pagkatapos upang tawagan sila, ang panaklong ay binuksan at agad na isinara:
NoInterrupts() ;
Sa katunayan, maaaring napansin mo na ang aming setup at loop function ay hindi rin kumukuha ng anumang mga argumento. At ang mahiwagang "isang bagay" ay tumatawag sa kanila sa parehong paraan na may mga walang laman na panaklong sa tamang sandali.
Bumalik tayo sa ating code. Kaya, dahil plano naming i-blink ang LED magpakailanman, ang control pin ay kailangang gawing output nang isang beses at pagkatapos ay hindi namin nais na matandaan ang tungkol dito. Ito ang layunin ng pag-setup ng function: pag-set up ng board kung kinakailangan at pagkatapos ay magtrabaho kasama nito.
Lumipat tayo sa loop function:
void loop() ( digitalWrite(13, HIGH) ; delay(100) ; digitalWrite(13, LOW) ; delay(900) ; )Tulad ng nabanggit, ito ay tinatawag kaagad pagkatapos ng pag-setup . At ito ay tinatawag na muli at muli sa sandaling ito ay natapos. Ang loop function ay tinatawag na pangunahing loop ng programa at ideologically dinisenyo upang magsagawa ng kapaki-pakinabang na gawain. Sa aming kaso, ang kapaki-pakinabang na gawain ay kumikislap sa LED.
Suriin natin ang mga expression sa pagkakasunud-sunod. Kaya ang unang expression ay isang tawag sa digitalWrite built-in na function. Ito ay dinisenyo upang maglapat ng isang lohikal na zero (LOW, 0 volts) o isang lohikal na isa (HIGH, 5 volts) sa isang ibinigay na pin Dalawang argumento ang ipinapasa sa digitalWrite function: ang pin number at ang lohikal na halaga. Bilang resulta, ang unang bagay na ginagawa namin ay sindihan ang LED sa ika-13 pin, na naglalagay ng 5 volts dito.
Kapag ito ay tapos na, ang processor ay agad na lumipat sa susunod na expression. Para sa amin, ito ay isang tawag sa delay function. Ang delay function ay, muli, isang built-in na function na nagpapatulog sa processor sa isang tiyak na oras. Isang argument lang ang kailangan: ang oras sa millisecond para matulog. Sa aming kaso ito ay 100 ms.
Habang natutulog kami, ang lahat ay nananatiling tulad nito, i.e. nananatiling ilaw ang LED. Sa sandaling mag-expire ang 100 ms, magigising ang processor at agad na lumipat sa susunod na expression. Sa aming halimbawa, isa itong tawag muli sa pamilyar na digitalWrite na built-in na function. Totoo, sa pagkakataong ito ipinapasa namin ang halagang LOW bilang pangalawang argumento. Iyon ay, nagtakda kami ng isang lohikal na zero sa ika-13 pin, iyon ay, nagbibigay kami ng 0 volts, iyon ay, pinapatay namin ang LED.
Matapos mapatay ang LED ay nagpapatuloy kami sa susunod na expression. Muli, ito ay isang tawag sa function ng pagkaantala. Sa pagkakataong ito, 900 ms kami nakatulog.
Kapag natapos na ang pagtulog, lalabas ang function ng loop. Sa pagkumpleto, "may" agad na tumatawag dito at ang lahat ay nangyayari muli: ang LED na ilaw, ilaw, patay, naghihintay, atbp.
Kung isasalin mo ang nakasulat sa Russian, makukuha mo ang sumusunod na algorithm:
Pag-iilaw sa LED
Matulog ng 100 millisecond
Pinapatay ang LED
Natutulog kami ng 900 milliseconds
Pumunta tayo sa point 1
Kaya nakakuha kami ng Arduino na may beacon na kumikislap tuwing 100 + 900 ms = 1000 ms = 1 segundo.
Ano ang maaaring baguhin
Gamitin lamang natin ang kaalamang natamo natin upang makagawa ng ilang pagkakaiba-iba ng programa upang mas maunawaan ang prinsipyo.
Maaari mong ikonekta ang isang panlabas na LED o iba pang device na kailangang "mag-blink" sa ibang pin. Halimbawa, sa ika-5. Paano dapat magbago ang programa sa kasong ito? Dapat nating palitan ang numero ng ika-5 saanman natin na-access ang ika-13 pin:
I-compile, i-download, subukan.
Ano ang kailangang gawin para magawa ang LED flash ng 2 beses bawat segundo? Bawasan ang oras ng pagtulog upang ang kabuuan ay 500 ms:
void setup() ( pinMode(5 , OUTPUT) ; ) void loop() ( digitalWrite(5 , HIGH) ; delay(50); digitalWrite(5 , LOW) ; delay(450); )Paano ko gagawin ang LED na kumikislap nang dalawang beses sa tuwing kumukurap ito? Kailangan mong sindihan ito nang dalawang beses nang may maikling pag-pause sa pagitan ng pag-on:
void setup() ( pinMode(5 , OUTPUT) ; ) void loop() ( digitalWrite(5 , HIGH) ; delay(50); digitalWrite(5 , LOW) ; delay(50); digitalWrite(5 , HIGH) ; delay (50 ); digitalWrite(5 , LOW) ;Paano ko gagawing may 2 LED ang device na kumukurap na salit-salit bawat segundo? Kailangan mong makipag-usap sa dalawang pin at magtrabaho sa isang loop sa isa o sa isa pa:
void setup() ( pinMode(5 , OUTPUT) ; pinMode(6 , OUTPUT) ; ) void loop() ( digitalWrite(5 , HIGH) ; delay(100); digitalWrite(5 , LOW) ; delay(900); digitalWrite (6 , HIGH) ;Paano makasigurado na ang aparato ay may 2 LED na lumilipat tulad ng isang ilaw ng trapiko ng tren: una ang isa pagkatapos ay ang iba pang ilaw? Kailangan mo lamang na huwag patayin ang nakailaw na LED kaagad, ngunit maghintay hanggang sa sandali ng paglipat:
void setup() ( pinMode(5 , OUTPUT) ; pinMode(6 , OUTPUT) ; ) void loop() ( digitalWrite(5 , HIGH) ; digitalWrite(6 , LOW) ; delay(1000); digitalWrite(5 , LOW) ; digitalWrite(6 , HIGH) ;Huwag mag-atubiling tingnan ang iba pang mga ideya sa iyong sarili. Tulad ng nakikita mo, ito ay simple!
Tungkol sa walang laman na espasyo at magandang code
Sa C++, hindi mahalaga sa compiler ang mga space, line break, at mga character ng tab. Kung saan may puwang, maaaring may line break at vice versa. Sa katunayan, 10 puwang sa isang hilera, 2 line break at 5 pang espasyo ay katumbas ng isang puwang.
Ang walang laman na espasyo ay isang tool ng programmer, kung saan maaari mong gawin ang isang programa na maunawaan at makita, o i-disfigure ito nang hindi na makilala. Halimbawa, tandaan ang programa para sa pag-blink ng LED:
void setup() ( pinMode(5 , OUTPUT) ; ) void loop() ( digitalWrite(5 , HIGH) ; delay(100); digitalWrite(5 , LOW) ; delay(900); )Maaari naming baguhin ito tulad nito:
void setup( ) ( pinMode(5 , OUTPUT) ; ) void loop () ( digitalWrite(5 ,HIGH) ; delay(100); digitalWrite(5 ,LOW) ; delay(900); )Ang ginawa lang namin ay gumawa ng kaunti sa bakanteng espasyo. Ngayon ay malinaw mong makikita ang pagkakaiba sa pagitan ng maayos na code at hindi nababasang code.
Upang sundin ang hindi sinasabing batas ng disenyo ng programa, na iginagalang sa mga forum, kapag binasa ng ibang tao, at madaling naiintindihan mo, sundin ang ilang simpleng panuntunan:
1. Palaging taasan ang indentation sa pagitan ng ( at ) kapag nagsisimula ng bagong block. Karaniwang 2 o 4 na puwang ang ginagamit. Pumili ng isa sa mga halaga at manatili dito sa kabuuan.
masama:
void loop() ( digitalWrite(5 , HIGH) ; delay(100); digitalWrite(5 , LOW) ; delay(900); )fine:
void loop() ( digitalWrite(5 , HIGH) ; delay(100); digitalWrite(5 , LOW) ; delay(900); )2. Tulad ng sa natural na wika: maglagay ng puwang pagkatapos ng mga kuwit at huwag maglagay ng bago.
masama:
DigitalWrite(5 ,MATAAS) ; digitalWrite(5 , HIGH) ; digitalWrite(5 ,MATAAS);
fine:
DigitalWrite(5 , HIGH) ;
3. Ilagay ang start-of-block na character (sa isang bagong linya sa kasalukuyang antas ng indentation o sa dulo ng nauna. At ang end-of-block na character) sa isang hiwalay na linya sa kasalukuyang antas ng indentation:
masama:
void setup() ( pinMode(5, OUTPUT); ) void setup() ( pinMode(5, OUTPUT); ) void setup() ( pinMode(5, OUTPUT); )fine:
void setup() ( pinMode(5 , OUTPUT) ; ) void setup() ( pinMode(5 , OUTPUT) ; )4. Gumamit ng mga walang laman na linya upang paghiwalayin ang mga bloke ng kahulugan:
fine:
Mas mabuti:
void loop() ( digitalWrite(5 , HIGH) ; delay(100 ); digitalWrite(5 , LOW) ; delay(900); digitalWrite(6 , HIGH) ; delay(100); digitalWrite(6 , LOW) ; delay( 900);Tungkol sa mga semicolon
Maaaring nagtataka ka: bakit may semicolon sa dulo ng bawat expression? Ito ang mga patakaran ng C++. Ang mga ganitong tuntunin ay tinatawag syntax ng wika. Sa pamamagitan ng simbolo; naiintindihan ng compiler kung saan nagtatapos ang expression.
Gaya ng nabanggit na, ang mga line break ay isang walang laman na parirala para sa kanya, kaya nakatuon siya sa bantas na ito. Nagbibigay-daan ito sa iyo na magsulat ng maraming expression sa isang linya:
void loop() ( digitalWrite(5 , HIGH) ; delay(100); digitalWrite(5 , LOW) ; delay(900); )Ang programa ay tama at katumbas ng kung ano ang nakita na natin. Gayunpaman, ang pagsulat na tulad nito ay masamang anyo. Ang code ay mas mahirap basahin. Kaya maliban kung mayroon kang 100% magandang dahilan upang magsulat ng maraming expression sa parehong linya, huwag gawin ito.
Tungkol sa mga komento
Ang isa sa mga alituntunin ng mahusay na programming ay: "magsulat ng code upang ito ay napakalinaw na hindi ito nangangailangan ng paliwanag." Ito ay posible, ngunit hindi palaging. Upang maipaliwanag ang ilang di-halatang mga punto sa code sa mga mambabasa nito: ang iyong mga kasamahan o ang iyong sarili sa isang buwan, may mga tinatawag na komento.
Ito ay mga konstruksyon sa program code na ganap na hindi pinansin ng compiler at may kahulugan lamang sa mambabasa. Ang mga komento ay maaaring multi-line o single-line:
/* Ang setup function ay tinatawag na pinakaunang kapag ang kapangyarihan ay inilapat sa Arduino At ito ay isang multi-line na komento */. void setup() ( // itakda ang pin 13 sa output mode pinMode(13 , OUTPUT) ; ) void loop() ( digitalWrite(13, HIGH) ; delay(100) ; // sleep for 100 ms digitalWrite(13, LOW) ; delay(900) ; )Gaya ng nakikita mo, maaari kang magsulat ng maraming linya ng komento hangga't gusto mo sa pagitan ng mga simbolo na /* at */. At pagkatapos ng pagkakasunud-sunod / / lahat ng kasunod hanggang sa dulo ng linya ay itinuturing na isang komento.
Kaya, umaasa kami na ang pinakapangunahing mga prinsipyo ng pagsusulat ng mga programa ay naging malinaw. Ang kaalamang natamo ay nagpapahintulot sa iyo na kontrolin ang power supply sa mga Arduino pin ayon sa ilang partikular na timing scheme. Ito ay hindi gaanong, ngunit sapat pa rin para sa mga unang eksperimento.
Ang Arduino, sa katunayan, ay ang pagbuo ng mga natatanging proyekto para sa lahat ng okasyon.
Tulad ng naisulat ko na, ang Arduino ay isang uri ng board na may microcontroller na nakalagay dito, na maaaring ma-program nang walang problema.
Ang pinakalayunin ng mga manipulasyong ito ay magbigay ng madaling kontrol sa maraming panlabas na device. Nakikipag-ugnayan ang board na ito sa labas ng mundo sa pamamagitan ng maraming add-on:
- at iba pa.
Gagawin nitong isang medyo unibersal na plataporma para sa maraming proyekto na may iba't ibang antas - tingnan ang seksyon sa aming website ng Arduino Lessons. Sa kasalukuyan, mayroong maraming iba't ibang mga microcontroller, kung saan ang Arduino ay lalong sikat, na nauugnay sa aktibong paglalagay ng mga pinaka-hindi kapani-paniwalang mga proyekto at pag-unlad sa network.
Upang madaling ipatupad ang isa sa milyun-milyong ideya, madali mong magagamit ang pinakabagong impormasyon na magagamit nang nakapag-iisa sa maraming mga site. Nasa ibaba ang isang halimbawa ng pagpapatupad ng isa sa mga ideyang ito - isang kampana ng Pasko na maaaring kontrolin:
Titingnan natin kung paano ito gagawin sa isa sa mga sumusunod na aralin.
Kung wala kang kahit kaunting karanasan sa pagtatrabaho sa mga microcontroller (programming at configuration), salamat sa mga feature ng Arduino, madali kang matuto nang mag-isa sa pamamagitan ng pagsasagawa ng medyo maiikling mga eksperimento. Iminumungkahi kong suriin sa ibaba ang ilan sa mga kakayahan ng Arduino, mga halimbawa kung saan pinakamahusay na gamitin ang natatanging constructor na ito.
Mga sketch ng Arduino
Sa totoo lang, ang programa para sa isang microcontroller ng ganitong uri ay tinatawag sketch. Anumang naturang programa ay direktang binubuo ng dalawang pangunahing pag-andar.
Setup
setup()– ibinigay na sa loob ng function na ito, magagawa ng user na itakda ang lahat ng mga pangunahing setting.
Halimbawa, tinutukoy kung aling mga pin ang kasunod na gagana bilang output o input, na tinutukoy ang koneksyon ng mga partikular na aklatan, kahit na ang pagsisimula ng mga variable, ang lahat ng ito ay natutukoy sa pamamagitan ng paggamit ng functionality na ito.
Ang paglulunsad ay mahigpit na isinasagawa nang isang beses sa buong sketch, kapag ang pinakasimula ng pagpapatupad ng programang ito ay nabanggit.
Loop
loop()- kumakatawan sa pangunahing function na isinasagawa kaagad pagkatapos ng startup (sa kasong ito ito ay ginagamit setup()).
Sa katunayan, ito ang mismong programa; ang function na ito ay tatakbo nang walang hanggan hanggang sa patayin ng user ang kapangyarihan ng device.
Mga halimbawa ng sketch
Maaari mong isaalang-alang ang ilang mga halimbawa ng mga sketch na magiging gabay para sa kasunod na operasyon ng kagamitan. Susubukan kong ipatupad ang bawat isa sa mga halimbawa sa mga sumusunod na materyales. Ngayon ay pag-uusapan lang natin ang mga posibilidad.
Halimbawa 1
Ang isa sa mga kagiliw-giliw na sketch ay maaaring magamit upang ipakita ang oras ng pagpapatakbo ng controller, pagkatapos ay tanggapin ang "blink" na utos, ito ay ibinigay upang simulan ang kumikislap na pamamaraan ng mga elemento ng LED.
Sa katunayan, walang partikular na kapaki-pakinabang sa sketch, ngunit kasama rin dito ang posibilidad ng random na pagpapakita ng isang tiyak na parirala " Natanggap na Data", maaari itong magamit nang direkta sa hinaharap para sa pagsubok at pagsusuri sa mga itinatag na panuntunan para sa pagpapatakbo ng isang modular na elemento.
Halimbawa 2
Halimbawa 3
Ang espesyal na pansin ay dapat bayaran sa posibilidad ng pag-output ng mga character at pagkatapos ay i-install ang mga font LCD5110, na titiyakin ang pinakamadali at pinaka-maaasahang kontrol sa kundisyon ng mismong kagamitan.
Ang mga font ay output at binago gamit ang mga kakayahan ng Arduino. Sa kasong ito, kakailanganin mong gumamit ng isang handa na data library, pati na rin ang source code.
Mga halimbawa ng paggamit ng Arduino
Sa pagtingin sa maraming mga halimbawa ng Arduino, ang isa ay maaari lamang namangha sa malikhaing diskarte ng mga developer ng proyekto at hindi pangkaraniwang imahinasyon. Sa katunayan, maaari kang lumikha ng pinaka-hindi kapani-paniwalang mga bagay, halimbawa, ang parehong music player na may isang hanay ng mga LED.
Ang ganitong pag-unlad ay lubos na pahahalagahan ng mga mahilig sa musika, na nagpapahintulot sa kanila na lumikha hindi lamang ng isang orihinal na soundtrack, ngunit binibigyan din sila ng pagkakataong tamasahin ang isang maliwanag, hindi pangkaraniwang kumbinasyon ng kulay.
Kahit na ang mga alagang hayop, halimbawa, mga pusa, ay magagawang suriin ang mga proyekto. Ang dahilan ay isang awtomatikong tagapagpakain ng pusa, na maaaring binuo batay sa isang maginoo na CD player, halimbawa, at hindi lamang.
Kabilang sa mga pakinabang ng kagamitang ito, kinakailangang tandaan ang posibilidad ng dosed na pagpapakain ng pagkain sa hayop ngayon ay hindi na kailangang regular na suriin ang dami ng pagkain sa mangkok. Ang oras ng pagbubukas ay nababagay, pagkatapos nito ang pusa ay makakatanggap ng mga masustansyang pagkain nang mahigpit ayon sa itinatag na iskedyul, tinatamasa ang orihinal na ideya ng may-ari nito.
Kung pinag-uusapan natin ang tungkol sa ganap na hindi pangkaraniwang mga proyekto, maaari nating i-highlight ang mga awtomatikong kagamitan para sa isang bulaklak, na maaari na ngayong magpadala ng impormasyon tungkol sa kasalukuyang estado nito nang direkta sa Twitter. Ang lahat ng ito ay ginagawa sa pamamagitan ng paggamit ng mga kakayahan ng Arduino microcontroller, na magbibigay-daan sa iyong direktang maglipat ng data gamit ang isang koneksyon sa Internet. Tulad ng nakikita mo, ang mga halimbawa ay maaaring ibang-iba, susubukan kong bigyang-pansin ang bawat isa sa kanila sa mga sumusunod na artikulo.
