Pin Change Interrupt atmega168

/*****************************************************

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;

        }                     

    }

}