/* Includes ------------------------------------------------------------------*/
#include "main.h"

//----------------------------------------------------
// ¸±¸®Áî½Ã È®ÀÎ
// 1. ¾×Ãò¿¡ÀÌÅÍ Ã¼Å© ±â´É È°¼ºÈ­
// 2. ¼¾¼­µ¥ÀÌÅÍ Ãâ·Â ÁßÁö
// 3. Ç÷¡½¬ ÀúÀå ¹× Ãâ·Â±â´É È°¼ºÈ­
// 4. BLE¸ðµå ¼³Á¤
//----------------------------------------------------
#define  ACUTUATOR_CHECK_ENABLE      1
#define  SENSOR_DATA_OUT_DISABLE     1
#define  STORED_DATA_PRINT_ENABLE    1
#define  BLE_MODE                    1
//--------------------------------------------
// µ¥ÀÌÅÍ ¼öÁý Àü¿ëÀÎ °æ¿ì °Ý¹ß ºÎºÐ ¾Èµé¾î°¨.
// µ¥ÀÌÅÍ ¼öÁý Àü¿ëÀÎ °æ¿ì O, ³ª¸ÓÁö´Â 1 ¼ÂÆÃ. 
#define  PROCESS_TRIGGER             1
//--------------------------------------------
// µ¥ÀÌÅÍ ÃßÃâ use block

//----------------------------------------------------
// ¹öÀü Á¤º¸ ÀÔ·Â ÁÖÀÇÇÒ °Í.
// Ver02xx_xxx :  STM32F105xx 
// Ver03xx_xxx :  STM32L431xx 
//
// New¹öÀü¸í
// <yymmdd>_<±¸ºÐ>_<major>.<minor>.<patch>
// ±¸ºÐ : Á¦Ç°¸í
// major : ±â´ÉÃß°¡
// minor : ±â´É¼öÁ¤
// patch : SVN Ä¿¹Ô
//----------------------------------------------------
#if(BLE_MODE)
  const char* VersionInfo = "230102_C3BLE_1.2.0";
#else
  const char* VersionInfo = "230102_C3_1.2.0";
#endif 
//----------------------------------------------------


#include<queue>
#include<array>
#include<list>

#include "math.h"

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>

#include "myQueue.h"

#include "stm32l4xx_hal.h"
#include "stm32l4xx_hal_uart.h"
#include "stm32l4xx_hal_uart_ex.h"

#include "gyro.h"
#include "hs_uart5.h"
#include "flash.h"
#include "exflash.h"

#include "Quaternion/Quaternion.h"

using namespace std;


//----------------------------------------------------
// Ŭ·°¼³Á¤, HSE 24MHz ()
// Ŭ·°¼³Á¤, HSE 48MHz ()
#define  CLOCK_HSE_48MHz  1
//----------------------------------------------------

list<int> myGravList;
list<int> myGravJumpList;
list<int> myOmegaAngleList;

list<uint32_t> flashSaveList_A1;  // flash Acc ÀúÀå 
list<uint32_t> flashSaveList_A2;
list<uint32_t> flashSaveList_G1;  // flash Gyro ÀúÀå 
list<uint32_t> flashSaveList_G2;

MyQueue  uartTransQ ; 

ADC_HandleTypeDef hadc1;
I2C_HandleTypeDef hi2c1;
I2C_HandleTypeDef hi2c2;

QSPI_HandleTypeDef hqspi;


TIM_HandleTypeDef htim6;
TIM_HandleTypeDef htim7;

UART_HandleTypeDef huart1;
UART_HandleTypeDef huart3;

DMA_HandleTypeDef hdma_usart1_rx;
DMA_HandleTypeDef hdma_usart1_tx;
DMA_HandleTypeDef hdma_usart3_rx;
DMA_HandleTypeDef hdma_usart3_tx;


extern RTC_HandleTypeDef hrtc;
extern RTC_TimeTypeDef time_;
extern RTC_DateTypeDef date_;
extern RTC_DnTTypeDef dnt_;
extern SensorData_TypeDef sData_;

volatile int MS_1 = 0;

// HCLK ·Î ŸÀÌ¸Ó ¼³Á¤Çϱâ À§ÇÑ. 
#if (CLOCK_HSE_48MHz)
  static int g_HCLK = 48000 ; 
#else
  static int g_HCLK = 24000 ; 
#endif

// low batt ó¸® °ü·Ã º¯¼ö ----------------------
static uint32_t   timer7_10ms_counter = 0 ; 
//static uint32_t   timer7_1s_counter=0;
static uint32_t   low_batt_hit_counter = 0 ; 
static uint32_t   standby_hit_counter = 0 ; 
static bool      low_batt_status = false ; 
static int       nBattBlinkingCount = 0 ; 
static int       nHeartbitCount = 0; 
//-----------------------------------------------

// temp, µð¹ö±× Ãâ·Â ÀÚµ¿Áõ°¡.
uint32_t           tmepCount = 0 ;  

// BT ¾Èµå·ÎÀ̵å Æù ¿¬°áµÇ¸é 1ºÐ¸¶´Ù Àü¼Û, ±âŸ 5Ãʸ¶´Ù.
bool               bt_Android_connected = false ;
// 5Ãʸ¶´Ù 4°³¿Ã¸°ÈÄ, 1ºÐ¸¶´Ù Àü¼Û. 
bool               bt_Android_conn_2    = false ; 
int                bt_Android_conn_2_count = 0 ; 



/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
static void MX_GPIO_Init(void);
static void MX_DMA_Init(void);
static void MX_ADC1_Init(void);
static void MX_I2C1_Init(void);
static void MX_I2C2_Init(void);
static void MX_QUADSPI_Init(void);
static void MX_RTC_Init(void);
static void MX_TIM6_Init(void);
static void MX_TIM7_Init(void);
static void MX_USART1_UART_Init(void);
static void MX_USART3_UART_Init(void);
void MX_GPIO_standby(void);
/* USER CODE BEGIN PFP */


void trigger_process_start( uint8_t triggerType ) ; 


extern void ReadSensorData2( SENSORData* data) ;
extern void Gyro_SleepMode() ; 

extern void  parse_UART5(); 

// extern HAL_StatusTypeDef HAL_UARTEx_EnableFifoMode(UART_HandleTypeDef *huart) ; 

extern void test_Gyrocali(); 
extern void test_Angcali() ; 


extern void InitARS() ; 
extern dMatrix ARS (double gyro[3], double accl[3], double magn[3], double dt) ; 
extern Quaternion _Q ; 

int     g_QT_angX = 0, g_QT_angY = 0, g_QT_angZ = 0 ; 
int     c_angX = 0, c_angY = 0, c_angZ = 0 ;   //
double  LPF_G = 0 ;  // low pass filter 
double  gravity = 0 ; 

float ax_1=0, ax_2=0, ax_3=0 ; 
float ay_1=0, ay_2=0, ay_3=0 ; 
float az_1=0, az_2=0, az_3=0 ; 

float gx_1=0, gx_2=0, gx_3=0 ; 
float gy_1=0, gy_2=0, gy_3=0 ; 
float gz_1=0, gz_2=0, gz_3=0 ;

// UART1 RX -->  UART3 RX ·Î Àü´ÞÇØ ÁØ´Ù. 
bool    bTransferRFUartToDebugUart = false ; 
char    RxBufTrans[128] = {0x31,0x32,0x0d,0x0a,0,} ; 

char    RxBufUart1[64] = {0,} ; 
char    RxBufUart2[64] = {0,} ; 

uint8_t  RxBufPos1 =0 ; 
uint8_t Rx_data[6];
uint8_t BlockPoint[3];

int trigger_type=0 ;

void LPF(float *Input, float *Output, float *PastInput, float *PastOutput)
{
    // CutOffFrequency   ¸¦ 10hz·Î ¿øÇÒ°æ¿ì 10.0
    // SamplingFrequency ¸¦ 0.001ms·Î ¿øÇÒ°æ¿ì 1/0.001 => 1000

    float CutOffFrequency   = 10 ;  
    float SamplingFrequency = 500 ; 
    

    float a1,b0,b1,w0;
    w0 = 2 * 3.14 * CutOffFrequency;
    a1 = (w0 - 2 * SamplingFrequency) / (2*SamplingFrequency + w0);
    b0 = w0 / ( 2 * SamplingFrequency + w0);
    b1 = b0;

    *Output = b0*(*Input) + b1*(*PastInput) - a1*(*PastOutput);
    *PastOutput = *Output;
    *PastInput = *Input;
}


int RF_Printf(const char *fmt, ...)
{
    int n = 0;
  
    char buff[128];
    va_list args;
    
    va_start(args, fmt);
    n = vsnprintf(buff, 145, fmt, args);
    va_end(args);

    HAL_UART_Transmit(&huart1, (uint8_t*)buff, n, 1000);

    return n;
}



/* USER CODE BEGIN PFP */
/* Private function prototypes -----------------------------------------------*/

// ¹öŬ ½ºÀ§Ä¡ Àû¿ë ÀÌÈÄ. 
//const int  CONTINUE_COUNT = 18 ;   // ¿¬¼ÓµÇ´Â Ƚ¼ö Á¶°Ç.  // <----------------------------------

// LPF G Àû¿ëÈÄ,  LPF_G <=60 Àº  G°ªÀÌ ÀÌ¹Ì 0 ±ÙóÀÌ´Ù. 
const int  CONTINUE_COUNT = 15 ;   // ¿¬¼ÓµÇ´Â Ƚ¼ö Á¶°Ç.  // <----------------------------------


SENSORData sData = {0,}; 

bool bSensorReadToggle = true ; 
bool bEnterManualShoot = false ;  // manual shooting Å×½ºÆ®¿ë 

bool g_bTriggerON = false ; 
int  g_nTriggerONCount = 20 ; 

int  g_nTriggerFireCount = 0 ;     // trigger 10¹ø Á¤µµ¸¸ µ¿ÀÛ.  
bool g_bStopTriggerPin = false ;  // 
                        

int  gravityMean[40] = {0,} ;
int  gravityJump[40] = {0,} ;
int  omegaAngleMean[40] = {0,} ;

uint32_t seqNum = 0 ; 

uint32_t BT_seqNum = 0 ; 

uint8_t start_b=0;
uint8_t end_b=0;
u8_t IsFlash;
typedef struct PACKETDATA
{
  char   start; // <
  char   seqNum; 
  short   n1; 
  short   n2; 
  short   n3; 
  short   n4; 
  short   n5; 
  short   n6; 
  char   reserved ;
  char   end;  // 0x3E >
  char   end2; // 0x0D
  char   end3; // 0x0A
}PACKET ;  // 18 byte ¼öÁ¤

PACKET txPacket = {0x3C, 0,0,0,0,0,0,0,0, 0x3E,0x0D,0x0A} ; 

