Mga Bagong Artikulo

● 5.4. Pagpapalawak ng mga digital port para sa NodeMCU ESP8266 gamit ang MCP23017 chip

Ipapakilala namin ang LED indication at sound alarm kapag ginagamit ang Nodemcu module bilang isang smart home controller. Ang bilang ng mga pin sa Nodemcu module ay mas mababa kaysa sa Arduino Mega, kaya kailangan namin ang MCP23017 input expander IC. Ang MCP23017 chip ay nagdaragdag ng 16 na port na maaaring i-configure para sa parehong input at output (Figure 5.7). Ginagamit ng chip ang sikat na two-wire I2C bus.

kanin. 5.7. MCP23017 pinout

Ang address ng MCP23017 chip para sa I2C protocol ay maaaring itakda sa pamamagitan ng kumbinasyon ng mga signal sa mga digital input na A0 - A2 (Larawan 5.8), na nagpapahintulot sa iyo na ikonekta ang 8 MCP23017 chips sa microcontroller sa parehong oras, ayon sa pagkakabanggit 16* 8=128 pin.

kanin. 5.8. Pagtatakda ng address ng MCP23017 chip

Ang chip ay may 2 bangko ng mga port A (GPA0-GPA7) at B (GPB0-GPAB), bawat isa ay maaaring i-configure para sa input o output.
Listahan 5.3. nagpapakita ng halimbawa ng pag-set up ng mga output na bangko A at B.

Listahan 5.3

// pagkonekta sa Wire.h library #isama byte input=0 ; void setup()( Serial.begin(9600 ); Wire.begin(0 ,2); // simulan ang I2C Wire.beginTransmission(0x20); // i2c - address (A0-0,A1-0,A2-0) Wire.write(0x00); // IODIRA register Wire.write(0x00 ); // itakda ang PORT A bilang output Wire.endTransmission(); ) void loop(){ // basahin ang data mula sa PORT B Wire.beginTransmission(0x20 ); Wire.write(0x13 ); Wire.endTransmission(); Wire.requestFrom(0x20 , 1 ); input=Wire.read(); // isulat ang natanggap na data sa PORT A Wire.beginTransmission(0x20 ); Wire.write(0x12 ); // address PORT A Wire.write(input); // PORT A Wire.endTransmission(); pagkaantala(100); // pause)

Ang paggamit ng MCP23017 chip ay magpapalawak ng bilang ng mga digital na contact ng Nodemcu module ng 16 at magbibigay-daan sa pag-aayos ng LED indication at naririnig na pagbibigay ng senyas ng mga kritikal na parameter ng sensor.

Gustung-gusto ng lahat ang murang Arduino boards, ngunit kadalasan ang isang proyekto ay literal na nawawala ang isa o dalawang libreng port! At kung minsan ay may sapat na mga port, ngunit hindi mo nais na hilahin ang isang bundle ng mga wire sa isa pang bahagi ng istraktura. Ipagpalagay na kailangan mong maglagay ng ilang mga pindutan at LED sa front panel ng device. Ito ay mas maaasahan at mas madaling ikonekta ang mga ito sa pangunahing board gamit lamang ang dalawang data bus wires, at hindi gamit ang isang cable o isang harness, tama ba?

Para sa mga ganitong sitwasyon, idinisenyo ang iba't ibang mga expander (expanders) ng mga Arduino port.

Karaniwan, ang mga microcontroller pin ay nagpapatupad ng ilang iba't ibang mga function, kaya ang mga expander ay iba:

1. Karaniwang GPIO Port Expander
2. PWM output expander
3. Mga pagpapalawak ng analog input - mga multiplexer at mga panlabas na ADC

Hiwalay, ito ay nagkakahalaga ng pagbanggit ng mga digital-to-analog converter (DACs) at expanders ng I2C bus address space. Ang mga aparatong ito ay hindi direktang duplicate ang mga function ng mga port, ngunit pinalawak ang mga kakayahan ng microcontrollers.

Sa unang artikulo ng serye, pag-uusapan natin ang tungkol sa pinakasimple at pinakakapaki-pakinabang na mga expander na gumagana bilang digital I / O port. Ito ay mga microcircuits at. Ang mga ito ay nakaayos at gumaganang ganap na magkapareho, at naiiba lamang sa bilang ng mga port.

Pagpili ng isang expander module para sa Arduino

Ang pinakasikat at murang module ay ginawa sa PCF8574 chip (Fig. 1)

kanin. 1. Sikat na PCF8574 port expander module

Mga kalamangan:

• Mababa ang presyo.
• Ang mga module ay maaaring konektado sa isang chain sa pamamagitan lamang ng pagpasok ng mga plug ng isang module sa mga socket ng naunang isa. Huwag kalimutang itakda ang mga jumper sa iba't ibang mga address ng module!

