Timer interrupt werkt niet? AVR 328p

[spork]

Goedemiddag,
Ik ben bezig met het programmeren van een Arduino Uno in C met codeblocks met WinAVR.
Echter krijg ik mijn timers met geen mogelijkheid aan de praat.
Wie ziet de fout? En nog belangrijker: de oplossing.

Alvast bedankt voor het kijken!

Includes:

C: AVR

#include <inttypes.h>
#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>

#define TCCR0 _SFR_MEM16(0x53)
#define TIMSK _SFR_IO8(0x37)

Timer init:

C: AVR

void timer0_init(void){
    TCCR0 |= (1 << CS00);
    TCNT0 = 0;
    TIMSK |= (1 << TOIE0);
    sei();

}

Het interrupt event:

C: AVR

IRS(TIMER0_OVF_vect){
//regGreen |= (1 << pinGreen);
loopCount++;
}

En hier ook nog mijn volledige code:

C: AVR

#include <inttypes.h>
#include <stdlib.h>
#include <avr/io.h>
#include <avr/interrupt.h>

#define TCCR0 _SFR_MEM16(0x53)
#define TIMSK _SFR_IO8(0x37)

#define pinA PB0
#define pinB PD7
#define pinC PD6
#define pinD PD2
#define pinE PD4
#define pinF PD3
#define pinG PD5

# define regA PORTB
# define regB PORTD
# define regC PORTD
# define regD PORTD
# define regE PORTD
# define regF PORTD
# define regG PORTD

#define disPin0 PC0
#define disPin1 PC1
#define disPin2 PC2
#define disPin3 3

#define printRegB1 (0)
#define printRegD1 ((1<<pinB)|(1<<pinC))

#define printRegB2 (1<<pinA)
#define printRegD2 ((1<<pinB)|(1<<pinD)|(1<<pinE)|(1<<pinG))

#define printRegB3 (1<<pinA)
#define printRegD3 ((1<<pinB)|(1<<pinC)|(1<<pinD)|(1<<pinG))

#define printRegB4 (0)
#define printRegD4 ((1<<pinB)|(1<<pinC)|(1<<pinF)|(1<<pinG))

#define printRegB5 (1<<pinA)
#define printRegD5 ((1<<pinC)|(1<<pinD)|(1<<pinF)|(1<<pinG))

#define printRegB6 (1<<pinA)
#define printRegD6 ((1<<pinC)|(1<<pinD)|(1<<pinE)|(1<<pinF)|(1<<pinG))

#define printRegB7 (1<<pinA)
#define printRegD7 ((1<<pinB)|(1<<pinC))

#define printRegB8 (1<<pinA)
#define printRegD8 ((1<<pinB)|(1<<pinC)|(1<<pinD)|(1<<pinE)|(1<<pinF)|(1<<pinG))

#define printRegB9 (1<<pinA)
#define printRegD9 ((1<<pinB)|(1<<pinC)|(1<<pinD)|(1<<pinF)|(1<<pinG))

#define printRegB0 (1<<pinA)
#define printRegD0 ((1<<pinB)|(1<<pinC)|(1<<pinD)|(1<<pinE)|(1<<pinF))

#define pinGreen PB4
#define pinRed PB5

#define regGreen PORTB
#define regRed PORTB

static void ioinit(void);

void digitCreator(int);

void display(void);
void disp0(int);
void disp1(int);
void disp2(int);
void disp3(int);

void timer0_init(void);

int loopCount = 0;
int counter = 0;

int num0 = 0;
int num1 = 0;
int num2 = 0;
int num3 = 0;

IRS(TIMER0_OVF_vect){
//regGreen |= (1 << pinGreen);
loopCount++;
}

int main(void){

    ioinit();
    timer0_init();

 //   PORTC |= (1 << disPin0);
 //   PORTC |= (1 << disPin1);
 //   PORTC |= (1 << disPin2);
//    PORTC |= (1 << disPin3);
 //   regB &= ~(1 << pinB);

    while(1){
        if(loopCount == 1000){
            loopCount = 0;
            if(counter++ == 10000){
                    counter =0;
            }
            digitCreator(counter);
        }

        display();
    }
    return 0;
}
void timer0_init(void){
    TCCR0 |= (1 << CS00);
    TCNT0 = 0;
    TIMSK |= (1 << TOIE0);
    sei();

}

