upd

GyverLibs · GyverLibs · commit 147009a2d0bc · 2024-01-25T13:41:41.000+03:00
diff --git a/README.md b/README.md
@@ -128,8 +128,6 @@
 Объявлять до подключения библиотеки
 
 ```cpp
-// отключить привязку к библиотеке GyverIO и использовать стандартный digitalRead
-#define EB_NO_GYVER_IO
 
 // отключить поддержку pressFor/holdFor/stepFor и счётчик степов (экономит 2 байта оперативки)
 #define EB_NO_FOR
@@ -143,10 +141,6 @@
 // отключить буферизацию энкодера (экономит 2 байта оперативки)
 #define EB_NO_BUFFER
 
-// кастомные функции
-#define EB_CUSTOM_READ      // использовать своё чтение пина
-#define EB_CUSTOM_UPTIME  // использовать свой таймер
-
 /*
   Настройка таймаутов для всех классов
   - Заменяет таймауты константами, изменить их из программы (SetXxxTimeout()) будет нельзя
@@ -1214,23 +1208,14 @@ void loop() {
 <a id="custom"></a>
 
 ### Кастомные функции
-Библиотека поддерживает задание своих функций для чтения пина и получения времени без редактирования файлов библиотеки. Для этого нужно:
-- Объявить соответствующий дефайн перед подключением библиотеки
-  - `EB_CUSTOM_READ` - для своей функции чтения пина
-  - `EB_CUSTOM_UPTIME` - для своего аналога millis()
-  - `EB_CUSTOM_MODE` - для своего аналога pinMode()
-- Реализовать соответствующую функцию в .cpp или .ino файле
-  - `EB_read` - для своей функции чтения пина
-  - `EB_uptime` - для своего аналога millis()
-  - `EB_mode` - для своего аналога pinMode
+Библиотека поддерживает задание своих функций для чтения пина и получения времени без редактирования файлов библиотеки. Для этого нужно реализовать соответствующую функцию в своём .cpp или .ino файле:
+- `bool EB_read(uint8_t pin)` - для своей функции чтения пина
+- `void EB_mode(uint8_t pin, uint8_t mode)` - для своего аналога pinMode
+- `uint32_t EB_uptime()` - для своего аналога millis()
 
 Пример:
 
 ```cpp