Mga disadvantages:

• Hindi direktang maipasok sa isang breadboard (inirerekumenda ko ang paghihinang ng port connector sa likod na bahagi).
• Isang kabuuang walong port sa isang module.

Kung ikaw ay nasa mood para sa mas seryosong mga proyekto, mag-order ng 16-bit na module para sa PCF8575 sa Aliexpress. Lubos kong inirerekomenda ang module na ipinapakita sa Fig. 2.

kanin. 2. PCF8575 port expander module

Mga kalamangan:

• Doble sa dami ng port.
• Built-in na 3.3V power supply, maaari mong paganahin ang iba pang mga module.
• Built-in na logic level na tumutugma para sa I2C bus sa iba't ibang supply voltages.
• Maginhawang format para sa isang breadboard.

Mga disadvantages:

• Sa itaas ng presyo.

Paano Gumagana ang PCF8574/PCF8575 GPIO Port Expander

Nagaganap ang pagpapalitan ng data sa pamamagitan ng I2C bus. Apat na wire lamang ang kinakailangan upang kumonekta sa Arduino board, kabilang ang kapangyarihan. Ang expander address ay itinakda ng tatlong jumper sa mga input na A0…A2, kaya walong magkaparehong chip ang maaaring ikonekta sa bus nang sabay at makakuha ng maximum na 8*8=64 karagdagang port na may PCF8574 o 8*16=128 na may PCF8575 chip.

Upang mag-output ng data sa port, magsulat ng data byte sa address ng module sa I2C bus. Upang magbasa ng data mula sa isang port, magbasa ng isang byte sa parehong address. Ang isang byte ay palaging nakasulat at binabasa sa kabuuan, ang pagtatrabaho sa mga indibidwal na digit ay ginagawa sa pamamagitan ng program.

Ang mga output ng microcircuit ay sabay-sabay na mga input, at walang service register na tumutukoy sa layunin ng output. Mayroon lamang isang latch kung saan nakasulat ang output byte. Paano ito posible?

Ang mga port ay gumagana sa isang open-collector na paraan at may panloob na pull-up resistors. Kung ang isang lohikal na zero ay nakasulat sa output, pagkatapos ay bubukas ang output transistor, na pilit na hinihila ang output "sa lupa". Ang pagbabasa mula sa naturang port ay palaging magbabalik ng zero.

Mag-ingat kapag naglalagay ng direktang supply ng boltahe sa isang pin na may mababang antas o kung lumampas ang kasalukuyang 50 mA sisirain mo ang chip!

Para gumamit ng port bilang input, sumulat ng isa dito. Sa kasong ito, ang panloob na transistor ay isasara, at ang resulta ng pagbabasa ay matutukoy ng isang panlabas na antas ng lohika na inilapat sa pin. Ang libreng output ay hinila hanggang sa kapangyarihan ng isang built-in na risistor.

Upang sabay-sabay na magamit ang ilan sa mga port bilang mga input at ilan bilang mga output, bago isulat ang bawat byte ng data sa expander, kinakailangang maglapat ng mask ng mga yunit sa mga bit na iyon na tumutugma sa mga input gamit ang "lohikal na O" na operasyon . Iyon lang)))

Makagambala sa henerasyon

Ang PCF857* Port Expander ay Bumubuo ng Interrupt Pulse mababang antas sa INT output na may anumang pagbabago sa input signal sa anumang input ng microcircuit. Ito ay maginhawa kung ang expander ay nagsisilbi ng isang keypad. Ngunit dapat mong matukoy sa interrupt handler kung aling pindutan ang pinindot o binitawan. Ang interrupt generator ay nilagyan ng filter ng pagpigil sa satsat.

Halimbawa 1: Gamit ang PCF8574 module

Bumuo tayo ng isang simpleng circuit ng apat na LED, isang PCF8574 module at isang Arduino board (Larawan 3 at 4). Sa switching scheme na ito, hindi na namin kailangan ang pagsusubo ng mga resistor para sa mga LED. Ang kasalukuyang daloy sa pamamagitan ng LED at ang built-in na risistor ay konektado sa power rail.

kanin. 3. Wiring diagram ng PCF8574 module

kanin. 4. Layout ng circuit na may PCF8574 module

Kopyahin at i-paste ang sketch 1 sa Arduino board:

