/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * Copyright (c) 2024 STMicroelectronics.
  * All rights reserved.
  *
  * This software is licensed under terms that can be found in the LICENSE file
  * in the root directory of this software component.
  * If no LICENSE file comes with this software, it is provided AS-IS.
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "adc.h"
#include "dma.h"
#include "rtc.h"
#include "tim.h"
#include "usart.h"
#include "gpio.h"

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include "stdlib.h"
#include "stdio.h"
#include "string.h"
#include "lora_comm.h"
#include "stm32f0xx_hal_rtc.h"
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */

/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */
#define ENABLE_RTC_ALARM 1
#define ENABLE_SRAND_DELAY 1
#define ENABLE_TIMER_COUNT 1
#define ENABLE_TIMER_CALLBACK 0

#define ENABLE_UART1_DEBUG 0

#define DEV_MAC "01:02:03:04"

#define MAC_ADDR_CHAR_1 'A'
#define MAC_ADDR_CHAR_2 'D'	

#define HI_BYTE(value)        (U08)((value) >> 8)
#define LO_BYTE(value)        (U08)(value)


#define EVENT_MARK_CB				0x0001
#define EVENT_MARK_NURSE		0x0002
#define EVENT_MARK_CALL			0x0004
#define EVENT_MARK_HANDLE		0x0008

#define EVENT_MARK_C_D			0x0010
#define EVENT_MARK_CANCEL		0x0020
#define EVENT_MARK_UNPIN		0x0040
#define EVENT_MARK_BAT_LOW	0x0080

#define EVENT_MARK_SOS			0x0100 
 
#define SCAN_KEY_NUM 7 
//RF TX packet
//$ABlora1,1E#,(地址AB：0xF1234) 

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */
#define UART_RXBUF_LEN 64
#define UART_RXBUF_REV_LEN 24
uint8_t RX_recv_dma_buf[UART_RXBUF_LEN] = {0};
uint8_t RX_recv_buf[UART_RXBUF_LEN] = {0};

volatile uint16_t event_bits = 0;
volatile uint8_t rx_gateway_reps_flag = 0;
volatile uint8_t flag_cd_event = 0;
volatile uint8_t flag_handle_event = 0;



#define MAC_ADDR_LEN 4
#define RF_RXBUF_LEN  16
char MAC_ADDR[MAC_ADDR_LEN] = {'A', 'B'};
uint8_t RF_TX_Buf[RF_RXBUF_LEN] = {'$', 0x12, 0x34,0x46,0x45, 'L', 'O', 'R', 'A', '7', ',', '1', 'F', '#', 0x0D, 0x0A};


union u_tag {
    float f;
    unsigned char bytes[4];
} u;
const U08 DeviceMacInfo[] __attribute__((at(0X80036CC)))="F201";

uint8_t key_type = VALUE_SOS;
uint8_t key_value = KEY_EVENT_1;
uint8_t send_cnt = RX_RE_SEND_CNT;
uint8_t standby_flag = 0; 
volatile uint8_t even_cancel_flag = 0; 

#define LOW_VOL_HALF_VALUE 2.4
#define ADC_SAMPLE_CNT 20
uint16_t adc_value[ADC_SAMPLE_CNT] = {0};
uint16_t adc_buf[ADC_SAMPLE_CNT] = {0};

uint32_t ad_val;
float ad_vol;

#define KEY_DOWN 0
#define KEY_UP 1
#define KEY_DIDTH_TIME 50  		//MS
typedef struct __key_model {
	uint16_t key_gpio;
	uint8_t key_value;
	uint8_t ditch_time;
	GPIO_TypeDef * key_gpio_group;	
	void * timer;
}KEY_MODLE;

KEY_MODLE keyboard_v[SCAN_KEY_NUM];
uint16_t keyboard_gpio[SCAN_KEY_NUM] = {CANCEL_KEY_Pin, CHANGE_KEY_Pin, HADLE_KEY_Pin, CALL_KEY_Pin, NURSE_KEY_Pin, REINFORCE_KEY_Pin, UNPIN_KEY_Pin};
GPIO_TypeDef *key_io_group[SCAN_KEY_NUM] = {CANCEL_KEY_GPIO_Port, CHANGE_KEY_GPIO_Port, HADLE_KEY_GPIO_Port, CALL_KEY_GPIO_Port, NURSE_KEY_GPIO_Port, REINFORCE_KEY_GPIO_Port, UNPIN_KEY_GPIO_Port};
uart_comm uart1;

