Mercurial > public > ostc4

comparison Small_CPU/Src/uart.c @ 981:c6c781a2e85b default

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Merge into default
author heinrichsweikamp
date Tue, 11 Feb 2025 18:12:00 +0100
parents 0b81ac558e89
children d9290c76b840
comparison
equal deleted inserted replaced
871:f7318457df4d 981:c6c781a2e85b
20 */ 20 */
21 /* Includes ------------------------------------------------------------------*/ 21 /* Includes ------------------------------------------------------------------*/
22 #include "uart.h" 22 #include "uart.h"
23 #include "uartProtocol_O2.h" 23 #include "uartProtocol_O2.h"
24 #include "uartProtocol_Co2.h" 24 #include "uartProtocol_Co2.h"
25 #include "uartProtocol_Sentinel.h"
26 #include "uartProtocol_GNSS.h"
25 #include "externalInterface.h" 27 #include "externalInterface.h"
26 #include "data_exchange.h" 28 #include "data_exchange.h"
27 #include <string.h> /* memset */ 29 #include <string.h> /* memset */
28 30
31 #ifdef ENABLE_GPIO_V2
32 extern UART_HandleTypeDef huart6;
33 extern sUartComCtrl Uart6Ctrl;
34 #endif
35
29 /* Private variables ---------------------------------------------------------*/ 36 /* Private variables ---------------------------------------------------------*/
30 37
31 38 DMA_HandleTypeDef hdma_usart1_rx, hdma_usart1_tx;
32 39
33 #define CHUNK_SIZE (25u) /* the DMA will handle chunk size transfers */ 40 uint8_t rxBuffer[CHUNK_SIZE * CHUNKS_PER_BUFFER]; /* The complete buffer has a X * chunk size to allow variations in buffer read time */
34 #define CHUNKS_PER_BUFFER (5u) 41 uint8_t txBuffer[TX_BUF_SIZE]; /* tx uses less bytes */
35 42 uint8_t txBufferQue[TX_BUF_SIZE]; /* In MUX mode command may be send shortly after each other => allow q 1 entry que */
36 UART_HandleTypeDef huart1; 43
37 44
38 DMA_HandleTypeDef hdma_usart1_rx; 45 static uint8_t lastCmdIndex; /* Index of last command which has not been completely received */
39 46
40 uint8_t rxBuffer[CHUNK_SIZE * CHUNKS_PER_BUFFER]; /* The complete buffer has a X * chunk size to allow fariations in buffer read time */ 47 sUartComCtrl Uart1Ctrl;
41 static uint8_t rxWriteIndex; /* Index of the data item which is analysed */ 48 static sUartComCtrl* pGnssCtrl = NULL;
42 static uint8_t rxReadIndex; /* Index at which new data is stared */ 49
43 static uint8_t lastCmdIndex; /* Index of last command which has not been completly received */ 50 static uint32_t LastCmdRequestTick = 0; /* Used by ADC handler to avoid interferance with UART communication */
44 static uint8_t dmaActive; /* Indicator if DMA reception needs to be started */
45
46
47 static uint8_t SentinelConnected = 0; /* Binary indicator if a sensor is connected or not */
48
49 51
50 /* Exported functions --------------------------------------------------------*/ 52 /* Exported functions --------------------------------------------------------*/
51 53
52 54
55 void UART_SetGnssCtrl(sUartComCtrl* pTarget)
56 {
57 pGnssCtrl = pTarget;
58 }
59
60 sUartComCtrl* UART_GetGnssCtrl()
61 {
62 return pGnssCtrl;
63 }
64
65
66 void UART_clearRxBuffer(sUartComCtrl* pUartCtrl)
67 {
68 uint16_t index = 0;
69 do
70 {
71 pUartCtrl->pRxBuffer[index++] = BUFFER_NODATA_LOW;
72 pUartCtrl->pRxBuffer[index++] = BUFFER_NODATA_HIGH;
73 } while (index < sizeof(rxBuffer));
74
75 pUartCtrl->rxReadIndex = 0;
76 pUartCtrl->rxWriteIndex = 0;
77 }
78
53 void MX_USART1_UART_Init(void) 79 void MX_USART1_UART_Init(void)
54 { 80 {
55 /* regular init */ 81 /* regular init */
56
57 huart1.Instance = USART1; 82 huart1.Instance = USART1;
58 huart1.Init.BaudRate = 19200; 83 huart1.Init.BaudRate = 19200;
59 huart1.Init.WordLength = UART_WORDLENGTH_8B; 84 huart1.Init.WordLength = UART_WORDLENGTH_8B;
60 huart1.Init.StopBits = UART_STOPBITS_1; 85 huart1.Init.StopBits = UART_STOPBITS_1;
61 huart1.Init.Parity = UART_PARITY_NONE; 86 huart1.Init.Parity = UART_PARITY_NONE;
65 90
66 HAL_UART_Init(&huart1); 91 HAL_UART_Init(&huart1);
67 92
68 MX_USART1_DMA_Init(); 93 MX_USART1_DMA_Init();
69 94
70 memset(rxBuffer,BUFFER_NODATA,sizeof(rxBuffer)); 95 UART_clearRxBuffer(&Uart1Ctrl);
71 rxReadIndex = 0;
72 lastCmdIndex = 0; 96 lastCmdIndex = 0;
73 rxWriteIndex = 0; 97
74 dmaActive = 0; 98 Uart1Ctrl.pHandle = &huart1;
75 99 Uart1Ctrl.rxWriteIndex = 0;
76 SentinelConnected = 0; 100 Uart1Ctrl.rxReadIndex = 0;
77 101 Uart1Ctrl.dmaRxActive = 0;
78 } 102 Uart1Ctrl.dmaTxActive = 0;
103 Uart1Ctrl.pRxBuffer = rxBuffer;
104 Uart1Ctrl.pTxBuffer = txBuffer;
105 Uart1Ctrl.txBufferQueLen = 0;
106
107 #ifndef ENABLE_GPIO_V2
108 UART_SetGnssCtrl(&Uart1Ctrl);
109 #endif
110 }
111
112
79 113
80 void MX_USART1_UART_DeInit(void) 114 void MX_USART1_UART_DeInit(void)
81 { 115 {
82 HAL_DMA_Abort(&hdma_usart1_rx); 116 HAL_DMA_Abort(&hdma_usart1_rx);
83 HAL_DMA_DeInit(&hdma_usart1_rx); 117 HAL_DMA_DeInit(&hdma_usart1_rx);
118 HAL_DMA_Abort(&hdma_usart1_tx);
119 HAL_DMA_DeInit(&hdma_usart1_tx);
84 HAL_UART_DeInit(&huart1); 120 HAL_UART_DeInit(&huart1);
85 dmaActive = 0; 121 Uart1Ctrl.dmaRxActive = 0;
122 Uart1Ctrl.dmaTxActive = 0;
123 Uart1Ctrl.txBufferQueLen = 0;
86 } 124 }
87 125
88 void MX_USART1_DMA_Init() 126 void MX_USART1_DMA_Init()
89 { 127 {
90 /* DMA controller clock enable */ 128 /* DMA controller clock enable */
103 hdma_usart1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE; 141 hdma_usart1_rx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
104 HAL_DMA_Init(&hdma_usart1_rx); 142 HAL_DMA_Init(&hdma_usart1_rx);
105 143
106 __HAL_LINKDMA(&huart1,hdmarx,hdma_usart1_rx); 144 __HAL_LINKDMA(&huart1,hdmarx,hdma_usart1_rx);
107 145
146 hdma_usart1_tx.Instance = DMA2_Stream7;
147 hdma_usart1_tx.Init.Channel = DMA_CHANNEL_4;
148 hdma_usart1_tx.Init.Direction = DMA_MEMORY_TO_PERIPH;
149 hdma_usart1_tx.Init.PeriphInc = DMA_PINC_DISABLE;
150 hdma_usart1_tx.Init.MemInc = DMA_MINC_ENABLE;
151 hdma_usart1_tx.Init.PeriphDataAlignment = DMA_MDATAALIGN_BYTE;
152 hdma_usart1_tx.Init.MemDataAlignment = DMA_MDATAALIGN_BYTE;
153 hdma_usart1_tx.Init.Mode = DMA_NORMAL;
154 hdma_usart1_tx.Init.Priority = DMA_PRIORITY_LOW;
155 hdma_usart1_tx.Init.FIFOMode = DMA_FIFOMODE_DISABLE;
156 HAL_DMA_Init(&hdma_usart1_tx);
157
158 __HAL_LINKDMA(&huart1,hdmatx,hdma_usart1_tx);
159
160
108 /* DMA interrupt init */ 161 /* DMA interrupt init */
109 HAL_NVIC_SetPriority(DMA2_Stream5_IRQn, 0, 0); 162 HAL_NVIC_SetPriority(DMA2_Stream5_IRQn, 2, 2);
110 HAL_NVIC_EnableIRQ(DMA2_Stream5_IRQn); 163 HAL_NVIC_EnableIRQ(DMA2_Stream5_IRQn);
111 } 164 HAL_NVIC_SetPriority(DMA2_Stream7_IRQn, 2, 1);
112 165 HAL_NVIC_EnableIRQ(DMA2_Stream7_IRQn);
113 void UART_MUX_SelectAddress(uint8_t muxAddress) 166 }
167
168 void UART_MUX_SelectAddress(uint8_t muxAddress)
114 { 169 {
115 uint8_t indexstr[4]; 170 uint8_t indexstr[4];
116 171
117 if(muxAddress <= MAX_MUX_CHANNEL) 172 if(muxAddress <= MAX_MUX_CHANNEL)
118 { 173 {
119 indexstr[0] = '~'; 174 indexstr[0] = '~';
120 indexstr[1] = muxAddress; 175 indexstr[1] = muxAddress;
121 indexstr[2] = 0x0D; 176 indexstr[2] = 0x0D;
122 indexstr[3] = 0x0A; 177 indexstr[3] = 0x0A;
123 178 if(!Uart1Ctrl.dmaTxActive)
124 HAL_UART_Transmit(&huart1,indexstr,4,10); 179 {
180 memcpy(txBuffer, indexstr, 4);
181 Uart1Ctrl.dmaTxActive = 0;
182 if(HAL_OK == HAL_UART_Transmit_DMA(&huart1,txBuffer,4))
183 {
184 Uart1Ctrl.dmaTxActive = 1;
185 while(Uart1Ctrl.dmaTxActive)
186 {
187 HAL_Delay(1);
188 }
189 }
190 }
191 else
192 {
193 memcpy(txBufferQue, indexstr, 4);
194 Uart1Ctrl.txBufferQueLen = 4;
195 }
125 } 196 }
126 } 197 }
127 198
128 199
129 void UART_SendCmdString(uint8_t *cmdString) 200 void UART_SendCmdString(uint8_t *cmdString)
130 { 201 {
131 uint8_t cmdLength = strlen((char*)cmdString); 202 uint8_t cmdLength = strlen((char*)cmdString);
132 203
133 if(cmdLength < 20) /* A longer string is an indication for a missing 0 termination */ 204 if(Uart1Ctrl.dmaTxActive == 0)
134 { 205 {
135 if(dmaActive == 0) 206 if(cmdLength < TX_BUF_SIZE) /* A longer string is an indication for a missing 0 termination */
136 { 207 {
137 UART_StartDMA_Receiption(); 208 if(Uart1Ctrl.dmaRxActive == 0)
138 } 209 {
139 HAL_UART_Transmit(&huart1,cmdString,cmdLength,10); 210 UART_StartDMA_Receiption(&Uart1Ctrl);
211 }
212 memcpy(txBuffer, cmdString, cmdLength);
213 if(HAL_OK == HAL_UART_Transmit_DMA(&huart1,txBuffer,cmdLength))
214 {
215 Uart1Ctrl.dmaTxActive = 1;
216 LastCmdRequestTick = HAL_GetTick();
217 }
218 }
219 }
220 else
221 {
222 memcpy(txBufferQue, cmdString, cmdLength);
223 Uart1Ctrl.txBufferQueLen = cmdLength;
224 }
225 }
226
227 void UART_AddFletcher(uint8_t* pBuffer, uint8_t length)
228 {
229 uint8_t ck_A = 0;
230 uint8_t ck_B = 0;
231 uint8_t index = 0;
232
233
234 pBuffer += 2; /* skip sync chars */
235 for(index = 2; index < length; index++)
236 {
237 ck_A += *pBuffer++;
238 ck_B += ck_A;
239 }
240 *pBuffer++ = ck_A;
241 *pBuffer++ = ck_B;
242 }
243
244 void UART_SendCmdUbx(const uint8_t *cmd, uint8_t len)
245 {
246 if(len < TX_BUF_SIZE) /* A longer string is an indication for a missing 0 termination */
247 {
248 if(pGnssCtrl != NULL)
249 {
250 if(pGnssCtrl->dmaRxActive == 0)
251 {
252 UART_StartDMA_Receiption(pGnssCtrl);
253 }
254 memcpy(pGnssCtrl->pTxBuffer, cmd, len);
255 UART_AddFletcher(pGnssCtrl->pTxBuffer, len);
256 len += 2;
257 if(HAL_OK == HAL_UART_Transmit_DMA(pGnssCtrl->pHandle,pGnssCtrl->pTxBuffer,len))
258 {
259 pGnssCtrl->dmaTxActive = 1;
260 LastCmdRequestTick = HAL_GetTick();
261 }
262 }
140 } 263 }
141 } 264 }
142 265
143 266
144 void StringToInt(char *pstr, uint32_t *puInt32) 267 void StringToInt(char *pstr, uint32_t *puInt32)
164 result += pstr[index] - '0'; 287 result += pstr[index] - '0';
165 index++; 288 index++;
166 } 289 }
167 *puint64 = result; 290 *puint64 = result;
168 } 291 }
169 void ConvertByteToHexString(uint8_t byte, char* str) 292
170 { 293 void UART_StartDMA_Receiption(sUartComCtrl* pUartCtrl)
171 uint8_t worker = 0; 294 {
172 uint8_t digit = 0; 295 if(pUartCtrl->dmaRxActive == 0)
173 uint8_t digitCnt = 1; 296 {
174 297 if(((pUartCtrl->rxWriteIndex / CHUNK_SIZE) != (pUartCtrl->rxReadIndex / CHUNK_SIZE)) || ((UART_isEndIndication(pUartCtrl, pUartCtrl->rxWriteIndex)) && (UART_isEndIndication(pUartCtrl, pUartCtrl->rxWriteIndex + 1)))) /* start next transfer if we did not catch up with read index */
175 worker = byte; 298 {
176 while((worker!=0) && (digitCnt != 255)) 299 if(HAL_OK == HAL_UART_Receive_DMA (pUartCtrl->pHandle, &pUartCtrl->pRxBuffer[pUartCtrl->rxWriteIndex], CHUNK_SIZE))
177 { 300 {
178 digit = worker % 16; 301 pUartCtrl->dmaRxActive = 1;
179 if( digit < 10) 302 }
180 { 303 }
181 digit += '0';
182 }
183 else
184 {
185 digit += 'A' - 10;
186 }
187 str[digitCnt--]= digit;
188 worker = worker / 16;
189 }
190 }
191
192 void UART_StartDMA_Receiption()
193 {
194 if(dmaActive == 0)
195 {
196 if(HAL_OK == HAL_UART_Receive_DMA (&huart1, &rxBuffer[rxWriteIndex], CHUNK_SIZE))
197 {
198 dmaActive = 1;
199 }
200 } 304 }
201 } 305 }
202 306
203 void UART_ChangeBaudrate(uint32_t newBaudrate) 307 void UART_ChangeBaudrate(uint32_t newBaudrate)
204 { 308 {
205 uint8_t dmaWasActive = dmaActive; 309 MX_USART1_UART_DeInit();
206 // HAL_DMA_Abort(&hdma_usart1_rx);
207 MX_USART1_UART_DeInit();
208 //HAL_UART_Abort(&huart1);
209 //HAL_DMA_DeInit(&hdma_usart1_rx);
210
211
212 // huart1.Instance->BRR = UART_BRR_SAMPLING8(HAL_RCC_GetPCLK2Freq()/2, newBaudrate);
213 huart1.Init.BaudRate = newBaudrate; 310 huart1.Init.BaudRate = newBaudrate;
214 HAL_UART_Init(&huart1); 311 HAL_UART_Init(&huart1);
215 MX_USART1_DMA_Init(); 312 MX_USART1_DMA_Init();
216 if(dmaWasActive) 313 HAL_NVIC_SetPriority(USART1_IRQn, 1, 3);
217 { 314 HAL_NVIC_EnableIRQ(USART1_IRQn);
218 memset(rxBuffer,BUFFER_NODATA,sizeof(rxBuffer)); 315
219 rxReadIndex = 0; 316 UART_clearRxBuffer(&Uart1Ctrl);
220 rxWriteIndex = 0; 317 Uart1Ctrl.rxReadIndex = 0;
221 dmaActive = 0; 318 Uart1Ctrl.rxWriteIndex = 0;
222 UART_StartDMA_Receiption(); 319 Uart1Ctrl.dmaRxActive = 0;
223 } 320 Uart1Ctrl.dmaTxActive = 0;
224 } 321 Uart1Ctrl.txBufferQueLen = 0;
225 322 }
226 #ifdef ENABLE_SENTINEL_MODE 323
227 void UART_HandleSentinelData(void) 324 void UART_HandleRxComplete(sUartComCtrl* pUartCtrl)
228 { 325 {
229 uint8_t localRX = rxReadIndex; 326 pUartCtrl->dmaRxActive = 0;
230 static uint8_t dataType = 0; 327 pUartCtrl->rxWriteIndex+=CHUNK_SIZE;
231 static uint32_t dataValue[3]; 328 if(pUartCtrl->rxWriteIndex >= CHUNK_SIZE * CHUNKS_PER_BUFFER)
232 static uint8_t dataValueIdx = 0; 329 {
233 static receiveState_t rxState = RX_Ready; 330 pUartCtrl->rxWriteIndex = 0;
234 static uint32_t lastReceiveTick = 0; 331 }
235 static uint8_t lastAlive = 0; 332 UART_StartDMA_Receiption(pUartCtrl);
236 static uint8_t curAlive = 0; 333 }
237 static uint8_t checksum = 0; 334 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
238 static char checksum_str[]="00"; 335 {
239 336 if(huart == &huart1)
240 while((rxBuffer[localRX]!=0)) 337 {
241 { 338 UART_HandleRxComplete(&Uart1Ctrl);
242 lastReceiveTick = HAL_GetTick(); 339 }
243 340 #ifdef ENABLE_GPIO_V2
244 switch(rxState) 341 if(huart == &huart6)
245 { 342 {
246 case RX_Ready: if((rxBuffer[localRX] >= 'a') && (rxBuffer[localRX] <= 'z')) 343 UART_HandleRxComplete(&Uart6Ctrl);
247 { 344 }
248 rxState = RX_DetectStart; 345 #endif
249 curAlive = rxBuffer[localRX]; 346 }
250 checksum = 0; 347
251 } 348 void UART_HandleTxComplete(sUartComCtrl* pUartCtrl)
349 {
350 pUartCtrl->dmaTxActive = 0;
351 UART_WriteData(pUartCtrl);
352 if(pUartCtrl->txBufferQueLen)
353 {
354 memcpy(pUartCtrl->pTxBuffer, pUartCtrl->pTxQue, pUartCtrl->txBufferQueLen);
355 HAL_UART_Transmit_DMA(pUartCtrl->pHandle,pUartCtrl->pTxBuffer,pUartCtrl->txBufferQueLen);
356 pUartCtrl->dmaTxActive = 1;
357 pUartCtrl->txBufferQueLen = 0;
358 }
359 }
360 void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
361 {
362 if(huart == &huart1)
363 {
364 UART_HandleTxComplete(&Uart1Ctrl);
365 }
366 #ifdef ENABLE_GPIO_V2
367 if(huart == &huart6)
368 {
369 UART_HandleTxComplete(&Uart6Ctrl);
370 }
371 #endif
372 }
373
374 uint8_t UART_isEndIndication(sUartComCtrl* pCtrl, uint8_t index)
375 {
376 uint8_t ret = 0;
377 if(index % 2)
378 {
379 if(pCtrl->pRxBuffer[index] == BUFFER_NODATA_HIGH)
380 {
381 ret = 1;
382 }
383 }
384 else
385 {
386 if(pCtrl->pRxBuffer[index] == BUFFER_NODATA_LOW)
387 {
388 ret = 1;
389 }
390 }
391
392 return ret;
393 }
394 void UART_ReadData(uint8_t sensorType, uint8_t flush) /* flush = 1 skips processing of data => data is discarded */
395 {
396 uint8_t localRX;
397 uint8_t futureIndex;
398 uint8_t moreData = 0;
399
400 sUartComCtrl* pUartCtrl;
401
402 if(sensorType == SENSOR_GNSS)
403 {
404 #ifdef ENABLE_GPIO_V2
405 pUartCtrl = &Uart6Ctrl;
406 #else
407 pUartCtrl = &Uart1Ctrl;
408 #endif
409 }
410 else
411 {
412 pUartCtrl = &Uart1Ctrl;
413 }
414 localRX = pUartCtrl->rxReadIndex;
415 futureIndex = pUartCtrl->rxReadIndex + 1;
416 if(futureIndex >= CHUNK_SIZE * CHUNKS_PER_BUFFER)
417 {
418 futureIndex = 0;
419 }
420
421 if(!UART_isEndIndication(pUartCtrl, futureIndex))
422 {
423 moreData = 1;
424 }
425
426 if((!UART_isEndIndication(pUartCtrl, localRX)) || (moreData))
427 do
428 {
429 while((!UART_isEndIndication(pUartCtrl, localRX)) || (moreData))
430 {
431 moreData = 0;
432 switch (sensorType)
433 {
434 case SENSOR_MUX:
435 case SENSOR_DIGO2: uartO2_ProcessData(pUartCtrl->pRxBuffer[localRX]);
252 break; 436 break;
253 437 #ifdef ENABLE_CO2_SUPPORT
254 case RX_DetectStart: checksum += rxBuffer[localRX]; 438 case SENSOR_CO2: uartCo2_ProcessData(pUartCtrl->pRxBuffer[localRX]);
255 if(rxBuffer[localRX] == '1')
256 {
257 rxState = RX_SelectData;
258 dataType = 0xFF;
259
260 }
261 else
262 {
263 rxState = RX_Ready;
264 }
265 break; 439 break;
266 440 #endif
267 case RX_SelectData: checksum += rxBuffer[localRX]; 441 #if defined ENABLE_GNSS_SUPPORT || defined ENABLE_GPIO_V2
268 switch(rxBuffer[localRX]) 442 case SENSOR_GNSS: uartGnss_ProcessData(pUartCtrl->pRxBuffer[localRX]);
269 { 443 break;
270 case 'T': dataType = rxBuffer[localRX]; 444 #endif
271 break; 445 #ifdef ENABLE_SENTINEL_MODE
272 case '0': if(dataType != 0xff) 446 case SENSOR_SENTINEL: uartSentinel_ProcessData(pUartCtrl->pRxBuffer[localRX]);
273 {
274 rxState = RX_Data0;
275 dataValueIdx = 0;
276 dataValue[0] = 0;
277
278 }
279 else
280 {
281 rxState = RX_Ready;
282 }
283 break;
284 default: rxState = RX_Ready;
285 }
286 break; 447 break;
287 448 #endif
288 case RX_Data0: 449 default:
289 case RX_Data1:
290 case RX_Data2:
291 case RX_Data4:
292 case RX_Data5:
293 case RX_Data6:
294 case RX_Data8:
295 case RX_Data9:
296 case RX_Data10: checksum += rxBuffer[localRX];
297 if((rxBuffer[localRX] >= '0') && (rxBuffer[localRX] <= '9'))
298 {
299 dataValue[dataValueIdx] = dataValue[dataValueIdx] * 10 + (rxBuffer[localRX] - '0');
300 rxState++;
301 }
302 else
303 {
304 rxState = RX_Ready;
305 }
306 break; 450 break;
307 451 }
308 case RX_Data3: 452 if(localRX % 2)
309 case RX_Data7: checksum += rxBuffer[localRX]; 453 {
310 if(rxBuffer[localRX] == '0') 454 pUartCtrl->pRxBuffer[localRX] = BUFFER_NODATA_HIGH;
311 { 455 }
312 rxState++; 456 else
313 dataValueIdx++; 457 {
314 dataValue[dataValueIdx] = 0; 458 pUartCtrl->pRxBuffer[localRX] = BUFFER_NODATA_LOW;
315 } 459 }
316 else 460
317 { 461 localRX++;
318 rxState = RX_Ready; 462 pUartCtrl->rxReadIndex++;
319 } 463 if(pUartCtrl->rxReadIndex >= CHUNK_SIZE * CHUNKS_PER_BUFFER)
320 break; 464 {
321 case RX_Data11: rxState = RX_DataComplete; 465 localRX = 0;
322 ConvertByteToHexString(checksum,checksum_str); 466 pUartCtrl->rxReadIndex = 0;
323 if(rxBuffer[localRX] == checksum_str[0]) 467 }
324 { 468 futureIndex++;
325 rxState = RX_DataComplete; 469 if(futureIndex >= CHUNK_SIZE * CHUNKS_PER_BUFFER)
326 } 470 {
327 else 471 futureIndex = 0;
328 { 472 }
329 rxState = RX_Ready; 473 }
330 } 474 if(!UART_isEndIndication(pUartCtrl, futureIndex))
331 475 {
332 break; 476 moreData = 1;
333 477 }
334 case RX_DataComplete: if(rxBuffer[localRX] == checksum_str[1]) 478 } while(moreData);
335 { 479 }
336 setExternalInterfaceChannel(0,(float)(dataValue[0] / 10.0)); 480
337 setExternalInterfaceChannel(1,(float)(dataValue[1] / 10.0)); 481 void UART_WriteData(sUartComCtrl* pUartCtrl)
338 setExternalInterfaceChannel(2,(float)(dataValue[2] / 10.0)); 482 {
339 SentinelConnected = 1; 483 if(pUartCtrl->pHandle->hdmatx->State == HAL_DMA_STATE_READY)
340 } 484 {
341 rxState = RX_Ready; 485 pUartCtrl->pHandle->gState = HAL_UART_STATE_READY;
342 break; 486 pUartCtrl->dmaTxActive = 0;
343 487 }
344 488 if(pUartCtrl->pHandle->hdmarx->State == HAL_DMA_STATE_READY)
345 default: rxState = RX_Ready; 489 {
346 break; 490 pUartCtrl->pHandle->RxState = HAL_UART_STATE_READY;
347 491 pUartCtrl->dmaRxActive = 0;
348 } 492 }
349 localRX++; 493 }
350 rxReadIndex++; 494
351 if(rxReadIndex >= CHUNK_SIZE * CHUNKS_PER_BUFFER) 495 uint8_t UART_isComActive(uint8_t sensorId)
352 { 496 {
353 localRX = 0; 497 uint8_t active = 1;
354 rxReadIndex = 0; 498
355 } 499 if(time_elapsed_ms(LastCmdRequestTick, HAL_GetTick()) > 300) /* UART activity should be inactive 300ms after last command */
356 } 500 {
357 501 active = 0;
358 if(time_elapsed_ms(lastReceiveTick,HAL_GetTick()) > 4000) /* check for communication timeout */ 502 }
359 { 503 return active;
360 if(curAlive == lastAlive) 504 }
361 {
362 setExternalInterfaceChannel(0,0.0);
363 setExternalInterfaceChannel(1,0.0);
364 setExternalInterfaceChannel(2,0.0);
365 SentinelConnected = 0;
366 }
367 lastAlive = curAlive;
368 }
369
370 if((dmaActive == 0) && (externalInterface_isEnabledPower33())) /* Should never happen in normal operation => restart in case of communication error */
371 {
372 UART_StartDMA_Receiption();
373 }
374 }
375 #endif
376
377
378
379 uint8_t UART_isSentinelConnected()
380 {
381 return SentinelConnected;
382 }
383
384 void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
385 {
386 if(huart == &huart1)
387 {
388 dmaActive = 0;
389 rxWriteIndex+=CHUNK_SIZE;
390 if(rxWriteIndex >= CHUNK_SIZE * CHUNKS_PER_BUFFER)
391 {
392 rxWriteIndex = 0;
393 }
394 if((rxWriteIndex / CHUNK_SIZE) != (rxReadIndex / CHUNK_SIZE) || (rxWriteIndex == rxReadIndex)) /* start next transfer if we did not catch up with read index */
395 {
396 UART_StartDMA_Receiption();
397 }
398 }
399 }
400
401 void UART_ReadData(uint8_t sensorType)
402 {
403 uint8_t localRX = rxReadIndex;
404
405 while((rxBuffer[localRX]!=BUFFER_NODATA))
406 {
407 switch (sensorType)
408 {
409 case SENSOR_MUX:
410 case SENSOR_DIGO2: uartO2_ProcessData(rxBuffer[localRX]);
411 break;
412 #ifdef ENABLE_CO2_SUPPORT
413 case SENSOR_CO2: uartCo2_ProcessData(rxBuffer[localRX]);
414 break;
415 #endif
416 default:
417 break;
418 }
419
420 rxBuffer[localRX] = BUFFER_NODATA;
421 localRX++;
422 rxReadIndex++;
423 if(rxReadIndex >= CHUNK_SIZE * CHUNKS_PER_BUFFER)
424 {
425 localRX = 0;
426 rxReadIndex = 0;
427 }
428 }
429 }
430
431 void UART_FlushRxBuffer(void)
432 {
433 while(rxBuffer[rxReadIndex] != BUFFER_NODATA)
434 {
435 rxBuffer[rxReadIndex] = BUFFER_NODATA;
436 rxReadIndex++;
437 if(rxReadIndex >= CHUNK_SIZE * CHUNKS_PER_BUFFER)
438 {
439 rxReadIndex = 0;
440 }
441 }
442 }
443
444 505
445 506
446 /************************ (C) COPYRIGHT heinrichs weikamp *****END OF FILE****/ 507 /************************ (C) COPYRIGHT heinrichs weikamp *****END OF FILE****/