// Module address sa bus (A0, A1, A2 = 0) int address = 0x38; // Nabasa ang data mula sa module uint8_t dataReceive; // Data na isusulat sa module uint8_t dataSend; void setup() ( Wire.begin(); Serial.begin(9600); // Mataas sa lahat ng PCF8574 ports dataSend = B11111111; pcf8574_write(dataSend); ) void loop() ( // Magbasa ng byte mula sa module dataReceive = pcf8574_read (); // Output sa monitor sa binary na format na Serial.println(dataReceive, BIN); // Shift ang mga bit na natitira sa pamamagitan ng nibble dataSend = dataReceive<< 4; // Накладываем битовую маску dataSend |= B00001111; // Записываем байт в модуль pcf8574_write(dataSend); delay(500); } // Процедура записи байта в модуль void pcf8574_write(uint8_t dt) { Wire.beginTransmission(address); Wire.write(dt); Wire.endTransmission(); } // Процедура чтения байта из модуля int8_t pcf8574_read() { Wire.beginTransmission(address); Wire.endTransmission(); Wire.requestFrom(address, 1); return (Wire.read()); }

Ang isang mataas na antas ay unang nakasulat sa lahat ng mga port ng microcircuit, kaya ang mga port na P0 ... P3 ay maaaring gumana bilang mga input.

Ang mga antas sa mga port pin ay binabasa tuwing 500 ms at ang resulta ng pagbabasa ay ipinapakita sa monitor. Kung ikinonekta mo ang isa sa mga P0…P3 input sa isang karaniwang wire, lalabas ang zero sa bit nito. Pagkatapos ang read value ay inilipat sa kaliwa ng apat na bits, ang resulta ay output sa port at ang isa sa mga LED ay lumabas. Halimbawa, kung ang zero ay nabasa sa pin P0, ang LED na konektado sa pin P4 ay i-off.

Pakitandaan na bago ang bawat pagsulat sa expander, dapat tayong maglapat ng kaunting mask ng mga isa sa lahat ng mga bit na dapat na mga input: dataSend |= B00001111;

Ang mga subroutine para sa pagtatrabaho sa I2C bus ay lubos na pinasimple, walang mga error na naproseso.

Payo: upang mahanap at suriin ang address ng module sa I2C bus, maaari mong gamitin ang . Inilalabas nito sa terminal ang mga address ng lahat ng device na tumutugon sa isang kahilingan sa bus.

Halimbawa 2: Gamit ang PCF8575 module

Ang kakaiba ng PCF8575 module ay mayroon itong 16 na port, kaya ito laging sumulat ng dalawang byte at magbasa ng dalawang byte. Dapat sundin ang panuntunang ito kahit na hindi kailangan ang pangalawang byte.

Baguhin natin ng kaunti ang schema. Ikokonekta namin ang mga LED sa mga port na P10 ... P13, at ikokonekta namin ang mga port na P00 ... P03 na may isang jumper sa karaniwang wire (Larawan 5 at 6).

kanin. 5. Wiring diagram ng PCF8575 module

kanin. 6. Layout ng circuit na may PCF8575 module

Ang Sketch 2 ay unang nagsusulat ng mga ito sa lahat ng port, pagkatapos ay binabasa ang kanilang estado tuwing 500 ms. Ang read procedure ay nagbabalik ng 16-bit na salita na nahahati sa mga byte. Ang nilalaman ng mababang byte (pins P00…P07) ay kinopya sa mataas na byte at na-upload pabalik sa module. Kung ang isa sa mga output na P00…P03 ay konektado sa isang karaniwang wire, ang isa sa mga LED na konektado sa P10…P13 ay mawawala.

// Library para sa pagtatrabaho sa I2C #include // Module address sa bus bilang default int address = 0x20; // Nabasa ang data mula sa module uint8_t hi, lo; uint16_t dataReceive; uint8_tdataHighByte; // High byte (P10...P17) uint8_t dataLowByte; // Low byte (P00...P07) void setup() ( Wire.begin(); Serial.begin(9600); // Mataas na antas sa lahat ng PCF8575 ports dataHighByte = B11111111; dataLowByte = B11111111; pcf8575_LoghByte(,data ); ) void loop() ( // Basahin ang isang byte mula sa module dataReceive = pcf8575_read(); // I-print sa monitor sa binary format Serial.println(dataReceive, BIN); // I-extract ang mababang byte mula sa mahabang salita dataLowByte = lowByte(dataReceive ); // Kopyahin ang mababang byte sa mataas na byte dataHighByte = dataLowByte; // I-mask ang mababang byte dataLowByte |= B11111111; // Sumulat ng bagong data sa module, dalawang byte pcf8575_write(dataHighByte); delay(500); ) // Pamamaraan para sa pagsusulat ng byte sa module void pcf8575_write(uint8_t dtl, int8_t dth) ( Wire.beginTransmission(address); Wire.write(dtl); // Sumulat ng mababang byte (P00... P07) Wire.write(dth); / / Sumulat ng mataas na byte (P10...P17) Wire.endTransmission(); ) // Pamamaraan para sa pagbabasa ng byte mula sa module int16_t pcf8575_read( ) ( Wire.beginTransmission(address); Wire.endTransmission(); Wire.requestFrom(address, 2); lo = Wire.read(); // Basahin ang mababang byte (P00...P07) hi = Wire.read(); // Read high byte (P10...P17) return (word(hi, lo)); // Ibalik ang mahabang salita )

