Mercurial > public > ostc4

comparison Small_CPU/Src/uartProtocol_Co2.c @ 1072:8b97003dbb60 Icon_Integration

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Improve CO2 calibration: The most common calibration environment for diving is fresh air => ~400ppm co2. Some sensors do not have this setting as default => Calibration to 0ppm. To make sure that a proper calibration reference is set the common used value of 400ppm is not set before starting the calibration. For implementation new states were added to the co2 protocol state maschine. In addition the rx processor is now able to handle two responds parameters.
author Ideenmodellierer
date Thu, 19 Feb 2026 21:37:34 +0100
parents 1f2067cad41b
children
comparison
equal deleted inserted replaced
1071:b4a79464caf7 1072:8b97003dbb60
40 { 40 {
41 *cmdLength = 0; 41 *cmdLength = 0;
42 42
43 switch (CO2Cmd) 43 switch (CO2Cmd)
44 { 44 {
45 case CO2CMD_MODE_POLL: *cmdLength = snprintf((char*)cmdString, 10, "K 2\r\n"); 45 case CO2CMD_MODE_POLL: *cmdLength = snprintf((char*)cmdString, 20, "K 2\r\n");
46 break; 46 break;
47 case CO2CMD_MODE_STREAM: *cmdLength = snprintf((char*)cmdString, 10, "K 1\r\n"); 47 case CO2CMD_MODE_STREAM: *cmdLength = snprintf((char*)cmdString, 20, "K 1\r\n");
48 break; 48 break;
49 case CO2CMD_CALIBRATE: *cmdLength = snprintf((char*)cmdString, 10, "G\r\n"); 49 case CO2CMD_CALIBRATE_H: *cmdLength = snprintf((char*)cmdString, 20, "P 10 1\r\n"); /* set 400ppm as reference => 1 (256) and 144 */
50 break; 50 break;
51 case CO2CMD_GETDATA: *cmdLength = snprintf((char*)cmdString, 10, "Q\r\n"); 51 case CO2CMD_CALIBRATE_L: *cmdLength = snprintf((char*)cmdString, 20, "P 11 144\r\n");
52 break; 52 break;
53 case CO2CMD_GETSCALE: *cmdLength = snprintf((char*)cmdString, 10, ".\r\n"); 53 case CO2CMD_CALIBRATE: *cmdLength = snprintf((char*)cmdString, 20, "G\r\n");
54 break;
55 case CO2CMD_GETDATA: *cmdLength = snprintf((char*)cmdString, 20, "Q\r\n");
56 break;
57 case CO2CMD_GETSCALE: *cmdLength = snprintf((char*)cmdString, 20, ".\r\n");
54 break; 58 break;
55 default: *cmdLength = 0; 59 default: *cmdLength = 0;
56 break; 60 break;
57 } 61 }
58 if(cmdLength != 0) 62 if(cmdLength != 0)
62 } 66 }
63 67
64 68
65 void uartCo2_Control(void) 69 void uartCo2_Control(void)
66 { 70 {
67 static uint8_t cmdString[10]; 71 static uint8_t cmdString[20];
68 static uint8_t cmdLength = 0; 72 static uint8_t cmdLength = 0;
69 static uint8_t lastComState = UART_CO2_INIT; 73 static uint8_t lastComState = UART_CO2_INIT;
70 74
71 uint8_t activeSensor = externalInterface_GetActiveUartSensor(); 75 uint8_t activeSensor = externalInterface_GetActiveUartSensor();
72 uartCO2Status_t localComState = externalInterface_GetSensorState(activeSensor + EXT_INTERFACE_MUX_OFFSET); 76 uartCO2Status_t localComState = externalInterface_GetSensorState(activeSensor + EXT_INTERFACE_MUX_OFFSET);
95 localComState = UART_CO2_MODE; 99 localComState = UART_CO2_MODE;
96 } 100 }
97 break; 101 break;
98 case UART_CO2_MODE: uartCo2_SendCmd(CO2CMD_MODE_POLL, cmdString, &cmdLength); 102 case UART_CO2_MODE: uartCo2_SendCmd(CO2CMD_MODE_POLL, cmdString, &cmdLength);
99 break; 103 break;
104 case UART_CO2_CALIBRATE_H: uartCo2_SendCmd(CO2CMD_CALIBRATE_H, cmdString, &cmdLength);
105 break;
106 case UART_CO2_CALIBRATE_L: uartCo2_SendCmd(CO2CMD_CALIBRATE_L, cmdString, &cmdLength);
107 break;
100 case UART_CO2_CALIBRATE: uartCo2_SendCmd(CO2CMD_CALIBRATE, cmdString, &cmdLength); 108 case UART_CO2_CALIBRATE: uartCo2_SendCmd(CO2CMD_CALIBRATE, cmdString, &cmdLength);
101 localComState = UART_CO2_IDLE; 109 localComState = UART_CO2_IDLE;
102 break; 110 break;
103 case UART_CO2_IDLE: if(externalInterface_GetCO2Scale() == 0.0) /* artifact from streaming mode => not needed for polling */ 111 case UART_CO2_IDLE: if(externalInterface_GetCO2Scale() == 0.0) /* artifact from streaming mode => not needed for polling */
104 { 112 {
123 } 131 }
124 132
125 void uartCo2_ProcessData(uint8_t data) 133 void uartCo2_ProcessData(uint8_t data)
126 { 134 {
127 static uint8_t dataType = 0; 135 static uint8_t dataType = 0;
128 static uint32_t dataValue = 0; 136 static uint32_t dataValue[3];
137 static uint8_t dataIndex = 0;
129 uint8_t activeSensor = externalInterface_GetActiveUartSensor(); 138 uint8_t activeSensor = externalInterface_GetActiveUartSensor();
130 uartCO2Status_t localComState = externalInterface_GetSensorState(activeSensor + EXT_INTERFACE_MUX_OFFSET); 139 uartCO2Status_t localComState = externalInterface_GetSensorState(activeSensor + EXT_INTERFACE_MUX_OFFSET);
131 140
132 if(rxState == CO2RX_Ready) /* identify data content */ 141 if(rxState == CO2RX_Ready) /* identify data content */
133 { 142 {
134 switch(data) 143 switch(data)
135 { 144 {
145 case 'P':
136 case 'G': 146 case 'G':
137 case 'K': 147 case 'K':
138 case 'l': 148 case 'l':
139 case 'D': 149 case 'D':
140 case 'Z': 150 case 'Z':
141 case '.': dataType = data; 151 case '.': dataType = data;
142 rxState = CO2RX_Data0; 152 rxState = CO2RX_Data0;
143 dataValue = 0; 153 dataValue[0] = 0;
154 dataIndex = 0;
144 break; 155 break;
145 case '?': localComState = UART_CO2_ERROR; 156 case '?': localComState = UART_CO2_ERROR;
146 rxState = CO2RX_Ready; 157 rxState = CO2RX_Ready;
147 break; 158 break;
148 default: /* unknown or corrupted => ignore */ 159 default: /* unknown or corrupted => ignore */
149 break; 160 break;
150 } 161 }
151 } 162 }
152 else if((data >= '0') && (data <= '9')) 163 else if((data >= '0') && (data <= '9'))
153 { 164 {
154 if((rxState >= CO2RX_Data0) && (rxState <= CO2RX_Data4)) 165 if((rxState >= CO2RX_Data0) && (rxState <= CO2RX_Data9))
155 { 166 {
156 dataValue = dataValue * 10 + (data - '0'); 167 dataValue[dataIndex] = dataValue[dataIndex] * 10 + (data - '0');
157 168
158 if((rxState == CO2RX_Data4)) 169 switch (dataType)
159 { 170 {
160 rxState = CO2RX_DataComplete; 171 case 'G':
161 } 172 case 'K':
162 else 173 case 'l':
163 { 174 case 'D':
164 rxState++; 175 case 'Z':
176 case '.':
177 default: if((rxState == CO2RX_Data4))
178 {
179 rxState = CO2RX_DataComplete; /* just one value to be received */
180 }
181 else
182 {
183 rxState++;
184 }
185 break;
186 case 'P': if(rxState == CO2RX_Data9) /* get second parameter */
187 {
188 rxState = CO2RX_DataComplete;
189 }
190 else
191 {
192 rxState++;
193 }
194 break;
165 } 195 }
166 } 196 }
167 else /* protocol error data has max 5 digits */ 197 else /* protocol error data has max 5 digits */
168 { 198 {
169 if(rxState != CO2RX_DataComplete) /* commands will not answer with number values */ 199 if(rxState != CO2RX_DataComplete) /* commands will not answer with number values */
182 case UART_CO2_SETUP: if(dataType == '.') 212 case UART_CO2_SETUP: if(dataType == '.')
183 { 213 {
184 localComState = UART_CO2_MODE; 214 localComState = UART_CO2_MODE;
185 } 215 }
186 break; 216 break;
187 case UART_CO2_MODE: if((dataType == 'K') && (dataValue == 2)) 217 case UART_CO2_MODE: if((dataType == 'K') && (dataValue[dataIndex] == 2))
188 { 218 {
189 localComState = UART_CO2_IDLE; 219 localComState = UART_CO2_IDLE;
190 } 220 }
191 break; 221 break;
222 case UART_CO2_CALIBRATE_H: if((dataType == 'P') && (dataValue[0] == 10) && (dataValue[1] == 1))
223 {
224 localComState = UART_CO2_CALIBRATE_L;
225 }
226 else
227 {
228 localComState = UART_CO2_IDLE;
229 }
230 break;
231 case UART_CO2_CALIBRATE_L: if((dataType == 'P') && (dataValue[0] == 11) && (dataValue[1] == 144))
232 {
233 localComState = UART_CO2_CALIBRATE;
234 }
235 else
236 {
237 localComState = UART_CO2_IDLE;
238 }
239 break;
192 default: localComState = UART_CO2_IDLE; 240 default: localComState = UART_CO2_IDLE;
193 break; 241 break;
194 } 242 }
195 243
196 switch(dataType) 244 switch(dataType)
197 { 245 {
198 case 'D': externalInterface_SetCO2SignalStrength(dataValue); 246 case 'D': externalInterface_SetCO2SignalStrength(dataValue[dataIndex]);
199 break; 247 break;
200 case 'l': LED_ZeroOffset = dataValue; 248 case 'l': LED_ZeroOffset = dataValue[dataIndex];
201 break; 249 break;
202 case 'Z': externalInterface_SetCO2Value(dataValue); 250 case 'Z': externalInterface_SetCO2Value(dataValue[dataIndex]);
203 break; 251 break;
204 case '.': externalInterface_SetCO2Scale(dataValue); 252 case '.': externalInterface_SetCO2Scale(dataValue[dataIndex]);
205 break; 253 break;
206 default: rxState = CO2RX_Ready; 254 default: rxState = CO2RX_Ready;
207 break; 255 break;
208 } 256 }
209 rxState = CO2RX_Ready; 257 rxState = CO2RX_Ready;
210 } 258 }
211 if(rxState != CO2RX_Data0) /* reset state machine because message in wrong format */ 259 else /* multi parameter */
260 {
261 if(rxState == CO2RX_Data5)
262 {
263 switch(dataType)
264 {
265 case 'P': dataIndex++;
266 dataValue[dataIndex] = 0;
267 break;
268 default:
269 break;
270 }
271 }
272 }
273 if((rxState != CO2RX_Data0) && (rxState != CO2RX_Data5)) /* reset state machine because message in wrong format */
212 { 274 {
213 rxState = CO2RX_Ready; 275 rxState = CO2RX_Ready;
214 } 276 }
215 } 277 }
216 else 278 else