ESP32. Управление кнопками в FreeRTOS

04 Мар 2021 2 комментария

Год назад я писал статью про управление кнопками в Arduino. С тех пор родилась библиотека SButton с кучей наворотов, которая активно используется мной в различных проектах. В последнее время я использую в проектах контроллер ESP32 компании Espressif Systems и много времени уделяю программирование под FreeRTOS, хорошо раскрывающей возможности этого двухъядерного контроллера.

Итак, задача реализовать работу кнопки параллельно выполнению других задач. Данные примеры публикую как памятку себе )

Итак, приступим…

Пример работающий на всех Arduino

Этот пример взят из предыдущей статьи и будет работать на любом микроконтроллере, который поддерживает Arduino IDE. Нужно только установить требуемый GPIO, к которому подключена кнопка.

// Порт GPIO к которому подключена кнопка
#define PIN_BUTTON 27
// Минимальный таймаут между событиями нажатия кнопки
#define TM_BUTTON 100

uint32_t ms_btn = 0;
bool state_btn  = true;

void setup() {
   Serial.begin(115200);
   Serial.println("Arduino button example");
// Определям режим работы GPIO с кнопкой   
   pinMode(PIN_BUTTON,INPUT_PULLUP);
}

void loop(void) {
   uint32_t ms = millis();
// Условие, которое выполняется не чаще одного раза в TM_BUTTON ms
   if( ms_btn == 0 || ms - ms_btn > TM_BUTTON ){
      ms_btn = ms;
      bool st = digitalRead(PIN_BUTTON);
// Изменилось состояник кнопки      
      if( st != state_btn ){
          state_btn = st;
          if( st == LOW ){
               Serial.println("Button pressed");
          }
          else {
               Serial.println("Button released");            
          }
      }
   }   
}

// Порт GPIO к которому подключена кнопка

#define PIN_BUTTON 27

// Минимальный таймаут между событиями нажатия кнопки

#define TM_BUTTON 100

uint32_t ms_btn = 0;

bool state_btn = true;

void setup() {

Serial.begin(115200);

Serial.println("Arduino button example");

// Определям режим работы GPIO с кнопкой

pinMode(PIN_BUTTON,INPUT_PULLUP);

}

