コード例 #1
0
ファイル: main.c プロジェクト: tymbys/Watch
void RTC_Alarm_IRQHandler()
{
    if(RTC_GetITStatus(RTC_IT_ALRA) != RESET)
    {
    	//RTC_AlarmCmd(RTC_Alarm_A, ENABLE);

    	PWR_RTCAccessCmd(ENABLE); // Доступ в RTC
    	RTC_ClearITPendingBit(RTC_IT_ALRA);
    	RTC_ClearFlag(RTC_FLAG_ALRAF);
    	PWR_RTCAccessCmd(DISABLE);

        EXTI_ClearITPendingBit(EXTI_Line17);
        //OLED_DrawString_fast(0,0,"alarm",10);
    }

    /////////////////////////?????????????????????????????????????????????????????????????????????????????????????
    if(RTC_GetFlagStatus(RTC_FLAG_ALRAF) != RESET)
    {
    	PWR_RTCAccessCmd(ENABLE);
    	RTC_ClearFlag(RTC_FLAG_ALRAF);
    	PWR_RTCAccessCmd(DISABLE);
    	//f_WakeupToAlarm=1;
    	curent_cmd = 5;

    }
/////////////////////////



}
コード例 #2
0
ファイル: stm32f4xx_it.c プロジェクト: Exchizz/Bachelor
/**
  * @brief  This function handles RTC Tamper and Time Stamp interrupts requests.
  * @param  None
  * @retval None
  */
void TAMP_STAMP_IRQHandler(void)
{
  if(RTC_GetFlagStatus(RTC_FLAG_TAMP1F) != RESET)
  { 
    /* Tamper 1 detection event occurred */
    /* Check if RTC Backup Data registers are cleared */
    if(IsBackupRegReset() == 0)
    {
      /* OK, RTC Backup Data registers are reset as expected */
      /* Toggle LED2 */
      STM_EVAL_LEDToggle(LED2);
    }
    else
    {
      /* RTC Backup Data registers are not reset */
      /* Toggle LED4 */
      STM_EVAL_LEDToggle(LED4);
    }
    
    /* Clear Tamper 1 pin Event pending flag */
    RTC_ClearFlag(RTC_FLAG_TAMP1F);

    /* Disable Tamper pin 1 */
    RTC_TamperCmd(RTC_Tamper_1, DISABLE);

    /* Enable Tamper pin */
    RTC_TamperCmd(RTC_Tamper_1, ENABLE); 
  }
}
コード例 #3
0
ファイル: hw_init.c プロジェクト: ADTL/AFGUI
unsigned int RTC_cfg(void)
{
	unsigned int ret;
	RTC_DateTypeDef   RTC_DateStruct;
	RTC_TimeTypeDef   RTC_TimeStruct;
	
	ret = 0;

	if (RTC_ReadBackupRegister(RTC_BKP_DR1) != 0xA5A5)
	{
	  	ret = 1;
		
		/* Allow access to BKP Domain */
		PWR_BackupAccessCmd(ENABLE);
	 
		/* Reset Backup Domain */
		RTC_DeInit();
	 
		/* Enable LSE */
		RCC_LSEConfig(RCC_LSE_ON);
		
		/* Wait till LSE is ready */
		while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
		{}
	 
		/* Select LSE as RTC Clock Source */
		RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
	 
		/* Enable RTC Clock */
		RCC_RTCCLKCmd(ENABLE);
	 
		/* Wait for RTC registers synchronization */
		RTC_WaitForSynchro();
	 
		/* Adjust time */
		RTC_DateStruct.RTC_Year = 13;
		RTC_DateStruct.RTC_Month = 05;
		RTC_DateStruct.RTC_Date = 29;
		RTC_DateStruct.RTC_WeekDay = 3;
		RTC_TimeStruct.RTC_Hours = 11;
		RTC_TimeStruct.RTC_Minutes = 0;	
		RTC_TimeStruct.RTC_Seconds = 0;
		RTC_SetTime(RTC_Format_BIN, &RTC_TimeStruct);	
		RTC_SetDate(RTC_Format_BIN, &RTC_DateStruct);
			
		RTC_WriteBackupRegister(RTC_BKP_DR1, 0xA5A5);
	}
	else
	{
	
		/* Allow access to BKP Domain */
		PWR_BackupAccessCmd(ENABLE);

		/* Wait for RTC registers synchronization */
		RTC_WaitForSynchro();
		while (RTC_GetFlagStatus(RTC_FLAG_RSF) == RESET);
		
	}
	return ret;
}
コード例 #4
0
ファイル: main.c プロジェクト: DerekTan/STM32F107_ucosIII
/**
  * @brief   Main program.
  * @param  None
  * @retval None
  */
