Added queue wrapper

include/wrappers/binary_semaphore.h

@@ -0,0 +1,33 @@
+#pragma once
+
+// espressif includes
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+// local includes
+#include "cppmacros.h"
+
+namespace espcpputils {
+class binary_semaphore
+{
+    CPP_DISABLE_COPY_MOVE(binary_semaphore)
+
+public:
+    binary_semaphore() :
+        handle{xSemaphoreCreateBinary()}
+    {}
+
+    ~binary_semaphore() { if (handle) vSemaphoreDelete(handle); }
+
+    TaskHandle_t getMutexHolder() const { return xSemaphoreGetMutexHolder(handle); }
+
+    UBaseType_t getCount() const        { return uxSemaphoreGetCount(handle); }
+
+    bool take(TickType_t xTicksToWait)  { return xSemaphoreTake(handle, xTicksToWait); }
+
+    bool give()                         { return xSemaphoreGive(handle); }
+
+    const SemaphoreHandle_t handle;
+};
+} // namespace espcpputils

include/wrappers/counting_semaphore.h

@@ -0,0 +1,33 @@
+#pragma once
+
+// espressif includes
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+// local includes
+#include "cppmacros.h"
+
+namespace espcpputils {
+class counting_semaphore
+{
+    CPP_DISABLE_COPY_MOVE(counting_semaphore)
+
+public:
+    counting_semaphore(UBaseType_t uxMaxCount, UBaseType_t uxInitialCount) :
+        handle{xSemaphoreCreateCounting(uxMaxCount, uxInitialCount)}
+    {}
+
+    ~counting_semaphore() { if (handle) vSemaphoreDelete(handle); }
+
+    TaskHandle_t getMutexHolder() const { return xSemaphoreGetMutexHolder(handle); }
+
+    UBaseType_t getCount() const        { return uxSemaphoreGetCount(handle); }
+
+    bool take(TickType_t xTicksToWait)  { return xSemaphoreTake(handle, xTicksToWait); }
+
+    bool give()                         { return xSemaphoreGive(handle); }
+
+    const SemaphoreHandle_t handle;
+};
+} // namespace espcpputils

include/wrappers/event_group.h

@@ -0,0 +1,36 @@
+#pragma once
+
+// espressif includes
+#include <freertos/FreeRTOS.h>
+#include <freertos/event_groups.h>
+
+// local includes
+#include "cppmacros.h"
+
+namespace espcpputils {
+class event_group
+{
+    CPP_DISABLE_COPY_MOVE(event_group)
+
+public:
+    event_group() :
+        handle{xEventGroupCreate()}
+    {}
+
+    ~event_group() { if (handle) vEventGroupDelete(handle); }
+
+    EventBits_t waitBits(const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait)
+    { return xEventGroupWaitBits(handle, uxBitsToWaitFor, xClearOnExit, xWaitForAllBits, xTicksToWait); }
+
+    EventBits_t clearBits(const EventBits_t uxBitsToClear) { return xEventGroupClearBits(handle, uxBitsToClear); }
+
+    EventBits_t setBits(const EventBits_t uxBitsToSet) { return xEventGroupSetBits(handle, uxBitsToSet); }
+
+    EventBits_t groupSync(const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait)
+    { return xEventGroupSync(handle, uxBitsToSet, uxBitsToWaitFor, xTicksToWait); }
+
+    EventBits_t getBits() const { return xEventGroupClearBits(handle, 0); }
+
+    const EventGroupHandle_t handle;
+};
+} // namespace espcpputils

include/wrappers/http_client.h