extern DMA_HandleTypeDef hdma_usart1_rx;
/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */
void RF_send_event(uint8_t event_type, uint8_t key_value, uint8_t send_cnt);
/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

#if ENABLE_UART1_DEBUG
int fputc(int ch, FILE *fp)
{
	HAL_UART_Transmit(&huart1, (uint8_t *)&ch, 1, 100);
	return ch;
}
#else

/*
 * The following is UART interpent handle functions.
 */
void uart_error_restore(UART_HandleTypeDef *huart)
{
  if (huart->ErrorCode)
  {
    __HAL_UART_CLEAR_PEFLAG(huart);
    __HAL_UART_CLEAR_FEFLAG(huart);
    __HAL_UART_CLEAR_NEFLAG(huart);
    __HAL_UART_CLEAR_OREFLAG(huart);
    HAL_UART_DeInit(huart);

    if (huart == &huart1)
    {
      MX_USART1_UART_Init();
    }
  }
}

/*
 * Todo: optimize huart variable the darkest sense in a interrupt handle.
 * xfli
 */
void HAL_UART_RxIdleCallback(UART_HandleTypeDef *huart)
{
  uint32_t temp;
  uint8_t ret;

  uart_error_restore(huart);

  if (RESET != __HAL_UART_GET_FLAG(huart, UART_FLAG_IDLE))
  {
    if (huart == uart1.uart) 
    {
      __HAL_UART_CLEAR_IDLEFLAG(huart);
      temp = __HAL_DMA_GET_COUNTER(uart1.dma);
      temp = uart1.rxtotal - temp;

      uart1.rxcnt = temp - uart1.rxoff;
      if (uart1.rxcnt)
      {
        temp = uart1.rxtotal - uart1.rxoff;
        if (temp >= uart1.rxcnt)
        {
          memcpy(RX_recv_buf, uart1.rxbuf+uart1.rxoff, uart1.rxcnt);
        }
        else
        {
          memcpy(RX_recv_buf, uart1.rxbuf+uart1.rxoff, temp);
          memcpy(RX_recv_buf+temp, uart1.rxbuf, uart1.rxcnt - temp);
        }

        uart1.rxoff += uart1.rxcnt;
				
				if(RX_recv_buf[16] == 0x0D && RX_recv_buf[17] == 0x0A) 
				{			
					//len = sizeof(RX_recv_buf);
					if(RX_recv_buf[0] == '$' && RX_recv_buf[15] == '#')
					{
						//To check if the received data is sended to current device.
						if(RX_recv_buf[1] == MAC_ADDR[0] && RX_recv_buf[2] == MAC_ADDR[1])
						{
							//char str[8];
							//memcpy(str, RX_recv_buf+3, 7);
							//Todo parse received data and if is valid.!!!
							//ret = strcmp(str, "CALLLED");
							//if(ret == 0)
							{
								rx_gateway_reps_flag = 1;
								// key_type = VALUE_SOS;
								//key_value = KEY_EVENT_1;							
							}					
						}		
					}
				}				
				
      }
    }
  }
}

#endif


#if ENABLE_TIMER_CALLBACK
void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)
{
  if(htim != &htim14)
  {
    //printf("Timer is htim14!\r\n");
    return;
  }

	///Todo needed code process...

  return;
}

#endif