int main(void)
{
  /* Setup the microcontroller system. Initialize the Embedded Flash Interface,  
     initialize the PLL and update the SystemFrequency variable. */
  SystemInit();

  /* Initialize LEDs and Key Button mounted on STM3210X-EVAL board */       
  STM_EVAL_LEDInit(LED1);
  STM_EVAL_LEDInit(LED2);
  STM_EVAL_LEDInit(LED3);
  STM_EVAL_PBInit(Button_KEY, Mode_EXTI);

  /* Enable PWR and BKP clock */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);

  /* Configure EXTI Line to generate an interrupt on falling edge */
  EXTI_Configuration();

  /* Configure RTC clock source and prescaler */
  RTC_Configuration();

  /* NVIC configuration */
  NVIC_Configuration();

  /* Configure the SysTick to generate an interrupt each 1 millisecond */
  SysTick_Configuration();

  /* Turn on LED1 */
  STM_EVAL_LEDOn(LED1);
  
  while (1)
  {
    /* Insert 1.5 second delay */
    Delay(1500);

    /* Wait till RTC Second event occurs */
    RTC_ClearFlag(RTC_FLAG_SEC);
    while(RTC_GetFlagStatus(RTC_FLAG_SEC) == RESET);

    /* Alarm in 3 second */
    RTC_SetAlarm(RTC_GetCounter()+ 3);
    /* Wait until last write operation on RTC registers has finished */
    RTC_WaitForLastTask();

    /* Turn off LED1 */
    STM_EVAL_LEDOff(LED1);

    /* Request to enter STOP mode with regulator in low power mode*/
    PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
    
    /* At this stage the system has resumed from STOP mode -------------------*/
    /* Turn on LED1 */
    STM_EVAL_LEDOn(LED1);

    /* Configures system clock after wake-up from STOP: enable HSE, PLL and select 
       PLL as system clock source (HSE and PLL are disabled in STOP mode) */
    SYSCLKConfig_STOP();
  }
}
コード例 #5
0
ファイル: main.c プロジェクト: timmy00274672/STM32-Learning
/*******************************************************************************
* Function Name  : main
* Description    : Main program.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
int main(void)
{
#ifdef DEBUG
  debug();
#endif
   
  /* Clock configuration */
  RCC_Configuration();

  /* Enable PWR and BKP clock */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);

  /* GPIO configuration */
  GPIO_Configuration();

  /* Configure EXTI Line to generate an interrupt on falling edge */
  EXTI_Configuration();

  /* Configure RTC clock source and prescaler */
  RTC_Configuration();

  /* NVIC configuration */
  NVIC_Configuration();

  /* Configure the SysTick to generate an interrupt each 1 millisecond */
  SysTick_Configuration();

  /* Turn on led connected to GPIO_LED Pin6 */
  GPIO_SetBits(GPIO_LED, GPIO_Pin_6); 
  
  while (1)
  {
    /* Insert 1.5 second delay */
    Delay(1500);

    /* Wait till RTC Second event occurs */
    RTC_ClearFlag(RTC_FLAG_SEC);
    while(RTC_GetFlagStatus(RTC_FLAG_SEC) == RESET);

    /* Alarm in 3 second */
    RTC_SetAlarm(RTC_GetCounter()+ 3);
    /* Wait until last write operation on RTC registers has finished */
    RTC_WaitForLastTask();

    /* Turn off led connected to GPIO_LED Pin6 */
    GPIO_ResetBits(GPIO_LED, GPIO_Pin_6); 

    /* Request to enter STOP mode with regulator in low power mode*/
    PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
    
    /* At this stage the system has resumed from STOP mode -------------------*/
    /* Turn on led connected to GPIO_LED Pin6 */
    GPIO_SetBits(GPIO_LED, GPIO_Pin_6); 

    /* Configures system clock after wake-up from STOP: enable HSE, PLL and select 
       PLL as system clock source (HSE and PLL are disabled in STOP mode) */
    SYSCLKConfig_STOP();
  }
}
コード例 #6
0
ファイル: stm32f10x_it.c プロジェクト: barriquello/iotstack
/*******************************************************************************
* Function Name  : RTC_IRQHandler
* Description    : This function handles RTC global interrupt request.
* Input          : None
* Output         : None
* Return         : None
*******************************************************************************/
void RTC_IRQHandler(void)
{
    if(RTC_GetFlagStatus(RTC_IT_ALR) != RESET)
    {
      RTC_ClearITPendingBit(RTC_IT_ALR);      //Clear RTC Alarm interrupt pending bit
      RTC_WaitForLastTask();                  //Wait until last write operation on RTC registers has finished
    }
}
コード例 #7
0
ファイル: PwrMode.c プロジェクト: congallenwang/107vc-iap
void RTC_STOP_WakeUp(void)
{
    /* Enable PWR and BKP clocks */
    /* PWR时钟(电源控制)与BKP时钟(RTC后备寄存器)使能 */
    RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);

    /* Allow access to BKP Domain */
    PWR_BackupAccessCmd(ENABLE);

    /* RTC clock source configuration ----------------------------------------*/
    /* Reset Backup Domain */
    BKP_DeInit();

    /* Enable LSE OSC */
    RCC_LSEConfig(RCC_LSE_ON);
    /* Wait till LSE is ready */
    while(RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
    {
    }

    /* Select the RTC Clock Source */
    RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);

    /* Enable the RTC Clock */
    RCC_RTCCLKCmd(ENABLE);

    /* RTC configuration -----------------------------------------------------*/
    /* Wait for RTC APB registers synchronisation */
    RTC_WaitForSynchro();

    /* Set the RTC time base to 1s */
    RTC_SetPrescaler(32767);
    /* Wait until last write operation on RTC registers has finished */
    RTC_WaitForLastTask();

    /* Enable the RTC Alarm interrupt */
    RTC_ITConfig(RTC_IT_ALR, ENABLE);
    /* Wait until last write operation on RTC registers has finished */
    RTC_WaitForLastTask();

    RTC_ClearFlag(RTC_FLAG_SEC);
    while(RTC_GetFlagStatus(RTC_FLAG_SEC) == RESET);

    /* Alarm in 5 second */
    RTC_SetAlarm(RTC_GetCounter()+ 5);
    /* Wait until last write operation on RTC registers has finished */
    RTC_WaitForLastTask();
}
コード例 #8
0
/**
  * @}
  */
void RTC_IRQHandler(void)
{
	static int delay_cnt;
	struct rtgui_event_command ecmd;

	/* enter interrupt */
	rt_interrupt_enter();

	++rtc_1s_int_cnt;

#if 1 == LCD_TEST_MALOOEI
	rt_kprintf("rtc:%d\n", rtc_1s_int_cnt);
#endif

	if (delay_cnt < 1) {
		++delay_cnt;
		goto ret_entry;
	}

	if (NULL == wb_thread)
		goto ret_entry;

	if (RTC_GetITStatus(RTC_IT_SEC) != RESET) {
		RTGUI_EVENT_COMMAND_INIT(&ecmd);
		ecmd.command_id = UPDATE_SYS_TIME;
		if (RT_EOK != rtgui_thread_send(wb_thread, &ecmd.parent, sizeof(struct rtgui_event_command)))
			rt_kprintf("[RTC_IRQHandler]send enent cmd fail\n");
	}
#if 0
	if(RTC_GetFlagStatus(RTC_FLAG_ALR) != RESET) {
	} else {
	}
#endif

ret_entry:
	RTC_ClearITPendingBit(RTC_IT_ALR | RTC_IT_SEC);

	/* leave interrupt */
	rt_interrupt_leave();

	return;
}
コード例 #9
0
ファイル: stm32f10x_it.c プロジェクト: ngocthanhtnt/ledshow
/**
  * @brief  This function handles External lines 9 to 5 interrupt request.
  * @param  None
  * @retval None
  */