void loop(void) {

uint32_t ms = millis();

// Условие, которое выполняется не чаще одного раза в TM_BUTTON ms

if( ms_btn == 0 || ms - ms_btn > TM_BUTTON ){

ms_btn = ms;

bool st = digitalRead(PIN_BUTTON);

// Изменилось состояник кнопки

if( st != state_btn ){

state_btn = st;

if( st == LOW ){

Serial.println("Button pressed");

}

else {

Serial.println("Button released");

}

Здесь отлавливаются события как на нажатие, так и на отпускание кнопки. Если померить время между этими событиями, то можно организовать обработку короткого нажатия кнопки и ее длинного удержания.

К недостаткам данного метода следует отнести то, что если в цикле loop() будут выполнятся еще какие то действия, занимающие, то мы вполне можем пропустить нажатие кнопки.

Пример 1. Цикл с кнопкой в параллельной задаче

В Arduino IDE Core ESP32 по умолчанию загружается FreeRTOS, где параллельными задачами запускается работа с WiFi на первом ядре и главный пользовательский цикл loop() и другие пользовательские задачи. При использовании WiFi лучше не трогать первое ядро, чтобы не получить «глючный ESP8266», когда всегда можно нарваться на «злобный WDT», если твоя задача будет что-то делать «не вовремя» или «слишком долго».

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

// Порт GPIO к которому подключена кнопка
#define PIN_BUTTON 27
// Минимальный таймаут между событиями нажатия кнопки
#define TM_BUTTON 100

void taskButton1( void *pvParameters );
bool state_btn  = true;

void setup() {
   Serial.begin(115200);
   Serial.println("ESP32 Button Example 1");
// Запускаем параллельную задачу обработки кнопок   
   xTaskCreateUniversal(taskButton1, "button", 2048, NULL, 5, NULL,1);   
}

void loop(void) {
// Здесь выполняем что-то свое  
}

void taskButton1( void *pvParameters ){
// Определяем режим работы GPIO с кнопкой   
   pinMode(PIN_BUTTON,INPUT_PULLUP);
   while( true ){
      bool st = digitalRead(PIN_BUTTON);
// Проверка изменения состояния кнопки      
      if( st != state_btn ){
          state_btn = st;
          if( st == LOW ){
               Serial.println("Button pressed");
          }
          else {
               Serial.println("Button released");            
          }
      }
// Задержка, во время которой выполняются задачи с меньшим приоритетом      
      vTaskDelay(TM_BUTTON);    
   }  
}

// Порт GPIO к которому подключена кнопка

#define PIN_BUTTON 27

// Минимальный таймаут между событиями нажатия кнопки

#define TM_BUTTON 100

void taskButton1( void *pvParameters );

bool state_btn = true;

void setup() {

Serial.begin(115200);

Serial.println("ESP32 Button Example 1");

// Запускаем параллельную задачу обработки кнопок

xTaskCreateUniversal(taskButton1, "button", 2048, NULL, 5, NULL,1);

}

void loop(void) {

// Здесь выполняем что-то свое

}

void taskButton1( void *pvParameters ){

// Определяем режим работы GPIO с кнопкой

pinMode(PIN_BUTTON,INPUT_PULLUP);

while( true ){

bool st = digitalRead(PIN_BUTTON);

// Проверка изменения состояния кнопки

if( st != state_btn ){

state_btn = st;

if( st == LOW ){

Serial.println("Button pressed");

}

else {

Serial.println("Button released");

}

// Задержка, во время которой выполняются задачи с меньшим приоритетом

vTaskDelay(TM_BUTTON);

}

При работе с параллельными процессами FreeRTOS следует обратить на следующие особенности:

Приоритет задачи обработки кнопки должен быть выше задач, во время которых может быть востребовано нажатие кнопки. В моем примере главный цикл loop() выполняется в задаче loopTask с приоритетом 1, а задача обработки кнопки имеет приоритет 5.

Если в обработке кнопки будет какой то сложный алгоритм, то нужно следить за размером стека, выделяемым при старте задачи. Ошибка переполнения стека будет выглядеть следующим образом

Guru Meditation Error: Core  1 panic'ed (Unhandled debug exception)
Debug exception reason: Stack canary watchpoint triggered (button) 
Core 1 register dump:
PC      : 0x4008a5ea  PS      : 0x00050036  A0      : 0x4008a4f3  A1      : 0x3ffb8320  
A2      : 0x3ffb8450  A3      : 0x00000000  A4      : 0x00000001  A5      : 0x4008a474  
A6      : 0x00000001  A7      : 0x00000085  A8      : 0x80081baa  A9      : 0x3ffbe7a0  
A10     : 0x3ffbe7d8  A11     : 0x00000001  A12     : 0x00000001  A13     : 0x00000001  
A14     : 0x00060021  A15     : 0x00000000  SAR     : 0x00000012  EXCCAUSE: 0x00000001  
EXCVADDR: 0x00000000  LBEG    : 0x00000000  LEND    : 0x00000000  LCOUNT  : 0x00000000  

Backtrace: 0x4008a5ea:0x3ffb8320 0x4008a4f0:0x3ffb8330

Rebooting...

Guru Meditation Error: Core 1 panic'ed (Unhandled debug exception)

Debug exception reason: Stack canary watchpoint triggered (button)

Core 1 register dump:

PC : 0x4008a5ea PS : 0x00050036 A0 : 0x4008a4f3 A1 : 0x3ffb8320

A2 : 0x3ffb8450 A3 : 0x00000000 A4 : 0x00000001 A5 : 0x4008a474

A6 : 0x00000001 A7 : 0x00000085 A8 : 0x80081baa A9 : 0x3ffbe7a0

A10 : 0x3ffbe7d8 A11 : 0x00000001 A12 : 0x00000001 A13 : 0x00000001

A14 : 0x00060021 A15 : 0x00000000 SAR : 0x00000012 EXCCAUSE: 0x00000001

EXCVADDR: 0x00000000 LBEG : 0x00000000 LEND : 0x00000000 LCOUNT : 0x00000000

Backtrace: 0x4008a5ea:0x3ffb8320 0x4008a4f0:0x3ffb8330

Rebooting...

При таком алгоритме цикл обработки кнопки постоянно крутится с задержкой 100 мсек, оставляя ровно столько времени другим задачам с более низким приоритетом. Непростительное расточение ресурсов микроконтроллера, поэтому следующий пример делаю на прерывании

Пример 2. Использование внешнего прерывания

Полностью запихать работу с кнопкой в обработчик прерывания мне не удалось. Дребезг, вызываемый при опускании кнопки, стабильно давал ложное срабатывания. Кроме того, внутри обработчика прерывания действует ряд ограничений, например, не работает delay() и не увеличивается значение millis(). Поэтому обработчик прерываний я использовал только для управления семафором, который «держит» задачу работы с кнопкой в ожидании.

// Порт GPIO к которому подключена кнопка
#define PIN_BUTTON 27
// Минимальный таймаут между событиями нажатия кнопки
#define TM_BUTTON 100

uint32_t ms_btn = 0;
bool state_btn  = true;
void taskButton1( void *pvParameters );
SemaphoreHandle_t btn1Semaphore;

void setup() {
   Serial.begin(115200);
   Serial.println("ESP32 button. Example 2");
// Запускается задача работы с кнопкой   
   xTaskCreateUniversal(taskButton1, "btn1", 4096, NULL, 5, NULL,1);   
}

void loop(void) {
// Здесь выполняем что-то свое  
}

void IRAM_ATTR ISR_btn1(){
// Прерывание по кнопке, отпускаем семафор  
   xSemaphoreGiveFromISR( btn1Semaphore, NULL );
}

void taskButton1( void *pvParameters ){
// Определяем режим работы GPIO с кнопкой   
   pinMode(PIN_BUTTON,INPUT_PULLUP);
// Создаем семафор     
   btn1Semaphore = xSemaphoreCreateBinary();
// Сразу "берем" семафор чтобы не было первого ложного срабатывания кнопки   
   xSemaphoreTake( btn1Semaphore, 100 );
   while(true){
// Запускаем обработчик прерывания (кнопка замыкает GPIO на землю)
      attachInterrupt(PIN_BUTTON, ISR_btn1, CHANGE);   
// Ждем "отпускание" семафора
      xSemaphoreTake( btn1Semaphore, portMAX_DELAY );
// Отключаем прерывание для устранения повторного срабатывания прерывания во время обработки
      detachInterrupt(PIN_BUTTON);
      bool st = digitalRead(PIN_BUTTON);
      uint32_t ms = millis();
// Проверка изменения состояния кнопки или превышение таймаута      
      if( st != state_btn || ms - ms_btn > TM_BUTTON){
          state_btn = st;
          ms_btn    = ms;
          if( st == LOW ){
               Serial.println("Button pressed");
          }
// Задержка для устранения дребезга контактов
          vTaskDelay(TM_BUTTON);
      }
   }
}

// Порт GPIO к которому подключена кнопка

#define PIN_BUTTON 27

// Минимальный таймаут между событиями нажатия кнопки

#define TM_BUTTON 100

uint32_t ms_btn = 0;

bool state_btn = true;

void taskButton1( void *pvParameters );

SemaphoreHandle_t btn1Semaphore;

void setup() {

Serial.begin(115200);

Serial.println("ESP32 button. Example 2");

// Запускается задача работы с кнопкой

xTaskCreateUniversal(taskButton1, "btn1", 4096, NULL, 5, NULL,1);

}

void loop(void) {

// Здесь выполняем что-то свое

}

void IRAM_ATTR ISR_btn1(){

// Прерывание по кнопке, отпускаем семафор

xSemaphoreGiveFromISR( btn1Semaphore, NULL );

}

void taskButton1( void *pvParameters ){

// Определяем режим работы GPIO с кнопкой

pinMode(PIN_BUTTON,INPUT_PULLUP);

// Создаем семафор

btn1Semaphore = xSemaphoreCreateBinary();

// Сразу "берем" семафор чтобы не было первого ложного срабатывания кнопки

xSemaphoreTake( btn1Semaphore, 100 );

while(true){

// Запускаем обработчик прерывания (кнопка замыкает GPIO на землю)

attachInterrupt(PIN_BUTTON, ISR_btn1, CHANGE);

// Ждем "отпускание" семафора

xSemaphoreTake( btn1Semaphore, portMAX_DELAY );

// Отключаем прерывание для устранения повторного срабатывания прерывания во время обработки

detachInterrupt(PIN_BUTTON);

bool st = digitalRead(PIN_BUTTON);

uint32_t ms = millis();

// Проверка изменения состояния кнопки или превышение таймаута

if( st != state_btn || ms - ms_btn > TM_BUTTON){

state_btn = st;

ms_btn = ms;

if( st == LOW ){

Serial.println("Button pressed");

}

// Задержка для устранения дребезга контактов

vTaskDelay(TM_BUTTON);

}

В данном примере задача обработки кнопки ожидает освобождения семафора и не занимает ресурсов контроллера большую часть времени. При получении внешнего прерывания по кнопке задача выполняет какое-то действие. Для устранения ложного срабатывания статус кнопки должен дважды смениться на противоположный с соответствующей задержкой. Если отпускание кнопки не успевает сработать, то возврат в состояние готовности следующего нажатие производится по таймауту.

Хороший, надежный алгоритм с программным подавлением дребезга контактов не занимающий ресурсов микроконтроллера во время ожидания на нажатие кнопки. К его недостатком можно отнести ненадежное определение отпускания кнопки, что не позволяет рассчитать время нажатия (для обработки длинных и коротких нажатий)

Пример 3. Комбинирование внешнего прерывания и цикла обработки нажатия кнопки

При получении прерывания по кнопке цикл задачи снимается с ожидания светофора и работает по таймауту, как в первом примере, до тех пор пока не будет зафиксирована отпущенная кнопка с учетом дребезга контактов.

// Порт GPIO к которому подключена кнопка
#define PIN_BUTTON 27
// Минимальный таймаут между событиями нажатия кнопки
#define TM_BUTTON 100

void taskButton1( void *pvParameters );
SemaphoreHandle_t btn1Semaphore;

void setup() {
   Serial.begin(115200);
   Serial.println("ESP32 button. Example 3");
// Запускается задача работы с кнопкой   
   xTaskCreateUniversal(taskButton1, "btn1", 4096, NULL, 2, NULL,1);   
}

void loop(void) {}

void IRAM_ATTR ISR_btn1(){
// Прерывание по кнопке, отпускаем семафор  
   xSemaphoreGiveFromISR( btn1Semaphore, NULL );
}

void taskButton1( void *pvParameters ){
   bool isISR1     = true;
   bool state_btn  = true;
   uint32_t ms_btn = 0;
// Определяем режим работы GPIO с кнопкой   
   pinMode(PIN_BUTTON,INPUT_PULLUP);
// Создаем семафор     
   btn1Semaphore = xSemaphoreCreateBinary();
// Сразу "берем" семафор чтобы не было первого ложного срабатывания кнопки   
   xSemaphoreTake( btn1Semaphore, 100 );
// Запускаем обработчик прерывания (кнопка замыкает GPIO на землю)
   attachInterrupt(PIN_BUTTON, ISR_btn1, FALLING);   
   while(true){
// Обработчик прерывания выключен, функция ждет окончания действия с кнопкой     
      if( isISR1 ){
// Ждем "отпускание" семафора
         xSemaphoreTake( btn1Semaphore, portMAX_DELAY );
// Отключаем прерывание для устранения повторного срабатывания прерывания во время обработки
         detachInterrupt(PIN_BUTTON);
// переводим задачу в цикл обработки кнопки
         isISR1 = false;   
      }
      else {
         bool st = digitalRead(PIN_BUTTON);
// Проверка изменения состояния кнопки      
         if( st != state_btn ){
            state_btn = st;
            if( st == LOW ){
// Фиксируем время нажатия кнопки               
               ms_btn = millis();
               Serial.println("Button pressed");
            }
            else {
// Рассчитываем продолжительность нажатия кнопки
               uint32_t ms_duration = millis() - ms_btn;
               Serial.print("Button released ");            
               Serial.println(ms_duration);            
               attachInterrupt(PIN_BUTTON, ISR_btn1, FALLING); 
               isISR1 = true;
            }
         }        
         vTaskDelay(100);
      }
   }
}

// Порт GPIO к которому подключена кнопка

#define PIN_BUTTON 27

// Минимальный таймаут между событиями нажатия кнопки

#define TM_BUTTON 100

void taskButton1( void *pvParameters );

SemaphoreHandle_t btn1Semaphore;

void setup() {

Serial.begin(115200);

Serial.println("ESP32 button. Example 3");

// Запускается задача работы с кнопкой

xTaskCreateUniversal(taskButton1, "btn1", 4096, NULL, 2, NULL,1);

}

void loop(void) {}

void IRAM_ATTR ISR_btn1(){

// Прерывание по кнопке, отпускаем семафор

xSemaphoreGiveFromISR( btn1Semaphore, NULL );

}

void taskButton1( void *pvParameters ){

bool isISR1 = true;

bool state_btn = true;

uint32_t ms_btn = 0;

// Определяем режим работы GPIO с кнопкой

pinMode(PIN_BUTTON,INPUT_PULLUP);

// Создаем семафор

btn1Semaphore = xSemaphoreCreateBinary();

// Сразу "берем" семафор чтобы не было первого ложного срабатывания кнопки

xSemaphoreTake( btn1Semaphore, 100 );

// Запускаем обработчик прерывания (кнопка замыкает GPIO на землю)

attachInterrupt(PIN_BUTTON, ISR_btn1, FALLING);

while(true){

// Обработчик прерывания выключен, функция ждет окончания действия с кнопкой

if( isISR1 ){

// Ждем "отпускание" семафора

xSemaphoreTake( btn1Semaphore, portMAX_DELAY );

// Отключаем прерывание для устранения повторного срабатывания прерывания во время обработки

detachInterrupt(PIN_BUTTON);

// переводим задачу в цикл обработки кнопки

isISR1 = false;

}

else {

bool st = digitalRead(PIN_BUTTON);

// Проверка изменения состояния кнопки

if( st != state_btn ){

state_btn = st;

if( st == LOW ){

// Фиксируем время нажатия кнопки

ms_btn = millis();

Serial.println("Button pressed");

}

else {

// Рассчитываем продолжительность нажатия кнопки

uint32_t ms_duration = millis() - ms_btn;

Serial.print("Button released ");

Serial.println(ms_duration);

attachInterrupt(PIN_BUTTON, ISR_btn1, FALLING);

isISR1 = true;

}

vTaskDelay(100);

}

В этом примере надежно фиксируется как нажатие, так и отпускание кнопки, что позволяет рассчитывать время ее нажатия. Данная задача «кушает ресурсы» только после нажатия кнопки до ее отпускания.

Пример 4. Обработка нескольких кнопок

При работе с несколькими кнопками вовсе не обязательно запускать несколько задач и обработчиков прерывания. Достаточно по прерыванию от любой кнопки переходить на цикл роботы по таймауту, а при фиксировании отпускания всех

// Порт GPIO к которому подключена кнопка
#define PIN_BUTTON1 25
#define PIN_BUTTON2 26
#define PIN_BUTTON3 27
// Минимальный таймаут между событиями нажатия кнопки
#define TM_BUTTON 100

void taskButtons( void *pvParameters );
SemaphoreHandle_t btnSemaphore;

void setup() {
   Serial.begin(115200);
   Serial.println("ESP32 button. Example 4");
// Запускается задача работы с кнопкой   
   xTaskCreateUniversal(taskButtons, "buttons", 4096, NULL, 2, NULL,1);   
}

void loop(void) {}

void IRAM_ATTR ISR_btn(){
// Прерывание по кнопке, отпускаем семафор  
   xSemaphoreGiveFromISR( btnSemaphore, NULL );
}

void taskButtons( void *pvParameters ){
   bool isISR     = true;
   bool state_btn1 = true, state_btn2 = true, state_btn3 = true;
// Определяем режим работы GPIO с кнопкой   
   pinMode(PIN_BUTTON1,INPUT_PULLUP);
   pinMode(PIN_BUTTON2,INPUT_PULLUP);
   pinMode(PIN_BUTTON3,INPUT_PULLUP);
// Создаем семафор     
   btnSemaphore = xSemaphoreCreateBinary();
// Сразу "берем" семафор чтобы не было первого ложного срабатывания кнопки   
   xSemaphoreTake( btnSemaphore, 100 );
// Запускаем обработчик прерывания (кнопка замыкает GPIO на землю) на все кнопки
   attachInterrupt(PIN_BUTTON1, ISR_btn, FALLING);   
   attachInterrupt(PIN_BUTTON2, ISR_btn, FALLING);   
   attachInterrupt(PIN_BUTTON3, ISR_btn, FALLING);   
   while(true){
// Обработчик прерывания выключен, функция ждет окончания действия с кнопкой     
      if( isISR ){
// Ждем "отпускание" семафора
         xSemaphoreTake( btnSemaphore, portMAX_DELAY );
// Отключаем прерывания по всем кнопкам
         detachInterrupt(PIN_BUTTON1);
         detachInterrupt(PIN_BUTTON2);
         detachInterrupt(PIN_BUTTON3);
// переводим задачу в цикл обработки кнопки
         isISR = false;   
      }
      else {
         bool st1 = digitalRead(PIN_BUTTON1);
         bool st2 = digitalRead(PIN_BUTTON2);
         bool st3 = digitalRead(PIN_BUTTON3);
// Проверка изменения состояния кнопки1      
         if( st1 != state_btn1 ){
            state_btn1 = st1;
            if( st1 == LOW ){ Serial.println("Button1 pressed"); }
            else { Serial.println("Button1 released"); }
         }        
// Проверка изменения состояния кнопки2      
         if( st2 != state_btn2 ){
            state_btn2 = st2;
            if( st2 == LOW ){ Serial.println("Button2 pressed"); }
            else { Serial.println("Button2 released"); }
         }        
// Проверка изменения состояния кнопки3      
         if( st3 != state_btn3 ){
            state_btn3 = st3;
            if( st3 == LOW ){ Serial.println("Button3 pressed"); }
            else { Serial.println("Button3 released"); }
         }        
// Проверка что все три кнопки отработали
         if( st1 == HIGH && st2 == HIGH && st2 == HIGH ){ 
            attachInterrupt(PIN_BUTTON1, ISR_btn, FALLING);   
            attachInterrupt(PIN_BUTTON2, ISR_btn, FALLING);   
            attachInterrupt(PIN_BUTTON3, ISR_btn, FALLING);   
            isISR = true;
         }
         vTaskDelay(100);
      }
   }
}

// Порт GPIO к которому подключена кнопка

#define PIN_BUTTON1 25

#define PIN_BUTTON2 26

#define PIN_BUTTON3 27

// Минимальный таймаут между событиями нажатия кнопки

#define TM_BUTTON 100

void taskButtons( void *pvParameters );

SemaphoreHandle_t btnSemaphore;

void setup() {

Serial.begin(115200);

Serial.println("ESP32 button. Example 4");

// Запускается задача работы с кнопкой

xTaskCreateUniversal(taskButtons, "buttons", 4096, NULL, 2, NULL,1);

}

void loop(void) {}

void IRAM_ATTR ISR_btn(){

// Прерывание по кнопке, отпускаем семафор

xSemaphoreGiveFromISR( btnSemaphore, NULL );

}

void taskButtons( void *pvParameters ){

bool isISR = true;

bool state_btn1 = true, state_btn2 = true, state_btn3 = true;

// Определяем режим работы GPIO с кнопкой

pinMode(PIN_BUTTON1,INPUT_PULLUP);

pinMode(PIN_BUTTON2,INPUT_PULLUP);

pinMode(PIN_BUTTON3,INPUT_PULLUP);

// Создаем семафор

btnSemaphore = xSemaphoreCreateBinary();

// Сразу "берем" семафор чтобы не было первого ложного срабатывания кнопки

xSemaphoreTake( btnSemaphore, 100 );

// Запускаем обработчик прерывания (кнопка замыкает GPIO на землю) на все кнопки

attachInterrupt(PIN_BUTTON1, ISR_btn, FALLING);

attachInterrupt(PIN_BUTTON2, ISR_btn, FALLING);

attachInterrupt(PIN_BUTTON3, ISR_btn, FALLING);

while(true){

// Обработчик прерывания выключен, функция ждет окончания действия с кнопкой

if( isISR ){

// Ждем "отпускание" семафора

xSemaphoreTake( btnSemaphore, portMAX_DELAY );

// Отключаем прерывания по всем кнопкам

detachInterrupt(PIN_BUTTON1);

detachInterrupt(PIN_BUTTON2);

detachInterrupt(PIN_BUTTON3);

// переводим задачу в цикл обработки кнопки

isISR = false;

}

else {

bool st1 = digitalRead(PIN_BUTTON1);

bool st2 = digitalRead(PIN_BUTTON2);

bool st3 = digitalRead(PIN_BUTTON3);

// Проверка изменения состояния кнопки1

if( st1 != state_btn1 ){

state_btn1 = st1;

if( st1 == LOW ){ Serial.println("Button1 pressed"); }

else { Serial.println("Button1 released"); }

}

// Проверка изменения состояния кнопки2

if( st2 != state_btn2 ){

state_btn2 = st2;

if( st2 == LOW ){ Serial.println("Button2 pressed"); }

else { Serial.println("Button2 released"); }

}

// Проверка изменения состояния кнопки3

if( st3 != state_btn3 ){

state_btn3 = st3;

if( st3 == LOW ){ Serial.println("Button3 pressed"); }

else { Serial.println("Button3 released"); }

}

// Проверка что все три кнопки отработали

if( st1 == HIGH && st2 == HIGH && st2 == HIGH ){

attachInterrupt(PIN_BUTTON1, ISR_btn, FALLING);

attachInterrupt(PIN_BUTTON2, ISR_btn, FALLING);

attachInterrupt(PIN_BUTTON3, ISR_btn, FALLING);

isISR = true;

}

vTaskDelay(100);

}

Пример 5. Обработка емкостного сенсорного входа по прерыванию

Touch интерфейс — чисто ESP-шная фича, позволяющая реализовать до 10 сенсорных кнопок. Далее привожу пример работы с сенсорной кнопкой на GPIO4 (TOUCH0) с прерыванием по порогу срабатывания. В остальном код ничем не отличается от Примера 3.

// Порт GPIO к которому подключена кнопка
#define PIN_BUTTON T0
// Минимальный таймаут между событиями нажатия кнопки
#define TM_BUTTON 100
#define THRESHOLD 20

void taskButton1( void *pvParameters );
SemaphoreHandle_t btn1Semaphore;

void setup() {
   Serial.begin(115200);
   Serial.println("ESP32 button. Example 3");
// Запускается задача работы с кнопкой   
   xTaskCreateUniversal(taskButton1, "btn1", 4096, NULL, 2, NULL,1);   
}

void loop(void) {
  }

void IRAM_ATTR ISR_btn1(){
// Прерывание по кнопке, отпускаем семафор  
   xSemaphoreGiveFromISR( btn1Semaphore, NULL );
}

void taskButton1( void *pvParameters ){
   bool isISR1     = true;
   bool state_btn  = true;
   uint32_t ms_btn = 0;
// Создаем семафор     
   btn1Semaphore = xSemaphoreCreateBinary();
// Сразу "берем" семафор чтобы не было первого ложного срабатывания кнопки   
   xSemaphoreTake( btn1Semaphore, 100 );
// Запускаем обработчик прерывания по порогу срабатывания
   touchAttachInterrupt(PIN_BUTTON, ISR_btn1, THRESHOLD);   
   while(true){
// Обработчик прерывания выключен, функция ждет окончания действия с кнопкой     
      if( isISR1 ){
// Ждем "отпускание" семафора
         xSemaphoreTake( btn1Semaphore, portMAX_DELAY );
// Отключаем прерывание для устранения повторного срабатывания прерывания во время обработки
         detachInterrupt(PIN_BUTTON);
// переводим задачу в цикл обработки кнопки
         isISR1 = false;   
      }
      else {
// Обрабатываем значение сенсорного входа        
         uint16_t t = touchRead(PIN_BUTTON);
         bool st;
         if( t < THRESHOLD )st = LOW;
         else st = HIGH;
// Проверка изменения состояния кнопки      
         if( st != state_btn ){
            state_btn = st;
            if( st == LOW ){
// Фиксируем время нажатия кнопки               
               ms_btn = millis();
               Serial.println("Button pressed");
            }
            else {
// Рассчитываем продолжительность нажатия кнопки
               uint32_t ms_duration = millis() - ms_btn;
               Serial.print("Button released ");            
               Serial.println(ms_duration);            
               touchAttachInterrupt(PIN_BUTTON, ISR_btn1, THRESHOLD);   
               isISR1 = true;
            }
         }        
         vTaskDelay(100);
      }
   }
}

// Порт GPIO к которому подключена кнопка

#define PIN_BUTTON T0

// Минимальный таймаут между событиями нажатия кнопки

#define TM_BUTTON 100

#define THRESHOLD 20

void taskButton1( void *pvParameters );

SemaphoreHandle_t btn1Semaphore;

void setup() {

Serial.begin(115200);

Serial.println("ESP32 button. Example 3");

// Запускается задача работы с кнопкой

xTaskCreateUniversal(taskButton1, "btn1", 4096, NULL, 2, NULL,1);

}

void loop(void) {

}

void IRAM_ATTR ISR_btn1(){

// Прерывание по кнопке, отпускаем семафор

xSemaphoreGiveFromISR( btn1Semaphore, NULL );

}

void taskButton1( void *pvParameters ){

bool isISR1 = true;

bool state_btn = true;

uint32_t ms_btn = 0;

// Создаем семафор

btn1Semaphore = xSemaphoreCreateBinary();

// Сразу "берем" семафор чтобы не было первого ложного срабатывания кнопки

xSemaphoreTake( btn1Semaphore, 100 );

// Запускаем обработчик прерывания по порогу срабатывания

touchAttachInterrupt(PIN_BUTTON, ISR_btn1, THRESHOLD);

while(true){

// Обработчик прерывания выключен, функция ждет окончания действия с кнопкой

if( isISR1 ){

// Ждем "отпускание" семафора

xSemaphoreTake( btn1Semaphore, portMAX_DELAY );

// Отключаем прерывание для устранения повторного срабатывания прерывания во время обработки

detachInterrupt(PIN_BUTTON);

// переводим задачу в цикл обработки кнопки

isISR1 = false;

}

else {

// Обрабатываем значение сенсорного входа

uint16_t t = touchRead(PIN_BUTTON);

bool st;

if( t < THRESHOLD )st = LOW;

else st = HIGH;

// Проверка изменения состояния кнопки

if( st != state_btn ){

state_btn = st;

if( st == LOW ){

// Фиксируем время нажатия кнопки

ms_btn = millis();

Serial.println("Button pressed");

}

else {

// Рассчитываем продолжительность нажатия кнопки

uint32_t ms_duration = millis() - ms_btn;

Serial.print("Button released ");

Serial.println(ms_duration);

touchAttachInterrupt(PIN_BUTTON, ISR_btn1, THRESHOLD);

isISR1 = true;

}

vTaskDelay(100);

}

Полезные ссылки

Хороший цикл статей про FreeRTOS на русском языке

Файлы примеров к статье
Examples_esp32_btn.zip

7.1 KiB
194 Downloads
Детали

Posted in ESP32, Программирование | Метки: Arduino, ESP32, FreeRTOS

Вы можете оставить отзыв или трекбек со своего сайта.

2 комментария на «ESP32. Управление кнопками в FreeRTOS»

Дамир:

15.11.2021 в 07:52

А Вы проверяли, действительно ли отключаются прерывания в примере 5 ?

У меня не получается отключить прерывания.

int threshold = 20;
bool touch1detected = false;

void gotTouch1() {
touch1detected = true;
}

void setup() {
Serial.begin(115200);
delay(1000);
Serial.println(«ESP32 Touch Interrupt Test»);

touchAttachInterrupt(T0, gotTouch1, threshold);
delay(1000);
detachInterrupt(T0);
delay(1000);

}
void loop() {
if (touch1detected) {
detachInterrupt(T0);
touch1detected = false;
Serial.println(«Touch 1 detected»);
Serial.println(touchRead(T0));
}
}

С уважением.

Войдите, чтобы ответить
Дамир:

17.11.2021 в 04:54

Результат

06:47:12.228 -> Touch 1 detected
06:47:12.228 -> 15
06:47:12.275 -> Touch 1 detected
06:47:12.275 -> 0
06:47:12.275 -> Touch 1 detected
06:47:12.275 -> 9
06:47:12.322 -> Touch 1 detected
06:47:12.322 -> 8
06:47:12.322 -> Touch 1 detected
06:47:12.322 -> 6
06:47:12.368 -> Touch 1 detected
06:47:12.368 -> 5
06:47:12.368 -> Touch 1 detected
06:47:12.368 -> 6
06:47:12.415 -> Touch 1 detected
06:47:12.415 -> 5

Войдите, чтобы ответить

Ваш отзыв

Вы должны войти, чтобы оставлять комментарии.

Платформы:	Windows 8
Лицензия:	Freeware
Дата:	05.03.2021