wakeup function

[SRAM.11]

How to use Port D as wake up function after the STMS003

goes to sleep

 

[AA1]

You have to configure a pin to generate and interrupt and you need the interrupt handler. See RM0016 "External interrupts" and "Power management"

[SRAM.11]

Thank you I had find out solution for sleep mode and also found my AWU config wrong I am trying to correct that.Now my sleep mode have been executed but wakeup function not.It may be because of that halt function? when I am running my code in step by step debugger it says program went to halt .

[Peter BENSCH]

Have you configured the port pin as an input pin?
Have you set the interrupt on this port pin to the desired edge (falling, rising) and activated it?

Regards
/Peter

[SRAM.11]

Yes in stm8s003f  I couldn't find the EXTIPIN sensitivity but I set it for the port

[Peter BENSCH]

So far you haven't shown any code. How are the following registers configured:

• CCR
• PD_DDR
• PD_CR1
• PD_CR2
• EXTI_CR1
• PWR_CSR

 

[SRAM.11]

#include "stm8s.h"
#include "stm8s_clk.h"
#include "stm8s_adc1.h"
#include "stm8s_gpio.h"
#include "stm8s_tim2.h"
#include "main.h"
#include "flash.h"
//#include "stm8s_iwdg.h"
//#include "stm8s_awu.h"
#include "stm8s_exti.h"




volatile unsigned short _500ms_tick;
volatile unsigned short idle_counter;

void Clk_Config(void);
void ADC_Config(void);
void GPIO_Config(void);
void EXTI_Setup(void);
void ADC_Read1(uint16_t *MV);
void ADC_Read2(uint16_t *Vbat);
void ADC_Read3(uint16_t *Ocd);
void ADC_Read4(uint16_t *Temp) ;
	void AWU_Config(void);
main()
{
uint16_t MV=0,Vbat=0,Ocd=0,Temp=0;
	unsigned short i;
	int counting = 0;


	Clk_Config();
	
	ADC_Config();
	
	GPIO_Config(); 
		

	EXTI_Setup();

	
	while(MV<100)
	{
		ADC_Read1(&MV);
	 delay_ms(100);
		Set_LED(0);
		idle_counter++;
		
		if (idle_counter>=300)
		{
		
		 EnterSleepMode();
		}
 
	}
	
	 
	
	while (1)
	
	{
	ADC_Read1(&MV);
 delay_ms(100);
		
	ADC_Read2(&Vbat);
	delay_ms(100);
	
	ADC_Read3(&Ocd);
		delay_ms(100);
		
	ADC_Read4(&Temp);
 delay_ms(100);
	
 if (MV > 20) // Mains Detect
 //WakeupFromSleep();
		{
 if ((MV < 370) && (Vbat > 227)) // Mains Fail
					{
 En_Emergency(1); 
						Set_LED(0);
												
					}
			 			
 else 
 {
 En_Emergency(0);
						Set_LED(0);
			 }
				
			 
				
		}
		if(MV<=10)
		{
			ADC_Read3(&Ocd);
			delay_ms(100);
			Set_LED(0);
						if(Ocd<93 || Ocd>186)
						{
						Set_LED(1); 
						delay_ms(1000);	
						Set_LED(0); 
						delay_ms(1000);	
						Set_LED(1); 
						delay_ms(1000);	
						Set_LED(0); 
						delay_ms(1000);	
						Set_LED(1);
						delay_ms(1000);	
						Set_LED(0); 				
				
							delay_ms(5000);	
				
						}
				else if(Ocd>93 || Ocd<186)
				{
				Set_LED(0);
				}
			
	}
	
		ADC_Read2(&Vbat);
			if (MV < 250)
			{
				Set_LED(0);
			}
			else if(Vbat>460 || Vbat < 155)
			 {
					Set_Bch(1);
					Set_LED(0);
				}
			else if( Vbat>395)
			 {
					
					Set_LED(1); 
					Set_Bch(0);
				}
			else if(Vbat<383)
				{
						Set_LED(1); 
						Set_Bch(1);
				}
			ADC_Read4(&Temp);
			if(Temp>87 || Temp>425)
			{
				Set_Bch(1);
			}
			else //if(Vbat<87 || Vbat>425)
			{
			 Set_Bch(0);
				Set_LED(1); 
				delay_ms(1000);	
				Set_LED(0); 
				delay_ms(1000);	
				Set_LED(1); 
				delay_ms(1000);	
				Set_LED(0); 
				delay_ms(5000);
			 
			}
			
			

			
			


}
}