bool g_bResetMsgProcess = false ; 
bool stanby_batt_status  = false;
bool show_low_batt = false;     //Àü¾ÐÀÌ ¿Ã¶ó°¡µµ LEDÇ¥±â°¡ µû¶ó°¡Áö ¾Ê±â À§ÇÔ

// ADC ÄݹéÇÔ¼ö ---------------------------------------------
uint32_t g_battAdcVal = 0 ;
uint32_t adcValArr[10]={0,}; // BATT val ÀúÀå. 
uint32_t adcValArrIndex=0;
void HAL_ADC_ConvCpltCallback(ADC_HandleTypeDef* hadc)
{
	adcValArr[adcValArrIndex++%10] = HAL_ADC_GetValue(hadc);
}
//-----------------------------------------------------------





uint8_t D2B(uint8_t byte)
{
  return ((byte/10)<<4)+(byte%10);
}

void HAL_TIM_PeriodElapsedCallback(TIM_HandleTypeDef *htim)  
{
   if( htim->Instance == TIM6 )
   {  
      MS_1++;

        
      if( MS_1 % 5 == 0 )  // 5ms
      {
        
         //-------------------------------------------------------------
         //FTP102, FTP103 find_data¿¡¼­ ÀÐÀ» ºí·° ¹Þ¾Æ¿À±â
         //-------------------------------------------------------------
          bool bLoad = HAL_GPIO_ReadPin( GPIOA, GPIO_PIN_12 ) ; 
          if( bLoad== false )
          {
              HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_RESET);//ÆĶõºÒ ²û

              HAL_TIM_Base_Stop_IT(&htim6);
              HAL_TIM_Base_Stop_IT(&htim7);
              //tool¿¡¼­ Àоî¿À´Â start_b, end_b
              while (true){
                  HAL_UART_Receive_DMA (&huart3, BlockPoint, 2);
                  if(BlockPoint[0] ==255 and BlockPoint[1]==255){
                      DnT_Load_All();
                      BlockPoint[0]=0;
                      BlockPoint[1]=0;
                  }
                  
                  else if (BlockPoint[0] !=0 and BlockPoint[1]!=0){
                      sData_Load(BlockPoint[0], BlockPoint[1]);
                      BlockPoint[0] =0 ;
                      BlockPoint[1]=0;
                      //break;
                  }
              }
              //sData_Load_Test();
          }
          
          //-------------------------------------------------------------
          // ¸Þ´º¾ó ½´ÆÃÀÎ °æ¿ì, Flash user data ¿µ¿ª Áö¿ì´Â ±â´É °ËÅä
          // 1. ŸÀÌ¸Ó ÁßÁö
          // 2. Flash user data »èÁ¦
          // 3. ´Ù½Ã ºÎÆõɶ§ ±îÁö »¡°£ LED ±ôºýÀÓ
          //-------------------------------------------------------------
          bool bRet = HAL_GPIO_ReadPin( MANUAL_SHOOT_PORT, MANUAL_SHOOT_Pin ) ; 
          if( bRet== false )
          {
              HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_RESET); //ÆĶõºÒ ²û

              HAL_TIM_Base_Stop_IT(&htim6);
              HAL_TIM_Base_Stop_IT(&htim7);
              
              Flash_Reset_Userdata() ; 

              while(true)
              {  
                 HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_SET); 
                 HAL_Delay(200);
                 HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_RESET);
                 HAL_Delay(200);
              }
          }
        
          //-------------------------------------------------------------
            
          //-------------------------------------------------------------------------------------
          // ½ÇÁ¦ °Ý¹ß. 
          // LED_red Á¡¸ê
          // uart5_printf
          if( g_bTriggerON == true )
          {
              if( g_nTriggerONCount  > 18 )
              {
                  HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_SET);

                 if( g_bStopTriggerPin == false )
                 {
                    for(int k=0; k< 1; k++)
                    {
                       UART5_Printf("g_bTriggerON = true -----------\r\n" );
                    }
                 }
                  
                  if( g_nTriggerONCount  > 19 )
                  {
                      g_nTriggerONCount = 0 ; 

                      if( g_nTriggerFireCount++ > 10)
                        g_bStopTriggerPin = true ; 
                  }
              }
              else
              {
                  HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_RESET);
              }
              g_nTriggerONCount ++ ; 
          }
          //-------------------------------------------------------------------------------------
           
       }
        
   } // TIMER 6 
    

   if( htim->Instance == TIM7 ) //term 10ms
   {
       timer7_10ms_counter ++ ; 
       //timer7_1s_counter++;
       
#if(BLE_MODE)
       //-------------------------------------------------------------------------------------
       // Android ÆùÀÌ ¿¬°áµÇ¸é [Android~~~~~] ¿¬°áÁ¤º¸¸¦ º¸³½´Ù. 
       // BT¿¡¼­ ¸¶ÀÌÄÄ¿¡ Àü´ÞÇϸé, ¸¶ÀÌÄÄ¿¡¼­ Àü¼ÛÁֱ⸦ 1ºÐÀ¸·Î ¼öÁ¤.
       
       if( bt_Android_connected == true ) 
       {
         if( timer7_10ms_counter % (100*60) == 0 )  // 10msx100 = 1ÃÊ  x 60 = 1ºÐ
         {
             RF_Printf("Q=0;1;%d,%02d,%03d,\n", g_bTriggerON, (g_battAdcVal/2300)*100, BT_seqNum++ );
         }
       }
       else
       {
         if( timer7_10ms_counter % (10*45) == 0 )  // 4.5ÃÊ  µðÆúÆ®. 
         {   
             RF_Printf("Q=0;1;%d,%02d,%03d,\n", g_bTriggerON, (g_battAdcVal/2300)*100, BT_seqNum++ );
             
             if( bt_Android_conn_2 == true )
             {
                 if( bt_Android_conn_2_count ++ > 4 )
                     bt_Android_connected = true ; 
             }
               
         }
       }      
#endif
       
       if(timer7_10ms_counter%100==0)     //term 1s
       {
           DnT_Write();
       }

      
       //-------------------------------------------------------------------------------------
       // ¹èÅ͸® üũ´Â 0.2ÃÊ¿¡ Çѹø¾¿ ÇÑ´Ù. 
       // if( timer7_10ms_counter % 50 == 0 )  //1 sec
       if( timer7_10ms_counter % 20 == 0 )  // test 200ms
       {
           HAL_ADC_Start_IT(&hadc1);
           uint32_t adcSum = 0;
      
           for( int i=0; i<10; i++)
             adcSum += adcValArr[i];
                  
           g_battAdcVal = adcSum/10;
           // UART5_Printf("ADC=%3d\r\n", g_battAdcVal );
                    
          
          
           // ADC VAL:   
           // 1990 : 3.3 V
           // 2040 : 3.35 V  
           // 2080 : 3.4  V  //-------------- 
           // 2120 : 3.45 V  
           // 2150 : 3.5  V   
           // 2220 : 3.6  V//-------------- 
           // 2300 : 3.7  V
                      
           if( g_battAdcVal < 2080 || stanby_batt_status == true )  // 3.4V ÀÌÇÏ·Î ¶³¾îÁö¸é standby ·Î µé¾î°£´Ù. 
           {
             low_batt_status = true; 
             stanby_batt_status = true;
             //standby_hit_counter++ ; 
             if( standby_hit_counter> 50 )   // ±×¸° LED 10ȸ. 
             {
                 UART5_Printf("Enter Standby mode!!!!! \r\n" );
                 ////// HAL_GPIO_WritePin( GPIOB, BLE_PWR_EN, GPIO_PIN_RESET);  //  LOW : BLE ¸ðµâ POWER DOWN
               
                
                 // Standby ¸ðµå ÁøÀÔ½Ã, BT ¸ðµâ ¸®¼ÂÇÉÀ» ³»¸°´Ù. 
                 HAL_GPIO_WritePin( RF_MOD_PWR_EN_PORT, RF_MOD_PWR_EN_Pin, GPIO_PIN_RESET);
                 HAL_GPIO_WritePin( RF_MOD_RESET_PORT, RF_MOD_RESET_Pin, GPIO_PIN_RESET);
                                  
                 
                 // pad ÀüºÎ Á×ÀÌ°í stand by ¸ðµå·Î ÁøÀÔÇÑ´Ù. 
                 HAL_TIM_Base_Stop_IT(&htim6);
                 HAL_TIM_Base_Stop_IT(&htim7);
                
                 Gyro_SleepMode() ; 
                 ////HAL_Delay(10); // < ----------- delay ÄÚµå ÀÖÀ¸¸é standby ¸ðµå·Î ¸øµé¾î °£´Ù. 
                
                 //// MX_GPIO_Deinit() ;  
                 // ÀÏ´Ü ´ë±â. ³ªÁß¿¡ ¼öÁ¤ ÇÊ¿ä. 
                 
                 ////SystemClock_Config__ALL_stop() ; // ¾ÈµÊ. 
                
                 HAL_PWR_DisableSleepOnExit() ; 
                 HAL_PWR_DisableBkUpAccess() ;
                 HAL_PWR_DisablePVD() ; 
                 HAL_PWR_DisableSEVOnPend() ; 
                 
                 MX_GPIO_standby();

                 HAL_PWR_EnterSTANDBYMode() ;  // <---------------------------------------------------
                 
                
             }
             else
                 UART5_Printf("standby hit count=%d \r\n", standby_hit_counter  );
            
           }
           else if( g_battAdcVal > 2080  && g_battAdcVal < 2220  ) // 3.4V ~ 3.6V ·Î¿ì ¹èÅ͸® ¾Ë¸².  
           {
             //standby_hit_counter = 0 ; 
             low_batt_hit_counter++ ; 
             if( low_batt_hit_counter> 10 )
             {
               low_batt_status = true ; 
             }
           }
           else
           {
             low_batt_hit_counter = 0 ; 
             //standby_hit_counter = 0 ; 
             low_batt_status = false ; 
           }
           if(stanby_batt_status == true)       standby_hit_counter++ ; 
       }
       //-------------------------------------------------------------------------------------
       // ¸Þ´º¾ó ½´Æà  //term 10ms
       //// bool bRet = HAL_GPIO_ReadPin( MANUAL_SHOOT_PORT, MANUAL_SHOOT_Pin ) ; 
       if( bEnterManualShoot == false )
       {
           if( g_bTriggerON == false )
           {
               // ¸Þ´º¾ó ½´ÆÃÀÌ ¾Æ´Ñ °æ¿ì 
               HAL_GPIO_WritePin(SHOOT_EN_GPIO_Port,     SHOOT_EN_Pin, GPIO_PIN_RESET );
               HAL_GPIO_WritePin(SHOOT_EN_1_GPIO_Port,     SHOOT_EN_1_Pin, GPIO_PIN_RESET );
               HAL_GPIO_WritePin(SHOOT_EN_2_GPIO_Port, SHOOT_EN_2_Pin, GPIO_PIN_RESET );
                  
               HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_RESET);
               HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_RESET);
              
               // Low batt ÀÎ °æ¿ì LED blinking  50 x 10ms 
               if( low_batt_status == true || show_low_batt == true )
               {
                   show_low_batt = true;
                   if( nBattBlinkingCount  > 89  )
                   {
                       if( stanby_batt_status == true )
                       {
                           HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_SET);
                           HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_SET);
                       }
                       else
                           HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_SET);
                      
                       if(nBattBlinkingCount  > 99)
                       {
                           nBattBlinkingCount = 0 ; 
                           //UART5_Printf("Low battary !!!!! \r\n" );
                       }
                   }
                   else
                   {
                       if( stanby_batt_status == true )
                       {
                           HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_RESET);
                           HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_RESET);
                       }
                       else
                           HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_RESET);
                   }
                   nBattBlinkingCount ++  ; 
               }
               else
               {
                   HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_RESET);
                  
                   // Low batt ¾Æ´Ï°í Á¤»ó µ¿ÀÛ ÇÏ°í ÀÖ´Â °æ¿ì. 100 x 10ms 
                   if( nHeartbitCount  > 89  )
                   {
                       HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_SET);
                       if( nHeartbitCount > 99 )
                       {
                           nHeartbitCount = 0 ; 
                       }
                   }
                   else
                   {
                       HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_RESET);
                   }
                   nHeartbitCount ++  ; 
               }
           }
       }
       //-------------------------------------------------------------------------------------
      
       if( bSensorReadToggle == true) // 20ms ÆÇ´ÜÁֱ⠸ÂÃß±â À§Çؼ­.(term 20ms)
       {
           ReadSensorData2(&sData);
           #define  MICOM_DIV    100 
           
           if (seqNum>1000){
               seqNum =0 ;
           }
           if (low_batt_status){
               seqNum = 7777;
           }
           if (stanby_batt_status){
               seqNum = 5555;
           }
           
           txPacket.seqNum = seqNum ; 
           txPacket.n1 = (int)( ((float)sData.accX/(float)MICOM_DIV)+0.0 );
           txPacket.n2 = (int)( ((float)sData.accY/(float)MICOM_DIV)+0.0 );
           txPacket.n3 = (int)( ((float)sData.accZ/(float)MICOM_DIV)+0.0 ); 
           txPacket.n4 = (int)( ((float)sData.gyroX/(float)MICOM_DIV)+0.0 ); 
           txPacket.n5 = (int)( ((float)sData.gyroY/(float)MICOM_DIV)+0.0 ); 
           txPacket.n6 = (int)( ((float)sData.gyroZ/(float)MICOM_DIV)+0.0 );
           
            
//           UART5_Printf("%02d,%02d,%02d,%02d,%02d,%02d,%02d>\r\n", seqNum, txPacket.n1, txPacket.n2, txPacket.n3,  txPacket.n4,txPacket.n5,txPacket.n6);
                      
           unsigned int flashTemp_A1 = 0 ; 
           unsigned int flashTemp_A2 = 0 ;
           unsigned int flashTemp_G1 = 0 ; 
           unsigned int flashTemp_G2 = 0 ;
           
//           SensorData
           sData_.num = seqNum;
           if(trigger_type !=0)
           {
             sData_.num = 1234;
             trigger_type = 0;
           }
           sData_.accX = txPacket.n1;
           sData_.accY = txPacket.n2;
           sData_.accZ = txPacket.n3;
           sData_.gyroX = txPacket.n4;
           sData_.gyroY = txPacket.n5;
           sData_.gyroZ = txPacket.n6;
           sData_Write();
           //UART5_Printf("sData_Write-----------\r\n" );

           flashTemp_A1 = (0xFFFF&txPacket.n1)<<16 | 0xFFFF&seqNum ;
           flashTemp_A2 = (0xFFFF&txPacket.n3)<<16 | 0xFFFF&txPacket.n2 ;
           flashTemp_G1 = (0xFFFF&txPacket.n5)<<16 | 0xFFFF&txPacket.n4;         
           flashTemp_G2 = (0xFFFF&txPacket.n6)<<16 ;
           
           flashSaveList_A1.push_back( flashTemp_A1 );
           flashSaveList_A2.push_back( flashTemp_A2 );
           flashSaveList_G1.push_back( flashTemp_G1 );
           flashSaveList_G2.push_back( flashTemp_G2 );
           
           int nFlashListSize = flashSaveList_A1.size(); 
         
           if( nFlashListSize > 150 )
           { 
               flashSaveList_A1.pop_front(); 
               flashSaveList_A2.pop_front(); 
               flashSaveList_G1.pop_front(); 
               flashSaveList_G2.pop_front(); 
           }


                                    
           txPacket.end  = 0x3E ; 
           txPacket.end2 = 0x0D ; 
           txPacket.end3 = 0x0A ; 
           seqNum++;
          
#if(!SENSOR_DATA_OUT_DISABLE)           
           //¸±¸®Áî½Ã ¼¾¼­ µ¥ÀÌÅÍ Ãâ·Â ÇÏÁö ¸»°Í
         if( g_bResetMsgProcess == false )
         {
             HAL_UART_Transmit(&huart3, (uint8_t*)(&txPacket), sizeof(txPacket), 1000);
         }
#endif         
          
          
          
//------------------------------------------------------------------------------                     
#if ( PROCESS_TRIGGER == 1)             
  
          
       //-------------------------------------------------------------------
       float nn1 = ((float)(sData.accX))/8192 ; 
       float nn2 = ((float)(sData.accY))/8192 ; 
       float nn3 = ((float)(sData.accZ))/8192 ;
       
       float nn4 = ((float)(sData.gyroX))/65.536f ; 
       float nn5 = ((float)(sData.gyroY))/65.536f ; 
       float nn6 = ((float)(sData.gyroZ))/65.536f ;
       
       
        //-------------------------------------------------------------------
        // low pass filter 
        float lpf_X =  (float)nn1; 
        float lpf_Y =  (float)nn2; 
        float lpf_Z =  (float)nn3; 

        LPF( &lpf_X, &ax_1, &ax_2, &ax_3  ) ; 
        LPF( &lpf_Y, &ay_1, &ay_2, &ay_3  ) ; 
        LPF( &lpf_Z, &az_1, &az_2, &az_3  ) ; 
        
        LPF_G = pow( (pow(ax_1,2.0f)+pow(ay_1,2.0f)+pow(az_1,2.0f)) , 0.5f ) *100 ;
       
        // ÄõÅʹϾð G°ªÀ¸·Î º¯È¯Çؼ­ ÀÔ·ÂÀÌ ³´´Ù.   //// G´Â ¼¾¼­°ªÀ¸·Î ±×³É »ç¿ëÇÑ´Ù. XXX  
        gravity = pow(pow(nn1,2.0f)+pow(nn2,2.0f)+pow(nn3,2.0f),0.5f) * 100 ;
                 
        //-------------------------------------------------------------------
        // W(°¢¼Óµµ) °ªÀº ÀÌ°Å·Î »ç¿ë
        float lpf_gyX =nn4 ;
        float lpf_gyY =nn5 ;
        float lpf_gyZ =nn6 ;

        LPF( &lpf_gyX, &gx_1, &gx_2, &gx_3  ) ; 
        LPF( &lpf_gyY, &gy_1, &gy_2, &gy_3  ) ; 
        LPF( &lpf_gyZ, &gz_1, &gz_2, &gz_3  ) ; 
        
        double omegaSumAngle =  pow( (pow(gx_1,2.0f)+pow(gy_1,2.0f)+pow(gz_1,2.0f)) , 0.5f)  ;
        
        //----------------------------------------------------------------------
        // ÄõÅʹϾð 
        double gyro[3] = {gx_1, gy_1, gz_1 };  // ÀÚÀÌ·Î dgree 
        double accl[3] = {ax_1, ay_1, az_1 };
        double magn[3] = {0.,0,0 };

        ARS (gyro, accl, magn, 0.020); 

        double q[4] ={0, } ; 
        q[0] =_Q.s_ ; 
        q[1] =_Q.v_[0];//roll   
        q[2] =_Q.v_[1];//yaw 
        q[3] =_Q.v_[2];//pitch

        c_angX=asinf (2*(q[0]*q[2] - q[1]*q[3])) * RAD_TO_DEG;    // pitch
        c_angY=atan2f(2*(q[2]*q[3] + q[0]*q[1]),2*(q[0]*q[0] + q[3]*q[3])-1) * RAD_TO_DEG;  //roll 
        c_angZ=atan2f(2*(q[1]*q[2] + q[0]*q[3]),2*(q[0]*q[0] + q[1]*q[1])-1) * RAD_TO_DEG;  //roll
        //------------------------------------------------------------

        //-----------------------------------------------
        // CF ó¸®µÈ °¢µµ°ª, ±Û·Î¹ú º¯¼ö¿¡ ÀúÀå. 
        g_QT_angX = c_angX ;   // roll  ¥õ
        g_QT_angY = c_angZ ;   // yow   ¥÷
        g_QT_angZ = c_angY -90 ;   // pitch ¥è
        //-----------------------------------------------
        
        //----------------------------------------------------------------------
       
           int  checkOverCount = 0 ;  // 1g ÀÌ»óµÇ´Â °æ¿ì Ä«¿îÆÃ
           int  checkCount = 0 ;      // Ä«¿îÆÃ
           int  overCount2 = 0 ; 
           int  k = 0 ; 
          
           int  fallSum = 0, fallAvg=0  ; 
           int  omegaSum=0, omegaAvg=0;  
           
           char standState  = 'X' ; 
           
            
           int avgX=0, avgY=0, avgZ=0; 
           int fallAvg2 = fallAvg; // ȸÀüÇÏ´Â °æ¿ì fallAvg °ªÀ» °¨¼è ½ÃÅ°±â À§ÇÑ.. 
           
           // Angle °ªÀ¸·Î ¼öÁ¤ÇÑ´Ù. 
           // roll(X, red)  pitch(Z, blue). 
                  
          
           
           myGravList.push_back( LPF_G ); 
           myGravJumpList.push_back( gravity ); 
           myOmegaAngleList.push_back( (int)omegaSumAngle ); 
     
           unsigned int nListSize = myGravList.size(); 
           if( nListSize > 40 )
           {
               myGravList.pop_front(); 
               myGravJumpList.pop_front(); 
               myOmegaAngleList.pop_front(); 
              
               nListSize-- ; 
                      
               std::list<int>::iterator it; 
               
               k = 0 ; 
               for (it = myOmegaAngleList.begin(); it != myOmegaAngleList.end(); ++it) 
               {
                   omegaAngleMean[k] =  (*it) ; 
                   
                   if( k >=  nListSize - 5 )
                   {
                     omegaSum += omegaAngleMean[ k ] ; 
                   }
                   k++ ;
               }
               
               omegaAvg = omegaSum / 5 ;  // omegaAvg´Â ¸¶Áö¸· 5°³ Æò±ÕÀ¸·Î ¼öÁ¤ 
               
               
               k = 0 ; 
               for (it = myGravList.begin(); it != myGravList.end(); ++it) 
               {
                   gravityMean[k] =  (*it) ; 
                  
                   if( k >=  nListSize - CONTINUE_COUNT )
                   {
                     fallSum += gravityMean[k] ; 
                   }
                     
                   k++ ;
               }
               
               fallAvg =  fallSum / CONTINUE_COUNT ; 
                              
               
               k = 0 ; 
               for (it = myGravJumpList.begin(); it != myGravJumpList.end(); ++it) 
               {
                   gravityJump[k] =  (*it) ; 
                   k++ ;
               }
                               
               
                // ÇÊÅÍ Àû¿ëÀ¸·Î Æò±ÕÇÏÁö ¾Ê°í »ç¿ë..
                avgX = g_QT_angX ; 
                avgY = g_QT_angY ; 
                avgZ = g_QT_angZ ; 
               
                
               //#------------------------------------------------------
               //# ¿¬¼¼´ë ³«»ó Á¶°ÇÀÎ °æ¿ì.
               //# ACC  root(square sum) < 0.82g ( 8192 * 0.82 /100 = 67 )
               //# GYRO root(square sum) > 47.3 degree
               //# roll  > 28¡Æ degree  ( 90µµ->8192, 28µµ->  2548/100 =% 25 --> 40 test )
               //# pitch > 45¡Æ degree  ( 90µµ->8192, 45µµ->  4096/100 =% 40 --> 56 test )
               //#------------------------------------------------------
              
               #define       FALL_START_G            60      // Ã߶ô ÆÇ´Ü ½ÃÀÛ °ª. 
               #define       JUMP_START_G            130     // Á¡ÇÁ ÆÇ´Ü ½ÃÀÛ °ª. 
               
               #define       OMEGA_ANGLE_LIMIT       160
               #define       OMEGA_ANGLE_LIMIT_2     360
               #define       FALL_AVG_LIMIT          40       // ÀÏ¹Ý Ã߶ô ¹× Á¡ÇÁ Ã߶ô. 
               #define       FALL_AVG_SPIN_LIMIT     50       // ȸÀü µé¾î°£ Ã߶ô ¹× Á¡ÇÁ Ã߶ô. 
                                      
               
               // C15 ÀåÂø½Ã, ¼­ ÀÖ´Â »óÅ ¼¾¼­ ±âÁØ°ª. 
               #define       ROLL_ANGLE_LIMIT        38   // ROLLÀº  38º¸´Ù ÀÛ°í, -38º¸´Ù Å©´Ù. ȸÀüÇÏ´Â °æ¿ì¿¡´Â 38ÀÌ ÀÛÀº °Í °°´Ù. 56 ¼öÁ¤ ÈÄ ÆÐŶ °ª ¹Ù²Ù°í 45·Î ¼öÁ¤
               #define       PITCH_ANGLE_FRONT      -45   // PITCH´Â ¾ÕÀ¸·Î ³Ñ¾îÁü. -45º¸´Ù Å©´Ù. 
               #define       PITCH_ANGLE_BACK        35   // PITCH´Â µÚ·Î ³Ñ¾îÁü. 35
                
               //#define       YAW_ANGLE_LIMIT         40   // YAW ´Â -25 º¸´Ù ÀÛÀº »óÅ À¯Áö. 
               
               
               if( ( avgX > -ROLL_ANGLE_LIMIT  && avgX < ROLL_ANGLE_LIMIT ) &&  
                   ( avgZ > PITCH_ANGLE_FRONT  && avgZ < PITCH_ANGLE_BACK ) )
                     // avgY < YAW_ANGLE_LIMIT )
               {
                   standState = 'O' ;
               }
               else
               {
                   standState = 'X' ;
               }
               
                   
               
              
              
               //------------------------------------------------------------------
               // ¾Ë°í¸®Áò ¼öÁ¤. 
               // 1. Ã߶ô»óÅ ī¿îÆà 
               // 2. Ã߶ô ½ÃÀÛ Á¶°ÇÀÌ °­Á¦·Î À§·Î ´øÁø °æ¿ì Á¦¿Ü. 
               // 3. À§·Î ´øÁø °æ¿ì¶óµµ ¿¬¼Ó½Ã°£(18) + 15 Á¤µµÀÎ °æ¿ì´Â °Ý¹ß. 
               // 4. gravityMean == 6  ->  =% 0.75 g
               //    gravityMean == 5  ->  =% 0.625 g
               //  
               //------------------------------------------------------------------
               
               // [ 1G -> 100 À¸·Î ´ÜÀ§ ¼öÁ¤ ]
               if( gravityMean[ nListSize -1 ] <= FALL_START_G )  // ¸Ç ¸¶Áö¸· µ¥ÀÌÅÍ°¡ 5º¸´Ù ÀÛÀº °æ¿ì¸¸
               {
                 
                   for ( int k = 0 ; k< nListSize ; k++)
                   {   
                       if( gravityMean[ nListSize -1 - k ]  <= FALL_START_G )
                         checkCount ++ ; 
                       else
                         break; 
                   }
                                    
                  
                   // --> ·Õ Á¡ÇÁ ¹®Á¦ »ý±è ´Ù½Ã 40°³ Àüü·Î. 
                   for ( int k = nListSize-1 ; k >=0 ; k-- )   
                   {   
                       // [ 1G -> 100 À¸·Î ´ÜÀ§ ¼öÁ¤ ]  
                       if( gravityJump[ k ]  >= JUMP_START_G ) 
                           checkOverCount ++ ; 
                   }
                  
                   
                   if( g_bTriggerON == false)
                   {
                       if(  checkOverCount > 0 )//======================================================== Á¡ÇÁ O
                       {   
                           if( standState == 'O' )
                             overCount2 = (int)(((float)checkOverCount * 1.0)) ;  // 1.2 test ÇÊ¿ä
                           else
                              overCount2 = (int)((float)checkOverCount * 0.8) ; // lpf g Àû¿ë, 0.9·Î¼öÁ¤. 
                                                                                
                           
                           if( omegaAvg < OMEGA_ANGLE_LIMIT )//-----------------------------------  Á¡ÇÁ O ȸÀü X
                           {
                               if( checkCount >= ( CONTINUE_COUNT + overCount2) )
                               {
                                   trigger_type = 3;
                                 trigger_process_start(3); // <<<<------------------------### Æ®¸®°Å ŸÀÔ 3 ¹ø

                               } 
                           }
                           else//------------------------------------------------------------------ Á¡ÇÁ O ȸÀü O
                           {
                           
                               if( omegaAvg < OMEGA_ANGLE_LIMIT_2 )
                               {
                                  int diffOmega = omegaAvg - OMEGA_ANGLE_LIMIT ;  // ȸÀü Å©±â. 

                                  // Â÷ÀÌ°¡ 200 Á¤µµÀ϶§, - 20%  ¸¦ Çϵµ·Ï.  
                                  // Â÷ÀÌ°¡ 100 Á¤µµÀ̸é, - 10%  ÇÔ. 

                                  float scale = ( 0.2 * diffOmega /200) ; 
                                  fallAvg2 = fallAvg -  fallAvg * scale ; 

                                  ////fallAvg2 = (int)(fallAvg * 0.9);
                                  
                                 
                                 if( fallAvg2 < FALL_AVG_LIMIT  &&  
                                     checkCount >= ( CONTINUE_COUNT + overCount2) / 4 )   //  /4 Å×½ºÆ® ÇÊ¿ä
                                 {
                                   trigger_type = 4;
  
                                     trigger_process_start(4); // <<<<-----------------------### Æ®¸®°Å ŸÀÔ 4 ¹ø
        
                                 }
                               }
                               
                            }
                       }
                       else//============================================================================= Á¡ÇÁ X
                       {
                           if( standState == 'O' )
                                overCount2 = 0 ; 
                           else
                                overCount2 = 2 ; 
                                                                                     

                           if( omegaAvg < OMEGA_ANGLE_LIMIT )//------------------------------------  Á¡ÇÁ X ȸÀü X
                           {  
                               if (  checkCount >= ( CONTINUE_COUNT - overCount2)  )
                               {
                                 // °¡Àå ±âº»ÀûÀÎ ÀÚÀ¯³«ÇÏ ½Ã³ª¸®¿À.
                                   trigger_type = 4;

                                 trigger_process_start(1); // <<<<------------------------### Æ®¸®°Å ŸÀÔ 1 ¹ø 
                                 
                               }
                            }
                            else//----------------------------------------------------------------- Á¡ÇÁ X ȸÀü O
                            {
                               if( omegaAvg < OMEGA_ANGLE_LIMIT_2 ) 
                               {
                                   int diffOmega = omegaAvg - OMEGA_ANGLE_LIMIT ;  // ȸÀü Å©±â. 

                                   // Â÷ÀÌ°¡ 200 Á¤µµÀ϶§, - 20%  ¸¦ Çϵµ·Ï.  
                                   // Â÷ÀÌ°¡ 100 Á¤µµÀ̸é, - 10%  ÇÔ. 

                                   float scale = ( 0.2 * diffOmega /200) ; 
                                   fallAvg2 = fallAvg -  fallAvg * scale ; 
                                                             
                                   if( fallAvg2 < FALL_AVG_LIMIT  &&  
                                       checkCount >= ( CONTINUE_COUNT - overCount2) / 4 )    //  /4 Å×½ºÆ® ÇÊ¿ä
                                   {
                                   trigger_type = 2;

                                     

                                     trigger_process_start(2); // <<<<------------------------### Æ®¸®°Å ŸÀÔ 2 ¹ø
                                   
                                   }
                               
                               }
                            }
                       }
                       
                   }//if( g_bTriggerON == false)
                   
                  
                  
                   // ±âŸ Ã߶ô Áö¼ÓÀÌ 600ms ÀÌ»ó µÇ´Â °æ¿ì´Â ¹«Á¶°Ç °Ý¹ßµÇ¾î¾ß ÇÑ´Ù. 
                   if ( g_bTriggerON == false  &&  
                        checkCount >= CONTINUE_COUNT + 18  )  // 12 + 18 =  30*20ms --> 600ms 
                   {
                       // À§ Á¶°Ç¿¡ ¾È°É¸®°í, ¹«Á¶°Ç ½Ã°£ÀÌ contiueCount +12 ÀÌ¸é °Ý¹ß. 
                       // Æ®¸®°Å ŸÀÔ 9 ¹ø 
                     trigger_type = 9;

                       trigger_process_start(9) ; 

                   }
                  
                                     
                  
                  // µ¥ÀÌÅÍ ¼öÁý¿ë Á¦°Å 
                  //UART5_Printf("ck,v,v2(%02d,%02d,%02d) R,Y,P,st(%02d,%02d,%02d,%c) g,lG,fA,fA2,omgA(%d,%d, %d,%d,%d)\r\n", 
                  //           checkCount, checkOverCount, overCount2,  g_QT_angX,g_QT_angY,g_QT_angZ, standState,  
                  //           (int)gravity, (int)LPF_G, fallAvg, fallAvg2, (int)omegaAvg );

                  
               } 
               else  //// if( gravityMean[ nListSize -1 ] <= 5 )  // ¸Ç ¸¶Áö¸· µ¥ÀÌÅÍ°¡ 5º¸´Ù ÀÛÀº °æ¿ì¸¸
               {
                   // ¿¬¼ÓµÇ°Ô 0.625g ÀÌÇϸ¦ À¯ÁöÇÏÁö ¸øÇÏ¸é ºñ±³°ªµé ¸®¼ÂÇÑ´Ù. 
                   checkCount = 0; 
                   checkOverCount = 0; 
               }


//               UART5_Printf("ck,v,v2(%02d,%02d,%02d) R,Y,P,st(%02d,%02d,%02d,%c) g,lG,fA,fA2,omgA(%d,%d, %d,%d,%d)\r\n", 
//                             checkCount, checkOverCount, overCount2,  g_QT_angX,g_QT_angY,g_QT_angZ, standState,  
//                             (int)gravity, (int)LPF_G, fallAvg, fallAvg2, (int)omegaAvg );
               
               
           }

#endif  // #if (PROCESS_TRIGGER == 1)
//------------------------------------------------------------------------------            
       } // end of if( bSensorReadToggle == true) // 20ms ÆÇ´ÜÁֱ⠸ÂÃß±â À§Çؼ­.
       bSensorReadToggle = !bSensorReadToggle ; 
       //-------------------------------------------------------------------------------------
      
   }// end of TIMER 7	
    
}


