ESP32:Примеры/Создание задач для использования обоих ядер ESP32

Материал из Онлайн справочника
Перейти к навигации Перейти к поиску

Перевод: Максим Кузьмин (Cubewriter) Контакты:</br>* Skype: cubewriter</br>* E-mail: cubewriter@gmail.com</br>* Максим Кузьмин на freelance.ru
Проверка/Оформление/Редактирование: Мякишев Е.А.


Pixel Art Mini Meow Animated.gif Черновик


Создание задач для использования обоих ядер ESP32

Плата ESP32 оснащена двумя 32-битными микропроцессорами Xtensa LX6 – ядром 0 и ядром 1. То есть, это 2-ядерная плата. По умолчанию код IDE Arduino запускается на ядре 1. В этом руководстве мы расскажем, как запустить код на втором ядре ESP32 при помощи создания заданий. Благодаря этому вы сможете запускать код одновременно на обоих ядрах, что сделает ESP32 многозадачной.

Примечание: Для того, чтобы добиться многозадачности, необязательно запускать оба ядра.

Необходимые компоненты

Введение

Плата ESP32 оснащена двумя 32-битными микропроцессорами Xtensa LX6. То есть это 2-ядерная плата:

  • Ядро 0;
  • Ядро 1;
Espressif ESP32 Chip Function Block Diagram.svg.png

По умолчанию код IDE Arduino запускается на ядре 1. В этом руководстве мы расскажем, как использовать второе ядро ESP32 при помощи создания задач. В результате вы сможете запускать код на обоих ядрах одновременно, тем самым сделав ESP32 многозадачной (впрочем, ESP32 можно сделать многозадачной и по-другому – не запуская оба ядра ESP32).

Когда мы загружаем код на ESP32 через IDE Arduino, он просто запускается и все – нам не нужно беспокоиться о том, на каком ядре выполняется этот код.

Но есть функция, с помощью которой можно узнать, на каком именно ядре запущен код:

xPortGetCoreID()

Воспользовавшись этой функцией в скетче IDE Arduino, вы увидите, что оба главных блока скетча – setup() и loop() – выполняются на ядре 1. Можете проверить это, загрузив на ESP32 код ниже.

 1 /*********
 2   Руи Сантос
 3   Более подробно о проекте на: http://randomnerdtutorials.com  
 4 *********/
 5 
 6 void setup() {
 7   Serial.begin(115200);
 8   Serial.print("setup() running on core ");
 9            //  "Блок setup() выполняется на ядре "
10   Serial.println(xPortGetCoreID());
11 }
12 
13 void loop() {
14   Serial.print("loop() running on core ");
15            //  "Блок loop() выполняется на ядре "
16   Serial.println(xPortGetCoreID());
17 }
Esp32 serial monitor xportgetcoreid loop setup 1.PNG

Создаем задачи

IDE Arduino поддерживает использование для ESP32 операционной системы FreeRTOS. Она позволяет паралельно выполнять на микропроцессорах платы несколько независимых друг от друга задач.

Задачи – это фрагменты кода, выполняющие что-либо. К примеру, это может быть мигание светодиодом, выполнение сетевого запроса, считывание данных от датчика, публикация данных от датчика и т.д.

И мы можем создавать задачи, привязывая определенные фрагменты кода к определенным ядрам. Создавая задачу, вы можете выбрать, на каком ядре его нужно запустить и с каким приоритетом. Самый слабый приоритет – это «0». Процессор в первую очередь выполняет задачи со высоким приоритетом.

Итак, чтобы создать задачу, нужно сделать следующее:

  • Создаем идентификатор задачи. Например, «Task1»:
TaskHandle_t Task1;
  • В блоке setup() при помощи функции xTaskCreatePinnedToCore() создаем задачу и привязываем ее к ядру 0 (последний параметр). Кроме того, в параметрах этой функции задаются код самой задачи, приоритет и т.д. Выглядит она вот так:
1 xTaskCreatePinnedToCore(
2  Task1code, /* Функция, содержащая код задачи */
3  "Task1", /* Название задачи */
4  10000, /* Размер стека в словах */
5  NULL, /* Параметр создаваемой задачи */
6  0, /* Приоритет задачи */
7  &Task1, /* Идентификатор задачи */
8  0); /* Ядро, на котором будет выполняться задача */
  • После создания задачи нам нужно создать функцию, содержащую код для созданной задачи. В нашем случае нужно создать функцию Task1code(). Выглядит она вот так:
1 Void Task1code( void * parameter) {
2   for(;;){
3     Код для задачи «Task1»  бесконечный цикл
4     (...)
5   }
6 }

