Хочешь создать умный дом, но не знаешь как? Присмотрись к Node-REDCutehamster.gif! Так же не забывай поддержать наш справочникCutehamster.gif.

ESP32:Примеры/Как запомнить последнее состояние контакта

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

Перевод: Максим Кузьмин (Cubewriter)
Перевел 3377 статей для сайта.

Контакты:

Проверка/Оформление/Редактирование: Мякишев Е.А.


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


Как запомнить последнее состояние контакта

В этом примере мы научимся сохранять и считывать данные из flash-памяти ESP32. В качестве примера мы сохраним в нее последнее состояние GPIO-контакта.

Данные, сохраненные на flash-память, остаются там даже при сбросе ESP32 или отключении питания. Flash-память очень похожа на память EEPROM, потому что обе они – разновидности энергонезависимой памяти.

Сохранение данных на flash-память может пригодиться в следующих случаях:

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

У flash-памяти есть одно ограничение – то, сколько раз можно выполнить запись на нее. Считывать данные можно сколько угодно раз, но у большинства устройств максимальное количество записей ограничивается диапазоном от 100 тысяч до 1 млн.

Для считывания и записи данных на flash-память ESP32 при помощи IDE Arduino мы воспользуемся библиотекой EEPROM. Ее использование на ESP32 почти аналогично использованию на Arduino. То есть если вы уже пользовались EEPROM-памятью Arduino, то особых проблем у вас не возникнет.

При помощи библиотеки EEPROM можно использовать до 512 байт flash-памяти ESP32. Это значит, что у вас есть 512 разных адресов, и в каждом из них можно сохранить значение от «0» до «255».

Чтобы записать данные на flash-память, необходимо воспользоваться функцией EEPROM.write(), где параметрами служат место (адрес) для сохранения данных и значение (байтовая переменная), которое нужно сохранить:

EEPROM.write(address, value);

К примеру, чтобы записать значение «9» на адрес «0», нужно вписать следующее:

EEPROM.write(0, 9);

После этого нужно вызвать...

EEPROM.commit();

Это нужно, чтобы сохранить изменения.

Чтобы прочесть байт из flash-памяти, воспользуйтесь функцией EEPROM.read(). Параметром для нее служит адрес байта, который нужно прочесть.

EEPROM.read(address);

К примеру, чтобы прочесть байт, хранящийся по адресу «0», нужно вписать следующее:

EEPROM.read(0);

В результате функция EEPROM.read() вернет значение «9», хранящееся по адресу «0».

Чтобы продемонстрировать сохранение данных на flash-память ESP32, мы сохраним последнее состояние выходного контакта (в нашем случае – светодиода). Представьте следующий сценарий:

  1. Вы управляете лампой при помощи ESP32
  2. Вы задали значение, включающее лампу
  3. У платы ESP32 внезапно отключается питание
  4. Поле включения питания лампа остается выключенной, потому что ESP32 не сохранила последнее состояние выходного контакта, к которому подключена лампа
Esp32 lamp is off.png

Разумеется, вы не хотите, чтобы так вышло. Вам нужно, чтобы ESP32 сохранила то, что произошло до выключения питания и вернула последнее состояние того выходного контакта.

Чтобы решить эту проблему, нужно сохранить состояние контакта лампы на flash-память. Затем вам просто нужно добавить условие в начало скетча, которое будет проверять последнее состояние контакта лампы, чтобы соответствующим образом включать/выключать лампу.

На схеме ниже показано, что мы собираемся сделать:

Esp32 lamp is on.png

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

Давайте разберемся как работает этот код.

Этот код меняет состояние светодиода при каждом нажатии на кнопку, а также имеет фрагмент с «антидребезгом». Но этот код особенный – он запоминает последнее состояние светодиода даже после сброса платы ESP32 и ее отключения от питания. Итак, давайте разберемся, что нужно сделать, чтобы ESP32 запоминал последнее состояние GPIO-контакта.

Во-первых, нам нужно подключить библиотеку EEPROM.

#include <EEPROM.h>

Затем задаем размер памяти. Это количество байтов flash-памяти, к которым вы хотите получить доступ в этом скетче. В данном случае мы просто сохраняем состояние светодиода, поэтому нам достаточно EEPROM-памяти размера «1».

