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

renaming of proto messages with packages in mind

Browse Source
This commit is contained in:
Oliver Walter
2024-02-25 01:21:36 +01:00
parent 894abf9058
commit b09924b9c8
6 changed files with 97 additions and 97 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
Application/Tasks/CanDataTask.c
View File

@@ -122,15 +122,15 @@ void HAL_FDCAN_RxFifo1Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo1ITs)
} }
void DataClbk_ResponseDeviceList(void* msg, uint32_t length) { void DataClbk_cls_device_ResponseList(void* msg, uint32_t length) {
// igored // igored
} }
#include "UsbDataHandler.h" #include "UsbDataHandler.h"
ResponseDeviceList list; cls_device_ResponseList list;
extern uint8_t gCLS_DEVICE_ADDRESS; extern uint8_t gCLS_DEVICE_ADDRESS;
void DataClbk_RequestDeviceList(void* msg, uint32_t length) { void DataClbk_cls_device_RequestList(void* msg, uint32_t length) {
// add yourself // add yourself
list.devices[list.devices_count].available = true; list.devices[list.devices_count].available = true;
@@ -154,6 +154,6 @@ void DataClbk_RequestDeviceList(void* msg, uint32_t length) {
} }
} }
USBDataResonse(&list, ResponseDeviceList_fields, UsbPackageType_RESPONSE_DEVICE_LIST); USBDataResonse(&list, cls_device_ResponseList_fields, cls_usb_PackageType_RESPONSE_DEVICE_LIST);
} }

82
Application/Tasks/FirmwareHandler.c
View File

