upd

Author: GyverLibs

README.md

@@ -208,6 +208,7 @@
 | getSteps        |     ✔      |       ✔       |   ✔    |     ✔     |
 | releaseHold     |     ✔      |       ✔       |   ✔    |     ✔     |
 | releaseStep     |     ✔      |       ✔       |   ✔    |     ✔     |
+| releaseHoldStep |     ✔      |       ✔       |   ✔    |     ✔     |
 | waiting         |     ✔      |       ✔       |   ✔    |     ✔     |
 | busy            |     ✔      |       ✔       |   ✔    |     ✔     |
 | action          |     ✔      |       ✔       |   ✔    |     ✔     |
@@ -334,6 +335,10 @@ bool releaseHold(uint8_t clicks);
 bool releaseStep();
 bool releaseStep(uint8_t clicks);
 
+// кнопка отпущена после удержания или импульсного удержания [событие]
+bool releaseHoldStep();
+bool releaseHoldStep(uint8_t clicks);
+
 // получить количество кликов
 uint8_t getClicks();
 
@@ -1767,6 +1772,7 @@ void loop() {
 - v3.5.3
   - Добавлено количество кликов в опрос press/release/click/pressing
 - v3.5.5 - коллбэк на базе std::function для ESP
+- v3.5.8 - добавлен метод releaseHoldStep()
     
 <a id="feedback"></a>
 ## Баги и обратная связь

keywords.txt

@@ -51,6 +51,7 @@ getClicks	KEYWORD2
 getSteps	KEYWORD2
 releaseHold	KEYWORD2
 releaseStep	KEYWORD2
+releaseHoldStep	KEYWORD2
 timeout	KEYWORD2
 waiting	KEYWORD2
 busy	KEYWORD2

library.properties

@@ -1,5 +1,5 @@
 name=EncButton
-version=3.5.7
+version=3.5.8
 author=AlexGyver <[email protected]>
 maintainer=AlexGyver <[email protected]>
 sentence=Light and powerful library for button and encoder operation for Arduino

src/core/VirtButton.h

@@ -76,35 +76,35 @@ class VirtButton {
    public:
     // ====================== SET ======================
     // установить таймаут удержания, умолч. 600 (макс. 4000 мс)
-    void setHoldTimeout(const uint16_t& tout) {
+    void setHoldTimeout(const uint16_t tout) {
 #ifndef EB_HOLD_TIME
         EB_HOLD_T = tout >> EB_SHIFT;
 #endif
     }
 
     // установить таймаут импульсного удержания, умолч. 200 (макс. 4000 мс)
-    void setStepTimeout(const uint16_t& tout) {
+    void setStepTimeout(const uint16_t tout) {
 #ifndef EB_STEP_TIME
         EB_STEP_T = tout >> EB_SHIFT;
 #endif
     }
 
     // установить таймаут ожидания кликов, умолч. 500 (макс. 4000 мс)
-    void setClickTimeout(const uint16_t& tout) {
+    void setClickTimeout(const uint16_t tout) {
 #ifndef EB_CLICK_TIME
         EB_CLICK_T = tout >> EB_SHIFT;
 #endif
     }
 
     // установить таймаут антидребезга, умолч. 50 (макс. 255 мс)
-    void setDebTimeout(const uint8_t& tout) {
+    void setDebTimeout(const uint8_t tout) {
 #ifndef EB_DEB_TIME
         EB_DEB_T = tout;
 #endif
     }
 
     // установить уровень кнопки (HIGH - кнопка замыкает VCC, LOW - замыкает GND)
-    void setBtnLevel(const bool& level) {
+    void setBtnLevel(const bool level) {
         bf.write(EB_INV, !level);
     }
 
@@ -149,7 +149,7 @@ class VirtButton {
     }
 
     // кнопка нажата с предварительными кликами [событие]
-    bool press(const uint8_t& num) {
+    bool press(const uint8_t num) {
         return (clicks == num) && press();
     }
 
@@ -159,7 +159,7 @@ class VirtButton {
     }
 
     // кнопка отпущена (в любом случае) с предварительными кликами [событие]
-    bool release(const uint8_t& num) {
+    bool release(const uint8_t num) {
         return (clicks == num) && release();
     }
 
@@ -169,7 +169,7 @@ class VirtButton {
     }
 
     // клик по кнопке (отпущена без удержания) с предварительными кликами [событие]
-    bool click(const uint8_t& num) {
+    bool click(const uint8_t num) {
         return (clicks == num) && click();
     }
 
@@ -179,7 +179,7 @@ class VirtButton {
     }
 
     // кнопка зажата (между press() и release()) с предварительными кликами [состояние]
-    bool pressing(const uint8_t& num) {
+    bool pressing(const uint8_t num) {
         return (clicks == num) && pressing();
     }
 
@@ -189,7 +189,7 @@ class VirtButton {
     }
 
     // кнопка была удержана (больше таймаута) с предварительными кликами [событие]
-    bool hold(const uint8_t& num) {
+    bool hold(const uint8_t num) {
         return (clicks == num) && hold();
     }
 
@@ -199,7 +199,7 @@ class VirtButton {
     }
 
     // кнопка удерживается (больше таймаута) с предварительными кликами [состояние]
-    bool holding(const uint8_t& num) {
+    bool holding(const uint8_t num) {
         return (clicks == num) && holding();
     }
 
@@ -209,7 +209,7 @@ class VirtButton {
     }
 
     // импульсное удержание с предварительными кликами [событие]
-    bool step(const uint8_t& num) {
+    bool step(const uint8_t num) {
         return (clicks == num) && step();
     }
 
@@ -219,7 +219,7 @@ class VirtButton {
     }
 
     // зафиксировано указанное количество кликов [событие]
-    bool hasClicks(const uint8_t& num) {
+    bool hasClicks(const uint8_t num) {
         return (clicks == num) && hasClicks();
     }
 
@@ -246,7 +246,7 @@ class VirtButton {
     }
 
     // кнопка отпущена после удержания с предварительными кликами [событие]
-    bool releaseHold(const uint8_t& num) {
+    bool releaseHold(const uint8_t num) {
         return clicks == num && bf.eq(EB_CLKS_R | EB_HLD | EB_STP, EB_CLKS_R | EB_HLD);
     }
 
@@ -256,10 +256,20 @@ class VirtButton {
     }
 
     // кнопка отпущена после импульсного удержания с предварительными кликами [событие]
-    bool releaseStep(const uint8_t& num) {
+    bool releaseStep(const uint8_t num) {
         return clicks == num && bf.eq(EB_CLKS_R | EB_STP, EB_CLKS_R | EB_STP);
     }
 
+    // кнопка отпущена после удержания или импульсного удержания [событие]
+    bool releaseHoldStep() {
+        return releaseHold() || releaseStep();
+    }
+
+    // кнопка отпущена после удержания или импульсного удержания с предварительными кликами [событие]
+    bool releaseHoldStep(const uint8_t num) {
+        return releaseHold(num) || releaseStep(num);
+    }
+
     // кнопка ожидает повторных кликов [состояние]
     bool waiting() {
         return clicks && bf.eq(EB_PRS | EB_REL, 0);
@@ -301,7 +311,7 @@ class VirtButton {
 
     // ====================== TIME ======================
     // после взаимодействия с кнопкой (или энкодером EncButton) прошло указанное время, мс [событие]
-    bool timeout(const uint16_t& tout) {
+    bool timeout(const uint16_t tout) {
         if (bf.read(EB_TOUT) && (uint16_t)((uint16_t)EB_uptime() - tmr) > tout) {
             bf.clear(EB_TOUT);
             return 1;
@@ -318,7 +328,7 @@ class VirtButton {
     }
 
     // кнопка удерживается дольше чем (с начала нажатия), мс [состояние]
-    bool pressFor(const uint16_t& ms) {
+    bool pressFor(const uint16_t ms) {
         return pressFor() > ms;
     }
 
@@ -337,7 +347,7 @@ class VirtButton {
     }
 
     // кнопка удерживается дольше чем (с начала удержания), мс [состояние]
-    bool holdFor(const uint16_t& ms) {
+    bool holdFor(const uint16_t ms) {
         return holdFor() > ms;
     }
 
@@ -387,7 +397,7 @@ class VirtButton {
     }
 
     // обработка кнопки без сброса событий и вызова коллбэка
-    bool tickRaw(const bool& s) {
+    bool tickRaw(const bool s) {
         return pollBtn(s);
     }
 

src/core/VirtEncButton.h

@@ -14,7 +14,7 @@ class VirtEncButton : public VirtButton, public VirtEncoder {
    public:
     // ====================== SET ======================
     // установить таймаут быстрого поворота, мс
-    void setFastTimeout(const uint8_t& tout) {
+    void setFastTimeout(const uint8_t tout) {
 #ifndef EB_FAST_TIME
         EB_FAST_T = tout;
 #endif
@@ -71,7 +71,7 @@ class VirtEncButton : public VirtButton, public VirtEncoder {
     // ====================== POLL ======================
     // ISR
     // обработка в прерывании (только энкодер). Вернёт 0 в покое, 1 или -1 при повороте
-    int8_t tickISR(const bool& e0, const bool& e1) {
+    int8_t tickISR(const bool e0, const bool e1) {
         return tickISR(e0 | (e1 << 1));
     }
 
@@ -99,12 +99,12 @@ class VirtEncButton : public VirtButton, public VirtEncoder {
 
     // TICK
     // обработка энкодера и кнопки
-    bool tick(const bool& e0, const bool& e1, const bool& btn) {
+    bool tick(const bool e0, const bool e1, const bool btn) {
         return tick(e0 | (e1 << 1), btn);
     }
 
     // обработка энкодера и кнопки. state = -1 для пропуска обработки энкодера
-    bool tick(const int8_t& state, const bool& btn) {
+    bool tick(const int8_t state, const bool btn) {
         clear();
         bool f = tickRaw(state, btn);
 
@@ -115,13 +115,13 @@ class VirtEncButton : public VirtButton, public VirtEncoder {
     }
 
     // обработка энкодера (в прерывании) и кнопки
-    bool tick(const bool& btn) {
+    bool tick(const bool btn) {
         return tick(-1, btn);
     }
 
     // RAW
     // обработка без сброса событий и вызова коллбэка
-    bool tickRaw(const bool& e0, const bool& e1, const bool& btn) {
+    bool tickRaw(const bool e0, const bool e1, const bool btn) {
         return tickRaw(e0 | (e1 << 1), btn);
     }
 
@@ -158,7 +158,7 @@ class VirtEncButton : public VirtButton, public VirtEncoder {
     }
 
     // обработка без сброса событий и вызова коллбэка (кнопка)
-    bool tickRaw(const bool& btn) {
+    bool tickRaw(const bool btn) {
         return tickRaw(-1, btn);
     }
 

src/core/VirtEncoder.h

@@ -27,28 +27,28 @@ class VirtEncoder {
     }
     // ====================== SET ======================
     // инвертировать направление энкодера
-    void setEncReverse(const bool& rev) {
+    void setEncReverse(const bool rev) {
         if (rev) ef.set(EB_REV);
         else ef.clear(EB_REV);
     }
 
     // установить тип энкодера (EB_STEP4_LOW, EB_STEP4_HIGH, EB_STEP2, EB_STEP1)
-    void setEncType(const uint8_t& type) {
+    void setEncType(const uint8_t type) {
         ef.flags = (ef.flags & 0b11111100) | type;
     }
 
     // использовать обработку энкодера в прерывании
-    void setEncISR(const bool& use) {
+    void setEncISR(const bool use) {
         ef.write(EB_EISR, use);
     }
 
     // инициализация энкодера
-    void initEnc(const bool& e0, const bool& e1) {
+    void initEnc(const bool e0, const bool e1) {
         initEnc(e0 | (e1 << 1));
     }
 
     // инициализация энкодера совмещённым значением
-    void initEnc(const int8_t& v) {
+    void initEnc(const int8_t v) {
         prev = v;
     }
 
@@ -71,7 +71,7 @@ class VirtEncoder {
     // ====================== POLL ======================
     // ISR
     // опросить энкодер в прерывании. Вернёт 1 или -1 при вращении, 0 при остановке
-    int8_t tickISR(const bool& e0, const bool& e1) {
+    int8_t tickISR(const bool e0, const bool e1) {
         return tickISR(e0 | (e1 << 1));
     }
 
@@ -87,7 +87,7 @@ class VirtEncoder {
 
     // TICK
     // опросить энкодер. Вернёт 1 или -1 при вращении, 0 при остановке
-    int8_t tick(const bool& e0, const bool& e1) {
+    int8_t tick(const bool e0, const bool e1) {
         return tick(e0 | (e1 << 1));
     }
 
@@ -106,7 +106,7 @@ class VirtEncoder {
 
     // RAW
     // опросить энкодер без сброса события поворота
-    int8_t tickRaw(const bool& e0, const bool& e1) {
+    int8_t tickRaw(const bool e0, const bool e1) {
         return tickRaw(e0 | (e1 << 1));
     }
 
@@ -132,7 +132,7 @@ class VirtEncoder {
 
     // POLL
     // опросить энкодер без установки события поворота (быстрее). Вернёт 1 или -1 при вращении, 0 при остановке
-    int8_t pollEnc(const bool& e0, const bool& e1) {
+    int8_t pollEnc(const bool e0, const bool e1) {
         return pollEnc(e0 | (e1 << 1));
     }
 

src/core/flags.h

@@ -7,23 +7,23 @@ template <typename T>
 struct Flags {
     T flags = 0;
 
-    inline T mask(const T& x) __attribute__((always_inline)) {
+    inline T mask(const T x) __attribute__((always_inline)) {
         return flags & x;
     }
-    inline void set(const T& x) __attribute__((always_inline)) {
+    inline void set(const T x) __attribute__((always_inline)) {
         flags |= x;
     }
-    inline void clear(const T& x) __attribute__((always_inline)) {
+    inline void clear(const T x) __attribute__((always_inline)) {
         flags &= ~x;
     }
-    inline bool read(const T& x) __attribute__((always_inline)) {
+    inline bool read(const T x) __attribute__((always_inline)) {
         return flags & x;
     }
-    inline void write(const T& x, const bool& v) __attribute__((always_inline)) {
+    inline void write(const T x, const bool v) __attribute__((always_inline)) {
         if (v) set(x);
         else clear(x);
     }
-    inline bool eq(const T& x, const T& y) __attribute__((always_inline)) {
+    inline bool eq(const T x, const T y) __attribute__((always_inline)) {
         return (flags & x) == y;
     }
 };