void trigger_process_start( uint8_t triggerType )
{
  // °Ý¹ß.. ÀÌÈÄ 5ms ŸÀ̸ӿ¡¼­ 1Ãʸ¶´Ù °è¼Ó °Ý¹ßÇÔ. 

  HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_RESET); // ÆĶõºÒ ²û
  
  HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_SET);
  HAL_GPIO_WritePin(SHOOT_EN_GPIO_Port, SHOOT_EN_Pin , GPIO_PIN_SET );
  HAL_GPIO_WritePin(SHOOT_EN_1_GPIO_Port, SHOOT_EN_1_Pin , GPIO_PIN_SET );
  g_bResetMsgProcess = true ; 
 
  // ù¹ø° ¾×Ãò¿¡ÀÌÅÍ °Ý¹ßÈÄ ¾à =% 2.5ms delay  
  PACKET txPacketFire = {0x3C, 't','r', (char)(0x30+triggerType), '_', 'j','-', 's','-', 0x3C,0x0D,0x0A} ;   // jump, spin 
  
  if     ( triggerType == 1 ){ txPacketFire.n5='X'; txPacketFire.reserved='X'; }
  else if( triggerType == 2 ){ txPacketFire.n5='X'; txPacketFire.reserved='O'; }
  else if( triggerType == 3 ){ txPacketFire.n5='O'; txPacketFire.reserved='X'; }
  else if( triggerType == 4 ){ txPacketFire.n5='O'; txPacketFire.reserved='O'; }
  else if( triggerType == 9 ){ txPacketFire.n5='-'; txPacketFire.reserved='-'; }
  
  HAL_UART_Transmit(&huart3, (uint8_t*)(&txPacketFire), sizeof(txPacketFire), 1000);

  HAL_GPIO_WritePin(SHOOT_EN_2_GPIO_Port, SHOOT_EN_2_Pin, GPIO_PIN_SET );
  g_nTriggerONCount = 0 ;

  Flash_Save_SensorData( triggerType );
  Trigger_Write(triggerType);
  
  g_bResetMsgProcess = false ; 
  g_bTriggerON = true ; 
  
  // Trigger ÀÛµ¿, ¸¶ÀÌÄÄ¿¡¼­, Q=2, fall=1 ·Î º¸³½´Ù.
  RF_Printf("Q=2;1;%d,%02d,%03d,\n", g_bTriggerON, (g_battAdcVal/2300)*100, BT_seqNum++ );
}