void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{
    // 刚从STOP模式唤醒时钟默认使用内部高速8M时钟，所以需要重新配置时钟)
    //SystemClock_Config();

    // 如果使用了WKUP引脚唤醒则需要清除这个WKUP唤醒标记
    //__HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);

    switch(GPIO_Pin)
    {
      case CANCEL_KEY_Pin:
#if ENABLE_UART1_DEBUG				
          printf("CANCEL_Pin.\r\n");
#endif			
          BEEP_OFF();			
					event_bits |= EVENT_MARK_CANCEL;
					//even_cancel_flag = 1;
          break;

      case CHANGE_KEY_Pin:
#if ENABLE_UART1_DEBUG				
          printf("CHANGE_KEY_Pin.\r\n");
#endif		
					event_bits |= EVENT_MARK_C_D;
          break;

      case HADLE_KEY_Pin:
#if ENABLE_UART1_DEBUG				
          printf("HADLE_KEY_Pin.\r\n");
#endif		
					event_bits |= EVENT_MARK_HANDLE;
          break;

      case CALL_KEY_Pin:
#if ENABLE_UART1_DEBUG				
          printf("CALL_KEY_Pin.\r\n");
#endif			
					event_bits |= EVENT_MARK_CALL;
          break;

      case NURSE_KEY_Pin:
#if ENABLE_UART1_DEBUG				
          printf("NURSE_KEY_Pin.\r\n");
#endif			
					event_bits |= EVENT_MARK_NURSE;
          break;			
	
      case REINFORCE_KEY_Pin:
#if ENABLE_UART1_DEBUG				
          printf("REINFORCE_KEY_Pin.\r\n");
#endif			
					event_bits |= EVENT_MARK_CB;
          break;	
			
      case UNPIN_KEY_Pin:
#if ENABLE_UART1_DEBUG				
          printf("UNPIN_KEY_Pin.\r\n");
#endif			
					event_bits |= EVENT_MARK_UNPIN;
          break;	
			
      default:
          break;
    }

    return;
}



uint32_t srand_delay(void)
{
  #define RANDOM_MAX  500   //随机数最大值
  #define RANDOM_MIN  50     //随机数最小值
	uint32_t random_value = 0;
	
#if ENABLE_SRAND_DELAY
  
  //RTC_DateTypeDef  date_info;
  RTC_TimeTypeDef  time_info;

  HAL_RTC_GetTime(&hrtc, &time_info, RTC_FORMAT_BIN);   
  //HAL_RTC_GetDate(&hrtc, &date_info, RTC_FORMAT_BIN);
#if ENABLE_UART1_DEBUG 	
  printf("当前时间：%2d:%2d:%2d", time_info.Hours, time_info.Minutes, time_info.Seconds); 
#endif	

#if ENABLE_TIMER_COUNT	
  //HAL_TIM_Base_Start(&htim14);
	random_value = __HAL_TIM_GET_COUNTER(&htim14);
  srand(time_info.Hours + time_info.Minutes + time_info.Seconds + random_value);//随机数种子设置
#endif
	
  random_value = rand() % (RANDOM_MAX + 1 - RANDOM_MIN) + RANDOM_MIN;//随机数生成	
#if ENABLE_UART1_DEBUG	
  printf("  当前随机数为：%d\r\n", random_value);
#endif	
	
#endif

  return random_value;	
}


void GPIO_AnalogState_Config(void)
{
    GPIO_InitTypeDef GPIO_InitStruct;
    
    /*Set all GPIO in analog state to reduce power consumption*/
    
    __HAL_RCC_GPIOA_CLK_ENABLE();
    __HAL_RCC_GPIOB_CLK_ENABLE();
    
    GPIO_InitStruct.Mode = GPIO_MODE_ANALOG;
    GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
    GPIO_InitStruct.Pull = GPIO_NOPULL;
    GPIO_InitStruct.Pin = GPIO_PIN_All;
    
    HAL_GPIO_Init(GPIOA,&GPIO_InitStruct);
    HAL_GPIO_Init(GPIOB,&GPIO_InitStruct);
    
    __HAL_RCC_GPIOA_CLK_DISABLE();
    __HAL_RCC_GPIOB_CLK_DISABLE();
}




#if ENABLE_RTC_ALARM

void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
{
	uint8_t i;
	
	// STOP模式唤醒后默认时钟主频为内部8M时钟，所以要先初始化时钟配置
	SystemClock_Config();  
  //printf("3s时间到，唤醒！\r\n");
	
	//唤醒后红灯提示报警发生
//	for(i=0; i<LED_GREEN_FLUSH_COUNT; i++)
//	{
//		LED_GREEN_ON();
//		HAL_Delay(LED_FLUSH_TIME_DELAY);
//		LED_GREEN_OFF();
//		HAL_Delay(LED_FLUSH_TIME_DELAY);    
//	}

//	uint8_t event_t = VALUE_ONLINE_FB;
//	RF_send_event(event_t, KEY_EVENT_1, RX_RE_SEND_CNT);

	return;
}


