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

Last change on this file since 70 was 55, checked in by f.jahn, 5 weeks ago

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