upd

GyverLibs · Jan 25, 2024 · 147009a · 147009a
1 parent a398ba6
commit 147009a
Show file tree

Hide file tree

Showing 12 changed files with 75 additions and 105 deletions.
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 <[email protected]>
 maintainer=AlexGyver <[email protected]>
 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);
     }