void RTC_AlarmStart(void)
{
	RTC_TimeTypeDef  tim = {0};
	RTC_AlarmTypeDef sAlarm = {0};
	RTC_DateTypeDef sdate = {0};

	// 获取当前时间
	//RTC_GetTime(&tim);
	HAL_RTC_GetTime(&hrtc, &tim, RTC_FORMAT_BIN);
	HAL_RTC_GetDate(&hrtc, &sdate, RTC_FORMAT_BIN);
	
	sAlarm.AlarmTime.Hours = tim.Hours+24;//每24小时一次唤醒，心跳
	sAlarm.AlarmTime.Minutes = tim.Minutes;
	sAlarm.AlarmTime.Seconds = tim.Seconds ;  /* 设置下次闹钟提醒时间是当前时间的3s之后 */
	sAlarm.Alarm = RTC_ALARM_A;
	
	if(sAlarm.AlarmTime.Seconds >= 60)
	{
			sAlarm.AlarmTime.Seconds = sAlarm.AlarmTime.Seconds % 60;
			sAlarm.AlarmTime.Minutes += 1;
			if(sAlarm.AlarmTime.Minutes >= 60)
			{
					sAlarm.AlarmTime.Minutes = sAlarm.AlarmTime.Minutes % 60;
					sAlarm.AlarmTime.Hours += 1;
					if(sAlarm.AlarmTime.Hours >= 24)
					{
							sAlarm.AlarmTime.Hours = sAlarm.AlarmTime.Hours % 24;
							sdate.Date += 1;
					}
			}
	}

    sAlarm.AlarmTime.SubSeconds = 0;
    sAlarm.AlarmTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
    sAlarm.AlarmTime.StoreOperation = RTC_STOREOPERATION_RESET;
    sAlarm.AlarmMask = RTC_ALARMMASK_NONE;
    sAlarm.AlarmSubSecondMask = RTC_ALARMSUBSECONDMASK_NONE;
    sAlarm.AlarmDateWeekDaySel = RTC_ALARMDATEWEEKDAYSEL_DATE;
    sAlarm.AlarmDateWeekDay = sdate.Date; 
	
	// 启动闹钟中断事件
	HAL_RTC_SetAlarm_IT(&hrtc, &sAlarm, RTC_FORMAT_BIN);
}
#endif
/*
void sys_enter_stop_mode(void)
{
    // 使能PWR时钟
    __HAL_RCC_PWR_CLK_ENABLE();
	
		HAL_PWR_DisableWakeUpPin(PWR_WAKEUP_PIN1);

    // 清除唤醒标记
    __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);

    // 如果使用WK-UP引脚唤醒那么需要使能
    HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);

    // 进入STOP模式
    HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
}
*/
void sys_enter_standby_mode(void)
{
    // 使能PWR时钟
    __HAL_RCC_PWR_CLK_ENABLE();
	
		HAL_PWR_DisableWakeUpPin(PWR_WAKEUP_PIN1);

    // 清除唤醒标记
    __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);

    // 如果使用WK-UP引脚唤醒那么需要使能
    HAL_PWR_EnableWakeUpPin(PWR_WAKEUP_PIN1);

    // 进入待机模式
    HAL_PWR_EnterSTANDBYMode();
}
/*
void sys_enter_stop_mode(void)
{	
    __HAL_RCC_PWR_CLK_ENABLE();                                                // 使能PWR时钟
    __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);                                         // 清除唤醒标记
    HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);        // 进入STOP模式
}

void sys_enter_standby_mode(void)
{
    __HAL_RCC_PWR_CLK_ENABLE();           // 使能PWR时钟
    __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);    // 清除唤醒标记
    HAL_PWR_EnterSTANDBYMode();           // 进入待机模式
}
*/
void uart_comm_init(void)
{
  /*Init UART1 RX for ECG DATA CHANNEL*/
  uart1.uart = &huart1;
  uart1.dma = &hdma_usart1_rx;
  uart1.rxbuf = RX_recv_dma_buf;
  uart1.rxcnt = 0;
  uart1.rxoff = 0;
  uart1.rxtotal = UART_RXBUF_LEN;

  __HAL_UART_ENABLE_IT(uart1.uart, UART_IT_IDLE);
  HAL_UART_Receive_DMA(uart1.uart, uart1.rxbuf, uart1.rxtotal);
}