void digitCreator (int number){
    num0 = number/1000;
    num1 = number/100 - num0*10;
    num2 = number/10 - num1*10 - num0*100;
    num3 = number - num2*10 - num1*100 - num0*1000;

}

void display (){
    disp0(num0);
    disp1(num1);
    disp2(num2);
    disp3(num3);
}

void disp0(int number){
//PORTC |= (1<< disPin0);
//PORTB &=~ printRegB4;
//PORTD &=~ printRegD4;

//PORTC &= ~(1<< disPin0);
//PORTB |= printRegB4;
//PORTD |= printRegD4;

switch (number){
    case 0:
        PORTC |= (1 << disPin0);
        PORTB &=~ printRegB0;
        PORTD &=~ printRegD0;

        PORTB |= printRegB0;
        PORTC &= ~(1 << disPin0);
        PORTD |= printRegD0;

        break;
    case 1:
        PORTC |= (1 << disPin0);
        PORTB &=~ printRegB1;
        PORTD &=~ printRegD1;

        PORTB |= printRegB1;
        PORTC &= ~(1 << disPin0);
        PORTD |= printRegD1;
        break;
    case 2:
        PORTC |= (1 << disPin0);
        PORTB &=~ printRegB2;
        PORTD &=~ printRegD2;

        PORTB |= printRegB2;
        PORTC &= ~(1 << disPin0);
        PORTD |= printRegD2;
        break;
    case 3:
        PORTC |= (1 << disPin0);
        PORTB &=~ printRegB3;
        PORTD &=~ printRegD3;

        PORTB |= printRegB3;
        PORTC &= ~(1 << disPin0);
        PORTD |= printRegD3;
        break;
    case 4:
        PORTC |= (1 << disPin0);
        PORTB &=~ printRegB4;
        PORTD &=~ printRegD4;

        PORTB |= printRegB4;
        PORTC &= ~(1 << disPin0);
        PORTD |= printRegD4;
        break;
    case 5:
        PORTC |= (1 << disPin0);
        PORTB &=~ printRegB5;
        PORTD &=~ printRegD5;

        PORTB |= printRegB5;
        PORTC &= ~(1 << disPin0);
        PORTD |= printRegD5;
        break;
    case 6:
        PORTC |= (1 << disPin0);
        PORTB &=~ printRegB6;
        PORTD &=~ printRegD6;

        PORTB |= printRegB6;
        PORTC &= ~(1 << disPin0);
        PORTD |= printRegD6;
        break;
    case 7:
        PORTC |= (1 << disPin0);
        PORTB &=~ printRegB7;
        PORTD &=~ printRegD7;

        PORTB |= printRegB7;
        PORTC &= ~(1 << disPin0);
        PORTD |= printRegD7;
        break;
    case 8:
        PORTC |= (1 << disPin0);
        PORTB &=~ printRegB8;
        PORTD &=~ printRegD8;

        PORTB |= printRegB8;
        PORTC &= ~(1 << disPin0);
        PORTD |= printRegD8;
        break;
    case 9:
        PORTC |= (1 << disPin0);
        PORTB &=~ printRegB9;
        PORTD &=~ printRegD9;

        PORTB |= printRegB9;
        PORTC &= ~(1 << disPin0);
        PORTD |= printRegD9;
        break;
}
}

