Statistics
| Branch: | Tag: | Revision:

amiro-blt / Target / Modules / PowerManagement_1-2 / Boot / main.c @ 3decc02a

History | View | Annotate | Download (56.968 KB)

1
/************************************************************************************//**
2
* \file         Demo\ARMCM4_STM32_Olimex_STM32E407_GCC\Boot\main.c
3
* \brief        Bootloader application source file.
4
* \ingroup      Boot_ARMCM4_STM32_Olimex_STM32E407_GCC
5
* \internal
6
*----------------------------------------------------------------------------------------
7
*                          C O P Y R I G H T
8
*----------------------------------------------------------------------------------------
9
*   Copyright (c) 2013  by Feaser    http://www.feaser.com    All rights reserved
10
*
11
*----------------------------------------------------------------------------------------
12
*                            L I C E N S E
13
*----------------------------------------------------------------------------------------
14
* This file is part of OpenBLT. OpenBLT is free software: you can redistribute it and/or
15
* modify it under the terms of the GNU General Public License as published by the Free
16
* Software Foundation, either version 3 of the License, or (at your option) any later
17
* version.
18
*
19
* OpenBLT is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
20
* without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
21
* PURPOSE. See the GNU General Public License for more details.
22
*
23
* You should have received a copy of the GNU General Public License along with OpenBLT.
24
* If not, see <http://www.gnu.org/licenses/>.
25
*
26
* A special exception to the GPL is included to allow you to distribute a combined work
27
* that includes OpenBLT without being obliged to provide the source code for any
28
* proprietary components. The exception text is included at the bottom of the license
29
* file <license.html>.
30
*
31
* \endinternal
32
****************************************************************************************/
33

    
34
/****************************************************************************************
35
* Include files
36
****************************************************************************************/
37
#include "boot.h"                                /* bootloader generic header          */
38
#include "com.h"
39
#include "ARMCM4_STM32/types.h"
40
#include "AMiRo/amiroblt.h"
41
#include "helper.h"
42
#include "iodef.h"
43

    
44
/****************************************************************************************
45
* Defines
46
****************************************************************************************/
47
#define HIBERNATE_TIME_MS       5000
48

    
49
/****************************************************************************************
50
* Function prototypes and static variables
51
****************************************************************************************/
52
static void Init(void);
53

    
54
static void initGpio();
55
static void initExti();
56
void configGpioForShutdown();
57
void systemPowerDown();
58

    
59
ErrorStatus handleColdReset();
60
ErrorStatus handleSoftwareReset();
61
ErrorStatus handleUartDnWakeup();
62
ErrorStatus handlePathDcWakeup();
63
ErrorStatus handleTouchWakeup();
64
ErrorStatus handleIwdgWakeup();
65

    
66
static void indicateHibernate();
67
static void AdcSingleMeasurement();
68

    
69
ADC_TypeDef* setupADC(ADC_TypeDef* adc, const uint16_t low_th, const uint16_t high_th);
70
uint16_t configIwdg(const uint16_t ms);
71

    
72
ErrorStatus shutdownDisambiguationProcedure(const uint8_t type);
73
void shutdownToTransportation();
74
void shutdownToDeepsleep();
75
void shutdownToHibernate();
76
void shutdownAndRestart();
77

    
78
volatile blBackupRegister_t backup_reg;
79

    
80
/****************************************************************************************
81
* Callback configuration
82
****************************************************************************************/
83
void blCallbackShutdownTransportation(void);
84
void blCallbackShutdownDeepsleep(void);
85
void blCallbackShutdownHibernate(void);
86
void blCallbackShutdownRestart(void);
87
void blCallbackHandleShutdownRequest(void);
88

    
89
const blCallbackTable_t cbtable __attribute__ ((section ("_callback_table"))) = {
90
  .magicNumber = BL_MAGIC_NUMBER,
91
  .vBootloader = {BL_VERSION_ID_AMiRoBLT_Beta, BL_VERSION_MAJOR, BL_VERSION_MINOR, 3},
92
  .vSSSP = {BL_VERSION_ID_SSSP, BL_SSSP_VERSION_MAJOR, BL_SSSP_VERSION_MINOR, 0},
93
  .vCompiler = {BL_VERSION_ID_GCC, __GNUC__, __GNUC_MINOR__, __GNUC_PATCHLEVEL__},  // currently only GCC is supported
94
  .cbShutdownHibernate = blCallbackShutdownHibernate,
95
  .cbShutdownDeepsleep = blCallbackShutdownDeepsleep,
96
  .cbShutdownTransportation = blCallbackShutdownTransportation,
97
  .cbShutdownRestart = blCallbackShutdownRestart,
98
  .cbHandleShutdownRequest = blCallbackHandleShutdownRequest,
99
  .cb5 = (void*)0,
100
  .cb6 = (void*)0,
101
  .cb7 = (void*)0,
102
  .cb8 = (void*)0,
103
  .cb9 = (void*)0,
104
  .cb10 = (void*)0,
105
  .cb11 = (void*)0
106
};
107

    
108
/************************************************************************************//**
109
** \brief     This is the entry point for the bootloader application and is called
110
**            by the reset interrupt vector after the C-startup routines executed.
111
** \return    none.
112
**
113
****************************************************************************************/
114
void main(void)
115
{
116
  /* initialize the microcontroller */
117
  Init();
118

    
119
  /* activate some required clocks */
120
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD, ENABLE);
121
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
122
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_SYSCFG, ENABLE);
123

    
124
  /* initialize GPIOs and EXTI lines */
125
  initGpio();
126
  setLed(BLT_TRUE);
127
  initExti();
128

    
129
  /* initialize the timer */
130
  TimerInit(); // do not use saTimerInit() in order to initialize the static variable.
131

    
132
  /* read the backup register */
133
  backup_reg.raw = RTC_ReadBackupRegister(BL_RTC_BACKUP_REG);
134

    
135
  /* detect the primary reason for this wakeup/restart */
136
  backup_reg.wakeup_pri_reason =
137
      ((RCC_GetFlagStatus(RCC_FLAG_LPWRRST) == SET) ? BL_WAKEUP_PRI_RSN_LPWRRST : 0) |
138
      ((RCC_GetFlagStatus(RCC_FLAG_WWDGRST) == SET) ? BL_WAKEUP_PRI_RSN_WWDGRST : 0) |
139
      ((RCC_GetFlagStatus(RCC_FLAG_IWDGRST) == SET) ? BL_WAKEUP_PRI_RSN_IWDGRST : 0) |
140
      ((RCC_GetFlagStatus(RCC_FLAG_SFTRST) == SET) ? BL_WAKEUP_PRI_RSN_SFTRST : 0)   |
141
      ((RCC_GetFlagStatus(RCC_FLAG_PORRST) == SET) ? BL_WAKEUP_PRI_RSN_PORRST : 0)   |
142
      ((RCC_GetFlagStatus(RCC_FLAG_PINRST) == SET) ? BL_WAKEUP_PRI_RSN_PINRST : 0)   |
143
      ((RCC_GetFlagStatus(RCC_FLAG_BORRST) == SET) ? BL_WAKEUP_PRI_RSN_BORRST : 0)   |
144
      ((PWR_GetFlagStatus(PWR_FLAG_WU) == SET) ? BL_WAKEUP_PRI_RSN_WKUP : 0);
145

    
146
  /* when woken from standby mode, detect the secondary reason for this wakeup/reset */
147
  if ( (backup_reg.wakeup_pri_reason & BL_WAKEUP_PRI_RSN_WKUP) && (PWR_GetFlagStatus(PWR_FLAG_SB) == SET) ) {
148
    if (GPIO_ReadInputDataBit(SYS_UART_DN_GPIO, SYS_UART_DN_PIN) == Bit_RESET) {
149
      backup_reg.wakeup_sec_reason = BL_WAKEUP_SEC_RSN_UART;
150
    } else if (GPIO_ReadInputDataBit(PATH_DC_GPIO, PATH_DC_PIN) == Bit_SET) {
151
      backup_reg.wakeup_sec_reason = BL_WAKEUP_SEC_RSN_PWRPLUG;
152
    } else {
153
      backup_reg.wakeup_sec_reason = BL_WAKEUP_SEC_RSN_TOUCH;
154
    }
155
  } else {
156
    backup_reg.wakeup_sec_reason = BL_WAKEUP_SEC_RSN_UNKNOWN;
157
  }
158

    
159
  /* store the information about this wakeup/restart in the backup register */
160
  PWR_BackupAccessCmd(ENABLE);
161
  RTC_WriteBackupRegister(BL_RTC_BACKUP_REG, backup_reg.raw);
162

    
163
  /* clear the flags */
164
  RCC_ClearFlag();
165
  PWR_ClearFlag(PWR_FLAG_WU);
166

    
167
  setLed(BLT_FALSE);
168

    
169
  /* handle different wakeup/reset reasons */
170
  ErrorStatus status = ERROR;