void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin)
{

}



void HAL_UART_TxCpltCallback(UART_HandleTypeDef *huart)
{
    if( huart->Instance == USART1 )
    { 
    }
    else if( huart->Instance == USART3 )
    {
      // DMA »ç¿ë½Ã
      // HAL_UART_DMAStop(&huart3); 
      
    }

}


void HAL_UART_RxCpltCallback(UART_HandleTypeDef *huart)
{
    if( huart->Instance == USART1 )
    { 
      // UART1 --> UART3 À¸·Î Àü´Þ 
      uartTransQ.push( RxBufUart1 ) ; 
      bTransferRFUartToDebugUart = true ; 
    }
    else if( huart->Instance == USART3 )
    { 
      // UART3 ÀÔ·Â ÆÄ½Ì ºÎºÐ, ³ªÁß¿¡ ´Ù½Ã ó¸® ÇÒ °Í. 

        for( int i=0 ; i < 8 ; i++ )
        {
            RxBuf[ RxBufPos % 200 ] = RxBufTrans[i] ; 
            RxBufPos++ ; 
        }
        
        for( int i= RxBufPos ; i > 7 ; i-- )
        {

            if( RxBuf[ i - 7 ] == 'A' &&
                RxBuf[ i - 6 ] == 'T' &&
                RxBuf[ i - 5 ] == '+' &&
                RxBuf[ i - 4 ] == 'S' &&
                RxBuf[ i - 3 ] == 'H' &&
                RxBuf[ i - 2 ] == 'O' &&
                RxBuf[ i - 1 ] == 'W' )
            {
                RF_Printf("AT+SHOW\r"); 

                memset(RxBuf,0,sizeof(RxBuf)) ;
                RxBufPos=0 ; 
                break; 
            
            }
            else if
              ( RxBuf[ i - 7 ] == 'A' &&
                RxBuf[ i - 6 ] == 'T' &&
                RxBuf[ i - 5 ] == '+' &&
                RxBuf[ i - 4 ] == 'T' &&
                RxBuf[ i - 3 ] == 'E' &&
                RxBuf[ i - 2 ] == 'S' &&
                RxBuf[ i - 1 ] == 'T' )
            {
                RF_Printf("AT+DATA=1\r"); 

                memset(RxBuf,0,sizeof(RxBuf)) ;
                RxBufPos=0 ; 
                break; 
            
            }
            
        }
         

    }

}

