upd

Author: GyverLibs

docs/0.main.md

@@ -39,37 +39,12 @@ LP_TICKER_(id, func)
 // создать статический таймер
 LP_TIMER(ms, func)
 LP_TIMER_(id, ms, func)
-```
 
-### Макросы потоков
-```cpp
 // создать статический поток
 LP_THREAD(body)
 LP_THREAD_(id, body)
 LP_THREAD_DATA(T, data, data_arg, body)
 LP_THREAD_DATA_(id, T, data, data_arg, body)
-
-// начало и конец потока для создания вручную
-LP_THREAD_BEGIN()
-LP_THREAD_END()
-
-// асинхронно ждать события в потоке
-LP_WAIT_EVENT(cond)
-
-// асинхронно ждать условия в потоке
-LP_WAIT(cond)
-
-// асинхронно ждать время в мс в потоке
-LP_DELAY(ms)
-
-// выйти из потока и потом вернуться в эту точку
-LP_EXIT()
-
-// освободить семафор
-LP_SEM_SIGNAL(sem)
-
-// ждать семафор
-LP_SEM_WAIT(sem)
 ```
 
 ### `Looper`

docs/2.threads.md

@@ -25,7 +25,34 @@ LP_THREAD_("thread_id", {
 
 > Внутри обработчика точно так же можно обращаться к задаче через `thisTask` и делать всё то же самое, что с `LoopTicker` (остановить, исключить из loop, отправить-поймать событие и так далее).
 
-Для управления потоком используются специальные макросы.
+Для управления потоком используются специальные управляющие макросы:
+
+```cpp
+// начало и конец потока для создания вручную
+LP_THREAD_BEGIN()
+LP_THREAD_END()
+
+// перезапустить поток (начать выполнение с начала)
+LP_RESTART()
+
+// выйти из потока и потом вернуться в эту точку
+LP_EXIT()
+
+// асинхронно ждать время в потоке, мс
+LP_DELAY(ms)
+
+// асинхронно ждать условия в потоке
+LP_WAIT(cond)
+
+// асинхронно ждать Looper-события в потоке
+LP_WAIT_EVENT()
+
+// ждать семафор
+LP_SEM_WAIT(sem)
+
+// освободить семафор
+LP_SEM_SIGNAL(sem)
+```
 
 ### Выход из потока
 В любой момент можно покинуть поток и отдать выполнение другим потокам, на следующем круге диспетчера задач управление вернётся к потоку и продолжится после точки выхода. Полезно например если нужно "размазать" какие то долгие сложные вычисления по времени и выполнять в промежутках другие потоки:
@@ -114,10 +141,11 @@ LP_TIMER(1000, []() {
 ```
 
 ## Ограничения
-Реализация потоков очень простая и лёгкая, поэтому есть ограничения. По сути все макросы ожидания создают метку перехода, а весь код находится внутри `switch`, это означает что:
+Реализация потоков очень простая и лёгкая, поэтому есть ограничения. По сути все управляющие макросы создают метку перехода, а весь код находится внутри `switch`, это означает что:
 - После макроса ожидания будет выход из функции без сохранения стека, т.е. объявленные выше локальные переменные потеряют значения
-- Нельзя создавать внутри потока локальные переменные, которые "живут" между вызовами макросов ожидания
+- Нельзя создавать внутри потока локальные переменные, которые "живут" между вызовами управляющих макросов
 - Для создания "стека" используем статические переменные внутри функции
+- Нельзя использовать управляющие макросы внутри `switch`
 
 Например цикл с задержкой делать вот так **нельзя**:
 ```cpp

library.properties

@@ -1,9 +1,9 @@
 name=Looper
-version=1.1.2
+version=1.1.3
 author=AlexGyver <[email protected]>
 maintainer=AlexGyver <[email protected]>
-sentence=Simple task and event manager for Arduino
-paragraph=Simple task and event manager for Arduino
+sentence=Simple task, thread and event manager for Arduino
+paragraph=Simple task, thread and event manager for Arduino
 category=Control
 url=https://github.com/GyverLibs/Looper
 architectures=*

src/Looper.h

@@ -33,36 +33,54 @@
 #define LP_TIMER_(id, ms, func) LP_MAKE_(id, LoopTimer, ms, func)
 
 // THREAD
-#define LP_THREAD_BEGIN()                 \
-    switch (Looper.thisThread()->_case) { \
+#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() \
     }                   \
-    Looper.thisThread()->_case = 0;
+    _LP_THREAD_RESET();
 
 #define _LP_THREAD_INNER(body) \
     LP_THREAD_BEGIN();         \
-    body;                      \
+    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()                                 \
-    Looper.thisThread()->_case = __COUNTER__ + 1; \
-    case __COUNTER__:
+#define LP_EXIT()                          \
+    do {                                   \
+        _LP_THREAD_CASE = __COUNTER__ + 1; \
+        return;                            \
+        case __COUNTER__:;                 \
+    } while (0);
 
 // асинхронно ждать условия
-#define LP_WAIT(cond) \
-    LP_EXIT();        \
-    if (!(cond)) return;
+#define LP_WAIT(cond)                      \
+    do {                                   \
+        _LP_THREAD_CASE = __COUNTER__ + 1; \
+        case __COUNTER__:                  \
+            if (!(cond)) return;           \
+    } while (0);
 
 // асинхронно ждать события
-#define LP_WAIT_EVENT(cond) LP_WAIT(Looper.thisEvent());
+#define LP_WAIT_EVENT() LP_WAIT(Looper.thisEvent());
 
 // асинхронно ждать время в мс
 #define LP_DELAY(ms)                                \
@@ -86,4 +104,4 @@
     } while (0);
 
 // семафор
-typedef uint8_t LP_SEM;
+typedef uint16_t LP_SEM;