Pagpunta sa Higit sa StandardFirmata - Muling Bumisita: 5 Hakbang

2024 May -akda: John Day | [email protected]. Huling binago: 2024-01-30 13:11

Ilang sandali lang ang nakakaraan, nakontak ako ni Dr. Martyn Wheeler, isang gumagamit ng pymata4, para sa patnubay sa pagdaragdag ng suporta para sa sensor ng DHT22 Humidity / Temperature sa library ng pymata4. Ang pymata4 library, kasabay ng katapat nitong Arduino, FirmataExpress, ay nagbibigay-daan sa mga gumagamit na kontrolin at subaybayan ang kanilang mga aparatong Arduino mula sa malayo. Sa loob ng ilang mga pag-ikot ng palitan ng email, matagumpay na binago ni Dr. Wheeler ang parehong pymata4 at FirmataExpress. Bilang isang resulta, ang suporta para sa DHT22 at DHT11 sensor ay ngayon isang karaniwang bahagi ng pymata4 at FirmataExpress.

Noong Mayo ng 2014, nagsulat ako ng isang artikulo sa pagdaragdag ng suporta sa Firmata para sa mga karagdagang aparato. Sumasalamin sa artikulong iyon, napagtanto ko kung magkano ang nagbago mula nang kumuha ako ng panulat sa papel para sa artikulong iyon. Bilang karagdagan sa artikulong ito, naitala ni Dr. Wheeler ang kanyang mga pagsisikap, at maaari mong hilingin na suriin din iyon.

Ang FirmataExpress ay batay sa StandardFirmata, at ang istrakturang direktoryo ng StandardFirmata ay umunlad. Bilang karagdagan, ang pymata4 API ay medyo kakaiba din mula sa orihinal na PyMata API ng 2014. Akala ko ito ang magiging perpektong oras upang muling bisitahin at i-update ang artikulong iyon. Gamit ang trabaho ni Dr. Wheeler bilang batayan, tuklasin natin kung paano pahabain ang pagpapaandar ng pymata4 / FirmataExpress.

Bago Kami Magsimula - Ang Ilang Impormasyon sa Background Tungkol sa Arduino / Firmata

Kaya ano ang Firmata? Sumipi mula sa web page ng Firmata, "Ang Firmata ay isang pangkaraniwang protokol para sa pakikipag-usap sa mga microcontroller mula sa software sa isang host computer."

Gumagamit ang Arduino Firmata ng isang serial interface upang maihatid ang parehong utos at mag-ulat ng impormasyon sa pagitan ng isang Arduino microcontroller at isang PC, karaniwang gumagamit ng isang serial / USB link na nakatakda sa 57600 bps. Ang data na inilipat sa buong link na ito ay binary, at ang protocol ay ipinatupad sa isang modelo ng client / server.

Ang panig ng server ay na-upload sa isang Arduino microcontroller sa anyo ng isang Arduino sketch. Ang StandardFirmata sketch, na kasama ng Arduino IDE, ay kumokontrol sa mga Arduino I / O pin, tulad ng iniutos ng kliyente. Iniuulat din nito ang mga pagbabago sa pag-input ng pin at iba pang impormasyon sa ulat na bumalik sa kliyente. Ang FirmataExpress ay isang pinalawig na bersyon ng StandardFirmata. Tumatakbo ito sa isang serial link na bilis ng 115200 bps.

Ang Arduino client na ginamit para sa artikulong ito ay pymata4. Ito ay isang application ng Python na naisakatuparan sa isang PC. Parehong nagpapadala ito ng mga utos at tumatanggap ng mga ulat mula sa Arduino server. Dahil ang pymata4 ay ipinatupad sa Python, tumatakbo ito sa Windows, Linux (kasama ang Raspberry Pi), at mga macOS computer.

Bakit Gumagamit ng Firmata?

