Timer0 Mode0

Macros
#define	INTO   P32
	INT0 pin definition.

init
Timer initializaion functions
#define	timer0_mode0_12T_init()
	Initialize mode0 12T for timer0.
#define	timer0_mode0_1T_init()
	Initialize mode0 1T for timer0.

config
Timer configuration functions
#define	timer0_mode0_enable_P35_output()   (bit_set(INT_CLKO, SBIT0))
	Enable P35 meander output.
#define	timer0_mode0_disable_P35_output()   (bit_clr(INT_CLKO, CBIT0))
	Disable P35 meander output.
#define	is_timer0_mode0_P35_output_enabled()   (test_if_bit_set(INT_CLKO, SBIT0))
	Get output to pin P3.5 output flag enabled value.
#define	timer0_mode0_close_gate()   (bit_set(TMOD, SBIT3))
	Close timer starting gate.
#define	timer0_mode0_open_gate()   (bit_clr(TMOD, CBIT3))
	Open timer starting gate.
#define	is_timer0_mode0_gate_opened()   (test_if_bit_cleared(TMOD, SBIT3))
	Get timer starting gate state.

run in async mode
Timer run/stop/reload functions
#define	timer0_mode0_reload(ticks)
	Reload timer0 mode0 ticks on the fly.
#define	timer0_mode0_direct_reload(th0, tl0)
	Reload timer0 mode0 timer TL0 and TH0 on the fly.
#define	timer0_mode0_start(ticks)
	Run timer0.
#define	timer0_mode0_direct_start(th0, tl0)
	Run timer0 with direct set of TL0, TH0 registers.
#define	timer0_mode0_stop()
	Stop timer0.
#define	is_timer0_mode0_started()   (TR0 == 1 && (is_timer0_mode0_gate_opened() || INT0 == 1))
	Get timer0 mode0 started status.

run in sync mode
Timer run once functions
#define	timer0_mode0_delay(ticks)
	Run timer0 mode0 once and wait with program flow blocking timer not finished.

Detailed Description

Functions and data structures for timer0 mode0.

This module supports general purpose timer0. Timer can work as COUNTER or TIMER. You can not use counter0 and timer0 at the same time.

Counter increments on external singnal (like pin 1/0 change state).

For timer0 in mode0:

• Input of timer is system clock.
• By default timer input is 12T mode. Timer increments by sysClock/12.
• Timer input can be switched to 1T mode. In this mode timer increments by sysClock/1.

Timer0 in mode0 can be used in sync (main prorgam flow blocked until timer overloaded) and interrupt (call interrupt handler on timer overloaded) modes.

Author

Michael Golovanov

Macro Definition Documentation

is_timer0_mode0_gate_opened

#define is_timer0_mode0_gate_opened

(

)

(test_if_bit_cleared(TMOD, SBIT3))

Get timer starting gate state.

Returns

bool true if gate is open otherwise false

is_timer0_mode0_P35_output_enabled

#define is_timer0_mode0_P35_output_enabled

(

)

(test_if_bit_set(INT_CLKO, SBIT0))

Get output to pin P3.5 output flag enabled value.

Returns

bool true if output enabled oterwise false

is_timer0_mode0_started

#define is_timer0_mode0_started

(

)

(TR0 == 1 && (is_timer0_mode0_gate_opened() || INT0 == 1))

Get timer0 mode0 started status.

Returns

bool true if started otherwise false

timer0_mode0_12T_init

#define timer0_mode0_12T_init

(

)

Value:

do {                                            \
    enable_mcu_interrupts();                    \
    enable_timer0_interrupt();                  \
    TMOD &= 0xf0;                               \
    bit_clr(AUXR, CBIT7);                       \
} while(0)

Initialize mode0 12T for timer0.

timer0_mode0_1T_init

#define timer0_mode0_1T_init

(

)

Value:

do {                                            \
    enable_mcu_interrupts();                    \
    enable_timer0_interrupt();                  \
    TMOD &= 0xf0;                               \
    bit_set(AUXR, SBIT7);                       \
} while(0)

Initialize mode0 1T for timer0.

timer0_mode0_close_gate

#define timer0_mode0_close_gate

(

)

(bit_set(TMOD, SBIT3))

Close timer starting gate.

