Pin Change Interrupt atmega168

[daslachendeknie (Gast)]

Hallo an Alle!

Da dies mein erster Beitrag hier im Forum ist, möchte ich mich erstmal 
für die tolle Arbeit hier bedanken! Hat mir schon oft aus der Patsche 
geholfen.. ;)

Nun aber zum Problem:
Ich habe an meinem atmega168 insgesammt vier PWM-Eingänge angeschlossen. 
Diese möchte ich nun auswerten um die PWM-Dauer festzustellen. Dazu sei 
gesagt, dass sich jeweils zwei der Pins (4,6 / 13,14) in den 
Pin-Change-Bereichen 0 und 1 befinden.

Mein Code funktioniert bisher aber leider nur für den 
Pin-Change-Interrupt-0 (PCINT0). Der PCINT1 wird irgendwie nicht 
ausgelöst! :( Die Signale liegen aber an - habs mit dem OSZI 
nachgemessen.

PCICR und PCIFR sollten korrekt sein und auch die PCMSK0/1 sollten mit 
den Pins überein stimmen (habs auch schon mit PCMSK1 = 0x7F) probiert.

Weis noch jemand einen Rat?

Grüße, Sascha

Code:

/*****************************************************
This program was produced by the
CodeWizardAVR V2.05.2 Evaluation
Automatic Program Generator
© Copyright 1998-2011 Pavel Haiduc, HP InfoTech s.r.l.
http://www.hpinfotech.com

Project : RC-Panzer
Version : 1
Date    : 07.07.2011
Author  : Sascha Albrecht
Company : Modellfreunde Thüringen
Comments: 


Chip type               : ATmega168
Program type            : Application
AVR Core Clock frequency: 16,001000 MHz
Memory model            : Small
External RAM size       : 0
Data Stack size         : 256
*****************************************************/

#include <mega168.h>

//Achtung: PWM-Signal ist invertiert! - damit liegt Fall vor Rise
unsigned int pwm1rise;  //steigende Flanke
unsigned int pwm1fall;  //fallende Flanke
unsigned int pwm1time;  //berechneter Zeitwert des PWM-(High)-Signals 
unsigned int pwm1last = 1;  //merkt sich den letzten Zustand des Pins (um zu prüfen, ob er geändert wurde)
unsigned int pwm1flag = 0;
unsigned int pwm2rise;
unsigned int pwm2fall;
unsigned int pwm2time;
unsigned int pwm2last = 1;
unsigned int pwm2flag = 0;
unsigned int pwm3rise;
unsigned int pwm3fall;
unsigned int pwm3time;
unsigned int pwm3last = 1;
unsigned int pwm3flag = 0;
unsigned int pwm4rise;
unsigned int pwm4fall;
unsigned int pwm4time;
unsigned int pwm4last = 1;
unsigned int pwm4flag = 0;



// Pin change 0-7 interrupt service routine
interrupt [PC_INT0] void pin_change_isr0(void)
{  
    int time_h, time_l;
    time_l = TCNT1L;
    time_h = TCNT1H;    
  
    if(PIND.2 != pwm1last)
    { 
        if(pwm1last == 1)
        {
            pwm1fall = ((int)time_h << 8) + time_l;
            pwm1last = 0;
        }
        else
        {
            pwm1rise = ((int)time_h << 8) + time_l;
            pwm1last = 1;
            pwm1flag = 1;            
        }            
    }
    
    if(PIND.4 != pwm2last)
    { 
        if(pwm2last == 1)
        {
            pwm2fall = ((int)time_h << 8) + time_l;        //Achtung: Signal ist invertiert -> Fall kommt vor Rise!
            pwm2last = 0;
        }
        else
        {
            pwm2rise = ((int)time_h << 8) + time_l;
            pwm2last = 1;
            pwm2flag = 1;
        }            
    }            
}

// Pin change 8-14 interrupt service routine
interrupt [PC_INT1] void pin_change_isr1(void)
{
    int time_h, time_l;
    time_l = TCNT1L;
    time_h = TCNT1H;    
  
    if(PIND.7 != pwm3last)
    { 
        if(pwm3last == 1)
        {
            pwm3fall = ((int)time_h << 8) + time_l;
            pwm3last = 0;
        }
        else
        {
            pwm3rise = ((int)time_h << 8) + time_l;
            pwm3last = 1;
            pwm3flag = 1;            
        }            
    }
    
    if(PINB.0 != pwm4last)
    { 
        if(pwm4last == 1)
        {
            pwm4fall = ((int)time_h << 8) + time_l;        //Achtung: Signal ist invertiert -> Fall kommt vor Rise!
            pwm4last = 0;
        }
        else
        {
            pwm4rise = ((int)time_h << 8) + time_l;
            pwm4last = 1;
            pwm4flag = 1;
        }            
    } 
    
  //Dient nur zur Überprüfung, ob die ISR ausgeführt wird, oder nicht
    //if(PINC.5)
    //    PORTC.5 = 0;
    //else
    PORTC.5 = 1;        //Der Ausgang sollte jett HI sein, sobald die ISR einmal ausgeführt wurde
}

// Standard Input/Output functions
#include <stdio.h>

// Declare your global variables here

void main(void)
{
// Declare your local variables here

// Crystal Oscillator division factor: 1
#pragma optsize-
CLKPR=0x80;
CLKPR=0x00;
#ifdef _OPTIMIZE_SIZE_
#pragma optsize+
#endif

// Input/Output Ports initialization
// Port B initialization
// Func7=Out Func6=In Func5=In Func4=Out Func3=Out Func2=Out Func1=Out Func0=In 
// State7=0 State6=T State5=T State4=0 State3=0 State2=0 State1=0 State0=P 
PORTB=0x01;
DDRB=0x9E;

// Port C initialization
// Func6=In Func5=Out Func4=In Func3=In Func2=Out Func1=Out Func0=Out 
// State6=T State5=0 State4=T State3=T State2=0 State1=0 State0=0 
PORTC=0x00;
DDRC=0x27;

// Port D initialization
// Func7=In Func6=Out Func5=Out Func4=In Func3=Out Func2=In Func1=Out Func0=In 
// State7=P State6=0 State5=0 State4=P State3=0 State2=P State1=0 State0=T 
PORTD=0x94;
DDRD=0x6A;

// Timer/Counter 0 initialization
// Clock source: System Clock
// Clock value: 16001,000 kHz
// Mode: Fast PWM top=0xFF
// OC0A output: Non-Inverted PWM
// OC0B output: Non-Inverted PWM
TCCR0A=0xA3;
TCCR0B=0x01;
TCNT0=0x00;
OCR0A=0x30;
OCR0B=0xA0;

// Timer/Counter 1 initialization
// Clock source: System Clock
// Clock value: 2000,125 kHz
// Mode: Fast PWM top=ICR1
// OC1A output: Non-Inv.
// OC1B output: Non-Inv.
// Noise Canceler: Off
// Input Capture on Falling Edge
// Timer1 Overflow Interrupt: Off
// Input Capture Interrupt: Off
// Compare A Match Interrupt: Off
// Compare B Match Interrupt: Off
TCCR1A=0xA2;
TCCR1B=0x1A;
TCNT1H=0x00;
TCNT1L=0x00;
//ICR1H=0x9C;                           //20ms Periode
//ICR1L=0x40;
ICR1H=0xAB;                             //22ms Periode
ICR1L=0xE0;
OCR1AH=0x0B;
OCR1AL=0xB8;
OCR1BH=0x0F;
OCR1BL=0xA0;

// Timer/Counter 2 initialization
// Clock source: System Clock
// Clock value: 16001,000 kHz
// Mode: Fast PWM top=0xFF
// OC2A output: Non-Inverted PWM
// OC2B output: Non-Inverted PWM
ASSR=0x00;
TCCR2A=0xA3;
TCCR2B=0x01;
TCNT2=0x00;
OCR2A=0x30;
OCR2B=0xA0;

// External Interrupt(s) initialization
// INT0: Off
// INT1: Off
// Interrupt on any change on pins PCINT0-7: On
// Interrupt on any change on pins PCINT8-14: On
// Interrupt on any change on pins PCINT16-23: Off
EICRA=0x00;
EIMSK=0x00;
PCICR=0x03;
PCMSK0=0x28;
PCMSK1=0x60;
PCIFR=0x03;

// Timer/Counter 0 Interrupt(s) initialization
TIMSK0=0x00;

// Timer/Counter 1 Interrupt(s) initialization
TIMSK1=0x00;

// Timer/Counter 2 Interrupt(s) initialization
TIMSK2=0x00;

// USART initialization
// Communication Parameters: 8 Data, 1 Stop, No Parity
// USART Receiver: On
// USART Transmitter: On
// USART0 Mode: Asynchronous
// USART Baud Rate: 19200
UCSR0A=0x00;
UCSR0B=0x18;
UCSR0C=0x06;
UBRR0H=0x00;
UBRR0L=0x33;

// Analog Comparator initialization
// Analog Comparator: Off
// Analog Comparator Input Capture by Timer/Counter 1: Off
ACSR=0x80;
ADCSRB=0x00;
DIDR1=0x00;

// ADC initialization
// ADC disabled
ADCSRA=0x00;

// SPI initialization
// SPI disabled
SPCR=0x00;

// TWI initialization
// TWI disabled
TWCR=0x00;

// Global enable interrupts
#asm("sei")

while (1)
    {            
        if(pwm1flag == 1)
        {   
            //if(pwm1fall > pwm1rise)          //für den Fall, dass zwischen pwmXfall und pwmXrise ein TimerOverflow stattgefunden hat
            //    pwm1time = ((int)(((int)ICR1H << 8) + ICR1L)) - pwm1fall + pwm1rise;
            //else
                pwm1time = pwm1rise - pwm1fall;             //Zeit berechnen
            
            if(pwm1time >= 1800 && pwm1time <= 4200)            //nur Werte zwischen 900us und 2100us sind gültig!
            {              
                #asm("cli") 
        //OCR1AH = pwm1time >> 8;            //setze den PWM-Ausgang mit der eingelesenen Zeit
        //OCR1AL = pwm1time & 0xFF;            //-"-      --> nur zum Test!
                #asm("sei")
            }   
            pwm1flag = 0;
        }  
  
        if(pwm2flag == 1)
        {   
            pwm2time = pwm2rise - pwm2fall;                     //Zeit berechnen           
            if(pwm2time >= 1800 && pwm2time <= 4200)            //nur Werte zwischen 900us und 2100us sind gültig!
            {    
                #asm("cli")           
                //OCR1BH = pwm2time >> 8;            //setze den PWM-Ausgang mit der eingelesenen Zeit
                //OCR1BL = pwm2time & 0xFF;            //-"-      --> nur zum Test!
                #asm("sei")
            }   
            pwm2flag = 0;
        }   
        
        if(pwm3flag == 1)
        {   
            pwm3time = pwm3rise - pwm3fall;                     //Zeit berechnen           
            if(pwm3time >= 1800 && pwm3time <= 4200)            //nur Werte zwischen 900us und 2100us sind gültig!
            {    
                #asm("cli")           
        OCR1AH = pwm3time >> 8;              //setze den PWM-Ausgang mit der eingelesenen Zeit
        OCR1AL = pwm3time & 0xFF;            //-"-      --> nur zum Test!
                #asm("sei")
            }   
            pwm3flag = 0;
        }
        
        if(pwm4flag == 1)
        {   
            pwm4time = pwm4rise - pwm4fall;                     //Zeit berechnen           
            if(pwm4time >= 1800 && pwm4time <= 4200)            //nur Werte zwischen 900us und 2100us sind gültig!
            {    
                #asm("cli")           
        OCR1BH = pwm4time >> 8;              //setze den PWM-Ausgang mit der eingelesenen Zeit
        OCR1BL = pwm4time & 0xFF;            //-"-      --> nur zum Test!
                #asm("sei")
            }   
            pwm4flag = 0;
        }                     
    }
}