void RF_send_event(uint8_t event_type, uint8_t event_value, uint8_t send_cnt)
{
  uint8_t i;
  uint16_t delay;
  //uint8_t crc_t = 0;


  for(i=0; i<MAC_ADDR_LEN; i++)
  {
    RF_TX_Buf[i+1] = MAC_ADDR[i];
  }
  
  RF_TX_Buf[RF_RXBUF_LEN - 7] = event_type+48;
  RF_TX_Buf[RF_RXBUF_LEN - 5] = event_value+48;

/*
  for(i=1; i<RF_RXBUF_LEN-2; i++)
  {
    crc_t += RF_RXBUF_LEN[i]
  }  
*/

  for(i=0; i<send_cnt; i++)
  {
    delay = srand_delay();
		HAL_Delay(delay+send_cnt*15); 
    HAL_UART_Transmit(uart1.uart, RF_TX_Buf, RF_RXBUF_LEN, 100);     
  }

  return;
}

uint8_t read_flash_get_MAC(void)
{
	uint8_t i, ret = 0;
	
	//get MAC address from flash specical page.
	//????
#if 0	
  for(i=0; i<MAC_ADDR_LEN; i++)
  {
    MAC_ADDR[i] = read_flash_get_MAC();
  }	
#else
	U32 u32prm = *(U32*)(0X80036CC);
	MAC_ADDR[0] = LO_BYTE(u32prm); //MAC_ADDR_CHAR_1;
	MAC_ADDR[1] = u32prm>>8; //MAC_ADDR_CHAR_2;
	MAC_ADDR[2] = u32prm>>16;
	MAC_ADDR[3] = u32prm>>24;
#endif
	return ret;
}

static void event_response_func(uint8_t event)
{
	BEEP_OFF();
	LED_RED_OFF();
	
			BEEP_ON();
    HAL_Delay(200);
		BEEP_OFF();		
		LED_RED_ON();
		HAL_Delay(100);
		LED_RED_OFF();
	RF_send_event(event, KEY_EVENT_1, 3);	

	return;
}

static void init_keyboard_model(void)
{
	uint8_t i;

	memset((char *)keyboard_v, 0, sizeof(KEY_MODLE));

	for(i=0; i<SCAN_KEY_NUM; i++)
	{
	  keyboard_v[i].key_value = GPIO_PIN_SET;
	  keyboard_v[i].key_value = KEY_DIDTH_TIME;
	  keyboard_v[i].key_gpio = keyboard_gpio[i];
	  keyboard_v[i].key_gpio_group = key_io_group[i];		
	}
	
	return;
}


static void event_scan_key_status(void)
{
	uint8_t i;
	uint16_t k_value;
	
	for(i=0; i<SCAN_KEY_NUM; i++)
	{
		k_value = HAL_GPIO_ReadPin(keyboard_v[i].key_gpio_group, keyboard_v[i].key_gpio);
		if(k_value == GPIO_PIN_RESET)	{
	    switch(keyboard_v[i].key_gpio)
	    {
	      case CANCEL_KEY_Pin:
	#if ENABLE_UART1_DEBUG				
	          printf("CANCEL_Pin.\r\n");
	#endif				
						event_bits |= EVENT_MARK_CANCEL;
	          break;

	      case CHANGE_KEY_Pin:
	#if ENABLE_UART1_DEBUG				
	          printf("CHANGE_KEY_Pin.\r\n");
	#endif		
						event_bits |= EVENT_MARK_C_D;
	          break;

	      case HADLE_KEY_Pin:
	#if ENABLE_UART1_DEBUG				
	          printf("HADLE_KEY_Pin.\r\n");
	#endif		
						event_bits |= EVENT_MARK_HANDLE;
	          break;

	      case CALL_KEY_Pin:
	#if ENABLE_UART1_DEBUG				
	          printf("CALL_KEY_Pin.\r\n");
	#endif			
						event_bits |= EVENT_MARK_CALL;
	          break;

	      case NURSE_KEY_Pin:
	#if ENABLE_UART1_DEBUG				
	          printf("NURSE_KEY_Pin.\r\n");
	#endif			
						event_bits |= EVENT_MARK_NURSE;
	          break;			
		
	      case REINFORCE_KEY_Pin:
	#if ENABLE_UART1_DEBUG				
	          printf("REINFORCE_KEY_Pin.\r\n");
	#endif			
						event_bits |= EVENT_MARK_CB;
	          break;	
				
	      case UNPIN_KEY_Pin:
	#if ENABLE_UART1_DEBUG				
	          printf("UNPIN_KEY_Pin.\r\n");
	#endif			
						event_bits |= EVENT_MARK_UNPIN;
	          break;	
			
	      default:
	          break;
	    }
		}
	}
	
  return;	
}


