تایمر 4 در STM8

63 بازدید

۱۳۹۷-۰۸-۰۹

5 دقیقه

سیسوگ در قسمت هفدهم آموزش میکروکنترلر STM8 تایمر 2 را به شما معرفی کرد. در این قسمت از مجموعه مقالات آموزش میکروکنترلر STM8 قصد دارد تایمر 4 را آموزش دهد. با سیسوگ همراه باشید.

تایمر 4 :

در میکروکنترلر، تایمر 4 نسبت به دیگر تایمرها از اهمیت بالاتری برخوردار است. این مقاله، نحوه اسکن و نمایش اطلاعات روی سون سگمنت با استفاده از وقفه را نشان می دهد، در حالیکه حلقه اصلی می تواند اطلاعات را نمایش دهد.

اتصالات سخت افزاری

اتصالات سخت افزاری تایمر 4 در STM8

نمونه کد تایمر 4

main.c

#include "STM8S.h"
 
 
unsigned int value = 0x00;
 
unsigned char n = 0x00;
const unsigned char num[0x0A] = 
{0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F};
 
 
void GPIO_setup(void);
void clock_setup(void);
void TIM4_setup(void);
 
 
void main(void)
{
    int j=0;
		
		 GPIO_setup();
     clock_setup();
     TIM4_setup();
                

		 while(TRUE)
    {
			value++;
			for(j=0;j<0x3FFF;j++);
    };
			 
}
 
 
void GPIO_setup(void)
{
	
     GPIO_DeInit(GPIOC);
		 GPIO_DeInit(GPIOD);
		 GPIO_DeInit(GPIOB);
		 
     GPIO_Init(GPIOD, ((GPIO_Pin_TypeDef)(GPIO_PIN_2 | GPIO_PIN_3 
               | GPIO_PIN_4 | GPIO_PIN_5)), GPIO_MODE_OUT_PP_LOW_FAST);
                
     
     GPIO_Init(GPIOD, GPIO_PIN_1| GPIO_PIN_6, GPIO_MODE_OUT_PP_LOW_FAST);

     GPIO_Init(GPIOC, GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7 , GPIO_MODE_OUT_PP_LOW_FAST);

     GPIO_Init(GPIOB, GPIO_PIN_4 | GPIO_PIN_5, GPIO_MODE_OUT_PP_LOW_FAST);		 
		 
}
 
 
void clock_setup(void)
{
     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_HSIDIV8);
     CLK_SYSCLKConfig(CLK_PRESCALER_CPUDIV1);
                
     CLK_ClockSwitchConfig(CLK_SWITCHMODE_AUTO, CLK_SOURCE_HSI, 
     DISABLE, CLK_CURRENTCLOCKSTATE_ENABLE);
                
     CLK_PeripheralClockConfig(CLK_PERIPHERAL_SPI, DISABLE);
     CLK_PeripheralClockConfig(CLK_PERIPHERAL_I2C, DISABLE);
     CLK_PeripheralClockConfig(CLK_PERIPHERAL_ADC, DISABLE);
     CLK_PeripheralClockConfig(CLK_PERIPHERAL_AWU, DISABLE);
     CLK_PeripheralClockConfig(CLK_PERIPHERAL_UART1, DISABLE);
     CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER1, DISABLE);
     CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER2, DISABLE);
     CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER4, ENABLE);
}
 

void TIM4_setup(void)
{   

     TIM4_DeInit();
     TIM4_TimeBaseInit(TIM4_PRESCALER_32, 128);      
     TIM4_ITConfig(TIM4_IT_UPDATE, ENABLE);
     TIM4_Cmd(ENABLE);
     
     enableInterrupts();
		 
}

#include "STM8S.h"

unsigned int value = 0x00;

unsigned char n = 0x00;

const unsigned char num[0x0A] =

{0x3F, 0x06, 0x5B, 0x4F, 0x66, 0x6D, 0x7D, 0x07, 0x7F, 0x6F};

void GPIO_setup(void);

void clock_setup(void);

void TIM4_setup(void);

void main(void)

{

int j=0;

GPIO_setup();

clock_setup();

TIM4_setup();

while(TRUE)

{

value++;

for(j=0;j<0x3FFF;j++);

};

}

void GPIO_setup(void)