void Clk_Config() // INTERNAL CLOCK CONFIGUARATION
	{
	CLK_DeInit();
	
	CLK_HSECmd(DISABLE);
	CLK_LSICmd(DISABLE);
	CLK_HSICmd(ENABLE);
	while(CLK_GetFlagStatus(CLK_FLAG_HSIRDY) == FALSE);
	
	CLK_ClockSwitchCmd(ENABLE);
	CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV2);
	CLK_SYSCLKConfig(CLK_PRESCALER_CPUDIV1);
	
	CLK_ClockSwitchConfig(CLK_SWITCHMODE_AUTO, CLK_SOURCE_HSI, 
	DISABLE, CLK_CURRENTCLOCKSTATE_ENABLE);
	

	CLK_PeripheralClockConfig(CLK_PERIPHERAL_ADC, ENABLE);
	 CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER2, ENABLE);
	}

void ADC_Config() // ADC INITIALIZATION
	{
		 ADC1_DeInit();
		
		 ADC1_Cmd(ENABLE);

 ADC1_ITConfig(ADC1_IT_EOCIE, ENABLE);
		
	}
	
void ADC_Read1(uint16_t *MV)
{
	
	 ADC1_Init(ADC1_CONVERSIONMODE_CONTINUOUS, // MAINS INPUT
					 ADC1_CHANNEL_5,
					 ADC1_PRESSEL_FCPU_D2, 
					 ADC1_EXTTRIG_GPIO, 
					 DISABLE, 
					 ADC1_ALIGN_RIGHT, 
					 ADC1_SCHMITTTRIG_CHANNEL5, 
					 DISABLE);
 ADC1_StartConversion();
 while (!ADC1_GetFlagStatus(ADC1_FLAG_EOC))
 {
 // Wait for conversion to complete
 }

 *MV= ADC1_GetConversionValue();

}
void ADC_Read2(uint16_t *Vbat)
{
	 ADC1_Init(ADC1_CONVERSIONMODE_CONTINUOUS, //ADC Channel_4 VBATT
					 ADC1_CHANNEL_4,
					 ADC1_PRESSEL_FCPU_D2, 
					 ADC1_EXTTRIG_GPIO, 
					 DISABLE, 
					 ADC1_ALIGN_RIGHT, 
					 ADC1_SCHMITTTRIG_CHANNEL4, 
					 DISABLE);
 ADC1_StartConversion();
 while (!ADC1_GetFlagStatus(ADC1_FLAG_EOC))
 {
 // Wait for conversion to complete
 }

 
	*Vbat=ADC1_GetConversionValue();
}
void ADC_Read3(uint16_t *Ocd) // ADC Channel_2 OPEN CIRCUIT DETECTION
{
	 ADC1_Init(ADC1_CONVERSIONMODE_CONTINUOUS, 
					 ADC1_CHANNEL_2,
					 ADC1_PRESSEL_FCPU_D2, 
					 ADC1_EXTTRIG_GPIO, 
					 DISABLE, 
					 ADC1_ALIGN_RIGHT, 
					 ADC1_SCHMITTTRIG_CHANNEL2, 
					 DISABLE);
 ADC1_StartConversion();
 while (!ADC1_GetFlagStatus(ADC1_FLAG_EOC))
 {
 // Wait for conversion to complete
 }

 
	*Ocd=ADC1_GetConversionValue();
}
void ADC_Read4(uint16_t *Temp) // ADC Channel_2 TEMPARATURE MONITORING
{
	 ADC1_Init(ADC1_CONVERSIONMODE_CONTINUOUS, 
					 ADC1_CHANNEL_3,
					 ADC1_PRESSEL_FCPU_D2, 
					 ADC1_EXTTRIG_GPIO, 
					 DISABLE, 
					 ADC1_ALIGN_RIGHT, 
					 ADC1_SCHMITTTRIG_CHANNEL3, 
					 DISABLE);
 ADC1_StartConversion();
 while (!ADC1_GetFlagStatus(ADC1_FLAG_EOC))
 {
 // Wait for conversion to complete
 }

 
	*Temp=ADC1_GetConversionValue();
}

