Mocks have been updated

OZE_Main/Core/Inc/serial_protocol.h

@@ -53,11 +53,11 @@ typedef enum _SerialProtocolRespStatus SerialProtocolRespStatus;
 #define GET_WORD_THIRD_BYTE(cmd) ((uint8_t)((cmd >> 16) & 0xFF))
 #define GET_WORD_FOURTH_BYTE(cmd) ((uint8_t)((cmd >> 24) & 0xFF))
 
-#define CONVERT_BYTES_TO_SHORT_WORD(buffer) \
-    ((uint16_t)((*(buffer + 1) << 8) | *buffer))
-#define CONVERT_BYTES_TO_WORD(buffer) ((uint32_t)((*(buffer + 3) << 24) | *(buffer + 2) << 16) | *(buffer + 1) << 8) | *buffer))
+#define CONVERT_BYTES_TO_SHORT_WORD(buffer) ((uint16_t)((*(buffer + 1) << 8) | *buffer))
+#define CONVERT_BYTES_TO_WORD(buffer) ((uint32_t)((*(buffer + 3) << 24) | (*(buffer + 2) << 16) | (*(buffer + 1) << 8) | *buffer))
 
 void WriteDataToBuffer (uint8_t* buff, uint16_t* buffPos, void* data, uint8_t dataSize);
+void ReadFloatFromBuffer(uint8_t* buff, uint16_t* buffPos, float* data);
 uint16_t PrepareReqFrame (uint8_t* txBuffer, uint16_t frameId, SerialProtocolCommands frameCommand, uint8_t* dataBuffer,uint16_t dataLength);
 uint16_t PrepareRespFrame (uint8_t* txBuffer, uint16_t frameId, SerialProtocolCommands frameCommand, SerialProtocolRespStatus respStatus, uint8_t* dataBuffer, uint16_t dataLength);
 

OZE_Main/Core/Inc/uart_tasks.h

@@ -71,5 +71,8 @@ void UartRxTask (void* argument);
 void UartTxTask (void* argument);
 void HandleUartRxCallback (UartTaskData* uartTaskData, UART_HandleTypeDef* huart, uint16_t Size);
 
+void MeasurmentsReqSchedulerTaskkInit(void);
+void MeasurmentsReqSchedulerTask(void* argument);
+
 
 #endif /* INC_UART_TASKS_H_ */

OZE_Main/Core/Src/main.c

@@ -162,7 +162,11 @@ int main(void)
   /* add threads, ... */
   mqtt_cli_init();
   Uart8TasksInit();
+#ifdef USER_MOCKS
   MockMeasurmetsTaskInit();
+#else
+  XXXTaskInit();
+#endif
   /* USER CODE END RTOS_THREADS */
 
   /* USER CODE BEGIN RTOS_EVENTS */

OZE_Main/Core/Src/mock_tasks.c

@@ -37,11 +37,12 @@ float rndflt (float rng)
 
 void MockMeasurmetsTaskInit(void) {
 	osThreadAttr_t osThreadAttrMockMeasTask = { 0 };
-	osThreadId_t osThreadMockMeasurmetsTaskId;
+//	osThreadId_t osThreadMockMeasurmetsTaskId;
 	osThreadAttrMockMeasTask.name       = "os_thread_mock_measurmets";
 	osThreadAttrMockMeasTask.stack_size = configMINIMAL_STACK_SIZE * 2;
 	osThreadAttrMockMeasTask.priority   = (osPriority_t)osPriorityNormal;
-	osThreadMockMeasurmetsTaskId = osThreadNew (MockMeasurmetsTask, NULL, &osThreadAttrMockMeasTask);
+//	osThreadMockMeasurmetsTaskId = osThreadNew (MockMeasurmetsTask, NULL, &osThreadAttrMockMeasTask);
+	osThreadNew (MockMeasurmetsTask, NULL, &osThreadAttrMockMeasTask);
 
 }
 