void EXTI9_5_IRQHandler(void)
{
  if(EXTI_GetITStatus(KEY_BUTTON_EXTI_LINE) != RESET)
  { 
    /* Clear the Key Button EXTI line pending bit */  
    EXTI_ClearITPendingBit(KEY_BUTTON_EXTI_LINE);

    /* Turn on LED1 */
    STM_EVAL_LEDOn(LED1);

    /* Wait till RTC Second event occurs */
    RTC_ClearFlag(RTC_FLAG_SEC);
    while(RTC_GetFlagStatus(RTC_FLAG_SEC) == RESET);

    /* Set the RTC Alarm after 3s */
    RTC_SetAlarm(RTC_GetCounter()+ 3);
    /* Wait until last write operation on RTC registers has finished */
    RTC_WaitForLastTask();

    /* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */
    PWR_EnterSTANDBYMode();
  }
}
コード例 #10
0
ファイル: stm32f10x_it.c プロジェクト: fidiaslothes/stm32gps
void TIM2_IRQHandler(void)
{
	if ( TIM_GetITStatus(TIM2 , TIM_IT_Update) != RESET ) 
	{	
		TIM_ClearITPendingBit(TIM2 , TIM_FLAG_Update);

		/////////////////////////////////////////////////////////////////
		// Power OFF GPS and GSM before go into standby mode
		/////////////////////////////////////////////////////////////////
		GSM_TurnOnOff_delay();
#ifdef USE_STM32_GPS_BOARD_VB
		GPSPowerOff();
		GSM_PowerOff();
#endif
		/* Wait till RTC Second event occurs */
		RTC_ClearFlag(RTC_FLAG_SEC);
		while(RTC_GetFlagStatus(RTC_FLAG_SEC) == RESET);

		// normal working state
		if(BKP_TRUE == BKP_ReadBackupRegister(BKP_DR1))
		{
			/* Set the RTC Alarm after xx s */
			DEBUG("in timer2 bkptrue %d\n", (BKP_ReadBackupRegister(BKP_DR4) + BKP_ReadBackupRegister(BKP_DR4) <<16));
			RTC_SetAlarm(RTC_GetCounter()+ ((BKP_ReadBackupRegister(BKP_DR4) + BKP_ReadBackupRegister(BKP_DR4) <<16)/SLEEP_TIM2_RATIO));
		}
		else
		{
			DEBUG("in timer2 bkpfalse\n");
			RTC_SetAlarm(RTC_GetCounter()+ (SLEEP_NORMAL_SEC/SLEEP_TIM2_RATIO));
		}
	
		/* Wait until last write operation on RTC registers has finished */
		RTC_WaitForLastTask();		
		/* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */
		PWR_EnterSTANDBYMode();
	}		 	
}
コード例 #11
0
ファイル: stm32l1xx_it.c プロジェクト: coocox/Mplib
/**
 * @brief  This function handles Tamper interrupt request.
 * @param  None
 * @retval None
 */
