C++ conversions (#111)

* Remove version from artifact name
* Target C++ 20 and higher
* Use cpp string
* Better crash implementation
* String utils in cpp style
* Replace parameter methods with start() method
* MutexType to Mutex::Type
* Kernel c to cpp style
* Cleanup event flag
* More cpp conversions
* Test fixes
* Updated ideas docs

TactilityCore/Source/kernel/Kernel.h

@@ -0,0 +1,125 @@
+#pragma once
+
+#include "CoreTypes.h"
+
+#ifdef ESP_PLATFORM
+#include "freertos/FreeRTOS.h"
+#else
+#include "FreeRTOS.h"
+#endif
+
+namespace tt::kernel {
+
+typedef enum {
+    PlatformEsp,
+    PlatformSimulator
+} Platform;
+
+/** Check if CPU is in IRQ or kernel running and IRQ is masked
+ * 
+ * Originally this primitive was born as a workaround for FreeRTOS kernel primitives shenanigans with PRIMASK.
+ * 
+ * Meaningful use cases are:
+ * 
+ * - When kernel is started and you want to ensure that you are not in IRQ or IRQ is not masked(like in critical section)
+ * - When kernel is not started and you want to make sure that you are not in IRQ mode, ignoring PRIMASK.
+ * 
+ * As you can see there will be edge case when kernel is not started and PRIMASK is not 0 that may cause some funky behavior.
+ * Most likely it will happen after kernel primitives being used, but control not yet passed to kernel.
+ * It's up to you to figure out if it is safe for your code or not.
+ * 
+ * @return     true if CPU is in IRQ or kernel running and IRQ is masked
+ */
+bool isIrq();
+
+/** Check if kernel is running
+ *
+ * @return     true if running, false otherwise
+ */
+bool isRunning();
+
+/** Lock kernel, pause process scheduling
+ *
+ * @warning This should never be called in interrupt request context.
+ *
+ * @return     previous lock state(0 - unlocked, 1 - locked)
+ */
+int32_t lock();
+
+/** Unlock kernel, resume process scheduling
+ *
+ * @warning This should never be called in interrupt request context.
+ *
+ * @return     previous lock state(0 - unlocked, 1 - locked)
+ */
+int32_t unlock();
+
+/** Restore kernel lock state
+ *
+ * @warning This should never be called in interrupt request context.
+ *
+ * @param[in]  lock  The lock state
+ *
+ * @return     new lock state or error
+ */
+int32_t restoreLock(int32_t lock);
+
+/** Get kernel systick frequency
+ *
+ * @return     systick counts per second
+ */
+uint32_t getTickFrequency();
+
+TickType_t getTicks();
+
+/** Delay execution
+ *
+ * @warning This should never be called in interrupt request context.
+ *
+ * Also keep in mind delay is aliased to scheduler timer intervals.
+ *
+ * @param[in]  ticks  The ticks count to pause
+ */
+void delayTicks(TickType_t ticks);
+
+/** Delay until tick
+ *
+ * @warning This should never be called in interrupt request context.
+ *
+ * @param[in]  ticks  The tick until which kerel should delay task execution
+ *
+ * @return     The status.
+ */
+TtStatus delayUntilTick(uint32_t tick);
+
+/** Convert milliseconds to ticks
+ *
+ * @param[in]   milliSeconds    time in milliseconds
+ * @return      time in ticks
+ */
+TickType_t millisToTicks(uint32_t milliSeconds);
+
+/** Delay in milliseconds
+ * 
+ * This method uses kernel ticks on the inside, which causes delay to be aliased to scheduler timer intervals.
+ * Real wait time will be between X+ milliseconds.
+ * Special value: 0, will cause task yield.
+ * Also if used when kernel is not running will fall back to `tt_delay_us`.
+ * 
+ * @warning    Cannot be used from ISR
+ *
+ * @param[in]  milliSeconds  milliseconds to wait
+ */
+void delayMillis(uint32_t milliSeconds);
+
+/** Delay in microseconds
+ *
+ * Implemented using Cortex DWT counter. Blocking and non aliased.
+ *
+ * @param[in]  microSeconds  microseconds to wait
+ */
+void delayMicros(uint32_t microSeconds);
+
+Platform getPlatform();
+
+} // namespace