{

GPIO_DeInit(GPIOC);

GPIO_DeInit(GPIOD);

GPIO_DeInit(GPIOB);

GPIO_Init(GPIOD, ((GPIO_Pin_TypeDef)(GPIO_PIN_2 | GPIO_PIN_3

| GPIO_PIN_4 | GPIO_PIN_5)), GPIO_MODE_OUT_PP_LOW_FAST);

GPIO_Init(GPIOD, GPIO_PIN_1| GPIO_PIN_6, GPIO_MODE_OUT_PP_LOW_FAST);

GPIO_Init(GPIOC, GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5 | GPIO_PIN_6 | GPIO_PIN_7 , GPIO_MODE_OUT_PP_LOW_FAST);

GPIO_Init(GPIOB, GPIO_PIN_4 | GPIO_PIN_5, GPIO_MODE_OUT_PP_LOW_FAST);

}

void clock_setup(void)

{

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_HSIDIV8);

CLK_SYSCLKConfig(CLK_PRESCALER_CPUDIV1);

CLK_ClockSwitchConfig(CLK_SWITCHMODE_AUTO, CLK_SOURCE_HSI,

DISABLE, CLK_CURRENTCLOCKSTATE_ENABLE);

CLK_PeripheralClockConfig(CLK_PERIPHERAL_SPI, DISABLE);

CLK_PeripheralClockConfig(CLK_PERIPHERAL_I2C, DISABLE);

CLK_PeripheralClockConfig(CLK_PERIPHERAL_ADC, DISABLE);

CLK_PeripheralClockConfig(CLK_PERIPHERAL_AWU, DISABLE);

CLK_PeripheralClockConfig(CLK_PERIPHERAL_UART1, DISABLE);

CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER1, DISABLE);

CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER2, DISABLE);

CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER4, ENABLE);

}

void TIM4_setup(void)

{

TIM4_DeInit();

TIM4_TimeBaseInit(TIM4_PRESCALER_32, 128);

TIM4_ITConfig(TIM4_IT_UPDATE, ENABLE);

TIM4_Cmd(ENABLE);

enableInterrupts();

}