static uint8_t event_checkout_and_scan(void)
{
	uint8_t type, ret;
	uint8_t value = KEY_EVENT_1; 

	ret = 0;
	type = (uint8_t)VALUE_UNKOWN;	
	event_scan_key_status();	

	//Checkout the event list...
	if (event_bits & EVENT_MARK_CANCEL) //实际修改为增援
	{
		type = VALUE_CB;//VALUE_CANCEL;
		event_response_func(type);
		event_bits &= ~EVENT_MARK_CANCEL;
	}

	if (event_bits & EVENT_MARK_CB) //实际修改为Nurse
	{
		type = VALUE_NURSING; //VALUE_CB;
		event_response_func(type);
		event_bits &= ~EVENT_MARK_CB;
	}	
	
	if (event_bits & EVENT_MARK_NURSE) //实际修改为面板呼叫
	{
		type = VALUE_CALL;//VALUE_NURSING;
		event_response_func(type);
		event_bits &= ~EVENT_MARK_NURSE;
	}	
	
	if (event_bits & EVENT_MARK_CALL) //实际修改为取消
	{
		type = VALUE_CANCEL;//VALUE_CALL;
		event_response_func(type);
		event_bits &= ~EVENT_MARK_CALL;
	}
	
	if (event_bits & EVENT_MARK_UNPIN)
	{
		type = VALUE_UNPIN;
		event_response_func(type);
		event_bits &= ~EVENT_MARK_UNPIN;
	}

	if (event_bits & EVENT_MARK_HANDLE)
	{
		type = VALUE_HANDLE_CALL;
		flag_handle_event = 1;	
		event_response_func(type);
		event_bits &= ~EVENT_MARK_HANDLE;
	}			

	if (event_bits & EVENT_MARK_C_D)
	{
		type = VALUE_C_D;
		flag_cd_event = 1;
		event_response_func(type);
		event_bits &= ~EVENT_MARK_C_D;
	}
	
	if (event_bits & EVENT_MARK_SOS)
	{
		type = VALUE_SOS;
		event_response_func(type);
		event_bits &= ~EVENT_MARK_SOS;
	}
	
	if(type)
	{	
		type = (uint8_t)VALUE_UNKOWN;				
		ret = 1;		
	}
	
	return ret;
}




/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
int main(void)
{

  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_DMA_Init();
  MX_ADC_Init();
  MX_RTC_Init();
  MX_TIM14_Init();
  MX_USART1_UART_Init();
  /* USER CODE BEGIN 2 */

  //Wait the power bapass capacitance chargeing to full.
  HAL_Delay(200);
	
	//printf("Hello word!! I'm main Ctroller board.\r\n");
	LED_GREEN_OFF();
	LED_RED_OFF();	

  RF_PWR_ON();
  HAL_Delay(200);
	HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_SET);
	HAL_GPIO_WritePin(GPIOA, CE_Pin|RLED2_Pin|GLED1_Pin, GPIO_PIN_SET);
	HAL_GPIO_WritePin(GPIOA, RESET_Pin, GPIO_PIN_RESET);
	  /*Configure GPIO pin Output Level */
  
	
  uart_comm_init();
#if ENABLE_TIMER_COUNT	
  HAL_TIM_Base_Start(&htim14);
#endif
  uint8_t i, ret;
  key_type = VALUE_SOS;
  key_value = KEY_EVENT_1;
  send_cnt = 0;
  standby_flag = 0; 
	
	//Todo read the device MAC address from the indicated page in flash and to save.
	read_flash_get_MAC();

	//Todo Set LORA module...
	//81 ---开启透传模式
	//82 ---关闭透传模式，即 AT 命令模式
	HAL_Delay(200);
	set_work_mode(0);
	//485125000Hz
	//483200000Hz
	set_work_freq(1);
	//6 ---速率 1868bps
	set_rf_rate(6);
	//set_rf_tx_power(int index);  

	HAL_Delay(20);
	set_work_mode(1);
	HAL_Delay(50);
	
	HAL_ADC_Start_DMA(&hadc, (uint32_t *)adc_value, ADC_SAMPLE_CNT);
	//HAL_ADC_Start(&hadc);
	
	//init keyboard model.
	init_keyboard_model();
  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
