fix CI compile

Application/BSP/BSP_SDLogger.c

@@ -34,7 +34,7 @@ void BSP_SDLogger_Init(int log_number) {
         ULOG_ERROR("Failed to open file %s", file_name);
     }
 
-    ULOG_SUBSCRIBE(BSP_SDLogger_ULOG, ULOG_DEBUG_LEVEL);
+    //ULOG_SUBSCRIBE(BSP_SDLogger_ULOG, ULOG_DEBUG_LEVEL);
 
     // close the file
     f_close(&file);

Application/CLS_BSP/CLS_BSP.c

@@ -1,4 +1,5 @@
 #include "CLS_BSP.h"
+#include "CLSAddress.h"
 
 
 #ifdef CLS_BSP_FDCAN
@@ -68,3 +69,8 @@ CLS_Position_t CLS_BSP_GetPosition(void) {
 
 void CLS_BSP_SetPosition(CLS_Position_t position) {
 }
+
+
+
+#include "BSP_GPIO.h"
+

Application/CLS_BSP/CMakeLists.txt

@@ -12,4 +12,4 @@ target_sources(${PROJECT_NAME}
     )
 
 target_include_directories(${PROJECT_NAME} PUBLIC ${CMAKE_CURRENT_LIST_DIR})
-target_link_libraries(${PROJECT_NAME} PRIVATE CLS)
+target_link_libraries(${PROJECT_NAME} PRIVATE CLS BSP Vehicle)

Application/CMakeLists.txt

@@ -2,3 +2,5 @@ add_subdirectory(Tasks)
 add_subdirectory(CLS)
 add_subdirectory(CLS_BSP)
 add_subdirectory(BSP)
+add_subdirectory(ram_loader)
+add_subdirectory(Vehicle)

Application/Tasks/CMakeLists.txt

@@ -22,4 +22,4 @@ target_sources(${PROJECT_NAME}
 
 target_include_directories(${PROJECT_NAME} INTERFACE ${CMAKE_CURRENT_LIST_DIR})
 target_link_libraries(${PROJECT_NAME} PUBLIC PROTOS CLS)
-target_link_libraries(${PROJECT_NAME} PRIVATE Revision CLS_BSP BSP ulog)
+target_link_libraries(${PROJECT_NAME} PRIVATE Revision CLS_BSP BSP ulog Vehicle ram_loader)

Application/Tasks/CanDataTask.c

@@ -11,6 +11,7 @@
 #include "ulog.h"
 #include "BSP_POWER.h"
 #include "BSP_GPIO.h"
+#include "Vehicle.h"
 // Define thread flags
 #define FLAG_FDCAN_RX_FIFO0  (1<<0)
 #define FLAG_FDCAN_RX_FIFO1  (1<<1)
@@ -46,7 +47,7 @@ const osThreadAttr_t CarCanTask_attr = {
   .priority = osPriorityNormal,
 };
 
-
+static uint64_t last_car_message_time = 0;
 
 uint32_t dlcDecode(uint32_t dlcCode) {
     switch(dlcCode) {
@@ -130,11 +131,6 @@ void CanDataTask_func(void *argument) {
     }   
 }
 
-static uint64_t last_unlock_message_time = UINT64_MAX;
-static uint64_t last_car_message_time = 0;
-static uint8_t car_can_brightness = 255;
-static float car_can_speed = 0;
-static int car_can_direction = 0;
 
 // convert byte to 2 hex characters
 void byteToHex(uint8_t byte, char * hex) {
@@ -143,6 +139,10 @@ void byteToHex(uint8_t byte, char * hex) {
     hex[1] = hexLookup[byte & 0x0F];
 }
 
+
+static FDCAN_RxHeaderTypeDef RxHeader = {0};
+static uint8_t RxData[8] = {0};
+
 void CarCanTask_func(void *argument) {
 
     // for testing accept all messages from the car can bus
@@ -152,20 +152,8 @@ void CarCanTask_func(void *argument) {
     }
 
 
+    Vehicle_Setup_CAN();
      
-    FDCAN_FilterTypeDef sFilterConfig;
-    sFilterConfig.IdType = FDCAN_STANDARD_ID;
-    sFilterConfig.FilterIndex = 0;
-    sFilterConfig.FilterType = CLS_BSP_CAN_FILTER_LIST;
-    sFilterConfig.FilterConfig = FDCAN_FILTER_TO_RXFIFO1;
-    sFilterConfig.FilterID1 = 0x391;
-    sFilterConfig.FilterID2 = 0x395;
-    HAL_FDCAN_ConfigFilter(&hfdcan2, &sFilterConfig);
-
-    sFilterConfig.FilterIndex = 1;
-    sFilterConfig.FilterID1 = 0x351;
-    sFilterConfig.FilterID2 = 0x635;
-    HAL_FDCAN_ConfigFilter(&hfdcan2, &sFilterConfig);
 
     /* Start the FDCAN module */
     if (HAL_FDCAN_Start(&hfdcan2) != HAL_OK){
@@ -176,8 +164,7 @@ void CarCanTask_func(void *argument) {
         Error_Handler();
     }
 
-    FDCAN_RxHeaderTypeDef RxHeader;
-    uint8_t RxData[8];
+
 
     for(;;) {
         // wait for interrupt event on any fifo
@@ -261,71 +248,8 @@ void CarCanTask_func(void *argument) {
             if (HAL_FDCAN_GetRxMessage(&hfdcan2, FDCAN_RX_FIFO1, &RxHeader, RxData) != HAL_OK) {
                 Error_Handler();
             } else {
-                char msg[17] = {0};
 
-
-                // do something with the can data
-
-
-                if(RxHeader.Identifier == 0x391) {
-                    byteToHex(RxData[0], &msg[0]);
-                    byteToHex(RxData[1], &msg[2]);
-                    byteToHex(RxData[2], &msg[4]);
-                    if (RxData[1]  == 0x04)
-                    {
-                        // car was unlocked
-                        last_unlock_message_time = osKernelGetTickCount();
-                    } 
-                    else if (RxData[1]  ==0x80)
-                    {
-                        // car was locked
-                        if (!BSP_GPIO_K15isSet()) {
-                         NVIC_SystemReset();
-                        }
-                    }
-                
-                }
-
-                if (RxHeader.Identifier == 0x395) {
-                    byteToHex(RxData[0], &msg[0]);
-
-                    // send the unlock message to the car
-                    if ((RxData[0] & 0x0F) == 0x01) {
-                        // car was unlocked
-                        last_unlock_message_time = osKernelGetTickCount();
-                        ULOG_DEBUG("Unlock message received");
-
-                    } else if ((RxData[0] & 0x0F) == 0x02) {
-                        // car was locked
-                        if (!BSP_GPIO_K15isSet()) {
-                            NVIC_SystemReset();
-                        }
-                    }
-
-                }
-
-                // speed signal 
-                // AA BB XX YY 00 00 00 00 
-                // Speed (XX*(2^8)+(YY-1))/190
-                // direction AA = 0x00 forward, 0x02 backward
-                if (RxHeader.Identifier == 0x351) {
-
-                    uint16_t speed = (RxData[2] << 8) + RxData[3];
-                    float speed_kmh = (speed - 1) / 190.0;
-                    car_can_speed = speed_kmh;
-                    car_can_direction = RxData[0];
-                    ULOG_DEBUG("Speed: %f, Direction: %d", car_can_speed, car_can_direction);
-
-
-                }
-
-                // brightness knob in 0 - 100
-                if (RxHeader.Identifier == 0x635) {
-                    // scale the brightness to 0 - 255 only using integer math
-                    car_can_brightness = ((uint32_t)RxData[0] * 255) / 100;
-                    ULOG_DEBUG("Brightness: %d", car_can_brightness);
-
-                }
+                Vehicle_Receive_CAN(RxHeader, RxData);
 
                 //ULOG_DEBUG("Used Car MSG: %x, %d %s", RxHeader.Identifier, CLS_BSP_DLC_ToBytes(RxHeader.DataLength), msg );
             }
@@ -339,9 +263,6 @@ void CarCanTask_func(void *argument) {
  * @return true if a car can message has been received
  * @return false if no car can message has been received
  */
-bool CanDataTask_gotCarCanMessage() {
-    return last_unlock_message_time != UINT64_MAX;
-}
 
 
 bool CanDataTask_CarCanActive() {
@@ -350,20 +271,9 @@ bool CanDataTask_CarCanActive() {
     }
 
     return osKernelGetTickCount() - last_car_message_time < 1000;
-
 }
 
-uint8_t CanDataTask_CarCanBrightness() {
-    return car_can_brightness;
-}
 
-float CanDataTask_CarCanSpeed() {
-    return car_can_speed;
-}
-
-int CanDataTask_CarCanDirectionIsForward() {
-    return car_can_direction == 0;
-}
 
 void HAL_FDCAN_RxFifo0Callback(FDCAN_HandleTypeDef *hfdcan, uint32_t RxFifo0ITs) {
     // Notify the thread

Application/Tasks/FirmwareHandler.c

@@ -10,6 +10,9 @@
 #include "crc.h"
 #include "FirmwareUpdate.h"
 #include "stdbool.h"
+#include "CLS.h"
+#include "stdbool.h"
+#include "ram_loader.h"
 
 // static memory only for decoding messages
 static cls_firmware_Start msg_cls_firmware_Start;
@@ -58,19 +61,15 @@ void DataSend_FirmwareFileCheck(uint32_t crc, uint32_t device_id, bool ready_for
 #define CHUNK_SIZE 256  // Change this to the size of chunks you want to read
 static uint8_t crc_buffer[CHUNK_SIZE];
 
-void DataClbk_cls_firmware_Start(void *msg, uint32_t length) {
-  DATA_CLBK_SETUP(cls_firmware_Start);
-  fwStartTime = osKernelGetSysTimerCount();
-  fwPackageCounter = 0;
+
+void fw_Start_Slave( cls_firmware_Start * msg)  {
+
   uint32_t crc = 0;
   UINT totalRead = 0;
   UINT bytesRead = 0;
   
-  if(FileOpen) {
-    f_close(&FwFile);
-  }
   // Check if file already exists
-  if(f_open(&FwFile, msg_cls_firmware_Start.name, FA_READ) == FR_OK) {
+  if(f_open(&FwFile, msg->name, FA_READ) == FR_OK) {
 
     __HAL_CRC_DR_RESET(&hcrc);
     do {
@@ -80,16 +79,38 @@ void DataClbk_cls_firmware_Start(void *msg, uint32_t length) {
     } while(bytesRead == CHUNK_SIZE);
     f_close(&FwFile);
 
-    if(crc == msg_cls_firmware_Start.crc_fw) { 
+    if(crc == msg->crc_fw) { 
       // CRC matches, no need for transfer
-      DataSend_FirmwareFileCheck(crc, msg_cls_firmware_Start.device_id, false, totalRead, msg_cls_firmware_Start.name);
+      DataSend_FirmwareFileCheck(crc, msg->device_id, false, totalRead, msg->name);
       return;
     }
   }
 
-  fresult_open = f_open(&FwFile, msg_cls_firmware_Start.name, FA_CREATE_ALWAYS | FA_WRITE);
+  fresult_open = f_open(&FwFile, msg->name, FA_CREATE_ALWAYS | FA_WRITE);
   FileOpen=true;
-  DataSend_FirmwareFileCheck(crc, msg_cls_firmware_Start.device_id, fresult_open==FR_OK, totalRead, msg_cls_firmware_Start.name);
+  DataSend_FirmwareFileCheck(crc, msg->device_id, fresult_open==FR_OK, totalRead, msg->name);
+}
+
+void fw_Start_Master( cls_firmware_Start * msg) {
+  fresult_open = f_open(&FwFile, "firm.bin", FA_CREATE_ALWAYS | FA_WRITE);
+  FileOpen=true;
+  DataSend_FirmwareFileCheck(0, msg->device_id, fresult_open==FR_OK, 0, msg->name);
+}
+
+void DataClbk_cls_firmware_Start(void *msg, uint32_t length) {
+  DATA_CLBK_SETUP(cls_firmware_Start);
+  fwStartTime = osKernelGetSysTimerCount();
+  fwPackageCounter = 0;
+
+  if(FileOpen) {
+    f_close(&FwFile);
+  }
+
+  if(msg_cls_firmware_Start.device_id == gCLS_DEVICE_ADDRESS) {
+    fw_Start_Master(&msg_cls_firmware_Start);
+  } else {
+    fw_Start_Slave(&msg_cls_firmware_Start);
+  }
 }
 
 
@@ -133,10 +154,14 @@ void DataClbk_cls_firmware_Done(void *msg, uint32_t length) {
   fresult_open = 0xFF;
   FileOpen=false;
 
+  if(msg_cls_firmware_Done.device_id == gCLS_DEVICE_ADDRESS) {
+    RamLoader_LoadApplication();
+  } else {
+
     FirmwareUpdateArgs args;
     args.device = msg_cls_firmware_Done.device_id;
     memcpy(args.name, msg_cls_firmware_Start.name, sizeof(args.name));
 
     FirmwareUpdateTask_start(args);
-  
+  }
 }

Application/Tasks/FirmwareUpdate.c

@@ -160,7 +160,6 @@ void FirmwareUpdateTask_start(FirmwareUpdateArgs args) {
    }
 }
 
-UsbDataPacket buffer;
 void CLSFirmwareUpdateTask_func(void *argument) {
     FirmwareUpdateArgs args;
     osStatus_t status;

Application/Tasks/LightState.c

@@ -5,6 +5,7 @@
 #include "LightTask.h"
 #include "ulog.h"
 #include "stdbool.h"
+#include "Vehicle.h"
 
 // Create the task with a specific priority and stack size
 osThreadAttr_t task_attr = {
@@ -24,89 +25,15 @@ void LightStateTask_start(void)
 
 
 
-// Check if K15 is on for switching the light state
-static bool isK15On()
-{
-    return BSP_GPIO_K15isSet();
-}
-
-
-// Define the threshold voltage for engine running
-#define ENGINE_RUNNING_THRESHOLD 13.3 // 13.5V
-
-// Define thresholds with hysteresis
-#define ENGINE_RUNNING_THRESHOLD_HIGH (ENGINE_RUNNING_THRESHOLD + 0.125)
-#define ENGINE_RUNNING_THRESHOLD_LOW (ENGINE_RUNNING_THRESHOLD - 0.125)
-
-// Global variable to store the current engine state
-static bool engineRunning = false;
-
-// Function to initialize the engine state based on the initial voltage
-static void initializeEngineState()
-{
-    float initialVoltage = BSP_ADC_ReadBusValue();
-    if (initialVoltage > ENGINE_RUNNING_THRESHOLD)
-    {
-        engineRunning = true;
-    }
-    else
-    {
-        engineRunning = false;
-    }
-}
-
-// Ensure the engine state is initialized once
-static bool isEngineInitialized = false;
-
-static bool isEngineRunning()
-{
-    if (!isEngineInitialized)
-    {
-        initializeEngineState();
-        isEngineInitialized = true;
-    }
-
-    float voltage = BSP_ADC_ReadBusValue();
-
-    if (engineRunning)
-    {
-        // If engine is currently running, use the lower threshold to turn it off
-        if (voltage < ENGINE_RUNNING_THRESHOLD_LOW)
-        {
-            engineRunning = false;
-        }
-    }
-    else
-    {
-        // If engine is currently off, use the higher threshold to turn it on
-        if (voltage > ENGINE_RUNNING_THRESHOLD_HIGH)
-        {
-            engineRunning = true;
-        }
-
-
-
-    }
-    return engineRunning;
-}
-// check if the headlight is on and the engine is running to switch the light state
-// we can check the headlight using the GPIO functions
-static bool isHeadlightOn()
-{
-    return BSP_GPIO_HeadLightIsSet();
-}
-
-
-
 // Function to determine the next state of the light
 // return 1 as default state
 // return 2 if the engine is running
 // return 3 if the headlight and engine is running
 static int determineNextState()
 {
-    if (isHeadlightOn() && isEngineRunning()) {
+    if (Vehicle_isHeadlightOn() && Vehicle_isEngineRunning()) {
         return 2;
-    } else if (isEngineRunning()) {
+    } else if (Vehicle_isEngineRunning()) {
         return 1;
     } else {
         return 0;

Application/Tasks/LightTask.c

@@ -11,6 +11,7 @@
 #include "BSP_GPIO.h"
 
 #include "CanDataTask.h"
+#include "Vehicle.h"
 #include "BSP_ADC.h"
 #define DIMM_DEADZONE_VOLTAGE 0.7
 
@@ -82,14 +83,14 @@ void LightTask_func(void *argument) {
 
 
 
-        float dimmfactor = 1.0;
+        uint8_t dimm = 255;
 
+        // currenlty not working
         // only dimm if the headlight is on
-        if (BSP_GPIO_HeadLightIsSet()) {
+        //if (Vehicle_isHeadlightOn()) {
 
             // new version over CAN
-            uint8_t precent = CanDataTask_CarCanBrightness();
-            dimmfactor = (float)precent / 100.0;
+            //dimm  = Vehicle_Brightness();
 
             // old version over ADC
             // calculate the dimmfactor based on the battery voltage and the dimmer voltage
@@ -104,9 +105,10 @@ void LightTask_func(void *argument) {
             //} else {
             //    dimmfactor = (v_dimm - 4.0) / (v_bus - 4.0);
             //}
-        }
 
-        uint8_t adjustedBrightness = (uint8_t)(brightness * dimmfactor);
+        //}
+
+        uint8_t adjustedBrightness = (brightness * dimm)/ 255;
         lightSettings_dimmed.brightness = adjustedBrightness;
         lightSettings_dimmed.theme = lightSettings.theme;
         

Application/Vehicle/CMakeLists.txt

@@ -0,0 +1,32 @@
+# Set the minimum required CMake version
+cmake_minimum_required(VERSION 3.12)
+
+# Set the project name
+project(Vehicle)
+
+# Add the source files for the library
+set(SOURCES
+Vehicle.c
+Vehicle_can.c
+)
+
+# Add the header files for the library
+set(HEADERS
+    Vehicle.h
+)
+
+# Create the library target
+add_library(Vehicle ${SOURCES} ${HEADERS})
+
+# Set the include directories for the library
+target_include_directories(Vehicle PUBLIC ./)
+
+# Set any additional compiler flags or options
+# target_compile_options(Vehicle PRIVATE ...)
+
+# Set any additional linker flags or options
+# target_link_options(Vehicle PRIVATE ...)
+
+# Specify any dependencies for the library
+target_link_libraries(Vehicle BSP CLS CLS_BSP)
+

Application/Vehicle/Vehicle.c

@@ -0,0 +1,82 @@
+
+#include "Vehicle.h"
+#include "BSP_GPIO.h"
+#include "stdbool.h"
+#include "BSP_ADC.h"
+
+// Define the threshold voltage for engine running
+#define ENGINE_RUNNING_THRESHOLD 13.0 // 13.5V
+
+// Define thresholds with hysteresis
+#define ENGINE_RUNNING_THRESHOLD_HIGH (ENGINE_RUNNING_THRESHOLD + 0.225)
+#define ENGINE_RUNNING_THRESHOLD_LOW (ENGINE_RUNNING_THRESHOLD - 0.225)
+
+// Global variable to store the current engine state
+static bool engineRunning = false;
+
+
+void Vehicle_Init() {
+    engineRunning = false;
+}
+
+bool Vehicle_isHeadlightOn()
+{
+    return BSP_GPIO_HeadLightIsSet();
+}
+
+bool Vehicle_isEngineRunning() {
+
+
+    float voltage = BSP_ADC_ReadBusValue();
+
+    if (engineRunning)
+    {
+        // If engine is currently running, use the lower threshold to turn it off
+        if (voltage < ENGINE_RUNNING_THRESHOLD_LOW)
+        {
+            engineRunning = false;
+        }
+    }
+    else
+    {
+        // If engine is currently off, use the higher threshold to turn it on
+        if (voltage > ENGINE_RUNNING_THRESHOLD_HIGH)
+        {
+            engineRunning = true;
+        }
+
+
+
+    }
+    return engineRunning;
+}
+
+bool Vehicle_isK15On() {
+    return BSP_GPIO_K15isSet();
+}
+
+
+
+
+
+
+#include "CLS.h"
+#include "CLS_BSP.h"
+#include "CLSAddress.h"
+
+static CLS_VehicleStatus_t status = {0};
+_Static_assert(sizeof(status) == 8, "CLS_HeatbeatData_t is not 8 bytes");
+
+void CLS_VehicleHeatbeat(void *argument) {
+    CLS_BSP_TxHeaderType cls_vehicle_header = CREATE_BSP_CAN_HEADER(GENERATE_CLS_ADDRESS(CLS_CODE_STATUS,0,CLS_CH_STA_VEHICLE), CLS_BSP_DLC_BYTES_8);
+
+    
+    status.k15 = Vehicle_isK15On();
+    status.headlight = Vehicle_isHeadlightOn();
+    status.engine = Vehicle_isEngineRunning();
+    status.speed = (uint8_t)Vehicle_Speed();
+    status.unlocked = Vehicle_UnlockedSignal();
+
+    CLS_BSP_CAN_AddMessageToSend(&cls_vehicle_header, (uint8_t*)&status);
+
+}

Application/Vehicle/Vehicle.h

@@ -0,0 +1,24 @@
+
+#include "fdcan.h"
+#include "stdint.h"
+#include "stdbool.h"
+
+void Vehicle_Init();
+
+bool Vehicle_isHeadlightOn();
+
+bool Vehicle_isEngineRunning();
+
+bool Vehicle_isK15On();
+
+
+void Vehicle_Setup_CAN();
+
+void Vehicle_Receive_CAN( FDCAN_RxHeaderTypeDef header, uint8_t* data);
+
+
+bool Vehicle_gotUnlockMessage();
+uint8_t Vehicle_Brightness();
+float Vehicle_Speed();
+int Vehicle_DirectionIsForward();
+bool Vehicle_UnlockedSignal();

Application/Vehicle/Vehicle_can.c

@@ -0,0 +1,146 @@
+#include "Vehicle.h"
+#include "fdcan.h"
+#include "CLS.h"
+#include "CLS_BSP.h"
+#include "BSP_GPIO.h"
+#include "cmsis_os2.h"
+
+static uint64_t last_unlock_message_time = UINT64_MAX;
+static uint8_t car_can_brightness = 255;
+static float car_can_speed = 0;
+static int car_can_direction = 0;
+
+
+void Vehicle_Setup_CAN() {
+
+
+    FDCAN_FilterTypeDef sFilterConfig;
+    sFilterConfig.IdType = FDCAN_STANDARD_ID;
+    sFilterConfig.FilterIndex = 0;
+    sFilterConfig.FilterType = CLS_BSP_CAN_FILTER_LIST;
+    sFilterConfig.FilterConfig = FDCAN_FILTER_TO_RXFIFO1;
+    sFilterConfig.FilterID1 = 0x391;
+    sFilterConfig.FilterID2 = 0x395;
+    HAL_FDCAN_ConfigFilter(&hfdcan2, &sFilterConfig);
+
+    sFilterConfig.FilterIndex = 1;
+    sFilterConfig.FilterID1 = 0x351;
+    sFilterConfig.FilterID2 = 0x635;
+    HAL_FDCAN_ConfigFilter(&hfdcan2, &sFilterConfig);
+
+}
+
+
+static void rx_unlock_key(uint8_t * RxData ) {
+    if (RxData[1]  == 0x04)
+        {
+            // car was unlocked
+            last_unlock_message_time = osKernelGetTickCount();
+        } 
+        else if (RxData[1]  ==0x80)
+        {
+            // car was locked
+            if (!BSP_GPIO_K15isSet()) {
+                NVIC_SystemReset();
+            }
+        }
+
+}
+
+static void rx_unlock_secure(uint8_t * RxData ) {
+    if ((RxData[0] & 0x0F) == 0x01) {
+        // car was unlocked
+        last_unlock_message_time = osKernelGetTickCount();
+
+    } else if ((RxData[0] & 0x0F) == 0x02) {
+        // car was locked
+        if (!BSP_GPIO_K15isSet()) {
+            NVIC_SystemReset();
+        }
+    }
+
+
+}
+
+static void rx_speed(uint8_t *  RxData) {
+    // speed signal 
+    // AA BB XX YY 00 00 00 00 
+    // Speed (XX*(2^8)+(YY-1))/190
+    // direction AA = 0x00 forward, 0x02 backward
+    uint16_t speed = (RxData[2] << 8) + RxData[3];
+    float speed_kmh = (speed - 1) / 190.0;
+    car_can_speed = speed_kmh;
+    car_can_direction = RxData[0];
+    //ULOG_DEBUG("Speed: %f, Direction: %d", car_can_speed, car_can_direction);
+
+}
+
+static void rx_brightness(uint8_t* RxData) {
+    // scale the brightness to 0 - 255 only using integer math
+    car_can_brightness = ((uint32_t)RxData[0] * 255) / 100;
+    //ULOG_DEBUG("Brightness: %d", car_can_brightness);
+}
+
+void Vehicle_Receive_CAN( FDCAN_RxHeaderTypeDef RxHeader, uint8_t* RxData) {
+
+                if(RxHeader.Identifier == 0x391) {
+                    rx_unlock_key(RxData);
+                }
+
+                if (RxHeader.Identifier == 0x395) {
+                    rx_unlock_secure(RxData);
+                }
+
+
+                if (RxHeader.Identifier == 0x351) {
+                    rx_speed(RxData);
+                }
+
+                // brightness knob in 0 - 100
+                if (RxHeader.Identifier == 0x635) {
+                    rx_brightness(RxData);
+                }
+
+}
+
+
+
+bool Vehicle_gotUnlockMessage() {
+    return last_unlock_message_time != UINT64_MAX;
+}
+
+
+
+uint8_t Vehicle_Brightness() {
+    return car_can_brightness;
+}
+
+float Vehicle_Speed() {
+    return car_can_speed;
+}
+
+int Vehicle_DirectionIsForward() {
+    return car_can_direction == 0;
+}
+
+
+static bool unlocked = false;
+
+ 
+bool Vehicle_UnlockedSignal() {
+
+    if (unlocked) {
+        if(Vehicle_isK15On()) {
+            unlocked = false;
+            last_unlock_message_time = UINT64_MAX;
+        }
+    }
+
+    if (!unlocked) {
+        if (Vehicle_gotUnlockMessage()) {
+            unlocked = true;
+        }
+    }
+
+    return unlocked;
+}

Application/ram_loader/CMakeLists.txt

@@ -0,0 +1,34 @@
+# Set the minimum required CMake version
+cmake_minimum_required(VERSION 3.12)
+
+# Set the project name
+project(ram_loader)
+
+# Add the source files for the library
+set(SOURCES
+    ram_loader.c
+)
+
+# Add the header files for the library
+set(HEADERS
+    ram_loader.h
+)
+
+# Create the library target
+add_library(ram_loader ${SOURCES} ${HEADERS})
+
+# Set the include directories for the library
+target_include_directories(ram_loader PUBLIC ./)
+
+# Set any additional compiler flags or options
+# target_compile_options(${PROJECT_NAME} PRIVATE ...)
+
+# Set any additional linker flags or options
+# target_link_options(${PROJECT_NAME} PRIVATE ...)
+
+# Specify any dependencies for the library
+# target_link_libraries(${PROJECT_NAME} <dependency1> <dependency2> ...)
+
+# Optionally, add an executable target for testing
+# add_executable(test_ram_loader test/test_ram_loader.cpp)
+# target_link_libraries(test_ram_loader ${PROJECT_NAME})

Application/ram_loader/ram_loader.c

@@ -0,0 +1,110 @@
+#include "fatfs.h"
+#include "string.h"
+
+#define RAM_LOADER_BUFFER_SIZE 15*1024
+#define RAM_LOADER_ADDRESS 0x38000000
+#define APP_START_ADDRESS RAM_LOADER_ADDRESS
+uint8_t * ram_loader_buffer = (uint8_t *) RAM_LOADER_ADDRESS;
+
+void _app_start(void)
+{
+    __disable_irq();
+    // Reset USB
+
+    //De-init all peripherals
+    //HAL_ADC_DeInit(&hadc1);
+
+    // Disable Systick
+    SysTick->CTRL = 0;
+    SysTick->LOAD = 0;
+    SysTick->VAL = 0;
+
+    // Reset clock to default
+    HAL_RCC_DeInit();
+
+    // Clear all interrupt bits
+    for (uint8_t i = 0; i < sizeof(NVIC->ICER) / sizeof(NVIC->ICER[0]); i++)
+    {
+        NVIC->ICER[i] = 0xFFFFFFFF;
+        NVIC->ICPR[i] = 0xFFFFFFFF;
+    }
+
+    __enable_irq();
+
+
+    // set the vector table offset register
+    SCB->VTOR = APP_START_ADDRESS;
+
+    // get the application stack pointer
+    __set_MSP(((uint32_t *)APP_START_ADDRESS)[0]);
+
+
+    // jump to the application
+    ((void (*)(void))((uint32_t *)APP_START_ADDRESS)[1])();
+
+    // the application should never return
+    // ULOG_ERROR("Failed to start application");
+    while (1) {}
+
+}
+
+static uint8_t buffer[512];
+
+void RamLoader_LoadApplication()
+{
+
+    // check if the file "load.bin" exists
+    FIL file;
+    FRESULT res = f_open(&file, "load.bin", FA_READ);
+    if (res != FR_OK) {
+        // ULOG_ERROR("Failed to open file load.bin");
+        return;
+    }
+
+    UINT size =  f_size(&file);
+    // ensure the file is not larger than the buffer
+    if (size > RAM_LOADER_BUFFER_SIZE ) {
+        // ULOG_ERROR("File load.bin is too large");
+        return;
+    }
+
+    // read the file into the buffer
+    UINT bytes_read;
+    uint32_t remaining_bytes = size;
+    uint8_t *destination_ptr = ram_loader_buffer;
+    uint8_t *buffer_ptr = buffer;
+    while (remaining_bytes > 0) {
+        UINT read_size = remaining_bytes > 512 ? 512 : remaining_bytes;
+        res = f_read(&file, buffer_ptr, read_size, &bytes_read);
+        if (res != FR_OK) {
+            // ULOG_ERROR("Failed to read file load.bin");
+            return;
+        }
+        if (bytes_read != read_size) {
+            // ULOG_ERROR("Failed to read file load.bin completely");
+            return;
+        }
+
+        memcpy(destination_ptr, buffer_ptr, read_size);
+        remaining_bytes -= read_size;
+        destination_ptr += read_size;
+    }
+
+    // close the file
+    f_close(&file);
+
+
+    // check that the file to flash exists ("firm.bin")
+    res = f_open(&file, "firm.bin", FA_READ);
+    if (res != FR_OK) {
+        // ULOG_ERROR("Failed to open file firm.bin");
+        return;
+    }
+    //close the file
+    f_close(&file);
+
+
+    _app_start();
+
+
+}

Application/ram_loader/ram_loader.h

@@ -0,0 +1,3 @@
+#pragma once
+
+void RamLoader_LoadApplication();

CMakeLists.txt

@@ -140,7 +140,7 @@ add_subdirectory("Application")
 add_executable(${CMAKE_PROJECT_NAME})
 target_sources(${CMAKE_PROJECT_NAME} PUBLIC ${sources_SRCS})
 
-target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC Tasks CLS CLS_BSP BSP EE24 INA219 ulog)
+target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC Tasks CLS CLS_BSP BSP EE24 INA219 ulog ram_loader Vehicle)
 #target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC PROTOS)
 target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC uart_driver)
 #target_link_libraries(${CMAKE_PROJECT_NAME} PUBLIC lwrb)

Core/Src/freertos.c

@@ -40,6 +40,7 @@
 #include "BSP_GPIO.h"
 #include "BSP_ADC.h"
 #include "BSP_SDLogger.h"
+#include "Vehicle.h"
 /* USER CODE END Includes */
 
 /* Private typedef -----------------------------------------------------------*/
@@ -236,7 +237,7 @@ void WaitForStartConfirm_Task(void *argument) {
   while(1) {
     osDelayUntil(tick);
     tick += delayTime;
-    if(BSP_GPIO_K15isSet() || CanDataTask_gotCarCanMessage()) {
+    if(BSP_GPIO_K15isSet() || Vehicle_gotUnlockMessage()) {
         BSP_POWER_FullPowerMode();
         ULOG_INFO("Power systems started");
         osThreadExit();

Core/Src/main.c

@@ -41,6 +41,7 @@
 #include "BSP_POWER.h"
 #include "BSP_GPIO.h"
 #include "BSP_ADC.h"
+#include "ram_loader.h"
 /* USER CODE END Includes */
 
 /* Private typedef -----------------------------------------------------------*/
@@ -73,13 +74,12 @@ static void MPU_Config(void);
 void MX_FREERTOS_Init(void);
 /* USER CODE BEGIN PFP */
 void ULOG_SendLPUART(ulog_level_t level, char *msg);
-void JumpToBootloader_system(void);
+
 /* USER CODE END PFP */
 
 /* Private user code ---------------------------------------------------------*/
 /* USER CODE BEGIN 0 */
-const uint32_t OS_BOOTFLAG_ADDRESS = 0x38000000;
-const uint32_t OS_BOOTFLAG_MAGIC = 0xDEADBEFF;
+
 /* USER CODE END 0 */
 
 /**
@@ -90,19 +90,6 @@ int main(void)
 {
   /* USER CODE BEGIN 1 */
 
-  // Check if the bootloader magic number is set at the given address
-  volatile uint32_t * ptr = (uint32_t *)OS_BOOTFLAG_ADDRESS;
-  if (*ptr == OS_BOOTFLAG_MAGIC) {
-    // Jump to the bootloader
-    *ptr = 0;
-    JumpToBootloader_system();
-  }
-
-  if (*ptr == 0) {
-    *ptr = 2;
-    NVIC_SystemReset();
-  }
-  
 
   /* USER CODE END 1 */
 
@@ -302,58 +289,8 @@ void ULOG_SendLPUART(ulog_level_t level, char *msg) {
   HAL_UART_Transmit(&hlpuart1, (const uint8_t*)ulog_send_buffer, send_length,  LOG_TIMEOUT);
 }
 
-void JumpToBootloader(void)
-{
-
-    // Set the magic number to the given address
-    volatile uint32_t * ptr = (uint32_t *)OS_BOOTFLAG_ADDRESS;
-    *ptr = OS_BOOTFLAG_MAGIC;
-
-
-    NVIC_SystemReset();
-}
-
-void JumpToBootloader_system(void)
-{
-#define conBootloadAddress 0x1FF09800
-
-    void (*SysMemBootJump)(void);
-    uint8_t i;
-
-    __disable_irq();
-    // Reset USB
-    //USBD_DeInit(&hUsbDeviceHS);
-
-    //De-init all peripherals
-    //HAL_ADC_DeInit(&hadc1);
-
-    // Disable Systick
-    SysTick->CTRL = 0;
-    SysTick->LOAD = 0;
-    SysTick->VAL = 0;
-
-    // Reset clock to default
-    HAL_RCC_DeInit();
-
-    // Clear all interrupt bits
-    for (i = 0; i < sizeof(NVIC->ICER) / sizeof(NVIC->ICER[0]); i++)
-    {
-        NVIC->ICER[i] = 0xFFFFFFFF;
-        NVIC->ICPR[i] = 0xFFFFFFFF;
-    }
-
-    __enable_irq();
-
-    SysMemBootJump = (void (*)(void)) (*((uint32_t *) (conBootloadAddress + 4)));
-    __set_MSP(*(uint32_t *)conBootloadAddress);
-    SysMemBootJump();
-
-    while (1); // Just in case...
-}
-
-
 void DataClbk_cls_usb_JumpToBootloader(void* msg, uint32_t length) {
-  JumpToBootloader();
+  RamLoader_LoadApplication();
 }
 /* USER CODE END 4 */
 

tools/send_fw.py

@@ -30,7 +30,7 @@ def make_header(typeid: PackageType, length: int) -> bytearray:
     struct_format = '<HHB'  # '<' for little-endian, 'H' for uint16_t, 'B' for uint8_t
     # Calculate the check byte as the sum of length and type
     typeidint = int(typeid) 
-    check = (length & 0xFF) + ((length >> 8) & 0xFF) + (typeidint & 0xFF) + ((typeidint >> 8) & 0xFF)
+    check = ((length & 0xFF) + ((length >> 8) & 0xFF) + (typeidint & 0xFF) + ((typeidint >> 8) & 0xFF) ) & 0xff
     packed_data = struct.pack(struct_format, length, typeid, check)
     return packed_data
 

tools/set_device_type.py

@@ -6,10 +6,10 @@ if __name__ == "__main__":
         ser = setup_connection()
         # Create a message
         request = UpdateDeviceSettings()
-        request.device = 5
-        request.type = Type.LIGHT
-        request.position.append(Position.RIGHT)
-        request.position.append(Position.FLOOR)
+        request.device = 0
+        request.type = Type.COMMING_HOME
+        request.position.append(Position.LEFT)
+        request.position.append(Position.CENTER)
         # Serialize the request to a bytearray
         request_data = request.SerializeToString()