@@ -0,0 +1,77 @@
+#pragma once
+
+// espressif includes
+#include <esp_http_client.h>
+
+// local includes
+#include "cppmacros.h"
+
+namespace espcpputils {
+class http_client
+{
+    CPP_DISABLE_COPY_MOVE(http_client)
+
+public:
+    http_client(const esp_http_client_config_t *config) :
+        handle{esp_http_client_init(config)}
+    {}
+
+    ~http_client() { if (handle) esp_http_client_cleanup(handle); }
+
+    esp_err_t perform()                                      { return esp_http_client_perform(handle); }
+    esp_err_t set_url(const char *url)                       { return esp_http_client_set_url(handle, url); }
+    esp_err_t set_post_field(const char *data, int len)      { return esp_http_client_set_post_field(handle, data, len); }
+    int       get_post_field(char **data)                    { return esp_http_client_get_post_field(handle, data); }
+    esp_err_t set_header(const char *key, const char *value) { return esp_http_client_set_header(handle, key, value); }
+    esp_err_t get_header(const char *key, char **value)      { return esp_http_client_get_header(handle, key, value); }
+    esp_err_t get_username(char **value)                     { return esp_http_client_get_username(handle, value); }
+    esp_err_t set_username(const char *username)             { return esp_http_client_set_username(handle, username); }
+    esp_err_t get_password(char **value)                     { return esp_http_client_get_password(handle, value); }
+    esp_err_t set_password(char *password)                   { return esp_http_client_set_password(handle, password); }
+    esp_err_t set_method(esp_http_client_method_t method)    { return esp_http_client_set_method(handle, method); }
+    esp_err_t delete_header(const char *key)                 { return esp_http_client_delete_header(handle, key); }
+    esp_err_t open(int write_len)                            { return esp_http_client_open(handle, write_len); }
+    int       write(const char *buffer, int len)             { return esp_http_client_write(handle, buffer, len); }
+    int       fetch_headers()                                { return esp_http_client_fetch_headers(handle); }
+    bool      is_chunked_response() const                    { return esp_http_client_is_chunked_response(handle); }
+    int       read(char *buffer, int len)                    { return esp_http_client_read(handle, buffer, len); }
+    int       get_status_code() const                        { return esp_http_client_get_status_code(handle); }
+    int       get_content_length() const                     { return esp_http_client_get_content_length(handle); }
+    esp_err_t close()                                        { return esp_http_client_close(handle); }
+    esp_http_client_transport_t get_transport_type() const   { return esp_http_client_get_transport_type(handle); }
+    esp_err_t set_redirection()                              { return esp_http_client_set_redirection(handle); }
+    void      add_auth()                                     { return esp_http_client_add_auth(handle); }
+    bool      is_complete_data_received() const              { return esp_http_client_is_complete_data_received(handle); }
+
+    static esp_http_client_config_t zeroInitializedConfig()
+    {
+        return esp_http_client_config_t {
+            .url = {},
+            .host = {},
+            .port = {},
+            .username = {},
+            .password = {},
+            .auth_type = {},
+            .path = {},
+            .query = {},
+            .cert_pem = {},
+            .client_cert_pem = {},
+            .client_key_pem = {},
+            .method = {},
+            .timeout_ms = {},
+            .disable_auto_redirect = {},
+            .max_redirection_count = {},
+            .event_handler = {},
+            .transport_type = {},
+            .buffer_size = {},
+            .buffer_size_tx = {},
+            .user_data = {},
+            .is_async = {},
+            .use_global_ca_store = {},
+            .skip_cert_common_name_check = {}
+        };
+    }
+
+    const esp_http_client_handle_t handle;
+};
+} // namespace espcpputils

include/wrappers/mutex_semaphore.h

@@ -0,0 +1,33 @@
+#pragma once
+
+// espressif includes
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+// local includes
+#include "cppmacros.h"
+
+namespace espcpputils {
+class mutex_semaphore
+{
+    CPP_DISABLE_COPY_MOVE(mutex_semaphore)
+
+public:
+    mutex_semaphore() :
+        handle{xSemaphoreCreateMutex()}
+    {}
+
+    ~mutex_semaphore() { if (handle) vSemaphoreDelete(handle); }
+
+    TaskHandle_t getMutexHolder() const { return xSemaphoreGetMutexHolder(handle); }
+
+    UBaseType_t getCount() const        { return uxSemaphoreGetCount(handle); }
+
+    bool take(TickType_t xTicksToWait)  { return xSemaphoreTake(handle, xTicksToWait); }
+
+    bool give()                         { return xSemaphoreGive(handle); }
+
+    const SemaphoreHandle_t handle;
+};
+} // namespace espcpputils

include/wrappers/queue.h