int main(void)
{
    int i=0 ; 
    HAL_Init();
    SystemClock_Config();
    for( i = 0 ; i < 10; i++)  // adc value buff ÃʱâÈ­.
      adcValArr[i] = 2800 ; 
    MX_GPIO_Init();
    MX_ADC1_Init();
    MX_I2C1_Init();   
    MX_I2C2_Init();
    MX_TIM6_Init();
    MX_TIM7_Init();
    MX_QUADSPI_Init();
    MX_DMA_Init();
    MX_USART1_UART_Init();
    MX_USART3_UART_Init();
    MX_RTC_Init();
    W25Q_STATE flashInit = W25Q_Init();
    W25Q_ReadID(&IsFlash);
    //W25Q_ReadByte(&IsFlash,0,0+(16*0)+(256*511));
    
    
    if(IsFlash == 0)
    {
      while(true)
      {
          // ¿ÜÀå¸Þ¸ð¸® Áغñ ¾ÈµÇ¸é : RedÁ¡¸ê-VioletÁ¡¸ê
          HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_SET); 
          HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_RESET);
          HAL_Delay(500);
          HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_SET);              
          HAL_Delay(500);  
          
          UART5_Printf("External Memory is not OK!!!! c=%d \r\n", tmepCount++ );
      }
    }			
//    //RTC_Init====================================
//    if(__HAL_PWR_GET_FLAG(PWR_FLAG_WU) != RESET)
//    {
//      __HAL_PWR_CLEAR_FLAG(PWR_FLAG_WU);
//    }
//      /* Check the status of standby flag SB*/
//    if (__HAL_PWR_GET_FLAG(PWR_FLAG_SB) == RESET)
//    {
//      MX_RTC_Init();
//    }
// 
//    else
//    {
//      /*Resuming from standby routine */
//      __HAL_PWR_CLEAR_FLAG(PWR_FLAG_SB);
//    }
//    //=============================================
    
    HAL_ADC_Start_IT(&hadc1);
    bool bGyroInit = GyroInit(); 
    if( bGyroInit == false )
    { 
        while(true)
        {
            // ¼¾¼­ ¾È ÀâÈ÷¸é : Blue Á¡¸ê-VioletÁ¡¸ê
            HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_SET); 
            HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_RESET);
            HAL_Delay(500);
            HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_SET);              
            HAL_Delay(500);  
        
            UART5_Printf("Gyro sensor detect fail!!!! c=%d \r\n", tmepCount++ );    
        }
    }

//check
//     getDnT();
//      UART5_Printf("ÇöÀç ½Ã°£ :  %04d-%02d-%02d %02d:%02d:%02d\r\n", 
//         B2D(dnt_.Year)+1900, B2D(dnt_.Month), B2D(dnt_.Date),
//         B2D(dnt_.Hours), B2D(dnt_.Minutes), B2D(dnt_.Seconds));
       
//////////////////////////////////////////////////////////////////
      
    //exFlash_Reset();
//     W25Q_EraseChip();  
    DnT_Init();
    sData_Init();

    InitARS() ;  // ÄõÅʹϾ𠽺Į¶ó,º¤ÅÍ°ª ÃʱâÈ­ ÇÊ¿ä.
    //---------------------------------------
    
    //HAL_UART_Receive_DMA(&huart1,(uint8_t*)RxBufUart1,16) ;
    //HAL_UART_Receive_DMA(&huart1,(uint8_t*)RxBufUart1,2) ;
      
    //HAL_UART_Receive_DMA(&huart3,(uint8_t*)RxBufTrans,8) ;
    
    // Acutator R detect
    bool bPort1 = HAL_GPIO_ReadPin( ACTUATOR_DETECT_PORT, ACTUATOR_DETECT_1_Pin ) ;
    bool bPort2 = HAL_GPIO_ReadPin( ACTUATOR_DETECT_PORT, ACTUATOR_DETECT_2_Pin ) ;
            
    if( !(bPort1 == false && bPort2 == false) )
    {
        // bPort1==false && bPort2==false // --> Actuator detect OK 
      
        UART5_Printf("Actuator detect fail!!!! c=%d \r\n", tmepCount++ );    
      
#if(ACUTUATOR_CHECK_ENABLE)
        // 2021.05.03
        // ¾×Ãò¿¡ÀÌÅÍ ¿¬°áÀÌ Á¦´ë·Î ¾ÈµÇ¸é ºÎÆà ¾ÈµÇ°í, µ¿ÀÛ ¾ÈµÇµµ·Ï ÇÑ´Ù. 
        while(true)
#endif        
        {
            // Red-Blue Á¡¸ê
            HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_SET); 
            HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_RESET);
            HAL_Delay(500);
            HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_SET); 
            HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_RESET);             
            HAL_Delay(500);
            
            UART5_Printf("Actuator detect fail!!!! c=%d \r\n", tmepCount++ );    
        }
        
        
    }
  
    //--------------------------------------------------------------------------------------