Ang mga Arduino microcontroller ay kamangha-manghang maliit na mga aparato, ngunit ang mga mapagkukunan ng processor at memorya ay medyo limitado. Para sa mga application na masinsinang processor o memorya, madalas may kaunting pagpipilian ngunit upang mai-offload ang demand na mapagkukunan sa isang PC para maging matagumpay ang aplikasyon.

Ngunit hindi lamang iyon ang dahilan para gamitin ang StandardFirmata. Kapag nagkakaroon ng mas magaan na timbang na mga application ng Arduino, ang isang PC ay maaaring magbigay ng mga tool at mga kakayahan sa pag-debug na hindi direktang magagamit sa isang Arduino microcontroller. Ang paggamit ng isang "nakapirming" client at server ay makakatulong na makulong ang pagiging kumplikado ng aplikasyon sa isang PC, na mas madaling mapamahalaan. Kapag ang application ay naperpekto, maaari itong isalin sa isang pasadyang, may sariling Arduino sketch.

Bakit Gumagamit ng pymata4?

Ang pagiging may-akda nito, syempre, bias ako. Sinabi na, ito lamang ang client na naka-base sa Python na Firmata na patuloy na napanatili sa huling ilang taon. Nagbibigay ito ng isang madaling maunawaan at madaling gamitin na API. Bilang karagdagan sa mga sketch na batay sa StandardFirmata, sinusuportahan nito ang Firmata sa paglipas ng WiFi para sa mga aparato tulad ng ESP-8266 kapag ginagamit ang StandardFirmataWifI sketch.

Gayundin, ang pymata4 ay idinisenyo upang madaling mapalawak ng isang gumagamit upang suportahan ang mga karagdagang sensor at actuator na hindi kasalukuyang sinusuportahan ng StandardFirmata.

Hakbang 1: Pag-unawa sa Firmata Protocol

Ang Arduino Firmata komunikasyon protocol ay nagmula sa MIDI protocol, na gumagamit ng isa o higit pang 7-bit bytes upang kumatawan sa data.

Ang Firmata ay idinisenyo upang ma-extensible ng gumagamit. Ang mekanismo na nagbibigay ng kakayahang lumawak na ito ay ang System Exclusive (SysEx) na messaging protocol.

Ang format ng isang mensahe na SysEx, tulad ng tinukoy ng Firmata Protocol, ay ipinapakita sa ilustrasyon sa itaas. Nagsisimula ito sa isang byte na START_SYSEX na may isang nakapirming halaga ng hexadecimal 0xF0, at sinusundan ng isang natatanging byte ng SysEx na utos. Ang halaga ng command byte ay dapat na nasa saklaw ng hexadecimal 0x00-0x7F. Ang command byte ay sinusundan ng isang hindi natukoy na bilang ng 7-bit na byte ng data. Sa wakas, ang mensahe ay winakasan ng isang byte ng END_SYSEX, na may isang nakapirming halaga ng hexadecimal 0xF7.

Pag-encode / pag-decode ng Data ng Firmata

Dahil ang bahagi ng data ng gumagamit ng isang mensahe na SysEx ay binubuo ng isang serye ng 7-bit bytes, maaari kang magtaka kung paano kumakatawan ang isang halaga na higit sa 128 (0x7f)? Na-encode ng Firmata ang mga halagang iyon sa pamamagitan ng pag-disassemble ng mga ito sa maraming 7-bit byte chunks bago ma-marshaled ang data sa buong link ng data. Ang hindi gaanong makabuluhang byte (LSB) ng isang item ng data ay naipadala muna, na sinusundan ng lalong nagiging makabuluhang mga bahagi ng item ng data sa pamamagitan ng kombensyon. Ang pinaka makabuluhang byte (MSB) ng item ng data ay ang huling ipinadala na item ng data.

Paano Ito Magagawa?

Sabihin nating nais naming isama ang isang halagang 525 sa bahagi ng data ng isang mensahe na SysEx. Dahil ang halagang 525 ay malinaw na mas malaki kaysa sa halagang 128, kailangan nating hatiin o i-disassemble ito sa 7-bit byte na "mga chunks."

