hoi again,

ik ben nu een beetje met de timer en interrupts aan het stoeien, ik heb 2 leds via weerstanden van de Vcc naar RB0 en RB1 geplaats. Als ik nu een uitgang hoog zet, gaat dat lampje dus uit. Nu wil ik met de timer een interrupt maken, en die verhoogt telkens een countertje. zodra die counter een bepaalt getal haalt, xor ik de ledjes zodat ze uit gaan. Nu werkt dit laatste niet. Ze blijven branden!!! Ik snap niet waarom :s Ik werk met C

// PIC = PIC16F648
// COMPILER = HI-TECH PICC 7.86
// gemaakt door Berry Bakker, 2004

// RB0 = led1
// RB1 = led2

#include <pic.h>

#ifndef EI
#define EI()	(GIE = 1)			// enable interrupts
#endif

#ifndef DI
#define DI()	{while(GIE == 1){GIE = 0;}}	// disable interrupts
#endif

__CONFIG(FOSC2);

void interrupt interrupt_handler(void);
void Timer0_int(void);

void main(void)
{
	CMCON = 0x07;	// comperators uit
		
	TRISB = 0x00;	// PORTB allemaal uitgangen
	PORTB = 0x02;	// led1 aan, led2 uit
	
	T0IE = 1;	// Timer0 interrupt aan
	T0CS = 0;	// Timer mode
	PSA = 0;	// Timer0 prescaler
	PS2 = 0;	// 1:16 prescaler
	PS1 = 1;	//
	PS0 = 1;	//
	
	EI();		// enable interrupts!
	
	// vanaf nu kunnen interrupts plaatsvinden!
}

void interrupt interrupt_handler(void)
{
	DI();		// disable interrupts
	if(T0IF == 1)
		Timer0_int();	// Timer0 interrupt!
	EI();		// enable interrupts
}


void Timer0_int(void)
{
	static unsigned int count = 0;
	
	if(++count >= 62500)	// 1 cycle duurt 1uS.
//Schaal 1:16. Dit interrupt vind elke 16uS plaats. 1/0,000016 = 62500
	{
		PORTB ^= 0x03;	// XOR RB0 en RB1!
		count = 0;	// begin weer bij 0 te tellen!
	}
	
	T0IF = 0;	// maak klaar voor de volgende interrupt
}

je hoeft denk ik niet veel van C te kennen om te begrijpen wat er gebeurt? Wie kan me helpen?

[Bericht gewijzigd door Jonathan op ]

klein beetje gewijzigd want de tekst viel nogal breed uit

je probleem denk ik:) :

je zet iedere keer je een interrupt hebt de "Count" teller op 0 bij declaratie, zo kan hij niet tellen, of ben ik mis?

[Bericht gewijzigd door Jonathan op ]

Ok

wat ik raar vind is dat als ik if(++count >= 62500) verander in if(++count >= 1) het ene ledje vel brand, en de andere heel zacht een beetje flikkert... Dus het moet daar ergens fout gaan... Je zou toch verwachten dat ze allebij dan gaan flikkeren?

Op 22 september 2004 19:55:53 schreef Sp3ci3S:
klein beetje gewijzigd want de tekst viel nogal breed uit

je probleem denk ik:) :

je zet iedere keer je een interrupt hebt de "Count" teller op 0 bij declaratie, zo kan hij niet tellen, of ben ik mis?

nee dat is het probleem niet. count is een static int, dus hij wordt maar 1 keer gedeclareerd. Ik kan het wel weghalen, heb ik al geprobeerd, maar heeft geen zin...

Is PICC slim genoeg om een read-modify-write instructie (zoals XOR) op een PORT niet toe te staan, of gaat die compiler gewoon z'n gang? Het zou namelijk daar wel eens aan kunnen liggen.

Op 22 september 2004 20:01:09 schreef Berry:
count is een static int, dus hij wordt maar 1 keer gedeclareerd.

een C-aangelegenheid, dit wist ik niet :)

PS1 = 1; //
PS0 = 1; //

EI(); // enable interrupts!

// vanaf nu kunnen interrupts plaatsvinden!

Moet daar achter //vanaf nu kunnen interrupts enz ...

niet

while (1==1)
{
};

komen te staan als oneindig loopje?

Ik heb het vermoeden dat main wordt uitgevoerd,
en dat daarna de chip doorgaat maar niks meer
vindt behalve onzin = crash.....

Met while loop blijft ie mooi in loopje en
worden de interrupts afgehandeld....

Robert