#if(BLE_MODE)
    // RF MODULE POWER EN 
    HAL_GPIO_WritePin( RF_MOD_PWR_EN_PORT, RF_MOD_PWR_EN_Pin, GPIO_PIN_SET);
    //// HAL_GPIO_WritePin( RF_MOD_PWR_EN_PORT, RF_MOD_PWR_EN_Pin, GPIO_PIN_RESET);
    HAL_Delay(100);
    
    // »ç¿ë¾ÈÇÔ
    //// HAL_GPIO_WritePin( RF_MOD_SLEEP_PORT, RF_MOD_SLEEP_Pin, GPIO_PIN_SET);
    
    // BT ¸ðµâ Ãʱ⠺ÎÆýà ¸®¼Â ½ÃÄö½º µé¾î°¡¾ß Á¤»ó µ¿ÀÛÇÔ.
    // RESET ÇÉÀ¸·Î LORA¸ðµâ/BT¸ðµâ  ÆÄ¿ö ÄÁÆ®·Ñ ( Ãʱ⠺ÎÆýà ¸®¼ÂÇѹø ÇØÁØ´Ù )
    HAL_GPIO_WritePin( RF_MOD_RESET_PORT, RF_MOD_RESET_Pin, GPIO_PIN_SET);
    HAL_Delay(10);
    HAL_GPIO_WritePin( RF_MOD_RESET_PORT, RF_MOD_RESET_Pin, GPIO_PIN_RESET);
    HAL_Delay(100);
    HAL_GPIO_WritePin( RF_MOD_RESET_PORT, RF_MOD_RESET_Pin, GPIO_PIN_SET);
    HAL_Delay(10);
    //--------------------------------------------------------------------------------------

    // BT Á¤»ó µ¿ÀÛ Áغñ ¾ÈµÇ¸é Red Á¡µî 
    //ÃßÈÄ ¾÷µ¥ÀÌÆ®, ÇÉüũ ¸»°í RX µ¥ÀÌÅÍ Ã¼Å©·Î ¼öÁ¤
//    bool bPower = HAL_GPIO_ReadPin( RF_MOD_PWR_EN_PORT, RF_MOD_PWR_EN_Pin ) ;
//    bool bReset = HAL_GPIO_ReadPin( RF_MOD_RESET_PORT, RF_MOD_RESET_Pin ) ;
//    bool bTX = HAL_GPIO_ReadPin( GPIOB, GPIO_PIN_6 ) ;
//    bool bRX = HAL_GPIO_ReadPin( GPIOB, GPIO_PIN_7 ) ;
//    
//    if( (bPower == false || bReset == false || bTX == false || bRX == false) )
//    {
//        HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_RESET);
//        while(true)
//        {   
//            HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_SET); 
//            UART5_Printf("BT is NOT ready for use!!!! c=%d \r\n", tmepCount++ );    
//        }
//    }
        
#else 
    __HAL_UART_DISABLE(&huart1);
#endif     
    
    for( i=0; i<1; i++)
    {
        // Àü¿ø on : RedÁ¡¸ê1-BlueÁ¡¸ê1-RedÁ¡¸ê2-BlueÁ¡¸ê2
        HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_SET); HAL_Delay(500);
        HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_RESET); HAL_Delay(100);
        
        HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_SET); HAL_Delay(500);
        HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_RESET); HAL_Delay(100);;

        HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_SET); HAL_Delay(500);
        HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_RESET); HAL_Delay(100);
        
        HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_SET); HAL_Delay(500);
        HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_RESET); //HAL_Delay(100);      
    }
      
    UART5_Printf("Start! CLK=%dMHz, Ver=%s \r\n", g_HCLK/1000, VersionInfo );    

    PACKET txPacketFire = {0x3C, 'r','s','t','-','c','1','.','5', 0x3C,0x0D,0x0A} ; 
    HAL_UART_Transmit(&huart3, (uint8_t*)(&txPacketFire), sizeof(txPacketFire), 1000);
    
#if(STORED_DATA_PRINT_ENABLE)
    Flash_Load_SensorData();
    DnT_Load(); 
#endif    
    
    
    
    
    //LORA Send test message 
    // RF_Printf("AT+DATA=20210120TESTUPLOAD\r" ); 
    
    // RF_Printf("AT+APKE=35dd427b17e709b763e07ece7ced2865\r" ); 
          
    
    
    
    
    HAL_TIM_Base_Start_IT(&htim6);
    HAL_TIM_Base_Start_IT(&htim7);

    while (1)
    {
        if( bTransferRFUartToDebugUart )
        {
          int n = uartTransQ.size(); 
          for( int k=0; k<n; k++)
          {
            if( huart1.gState == HAL_UART_STATE_READY)
            {
              uartTransQ.pop( RxBufUart2 ); 
              HAL_UART_Transmit( &huart3, (uint8_t*)RxBufUart2, 2, 100 ); 
              
              //----------------------------------------------------------------
              // Android ÆùÀÌ ¿¬°áµÇ¸é [Android~~~~~] ¿¬°áÁ¤º¸¸¦ º¸³½´Ù. 
              // BT¿¡¼­ ¸¶ÀÌÄÄ¿¡ Àü´ÞÇϸé, ¸¶ÀÌÄÄ¿¡¼­ Àü¼ÛÁֱ⸦ 1ºÐÀ¸·Î ¼öÁ¤.
              if( RxBufUart2[0] == '~' && RxBufUart2[1] == '~' )
              {
                  bt_Android_conn_2 = true; 
                  UART5_Printf("\r\n[Android APP]!\r\n");    
              }
              
            }
            
          }
        }
                      
// ¹öŬ½ºÀ§Ä¡ Àû¿ë
// 1Â÷ »ï¼º¹°»ê¿ë¿¡¼­´Â ÀÏ´Ü Á¦°ÅÇÔ. Åë½Å ¸ðµâ ÀåÂø½Ã Àû¿ë.            
/*            
          if( __HAL_UART_GET_FLAG( &huart1, UART_FLAG_IDLE) )
          {
                //uint8_t remainSize = __HAL_DMA_GET_COUNTER( huart1.hdmarx ); 
                uint8_t remainSize = huart1.hdmarx->Instance->CNDTR ; 
                if( remainSize > 0 )
                {
                  uint8_t tempBuf[8] ={0,};  // USART1->RDR ; 
                  memcpy( tempBuf, huart1.pRxBuffPtr, remainSize) ; 
                    
                  HAL_UART_Transmit( &huart3, (uint8_t*)&tempBuf, remainSize, 100 ); 
                  
                  __HAL_UART_CLEAR_IDLEFLAG(&huart1) ; 

    
                  HAL_UART_DMAStop( &huart1 ) ;
                  //// CLEAR_BIT(huart1.Instance->CR3, USART_CR3_DMAR);
                  ////huart1.hdmarx->Instance->CCR  &= (~DMA_CCR_EN) ; 
                  huart1.hdmarx->Instance->CNDTR = 0 ; 
                  ////huart1.hdmarx->Instance->CCR  |=  DMA_CCR_EN ; 
                  //// SET_BIT(huart1.Instance->CR3, USART_CR3_DMAR);
                  HAL_UART_Receive_DMA(&huart1,(uint8_t*)RxBufUart1,2) ;
                }
*/          
    
    }

}




void SystemClock_Config__24MHz(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_HSI|RCC_OSCILLATORTYPE_LSE;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.LSEState = RCC_LSE_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 1;
  RCC_OscInitStruct.PLL.PLLN = 12;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV7;
  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV4;
  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_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV2;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1|RCC_PERIPHCLK_USART3
                              |RCC_PERIPHCLK_I2C1|RCC_PERIPHCLK_ADC;
  
  PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_SYSCLK;
  PeriphClkInit.Usart3ClockSelection = RCC_USART3CLKSOURCE_SYSCLK;
  PeriphClkInit.I2c1ClockSelection = RCC_I2C1CLKSOURCE_SYSCLK;  
  PeriphClkInit.AdcClockSelection = RCC_ADCCLKSOURCE_SYSCLK;
   
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure the main internal regulator output voltage
  */
  if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK)
  {
    Error_Handler();
  }

   
  g_HCLK = HAL_RCC_GetHCLKFreq()/1000 ; 
  HAL_SYSTICK_Config(g_HCLK);  
  
  HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
  HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}



// 48MHz ¼ÂÆÃ
void SystemClock_Config__48MHz(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_HSI|RCC_OSCILLATORTYPE_LSE;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.LSEState = RCC_LSE_ON;
  RCC_OscInitStruct.HSICalibrationValue = RCC_HSICALIBRATION_DEFAULT;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSI;
  RCC_OscInitStruct.PLL.PLLM = 1;
  RCC_OscInitStruct.PLL.PLLN = 12;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV7;
  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV4;
  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_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1|RCC_PERIPHCLK_USART3
                              |RCC_PERIPHCLK_I2C1|RCC_PERIPHCLK_ADC;
  PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_SYSCLK;
  PeriphClkInit.Usart3ClockSelection = RCC_USART3CLKSOURCE_SYSCLK;
  PeriphClkInit.I2c1ClockSelection = RCC_I2C1CLKSOURCE_SYSCLK;
  PeriphClkInit.AdcClockSelection = RCC_ADCCLKSOURCE_SYSCLK;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure the main internal regulator output voltage
  */
  if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK)
  {
    Error_Handler();
  }
  
  g_HCLK = HAL_RCC_GetHCLKFreq()/1000 ; 
  HAL_SYSTICK_Config(g_HCLK);  
  
  HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
  HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}





