Zeitsteuerung für asuro

[D1K0]

Hallo D1KO,ich hab`mir deinen vorschlag angeschaut,und hab`noch ne frage.Dein prog. bezieht sich aur IR,und ich spreche von Ultraschall.Das verwirrt mich nun.Vielleicht kannst du mir das nochmal erläutern.ob das trotzdem so ginge.
Danke und gruss
Hans2

Ich denke, du beziehst dich auf den Teil:

/* uses timer2 (36kHz for IR communication */ 
/* counts falling and rising edge => 36kHz*2 = 72kHz */

Das hat nichts mit Infrarotsensoren zu tun, sondern mit der Infrarotkommunikation zwischen ASURO und PC. Es wird Timer2 benutzt und wenn ich das jetzt richtig verstanden habe, wird der auch bei der IR-Kommunikation verwendet.
Wenn du nicht die count72kHz-Variable auch für deine Ultraschallsensoren benutzt, müsste es eigentlich gehen.
Falls doch kannst du z.B. die Variable, die du für deine Sensoren brauchst in ucount72kHz umbenennen, sodass du dann eine Variable für den Ultraschall hast und eine für den 10min-Zähler.

Am Besten du testest es erst mal und sagst uns, ob es klappt oder nicht.

[Hans2]

Aha,verstehe,ich werde testen
Danke Hans2

[Der Ire]

Moin, ich krame diesen Threat mal aus, da ich ein ähnliches Problem hab:

Ich möchte eine kontrollierte zeit lang eine Schleife ausführen und danach eine kontrollierte zeit lang eine andere Schleife ausführen.

ich hab mir verschiedene Threats durchgelesen und die hier beschriebene Lösung war die, die ich am meisten Verstand^^

Ich habe in der asuro.c folgendes geändert:

von:

volatile unsigned char count72kHz;
/* uses timer2 (36kHz for IR communication */
/* counts falling and rising edge => 36kHz*2 = 72kHz */
SIGNAL (SIG_OUTPUT_COMPARE2)
{
	count72kHz ++;
}

in:

volatile unsigned char count72kHz;
volatile int flag = 0; 
/* uses timer2 (36kHz for IR communication */
/* counts falling and rising edge => 36kHz*2 = 72kHz */
SIGNAL (SIG_OUTPUT_COMPARE2)
{
	count72kHz ++;
	flag=count72kHz;
}

Im Hauptprogramm sieht das bei mir folgendermaßen aus:

#include "asuro.h"
#include "Funktionen.h"

#define XGRENZE 630	//560 ohne Motoren
#define YGRENZE 650 //573 ohne Motoren

int main(void)
{
int count72kHz;
Init();
	
	while (flag<72000)
		{
		StatusLED(GREEN);
		WaitM(50);
		StatusLED(RED);
		WaitM(50);
		}


	flag = 0;
	while (flag<144000)
		{
		StatusLED(GREEN);
		WaitM(500);
		StatusLED(RED);
		WaitM(500);
		}
	
	while(1);
	return 0;
}

Das ding ist, beim compilieren sagt der mir, das die variable flag unbekannt ist.

wie bekomm ich das hin?
was mache ich genau falsch?

[accControl]

soweit ich sehen kann, hast du die variable flag auch nicht definiert, zumindest hast du uns den teil vom code nicht mitgeschickt

um sowohl von der interrupt routine in asuro.c als auch von deinem hauptprogramm auf die variable flag zugreiffen zu können, musst du eine globale variable im asuro.c machen; diese musst du außerdem als 'volatile' deklarieren, da du auf diese sonst keinen zugriff hast

das heißt du schreibst im asuro.h

unsigned volatile long flag = 0;

und kannst dann auf sie zugreiffen

btw, das ist nicht der sinn eines flags
ein flag zeigt eine zustandsänderung an, das heißt du zählst in der interrupt-routine bis 72k und setzt dann das flag auf 1 (dann reicht auch ein char/integer) und fragst im hauptprogramm nur ab, ob das flag auf 1 oder 0 ist
sobald das flag auf 1 ist, reagierst du darauf und setzt es wieder auf 0 zurück, damit du die nächste zustandsänderung wieder erfassen kannst

mehr zu flags hier: http://de.wikipedia.org/wiki/Flag_(Informatik)

EDIT: ok, hab übersehen, dass du das flag definiert hast
du musst es auch in der asuro.h angeben, sonst findet das hauptprogramm die variable nicht.
dein nächstes problem sein, dass ein integer den wertebereich von -32k bis +32k annehmen kann und du somit nie auf einen wert von 72k kommen wirst - verwende einen long

[Der Ire]

hi, erstmal vielen dank

wie würdest du denn mein Problem sonst lösen?

wieso muss ich da volatile hinschreiben?

Arbeite relativ kurz erst mit c, hab davor, nur Software fürn pc mit Delphi geschrieben.

und wie genau mache ich eine globale variable?

[accControl]

wie würdest du denn mein Problem sonst lösen?

in der interrupt-routine solange eine variable inkrementieren, bis du auf 72000 bist, und wenn du auf 72000 bist dann das flag auf 1 setzen
im hauptprogramm baust du eine abfrage ein, die sobald das flag auf 1 ist ausgeführt wird, flag 1 auf 0 setzt (sonst 'meint dein hauptprogramm das du bei jedem durchlauf auf 72000 bist') und schreibst in diese abfrage dann das, was du sonst tust wenn flag auf 72000 ist

wieso muss ich da volatile hinschreiben?

nachdem du geschrieben hast, dass du erst am beginn mit C bist ist das jetzt nicht sehr einfach zu erklären
im prinzip musst du das hinschreiben, damit beide funktionen (hauptfunktion und interruptroutine) darauf zugreiffen und diese ändern können

und wie genau mache ich eine globale variable?

die globale variable hast du schon definiert, dass ist die volatile int flag;
eine globale variable ist eine variable, die auch außerhalb der funktion gültigkeit hat und somit von allen funktionen verwendet werden kann (gegenteil: lokale variable)

[Der Ire]

Falls es je,anden interessiert:
So sieht jetzt mein Timer aus:

So in der asuro.c

unsigned volatile char count72kHz;
unsigned volatile int  countkhz,countmsek,countsek;
/* uses timer2 (36kHz for IR communication */
/* counts falling and rising edge => 36kHz*2 = 72kHz */
SIGNAL (SIG_OUTPUT_COMPARE2)
{
	count72kHz ++;
	countkhz ++;
	if (countkhz == 72)
		{
		countmsek++;
		countkhz = 0;
		}
	
	if (countmsek == 1000)
		{
		countsek++;
		countmsek = 0;
		countkhz = 0;
		}
}

und im Hauptprogramm wird das folgendermaßen benutzt:

#include "asuro.h"
#include "Funktionen.h"	

int main(void)
{

Init();
	countsek=0;
	while (countsek<10)
		{
		StatusLED(RED);
		WaitM(100);
		StatusLED(GREEN);
		WaitM(100);
		}
	
	StatusLED(OFF);
	WaitS(1);
	
	countkhz=0;
	countmsek=0;
	countsek=0;
	while (countsek<5) 
		{
		StatusLED(GREEN);
		WaitM(500);
		StatusLED(RED);
		WaitM(500);
		}

	StatusLED(OFF);
	
	while(1);
	return 0;
}

Das bewirkt, dass die StatusLED 10 Sekunden lang schnell bilinkt und danach 5 Sekunden lang langsamer.