171
  if (backup_reg.wakeup_pri_reason & BL_WAKEUP_PRI_RSN_SFTRST) {
172
    /* system was reset by software */
173
    status = handleSoftwareReset();
174
  } else if (backup_reg.wakeup_pri_reason & BL_WAKEUP_PRI_RSN_WKUP) {
175
    /* system was woken via WKUP pin */
176
    /* differeciate between thre wakeup types */
177
    switch (backup_reg.wakeup_sec_reason) {
178
      case BL_WAKEUP_SEC_RSN_UART:
179
        status = handleUartDnWakeup();
180
        break;
181
      case BL_WAKEUP_SEC_RSN_PWRPLUG:
182
        status = handlePathDcWakeup();
183
        break;
184
      case BL_WAKEUP_SEC_RSN_TOUCH:
185
        status = handleTouchWakeup();
186
        break;
187
      default:
188
        status = ERROR;
189
        break;
190
    }
191
  } else if (backup_reg.wakeup_pri_reason & BL_WAKEUP_PRI_RSN_IWDGRST) {
192
    /* system was woken by IWDG */
193
    status = handleIwdgWakeup();
194
  } else if (backup_reg.wakeup_pri_reason == BL_WAKEUP_PRI_RSN_PINRST) {
195
    /* system was reset via NRST pin */
196
    status = handleColdReset();
197
  } else {
198
    /* system was woken/reset for an unexpected reason.
199
     * In this case the LED blinks "SOS" (... --- ...) and the system resets.
200
     */
201
    blinkSOS(1);
202
    status = ERROR;
203
    backup_reg.shutdown_pri_reason = BL_SHUTDOWN_PRI_RSN_RESTART;
204
    backup_reg.shutdown_sec_reason = BL_SHUTDOWN_SEC_RSN_UNKNOWN;
205
    RTC_WriteBackupRegister(BL_RTC_BACKUP_REG, backup_reg.raw);
206
    NVIC_SystemReset();
207
  }
208

    
209
  /* if something went wrong, signal this failure */
210
  if (status != SUCCESS) {
211
    blinkSOSinf();
212
  }
213

    
214
  return;
215
} /*** end of main ***/
216

    
217

    
218
/************************************************************************************//**
219
** \brief     Initializes the microcontroller.
220
** \return    none.
221
**
222
****************************************************************************************/
223
static void Init(void)
224
{
225
#if (BOOT_COM_UART_ENABLE > 0 || BOOT_GATE_UART_ENABLE > 0)
226
  GPIO_InitTypeDef  GPIO_InitStructure;
227
#elif (BOOT_FILE_SYS_ENABLE > 0)
228
  GPIO_InitTypeDef  GPIO_InitStructure;
229
  USART_InitTypeDef USART_InitStructure;
230
#elif (BOOT_COM_CAN_ENABLE > 0 || BOOT_GATE_CAN_ENABLE > 0)
231
  GPIO_InitTypeDef  GPIO_InitStructure;
232
#endif
233

    
234
  /* initialize the system and its clocks */
235
  SystemInit();
236
#if (BOOT_COM_UART_ENABLE > 0 || BOOT_GATE_UART_ENABLE > 0)
237
  /* enable UART peripheral clock */
238
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);
239
  /* enable GPIO peripheral clock for transmitter and receiver pins */
240
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
241
  /* connect the pin to the peripherals alternate function */
242
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource9, GPIO_AF_USART1);
243
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource10, GPIO_AF_USART1);
244
  /* configure USART Tx as alternate function  */
245
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
246
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
247
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
248
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9;
249
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
250
  GPIO_Init(GPIOA, &GPIO_InitStructure);
251
  /* configure USART Rx as alternate function */
252
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
253
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
254
  GPIO_Init(GPIOA, &GPIO_InitStructure);
255
#endif
256

    
257
#if (BOOT_COM_BLUETOOTH_UART_ENABLE > 0)
258
  /* enable UART peripheral clock */
259
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE);
260

    
261
  /* enable GPIO peripheral clock for transmitter and receiver pins */
262
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
263
  /* connect the pin to the peripherals alternate function */
264
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource10, GPIO_AF_USART3);
265
  GPIO_PinAFConfig(GPIOC, GPIO_PinSource11, GPIO_AF_USART3);
266
  /* configure USART Tx as alternate function  */
267
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
268
  GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_UP;
269
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
270
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
271
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
272
  GPIO_Init(GPIOC, &GPIO_InitStructure);
273
  /* configure USART Rx as alternate function */
274
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
275
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
276
  GPIO_Init(GPIOC, &GPIO_InitStructure);
277

    
278
  /* Configure Bluetooth reset pin */
279
  GPIO_InitTypeDef  gpio_init;
280
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOC, ENABLE);
281
  gpio_init.GPIO_Pin   = BT_RST_PIN;
282
  gpio_init.GPIO_OType = GPIO_OType_OD;
283
  gpio_init.GPIO_PuPd = GPIO_PuPd_NOPULL;
284
  gpio_init.GPIO_Mode = GPIO_Mode_OUT;
285
  gpio_init.GPIO_Speed = GPIO_Speed_50MHz;
286
  GPIO_Init(BT_RST_GPIO, &gpio_init);
287
  /* Reset Bluetooth reset pin */
288
  GPIO_ResetBits(BT_RST_GPIO, BT_RST_PIN);
289
#endif
290

    
291

    
292
#if (BOOT_COM_CAN_ENABLE > 0 || BOOT_GATE_CAN_ENABLE > 0)
293
  /* enable clocks for CAN transmitter and receiver pins */
294
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA, ENABLE);
295
  /* select alternate function for the CAN pins */
296
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource11, GPIO_AF_CAN1);
297
  GPIO_PinAFConfig(GPIOA, GPIO_PinSource12, GPIO_AF_CAN1);
298
  /* configure CAN RX and TX pins */
299
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;
300
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
301
  GPIO_InitStructure.GPIO_Mode  = GPIO_Mode_AF;
302
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
303
  GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
304
  GPIO_Init(GPIOA, &GPIO_InitStructure);
305
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_12;
306
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
307
  GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;
308
  GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
309
  GPIO_InitStructure.GPIO_PuPd  = GPIO_PuPd_NOPULL;
310
  GPIO_Init(GPIOA, &GPIO_InitStructure);
311
#endif
312
} /*** end of Init ***/
313

    
314
/*
315
 * Initializes all GPIO used by the bootloader
316
 */