Arduino Library para sa PCF8574/PCF8575

Maaaring ma-download ang library mula sa GitHub. Ngunit, tulad ng nakikita mo, ang pagtatrabaho sa mga extender ng port ay napaka-simple at madali mong magagawa nang walang espesyal na library.

Ang isa sa mga pangunahing bentahe ng Arduino platform ay ang katanyagan nito. Ang sikat na platform ay aktibong sinusuportahan ng mga tagagawa ng mga elektronikong aparato, na naglalabas ng mga espesyal na bersyon ng iba't ibang mga board na nagpapalawak sa pangunahing pag-andar ng controller. Ang ganitong mga board, medyo lohikal na tinatawag na mga expansion board (isa pang pangalan: arduino shield, shield), ay nagsisilbi upang magsagawa ng iba't ibang uri ng mga gawain at maaaring lubos na gawing simple ang buhay ng isang ardunian. Sa artikulong ito, malalaman natin kung ano ang Arduino expansion board at kung paano ito magagamit para gumana sa iba't ibang Arduino device: mga motor (motor driver shield), LCD screen (LCD shield), SD card (data logger), sensor. (sensor shield ) at marami pang iba.

Unawain muna natin ang mga tuntunin. Ang Arduino expansion board ay isang kumpletong device na idinisenyo upang magsagawa ng ilang mga function at konektado sa pangunahing controller gamit ang mga karaniwang connector. Ang isa pang sikat na pangalan para sa isang expansion board ay ang English-language Arduino shield o simpleng shield. Ang lahat ng kinakailangang elektronikong bahagi ay naka-install sa expansion board, at ang pakikipag-ugnayan sa microcontroller at iba pang elemento ng main board ay nangyayari sa pamamagitan ng karaniwang arduino pin. Kadalasan, ang kalasag ay pinapagana din mula sa pangunahing arduino board, bagaman sa maraming mga kaso posible itong paganahin mula sa iba pang mga mapagkukunan. Sa anumang kalasag, mayroong ilang libreng pin na magagamit mo sa iyong paghuhusga sa pamamagitan ng pagkonekta sa anumang iba pang bahagi sa kanila.

Ang salitang Ingles na Shield ay isinalin bilang isang kalasag, screen, screen. Sa aming konteksto, dapat itong maunawaan bilang isang bagay na sumasaklaw sa controller board, na lumilikha ng karagdagang layer ng device, isang screen kung saan nakatago ang iba't ibang elemento.

Bakit kailangan ang mga arduino shield?

Napakasimple ng lahat: 1) para makatipid tayo ng oras, at 2) may maaaring kumita dito. Bakit mag-aaksaya ng oras sa pagdidisenyo, paglalagay, paghihinang, at pag-debug ng isang bagay na maaari mong kunin na naka-assemble na at simulang gamitin kaagad? Mahusay na idinisenyo at binuo sa mataas na kalidad na hardware, ang mga expansion board ay karaniwang mas maaasahan at kumukuha ng mas kaunting espasyo sa huling device. Hindi ito nangangahulugan na kailangan mong ganap na iwanan ang pagpupulong sa sarili at hindi kailangang maunawaan ang prinsipyo ng pagpapatakbo ng ilang mga elemento. Pagkatapos ng lahat, palaging sinusubukan ng isang tunay na inhinyero na maunawaan kung paano gumagana ang kanyang ginagamit. Ngunit makakagawa tayo ng mas kumplikadong mga device kung hindi natin muling iimbento ang gulong sa bawat oras, ngunit ituon ang ating pansin sa kung ano ang nalutas ng ilang tao bago tayo.

Naturally, kailangan mong magbayad para sa mga pagkakataon. Halos palaging, ang halaga ng panghuling kalasag ay mas mataas kaysa sa presyo ng mga indibidwal na bahagi, maaari mong palaging gawing mas mura ang isang katulad na opsyon. Ngunit narito, nasa iyo ang pagpapasya kung gaano kahalaga ang oras o pera na ginugol para sa iyo. Isinasaalang-alang ang lahat ng posibleng tulong mula sa industriya ng Tsino, ang halaga ng mga board ay patuloy na bumababa, kaya kadalasan ang pagpili ay ginawa pabor sa paggamit ng mga yari na device.

Ang pinakasikat na mga halimbawa ng mga kalasag ay ang mga expansion board para sa pagtatrabaho sa mga sensor, motor, LCD screen, SD card, network at GPS na kalasag, mga kalasag na may mga built-in na relay para sa pagkonekta sa load.

Pagkonekta ng Arduino Shields

Upang ikonekta ang kalasag, kailangan mo lamang na maingat na "ilagay" ito sa pangunahing board. Karaniwan, ang mga pin ng comb-type shield (lalaki) ay madaling ipinasok sa Arduino board connectors. Sa ilang mga kaso, ito ay kinakailangan upang maingat na sabunot ang mga pin kung ang board mismo ay hindi soldered nang maayos. Ang pangunahing bagay dito ay kumilos nang maingat at huwag maglapat ng labis na puwersa.

Bilang isang patakaran, ang kalasag ay idinisenyo para sa isang napaka-espesipikong bersyon ng controller, bagaman, halimbawa, maraming Arduino Uno shield ang gumagana nang maayos sa mga Arduino Mega board. Ang pinout sa mega ay ginawa sa paraang ang unang 14 na digital na contact at ang mga contact sa kabilang panig ng board ay nag-tutugma sa lokasyon ng mga contact sa UNO, kaya ang kalasag mula sa arduino ay madaling naging ito.

Arduino Shield Programming

Ang pag-program ng isang circuit na may expansion board ay hindi naiiba sa karaniwang programming ng isang arduino, dahil mula sa punto ng view ng controller, ikinonekta lang namin ang aming mga device sa mga karaniwang pin nito. Sa sketch, kailangan mong tukuyin ang mga pin na konektado sa kalasag sa kaukulang mga pin sa board. Bilang isang patakaran, ang tagagawa ay nagpapahiwatig ng pagsusulatan ng mga pin sa kalasag mismo o sa isang hiwalay na manwal ng koneksyon. Kung ida-download mo ang mga sketch na inirerekomenda ng tagagawa ng board, hindi mo na kakailanganing gawin iyon.

Ang pagbabasa o pagsusulat ng mga signal ng kalasag ay ginagawa din sa karaniwang paraan: gamit ang mga function, at iba pang mga utos na pamilyar sa sinumang arduinist. Sa ilang mga kaso, posible ang mga banggaan kapag nasanay ka sa scheme ng koneksyon na ito, at ang tagagawa ay pumili ng isa pa (halimbawa, hinila mo ang pindutan sa lupa, at sa kalasag - sa kapangyarihan). Dito kailangan mo lang mag-ingat.

Bilang panuntunan, ang expansion board na ito ay nasa mga arduino kit at samakatuwid ay kasama nito ang pinakamadalas na pagkikita ng mga arduino. Ang kalasag ay medyo simple - ang pangunahing gawain nito ay upang magbigay ng mas maginhawang mga opsyon para sa pagkonekta sa Arduino board. Ginagawa ito sa pamamagitan ng karagdagang mga konektor ng kapangyarihan at lupa, na dinadala sa board sa bawat isa sa mga analog at digital na pin. Gayundin sa board maaari kang makahanap ng mga konektor para sa pagkonekta sa isang panlabas na mapagkukunan ng kuryente (kailangan mong mag-install ng mga jumper upang lumipat), isang LED at isang pindutan ng pag-restart. Ang mga opsyon sa kalasag at mga halimbawa ng paggamit ay makikita sa mga guhit.

Mayroong ilang mga bersyon ng sensor expansion board. Ang lahat ng mga ito ay naiiba sa bilang at uri ng mga konektor. Ang pinakasikat na mga bersyon ngayon ay ang Sensor Shield v4 at v5.

Ang arduino shield na ito ay napakahalaga sa robotics projects. Binibigyang-daan kang ikonekta ang mga regular at servo motor sa Arduino board nang sabay-sabay. Ang pangunahing gawain ng kalasag ay ang magbigay ng kontrol sa mga device na kumonsumo ng kasalukuyang sapat na mataas para sa isang regular na arduino board. Ang mga karagdagang tampok ng board ay ang pag-andar ng pagkontrol sa kapangyarihan ng motor (gamit ang PWM) at pagbabago ng direksyon ng pag-ikot. Mayroong maraming mga uri ng motor shield boards. Karaniwan sa lahat ng mga ito ay ang presensya sa circuit ng isang malakas na transistor kung saan konektado ang isang panlabas na load, mga elemento ng heat sink (karaniwang radiator), mga circuit para sa pagkonekta ng panlabas na kapangyarihan, mga konektor para sa pagkonekta ng mga motor at mga pin para sa pagkonekta sa isang arduino.

Ang organisasyon ng trabaho kasama ang network ay isa sa pinakamahalagang gawain sa mga modernong proyekto. Upang kumonekta sa isang lokal na network ng lugar sa pamamagitan ng Ethernet, mayroong kaukulang expansion board.

Mga Prototyping Expansion Board

Ang mga board na ito ay medyo simple - mayroon silang mga contact pad para sa mga elemento ng pag-mount, isang pindutan ng pag-reset ay ipinapakita at posible na ikonekta ang panlabas na kapangyarihan. Ang layunin ng mga kalasag na ito ay upang madagdagan ang pagiging compactness ng aparato, kapag ang lahat ng kinakailangang mga bahagi ay matatagpuan kaagad sa itaas ng pangunahing board.

Arduino LCD shield at tft shield

Ang ganitong uri ng kalasag ay ginagamit upang gumana sa mga LCD screen sa arduino. Tulad ng alam mo, ang pagkonekta kahit na ang pinakasimpleng 2-line na text screen ay malayo sa isang maliit na gawain: kailangan mong ikonekta nang tama ang 6 na mga contact sa screen nang sabay-sabay, hindi binibilang ang power supply. Mas madaling magpasok ng isang handa na module sa isang arduino board at i-upload lamang ang naaangkop na sketch. Sa sikat na LCD Keypad Shield, mula 4 hanggang 8 na mga pindutan ay agad na nakakonekta sa board, na nagbibigay-daan sa iyo upang agad na ayusin ang isang panlabas na interface para sa gumagamit ng device. Nakakatulong din ang TFT Shield

Arduino Data Logger Shield

Ang isa pang gawain na medyo mahirap ipatupad nang mag-isa sa iyong mga produkto ay ang pag-iimbak ng data na natanggap mula sa mga sensor na may time reference. Ang handa na kalasag ay nagbibigay-daan hindi lamang upang i-save ang data at makatanggap ng oras mula sa built-in na orasan, ngunit din upang ikonekta ang mga sensor sa isang maginhawang paraan sa pamamagitan ng paghihinang o sa circuit board.

Maikling buod

Sa artikulong ito, isinasaalang-alang lamang namin ang isang maliit na bahagi ng malaking hanay ng iba't ibang mga aparato na nagpapalawak ng pag-andar ng arduino. Nagbibigay-daan sa iyo ang mga expansion board na tumuon sa pinakamahalagang bagay - ang lohika ng iyong programa. Ang mga tagalikha ng mga kalasag ay nagbigay para sa tama at maaasahang pag-install, ang kinakailangang suplay ng kuryente. Ang natitira na lang para sa iyo ay hanapin ang board na kailangan mo gamit ang itinatangi na salitang Ingles na kalasag, ikonekta ito sa arduino at i-upload ang sketch. Karaniwan, ang anumang pagprograma ng isang kalasag ay binubuo sa pagsasagawa ng mga simpleng aksyon upang palitan ang pangalan ng mga panloob na variable ng isang tapos na programa. Bilang resulta, nakakakuha kami ng kadalian ng paggamit at koneksyon, pati na rin ang bilis ng pag-assemble ng mga natapos na device o prototype.

Ang downside ng paggamit ng mga expansion card ay ang kanilang gastos at posibleng pagkawala ng kahusayan dahil sa versatility ng mga shield na nasa kanilang kalikasan. Para sa iyong partikular na application o end device, maaaring hindi kailanganin ang lahat ng feature ng shield. Sa kasong ito, dapat mong gamitin ang kalasag lamang sa yugto ng prototyping at pagsubok, at kapag lumilikha ng panghuling bersyon ng iyong device, isipin ang pagpapalit nito ng isang disenyo gamit ang iyong sariling scheme at uri ng layout. Ikaw ang bahala, nasa iyo ang lahat ng posibilidad para sa tamang pagpipilian.

→ Paano palawakin ang bilang ng mga analog input at output sa iyong Arduino?

Paano palawakin ang bilang ng mga analog input at output sa iyong Arduino?

Ang isang multiplexer o demultiplexer ay magbibigay-daan sa iyo na palawakin ang bilang ng mga input at output sa iyong Arduino.
Ang 4051 ay isang 8-channel na analog multiplexer/demultiplexer, kaya:
* Kung ginagamit mo ang 4051 bilang isang multiplexer: Maaari kang pumili ng alinman sa 8 magkakaibang input at basahin ang status nito sa controller.
* Kung ginagamit mo ang 4051 bilang isang demultiplexer, maaari kang pumili ng alinman sa 8 magkakaibang mga output at isulat ang halaga na gusto mo doon.

Gayundin, kayang hawakan ng 4051 ang mga analog na halaga, sa iyong Arduino, maaari mong gamitin ang 0-5V analog signal at ikonekta ang IC sa mga analog input sa Arduino.