Narito kung paano ito ginagawa.

Ang halaga ng 525 sa decimal ay katumbas ng hexadecimal na halaga ng 0x20D, isang 2-byte na halaga. Upang makuha ang LSB, tinakpan namin ang halaga sa pamamagitan ng AND'ing ito sa 0x7F. Ang parehong pagpapatupad ng "C" at Python ay ipinapakita sa ibaba:

// pagpapatupad ng "C" upang ihiwalay ang LSB

int max_distance_LSB = max_distance & 0x7f; // mask the lower byte # Python pagpapatupad upang ihiwalay ang LSB max_distance_LSB = max_distance & 0x7F # mask ang mas mababang byte

Pagkatapos ng masking, maglalaman ang max_distance_LSB ng 0x0d. 0x20D & 0x7F = 0x0D.

Susunod, kailangan naming ihiwalay ang MSB para sa halagang 2-byte na ito. Upang magawa ito, ililipat namin ang halaga ng 0x20D sa kanan, 7 na lugar.

// pagpapatupad ng "C" upang ihiwalay ang MSB ng 2 byte na halaga

int max_distance_MSB = max_distance >> 7; // shift the high order byte # Python pagpapatupad upang isoloate ang MSB ng 2 byte na halaga max_distance_MSB = max_distance >> 7 # shift upang makuha ang itaas na byte Pagkatapos ng paglilipat, ang max_distance_MSB ay maglalaman ng halagang 0x04.

Kapag natanggap ang "chunkified" na marshaled data, kailangan itong muling buuin sa isang solong halaga. Narito kung paano muling ibinalik ang data sa parehong "C" at Python

// pagpapatupad ng "C" upang muling pagsama-samahin ang 2 byte, // 7 bit na halaga sa isang solong halaga int max_distance = argv [0] + (argv [1] << 7); Pagpapatupad ng # Python upang muling pagsama-samahin ang 2 byte, mga halagang # 7 bit sa isang solong halaga max_distance = data [0] + (data [1] << 7)

Pagkatapos ng muling pagtitipon, ang halaga ay muling katumbas ng 525 decimal o 0x20D hexadecimal.

Ang proseso ng pag-disassemble / muling pagsasama ay maaaring isagawa ng alinman sa client o server.

Hakbang 2: Magsimula Na Tayo

Ang pagsuporta sa isang bagong aparato ay nangangailangan ng mga pagbabago sa parehong residente ng server ng Arduino at ng client ng PC na residente ng Python. Ang gawa ni Dr. Wheeler ay gagamitin upang ilarawan ang mga kinakailangang pagbabago.

Marahil ang pinakamahalagang hakbang ay upang magpasya kung nais mong isama ang isang umiiral na library ng pagsuporta sa aparato sa bahagi ng Arduino ng equation o isulat ang iyong sarili. Inirerekumenda na kung maaari kang makahanap ng isang umiiral na silid-aklatan, mas simple na gamitin ito kaysa sa pagsusulat ng iyong sarili mula sa simula.

Para sa suporta sa aparato ng DHT, ibinase ni Dr. Wheeler ang kanyang extension code sa DHTNew library. Napakatalino, pinaghiwalay ni Dr. Wheeler ang pag-andar ng DHTNew library sa buong panig ng Arduino at pymata4 ng equation upang magbigay ng kaunting pag-block sa panig ng Arduino.

Kung titingnan natin ang DHTNew, ginaganap nito ang lahat ng mga sumusunod:

• Itinatakda ang napiling pin digital output mode.
• Clocks isang naka-encode signal upang makuha ang pinakabagong halagang halumigmig at temperatura.
• Sinusuri para sa at naiulat ang anumang mga error.
• Kinakalkula ang nababasa ng tao na mga halaga ng temperatura at halumigmig mula sa hilaw na data na nakuha.

