upd

GyverLibs · GyverLibs · commit 386c364c4a60 · 2025-01-27T12:46:12.000+03:00
diff --git a/docs/0.main.md b/docs/0.main.md
@@ -196,6 +196,9 @@ bool isTimer();
 // задача - тикер
 bool isTicker();
 
+// задача - поток
+bool isThread();
+
 // задача - обработчик событий
 bool isListener();
 ```
@@ -344,11 +347,12 @@ T* getData();
 ```
 
 ### LoopThread
-Тикер, наследует `LoopTicker`
+Поток, наследует `LoopTask`
+
 ```cpp
-LoopThread(TaskCallback callback, bool states = true, bool events = true);
-LoopThread(const char* id, TaskCallback callback, bool states = true, bool events = true);
-LoopThread(hash_t id, TaskCallback callback, bool states = true, bool events = true);
+LoopThread(TaskCallback callback);
+LoopThread(const char* id, TaskCallback callback);
+LoopThread(hash_t id, TaskCallback callback);
 ```
 
 ### LoopThreadData<T>
diff --git a/docs/2.threads.md b/docs/2.threads.md
@@ -102,6 +102,8 @@ LP_THREAD({
 });
 ```
 
+> Примечание: оставшееся время до продолжения выполнения учитывается в `Looper.nextTimerLeft()`, как и у задач-таймеров
+
 ### Ожидание условия
 Поток также может асинхронно ждать наступления указанного условия, например:
 
diff --git a/library.properties b/library.properties
@@ -1,5 +1,5 @@
 name=Looper
-version=1.1.5
+version=1.1.6
 author=AlexGyver <alex@alexgyver.ru>
 maintainer=AlexGyver <alex@alexgyver.ru>
 sentence=Simple task, thread and event manager for Arduino
diff --git a/src/Looper.h b/src/Looper.h
@@ -5,103 +5,4 @@
 #include "nodes/Thread.h"
 #include "nodes/Ticker.h"
 #include "nodes/Timer.h"
-
-// ========= macro =========
-// широковещательное событие
-#define LP_BROADCAST (hash_t)0
-
-// отправить событие
-#define LP_SEND_EVENT(id, data) Looper.sendEvent(LPH(id), data)
-
-// отложить отправку события
-#define LP_PUSH_EVENT(id, data) Looper.pushEvent(LPH(id), data)
-
-#define LP_MAKE(type, ...) static type _LP_CONCAT(__loop_obj_, __COUNTER__)(__VA_ARGS__)
-#define LP_MAKE_(id, type, ...) static type _LP_CONCAT(__loop_obj_, __COUNTER__)(LPH(id), __VA_ARGS__)
-#define LP_NEW(type, ...) new type(__VA_ARGS__)
-#define LP_NEW_(id, type, ...) new type(LPH(id), __VA_ARGS__)
-
-// LISTENER
-#define LP_LISTENER_(id, ...) LP_MAKE_(id, LoopListener, __VA_ARGS__)
-
-// TICKER
-#define LP_TICKER(...) LP_MAKE(LoopTicker, __VA_ARGS__)
-#define LP_TICKER_(id, ...) LP_MAKE_(id, LoopTicker, __VA_ARGS__)
-
-// TIMER
-#define LP_TIMER(ms, ...) LP_MAKE(LoopTimer, ms, __VA_ARGS__)
-#define LP_TIMER_(id, ms, ...) LP_MAKE_(id, LoopTimer, ms, __VA_ARGS__)
-
-// THREAD
-#define _LP_THREAD_CASE Looper.thisThread()->_case
-#define _LP_THREAD_RESET() _LP_THREAD_CASE = 0;
-
-// начать поток
-#define LP_THREAD_BEGIN()      \
-    switch (_LP_THREAD_CASE) { \
-        case 0:;
-
-// завершить поток
-#define LP_THREAD_END() \
-    }                   \
-    _LP_THREAD_RESET();
-
-#define _LP_THREAD_INNER(body) \
-    LP_THREAD_BEGIN();         \
-    body                       \
-    LP_THREAD_END();
-
-#define LP_THREAD(body) static LoopThread _LP_CONCAT(__loop_obj_, __COUNTER__)([]() { _LP_THREAD_INNER(body) })
-#define LP_THREAD_(id, body) static LoopThread _LP_CONCAT(__loop_obj_, __COUNTER__)(LPH(id), []() { _LP_THREAD_INNER(body) })
-#define LP_THREAD_DATA(T, data, data_arg, body) static LoopThreadData<T> _LP_CONCAT(__loop_obj_, __COUNTER__)(data, [](data_arg) { _LP_THREAD_INNER(body) })
-#define LP_THREAD_DATA_(id, T, data, data_arg, body) static LoopThreadData<T> _LP_CONCAT(__loop_obj_, __COUNTER__)(LPH(id), data, [](data_arg) { _LP_THREAD_INNER(body) })
-
-// перезапустить поток (начать выполнение с начала)
-#define LP_RESTART()        \
-    do {                    \
-        _LP_THREAD_RESET(); \
-        return;             \
-    } while (0);
-
-// выйти из потока и потом вернуться в эту точку
-#define LP_EXIT()                          \
-    do {                                   \
-        _LP_THREAD_CASE = __COUNTER__ + 1; \
-        return;                            \
-        case __COUNTER__:;                 \
-    } while (0);
-
-// асинхронно ждать условия
-#define LP_WAIT(cond)                      \
-    do {                                   \
-        _LP_THREAD_CASE = __COUNTER__ + 1; \
-        case __COUNTER__:                  \
-            if (!(cond)) return;           \
-    } while (0);
-
-// асинхронно ждать события
-#define LP_WAIT_EVENT() LP_WAIT(Looper.thisEvent());
-
-// асинхронно ждать время в мс
-#define LP_DELAY(ms)                                \
-    do {                                            \
-        Looper.thisThread()->_resetTmr();           \
-        LP_WAIT(Looper.thisThread()->_elapsed(ms)); \
-        Looper.thisThread()->_stopTmr();            \
-    } while (0);
-
-// устарело
-#define LP_SLEEP(ms) LP_DELAY(ms)
-
-// освободить семафор
-#define LP_SEM_SIGNAL(sem) sem++;
-
-// ждать семафор
-#define LP_SEM_WAIT(sem) \
-    do {                 \
-        LP_WAIT(sem);    \
-        sem--;           \
-    } while (0);
-
-// семафор
-typedef uint16_t LP_SEM;
+#include "nodes/macro.h"
diff --git a/src/LooperClass.cpp b/src/LooperClass.cpp
@@ -17,10 +17,12 @@ void LooperClass::loop() {
     while (_thisTask) {
         looper::yield();
         switch (_thisTask->_tickMask()) {
-            case (TASK_ENABLED_TICKER):
+            case TASK_ENABLED_THREAD:
+            case TASK_ENABLED_TICKER:
                 _thisTask->exec();
                 break;
-            case (TASK_ENABLED_TIMER):
+
+            case TASK_ENABLED_TIMER:
                 static_cast<LoopTimer*>(_thisTask)->poll();
                 break;
         }
@@ -49,11 +51,19 @@ void LooperClass::restart() {
 uint32_t LooperClass::nextTimerLeft() {
     uint32_t next = UINT32_MAX;
     LoopTask* p = _tasks.getLast();
+    uint32_t left = 0;
     while (p) {
-        if (p->_tickMask() == TASK_ENABLED_TIMER) {
-            uint32_t left = static_cast<LoopTimer*>(p)->left();
-            if (left < next) next = left;
+        switch (p->_tickMask()) {
+            case TASK_ENABLED_THREAD:
+                left = static_cast<LoopThread*>(p)->_tmr.left();
+                break;
+
+            case TASK_ENABLED_TIMER:
+                left = static_cast<LoopTimer*>(p)->left();
+                break;
         }
+        if (!left) return 0;
+        if (next > left) next = left;
         p = p->getPrev();
     }
     return next == UINT32_MAX ? 0 : next;
diff --git a/src/nodes/LoopTask.cpp b/src/nodes/LoopTask.cpp
@@ -69,11 +69,14 @@ bool LoopTask::isTicker() {
 bool LoopTask::isListener() {
     return sreg.read(TASK_IS_LISTENER);
 }
+bool LoopTask::isThread() {
+    return sreg.read(TASK_IS_THREAD);
+}
 
 bool LoopTask::canListen() {
     return sreg.isSet(TASK_ENABLED | TASK_HAS_EVENTS);
 }
 
 uint8_t LoopTask::_tickMask() {
-    return sreg.mask(TASK_ENABLED | TASK_IS_TICKER | TASK_IS_TIMER);
+    return sreg.mask(TASK_ENABLED | TASK_IS_TICKER | TASK_IS_TIMER | TASK_IS_THREAD);
 }
diff --git a/src/nodes/LoopTask.h b/src/nodes/LoopTask.h
@@ -12,11 +12,13 @@
 #define TASK_IS_LISTENER (1 << 1)
 #define TASK_IS_TICKER (1 << 2)
 #define TASK_IS_TIMER (1 << 3)
-#define TASK_HAS_EVENTS (1 << 4)
-#define TASK_HAS_STATES (1 << 5)
+#define TASK_IS_THREAD (1 << 4)
+#define TASK_HAS_EVENTS (1 << 5)
+#define TASK_HAS_STATES (1 << 6)
 
 #define TASK_ENABLED_TICKER (TASK_ENABLED | TASK_IS_TICKER)
 #define TASK_ENABLED_TIMER (TASK_ENABLED | TASK_IS_TIMER)
+#define TASK_ENABLED_THREAD (TASK_ENABLED | TASK_IS_THREAD)
 
 enum class tState : uint8_t {
     None,
@@ -99,6 +101,9 @@ class LoopTask : public looper::List<LoopTask>::Node {
 
     // задача - обработчик событий
     bool isListener();
+    
+    // задача - поток
+    bool isThread();
 
     // запущен и слушает события
     bool canListen();
diff --git a/src/nodes/Thread.h b/src/nodes/Thread.h
@@ -1,28 +1,19 @@
 #pragma once
-#include "Ticker.h"
+#include "../utils/SimpleTimer.h"
+#include "CallbackData.h"
+#include "LoopTask.h"
 
 // задача-поток, вызывается постоянно
-class LoopThread : public LoopTicker {
+class LoopThread : public LoopTask {
    public:
-    using LoopTicker::LoopTicker;
-
-    void _resetTmr() {
-        if (!_tmr) {
-            _tmr = looper::millis();
-            if (!_tmr) _tmr--;
-        }
-    }
-    void _stopTmr() {
-        _tmr = 0;
-    }
-    bool _elapsed(uint32_t ms) {
-        return looper::millis() - _tmr >= ms;
-    }
+    LoopThread(TaskCallback callback) : LoopThread((hash_t)0, callback) {}
+    LoopThread(const char* id, TaskCallback callback) : LoopThread(LPHr(id), callback) {}
+    LoopThread(hash_t id, TaskCallback callback) : LoopTask(id, callback, TASK_IS_THREAD, true, true) {}
 
     uint16_t _case = 0;
+    SimpleTimer _tmr;
 
    private:
-    uint32_t _tmr = 0;
 };
 
 // поток с данными
diff --git a/src/nodes/macro.h b/src/nodes/macro.h
@@ -0,0 +1,101 @@
+#pragma once
+#include <inttypes.h>
+
+// ========= macro =========
+// широковещательное событие
+#define LP_BROADCAST (hash_t)0
+
+// отправить событие
+#define LP_SEND_EVENT(id, data) Looper.sendEvent(LPH(id), data)
+
+// отложить отправку события
+#define LP_PUSH_EVENT(id, data) Looper.pushEvent(LPH(id), data)
+
+#define LP_MAKE(type, ...) static type _LP_CONCAT(__loop_obj_, __COUNTER__)(__VA_ARGS__)
+#define LP_MAKE_(id, type, ...) static type _LP_CONCAT(__loop_obj_, __COUNTER__)(LPH(id), __VA_ARGS__)
+#define LP_NEW(type, ...) new type(__VA_ARGS__)
+#define LP_NEW_(id, type, ...) new type(LPH(id), __VA_ARGS__)
+
+// LISTENER
+#define LP_LISTENER_(id, ...) LP_MAKE_(id, LoopListener, __VA_ARGS__)
+
+// TICKER
+#define LP_TICKER(...) LP_MAKE(LoopTicker, __VA_ARGS__)
+#define LP_TICKER_(id, ...) LP_MAKE_(id, LoopTicker, __VA_ARGS__)
+
+// TIMER
+#define LP_TIMER(ms, ...) LP_MAKE(LoopTimer, ms, __VA_ARGS__)
+#define LP_TIMER_(id, ms, ...) LP_MAKE_(id, LoopTimer, ms, __VA_ARGS__)
+
+// THREAD
+#define _LP_THREAD_CASE Looper.thisThread()->_case
+#define _LP_THREAD_RESET() _LP_THREAD_CASE = 0;
+
+// начать поток
+#define LP_THREAD_BEGIN()      \
+    switch (_LP_THREAD_CASE) { \
+        case 0:;
+
+// завершить поток
+#define LP_THREAD_END() \
+    }                   \
+    _LP_THREAD_RESET();
+
+#define _LP_THREAD_INNER(body) \
+    LP_THREAD_BEGIN();         \
+    body                       \
+    LP_THREAD_END();
+
+#define LP_THREAD(body) static LoopThread _LP_CONCAT(__loop_obj_, __COUNTER__)([]() { _LP_THREAD_INNER(body) })
+#define LP_THREAD_(id, body) static LoopThread _LP_CONCAT(__loop_obj_, __COUNTER__)(LPH(id), []() { _LP_THREAD_INNER(body) })
+#define LP_THREAD_DATA(T, data, data_arg, body) static LoopThreadData<T> _LP_CONCAT(__loop_obj_, __COUNTER__)(data, [](data_arg) { _LP_THREAD_INNER(body) })
+#define LP_THREAD_DATA_(id, T, data, data_arg, body) static LoopThreadData<T> _LP_CONCAT(__loop_obj_, __COUNTER__)(LPH(id), data, [](data_arg) { _LP_THREAD_INNER(body) })
+
+// перезапустить поток (начать выполнение с начала)
+#define LP_RESTART()        \
+    do {                    \
+        _LP_THREAD_RESET(); \
+        return;             \
+    } while (0);
+
+// выйти из потока и потом вернуться в эту точку
+#define LP_EXIT()                          \
+    do {                                   \
+        _LP_THREAD_CASE = __COUNTER__ + 1; \
+        return;                            \
+        case __COUNTER__:;                 \
+    } while (0);
+
+// асинхронно ждать условия
+#define LP_WAIT(cond)                      \
+    do {                                   \
+        _LP_THREAD_CASE = __COUNTER__ + 1; \
+        case __COUNTER__:                  \
+            if (!(cond)) return;           \
+    } while (0);
+
+// асинхронно ждать события
+#define LP_WAIT_EVENT() LP_WAIT(Looper.thisEvent());
+
+// асинхронно ждать время в мс
+#define LP_DELAY(ms)                                  \
+    do {                                              \
+        Looper.thisThread()->_tmr.restart(ms);        \
+        LP_WAIT(Looper.thisThread()->_tmr.timeout()); \
+    } while (0);
+
+// устарело
+#define LP_SLEEP(ms) LP_DELAY(ms)
+
+// освободить семафор
+#define LP_SEM_SIGNAL(sem) sem++;
+
+// ждать семафор
+#define LP_SEM_WAIT(sem) \
+    do {                 \
+        LP_WAIT(sem);    \
+        sem--;           \
+    } while (0);
+
+// семафор
+typedef uint16_t LP_SEM;

-Original file line number
+Diff line change
@@ @@ -1,5 +1,5 @@ @@
 name=Looper
 -version=1.1.5
 +version=1.1.6
 author=AlexGyver <[email protected]>
 maintainer=AlexGyver <[email protected]>
 sentence=Simple task, thread and event manager for Arduino
Original file line number	Diff line number	Diff line change
`@@ -69,11 +69,14 @@ bool LoopTask::isTicker() {`
`69`	`69`	`bool LoopTask::isListener() {`
`70`	`70`	`return sreg.read(TASK_IS_LISTENER);`
`71`	`71`	`}`
	`72`	`+bool LoopTask::isThread() {`
	`73`	`+ return sreg.read(TASK_IS_THREAD);`
	`74`	`+}`
`72`	`75`
`73`	`76`	`bool LoopTask::canListen() {`
`74`	`77`	`return sreg.isSet(TASK_ENABLED \| TASK_HAS_EVENTS);`
`75`	`78`	`}`
`76`	`79`
`77`	`80`	`uint8_t LoopTask::_tickMask() {`
`78`		`- return sreg.mask(TASK_ENABLED \| TASK_IS_TICKER \| TASK_IS_TIMER);`
	`81`	`+ return sreg.mask(TASK_ENABLED \| TASK_IS_TICKER \| TASK_IS_TIMER \| TASK_IS_THREAD);`
`79`	`82`	`}`