Timerproblem

[schorsch_76]

Hallo zusammen!

Momentan erzeugen meine 3 Timer konstant IRQs. Das funktioniert auch im CTC Mode.

Das Problem: Jetzt möchte ich aber in der ISR des Timer1 den Timer0 bzw Timer 2 starten. Diese sollen "Singleshot" Timer sein. Bisher habe ich diese am Anfang vor der while(1) Schleife Prescale etc initialisiert. um jetzt den Timer zu starten, setze ich jetzt in der Timer1 ISR

OCR0A = x-1;	TIMSK0 |= (1 << OCIE0A);

Die Timer0 ISR macht ihre Aktion und soll dann sich selbst wieder stoppen mit

TIMSK0 &= ~(1 << OCIE0A);

Geht das prinzipell oder ist das unmöglich dass der Atmega168 in einer TimerISR einen anderen Timer startet? Bzw seine "eigenen" IRQ register beschreibt?

Der Atmega168 läuft mit 16 MHz.

Hier ist mein Code:

#include <stdlib.h>
#include <stdint.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>

#include "i2cmaster.h"
#include "uart.h"

// -----------------------------------------------------
// defines for better readability
// -----------------------------------------------------

// Leds
#define led_alive_on()		(PORTC |= (1<<PC0))
#define led_alive_off()		(PORTC &= ~(1<<PC0))

// timer
#define start_timer0(x)			{	OCR0A = x-1;	TIMSK0 |= (1 << OCIE0A);}
#define start_timer2(x)			{	OCR2A = x-1;	TIMSK2 |= (1 << OCIE2A);}

#define stop_timer0()			(TIMSK0 &= ~(1 << OCIE0A))
#define stop_timer2()			(TIMSK2 &= ~(1 << OCIE2A))

// EEPROMs
#define EEPROM_SERVO_1	0b01010000
#define EEPROM_SERVO_2	0b01010001

// Baud rate 
#define UART_BAUD_RATE      38400      

// -----------------------------------------------------
// global variables
// - communication of IRQ routines with main loop
// - communication if pin change irqs with impuls generation
// -----------------------------------------------------

// status of live led
volatile bool b_live_led = false;
volatile uint16_t gi_cnt = 0;

// -----------------------------------------------------
// io handling
// -----------------------------------------------------
void init_io()
{
	DDRB  = 0b00000000;   // All inputs
	DDRC  = 0b11111111;   // All outputs
	DDRD  = 0b11111000;   // mixed in-/outputs

	PORTB = 0b11111001;   // set inputs to high
	PORTC = 0b00000000;   // set outputs to low
	PORTD = 0b00000111;   // set inputs to high
}

// -----------------------------------------------------
// Timer handling
// -----------------------------------------------------
void init_timer(void)
{
	// prescalefactor settings is equal at timer 0 and 1. Timer 2 is different
	// ((16.000.000 MHz / 64) =  250 kHz Prescaleclock;

	// ----------------------------
	// Timer 1
	// ----------------------------
	TCCR1A  = 0;									// CTC Mode
	TCCR1B = ((1<<WGM12) | (1<<CS01) | (1<<CS00));	// prescale factor 64 
	OCR1A = 2500-1;	
	TIMSK1 |= (1 << OCIE1A);
	
	// ----------------------------
	// Timer 0
	// ----------------------------
	TCCR0A  = 0;									// CTC Mode
	TCCR0B = ((1<<WGM12) | (1<<CS11) | (1<<CS10));	// prescale factor 64 
	
	// ----------------------------
	// Timer 2
	// ----------------------------
	TCCR2A  = 0;									// CTC Mode
	TCCR2B = ((1<<WGM12) | (1<<CS22));				// prescale factor 64 
}

// Timer ISR
ISR(TIMER1_COMPA_vect)
{
	// Debug
	if (++gi_cnt > 100)
	{
		led_alive_on();
		start_timer0(250);
		gi_cnt = 0;
	}	
}

// set servo output off for servo 1
ISR(TIMER0_COMPA_vect)
{
	led_alive_off();
	stop_timer0();

#if 0
	// regular ISR
	// set output off for servo 1
	servo1_off();
	stop_timer0();
#endif
}

ISR(TIMER2_COMPA_vect)
{
	led_alive_off();
	stop_timer0();
	return;

#if 0
	// regular ISR
	// set output off for servo 2
	servo2_off();
	stop_timer2();
#endif
}

// -----------------------------------------------------
// main loop
// - handle modes
// - handle I2C storage, save and read
// -----------------------------------------------------

int main(void)
{
	// io port directions
	init_io();

	// init timer at 1ms rate
	init_timer();

	// init the UART library
	uart_init(UART_BAUD_SELECT(UART_BAUD_RATE,F_CPU));
	
	// allow all interrupts
	sei();

	// endless loop
	while(1)
	{
		// check mode switch
		static uint8_t s_old_mode_switch_status = 0;
		static uint8_t s_new_mode_switch_status = 0;
		
		s_new_mode_switch_status = is_mode_switch_on();
		if (s_new_mode_switch_status && !s_old_mode_switch_status)
		{
			gb_mode++;
			if (gb_mode > MODE_REPLAY)
				gb_mode = MODE_DIRECT;
		}
		s_old_mode_switch_status = s_new_mode_switch_status;
		
		// mode direct
		if (gb_mode == MODE_DIRECT)
		{
			// leds
			led_mode_direct_on();
			led_mode_capture_off();
			led_mode_replay_off();

			// only display active led for debug purpose
		}

		// mode capture
		else if (gb_mode == MODE_CAPTURE)
		{
			// leds
			led_mode_direct_off();
			led_mode_capture_on();
			led_mode_replay_off();
		}

		// mode replay
		else if (gb_mode == MODE_REPLAY)
		{
			// leds
			led_mode_direct_off();
			led_mode_capture_off();
			led_mode_replay_on();
		}
	}
}

Gruß
Georg

[Kampi]

Hi,

also generell kannst du in einer ISR alles machen was du willst. Bei der ISR passiert ja nichts anderes als das ein Interruptbit gesetzt wird und dadurch springt der Programmzähler zu einer Vektoradresse die für diese Interruptquelle deffiniert ist und an dieser Vektoradresse steht dann ein Sprungbefehl zu der Startadresse deiner eigentlichen ISR wo dann der Code steht.
Klar kannst du dann in einer ISR einen anderen Timer starten oder den Timer der die ISR verändert hat "bearbeiten".
Die Timer kannst du generell immer "bearbeiten". Das ist nicht so das die dann keine Änderungen zulassen
Nur eventuell treten diese Änderungen dann nicht sofort in Kraft.
Und du kannst in einer Timer-ISR auch den Timer stoppen der diese ISR ausgelöst hat (z.B. wenn du einen Puls messen willst machst du das auch so. Bei der steigenden Flanke wird eine ISR abgearbeitet wo ein Timer gestartet wird und bei einer fallenden Flanke wird der Timer gestoppt und dann hast du die Zeit wie lange der Impuls High war).

[schorsch_76]

Danke Daniel!