void TAMPER_STAMP_IRQHandler(void) {
	if (RTC_GetFlagStatus(RTC_FLAG_TAMP1F) != RESET) {
		/* Tamper 1 detection event occurred */
		/* Check if RTC Backup Data registers are cleared */
		if (IsBackupRegReset() == 0) {
			/* OK, RTC Backup Data registers are reset as expected */
			/* Turn on GREEN and BLUE */
			GPIO_SetBits(GPIOB, LD_GREEN_GPIO_PIN | LD_BLUE_GPIO_PIN);
		} else {
			/* RTC Backup Data registers are not reset */
			/* Turn off GREEN and BLUE */
			GPIO_ResetBits(GPIOB, LD_GREEN_GPIO_PIN | LD_BLUE_GPIO_PIN);
		}

		/* Clear Tamper 1 pin Event(TAMP1F) pending flag */
		RTC_ClearFlag(RTC_FLAG_TAMP1F);

		/* Disable Tamper pin 1 */
		RTC_TamperCmd(RTC_Tamper_1, DISABLE);

		/* Enable Tamper pin */
		RTC_TamperCmd(RTC_Tamper_1, ENABLE);
	}
}
コード例 #12
0
ファイル: Calendar.c プロジェクト: afxstar/Mplib
/* Private functions ---------------------------------------------------------------------------------------*/
void RTC_IRQHandler(void)
{
    u8 bFlags ;
    bFlags = RTC_GetFlagStatus();
    if((bFlags & 0x2) != 0x0) /* Match flag */
    {
        /* Reset RTC init time when Time is 23:59:59 */
        RTC_SetCompare(86400) ;
        PWRCU_WriteBackupRegister(PWRCU_BAKREG_1, 0);
    }

    /* Toggle LED3 each 1s */
    if(led_on) {
        GPIO_SetOutBits(GPIOA, GPIO_PIN_5);
        led_on = 0;
    }
    else {
        GPIO_ClearOutBits(GPIOA, GPIO_PIN_5);
        led_on = 1;
    }

    /* Enable time update */
    gwTimeDisplay = 1;
}
コード例 #13
0
ファイル: rtc.c プロジェクト: MaxStudio/GPS_TRACER_CODE
// 设定闹钟时间
void SetAlarmTime(void)
{
	// 23:59:59
	struct tm time_current;
	uint32_t DayTotalSeconds; // 一天累积总秒数
	uint32_t CurrentTotalSeconds; // 当前时间累积总秒数
	uint32_t AlarmValue;  // 秒差
	
	DayTotalSeconds = 23*3600 + 59*60 +59;
	
	time_current = Time_GetCalendarTime();
	CurrentTotalSeconds = time_current.tm_hour*3600 + time_current.tm_min*60 + time_current.tm_sec;
	
	AlarmValue = DayTotalSeconds - CurrentTotalSeconds;
	
	/* Wait till RTC Second event occurs */
	RTC_ClearFlag(RTC_FLAG_SEC);
	while(RTC_GetFlagStatus(RTC_FLAG_SEC) == RESET);

	/* Set the RTC Alarm after 3s */
	RTC_SetAlarm(RTC_GetCounter()+AlarmValue);
	/* Wait until last write operation on RTC registers has finished */
	RTC_WaitForLastTask();
}
コード例 #14
0
ファイル: rtc.c プロジェクト: Lasitha78/elua
// Get elapsed number of seconds
static int rtc_status( lua_State *L ) {
  lua_pushinteger(L, (lua_Integer)RTC_GetFlagStatus());
  return 1;
}
コード例 #15
0
ファイル: main.c プロジェクト: tymbys/Watch
int main(void)
{


	RCC_APB1PeriphClockCmd( RCC_APB1Periph_PWR, ENABLE);//!!!!

	// тактирование ядра низкоскоростным внутренним генератором 4мгц
	RCC->ICSCR &= ~RCC_ICSCR_MSIRANGE;//!!!!
	RCC->ICSCR |= RCC_ICSCR_MSIRANGE_6;//!!!!
	//RTC_Initilithahion();//!!!!
	////////////////////////////////////////////////////////////////////

	delay_ms(1000);//!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!



	curent_cmd = 0;
	PCount_Start = 0;
	/////////////////// настройка пробуждения
		RCC_HSICmd(DISABLE);
		PWR_PVDCmd(DISABLE);
		PWR_UltraLowPowerCmd(ENABLE);
		PWR_WakeUpPinCmd(PWR_WakeUpPin_1,ENABLE);
		PWR_UltraLowPowerCmd(ENABLE);

	////////////// настройка прирывания для будильника в неспящем режиме
		EXTI_InitTypeDef exti;
		NVIC_InitTypeDef NVIC_InitStructure;

		EXTI_ClearITPendingBit(EXTI_Line17);
		exti.EXTI_Line = EXTI_Line17;
		exti.EXTI_Mode = EXTI_Mode_Interrupt;
		exti.EXTI_Trigger = EXTI_Trigger_Rising;
		exti.EXTI_LineCmd = ENABLE;
		EXTI_Init(&exti);

		NVIC_InitStructure.NVIC_IRQChannel = RTC_Alarm_IRQn;
		NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority = 0;
		NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;
		NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;
		NVIC_Init(&NVIC_InitStructure);

		//////////////////




	if(PWR_GetFlagStatus(PWR_FLAG_SB)!=RESET)//Если МК вышел из режима standby
	{
		WkupFlag=1;
		curent_cmd = 1;


		if(RTC_GetFlagStatus(RTC_FLAG_ALRAF)!=RESET)//Если МК вышел из режима ALARM
		{
							//RTC_Initilithahion();//!!!!
						//PWR_RTCAccessCmd(ENABLE);
						//RTC_ClearFlag(RTC_FLAG_ALRAF);
						//PWR_RTCAccessCmd(DISABLE);
							//f_WakeupToAlarm=1;
						curent_cmd = 5;
		}




		//RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR,ENABLE);
		PWR_ClearFlag(PWR_FLAG_SB); //Сброс флага, который указывает на то, что МК вышел из режима standby


		PWR_RTCAccessCmd(ENABLE); // Доступ в RTC
		//RTC_ClearITPendingBit(RTC_IT_WUT);
		//RTC_ClearFlag(RTC_FLAG_WUTF);
		RTC_ClearFlag(RTC_FLAG_ALRAF);
		PWR_RTCAccessCmd(DISABLE);





	}
	else
	{


		WkupFlag=0;

		RTC_TimeTypeDef alarmTime;
		alarmTime.RTC_H12 = RTC_H12_PM;//!!!!;
		alarmTime.RTC_Hours = 20;
		alarmTime.RTC_Minutes = 0;
		alarmTime.RTC_Seconds = 20;


		RTC_Initilithahion();//!!!!
		//RTC_Set_Alarm(alarmTime);/// Магическая последовательность, 1. RTC_Set_Alarm, 2. RTC_Set_Time иначе не работает будильник


		RTC_TimeTypeDef RTC_Time;
		RTC_DateTypeDef RTC_Date;

		RTC_Time.RTC_H12 = RTC_H12_PM;//!!!!;
		RTC_Time.RTC_Hours = 20;
		RTC_Time.RTC_Minutes = 00;
		RTC_Time.RTC_Seconds = 00;


		RTC_Date.RTC_WeekDay = RTC_Weekday_Sunday;

		RTC_Date.RTC_Year = 14;
		RTC_Date.RTC_Month = 8;
		RTC_Date.RTC_Date = 17;

		RTC_Set_TimeDate(RTC_Time, RTC_Date);///


	}





	//else curent_cmd = 0;//f_WakeupToAlarm=0;











	//RTC_Initilithahion();//!!!!
	//RTC_Set_Time();






OLED_Init();
OLED_Clear();
char i,j;






/*
RCC_GetClocksFreq(&Frequency);
f=Frequency.SYSCLK_Frequency/1000;
IntToStr(a,f);
OLED_DrawString_fast(30,30,a,10);
*/


OLED_LcdCache_Clear();



//if(0==WkupFlag) //Если МК до этого не находился в режиме STANDBY!!!!!!!!!!!!!!!!!
//PWR_EnterSTANDBYMode(); //Перейди в режим STANDBY!!!!!!!!!!!!!!!!!!!


//OLED_DrawBitmap_fast(3,12,menu1_sprait,123,40);
//delay_ms(10000);


WaitToSleep = 0;



TACT_Config();

BackTimeAndData.hour=0;
BackTimeAndData.minute=0;
BackTimeAndData.second=0;

globa_menu = 1;
f_aktive_menu = 0;
//curent_cmd = 0;

PWatch_Setup_Step = 0;

key_up = 0;
key_down = 0;
key_ok = 0;

PCount_Start = 0;

while(1)
{

	key = 0;

	key_ok = GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_0);
	key_down = GPIO_ReadInputDataBit(GPIOA, GPIO_Pin_2);
	key_up = GPIO_ReadInputDataBit(GPIOB, GPIO_Pin_12);


/*
	OLED_DrawString_fast(0,0,"            ",10);

	IntToStr(bbb,key_ok);
	OLED_DrawString_fast(0,0,bbb,10);

	IntToStr(bbb,key_down);
	OLED_DrawString_fast(30,0,bbb,10);

	IntToStr(bbb,key_up);
	OLED_DrawString_fast(60,0,bbb,10);
*/

	if (key_ok!=0)
	{
		key_ok = 0;
		key = 1;



		//OLED_DrawString_fast(0,0,"000000000",10);
		//f_aktive_menu = 1;


		/*
		if (f_aktive_menu == 1)
		{
			//f_work_comand = 1;
			f_aktive_menu = 0;
			f_clearScrin = 1;
			curent_cmd = menu_cmd[globa_menu-1];

		}
		else curent_cmd = 255 ;
		*/
	}


	if (key_down==0)
	{
		key_down = 0;
		key = 2;

		/*
		if ((globa_menu>1)&&(f_work_comand == 0)) globa_menu--;
		else globa_menu = 1;

		//IntToStr(bbb,globa_menu);
		//OLED_DrawString_fast(0,0,bbb,10);

		 */

	}


	if (key_up==0)
	{

		key_up = 0;
		key = 12;

		/*
		if ((globa_menu<4)&&(f_work_comand == 0)) globa_menu++;
		else globa_menu = 4;

		//IntToStr(bbb,globa_menu);
		//OLED_DrawString_fast(0,0,bbb,10);

		 */

	}


	if (key!=0)
		{
			GPIO_SetBits(GPIOA, GPIO_Pin_1);
			delay_ms(30);
			GPIO_ResetBits(GPIOA, GPIO_Pin_1);
		}



/*
	if (f_clearScrin==1)
	{
		OLED_Clear();
		f_clearScrin=0;
	}
*/


	//if (f_aktive_menu==0)
	//{

	switch(curent_cmd)
	{
		case 0:			//нет команды

				PWatch_Menu();

				break;
		case 1:			//Программа показа часов (главная страница)

				//OLED_Clear();
				//f_work_comand = 1;
				PWatch_Anim();
				break;
		case 2:			//Программа настройки даты/времени и др.

				//OLED_Clear();
				OLED_DrawString_fast(0,0,"Календарь",10);
				curent_cmd = 0;
				break;

		case 3:

				//OLED_Clear();
				PWatch_Set_Alarm();
				break;

		case 4:

				//OLED_Clear();
				//OLED_DrawString_fast(0,0,"Настройки",10);

				//f_work_comand = 1;
				PWatch_Setup();

				break;

		case 5:

				PWatch_Vibration();

				break;


		case 254:

				OLED_Clear();

				break;

		/*case 255:

				OLED_Clear();
				OLED_DrawBitmap_fast(3,12,menu1_sprait,123,40);
				f_aktive_menu = 1;
				//f_work_comand = 0;
				//key=0;
				break;
		*/
		default: 		//выполнить, если ни один вариант не подошел

				break;
	}
	//}
	//else
	//{
		//PWatch_Menu();
	//}

/*
				if(WainToAlarm == 1)
				{
					OLED_DrawString_fast(0,0,"alarm1",10);
					WainToAlarm =0;
				}
*/


				//if(WaitToSleep>=5)
				//{
					//WaitToSleep=0;


					//PWR_ClearFlag(PWR_FLAG_SB); //Сброс флага, который указывает на то, что МК вышел из режима standby


/*
					for (i=255; i>0; i--)
					{
						OLED_SetContrast(i);
						IntToStr(a,i);
						OLED_DrawString_fast(0,0,a,10);
						//delay_ms(500);
					}*/




					//OLED_DrawBitmap_fast(32,10,Fallout_Bitmaps,58,60);
					//delay_ms(1000);

					//OLED_Display_Off();!!!!!!!!!!!!!!!!!!!!!!!!1

					//RCC_AHBPeriphClockCmd(RCC_AHBPeriph_GPIOA, DISABLE);
					//походу стабилитрон кушает 0.1 мА, общее потребление 0.15мА


					//PWR_EnterSTANDBYMode();!!!!!!!!!!!!!!!!!!!!!



				//}


				//WaitToSleep++;

/*
				RCC_GetClocksFreq(&Frequency);
				f=Frequency.SYSCLK_Frequency/1000;
				IntToStr(a,f);
				OLED_DrawString_fast(0,0,a,10);
*/






	delay_ms(250);



}

}
コード例 #16
0
/**
  * @brief  Enter the MCU selected low power modes.
  * @param  lpmode: selected MCU low power modes. This parameter can be one of the
  *         following values:
  *              @arg STM32L_RUN: Run mode at 32MHz.
  *              @arg STM32L_RUN_1M: Run mode at 1MHz.
  *              @arg STM32L_RUN_LP: Low power Run mode at 32KHz.  
  *              @arg STM32L_SLEEP: Sleep mode at 16MHz.
  *              @arg STM32L_SLEEP_LP: Low power Sleep mode at 32KHz.
  *              @arg STM32L_STOP: Stop mode with or without RTC.
  *              @arg STM32L_STANDBY: Standby mode with or without RTC.
  * @param  RTCState: RTC peripheral state during low power modes. This parameter
  *         is valid only for STM32L_RUN_LP, STM32L_SLEEP_LP, STM32L_STOP and
  *         STM32L_STANDBY. This parameter can be one of the following values:
  *              @arg RTC_STATE_ON: RTC peripheral is ON during low power modes.
  *              @arg RTC_STATE_OFF: RTC peripheral is OFF during low power modes.
  * @param  CalibrationState: Bias Calibration mode selection state during low 
  *         power modes. 
  *         This parameter can be one of the following values:
  *              @arg BIAS_CALIB_OFF: Bias Calibration mode is selected during 
  *                   low power modes.
  *              @arg BIAS_CALIB_ON: Bias Calibration mode isn't selected during 
  *                   low power modes.
  * @retval None
*/
void IDD_Measurement(uint32_t lpmode, uint8_t RTCState, uint8_t CalibrationState)
{
  GPIO_InitTypeDef GPIO_InitStructure;
  uint16_t mode = STM32L_MODE_LP, adcdata, i;

  /* Disable the Wakeup Interrupt */
  RTC_ITConfig(RTC_IT_WUT, DISABLE);

  /* Disable the JoyStick interrupts */
  Demo_IntExtOnOffConfig(DISABLE);

  /* Disable Leds toggling */
  Demo_LedShow(DISABLE);

  /* Save the RCC configuration */
  RCC_AHBENR   = RCC->AHBENR;
  RCC_APB2ENR  = RCC->APB2ENR;
  RCC_APB1ENR  = RCC->APB1ENR;

  /* Disable PVD */
  PWR_PVDCmd(DISABLE);

  /* Wait until JoyStick is pressed */
  while (Menu_ReadKey() != NOKEY)
  {}

  /* Save the GPIO pins current configuration then put all GPIO pins in Analog
     Input mode ...*/
  IDD_Measurement_SaveContext();

  /* Clear Wake Up flag */
  PWR_ClearFlag(PWR_FLAG_WU);

  RCC->AHBENR = 0x05;
  RCC->APB2ENR = 0x00;
  RCC->APB1ENR = 0x10000000;  /* PWR APB1 Clock enable */
  
  switch(lpmode)
  {
    /*=========================================================================*
     *                        RUN MODE 32MHz (HSE + PLL)                       *
     *========================================================================*/
    case STM32L_RUN:
    {  
      mode = STM32L_MODE_RUN;
      /* Needed delay to have a correct value on capacitor C25.
        Running NOP during waiting loop will decrease the current consumption. */
      for (i = 0;i < 0xFFFF; i++) 
      {
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
      }
    }
    break;

    /*=========================================================================*
     *                        RUN MODE MSI 1MHz                                *
     *========================================================================*/
    case STM32L_RUN_1M:
    {      
      mode = STM32L_MODE_RUN;
      
      /* Reconfigure the System Clock at MSI 1 MHz */
      SetHCLKToMSI_1MHz();
        
      /* Needed delay to have a correct value on capacitor C25.
        Running NOP during waiting loop will decrease the current consumption. */
      for (i = 0;i < 0x3FFF; i++) 
      {
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
      }
    }
    break;

    /*=========================================================================*
     *                        RUN LOW POWER MODE MSI 32KHz                     *
     *========================================================================*/    
    case STM32L_RUN_LP:
    {                
      if(!RTCState)
      {  
        RCC_LSEConfig(RCC_LSE_OFF);
      }
      else
      {
        if (RTC_GetFlagStatus(RTC_FLAG_INITS) == RESET)
        {
          /* RTC Configuration ************************************************/
          /* Reset RTC Domain */
          RCC_RTCResetCmd(ENABLE);
          RCC_RTCResetCmd(DISABLE);
          
          /* Enable the LSE OSC */
          RCC_LSEConfig(RCC_LSE_ON);
          
          /* Wait till LSE is ready */
          while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
          {}
          
          /* Select the RTC Clock Source */
          RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
          
          /* Enable the RTC Clock */
          RCC_RTCCLKCmd(ENABLE);
          
          /* Wait for RTC APB registers synchronisation */
          RTC_WaitForSynchro();
        }        
      }
      /* Configure the System Clock at MSI 32 KHz */
      SetHCLKToMSI_64KHz(); 
      RCC_HCLKConfig(RCC_SYSCLK_Div2); 
      
      /* Clear IDD_CNT_EN pin */
      GPIO_ResetBits(IDD_CNT_EN_GPIO_PORT, IDD_CNT_EN_PIN);
      
      /* Enter low power run mode */
      PWR_EnterLowPowerRunMode(ENABLE);
      
      /* Waiting wake-up interrupt */
      /* Needed delay to have a correct value on capacitor C25.
        Running NOP during waiting loop will decrease the current consumption. */
      do 
      {
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
        __NOP();  __NOP();    __NOP();  __NOP();
      }while(LowPowerStatus == 0x00);

      /* Exit low power run mode before setting the clock to 32MHz */
      PWR_EnterLowPowerRunMode(DISABLE);
      while(PWR_GetFlagStatus(PWR_FLAG_REGLP) != RESET)
      {
      }  
    }       
    break;

    /*=========================================================================*
     *                        SLEEP MODE HSI 16MHz                             * 
     *========================================================================*/        
    case STM32L_SLEEP:
    {            
      mode = STM32L_MODE_RUN;      
      /* Enable Ultra low power mode */
      PWR_UltraLowPowerCmd(ENABLE);
      
      /* Diable FLASH during SLeep LP */
      FLASH_SLEEPPowerDownCmd(ENABLE);
            
      RCC_APB2PeriphClockLPModeCmd(RCC_APB2Periph_CLOCK, ENABLE);
      RCC_APB1PeriphClockLPModeCmd(RCC_APB1Periph_CLOCK, ENABLE);
      RCC_AHBPeriphClockLPModeCmd(RCC_AHBPeriph_CLOCK, ENABLE);
      
      /* Configure the System Clock to 16MHz */
      SetHCLKToHSI();
      
      Demo_SysTickConfig();
      Demo_Delay(5);
      
      /* Request to enter SLEEP mode with regulator on */
      PWR_EnterSleepMode(PWR_Regulator_ON, PWR_STOPEntry_WFI); 
    }   
    break;

    /*=========================================================================*
     *                      SLEEP LOW POWER MODE MSI 32KHz                     *
     *========================================================================*/     
    case STM32L_SLEEP_LP:
    {            
      if(!RTCState)
      {  
        RCC_LSEConfig(RCC_LSE_OFF);
      }
      else
      {
        if (RTC_GetFlagStatus(RTC_FLAG_INITS) == RESET)
        {
          /* RTC Configuration ************************************************/
          /* Reset RTC Domain */
          RCC_RTCResetCmd(ENABLE);
          RCC_RTCResetCmd(DISABLE);
          
          /* Enable the LSE OSC */
          RCC_LSEConfig(RCC_LSE_ON);
          
          /* Wait till LSE is ready */
          while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
          {}
          
          /* Select the RTC Clock Source */
          RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
          
          /* Enable the RTC Clock */
          RCC_RTCCLKCmd(ENABLE);
          
          /* Wait for RTC APB registers synchronisation */
          RTC_WaitForSynchro();
        }        
      }
      
      /* Enable Ultra low power mode */
      PWR_UltraLowPowerCmd(ENABLE);
      
      /* Diable FLASH during SLeep LP */
      FLASH_SLEEPPowerDownCmd(ENABLE);
      
      /* Disable HSI clock before entering Sleep LP mode */ 
      RCC_HSICmd(DISABLE);
      /* Disable HSE clock */
      RCC_HSEConfig(RCC_HSE_OFF);
      /* Disable LSI clock */
      RCC_LSICmd(DISABLE);
      
      RCC_APB2PeriphClockLPModeCmd(RCC_APB2Periph_CLOCK, ENABLE);
      RCC_APB1PeriphClockLPModeCmd(RCC_APB1Periph_CLOCK, ENABLE);
      RCC_AHBPeriphClockLPModeCmd(RCC_AHBPeriph_CLOCK, ENABLE);
      
      /* Clear IDD_CNT_EN pin */
      GPIO_ResetBits(IDD_CNT_EN_GPIO_PORT, IDD_CNT_EN_PIN);
      
      /* Reconfigure the System Clock at MSI 64 KHz */
      SetHCLKToMSI_64KHz();
      RCC_HCLKConfig(RCC_SYSCLK_Div2); 
      
      /* Request to enter SLEEP mode with regulator low power */
      PWR_EnterSleepMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);        
    }
    break;
    
    /*=========================================================================*
     *                          STOP LOW POWER MODE                            *
     *========================================================================*/    
    case STM32L_STOP:
    {                 
      /* Enable Ultra low power mode */
      PWR_UltraLowPowerCmd(ENABLE);

      if(!RTCState)
      {  
        RCC_LSEConfig(RCC_LSE_OFF);
      }
      else
      {
        if (RTC_GetFlagStatus(RTC_FLAG_INITS) == RESET)
        {
          /* RTC Configuration ************************************************/
          /* Reset RTC Domain */
          RCC_RTCResetCmd(ENABLE);
          RCC_RTCResetCmd(DISABLE);
          
          /* Enable the LSE OSC */
          RCC_LSEConfig(RCC_LSE_ON);
          
          /* Wait till LSE is ready */
          while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
          {}
          
          /* Select the RTC Clock Source */
          RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
          
          /* Enable the RTC Clock */
          RCC_RTCCLKCmd(ENABLE);
          
          /* Wait for RTC APB registers synchronisation */
          RTC_WaitForSynchro();
        }        
      }
      
      /* Clear IDD_CNT_EN pin */
      GPIO_ResetBits(IDD_CNT_EN_GPIO_PORT, IDD_CNT_EN_PIN);
      
      /* Request to enter STOP mode with regulator in low power */
      PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
      
      /* Reset the counter by programming IDD_CNT_EN High in less than 70ms after
      the wakeup to avoid 1Kohm to be connected later on VDD_MCU */
      GPIO_SetBits(IDD_CNT_EN_GPIO_PORT, IDD_CNT_EN_PIN);
      
      /* Configures system clock after wake-up from STOP: enable HSE, PLL and select PLL
         as system clock source (HSE and PLL are disabled in STOP mode) */
      IDD_Measurement_SYSCLKConfig_STOP();      
    }
    break;

    /*=========================================================================*
     *                          STANDBY LOW POWER MODE                         *
     *========================================================================*/        
    case STM32L_STANDBY:
    {      
      if (RTC_GetFlagStatus(RTC_FLAG_INITS) == RESET)
      {
        /* RTC Configuration **************************************************/
        /* Reset RTC Domain */
        RCC_RTCResetCmd(ENABLE);
        RCC_RTCResetCmd(DISABLE);
        
        /* Enable the LSE OSC */
        RCC_LSEConfig(RCC_LSE_ON);
        
        /* Wait till LSE is ready */
        while (RCC_GetFlagStatus(RCC_FLAG_LSERDY) == RESET)
        {}
        
        /* Select the RTC Clock Source */
        RCC_RTCCLKConfig(RCC_RTCCLKSource_LSE);
        
        /* Enable the RTC Clock */
        RCC_RTCCLKCmd(ENABLE);
        
        /* Wait for RTC APB registers synchronisation */
        RTC_WaitForSynchro();
      } 
      
      RTC_OutputTypeConfig(RTC_OutputType_PushPull);
      RTC_OutputConfig(RTC_Output_WakeUp, RTC_OutputPolarity_High);  
      
      /* To configure PC13 WakeUP output */
      GPIO_InitStructure.GPIO_Pin = GPIO_Pin_13;
      GPIO_InitStructure.GPIO_OType = GPIO_OType_PP;
      GPIO_InitStructure.GPIO_PuPd = GPIO_PuPd_NOPULL;
      GPIO_InitStructure.GPIO_Speed = GPIO_Speed_400KHz;  
      GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF;
      GPIO_Init(GPIOC, &GPIO_InitStructure); 
      GPIO_PinAFConfig(GPIOC, GPIO_PinSource13, GPIO_AF_RTC_AF1);
      
      PWR_WakeUpPinCmd(PWR_WakeUpPin_1, ENABLE);
      
      PWR_UltraLowPowerCmd(ENABLE); 
      
      RTC_ClearFlag(RTC_FLAG_WUTF | RTC_FLAG_ALRBF | RTC_FLAG_ALRAF | RTC_FLAG_TAMP1F | RTC_FLAG_TSF); 
      RTC_ITConfig(RTC_IT_WUT, DISABLE);

      if(!RTCState)
      {  
        RCC_LSEConfig(RCC_LSE_OFF);
      }
      
      /* Clear Wake Up flag */
      PWR_ClearFlag(PWR_FLAG_WU);  
      
      /* Request to enter STANDBY mode (Wake Up flag is cleared in PWR_EnterSTANDBYMode function) */
      PWR_EnterSTANDBYMode();
    }     
    break; 
  }

  /* Configure the System Clock to 32MHz */
  SetHCLKTo32();
      
  /* Reset lowpower status variable*/  
  LowPowerStatus = 0x00;
      
  RCC->AHBENR = RCC_AHBENR;
  RCC->APB2ENR = RCC_APB2ENR;
  RCC->APB1ENR = RCC_APB1ENR;
      
  /* Reset the counter by programming IDD_CNT_EN High in less than 70ms after
     the wakeup to avoid 1Kohm to be connected later on VDD_MCU */
  GPIO_SetBits(IDD_CNT_EN_GPIO_PORT, IDD_CNT_EN_PIN);
  
  /* Measure the Voltage using the ADC */    
  adcdata = IDD_Measurement_ADC_ReadValue();
  
  /* Write the ADC converted value in the DATA EEPROM memory for Bias Measurement */
  if(CalibrationState == BIAS_CALIB_ON)
  {
    /* Unlock EEPROM write access*/
    DATA_EEPROM_Unlock();
  
    /* Store the value in EEPROM for application needs */
    DATA_EEPROM_ProgramHalfWord(DATA_EEPROM_BIAS_ADDR, adcdata);
  
    /* Lock back EEPROM write access */
    DATA_EEPROM_Lock(); 
  }

  IDD_Measurement_ADC_DisplayValue(adcdata, mode);
    
  /* Clear Wake Up flag */
  PWR_ClearFlag(PWR_FLAG_WU);
      
  /* Enable PVD */
  PWR_PVDCmd(ENABLE);
      
  /* Restore Demonstration Context. */
  IDD_Measurement_RestoreContext();
  
  LCD_SetBackColor(LCD_COLOR_GREEN);  
  LCD_DisplayStringLine(LCD_LINE_6, "STM32L LowPower Mode");          
  LCD_DisplayStringLine(LCD_LINE_7, Str);

  LCD_DisplayStringLine(LCD_LINE_8, "Press JoyStick to   ");
  LCD_DisplayStringLine(LCD_LINE_9, "continue.           ");  

  /* Wait until Joystick pressed. */
  while (Menu_ReadKey() == NOKEY)
  {} 
  
  /* Disable ADC1 */
  ADC_Cmd(ADC1, DISABLE);

  LCD_Clear(LCD_COLOR_WHITE);
  
  LCD_GLASS_DisplayString(" STM32L ");

  /* Enable the Wakeup Interrupt */
  RTC_ITConfig(RTC_IT_WUT, ENABLE);

  /* Enable the JoyStick interrupts */
  Demo_IntExtOnOffConfig(ENABLE);
  
  /* Display the previous menu */
  Menu_DisplayMenu(); 
}
コード例 #17
0
ファイル: main.c プロジェクト: arantius/vfd-clock
void initUart() {
  RCC_APB2PeriphClockCmd(
      RCC_APB2Periph_USART1 | RCC_APB2Periph_GPIOA | RCC_APB2Periph_AFIO,
      ENABLE);

  GPIO_InitTypeDef GPIO_InitStructure;
  GPIO_StructInit(&GPIO_InitStructure);

  // Transmit pin.
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9,
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  // Receive pin.
  GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;
  GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;
  GPIO_Init(GPIOA, &GPIO_InitStructure);

  // Default clock structure works for us.
  USART_ClockInitTypeDef USART_ClockInitStructure;
  USART_ClockStructInit(&USART_ClockInitStructure);
  USART_ClockInit(USART1, &USART_ClockInitStructure);

  // Default USART structure works for us.
  USART_InitTypeDef USART_InitStructure;
  USART_StructInit(&USART_InitStructure);
  USART_Init(USART1, &USART_InitStructure);

  USART_Cmd(USART1, ENABLE);

//  // Disable data pushes from GPS.
//  usartTx("$PUBX,40,GGA,0,0,0,0*5A\r\n");
//  usartTx("$PUBX,40,GGA,0,0,0,0*5A\r\n");  // Repeat first; timing work around.
//  usartTx("$PUBX,40,GLL,0,0,0,0*5C\r\n");
//  usartTx("$PUBX,40,GSA,0,0,0,0*4E\r\n");
//  usartTx("$PUBX,40,GSV,0,0,0,0*59\r\n");
//  usartTx("$PUBX,40,RMC,0,0,0,0*47\r\n");
//  usartTx("$PUBX,40,VTG,0,0,0,0*5E\r\n");
//  // Keep just the recommended minimum flowing, slowly.
//  usartTx("$PUBX,40,GGA,0,15,0,0*6E\r\n");
//  usartTx("$PUBX,40,GGA,0,15,0,0*6E\r\n");  // Repeat first; timing work around.
//  usartTx("$PUBX,40,GLL,0,15,0,0*68\r\n");
//  usartTx("$PUBX,40,GSA,0,15,0,0*7A\r\n");
//  usartTx("$PUBX,40,GSV,0,15,0,0*6D\r\n");
//  usartTx("$PUBX,40,RMC,0,15,0,0*73\r\n");
//  usartTx("$PUBX,40,VTG,0,15,0,0*6A\r\n");

  // The first character is sometimes (always?) dropped, so send a few
  // buffer characters that can be safely discarded.
  gpsTxChar('\r'); gpsTxChar('\n');
  gpsTxChar('\r'); gpsTxChar('\n');

  // Disable all data pushes from GPS.
  gpsSetPushFreq("DTM", 0);
  gpsSetPushFreq("GBS", 0);
  gpsSetPushFreq("GGA", 0);
  gpsSetPushFreq("GLL", 0);
  gpsSetPushFreq("GPQ", 0);
  gpsSetPushFreq("GRS", 0);
  gpsSetPushFreq("GSA", 0);
  gpsSetPushFreq("GST", 0);
  gpsSetPushFreq("GSV", 0);
  gpsSetPushFreq("RMC", 0);
  gpsSetPushFreq("THS", 0);
  gpsSetPushFreq("VTG", 0);
  // Except the one which tells us what time it is.
  gpsSetPushFreq("ZDA", 2);

  // Now that it won't be noisy, enable the RX interrupt.
  NVIC_InitTypeDef NVIC_InitStructure = {
    .NVIC_IRQChannel = USART1_IRQn,
    .NVIC_IRQChannelPreemptionPriority = 1,
    .NVIC_IRQChannelSubPriority = 1,
    .NVIC_IRQChannelCmd = ENABLE,
  };
  NVIC_Init(&NVIC_InitStructure);
  USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);
}