317
static void initGpio() {
318
  GPIO_InitTypeDef gpio_init;
319

    
320
  /*
321
   * OUTPUTS
322
   */
323

    
324
  /* initialize LED and push it up (inactive) */
325
  GPIO_SetBits(LED_GPIO, LED_PIN);
326
  gpio_init.GPIO_Pin    = LED_PIN;
327
  gpio_init.GPIO_Mode   = GPIO_Mode_OUT;
328
  gpio_init.GPIO_Speed  = GPIO_Speed_50MHz;
329
  gpio_init.GPIO_OType  = GPIO_OType_PP;
330
  gpio_init.GPIO_PuPd   = GPIO_PuPd_NOPULL;
331
  GPIO_Init(LED_GPIO, &gpio_init);
332

    
333
  /* initialize SYS_PD_N and push it up (inactive) */
334
  GPIO_SetBits(SYS_PD_N_GPIO, SYS_PD_N_PIN);
335
  gpio_init.GPIO_Pin    = SYS_PD_N_PIN;
336
  gpio_init.GPIO_Mode   = GPIO_Mode_OUT;
337
  gpio_init.GPIO_Speed  = GPIO_Speed_50MHz;
338
  gpio_init.GPIO_OType  = GPIO_OType_OD;
339
  gpio_init.GPIO_PuPd   = GPIO_PuPd_NOPULL;
340
  GPIO_Init(SYS_PD_N_GPIO, &gpio_init);
341

    
342
  /* initialize SYS_SYNC_N and pull it down (active) */
343
  GPIO_ResetBits(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN);
344
  gpio_init.GPIO_Pin    = SYS_SYNC_N_PIN;
345
  gpio_init.GPIO_Mode   = GPIO_Mode_OUT;
346
  gpio_init.GPIO_Speed  = GPIO_Speed_50MHz;
347
  gpio_init.GPIO_OType  = GPIO_OType_OD;
348
  gpio_init.GPIO_PuPd   = GPIO_PuPd_NOPULL;
349
  GPIO_Init(SYS_SYNC_N_GPIO, &gpio_init);
350

    
351
  /* initialize SYS_WARMRST_N and pull it down (active) */
352
  GPIO_ResetBits(SYS_WARMRST_N_GPIO, SYS_WARMRST_N_PIN);
353
  gpio_init.GPIO_Pin    = SYS_WARMRST_N_PIN;
354
  gpio_init.GPIO_Mode   = GPIO_Mode_OUT;
355
  gpio_init.GPIO_Speed  = GPIO_Speed_50MHz;
356
  gpio_init.GPIO_OType  = GPIO_OType_OD;
357
  gpio_init.GPIO_PuPd   = GPIO_PuPd_NOPULL;
358
  GPIO_Init(SYS_WARMRST_N_GPIO, &gpio_init);
359

    
360
  /* initialize SYS_UART_DN and push it up (inactive) */
361
  GPIO_SetBits(SYS_UART_DN_GPIO, SYS_UART_DN_PIN);
362
  gpio_init.GPIO_Pin    = SYS_UART_DN_PIN;
363
  gpio_init.GPIO_Mode   = GPIO_Mode_OUT;
364
  gpio_init.GPIO_Speed  = GPIO_Speed_50MHz;
365
  gpio_init.GPIO_OType  = GPIO_OType_OD;
366
  gpio_init.GPIO_PuPd   = GPIO_PuPd_NOPULL;
367
  GPIO_Init(SYS_UART_DN_GPIO, &gpio_init);
368

    
369
  /* initialize POWER_EN and pull it down (inactive) */
370
  GPIO_ResetBits(POWER_EN_GPIO, POWER_EN_PIN);
371
  gpio_init.GPIO_Pin    = POWER_EN_PIN;
372
  gpio_init.GPIO_Mode   = GPIO_Mode_OUT;
373
  gpio_init.GPIO_Speed  = GPIO_Speed_50MHz;
374
  gpio_init.GPIO_OType  = GPIO_OType_PP;
375
  gpio_init.GPIO_PuPd   = GPIO_PuPd_NOPULL;
376
  GPIO_Init(POWER_EN_GPIO, &gpio_init);
377

    
378
  /* initialize SYS_REG_EN and pull it down (inactive) */
379
  GPIO_ResetBits(SYS_REG_EN_GPIO, SYS_REG_EN_PIN);
380
  gpio_init.GPIO_Pin    = SYS_REG_EN_PIN;
381
  gpio_init.GPIO_Mode   = GPIO_Mode_OUT;
382
  gpio_init.GPIO_Speed  = GPIO_Speed_50MHz;
383
  gpio_init.GPIO_OType  = GPIO_OType_PP;
384
  gpio_init.GPIO_PuPd   = GPIO_PuPd_NOPULL;
385
  GPIO_Init(SYS_REG_EN_GPIO, &gpio_init);
386

    
387
  /* initialize CHARGE_EN1_N and CHARGE_EN2_N and push them up (inactive) */
388
  GPIO_SetBits(CHARGE_EN1_N_GPIO, CHARGE_EN1_N_PIN);
389
  GPIO_SetBits(CHARGE_EN2_N_GPIO, CHARGE_EN2_N_PIN);
390
  gpio_init.GPIO_Pin    = CHARGE_EN1_N_PIN;
391
  gpio_init.GPIO_Mode   = GPIO_Mode_OUT;
392
  gpio_init.GPIO_Speed  = GPIO_Speed_50MHz;
393
  gpio_init.GPIO_OType  = GPIO_OType_PP;
394
  gpio_init.GPIO_PuPd   = GPIO_PuPd_NOPULL;
395
  GPIO_Init(CHARGE_EN1_N_GPIO, &gpio_init);
396
  gpio_init.GPIO_Pin    = CHARGE_EN2_N_PIN;
397
  GPIO_Init(CHARGE_EN2_N_GPIO, &gpio_init);
398

    
399
  /*
400
   * INPUTS
401
   */
402

    
403
  /* initialize SWITCH_STATUS_N */
404
  gpio_init.GPIO_Pin    = SWITCH_STATUS_N_PIN;
405
  gpio_init.GPIO_Mode   = GPIO_Mode_IN;
406
  gpio_init.GPIO_Speed  = GPIO_Speed_50MHz;
407
  gpio_init.GPIO_OType  = GPIO_OType_PP;
408
  gpio_init.GPIO_PuPd   = GPIO_PuPd_NOPULL;
409
  GPIO_Init(SWITCH_STATUS_N_GPIO, &gpio_init);
410

    
411
  /* initialize PATH_DC */
412
  gpio_init.GPIO_Pin    = PATH_DC_PIN;
413
  gpio_init.GPIO_Mode   = GPIO_Mode_IN;
414
  gpio_init.GPIO_Speed  = GPIO_Speed_50MHz;
415
  gpio_init.GPIO_OType  = GPIO_OType_PP;
416
  gpio_init.GPIO_PuPd   = GPIO_PuPd_NOPULL;
417
  GPIO_Init(PATH_DC_GPIO, &gpio_init);
418

    
419
  /* initialize TOUCH_INT_N */
420
  gpio_init.GPIO_Pin    = TOUCH_INT_N_PIN;
421
  gpio_init.GPIO_Mode   = GPIO_Mode_IN;
422
  gpio_init.GPIO_Speed  = GPIO_Speed_50MHz;
423
  gpio_init.GPIO_OType  = GPIO_OType_PP;
424
  gpio_init.GPIO_PuPd   = GPIO_PuPd_NOPULL;
425
  GPIO_Init(TOUCH_INT_N_GPIO, &gpio_init);
426

    
427
  /* initialize VSYS_SENSE as analog input */
428
  gpio_init.GPIO_Pin    = VSYS_SENSE_PIN;
429
  gpio_init.GPIO_Mode   = GPIO_Mode_AN;
430
  gpio_init.GPIO_Speed  = GPIO_Speed_50MHz;
431
  gpio_init.GPIO_OType  = GPIO_OType_PP;
432
  gpio_init.GPIO_PuPd   = GPIO_PuPd_NOPULL;
433
  GPIO_Init(VSYS_SENSE_GPIO, &gpio_init);
434

    
435
  /* initialize GPIOB4, since it is configured in alternate function mode on reset */
436
  gpio_init.GPIO_Pin    = CHARGE_STAT2A_PIN;
437
  gpio_init.GPIO_Mode   = GPIO_Mode_IN;
438
  gpio_init.GPIO_Speed  = GPIO_Speed_50MHz;
439
  gpio_init.GPIO_OType  = GPIO_OType_PP;
440
  gpio_init.GPIO_PuPd   = GPIO_PuPd_NOPULL;
441
  GPIO_Init(CHARGE_STAT2A_GPIO, &gpio_init);
442

    
443
  return;
444
} /*** end of initGpio ***/
445

    
446
/*
447
 * Initialize all EXTI lines
448
 */
449
static void initExti() {
450
  /* configure EXTI lines */
451
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOB, EXTI_PinSource0); // IR_INT1_N
452
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOC, EXTI_PinSource0); // CHARGE_STAT1A
453
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOC, EXTI_PinSource1); // GAUGE_BATLOW1
454
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOC, EXTI_PinSource2); // GAUGE_BATGD1_N
455
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOB, EXTI_PinSource3); // SYS_UART_DN
456
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOB, EXTI_PinSource4); // CHARGE_STAT2A
457
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOC, EXTI_PinSource4); // IR_INT2_N
458
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOC, EXTI_PinSource5); // TOUCH_INT_N
459
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOB, EXTI_PinSource6); // GAUGE_BATLOW2
460
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOB, EXTI_PinSource7); // GAUGE_BATGD2_N
461
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOC, EXTI_PinSource8); // PATH_DC
462
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOC, EXTI_PinSource9); // SYS_SPI_DIR
463
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOC, EXTI_PinSource12); // SYS_SYNC_N
464
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOC, EXTI_PinSource13); // SYS_PD_N
465
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOC, EXTI_PinSource14); // SYS_WARMRST_N
466
  SYSCFG_EXTILineConfig(EXTI_PortSourceGPIOB, EXTI_PinSource15); // SYS_UART_UP
467

    
468
  return;
469
} /*** end of initExti ***/
470

    
471
/*
472
 * Signals, which type of low-power mode the system shall enter after the shutdown sequence.
473
 */
474
ErrorStatus shutdownDisambiguationProcedure(const uint8_t type) {
475
  GPIO_SetBits(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN);
476
  ErrorStatus ret_val = ERROR;
477

    
478
  switch (type) {
479
    case BL_SHUTDOWN_PRI_RSN_UNKNOWN:
480
    case BL_SHUTDOWN_PRI_RSN_HIBERNATE:
481
    case BL_SHUTDOWN_PRI_RSN_DEEPSLEEP:
482
    case BL_SHUTDOWN_PRI_RSN_TRANSPORT:
483
    {
484
      // broadcast a number of pulses, depending on the argument
485
      uint8_t pulse_counter = 0;
486
      for (pulse_counter = 0; pulse_counter < type; ++pulse_counter) {
487
        msleep(1);
488
        GPIO_ResetBits(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN);
489
        msleep(1);
490
        GPIO_SetBits(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN);
491
      }
492
      // wait for timeout
493
      msleep(10);
494
      ret_val = SUCCESS;
495
      break;
496
    }
497
    case BL_SHUTDOWN_PRI_RSN_RESTART:
498
    {
499
      // since there is no ambiguity for restart requests, no pulses are generated
500
      msleep(10);
501
      ret_val = SUCCESS;
502
      break;
503
    }
504
    default:
505
      ret_val = ERROR;
506
      break;
507
  }
508

    
509
  return ret_val;
510
} /*** end of shutdownDisambiguationProcedure ***/
511

    
512
/*
513
 * Final shutdown of the system to enter transportation mode.
514
 */
515
void shutdownToTransportation() {
516
  /* configure some criticpal GPIOs as input
517
   * This is required, because otherwise some hardware might be powered through these signals */
518
  configGpioForShutdown();
519

    
520
  /* power down the system */
521
  systemPowerDown();
522

    
523
  /* deactivate the WKUP pin */
524
  PWR_WakeUpPinCmd(DISABLE);
525

    
526
  /* deactivate any RTC related events */
527
  RTC_WakeUpCmd(DISABLE);
528
  RTC_TamperCmd(RTC_Tamper_1, DISABLE);
529
  RTC_TimeStampCmd(RTC_TimeStampEdge_Rising, DISABLE);
530
  RTC_TimeStampCmd(RTC_TimeStampEdge_Falling, DISABLE);
531
  RTC_ClearFlag(~0);
532

    
533
  /* disable the IWDG */
534
  IWDG_ReloadCounter();
535

    
536
  /* write some information to the backup register */
537
  blBackupRegister_t backup;
538
  backup.shutdown_pri_reason = BL_SHUTDOWN_PRI_RSN_TRANSPORT;
539
  backup.shutdown_sec_reason = BL_SHUTDOWN_SEC_RSN_UNKNOWN;
540
  backup.wakeup_pri_reason = BL_WAKEUP_PRI_RSN_UNKNOWN;
541
  backup.wakeup_sec_reason = BL_WAKEUP_SEC_RSN_UNKNOWN;
542
  PWR_BackupAccessCmd(ENABLE);
543
  RTC_WriteBackupRegister(BL_RTC_BACKUP_REG, backup.raw);
544

    
545
  /* morse 'OK' via the LED to signal that shutdown was successful */
546
  blinkOK(1);
547

    
548
  /* enter standby mode */
549
  PWR_EnterSTANDBYMode();
550

    
551
  return;
552
} /*** end of shutdownToTransportation ***/
553

    
554
/*
555
 * Final shutdown of the system to enter deepsleep mode.
556
 */
557
void shutdownToDeepsleep() {
558
  /* configure some criticpal GPIOs as input
559
   * This is required, because otherwise some hardware might be powered through these signals */
560
  configGpioForShutdown();
561

    
562
  /* power down the system */
563
  systemPowerDown();
564

    
565
  /* activate the WKUP pin */
566
  PWR_WakeUpPinCmd(ENABLE);
567

    
568
  /*
569
   * Configuration of RTC and IWDG belongs to the OS.
570
   */
571

    
572
  /* write some information to the backup register */
573
  blBackupRegister_t backup;
574
  backup.shutdown_pri_reason = BL_SHUTDOWN_PRI_RSN_DEEPSLEEP;
575
  backup.shutdown_sec_reason = BL_SHUTDOWN_SEC_RSN_UNKNOWN;
576
  backup.wakeup_pri_reason = BL_WAKEUP_PRI_RSN_UNKNOWN;
577
  backup.wakeup_sec_reason = BL_WAKEUP_SEC_RSN_UNKNOWN;
578
  PWR_BackupAccessCmd(ENABLE);
579
  RTC_WriteBackupRegister(BL_RTC_BACKUP_REG, backup.raw);
580

    
581
  /* morse 'OK' via the LED to signal that shutdown was successful */
582
  blinkOK(1);
583

    
584
  /* enter standby mode or restart the system in case a power plug is already present */
585
  if (GPIO_ReadInputDataBit(PATH_DC_GPIO, PATH_DC_PIN) != Bit_SET) {
586
    PWR_EnterSTANDBYMode();
587
  } else {
588
    NVIC_SystemReset();
589
  }
590

    
591
  return;
592
} /*** end of shutdownToDeepsleep ***/
593

    
594
/*
595
 * Final shutdown of the system to enter hibernate mode.
596
 */
597
void shutdownToHibernate() {
598
  /* configure some criticpal GPIOs as input
599
   * This is required, because otherwise some hardware might be powered through these signals */
600
  configGpioForShutdown();
601

    
602
  /* power down the system */
603
  systemPowerDown();
604

    
605
  /* write some information to the backup register */
606
  blBackupRegister_t backup;
607
  backup.shutdown_pri_reason = BL_SHUTDOWN_PRI_RSN_HIBERNATE;
608
  backup.shutdown_sec_reason = BL_SHUTDOWN_SEC_RSN_UNKNOWN;
609
  backup.wakeup_pri_reason = BL_WAKEUP_PRI_RSN_UNKNOWN;
610
  backup.wakeup_sec_reason = BL_WAKEUP_SEC_RSN_UNKNOWN;
611
  PWR_BackupAccessCmd(ENABLE);
612
  RTC_WriteBackupRegister(BL_RTC_BACKUP_REG, backup.raw);
613

    
614
  /* morse 'OK' via the LED to signal that shutdown was successful */
615
  blinkOK(1);
616

    
617
  /* reset the MCU */
618
  NVIC_SystemReset();
619

    
620
  return;
621
} /*** end of shutdownToHibernate ***/
622

    
623
/*
624
 * Final shutdown of the system and restart.
625
 */
626
void shutdownAndRestart() {
627
  /* configure some criticpal GPIOs as input
628
   * This is required, because otherwise some hardware might be powered through these signals */
629
  configGpioForShutdown();
630

    
631
  /* power down the system */
632
  systemPowerDown();
633

    
634
  /* write some information to the backup register */
635
  blBackupRegister_t backup;
636
  backup.shutdown_pri_reason = BL_SHUTDOWN_PRI_RSN_RESTART;
637
  backup.shutdown_sec_reason = BL_SHUTDOWN_SEC_RSN_UNKNOWN;
638
  backup.wakeup_pri_reason = BL_WAKEUP_PRI_RSN_UNKNOWN;
639
  backup.wakeup_sec_reason = BL_WAKEUP_SEC_RSN_UNKNOWN;
640
  PWR_BackupAccessCmd(ENABLE);
641
  RTC_WriteBackupRegister(BL_RTC_BACKUP_REG, backup.raw);
642

    
643
  /* morse 'OK' via the LED to signal that shutdown was successful */
644
  blinkOK(1);
645

    
646
  /* reset the MCU */
647
  NVIC_SystemReset();
648

    
649
  return;
650
} /*** end of shutdownAndRestart ***/
651

    
652
/*
653
 * Configures some GPIO pins as inputs for safety reasons.
654
 * Under certain circumstances, these pins might power hardware that is supposed to be shut down.
655
 */
656
void configGpioForShutdown() {
657
  /* setup the configuration */
658
  GPIO_InitTypeDef gpio_init;
659
  gpio_init.GPIO_Mode   = GPIO_Mode_IN;
660
  gpio_init.GPIO_Speed  = GPIO_Speed_50MHz;
661
  gpio_init.GPIO_OType  = GPIO_OType_PP;
662
  gpio_init.GPIO_PuPd   = GPIO_PuPd_NOPULL;
663

    
664
  /* configure SYS_UART_TX */
665
  gpio_init.GPIO_Pin = SYS_UART_TX_PIN;
666
  GPIO_Init(SYS_UART_TX_GPIO, &gpio_init);
667

    
668
  /* configure all SYS_SPI signals */
669
  gpio_init.GPIO_Pin = SYS_SPI_SS0_N_PIN;
670
  GPIO_Init(SYS_SPI_SS0_N_GPIO, &gpio_init);
671
  gpio_init.GPIO_Pin = SYS_SPI_SCLK_PIN;
672
  GPIO_Init(SYS_SPI_SCLK_GPIO, &gpio_init);
673
  gpio_init.GPIO_Pin = SYS_SPI_MISO_PIN;
674
  GPIO_Init(SYS_SPI_MISO_GPIO, &gpio_init);
675
  gpio_init.GPIO_Pin = SYS_SPI_MOSI_PIN;
676
  GPIO_Init(SYS_SPI_MOSI_GPIO, &gpio_init);
677
  gpio_init.GPIO_Pin = SYS_SPI_SS1_N_PIN;
678
  GPIO_Init(SYS_SPI_SS1_N_GPIO, &gpio_init);
679
  gpio_init.GPIO_Pin = SYS_SPI_DIR_PIN;
680
  GPIO_Init(SYS_SPI_DIR_GPIO, &gpio_init);
681

    
682
  /* configure CAN_TX */
683
  gpio_init.GPIO_Pin = CAN_TX_PIN;
684
  GPIO_Init(CAN_TX_GPIO, &gpio_init);
685

    
686
  /* configure all Bluetooth signals */
687
  gpio_init.GPIO_Pin = BT_CTS_PIN;
688
  GPIO_Init(BT_CTS_GPIO, &gpio_init);
689
  gpio_init.GPIO_Pin = BT_RX_PIN;
690
  GPIO_Init(BT_RX_GPIO, &gpio_init);
691

    
692
  return;
693
} /*** end of configGpioForShutdown ***/
694

    
695
/*
696
 * Disables all regulated voltages and finally cuts power to the rest of the system.
697
 */
698
void systemPowerDown() {
699
  setLed(BLT_TRUE);
700

    
701
  /* make sure that all other modules are shut down */
702
  msleep(10);
703

    
704
  /* reset slave modules */
705
  GPIO_ResetBits(SYS_WARMRST_N_GPIO, SYS_WARMRST_N_PIN);
706

    
707
  /* disable voltage regulators */
708
  GPIO_ResetBits(SYS_REG_EN_GPIO, SYS_REG_EN_PIN);
709

    
710
  /* cut power */
711
  GPIO_ResetBits(POWER_EN_GPIO, POWER_EN_PIN);
712

    
713
  /* make sure, all capacitors are discharged */
714
  msleep(100);
715

    
716
  setLed(BLT_FALSE);
717

    
718
  return;
719
} /*** end of systemPowerDown ***/
720

    
721
/*
722
 * Cofigures the independent watchdog (IWDG) to fire after the specified time when it is enabled.
723
 * The argument is the requested time in milliseconds.
724
 * The time that was actually set for the IWDG is returned by the function (again in milliseconds).
725
 * In some cases the returned value might differ from the requested one, but if so, it will alwyas be smaller.
726
 * Although the IWDG provides higher resolutions than milliseconds, these are not supported by this function.
727
 */
728
uint16_t configIwdg(const uint16_t ms) {
729
  /* apply an upper bound to the ms argument */
730
  uint16_t ms_capped = (ms >= 0x8000) ? 0x7FFF : ms;
731

    
732
  /* detect the best fitting prescaler and compute the according reload value */
733
  uint8_t prescaler = 0;
734
  uint16_t reload_val = 0;
735
  if (ms_capped >= 0x4000) {
736
    prescaler = IWDG_Prescaler_256;
737
    reload_val = ms_capped >> 3;  // note: this corresponds to a floor function
738
    ms_capped = reload_val << 3;  // this applies the floor function to ms_capped
739
  } else if (ms_capped >= 0x2000) {
740
    prescaler = IWDG_Prescaler_128;
741
    reload_val = ms_capped >> 2;  // note: this corresponds to a floor function
742
    ms_capped = reload_val << 2;  // this applies the floor function to ms_capped
743
  } else if (ms_capped >= 0x1000) {
744
    ms_capped &= ~(0x0001);
745
    prescaler = IWDG_Prescaler_64;
746
    reload_val = ms_capped >> 1;  // note: this corresponds to a floor function
747
    ms_capped = reload_val << 1;  // this applies the floor function to ms_capped
748
  } else {
749
    prescaler = IWDG_Prescaler_32;
750
    reload_val = ms_capped;
751
  }
752

    
753
  /* configure the IWDG */
754
  if (reload_val > 0) {
755
    IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);
756
    IWDG_SetPrescaler(prescaler);
757
    IWDG_SetReload(reload_val);
758
    IWDG_WriteAccessCmd(IWDG_WriteAccess_Disable);
759
  }
760

    
761
  return ms_capped;
