moved threadx helpers to embedded base

Author: caiodasilva2005

threadX/inc/threadX_utils.h

@@ -0,0 +1,50 @@
+
+#ifndef __U_DEBUG_H
+#define __U_DEBUG_H
+
+#include <string.h>
+#include <stdio.h>
+#include "tx_api.h"
+#include "stm32h5xx_hal.h"
+
+/* General-purpose status macros. */
+#define U_SUCCESS     0
+#define U_ERROR       1
+#define U_QUEUE_EMPTY 2
+
+/* Debugging Macros */
+#define __FILENAME__ (strrchr(__FILE__, '/') ? strrchr(__FILE__, '/') + 1 : __FILE__) /* Gets the name of the file. */
+#define U_DEBUG /* Comment out to enable/disable debugging. */
+#ifdef U_DEBUG
+    #define DEBUG_PRINTLN(message, ...) printf("[%s/%s()] " message "\n", __FILENAME__, __func__, ##__VA_ARGS__) /* Prints an error message in the format: "[file_name.c/function()] {message}"*/
+#else
+    #define DEBUG_PRINTLN(message, ...) /* If debugging is turned off, macro doesn't need to expand to anything. */
+#endif
+
+/**
+ * @brief Checks if a function is successful when called. DEBUG_PRINTLNs an error message if it fails.
+ * @param function_call The function to call.
+ * @param success The function's success code/macro (e.g., U_SUCCESS, TX_SUCCESS, etc.).
+ * 
+ * @note This macro intentionally doesn't support custom error messages, for the sake of readability. If an error is complex enough to 
+ *       require a custom message, the error should probably be checked manually and DEBUG_PRINTLN() called directly.
+ */
+#define CATCH_ERROR(function_call, success) do { \
+    int _function_status = (function_call); \
+    if (_function_status != success) { \
+        DEBUG_PRINTLN("CATCH_ERROR(): Function failed: %s (Status: %d)", #function_call, _function_status); \
+        return _function_status; \
+    } \
+} while(0)
+
+/* Converts a ThreadX status macro to a printable string. */
+/* This function is intended to be used with DEBUG_PRINTLN(), and shouldn't really ever be used outside of debugging purposes. */
+/* (these macros are defined in tx_api.h) */
+const char* tx_status_toString(UINT status);
+
+/* Converts a STM32 HAL status macro to a printable string. */
+/* This function is intended to be used with DEBUG_PRINTLN(), and shouldn't really ever be used outside of debugging purposes. */
+/* (these macros are defined in stm32h5xx_hal_def.h) */
+const char* hal_status_toString(HAL_StatusTypeDef status);
+
+#endif

threadX/inc/u_debug.h

@@ -1,14 +1,10 @@
-
 #ifndef __U_GENERAL_H
 #define __U_GENERAL_H
 
-#include <string.h>
-#include <stdio.h>
-/* This file (and u_general.c) contain miscellaneous macros, functions, and configuration settings that can be used throughout the project. */
+#include "tx_port.h"
 
-/* General-purpose status macros. */
-#define U_SUCCESS     0
-#define U_ERROR       1
-#define U_QUEUE_EMPTY 2
+/* Time and tick conversions */
+#define MS_TO_TICKS(ms) (((ms) * TX_TIMER_TICKS_PER_SECOND + 999) / 1000)
+#define TICKS_TO_MS(ticks)  ((ticks) * 1000 / TX_TIMER_TICKS_PER_SECOND)
 
 #endif

threadX/inc/u_general.h

@@ -0,0 +1,38 @@
+#ifndef __U_QUEUES_H
+#define __U_QUEUES_H
+
+#include "tx_api.h"
+#include "u_debug.h"
+#include <stdint.h>
+
+/*
+*   Basically just a wrapper for ThreadX stuff. Lets you create/configure queues.
+*   
+*   Author: Blake Jackson
+*/
+
+/* Queue Config Macros */
+#define QUEUE_WAIT_TIME TX_NO_WAIT
+
+typedef struct {
+
+    /* PUBLIC: Queue Configuration Settings */
+    /* Set these when defining an instance of this struct. */
+    const CHAR *name;        /* Name of the queue */
+    const UINT message_size; /* Size of each message in the queue, in bytes. */
+    const UINT capacity;     /* Maximum number of messages in the queue */
+
+    /* PRIVATE: Internal implementation - DO NOT ACCESS DIRECTLY */
+    /* (should only be accessed by functions in u_queues.c) */
+    TX_QUEUE _TX_QUEUE;      /* Queue instance. */
+    size_t   _bytes;         /* Size of each queue message, in bytes. */
+    size_t   _words;         /* Size of each queue message, in 32-bit words. */
+} queue_t;
+
+
+/* API */
+uint8_t create_queue(TX_BYTE_POOL *byte_pool, queue_t *queue);
+uint8_t queue_send(queue_t *queue, void *message); // Sends a message to the specified queue.
+uint8_t queue_receive(queue_t *queue, void *message); // Receives a message from the specified queue
+
+#endif