void GPIO_Config(void)
	{
								//GPIO INPUTS
			
		//GPIO_Init(GPIOD,GPIO_PIN_2,GPIO_MODE_IN_FL_NO_IT);			// TEMP SENSE
		GPIO_Init(GPIOD,GPIO_PIN_3,GPIO_MODE_IN_FL_NO_IT);			//VBATT
		GPIO_Init(GPIOD,GPIO_PIN_5,GPIO_MODE_IN_FL_NO_IT);			//MAINS INPUT
		GPIO_Init(GPIOC,GPIO_PIN_4,GPIO_MODE_IN_FL_NO_IT);			// OCD SENSE
		
		
								//GPIO OUTPUTS
								
		GPIO_Init(GPIOA,GPIO_PIN_3,GPIO_MODE_OUT_PP_LOW_FAST);			// MAIN LAMP
		GPIO_Init(GPIOC,GPIO_PIN_3,GPIO_MODE_OUT_PP_HIGH_FAST);			//LED O/P
		GPIO_Init(GPIOC,GPIO_PIN_5,GPIO_MODE_OUT_PP_LOW_FAST);			//BCH
		
	}
void TIM2_Config(void)
{
 TIM2_TimeBaseInit(TIM2_PRESCALER_32768, 244);
 TIM2_ClearFlag(TIM2_FLAG_UPDATE);
 TIM2_ITConfig(TIM2_IT_UPDATE, ENABLE);
 TIM2_Cmd(ENABLE);
		AWU_DeInit();
		
		/* auto wake up at 32ms */
		AWU_Init(AWU_TIMEBASE_32MS);
		
		/* enable auto wake up*/
		AWU_Cmd(ENABLE);
		
		enableInterrupts();
}


 
INTERRUPT_HANDLER(TIM2_UPD_OVF_BRK_IRQHandler, 13)
{
 if (TIM2_GetITStatus(TIM2_IT_UPDATE) != RESET)
 {
			
 // Increment the idle_counter every 500ms
 idle_counter++;

 // Enter sleep mode if idle for approximately 30 seconds (60 * 500ms)
 if (idle_counter >= 300)
 {
 EnterSleepMode();
 }
				TIM2_ClearITPendingBit(TIM2_IT_UPDATE);
 }
}

void EnterSleepMode(void)
{
 // Disable TIM2 interrupt
 TIM2_ITConfig(TIM2_IT_UPDATE, DISABLE);

 // Disable ADC peripheral
 ADC1_Cmd(DISABLE);

 // Disable GPIO inputs
 GPIO_Init(GPIOD, GPIO_PIN_3, GPIO_MODE_IN_PU_NO_IT);
 GPIO_Init(GPIOD, GPIO_PIN_5, GPIO_MODE_IN_FL_IT);
 GPIO_Init(GPIOC, GPIO_PIN_4, GPIO_MODE_IN_PU_NO_IT);

 halt();

 // Re-enable ADC peripheral
 
}

void Inc500mSCounter(void)
{
 if (_500ms_tick < 500)
 {
 _500ms_tick++;
 }
 else
 {
 _500ms_tick = 0;
 idle_counter++;
 }
}
/*void IWDG_Config(void)
	{
		uint8_t WTG_TIME;
	
		IWDG_Enable();
		
	
		IWDG_WriteAccessCmd(IWDG_WriteAccess_Enable);
		
		
		IWDG_SetPrescaler(IWDG_Prescaler_128);
		
		
		IWDG_SetReload( WTG_TIME);
		
		
		IWDG_ReloadCounter();
		
	}*/
/*void AWU_Config(void)
{
	AWU_Init(AWU_TIMEBASE_32MS);
		
	
		AWU_Cmd(ENABLE);
		
		enableInterrupts();
}*/




void EXTI_Setup(void)
{
	EXTI_DeInit();
	EXTI_SetExtIntSensitivity(EXTI_PORT_GPIOD, EXTI_SENSITIVITY_RISE_ONLY);
	EXTI_SetTLISensitivity(EXTI_TLISENSITIVITY_RISE_ONLY);

}

void WakeupFromSleep(void)
{
	ADC1_Cmd(ENABLE);

 // Re-enable GPIO inputs
 GPIO_Init(GPIOD, GPIO_PIN_3, GPIO_MODE_IN_FL_NO_IT);
 GPIO_Init(GPIOD, GPIO_PIN_5, GPIO_MODE_IN_FL_NO_IT);
 GPIO_Init(GPIOC, GPIO_PIN_4, GPIO_MODE_IN_FL_NO_IT);

 // Reset idle counter
 idle_counter = 0;

 // Re-enable TIM2 interrupt
 TIM2_ITConfig(TIM2_IT_UPDATE, ENABLE);
 
}
INTERRUPT_HANDLER(EXTI_PORTD_IRQHandler, 6)
{
	 //EXTI_ClearITPendingBit(EXTI_PORT_GPIOD);
 { // Wake up from sleep mode
 WakeupFromSleep();
 }
}

for this code my sleep function is working if i enable Apologies for any confusion in this code as I am literally working on it to sort it out .I am in an independent work environment no teams to help it out.Little struggle in developing the code