762
} /*** end of configIWDG ***/
763

    
764
/*
765
 * System was reset via the NRST pin or the reason could not be detected.
766
 * In this case, everything is started up.
767
 * If an attempt for an OS update is detected, flashing mode is entered.
768
 * Otherwise, the system will boot the OS.
769
 */
770
ErrorStatus handleColdReset() {
771
  /* activate system power and wait some time to ensure stable voltages */
772
  setLed(BLT_TRUE);
773
  GPIO_SetBits(POWER_EN_GPIO, POWER_EN_PIN);
774
  msleep(10);
775
  GPIO_SetBits(SYS_REG_EN_GPIO, SYS_REG_EN_PIN);
776
  msleep(10);
777
  setLed(BLT_FALSE);
778

    
779
  /* drive SYS_WARMRST_N high (inactive) */
780
  GPIO_SetBits(SYS_WARMRST_N_GPIO, SYS_WARMRST_N_PIN);
781

    
782
  /* enable CAN clock
783
   * Note that CAN1 shares reception filters with CAN1 so for CAN2 the CAN1 peripheral also needs to be enabled. */
784
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_CAN2 | RCC_APB1Periph_CAN1, ENABLE);
785

    
786
  /* wait 1ms to make sure that all modules are running and started the bootloader */
787
  msleep(1);
788

    
789
  /* initialize the bootloader */
790
  BootInit();
791

    
792
  /* start the infinite program loop */
793
  uint32_t loopStartTime = 0;
794
  saTimerUpdate(&loopStartTime);
795
  uint32_t currentTime = loopStartTime;
796
  while (1)
797
  {
798
//    /* make the LED "double-blink" */
799
//    saTimerUpdate(&currentTime);
800
//    if (currentTime < loopStartTime + 50) {
801
//      setLed(BLT_TRUE);
802
//    } else if (currentTime < loopStartTime + 50+100) {
803
//      setLed(BLT_FALSE);
804
//    } else if (currentTime < loopStartTime + 50+100+50) {
805
//      setLed(BLT_TRUE);
806
//    } else if (currentTime < loopStartTime + 50+100+50+300) {
807
//      setLed(BLT_FALSE);
808
//    } else {
809
//      loopStartTime = currentTime;
810
//    }
811

    
812
    /* run the bootloader task */
813
    BootTask();
814

    
815
    /* check the SYS_PD_N signal */
816
    if (GPIO_ReadInputDataBit(SYS_PD_N_GPIO, SYS_PD_N_PIN) == Bit_RESET) {
817
      blCallbackHandleShutdownRequest();
818
      return SUCCESS;
819
    }
820
  }
821

    
822
  return ERROR;
823
} /*** end of handleColdReset ***/
824

    
825
/*
826
 * System was reset by software.
827
 * Depending on the argument, which was read from the 1st backup register (see main function) the effect of this function differs.
828
 * There are three cases that can occur:
829
 * - The system was reset to enter hibernate mode.
830
 *   In this case the system will enter a medium power saving mode (hibernate mode), but can be charged via the charging pins.
831
 *   The system can be woken up in the same way as in deepsleep mode (cf. blCallbackShutdownDeepsleep() function).
832
 * - The system was reset to reboot.
833
 *   In this case the system will restart in the same way as after a cold reset.
834
 * - The reason is unknown.
835
 *   This case will cause an error.
836
 */
837
ErrorStatus handleSoftwareReset() {
838
  /* action depends on original shutdown reason */
839
  switch (backup_reg.shutdown_pri_reason) {
840
    case BL_SHUTDOWN_PRI_RSN_HIBERNATE:
841
    {
842
      /* activate the WKUP pin */
843
      PWR_WakeUpPinCmd(ENABLE);
844

    
845
      /* deactivate any RTC related events */
846
      RTC_WakeUpCmd(DISABLE);
847
      RTC_TamperCmd(RTC_Tamper_1, DISABLE);
848
      RTC_TimeStampCmd(RTC_TimeStampEdge_Rising, DISABLE);
849
      RTC_TimeStampCmd(RTC_TimeStampEdge_Falling, DISABLE);
850

    
851
      /* configure the IWDG to wake the system from standby mode */
852
      uint16_t iwdg_ms = 1;
853
      if (GPIO_ReadInputDataBit(PATH_DC_GPIO, PATH_DC_PIN) != Bit_SET) {
854
        /* if a power plug is detected, fire immediately (1ms), else fire after the defined hibernate time */
855
        iwdg_ms = HIBERNATE_TIME_MS;
856
      }
857
      configIwdg(iwdg_ms);
858
      IWDG_Enable();
859

    
860
      /* enter standby mode */
861
      PWR_EnterSTANDBYMode();
862

    
863
      return SUCCESS;
864
      break;
865
    }
866
    case BL_SHUTDOWN_PRI_RSN_RESTART:
867
    {
868
      return handleColdReset();
869
      break;
870
    }
871
    case BL_SHUTDOWN_PRI_RSN_DEEPSLEEP:
872
    {
873
      if (GPIO_ReadInputDataBit(PATH_DC_GPIO, PATH_DC_PIN) == Bit_SET) {
874
        return handlePathDcWakeup();
875
      } else {
876
        blCallbackShutdownDeepsleep();
877
      }
878
      break;
879
    }
880
    default:
881
      return ERROR;
882
  }
883
  return ERROR;
884
} /*** end of handleSoftwareReset ***/
885

    
886
/*
887
 * System was woken up via the WKUP pin and the SYS_UART_DN signal was found to be responsible.
888
 * In this case, the system starts as after a cold reset.
889
 * this function is identical to handleTouchWakeup().
890
 */
891
ErrorStatus handleUartDnWakeup() {
892
  return handleColdReset();
893
} /*** end of hanldeUartDnWakeup ***/
894

    
895
/*
896
 * System was woken up via the WKUP pin and the PATH_DC signal was found to be responsible.
897
 * If the system was woken from deepsleep mode, it will enter hibernate mode to enable charging as long as the power plug is present.
898
 * In any other case, the system will just enter the previous low-power mode again.
899
 */
900
ErrorStatus handlePathDcWakeup() {
901
  /* reenter the previous low-power mode */
902
  switch (backup_reg.shutdown_pri_reason) {
903
    case BL_SHUTDOWN_PRI_RSN_HIBERNATE:
904
      blCallbackShutdownHibernate();
905
      return SUCCESS;
906
      break;
907
    case BL_SHUTDOWN_PRI_RSN_DEEPSLEEP:
908
      /* visualize that the power plug was detected
909
       * This is helpful for feedback, and required for the follwing reason:
910
       * When the power plug is detected, it takes some additional time for the ADC to detect a high voltage.
911
       * If the ADC detects a low voltage at the first attempt, the system will enter hibernate mode.
912
       * Thus, the ADC will measure the voltage again after several seconds and charging will start.
913
       * However, this behaviour does not meet the user expection.
914
       * Hence, the voltage has some to adapt at this point
915
       */
916
      setLed(BLT_TRUE);
917
      msleep(500);
918
      setLed(BLT_FALSE);
919

    
920
      return handleIwdgWakeup();
921
      break;
922
    case BL_SHUTDOWN_PRI_RSN_TRANSPORT:
923
      blCallbackShutdownTransportation();
924
      return SUCCESS;
925
      break;
926
    default:
927
      return ERROR;
928
      break;
929
  }
930

    
931
  return ERROR;
932
} /*** end of handlePathDcWakeup ***/
933

    
934
/*
935
 * System was woken up via the WKUP pin and the touch sensors were found to be responsible.
936
 * In this case the system starts as after an cold reset.
937
 * This function is identical to handleUartDnWakeup().
938
 */
939
ErrorStatus handleTouchWakeup() {
940
  return handleColdReset();
941
} /*** end of handleTouchWakeup ***/
942

    
943
/*
944
 * System was woken up via the IWDG.
945
 * In this case the ADC is configured and VSYS is measured once.
946
 * If VSYS is found to be high enough to charge the batteries, the system will stay active until VSYS drops or an EXTI event occurs.
947
 * Otherwise, the system will configure the IWDG to wake the system again after five seconds and enter standby mode.
948
 */