When gate is closed timer will ticks after start only when INT0 pin is HIGH

timer0_mode0_delay

#define timer0_mode0_delay

(

ticks

)

Value:

do {                                                                    \
    bool is_gate_opened = is_timer0_mode0_gate_opened();                \
                                                                        \
    timer0_mode0_open_gate();                                           \
                                                                        \
    timer0_mode0_start(ticks);                                          \
    /* Waiting for timer overloaded (timer overload flag set to 1) */   \
    while(!TF0)                                                         \
    {                                                                   \
    }                                                                   \
    timer0_mode0_stop();                                                \
                                                                        \
    if (!is_gate_opened)                                                \
    {                                                                   \
        timer0_mode0_close_gate();                                      \
    }                                                                   \
} while(0)

Run timer0 mode0 once and wait with program flow blocking timer not finished.

Before run timer0_mode0_12T_init or timer0_mode0_1T_init should be called.

After run program flow blocked until timer does not overloaded.

Dont mix call of timer0_mode0_delay with timer0_mode0_open_gate/timer0_mode0_close_gate calls.

Parameters

ticks

uint16_t timer ticks count.

timer0_mode0_direct_reload

#define timer0_mode0_direct_reload	(		th0,
			tl0
	)

Value:

do {                                                        \
    TL0 = tl0;                                              \
    TH0 = th0;                                              \
} while(0)

Reload timer0 mode0 timer TL0 and TH0 on the fly.

Reload is available in modes 0, 2, 3.

Parameters

th0	uint8_t TH0 value
tl0	uint8_t TL0 value

timer0_mode0_direct_start

#define timer0_mode0_direct_start	(		th0,
			tl0
	)

Value:

do {                                                                                       \
    timer0_mode0_direct_reload(th0, tl0);                                               \
                                                                                        \
    TF0 = 0;                                                                            \
    TR0 = 1;                                                                            \
} while(0)

Run timer0 with direct set of TL0, TH0 registers.

Before run timer0_mode0_12T_init or timer0_mode0_1T_init should be called.

After run program flow not blocked and interrupt will raised when timer is overloaded. Interrupt handler void timer0ISR(void) __interrupt(1) should be defined in user code. Interrupt is raised when TH0 = TL0 = 0xff + 1 (TH0, TL0 overload)

Timer rerun after overloaded and interupt handler called.

Dont mix call timer0_mode0_direct_start call with void timer0_mode0_delay call

Parameters

th0	uint8_t TH0 value
tl0	uint8_t TL0 value

timer0_mode0_open_gate

#define timer0_mode0_open_gate

(

)

(bit_clr(TMOD, CBIT3))

Open timer starting gate.

When gate is open timer ticks after starts

timer0_mode0_reload

#define timer0_mode0_reload

(

ticks

)

Value:

do {                                                        \
    uint16_t value = 0xffff - ticks;                        \
    /* Load timer high and low bytes value */               \
    TL0 = value & 0xff;                                     \
    TH0 = (value >> 8) & 0xff;                              \
} while(0)

Reload timer0 mode0 ticks on the fly.

Reload is available in modes 0, 2, 3.

Parameters

ticks

uint16_t timer ticks reloaded value.

timer0_mode0_start

#define timer0_mode0_start

(

ticks

)

Value:

do {                                                                                    \
    timer0_mode0_reload(ticks);                                                         \
                                                                                        \
    TF0 = 0; /* clear timer overload flag */                                            \
    TR0 = 1; /* set run timer flag */                                                   \
} while(0)

Run timer0.

Before run timer0_mode0_12T_init or timer0_mode0_1T_init should be called.

After run program flow not blocked and interrupt will raised when timer is overloaded. Interrupt handler void timer0ISR(void) __interrupt(1) should be defined in user code.

Timer rerun after overloaded and interupt handler called.

Dont mix call timer0_mode0_start call with void timer0_mode0_delay call

Parameters

ticks

uint16_t timer ticks count.

timer0_mode0_stop

#define timer0_mode0_stop

(

)

Value:

do {                                                        \
    TR0 = 0; /* clear run timer flag */                     \
    TF0 = 0; /* clear timer overload flag */                \
} while(0)

Stop timer0.

Before stop timer0_start should be called. Dont mix timer0_stop call with timer0_mode0_delay call