void disp1(int number){

switch (number){
    case 0:
        PORTC |= (1 << disPin1);
        PORTB &=~ printRegB0;
        PORTD &=~ printRegD0;

        PORTB |= printRegB0;
        PORTC &= ~(1 << disPin1);
        PORTD |= printRegD0;
        break;
    case 1:
        PORTC |= (1 << disPin1);
        PORTB &=~ printRegB1;
        PORTD &=~ printRegD1;

        PORTB |= printRegB1;
        PORTC &= ~(1 << disPin1);
        PORTD |= printRegD1;
        break;
    case 2:
        PORTC |= (1 << disPin1);
        PORTB &=~ printRegB2;
        PORTD &=~ printRegD2;

        PORTB |= printRegB2;
        PORTC &= ~(1 << disPin1);
        PORTD |= printRegD2;
        break;
    case 3:
        PORTC |= (1 << disPin1);
        PORTB &=~ printRegB3;
        PORTD &=~ printRegD3;

        PORTB |= printRegB3;
        PORTC &= ~(1 << disPin1);
        PORTD |= printRegD3;
        break;
    case 4:
        PORTC |= (1 << disPin1);
        PORTB &=~ printRegB4;
        PORTD &=~ printRegD4;

        PORTB |= printRegB4;
        PORTC &= ~(1 << disPin1);
        PORTD |= printRegD4;
        break;
    case 5:
        PORTC |= (1 << disPin1);
        PORTB &=~ printRegB5;
        PORTD &=~ printRegD5;

        PORTB |= printRegB5;
        PORTC &= ~(1 << disPin1);
        PORTD |= printRegD5;
        break;
    case 6:
        PORTC |= (1 << disPin1);
        PORTB &=~ printRegB6;
        PORTD &=~ printRegD6;

        PORTB |= printRegB6;
        PORTC &= ~(1 << disPin1);
        PORTD |= printRegD6;
        break;
    case 7:
        PORTC |= (1 << disPin1);
        PORTB &=~ printRegB7;
        PORTD &=~ printRegD7;

        PORTB |= printRegB7;
        PORTC &= ~(1 << disPin1);
        PORTD |= printRegD7;
        break;
    case 8:
        PORTC |= (1 << disPin1);
        PORTB &=~ printRegB8;
        PORTD &=~ printRegD8;

        PORTB |= printRegB8;
        PORTC &= ~(1 << disPin1);
        PORTD |= printRegD8;
        break;
    case 9:
        PORTC |= (1 << disPin1);
        PORTB &=~ printRegB9;
        PORTD &=~ printRegD9;

        PORTB |= printRegB9;
        PORTC &= ~(1 << disPin1);
        PORTD |= printRegD9;
        break;
}
}

void disp2(int number){

switch (number){
    case 0:
        PORTC |= (1 << disPin2);
        PORTB &=~ printRegB0;
        PORTD &=~ printRegD0;

        PORTB |= printRegB0;
        PORTC &= ~(1 << disPin2);
        PORTD |= printRegD0;
        break;
    case 1:
        PORTC |= (1 << disPin2);
        PORTB &=~ printRegB1;
        PORTD &=~ printRegD1;

        PORTB |= printRegB1;
        PORTC &= ~(1 << disPin2);
        PORTD |= printRegD1;
        break;
    case 2:
        PORTC |= (1 << disPin2);
        PORTB &=~ printRegB2;
        PORTD &=~ printRegD2;

        PORTB |= printRegB2;
        PORTC &= ~(1 << disPin2);
        PORTD |= printRegD2;
        break;
    case 3:
        PORTC |= (1 << disPin2);
        PORTB &=~ printRegB3;
        PORTD &=~ printRegD3;

        PORTB |= printRegB3;
        PORTC &= ~(1 << disPin2);
        PORTD |= printRegD3;
        break;
    case 4:
        PORTC |= (1 << disPin2);
        PORTB &=~ printRegB4;
        PORTD &=~ printRegD4;

        PORTB |= printRegB4;
        PORTC &= ~(1 << disPin2);
        PORTD |= printRegD4;
        break;
    case 5:
        PORTC |= (1 << disPin2);
        PORTB &=~ printRegB5;
        PORTD &=~ printRegD5;

        PORTB |= printRegB5;
        PORTC &= ~(1 << disPin2);
        PORTD |= printRegD5;
        break;
    case 6:
        PORTC |= (1 << disPin2);
        PORTB &=~ printRegB6;
        PORTD &=~ printRegD6;

        PORTB |= printRegB6;
        PORTC &= ~(1 << disPin2);
        PORTD |= printRegD6;
        break;
    case 7:
        PORTC |= (1 << disPin2);
        PORTB &=~ printRegB7;
        PORTD &=~ printRegD7;

        PORTB |= printRegB7;
        PORTC &= ~(1 << disPin2);
        PORTD |= printRegD7;
        break;
    case 8:
        PORTC |= (1 << disPin2);
        PORTB &=~ printRegB8;
        PORTD &=~ printRegD8;

        PORTB |= printRegB8;
        PORTC &= ~(1 << disPin2);
        PORTD |= printRegD8;
        break;
    case 9:
        PORTC |= (1 << disPin2);
        PORTB &=~ printRegB9;
        PORTD &=~ printRegD9;

        PORTB |= printRegB9;
        PORTC &= ~(1 << disPin2);
        PORTD |= printRegD9;
        break;
}
}

