Assembler timer

[achim S.]

Hallo Dirk
Versuche mal meine Gedanken zu ordnen. Ich möchte ein Signal für das Hauptprogramm haben das alle 10 ms erzeugt wird (durch Timer). Der Sinn ist daran, delay nicht mehr zu verwenden. Möchte zu jedem Zeitpunkt einfach eine Schleife machen können ohne die Zeiten zu verändern durch unnötiges warten und das Progrann soll wieter laufen. Als beispiel nehme ich eine Laufschrift, Wenn ich einen Balken mit Infos laufen lassen will, muss dieser sich bewegen obwohl das Prg auf einen Taste wartet. Oder die andere Variante, ein Motor soll sich drehen und die Räder bewegen. Bei fahrt Rückwärts sollen die LED angehen im Takt von 1s rot blinken. Der Sinn besteht darin zwei Zeiten (Aktionen) unabhängig auszuführen (oder mehr). Es reicht dabei ein 8-Bit Timer aus. Wenn ich nur ein Signal alle 10 ms bekomme reicht das aus. Die Aktionen(Zeiten) dürfen sich nicht gegenseitig beeinflussen. Es geht dabei auch um die Funktion, eimal normale Bewegung und Gefahr z.B. durch Kante, Abgrund, Hinderniss auf entfernung und später Speicherung des Weges.
Achim

 

[Dirk]

Hallo Achim,

in deinem Hauptprogramm befindest du dich ja immer in einer Schleife, also zum Beispiel wie unten innerhalb der while(1) Schleife:

int main (void)
{

  // Hier erfolgen Initialisierungen

  while (1)
  {

    // Dies ist die Schleife in main.

  }

  return 0;
}

Nun möchtest du zum Beispiel innerhalb der Schleife eine LED mit 500ms Periodendauer blinken lassen, ohne dass dies andere Bereiche innerhalb der Schleife blockiert, du verwendest also kein _delay_ms(250) oder ähnliches.

Jetzt stell dir vor, die TimerISR schreibt alle 250ms zum Beispiel 0xFF in eine Variable, die nenne ich mal MeinSignal250.

Diese Variable kannst du nun im Programm auswerten und darauf reagieren, das geht zum Beispiel so:
(Ich verwende absichtlich keine Bitadressierungen, sondern ganze Bytes. Auch die Schreibweise 1<<n umgehe ich mal, damit das Prinzip besser verständlich wird)

int main (void)
{

  // Hier erfolgen Initialisierungen

  while (1)
  {

    // Dies ist die Schleife in main.

    if (MeinSignal250 == 0xFF)
    {
      cli();
      MeinSignal250 = 0;  // Wir bestätigen, indem wir auf 0 setzen, sonst sind wir im nächsten Durchlauf sofort weider hier.
      sei();

      // Hier eine LED an PB0 toggeln (es geht noch etwas eleganter, aber dann ist es schlechter verständlich)

      if (PORTB & 0b00000001)  // die Bedingung ist wahr, wenn PB0 high ist
        PORTB = PORTB & 0b11111110;  // PB0 wird auf low gesetzt (UND Verknüfung)
      else
        PORTB = PORTB | 0b00000001;  // PB0 wird auf high gesetzt (ODER Verknüpfung)

    }

  }

  return 0;
}

Andere Programmbereiche innerhalb der Schleife werden somit nicht blockiert. Falls dein Hauptprogramm (die Programmbereiche innerhalb der Schleife) sehr ausgelastet ist, ist es ratsam, kritische Bereiche in die ISR zu verlagern, damit gewährleistet ist, dass diese zu festen Zeiten ausgeführt werden. Das könnte bei dir die Erkennung eines Abgrundes oder einer Kante sein, wo man unbedingt reagieren muss. Das ist aber vom Hauptprogramm abhängig.

Wenn du mehrere unabhängige Ereignisse innerhalb des Hauptprogramms steuern möchtest, musst du dann in der TimerISR einen weiteren Counter realisieren, wenn die zeitlichen Ereignisse sich nicht von einem Zähler ableiten lassen. Natürlich benötigst du dann auch weitere Variablen, die das Hauptprogramm als Ereignissignale abfragen kann.

Verwende erst einmal ganze Bytes, wie oben gezeigt. Wenn man Speicherplatz (SRAM) sparen möchte, werwendet man Bitadressierung, wie ich in einem Beitrag vor diesem schon mal gezeigt habe.

Ich hoffe, dir hilft das ein bisschen weiter.

Gruß,
Dirk

 

[achim S.]

Hallo Dirk
danke für deine Geduld. Es wird wieder heller. Stelle fest, muss noch viel lernen. Bin gerade dabei was zu machen. Schreibe es erst mai und probiere, wennes läuft stelle ich es rein.
Hatte mir mal inzwischen den Rechner mit Beispielen angesehen.Dort wird sehr schön mit 16 Bit dargestellt wie man auf 1ms kommt. Auch die Erklärung für 249. Werde es mal ausprobieren. Danke bis hier her
Achim

 

[achim S.]

Hallo Dirk
habe mal deine Sachen ins Programm gebracht. Es läuft sehr gut. Meine Vorstellungen kommen auch hin.

void nibo_timer2()    // Timer 1ms  - 1000ms=1Sekunde
    {                    
    TCNT2 = 0;
    OCR2=249;
    TCCR2=(1<<WGM21)|(1<<CS21)|(1<<CS20);    
    TIMSK |= (1<<OCIE2);                    
    }

ISR (TIMER2_COMP_vect)    // wait1=1ms, wait2=10ms, wait3=500ms
{
    if(wait1<9)        // Takt 1ms auf 10ms
    {
    wait1++;        // erhöht um je 1ms
    }
    else            // wenn dann ...
    {
    wait1=zaehler1;
    wait1=0;        // setzt wait1 auf 0
    if(wait2<49)    // Takt 10ms
    {
    wait2++;        // erhöht um je 10ms
    }
    else            // wenn dann ...
    {
    wait2=zaehler2;
    wait2=0;        // setzt wait2 auf 0 
    //if(wait
    }
    }
}

Habe das geändert im Timer. In der ISR habe ich die Schleifen drin mit den unterschiedlichen Zeiten. Bin mir aber nicht ganz klar, was was ist, Wie bekomme ich den nun wait 3? Sind wirklich die wait1,2,3 richtig? und was passiert wenn ich 5 s haben will? Kann ich mit wait3 einfach weiter zählen oder muss ich es in eine andere Variable speichern?
Achim

 

[Dirk]

Hallo Achim,

wait1 und wait2 sind deine Counter innerhalb der TimerISR. Die Variablen zaehler1 und zaehler2 haben keinen Einfluss auf dein Programm.

wait1 wird alle 10ms zurückgesetzt, wait2 wird alle 10ms erhöht und im Moment alle 50x10ms zurückgesetzt.

Die Counter direkt im Hauptprogramm auszuwerten, macht eigentlich nicht viel Sinn, ich denke du benötigst auch die Ereignissignale für das Hauptprogramm.
Einfachheitshalber habe ich zwei Byte-Variablen verwendet (signal_wait1, signal_wait2), die man im Hauptprogramm auswerten kann.

Der wait2 Counter ist mit wait1 Counter verschachtelt und wird alle 10ms erhöht, du kannst mit wait2 nur Signale alle n x 10ms erzeugen.

Wie man das ganze letztendlich realsiert, ist win der Anwendung bzw. den Anforderungen abhängig.

Im unteren Beispiel könntest du alle 10ms eine Tastatur abfragen und alle 500ms eine LED toggeln.

Dirk

ISR (TIMER2_COMP_vect) // wait1=1ms, wait2=10ms, wait3=500ms
{
  if(wait1<9) // Takt 1ms auf 10ms
  {
    wait1++; // erhöht um je 1ms
  }
  else // wenn dann ...
  {
    wait1=0; 
    signal_wait1 = 0xFF;  // Signal alle 10ms;
    if(wait2<49) // Takt 10ms
    {
      wait2++; // erhöht um je 10ms
    }
    else
    {
      signal_wait2 = 0xFF;  // Signal alle 500ms;
      wait2=0; // setzt wait2 auf 0
    }
  }
}


while(1)
{
if (signal_wait1 == 0xFF)
{
  cli();
  signal_wait1 = 0;
  sei();
  
  // hier das ausführen, was alle 10ms ausgeführt werden soll

}

if (signal_wait2 == 0xFF)
{
  cli();
  signal_wait2 = 0;
  sei();
  
  // hier das ausführen, was alle 500ms ausgeführt werden soll

}


// weitere Programmteile innerhalb while(1)


} // Ende while(1)

 

[achim S.]

Hallo Dirk
wait1 ist für 10ms und wait2 für 500ms. Muss noch die entsprechenden Zeilen ändern. Ab dem while ist alles im normalem Programm. Soweit klar. In der Zeile 5 bis 7 Schaltest du Interups ab, setzt wait auf null und schaltest wieder ein. Sorry, unklar. Wie muss ich die Zeit angeben, wenn ich z.B. 40 oder 300ms was anderes machen will?
(Wolltees auch in Code einsetzen wie in den andere Artkeln, habe es leider nicht geschafft, muss noch mal lesen in Erklärung)

1. while(1)
2. {
3. if (signal_wait1 == 0xFF)
4. {
5. cli();
6. signal_wait1 = 0;
7. sei();

// hier das ausführen, was alle 10ms ausgeführt werden soll

}

Achom

 

[Dirk]

Hallo Achim,

das mit dem Abaschalten der Interrupts habe ich aus Gewohnheit gemacht. Falls deine Variable uint16 (oder größer) ist, kann es passieren, dass die ISR den Inhalt ändert, wenn gerade im Hauptprogramm ein Teilbyte geändert wird. Wenn du zuvor Interrupts abschaltest, kann das nicht passieren. Denk dir einfach das cli() sei() weg und verwende uint8.

Bei 40ms läßt du eben wait1 bis 40 Zählen, setzt wait1 dann zurück und signalisierst durch signal_wait1=0xFF.

400ms geht mit wait1 im Moment nicht, da wait1 wahrscheinlich uint8_t ist. Du kannst hier wait2 verwenden, wait2 wird mit 10ms inkrementiert, du läßt den dann bis 40 zählen.

Dirk

 

[achim S.]

Hallo Dirk
Habe die Sachen in meinen Code eingebaut. Es läuft auf Anhieb. Beim Probelauf ist mir noch was aufgefallen. Die LED (zur Probe) leuchtet unterschiedlich. Mal ist sie länger Hell manchmal ist sie länger dunkel. Konnte keinen Grund finden. Eine Sache ist mir unklar. Habe jetzt signal2 verwendet, damit 500ms. Wie stelle ich z.B. 5 Sekunden ein?
Achim

#include <nibo/niboconfig.h> 				
#include <nibo/iodefs.h>
#include <nibo/leds.h>       				
#include <nibo/delay.h>      
#include <avr/interrupt.h>				
#include <nibo/gfx.h>
#include <nibo/display.h>
#include <nibo/pwm.h>
#include <nibo/bot.h>
#include <nibo/adc.h>
#include <avr/pgmspace.h>
#include <nibo/spi.h>
#include <nibo/copro.h>
#include <stdio.h>
#include <stdlib.h>

static volatile uint16_t signal_wait1;
static volatile uint16_t signal_wait2;
static volatile uint16_t zaehler2;
static volatile uint16_t wait1;
static volatile uint16_t wait2;
 
void nibo_timer2()	// Timer 1ms  - 1000ms=1Sekunde
	{					
	TCNT2 = 0;
	OCR2=249;
	TCCR2=(1<<WGM21)|(1<<CS21)|(1<<CS20);	
	TIMSK |= (1<<OCIE2);					
	}

ISR (TIMER2_COMP_vect)		// wait1=1ms, wait2=10ms, wait3=500ms
{
	if(wait1<9)			// Takt 1ms auf 10ms
	{
	wait1++;			// erhöht um je 1ms
	}
	else				// wenn dann ...
	{
	wait1=0;			// setzt wait1 auf 0
	signal_wait1=0xFF;		// Signal alle 10ms
	if(wait2<49)			// Takt 10ms
	{
	wait2++;			// erhöht um je 10ms
	}
	else				// wenn dann ...
	{
	signal_wait2=0xFF;	//Signal alle 500ms
	wait2=0;			// setzt wait2 auf 0 
	}
	}
	}

int main(){							

	sei();							
	display_init();
	pwm_init();						
	gfx_init();						
	bot_init();						
	leds_init();                					

	leds_set_displaylight(800);				
	nibo_timer2();						

	gfx_fill(0x00);						
	gfx_move(5, 5);						
	gfx_set_proportional(0);				
	gfx_print_text("Testprogramm Nibo 2");		
	gfx_move(13, 15);					
	gfx_set_proportional(0);				
	gfx_print_text("LED5 Test c SZR 2011");			

	gfx_move(0,25);					
	gfx_hline(128);						

	while(1){
		
	if (signal_wait2==0xFF)
	{
	cli();
	signal_wait2=0;
	sei();
	
	leds_set_status(1,5); 		/* Led5 soll 5sek lang rot sein */***************************
	}

	{
	if (signal_wait2==0xFF)
	{
	cli();
	signal_wait2=0;
	sei();
	
	leds_set_status(0,5); 		/* Led5 soll 5sek lang rot aus sein */*****************************
	}
	}}
return 0;			
	
}

 

[Dirk]

Hallo Achim,

die beiden Signale brauchen nur uint8 sein. cli()/sei() entfällt.

Wenn du 5s haben möchtest und jetzt 500ms hast, läßt du wait2 10 mal soweit zählen.

Du machst innerhalb der while(1) Schleife zweimal die Abfrage des Signals, das gibt dann diesen Effekt (der ist "pseudozufällig"). Einmal schaltest du die LED an, einmal aus. Du darfst nur einmal das Signal abfragen und bei dem Ereignis dann die LED toggeln.

Dirk

 

[achim S.]

Hallo Dirk
habe den Code so geschrieben bzw. geändert, wie du es geschrieben hast. Jetzt komme ich aber mit sei und cli nicht klar. Brauche ich diese jetzt noch. Hatte die Zeitem lauffähig drin, aber nicht ganz gleich. Habe sie jetzt geändert und komme wieder durch einander. So wie ich die if sonst schreibe geht nicht. Was mache ich schon wieder falsch?
Achim

void nibo_timer2()	// Timer 1ms  - 1000ms=1Sekunde
	{					
	TCNT2 = 0;
	OCR2=249;
	TCCR2=(1<<WGM21)|(1<<CS21)|(1<<CS20);	
	TIMSK |= (1<<OCIE2);					
	}

ISR (TIMER2_COMP_vect)	// wait1=1ms, wait2=10ms, wait3=500ms
{
	if(wait1<9)			// Takt 1ms auf 10ms
	{
	wait1++;			// erhöht um je 1ms
	}
	else				// wenn dann ...
	{
	wait1=0;			// setzt wait1 auf 0
	signal_wait1=0xFF;	// Signal alle 10ms
	if(wait2<49)		// Takt 10ms
	{
	wait2++;			// erhöht um je 10ms
	}
	else				// wenn dann ...
	{
	signal_wait2=0xFF;	//Signal alle 500ms
	wait2=0;			// setzt wait2 auf 0 
	}
	}
	}

int main(){							

	sei();							
	display_init();
	pwm_init();						
	gfx_init();						
	bot_init();						
	leds_init();                					

	leds_set_displaylight(800);				
	nibo_timer2();						

	gfx_fill(0x00);						
	gfx_move(5, 5);						
	gfx_set_proportional(0);				
	gfx_print_text("Testprogramm Nibo 2");		
	gfx_move(13, 15);					
	gfx_set_proportional(0);				
	gfx_print_text("LED5 Test c HJS 2011");			

	gfx_move(0,25);					
	gfx_hline(128);	
						
	signal_wait1=0;
	signal_wait2=0;

	while(1){
		
	if (signal_wait1<=100)
	{
	signal_wait1++;
	}
	else
	cli();
	signal_wait1=0;
	sei();
	
	leds_set_status(1,5); 		/* Led5 soll 5sek lang rot sein */
	}
	{

if (signal_wait1<=100)
	{
	signal_wait1++;
	}
	cli();
	signal_wait1=0;
	sei();
	
	leds_set_status(0,5); 		/* Led5 soll 5sek lang rot sein */

 

[Dirk]

Hallo Achim,

du zählst ja nun mit den Signalen, die dir die TimerISR zur Verügung stellt. Diese Signale sind eigentlich dazu gedacht, dem Hauptprogramm mitzuteilen, dass 10ms oder 500ms vergangen sind. Du kannst diese Signale im Hauptprogramm abfragen und dort auch zurücksetzen zum Bestätigen (hier brauchst du Interrupts nicht abschalten, falls die Signale als volatile uint8_t definiert sind).

Was möchtest du denn genau machen?

• Soll die LED bei Tastendruck o.ä. an gehen und dann nach 5 Sekunden automatisch aus gehen oder
• soll die LED alle 5 Sekunden toggeln?

Dirk

 

[achim S.]

Hallo Dirk
es soll nur 5 s toggeln. Das mit dem Taster nehme ich mir später vor. Eine "normale" Abfrage habe ich schon in meinen Prg drin, auch mit Verzögerung.
Achim

 

[achim S.]

Hallo Dirk
habe weiter gemacht und dabei ist mir was toatal unklar. Habe mal ein Stück Code reingestellt.

wait1++;			// erhöht um je 1ms
	}
	else				// wenn dann ...
	{
	wait1=0;			// setzt wait1 auf 0
	signal_wait1=0xFF;		// Signal alle 10ms
	if(wait2<49)			// Takt 10ms
	{
	wait2++;			// erhöht um je 10ms

Du verwendest hier signal_wait=0xFF. Weiter unten verwendest du if

if (signal_wait2==0xFF)

Wenn ich einfache Zahl eingebe bei if z.B. 10 dann läuft das Prg nicht. Wieso?
Achim

 

[Dirk]

Hallo Achim,

ich weiß nicht, wo du genau einen Wert vorgibst. Wichtig ist, dass du signal_wait1 und signal_wait2 (beides volatile uint8_t) nicht zum Zählen verwendest. Die Interruptroutine "setzt" die mit einem bestimmten Wert (bei dir 0xFF), wenn ein Ereignis (10ms oder 500ms) eingetreten ist. Das Hauptprogramm prüft, ob die den Wert 0xFF haben, falls ja, werden sie wieder zurückgesetzt (0x00) und das Hauptprogramm führt dann diesen Bereich aus, der zu dem Ereignis folgen soll. Zum Beispiel alle 500ms die LED toggeln.

Wie schon geschrieben, ist es eleganter, anstelle von ganzen Bytes einzelne Bits zu verwenden, damit man weniger SRAM belegt, mit Bytes zu arbeiten ist aber einfacher.

Hier nochmal das Prinzip:

Dirk

volatile uint8_t [COLOR=#0000ff]MeinSignal[/COLOR]

TimerISR
{

  Ereignis eingetreten (alle 500ms zB)? Wenn ja, dann [COLOR=#0000ff]MeinSignal[/COLOR]=0xFF

}


main
while(1)
{

  ist [COLOR=#0000ff]MeinSignal[/COLOR] == 0xFF?
  wenn ja dann
  {
 
    [COLOR=#0000ff]MeinSignal [/COLOR]= 0x00  (wieder zurücksetzen)

    Auf Ereignis reagieren: LED toggeln

  }

  sonstige Sachen machen

}

 

[achim S.]

Hallo Dirk
hoffe es langsam zu verstehen. So weit es klar. Ich möchte das "Mein signal" nehme und in eine if Schleife bringen um z:B. 300 ms zu warte, dann LED schalten oder toggeln. Mir ist nur die Funktion oder Ausgabe von Mein Signal nicht ganz klar. Kann ich es einfach in if schreiben. so wie if(Meinsiganl<=50) {Meinsignal++}{led an/aus} (Beispiel).
Wie kann ich denn wait1 in die Tastenabfrage einbinden?
Gibt es eine kurze Erklärung für die Bit Programmierung? Der Speicher von meinem 128 ist ja begrenzt. Bin bisher noch nicht aufs Ende gestossen. Es wird aber langsam mehr. Es ist nicht schlecht dadurch zu sparen.
Achim

 

[achim S.]

Hallo Dirk
habe die Sachen mit eingebaut. LED lasseb sich schalten. Bin noch an den Versuchen zu den Zeiten und toggeln. So weit klappt alles. Eine Sache habe ich noch nicht ganz geschnallt. Ich wollte noch den Befehl sleep mit einbinden und dadurch ein paar Sekunden warten. Klappt aber nicht so wie es soll. Was mach wieder falsch?
Achim

main
while(1)
{

  ist MeinSignal == 0xFF?
  wenn ja dann
  
****************
 if(sleep<5)sleep++;
*******************

{
    MeinSignal = 0x00  (wieder zurücksetzen)

    Auf Ereignis reagieren: LED toggeln

  }

  sonstige Sachen machen

}

 

[Dirk]

Hallo Achim,

ich gehe davon aus, dass der letzte Soucecode lediglich zeigen soll, wo du die Abfrage mit "sleep" eingebaut hast. Der Code würde so nämlich nicht fehlerfrei kompiliert.

Ich weiss auch nicht was "sleep" ist, uint8_t? Und wie und wo wurde "sleep" initialisiert?

Falls sleep eine Variable im SRAM ist und mit 0x00 initialisiert wurde, dann wird in der while(1) Schleife sleep 5 mal inkrementiert, sonst passiert nichts.

Ich verstehe die Sache mit "sleep" auch noch nicht so genau. Normalerweise bringt man mit einer Art "sleep" den Mikrocontroller in den "Schlafmodus" (Stromsparmodus, sleep.h) oder allgemein bei anderen Betriebssystemen einen Task einige Zeit zum warten.

Ich kann dir leider bei deiner letzten Frage nicht weiterhelfen.

Nochmal eine kurze Erlärung zu der zeitlichen Steuerung von Programmaufgaben innerhalb des Hauptprogramms.

• Du benötigst mindestens ein Signal, was dir irgendwo erzeugt wird und auf das du im Hauptprogramm reagieren kannst. Das hast du ja im Moment.
• Innerhalb des Hauptprogramms kannst du durch Abfragen des Signals direkt eine bestimmte Aufgabe abarbeiten (einfacher Fall LED toggeln)
• Die Aufgabe kann allerdings auch die Steuerung eines oder mehrerer Counter innerhalb des Hauptprogramms sein, mit denen du dir weitere Signale (Ereignisse) innerhalb des Hauptprogramms erzeugen kannst. Das muss also nicht unbedingt alles in der TimerISR realisiert sein. Das Hauptprogramm darf allgemein nur nicht so sehr ausgelastet sein, zum Beispiel durch _delay_ms, warten auf einen Tastendruch in Schleife o.ä., weil es dann passieren kann, dass Ereignisse nicht immer ausreichen oft erkanntwerden. (Kritische Aufgaben verlagert man dann direkt in die TimerISR).

Dirk

 

[achim S.]

Hallo Dirk
es ist eigentlich recht einfach. Die Timer und die ISR brungen mir die Impulse für 10 und 500ms. Die kommen mit dem Signal.. rüber in/als 0xff. Möchte einfach dieses Signal in sleep nehmen und 5x500ms warten. Sleep wird zu anfang deklariert. Habe es einfach weggelasasen im Beispiel. Du hast als Beispiel mein_signal genommen. und das brauche ich in sleep. Wie kann ich den Aufruf von sleep und mein signal zusammenbringen. Habe mit verschiedenen Schleifen und und so probiert. es klappt nicht. Entweder Fehlermeldung oder keine Funktion. Ich möchte den Proz nicht schlafen schicken, sondern die Timer Funktion über ISR zum warten nutzen. Es fehlt nur noch die Zusammenschaltung.
Achim

 

[Dirk]

... die Timer Funktion über ISR zum warten nutzen. Es fehlt nur noch die Zusammenschaltung.

Meinst du sowas:

sleep_10ms(50) wartet 50 x 10ms, also 500ms.

Mein_Signal wird durch die ISR alle 10ms auf 0xFF gesetzt.

Da könnte man aber auch einfach _delay_ms(500) verwenden.

In der Wartezeit macht der Mikrocontroller in beiden Fällen nichts sinnvolles.

int main (void)
{

  // ...

  while(1)
  {

    // ...

    sleep_10ms(50);  // wartet 500ms

  }

  return 0;
}

void sleep_10ms(uint8_t zeit)
{

  // um genauer zu sein, müsste der Counter der TimerISR hier synchronisiert(initialisiert) werden
  // ansonsten haben wir hier einen Fehler von bis zu 10ms

  do
  {
    if (mein_signal == 0xFF)
    {
      mein_signal = 0;
      zeit--;
    }

  } while (zeit):

}

 

[achim S.]

Hallo Dirk
genau da will ich hin. Hatte zwar einen anderen Weg genommen im Prg, aber nur das Ergebnis zählt.
Nach deiner Angabe macht der Proz in der Wartezeit nichts sinnvolles. Bei delay ist mir das klar. In wie weit gilt das für dies Teil? Hatte angenommen, das die Teil durchgearbeitet wird und danach noch was anderes macht, z.B. Abfrage Taster oder Sensoren oder Absturzerkennnung. Wenn ich mir es genau anschaue, hast du recht. Es wird die Schleife do - while durchlaufen.
Für eine genaue Zeit ist eine synchronisierung mit Timer ISR notwendig. Erfolgt das nicht bereits durch den "mein_signal==0xFF"? o.K. 10ms abweichung. Bei 500ms kein Problem. Hast du für diese Sache einen andere Möglichkeit?
Achim