(stm8s_it.h (top part only

#ifndef __STM8S_IT_H
#define __STM8S_IT_H
 
@far @interrupt void TIM4_UPD_IRQHandler(void);
/* Includes ------------------------------------------------------------------*/
#include "stm8s.h"

#ifndef __STM8S_IT_H

#define __STM8S_IT_H

@far @interrupt void TIM4_UPD_IRQHandler(void);

/* Includes ------------------------------------------------------------------*/

#include "stm8s.h"

stm8s_it.c

#include "stm8s.h"
#include "stm8s_it.h"
 
 
extern unsigned int value;
 
extern unsigned char n;
extern unsigned char seg;
extern const unsigned char num[10];

#define SEG_A		1
#define SEG_B		2
#define SEG_C		4
#define SEG_D		8
#define SEG_E		16
#define SEG_F		32
#define SEG_G		64

#define SegNum_0	(SEG_A|SEG_B|SEG_C|SEG_D|SEG_E|SEG_F)
#define SegNum_1	(SEG_B|SEG_C)
#define SegNum_2	(SEG_A|SEG_B|SEG_D|SEG_E|SEG_G)
#define SegNum_3	(SEG_A|SEG_B|SEG_C|SEG_D|SEG_G)
#define SegNum_4	(SEG_B|SEG_C|SEG_F|SEG_G)
#define SegNum_5	(SEG_A|SEG_C|SEG_D|SEG_F|SEG_G)
#define SegNum_6	(SEG_A|SEG_C|SEG_D|SEG_E|SEG_F|SEG_G)
#define SegNum_7	(SEG_A|SEG_B|SEG_C)
#define SegNum_8	(SEG_A|SEG_B|SEG_C|SEG_D|SEG_E|SEG_F|SEG_G)
#define SegNum_9	(SEG_A|SEG_B|SEG_C|SEG_D|SEG_F|SEG_G)

void SegWriteByte(char Data)
{
	int i;
char Pin[] =  			   {GPIO_PIN_1,GPIO_PIN_7,GPIO_PIN_6,GPIO_PIN_5,GPIO_PIN_4,GPIO_PIN_3,GPIO_PIN_6};
GPIO_TypeDef *GPIOx[]= {GPIOD,			GPIOC,			GPIOC,		GPIOC,		GPIOC,		 GPIOC,			GPIOD};
	
	
	for( i=0;i<7;i++)
	{
		if(Data&1)
		{
			GPIOx[i]->ODR |=Pin[i];
		}
		else
		{
			GPIOx[i]->ODR &=~Pin[i];
		}
		Data>>=1;
	}
	GPIO_WriteHigh(GPIOB, GPIO_PIN_4);
}

 
void TIM4_UPD_IRQHandler(void) 
{
	static char index = 0;
	GPIOD->ODR &=~((GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5));
	switch(index++)
	{
		case 0: 
		n = (value / 1000);
		SegWriteByte(num[n]);
		GPIOD->ODR |=(GPIO_PIN_5);
		break;
		case 1: 
		n = ((value / 100) % 10);
		SegWriteByte(num[n]);
		GPIOD->ODR |=(GPIO_PIN_4);
		break;
		case 2: 
		n = ((value / 10) % 10);
		SegWriteByte(num[n]);
		GPIOD->ODR |=(GPIO_PIN_3);
		break;
		case 3:
    n = (value % 10);		
		SegWriteByte(num[n]);
		GPIOD->ODR |=(GPIO_PIN_2);
		break;
	}
	
	 if(index>3)
		index = 0;
		TIM4_ClearFlag(TIM4_FLAG_UPDATE);
}

#include "stm8s.h"

#include "stm8s_it.h"

extern unsigned int value;

extern unsigned char n;

extern unsigned char seg;

extern const unsigned char num[10];

#define SEG_A 1

#define SEG_B 2

#define SEG_C 4

#define SEG_D 8

#define SEG_E 16

#define SEG_F 32

#define SEG_G 64

#define SegNum_1 (SEG_B|SEG_C)

#define SegNum_2 (SEG_A|SEG_B|SEG_D|SEG_E|SEG_G)

#define SegNum_3 (SEG_A|SEG_B|SEG_C|SEG_D|SEG_G)

#define SegNum_4 (SEG_B|SEG_C|SEG_F|SEG_G)

#define SegNum_5 (SEG_A|SEG_C|SEG_D|SEG_F|SEG_G)

#define SegNum_7 (SEG_A|SEG_B|SEG_C)

void SegWriteByte(char Data)

{

int i;

char Pin[] = {GPIO_PIN_1,GPIO_PIN_7,GPIO_PIN_6,GPIO_PIN_5,GPIO_PIN_4,GPIO_PIN_3,GPIO_PIN_6};

GPIO_TypeDef *GPIOx[]= {GPIOD, GPIOC, GPIOC, GPIOC, GPIOC, GPIOC, GPIOD};

for( i=0;i<7;i++)

{

if(Data&1)

{

GPIOx[i]->ODR |=Pin[i];

}

else

{

GPIOx[i]->ODR &=~Pin[i];

}

Data>>=1;

}

GPIO_WriteHigh(GPIOB, GPIO_PIN_4);

}

void TIM4_UPD_IRQHandler(void)

{

static char index = 0;

GPIOD->ODR &=~((GPIO_PIN_2 | GPIO_PIN_3 | GPIO_PIN_4 | GPIO_PIN_5));

switch(index++)

{

case 0:

n = (value / 1000);

SegWriteByte(num[n]);

GPIOD->ODR |=(GPIO_PIN_5);

break;

case 1:

n = ((value / 100) % 10);

SegWriteByte(num[n]);

GPIOD->ODR |=(GPIO_PIN_4);

break;

case 2:

n = ((value / 10) % 10);

SegWriteByte(num[n]);

GPIOD->ODR |=(GPIO_PIN_3);

break;

case 3:

n = (value % 10);

SegWriteByte(num[n]);

GPIOD->ODR |=(GPIO_PIN_2);

break;

}

if(index>3)

index = 0;

TIM4_ClearFlag(TIM4_FLAG_UPDATE);

}

stm8_interrupt_vector.c

/*	BASIC INTERRUPT VECTOR TABLE FOR STM8 devices
 *	Copyright (c) 2007 STMicroelectronics
 */
#include "stm8s_it.h"

typedef void @far (*interrupt_handler_t)(void);

struct interrupt_vector {
	unsigned char interrupt_instruction;
	interrupt_handler_t interrupt_handler;
};

@far @interrupt void NonHandledInterrupt (void)
{
	/* in order to detect unexpected events during development, 
	   it is recommended to set a breakpoint on the following instruction
	*/
	return;
}

extern void _stext();     /* startup routine */
//@far @interrupt void TIM4_UPD_IRQHandler(void) ;

struct interrupt_vector const _vectab[] = {
	{0x82, (interrupt_handler_t)_stext}, /* reset */
	{0x82, NonHandledInterrupt}, /* trap  */
	{0x82, NonHandledInterrupt}, /* irq0  */
	{0x82, NonHandledInterrupt}, /* irq1  */
	{0x82, NonHandledInterrupt}, /* irq2  */
	{0x82, NonHandledInterrupt}, /* irq3  */
	{0x82, NonHandledInterrupt}, /* irq4  */
	{0x82, NonHandledInterrupt}, /* irq5  */
	{0x82, NonHandledInterrupt}, /* irq6  */
	{0x82, NonHandledInterrupt}, /* irq7  */
	{0x82, NonHandledInterrupt}, /* irq8  */
	{0x82, NonHandledInterrupt}, /* irq9  */
	{0x82, NonHandledInterrupt}, /* irq10 */
	{0x82, NonHandledInterrupt}, /* irq11 */
	{0x82, NonHandledInterrupt}, /* irq12 */
	{0x82, NonHandledInterrupt}, /* irq13 */
	{0x82, NonHandledInterrupt}, /* irq14 */
	{0x82, NonHandledInterrupt}, /* irq15 */
	{0x82, NonHandledInterrupt}, /* irq16 */
	{0x82, NonHandledInterrupt}, /* irq17 */
	{0x82, NonHandledInterrupt}, /* irq18 */
	{0x82, NonHandledInterrupt}, /* irq19 */
	{0x82, NonHandledInterrupt}, /* irq20 */
	{0x82, NonHandledInterrupt}, /* irq21 */
	{0x82, NonHandledInterrupt}, /* irq22 */
	{0x82, (interrupt_handler_t)TIM4_UPD_IRQHandler}, /* irq23 */
	{0x82, NonHandledInterrupt}, /* irq24 */
	{0x82, NonHandledInterrupt}, /* irq25 */
	{0x82, NonHandledInterrupt}, /* irq26 */
	{0x82, NonHandledInterrupt}, /* irq27 */
	{0x82, NonHandledInterrupt}, /* irq28 */
	{0x82, NonHandledInterrupt}, /* irq29 */
};

/* BASIC INTERRUPT VECTOR TABLE FOR STM8 devices

#include "stm8s_it.h"

typedef void @far (*interrupt_handler_t)(void);

struct interrupt_vector {

unsigned char interrupt_instruction;

interrupt_handler_t interrupt_handler;

};

@far @interrupt void NonHandledInterrupt (void)

{

/* in order to detect unexpected events during development,

it is recommended to set a breakpoint on the following instruction

return;

}

extern void _stext(); /* startup routine */

//@far @interrupt void TIM4_UPD_IRQHandler(void) ;

struct interrupt_vector const _vectab[] = {

{0x82, (interrupt_handler_t)_stext}, /* reset */

{0x82, NonHandledInterrupt}, /* trap */

{0x82, NonHandledInterrupt}, /* irq0 */

{0x82, NonHandledInterrupt}, /* irq1 */

{0x82, NonHandledInterrupt}, /* irq2 */

{0x82, NonHandledInterrupt}, /* irq3 */

{0x82, NonHandledInterrupt}, /* irq4 */

{0x82, NonHandledInterrupt}, /* irq5 */

{0x82, NonHandledInterrupt}, /* irq6 */

{0x82, NonHandledInterrupt}, /* irq7 */

{0x82, NonHandledInterrupt}, /* irq8 */

{0x82, NonHandledInterrupt}, /* irq9 */

{0x82, NonHandledInterrupt}, /* irq10 */

{0x82, NonHandledInterrupt}, /* irq11 */

{0x82, NonHandledInterrupt}, /* irq12 */

{0x82, NonHandledInterrupt}, /* irq13 */

{0x82, NonHandledInterrupt}, /* irq14 */

{0x82, NonHandledInterrupt}, /* irq15 */

{0x82, NonHandledInterrupt}, /* irq16 */

{0x82, NonHandledInterrupt}, /* irq17 */

{0x82, NonHandledInterrupt}, /* irq18 */

{0x82, NonHandledInterrupt}, /* irq19 */

{0x82, NonHandledInterrupt}, /* irq20 */

{0x82, NonHandledInterrupt}, /* irq21 */

{0x82, NonHandledInterrupt}, /* irq22 */

{0x82, (interrupt_handler_t)TIM4_UPD_IRQHandler}, /* irq23 */

{0x82, NonHandledInterrupt}, /* irq24 */

{0x82, NonHandledInterrupt}, /* irq25 */

{0x82, NonHandledInterrupt}, /* irq26 */

{0x82, NonHandledInterrupt}, /* irq27 */

{0x82, NonHandledInterrupt}, /* irq28 */

{0x82, NonHandledInterrupt}, /* irq29 */

};

توضیحات

کلاک داخلی و CPU هر دو روی 2 مگاهرتز کار می کنند.

CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV8);
CLK_SYSCLKConfig(CLK_PRESCALER_CPUDIV1);
....
….
CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER4, ENABLE);

