upd

Author: GyverLibs

README.md

@@ -62,7 +62,7 @@ void loop() {
 > Это позволяет разделять программу на полностью независимые потоки, а также писать код в событийно-ориентированном стиле
 
 Минусы:
-- Каждая задача занимает в оперативной памяти 7 байт
+- Каждая задача занимает в оперативной памяти 7 байт (вес можно уменьшить, отключив поддержку ID и событий)
 - Проход по списку задач и вызов обработчиков занимает в районе 8us на одну задачу (AVR 16MHz), что равносильно двум вызовам digitalRead
 
 <a id="versions"></a>

docs/0.main.md

@@ -4,6 +4,9 @@
 - `DataCallback` - функция вида `void f(T* data)`
 - `LooperCallback` - функция вида `void f(hash_t id)`
 
+### Настройки
+В файле platform.h можно настроить некоторые параметры библиотеки для уменьшения веса и переноса на отличные от Arduino платформы. Например можно отключить поддержку ID задач для уменьшения веса самих задач и отключить поддержку отправки событий для уменьшения веса всей библиотеки в целом
+
 ### Макросы
 ```cpp
 // создать обработчик

library.properties

@@ -1,5 +1,5 @@
 name=Looper
-version=1.1.0
+version=1.1.1
 author=AlexGyver <[email protected]>
 maintainer=AlexGyver <[email protected]>
 sentence=Simple task and event manager for Arduino

src/LooperClass.cpp

@@ -2,8 +2,8 @@
 
 #include <limits.h>
 
-#include "nodes/Timer.h"
 #include "nodes/Thread.h"
+#include "nodes/Timer.h"
 #include "platform.h"
 
 #define LP_LIST_AMOUNT 2
@@ -26,14 +26,20 @@ void LooperClass::loop() {
         }
         if (_removed) _removed = false;
         else _thisTask = _thisTask->getPrev();
+#if LOOPER_USE_EVENTS
         while (_events.length()) _sendEvent(_events.pop());
+#endif
     }
+#if LOOPER_USE_EVENTS
     while (_events.length()) _sendEvent(_events.pop());
+#endif
     _thisState = tState::None;
 }
 
 void LooperClass::onEvent(LooperCallback callback) {
+#if LOOPER_USE_EVENTS
     _event_cb = callback;
+#endif
 }
 
 void LooperClass::restart() {
@@ -54,7 +60,11 @@ uint32_t LooperClass::nextTimerLeft() {
 }
 
 uint16_t LooperClass::length() {
+#if LOOPER_USE_EVENTS
     return _tasks.length() + _lisns.length();
+#else
+    return _tasks.length();
+#endif
 }
 
 void LooperClass::delay(uint32_t ms) {
@@ -65,14 +75,26 @@ void LooperClass::delay(uint32_t ms) {
 
 void LooperClass::add(LoopTask* task) {
     if (!task) return;
+
+#if LOOPER_USE_EVENTS
     task->isListener() ? _lisns.add(task) : _tasks.add(task);
+#else
+    if (!task->isListener()) _tasks.add(task);
+#endif
+
     if (!_setup) _tickState(task, tState::Setup);
 }
 
 void LooperClass::remove(LoopTask* task) {
     if (!task) return;
     _tickState(task, tState::Exit);
+
+#if LOOPER_USE_EVENTS
     task->isListener() ? _lisns.remove(task) : _tasks.remove(task);
+#else
+    if (!task->isListener()) _tasks.remove(task);
+#endif
+
     if (_thisTask == task) {
         _thisTask = _thisTask->getPrev();
         _removed = true;
@@ -95,8 +117,6 @@ void LooperClass::removeThis() {
     remove(thisTask());
 }
 
-bool LooperClass::eventBroadcast() { return _broadcast; }
-LoopTask* LooperClass::eventSource() { return _source; }
 LoopTask* LooperClass::thisTask() { return _removed ? nullptr : _thisTask; }
 LoopTimer* LooperClass::thisTimer() { return thisTaskAs<LoopTimer>(); }
 LoopThread* LooperClass::thisThread() { return thisTaskAs<LoopThread>(); }
@@ -106,15 +126,35 @@ bool LooperClass::thisExit() { return _thisState == tState::Exit; }
 bool LooperClass::thisEvent() { return _thisState == tState::Event; }
 bool LooperClass::thisLoop() { return _thisState == tState::Loop; }
 
+bool LooperClass::eventBroadcast() {
+#if LOOPER_USE_EVENTS
+    return _broadcast;
+#else
+    return 0;
+#endif
+}
+
+LoopTask* LooperClass::eventSource() {
+#if LOOPER_USE_EVENTS
+    return _source;
+#else
+    return nullptr;
+#endif
+}
 void* LooperClass::eventData() {
+#if LOOPER_USE_EVENTS
     return _thisState == tState::Event ? _data : nullptr;
+#else
+    return nullptr;
+#endif
 }
 
 void LooperClass::_sendEvent(EventData& evt) {
     sendEvent(evt.id, evt.data);
 }
 
 void LooperClass::sendEvent(hash_t id, void* data) {
+#if LOOPER_USE_EVENTS
     LoopTask* source = _thisTask;
     tState stateTemp = _thisState;
     _thisState = tState::Event;
@@ -126,6 +166,7 @@ void LooperClass::sendEvent(hash_t id, void* data) {
         _event_cb(id);
     }
 
+#if LOOPER_USE_ID
     for (uint8_t i = 0; i < LP_LIST_AMOUNT; i++) {
         _thisTask = _getList(i)->getLast();
         while (_thisTask) {
@@ -140,26 +181,33 @@ void LooperClass::sendEvent(hash_t id, void* data) {
             else _thisTask = _thisTask->getPrev();
         }
     }
+#endif
 
     _broadcast = false;
     _source = nullptr;
     _thisTask = source;
     _thisState = stateTemp;
+#endif
 }
 
 void LooperClass::sendEvent(const char* id, void* data) {
     sendEvent(LPHr(id), data);
 }
 
 bool LooperClass::pushEvent(hash_t id, void* data) {
+#if LOOPER_USE_EVENTS
     return _events.push(EventData{id, data});
+#else
+    return 0;
+#endif
 }
 
 bool LooperClass::pushEvent(const char* id, void* data) {
     return pushEvent(LPHr(id), data);
 }
 
 LoopTask* LooperClass::getTask(hash_t id) {
+#if LOOPER_USE_EVENTS
     if (!id) return nullptr;
     for (uint8_t i = 0; i < LP_LIST_AMOUNT; i++) {
         LoopTask* p = _getList(i)->getLast();
@@ -168,6 +216,7 @@ LoopTask* LooperClass::getTask(hash_t id) {
             p = p->getPrev();
         }
     }
+#endif
     return nullptr;
 }
 
@@ -190,6 +239,8 @@ LoopTimer* LooperClass::getTimer(const char* id) {
     return getTimer(LPHr(id));
 }
 
+#if LOOPER_USE_EVENTS
 looper::List<LoopTask>* LooperClass::_getList(uint8_t idx) {
     return (looper::List<LoopTask>*[]){&_tasks, &_lisns}[idx];
-}
+}
+#endif

src/LooperClass.h

@@ -113,21 +113,26 @@ class LooperClass {
         void* data;
     };
 
-    LooperCallback _event_cb = nullptr;
     LoopTask* _thisTask = nullptr;
+    looper::List<LoopTask> _tasks;
+
+#if LOOPER_USE_EVENTS
     LoopTask* _source = nullptr;
+    LooperCallback _event_cb = nullptr;
     void* _data = nullptr;
-    looper::List<LoopTask> _tasks;
     looper::List<LoopTask> _lisns;
     looper::Stack<EventData, LOOPER_QUEUE_SIZE> _events;
+    
+    looper::List<LoopTask>* _getList(uint8_t idx);
+#endif
+
     tState _thisState = tState::None;
     bool _setup = true;
     bool _removed = false;
     bool _broadcast = false;
 
     void _sendEvent(EventData& evt);
     void _tickState(LoopTask* task, tState state);
-    looper::List<LoopTask>* _getList(uint8_t idx);
 };
 
 extern LooperClass Looper;

src/nodes/LoopTask.cpp

@@ -20,7 +20,11 @@ void LoopTask::detach() {
 }
 
 hash_t LoopTask::id() {
+#if LOOPER_USE_ID
     return _id;
+#else
+    return 0;
+#endif
 }
 
 void LoopTask::enable() {

src/nodes/LoopTask.h

@@ -2,6 +2,7 @@
 #include <inttypes.h>
 #include <stddef.h>
 
+#include "../platform.h"
 #include "../utils/flags.h"
 #include "../utils/hash.h"
 #include "../utils/list.h"
@@ -29,7 +30,10 @@ LP_MAKE_CALLBACK(TaskCallback, void);
 
 class LoopTask : public looper::List<LoopTask>::Node {
    public:
-    LoopTask(hash_t id, TaskCallback callback, uint8_t type, bool states, bool events) : _id(id), _cb(callback) {
+    LoopTask(hash_t id, TaskCallback callback, uint8_t type, bool states, bool events) : _cb(callback) {
+#if LOOPER_USE_ID
+        _id = id;
+#endif
         sreg.set(TASK_ENABLED | type);
         if (states) enableStates();
         if (events) enableEvents();
@@ -102,7 +106,9 @@ class LoopTask : public looper::List<LoopTask>::Node {
     uint8_t _tickMask();
 
    private:
+#if LOOPER_USE_ID
     hash_t _id;
+#endif
     TaskCallback _cb;
     looper::Flags sreg;
 };

src/platform.h

@@ -4,6 +4,12 @@
 // размер стека отложенных событий
 #define LOOPER_QUEUE_SIZE 3
 
+// использовать ID задач для событий
+#define LOOPER_USE_ID true
+
+// использовать события
+#define LOOPER_USE_EVENTS true
+
 namespace looper {
 
 // миллисекунды со старта МК