source: trunk/fw_g473rct/SES/src/outputs.c@ 73

Last change on this file since 73 was 73, checked in by f.jahn, 25 hours ago

Delta Sigma ADC auf 10Channel geändert.
File size: 17.3 KB
Line 
1/******************************************************************************
2*
3* @file outputs.c
4* @author ECS, Falko Jahn
5* @version V1.0.0
6* @date 2020-05-01
7* @brief
8*
9******************************************************************************/
10
11//--- INCLUDES -----------------------------------------------------------------
12#include "outputs.h"
13#include "main.h"
14#include "stdio.h"
15#include "sysdata.h"
16//--- EXTERNE VARIABLEN --------------------------------------------------------
17
18//--- LOKALE DEFINES - bitte hier dokumentieren --------------------------------
19
20//--- LOKALE TYPE DEFS - bitte hier dokumentieren-------------------------------
21
22//--- DEFINITIONEN GLOBALER VARIABLEN - Bitte in Header dokumentieren ----------
23
24//--- LOKALE VARIABLEN - bitte hier dokumentieren ------------------------------
25
26//--- LOKALE FUNKTIONS PROTOTYPEN ----------------------------------------------
27/*
28* @brief Heizungssteuerung
29* @param kein
30* @retval kein
31*/
32void AuxModeHeaterExec(void);
33
34
35//--- LOKALE FUNKTIONEN - bitte hier dokumentieren -----------------------------
36
37
38
39// --- GLOBALE FUNKTIONEN - bitte in Header dokumentieren------------------------
40void OUTPUTS_Init(void)
41{
42 sys_data.s.values.lvpState = OUTPUTS_LVP_UNKNOWN;
43 sys_data.s.values.ovpState = OUTPUTS_OVP_UNKNOWN;
44
45}
46
47
48
49void OUTPUTS_OverwriteChargeCtrl_ChargeEnabled(void)
50{
51 GPIO_InitTypeDef GPIO_InitStruct = {0};
52 GPIO_InitStruct.Pin = OVERWRITE_CHARGE_CTRL_Pin;
53 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
54 GPIO_InitStruct.Pull = GPIO_NOPULL;
55 HAL_GPIO_Init(OVERWRITE_CHARGE_CTRL_GPIO_Port, &GPIO_InitStruct);
56 HAL_GPIO_WritePin(OVERWRITE_CHARGE_CTRL_GPIO_Port, OVERWRITE_CHARGE_CTRL_Pin, OUTPUTS_CHARGE_ALLOWED);
57
58
59}
60
61
62void OUTPUTS_OverwriteChargeCtrl_ChargeDisabled(void)
63{
64 GPIO_InitTypeDef GPIO_InitStruct = {0};
65 GPIO_InitStruct.Pin = OVERWRITE_CHARGE_CTRL_Pin;
66 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
67 GPIO_InitStruct.Pull = GPIO_NOPULL;
68 HAL_GPIO_Init(OVERWRITE_CHARGE_CTRL_GPIO_Port, &GPIO_InitStruct);
69
70 HAL_GPIO_WritePin(OVERWRITE_CHARGE_CTRL_GPIO_Port, OVERWRITE_CHARGE_CTRL_Pin, OUTPUTS_CHARGE_NOT_ALLOWED);
71
72
73}
74
75
76void OUTPUTS_OverwriteChargeCtrl_Disabled(void)
77{
78
79
80 GPIO_InitTypeDef GPIO_InitStruct = {0};
81 GPIO_InitStruct.Pin = OVERWRITE_CHARGE_CTRL_Pin;
82 GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
83 GPIO_InitStruct.Pull = GPIO_NOPULL;
84 HAL_GPIO_Init(OVERWRITE_CHARGE_CTRL_GPIO_Port, &GPIO_InitStruct);
85
86
87}
88
89
90void OUTPUTS_OverwriteDischargeCtrl_DischargeEnabled(void)
91{
92 GPIO_InitTypeDef GPIO_InitStruct = {0};
93 GPIO_InitStruct.Pin = OVERWRITE_DISCHARGE_CTRL_Pin;
94 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
95 GPIO_InitStruct.Pull = GPIO_NOPULL;
96 HAL_GPIO_Init(OVERWRITE_DISCHARGE_CTRL_GPIO_Port, &GPIO_InitStruct);
97 HAL_GPIO_WritePin(OVERWRITE_DISCHARGE_CTRL_GPIO_Port, OVERWRITE_DISCHARGE_CTRL_Pin, OUTPUTS_DISCHARGE_ALLOWED);
98
99
100}
101
102
103void OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled(void)
104{
105 GPIO_InitTypeDef GPIO_InitStruct = {0};
106 GPIO_InitStruct.Pin = OVERWRITE_DISCHARGE_CTRL_Pin;
107 GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
108 GPIO_InitStruct.Pull = GPIO_NOPULL;
109 HAL_GPIO_Init(OVERWRITE_DISCHARGE_CTRL_GPIO_Port, &GPIO_InitStruct);
110
111 HAL_GPIO_WritePin(OVERWRITE_DISCHARGE_CTRL_GPIO_Port, OVERWRITE_DISCHARGE_CTRL_Pin, OUTPUTS_CHARGE_NOT_ALLOWED);
112
113
114}
115
116
117void OUTPUTS_OverwriteDischargeCtrl_Disabled(void)
118{
119 GPIO_InitTypeDef GPIO_InitStruct = {0};
120 GPIO_InitStruct.Pin = OVERWRITE_DISCHARGE_CTRL_Pin;
121 GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
122 GPIO_InitStruct.Pull = GPIO_NOPULL;
123 HAL_GPIO_Init(OVERWRITE_DISCHARGE_CTRL_GPIO_Port, &GPIO_InitStruct);
124
125
126}
127
128/*
129* @brief Prüfen ob LVP Signal abgeschaltet werden muss
130* LVP Signal kommt vom BMS und schaltet die Lasten ab. Wird hier auch abgeschaltet wenn der Laststrom zu hoch ist,
131* oder wenn die Geräte Temperatur zu hoch oder zu niedrig ist.
132* @param kein
133* @retval kein
134*/
135void OUTPUTS_CheckLVP(void)
136{
137 static uint16_t lastMode;
138
139 if (sys_data.s.parameter.lvpMode == OUTPUTS_LVP_MODE_AUTO)
140 {
141 if (lastMode != OUTPUTS_LVP_MODE_AUTO)
142 {
143 sys_data.s.values.lvpState = OUTPUTS_LVP_UNKNOWN;
144 }
145
146 if ((sys_data.s.values.lvpState == OUTPUTS_LVP_OK) || (sys_data.s.values.lvpState == OUTPUTS_LVP_UNKNOWN))
147 {
148 if(sys_data.s.values.batteryVoltage < sys_data.s.parameter.lvpStart)
149 {
150 printf("OUTPUTS_LVP_BATTERY_UNDERVOLTAGE\n");
151 sys_data.s.values.lvpState = OUTPUTS_LVP_BATTERY_UNDERVOLTAGE;
152 OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
153 }
154 else if(sys_data.s.values.batteryCurrent < ((int32_t)sys_data.s.parameter.loadCurrentLimit*1000))
155 {
156 printf("OUTPUTS_LVP_OVERCURRENT\n");
157 sys_data.s.values.lvpState = OUTPUTS_LVP_OVERCURRENT;
158 OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
159 }
160 else if(sys_data.s.values.shuntTemperature > sys_data.s.parameter.dischargeStopHighTemperatureStart)
161 {
162 printf("OUTPUTS_LVP_SHUNT_OVERTEMPERATURE\n");
163 sys_data.s.values.lvpState = OUTPUTS_LVP_SHUNT_OVERTEMPERATURE;
164 OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
165 }
166 else if(sys_data.s.values.chipTemperature > sys_data.s.parameter.dischargeStopHighTemperatureStart)
167 {
168 printf("OUTPUTS_LVP_CHIP_OVERTEMPERATURE\n");
169 sys_data.s.values.lvpState = OUTPUTS_LVP_CHIP_OVERTEMPERATURE;
170 OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
171 }
172 else if(sys_data.s.values.shuntTemperature < sys_data.s.parameter.dischargeStopLowTemperatureStart)
173 {
174 printf("OUTPUTS_LVP_SHUNT_UNDERTEMPERATURE\n");
175 sys_data.s.values.lvpState = OUTPUTS_LVP_SHUNT_UNDERTEMPERATURE;
176 OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
177 }
178 else if(sys_data.s.values.chipTemperature < sys_data.s.parameter.dischargeStopLowTemperatureStart)
179 {
180 printf("OUTPUTS_LVP_CHIP_OVERTEMPERATURE\n");
181 sys_data.s.values.lvpState = OUTPUTS_LVP_CHIP_UNDERTEMPERATURE;
182 OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
183 }
184 }
185
186 if ((sys_data.s.values.lvpState != OUTPUTS_LVP_OK) &&
187 (sys_data.s.values.batteryVoltage > sys_data.s.parameter.lvpStop) &&
188 (sys_data.s.values.batteryCurrent > ((int32_t)sys_data.s.parameter.loadCurrentLimit * 1000)) &&
189 (sys_data.s.values.shuntTemperature < sys_data.s.parameter.dischargeStopHighTemperatureStop) &&
190 (sys_data.s.values.chipTemperature < sys_data.s.parameter.dischargeStopHighTemperatureStop) &&
191 (sys_data.s.values.shuntTemperature > sys_data.s.parameter.dischargeStopLowTemperatureStop) &&
192 (sys_data.s.values.chipTemperature > sys_data.s.parameter.dischargeStopLowTemperatureStop))
193 {
194 //Abschaltkriterien für LVP liegen nicht mehr vor
195 //Wenn Abschaltung aufgrund zu hohem Lade/Lastrom erfolgt ist, muss Fehler durch Geräte Reset zurück gesetzt werden
196 //Andere Fehler automatisches Reset, wenn Fehler nicht mehr vorliegt.
197 //Kunde könnte automatische Reset verhindern, indem er die Stop Werte anders programmiert
198 //z.B.
199 //Temperabschaltung Start 80°C
200 //Temperaturabschaltung Stop -99°C
201 if ((sys_data.s.values.lvpState != OUTPUTS_LVP_OVERCURRENT) && (sys_data.s.values.lvpState != OUTPUTS_LVP_SHORT_PROTECTION))
202 {
203 //Andere Fehler, automatisches zurücksetzen, wenn keine Fehlerbedingungen mehr vorliegen
204 printf("OUTPUT LVP OK\n");
205 sys_data.s.values.lvpState = OUTPUTS_LVP_OK;
206#ifndef NO_TRISTATE_OUTPUTS
207 OUTPUTS_OverwriteDischargeCtrl_Disabled();
208#else
209 OUTPUTS_OverwriteDischargeCtrl_DischargeEnabled();
210#endif
211 }
212 }
213 }
214 else if (sys_data.s.parameter.lvpMode == OUTPUTS_LVP_MODE_MANUAL_ON)
215 {
216 OUTPUTS_OverwriteDischargeCtrl_DischargeEnabled();
217 }
218 else if (sys_data.s.parameter.lvpMode == OUTPUTS_LVP_MODE_MANUAL_OFF)
219 {
220 OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
221 }
222 else
223 {
224 OUTPUTS_OverwriteDischargeCtrl_DischargeDisabled();
225 }
226
227 lastMode = sys_data.s.parameter.lvpMode;
228}
229
230/*
231* @brief Prüfen ob OVP Signal abgeschaltet werden muss
232* OVP Signal kommt vom BMS und schaltet die Ladequellen ab. Wird hier auch abgeschaltet wenn der Ladestrom zu hoch ist,
233* oder wenn die Geräte Temperatur zu hoch oder zu niedrig ist.
234* @param kein
235* @retval kein
236*/
237void OUTPUTS_CheckOVP(void)
238{
239 static uint16_t lastMode;
240
241 if (sys_data.s.parameter.ovpMode == OUTPUTS_OVP_MODE_AUTO)
242 {
243 if (lastMode != OUTPUTS_OVP_MODE_AUTO)
244 {
245 sys_data.s.values.ovpState = OUTPUTS_OVP_UNKNOWN;
246 }
247
248 if ((sys_data.s.values.ovpState == OUTPUTS_OVP_OK) || (sys_data.s.values.ovpState == OUTPUTS_OVP_UNKNOWN))
249 {
250 if(sys_data.s.values.batteryVoltage > sys_data.s.parameter.ovpStart)
251 {
252 printf("OUTPUTS_OVP_BATTERY_OVERVOLTAGE\n");
253 sys_data.s.values.ovpState = OUTPUTS_OVP_BATTERY_OVERVOLTAGE;
254 OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
255 }
256 else if(sys_data.s.values.batteryCurrent > ((int32_t) sys_data.s.parameter.chargeCurrentLimit * 1000))
257 {
258 printf("OUTPUTS_OVP_OVERCURRENT\n");
259 sys_data.s.values.ovpState = OUTPUTS_OVP_OVERCURRENT;
260 OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
261 }
262 else if(sys_data.s.values.shuntTemperature > sys_data.s.parameter.chargeStopHighTemperatureStart)
263 {
264 printf("OUTPUTS_OVP_SHUNT_OVERTEMPERATURE\n");
265 sys_data.s.values.ovpState = OUTPUTS_OVP_SHUNT_OVERTEMPERATURE;
266 OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
267 }
268 else if(sys_data.s.values.chipTemperature > sys_data.s.parameter.chargeStopHighTemperatureStart)
269 {
270 printf("OUTPUTS_OVP_CHIP_OVERTEMPERATURE\n");
271 sys_data.s.values.ovpState = OUTPUTS_OVP_CHIP_OVERTEMPERATURE;
272 OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
273 }
274 else if(sys_data.s.values.shuntTemperature < sys_data.s.parameter.chargeStopLowTemperatureStart)
275 {
276 printf("OUTPUTS_OVP_SHUNT_UNDERTEMPERATURE\n");
277 sys_data.s.values.ovpState = OUTPUTS_OVP_SHUNT_UNDERTEMPERATURE;
278 OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
279 }
280 else if(sys_data.s.values.chipTemperature < sys_data.s.parameter.chargeStopLowTemperatureStart)
281 {
282 printf("OUTPUTS_OVP_CHIP_UNDETEMPERATURE\n");
283 sys_data.s.values.ovpState = OUTPUTS_OVP_CHIP_UNDERTEMPERATURE;
284 OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
285 }
286 }
287
288 if ((sys_data.s.values.ovpState != OUTPUTS_OVP_OK) &&
289 (sys_data.s.values.batteryVoltage < sys_data.s.parameter.ovpStop) &&
290 (sys_data.s.values.batteryCurrent < ( (int32_t) sys_data.s.parameter.chargeCurrentLimit*1000)) &&
291 (sys_data.s.values.shuntTemperature < sys_data.s.parameter.chargeStopHighTemperatureStop) &&
292 (sys_data.s.values.chipTemperature < sys_data.s.parameter.chargeStopHighTemperatureStop) &&
293 (sys_data.s.values.shuntTemperature > sys_data.s.parameter.chargeStopLowTemperatureStop) &&
294 (sys_data.s.values.chipTemperature > sys_data.s.parameter.chargeStopLowTemperatureStop))
295 {
296 //Abschaltkriterien für OVP liegen nicht mehr vor
297 //Wenn Abschaltung aufgrund zu hohem Lade/Lastrom erfolgt ist, dann muss Rücksetzen durch Reset Button erfolgen
298 //Andere Fehler, automatisches zurücksetzen, wenn keine Fehlerbedingungen mehr vorliegen
299 if ((sys_data.s.values.ovpState != OUTPUTS_OVP_OVERCURRENT) && (sys_data.s.values.ovpState != OUTPUTS_OVP_SHORT_PROTECTION) )
300 {
301 printf("OUTPUT OVP OK\n");
302 sys_data.s.values.ovpState = OUTPUTS_OVP_OK;
303#ifndef NO_TRISTATE_OUTPUTS
304 OUTPUTS_OverwriteChargeCtrl_Disabled();
305#else
306 OUTPUTS_OverwriteChargeCtrl_ChargeEnabled();
307#endif
308 }
309 }
310 }
311 else if (sys_data.s.parameter.ovpMode == OUTPUTS_OVP_MODE_MANUAL_ON)
312 {
313 OUTPUTS_OverwriteChargeCtrl_ChargeEnabled(); //ACHTUNG: Manual On
314 }
315 else if (sys_data.s.parameter.ovpMode == OUTPUTS_OVP_MODE_MANUAL_OFF)
316 {
317 OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
318 }
319 else
320 {
321 OUTPUTS_OverwriteChargeCtrl_ChargeDisabled();
322 }
323
324 lastMode = sys_data.s.parameter.ovpMode;
325}
326
327
328
329#define LVP_DETECTION_LEVEL 6000 //< 6 V
330#define CHARGE_DETECT_HYSTERESE 10
331
332void AuxModeHeaterExec(void)
333{
334 static int outputState=0;
335
336 int offv = sys_data.s.parameter.auxOutputSetpointOn - CHARGE_DETECT_HYSTERESE;
337 int onv = sys_data.s.parameter.auxOutputSetpointOn + CHARGE_DETECT_HYSTERESE;
338
339 if ((sys_data.s.values.shuntVoltage > onv) && (sys_data.s.values.ovp_sense < LVP_DETECTION_LEVEL) && (outputState == 0))
340 {
341 printf("Heater on\r\n");
342 outputState = 1;
343 if (sys_data.s.parameter.auxOutputInverted == 0)
344 {
345 HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_SET);
346 }
347 else
348 {
349 HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET);
350 }
351
352 }
353
354 //Ausschalten
355 //Wenn Spannung am Shunt < setpoint (ladegeräteerkennung 14,8V?) und Entladung
356 //Oder wenn OVP wieder da ist
357 //sys_data.s.values.batteryCurrent < sys_data.s.parameter.auxOutputSetpointOff
358
359 if ((sys_data.s.values.shuntVoltage < offv ) || (sys_data.s.values.ovp_sense > LVP_DETECTION_LEVEL))
360 {
361 if (outputState == 1)
362 {
363 printf("Heater off\r\n");
364 outputState = 0;
365 if (sys_data.s.parameter.auxOutputInverted == 0)
366 {
367 HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET);
368 }
369 else
370 {
371 HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_SET);
372 }
373 }
374 }
375}
376
377void AuxModeSOCExec(void)
378{
379 static int outputState=0;
380
381
382 if ((sys_data.s.values.soc > (sys_data.s.parameter.auxOutputSetpointOn*1000)) && (outputState == 0))
383 {
384 printf("AUX on (SOC Mode)\r\n");
385 outputState = 1;
386 if (sys_data.s.parameter.auxOutputInverted == 0)
387 {
388 HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_SET);
389 }
390 else
391 {
392 HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET);
393 }
394
395 }
396
397
398 if ((sys_data.s.values.soc < (sys_data.s.parameter.auxOutputSetpointOff*1000)) && (outputState == 1))
399 {
400 printf("AUX off (SOC Mode)\r\n");
401 outputState = 0;
402 if (sys_data.s.parameter.auxOutputInverted == 0)
403 {
404 HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET);
405 }
406 else
407 {
408 HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_SET);
409 }
410 }
411
412
413}
414
415
416 int16_t loadCurrentLimit; // 30 maximaler Laststrom in A wenn der Strom grer ist als der eingestelle Wert dann wird die Laststrom Protection aktiv, darf nicht unsigned sein, da Entladestrom mit Minus angegeben [A] Default -500 A
417 int16_t chargeCurrentLimit; // 31 maximaler Ladestrom in A wenn der Strom grer ist als der eingestelle Wert dann wird die Ladestrom Protection aktiv [A] Default:500A
418
419
420 int16_t chargeStopHighTemperatureStart; // 32 Abschalttemperatur Ladung wegen zu hoher Temperatur [C * 100]
421 int16_t chargeStopHighTemperatureStop; // 33 Wiedereinschalttemperatur [C * 100]
422
423 int16_t chargeStopLowTemperatureStart; // 34 Abschalttemperatur Ladung wegen zu niedriger Temperatur [C * 100]
424 int16_t chargeStopLowTemperatureStop; // 35 Wiedereinschalttemperatur [C * 100]
425
426 int16_t dischargeStopHighTemperatureStart; // 36 Abschalttemperatur Entladung wegen zu hoher Temperatur [C * 100]
427 int16_t dischargeStopHighTemperatureStop; // 37 Wiedereinschalttemperatur[C * 100]
428
429 int16_t dischargeStopLowTemperatureStart; // 38 Abschalttemperatur EntLadung wegen zu niedriger Temperatur
430 int16_t dischargeStopLowTemperatureStop; // 39 Wiedereinschalttemperatur
431
432
433
434void AuxModeAlarmExec(void)
435{
436 static int outputState=0;
437
438
439 if (
440 (sys_data.s.values.shuntTemperature > (chargeStopHighTemperatureStart - 500)) ||
441 (sys_data.s.values.chipTemperature > (chargeStopHighTemperatureStart - 500)) ||
442 (sys_data.s.values.shuntTemperature < (chargeStopLowTemperatureStart + 500)) ||
443 (sys_data.s.values.chipTemperature < (chargeStopLowTemperatureStart + 500)) ||
444 (sys_data.s.values.shuntTemperature > (dischargeStopHighTemperatureStart - 500)) ||
445 (sys_data.s.values.chipTemperature > (dischargeStopHighTemperatureStart - 500)) ||
446 (sys_data.s.values.shuntTemperature < (dischargeStopLowTemperatureStart + 500)) ||
447 (sys_data.s.values.chipTemperature < (dischargeStopLowTemperatureStart + 500)) ||
448 (sys_data.s.values.batteryCurrent > ((chargeCurrentLimit*1000LL) - 10000)) ||
449 (sys_data.s.values.batteryCurrent < ((loadCurrentLimit*1000LL) + 10000))
450
451 )
452 {
453 if ( outputState == 0)
454 {
455 printf("AUX on (Alarm Mode)\r\n");
456 outputState = 1;
457 if (sys_data.s.parameter.auxOutputInverted == 0)
458 {
459 HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_SET);
460 }
461 else
462 {
463 HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET);
464 }
465 }
466 }
467 else // Alles OK
468 {
469 if ( outputState == 0)
470 {
471 printf("AUX off (Alarm Mode)\r\n");
472 outputState = 0;
473 if (sys_data.s.parameter.auxOutputInverted == 0)
474 {
475 HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET);
476 }
477 else
478 {
479 HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_SET);
480 }
481 }
482 }
483}
484
485
486void OUTPUTS_CheckAUX(void)
487{
488
489 switch (sys_data.s.parameter.auxOutputMode)
490 {
491 case AUX_MODE_OFF:
492 HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET);
493 break;
494
495 case AUX_MODE_HEATER:
496 AuxModeHeaterExec();
497 break;
498
499 case AUX_MODE_SOC:
500 AuxModeSOCExec();
501 break;
502
503 case AUX_MODE_ALARM:
504 AuxModeAlarmExec();
505 break;
506
507
508 default:
509 HAL_GPIO_WritePin(AUX_EN_GPIO_Port, AUX_EN_Pin, GPIO_PIN_RESET);
510 break;
511
512
513 }
514
515
516}
517
518/*************************** End of file ****************************/
Note: See TracBrowser for help on using the repository browser.