CLK_HSIPrescalerConfig(CLK_PRESCALER_HSIDIV8);

CLK_SYSCLKConfig(CLK_PRESCALER_CPUDIV1);

....

….

CLK_PeripheralClockConfig(CLK_PERIPHERAL_TIMER4, ENABLE);

تایمر 4 یک تایمر پایه است و بهتر است آن را برای کارهای ساده استفاده کنیم. ما آن را با مقدار پیش فرض 32 و بارگیری شمارنده روی 128 تنظیم کردیم. این مقادیر باعث می شود تایمر 4 سرریز کند و وقفه ای 2ms ای ایجاد کند. که این مدت زمان برای نمایش اطلاعات بر روی یک سون سگمنت کافی است. در اینجا 4 سون سگمنت در طول 8ms به روز می شوند ولی چشم شما تمامی اطلاعات را در یک لحظ می بیند، در واقع در اینجا به مغز انسان حقه میزنیم. در نهایت، باید وقفه های که مورد نیاز هستند را فعال کنیم.

void TIM4_setup(void)
{               
    TIM4_DeInit();
    TIM4_TimeBaseInit(TIM4_PRESCALER_32, 128);     
    TIM4_ITConfig(TIM4_IT_UPDATE, ENABLE);
    TIM4_Cmd(ENABLE);
    
    enableInterrupts();
}