void disp3(int number){

switch (number){
    case 0:
        PORTC |= (1 << disPin3);
        PORTB &=~ printRegB0;
        PORTD &=~ printRegD0;

        PORTB |= printRegB0;
        PORTC &= ~(1 << disPin3);
        PORTD |= printRegD0;
        break;
    case 1:
        PORTC |= (1 << disPin3);
        PORTB &=~ printRegB1;
        PORTD &=~ printRegD1;

        PORTB |= printRegB1;
        PORTC &= ~(1 << disPin3);
        PORTD |= printRegD1;
        break;
    case 2:
        PORTC |= (1 << disPin3);
        PORTB &=~ printRegB2;
        PORTD &=~ printRegD2;

        PORTB |= printRegB2;
        PORTC &= ~(1 << disPin3);
        PORTD |= printRegD2;
        break;
    case 3:
        PORTC |= (1 << disPin3);
        PORTB &=~ printRegB3;
        PORTD &=~ printRegD3;

        PORTB |= printRegB3;
        PORTC &= ~(1 << disPin3);
        PORTD |= printRegD3;
        break;
    case 4:
        PORTC |= (1 << disPin3);
        PORTB &=~ printRegB4;
        PORTD &=~ printRegD4;

        PORTB |= printRegB4;
        PORTC &= ~(1 << disPin3);
        PORTD |= printRegD4;
        break;
    case 5:
        PORTC |= (1 << disPin3);
        PORTB &=~ printRegB5;
        PORTD &=~ printRegD5;

        PORTB |= printRegB5;
        PORTC &= ~(1 << disPin3);
        PORTD |= printRegD5;
        break;
    case 6:
        PORTC |= (1 << disPin3);
        PORTB &=~ printRegB6;
        PORTD &=~ printRegD6;

        PORTB |= printRegB6;
        PORTC &= ~(1 << disPin3);
        PORTD |= printRegD6;
        break;
    case 7:
        PORTC |= (1 << disPin3);
        PORTB &=~ printRegB7;
        PORTD &=~ printRegD7;

        PORTB |= printRegB7;
        PORTC &= ~(1 << disPin3);
        PORTD |= printRegD7;
        break;
    case 8:
        PORTC |= (1 << disPin3);
        PORTB &=~ printRegB8;
        PORTD &=~ printRegD8;

        PORTB |= printRegB8;
        PORTC &= ~(1 << disPin3);
        PORTD |= printRegD8;
        break;
    case 9:
        PORTC |= (1 << disPin3);
        PORTB &=~ printRegB9;
        PORTD &=~ printRegD9;

        PORTB |= printRegB9;
        PORTC &= ~(1 << disPin3);
        PORTD |= printRegD9;
        break;
}
}

static void ioinit(){

    DDRC |=  (1 << disPin0);
    DDRC |=  (1 << disPin1);
    DDRC |=  (1 << disPin2);
    DDRC |=  (1 << disPin3);

    DDRB |= (1 << PB0);
    DDRD |= (1 << PD2);
    DDRD |= (1 << PD3);
    DDRD |= (1 << PD4);
    DDRD |= (1 << PD5);
    DDRD |= (1 << PD6);
    DDRD |= (1 << PD7);

    regA |= (1<< pinA);
    regB |= (1<< pinB);
    regC |= (1<< pinC);
    regD |= (1<< pinD);
    regE |= (1<< pinE);
    regF |= (1<< pinF);
    regG |= (1<< pinG);

    DDRB |= (1 << pinGreen);
    DDRB |= (1 << pinRed);
}

