Esp32 dual core programming na may arduino id

Ang mga module ng ESP ay popular para sa kanilang mga pag-andar sa Wi-Fi tulad ng ESP8266, ESP-12E, atbp. Ang lahat ng ito ay malakas na mga module ng Microcontroller na may mga pag-andar ng Wi-Fi. Mayroong isa pang module ng ESP na mas malakas at maraming nalalaman kaysa sa mga nakaraang module ng ESP- ang pangalan nito ay ESP32. Mayroon itong pagkakakonekta sa Bluetooth at Wi-Fi at ipinaliwanag na namin ang mga kakayahan ng BLE ng ESP32 at ginamit ang ESP32 sa maraming mga proyekto ng IoT. Ngunit napakakaunting mga tao ang nakakaalam na ang ESP32 ay isang Dual-core microcontroller.

Ang ESP32 ay mayroong dalawang 32-bit na Tensilica Xtensa LX6 microprocessors na ginagawang isang malakas na dual-core (core0 at core1) microcontroller. Magagamit ito sa dalawang variant na solong-core at dual-core. Ngunit ang variant ng dual-core ay mas popular dahil walang makabuluhang pagkakaiba sa presyo.

Maaaring maprograma ang ESP32 gamit ang Arduino IDE, Espressif IDF, Lua RTOS, atbp Habang ang pagprogram sa Arduino IDE, ang code ay tumatakbo lamang sa Core1 dahil na-program na ang Core0 para sa komunikasyon ng RF. Ngunit narito ang tutorial na ito na ipapakita namin kung paano gamitin ang parehong mga core ng ESP32 upang maisagawa ang dalawang operasyon nang sabay-sabay. Dito ang unang gawain ay upang i-blink ang onboard LED at ang pangalawang gawain ay upang makuha ang data ng temperatura mula sa sensor ng DHT11.

Una nating makita ang mga pakinabang ng isang multi-core na processor sa isang solong core.

Mga kalamangan ng Multi-core na processor

1. Ang mga processor na multi-core ay kapaki-pakinabang kapag mayroong higit sa 2 proseso upang gumana nang sabay-sabay.
2. Tulad ng pamamahagi ng trabaho sa iba't ibang mga core, ang bilis nito ay nagdaragdag at maraming proseso ang maaaring matapos sa parehong oras.
3. Ang pagkonsumo ng kuryente ay maaaring mabawasan sapagkat kapag ang anumang core ay nasa idle mode kaysa sa maaari itong magamit upang isara ang mga peripheral na hindi ginagamit sa oras na iyon.
4. Ang mga dual-core na processor ay kailangang lumipat sa pagitan ng iba't ibang mga thread na mas madalas kaysa sa mga solong-core na processor dahil maaari nilang hawakan ang dalawa nang sabay-sabay sa halip na isa-isa.

ESP32 at FreeRTOS

Ang board ng ESP32 ay mayroon nang naka-install na firmware na FreeRTOS. Ang FreeRTOS ay isang open-source na Real-time na operating system na napaka kapaki-pakinabang sa multitasking. Tumutulong ang RTOS sa pamamahala ng mga mapagkukunan at pag-maximize ng pagganap ng system. Ang FreeRTOS ay may maraming mga pagpapaandar sa API para sa iba't ibang mga layunin at paggamit ng mga API na ito, makakalikha kami ng mga gawain at mapatakbo sila sa iba't ibang mga core.

Ang kumpletong dokumentasyon ng mga FreeRTOS API ay matatagpuan dito. Susubukan naming gumamit ng ilang mga API sa aming code upang bumuo ng isang application na multitasking na tatakbo sa parehong mga core.

Paghahanap ng pangunahing ID ng ESP32

Dito ay gagamitin namin ang Arduino IDE upang mai-upload ang code sa ESP32. Upang malaman ang Core ID kung saan tumatakbo ang code, mayroong isang pagpapaandar ng API

xPortGetCoreID ()

Ang pagpapaandar na ito ay maaaring tawagan mula sa walang bisa na pag-setup () at pag- andar ng void loop () upang malaman ang pangunahing ID kung saan tumatakbo ang mga pagpapaandar na ito.

Maaari mong subukan ang API na ito sa pamamagitan ng pag-upload ng sketch sa ibaba:

void setup () { Serial.begin (115200); Serial.print ("setup () function na tumatakbo sa core:"); Serial.println (xPortGetCoreID ()); } void loop () { Serial.print ("loop () function na tumatakbo sa core:"); Serial.println (xPortGetCoreID ()); }

Matapos i-upload ang sketch sa itaas, buksan ang Serial monitor at makikita mo na ang parehong mga function ay tumatakbo sa core1 tulad ng ipinakita sa ibaba.

Mula sa mga naobserbahang nasa itaas, maipapalagay na ang default na Arduino sketch ay laging tumatakbo sa core1.

