oliver/cls_master
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

make libCLS more independen of HW

Browse Source 
goal is to reuse libCLS on an diffrent MCU
This commit is contained in:
Oliver Walter
2024-02-05 19:46:48 +01:00
parent 31f3172ba3
commit a3c3b99fb3
18 changed files with 309 additions and 54 deletions
Download Patch File Download Diff File Expand all files Collapse all files

22
Application/CLS/CLS.c
View File

@@ -1,33 +1,17 @@
#include "CLS_BSP.h"
#include "CLS.h"
#include "CLSAddress.h"
#include "cmsis_os2.h"
#include "fdcan.h"
osTimerId_t CLS_HeatbeatTimerId; // Timer ID
static uint8_t cls_hartbeat_counter = 0;
static FDCAN_TxHeaderTypeDef cls_hartbeat_header = {
.IdType = FDCAN_STANDARD_ID,
.Identifier = GENERATE_CLS_ADDRESS(CLS_CODE_STATUS,CLS_DEVICE,CLS_CH_STA_HEATBEAT),
.TxFrameType = FDCAN_DATA_FRAME,
.DataLength = FDCAN_DLC_BYTES_1,
.ErrorStateIndicator = FDCAN_ESI_PASSIVE,
.BitRateSwitch = FDCAN_BRS_OFF,
.FDFormat = FDCAN_CLASSIC_CAN,
.TxEventFifoControl = FDCAN_NO_TX_EVENTS,
.MessageMarker = 0xCC,
};
static CLS_BSP_TxHeaderType cls_hartbeat_header = CREATE_BSP_CAN_HEADER(GENERATE_CLS_ADDRESS(CLS_CODE_STATUS,CLS_DEVICE,CLS_CH_STA_HEATBEAT), CLS_BSP_DLC_BYTES_1);
uint8_t TxData[8];
FDCAN_TxHeaderTypeDef TxHeader;
void CLS_Heatbeat(void *argument) {
// Code to be executed every 500ms
cls_hartbeat_counter++;
if (HAL_FDCAN_GetTxFifoFreeLevel(&hfdcan1) > 1){
HAL_FDCAN_AddMessageToTxFifoQ(&hfdcan1, &cls_hartbeat_header, &cls_hartbeat_counter);
}
CLS_BSP_CAN_AddMessageToSend(&cls_hartbeat_header, &cls_hartbeat_counter);
}

2
Application/CLS/CLSFirmware.c
View File

@@ -1,4 +1,3 @@
#include "fdcan.h"
#include "CanDataHandler.h"
#include "cmsis_os2.h"
#include "FreeRTOS.h"
@@ -17,7 +16,6 @@ const osThreadAttr_t CLS_FW_Task_attr = {
.stack_mem = CLS_FW_Task_stk,
.stack_size = sizeof(CLS_FW_Task_stk),
.priority = osPriorityNormal,
.tz_module = 0U,
.reserved = 0U
};

5
Application/CLS/CMakeLists.txt
View File