@@ -0,0 +1,48 @@
+#pragma once
+
+// espressif includes
+#include <freertos/FreeRTOS.h>
+#include <freertos/queue.h>
+
+// local includes
+#include "cppmacros.h"
+
+namespace espcpputils {
+class queue
+{
+    CPP_DISABLE_COPY_MOVE(queue)
+
+public:
+    queue(const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize) :
+        handle{xQueueCreate(uxQueueLength, uxItemSize)}
+    {}
+
+    ~queue() { if (handle) vQueueDelete(handle); }
+
+    BaseType_t send(const void * pvItemToQueue, TickType_t xTicksToWait)        { return xQueueSend(handle, pvItemToQueue, xTicksToWait); }
+
+    BaseType_t sendToBack(const void * pvItemToQueue, TickType_t xTicksToWait)  { return xQueueSendToBack(handle, pvItemToQueue, xTicksToWait); }
+
+    BaseType_t sendToFront(const void * pvItemToQueue, TickType_t xTicksToWait) { return xQueueSendToFront(handle, pvItemToQueue, xTicksToWait); }
+
+    BaseType_t receive(void *pvBuffer, TickType_t xTicksToWait)                 { return xQueueReceive(handle, pvBuffer, xTicksToWait); }
+
+    UBaseType_t messagesWaiting() const                                         { return uxQueueMessagesWaiting(handle); }
+
+    UBaseType_t spacesAvailable() const                                         { return SpacesAvailable(handle); }
+
+    BaseType_t reset()                                                          { return xQueueReset(handle); }
+
+    BaseType_t overwrite(const void * pvItemToQueue)                            { return xQueueOverwrite(handle, pvItemToQueue); }
+
+    BaseType_t peek(void *pvBuffer, TickType_t xTicksToWait) const              { return xQueuePeek(handle, pvBuffer, xTicksToWait); }
+
+    void addToRegistry(char *pcQueueName)                                       { return vQueueAddToRegistry(handle, pcQueueName); }
+
+    void unregisterQueue()                                                      { return vQueueUnregisterQueue(handle); }
+
+    const char *getName() const                                                 { return pcQueueGetName(handle); }
+
+    const QueueHandle_t handle;
+};
+} // namespace espcpputils

include/wrappers/recursive_mutex_semaphore.h

@@ -0,0 +1,33 @@
+#pragma once
+
+// espressif includes
+#include <freertos/FreeRTOS.h>
+#include <freertos/semphr.h>
+#include <freertos/task.h>
+
+// local includes
+#include "cppmacros.h"
+
+namespace espcpputils {
+class recursive_mutex_semaphore
+{
+    CPP_DISABLE_COPY_MOVE(recursive_mutex_semaphore)
+
+public:
+    recursive_mutex_semaphore() :
+        handle{xSemaphoreCreateRecursiveMutex()}
+    {}
+
+    ~recursive_mutex_semaphore() { if (handle) vSemaphoreDelete(handle); }
+
+    TaskHandle_t getMutexHolder() const { return xSemaphoreGetMutexHolder(handle); }
+
+    UBaseType_t getCount() const        { return uxSemaphoreGetCount(handle); }
+
+    bool takeRecursive(TickType_t xTicksToWait) { return xSemaphoreTakeRecursive(handle, xTicksToWait); }
+
+    bool giveRecursive()                { return xSemaphoreGiveRecursive(handle); }
+
+    const SemaphoreHandle_t handle;
+};
+} // namespace espcpputils

include/wrappers/websocket_client.h

@@ -0,0 +1,36 @@
+#pragma once
+
+// espressif includes
+#include <esp_websocket_client.h>
+
+// local includes
+#include "cppmacros.h"
+
+namespace espcpputils {
+class websocket_client
+{
+    CPP_DISABLE_COPY_MOVE(websocket_client)
+
+public:
+    websocket_client(const esp_websocket_client_config_t &config) :
+        handle{esp_websocket_client_init(&config)}
+    {
+    }
+
+    ~websocket_client() { if (handle) esp_websocket_client_destroy(handle); }
+
+    esp_err_t set_uri        (const char *uri)                                         { return esp_websocket_client_set_uri        (handle, uri);                      }
+    esp_err_t start          ()                                                        { return esp_websocket_client_start          (handle);                           }
+    esp_err_t stop           ()                                                        { return esp_websocket_client_stop           (handle);                           }
+    int       send           (const char *data, int len, TickType_t timeout)           { return esp_websocket_client_send           (handle, data, len, timeout);       }
+    int       send_bin       (const char *data, int len, TickType_t timeout)           { return esp_websocket_client_send_bin       (handle, data, len, timeout);       }
+    int       send_text      (const char *data, int len, TickType_t timeout)           { return esp_websocket_client_send_text      (handle, data, len, timeout);       }
+    //esp_err_t close          (TickType_t timeout)                                      { return esp_websocket_client_close          (handle, timeout);                  }
+    //esp_err_t close_with_code(int code, const char *data, int len, TickType_t timeout) { return esp_websocket_client_close_with_code(handle, code, data, len, timeout); }
+    bool      is_connected   () const                                                  { return esp_websocket_client_is_connected   (handle); }
+    esp_err_t register_events(esp_websocket_event_id_t event, esp_event_handler_t event_handler, void *event_handler_arg)
+    { return esp_websocket_register_events(handle, event, event_handler, event_handler_arg); }
+
+    const esp_websocket_client_handle_t handle;
+};
+} // namespace espcpputils