void SystemClock_Config__HSE_24MHz(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_HSE|RCC_OSCILLATORTYPE_LSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.LSEState = RCC_LSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 1;
  RCC_OscInitStruct.PLL.PLLN = 12;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV7;
  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  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_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV2;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_RTC|RCC_PERIPHCLK_USART1|RCC_PERIPHCLK_USART3
                              |RCC_PERIPHCLK_I2C1|RCC_PERIPHCLK_ADC;
  PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK2;
  PeriphClkInit.Usart3ClockSelection = RCC_USART3CLKSOURCE_PCLK1;
  PeriphClkInit.I2c1ClockSelection = RCC_I2C1CLKSOURCE_PCLK1;
  PeriphClkInit.AdcClockSelection = RCC_ADCCLKSOURCE_PLLSAI1;
  PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
  PeriphClkInit.PLLSAI1.PLLSAI1Source = RCC_PLLSOURCE_HSE;
  PeriphClkInit.PLLSAI1.PLLSAI1M = 1;
  PeriphClkInit.PLLSAI1.PLLSAI1N = 8;
  PeriphClkInit.PLLSAI1.PLLSAI1P = RCC_PLLP_DIV7;
  PeriphClkInit.PLLSAI1.PLLSAI1Q = RCC_PLLQ_DIV2;
  PeriphClkInit.PLLSAI1.PLLSAI1R = RCC_PLLR_DIV4;
  PeriphClkInit.PLLSAI1.PLLSAI1ClockOut = RCC_PLLSAI1_ADC1CLK;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure the main internal regulator output voltage
  */
  if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK)
  {
    Error_Handler();
  }
   
  g_HCLK = HAL_RCC_GetHCLKFreq()/1000 ; 
  HAL_SYSTICK_Config(g_HCLK);  
  
  HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
  HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}




void SystemClock_Config__HSE_48MHz(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
  RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};
  
  HAL_PWR_EnableBkUpAccess();
  __HAL_RCC_LSEDRIVE_CONFIG(RCC_LSEDRIVE_LOW);
  
  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE|RCC_OSCILLATORTYPE_LSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.LSEState = RCC_LSE_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLM = 1;
  RCC_OscInitStruct.PLL.PLLN = 12;
  RCC_OscInitStruct.PLL.PLLP = RCC_PLLP_DIV7;
  RCC_OscInitStruct.PLL.PLLQ = RCC_PLLQ_DIV2;
  RCC_OscInitStruct.PLL.PLLR = RCC_PLLR_DIV2;
  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_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
  PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_RTC|RCC_PERIPHCLK_USART1|RCC_PERIPHCLK_USART3
                              |RCC_PERIPHCLK_I2C1|RCC_PERIPHCLK_I2C2|RCC_PERIPHCLK_ADC;
  PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_PCLK2;
  PeriphClkInit.Usart3ClockSelection = RCC_USART3CLKSOURCE_PCLK1;
  PeriphClkInit.I2c1ClockSelection = RCC_I2C1CLKSOURCE_PCLK1;  
  PeriphClkInit.I2c2ClockSelection = RCC_I2C2CLKSOURCE_PCLK1;
  PeriphClkInit.AdcClockSelection = RCC_ADCCLKSOURCE_PLLSAI1;
  PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
  PeriphClkInit.PLLSAI1.PLLSAI1Source = RCC_PLLSOURCE_HSE;
  PeriphClkInit.PLLSAI1.PLLSAI1M = 1;
  PeriphClkInit.PLLSAI1.PLLSAI1N = 8;
  PeriphClkInit.PLLSAI1.PLLSAI1P = RCC_PLLP_DIV7;
  PeriphClkInit.PLLSAI1.PLLSAI1Q = RCC_PLLQ_DIV2;
  PeriphClkInit.PLLSAI1.PLLSAI1R = RCC_PLLR_DIV4;
  PeriphClkInit.PLLSAI1.PLLSAI1ClockOut = RCC_PLLSAI1_ADC1CLK;
  if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure the main internal regulator output voltage
  */
  if (HAL_PWREx_ControlVoltageScaling(PWR_REGULATOR_VOLTAGE_SCALE1) != HAL_OK)
  {
    Error_Handler();
  }
   
  g_HCLK = HAL_RCC_GetHCLKFreq()/1000 ; 
  HAL_SYSTICK_Config(g_HCLK);  
  
  HAL_SYSTICK_CLKSourceConfig(SYSTICK_CLKSOURCE_HCLK);
  HAL_NVIC_SetPriority(SysTick_IRQn, 0, 0);
}



void SystemClock_Config(void)
{
  //// SystemClock_Config__24MHz() ;
  //// SystemClock_Config__48MHz() ;
  
#if (CLOCK_HSE_48MHz)
  SystemClock_Config__HSE_48MHz() ;
#else
  SystemClock_Config__HSE_24MHz() ; 
#endif

}




static void MX_ADC1_Init(void)
{

  ADC_ChannelConfTypeDef sConfig = {0};

  /** Common config
  */
  hadc1.Instance = ADC1;
  hadc1.Init.ClockPrescaler = ADC_CLOCK_ASYNC_DIV2;
  hadc1.Init.Resolution = ADC_RESOLUTION_12B;
  hadc1.Init.DataAlign = ADC_DATAALIGN_RIGHT;
  hadc1.Init.ScanConvMode = ADC_SCAN_DISABLE;
  hadc1.Init.EOCSelection = ADC_EOC_SEQ_CONV; //
  hadc1.Init.LowPowerAutoWait = DISABLE;
  hadc1.Init.ContinuousConvMode = DISABLE;
  hadc1.Init.NbrOfConversion = 1;
  hadc1.Init.DiscontinuousConvMode = DISABLE;
  hadc1.Init.ExternalTrigConv = ADC_SOFTWARE_START;
  hadc1.Init.ExternalTrigConvEdge = ADC_EXTERNALTRIGCONVEDGE_NONE;
  hadc1.Init.DMAContinuousRequests = DISABLE;
  hadc1.Init.Overrun = ADC_OVR_DATA_PRESERVED;
  hadc1.Init.OversamplingMode = DISABLE;
  if (HAL_ADC_Init(&hadc1) != HAL_OK)
  {
    Error_Handler();
  }
  /** Configure Regular Channel
  */
  sConfig.Channel = ADC_CHANNEL_6;
  sConfig.Rank = ADC_REGULAR_RANK_1;
  //sConfig.SamplingTime = ADC_SAMPLETIME_2CYCLES_5;
  sConfig.SamplingTime = ADC_SAMPLETIME_24CYCLES_5;
  
  sConfig.SingleDiff = ADC_SINGLE_ENDED;
  sConfig.OffsetNumber = ADC_OFFSET_NONE;
  sConfig.Offset = 0;
  if (HAL_ADC_ConfigChannel(&hadc1, &sConfig) != HAL_OK)
  {
    Error_Handler();
  }

}




static void MX_I2C1_Init(void)
{

  /* USER CODE END I2C1_Init 1 */
  hi2c1.Instance = I2C1;
  hi2c1.Init.Timing = 0x00506682;
  hi2c1.Init.OwnAddress1 = 0;
  hi2c1.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c1.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c1.Init.OwnAddress2 = 0;
  hi2c1.Init.OwnAddress2Masks = I2C_OA2_NOMASK;
  hi2c1.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c1.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  if (HAL_I2C_Init(&hi2c1) != HAL_OK)
  {
    Error_Handler();
  }

  if (HAL_I2CEx_ConfigAnalogFilter(&hi2c1, I2C_ANALOGFILTER_ENABLE) != HAL_OK)
  {
    Error_Handler();
  }

  if (HAL_I2CEx_ConfigDigitalFilter(&hi2c1, 0) != HAL_OK)
  {
    Error_Handler();
  }

}

static void MX_I2C2_Init(void)
{

  /* USER CODE END I2C2_Init 1 */
  hi2c2.Instance = I2C2;
  hi2c2.Init.Timing = 0x00506682; //
  hi2c2.Init.OwnAddress1 = 0;
  hi2c2.Init.AddressingMode = I2C_ADDRESSINGMODE_7BIT;
  hi2c2.Init.DualAddressMode = I2C_DUALADDRESS_DISABLE;
  hi2c2.Init.OwnAddress2 = 0;
  hi2c2.Init.OwnAddress2Masks = I2C_OA2_NOMASK;
  hi2c2.Init.GeneralCallMode = I2C_GENERALCALL_DISABLE;
  hi2c2.Init.NoStretchMode = I2C_NOSTRETCH_DISABLE;
  if (HAL_I2C_Init(&hi2c2) != HAL_OK)
  {
    Error_Handler();
  }
  
  if (HAL_I2CEx_ConfigAnalogFilter(&hi2c2, I2C_ANALOGFILTER_ENABLE) != HAL_OK)
  {
    Error_Handler();
  }
  
  if (HAL_I2CEx_ConfigDigitalFilter(&hi2c2, 0) != HAL_OK)
  {
    Error_Handler();
  }

}

static void MX_QUADSPI_Init(void)
{

  /* QUADSPI parameter configuration*/
  hqspi.Instance = QUADSPI;
  hqspi.Init.ClockPrescaler = 255;
  hqspi.Init.FifoThreshold = 1;
  hqspi.Init.SampleShifting = QSPI_SAMPLE_SHIFTING_NONE;
  hqspi.Init.FlashSize = 25;
  hqspi.Init.ChipSelectHighTime = QSPI_CS_HIGH_TIME_1_CYCLE;
  hqspi.Init.ClockMode = QSPI_CLOCK_MODE_0;
  hqspi.Init.FlashID = QSPI_FLASH_ID_1;
  hqspi.Init.DualFlash = QSPI_DUALFLASH_DISABLE;
  if (HAL_QSPI_Init(&hqspi) != HAL_OK)
  {
    Error_Handler();
  }
}

static void MX_RTC_Init(void)
{
    /* Initialize RTC Only  */
    hrtc.Instance = RTC;
    
    if(HAL_RTCEx_BKUPRead(&hrtc, RTC_BKP_DR0) != 0x32F2)
    {
        while(1)
        {       
            HAL_UART_Receive_DMA (&huart3, Rx_data, 6);
            HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_SET); 
            HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_SET); 
            
            if ( Rx_data[0]>= 0x16)
            {
                HAL_GPIO_WritePin(GPIOA, LED_R_Pin, GPIO_PIN_RESET); 
                HAL_GPIO_WritePin(GPIOA, LED_B_Pin, GPIO_PIN_RESET); 
                break;
            }
            HAL_Delay(250);
        }
        hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
        hrtc.Init.AsynchPrediv = 127;
        hrtc.Init.SynchPrediv = 255;        //249
        hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
        hrtc.Init.OutPutRemap = RTC_OUTPUT_REMAP_NONE;
        hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
        hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;
        
        if (HAL_RTC_Init(&hrtc) != HAL_OK)
        {
          Error_Handler();
        }

  //    
  //    time_t t = time(NULL);
  //    t+=32400;
  //
  //
  //    struct tm tm = *localtime(&t);
  //    tm.tm_isdst=0;

      
        /* Initialize RTC and set the Time and Date  */
        time_.Hours = D2B(Rx_data[3]);
        time_.Minutes = D2B(Rx_data[4]);
        time_.Seconds = D2B(Rx_data[5]);
        time_.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
        time_.StoreOperation = RTC_STOREOPERATION_RESET;
        if (HAL_RTC_SetTime(&hrtc, &time_, RTC_FORMAT_BCD) != HAL_OK)
        {
          Error_Handler();
        }
        date_.WeekDay = RTC_WEEKDAY_MONDAY;
        date_.Month = D2B(Rx_data[1]);
        date_.Date = D2B(Rx_data[2]);
        date_.Year = D2B(Rx_data[0]);

        if (HAL_RTC_SetDate(&hrtc, &date_, RTC_FORMAT_BCD) != HAL_OK)
        {
          Error_Handler();
        }
        HAL_RTCEx_BKUPWrite(&hrtc,RTC_BKP_DR0,0x32F2);
        HAL_RTC_GetTime(&hrtc, &time_, RTC_FORMAT_BCD);
        HAL_RTC_GetDate(&hrtc, &date_, RTC_FORMAT_BCD);
        dnt_.Power = 0;
        dnt_.Year = date_.Year;
        dnt_.Month = date_.Month;
        dnt_.Date = date_.Date;
        dnt_.Hours = time_.Hours;
        dnt_.Minutes = time_.Minutes;
        dnt_.Seconds = time_.Seconds;
        dnt_.sBlock = 0;
        
        UART5_Printf("setting_time : %02d-%02d-%02d %02d:%02d:%02d  \r\n",
                            B2D(dnt_.Year), B2D(dnt_.Month), B2D(dnt_.Date),
                            B2D(dnt_.Hours), B2D(dnt_.Minutes), B2D(dnt_.Seconds));
    }
  
  
  