@@ -68,6 +69,22 @@ void MockMeasurmetsTask (void* argument) {
 			resMeas->power[0] = resMeas->voltagePeak[0] * resMeas->currentRMS[0];
 			resMeas->power[1] = resMeas->voltagePeak[1] * resMeas->currentRMS[1];
 			resMeas->power[2] = resMeas->voltagePeak[2] * resMeas->currentRMS[2];
+
+			SesnorsInfo* sensors = &sensorsInfo[boardNumber];
+			sensors->pvTemperature[0] = 50 + (0.01 * (counter % 100));
+			sensors->pvTemperature[1] = 51 + (0.01 * (counter % 100));
+			sensors->fanVoltage = 12 + (0.01 * (counter % 100));
+			sensors->pvEncoder = 15 + (0.01 * (counter % 100));
+			sensors->motorXStatus = (counter % 100) > 50 ? 1 : 0;
+			sensors->motorYStatus = (counter % 100) > 75 ? 1 : 0;
+			sensors->motorXAveCurrent = 3 + (0.01 * (counter % 100));
+			sensors->motorYAveCurrent = 3 + (0.01 * (counter % 100));
+			sensors->motorXPeakCurrent = 6 + (0.01 * (counter % 100));
+			sensors->motorYPeakCurrent = 6 + (0.01 * (counter % 100));
+			sensors->limitSwitchUp = (counter % 100) > 50 ? 1 : 0;
+			sensors->limitSwitchDown = (counter % 100) < 25 ? 1 : 0;
+			sensors->limitSwitchCenter = (counter % 100) > 35 ? 1 : 0;
+			sensors->powerSupplyFailMask = 0;
 		}
     	osMutexRelease(resMeasurementsMutex);
     	osMutexAcquire (sensorsInfoMutex, osWaitForever);
@@ -76,3 +93,4 @@ void MockMeasurmetsTask (void* argument) {
         osDelay (pdMS_TO_TICKS (1000));
     }
 }
+

OZE_Main/Core/Src/mqtt_client.c