@@ -8,11 +8,14 @@ target_sources(${PROJECT_NAME}
PRIVATE
${CMAKE_CURRENT_LIST_DIR}/CLS.c
${CMAKE_CURRENT_LIST_DIR}/CLSFirmware.c
${CMAKE_CURRENT_LIST_DIR}/CanDataHandler.c
INTERFACE
${CMAKE_CURRENT_LIST_DIR}/CLS.h
${CMAKE_CURRENT_LIST_DIR}/CLSAddress.h
${CMAKE_CURRENT_LIST_DIR}/CLSFirmware.h
${CMAKE_CURRENT_LIST_DIR}/CanDataHandler.h
)
target_include_directories(${PROJECT_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(${PROJECT_NAME} PUBLIC Tasks)
target_link_libraries(${PROJECT_NAME} PUBLIC Tasks)
target_link_libraries(${PROJECT_NAME} PRIVATE CLS_BSP)

74
Application/Tasks/CanDataHandler.c → Application/CLS/CanDataHandler.c
View File

@@ -1,5 +1,4 @@
#include "CanDataHandler.h"
#include "fdcan.h"
#include "string.h"
#define MAX_DATA_STORAGE 100
@@ -16,17 +15,25 @@ static CanDataEventSlot CanEventStore[MAX_DATA_STORAGE] = {0};
static CanDataFilterSlot CanFilterSlots[MAX_FILTER_SLOTS] = {0};
// this will setup the canfilter accoridng to the settings
void setup_StmFdCanFilter(const CanDataFilterSlot* filterSetting ) {
void setup_StmCanFilter(const CanDataFilterSlot* filterSetting ) {
size_t f_index = filterSetting - CanFilterSlots;// index of the filter in CanFilterSlots
FDCAN_FilterTypeDef sFilterConfig;
sFilterConfig.IdType = FDCAN_STANDARD_ID;
sFilterConfig.FilterIndex = f_index;
sFilterConfig.FilterType = FDCAN_FILTER_DUAL;
sFilterConfig.FilterConfig = filterSetting->fifo;
sFilterConfig.FilterID1 = filterSetting->id[0];
sFilterConfig.FilterID2 = filterSetting->id[1];
HAL_FDCAN_ConfigFilter(&hfdcan1, &sFilterConfig);
CLS_BSP_CAN_UniversalFilter clsFilterConfig = {
.filterIndex = f_index,
.filterDestination = filterSetting->fifo,
.filterMode = CLS_BSP_CAN_FILTER_LIST,
.id0 = filterSetting->id[0],
.id1 = filterSetting->id[1],
};
CLS_BSP_CAN_SetUniversalFilter(&clsFilterConfig);
}
// this will setup the canfilter using a custom defined filter
void setup_StmCanFilterManual(const CanDataFilterSlot* filterSetting, CLS_BSP_CAN_UniversalFilter * filter ) {
size_t f_index = filterSetting - CanFilterSlots;// index of the filter in CanFilterSlots
filter->filterIndex = f_index;
CLS_BSP_CAN_SetUniversalFilter(filter);
}
@@ -66,11 +73,14 @@ CanDataFilterRef CanData_unusedFilterSlot(CanDataSlotFifo reqest_fifo) {
for (size_t i = 0; i < MAX_FILTER_SLOTS; i++) {
// find a slot with free some id
if (CanFilterSlots[i].free != CANDATA_FULL) {
if (CanFilterSlots[i].free < CANDATA_FULL) {
// either the fifo settig matches or is undefined
if(CanFilterSlots[i].fifo == reqest_fifo || CanFilterSlots[i].fifo == CANDATA_FIFOX_UNDEFIEND)
filterRef.ref = &CanFilterSlots[i];
if (CanFilterSlots[i].fifo == CANDATA_FIFOX_UNDEFIEND) {
CanFilterSlots[i].fifo = reqest_fifo;
}
// Determine the index based on the 'free' field
switch (CanFilterSlots[i].free) {
@@ -115,7 +125,7 @@ void CanData_clearFilterSlot(CanDataFilterRef filter) {
// finaly write new HW config
setup_StmFdCanFilter(filter.ref);
setup_StmCanFilter(filter.ref);
}
/**
@@ -168,7 +178,7 @@ bool CanData_regDataMsg(CanDataId canid) {
filter.ref->id[filter.index] = canid;
// Set up the filter with the new settings
setup_StmFdCanFilter(filter.ref);
setup_StmCanFilter(filter.ref);
// Register the data message with the data slot
@@ -178,6 +188,42 @@ bool CanData_regDataMsg(CanDataId canid) {
return true;
}
// Function to register a Set of ID for Data Messages using a Manual filter
size_t CanData_regDataManualMsg(const CanDataId* canid, size_t id_count, CLS_BSP_CAN_UniversalFilter * filter) {
// first check all id to be new
for (size_t i = 0; i < id_count; i++) {
if(CanData_getDataMessage(canid[i]) != NULL) {
return 0; // invalid operation one id is already used
}
}
// Find and configure one unused slot for the manual filter
CanDataFilterRef filterRef = CanData_unusedFilterSlot(CANDATA_FIFOX_MANUAL);
if (filterRef.ref == NULL) {
return 0; // No unused filter slot available
}
// setup the manual filters
filterRef.ref->fifo = CANDATA_FIFOX_MANUAL;
filterRef.ref->free = CANDATA_MANUAL;
setup_StmCanFilterManual(filterRef.ref, filter);
for (size_t i = 0; i < id_count; i++) {
// Find an unused slot in the data store
CanDataMessageSlot *dataSlot = CanData_unusedDataSlot();
if (!dataSlot) {
return i; // No unused data slot available
}
dataSlot->filter = filterRef;
dataSlot->filter.index = -1; // this idecates is a manual filter
}
return id_count;
}
/**
* Registers a event message with given CanDataId. Returns true if registration is successful, false otherwise.
*/
@@ -211,7 +257,7 @@ bool CanData_regEventMsg(CanDataId canid, EventCallback event_callback) {
filter.ref->id[filter.index] = canid;
// Set up the filter with the new settings
setup_StmFdCanFilter(filter.ref);
setup_StmCanFilter(filter.ref);
// Register the event message with the event slot
eventSlot->canid = canid;

22
Application/Tasks/CanDataHandler.h → Application/CLS/CanDataHandler.h
View File

@@ -22,8 +22,7 @@
#include <stdint.h>
#include <stdbool.h>
#include <stddef.h>
#include "fdcan.h"
#include "CLS_BSP.h"
// Define the maximum length of data for a Data Message
#define MAX_DATA_LENGTH 8
@@ -35,17 +34,19 @@ typedef void (*EventCallback)(CanDataId canid, uint8_t* data, uint8_t len);
// type of fifo that this slot uses
typedef enum {
CANDATA_FIFOX_UNDEFIEND = FDCAN_FILTER_DISABLE,
CANDATA_FIFO0_DATA = FDCAN_FILTER_TO_RXFIFO0,
CANDATA_FIFO1_EVENT = FDCAN_FILTER_TO_RXFIFO1,
CANDATA_FIFOX_UNDEFIEND = CLS_CAN_FILTER_DISABLE,
CANDATA_FIFO0_DATA = CLS_CAN_FILTER_TO_RXFIFO0,
CANDATA_FIFO1_EVENT = CLS_CAN_FILTER_TO_RXFIFO1,
CANDATA_FIFOX_MANUAL = 0x0f,
} CanDataSlotFifo;
// count of free ids in the slot
typedef enum {
CANDATA_ALLFREE = 0,
CANDATA_FREE1 = 1,
CANDATA_FREE0 = 2,
CANDATA_FULL = 3,
CANDATA_ALLFREE = 0x00,
CANDATA_FREE1 = 0x01,
CANDATA_FREE0 = 0x02,
CANDATA_FULL = 0x03,
CANDATA_MANUAL = 0x0f,
} CanDataSlotFree;
// Define s structer for a used filter slot
@@ -92,6 +93,9 @@ void CanDataHandler_init(void);
// Function to register a CAN ID for Data Messages
bool CanData_regDataMsg(CanDataId canid);
// Function to register a Set of ID for Data Messages using a Manual filter
size_t CanData_regDataManualMsg(const CanDataId* canid, size_t id_count, CLS_BSP_CAN_UniversalFilter * filter);
// Function to register a CAN ID for Event Messages and associate it with a callback function
bool CanData_regEventMsg(CanDataId canid, EventCallback event_callback);

28
Application/CLS_BSP/CLS_BSP.c Normal file
View File

@@ -0,0 +1,28 @@
#include "CLS_BSP.h"
#ifdef CLS_BSP_FDCAN
HAL_StatusTypeDef CLS_BSP_CAN_AddMessageToSend(CLS_BSP_TxHeaderType * header, uint8_t * data) {
if (HAL_FDCAN_GetTxFifoFreeLevel(&hfdcan1) > 0) {
return HAL_FDCAN_AddMessageToTxFifoQ(&hfdcan1, header, data);
}
return HAL_ERROR;
}
HAL_StatusTypeDef CLS_BSP_CAN_SetUniversalFilter(const CLS_BSP_CAN_UniversalFilter * filter) {
FDCAN_FilterTypeDef sFilterConfig;
sFilterConfig.IdType = FDCAN_STANDARD_ID;
sFilterConfig.FilterIndex = filter->filterIndex;
sFilterConfig.FilterType = filter->filterMode;
sFilterConfig.FilterConfig = filter->filterDestination;
sFilterConfig.FilterID1 = filter->id0;
sFilterConfig.FilterID2 = filter->id1;
return HAL_FDCAN_ConfigFilter(&hfdcan1, &sFilterConfig);
}
#endif

53
Application/CLS_BSP/CLS_BSP.h Normal file
View File

@@ -0,0 +1,53 @@
#define CLS_BSP_FDCAN
#ifdef CLS_BSP_FDCAN
#include "fdcan.h"
typedef FDCAN_TxHeaderTypeDef CLS_BSP_TxHeaderType;
#define CREATE_BSP_CAN_HEADER(identifier, datalength) \
{ \
.IdType = FDCAN_STANDARD_ID, \
.Identifier = identifier, \
.TxFrameType = FDCAN_DATA_FRAME, \
.DataLength = datalength, \
.ErrorStateIndicator = FDCAN_ESI_PASSIVE, \
.BitRateSwitch = FDCAN_BRS_OFF, \
.FDFormat = FDCAN_CLASSIC_CAN, \
.TxEventFifoControl = FDCAN_NO_TX_EVENTS, \
.MessageMarker = 0xCC, \
}
#define CLS_BSP_DLC_BYTES_1 FDCAN_DLC_BYTES_1
#define CLS_BSP_DLC_BYTES_2 FDCAN_DLC_BYTES_2
#define CLS_BSP_DLC_BYTES_3 FDCAN_DLC_BYTES_3
#define CLS_BSP_DLC_BYTES_4 FDCAN_DLC_BYTES_4
#define CLS_BSP_DLC_BYTES_5 FDCAN_DLC_BYTES_5
#define CLS_BSP_DLC_BYTES_6 FDCAN_DLC_BYTES_6
#define CLS_BSP_DLC_BYTES_7 FDCAN_DLC_BYTES_7
#define CLS_BSP_DLC_BYTES_8 FDCAN_DLC_BYTES_8
#define CLS_CAN_FILTER_DISABLE FDCAN_FILTER_DISABLE
#define CLS_CAN_FILTER_TO_RXFIFO0 FDCAN_FILTER_TO_RXFIFO0
#define CLS_CAN_FILTER_TO_RXFIFO1 FDCAN_FILTER_TO_RXFIFO1
#define CLS_BSP_CAN_FILTER_LIST FDCAN_FILTER_DUAL
#endif
typedef struct {
uint32_t filterIndex;
uint32_t filterDestination;
uint32_t filterMode;
uint16_t id0;
uint16_t id1;
} CLS_BSP_CAN_UniversalFilter;
HAL_StatusTypeDef CLS_BSP_CAN_AddMessageToSend(CLS_BSP_TxHeaderType * header, uint8_t * data);
HAL_StatusTypeDef CLS_BSP_CAN_SetUniversalFilter(const CLS_BSP_CAN_UniversalFilter * filter);

14
Application/CLS_BSP/CMakeLists.txt Normal file
View File

@@ -0,0 +1,14 @@
cmake_minimum_required(VERSION 3.12)
project(CLS_BSP C)
add_library(${PROJECT_NAME} STATIC "")
target_sources(${PROJECT_NAME}
PRIVATE
${CMAKE_CURRENT_LIST_DIR}/CLS_BSP.c
INTERFACE
${CMAKE_CURRENT_LIST_DIR}/CLS_BSP.h
)
target_include_directories(${PROJECT_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})

1
Application/CMakeLists.txt
View File

@@ -1,2 +1,3 @@
add_subdirectory(Tasks)
add_subdirectory(CLS_BSP)
add_subdirectory(CLS)

5
Application/Tasks/CMakeLists.txt
View File

@@ -7,15 +7,14 @@ add_library(${PROJECT_NAME} STATIC "")
target_sources(${PROJECT_NAME}
PRIVATE
${CMAKE_CURRENT_LIST_DIR}/UsbDataHandler.c
${CMAKE_CURRENT_LIST_DIR}/CanDataHandler.c
${CMAKE_CURRENT_LIST_DIR}/CanDataTask.c
${CMAKE_CURRENT_LIST_DIR}/FirmwareHandler.c
INTERFACE
${CMAKE_CURRENT_LIST_DIR}/UsbDataHandler.h
${CMAKE_CURRENT_LIST_DIR}/CanDataHandler.h
${CMAKE_CURRENT_LIST_DIR}/CanDataTask.h
)
target_include_directories(${PROJECT_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})
target_link_libraries(${PROJECT_NAME} PUBLIC PROTOS)
target_link_libraries(${PROJECT_NAME} PUBLIC PROTOS CLS)
target_link_libraries(${PROJECT_NAME} PRIVATE CLS_BSP)

2
Application/Tasks/CanDataTask.c
View File

@@ -23,8 +23,6 @@ const osThreadAttr_t CanDataTask_attr = {
.stack_mem = CanDataTask_stk,
.stack_size = sizeof(CanDataTask_stk),
.priority = osPriorityNormal,
.tz_module = 0U,
.reserved = 0U
};