// \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ // \\ //

void RTC_IRQHandler(void) {
  if (RTC_GetFlagStatus(RTC_FLAG_SEC) != RESET) {
    RTC_ClearFlag(RTC_FLAG_SEC);
    gSecondFlag = 1;
    gSeconds = RTC_GetCounter();
  }
}


void SysTick_Handler(void) {
  gBlinkTick++;
  if (gBlinkTick > 125) {
    gBlinkTick = 0;
    gBlinkStatus = !gBlinkStatus;
  }

  uint8_t btnPressed = 0;
  uint16_t btns = GPIO_ReadInputData(BTN_PORT) & BTN_ALL_PINS;
  if ((btns & BTN_MAPLE_PIN) == BTN_MAPLE_PIN) btnPressed = BTN_MAPLE;
  else if ((btns & BTN_DIM_PIN) == 0) btnPressed = BTN_DIM;
  else if ((btns & BTN_DN_PIN) == 0) btnPressed = BTN_DOWN;
  else if ((btns & BTN_UP_PIN) == 0) btnPressed = BTN_UP;
  else if ((btns & BTN_SET_PIN) == 0) btnPressed = BTN_SET;
  if (btnPressed && gButtonPending == btnPressed) {
    if (gButtonDebounce > 10) {
      // Button already activated, still held, do nothing.
    } else if (gButtonDebounce == 10) {
      // Transition!  Set pressed button.
      gButtonPressed = btnPressed;
      gButtonDebounce++;
    } else {
      gButtonDebounce++;
    }
  } else {
    gButtonDebounce = 0;
    gButtonPending = btnPressed;
  }

  if (gDpTick > 0) {
    gDpTick--;
    if (gDpTick == 0) {
      GPIO_WriteBit(DP_PORT, DP_PIN, RESET);
    }
  }
}
コード例 #18
0
ファイル: main.c プロジェクト: Axis-Labs/STM32
/**
  * @brief   Main program.
  * @param  None
  * @retval None
  */