// PIC = PIC16F648
// COMPILER = HI-TECH PICC 7.86
// gemaakt door Berry Bakker, 2004

// RB0 = led1
// RB1 = led2

#include <pic.h>

#ifndef EI
#define EI()	(GIE = 1)			// enable interrupts
#endif

#ifndef DI
#define DI()	{while(GIE == 1){GIE = 0;}}	// disable interrupts
#endif

__CONFIG(FOSC2);

void interrupt Timer0_int(void);

static unsigned int count = 0;          //---> Globaal maken!!
 unsigned int counter;

void main(void)
{
	CMCON = 0x07;	// comperators uit
		
	TRISB = 0x00;	// PORTB allemaal uitgangen
	PORTB = 0x02;	// led1 aan, led2 uit
	
           DI();
	T0IE = 1;	// Timer0 interrupt aan
	T0CS = 0;	// Timer mode
	PSA = 0;	// Timer0 prescaler
	PS2 = 0;	// 1:16 prescaler
	PS1 = 1;	//
	PS0 = 1;	//
	
         EI();		// enable interrupts!
	
        while (1) { counter++}     // oneindige loop
	
}

void interrupt Timer0_int(void)   //hier staat wat te doen tijdens interrupts
{
	DI();		// disable interrupts
	if(T0IF == 1)
                         if(++count >= 62500)	// 1 cycle duurt 1uS.
		{
		PORTB ^= 0x03;	// XOR RB0 en RB1!
		count = 0;	// begin weer bij 0 te tellen!
	                 T0IF = 0;	// maak klaar voor de volgende interrupt
                                     }
	
	EI();		// enable interrupts
}

Moet interrupt programmering niet iets van deze aard zijn.
Zo weinig mogelijk functies aanroepen in een interruptroutine, dit veroorzaakt veel tijdverlies.
Het kan gebeuren dat de interrupt er alweer is en de vorige is nog niet afgehandeld.
Daarom zoveel mogelijk inline asm routines in de int.handler schrijven.
C gaat ook, maar niet te uitgebreid maken.
Dit is een beetje mijn ervaring bij een x86.
Of het bovenstaand voorbeeld zal werken betwijfel ik, het is maar een voorbeeld van volgorde.

waarom zou count globaal moeten worden? En als het globaal is moet die static toch weg???

Anyway, PICC is slim genoeg om Read-Modify-Write instructies op een poort niet toe te staan ja. Ik heb al met een loopje geprobeert, geen instructies in het loopje zoals een NOP ofzo, maar dat zou toch niet uit mogen maken...

Op 23 september 2004 17:20:12 schreef Berry:
waarom zou count globaal moeten worden? En als het globaal is moet die static toch weg???

Die static(permanent) mag en moet blijven, het gaat er hem enkel om dat ,als een variabele in een functie gedefineerd wordt die elke keer zoals in uw geval de waarde 0 krijgt bij elke interrupt.
Met globaal bedoel ik dat 'count' door elke functie kan gelezen worden en dat die buiten de interrupthandler blijft.
Over de rest kan ik niet meepraten omdat ik weinig of niets van pic's ken....voorlopig nog niet ;)

Op 23 september 2004 17:20:12 schreef Berry:
Anyway, PICC is slim genoeg om ....

Nog iets, reken maar niet teveel op uw compiler(s) om programmeerfouten te ontdekken.
In syntaxfouten zijn die onovertroffen, maar voor de rest zien ze veel door de vingers.
In C is veel toegestaan en daarom zéér flexibel.
Dit gaat niet enkel over PICC maar over C compilers in het algemeen.

Nog iets, reken maar niet teveel op uw compiler(s) om programmeerfouten te ontdekken.
In syntaxfouten zijn die onovertroffen, maar voor de rest zien ze veel door de vingers.
In C is veel toegestaan en daarom zéér flexibel.
Dit gaat niet enkel over PICC maar over C compilers in het algemeen

jah, dat kan zijn, maar PICC 'snapt' wel dat hij bij een write naar een poort geen R-m-W instructies mag gebruiken ;)

OMG!!! Wat ben ik dom geweest! Dat loopje moest dus! (ik dacht dat een programma gewoon na de main zou stoppen :P je hebt ook in asm het woord END :P). En de domste fout van mij was 62500 :D Ik dacht niet goed na en dom dom dom rekende alsof een interrupt elke keer gebeurt als TMR0 opgehoogt wordt dom dom dom :P Dus die 2 dingen samen en hij doet het perfect :D