threadX/inc/u_queues.h

@@ -2,9 +2,6 @@
 #include <stdint.h>
 #include <stdio.h>
 
-/* Initializes all threads. Called from app_threadx.c */
-uint8_t threads_init(TX_BYTE_POOL *byte_pool);
-
 typedef struct {
     /* PUBLIC: Thread Configuration Settings */
     /* Set these when defining an instance of this struct. */
@@ -21,4 +18,6 @@ typedef struct {
     /* PRIVATE: Internal implementation - DO NOT ACCESS DIRECTLY */
     /* (should only be accessed by functions in u_threads.c) */
     TX_THREAD _TX_THREAD;
-} thread_t;
+} thread_t;
+
+uint8_t create_thread(TX_BYTE_POOL *byte_pool, thread_t *thread);

threadX/inc/u_threads.h

@@ -0,0 +1,54 @@
+#include "u_debug.h"
+#include <stdio.h>
+
+const char* tx_status_toString(UINT status) {
+    switch(status) {
+        case TX_SUCCESS: return "TX_SUCCESS";
+        case TX_DELETED: return "TX_DELETED";
+        case TX_POOL_ERROR: return "TX_POOL_ERROR";
+        case TX_PTR_ERROR: return "TX_PTR_ERROR";
+        case TX_WAIT_ERROR: return "TX_WAIT_ERROR";
+        case TX_SIZE_ERROR: return "TX_SIZE_ERROR";
+        case TX_GROUP_ERROR: return "TX_GROUP_ERROR";
+        case TX_NO_EVENTS: return "TX_NO_EVENTS";
+        case TX_OPTION_ERROR: return "TX_OPTION_ERROR";
+        case TX_QUEUE_ERROR: return "TX_QUEUE_ERROR";
+        case TX_QUEUE_EMPTY: return "TX_QUEUE_EMPTY";
+        case TX_QUEUE_FULL: return "TX_QUEUE_FULL";
+        case TX_SEMAPHORE_ERROR: return "TX_SEMAPHORE_ERROR";
+        case TX_NO_INSTANCE: return "TX_NO_INSTANCE";
+        case TX_THREAD_ERROR: return "TX_THREAD_ERROR";
+        case TX_PRIORITY_ERROR: return "TX_PRIORITY_ERROR";
+        case TX_NO_MEMORY: return "TX_NO_MEMORY"; // Same as TX_START_ERROR
+        case TX_DELETE_ERROR: return "TX_DELETE_ERROR";
+        case TX_RESUME_ERROR: return "TX_RESUME_ERROR";
+        case TX_CALLER_ERROR: return "TX_CALLER_ERROR";
+        case TX_SUSPEND_ERROR: return "TX_SUSPEND_ERROR";
+        case TX_TIMER_ERROR: return "TX_TIMER_ERROR";
+        case TX_TICK_ERROR: return "TX_TICK_ERROR";
+        case TX_ACTIVATE_ERROR: return "TX_ACTIVATE_ERROR";
+        case TX_THRESH_ERROR: return "TX_THRESH_ERROR";
+        case TX_SUSPEND_LIFTED: return "TX_SUSPEND_LIFTED";
+        case TX_WAIT_ABORTED: return "TX_WAIT_ABORTED";
+        case TX_WAIT_ABORT_ERROR: return "TX_WAIT_ABORT_ERROR";
+        case TX_MUTEX_ERROR: return "TX_MUTEX_ERROR";
+        case TX_NOT_AVAILABLE: return "TX_NOT_AVAILABLE";
+        case TX_NOT_OWNED: return "TX_NOT_OWNED";
+        case TX_INHERIT_ERROR: return "TX_INHERIT_ERROR";
+        case TX_NOT_DONE: return "TX_NOT_DONE";
+        case TX_CEILING_EXCEEDED: return "TX_CEILING_EXCEEDED";
+        case TX_INVALID_CEILING: return "TX_INVALID_CEILING";
+        case TX_FEATURE_NOT_ENABLED: return "TX_FEATURE_NOT_ENABLED";
+        default: return "UNKNOWN_STATUS";
+    }
+}
+
+const char* hal_status_toString(HAL_StatusTypeDef status) {
+    switch(status) {
+        case HAL_OK: return "HAL_OK";
+        case HAL_ERROR: return "HAL_ERROR";
+        case HAL_BUSY: return "HAL_BUSY";
+        case HAL_TIMEOUT: return "HAL_TIMEOUT";
+        default: return "UNKNOWN_STATUS";
+    }
+}

threadX/src/threadX_utils.c