[CurlyMo]

Misschien eerst even code tags gebruiken i.p.v. quote tags?

[spork]

CurlyMo schreef op donderdag 18 april 2019 @ 14:32:
Misschien eerst even code tags gebruiken i.p.v. quote tags?

Ik zal vast scheel zijn maar ik zie ze er niet bij staan

edit:
Inmiddels gevonden, moest iets verder zoeken dan het bovenste rijtje..

[ Voor 16% gewijzigd door spork op 18-04-2019 14:41 ]

[Cassettebandje]

code:

#define TCCR0 _SFR_MEM16(0x53)
#define TIMSK _SFR_IO8(0x37)

Waarom?
Dat moet in je headers gedefinieerd zijn en zou je niet handmatig moeten definieren.

[spork]

Cassettebandje schreef op donderdag 18 april 2019 @ 14:36:

code:

#define TCCR0 _SFR_MEM16(0x53)
#define TIMSK _SFR_IO8(0x37)

Waarom?
Dat moet in je headers gedefinieerd zijn en zou je niet handmatig moeten definieren.

Omdat ik een undeclared foutmelding kreeg..


Ik krijg bij het compileren deze waarschuwing:

code:

||=== Build: Release in AVR5 (compiler: GNU GCC Compiler for AVR) ===|
main.c|91|warning: return type defaults to 'int'|
main.c||In function 'IRS':|
main.c|94|warning: control reaches end of non-void function|
||=== Build finished: 0 error(s), 2 warning(s) (0 minute(s), 0 second(s)) ===|

[ Voor 34% gewijzigd door spork op 18-04-2019 15:25 ]

[Cassettebandje]

Typefout: IRS -> ISR
ISR betekent Interrupt Service Routine

[spork]

Cassettebandje schreef op donderdag 18 april 2019 @ 15:36:
Typefout: IRS -> ISR
ISR betekent Interrupt Service Routine

Wauw wat stom, bedankt!


Alleen werkt de interrupt nog steeds niet


In de timer init een kleine aanpassing gemaakt:

code:

void timer0_init(void){
    TCCR0A |= (1 << CS00);
    TCNT0 = 0;
    TIMSK0 |= (1 << TOIE0);
    sei();

}

TCCR0A en TIMSK0 worden wel herkent en hebben dus geen aparte definities meer nodig, echter wordt er nog niets opgeteld

[ Voor 38% gewijzigd door spork op 18-04-2019 16:14 ]

[Cassettebandje]

Het CS00 bit zit in TCCR0B. TCCR0A is voor het instellen van de output pinnen en waveform generation mode. Zie hoofdstuk 14.9 van http://ww1.microchip.com/...-ATmega328P_Datasheet.pdf

[spork]

Cassettebandje schreef op donderdag 18 april 2019 @ 16:28:
Het CS00 bit zit in TCCR0B. TCCR0A is voor het instellen van de output pinnen en waveform generation mode. Zie hoofdstuk 14.9 van http://ww1.microchip.com/...-ATmega328P_Datasheet.pdf

Jij hebt hier duidelijk een stuk meer kaas van gegeten dan ik..

code:

  TCCR0A = 0;
  // start timer 0
  // 16000000Hz / 64 / 256 = 976.56Hz
  TCCR0B = TCCR0B | (1 << CS00) | (1 << CS01);
  // enable timer 0 overflow interrupt.
  TIMSK0 = (1 << TOIE0);
  // enable global interrupts
  sei();

Met dit stuk code als de timer init werkt de handel, maar ik moet eerlijk zeggen, ik snap niet waarom.

---

Met de timer werkend ben ik bezig met de volgende stap mijn counter bedienen met knoppen dmv interrupts waarbij ik de timer gebruik om te debouncen.

Het optellen lukt met de volgende stukjes code:

code:

void pcint0_init(void){
  //  configure PCINT0 for SW2
  //  set bit mask for SW2
  //  set 'PCINT3' in 'Pin Change Mask Register 0'
  PCMSK0 |= (1 << PCINT3);
  //  set 'Pin Change Interrupt Enable 0' in 'Pin Change Interrupt Control Register'
  PCICR |= (1 << PCIE0);
}