-#define EB_CUSTOM_READ
-#define EB_CUSTOM_MODE
-#define EB_CUSTOM_UPTIME
-
 #include <EncButton.h>
 
 bool EB_read(uint8_t pin) {
@@ -1780,6 +1765,10 @@ void loop() {
 - v3.5 
   - Добавлена зависимость GyverIO (ускорен опрос пинов)
   - Добавлена возможность задать свои функции аптайма и чтения пина
+- v3.5.2 
+  - Оптимизация
+  - Упрощена замена кастомных функций
+  - Исправлена ошибка компиляции при использовании библиотеки в нескольких .cpp файлах
     
 <a id="feedback"></a>
 ## Баги и обратная связь
diff --git a/keywords.txt b/keywords.txt
@@ -24,11 +24,6 @@ EB_HOLD_TIME	KEYWORD1
 EB_STEP_TIME	KEYWORD1
 EB_FAST_TIME	KEYWORD1
 
-EB_NO_GYVER_IO	KEYWORD1
-EB_CUSTOM_READ	KEYWORD1
-EB_CUSTOM_MODE	KEYWORD1
-EB_CUSTOM_UPTIME	KEYWORD1
-
 #######################################
 # Methods and Functions (KEYWORD2)
 #######################################
diff --git a/library.properties b/library.properties
@@ -1,5 +1,5 @@
 name=EncButton
-version=3.5.1
+version=3.5.2
 author=AlexGyver <alex@alexgyver.ru>
 maintainer=AlexGyver <alex@alexgyver.ru>
 sentence=Light and powerful library for button and encoder operation for Arduino
diff --git a/src/core/Button.h b/src/core/Button.h
@@ -2,7 +2,7 @@
 #include <Arduino.h>
 
 #include "VirtButton.h"
-#include "utils.h"
+#include "io.h"
 
 // ============= VAR PIN =============
 class Button : public VirtButton {
diff --git a/src/core/EncButton.h b/src/core/EncButton.h
@@ -2,7 +2,7 @@
 #include <Arduino.h>
 
 #include "VirtEncButton.h"
-#include "utils.h"
+#include "io.h"
 
 // ===================== CLASS =====================
 class EncButton : public VirtEncButton {
diff --git a/src/core/Encoder.h b/src/core/Encoder.h
@@ -2,7 +2,7 @@
 #include <Arduino.h>
 
 #include "VirtEncoder.h"
-#include "utils.h"
+#include "io.h"
 
 // ============= VAR PIN =============
 class Encoder : public VirtEncoder {
diff --git a/src/core/VirtButton.h b/src/core/VirtButton.h
@@ -1,7 +1,7 @@
 #pragma once
 #include <Arduino.h>
 
-#include "utils.h"
+#include "io.h"
 
 // ===================== FLAGS ======================
 #define EB_PRESS (1 << 0)        // нажатие на кнопку
@@ -67,35 +67,35 @@ class VirtButton {
    public:
     // ====================== SET ======================
     // установить таймаут удержания, умолч. 600 (макс. 4000 мс)
-    void setHoldTimeout(uint16_t tout) {
+    void setHoldTimeout(const uint16_t& tout) {
 #ifndef EB_HOLD_TIME
         EB_HOLD_T = tout >> EB_SHIFT;
 #endif
     }
 
     // установить таймаут импульсного удержания, умолч. 200 (макс. 4000 мс)
-    void setStepTimeout(uint16_t tout) {
+    void setStepTimeout(const uint16_t& tout) {
 #ifndef EB_STEP_TIME
         EB_STEP_T = tout >> EB_SHIFT;
 #endif
     }
 
     // установить таймаут ожидания кликов, умолч. 500 (макс. 4000 мс)
-    void setClickTimeout(uint16_t tout) {
+    void setClickTimeout(const uint16_t& tout) {
 #ifndef EB_CLICK_TIME
         EB_CLICK_T = tout >> EB_SHIFT;
 #endif
     }
 
     // установить таймаут антидребезга, умолч. 50 (макс. 255 мс)
-    void setDebTimeout(uint8_t tout) {
+    void setDebTimeout(const uint8_t& tout) {
 #ifndef EB_DEB_TIME
         EB_DEB_T = tout;
 #endif
     }
 
     // установить уровень кнопки (HIGH - кнопка замыкает VCC, LOW - замыкает GND)
-    void setBtnLevel(bool level) {
+    void setBtnLevel(const bool& level) {
         write_bf(EB_INV, !level);
     }
 
@@ -160,7 +160,7 @@ class VirtButton {
     }
 
     // кнопка была удержана (больше таймаута) с предварительными кликами [событие]
-    bool hold(uint8_t num) {
+    bool hold(const uint8_t& num) {
         return clicks == num && hold();
     }
 
@@ -170,7 +170,7 @@ class VirtButton {
     }
 
     // кнопка удерживается (больше таймаута) с предварительными кликами [состояние]
-    bool holding(uint8_t num) {
+    bool holding(const uint8_t& num) {
         return clicks == num && holding();
     }
 
@@ -180,7 +180,7 @@ class VirtButton {
     }
 
     // импульсное удержание с предварительными кликами [событие]
-    bool step(uint8_t num) {
+    bool step(const uint8_t& num) {
         return clicks == num && step();
     }
 
@@ -190,7 +190,7 @@ class VirtButton {
     }
 
     // зафиксировано указанное количество кликов [событие]
-    bool hasClicks(uint8_t num) {
+    bool hasClicks(const uint8_t& num) {
         return clicks == num && hasClicks();
     }
 
@@ -217,7 +217,7 @@ class VirtButton {
     }
 
     // кнопка отпущена после удержания с предварительными кликами [событие]
-    bool releaseHold(uint8_t num) {
+    bool releaseHold(const uint8_t& num) {
         return clicks == num && eq_bf(EB_CLKS_R | EB_HLD | EB_STP, EB_CLKS_R | EB_HLD);
     }
 
@@ -227,7 +227,7 @@ class VirtButton {
     }
 
     // кнопка отпущена после импульсного удержания с предварительными кликами [событие]
-    bool releaseStep(uint8_t num) {
+    bool releaseStep(const uint8_t& num) {
         return clicks == num && eq_bf(EB_CLKS_R | EB_STP, EB_CLKS_R | EB_STP);
     }
 
@@ -272,7 +272,7 @@ class VirtButton {
 
     // ====================== TIME ======================
     // после взаимодействия с кнопкой (или энкодером EncButton) прошло указанное время, мс [событие]
-    bool timeout(uint16_t tout) {
+    bool timeout(const uint16_t& tout) {
         if (read_bf(EB_TOUT) && (uint16_t)((uint16_t)EB_uptime() - tmr) > tout) {
             clr_bf(EB_TOUT);
             return 1;
@@ -289,7 +289,7 @@ class VirtButton {
     }
 
     // кнопка удерживается дольше чем (с начала нажатия), мс [состояние]
-    bool pressFor(uint16_t ms) {
+    bool pressFor(const uint16_t& ms) {
         return pressFor() > ms;
     }
 
@@ -308,7 +308,7 @@ class VirtButton {
     }
 
     // кнопка удерживается дольше чем (с начала удержания), мс [состояние]
-    bool holdFor(uint16_t ms) {
+    bool holdFor(const uint16_t& ms) {
         return holdFor() > ms;
     }
 
@@ -358,7 +358,7 @@ class VirtButton {
     }
 
     // обработка кнопки без сброса событий и вызова коллбэка
-    bool tickRaw(bool s) {
+    bool tickRaw(const bool& s) {
         return pollBtn(s);
     }
 
@@ -480,20 +480,20 @@ class VirtButton {
     uint8_t EB_STEP_T = (200 >> EB_SHIFT);
 #endif
 
-    inline void set_bf(const uint16_t x) __attribute__((always_inline)) {
+    inline void set_bf(const uint16_t& x) __attribute__((always_inline)) {
         flags |= x;
     }
-    inline void clr_bf(const uint16_t x) __attribute__((always_inline)) {
+    inline void clr_bf(const uint16_t& x) __attribute__((always_inline)) {
         flags &= ~x;
     }
-    inline bool read_bf(const uint16_t x) __attribute__((always_inline)) {
+    inline bool read_bf(const uint16_t& x) __attribute__((always_inline)) {
         return flags & x;
     }
-    inline void write_bf(const uint16_t x, bool v) __attribute__((always_inline)) {
+    inline void write_bf(const uint16_t& x, const bool& v) __attribute__((always_inline)) {
         if (v) set_bf(x);
         else clr_bf(x);
     }
-    inline bool eq_bf(const uint16_t x, const uint16_t y) __attribute__((always_inline)) {
+    inline bool eq_bf(const uint16_t& x, const uint16_t& y) __attribute__((always_inline)) {
         return (flags & x) == y;
     }
 
diff --git a/src/core/VirtEncButton.h b/src/core/VirtEncButton.h
@@ -3,7 +3,7 @@
 
 #include "VirtButton.h"
 #include "VirtEncoder.h"
-#include "utils.h"
+#include "io.h"
 
 #ifdef EB_FAST_TIME
 #define EB_FAST_T (EB_FAST_TIME)
@@ -14,7 +14,7 @@ class VirtEncButton : public VirtButton, public VirtEncoder {
    public:
     // ====================== SET ======================
     // установить таймаут быстрого поворота, мс
-    void setFastTimeout(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(bool e0, 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(bool e0, bool e1, bool btn) {
+    bool tick(const bool& e0, const bool& e1, const bool& btn) {
         return tick(e0 | (e1 << 1), btn);
     }
 
     // обработка энкодера и кнопки. state = -1 для пропуска обработки энкодера
-    bool tick(int8_t state, 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(bool btn) {
+    bool tick(const bool& btn) {
         return tick(-1, btn);
     }
 
     // RAW
     // обработка без сброса событий и вызова коллбэка
-    bool tickRaw(bool e0, bool e1, 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(bool btn) {
+    bool tickRaw(const bool& btn) {
         return tickRaw(-1, btn);
     }
 
diff --git a/src/core/VirtEncoder.h b/src/core/VirtEncoder.h
diff --git a/src/core/io.cpp b/src/core/io.cpp
diff --git a/src/core/io.h b/src/core/io.h
diff --git a/src/core/utils.h b/src/core/utils.h

-Original file line number
+Diff line change
@@ @@ -1,5 +1,5 @@ @@
 name=EncButton
 -version=3.5.1
 +version=3.5.2
 author=AlexGyver <[email protected]>
 maintainer=AlexGyver <[email protected]>
 sentence=Light and powerful library for button and encoder operation for Arduino
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`#pragma once`
`2`	`2`	`#include <Arduino.h>`
`3`	`3`
`4`		`-#include "utils.h"`
	`4`	`+#include "io.h"`
`5`	`5`
`6`	`6`	`// ===================== FLAGS ======================`
`7`	`7`	`#define EB_PRESS (1 << 0) // нажатие на кнопку`
`@@ -67,35 +67,35 @@ class VirtButton {`
`67`	`67`	`public:`
`68`	`68`	`// ====================== SET ======================`
`69`	`69`	`// установить таймаут удержания, умолч. 600 (макс. 4000 мс)`
`70`		`- void setHoldTimeout(uint16_t tout) {`
	`70`	`+ void setHoldTimeout(const uint16_t& tout) {`
`71`	`71`	`#ifndef EB_HOLD_TIME`
`72`	`72`	`EB_HOLD_T = tout >> EB_SHIFT;`
`73`	`73`	`#endif`
`74`	`74`	`}`
`75`	`75`
`76`	`76`	`// установить таймаут импульсного удержания, умолч. 200 (макс. 4000 мс)`
`77`		`- void setStepTimeout(uint16_t tout) {`
	`77`	`+ void setStepTimeout(const uint16_t& tout) {`
`78`	`78`	`#ifndef EB_STEP_TIME`
`79`	`79`	`EB_STEP_T = tout >> EB_SHIFT;`
`80`	`80`	`#endif`
`81`	`81`	`}`
`82`	`82`
`83`	`83`	`// установить таймаут ожидания кликов, умолч. 500 (макс. 4000 мс)`
`84`		`- void setClickTimeout(uint16_t tout) {`
	`84`	`+ void setClickTimeout(const uint16_t& tout) {`
`85`	`85`	`#ifndef EB_CLICK_TIME`
`86`	`86`	`EB_CLICK_T = tout >> EB_SHIFT;`
`87`	`87`	`#endif`
`88`	`88`	`}`
`89`	`89`
`90`	`90`	`// установить таймаут антидребезга, умолч. 50 (макс. 255 мс)`
`91`		`- void setDebTimeout(uint8_t tout) {`
	`91`	`+ void setDebTimeout(const uint8_t& tout) {`
`92`	`92`	`#ifndef EB_DEB_TIME`
`93`	`93`	`EB_DEB_T = tout;`
`94`	`94`	`#endif`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`// установить уровень кнопки (HIGH - кнопка замыкает VCC, LOW - замыкает GND)`
`98`		`- void setBtnLevel(bool level) {`
	`98`	`+ void setBtnLevel(const bool& level) {`
`99`	`99`	`write_bf(EB_INV, !level);`
`100`	`100`	`}`
`101`	`101`
`@@ -160,7 +160,7 @@ class VirtButton {`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`// кнопка была удержана (больше таймаута) с предварительными кликами [событие]`
`163`		`- bool hold(uint8_t num) {`
	`163`	`+ bool hold(const uint8_t& num) {`
`164`	`164`	`return clicks == num && hold();`
`165`	`165`	`}`
`166`	`166`
`@@ -170,7 +170,7 @@ class VirtButton {`
`170`	`170`	`}`
`171`	`171`
`172`	`172`	`// кнопка удерживается (больше таймаута) с предварительными кликами [состояние]`
`173`		`- bool holding(uint8_t num) {`
	`173`	`+ bool holding(const uint8_t& num) {`
`174`	`174`	`return clicks == num && holding();`
`175`	`175`	`}`
`176`	`176`
`@@ -180,7 +180,7 @@ class VirtButton {`
`180`	`180`	`}`
`181`	`181`
`182`	`182`	`// импульсное удержание с предварительными кликами [событие]`
`183`		`- bool step(uint8_t num) {`
	`183`	`+ bool step(const uint8_t& num) {`
`184`	`184`	`return clicks == num && step();`
`185`	`185`	`}`
`186`	`186`
`@@ -190,7 +190,7 @@ class VirtButton {`
`190`	`190`	`}`
`191`	`191`
`192`	`192`	`// зафиксировано указанное количество кликов [событие]`
`193`		`- bool hasClicks(uint8_t num) {`
	`193`	`+ bool hasClicks(const uint8_t& num) {`
`194`	`194`	`return clicks == num && hasClicks();`
`195`	`195`	`}`
`196`	`196`
`@@ -217,7 +217,7 @@ class VirtButton {`
`217`	`217`	`}`
`218`	`218`
`219`	`219`	`// кнопка отпущена после удержания с предварительными кликами [событие]`
`220`		`- bool releaseHold(uint8_t num) {`
	`220`	`+ bool releaseHold(const uint8_t& num) {`
`221`	`221`	`return clicks == num && eq_bf(EB_CLKS_R \| EB_HLD \| EB_STP, EB_CLKS_R \| EB_HLD);`
`222`	`222`	`}`
`223`	`223`
`@@ -227,7 +227,7 @@ class VirtButton {`
`227`	`227`	`}`
`228`	`228`
`229`	`229`	`// кнопка отпущена после импульсного удержания с предварительными кликами [событие]`
`230`		`- bool releaseStep(uint8_t num) {`
	`230`	`+ bool releaseStep(const uint8_t& num) {`
`231`	`231`	`return clicks == num && eq_bf(EB_CLKS_R \| EB_STP, EB_CLKS_R \| EB_STP);`
`232`	`232`	`}`
`233`	`233`
`@@ -272,7 +272,7 @@ class VirtButton {`
`272`	`272`
`273`	`273`	`// ====================== TIME ======================`
`274`	`274`	`// после взаимодействия с кнопкой (или энкодером EncButton) прошло указанное время, мс [событие]`
`275`		`- bool timeout(uint16_t tout) {`
	`275`	`+ bool timeout(const uint16_t& tout) {`
`276`	`276`	`if (read_bf(EB_TOUT) && (uint16_t)((uint16_t)EB_uptime() - tmr) > tout) {`
`277`	`277`	`clr_bf(EB_TOUT);`
`278`	`278`	`return 1;`
`@@ -289,7 +289,7 @@ class VirtButton {`
`289`	`289`	`}`
`290`	`290`
`291`	`291`	`// кнопка удерживается дольше чем (с начала нажатия), мс [состояние]`
`292`		`- bool pressFor(uint16_t ms) {`
	`292`	`+ bool pressFor(const uint16_t& ms) {`
`293`	`293`	`return pressFor() > ms;`
`294`	`294`	`}`
`295`	`295`
`@@ -308,7 +308,7 @@ class VirtButton {`
`308`	`308`	`}`
`309`	`309`
`310`	`310`	`// кнопка удерживается дольше чем (с начала удержания), мс [состояние]`
`311`		`- bool holdFor(uint16_t ms) {`
	`311`	`+ bool holdFor(const uint16_t& ms) {`
`312`	`312`	`return holdFor() > ms;`
`313`	`313`	`}`
`314`	`314`
`@@ -358,7 +358,7 @@ class VirtButton {`
`358`	`358`	`}`
`359`	`359`
`360`	`360`	`// обработка кнопки без сброса событий и вызова коллбэка`
`361`		`- bool tickRaw(bool s) {`
	`361`	`+ bool tickRaw(const bool& s) {`
`362`	`362`	`return pollBtn(s);`
`363`	`363`	`}`
`364`	`364`
`@@ -480,20 +480,20 @@ class VirtButton {`
`480`	`480`	`uint8_t EB_STEP_T = (200 >> EB_SHIFT);`
`481`	`481`	`#endif`
`482`	`482`
`483`		`- inline void set_bf(const uint16_t x) __attribute__((always_inline)) {`
	`483`	`+ inline void set_bf(const uint16_t& x) __attribute__((always_inline)) {`
`484`	`484`	`flags \|= x;`
`485`	`485`	`}`
`486`		`- inline void clr_bf(const uint16_t x) __attribute__((always_inline)) {`
	`486`	`+ inline void clr_bf(const uint16_t& x) __attribute__((always_inline)) {`
`487`	`487`	`flags &= ~x;`
`488`	`488`	`}`
`489`		`- inline bool read_bf(const uint16_t x) __attribute__((always_inline)) {`
	`489`	`+ inline bool read_bf(const uint16_t& x) __attribute__((always_inline)) {`
`490`	`490`	`return flags & x;`
`491`	`491`	`}`
`492`		`- inline void write_bf(const uint16_t x, bool v) __attribute__((always_inline)) {`
	`492`	`+ inline void write_bf(const uint16_t& x, const bool& v) __attribute__((always_inline)) {`
`493`	`493`	`if (v) set_bf(x);`
`494`	`494`	`else clr_bf(x);`
`495`	`495`	`}`
`496`		`- inline bool eq_bf(const uint16_t x, const uint16_t y) __attribute__((always_inline)) {`
	`496`	`+ inline bool eq_bf(const uint16_t& x, const uint16_t& y) __attribute__((always_inline)) {`
`497`	`497`	`return (flags & x) == y;`
`498`	`498`	`}`
`499`	`499`