mirivlad/Petfilamachine
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Add libraries dir

Browse Source
This commit is contained in:
mirv
2022-03-12 03:50:28 +08:00
parent 816f0bb3a5
commit 7572125fcb
256 changed files with 41193 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
libraries/GyverButton/src/AnalogKey.h
+64
View File
@@ -0,0 +1,64 @@
#ifndef AnalogKey_h
#define AnalogKey_h
/*
Мини класс для работы с аналоговой клавиатурой
GitHub: https://github.com/GyverLibs/AnalogKey
- Встроенный простенький дебаунс
- Оптимальный опрос пина по таймеру
- Проверка конкретной кнопки или вывод номера нажатой
AlexGyver, alex@alexgyver.ru
https://alexgyver.ru/
MIT License
*/
#define _AKEY_PERIOD 50 // период опроса в мс
template <byte PIN, byte AMOUNT>
class AnalogKey {
public:
// подключает кнопку на указанное значение
void attach(byte num, int value) {
if (num >= AMOUNT) return;
signals[num] = value;
}
// устанавливает окно сигнала (умолч. 20)
void setWindow(int window) {
_window = window;
}
// возвращает статус указанной кнопки
bool status(byte num) {
if (millis() - tmr > _AKEY_PERIOD) {
tmr = millis();
int thisRead = analogRead(PIN);
if (abs(thisRead - _lastRead) < _window) _ready = true;
else _ready = false;
_lastRead = thisRead;
}
if (_ready &&
_lastRead > signals[num] - _window &&
_lastRead < signals[num] + _window) return true;
else return false;
}
// выводит номер нажатой кнопки или -1, если нажатых кнопок нет
int pressed() {
status(0); // вызываем опрос
for (byte i = 0; i < AMOUNT; i++) {
if (_ready &&
_lastRead > signals[i] - _window &&
_lastRead < signals[i] + _window) return i;
}
return -1;
}
private:
int signals[AMOUNT];
int _lastRead = 0;
int _window = 20;
bool _ready = false;
uint32_t tmr;
};
#endif
libraries/GyverButton/src/GyverButton.cpp
+224
View File
@@ -0,0 +1,224 @@
#include "GyverButton.h"
// ==================== CONSTRUCTOR ====================
GButton::GButton(int8_t pin, bool type, bool dir) {
if (pin != BTN_NO_PIN) {
_PIN = (uint8_t)pin;
flags.noPin = false;
} else {
flags.noPin = true;
}
setType(type);
flags.mode = false;
flags.tickMode = false;
flags.inv_state = dir;
}
// ==================== SET ====================
void GButton::setDebounce(uint16_t debounce) {
_debounce = debounce;
}
void GButton::setTimeout(uint16_t new_timeout) {
_timeout = new_timeout;
}
void GButton::setClickTimeout(uint16_t new_timeout) {
_click_timeout = new_timeout;
}
void GButton::setStepTimeout(uint16_t step_timeout) {
_step_timeout = step_timeout;
}
void GButton::setType(bool type) {
flags.type = type;
if (!flags.noPin) {
if (type) pinMode(_PIN, INPUT);
else pinMode(_PIN, INPUT_PULLUP);
#if defined(__AVR__)
_pin_reg = portInputRegister(digitalPinToPort(_PIN));
_bit_mask = digitalPinToBitMask(_PIN);
#endif
}
}
void GButton::setDirection(bool dir) {
flags.inv_state = dir;
}
void GButton::setTickMode(bool tickMode) {
flags.tickMode = tickMode;
}
// ==================== IS ====================
boolean GButton::isPress() {
if (flags.tickMode) GButton::tick();
if (flags.isPress_f) {
flags.isPress_f = false;
return true;
} else return false;
}
boolean GButton::isRelease() {
if (flags.tickMode) GButton::tick();
if (flags.isRelease_f) {
flags.isRelease_f = false;
return true;
} else return false;
}
boolean GButton::isClick() {
if (flags.tickMode) GButton::tick();
if (flags.isOne_f) {
flags.isOne_f = false;
return true;
} else return false;
}
boolean GButton::isHolded() {
if (flags.tickMode) GButton::tick();
if (flags.isHolded_f) {
flags.isHolded_f = false;
return true;
} else return false;
}
boolean GButton::isHold() {
if (flags.tickMode) GButton::tick();
if (flags.step_flag) return true;
else return false;
}
boolean GButton::state() {
if (flags.tickMode) GButton::tick();
return btn_state;
}
boolean GButton::isSingle() {
if (flags.tickMode) GButton::tick();
if (flags.counter_flag && last_counter == 1) {
// last_counter = 0;
// flags.counter_flag = false;
flags.counter_reset = true;
return true;
} else return false;
}
boolean GButton::isDouble() {
if (flags.tickMode) GButton::tick();
if (flags.counter_flag && last_counter == 2) {
// flags.counter_flag = false;
// last_counter = 0;
flags.counter_reset = true;
return true;
} else return false;
}
boolean GButton::isTriple() {
if (flags.tickMode) GButton::tick();
if (flags.counter_flag && last_counter == 3) {
// flags.counter_flag = false;
// last_counter = 0;
flags.counter_reset = true;
return true;
} else return false;
}
boolean GButton::hasClicks() {
if (flags.tickMode) GButton::tick();
if (flags.counter_flag) {
// flags.counter_flag = false;
flags.counter_reset = true;
return true;
} else return false;
}
uint8_t GButton::getClicks() {
// byte thisCount = last_counter; // Исключено 14.01.2021
// last_counter = 0;
flags.counter_reset = true;
return last_counter; // return thisCount; (замена) 14.01.2021
}
uint8_t GButton::getHoldClicks() {
if (flags.tickMode) GButton::tick();
return last_hold_counter; //return flags.hold_flag ? last_hold_counter : 0; (Замена) 14.01.2021
}
boolean GButton::isStep(byte clicks) {
if (flags.tickMode) GButton::tick();
if (btn_counter == clicks && flags.step_flag && (millis() - btn_timer >= _step_timeout)) {
btn_timer = millis();
return true;
}
else return false;
}
void GButton::resetStates() {
flags.isPress_f = false;
flags.isRelease_f = false;
flags.isOne_f = false;
flags.isHolded_f = false;
flags.step_flag = false;
flags.counter_flag = false;
last_hold_counter = 0;
last_counter = 0;
}
// ==================== TICK ====================
void GButton::tick(boolean state) {
flags.mode = true;
btn_state = state ^ flags.inv_state;
GButton::tick();
flags.mode = false;
}
void GButton::tick() {
// читаем пин
if (!flags.mode && !flags.noPin) btn_state = !_buttonRead() ^ (flags.inv_state ^ flags.type);
uint32_t thisMls = millis();
// нажатие
if (btn_state && !btn_flag) {
if (!flags.btn_deb) {
flags.btn_deb = true;
btn_timer = thisMls;
} else {
if (thisMls - btn_timer >= _debounce) {
btn_flag = true;
flags.isPress_f = true;
flags.oneClick_f = true;
}
}
} else {
flags.btn_deb = false;
}
// отпускание
if (!btn_state && btn_flag) {
btn_flag = false;
if (!flags.hold_flag) btn_counter++;
flags.hold_flag = false;
flags.isRelease_f = true;
btn_timer = thisMls;
if (flags.step_flag) {
last_counter = 0;
btn_counter = 0;
flags.step_flag = false;
}
if (flags.oneClick_f) {
flags.oneClick_f = false;
flags.isOne_f = true;
}
}
// кнопка удерживается
if (btn_flag && btn_state && (thisMls - btn_timer >= _timeout) && !flags.hold_flag) {
flags.hold_flag = true;
last_hold_counter = btn_counter;
//btn_counter = 0;
//last_counter = 0;
flags.isHolded_f = true;
flags.step_flag = true;
flags.oneClick_f = false;
btn_timer = thisMls;
}
// обработка накликивания
if ((thisMls - btn_timer >= _click_timeout) && (btn_counter != 0) && !btn_state) { //И здесь еще добавлен !btn_state
last_counter = btn_counter;
btn_counter = 0;
flags.counter_flag = true;
}
// сброс накликивания //Добавлено
if (flags.counter_reset) {
last_counter = 0;
flags.counter_flag = false;
flags.counter_reset = false;
}
}
libraries/GyverButton/src/GyverButton.h
+134
View File
@@ -0,0 +1,134 @@
/*
GyverButton - библиотека для многофункциональной отработки нажатия кнопки
ВНИМАНИЕ, БИБЛИОТЕКА УСТАРЕЛА! ИСПОЛЬЗУЙ БИБЛИОТЕКУ EncButton https://github.com/GyverLibs/EncButton
GitHub: https://github.com/GyverLibs/GyverButton
Документация: https://alexgyver.ru/gyverbutton/
Возможности:
- Работа с нормально замкнутыми и нормально разомкнутыми кнопками
- Работа с подключением PULL_UP и PULL_DOWN
- Опрос кнопки с программным антидребезгом контактов (настраиваемое время)
- Отработка нажатия, удерживания, отпускания, клика по кнопке (+ настройка таймаутов)
- Отработка одиночного, двойного и тройного нажатия (вынесено отдельно)
- Отработка любого количества нажатий кнопки (функция возвращает количество нажатий)
- Функция изменения значения переменной с заданным шагом и заданным интервалом по времени
- Возможность работы с "виртуальными" кнопками (все возможности библиотеки используются для матричных и резистивных клавиатур)
Версии:
v2.15: Добавлена возможность объявить кнопку без привязки к пину
v3.0: Ускорен и оптимизирован код, переделана инициализация, дополнены примеры
v3.1: isStep может принимать количество кликов, сделанных перед ним (см. пример clicks_step)
v3.2: Добавлен метод getHoldClicks() - вернуть количество кликов, предшествующее удерживанию
v3.3: Мелкие исправления
v3.4: Добавлен метод resetStates(), сбрасывающий состояния и счётчики
v3.5: увелична производительность для AVR Arduino
v3.6: добавлен отдельный класс для работы с аналоговыми клавиатурами, см пример analogKeyboardG
v3.7: исправления от Dryundel:
- Любой таймаут удержания
- Single, Double и Triple теперь не мешают hasClicks и getClicks и работают совместно
- isStep() тоже теперь ничего не мешает и он работает более корректно
v3.8: исправления от Dryundel:
*/
#ifndef GyverButton_h
#define GyverButton_h
#include <Arduino.h>
#if defined(__AVR__)
#define _buttonRead() bool(*_pin_reg & _bit_mask)
#else
#define _buttonRead() digitalRead(_PIN)
#endif
#pragma pack(push,1)
typedef struct {
bool btn_deb: 1;
bool hold_flag: 1;
bool counter_flag: 1;
bool isHolded_f: 1;
bool isRelease_f: 1;
bool isPress_f: 1;
bool step_flag: 1;
bool oneClick_f: 1;
bool isOne_f: 1;
bool inv_state: 1;
bool mode: 1;
bool type: 1;
bool tickMode: 1;
bool noPin: 1;
bool counter_reset: 1; //Добавлен
} GyverButtonFlags;
#pragma pack(pop)
#define BTN_NO_PIN -1
#define HIGH_PULL 0
#define LOW_PULL 1
#define NORM_OPEN 0
#define NORM_CLOSE 1
#define MANUAL 0
#define AUTO 1
// Варианты инициализации:
// GButton btn; // без привязки к пину (виртуальная кнопка) и без указания типа (по умолч. LOW_PULL и NORM_OPEN)
// GButton btn(пин); // с привязкой к пину и без указания типа (по умолч. HIGH_PULL и NORM_OPEN)
// GButton btn(пин, тип подключ.); // с привязкой к пину и указанием типа подключения (HIGH_PULL / LOW_PULL) и без указания типа кнопки (по умолч. NORM_OPEN)
// GButton btn(пин, тип подключ., тип кнопки); // с привязкой к пину и указанием типа подключения (HIGH_PULL / LOW_PULL) и типа кнопки (NORM_OPEN / NORM_CLOSE)
// GButton btn(BTN_NO_PIN, тип подключ., тип кнопки); // без привязки к пину и указанием типа подключения (HIGH_PULL / LOW_PULL) и типа кнопки (NORM_OPEN / NORM_CLOSE)
class GButton {
public:
GButton(int8_t pin = BTN_NO_PIN, bool type = HIGH_PULL, bool dir = NORM_OPEN); // конструктор кнопки, принимает PIN пин, тип type (HIGH_PULL / LOW_PULL) и направление dir (NORM_OPEN / NORM_CLOSE)
// HIGH_PULL - кнопка подключена к GND, пин подтянут к VCC, pinMode - INPUT_PULLUP (по умолчанию)
// LOW_PULL - кнопка подключена к VCC, пин подтянут к GND, pinMode - INPUT
// NORM_OPEN - кнопка по умолчанию разомкнута (по умолчанию)
// NORM_CLOSE - кнопка по умолчанию замкнута
void setDebounce(uint16_t debounce); // установка времени антидребезга (по умолчанию 80 мс)
void setTimeout(uint16_t new_timeout); // установка таймаута удержания (по умолчанию 300 мс)
void setClickTimeout(uint16_t new_timeout); // установка таймаута между кликами (по умолчанию 500 мс)
void setStepTimeout(uint16_t step_timeout); // установка таймаута между инкрементами (по умолчанию 400 мс)
void setType(bool type); // установка типа кнопки (HIGH_PULL - подтянута к питанию, LOW_PULL - к gnd)
void setDirection(bool dir); // установка направления (разомкнута/замкнута по умолчанию - NORM_OPEN, NORM_CLOSE)
void setTickMode(bool tickMode); // (MANUAL / AUTO) ручной или автоматический опрос кнопки функцией tick()
// MANUAL - нужно вызывать функцию tick() вручную
// AUTO - tick() входит во все остальные функции и опрашивается сама
void tick(); // опрос кнопки
void tick(boolean state); // опрос внешнего значения (1 нажато, 0 не нажато) (для матричных, резистивных клавиатур и джойстиков)
boolean isPress(); // возвращает true при нажатии на кнопку. Сбрасывается после вызова
boolean isRelease(); // возвращает true при отпускании кнопки. Сбрасывается после вызова
boolean isClick(); // возвращает true при клике. Сбрасывается после вызова
boolean isHolded(); // возвращает true при удержании дольше timeout. Сбрасывается после вызова
boolean isHold(); // возвращает true при нажатой кнопке, не сбрасывается
boolean state(); // возвращает состояние кнопки
boolean isSingle(); // возвращает true при одиночном клике. Сбрасывается после вызова
boolean isDouble(); // возвращает true при двойном клике. Сбрасывается после вызова
boolean isTriple(); // возвращает true при тройном клике. Сбрасывается после вызова
boolean hasClicks(); // проверка на наличие кликов. Сбрасывается после вызова
uint8_t getClicks(); // вернуть количество кликов
uint8_t getHoldClicks();// вернуть количество кликов, предшествующее удерживанию
boolean isStep(byte clicks = 0); // возвращает true по таймеру setStepTimeout, смотри пример
void resetStates(); // сбрасывает все is-флаги и счётчики
private:
GyverButtonFlags flags;
uint8_t _PIN = 0;
uint16_t _debounce = 60;
uint16_t _timeout = 500;
uint16_t _click_timeout = 500;
uint16_t _step_timeout = 400;
uint8_t btn_counter = 0, last_counter = 0, last_hold_counter = 0;
uint32_t btn_timer = 0;
bool btn_state = false;
bool btn_flag = false;
#if defined(__AVR__)
volatile uint8_t *_pin_reg;
volatile uint8_t _bit_mask;
#endif
};
#endif