//    __HAL_RTC_WAKEUPTIMER_EXTI_CLEAR_FLAG();
//  if(__HAL_RTC_WAKEUPTIMER_GET_FLAG(&hrtc, RTC_FLAG_WUTF) != RESET)
//  {   
//    /* Clear the WAKEUPTIMER interrupt pending bit */
//    __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(&hrtc, RTC_FLAG_WUTF);
//
//    /* WAKEUPTIMER callback */ 
//    HAL_RTCEx_WakeUpTimerEventCallback(&hrtc);
//  }
  
}

static void MX_TIM6_Init(void)
{

  TIM_MasterConfigTypeDef sMasterConfig = {0};

  int timerPerscaleVal = g_HCLK / 1000 ; 

  htim6.Instance = TIM6;
  htim6.Init.Prescaler = timerPerscaleVal-1 ;
  htim6.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim6.Init.Period =1000  -1 ;   // 999 ~ 0 ±îÁö  1ms. 
  
  htim6.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim6) != HAL_OK)
  {
    Error_Handler();
  }

  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim6, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }

}


static void MX_TIM7_Init(void)
{

  TIM_MasterConfigTypeDef sMasterConfig = {0};

  int timerPerscaleVal = g_HCLK / 1000 ; 
  
  /* USER CODE END TIM7_Init 1 */
  htim7.Instance = TIM7;
  htim7.Init.Prescaler = timerPerscaleVal-1 ;
  htim7.Init.CounterMode = TIM_COUNTERMODE_UP;
  htim7.Init.Period =  1000*10  -1 ;   // 10ms. 

  // htim7.Init.Period =  1000*5  -1 ;   // 5ms. 
  
  htim7.Init.AutoReloadPreload = TIM_AUTORELOAD_PRELOAD_ENABLE;
  if (HAL_TIM_Base_Init(&htim7) != HAL_OK)
  {
    Error_Handler();
  }

  sMasterConfig.MasterOutputTrigger = TIM_TRGO_RESET;
  sMasterConfig.MasterSlaveMode = TIM_MASTERSLAVEMODE_DISABLE;
  if (HAL_TIMEx_MasterConfigSynchronization(&htim7, &sMasterConfig) != HAL_OK)
  {
    Error_Handler();
  }

}


static void MX_USART3_UART_Init(void)
{

  huart3.Instance = USART3;
  huart3.Init.BaudRate = 115200;
  huart3.Init.WordLength = UART_WORDLENGTH_8B;
  huart3.Init.StopBits = UART_STOPBITS_1;
  huart3.Init.Parity = UART_PARITY_NONE;
  huart3.Init.Mode = UART_MODE_TX_RX;
  huart3.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart3.Init.OverSampling = UART_OVERSAMPLING_8;
  //huart3.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  //huart3.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart3) != HAL_OK)
  {
    Error_Handler();
  }
    
  //__HAL_UART_DISABLE_IT(&huart3, UART_IT_TXE) ; 
  
}



static void MX_USART1_UART_Init(void)
{

  huart1.Instance = USART1;
  
  ////huart1.Init.BaudRate = 9600;
  huart1.Init.BaudRate = 115200;
  
  huart1.Init.WordLength = UART_WORDLENGTH_8B;
  huart1.Init.StopBits = UART_STOPBITS_1;
  huart1.Init.Parity = UART_PARITY_NONE;
  huart1.Init.Mode = UART_MODE_TX_RX;
  huart1.Init.HwFlowCtl = UART_HWCONTROL_NONE;
  huart1.Init.OverSampling = UART_OVERSAMPLING_8;
  //huart1.Init.OneBitSampling = UART_ONE_BIT_SAMPLE_DISABLE;
  //huart1.AdvancedInit.AdvFeatureInit = UART_ADVFEATURE_NO_INIT;
  if (HAL_UART_Init(&huart1) != HAL_OK)
  {
    Error_Handler();
  }
  
  // __HAL_UART_DISABLE_IT(&huart1, UART_IT_TXE);
  
}




/**
  * Enable DMA controller clock
  */
static void MX_DMA_Init(void)
{

  /* DMA controller clock enable */
  __HAL_RCC_DMA1_CLK_ENABLE();

  /* DMA interrupt init */
  /* DMA1_Channel2_IRQn interrupt configuration */
  HAL_NVIC_SetPriority(DMA1_Channel2_IRQn, 5, 0);   // UART3 TX
  HAL_NVIC_EnableIRQ(DMA1_Channel2_IRQn);
  
  /* DMA1_Channel3_IRQn interrupt configuration */  // UART3 RX
  HAL_NVIC_SetPriority(DMA1_Channel3_IRQn, 10, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel3_IRQn);
  
  
  /* DMA1_Channel4_IRQn interrupt configuration */   // UART1 TX
  HAL_NVIC_SetPriority(DMA1_Channel4_IRQn, 3, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel4_IRQn);
  
  /* DMA1_Channel5_IRQn interrupt configuration */    // UART1 RX
  HAL_NVIC_SetPriority(DMA1_Channel5_IRQn, 0, 0);
  HAL_NVIC_EnableIRQ(DMA1_Channel5_IRQn);

}




static void MX_GPIO_Init(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

  /* GPIO Ports Clock Enable */
  __HAL_RCC_GPIOC_CLK_ENABLE();
  __HAL_RCC_GPIOH_CLK_ENABLE();
  __HAL_RCC_GPIOA_CLK_ENABLE();
  __HAL_RCC_GPIOB_CLK_ENABLE();

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11|GPIO_PIN_12, GPIO_PIN_RESET);

  /*Configure GPIO pin Output Level */
  HAL_GPIO_WritePin(GPIOB, GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_15, GPIO_PIN_RESET);

  /*Configure GPIO pins : PA4 PA5 */ // ACTUATOR(4, 5) DETECTOR
  GPIO_InitStruct.Pin = GPIO_PIN_4|GPIO_PIN_5;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_NOPULL;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  
  /*Configure GPIO pins : PA12 */ // FLASH MEMORY ERASE
  GPIO_InitStruct.Pin = GPIO_PIN_12;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);  
  
  /*Configure GPIO pins : PB12 */  // F/W ERASE
  GPIO_InitStruct.Pin = GPIO_PIN_12 ;
  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
  GPIO_InitStruct.Pull = GPIO_PULLUP;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);  
  
  /*Configure GPIO pins : PA8 PA9 PA10 PA11 */
  GPIO_InitStruct.Pin = GPIO_PIN_8|GPIO_PIN_9|GPIO_PIN_10|GPIO_PIN_11;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_PULLDOWN;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  
  /*Configure GPIO pins : PB4 PB5 PB15 */
  GPIO_InitStruct.Pin  = GPIO_PIN_4|GPIO_PIN_5|GPIO_PIN_15;
  GPIO_InitStruct.Mode = GPIO_MODE_OUTPUT_PP;
  GPIO_InitStruct.Pull = GPIO_PULLDOWN;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  
     
  
  /*Configure GPIO pins : PB1 */ // MANUAL SHOOTING 
//  GPIO_InitStruct.Pin = GPIO_PIN_1 ;
//  GPIO_InitStruct.Mode = GPIO_MODE_INPUT;
//  GPIO_InitStruct.Pull = GPIO_NOPULL;
//  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  
  
//  // GPB 10, 11, UART3  Ç®¾÷¼³Á¤.
//  GPIO_InitStruct.Pin = GPIO_PIN_10 | GPIO_PIN_11 ; 
//  GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
//  GPIO_InitStruct.Pull = GPIO_PULLUP;
//  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
//
//  // GPB 6, 7, UART1  Ç®¾÷¼³Á¤.
//  GPIO_InitStruct.Pin = GPIO_PIN_6 | GPIO_PIN_7 ; 
//  GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
//  GPIO_InitStruct.Pull = GPIO_PULLUP;
//  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  
}

/* USER CODE BEGIN 4 */
void MX_GPIO_standby(void)
{
  GPIO_InitTypeDef GPIO_InitStruct = {0};

//  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_RESET);  QSPI CS 
  W25Q_Sleep(); // exflash sleep
//  HAL_GPIO_WritePin(GPIOA, GPIO_PIN_2, GPIO_PIN_SET);  QSPI CS 
  GPIO_InitStruct.Pin  = GPIO_PIN_0|GPIO_PIN_1|GPIO_PIN_6|GPIO_PIN_7;
  GPIO_InitStruct.Pull = GPIO_PULLDOWN;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  
  GPIO_InitStruct.Pin  = GPIO_PIN_13|GPIO_PIN_14;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
  HAL_GPIO_Init(GPIOB, &GPIO_InitStruct);
  
  GPIO_InitStruct.Pin  = GPIO_PIN_6|GPIO_PIN_7;
  GPIO_InitStruct.Pull = GPIO_PULLDOWN;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  
  GPIO_InitStruct.Pin  = GPIO_PIN_2;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_HIGH;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  
  GPIO_InitStruct.Pin  = GPIO_PIN_3;
  GPIO_InitStruct.Speed = GPIO_SPEED_FREQ_LOW;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  
  GPIO_InitStruct.Pin  = GPIO_PIN_1;
  GPIO_InitStruct.Mode = GPIO_MODE_AF_OD;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
  
  GPIO_InitStruct.Pin  = GPIO_PIN_13|GPIO_PIN_14;
  GPIO_InitStruct.Pull = GPIO_PULLDOWN;
  HAL_GPIO_Init(GPIOA, &GPIO_InitStruct);
}
/* 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 */

  /* 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,
     tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/