Upang piliin ang nais na microcircuit input pati na rin ang read o write operation modes, dapat tayong gumamit ng tatlong control signal (S0, S1 at S2). Ang bawat isa sa mga pin na ito ay dapat na konektado sa isa sa mga digital na output ng Arduino. Ang bawat output ay may numero (S0 = 1; S1 = 2; S2 = 4) at kung ang isa sa mga output na ito ay nakatakda sa isang mataas na antas ng logic, ang bilang ng mga pin na kinakatawan ay magiging 4051.

Halimbawa:
* Kung itinakda mo ang log "1" sa mga input ng microcircuit S0 at S1 at mag-log "0" sa S2, pagkatapos ay napili ang input y3 ng microcircuit, ganito ang hitsura nito (1 +2 +0 = 3).
* Kung itinakda mo ang log "1" sa mga input ng microcircuit S0 at S2 at mag-log "0" sa S1, pagkatapos ay napili ang input y5 ng microcircuit, ganito ang hitsura nito (1 +0 +4 = 5).

Hindi posibleng magbasa o magsulat ng status sa higit sa isang 4051 pin sa isang pagkakataon. Ngunit maaari mong basahin at isulat ang estado mula sa output ng chip nang medyo mabilis. Hindi na kailangan ng pagkaantala sa pagitan ng pagpili, pagbabasa o pagsulat ng estado ng 4051 pin.

* Z----- karaniwang input o output signal (nakakonekta sa Arduino I/O)
* E ----- paganahin ang input (aktibong log "0") (nakakonekta sa ground (GND))
* Vee --- negatibong boltahe ng supply (nakakonekta sa lupa (GND ))
* GND --- ground negatibo (0 V)
* S0-S2 - piliin ang mga input (nakakonekta sa tatlong Arduino digital pin)
* y0-Y7 - mga independiyenteng input/output
* Vcc --- positibong supply ng boltahe (5V)

Ang kaliwang larawan sa itaas ay isang halimbawa kung paano gumamit ng 9 multiplexer upang basahin ang 64 analog input na may isang Arduino analog input lamang.
Ang kanang larawan sa itaas ay isang halimbawa ng kung paano gumamit ng dalawang 4051s (isa ay naka-configure bilang isang demultiplexer at isa bilang isang multiplexer) sa isang 8x8 matrix upang subukan ang 64 na mga pindutan o iba pang mga digital input mula sa isang digital input lamang sa Arduino (mula sa pangalawang setup maaari kang magkaroon ng dalawang pindutan sa isang pagkakataon). parehong oras, kung hindi, dapat mong gamitin ang unang (kaliwa) na setting).

Halimbawa ng code:

// Halimbawa para sa paggamit ng 4051 analog multiplexer/demultiplexer
// ni david c.

int led = 13 ; // I-set up ang LED sa 13th leg
int r0 = 0 ; // value piliin ang output sa 4051 (S0)
int r1 = 0 ; // value piliin ang output sa 4051 (S1)
int r2 = 0 ; // value piliin ang output sa 4051 (S2)
int row = 0 ; // itabi ang bin code
int count = 0 ; // brush
int bin = ( 000, 1, 10, 11, 100, 101, 110, 111 ); // Isang hanay ng mga binary na numero na tumutukoy sa bilang ng napiling input / output ng 4051 chip, mula 1 hanggang 8.
void setup () ( // INITIALIZE
pinMode (2 , OUTPUT) ; // s0 paglabas
pinMode (3 , OUTPUT) ; // s1 paglabas
pinMode (4 , OUTPUT) ; // s2 exit
digitalWrite (humantong , HIGH) ; //sindi ang LED
beginSerial(9600) ; // exchange rate ng UART
}