949
ErrorStatus handleIwdgWakeup() {
950
  /* handle different situations, depending on the backup data */
951
  if ((backup_reg.shutdown_pri_reason == BL_SHUTDOWN_PRI_RSN_HIBERNATE) ||
952
      (backup_reg.shutdown_pri_reason == BL_SHUTDOWN_PRI_RSN_DEEPSLEEP)) {
953
    /* handle periodic wakeup in hibernate mode and in deepsleep mode when a power plug was detetced */
954

    
955
    /* if in hibernate mode, indicate the DiWheelDrive to enter hibernate mode as well, so it will activate the charging pins */
956
    if (backup_reg.shutdown_pri_reason == BL_SHUTDOWN_PRI_RSN_HIBERNATE) {
957
      indicateHibernate();
958
    }
959

    
960
    /* measure the current voltage of VSYS */
961
    AdcSingleMeasurement();
962

    
963
    /* evaluate the value
964
     * The ADC value represents the analog voltage between Vref- (= GND = 0.0V) and Vref+ (= VDD = 3.3V) as 12-bit value.
965
     * Hence, the value read from the register is first scaled to [0V .. 3.3V].
966
     * Then, an additional factor 5.33 is applied to account the downscaling on the board.
967
     * Actually, the factor should be 5.0, but due to too large resistors it was corrected to 5.33.
968
     */
969
    if ( (((float)(ADC_GetConversionValue(ADC1)) / (float)(0x0FFF)) * 3.3f * 5.33f) < 9.0f ) {
970
      /* VSYS was found to be < 9V */
971

    
972
      /* re-enter power saving mode
973
       * If the system was shut down to deepsleep mode and the power plug was removed, re-enter deepsleep mode.
974
       * (This could be done earlier in this function, but since charging via the pins of the DeWheelDrive may be
975
       *  supported in the future, this is done after measuring VSYS)
976
       */
977
      if (backup_reg.shutdown_pri_reason == BL_SHUTDOWN_PRI_RSN_DEEPSLEEP &&
978
          GPIO_ReadInputDataBit(PATH_DC_GPIO, PATH_DC_PIN) == Bit_RESET) {
979
        blCallbackShutdownDeepsleep();
980
      } else {
981
        /* reconfigure the IWDG and power down for five seconds */
982
        configIwdg(HIBERNATE_TIME_MS);
983
        IWDG_Enable();
984

    
985
        /* enter standby mode */
986
        PWR_EnterSTANDBYMode();
987
      }
988

    
989
      return SUCCESS;
990
    } else {
991
      /* VSYS was found to be >= 9V */
992
      setLed(BLT_TRUE);
993

    
994
      /* charge the battieries */
995
      GPIO_ResetBits(CHARGE_EN1_N_GPIO, CHARGE_EN1_N_PIN);
996
      GPIO_ResetBits(CHARGE_EN2_N_GPIO, CHARGE_EN2_N_PIN);
997

    
998
      /* configure analog watchdoch to fire as soon as the voltage drops below 9V */
999
      ADC_DeInit();
1000
      setupADC(ADC1, (uint16_t)(9.0f / 5.33f / 3.3f * (float)0x0FFF), 0x0FFF);
1001

    
1002
      EXTI_InitTypeDef exti;
1003
      /* configure UART_DN EXTI */
1004
      exti.EXTI_Line = EXTI_Line3;
1005
      exti.EXTI_Mode = EXTI_Mode_Interrupt;
1006
      exti.EXTI_Trigger = EXTI_Trigger_Falling;
1007
      exti.EXTI_LineCmd = ENABLE;
1008
      EXTI_Init(&exti);
1009

    
1010
      /* configure TOUCH_INT_N EXTI */
1011
      exti.EXTI_Line = EXTI_Line5;
1012
      exti.EXTI_Mode = EXTI_Mode_Interrupt;
1013
      exti.EXTI_Trigger = EXTI_Trigger_Falling;
1014
      exti.EXTI_LineCmd = ENABLE;
1015
      EXTI_Init(&exti);
1016

    
1017
      /* configure PATH_DC EXTI */
1018
      if (backup_reg.shutdown_pri_reason == BL_SHUTDOWN_PRI_RSN_DEEPSLEEP) {
1019
        exti.EXTI_Line = EXTI_Line8;
1020
        exti.EXTI_Mode = EXTI_Mode_Interrupt;
1021
        exti.EXTI_Trigger = EXTI_Trigger_Falling;
1022
        exti.EXTI_LineCmd = ENABLE;
1023
        EXTI_Init(&exti);
1024
      }
1025

    
1026
      /* configure the NVIC so ADC and EXTI will be handled */
1027
      NVIC_InitTypeDef nvic;
1028
      nvic.NVIC_IRQChannel = ADC_IRQn;
1029
      nvic.NVIC_IRQChannelPreemptionPriority = 6;
1030
      nvic.NVIC_IRQChannelSubPriority = 6;
1031
      nvic.NVIC_IRQChannelCmd = ENABLE;
1032
      NVIC_Init(&nvic);
1033
      nvic.NVIC_IRQChannel = EXTI3_IRQn;
1034
      nvic.NVIC_IRQChannelPreemptionPriority = 6;
1035
      nvic.NVIC_IRQChannelSubPriority = 6;
1036
      nvic.NVIC_IRQChannelCmd = ENABLE;
1037
      NVIC_Init(&nvic);
1038
      NVIC_EnableIRQ(EXTI3_IRQn);
1039
      nvic.NVIC_IRQChannel = EXTI9_5_IRQn;
1040
      nvic.NVIC_IRQChannelPreemptionPriority = 6;
1041
      nvic.NVIC_IRQChannelSubPriority = 6;
1042
      nvic.NVIC_IRQChannelCmd = ENABLE;
1043
      NVIC_Init(&nvic);
1044
      NVIC_EnableIRQ(EXTI9_5_IRQn);
1045

    
1046
      /* activate the ADC */
1047
      ADC_SoftwareStartConv(ADC1);
1048

    
1049
      /* sleep until something happens */
1050
      __WFI();
1051

    
1052
      /* disable the chargers */
1053
      GPIO_SetBits(CHARGE_EN1_N_GPIO, CHARGE_EN1_N_PIN);
1054
      GPIO_SetBits(CHARGE_EN2_N_GPIO, CHARGE_EN2_N_PIN);
1055
      setLed(BLT_FALSE);
1056

    
1057
      /* evaluate wakeup reason */
1058
      // note: since I (tschoepp) don't know the difference between 'pending' and 'active' IRQs, both flags are ORed.
1059
      uint8_t wkup_rsn = BL_WAKEUP_SEC_RSN_UNKNOWN;
1060
      if ((NVIC_GetActive(ADC_IRQn) != 0 || NVIC_GetPendingIRQ(ADC_IRQn) != 0) &&
1061
          ADC_GetITStatus(ADC1, ADC_IT_AWD) == SET &&
1062
          ADC_GetFlagStatus(ADC1, ADC_FLAG_AWD) == SET) {
1063
        wkup_rsn |= BL_WAKEUP_SEC_RSN_VSYSLOW;
1064
      }
1065
      if ((NVIC_GetActive(EXTI3_IRQn) != 0 || NVIC_GetPendingIRQ(EXTI3_IRQn) != 0) &&
1066
          EXTI_GetFlagStatus(EXTI_Line3) == SET) {
1067
        wkup_rsn |= BL_WAKEUP_SEC_RSN_UART;
1068
      }
1069
      if ((NVIC_GetActive(EXTI9_5_IRQn) != 0 || NVIC_GetPendingIRQ(EXTI9_5_IRQn) != 0) &&
1070
          EXTI_GetFlagStatus(EXTI_Line5) == SET) {
1071
        wkup_rsn |= BL_WAKEUP_SEC_RSN_TOUCH;
1072
      }
1073
      if ((NVIC_GetActive(EXTI9_5_IRQn) != 0 || NVIC_GetPendingIRQ(EXTI9_5_IRQn) != 0) &&
1074
          EXTI_GetFlagStatus(EXTI_Line8) == SET) {
1075
        wkup_rsn |= BL_WAKEUP_SEC_RSN_PWRPLUG;
1076
      }
1077

    
1078
      /* since only the first interrupt will be handles, clear any pending ones */
1079
      NVIC_DisableIRQ(ADC_IRQn);
1080
      NVIC_DisableIRQ(EXTI3_IRQn);
1081
      NVIC_DisableIRQ(EXTI9_5_IRQn);
1082
      NVIC_ClearPendingIRQ(ADC_IRQn);
1083
      NVIC_ClearPendingIRQ(EXTI3_IRQn);
1084
      NVIC_ClearPendingIRQ(EXTI9_5_IRQn);
1085

    
1086
      /* clear all pending EXTI events */
1087
      EXTI_DeInit();
1088
      EXTI_ClearFlag(EXTI_Line3);
1089
      EXTI_ClearFlag(EXTI_Line5);
1090
      EXTI_ClearFlag(EXTI_Line8);
1091

    
1092
      /* make sure the LED was visibly turned off */
1093
      msleep(100);
1094

    
1095
      /* depending on the wakup reason, handle accordingly */
1096
      if (wkup_rsn & BL_WAKEUP_SEC_RSN_TOUCH) {
1097
        /* the system was interrupted via the TOUCH_INT_N signal */
1098

    
1099
        /* act as if this was a normal touch wakeup */
1100
        backup_reg.wakeup_pri_reason = BL_WAKEUP_PRI_RSN_WKUP;
1101
        backup_reg.wakeup_sec_reason = BL_WAKEUP_SEC_RSN_TOUCH;
1102
        RTC_WriteBackupRegister(BL_RTC_BACKUP_REG, backup_reg.raw);
1103
        return handleTouchWakeup();
1104
      } else if (wkup_rsn & BL_WAKEUP_SEC_RSN_UART) {
1105
        /* the system was interrupted via the SYS_UARTDN signal */
1106

    
1107
        /* act as if this was a normal UART wakeup */
1108
        backup_reg.wakeup_pri_reason = BL_WAKEUP_PRI_RSN_WKUP;
1109
        backup_reg.wakeup_sec_reason = BL_WAKEUP_SEC_RSN_UART;
1110
        RTC_WriteBackupRegister(BL_RTC_BACKUP_REG, backup_reg.raw);
1111
        return handleUartDnWakeup();
1112
      } else if (wkup_rsn & BL_WAKEUP_SEC_RSN_VSYSLOW) {
1113
        /* VSYS has dropped below 9V */
1114

    
1115
        /* depending on the original reason for shutdown, act differenty */
1116
        switch (backup_reg.shutdown_pri_reason) {
1117
          case BL_SHUTDOWN_PRI_RSN_HIBERNATE:
1118
          {
1119
            blCallbackShutdownHibernate();
1120
            return SUCCESS;
1121
          }
1122
          case BL_SHUTDOWN_PRI_RSN_DEEPSLEEP:
1123
          {
1124
            NVIC_SystemReset();
1125
            return SUCCESS;
1126
          }
1127
          default:
1128
            return ERROR;
1129
        }
1130
      } else if (wkup_rsn & BL_WAKEUP_SEC_RSN_PWRPLUG) {
1131
        /* system was interrupted because the power plug was removed
1132
         * note: when a power cord is plugged in, this will not trigger an interrupt because the NVIC is configured for a falling edge only */
1133
        if (backup_reg.shutdown_pri_reason == BL_SHUTDOWN_PRI_RSN_DEEPSLEEP) {
1134
          blCallbackShutdownDeepsleep();
1135
          return SUCCESS;
1136
        } else {
1137
          /* this state is undefined, because the PATH_DC inerrupt is only configured when the primary shutdown reason was to enter deepsleep mode */
1138
          return ERROR;
1139
        }
1140
      } else {
1141
        /* the system was interrupted for an unknown reason */
1142
        return ERROR;
1143
      }
1144
    } // end of ADC evaluation
1145
  } else {
1146
    /* since it is unknown why the IWDG was configured, act as after a cold reset */
1147
    return handleColdReset();
1148
  }
1149

    
1150
  return ERROR;
1151
} /*** end of handleIwdgWakeup ***/
1152

    
1153
/*
1154
 * Indicates the DiWheelDrive module to enter hibernate mode at wakeup.
1155
 * This function should be called quite at the beginning of the according handleXXXReset/Wakeup() methods.
1156
 */
