didas/incphub_test
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: Renamed incphub to libshunt

Browse Source
This commit is contained in:
Diogo Diniz
2026-07-01 17:54:07 +01:00
parent ff8d7914a9
commit 14ca6d651b
18 changed files with 280 additions and 276 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
app/CMakeLists.txt
View File

@@ -31,7 +31,7 @@ add_executable(${EXECUTABLE} "")
# Set compiler/linker options # Set compiler/linker options
target_compile_definitions(${EXECUTABLE} PRIVATE target_compile_definitions(${EXECUTABLE} PRIVATE
${COMPILER_DEFINES} ${COMPILER_DEFINES}
INCPHUB_LOCAL_NIL_ADDR=1 LIBSHUNT_LOCAL_NIL_ADDR=1
) )
target_compile_options(${EXECUTABLE} PRIVATE target_compile_options(${EXECUTABLE} PRIVATE
-Wall -Wall

2
app/src/CMakeLists.txt
View File

@@ -1,5 +1,5 @@
add_subdirectory(tasks) add_subdirectory(tasks)
add_subdirectory(incphub) add_subdirectory(libshunt)
add_subdirectory(nil) add_subdirectory(nil)
add_subdirectory(ntl) add_subdirectory(ntl)

35
app/src/incphub/README.md
View File

@@ -1,35 +0,0 @@
# INCPHUB
## FreeRTOS requirements
- INCLUDE_xTaskGetCurrentTaskHandle set to 1
- INCLUDE_vTaskSuspend set to 1
- configUSE_TASK_NOTIFICATIONS set to 1
- configTASK_NOTIFICATION_ARRAY_ENTRIES set to >= 2 (0 is for stream/message buffers, 1(configurable) is used by incphub)
- configUSE_MUTEXES set to 1
## Configuration
Set as a macro in compile flags if wishing to override the defaults
- INCPHUB_TASKINDEX_MAILBOX, defaults to 1 (avoid using 0)
## Setup
- incphub_task_preinit MUST be run before any calls to the client, likely even before the scheduler is started
## IPC flow
Ingest (accepting of messages into incphub) is done via queue (many to one)
Dispatch (internal routing to local task) is done via direct-to-task notifications (see INCPHUB_TASKINDEX_MAILBOX) by passing the message buffer pointer
## Buffer ownership
Buffers are allocated with incphub_get_msg_buffer, at which point they belong to the requesting task.
When passed to incphub_send_XXX functions, they become owned by incphub
When dispatched internally, the receiving task becomes the owner and must invoke incphub_release_msg_buffer when done
When routed externally, after calling the transmitter function, incphub releases the buffer

17
app/src/incphub/include/incphub/incphub_task.h
View File

@@ -1,17 +0,0 @@
#ifndef INCPHUB_TASK_H_
#define INCPHUB_TASK_H_
#include "FreeRTOS.h"
#include "task.h"
#include "FreeRTOSConfig.h"
#define INCPHUB_TASK_STACK_DEPTH configMINIMAL_STACK_SIZE
#define INCPHUB_TASK_PRIORITY (configMAX_PRIORITIES - 1)
extern StackType_t _incphub_task_stack[INCPHUB_TASK_STACK_DEPTH];
extern StaticTask_t _incphub_task;
void incphub_task_preinit();
void incphub_task_main(void *params);
#endif

30
app/src/incphub/src/incphub_config.h
View File

@@ -1,30 +0,0 @@
// incphub_config.h - Default configurations for incphub
#ifndef INCPHUB_CONFIG_H_
#define INCPHUB_CONFIG_H_
#ifndef INCPHUB_TASKINDEX_MAILBOX
/// @brief Index of direct-to-task notification for mailbox to use
#define INCPHUB_TASKINDEX_MAILBOX 1
#endif
#ifndef INCPHUB_MAX_CLIENTS
/// @brief Number of client slots to allocate
#define INCPHUB_MAX_CLIENTS 8
#endif
#ifndef INCPHUB_MSG_BUFFER_SIZE
/// @brief Message buffer size in bytes. Must allow space for NIL and NTL headers
#define INCPHUB_MSG_BUFFER_SIZE 32
#endif
#ifndef INCPHUB_MSG_BUFFER_COUNT
/// @brief Number of message buffers to allocate
#define INCPHUB_MSG_BUFFER_COUNT 8
#endif
#ifndef INCPHUB_LOCAL_NIL_ADDR
#error "Local NIL address must be specified with INCPHUB_LOCAL_NIL_ADDR"
#endif
#endif

6
app/src/incphub/CMakeLists.txt → app/src/libshunt/CMakeLists.txt
View File

@@ -1,7 +1,7 @@
target_sources(${EXECUTABLE} PRIVATE target_sources(${EXECUTABLE} PRIVATE
src/incphub_client.c src/shunt_client.c
src/incphub_task.c src/shunt_task.c
src/incphub_shared.c src/shunt_shared.c
) )
target_include_directories(${EXECUTABLE} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include) target_include_directories(${EXECUTABLE} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/include)

37
app/src/libshunt/README.md Normal file
View File

@@ -0,0 +1,37 @@
# LibShunt
Shunts messages, like trains
## FreeRTOS requirements
- INCLUDE_xTaskGetCurrentTaskHandle set to 1
- INCLUDE_vTaskSuspend set to 1
- configUSE_TASK_NOTIFICATIONS set to 1
- configTASK_NOTIFICATION_ARRAY_ENTRIES set to >= 2 (0 is for stream/message buffers, 1(configurable) is used by libshunt)
- configUSE_MUTEXES set to 1
## Configuration
Set as a macro in compile flags if wishing to override the defaults
- LIBSHUNT_TASKINDEX_MAILBOX, defaults to 1 (avoid using 0)
## Setup
- libshunt_task_preinit MUST be run before any calls to the client, likely even before the scheduler is started
## IPC flow
Ingest (accepting of messages into libshunt) is done via queue (many to one)
Dispatch (internal routing to local task) is done via direct-to-task notifications (see LIBSHUNT_TASKINDEX_MAILBOX) by passing the message buffer pointer
## Buffer ownership
Buffers are allocated with shunt_get_msg_buffer, at which point they belong to the requesting task.
When passed to libshunt_send_XXX functions, they become owned by libshunt
When dispatched internally, the receiving task becomes the owner and must invoke shunt_release_msg_buffer when done
When routed externally, after calling the transmitter function, libshunt releases the buffer

24
app/src/incphub/include/incphub/incphub.h → app/src/libshunt/include/libshunt/libshunt.h
View File

@@ -1,31 +1,31 @@
// incphub.h - Public definitions common to incphub and incphub client // libshunt.h - Public definitions common to all libshunt components
#ifndef INCPHUB_H_ #ifndef LIBSHUNT_H_
#define INCPHUB_H_ #define LIBSHUNT_H_
#include "ntl/ntl.h" #include "ntl/ntl.h"
#include "nil/nil.h" #include "nil/nil.h"
/// @brief Success /// @brief Success
#define INCPHUB_OK (0) #define LIBSHUNT_OK (0)
/// @brief Unspecified error /// @brief Unspecified error
#define INCPHUB_ERR (1) #define LIBSHUNT_ERR (1)
/// @brief Invalid argument /// @brief Invalid argument
#define INCPHUB_EINVAL (2) #define LIBSHUNT_EINVAL (2)
/// @brief Resource or entry not found /// @brief Resource or entry not found
#define INCPHUB_ENOTFOUND (3) #define LIBSHUNT_ENOTFOUND (3)
/// @brief Resource in use /// @brief Resource in use
#define INCPHUB_EBUSY (4) #define LIBSHUNT_EBUSY (4)
/// @brief Resource temporarily unavailable /// @brief Resource temporarily unavailable
#define INCPHUB_EAGAIN (5) #define LIBSHUNT_EAGAIN (5)
/// @brief Could not allocate memory /// @brief Could not allocate memory
#define INCPHUB_ENOMEM (6) #define LIBSHUNT_ENOMEM (6)
/// @brief Packet failed integrity checks /// @brief Packet failed integrity checks
#define INCPHUB_BAD_PACKET (7) #define LIBSHUNT_BAD_PACKET (7)
typedef struct { typedef struct {
nil_addr_t addr; nil_addr_t addr;
ntl_port_t port; ntl_port_t port;
} incphub_addr_t; } shunt_addr_t;
#endif #endif

34
app/src/incphub/include/incphub/incphub_client.h → app/src/libshunt/include/libshunt/shunt_client.h
View File

@@ -1,40 +1,40 @@
// incphub_client.h - Public interface of incphub client side // shunt_client.h - Public interface of libshunt client side
#ifndef INCPHUB_CLIENT_H_ #ifndef LIBSHUNT_CLIENT_H_
#define INCPHUB_CLIENT_H_ #define LIBSHUNT_CLIENT_H_
#include <stddef.h> #include <stddef.h>
#include "FreeRTOS.h" #include "FreeRTOS.h"
#include "incphub/incphub.h" #include "libshunt/libshunt.h"
#include "nil/nil.h" #include "nil/nil.h"
#include "ntl/ntl.h" #include "ntl/ntl.h"
typedef struct incphub_cli_t incphub_cli_t; typedef struct shunt_cli_t shunt_cli_t;
/// @brief Initializes an incphub client /// @brief Initializes an libshunt client
/// @param port The port number to assign to the caller /// @param port The port number to assign to the caller
/// @return INCPHUB_OK on success, an error otherwise /// @return LIBSHUNT_OK on success, an error otherwise
int incphub_init_client(incphub_cli_t **cli, ntl_port_t port); int shunt_init_client(shunt_cli_t **cli, ntl_port_t port);
/// @brief Attempts to get a free message buffer from the central storage space /// @brief Attempts to get a free message buffer from the central storage space
/// @param cli Current client handle /// @param cli Current client handle
/// @param buffer_ptr Location to return the buffer /// @param buffer_ptr Location to return the buffer
/// @param length The minimum size, in bytes, of the buffer get /// @param length The minimum size, in bytes, of the buffer get
/// @return INCPHUB_OK on success, an error otherwise /// @return LIBSHUNT_OK on success, an error otherwise
int incphub_get_msg_buffer(incphub_cli_t *cli, uint8_t **buffer_ptr, size_t length); int shunt_get_msg_buffer(shunt_cli_t *cli, uint8_t **buffer_ptr, size_t length);
/// @brief Releases a buffer received from incphub_await_msg /// @brief Releases a buffer received from shunt_await_msg
/// @param cli Current client handle /// @param cli Current client handle
/// @param buffer The buffer to release /// @param buffer The buffer to release
/// @return INCPHUB_OK on success, an error otherwise /// @return LIBSHUNT_OK on success, an error otherwise
int incphub_release_msg_buffer(incphub_cli_t *cli, uint8_t *buffer); int shunt_release_msg_buffer(shunt_cli_t *cli, uint8_t *buffer);
/// @brief Attempts to send a message /// @brief Attempts to send a message
/// @param cli Current client handle /// @param cli Current client handle
@@ -42,8 +42,8 @@ int incphub_release_msg_buffer(incphub_cli_t *cli, uint8_t *buffer);
/// @param length The message length /// @param length The message length
/// @param dst_addr The destination address /// @param dst_addr The destination address
/// @param max_delay The maximum time to wait for a resources, in ticks /// @param max_delay The maximum time to wait for a resources, in ticks
/// @return INCPHUB_OK on success, an error otherwise /// @return LIBSHUNT_OK on success, an error otherwise
int incphub_send_msg(incphub_cli_t *cli, uint8_t *buffer, size_t length, incphub_addr_t dst, TickType_t max_delay); int shunt_send_msg(shunt_cli_t *cli, uint8_t *buffer, size_t length, shunt_addr_t dst, TickType_t max_delay);
/// @brief Awaits the receival of a message /// @brief Awaits the receival of a message
/// @param cli Current client handle /// @param cli Current client handle
@@ -51,7 +51,7 @@ int incphub_send_msg(incphub_cli_t *cli, uint8_t *buffer, size_t length, incphub
/// @param length_ptr Location to return the length /// @param length_ptr Location to return the length
/// @param source_ptr Location to return the message sender /// @param source_ptr Location to return the message sender
/// @param max_delay The maximum time to wait for a message, in ticks /// @param max_delay The maximum time to wait for a message, in ticks
/// @return INCPHUB_OK on success, an error otherwise /// @return LIBSHUNT_OK on success, an error otherwise
int incphub_await_msg(incphub_cli_t *cli, uint8_t **buffer_ptr, size_t *length_ptr, incphub_addr_t *source_ptr, TickType_t max_delay); int shunt_await_msg(shunt_cli_t *cli, uint8_t **buffer_ptr, size_t *length_ptr, shunt_addr_t *source_ptr, TickType_t max_delay);
#endif #endif

19
app/src/libshunt/include/libshunt/shunt_task.h Normal file
View File

@@ -0,0 +1,19 @@
// shunt_task.h - Public interface to launch the libshunt FreeRTOS task
#ifndef LIBSHUNT_TASK_H_
#define LIBSHUNT_TASK_H_
#include "FreeRTOS.h"
#include "task.h"
#include "FreeRTOSConfig.h"
#define LIBSHUNT_TASK_STACK_DEPTH configMINIMAL_STACK_SIZE
#define LIBSHUNT_TASK_PRIORITY (configMAX_PRIORITIES - 1)
extern StackType_t _libshunt_task_stack[LIBSHUNT_TASK_STACK_DEPTH];
extern StaticTask_t _libshunt_task;
void libshunt_task_preinit();
void libshunt_task_main(void *params);
#endif

60
app/src/incphub/src/incphub_client.c → app/src/libshunt/src/shunt_client.c
View File

@@ -1,10 +1,10 @@
#include <stdbool.h> #include <stdbool.h>
#include "incphub/incphub_client.h" #include "libshunt/shunt_client.h"
#include "incphub/incphub_task.h" #include "libshunt/shunt_task.h"
#include "incphub/incphub.h" #include "libshunt/libshunt.h"
#include "incphub_config.h" #include "shunt_config.h"
#include "incphub_shared.h" #include "shunt_shared.h"
#include "ntl/ntl.h" #include "ntl/ntl.h"
#include "nil/nil.h" #include "nil/nil.h"
@@ -13,24 +13,24 @@
int incphub_init_client(incphub_cli_t **cli, ntl_port_t port) int shunt_init_client(shunt_cli_t **cli, ntl_port_t port)
{ {
return register_client(cli, port, xTaskGetCurrentTaskHandle()); return register_client(cli, port, xTaskGetCurrentTaskHandle());
} }
int incphub_get_msg_buffer(incphub_cli_t *cli, uint8_t **buffer_ptr, size_t length) int shunt_get_msg_buffer(shunt_cli_t *cli, uint8_t **buffer_ptr, size_t length)
{ {
if (cli == NULL) if (cli == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
if (buffer_ptr == NULL) if (buffer_ptr == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
// Request extra space for NIL/NTL headers // Request extra space for NIL/NTL headers
size_t extended_len = sizeof(nil_header_t) + sizeof(ntl_header_t) + length; size_t extended_len = sizeof(nil_header_t) + sizeof(ntl_header_t) + length;
uint8_t *buf; uint8_t *buf;
int status = get_msg_buffer(&buf, extended_len); int status = get_msg_buffer(&buf, extended_len);
if (status != INCPHUB_OK) if (status != LIBSHUNT_OK)
return status; return status;
// Reserve space for NIL/NTL headers // Reserve space for NIL/NTL headers
@@ -39,15 +39,15 @@ int incphub_get_msg_buffer(incphub_cli_t *cli, uint8_t **buffer_ptr, size_t leng
// Return buffer // Return buffer
*buffer_ptr = buf; *buffer_ptr = buf;
return INCPHUB_OK; return LIBSHUNT_OK;
} }
int incphub_release_msg_buffer(incphub_cli_t *cli, uint8_t *buffer) int shunt_release_msg_buffer(shunt_cli_t *cli, uint8_t *buffer)
{ {
if (cli == NULL) if (cli == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
if (buffer == NULL) if (buffer == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
// cli requested for interface consistency only (for now) // cli requested for interface consistency only (for now)
(void)cli; (void)cli;
@@ -59,14 +59,14 @@ int incphub_release_msg_buffer(incphub_cli_t *cli, uint8_t *buffer)
return release_msg_buffer(unwound); return release_msg_buffer(unwound);
} }
int incphub_send_msg(incphub_cli_t *cli, uint8_t *buffer, size_t length, incphub_addr_t dst, TickType_t max_delay) int shunt_send_msg(shunt_cli_t *cli, uint8_t *buffer, size_t length, shunt_addr_t dst, TickType_t max_delay)
{ {
if (cli == NULL) if (cli == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
if (buffer == NULL) if (buffer == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
if (dst.port == NTL_PORT_EMPTY) if (dst.port == NTL_PORT_EMPTY)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
// Unwind buffer pointer // Unwind buffer pointer
ntl_packet_t *ntl_packet = (ntl_packet_t*)((uint8_t*)buffer - sizeof(ntl_header_t)); ntl_packet_t *ntl_packet = (ntl_packet_t*)((uint8_t*)buffer - sizeof(ntl_header_t));
@@ -76,47 +76,47 @@ int incphub_send_msg(incphub_cli_t *cli, uint8_t *buffer, size_t length, incphub
ntl_build_header(&ntl_packet->header, dst.port, cli->port, length); ntl_build_header(&ntl_packet->header, dst.port, cli->port, length);
// Populate NIL header // Populate NIL header
nil_build_header(&nil_packet->header, dst.addr, INCPHUB_LOCAL_NIL_ADDR, length + sizeof(ntl_header_t)); nil_build_header(&nil_packet->header, dst.addr, LIBSHUNT_LOCAL_NIL_ADDR, length + sizeof(ntl_header_t));
// Pass to ingest // Pass to ingest
return enqueue_message_ingest((uint8_t *)nil_packet, max_delay); return enqueue_message_ingest((uint8_t *)nil_packet, max_delay);
} }
int incphub_await_msg(incphub_cli_t *cli, uint8_t **buffer_ptr, size_t *length_ptr, incphub_addr_t *source_ptr, TickType_t max_delay) int shunt_await_msg(shunt_cli_t *cli, uint8_t **buffer_ptr, size_t *length_ptr, shunt_addr_t *source_ptr, TickType_t max_delay)
{ {
if (cli == NULL) if (cli == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
if (buffer_ptr == NULL) if (buffer_ptr == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
if (length_ptr == NULL) if (length_ptr == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
if (source_ptr == NULL) if (source_ptr == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
// cli requested for interface consistency only (for now) // cli requested for interface consistency only (for now)
(void)cli; (void)cli;
uint8_t *buffer; uint8_t *buffer;
int err = await_message_dispatch(&buffer, max_delay); int err = await_message_dispatch(&buffer, max_delay);
if (err != INCPHUB_OK) if (err != LIBSHUNT_OK)
{ {
return err; return err;
} }
// Extract header information // Extract header information
nil_packet_t *nil = extract_nil_packet(buffer, INCPHUB_MSG_BUFFER_SIZE); nil_packet_t *nil = extract_nil_packet(buffer, LIBSHUNT_MSG_BUFFER_SIZE);
if (nil == NULL) if (nil == NULL)
{ {
return INCPHUB_BAD_PACKET; return LIBSHUNT_BAD_PACKET;
} }
ntl_packet_t *ntl = extract_ntl_packet(nil); ntl_packet_t *ntl = extract_ntl_packet(nil);
if (nil == NULL) if (nil == NULL)
{ {
return INCPHUB_BAD_PACKET; return LIBSHUNT_BAD_PACKET;
} }
// Build source spec // Build source spec
incphub_addr_t source = { 0 }; shunt_addr_t source = { 0 };
source.addr = nil->header.src_addr; source.addr = nil->header.src_addr;
source.port = ntl->header.src_port; source.port = ntl->header.src_port;
@@ -125,5 +125,5 @@ int incphub_await_msg(incphub_cli_t *cli, uint8_t **buffer_ptr, size_t *length_p
*length_ptr = ntl->header.len; *length_ptr = ntl->header.len;
*source_ptr = source; *source_ptr = source;
return INCPHUB_OK; return LIBSHUNT_OK;
} }

30
app/src/libshunt/src/shunt_config.h Normal file
View File

@@ -0,0 +1,30 @@
// shunt_config.h - Default configurations for libshunt
#ifndef LIBSHUNT_CONFIG_H_
#define LIBSHUNT_CONFIG_H_
#ifndef LIBSHUNT_TASKINDEX_MAILBOX
/// @brief Index of direct-to-task notification for mailbox to use
#define LIBSHUNT_TASKINDEX_MAILBOX 1
#endif
#ifndef LIBSHUNT_MAX_CLIENTS
/// @brief Number of client slots to allocate
#define LIBSHUNT_MAX_CLIENTS 8
#endif
#ifndef LIBSHUNT_MSG_BUFFER_SIZE
/// @brief Message buffer size in bytes. Must allow space for NIL and NTL headers
#define LIBSHUNT_MSG_BUFFER_SIZE 32
#endif
#ifndef LIBSHUNT_MSG_BUFFER_COUNT
/// @brief Number of message buffers to allocate
#define LIBSHUNT_MSG_BUFFER_COUNT 8
#endif
#ifndef LIBSHUNT_LOCAL_NIL_ADDR
#error "Local NIL address must be specified with LIBSHUNT_LOCAL_NIL_ADDR"
#endif
#endif

132
app/src/incphub/src/incphub_shared.c → app/src/libshunt/src/shunt_shared.c
View File

@@ -1,4 +1,4 @@
#include "incphub_shared.h" #include "shunt_shared.h"
#include <string.h> #include <string.h>
#include <stdbool.h> #include <stdbool.h>
@@ -8,15 +8,15 @@
#include "semphr.h" #include "semphr.h"
#include "task.h" #include "task.h"
#include "incphub/incphub.h" #include "libshunt/libshunt.h"
#include "incphub_config.h" #include "shunt_config.h"
#include "nil/nil.h" #include "nil/nil.h"
#if UINTPTR_MAX > UINT32_MAX #if UINTPTR_MAX > UINT32_MAX
#error "Pointers of 32-bits or less are required for incphub mailbox to function correctly." #error "Pointers of 32-bits or less are required for libshunt mailbox to function correctly."
#endif #endif
@@ -24,16 +24,16 @@
// === Private variables === // === Private variables ===
// Global lock // Global lock
static SemaphoreHandle_t _incphub_lock; static SemaphoreHandle_t _libshunt_lock;
static StaticSemaphore_t _incphub_lock_store; static StaticSemaphore_t _libshunt_lock_store;
// Clients // Clients
static incphub_cli_t _clients[INCPHUB_MAX_CLIENTS]; static shunt_cli_t _clients[LIBSHUNT_MAX_CLIENTS];
// Message buffers // Message buffers
// INCPHUB_MSG_BUFFER_COUNT buffers of INCPHUB_MSG_BUFFER_SIZE bytes // LIBSHUNT_MSG_BUFFER_COUNT buffers of LIBSHUNT_MSG_BUFFER_SIZE bytes
static uint8_t _msg_buffers[INCPHUB_MSG_BUFFER_COUNT][INCPHUB_MSG_BUFFER_SIZE]; static uint8_t _msg_buffers[LIBSHUNT_MSG_BUFFER_COUNT][LIBSHUNT_MSG_BUFFER_SIZE];
static bool _msg_buffer_used[INCPHUB_MSG_BUFFER_COUNT]; static bool _msg_buffer_used[LIBSHUNT_MSG_BUFFER_COUNT];
@@ -41,9 +41,9 @@ static bool _msg_buffer_used[INCPHUB_MSG_BUFFER_COUNT];
static bool global_lock(TickType_t max_delay); static bool global_lock(TickType_t max_delay);
static void global_unlock(); static void global_unlock();
/// @remark Returns NULL if not found /// @remark Returns NULL if not found
static incphub_cli_t *find_empty_client(); static shunt_cli_t *find_empty_client();
/// @remark Returns NULL if not found /// @remark Returns NULL if not found
static incphub_cli_t *find_client_with_port(ntl_port_t port); static shunt_cli_t *find_client_with_port(ntl_port_t port);
/// @remark Returns NULL if not found /// @remark Returns NULL if not found
static uint8_t *find_unused_buffer(); static uint8_t *find_unused_buffer();
/// @remark Returns -1 if not found /// @remark Returns -1 if not found
@@ -54,35 +54,35 @@ static int find_index_of_buffer(uint8_t *buffer);
// === Public functions === // === Public functions ===
int internal_init() int internal_init()
{ {
_incphub_lock = xSemaphoreCreateMutexStatic(&_incphub_lock_store); _libshunt_lock = xSemaphoreCreateMutexStatic(&_libshunt_lock_store);
memset(_clients, 0, sizeof(_clients)); memset(_clients, 0, sizeof(_clients));
memset(_msg_buffer_used, 0, sizeof(_msg_buffer_used)); memset(_msg_buffer_used, 0, sizeof(_msg_buffer_used));
return INCPHUB_OK; return LIBSHUNT_OK;
} }
int register_client(incphub_cli_t **cli_ptr, ntl_port_t port, TaskHandle_t task) int register_client(shunt_cli_t **cli_ptr, ntl_port_t port, TaskHandle_t task)
{ {
if (port == NTL_PORT_EMPTY) if (port == NTL_PORT_EMPTY)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
if (cli_ptr == NULL) if (cli_ptr == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
// == Enter == // == Enter ==
if (!global_lock(portMAX_DELAY)) if (!global_lock(portMAX_DELAY))
return INCPHUB_EAGAIN; return LIBSHUNT_EAGAIN;
// Prevent double binding of ports // Prevent double binding of ports
if (find_client_with_port(port) != NULL) if (find_client_with_port(port) != NULL)
{ {
global_unlock(); global_unlock();
return INCPHUB_EBUSY; return LIBSHUNT_EBUSY;
} }
incphub_cli_t *client = find_empty_client(); shunt_cli_t *client = find_empty_client();
if (client == NULL) if (client == NULL)
{ {
global_unlock(); global_unlock();
return INCPHUB_EBUSY; return LIBSHUNT_EBUSY;
} }
// Populate client data // Populate client data
@@ -93,43 +93,43 @@ int register_client(incphub_cli_t **cli_ptr, ntl_port_t port, TaskHandle_t task)
*cli_ptr = client; *cli_ptr = client;
global_unlock(); global_unlock();
return INCPHUB_OK; return LIBSHUNT_OK;
} }
int get_msg_buffer(uint8_t **buffer_ptr, size_t len) int get_msg_buffer(uint8_t **buffer_ptr, size_t len)
{ {
if (buffer_ptr == NULL) if (buffer_ptr == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
if (len > INCPHUB_MSG_BUFFER_SIZE) if (len > LIBSHUNT_MSG_BUFFER_SIZE)
return INCPHUB_ENOMEM; return LIBSHUNT_ENOMEM;
// == Enter == // == Enter ==
if (!global_lock(portMAX_DELAY)) if (!global_lock(portMAX_DELAY))
return INCPHUB_EAGAIN; return LIBSHUNT_EAGAIN;
//TODO: Allow buffer to be given by another layer (below NIL/NTL) //TODO: Allow buffer to be given by another layer (below NIL/NTL)
uint8_t *buf = find_unused_buffer(); uint8_t *buf = find_unused_buffer();
if (buf == NULL) if (buf == NULL)
{ {
global_unlock(); global_unlock();
return INCPHUB_ENOMEM; return LIBSHUNT_ENOMEM;
} }
// Return buffer // Return buffer
*buffer_ptr = buf; *buffer_ptr = buf;
global_unlock(); global_unlock();
return INCPHUB_OK; return LIBSHUNT_OK;
} }
int release_msg_buffer(uint8_t *buffer) int release_msg_buffer(uint8_t *buffer)
{ {
if (buffer == NULL) if (buffer == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
// == Enter == // == Enter ==
if (!global_lock(portMAX_DELAY)) if (!global_lock(portMAX_DELAY))
return INCPHUB_EAGAIN; return LIBSHUNT_EAGAIN;
int index = find_index_of_buffer(buffer); int index = find_index_of_buffer(buffer);
@@ -137,47 +137,47 @@ int release_msg_buffer(uint8_t *buffer)
if (index == -1) if (index == -1)
{ {
global_unlock(); global_unlock();
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
} }
// Handle not-in-use buffers // Handle not-in-use buffers
if (_msg_buffer_used[index] == false) if (_msg_buffer_used[index] == false)
{ {
global_unlock(); global_unlock();
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
} }
// Mark buffer as free // Mark buffer as free
_msg_buffer_used[index] = false; _msg_buffer_used[index] = false;
global_unlock(); global_unlock();
return INCPHUB_OK; return LIBSHUNT_OK;
} }
int get_client_with_port(ntl_port_t port, incphub_cli_t **client_ptr) int get_client_with_port(ntl_port_t port, shunt_cli_t **client_ptr)
{ {
if (port == NTL_PORT_EMPTY) if (port == NTL_PORT_EMPTY)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
if (client_ptr == NULL) if (client_ptr == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
// == Enter == // == Enter ==
if (!global_lock(portMAX_DELAY)) if (!global_lock(portMAX_DELAY))
return INCPHUB_EAGAIN; return LIBSHUNT_EAGAIN;
// Map port to client // Map port to client
incphub_cli_t *client = find_client_with_port(port); shunt_cli_t *client = find_client_with_port(port);
if (client == NULL) if (client == NULL)
{ {
global_unlock(); global_unlock();
return INCPHUB_ENOTFOUND; return LIBSHUNT_ENOTFOUND;
} }
// Return client // Return client
*client_ptr = client; *client_ptr = client;
global_unlock(); global_unlock();
return INCPHUB_OK; return LIBSHUNT_OK;
} }
int enqueue_message_ingest(uint8_t *buffer, TickType_t max_delay) int enqueue_message_ingest(uint8_t *buffer, TickType_t max_delay)
@@ -185,15 +185,15 @@ int enqueue_message_ingest(uint8_t *buffer, TickType_t max_delay)
//NOTE: Does not need global lock //NOTE: Does not need global lock
if (buffer == NULL) if (buffer == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
// Try to queue message // Try to queue message
if (xQueueSendToBack(incphub_ingest_queue, &buffer, max_delay) != pdPASS) if (xQueueSendToBack(libshunt_ingest_queue, &buffer, max_delay) != pdPASS)
{ {
return INCPHUB_EAGAIN; return LIBSHUNT_EAGAIN;
} }
return INCPHUB_OK; return LIBSHUNT_OK;
} }
int dequeue_message_ingest(uint8_t **buffer_ptr, TickType_t max_delay) int dequeue_message_ingest(uint8_t **buffer_ptr, TickType_t max_delay)
@@ -201,39 +201,39 @@ int dequeue_message_ingest(uint8_t **buffer_ptr, TickType_t max_delay)
//NOTE: Does not need global lock //NOTE: Does not need global lock
if (buffer_ptr == NULL) if (buffer_ptr == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
uint8_t *buffer; uint8_t *buffer;
// Try to dequeue message // Try to dequeue message
if (xQueueReceive(incphub_ingest_queue, &buffer, max_delay) == pdFALSE) if (xQueueReceive(libshunt_ingest_queue, &buffer, max_delay) == pdFALSE)
{ {
return INCPHUB_EAGAIN; return LIBSHUNT_EAGAIN;
} }
// Return buffer // Return buffer
*buffer_ptr = buffer; *buffer_ptr = buffer;
return INCPHUB_OK; return LIBSHUNT_OK;
} }
int do_message_dispatch(incphub_cli_t *cli, uint8_t *buffer) int do_message_dispatch(shunt_cli_t *cli, uint8_t *buffer)
{ {
//NOTE: Does not need global lock //NOTE: Does not need global lock
if (cli == NULL) if (cli == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
if (buffer == NULL) if (buffer == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
// Try to notify // Try to notify
if (xTaskNotifyIndexed(cli->task, INCPHUB_TASKINDEX_MAILBOX, (uint32_t)buffer, eSetValueWithoutOverwrite) == pdFALSE) if (xTaskNotifyIndexed(cli->task, LIBSHUNT_TASKINDEX_MAILBOX, (uint32_t)buffer, eSetValueWithoutOverwrite) == pdFALSE)
{ {
// Failed because previous message has not yet been processed // Failed because previous message has not yet been processed
return INCPHUB_EAGAIN; return LIBSHUNT_EAGAIN;
} }
return INCPHUB_OK; return LIBSHUNT_OK;
} }
int await_message_dispatch(uint8_t **buffer_ptr, TickType_t max_delay) int await_message_dispatch(uint8_t **buffer_ptr, TickType_t max_delay)
@@ -241,20 +241,20 @@ int await_message_dispatch(uint8_t **buffer_ptr, TickType_t max_delay)
//NOTE: Does not need global lock //NOTE: Does not need global lock
if (buffer_ptr == NULL) if (buffer_ptr == NULL)
return INCPHUB_EINVAL; return LIBSHUNT_EINVAL;
// Get raw msg buffer // Get raw msg buffer
uint8_t *buffer; uint8_t *buffer;
if (xTaskNotifyWaitIndexed(INCPHUB_TASKINDEX_MAILBOX, 0, 0, (uint32_t*)&buffer, max_delay) == pdFALSE) if (xTaskNotifyWaitIndexed(LIBSHUNT_TASKINDEX_MAILBOX, 0, 0, (uint32_t*)&buffer, max_delay) == pdFALSE)
{ {
// Nothing pending // Nothing pending
return INCPHUB_EAGAIN; return LIBSHUNT_EAGAIN;
} }
// Return buffer // Return buffer
*buffer_ptr = buffer; *buffer_ptr = buffer;
return INCPHUB_OK; return LIBSHUNT_OK;
} }
@@ -262,24 +262,24 @@ int await_message_dispatch(uint8_t **buffer_ptr, TickType_t max_delay)
// === Private function definitions === // === Private function definitions ===
static bool global_lock(TickType_t max_delay) static bool global_lock(TickType_t max_delay)
{ {
return xSemaphoreTake(_incphub_lock, max_delay) == pdTRUE; return xSemaphoreTake(_libshunt_lock, max_delay) == pdTRUE;
} }
static void global_unlock() static void global_unlock()
{ {
xSemaphoreGive(_incphub_lock); xSemaphoreGive(_libshunt_lock);
} }
static incphub_cli_t *find_empty_client() static shunt_cli_t *find_empty_client()
{ {
return find_client_with_port(NTL_PORT_EMPTY); return find_client_with_port(NTL_PORT_EMPTY);
} }
static incphub_cli_t *find_client_with_port(ntl_port_t port) static shunt_cli_t *find_client_with_port(ntl_port_t port)
{ {
for (int i = 0; i < INCPHUB_MAX_CLIENTS; ++i) for (int i = 0; i < LIBSHUNT_MAX_CLIENTS; ++i)
{ {
incphub_cli_t *client = &_clients[i]; shunt_cli_t *client = &_clients[i];
if (client->port == port) if (client->port == port)
return client; return client;
@@ -290,7 +290,7 @@ static incphub_cli_t *find_client_with_port(ntl_port_t port)
static uint8_t *find_unused_buffer() static uint8_t *find_unused_buffer()
{ {
for (int i = 0; i < INCPHUB_MSG_BUFFER_COUNT; ++i) for (int i = 0; i < LIBSHUNT_MSG_BUFFER_COUNT; ++i)
{ {
if (!_msg_buffer_used[i]) if (!_msg_buffer_used[i])
return _msg_buffers[i]; return _msg_buffers[i];
@@ -301,7 +301,7 @@ static uint8_t *find_unused_buffer()
static int find_index_of_buffer(uint8_t *buffer) static int find_index_of_buffer(uint8_t *buffer)
{ {
for (int i = 0; i < INCPHUB_MSG_BUFFER_COUNT; ++i) for (int i = 0; i < LIBSHUNT_MSG_BUFFER_COUNT; ++i)
{ {
if (buffer == _msg_buffers[i]) if (buffer == _msg_buffers[i])
return i; return i;

46
app/src/incphub/src/incphub_shared.h → app/src/libshunt/src/shunt_shared.h
View File

@@ -1,7 +1,7 @@
// incphub_sharedl.h - Internal mechanisms shared by incphub and incphub_client // shunt_sharedl.h - Internal mechanisms shared by libshunt components
#ifndef INCPHUB_SHARED_H_ #ifndef LIBSHUNT_SHARED_H_
#define INCPHUB_SHARED_H_ #define LIBSHUNT_SHARED_H_
#include "FreeRTOS.h" #include "FreeRTOS.h"
#include "task.h" #include "task.h"
@@ -10,75 +10,75 @@
#include "nil/nil.h" #include "nil/nil.h"
#include "ntl/ntl.h" #include "ntl/ntl.h"
#include "incphub/incphub.h" #include "libshunt/libshunt.h"
struct incphub_cli_t { struct shunt_cli_t {
/// @remark If set to NTL_PORT_EMPTY denotes an empty client /// @remark If set to NTL_PORT_EMPTY denotes an empty client
ntl_port_t port; ntl_port_t port;
TaskHandle_t task; TaskHandle_t task;
}; };
// Queue<uint8_t*> (queue of buffers) // Queue<uint8_t*> (queue of buffers)
extern QueueHandle_t incphub_ingest_queue; extern QueueHandle_t libshunt_ingest_queue;
#ifndef INCPHUB_CLIENT_H_ #ifndef LIBSHUNT_CLIENT_H_
typedef struct incphub_cli_t incphub_cli_t; typedef struct shunt_cli_t shunt_cli_t;
#endif #endif
/// @brief Initializes the internal state of incphub /// @brief Initializes the internal state of libshunt
/// @return INCPHUB_OK on success, an error otherwise /// @return LIBSHUNT_OK on success, an error otherwise
int internal_init(); int internal_init();
/// @brief Registers a task as an incphub client /// @brief Registers a task as an libshunt client
/// @param cli_ptr Location to return client /// @param cli_ptr Location to return client
/// @param port The port to register to /// @param port The port to register to
/// @param task The task to register as the handler /// @param task The task to register as the handler
/// @return INCPHUB_OK on success, an error otherwise /// @return LIBSHUNT_OK on success, an error otherwise
int register_client(incphub_cli_t **cli_ptr, ntl_port_t port, TaskHandle_t task); int register_client(shunt_cli_t **cli_ptr, ntl_port_t port, TaskHandle_t task);
/// @brief Attempts to get a free message buffer from the central storage space /// @brief Attempts to get a free message buffer from the central storage space
/// @param buffer_ptr Location to return the buffer /// @param buffer_ptr Location to return the buffer
/// @param len The minimum size, in bytes, of the buffer get /// @param len The minimum size, in bytes, of the buffer get
/// @return INCPHUB_OK on success, an error otherwise /// @return LIBSHUNT_OK on success, an error otherwise
int get_msg_buffer(uint8_t **buffer_ptr, size_t len); int get_msg_buffer(uint8_t **buffer_ptr, size_t len);
/// @brief Releases a buffer previously acquired with get_msg_buffer /// @brief Releases a buffer previously acquired with get_msg_buffer
/// @param buffer The buffer to release /// @param buffer The buffer to release
/// @return INCPHUB_OK on success, an error otherwise /// @return LIBSHUNT_OK on success, an error otherwise
int release_msg_buffer(uint8_t *buffer); int release_msg_buffer(uint8_t *buffer);
/// @brief Attempts to get the client assigned to the given port /// @brief Attempts to get the client assigned to the given port
/// @param port The port to look for /// @param port The port to look for
/// @param client_ptr Location to return the client /// @param client_ptr Location to return the client
/// @return INCPHUB_OK on success, an error otherwise /// @return LIBSHUNT_OK on success, an error otherwise
int get_client_with_port(ntl_port_t port, incphub_cli_t **client_ptr); int get_client_with_port(ntl_port_t port, shunt_cli_t **client_ptr);
/// @brief Enqueues a message for ingest by the incphub task /// @brief Enqueues a message for ingest by the libshunt task
/// @param buffer The buffer to enqueue /// @param buffer The buffer to enqueue
/// @param max_delay The maximum time to wait for resources, in ticks /// @param max_delay The maximum time to wait for resources, in ticks
/// @return INCPHUB_OK on success, an error otherwise /// @return LIBSHUNT_OK on success, an error otherwise
int enqueue_message_ingest(uint8_t *buffer, TickType_t max_delay); int enqueue_message_ingest(uint8_t *buffer, TickType_t max_delay);
/// @brief Dequeues a message for ingest /// @brief Dequeues a message for ingest
/// @param buffer_ptr Location to return the buffer /// @param buffer_ptr Location to return the buffer
/// @param max_delay The maximum time to wait for a message, in ticks /// @param max_delay The maximum time to wait for a message, in ticks
/// @return INCPHUB_OK on success, an error otherwise /// @return LIBSHUNT_OK on success, an error otherwise
int dequeue_message_ingest(uint8_t **buffer_ptr, TickType_t max_delay); int dequeue_message_ingest(uint8_t **buffer_ptr, TickType_t max_delay);
/// @brief Sends a message for dispatch to the corresponding client /// @brief Sends a message for dispatch to the corresponding client
/// @param cli The client to send the message to /// @param cli The client to send the message to
/// @param buffer The message buffer to send /// @param buffer The message buffer to send
/// @return INCPHUB_OK on success, an error otherwise /// @return LIBSHUNT_OK on success, an error otherwise
int do_message_dispatch(incphub_cli_t *cli, uint8_t *buffer); int do_message_dispatch(shunt_cli_t *cli, uint8_t *buffer);
/// @brief Blocks until a message is received for dispatch, or until a given timeout /// @brief Blocks until a message is received for dispatch, or until a given timeout
/// @param buffer_ptr Location to return the message buffer /// @param buffer_ptr Location to return the message buffer
/// @param max_delay The maximum time to wait for a message, in ticks /// @param max_delay The maximum time to wait for a message, in ticks
/// @return INCPHUB_OK on success, an error otherwise /// @return LIBSHUNT_OK on success, an error otherwise
/// @remark Buffers obatined from this function must be release with release_msg_buffer once no longer in use /// @remark Buffers obatined from this function must be release with release_msg_buffer once no longer in use
int await_message_dispatch(uint8_t **buffer_ptr, TickType_t max_delay); int await_message_dispatch(uint8_t **buffer_ptr, TickType_t max_delay);

38
app/src/incphub/src/incphub_task.c → app/src/libshunt/src/shunt_task.c
View File

@@ -1,13 +1,13 @@
#include "incphub/incphub_task.h" #include "libshunt/shunt_task.h"
#include <stdint.h> #include <stdint.h>
#include "FreeRTOS.h" #include "FreeRTOS.h"
#include "queue.h" #include "queue.h"
#include "incphub/incphub.h" #include "libshunt/libshunt.h"
#include "incphub_config.h" #include "shunt_config.h"
#include "incphub_shared.h" #include "shunt_shared.h"
#include "ntl/ntl.h" #include "ntl/ntl.h"
#include "nil/nil.h" #include "nil/nil.h"
@@ -15,15 +15,15 @@
// === Static task space === // === Static task space ===
StackType_t _incphub_task_stack[INCPHUB_TASK_STACK_DEPTH]; StackType_t _libshunt_task_stack[LIBSHUNT_TASK_STACK_DEPTH];
StaticTask_t _incphub_task; StaticTask_t _libshunt_task;
// === Public variables === // === Public variables ===
// Queue<nil_packet_t*> Packets awaiting to be accepted by incphub // Queue<nil_packet_t*> Packets awaiting to be accepted by libshunt
QueueHandle_t incphub_ingest_queue; QueueHandle_t libshunt_ingest_queue;
@@ -42,14 +42,14 @@ static int handle_ntl_packet(nil_packet_t *nil, ntl_packet_t *ntl);
// === Public functions === // === Public functions ===
void incphub_task_preinit() void libshunt_task_preinit()
{ {
internal_init(); internal_init();
incphub_ingest_queue = libshunt_ingest_queue =
xQueueCreateStatic(INGEST_QUEUE_LENGTH, INGEST_QUEUE_ITEM_SIZE, _ingest_queue_store, &_ingest_queue_static); xQueueCreateStatic(INGEST_QUEUE_LENGTH, INGEST_QUEUE_ITEM_SIZE, _ingest_queue_store, &_ingest_queue_static);
} }
void incphub_task_main(void *params) void libshunt_task_main(void *params)
{ {
(void)params; (void)params;
int err; int err;
@@ -61,7 +61,7 @@ void incphub_task_main(void *params)
err = dequeue_message_ingest(&buffer, portMAX_DELAY); err = dequeue_message_ingest(&buffer, portMAX_DELAY);
// Get NIL packet // Get NIL packet
nil_packet_t *nil = extract_nil_packet(buffer, INCPHUB_MSG_BUFFER_SIZE); nil_packet_t *nil = extract_nil_packet(buffer, LIBSHUNT_MSG_BUFFER_SIZE);
if (nil == NULL) if (nil == NULL)
{ {
//TODO: Error //TODO: Error
@@ -70,7 +70,7 @@ void incphub_task_main(void *params)
// Process or route // Process or route
err = handle_nil_packet(nil); err = handle_nil_packet(nil);
if (err == INCPHUB_EAGAIN) if (err == LIBSHUNT_EAGAIN)
{ {
// Failed but only temporarily // Failed but only temporarily
// Could be target task not ready // Could be target task not ready
@@ -81,7 +81,7 @@ void incphub_task_main(void *params)
// This avoids clogging the system due to a single unresponsive task // This avoids clogging the system due to a single unresponsive task
continue; continue;
} }
else if (err != INCPHUB_OK) else if (err != LIBSHUNT_OK)
{ {
// Failed for some other reason // Failed for some other reason
// Do not retry // Do not retry
@@ -95,21 +95,21 @@ void incphub_task_main(void *params)
// === Private functions === // === Private functions ===
static int handle_nil_packet(nil_packet_t *nil) static int handle_nil_packet(nil_packet_t *nil)
{ {
if (nil->header.dst_addr == INCPHUB_LOCAL_NIL_ADDR if (nil->header.dst_addr == LIBSHUNT_LOCAL_NIL_ADDR
|| nil->header.dst_addr == NIL_ADDR_LOCALHOST) || nil->header.dst_addr == NIL_ADDR_LOCALHOST)
{ {
ntl_packet_t *ntl = extract_ntl_packet(nil); ntl_packet_t *ntl = extract_ntl_packet(nil);
if (ntl == NULL) if (ntl == NULL)
{ {
//TODO: Error //TODO: Error
return INCPHUB_BAD_PACKET; return LIBSHUNT_BAD_PACKET;
} }
return handle_ntl_packet(nil, ntl); return handle_ntl_packet(nil, ntl);
} }
//TODO: Route to external interface //TODO: Route to external interface
return INCPHUB_ERR; return LIBSHUNT_ERR;
} }
static int handle_ntl_packet(nil_packet_t *nil, ntl_packet_t *ntl) static int handle_ntl_packet(nil_packet_t *nil, ntl_packet_t *ntl)
@@ -117,9 +117,9 @@ static int handle_ntl_packet(nil_packet_t *nil, ntl_packet_t *ntl)
int err; int err;
ntl_port_t port = ntl_get_dst(&ntl->header); ntl_port_t port = ntl_get_dst(&ntl->header);
incphub_cli_t *client; shunt_cli_t *client;
err = get_client_with_port(port, &client); err = get_client_with_port(port, &client);
if (err != INCPHUB_OK) if (err != LIBSHUNT_OK)
{ {
//TODO: Error //TODO: Error
return err; return err;

6
app/src/main.c
View File

@@ -6,18 +6,18 @@
#include "tasks/heartbeat_task.h" #include "tasks/heartbeat_task.h"
#include "tasks/sensor_task.h" #include "tasks/sensor_task.h"
#include "tasks/requester_task.h" #include "tasks/requester_task.h"
#include "incphub/incphub_task.h" #include "libshunt/shunt_task.h"
int my_main() int my_main()
{ {
// Init // Init
incphub_task_preinit(); libshunt_task_preinit();
// Create tasks // Create tasks
xTaskCreateStatic(heartbeat_task_main, "heartbeat", HEARTBEAT_TASK_STACK_DEPTH, NULL, HEARTBEAT_TASK_PRIORITY, _heartbeat_task_stack, &_heartbeat_task); xTaskCreateStatic(heartbeat_task_main, "heartbeat", HEARTBEAT_TASK_STACK_DEPTH, NULL, HEARTBEAT_TASK_PRIORITY, _heartbeat_task_stack, &_heartbeat_task);
xTaskCreateStatic(sensor_task_main, "sensor", SENSOR_TASK_STACK_DEPTH, NULL, SENSOR_TASK_PRIORITY, _sensor_task_stack, &_sensor_task); xTaskCreateStatic(sensor_task_main, "sensor", SENSOR_TASK_STACK_DEPTH, NULL, SENSOR_TASK_PRIORITY, _sensor_task_stack, &_sensor_task);
xTaskCreateStatic(requester_task_main, "requester", REQUESTER_TASK_STACK_DEPTH, NULL, REQUESTER_TASK_PRIORITY, _requester_task_stack, &_requester_task); xTaskCreateStatic(requester_task_main, "requester", REQUESTER_TASK_STACK_DEPTH, NULL, REQUESTER_TASK_PRIORITY, _requester_task_stack, &_requester_task);
xTaskCreateStatic(incphub_task_main, "incphub", INCPHUB_TASK_STACK_DEPTH, NULL, INCPHUB_TASK_PRIORITY, _incphub_task_stack, &_incphub_task); xTaskCreateStatic(libshunt_task_main, "shunt", LIBSHUNT_TASK_STACK_DEPTH, NULL, LIBSHUNT_TASK_PRIORITY, _libshunt_task_stack, &_libshunt_task);
// Run // Run
vTaskStartScheduler(); vTaskStartScheduler();

20
app/src/tasks/requester_task.c
View File

@@ -7,7 +7,7 @@
#include "stm32f4xx_hal_uart.h" #include "stm32f4xx_hal_uart.h"
#include "usart.h" #include "usart.h"
#include "incphub/incphub_client.h" #include "libshunt/shunt_client.h"
@@ -27,11 +27,11 @@ void requester_task_main(void *params)
uint8_t *buffer; uint8_t *buffer;
size_t length; size_t length;
incphub_addr_t source; shunt_addr_t source;
// Init incphub client // Init libshunt client
incphub_cli_t *cli; shunt_cli_t *cli;
incphub_init_client(&cli, 70); shunt_init_client(&cli, 70);
while (1) while (1)
{ {
@@ -43,17 +43,17 @@ void requester_task_main(void *params)
random_index %= RANDOM_COUNT; random_index %= RANDOM_COUNT;
// Get buffer // Get buffer
incphub_get_msg_buffer(cli, &buffer, sizeof(uint32_t)); shunt_get_msg_buffer(cli, &buffer, sizeof(uint32_t));
// Populate buffer // Populate buffer
*(uint32_t*)buffer = request; *(uint32_t*)buffer = request;
// Send to sendor task // Send to sendor task
incphub_addr_t destination = { .addr = NIL_ADDR_LOCALHOST, .port = 69 }; shunt_addr_t destination = { .addr = NIL_ADDR_LOCALHOST, .port = 69 };
incphub_send_msg(cli, buffer, sizeof(uint32_t), destination, portMAX_DELAY); shunt_send_msg(cli, buffer, sizeof(uint32_t), destination, portMAX_DELAY);
// Await reply (assumes no other task will send to this one) // Await reply (assumes no other task will send to this one)
incphub_await_msg(cli, &buffer, &length, &source, portMAX_DELAY); shunt_await_msg(cli, &buffer, &length, &source, portMAX_DELAY);
// Ignore messages of different size // Ignore messages of different size
if (length != sizeof(uint32_t)) if (length != sizeof(uint32_t))
@@ -63,7 +63,7 @@ void requester_task_main(void *params)
uint32_t num = *(uint32_t*)buffer; uint32_t num = *(uint32_t*)buffer;
// Release buffer // Release buffer
incphub_release_msg_buffer(cli, buffer); shunt_release_msg_buffer(cli, buffer);
// Profit (send to UART to ensure it worked) // Profit (send to UART to ensure it worked)
char strbuf[32]; char strbuf[32];

18
app/src/tasks/sensor_task.c
View File

@@ -4,7 +4,7 @@
#include "stm32f4xx_hal_gpio.h" #include "stm32f4xx_hal_gpio.h"
#include "gpio.h" #include "gpio.h"
#include "incphub/incphub_client.h" #include "libshunt/shunt_client.h"
@@ -19,16 +19,16 @@ void sensor_task_main(void *params)
uint8_t *buffer; uint8_t *buffer;
size_t length; size_t length;
incphub_addr_t source; shunt_addr_t source;
// Init incphub client // Init libshunt client
incphub_cli_t *cli; shunt_cli_t *cli;
incphub_init_client(&cli, 69); shunt_init_client(&cli, 69);
while (1) while (1)
{ {
// Get a message (assume it is a uint32_t) // Get a message (assume it is a uint32_t)
incphub_await_msg(cli, &buffer, &length, &source, portMAX_DELAY); shunt_await_msg(cli, &buffer, &length, &source, portMAX_DELAY);
// Ignore messages of different size // Ignore messages of different size
if (length != sizeof(uint32_t)) if (length != sizeof(uint32_t))
@@ -38,18 +38,18 @@ void sensor_task_main(void *params)
uint32_t num = *(uint32_t*)buffer; uint32_t num = *(uint32_t*)buffer;
// Release buffer once read // Release buffer once read
incphub_release_msg_buffer(cli, buffer); shunt_release_msg_buffer(cli, buffer);
// Process message // Process message
num++; num++;
// Request buffer for reply // Request buffer for reply
incphub_get_msg_buffer(cli, &buffer, sizeof(uint32_t)); shunt_get_msg_buffer(cli, &buffer, sizeof(uint32_t));
// Prepare reply message // Prepare reply message
*(uint32_t*)buffer = num; *(uint32_t*)buffer = num;
// Send reply // Send reply
incphub_send_msg(cli, buffer, sizeof(uint32_t), source, portMAX_DELAY); shunt_send_msg(cli, buffer, sizeof(uint32_t), source, portMAX_DELAY);
} }
} }