Upang mapanatili ang mga bagay hangga't maaari sa panig ng FirmataExpress, na-offload ni Dr. Wheeler ang mga gawain sa pag-convert ng data mula sa Arduino hanggang sa pymata4.

Hakbang 3: Pagbabago ng FirmataExpress para sa Suporta ng DHT

Ang Puno ng Direktoryo ng FirmataExpress

Nasa ibaba ang lahat ng mga file na binubuo ng lalagyan ng FirmataExpress. Ang puno na ito ay magkapareho sa StandardFiramata, ilan lamang sa mga filename ang sumasalamin sa pangalan ng imbakan.

Ang mga file na nangangailangan ng pagbabago ay ang mga mayroong isang asterisk (*) sa tabi nila.

FirmataExpress

├── * Mga Lupon.h

├── mga halimbawa

│ └── FirmataExpress

│ ├── boardx

│ ├── * FirmataExpress.ino

│ ├── LICENSE.txt

│ └── Makefile

├── * FirmataConstants.h

├── * FirmataDefines.h

├── FirmataExpress.cpp

├── FirmataExpress.h

├── FirmataMarshaller.cpp

├── FirmataMarshaller.h

├── FirmataParser.cpp

└── FirmataParser.h

Tingnan natin ang bawat isa sa mga file at mga pagbabagong nagawa.

Mga lupon.h

Naglalaman ang file na ito ng mga uri ng kahulugan ng macro na kahulugan para sa bawat isa sa mga sinusuportahang uri ng board. Tinutukoy nito ang maximum na bilang ng mga aparato na suportado kapag higit sa isang aparato ang kailangang suportahan.

Para sa aparatong DHT, hanggang sa 6 na mga aparato ay maaaring konektado nang sabay-sabay at ang halagang ito ay tinukoy bilang:

#ifndef MAX_DHTS

# tukuyin MAX_DHTS 6 #endif

Gayundin, ang mga macros na uri ng pin ay maaaring opsyonal na tukuyin para sa bagong aparato, alinman para sa lahat ng uri ng board o sa mga interesado ka lamang. Ang mga macros na ito ay ginagamit karamihan para sa mga layunin ng pag-uulat at hindi ginagamit para sa pagkontrol sa mga aparato. Ang mga macros na ito ay tumutukoy sa parehong mga pin na sumusuporta sa aparato:

#define IS_PIN_DHT (p) (IS_PIN_DIGITAL (p) && (p) - 2 <MAX_DHTS)

Pati na rin isang macro na tumutukoy sa isang conversion na pin-number.

# tukuyin ang PIN_TO_DHT (p) PIN_TO_DIGITAL (p)

FirmataConstants.h

Naglalaman ang file na ito ng numero ng bersyon ng firmware, na maaaring gusto mong baguhin upang subaybayan kung aling bersyon ang na-load mo sa iyong Arduino. Naglalaman din ito ng mga halaga ng mensahe ng Firmata, kabilang ang mga mensahe ng Firmata SysEx.

Kakailanganin mong magtalaga ng isang bagong mensahe o hanay ng mga mensahe para sa iyong aparato sa file na ito. Para sa DHT, dalawang mensahe ang naidagdag. Ang isa ay nag-configure ng isang pin bilang isang pin na "DHT", at ang iba pa, bilang isang mensahe ng reporter, kapag naipapadala ang pinakabagong data ng DHT sa kliyente.

static const int DHT_CONFIG = 0x64;

static const int DHT_DATA = 0x65;

Ang mga mode ng pin ay tinukoy din sa file na ito. Para sa DHT, isang bagong mode ng pin ang nilikha:

static const int PIN_MODE_DHT = 0x0F; // pin naka-configure para sa DHT

Kapag nagdaragdag ng isang bagong mode ng pin, dapat na ayusin ang TOTAL_PIN_MODES:

static const int TOTAL_PIN_MODES = 17;

FirmataDefines.h