#if ENABLE_UART1_DEBUG
		uint32_t random_value = __HAL_TIM_GET_COUNTER(&htim14);
		printf("tim14 cnt [%d].\r\n", random_value);
#endif		
		
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */

		//唤醒后红灯提示报警发生
		//HAL_Delay(800);
	
		
//		BEEP_ON();
//    HAL_Delay(200);
//		BEEP_OFF();
//		
//		LED_RED_ON();
//		HAL_Delay(100);
//		LED_RED_OFF();
//		HAL_Delay(400);
		//printf("BEEP_ON.\r\n");

		//HAL_Delay(LED_FLUSH_TIME_DELAY);      

		//Get AD value and calculate battery volume...
		ad_val=0;
		memcpy(adc_buf, adc_value, ADC_SAMPLE_CNT*2);
		for(i=0; i<ADC_SAMPLE_CNT; i++)
		{
			ad_val += adc_buf[i];
		}
		ad_vol = (ad_val / ADC_SAMPLE_CNT);
		HAL_Delay(20);
	
	
//		unsigned t=(unsigned)ad_vol;
//		RF_TX_Buf[1]=t/1000+48;
//		RF_TX_Buf[2]=(t/100)%10+48;
//		RF_TX_Buf[3]=(t/10)%10+48;
//		RF_TX_Buf[4]=t%10+48;
//		 HAL_UART_Transmit(uart1.uart, RF_TX_Buf, 16, 100);  
		
    //Send the alarm message by RF channel
    send_cnt++;
		if(send_cnt<=4){		
		 //低电量上报，前3秒发送
		 	if(4096/ad_vol*1.2 <= LOW_VOL_HALF_VALUE)
			{
				//low battery...
				uint8_t event_t = VALUE_BAT_LOW;		
				RF_send_event(event_t, KEY_EVENT_1, 1);
			}	
			//发送心跳
			RF_send_event(VALUE_ONLINE_FB, key_value, 1);
		}else{
			HAL_Delay(200);
		}
			
		
  	if(rx_gateway_reps_flag)
    {
      //To parse data from ... RX_recv_buf

      //唤醒后红灯提示报警发生
      for(i=0; i<LED_GREEN_FLUSH_COUNT; i++)
      {
        //LED_GREEN_ON();
				LED_RED_ON();
        HAL_Delay(100);
        //LED_GREEN_OFF();
				LED_RED_OFF();
        HAL_Delay(300);    
      } 
		
      rx_gateway_reps_flag = 0;
      standby_flag = 1;   
    }

		
		//Checkout the event list...
		ret = event_checkout_and_scan();
		if (ret)
    {
			HAL_Delay(200);			//Why delay?
			standby_flag = 1;
			//重置寄存器
			STATE_REST_H();
    }
		
    if(standby_flag == 1 || send_cnt > RX_RE_SEND_CNT)
    {
      standby_flag = 0;
      send_cnt = 0;
      
			
			
      //配置下次唤醒的闹钟时间
			//HAL_RTCEx_SetWakeUpTimer_IT(&hrtc, 5, RTC_WAKEUPCLOCK_CK_SPRE_16BITS);
      RTC_AlarmStart();   
      
			//set_work_mode(0);
			//set_work_mode(5);				//TC-037模块进入休眠
			HAL_GPIO_WritePin(GPIOB, GPIO_PIN_1, GPIO_PIN_RESET);
      RF_PWR_OFF();
			HAL_Delay(5);

      //sys_enter_stop_mode();
      sys_enter_standby_mode();
    }   
  }
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI14|RCC_OSCILLATORTYPE_LSI
                              |RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSI14State = RCC_HSI14_ON;
  RCC_OscInitStruct.HSI14CalibrationValue = 16;
  RCC_OscInitStruct.LSIState = RCC_LSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL6;
  RCC_OscInitStruct.PLL.PREDIV = RCC_PREDIV_DIV1;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }

  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1|RCC_PERIPHCLK_RTC;
  PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK1;
  PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_LSI;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */
  __disable_irq();
  while (1)
  {
  }
  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     ex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */