Multithreading mit AVRco

[morty]

schaut mal bei www.avrfreaks.net vorbei. Da ist ein sehr guter Artikel zu dem Thema. Letzendlich installiert man ein Betriebssystem, das die verschieden Threads(Prozess)/Tasks(Aufgabe) oder wie auch immer ihr die nennen wollt verwaltet. (Will mich hier nicht festlegen, aber ich glaube als Task bezeichnet man ein Programm das mehrere Prozesse haben kann) Grundsätzlich werden die Befehle nacheinander verarbeitet. (Es gibt zwar auch IC's mit mehreren Prozessoren aber ich glaub nicht in dieser Preisklasse)

[pbürgi]

OK ich hab nochmal nach der ct gesucht: es ist die 6/2004(8.3.2004) ab Seite 248.
Hier könnt ihr euch den kompletten Quellcode für den MSP430 downloaden, kann man aber sicher auch mim AVR realisieren:
ftp://ftp.heise.de/pub/ct/listings/0406-248.zip

Hier ist die komplette Linkseite von heise.de:
http://www.heise.de/ct/04/06/links/248.shtml

Wer die C't daheim hat hat Glück, denn da wird der Code erklärt.

Es wird hier natürlich kein echtes Betriebssystem programmiert, ich muss zugeben "Scheduler"(recycle) passt deutlich besser. Es ist wie recycle sagt ein Programm, das per Timer verschiedenen Pseudo-Threads verschieden viel Rechenzeit zuschaufelt.

[malef]

Also
schaut mal unter http://instruct1.cit.cornell.edu/courses/ee476/

und dann unter : AT90 MCU realtime operating systems

da gibts ne Menge MultiThREADING KERNELS

Thread bedeutet alle Funktionen (die Threads eben) laufen in einem gemeinsamen Speicherbereich (da der AVR oder sonstiger MC keine Memory Managment Unit besitzt um die Prozesse voneinaner zu schützen)
diese Threads werden aber Preemtiv (also vom Kernel selbst(zBsp:durch TimerINT) umgeschaltet und alles was zum Thread gehört (Stack,Register) wind gesichert und wenn der Thread wieder aktiv wird , wieder zürückgeholt !(Context Switching)
-Jeder Thread hat seinen eigenen Stack und seine eigenen Register

usw....

Dort findet man zum Beispiel das:

;***** Simple time-based scheduler ********
;
;The goal is to allow several tasks to execute at a regular rate
;without making a HUGE timer ISR. The timer 0 interrupt just
;decrements counters which are tested in a loop to dispatch
;subroutines. Timer 0 ticks at a mSec rate in this code.

;Task descriptions:
; task 1: blink LED 0 2/sec
; task 2: blink LED 1 1/sec
; task 3: Detect button 0 and change task 1 blink rate if the button is down
; 
;********************************
;You will need to CHANGE this path
,nolist
.include "c:\avrtools\appnotes\8515def.inc"
.list

;********************************
;define registers
.def	save	=r1
.def	temp	=r16	;temporary register
.def	LED	=r17	;the actual LED value to display
.def	reload	=r18	;holds timer reload value

;Specify the interval for each task to execute:
;since we are toggling LED state on each task entry,
;the task times are 1/2 the desired blink times
.equ	t1	=250	;250 mSec
.equ	t2	=125	;125 mSec - Task2 will need to have another counter
.equ	t3	=30	;30 mSec interval for the keyboard scanner

;********************************
;RAM locations:

;Task execution time intervals 
.dseg
time1:	.byte 1
time2:	.byte 1
time3:	.byte 1

;Task2 state variable needed to 
;count 4 times the 1/4 second secheduled time
tsk2c:	.byte 1

;message from task3 to task1 to change rate
tsk3m:	.byte 1

;*******************************
; Initialization
.cseg
.org $0000
	rjmp RESET	;reset entry vector
	reti		
	reti
	reti
	reti
	reti
	reti
	rjmp TIMER
	reti
	reti		
	reti
	reti	
	reti

RESET:
	ldi	Temp, LOW(RAMEND) 	;setup stack pointer
	out 	SPL, Temp
	ldi	Temp, HIGH(RAMEND)
	out	SPH, Temp

	;set up the PORTs
	ser	Temp		;set PORTB to be
	out	DDRB,Temp	;all outputs
	ldi	Temp, 0xff	;turn off LEDs
	out	PortB, Temp

	clr	Temp		;set PORTD to be
	out	DDRD,Temp	;all inputs

	;set up timer 0 for 1 mSec ticks
	ldi	Temp,exp2(TOIE0);enable timer interrupt
	out	TIMSK, Temp
	ldi 	Temp, 3		;prescale timer by 64
	out 	TCCR0, Temp
	ldi	Reload,256-62	;preload timer since
	out 	TCNT0, Reload	;62.5 x (64x.25) microSec = 1.0 mSec.

	;initialize task timers
	ldi	temp, t1	;mSec
	sts	time1, temp
	ldi	temp, t2
	sts	time2, temp
	ldi	temp, t3
	sts	time3, temp

	;initialize LED state
	ldi	LED, 0xff	;all LEDs off

	;initialize task2 state variable (4 times thru equals 1/2 sec)
	ldi	temp, 4
	sts	tsk2c, temp

	;initalize task3 message to zero (don't modify task1 rate)
	ldi	temp, 0
	sts	tsk3m, temp
	
	;Start the clock ticking
	sei			;enable all interrupts	

******************************************************************
;Now start scheduling events.
;This is the main program loop.
;All tasks are subroutines called from here when
;their respective timers reach zero.

Sched:		
tsk1:	lds	temp, time1	;test for first task ready
	tst	temp
	brne	tsk2		;if not then skip it
	rcall	Task1
	
tsk2:	lds	temp, time2	;test for second task ready
	tst	temp
	brne	tsk3		;if not then skip it
	rcall	Task2

tsk3:	lds	temp, time3	;test for third task ready
	tst	temp
	brne	Sched		;if not then skip it
	rcall	Task3
	
	rjmp	Sched
	
;*****************************************************************
;The three actual tasks:
;******************************
;LED 0 2/sec (but modified by Task 3)
Task1:	lds	temp, tsk3m	;get the message from task 3
	tst	temp		;and test it for "fast/normal"
	brne	t1fast

	;if we get here the message from task 3 ="normal rate"
	ldi	temp, t1	;reinit time counter
	sts	time1, temp
	rjmp	t1blk

	;if we get here the message from task 3 ="fast rate"
t1fast:	ldi	temp, t1	;reinit time counter
	lsr	temp		;divide time by four
	lsr	temp
	sts	time1, temp
	
	;now toggle the LED
t1blk:	mov	temp, LED	;isolate the zero bit
	andi	temp, 0b00000001; and invert it
	andi	LED,  0b11111110
	com	temp
	andi	temp, 0b00000001
	or	LED, temp	
	out	PORTB, LED

	ret			;go back to scheduler

;******************************
;LED 1 1/sec
Task2: 	ldi	temp, t2	;reinit time counter
	sts	time2, temp

	lds	temp, tsk2c	;find out if 4 counts have occured
	dec	temp		;so that we can count to 1/2 second
	sts	tsk2c, temp
	tst	temp	
	brne 	t2exit		;if not then leave

	;if we get here, then 1/2 second has passed and we
	;should toggle the LED
	mov	temp, LED	;isolate the zero bit
	andi	temp, 0b00000010;  invert it
	andi	LED,  0b11111101;  then combine it with LED again
	com	temp
	andi	temp, 0b00000010
	or	LED, temp	
	out	PORTB, LED	

	ldi	temp, 4		;and reset the state variable
	sts	tsk2c, temp

t2exit:	ret			;go back to scheduler

;******************************
;Button detect and modify Task 1 blink rate
Task3: 	ldi	temp, t3	;reinit time counter
	sts	time3, temp

	in	temp, PIND	;get all the buttons
	com	temp		;convert a button-down to a one
	andi	temp, 0b00000001;isolate button 0
	brne	t3modt

	;if we get here then set message to "normal" task1 rate
	ldi	temp, 0		;set message value 
	sts	tsk3m, temp	;and store it
	rjmp	t3exit

	;if we get here then set message to "fast" task1 rate
t3modt:	ldi	temp, 1		;set message value
	sts	tsk3m, temp	;and store it

t3exit:	ret			;go back to scheduler


;**************************************************************
;timer 0 ISR (timer-zero overflow)
;Enters every 1.0 mSec

TIMER:	in	save, SREG
	out 	TCNT0, Reload	; keeps clock ticking at 1 mSec
	push 	temp		; use temp in ISR
	
	;update each of the three timers
	;for the three tasks
	;BUT if the count is zero don't do anything until the process
	;resets it

	lds	temp, time1
	tst	temp	
	breq	t0t2
	dec	temp	
	sts	time1, temp
	
t0t2:	lds	temp, time2
	tst	temp	
	breq	t0t3
	dec	temp	
	sts	time2, temp

t0t3:	lds	temp, time3
	tst	temp	
	breq	t0end
	dec	temp	
	sts	time3, temp

t0end:	pop	temp
	out	SREG, save
	reti			;back to backgound tasks
;**************************************************************

Ist glaub für Mega32

Und in C sieht es so aus:

//Dup the function of sched1.asm 
//used as an example in the program organization doc.      
             
#include <90s8515.h> 

//timeout values for each task
#define t1 250  
#define t2 125
#define t3 60  
 
//the three task subroutines
void task1(void);  	//blink at 2 or 8 Hz
void task2(void);	//blink at 1 Hz
void task3(void);	//detect button and modify task 1 rate 

void initialize(void); //all the usual mcu stuff 
          
unsigned char reload;				//timer 0 reload to set 1 mSec
unsigned char time1, time2, time3;	//timeout counters 
unsigned char tsk2c;				//task 2 counter to get to 1/2 second
unsigned char tsk3m;				//task 3 message to task 1 
unsigned char led;					//light states  
         
//**********************************************************
//timer 0 overflow ISR
interrupt [TIM0_OVF] void timer0_overflow(void)
  {       
  //reload to force 1 mSec overflow
  TCNT0=reload;
  
  //Decrement the three times if they are not already zero
  if (time1>0)	--time1;
  if (time2>0) 	--time2;
  if (time3>0)	--time3;
  }  

//**********************************************************       
//Entry point and task scheduler loop
void main(void)
  {  
  initialize();
  
  //main task scheduler loop
  while(1)
    {     
    if (time1==0)	task1();
    if (time2==0) 	task2();
    if (time3==0)	task3();
    }
  }  
  
//**********************************************************          
//Task subroutines
//Task 1
void task1(void) 
  {  
  time1=t1;  //reset the task timer
  if (tsk3m != 0) time1 >>= 2;  //check for task 3 message
  
  //toggle the zeros bit
  if ((led & 0x01) == 0)
  	led = led | 0x01;
  else
  	led = led & 0xfe;	
  	
  PORTB = led;
  }  
 
//******************************* 
//Task 2  
void task2(void) 
  {
  time2=t2;  //reset the task timer
  if (--tsk2c == 0)  //have we waited 1/2 second?
  	{  
  	tsk2c = 4;		//reload the 1/2 sec counter
  
     //toggle the ones bit
  	if ((led & 0x02) == 0)
  		led = led | 0x02;
  	else
   		led = led & 0xfd;
   		
  	PORTB = led;
	}
  }  
 
//*******************************   
//Task 3  
void task3(void) 
  {
  time3=t3;     //reset the task timer
  tsk3m = ~PIND & 0x01;  //generate the message for task 1
  } 
  
//********************************************************** 
//Set it all up
void initialize(void)
{
//set up the ports
  DDRD=0x00;	// PORT D is an input
  DDRB=0xff;    // PORT B is an ouput  
  PORTB=0; 
           
  //set up timer 0
  reload=256-62; //value for 1 Msec  
  TCNT0=reload;
  TIMSK=2;		//turn on timer 0 overflow ISR
  TCCR0=3;		//prescalar to 64
    
  //init the LED status (all off)
  led=0xff; 
  
  //init the task timers
  time1=t1;
  time2=t2;
  time3=t3;    
  
  //init the task 2 state variable 
  //for four ticks
  tsk2c=4;
  
  //init the task 3 message
  //for no message
  tsk3m=0;
      
  //crank up the ISRs
  #asm
  	sei
  #endasm 
}

Nach einigem Halbwissen werde ich erst mal ein bisschen Aufklärung betreiben

In der Betriebssystemtechnik unterscheidet man grundsätzlich bei Multitasking-BS Prozesse und Threads.
Der wesentliche Unterschied ist, dass Prozesse in einem eigenem Addressraum ablaufen, Threads hingegen nicht. Threads laufen im Kontext von Prozessen. Aufgeweicht wird das Ganze durch shared Memory, den sich Prozesse teilen können.

Was ein Multitasking-Betriebssystem für Atemls AVR angeht, so muss man sich das in der Tat nicht als ein grosses BS ala Linux vorstellen.
Im einfachsten Fall ist das ein simpler Round-Robin-Scheduler, der in festen Zeitscheiben die Threads aufruft. Basta. Ein paar Programmzeilen, das war es.
Das Ganze kann man dann beliebig um die Üblichen Zutaten erweitern: variable Zeitscheiben, feste Prioritäten, variable Prioritäten, Interprozesskommunikation (Semaphore, shared Memory, etc).

Auch wenn man es etwas komplexer macht, so kostet das auch nur Rechenzeit in der Gegend von maximal einigen Prozent.

Ob das Ganze Sinn macht, muss jeder selbst wissen. Die weitaus meisten Controller-Anwendungen in der Industrie funktionieren nach einer Studie aus diesem Jahr immer noch nach dem guten alten Hauptschleife-Flags-Interrupt-Prinzip, wo in der Hauptschleife im Wesentlichen die Flags ausgewertet werden und der Controller dann die entsprechenden Routinen ausführt. In den entsprechenden Interrups werden die Flags dann je nach Ereignis gesetzt.
Vorteile macht ein Multitasking-System sicher, wenn man mit mehreren Leuten relativ unabhängig voneinander an einem Projekt arbeitet.
Und es macht sicherlich auch unabhängiger von der Hardware, wenn es ein komplexeres System ist, welches stärker abstrahiert.

[hrrh]

wenn die microprozessoren noch schneller sind und mehr speicher haben machts mehr sinn. wenn 3 prozesse gleichzeitig laufen, braucht man 3 mal so viel ram

[Hellmut]

Hallo Freunde

hab mal genau gewusst was der Unterschied zwischen Multitasking und Multithreading ist. Und zwar über Apples altes Mc68k basierendes Betriebssystem. Dort war es so, daß die Programmierrichtilinien verlangten Code so zu schreiben, dass wenn ein Unterprogramm ausgeführt war man keine Bits gesetzt haben durfte die dem eigenen Programm die Kontrolle über den Prozessor auschließßlich gewährten, also Interrupts maskieren. Das Betriebssystem speicherte die requests der einzelnen tasks selber auf seinen eigenen Stack, und so hat ein Interrupt dann eine Routine des Betriebssystems ausgelöst die der nächsten Task in Stack die Kontroller über den Computer gibt. Hat jetzt ein Programmierer diese maskable interrupts maskiert konnte er den Rechner ohne zeitlliche Begrenzung für sein Programm benutzen. Als dann bei Apple echtes Multitasking kam konnte das Betriebssystem über einen Timer und einem nicht maskable Interuupt die Kontrolle wieder übernehmen, hat die Inhalte aller Register auf das Stack gerettet und die nächste Task begann immer damit ihre Registerinhalte vom Stack zu holen und einzulesen.

Diese Beschreibung zeigt wie man in jedem Prozessor Multitasking einführen kann. Ich kenne den AVR noch nicht, aber ich vermute in Analogie es gibt dort eine Möglichkeit über einen Hardware Timer einen Soft Interrupt auszulösen der einen Zeiger auf eine Interrupt-Service Rotine verweist. Diese Rotine müßte dann wie oben beschrieben die "Laufzeitumgebung der alten Task auf den Stack zu pushen, für die nächste Routine die "Laufzeit" Umgebung wieder einrichten und den Programm Counter auf den letzten Wert, oder letzten Wert plus eins setzen. Natürlich nicht vergessen den Timer zu reseten und neu zu starten.

Wichtig erscheint mir aber der Hinweis, dass wenn eine Task eine "Echtzeit" Aufgabe bearbeitet die Möglichkeit haben muß das Interrupt des Taskmanagers zu maskieren und erst dann wieder entmaskieren wenn das zeitkritische erledigt ist. Gerade im embedded Bereich, und das sind wir hier ja.


Beim Mu

[hrrh]

vielleicht waere ein microprozessor mit linux besser geeignet (gibts fertig zu kaufen). die sind viel schneller als ein avr, haben viel mehr ram und mehr flash. sind nur etwas teurer.

[Hellmut]

Hallo hrrh

Du weisst schon das wir über Routinen sprechen die nur wenige Zeilen lang sind? Übrigens werden in der Industrie viele sogenannte RTOS eingesetzt die damit werben extrem effizient und extrem kleines footprint zu haben?! Und das in sehr kostensensitiven Anwendungen, z.B 68hc05!?