Dapat na-update ang file na ito upang maipakita ang mga bagong mensahe na idinagdag sa FirmataConstants.h:

#ifdef DHT_CONFIG # undef DHT_CONFIG #endif #define DHT_CONFIG firmata:: DHT_CONFIG // DHT request #ifdef DHT_DATA #undef DHT_DATA #endif #define DHT_DATA firmata:: DHT_DATA // DHT reply #if_ef PINDMEefDDDefine PINDDEef PINDME_DOD_DOD:: PIN_MODE_DHT

FirmataExpress.ino

Sa talakayang ito, sasakupin namin ang "mataas na puntos" ng mga pagbabagong ginawa sa Arduino sketch na ito.

Upang masuportahan ng FirmataExpress ang hanggang sa anim na mga aparatong DHT nang sabay-sabay, 3 mga array ang nilikha upang subaybayan ang bawat isa sa mga kaugnay na numero ng pin, ang halaga ng WakeUpDelay, at ang uri ng aparato, iyon ay DHT22 o DHT11:

// Mga sensor ng DHT

int numActiveDHTs = 0; // bilang ng mga DHT na naka-attach uint8_t DHT_PinNumber [MAX_DHTS]; uint8_t DHT_WakeUpDelay [MAX_DHTS]; uint8_t DHT_TYPE [MAX_DHTS];

Dahil ang parehong uri ng aparato ay nangangailangan ng humigit-kumulang na 2 segundo sa pagitan ng pagbabasa, kailangan naming tiyakin na binabasa namin ang bawat DHT nang isang beses lamang sa 2-segundong time frame. Ang ilang mga aparato, tulad ng mga aparato ng DHT at mga sensor ng distansya ng HC-SR04, pana-panahong mai-access lamang. Pinapayagan ang mga ito ng oras upang makipag-ugnay sa kanilang mga kapaligiran.

uint8_t sa susunodDHT = 0; // index into dht para mabasa ang susunod na aparato

uint8_t kasalukuyangDHT = 0; // Sinusubaybayan kung aling sensor ang aktibo. int dhtNumLoops = 0; // Target na bilang ng beses sa pamamagitan ng loop b4 pag-access sa isang DHT int dhtLoopCounter = 0; // Loop counter

Pag-configure At Pagbasa ng Ang DHT Device

Kapag nakatanggap ang FirmataExpress ng isang utos ng SysEx upang mai-configure ang isang pin para sa pagpapatakbo ng DHT, napatunayan nito na ang maximum na bilang ng mga aparatong DHT ay hindi lumampas. Kung ang bagong DHT ay maaaring suportahan, ang mga array ng DHT ay nai-update. Kung ang uri ng DHT ay hindi kilala, isang mensahe ng string ng SysEx ang nilikha at nailipat pabalik sa pymata4

kaso DHT_CONFIG: int DHT_Pin = argv [0]; int DHT_type = argv [1]; kung (numActiveDHTs <MAX_DHTS) {kung (DHT_type == 22) {DHT_WakeUpDelay [numActiveDHTs] = 1; } iba pa kung (DHT_type == 11) {DHT_WakeUpDelay [numActiveDHTs] = 18; } iba pa {Firmata.sendString ("ERROR: UNKNOWN SENSOR TYPE, VALID SENSORS AY 11, 22"); pahinga; } // subukan ang sensor DHT_PinNumber [numActiveDHTs] = DHT_Pin; DHT_TYPE [numActiveDHTs] = DHT_type; setPinModeCallback (DHT_Pin, PIN_MODE_DHT);

Pagkatapos ay tinangka ng FirmataExpress na makipag-usap sa aparato ng DHT. Kung mayroong anumang mga error, bumubuo ito ng isang mensahe ng SysEx na may data ng error at ipinapadala ang mensahe ng SysEx pabalik sa pymat4. Hawak ng variable ng _bits ang data na ibinalik ng aparato ng DHT para sa karagdagang pagproseso ng pymata4 kung nais.

Firmata.write (START_SYSEX);

Firmata.write (DHT_DATA); Firmata.write (DHT_Pin); Firmata.write (DHT_type); para sa (uint8_t i = 0; i> 7 & 0x7f); } Firmata.write (abs (rv)); Firmata.write (1); Firmata.write (END_SYSEX);