1157
static void indicateHibernate() {
1158
  /* signal the DiWheelDrive to enter hibernate mode as well, so it will activate the charging pins */
1159
  GPIO_ResetBits(SYS_UART_DN_GPIO, SYS_UART_DN_PIN);
1160
  msleep(10); // this must be that long, because the DiWheelDrive sleeps some time before evaluating any signals
1161
  GPIO_SetBits(SYS_UART_DN_GPIO, SYS_UART_DN_PIN);
1162

    
1163
  /* if the DiWheeDrive needs some time for setup it may pull down the signal */
1164
  waitForSignal(SYS_UART_DN_GPIO, SYS_UART_DN_PIN, Bit_SET);
1165

    
1166
  return;
1167
} /*** end of indicateHibernate ***/
1168

    
1169
/*
1170
 *Performs a one-shot measurement of the VSYS voltage.
1171
 */
1172
static void AdcSingleMeasurement() {
1173
  /* reset and initialize ADC for single-shot measurement */
1174
//    ADC_DeInit();
1175
  setupADC(ADC1, 0, 0);
1176

    
1177
  /* initialize the NVIC so ADC interrupts are handled */
1178
  NVIC_InitTypeDef nvic;
1179
  nvic.NVIC_IRQChannel = ADC_IRQn;
1180
  nvic.NVIC_IRQChannelPreemptionPriority = 6;
1181
  nvic.NVIC_IRQChannelSubPriority = 6;
1182
  nvic.NVIC_IRQChannelCmd = ENABLE;
1183
  NVIC_Init(&nvic);
1184

    
1185
  /* measure the voltage once */
1186
  setLed(BLT_TRUE);
1187
  ADC_ClearITPendingBit(ADC1, ADC_IT_EOC);
1188
  ADC_ClearFlag(ADC1, ADC_FLAG_EOC);
1189
  NVIC_EnableIRQ(ADC_IRQn);
1190
  ADC_SoftwareStartConv(ADC1);
1191
  while (ADC_GetITStatus(ADC1, ADC_IT_EOC) != SET && ADC_GetFlagStatus(ADC1, ADC_FLAG_EOC) != SET) {
1192
    __WFI();
1193
  }
1194
  NVIC_DisableIRQ(ADC_IRQn);
1195
  ADC_ClearITPendingBit(ADC1, ADC_IT_EOC);
1196
  ADC_ClearFlag(ADC1, ADC_FLAG_EOC);
1197
  NVIC_ClearPendingIRQ(ADC_IRQn);
1198
  setLed(BLT_FALSE);
1199

    
1200
  return;
1201
} /*** end of AdcSingleMeasurement ***/
1202

    
1203
/*
1204
 * Configures the ADC for measuring VSYS.
1205
 * ADCx is the ADC object to initialize.
1206
 * low_th and high_th are the threshold values for the analog watchdor (must be 12-bit!).
1207
 * If low_th >= high_th, the ADC is configured for single-shot measurements.
1208
 * Otherwise, the watchdog is configured with the corresponding thresholds.
1209
 */
1210
ADC_TypeDef* setupADC(ADC_TypeDef* adc, const uint16_t low_th, const uint16_t high_th) {
1211
  /* evaluate the arguments */
1212
  blt_bool awd_enable = BLT_FALSE;
1213
  if (low_th < high_th) {
1214
    awd_enable = BLT_TRUE;
1215
  }
1216

    
1217
  /* enable the clock */
1218
  RCC_APB2PeriphClockCmd(RCC_APB2Periph_ADC1, ENABLE);
1219

    
1220
  /* enable the ADC (wakes it from low-power mode) */
1221
  ADC_Cmd(adc, ENABLE);
1222

    
1223
  /* initialize the common registers */
1224
  ADC_CommonInitTypeDef adc_cinit;
1225
  ADC_CommonStructInit(&adc_cinit);
1226
  adc_cinit.ADC_Prescaler = ADC_Prescaler_Div8; // clock as slow as possible
1227
  ADC_CommonInit(&adc_cinit);
1228

    
1229
  /* initialize the ADC */
1230
  ADC_InitTypeDef adc_init;
1231
  ADC_StructInit(&adc_init);
1232
  adc_init.ADC_ContinuousConvMode = (awd_enable == BLT_TRUE) ? ENABLE : DISABLE;
1233
  ADC_Init(adc, &adc_init);
1234

    
1235
  /* disable internal sensors */
1236
  ADC_TempSensorVrefintCmd(DISABLE);
1237
  ADC_VBATCmd(DISABLE);
1238

    
1239
  /* configure ADC channel and speed */
1240
  ADC_RegularChannelConfig(adc, ADC_Channel_9, 1, ADC_SampleTime_480Cycles);
1241
  ADC_EOCOnEachRegularChannelCmd(adc, (awd_enable == BLT_TRUE) ? DISABLE : ENABLE);
1242
  ADC_DiscModeCmd(adc, DISABLE);
1243

    
1244
  /* disable DMA */
1245
  ADC_DMACmd(adc, DISABLE);
1246

    
1247
  /* disable injected mode */
1248
  ADC_AutoInjectedConvCmd(adc, DISABLE);
1249
  ADC_InjectedDiscModeCmd(adc, DISABLE);
1250

    
1251
  /* configure the analog watchdog */
1252
  if (awd_enable == BLT_TRUE) {
1253
    ADC_AnalogWatchdogSingleChannelConfig(adc, ADC_Channel_9);
1254
    ADC_AnalogWatchdogThresholdsConfig(adc, high_th, low_th);
1255
    ADC_AnalogWatchdogCmd(adc, ADC_AnalogWatchdog_SingleRegEnable);
1256
  } else {
1257
    ADC_AnalogWatchdogCmd(adc, ADC_AnalogWatchdog_None);
1258
  }
1259

    
1260
  /* configure the interrupts to be generated by the ADC */
1261
  ADC_ITConfig(adc, ADC_IT_EOC, (awd_enable == BLT_TRUE) ? DISABLE : ENABLE);
1262
  ADC_ITConfig(adc, ADC_IT_AWD, (awd_enable == BLT_TRUE) ? ENABLE : DISABLE);
1263
  ADC_ITConfig(adc, ADC_IT_JEOC, DISABLE);
1264
  ADC_ITConfig(adc, ADC_IT_OVR, DISABLE);
1265

    
1266
  return adc;
1267
}
1268

    
1269
/*
1270
 * Callback function that handles the system shutdown and enters transportation mode.
1271
 * When called from a multithreaded environment, it must be ensured that no other thread will preempt this function.
1272
 * In transportation low-power mode the system can only be woken up by pulling down the NRST signal.
1273
 * Furthermore, the system can not be charged when in transportation mode.
1274
 */
1275
void blCallbackShutdownTransportation(void) {
1276
  /* make sure that the required clocks are activated */
1277
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD, ENABLE);
1278
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
1279

    
1280
  /* set/keep the SYS_SYNC and SYS_PD signals active */
1281
  GPIO_ResetBits(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN);
1282
  GPIO_ResetBits(SYS_PD_N_GPIO, SYS_PD_N_PIN);
1283

    
1284
  /* initialized the standalone timer */
1285
  saTimerInit();
1286

    
1287
  setLed(BLT_TRUE);
1288

    
1289
  /* wait for all boards to be ready for shutdown */
1290
  GPIO_SetBits(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN);
1291
  if (GPIO_ReadOutputDataBit(SYS_REG_EN_GPIO, SYS_REG_EN_PIN) == Bit_SET) {
1292
    // this must skipped if the pullup voltage (VIO3.3) is not active
1293
    setLed(BLT_TRUE);
1294
    waitForSignal(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN, Bit_SET);
1295
    setLed(BLT_FALSE);
1296
  }
1297

    
1298
  /* execute disambiguation procedure and signal all modules to enter transportation mode */
1299
  if (shutdownDisambiguationProcedure(BL_SHUTDOWN_PRI_RSN_TRANSPORT) != SUCCESS) {
1300
    blinkSOS(1);
1301
    msleep(10);
1302
  }
1303

    
1304
  shutdownToTransportation();
1305

    
1306
  return;
1307
} /*** end of blCallbackTransportation ***/
1308

    
1309
/*
1310
 * Callback function that handles the system shutdown and enters deepsleep mode.
1311
 * When called from a multithreaded environment, it must be ensured that no other thread will preempt this function.
1312
 * In deepsleep low-power mode the system can only be woken up via the NRST or the WKUP signal, or the RTC or IWDG, if configured.
1313
 * When a power plug is detected, the system will switch to hibernate mode, to provide charging capabilities (cf. handlePathDcWakeup()).
1314
 * As soon as the plug is removed again, however, the system will return to deppsleep mode (cf. handleIwdgWakeup()).
1315
 */
1316
void blCallbackShutdownDeepsleep(void) {
1317
  /* make sure that the required clocks are activated */
1318
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD, ENABLE);
1319
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
1320

    
1321
  /* set/keep the SYS_SYNC and SYS_PD signals active */