Оператор for(;;) создает бесконечный цикл. Следовательно, эта функция будет работать так же, как и loop(). Она может пригодиться, например, если вам в коде нужен второй цикл loop().

Если вы во время выполнения кода хотите удалить созданную задачу, это можно сделать при помощи функции vTaskDelete(), указав в ее параметре идентификатор задачи (Task1):

vTaskDelete(Task1);

Теперь давайте посмотрим, как все это работает на практике.

Создание задач для разных ядер – пример

Чтобы продемонстрировать создание разных задач для разных ядер, давайте создадим две задачи для мигания двумя светодиодами с разной задержкой. Подключите два светодиода к ESP32 согласно схеме ниже:

Esp32 two leds task code 1.PNG
Pixel Art Mini Meow Animated.gif На этой схеме изображена 36-контактная версия платы ESP32 DEVKIT DOIT V1. Если у вас какая-то другая модель, обязательно сверьтесь с ее распиновкой.


Мы создадим две задачи, каждая из которых будет выполняться на собственном ядре.

  • Задача Task1 – на ядре 0
  • Задача Task2 – на ядре 1
Xtensa LX6 microprocessor.png

Загрузите скетч ниже на ESP32.

 1 /*********
 2   Руи Сантос
 3   Более подробно о проекте на: http://randomnerdtutorials.com  
 4 *********/
 5 
 6 TaskHandle_t Task1;
 7 TaskHandle_t Task2;
 8 
 9 // Контакты для светодиодов:
10 const int led1 = 2;
11 const int led2 = 4;
12 
13 void setup() {
14   Serial.begin(115200); 
15   pinMode(led1, OUTPUT);
16   pinMode(led2, OUTPUT);
17 
18   // Создаем задачу с кодом из функции Task1code(),
19   // с приоритетом 1 и выполняемую на ядре 0:
20   xTaskCreatePinnedToCore(
21                     Task1code,   /* Функция задачи */
22                     "Task1",     /* Название задачи */
23                     10000,       /* Размер стека задачи */
24                     NULL,        /* Параметр задачи */
25                     1,           /* Приоритет задачи */
26                     &Task1,      /* Идентификатор задачи,
27                                     чтобы ее можно было отслеживать */
28                     0);          /* Ядро для выполнения задачи (0) */                  
29   delay(500); 
30 
31   // Создаем задачу с кодом из функции Task2code(),
32   // с приоритетом 1 и выполняемую на ядре 1:
33   xTaskCreatePinnedToCore(
34                     Task2code,   /* Функция задачи */
35                     "Task2",     /* Название задачи */
36                     10000,       /* Размер стека задачи */
37                     NULL,        /* Параметр задачи */
38                     1,           /* Приоритет задачи */
39                     &Task2,      /* Идентификатор задачи,
40                                     чтобы ее можно было отслеживать */
41                     1);          /* Ядро для выполнения задачи (1) */
42     delay(500); 
43 }
44 
45 // Функция Task1code: мигает светодиодом каждые 1000 мс:
46 void Task1code( void * pvParameters ){
47   Serial.print("Task1 running on core ");
48            //  "Задача Task1 выполняется на ядре "
49   Serial.println(xPortGetCoreID());
50 
51   for(;;){
52     digitalWrite(led1, HIGH);
53     delay(1000);
54     digitalWrite(led1, LOW);
55     delay(1000);
56   } 
57 }
58 
59 // Функция Task2code: мигает светодиодом каждые 700 мс:
60 void Task2code( void * pvParameters ){
61   Serial.print("Task2 running on core ");
62            //  "Задача Task2 выполняется на ядре "
63   Serial.println(xPortGetCoreID());
64 
65   for(;;){
66     digitalWrite(led2, HIGH);
67     delay(700);
68     digitalWrite(led2, LOW);
69     delay(700);
70   }
71 }
72 
73 void loop() {
74   
75 }

Как работает этот код

Примечание: В этом коде создается две задачи. Выполнение одной из них привязывается к ядру 0, а другое – к ядру 1. По умолчанию Arduino-скетчи выполняются на ядре 1, поэтому код для задачи Task2 можно просто написать в блок loop(), не создавая для него отдельной задачи. Но в нашем случае мы создадим обе задачи – в обучающих целях. Впрочем, такой подход – организация кода по задачам – порой более практичен, но это зависит от особенностей проекта.

Код ниже начинается с создания идентификаторов для обеих задач – Task1 и Task2.

1 TaskHandle_t Task1;
2 TaskHandle_t Task2;

Задаем контакты GPIO2 и GPIO4 как контакты для подключения светодиодов.

1 const int led1 = 2;
2 const int led2 = 4;

В блоке setup() инициализируем монитор порта на скорости 115200 бод.