Kung ibinalik ang wastong data, ang bilang ng mga aktibong DHT ay nadagdagan. Ang isang variable na sumusubaybay sa kung gaano karaming mga loop iterasyon ang dapat makumpleto bago suriin ang susunod na DHT para sa data ay nababagay din. Tinitiyak ng variable na ito na gaano man karami ang mga DHT na idinagdag sa system, mabasa silang lahat sa loob ng isang 2 segundo na panahon.

int rv = readDhtSensor (numActiveDHTs);

kung (rv == DHTLIB_OK) {numActiveDHTs ++; dhtNumLoops = dhtNumLoops / numActiveDHTs; // lahat okay}

Kung ang isa o higit pang mga aparatong DHT ay na-configure sa pag-andar ng loop ng sketch, nabasa ang susunod na aparato ng DHT. Alinman sa wastong data o katayuan ng error nito ay ibinalik sa pymata4 sa anyo ng isang mensahe na SysEx:

kung (dhtLoopCounter ++> dhtNumLoops) {kung (numActiveDHTs) {int rv = readDhtSensor (nextDHT); uint8_t kasalukuyang_pin = DHT_PinNumber [susunodDHT]; uint8_t kasalukuyang_type = DHT_TYPE [susunodDHT]; dhtLoopCounter = 0; kasalukuyangDHT = susunodDHT; kung (nextDHT ++> = numActiveDHTs - 1) {nextDHT = 0; } kung (rv == DHTLIB_OK) {// TEST CHECKSUM uint8_t sum = _bits [0] + _bits [1] + _bits [2] + _bits [3]; kung (_bits [4]! = sum) {rv = -1; }} // ipadala ang mensahe pabalik gamit ang isang katayuan ng error Firmata.write (START_SYSEX); Firmata.write (DHT_DATA); Firmata.write (kasalukuyang_pin); Firmata.write (kasalukuyang_type); para sa (uint8_t i = 0; i <sizeof (_bits) - 1; ++ i) {Firmata.write (_bits ); // Firmata.write (_bits ;} Firmata.write (abs (rv)); Firmata.write (0); Firmata.write (END_SYSEX);}}

Ang code na ginamit upang makipag-usap sa aparato ng DHT ay direktang nagmula sa DHTNew library:

int readDhtSensor (int index) {

// INIT BUFFERVAR UPANG TANGGAPIN ANG DATA uint8_t mask = 128; uint8_t idx = 0; // EMPTY BUFFER // memset (_bits, 0, sizeof (_bits)); para sa (uint8_t i = 0; i 5 BYTES para sa (uint8_t i = 40; i! = 0; i--) {loopCnt = DHTLIB_TIMEOUT; habang (digitalRead (pin) == LOW) {kung (--loopCnt == 0) ibalik ang DHTLIB_ERROR_TIMEOUT;} uint32_t t = micros (); loopCnt = DHTLIB_TIMEOUT; habang (digitalRead (pin) == TAAS) {kung (--loopCnt == 0) ibalik ang DHTLIB_ERROR_TIMEOUT;} kung ((micros () - t)> 40) {_bits [idx] | = mask;} mask >> = 1; kung (mask == 0) // susunod na byte? {Mask = 128; idx ++;}} ibalik ang DHTLIB_OK;}

Hakbang 4: Pagbabago ng Pymata4 para sa Suporta ng DHT

private_constants.h

Upang suportahan ang DHT, kailangan naming idagdag ang parehong mga bagong pin-type at SysEx na mensahe sa file na ito:

# pin mode INPUT = 0x00 # pin set as input OUTPUT = 0x01 # pin set as output ANALOG = 0x02 # analog pin sa analogInput mode PWM = 0x03 # digital pin sa PWM output mode SERVO = 0x04 # digital pin sa Servo output mode I2C = 0x06 # pin na kasama sa I2C setup STEPPER = 0x08 # anumang pin sa stepper mode SERIAL = 0x0a PULLUP = 0x0b # Anumang pin sa pullup mode na SONAR = 0x0c # Anumang pin sa SONAR mode TONE = 0x0d # Anumang pin sa tone mode na PIXY = 0x0e # nakalaan para sa mode ng pixy camera DHT = 0x0f # DHT sensor IGNORE = 0x7f # DHT SysEx command message DHT_CONFIG = 0x64 # dht config command DHT_DATA = 0x65 # dht sensor reply

Ang idinagdag na uri ng pin at mga utos ng SysEx ay dapat na tumutugma sa mga halaga sa FirmataConstants.h idinagdag sa FirmataExpress.

pymata4.py

Gumagamit ang Pymata4 ng isang diksyunaryo sa Python upang mabilis na maiugnay ang isang papasok na mensahe ng Firmata sa isang handler ng mensahe. Ang pangalan ng diksyunaryo na ito ay report_dispatch.

Ang format para sa isang entry sa diksyunaryo ay:

{MessageID: [message_handler, bilang ng mga byte ng data na ipoproseso]}

Ang isang entry ay idinagdag sa diksyunaryo upang mahawakan ang mga papasok na mensahe ng DHT:

{PrivateConstants. DHT_DATA: [self._dht_read_response, 7]}

Ang 7 bytes ng data sa mensahe ay ang Arduino digital pin number, ang uri ng DHT device (22 o 11), at ang 5 bytes ng raw data.

Sinusuri ng pamamaraang _dht_read_response para sa anumang naiulat na mga error. Kung walang naiulat na mga pagkakamali, ang halumigmig at temperatura ay kinakalkula gamit ang algorithm na nai-port mula sa Arduino DHTNew library.

Ang kinakalkula na mga halaga ay iniulat sa pamamagitan ng isang paraan ng callback na ibinibigay ng gumagamit. Ang mga ito ay naka-imbak din sa panloob na istraktura ng data ng pin_data. Ang huling iniulat na halagang maaaring maalala sa pamamagitan ng botohan pin_data gamit ang dht_read na pamamaraan.

Pag-configure ng Isang Bagong Device ng DHT

Kapag nagdaragdag ng isang bagong aparato ng DHT, tinawag ang pamamaraan na set_pin_mode_dht. Ina-update ng pamamaraang ito ang pin_data para sa mga digital na pin. Lumilikha din ito at nagpapadala ng isang mensahe na DHT_CONFIG SysEx sa FirmataExpress.

Hakbang 5: Pagbabalot

Tulad ng nakita natin, ang pagdaragdag ng suporta sa Firmata para sa isang bagong aparato ay nangangailangan sa iyo na baguhin ang Arduino FirmataExpress server code at ang Python-based pymata4 client code. Ang FirmataExpress code ay maaaring maging hamon sa pag-debug. Ang isang pamamaraan na tinawag na printData ay idinagdag sa FirmataExpress upang makatulong sa pag-debug. Pinapayagan ka ng pamamaraang ito na magpadala ng mga halaga ng data mula sa FirmataExpress at mai-print ang mga ito sa pymata4 console.

Ang pagpapaandar na ito ay nangangailangan ng parehong pointer sa isang character string at ang halagang nais mong tingnan. Kung ang halaga ng data ay nilalaman sa isang variable na tinatawag na argc, maaari kang tumawag sa printData na may mga sumusunod na parameter.

printData ((char *) "argc =", argc);

Kung mayroon kang anumang mga katanungan, mag-iwan lamang ng isang puna, at magiging masaya akong sagutin.

Maligayang pag-coding!