code:

ISR(PCINT0_vect){
      // check for low level (switch pressed)
    if (((PINB & (1 << bttnL_PIN)) == 0) && (bttnPressL == 0)) {
        counter++;
        bttnPressL = 1;
        debounceL = 0;
    }
}

Waarbij in de timer het volgende gebeurt:

code:

ISR(TIMER0_OVF_vect){
//loopCount++;
    if (debounceL++ >= 50){ //976hz --> *50 = ~ 50ms
        bttnPressL = 0;
    }
    if (debounceR++ >= 50){ //976hz --> *50 = ~ 50ms
        bttnPressR = 0;
    }
}

Nou dacht ik dat de tweede knop een piece of cake zou worden:

code:

void pcint1_init(void){
  //  configure PCINT0 for SW3
  //  set bit mask for SW3
  //  set 'PCINT3' in 'Pin Change Mask Register 0'
  PCMSK0 |= (1 << PCINT2);
  //  set 'Pin Change Interrupt Enable 0' in 'Pin Change Interrupt Control Register'
 // PCICR |= (1 << PCIE0);
}

code:

ISR(PCINT1_vect){
      // check for low level (switch pressed)
    if (((PINB & (1 << bttnR_PIN)) == 0) && (bttnPressR == 0)) {
        counter--;
        bttnPressR = 1;
        debounceR = 0;
    }
}

Maar blijkbaar is het niet zo simpel, waar ga ik dit x de mist in?

[ Voor 51% gewijzigd door spork op 18-04-2019 18:04 ]

[farlane]

spork schreef op donderdag 18 april 2019 @ 16:49:
[...]
Met dit stuk code als de timer init werkt de handel, maar ik moet eerlijk zeggen, ik snap niet waarom.

Wat snap je er niet aan dan? Je selecteert een clock met CS00 en CS01 (Waarmee dus de counter start) en zet het overflow interrupt enable bit dus als zijn count register overflowed krijg je een interrupt.

Maar blijkbaar is het niet zo simpel, waar ga ik dit x de mist in?

Maak voor jezelf eens een klein schema/statemachine/flowchart whatever met wat je tracht te bereiken, dat voorkomt dat je in de probeer maar raak voor een knaak modus komt.

[spork]

farlane schreef op donderdag 18 april 2019 @ 22:45:
[...]

Wat snap je er niet aan dan? Je selecteert een clock met CS00 en CS01 (Waarmee dus de counter start) en zet het overflow interrupt enable bit dus als zijn count register overflowed krijg je een interrupt.

Met TIMSK0 zet ik dus de overflow interrupt aan, hoe is dat anders dan sei()?
Zet je met sei interrupts in het algemeen aan en met oa timsk0 specificeer je welke?

CS00 en CS01 gaat dan over de prescaling?
Alleen lijk ik een prescaler van 256 en 64 te hebben terwijl ik, als ik naar deze bron kijk, alleen de 64x prescaler zou moeten hebben. Maar gezien de uiteindelijke frequentie is het wel degelijk 64*256 (16000000Hz / 64 / 256 = 976.56Hz)

[...]

Maak voor jezelf eens een klein schema/statemachine/flowchart whatever met wat je tracht te bereiken, dat voorkomt dat je in de probeer maar raak voor een knaak modus komt.

Op dit moment is wat ik wil bereiken niet bijzonder gecompliceerd, knopje1 --> tellertje +1, knopje 2 --> tellertje -1. Het tellertje geef ik weer met een viertal 7 segmentdisplays.

---

Blijkbaar komen mijn twee knoppen dus in dezelfde interrupt terecht.

code:

  PCMSK0 |= (1 << PCINT3) | (1 << PCINT2);

Deze komen beide in PCINT0 terecht.

Is het mogelijk, zonder poorten te wisselen, hier twee aparte interrupts van te maken?

[ Voor 9% gewijzigd door spork op 19-04-2019 00:17 ]

[Vuikie]

