--upd

App/app.cpp

@@ -37,6 +37,8 @@ extern "C" {
 #include <cstring>
 #include "uart_bridge.hpp"
 #include "tim.h"
+#include <vector>
+
 
 UartBridge bridge(true, USART1, USART2, 9600, 9600);
 uint8_t flagTransmitCompleted = 1;
@@ -83,7 +85,8 @@ uint8_t controlPinFlag = 0;
 uint32_t controlPinDetectedMs = 0;
 uint8_t updateMode = 0;
 
-
+command_t lastZummerCommand;
+command_t sendCommand;
 void zummerOff(void) {
     HAL_TIM_Base_Stop(&htimZummer);
     HAL_TIM_PWM_Stop(&htimZummer, TIM_CHANNEL_2);
@@ -114,8 +117,10 @@ void proximityMessureCompleted(void) {
 VL6180_RangeData_t VL6180_Range;
 uint32_t waitAnswerFromReaderMs = 0;
 #define MAX_WAIT_ANSWER_FROM_GM60 30000
-#define DATA_TIMEOUT 500
+#define MAX_WAIT_FOR_BOOT_COMMAND 10000
 
+#define DATA_TIMEOUT 500
+uint32_t bootStartMs = 0;
 uint32_t lightStartMs = 0;
 uint8_t uart1Buf[1024];
 uint8_t uart2Buf[1024];
@@ -132,20 +137,37 @@ uint8_t uartTask(void) // return 0 if data received , otherwise return 1
         }
     }
 
-    if (!bridge.uart1Buf->is_empty() && bridge.getHuart2()->gState == 0x20) {
+    if (!bridge.uart1Buf.is_empty() && bridge.getHuart2()->gState == 0x20) {
         waitAnswerFromReaderMs = HAL_GetTick();
-        std::string_view stringView{bridge.uart1Buf->dequeue()};
+        std::string_view stringView{bridge.uart1Buf.dequeue()};
         uint32_t size = stringView.size();
         stringView.copy(reinterpret_cast<char *>(uart1Buf), size, 0);
-        if (stringView.find("FIRMWARE_UPDATE") != std::string::npos) {
+        if (size == sizeof(command_t))
-            HAL_UART_DeInit(bridge.getHuart1());
+        {
-            BootComInit();
+            uint8_t com = stringView[0];
-            zummerOff();
+            if (com == ENTER_FIRMWARE_UPDATE) {
-            lightingOff();
+                HAL_UART_DeInit(bridge.getHuart1());
-        } else if (stringView.find("ZOOMER_ON") != std::string::npos) {
+                BootComInit();
-            zummerOn();
+                zummerOff();
-        } else if (stringView.find("ZOOMER_OFF") != std::string::npos) {
+                lightingOff();
-            zummerOff();
+                updateMode = 1;
+                bootStartMs = HAL_GetTick();
+
+            } else if (com == ZUMMER_ON || com == ZUMMER_OFF) {
+                memcpy(&lastZummerCommand, uart1Buf, sizeof(lastZummerCommand));
+        }
+            else if (com == GET_FIRMWARE_VERSION)
+            {
+                uint8_t fw_ver[16];
+                sprintf(reinterpret_cast<char *>(fw_ver),"%s", FW_VERSION);
+                sendCommand = {
+                        GET_FIRMWARE_VERSION,
+                        *(uint16_t*)&fw_ver[0],
+                        *(uint16_t*)&fw_ver[2],
+                        0x00
+                };
+            }
+            HAL_UART_Transmit_IT(bridge.getHuart1(), (uint8_t*) &sendCommand, sizeof(sendCommand));
         } else {
             HAL_UART_Transmit_IT(bridge.getHuart2(), (const uint8_t *) uart1Buf, size);
         }
@@ -153,13 +175,13 @@ uint8_t uartTask(void) // return 0 if data received , otherwise return 1
         return 0;
     }
 
-    if (!bridge.uart2Buf->is_empty() && bridge.getHuart1()->gState == 0x20) {
+    if (!bridge.uart2Buf.is_empty() && bridge.getHuart1()->gState == 0x20) {
         msms = HAL_GetTick();
         __HAL_TIM_CLEAR_FLAG(&htimSecTimer, TIM_FLAG_UPDATE);
         HAL_TIM_Base_Start_IT(&htimSecTimer);
         flagTransmitCompleted = 0;
         waitAnswerFromReaderMs = 0;
-        std::string_view stringView{bridge.uart2Buf->dequeue()};
+        std::string_view stringView{bridge.uart2Buf.dequeue()};
         uint32_t size = stringView.size();
         stringView.copy(reinterpret_cast<char *>(uart2Buf), size, 0);
         HAL_UART_Transmit_IT(bridge.getHuart1(), (const uint8_t *) uart2Buf, size);
@@ -167,7 +189,55 @@ uint8_t uartTask(void) // return 0 if data received , otherwise return 1
     }
     return 1;
 }
+typedef struct currentlyZummerParam_t {
+    int32_t beepMs ;
+    uint32_t zumStartMs ;
+    int32_t zumPauseMs;
+    uint8_t beepCount;
+    uint8_t zumIsPaused ;
+};
+currentlyZummerParam_t currentlyZummerParam = {0};
+void zumHandle (void)
+{
+    if (lastZummerCommand.numOfCommand == ZUMMER_ON && currentlyZummerParam.zumStartMs == 0)
+    {
 
+        zummerOn();
+        currentlyZummerParam = {
+                lastZummerCommand.data1,
+                HAL_GetTick(),
+                lastZummerCommand.data2,
+                lastZummerCommand.data3,
+                0
+        };
+    }
+    else if (currentlyZummerParam.zumStartMs > 0 && currentlyZummerParam.zumIsPaused == 0 && currentlyZummerParam.beepCount >= 1 && currentlyZummerParam.beepMs <= (HAL_GetTick() - currentlyZummerParam.zumStartMs))
+    {
+        currentlyZummerParam.beepMs = 0;
+        if (currentlyZummerParam.beepCount >= 1)
+            {
+                currentlyZummerParam.beepCount--;
+                currentlyZummerParam.zumIsPaused = 1;
+                currentlyZummerParam.zumStartMs = HAL_GetTick();
+                currentlyZummerParam.zumPauseMs = lastZummerCommand.data2;
+                zummerOff();
+            }
+    }
+    else if (currentlyZummerParam.zumIsPaused == 1 && (HAL_GetTick() - currentlyZummerParam.zumStartMs) >= currentlyZummerParam.zumPauseMs )
+    {
+        currentlyZummerParam.zumPauseMs = 0;
+        currentlyZummerParam.beepMs = lastZummerCommand.data1;
+        currentlyZummerParam.zumIsPaused = 0;
+        currentlyZummerParam.zumStartMs = HAL_GetTick();
+        zummerOn();
+    }
+    else if (currentlyZummerParam.beepCount == 0 && currentlyZummerParam.zumIsPaused <= 0  )
+    {
+        currentlyZummerParam = {0};
+        zummerOff();
+        memset((uint8_t*)&lastZummerCommand, 0, sizeof(lastZummerCommand));
+    }
+}
 void AppTask(void) {
     if (!updateMode) {
         uartTask();
@@ -175,6 +245,9 @@ void AppTask(void) {
             lightStartMs = 0;
             lightingOff();
         }
+        zumHandle();
+        if (lastZummerCommand.numOfCommand == ZUMMER_ON)
+            return;
         if (flagTransmitCompleted == 1) {
             if (proximityCompleteMessure == 1) {
                 proximityCompleteMessure = 0;
@@ -191,6 +264,8 @@ void AppTask(void) {
         }
 
     } else {
+        if (HAL_GetTick() - bootStartMs > MAX_WAIT_FOR_BOOT_COMMAND)
+            updateMode = 0;
         BootComCheckActivationRequest();
     }
 }

CMakeLists.txt

@@ -95,7 +95,6 @@ else()
                 #//////////////////////////USER DEFINITIONS
                 MBEDTLS_CONFIG_FILE="mbedtls_config.h"
                 #/////////////////////////////////////////
-                FW_VERSION="${FW_VERSION}"
                 )
 
         set(LINK_OPTIONS "${LINK_OPTIONS}")

main_prog/CMakeLists.txt

@@ -7,7 +7,7 @@ set(CMAKE_OBJDUMP arm-none-eabi-objdump)
 set(SIZE arm-none-eabi-size)
 
 #///////////////////////////////////USER CAN SET VARIABLES HERE
-
+set (FW_VERSION 1.0)
 #///////////////////////////////////USER CAN SET VARIABLES HERE
 
 
@@ -43,7 +43,7 @@ set(INCLUDE_DIR
     set(CMAKE_CXX_STANDARD 17)
     set(CMAKE_C_STANDARD 11)
 
-
+    add_compile_definitions(FW_VERSION="${FW_VERSION}")
 
     # uncomment to mitigate c++17 absolute addresses warnings
     #set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-register")

main_prog/Core/Inc/reader_communication.h

@@ -0,0 +1,25 @@
+//
+// Created by Professional on 8/9/2023.
+//
+
+#ifndef MYPROJECT_READER_COMMUNICATION_H
+#define MYPROJECT_READER_COMMUNICATION_H
+#include "stdint-gcc.h"
+typedef enum command_enum{
+    LIGHT_ON = 0xF0,
+    LIGHT_OFF,
+    ZUMMER_ON,
+    ZUMMER_OFF,
+    ENTER_FIRMWARE_UPDATE,
+    EXIT_FIRMWARE_UPDATE,
+    GET_FIRMWARE_VERSION
+};
+
+typedef struct  command_t {
+    uint8_t numOfCommand;
+    uint16_t data1;  //data1
+    uint16_t data2; //data2
+    uint8_t data3; //data3
+} ;
+
+#endif //MYPROJECT_READER_COMMUNICATION_H

main_prog/Core/Inc/uart_bridge.hpp

@@ -6,7 +6,7 @@
 #define READER_MAIN_PROG_UART_BRIDGE_HPP
 #include "circular_buffer.hpp"
 #include "usart.h"
-
+#include "reader_communication.h"
 #define BUF_SIZE 1024U
 #define MAX_QUEUE 16
 
@@ -15,8 +15,8 @@ class UartBridge{
 public:
     UartBridge(bool isOn, USART_TypeDef *uart1, USART_TypeDef *uart2, uint16_t baudRate1,
                uint16_t baudRate2);
-    Circular_Buffer<std::string_view> *uart1Buf;
+    Circular_Buffer<std::string_view> uart1Buf;
-    Circular_Buffer<std::string_view> *uart2Buf;
+    Circular_Buffer<std::string_view> uart2Buf;
     bool isTurnOn() const;
     void setTurnOn(bool isTurnOn);
     volatile uint8_t dataFromUart1[BUF_SIZE];

main_prog/Core/Src/uart_bridge.cpp

@@ -20,14 +20,14 @@ extern "C" void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t S
         if (Size < 4)
             return;
         std::string_view stringView{(const char *) bridgePnt->dataFromUart1, Size};
-        bridgePnt->uart1Buf->enqueue(stringView);
+        bridgePnt->uart1Buf.enqueue(stringView);
     } else if (huart == bridgePnt->getHuart2()) {
         HAL_UARTEx_ReceiveToIdle_IT(bridgePnt->getHuart2(), (uint8_t *) bridgePnt->dataFromUart2, BUF_SIZE);
 
         if (Size < 4)
             return;
         std::string_view stringView{(const char *) bridgePnt->dataFromUart2, Size};
-        bridgePnt->uart2Buf->enqueue(stringView);
+        bridgePnt->uart2Buf.enqueue(stringView);
 
     }
 
@@ -36,10 +36,10 @@ extern "C" void HAL_UARTEx_RxEventCallback(UART_HandleTypeDef *huart, uint16_t S
 UartBridge::UartBridge(bool isOn, USART_TypeDef *uart1, USART_TypeDef *uart2, uint16_t baudRate1,
                        uint16_t baudRate2) : turnOn(isOn),
                                              uart1(uart1),
-                                             uart2(uart2) {
+                                             uart2(uart2),
+                                             uart1Buf(Circular_Buffer<std::string_view>(MAX_QUEUE)),
+                                             uart2Buf(Circular_Buffer<std::string_view>(MAX_QUEUE)){
     bridgePnt = this;
-    UartBridge::uart1Buf = new Circular_Buffer<std::string_view>(MAX_QUEUE);
-    UartBridge::uart2Buf = new Circular_Buffer<std::string_view>(MAX_QUEUE);
     uart1Handle.Instance = uart1;
     uart1Handle.Init.BaudRate = baudRate1;
     uart1Handle.Init.WordLength = UART_WORDLENGTH_8B;

main_prog/vl6180/App/vl6180_app.c

@@ -71,10 +71,8 @@ uint16_t range;             /* range average distance */
 #define AlarmKeepDispTime   250  /*  alarm message retain time after it fires */
 volatile int IntrFired=0;
 
-extern volatile uint32_t SensorsEnabled;
-
-
 
+uint8_t inited = 0;
 void AbortErr( const char * msg ){
     State.mode=  WaitForReset;
 }
@@ -87,12 +85,17 @@ void DoScalingSwap(int scaling){
 uint8_t allowIT = 0;
 void vl6180_init (void)
 {
+
     allowIT = 0;
     HAL_GPIO_WritePin(CS_PROXIMITY_GPIO_Port, CS_PROXIMITY_Pin, GPIO_PIN_RESET);
     HAL_Delay(200);
     HAL_GPIO_WritePin(CS_PROXIMITY_GPIO_Port, CS_PROXIMITY_Pin, GPIO_PIN_SET);
     HAL_Delay(200);
-    VL6180_WaitDeviceBooted(theVL6180Dev);
+    if (VL6180_WaitDeviceBooted(theVL6180Dev) )
+    {
+        return;
+    }
+    inited = 1;
     VL6180_InitData(theVL6180Dev);
     State.InitScale=VL6180_UpscaleGetScaling(theVL6180Dev);
     State.FilterEn=VL6180_FilterGetState(theVL6180Dev);
@@ -286,5 +289,7 @@ uint8_t vl6180_single_shot ()
 
 int32_t vl6180_is_ready ()
 {
+    if (inited < 0)
+        return -1;
      return VL6180_RangeWaitDeviceReady(theVL6180Dev, 3);
 }