@@ -137,7 +137,7 @@ void MqttClientPubTask (void* argument) {
                     osMutexAcquire (sensorsInfoMutex, osWaitForever);
                     SesnorsInfo* sensors = &sensorsInfo[boardNumber];
                     sprintf (topicTextBuffer, "Sensors/%d", boardNumber + 1);
-                    bytesInBuffer = sprintf (messageBuffer, "\"{pvTemperature\":[%.1f, %.1f], ", sensors->pvTemperature[0], sensors->pvTemperature[1]);
+                    bytesInBuffer = sprintf (messageBuffer, "{\"pvTemperature\":[%.1f, %.1f], ", sensors->pvTemperature[0], sensors->pvTemperature[1]);
                     bytesInBuffer += sprintf (&messageBuffer[bytesInBuffer], "\"fanVoltage\":%.2f, ", sensors->fanVoltage);
                     bytesInBuffer += sprintf (&messageBuffer[bytesInBuffer], "\"pvEncoder\":%.2f, ", sensors->pvEncoder);
                     bytesInBuffer += sprintf (&messageBuffer[bytesInBuffer], "\"motorXStatus\":%d, ", sensors->motorXStatus);

OZE_Main/Core/Src/serial_protocol.c

@@ -52,6 +52,13 @@ void WriteDataToBuffer (uint8_t* buff, uint16_t* buffPos, void* data, uint8_t da
     *buffPos = newBuffPos;
 }
 
+void ReadFloatFromBuffer(uint8_t* buff, uint16_t* buffPos, float* data)
+{
+	uint32_t* word =  (uint32_t *)data;
+	*word = CONVERT_BYTES_TO_WORD(&buff[*buffPos]);
+	*buffPos += sizeof(float);
+}
+
 uint16_t PrepareReqFrame (uint8_t* txBuffer, uint16_t frameId, SerialProtocolCommands frameCommand, uint8_t* dataBuffer, uint16_t dataLength) {
     uint16_t crc         = 0;
     uint16_t txBufferPos = 0;

OZE_Main/Core/Src/uart_tasks.c

@@ -34,12 +34,16 @@ uint8_t uart8RxBuffer[UART8_RX_BUFF_SIZE]        = { 0 };
 uint8_t uart8TxBuffer[UART8_TX_BUFF_SIZE]        = { 0 };
 uint8_t uart8TaskFrameData[INPUT_DATA_BUFF_SIZE] = { 0 };
 
+uint8_t boardToUartNumberMap[SLAVES_COUNT] = { /*1*/ 8, 3, 6, 2 };
+
 UartTaskData uart1TaskData = { 0 }; // Board 1
 UartTaskData uart3TaskData = { 0 }; // Board 2
 UartTaskData uart6TaskData = { 0 }; // Board 3
 UartTaskData uart2TaskData = { 0 }; // Board 4
 UartTaskData uart8TaskData = { 0 }; // Debug
 
+UartTaskData* uartTasks[] = { &uart8TaskData, NULL };
+
 uint8_t outputDataBuffer[OUTPUT_DATA_BUFF_SIZE];
 uint16_t outputDataBufferPos = 0;
 
@@ -311,6 +315,14 @@ void Uart8ReceivedDataProcessCallback (void* arg, SerialProtocolFrameData* spFra
 #endif
 }
 
+void ReadMeasSetFromBuffer(uint8_t* buff, uint16_t* buffPos, float* dataSet)
+{
+	for(uint8_t i = 0; i < 3; i++)
+	{
+		ReadFloatFromBuffer(buff, buffPos, &dataSet[i]);
+	}
+}
+
 void UartTxTask (void* argument) {
     UartTaskData* const uartTaskData  = (UartTaskData*)argument;
     InterProcessData data             = { 0 };
@@ -320,54 +332,99 @@ void UartTxTask (void* argument) {
     uint32_t rndVal                     = 0;
     uint16_t bytesToSend                = 0;
     SerialProtocolCommands frameCommand = spUnknown;
+    uint16_t inputDataBufferPos = 0;
 
     while (pdTRUE) {
         if (uartTaskData->sendCmdToSlaveQueue != NULL) {
             osMessageQueueGet (uartTaskData->sendCmdToSlaveQueue, &data, 0, osWaitForever);
             HAL_RNG_GenerateRandomNumber (&hrng, &rndVal);
-            frameId      = (uint16_t)(rndVal & 0xFFFF);
-            frameCommand = data.spCommand;
+            frameId             = (uint16_t)(rndVal & 0xFFFF);
+            frameCommand        = data.spCommand;
             outputDataBufferPos = 0;
-            memset(outputDataBuffer, 0x00, OUTPUT_DATA_BUFF_SIZE);
-            switch(frameCommand)
-            {
+            memset (outputDataBuffer, 0x00, OUTPUT_DATA_BUFF_SIZE);
+            switch (frameCommand) {
             case spSetFanSpeed:
             case spSetMotorXOn:
             case spSetMotorYOn:
-            	WriteDataToBuffer (outputDataBuffer, &outputDataBufferPos, &data.values.integerValues.value[0], sizeof (float));
-            	WriteDataToBuffer (outputDataBuffer, &outputDataBufferPos, &data.values.integerValues.value[1], sizeof (float));
-            	break;
-            case spSetDiodeOn:
-            	WriteDataToBuffer (outputDataBuffer, &outputDataBufferPos, &data.values.integerValues.value[0], sizeof (float));
-            	break;
+                WriteDataToBuffer (outputDataBuffer, &outputDataBufferPos, &data.values.integerValues.value[0], sizeof (float));
+                WriteDataToBuffer (outputDataBuffer, &outputDataBufferPos, &data.values.integerValues.value[1], sizeof (float));
+                break;
+            case spSetDiodeOn: WriteDataToBuffer (outputDataBuffer, &outputDataBufferPos, &data.values.integerValues.value[0], sizeof (float)); break;
             case spSetmotorXMaxCurrent:
-            case spSetmotorYMaxCurrent:
-            	WriteDataToBuffer (outputDataBuffer, &outputDataBufferPos, &data.values.flaotValues.value[0], sizeof (float));
-            	break;
+            case spSetmotorYMaxCurrent: WriteDataToBuffer (outputDataBuffer, &outputDataBufferPos, &data.values.flaotValues.value[0], sizeof (float)); break;
             case spGetElectricalMeasurments:
-            case spGetSensorMeasurments:
-            	break;
-            default:
-            	continue;
-            	break;
+            case spGetSensorMeasurments: break;
+            default: continue; break;
             }
 
-			bytesToSend  = PrepareReqFrame (uart8TxBuffer, frameId, frameCommand, outputDataBuffer, outputDataBufferPos);
-			HAL_UART_Transmit_IT (uartTaskData->huart, uart8TxBuffer, bytesToSend);
-			bytesInMsg = xMessageBufferReceive (uartTaskData->processRxDataMsgBuffer, &frameData, INPUT_DATA_BUFF_SIZE, pdMS_TO_TICKS (1000));
-			if(bytesInMsg == 0)
-			{
-				printf("Response timeout for frameId 0x%x\n", frameId);
-			}
-			else
-			{
-				if ( (frameId == frameData.frameHeader.frameId) && (frameData.frameHeader.respStatus == spOK))
-				{
-					printf("Response for frameId 0x%x OK\n", frameId);
-				}
-			}
+            bytesToSend = PrepareReqFrame (uart8TxBuffer, frameId, frameCommand, outputDataBuffer, outputDataBufferPos);
+            HAL_UART_Transmit_IT (uartTaskData->huart, uart8TxBuffer, bytesToSend);
+            bytesInMsg = xMessageBufferReceive (uartTaskData->processRxDataMsgBuffer, &frameData, INPUT_DATA_BUFF_SIZE, pdMS_TO_TICKS (1000));
+            if (bytesInMsg == 0) {
+#if UART_TASK_LOGS
+                printf ("Uart%d: Response timeout for frameId 0x%x\n", uartTaskData->uartNumber, frameId);
+#endif
+            } else {
+                if ((frameId == frameData.frameHeader.frameId) && (frameData.frameHeader.respStatus == spOK)) {
+#if UART_TASK_LOGS
+                    printf ("Uart%d: Response for frameId 0x%x OK\n", uartTaskData->uartNumber, frameId);
+#endif
+                    switch(frameData.frameHeader.frameCommand)
+                    {
+                    case spGetElectricalMeasurments:
+                    	uint8_t boardNumber;
+                    	osMutexAcquire (resMeasurementsMutex, osWaitForever);
+                    	for(boardNumber = 0; boardNumber < SLAVES_COUNT; boardNumber++)
+                    	{
+                    		if(boardToUartNumberMap[boardNumber] == uartTaskData->uartNumber)
+                    		{
+                    			break;
+                    		}
+                    	}
+            			RESMeasurements *resMeas = &resMeasurements[boardNumber];
+                    	inputDataBufferPos = 0;
+                    	ReadMeasSetFromBuffer(frameData.dataBuffer, &inputDataBufferPos, resMeas->voltageRMS);
+                    	ReadMeasSetFromBuffer(frameData.dataBuffer, &inputDataBufferPos, resMeas->voltagePeak);
+                    	ReadMeasSetFromBuffer(frameData.dataBuffer, &inputDataBufferPos, resMeas->currentRMS);
+                    	ReadMeasSetFromBuffer(frameData.dataBuffer, &inputDataBufferPos, resMeas->currentPeak);
+                    	ReadMeasSetFromBuffer(frameData.dataBuffer, &inputDataBufferPos, resMeas->power);
+                    	osMutexRelease(resMeasurementsMutex);
+                    	break;
+                    default:
+                    	break;
+                    }
+                }
+            }
         } else {
             osDelay (pdMS_TO_TICKS (1000));
         }
     }
 }
+
+void MeasurmentsReqSchedulerTaskTaskInit (void) {
+    osThreadAttr_t osThreadAttrMeasurmentsReqSchedulerTask = { 0 };
+
+    osThreadAttrMeasurmentsReqSchedulerTask.name       = "os_thread_XXX";
+    osThreadAttrMeasurmentsReqSchedulerTask.stack_size = configMINIMAL_STACK_SIZE * 2;
+    osThreadAttrMeasurmentsReqSchedulerTask.priority   = (osPriority_t)osPriorityNormal;
+
+    osThreadNew (MeasurmentsReqSchedulerTask, uartTasks, &osThreadAttrMeasurmentsReqSchedulerTask);
+}
+
+void MeasurmentsReqSchedulerTask (void* argument) {
+    while (pdTRUE) {
+        __uintptr_t* ptr = (__uintptr_t*)argument;
+        while (*ptr != 0) {
+            UartTaskData* uartTask = (UartTaskData*)*ptr;
+            if (uartTask->sendCmdToSlaveQueue != NULL) {
+                InterProcessData data = { 0 };
+                data.spCommand        = spGetElectricalMeasurments;
+                osMessageQueuePut (uartTask->sendCmdToSlaveQueue, &data, 0, (TickType_t)100);
+                //				data.spCommand = spGetSensorMeasurments;
+                //				osMessageQueuePut (uartTask->sendCmdToSlaveQueue, &data, 0, (TickType_t)100);
+            }
+            ptr++;
+        }
+        osDelay (pdMS_TO_TICKS (1000));
+    }
+}