Serial.begin(115200);

Переключаем контакты светодиодов в режим «OUTPUT» (т.е. в режим вывода данных).

1 pinMode(led1, OUTPUT);
2 pinMode(led2, OUTPUT);

Затем создаем задачу Task1 при помощи функции xTaskCreatePinnedToCore().

1 xTaskCreatePinnedToCore(
2                     Task1code,   /* Функция задачи */
3                     "Task1",     /* Название задачи */
4                     10000,       /* Размер стека задачи */
5                     NULL,        /* Параметр задачи */
6                     1,           /* Приоритет задачи */
7                     &Task1,      /* Идентификатор задачи,
8                                     чтобы ее можно было отслеживать */
9                     0);          /* Ядро для выполнения задачи (0) */

Эта задача будет выполнять код из функции Task1code(). Значит далее в коде нам нужно будет создать эту функцию. Мы даем ей приоритет 1 и привязываем к ядру 0.

Далее аналогичным образом создаем задачу Task2.

1 xTaskCreatePinnedToCore(
2                     Task2code,   /* Функция задачи */
3                     "Task2",     /* Название задачи */
4                     10000,       /* Размер стека задачи */
5                     NULL,        /* Параметр задачи */
6                     1,           /* Приоритет задачи */
7                     &Task2,      /* Идентификатор задачи,
8                                     чтобы ее можно было отслеживать */
9                     1);          /* Ядро для выполнения задачи (1) */

Создав задачи, создаем функции с кодом для этих задач.

 1 // Функция Task1code: мигает светодиодом каждые 1000 мс:
 2 void Task1code( void * pvParameters ){
 3   Serial.print("Task1 running on core ");
 4            //  "Задача Task1 выполняется на ядре "
 5   Serial.println(xPortGetCoreID());
 6 
 7   for(;;){
 8     digitalWrite(led1, HIGH);
 9     delay(1000);
10     digitalWrite(led1, LOW);
11     delay(1000);
12   } 
13 }

Функция в задаче Task1 называется Task1code(), но вы можете назвать ее как заблагорассудится. В целях отладки сначала она напечатает в мониторе порта ядро, на котором выполняется задача:

1 Serial.print("Task1 running on core ");
2          //  "Задача Task1 выполняется на ядре "
3 Serial.println(xPortGetCoreID());

Затем создаем бесконечный цикл, который работает аналогично loop() в скетче IDE Arduino. В этом цикле мигаем светодиодом «LED1» каждую секунду.

То же самое происходит и в функции для задачи Task2, но время мигания светодиода – другое.

 1 // Функция Task2code: мигает светодиодом каждые 700 мс:
 2 void Task2code( void * pvParameters ){
 3   Serial.print("Task2 running on core ");
 4            //  "Задача Task2 выполняется на ядре "
 5   Serial.println(xPortGetCoreID());
 6 
 7   for(;;){
 8     digitalWrite(led2, HIGH);
 9     delay(700);
10     digitalWrite(led2, LOW);
11     delay(700);
12   }
13 }

Наконец, в блоке loop() не пишем ничего.

1 void loop() { 
2 
3 }

Примечание: Ранее уже говорилось, но напомним – код в блоке loop() выполняется на ядре 1. Поэтому вместо создания задачи для выполнения на ядре 1 вы можете просто вписать этот код в блок loop().

Демонстрация

Загрузите этот код на ESP32, но перед этим убедитесь, что выбрали в IDE Arduino правильные плату и COM-порт.

Откройте монитор порта на скорости 115200 бод. Там должна появиться примерно такая информация:

Esp32 two leds task code serial monitor 1.PNG

Как и ожидалось, задача Task1 выполняется на ядре 0, а Task2 – на ядре 1.

В результате один из светодиодов, подключенных к ESP32, должен мигать раз в секунду, а другой – с периодичностью в 700 мс.

Итого

Итак, в этой статье мы узнали следующее:

  • Плата ESP32 имеет два ядра;
  • Скетчи IDE Arduino по умолчанию запускаются на ядре 1;
  • Чтобы использовать ядро 0, необходимо создать задачи;
  • Привязка задач к ядрам осуществляется с помощью функции xTaskCreatePinnedToCore();
  • С помощью этой функции можно запустить две разные задачи на двух разных ядрах одновременно и независимо друг от друга;

В этом руководстве мы продемонстрировали создание задач на скетче-примере с двумя светодиодами. Но вы можете использовать этот метод и для более продвинутых проектов. К примеру, одно ядро можно использовать для чтения данных с датчиков, а другое – для публикации этих данных в веб-сервер, подключенный к системе домашней автоматизации.

См.также

Внешние ссылки