int main(void)
{
  /*!< At this stage the microcontroller clock setting is already configured, 
       this is done through SystemInit() function which is called from startup
       file (startup_stm32f10x_xx.s) before to branch to application main.
       To reconfigure the default setting of SystemInit() function, refer to
       system_stm32f10x.c file
     */     

  /* Initialize LEDs and Key Button mounted on STM3210X-EVAL board */       
  STM_EVAL_LEDInit(LED1);
  STM_EVAL_LEDInit(LED2);
  STM_EVAL_LEDInit(LED3);
  STM_EVAL_PBInit(BUTTON_KEY, BUTTON_MODE_EXTI);

  /* Enable PWR and BKP clock */
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_PWR | RCC_APB1Periph_BKP, ENABLE);

  /* Configure EXTI Line to generate an interrupt on falling edge */
  EXTI_Configuration();

  /* Configure RTC clock source and prescaler */
  RTC_Configuration();

  /* NVIC configuration */
  NVIC_Configuration();

  /* Configure the SysTick to generate an interrupt each 1 millisecond */
  SysTick_Configuration();

  /* Turn on LED1 */
  STM_EVAL_LEDOn(LED1);
  
  while (1)
  {
    /* Insert 1.5 second delay */
    Delay(1500);

    /* Wait till RTC Second event occurs */
    RTC_ClearFlag(RTC_FLAG_SEC);
    while(RTC_GetFlagStatus(RTC_FLAG_SEC) == RESET);

    /* Alarm in 3 second */
    RTC_SetAlarm(RTC_GetCounter()+ 3);
    /* Wait until last write operation on RTC registers has finished */
    RTC_WaitForLastTask();

    /* Turn off LED1 */
    STM_EVAL_LEDOff(LED1);

    /* Request to enter STOP mode with regulator in low power mode*/
    PWR_EnterSTOPMode(PWR_Regulator_LowPower, PWR_STOPEntry_WFI);
    
    /* At this stage the system has resumed from STOP mode -------------------*/
    /* Turn on LED1 */
    STM_EVAL_LEDOn(LED1);

    /* Configures system clock after wake-up from STOP: enable HSE, PLL and select 
       PLL as system clock source (HSE and PLL are disabled in STOP mode) */
    SYSCLKConfig_STOP();
  }
}