void TIM4_setup(void)

{

TIM4_DeInit();

TIM4_TimeBaseInit(TIM4_PRESCALER_32, 128);

TIM4_ITConfig(TIM4_IT_UPDATE, ENABLE);

TIM4_Cmd(ENABLE);

enableInterrupts();

}

اولین مثال از وقفه ها در مجموعه آموزش میکروکنترلر STM8 را به یاد می آورید؟ همان طور که در پست های قبل دیدیم ما باید به کامپایلر بگوییم که از کدام وقفه استفاده می کنیم. با توجه به دیتاشیت مشاهده می شود که آپدیت و سرریز تایمر 4 در IRQ4 قرار دارد. بنابراین باید این تغییرات را در فایل stm8_interrupt_vector.c انجام دهیم:

{0x82, (interrupt_handler_t)TIM4_UPD_IRQHandler}, /* irq23 */

1	{0x82, (interrupt_handler_t)TIM4_UPD_IRQHandler}, /* irq23 */

به یاد داشته باشید که چون در این کد از وقفه استفاده می کنیم فایل های هدر و سورس وقفه را اضافه کنید. درون ISR، اسکن هر سون سگمنت را انجام می دهیم. هربار که وقفه سرریز کند سون سگمنت تغییر می کند. در پایان ISR یک شماره افزایش می یابد تا در هنگام سرریز جدید صفحه نمایش بعدی را انتخاب کند. در داخل Switch-Case، سون سگمنت ها را فعال و درباره مقداری را که باید نشان دهند تصمیم می گیریم. سرانجام پرچم سرریز/به روز رسانی پاک می شود.

تایمر 4 در STM8