@@ -0,0 +1,85 @@
+
+#include "u_queues.h"
+
+uint8_t create_queue(TX_BYTE_POOL *byte_pool, queue_t *queue) {
+    uint8_t status;
+    void *pointer;
+
+    /* Calculate message size in 32-bit words (round up), and then validate it. */
+    /* According to the Azure RTOS ThreadX Docs, "message sizes range from 1 32-bit word to 16 32-bit words". */
+    /* Basically, queue messages have to be a multiple of 4 bytes? Kinda weird but this should handle it. */
+    UINT message_size_words = (queue->message_size + 3) / 4;
+    if (message_size_words < 1 || message_size_words > 16) {
+        DEBUG_PRINTLN("ERROR: Invalid message size %d bytes (must be 1-64 bytes). Queue: %s", queue->message_size, queue->name);
+        return U_ERROR;
+    }
+
+    /* Store metadata */
+    queue->_bytes = queue->message_size;
+    queue->_words = message_size_words;
+
+    /* Calculate total queue size in bytes. */
+    int queue_size_bytes = message_size_words * 4 * queue->capacity;
+
+    /* Allocate the stack for the queue. */
+    status = tx_byte_allocate(byte_pool, (VOID**) &pointer, queue_size_bytes, TX_NO_WAIT);
+    if(status != TX_SUCCESS) {
+        DEBUG_PRINTLN("ERROR: Failed to allocate memory before creating queue (Status: %d/%s, Queue: %s).", status, tx_status_toString(status), queue->name);
+        return U_ERROR;
+    }
+
+    /* Create the queue */
+    status = tx_queue_create(&queue->_TX_QUEUE, (CHAR*)queue->name, message_size_words, pointer, queue_size_bytes);
+    if (status != TX_SUCCESS) {
+        DEBUG_PRINTLN("ERROR: Failed to create queue (Status: %d/%s, Queue: %s).", status, tx_status_toString(status), queue->name);
+        tx_byte_release(pointer); // Free allocated memory if queue creation fails
+        return U_ERROR;
+    }
+
+    return U_SUCCESS;
+
+}
+
+uint8_t queue_send(queue_t *queue, void *message) {
+    UINT status;
+
+    /* Create a buffer. */
+    uint32_t buffer[queue->_words];     // Max size is 16 words (64 bytes).
+    memset(buffer, 0, sizeof(buffer)); // Initialize buffer to zero
+
+    /* Copy message into the buffer. The buffer is what actually gets sent to the queue. */
+    memcpy(buffer, message, queue->_bytes);
+
+    /* Send message (buffer) to the queue. */
+    status = tx_queue_send(&queue->_TX_QUEUE, buffer, QUEUE_WAIT_TIME);
+    if(status != TX_SUCCESS) {
+        DEBUG_PRINTLN("ERROR: Failed to send message to queue (Status: %d/%s, Queue: %s).", status, tx_status_toString(status), queue->_TX_QUEUE.tx_queue_name);
+        return U_ERROR;
+    }
+
+    return U_SUCCESS;
+}
+
+uint8_t  queue_receive(queue_t *queue, void *message) {
+    UINT status;
+
+    /* Create a buffer */
+    uint32_t buffer[queue->_words];    // Max size is 16 words (64 bytes).
+    memset(buffer, 0, sizeof(buffer)); // Initialize buffer to zero
+
+    /* Receive message from the queue. */
+    status = tx_queue_receive(&queue->_TX_QUEUE, buffer, QUEUE_WAIT_TIME);
+    if(status == TX_QUEUE_EMPTY) {
+        return U_QUEUE_EMPTY;
+    }
+
+    if((status != TX_SUCCESS)) {
+        DEBUG_PRINTLN("ERROR: Failed to receive message from queue (Status: %d/%s, Queue: %s).", status, tx_status_toString(status), queue->_TX_QUEUE.tx_queue_name);
+        return U_ERROR;
+    }
+
+    /* Copy the data from the buffer into the message pointer. Using memcpy() here prevents memory overflow. */
+    memcpy(message, buffer, queue->_bytes);
+
+    return U_SUCCESS;
+}

threadX/src/u_debug.c

@@ -0,0 +1,25 @@
+
+#include "u_threads.h"
+#include "u_debug.h"
+
+uint8_t create_thread(TX_BYTE_POOL *byte_pool, thread_t *thread) {
+    CHAR *pointer;
+    uint8_t status;
+
+    /* Allocate the stack for the thread. */
+    status = tx_byte_allocate(byte_pool, (VOID**) &pointer, thread->size, TX_NO_WAIT);
+    if(status != TX_SUCCESS) {
+        DEBUG_PRINTLN("ERROR: Failed to allocate stack before creating thread (Status: %d/%s, Thread: %s).", status, tx_status_toString(status), thread->name);
+        return U_ERROR;
+    }
+
+    /* Create the thread. */
+    status = tx_thread_create(&thread->_TX_THREAD, (CHAR*)thread->name, thread->function, thread->thread_input, pointer, thread->size, thread->priority, thread->threshold, thread->time_slice, thread->auto_start);
+    if(status != TX_SUCCESS) {
+        DEBUG_PRINTLN("ERROR: Failed to create thread (Status: %d/%s, Thread: %s).", status, tx_status_toString(status), thread->name);
+        tx_byte_release(pointer); // Free allocated memory if thread creation fails
+        return U_ERROR;
+    }
+    
+    return U_SUCCESS;
+}