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

82
Application/Tasks/FirmwareHandler.c
View File

@@ -12,12 +12,12 @@
#include "stdbool.h"
// static memory only for decoding messages
static FirmwareStart msg_FirmwareStart;
static FirmwarePackage msg_FirmwarePackage;
static FirmwarePackageAck msg_FirmwarePackageAck;
static FirmwareDone msg_FirmwareDone;
static FirmwareFileCheck msg_FirmwareFileCheck;
static UsbDataPacket pack_FirmwarePackage;
static cls_firmware_Start msg_cls_firmware_Start;
static cls_firmware_Package msg_cls_firmware_Package;
static cls_firmware_PackageAck msg_cls_firmware_PackageAck;
static cls_firmware_Done msg_cls_firmware_Done;
static cls_firmware_FileCheck msg_cls_firmware_FileCheck;
static UsbDataPacket pack_cls_firmware_Package;
static FIL FwFile = {0};
@@ -27,7 +27,7 @@ static uint32_t fwStartTime = 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 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.
*/
void DataSend_FirmwarePackgeAck(bool ack, uint32_t crc, uint32_t counter, uint32_t device) {
msg_FirmwarePackageAck.ack = ack;
msg_FirmwarePackageAck.counter= counter;
msg_FirmwarePackageAck.crc_pac = crc;
msg_FirmwarePackageAck.device_id =device;
msg_cls_firmware_PackageAck.ack = ack;
msg_cls_firmware_PackageAck.counter= counter;
msg_cls_firmware_PackageAck.crc_pac = crc;
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) {
msg_FirmwareFileCheck.crc_fw = crc;
msg_FirmwareFileCheck.device_id = device_id;
msg_FirmwareFileCheck.ready_for_data = ready_for_data;
msg_FirmwareFileCheck.size = size;
memcpy(msg_FirmwareFileCheck.name, name, sizeof(msg_FirmwareFileCheck.name));
msg_cls_firmware_FileCheck.crc_fw = crc;
msg_cls_firmware_FileCheck.device_id = device_id;
msg_cls_firmware_FileCheck.ready_for_data = ready_for_data;
msg_cls_firmware_FileCheck.size = size;
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
static uint8_t crc_buffer[CHUNK_SIZE];
void DataClbk_FirmwareStart(void *msg, uint32_t length) {
DATA_CLBK_SETUP(FirmwareStart);
void DataClbk_cls_firmware_Start(void *msg, uint32_t length) {
DATA_CLBK_SETUP(cls_firmware_Start);
fwStartTime = osKernelGetSysTimerCount();
fwPackageCounter = 0;
uint32_t crc = 0;
@@ -70,7 +70,7 @@ void DataClbk_FirmwareStart(void *msg, uint32_t length) {
f_close(&FwFile);
}
// 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);
do {
@@ -80,52 +80,52 @@ void DataClbk_FirmwareStart(void *msg, uint32_t length) {
} while(bytesRead == CHUNK_SIZE);
f_close(&FwFile);
if(crc == msg_FirmwareStart.crc_fw) {
if(crc == msg_cls_firmware_Start.crc_fw) {
// 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;
}
}
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;
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) {
DATA_CLBK_SETUP(FirmwarePackage);
void DataClbk_cls_firmware_Package(void *msg, uint32_t length) {
DATA_CLBK_SETUP(cls_firmware_Package);
// check CRC and Package counter
uint32_t crc_check = HAL_CRC_Calculate(&hcrc,(uint32_t *)msg_FirmwarePackage.data.bytes, msg_FirmwarePackage.data.size);
if(msg_FirmwarePackage.crc_pac != crc_check ) {
DataSend_FirmwarePackgeAck(false, msg_FirmwarePackage.crc_pac, msg_FirmwarePackage.counter, msg_FirmwarePackage.device_id);
uint32_t crc_check = HAL_CRC_Calculate(&hcrc,(uint32_t *)msg_cls_firmware_Package.data.bytes, msg_cls_firmware_Package.data.size);
if(msg_cls_firmware_Package.crc_pac != crc_check ) {
DataSend_FirmwarePackgeAck(false, msg_cls_firmware_Package.crc_pac, msg_cls_firmware_Package.counter, msg_cls_firmware_Package.device_id);
return;
}
if(msg_FirmwarePackage.counter != fwPackageCounter) {
DataSend_FirmwarePackgeAck(false, msg_FirmwarePackage.crc_pac, msg_FirmwarePackage.counter, msg_FirmwarePackage.device_id);
if(msg_cls_firmware_Package.counter != fwPackageCounter) {
DataSend_FirmwarePackgeAck(false, msg_cls_firmware_Package.crc_pac, msg_cls_firmware_Package.counter, msg_cls_firmware_Package.device_id);
return;
}
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;
}
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++;
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) {
DATA_CLBK_SETUP(FirmwarePackageAck);
void DataClbk_cls_firmware_PackageAck(void *msg, uint32_t length) {
DATA_CLBK_SETUP(cls_firmware_PackageAck);
// Does notthing for the Master
}
void DataClbk_FirmwareDone(void *msg, uint32_t length) {
DATA_CLBK_SETUP(FirmwareDone);
void DataClbk_cls_firmware_Done(void *msg, uint32_t length) {
DATA_CLBK_SETUP(cls_firmware_Done);
// check CRC and Package counter
@@ -134,8 +134,8 @@ void DataClbk_FirmwareDone(void *msg, uint32_t length) {
FileOpen=false;
FirmwareUpdateArgs args;
args.device = msg_FirmwareDone.device_id;
memcpy(args.name, msg_FirmwareStart.name, sizeof(args.name));
args.device = msg_cls_firmware_Done.device_id;
memcpy(args.name, msg_cls_firmware_Start.name, sizeof(args.name));
FirmwareUpdateTask_start(args);