@@ -12,12 +12,12 @@
#include "stdbool.h" #include "stdbool.h"
// static memory only for decoding messages // static memory only for decoding messages
static FirmwareStart msg_FirmwareStart; static cls_firmware_Start msg_cls_firmware_Start;
static FirmwarePackage msg_FirmwarePackage; static cls_firmware_Package msg_cls_firmware_Package;
static FirmwarePackageAck msg_FirmwarePackageAck; static cls_firmware_PackageAck msg_cls_firmware_PackageAck;
static FirmwareDone msg_FirmwareDone; static cls_firmware_Done msg_cls_firmware_Done;
static FirmwareFileCheck msg_FirmwareFileCheck; static cls_firmware_FileCheck msg_cls_firmware_FileCheck;
static UsbDataPacket pack_FirmwarePackage; static UsbDataPacket pack_cls_firmware_Package;
static FIL FwFile = {0}; static FIL FwFile = {0};
@@ -27,7 +27,7 @@ static uint32_t fwStartTime = 0;
static uint32_t fwPackageCounter =0; static uint32_t fwPackageCounter =0;
/** /**
* @brief This function builds and sends a FirmwarePackageAck message over USB. * @brief This function builds and sends a cls_firmware_PackageAck message over USB.
* *
* @param ack A boolean flag indicating the acknowledgment status. * @param ack A boolean flag indicating the acknowledgment status.
* @param crc A 32-bit cyclic redundancy check (CRC) for the firmware package. * @param crc A 32-bit cyclic redundancy check (CRC) for the firmware package.
@@ -35,31 +35,31 @@ static uint32_t fwPackageCounter =0;
* @param device A 32-bit identifier for the device. * @param device A 32-bit identifier for the device.
*/ */
void DataSend_FirmwarePackgeAck(bool ack, uint32_t crc, uint32_t counter, uint32_t device) { void DataSend_FirmwarePackgeAck(bool ack, uint32_t crc, uint32_t counter, uint32_t device) {
msg_FirmwarePackageAck.ack = ack; msg_cls_firmware_PackageAck.ack = ack;
msg_FirmwarePackageAck.counter= counter; msg_cls_firmware_PackageAck.counter= counter;
msg_FirmwarePackageAck.crc_pac = crc; msg_cls_firmware_PackageAck.crc_pac = crc;
msg_FirmwarePackageAck.device_id =device; msg_cls_firmware_PackageAck.device_id =device;
UsbDataPacketSendMessage(UsbPackageType_FIRMWAREPACKAGEACK, &pack_FirmwarePackage, FirmwarePackageAck_fields, &msg_FirmwarePackageAck); UsbDataPacketSendMessage(cls_usb_PackageType_FIRMWAREPACKAGEACK, &pack_cls_firmware_Package, cls_firmware_PackageAck_fields, &msg_cls_firmware_PackageAck);
} }
void DataSend_FirmwareFileCheck(uint32_t crc, uint32_t device_id, bool ready_for_data, UINT size, char* name) { void DataSend_FirmwareFileCheck(uint32_t crc, uint32_t device_id, bool ready_for_data, UINT size, char* name) {
msg_FirmwareFileCheck.crc_fw = crc; msg_cls_firmware_FileCheck.crc_fw = crc;
msg_FirmwareFileCheck.device_id = device_id; msg_cls_firmware_FileCheck.device_id = device_id;
msg_FirmwareFileCheck.ready_for_data = ready_for_data; msg_cls_firmware_FileCheck.ready_for_data = ready_for_data;
msg_FirmwareFileCheck.size = size; msg_cls_firmware_FileCheck.size = size;
memcpy(msg_FirmwareFileCheck.name, name, sizeof(msg_FirmwareFileCheck.name)); memcpy(msg_cls_firmware_FileCheck.name, name, sizeof(msg_cls_firmware_FileCheck.name));
UsbDataPacketSendMessage(UsbPackageType_FIRMWAREFILECHECK, &pack_FirmwarePackage, FirmwareFileCheck_fields, &msg_FirmwareFileCheck); UsbDataPacketSendMessage(cls_usb_PackageType_FIRMWAREFILECHECK, &pack_cls_firmware_Package, cls_firmware_FileCheck_fields, &msg_cls_firmware_FileCheck);
} }
#define CHUNK_SIZE 256 // Change this to the size of chunks you want to read #define CHUNK_SIZE 256 // Change this to the size of chunks you want to read
static uint8_t crc_buffer[CHUNK_SIZE]; static uint8_t crc_buffer[CHUNK_SIZE];
void DataClbk_FirmwareStart(void *msg, uint32_t length) { void DataClbk_cls_firmware_Start(void *msg, uint32_t length) {
DATA_CLBK_SETUP(FirmwareStart); DATA_CLBK_SETUP(cls_firmware_Start);
fwStartTime = osKernelGetSysTimerCount(); fwStartTime = osKernelGetSysTimerCount();
fwPackageCounter = 0; fwPackageCounter = 0;
uint32_t crc = 0; uint32_t crc = 0;
@@ -70,7 +70,7 @@ void DataClbk_FirmwareStart(void *msg, uint32_t length) {
f_close(&FwFile); f_close(&FwFile);
} }
// Check if file already exists // Check if file already exists
if(f_open(&FwFile, msg_FirmwareStart.name, FA_READ) == FR_OK) { if(f_open(&FwFile, msg_cls_firmware_Start.name, FA_READ) == FR_OK) {
__HAL_CRC_DR_RESET(&hcrc); __HAL_CRC_DR_RESET(&hcrc);
do { do {
@@ -80,52 +80,52 @@ void DataClbk_FirmwareStart(void *msg, uint32_t length) {
} while(bytesRead == CHUNK_SIZE); } while(bytesRead == CHUNK_SIZE);
f_close(&FwFile); f_close(&FwFile);
if(crc == msg_FirmwareStart.crc_fw) { if(crc == msg_cls_firmware_Start.crc_fw) {
// CRC matches, no need for transfer // CRC matches, no need for transfer
DataSend_FirmwareFileCheck(crc, msg_FirmwareStart.device_id, false, totalRead, msg_FirmwareStart.name); DataSend_FirmwareFileCheck(crc, msg_cls_firmware_Start.device_id, false, totalRead, msg_cls_firmware_Start.name);
return; return;
} }
} }
fresult_open = f_open(&FwFile, msg_FirmwareStart.name, FA_CREATE_ALWAYS | FA_WRITE); fresult_open = f_open(&FwFile, msg_cls_firmware_Start.name, FA_CREATE_ALWAYS | FA_WRITE);
FileOpen=true; FileOpen=true;
DataSend_FirmwareFileCheck(crc, msg_FirmwareStart.device_id, fresult_open==FR_OK, totalRead, msg_FirmwareStart.name); DataSend_FirmwareFileCheck(crc, msg_cls_firmware_Start.device_id, fresult_open==FR_OK, totalRead, msg_cls_firmware_Start.name);
} }
void DataClbk_FirmwarePackage(void *msg, uint32_t length) { void DataClbk_cls_firmware_Package(void *msg, uint32_t length) {
DATA_CLBK_SETUP(FirmwarePackage); DATA_CLBK_SETUP(cls_firmware_Package);
// check CRC and Package counter // check CRC and Package counter
uint32_t crc_check = HAL_CRC_Calculate(&hcrc,(uint32_t *)msg_FirmwarePackage.data.bytes, msg_FirmwarePackage.data.size); uint32_t crc_check = HAL_CRC_Calculate(&hcrc,(uint32_t *)msg_cls_firmware_Package.data.bytes, msg_cls_firmware_Package.data.size);
if(msg_FirmwarePackage.crc_pac != crc_check ) { if(msg_cls_firmware_Package.crc_pac != crc_check ) {
DataSend_FirmwarePackgeAck(false, msg_FirmwarePackage.crc_pac, msg_FirmwarePackage.counter, msg_FirmwarePackage.device_id); DataSend_FirmwarePackgeAck(false, msg_cls_firmware_Package.crc_pac, msg_cls_firmware_Package.counter, msg_cls_firmware_Package.device_id);
return; return;
} }
if(msg_FirmwarePackage.counter != fwPackageCounter) { if(msg_cls_firmware_Package.counter != fwPackageCounter) {
DataSend_FirmwarePackgeAck(false, msg_FirmwarePackage.crc_pac, msg_FirmwarePackage.counter, msg_FirmwarePackage.device_id); DataSend_FirmwarePackgeAck(false, msg_cls_firmware_Package.crc_pac, msg_cls_firmware_Package.counter, msg_cls_firmware_Package.device_id);
return; return;
} }
if(fresult_open != 0) { if(fresult_open != 0) {
DataSend_FirmwarePackgeAck(false, 0, 0, msg_FirmwarePackage.device_id); DataSend_FirmwarePackgeAck(false, 0, 0, msg_cls_firmware_Package.device_id);
return; return;
} }
unsigned int bytes_written =0; unsigned int bytes_written =0;
f_write(&FwFile,msg_FirmwarePackage.data.bytes, msg_FirmwarePackage.data.size, &bytes_written); f_write(&FwFile,msg_cls_firmware_Package.data.bytes, msg_cls_firmware_Package.data.size, &bytes_written);
fwPackageCounter++; fwPackageCounter++;
DataSend_FirmwarePackgeAck(true, msg_FirmwarePackage.crc_pac, msg_FirmwarePackage.counter, msg_FirmwarePackage.device_id); DataSend_FirmwarePackgeAck(true, msg_cls_firmware_Package.crc_pac, msg_cls_firmware_Package.counter, msg_cls_firmware_Package.device_id);
} }
void DataClbk_FirmwarePackageAck(void *msg, uint32_t length) { void DataClbk_cls_firmware_PackageAck(void *msg, uint32_t length) {
DATA_CLBK_SETUP(FirmwarePackageAck); DATA_CLBK_SETUP(cls_firmware_PackageAck);
// Does notthing for the Master // Does notthing for the Master
} }
void DataClbk_FirmwareDone(void *msg, uint32_t length) { void DataClbk_cls_firmware_Done(void *msg, uint32_t length) {
DATA_CLBK_SETUP(FirmwareDone); DATA_CLBK_SETUP(cls_firmware_Done);
// check CRC and Package counter // check CRC and Package counter
@@ -134,8 +134,8 @@ void DataClbk_FirmwareDone(void *msg, uint32_t length) {
FileOpen=false; FileOpen=false;
FirmwareUpdateArgs args; FirmwareUpdateArgs args;
args.device = msg_FirmwareDone.device_id; args.device = msg_cls_firmware_Done.device_id;
memcpy(args.name, msg_FirmwareStart.name, sizeof(args.name)); memcpy(args.name, msg_cls_firmware_Start.name, sizeof(args.name));
FirmwareUpdateTask_start(args); FirmwareUpdateTask_start(args);

36
Application/Tasks/LightTask.c
View File

@@ -23,9 +23,9 @@ const osThreadAttr_t LightTask_attr = {
.priority = osPriorityNormal, .priority = osPriorityNormal,
}; };
static LightGlobalBrightness msg_LightGlobalBrightness; static cls_light_GlobalBrightness msg_cls_light_GlobalBrightness;
static LightGlobalTheme msg_LightGlobalTheme; static cls_light_GlobalTheme msg_cls_light_GlobalTheme;
static LightThemeSettings msg_LightThemeSettings; static cls_light_ThemeSettings msg_cls_light_ThemeSettings;
static volatile struct LightSettings_s { static volatile struct LightSettings_s {
volatile uint8_t brightness; volatile uint8_t brightness;
@@ -66,32 +66,32 @@ void LightTask_func(void *argument) {
} }
} }
void DataClbk_LightGlobalBrightness(void* msg, uint32_t length) { void DataClbk_cls_light_GlobalBrightness(void* msg, uint32_t length) {
DATA_CLBK_SETUP(LightGlobalBrightness); DATA_CLBK_SETUP(cls_light_GlobalBrightness);
lightSettings.brightness = msg_LightGlobalBrightness.brightness; lightSettings.brightness = msg_cls_light_GlobalBrightness.brightness;
settingChangeTime = osKernelGetTickCount(); settingChangeTime = osKernelGetTickCount();
} }
void DataClbk_LightGlobalTheme(void* msg, uint32_t length) { void DataClbk_cls_light_GlobalTheme(void* msg, uint32_t length) {
DATA_CLBK_SETUP(LightGlobalTheme); DATA_CLBK_SETUP(cls_light_ThemeSettings);
lightSettings.theme = msg_LightGlobalTheme.theme; lightSettings.theme = msg_cls_light_GlobalTheme.theme;
settingChangeTime = osKernelGetTickCount(); settingChangeTime = osKernelGetTickCount();
} }
void DataClbk_LightThemeSettings(void* msg, uint32_t length) { void DataClbk_cls_light_ThemeSettings(void* msg, uint32_t length) {
DATA_CLBK_SETUP(LightThemeSettings); DATA_CLBK_SETUP(cls_light_ThemeSettings);
uint8_t device = msg_LightThemeSettings.deviceId & 0x1F; uint8_t device = msg_cls_light_ThemeSettings.deviceId & 0x1F;
uint8_t theme = msg_LightGlobalTheme.theme & 0x3; uint8_t theme = msg_cls_light_ThemeSettings.theme & 0x3;
uint16_t msg_light_setting = GENERATE_CLS_ADDRESS(CLS_CODE_CONFIG, device, theme); uint16_t msg_light_setting = GENERATE_CLS_ADDRESS(CLS_CODE_CONFIG, device, theme);
CLS_BSP_TxHeaderType can_header = CREATE_BSP_CAN_HEADER(msg_light_setting, CLS_BSP_DLC_BYTES_8); CLS_BSP_TxHeaderType can_header = CREATE_BSP_CAN_HEADER(msg_light_setting, CLS_BSP_DLC_BYTES_8);
RGB_Theme_t data = {0}; RGB_Theme_t data = {0};
data.animation = msg_LightThemeSettings.animation; data.animation = msg_cls_light_ThemeSettings.animation;
data.max_brighness = msg_LightThemeSettings.brightness; data.max_brighness = msg_cls_light_ThemeSettings.brightness;
data.color.r = (msg_LightThemeSettings.rgb) & 0xFF; data.color.r = (msg_cls_light_ThemeSettings.rgb) & 0xFF;
data.color.g = (msg_LightThemeSettings.rgb>>8) & 0xFF; data.color.g = (msg_cls_light_ThemeSettings.rgb>>8) & 0xFF;
data.color.b = (msg_LightThemeSettings.rgb>>16) & 0xFF; data.color.b = (msg_cls_light_ThemeSettings.rgb>>16) & 0xFF;
CLS_BSP_CAN_AddMessageToSend(&can_header, (uint8_t*)&data); CLS_BSP_CAN_AddMessageToSend(&can_header, (uint8_t*)&data);
} }

46
Application/Tasks/UsbDataHandler.c
View File

@@ -49,15 +49,15 @@ typedef union {
// static memory only for decoding messages // static memory only for decoding messages
union { union {
FirmwareStart msg_FirmwareStart; cls_firmware_Start msg_cls_firmware_Start;
FirmwarePackage msg_FirmwarePackage; cls_firmware_Package msg_cls_firmware_Package;
FirmwarePackageAck msg_FirmwarePackageAck; cls_firmware_PackageAck msg_cls_firmware_PackageAck;
FirmwareDone msg_FirmwareDone; cls_firmware_Done msg_cls_firmware_Done;
RequestDeviceList msg_RequestDeviceList; cls_device_RequestList msg_cls_device_RequestList;
ResponseDeviceList msg_ResponseDeviceList; cls_device_ResponseList msg_cls_device_ResponseList;
LightGlobalBrightness msg_LightGlobalBrightness; cls_light_GlobalBrightness msg_cls_light_GlobalBrightness;
LightGlobalTheme msg_LightGlobalTheme; cls_light_GlobalTheme msg_cls_light_GlobalTheme;
LightThemeSettings msg_LightThemeSettings; cls_light_ThemeSettings msg_cls_light_ThemeSettings;
} mem_msg_decode; } mem_msg_decode;
@@ -103,15 +103,15 @@ typedef struct {
message_handler_t message_handlers[] = { message_handler_t message_handlers[] = {
MESSAGE_HANDLER(UsbPackageType_FIRMWARESTART, FirmwareStart), MESSAGE_HANDLER(cls_usb_PackageType_FIRMWARESTART, cls_firmware_Start),
MESSAGE_HANDLER(UsbPackageType_FIRMWAREPACKAGE, FirmwarePackage), MESSAGE_HANDLER(cls_usb_PackageType_FIRMWAREPACKAGE, cls_firmware_Package),
MESSAGE_HANDLER(UsbPackageType_FIRMWAREDONE, FirmwareDone), MESSAGE_HANDLER(cls_usb_PackageType_FIRMWAREDONE, cls_firmware_Done),
MESSAGE_HANDLER(UsbPackageType_FIRMWAREPACKAGEACK, FirmwarePackageAck), MESSAGE_HANDLER(cls_usb_PackageType_FIRMWAREPACKAGEACK, cls_firmware_PackageAck),
MESSAGE_HANDLER(UsbPackageType_REQUEST_DEVICE_LIST, RequestDeviceList), MESSAGE_HANDLER(cls_usb_PackageType_REQUEST_DEVICE_LIST, cls_device_RequestList),
MESSAGE_HANDLER(UsbPackageType_RESPONSE_DEVICE_LIST, ResponseDeviceList), MESSAGE_HANDLER(cls_usb_PackageType_RESPONSE_DEVICE_LIST, cls_device_ResponseList),
MESSAGE_HANDLER(UsbPackageType_LIGHT_GLOBAL_BRIGHT, LightGlobalBrightness), MESSAGE_HANDLER(cls_usb_PackageType_LIGHT_GLOBAL_BRIGHT, cls_light_GlobalBrightness),
MESSAGE_HANDLER(UsbPackageType_LIGHT_GLOBAL_THEME, LightGlobalTheme), MESSAGE_HANDLER(cls_usb_PackageType_LIGHT_GLOBAL_THEME, cls_light_GlobalTheme),
MESSAGE_HANDLER(UsbPackageType_LIGHT_SETTING_THEME, LightThemeSettings), MESSAGE_HANDLER(cls_usb_PackageType_LIGHT_SETTING_THEME, cls_light_ThemeSettings),
}; };
@@ -227,11 +227,11 @@ bool UsbDataPacketSendMessage(uint32_t type , UsbDataPacket * buffer ,const pb_m
static UsbDataPacket packet; static UsbDataPacket packet;
void USBDataResonse(void * msg, const pb_msgdesc_t* fields, UsbPackageType typeid) { void USBDataResonse(void * msg, const pb_msgdesc_t* fields, cls_usb_PackageType typeid) {
UsbDataPacketSendMessage(typeid, &packet, fields, msg); UsbDataPacketSendMessage(typeid, &packet, fields, msg);
} }
//__attribute__((weak)) void DataClbk_FirmwareStart(void *msg, uint32_t length) {} //__attribute__((weak)) void DataClbk_cls_firmware_Start(void *msg, uint32_t length) {}
//__attribute__((weak)) void DataClbk_FirmwarePackage(void *msg, uint32_t length) {} //__attribute__((weak)) void DataClbk_cls_firmware_Package(void *msg, uint32_t length) {}
//__attribute__((weak)) void DataClbk_FirmwarePackageAck(void *msg, uint32_t length) {} //__attribute__((weak)) void DataClbk_cls_firmware_PackageAck(void *msg, uint32_t length) {}
//__attribute__((weak)) void DataClbk_FirmwareDone(void *msg, uint32_t length) {} //__attribute__((weak)) void DataClbk_cls_firmware_Done(void *msg, uint32_t length) {}

20
Application/Tasks/UsbDataHandler.h
View File

@@ -123,19 +123,19 @@ void UsbDataHandler_Runner();
int UsbDataHandler_RxCallback(uint8_t* Buf, uint32_t Len); int UsbDataHandler_RxCallback(uint8_t* Buf, uint32_t Len);
void DataClbk_FirmwareStart(void* msg, uint32_t length); void DataClbk_cls_firmware_Start(void* msg, uint32_t length);
void DataClbk_FirmwarePackage(void* msg, uint32_t length); void DataClbk_cls_firmware_Package(void* msg, uint32_t length);
void DataClbk_FirmwarePackageAck(void* msg, uint32_t length); void DataClbk_cls_firmware_PackageAck(void* msg, uint32_t length);
void DataClbk_FirmwareDone(void* msg, uint32_t length); void DataClbk_cls_firmware_Done(void* msg, uint32_t length);
void DataClbk_ResponseDeviceList(void* msg, uint32_t length); void DataClbk_cls_device_ResponseList(void* msg, uint32_t length);
void DataClbk_RequestDeviceList(void* msg, uint32_t length); void DataClbk_cls_device_RequestList(void* msg, uint32_t length);
void DataClbk_LightGlobalBrightness(void* msg, uint32_t length); void DataClbk_cls_light_GlobalBrightness(void* msg, uint32_t length);
void DataClbk_LightGlobalTheme(void* msg, uint32_t length); void DataClbk_cls_light_GlobalTheme(void* msg, uint32_t length);
void DataClbk_LightThemeSettings(void* msg, uint32_t length); void DataClbk_cls_light_ThemeSettings(void* msg, uint32_t length);
#include "usb.pb.h" #include "usb.pb.h"
void USBDataResonse(void * msg, const pb_msgdesc_t *fields, UsbPackageType typeid); void USBDataResonse(void * msg, const pb_msgdesc_t *fields, cls_usb_PackageType typeid);
#ifdef __cplusplus #ifdef __cplusplus
} }

2
proto

Submodule proto updated: c771175e39...68005c6b87