spork schreef op vrijdag 19 april 2019 @ 00:03:
[...]


Met TIMSK0 zet ik dus de overflow interrupt aan, hoe is dat anders dan sei()?
Zet je met sei interrupts in het algemeen aan en met oa timsk0 specificeer je welke?

Dit klopt, met sei(); zet je de global interrupt aan en met cli(); zet je deze weer uit. Met de desbetreffende
mask registers zet je de functies aan en uit die jij wil dat een interrupt verzorgen. In jouw'n situatie timer 0

CS00 en CS01 gaat dan over de prescaling?
Alleen lijk ik een prescaler van 256 en 64 te hebben terwijl ik, als ik naar deze bron kijk, alleen de 64x prescaler zou moeten hebben. Maar gezien de uiteindelijke frequentie is het wel degelijk 64*256 (16000000Hz / 64 / 256 = 976.56Hz)

CS00~2 beheren de prescaler voor timer 0. In de datasheet van de Atmega328 staat een tabel hoe deze zich verhouden. Maar CS00 en CS01 aan betekend, idd, een prescaler van 64. Timer 0 is en 8 bit timer. Deze telt van 0 tot 255, bij een overflow (Van 255 naar 0) geeft deze een overflow interrupt. Dus, dan klopt het toch dat je 976,56 keer per seconde in de interrupt routine terecht komt?

Op dit moment is wat ik wil bereiken niet bijzonder gecompliceerd, knopje1 --> tellertje +1, knopje 2 --> tellertje -1. Het tellertje geef ik weer met een viertal 7 segmentdisplays.

---

Blijkbaar komen mijn twee knoppen dus in dezelfde interrupt terecht.

code:

  PCMSK0 |= (1 << PCINT3) | (1 << PCINT2);

Deze komen beide in PCINT0 terecht.

Is het mogelijk, zonder poorten te wisselen, hier twee aparte interrupts van te maken?

De PCINT0-7 vallen allemaal onder PCIE0 interrupt. Het is aan jou zelf om te bepalen welke pin de interrupt heeft getriggerd. Dus nee, hier kan je niet 2 aparte interrupts van maken zonder poort te wisselen.


Ik raad je toch aan om de door @Cassettebandje gelinkte datasheet door te gaan lezen en je Google/DuckDuckGo skills wat op te gaan poetsen, wat over deze chip os zoveel te vinden dat het niet heel moeilijk is om dit zelf op te lossen. Iets zelf oplossen geeft veel meer voldoening en leer je veel meer van dan als je het allemaal maar wordt aan gedragen

[farlane]

spork schreef op vrijdag 19 april 2019 @ 00:03:
[...]
Blijkbaar komen mijn twee knoppen dus in dezelfde interrupt terecht.

code:

  PCMSK0 |= (1 << PCINT3) | (1 << PCINT2);

Deze komen beide in PCINT0 terecht.

Is het mogelijk, zonder poorten te wisselen, hier twee aparte interrupts van te maken?

Ja, dit soort vooroorlogse controllers hebben een beperkte hoeveelheid registers en interrupt lijnen, dus er wordt nog weleens wat gecombineerd/bespaard.

In dit geval is de oplossing niet heel lastig trouwens, als je een pin change interrupt krijgt kijk je of de pin waarin je geinteresseerd bent is veranderd naar het logic niveau waarin je bent geinteresseerd (je moet zelf gaan vergelijken met de "vorige" toestand van de pin )

[spork]

farlane schreef op vrijdag 19 april 2019 @ 11:55:
[...]


Ja, dit soort vooroorlogse controllers hebben een beperkte hoeveelheid registers en interrupt lijnen, dus er wordt nog weleens wat gecombineerd/bespaard.

In dit geval is de oplossing niet heel lastig trouwens, als je een pin change interrupt krijgt kijk je of de pin waarin je geinteresseerd bent is veranderd naar het logic niveau waarin je bent geinteresseerd (je moet zelf gaan vergelijken met de "vorige" toestand van de pin )

Dat is exact wat ik nu maar doe. Maar vroeg mij toch af of er geen makkelijkere weg was.

Bedankt voor alle hulp tot zover!