#define EEPROM_SIZE 1

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

  1. // константы – это неизменяемые значения;
  2. // воспользуемся ими, чтобы задать номера контактов:
  3. const int buttonPin = 4;   // номер контакта для кнопки
  4. const int ledPin = 16;     // номер контакта для светодиода
  5.  
  6. // переменные – это изменяемые значения;
  7. int ledState = HIGH;        // текущее состояние
  8.                             // выходного контакта (для светодиода)
  9. int buttonState;            // текущее состояние
  10.                             // входного контакта (для кнопки)
  11. int lastButtonState = LOW;  // предыдущее состояние
  12.                             // входного контакта (для кнопки)
  13.  
  14. // переменные ниже имеют тип «unsigned long»,
  15. // потому что время измеряется в миллисекундах, и значение,
  16. // в котором оно хранится, очень быстро станет настолько большим,
  17. // что его нельзя будет сохранить в типе данных «int»
  18.  
  19. unsigned long lastDebounceTime = 0; // время, когда в последний раз
  20.                                     // был переключен выходной контакт
  21. unsigned long debounceDelay = 50;   // задержка для антидребезга;
  22.                                     // если выходной контакт
  23.                                     // «дребезжит», увеличьте
  24.                                     // это значение

В блоке setup() инициализируем EEPROM-память заданного размера.

EEPROM.begin(EEPROM_SIZE);

Чтобы начать этот код с последнего состояния светодиода, его нужно прочесть уже в блоке setup(). Оно хранится на flash-памяти по адресу «0».

ledState = EEPROM.read(0);

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

digitalWrite(ledPin, ledState);

Фрагмент ниже из блока loop() проверяет, нажата ли кнопка, и меняет значение в переменной «ledState» при каждом нажатии на кнопку. Чтобы случайно не переключить контакт из-за дребезга, здесь используется таймер. Этот фрагмент основан на скетче для IDE Arduino, предназначенном для считывания значения с кнопки и предотвращения дребезга.

  1.   // считываем состояние переключателя в локальную переменную:
  2.   int reading = digitalRead(buttonPin);
  3.  
  4.   // во фрагменте кода ниже проверяем, была ли нажата кнопка
  5.   // (т.е. изменилось ли входное значение с «LOW» на «HIGH»)
  6.   // и прошло ли достаточно времени с момента нажатия
  7.   // (чтобы исключить вероятность переключения из-за шума):
  8.  
  9.   // если состояние переключателя изменилось -
  10.   // либо из-за шума, либо из-за нажатия на кнопку...
  11.   if (reading != lastButtonState) {
  12.     // ...сбрасываем счетчик антидребезга:
  13.     lastDebounceTime = millis();
  14.   }
  15.  
  16.   if ((millis() - lastDebounceTime) > debounceDelay) {
  17.     // каким бы ни было считанное значение,
  18.     // оно держится уже дольше периода антидребезга,
  19.     // поэтому принимаем это значение за текущее состояние контакта:
  20.  
  21.     // если состояние кнопки изменилось:
  22.     if (reading != buttonState) {
  23.       buttonState = reading;
  24.  
  25.       // переключаем светодиод, только если
  26.       // новым состоянием кнопки является «HIGH»:
  27.       if (buttonState == HIGH) {
  28.         ledState = !ledState;
  29.       }
  30.     }
  31.   }

То есть нам нужно просто сохранять состояние светодиода на flash-память при каждом изменении этого состояния.

Здесь мы проверяем, отличается ли значение GPIO-контакта от значения в переменной «ledState».