1322
  GPIO_ResetBits(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN);
1323
  GPIO_ResetBits(SYS_PD_N_GPIO, SYS_PD_N_PIN);
1324

    
1325
  /* initialized the standalone timer */
1326
  saTimerInit();
1327

    
1328
  setLed(BLT_TRUE);
1329

    
1330
  /* wait for all boards to be ready for shutdown */
1331
  GPIO_SetBits(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN);
1332
  if (GPIO_ReadOutputDataBit(SYS_REG_EN_GPIO, SYS_REG_EN_PIN) == Bit_SET) {
1333
    // this must skipped if the pullup voltage (VIO3.3) is not active
1334
    setLed(BLT_TRUE);
1335
    waitForSignal(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN, Bit_SET);
1336
    setLed(BLT_FALSE);
1337
  }
1338

    
1339
  /* execute disambiguation procedure and signal all modules to enter deepsleep mode */
1340
  if (shutdownDisambiguationProcedure(BL_SHUTDOWN_PRI_RSN_DEEPSLEEP) != SUCCESS) {
1341
    blinkSOS(1);
1342
    msleep(10);
1343
  }
1344

    
1345
  shutdownToDeepsleep();
1346

    
1347
  return;
1348
} /*** end of blCallbackDeepsleep ***/
1349

    
1350
/*
1351
 * Callback function that handles the system shutdown and enters hibernate mode.
1352
 * When called from a multithreaded environment, it must be ensured that no other thread will preempt this function.
1353
 * Since this function actually just configures the system in a way, that it will enter hibernate mode after the next reset and rests it,
1354
 * see the handleSoftwareReset() function for more details about the hibernate low-power mode.
1355
 */
1356
void blCallbackShutdownHibernate(void) {
1357
  /* make sure that the required clocks are activated */
1358
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD, ENABLE);
1359
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
1360

    
1361
  /* set/keep the SYS_SYNC and SYS_PD signals active */
1362
  GPIO_ResetBits(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN);
1363
  GPIO_ResetBits(SYS_PD_N_GPIO, SYS_PD_N_PIN);
1364

    
1365
  /* initialized the standalone timer */
1366
  saTimerInit();
1367

    
1368
  setLed(BLT_TRUE);
1369

    
1370
  /* wait for all boards to be ready for shutdown */
1371
  GPIO_SetBits(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN);
1372
  if (GPIO_ReadOutputDataBit(SYS_REG_EN_GPIO, SYS_REG_EN_PIN) == Bit_SET) {
1373
    // this must skipped if the pullup voltage (VIO3.3) is not active
1374
    setLed(BLT_TRUE);
1375
    waitForSignal(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN, Bit_SET);
1376
    setLed(BLT_FALSE);
1377
  }
1378

    
1379
  /* execute disambiguation procedure and signal all modules to enter hibernate mode */
1380
  if (shutdownDisambiguationProcedure(BL_SHUTDOWN_PRI_RSN_DEEPSLEEP) != SUCCESS) {
1381
    blinkSOS(1);
1382
    msleep(10);
1383
  }
1384

    
1385
  shutdownToHibernate();
1386

    
1387
  return;
1388
} /*** end of blCallbackShutdownHibernate ***/
1389

    
1390
/*
1391
 * Callback function that handles the system shutdown and initializes a restart.
1392
 * When called from a multithreaded environment, it must be ensured that no other thread will preempt this function.
1393
 * By configuration it is ensured, that the system will end up executing the handleSoftwareReset() function after reset.
1394
 */
1395
void blCallbackShutdownRestart(void) {
1396
  /* make sure that the required clocks are activated */
1397
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD, ENABLE);
1398
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
1399

    
1400
  /* set/keep the SYS_SYNC and SYS_PD signals active */
1401
  GPIO_ResetBits(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN);
1402
  GPIO_ResetBits(SYS_PD_N_GPIO, SYS_PD_N_PIN);
1403

    
1404
  /* initialized the standalone timer */
1405
  saTimerInit();
1406

    
1407
  setLed(BLT_TRUE);
1408

    
1409
  /* deactivate SYS_PD_N and ensure that all modules had a chance to detect the falling edge */
1410
  msleep(1);
1411
  GPIO_SetBits(SYS_PD_N_GPIO, SYS_PD_N_PIN);
1412
  msleep(1);
1413

    
1414
  /* wait for all boards to be ready for shutdown */
1415
  GPIO_SetBits(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN);
1416
  if (GPIO_ReadOutputDataBit(SYS_REG_EN_GPIO, SYS_REG_EN_PIN) == Bit_SET) {
1417
    // this must skipped if the pullup voltage (VIO3.3) is not active
1418
    setLed(BLT_TRUE);
1419
    waitForSignal(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN, Bit_SET);
1420
    setLed(BLT_FALSE);
1421
  }
1422

    
1423
  /* execute disambiguation procedure and signal all modules to restart normally */
1424
  if (shutdownDisambiguationProcedure(BL_SHUTDOWN_PRI_RSN_RESTART) != SUCCESS) {
1425
    blinkSOS(1);
1426
    msleep(10);
1427
  }
1428

    
1429
  /* restart the system */
1430
  shutdownAndRestart();
1431

    
1432
  return;
1433
} /*** end of blCallbackRestart ***/
1434

    
1435
/*
1436
 * Callback function that handles a system shutdown/restart request from another module.
1437
 * Depending on the result of the disambiguation procedure, the module will enter the according low-power mode or restart.
1438
 * When called from a multithreaded environment, it must be ensured that no other thread will preempt this function.
1439
 */
1440
void blCallbackHandleShutdownRequest(void) {
1441
  /* make sure that the required clocks are activated */
1442
  RCC_AHB1PeriphClockCmd(RCC_AHB1Periph_GPIOA | RCC_AHB1Periph_GPIOB | RCC_AHB1Periph_GPIOC | RCC_AHB1Periph_GPIOD, ENABLE);
1443
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR, ENABLE);
1444

    
1445
  /* set/keep the SYS_SYNC and SYS_PD signals active */
1446
  GPIO_ResetBits(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN);
1447
  GPIO_ResetBits(SYS_PD_N_GPIO, SYS_PD_N_PIN);
1448

    
1449
  /* initialized the standalone timer */
1450
  saTimerInit();
1451

    
1452
  setLed(BLT_TRUE);
1453

    
1454
  /* deactivate SYS_PD_N and ensure that all modules had a chance to detect the falling edge */
1455
  msleep(1);
1456
  GPIO_SetBits(SYS_PD_N_GPIO, SYS_PD_N_PIN);
1457
  msleep(1);
1458

    
1459
  /* wait for all boards to be ready for shutdown */
1460
  GPIO_SetBits(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN);
1461
  if (GPIO_ReadOutputDataBit(SYS_REG_EN_GPIO, SYS_REG_EN_PIN) == Bit_SET) {
1462
    // this must be skipped if the pullup voltage (VIO3.3) is not active
1463
    setLed(BLT_TRUE);
1464
    waitForSignal(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN, Bit_SET);
1465
    setLed(BLT_FALSE);
1466
  }
1467

    
1468
  /* check ths SYS_PD_N signal, whether the system shall shutdown or restart */
1469
  blt_bool shutdown_nrestart = (GPIO_ReadInputDataBit(SYS_PD_N_GPIO, SYS_PD_N_PIN) == Bit_RESET) ? BLT_TRUE : BLT_FALSE;
1470

    
1471
  /* disambiguation procedure (passive) */
1472
  uint32_t pulse_counter = 0;
1473
  while (waitForSignalTimeout(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN, Bit_RESET, 10)) {
1474
    waitForSignal(SYS_SYNC_N_GPIO, SYS_SYNC_N_PIN, Bit_SET);
1475
    ++pulse_counter;
1476
  }
1477

    
1478
  /* evaluate and hanlde disambiguation result */
1479
  if (shutdown_nrestart == BLT_TRUE) {
1480
    /* shutdown request */
1481

    
1482
    /* handle special cases */
1483
    if (pulse_counter == BL_SHUTDOWN_PRI_RSN_UNKNOWN) {
1484
      /* no pulse at all was received */
1485
      pulse_counter = BL_SHUTDOWN_PRI_RSN_DEFAULT;
1486
    } else if (pulse_counter != BL_SHUTDOWN_PRI_RSN_HIBERNATE &&
1487
               pulse_counter != BL_SHUTDOWN_PRI_RSN_DEEPSLEEP &&
1488
               pulse_counter != BL_SHUTDOWN_PRI_RSN_TRANSPORT) {
1489
      /* invalid number of pulses received */
1490
      blinkSOS(1);
1491
      pulse_counter = BL_SHUTDOWN_PRI_RSN_DEFAULT;
1492
    }
1493

    
1494
    switch (pulse_counter) {
1495
      case BL_SHUTDOWN_PRI_RSN_HIBERNATE:
1496
        shutdownToHibernate();
1497
        break;
1498
      case BL_SHUTDOWN_PRI_RSN_DEEPSLEEP:
1499
        shutdownToDeepsleep();
1500
        break;
1501
      case BL_SHUTDOWN_PRI_RSN_TRANSPORT:
1502
        shutdownToTransportation();
1503
        break;
1504
    }
1505
  } else {
1506
    /* restart request */
1507

    
1508
    /* there is no ambiguity for restart, so it is ignored */
1509
    shutdownAndRestart();
1510
  }
1511

    
1512
  /* if this code is reached, the system did neither shut down, nor restart.
1513
   * This must never be the case!
1514
   */
1515
  blinkSOSinf();
1516
  return;
1517
} /*** end of blCallbackHandleShutdownRequest ***/
1518

    
1519
/*********************************** end of main.c *************************************/