void loop()(
para sa (bilang = 0 ; bilang ≤ 7 ; bilang ++) ( // umikot sa mga elemento ng array mula 1 hanggang 8
row = bin [ bilang ] ;
r0 = hilera & 0x01 ;
r1 = (row >> 1) & 0x01 ; //
r2 = (row >> 2) & 0x01 ; //
digitalWrite(2, r0);
digitalWrite(3, r1);
digitalWrite(4, r2);
Serial.println(bin);
pagkaantala(1000);

Ang mga SPI o I2C ADC chip ay madaling magagamit sa isang hanay ng mga resolution, sample rate, at bilang ng mga channel. Ang mga ito ay medyo madaling idagdag sa anumang Arduino.

Halimbawa, ang MCP3208 ay magbibigay ng 8 channel ng 12-bit na resolution bawat SPI, na nangangahulugang 3 pin (MOSI/MISO/SCK) + 1 bawat chip (SS). Kaya ang 1 chip ay magiging 4 pins, 2 chips 5 pins, 3 chips 6 pins, atbp.

Ang pagdaragdag ng maraming IC sa SPI bus ay maaaring maging isang istorbo sa loob at sa sarili nito na may tumaas na kapasidad ng lahat ng mga input na iyon na nangangahulugang kailangan mong pabagalin ng kaunti ang bilis ng pagmemensahe o magdagdag ng ilang dagdag na buffering upang mapabilis ang pagmamaneho ng bus.

Ang mga I2C chips ay maaaring maging mas mapanlinlang na magkaroon dahil mayroon lamang isang limitadong bilang ng mga address sa I2C bus - at sa maraming Arduinos I2C ay isa ring dalawang analog na pin na maaaring hindi mo gustong isakripisyo.

Ang pangalawang opsyon ay nagsasangkot ng paggamit ng mga analog multiplexer (hal. 4051) upang ilipat ang iba't ibang mga mapagkukunan sa mga umiiral na analog input.

Ang pangatlong opsyon, na malamang na hindi mo pa isinasaalang-alang, ay ang pagkakaroon ng maraming arduinos (o iba pang murang microcontrollers) bawat isa ay gumagawa ng ilang pagkuha at pagkatapos ay nagpapatupad ng ilang paraan ng komunikasyon sa pagitan nila (o sa isang master). Ito ay may dagdag na benepisyo ng pagiging maka-sample ng maramihang mga channel sa parehong oras (isa sa bawat microcontroller), na medyo nagpapabilis sa iyong trabaho.

Ang pagpapalawak sa sagot ni Mazhenko, maaari kang gumamit ng analog multiplexer tulad ng 74HC4051 upang gawing 8 ang isang analog port.

Ang pinsan nito, ang 74HC4067, ay magpaparami ng 16 na port. Ngayon na may 6 na analog input sa Arduino Uno maaari kang magkaroon ng 6 x 16 inputs = 96. Ang A/B/C control signal ay maaaring magkaparehas.

Papayagan ka nitong pangasiwaan ang 96 na input na may 6 na dagdag na chips at medyo simpleng code. Mayroon akong mga halimbawa ng code sa aking 74HC4051 mux/demux page.

Para sa 8 inputs code:

// Halimbawa ng paggamit ng 74HC4051 multiplexer/demultiplexer // May-akda: Nick Gammon // Petsa: 14 Marso 2013 const byte sensor = A0; //kung saan nakakonekta ang multiplexer in/out port // ang multiplexer address ay pumili ng mga linya (A/B/C) const byte addressA = 6;//low-order bit const byte addressB = 5; const byte addressC = 4; //high-order bit void setup()( Serial.begin(115200); Serial.println("Starting multiplexer test...");pinMode(addressA, OUTPUT);pinMode(addressB, OUTPUT );pinMode (addressC, OUTPUT); ) //end of setup int readSensor (const byte which) ( //piliin ang tamang MUX channel digitalWrite (addressA, (alin at 1) ? HIGH: LOW); //low-order bit digitalWrite (addressB, (alin at 2) ? HIGH: LOW); digitalWrite (addressC, (alin & 4) ? HIGH: LOW); //high-order bit //basahin ngayon ang sensor return analogRead (sensor); ) / /end of readSensor void loop () ( // ipakita ang lahat ng 8 sensor readings para sa (byte i = 0; i< 7; i++) { Serial.print ("Sensor "); Serial.print (i); Serial.print (" reads: "); Serial.println (readSensor (i)); } delay (1000); } //end of loop

Eksaktong nagtrabaho ako sa parehong isyu. Kailangan ko ng program na nagbabasa ng 100 thermistor... Bakit? well, kung kailangan mo ito.

natapos ko na.

Sinubukan ko ang 74HC4051 multiplexer/demultiplexer. Ngunit sa ilang kadahilanan ay hindi ko nakuha ang ninanais na resulta.

Ang unang makikita mo... POWER, kakailanganin mo ng external power supply, kaso gumawa lang ako ng boltahe divider at ikinonekta ang thermistor sa kapangyarihan na iyon at pagkatapos ay gamitin lamang ang analog port para magbasa...

Gumagamit ako ng I2C protocol, 8 arduino Mega 7 slave at isang master. at pagkatapos magpadala ng send Integer, float at blah blah ay hindi gumana para sa akin na gawin lamang ito. Maaari itong magpadala ng analog read over I2C at ginagawa ng master ang lahat ng kinakailangang conversion.

Kung interesado ka pa, maaari kong ipadala sa iyo ang source code para sa master at slaves. Sa template na ito, maaari kang kumonekta ng hanggang 50 arduino at hahanapin ng master ang bawat arduino na konektado sa network at humiling ng data.