if (digitalRead(ledPin)!= ledState) {

Если отличается, меняем состояние светодиода при помощи функции digitalWrite().

digitalWrite(ledPin, ledState);

И затем сохраняем текущее состояние на flash-память. Используем для этого функцию EEPROM.write(), а в параметрах у нее указываем адрес памяти («0»), и сохраняемое значение («ledState»).

EEPROM.write(0, ledState);

Наконец, используем EEPROM.commit(), чтобы изменения вступили в силу.

EEPROM.commit();

Итак, в этом примере мы научились сохранять данные на flash-память ESP32 при помощи библиотеки EEPROM. Данные, сохраняемые на flash-память, остаются там даже после сброса ESP32 или отключения ее от питания.

Pixel Art Mini Meow Animated.gif Важно: Перед тем, как строить какую-либо цепь, всегда сверяйтесь с распиновкой свой платы.


Необходимое оборудование

Схема

Pixel Art Mini Meow Animated.gif На данной схеме используется плата ESP32S-HiLetgo, если вы используете другую, сверьтесь с вашей распиновкой.


Кнопка подключена к контакту GPIO4 через резистор на 10 кОм, а светодиод – к контакту GPIO16 через резистор 330 Ом.

Esp32 button led on off 1.png

Код

  1. // подключаем библиотеку для считывания и записи на flash-память:
  2. #include <EEPROM.h>
  3.  
  4. // задаем количество байтов, к которым нужно получить доступ:
  5. #define EEPROM_SIZE 1
  6.  
  7. // константы – это неизменяемые значения;
  8. // воспользуемся ими, чтобы задать номера контактов:
  9. const int buttonPin = 4;   // номер контакта для кнопки
  10. const int ledPin = 16;     // номер контакта для светодиода
  11.  
  12. // переменные – это изменяемые значения;
  13. int ledState = HIGH;        // текущее состояние
  14.                             // выходного контакта (для светодиода)
  15. int buttonState;            // текущее состояние
  16.                             // входного контакта (для кнопки)
  17. int lastButtonState = LOW;  // предыдущее состояние
  18.                             // входного контакта (для кнопки)
  19.  
  20. // переменные ниже имеют тип «unsigned long»,
  21. // потому что время измеряется в миллисекундах, и значение,
  22. // в котором оно хранится, очень быстро станет настолько большим,
  23. // что его нельзя будет сохранить в типе данных «int»
  24.  
  25. unsigned long lastDebounceTime = 0; // время, когда в последний раз
  26.                                     // был переключен выходной контакт
  27. unsigned long debounceDelay = 50;   // задержка для антидребезга;
  28.                                     // если выходной контакт
  29.                                     // по-прежнему «дребезжит»,
  30.                                     // увеличьте это значение
  31.  
  32. void setup() {
  33.   Serial.begin(115200);
  34.  
  35.   // инициализируем EEPROM-память заданного ранее размера:
  36.   EEPROM.begin(EEPROM_SIZE);
  37.  
  38.   pinMode(buttonPin, INPUT);
  39.   pinMode(ledPin, OUTPUT);
  40.  
  41.   // считываем последнее состояние светодиода из flash-памяти:
  42.   ledState = EEPROM.read(0);
  43.   // задаем контакту светодиода последнее сохраненное состояние:
  44.   digitalWrite(ledPin, ledState);
  45. }
  46.  
  47. void loop() {
  48.   // считываем состояние переключателя в локальную переменную:
  49.   int reading = digitalRead(buttonPin);
  50.  
  51.   // во фрагменте ниже проверяем, была ли нажата кнопка
  52.   // (т.е. изменилось ли входное значение с «LOW» на «HIGH»)
  53.   // и прошло ли достаточно времени с момента нажатия
  54.   // (чтобы исключить вероятность переключения из-за шума):
  55.  
  56.   // если состояние переключателя изменилось -
  57.   // либо из-за шума, либо из-за нажатия на кнопку...
  58.   if (reading != lastButtonState) {
  59.     // ...сбрасываем счетчик антидребезга:
  60.     lastDebounceTime = millis();
  61.   }
  62.  
  63.   if ((millis() - lastDebounceTime) > debounceDelay) {
  64.     // каким бы ни было считанное значение,
  65.     // оно держится уже дольше периода антидребезга,
  66.     // поэтому принимаем это значение за текущее состояние контакта:
  67.  
  68.     // если состояние кнопки изменилось:
  69.     if (reading != buttonState) {
  70.       buttonState = reading;
  71.  
  72.       // переключаем светодиод, только если
  73.       // новым состоянием кнопки является «HIGH»:
  74.       if (buttonState == HIGH) {
  75.         ledState = !ledState;
  76.       }
  77.     }
  78.   }
  79.   // сохраняем считанное значение;
  80.   // во время следующего прохода через loop()
  81.   // это значение будет храниться в переменной «lastButtonState»:
  82.   lastButtonState = reading;
  83.  
  84.   // если значение в переменной «ledState»
  85.   // отличается от текущего состояния контакта:
  86.   if (digitalRead(ledPin)!= ledState) {  
  87.     Serial.println("State changed"); // "Состояние изменилось"
  88.     // меняем состояние светодиода:
  89.     digitalWrite(ledPin, ledState);
  90.     // сохраняем состояние на flash-память:
  91.     EEPROM.write(0, ledState);
  92.     EEPROM.commit();
  93.     Serial.println("State saved in flash memory");
  94.                //  "Состояние сохранено на flash-память"
  95.   }
  96. }

См.также

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