ESP32 Dual Core Programming

Sinusuportahan ng Arduino IDE ang FreeRTOS para sa ESP32 at FreeRTOS API ay pinapayagan kaming lumikha ng mga gawain na maaaring tumakbo nang nakapag-iisa sa parehong mga core. Ang gawain ay ang piraso ng code na gumaganap ng ilang operasyon sa board tulad ng blinking led, pagpapadala ng temperatura, atbp.

Ang pagpapaandar sa ibaba ay ginagamit upang lumikha ng mga gawain na maaaring tumakbo sa parehong mga core. Sa pagpapaandar na ito, kailangan naming magbigay ng ilang mga argumento tulad ng isang priyoridad, core id, atbp.

Ngayon, sundin ang mga hakbang sa ibaba upang lumikha ng pagpapaandar ng gawain at gawain.

1. Una, lumikha ng mga gawain sa walang bisa na pag- andar ng pag- setup . Dito lilikha kami ng dalawang gawain, isa para sa pagpikit ng LED pagkatapos ng bawat 0.5 segundo at isa pang gawain ay upang makakuha ng pagbabasa ng temperatura pagkatapos ng bawat 2 segundo.

xTaskCreatePinnedToCore () na pag-andar ay tumatagal ng 7 mga argumento:

1. Pangalan ng pagpapaandar upang maipatupad ang gawain (gawain1)
2. Anumang pangalan na ibinigay sa gawain ("task1", ​​atbp)
3. Laki ng stack na inilaan sa gawain sa mga salita (1 salita = 2bytes)
4. Parameter ng pag-input ng gawain (maaaring NUL)
5. Priority ng gawain (0 ay ang pinakamababang priyoridad)
6. Gawain ang gawain (maaaring NUL)
7. Core id kung saan tatakbo ang gawain (0 o 1)

Ngayon, lumikha ng Task1 para sa blinking na humantong sa pamamagitan ng pagbibigay ng lahat ng mga argumento sa xTaskCreatePinnedToCore () na function.

xTaskCreatePinnedToCore (Task1code, "Task1", ​​10000, NULL, 1, NULL, 0);

Katulad nito, lumikha ng Task2 para sa Task2 at gawin ang pangunahing id 1 sa ^ika- 7 na pagtatalo.

xTaskCreatePinnedToCore (Task2code, "Task2", 10000, NULL, 1, NULL, 1);

Maaari mong baguhin ang priyoridad at laki ng stack depende sa pagiging kumplikado ng gawain.

2. Ngayon, ipapatupad namin ang pagpapaandar ng Task1code at Task2code . Ang mga pagpapaandar na ito ay naglalaman ng code para sa kinakailangang gawain. Sa aming kaso, ang unang gawain ay magpapikit ang pinangunahan at ang isa pang gawain ay kukuha ng temperatura. Kaya gumawa ng dalawang magkakahiwalay na pag-andar para sa bawat gawain sa labas ng void setup function.

Ang pagpapaandar ng Task1code para sa pagpikit sa on-board na humantong pagkatapos ng 0.5 segundo ay ipinatupad tulad ng ipinakita sa ibaba.

I-void ang Task1code (walang bisa * parameter) { Serial.print ("Tumatakbo ang Task1 sa core"); Serial.println (xPortGetCoreID ()); para sa (;;) {// infinite loop digitalWrite (led, HIGH); pagkaantala (500); digitalWrite (humantong, LOW); antala (500); } }

Katulad nito, ipatupad ang function ng Task2code para sa pagkuha ng temperatura.

walang bisa ang Task2code (walang bisa * pvParameter) { Serial.print ("Tumatakbo ang Task2 sa core"); Serial.println (xPortGetCoreID ()); para sa (;;) { float t = dht.readTemperature (); Serial.print ("Temperatura:"); Serial.print (t); pagkaantala (2000); } }

3. Narito ang void loop function ay mananatiling walang laman. Tulad ng alam na natin na ang loop at pag- andar ng pag- setup ay tumatakbo sa core1 sa gayon maaari mong ipatupad ang gawain ng core1 sa void loop function din.

Ngayon ang bahagi ng pag-cod ay tapos na, kaya i-upload lamang ang code gamit ang Arduino IDE sa pamamagitan ng pagpili ng board na ESP32 sa menu ng Mga Tool. Tiyaking nakakonekta mo ang sensor ng DHT11 upang i-pin ang D13 ng ESP32.

Ngayon ang mga resulta ay maaaring subaybayan sa Serial Monitor o Arduino IDE tulad ng ipinakita sa ibaba:

Ang mga kumplikadong aplikasyon tulad ng real-time system ay maaaring mabuo sa pamamagitan ng pagpapatakbo ng maraming mga gawain nang sabay-sabay gamit ang dalawahang mga core ng ESP32.

Ang kumpletong code kasama ang isang Demo na video ay ibinibigay sa ibaba.