PIC18F87K22 Timer/Counter und PWM Problem

[Georg D. (georgdonner)]

Hallo,
ich habe folgendes Problem und bin schon echt am verzweifeln mit dem 
PIC.

Vorgeschichte:

Ich habe für ein elektrisches Einziehfahrwerk für einen Modelljet (11kg 
schwer) eine Steuerungselektronik gebaut. Die Motoren der Fahrwerke 
verfügen über magnetische Encoder um die Lage der Fahrwerksbeine zu 
bestimmen. Die Impulse der Encoder werden über die Timer 0, 3 und 5 
gezählt. Beim Referenzieren fahren die Beine auf Anschlag und schalten 
mittels Überstrom ab. Die dabei gezählten Impulse werden gespeichert.

Über das ECCP1 wird das Fernsteuerungssignal ausgewertet und das 
Fahrwerk fährt entweder ein oder aus. Zur Ansteuerung der 3 Motoren 
verwende ich drei VNH5180 Motortreiber. Diese besitzen einen PWM-Eingang 
der jeweils mit einem CCP-Modul (CCP 7, 8, 9) verbunden ist. Die 
Geschwindigkeit (Einschaltdauer des PWM-Signals) kann in einem Menü für 
jedes Fahrwerksbein separat eingestellt werden.


Problem:

Die Abschaltung der Fahrwerksbeine mit den gezählten Impulsen 
funktioniert nur korrekt, wenn die Einschaltzeit 100% beträgt. Sobald 
für den Ausgang 2 und einen anderen Ausgang die Einschaltzeit des PWM 
geringer ist schaltet der Timer 3 (zählt die Impulse des Motor2) zu früh 
ab. Je geringer die Einschaltdauer ist, desto früher kommt es beim Timer 
3 zu einem Interrupt, der die Motoren stoppt. Wenn ich nur bei einem 
Fahrwerksbein ein PWM-Signal einstelle so funktioniert auch alles. Der 
Fehler tritt nur beim Ausgang 2 auf, wenn auch bei einem zweiten Ausgang 
die Einschaltdauer geringer ist.

Ich habe leider keine Ahnung, woher der Fehler kommt.
Ich hoffe, dass mir jemand eine Tipp geben kann, um das Problem zu 
lösen.

Zur Programmierung des PICs verwende ich MPLAB X mit dem XC8 Compiler in 
der 60 Tage Pro Version.

Anbei ein Foto des Fahrwerks mit dem Teststand und der betroffene Teil 
des Quellcodes.

Vielen Dank für eure Hilfe.


High Interrupt

#include "Definition.h"


void interrupt high_isr(void)
{
    if(TMR0IE == 1 && TMR0IF == 1)
    {
        TMR0IF = 0;     //Flag lösche
        INA1 = 0;       //Motor stoppen
        INB1 = 0;
        motor1 = 0;     //Variable für Motor = 0 => Motor ausgeschaltn
        CCPR7L = 200;   //PWM auf 100% für die Bremsung
        if(Richt == 1)  //Wenn die Richtung = 1 = Ausfahren => Enpostion = 0 = Ausgefahren
            F1pos = 0;
        if(Richt == 0)  //Wenn die Richtung = 0 = Einfahren => Enpostion = 2 = Eingefahren
             F1pos = 2;
        CuError1 = 0;   //Überttromfehler keiner
        savep++;        //Endpostion im main speichern, wenn alle Fahrwerk in Endpostion
        return;
    }

    if(TMR3IE == 1 && TMR3IF == 1)
    {
        TMR3IF = 0;
        INA2 = 0;
        INB2 = 0;
        motor2 = 0;
        CCPR8L = 200;
        if(Richt == 1)
            F2pos = 0;
        if(Richt == 0)
            F2pos = 2;
        T3CONbits.TMR3ON = 0;
        CuError2 = 0;
        savep++;
        return;
    }

    if(TMR5IE == 1 && TMR5IF == 1)
    {
        TMR5IF = 0;
        INA3 = 0;
        INB3 = 0;
        motor3 = 0;
        CCPR9L = 200;
        if(Richt == 1)
            F3pos = 0;
        if(Richt == 0)
            F3pos = 2;
        T5CONbits.TMR5ON = 0;
        CuError3 = 0;
        savep++;
        return;
    }
}

Timer- und CCP-Einstellungen

    //Interrupt-Einstellungen
    INTCON = 0b11100000;    //TMR0-Interrupt eingeschalten
    INTCON2 = 0b10000100;   //TMR0-Interrupt High priority
    INTCON3 = 0b00000000;   //External Interrupts = 0 => unwichtig
    PIR1 = 0;               //Flag bits = 0
    PIR2 = 0;               //Flag bits = 0
    PIR3 = 0;               //Flag bits = 0
    PIR4 = 0;               //Flag bits = 0
    PIR5 = 0;               //Flag bits = 0
    PIR6 = 0;               //Flag bits = 0
    PIE1 = 0b01000000;      //ADC-Interrupt
    PIE2 = 0b00000010;      //TMR3-Interrupt eingeschalten
    PIE3 = 0b00000110;      //Interrupt für ECCP1 und ECCP2 eingeschalten
    PIE4 = 0b00000001;      //Interrupt Enable bits = 0
    PIE5 = 0b00000011;      //TMR5- & TMR4-Interrupt eingeschalten
    PIE6 = 0;               //Interrupt Enable bits = 0
    IPR1 = 0;               //Alle diese Interrupts haben Low priority
    IPR2 = 0b00000010;      //TMR3-Interrupt High priority
    IPR3 = 0;               //Alle diese Interrupts (ECCP1 und ECCP2) haben Low priority
    IPR4 = 0;               //Alle diese Interrupts haben Low priority
    IPR5 = 0b00000010;      //TMR5-Interrupt High priority
    IPR6 = 0;               //Alle diese Interrupts haben Low priority
    RCONbits.IPEN = 1;      //Priority levels sind aktiviert


    //ADC
    ANCON1bits.ANSEL9 = 1;  //RF4 als analoger Eingang
    ANCON2bits.ANSEL18 = 1; //RG2 als analoger Eingang (ISENSE3)
    ANCON2bits.ANSEL20 = 1; //RH3 als analoger Eingang (ISENSE2)
    ANCON2bits.ANSEL23 = 1; //RH0 als analoger Eingang (ISENSE1)
    ADCON1 = 0b01110000;    //Special trigger: CTMU; VREF+: 4,096V; VREF-: Masse; Neg. Chanel: Masse;
    ADCON2 = 0b10001101;    //Right; ACQU: 2xTAD; FOSC/16


    //Counter-Einstellungen
    T0CON = 0b00101000;     //TMR0: Stop, 16-Bit, T0CKI, kein Prescaler
    T3GCON = 0b00000000;    //TMR3: Gate-Funktionen ausgeschalten
    T3CON = 0b10000110;     //TMR3: Stop, 16-Bit-Mode, nicht synchronisieren, T3CKl, Prescaler 1:1, Signale von T3CKl
    T5GCON = 0b00000000;    //TMR5: Gate-Funktionen ausgeschalten
    T5CON = 0b10000110;     //TMR5: Stop, 16-Bit-Mode, nicht synchronisieren, T5CKl, Prescaler 1:1, Signale von T5CKl


    //Timer-Einstellungen
    T1CON = 0b00000011;     //TMR1: Instruction Clock, Prescaler 1:1, 16Bit-Mode
    T1GCON = 0;             //Gate Control ausgeschalten
    T2CON = 0b00000100;     //TMR2 eingeschalten, Prescaler 1:1
    PR2 = 199;              //TMR2 auf 20kHz eingestellt

    T4CON = 0b01111111;     //TMR4: Postscaler: 1:16; Prescaler: 1:16, TMR4: ON
    PR4 = 156;              //=> 0,25ns*16*16*156=9984ns => ~10ms gibt es einen Interrupt


    //Capture-Einstellungen
    CCPTMRS0 = 0;           //Alle ECCP Timer 1
    CCP1CON = 0b00000100;   //Capture eingestellt, steigende Flanke
    

    //PWM-Einstellungen
    CCPTMRS1 = 0b00000000;  //CCP4-7: TMR1/TMR2
    CCPTMRS2 = 0b00010000;  //CCP8-9: TMR1/TMR2; CCP10: TMR7/TMR2

Impulse in Register schreiben und Motoren starten

        //Ausfahren des Fahrwerks
        if((1000 <= imp1alt && imp1alt <= 1495 && 1000 <= imp1neu && imp1neu <= 1495 && VBATlow == 0) || VBATlow == 1)  //Nur ausfahren, wenn der neu under alte Impuls im selben Bereich liegen
        {                                                                                                               //Fahrwerk ausfahren, wenn die Akkuspannung zu gering ist
            if(F1pos == 2 && F2pos == 2 && F3pos == 2)      //Vorgang nur starten, wenn das Fahrwerk in der Enposition "Eingefahren" ist
            {
                TMR0H = F1impH;                 //Impulse in die Timer schreiben
                TMR0L = F1impL;
                TMR3H = F2impH;
                TMR3L = F2impL;
                TMR5H = F3impH;
                TMR5L = F3impL;

                eeprom_write(0x00, 1);          //Fahrwerk befindet sich in keiner Endpostion
                F3pos = F2pos = F1pos = 1;
                Richt = 1;                      //Richt => Ausfahren

                CCPR7L = 100 + 10 * runos1;     //Einschaltdeur der PWMs festlegen
                CCPR8L = 100 + 10 * runos2;
                CCPR9L = 100 + 10 * runos3;

                CCP7CON = 0b00001100;   //PWM7 eingeschalten (Motor 1)
                CCP8CON = 0b00001100;   //PWM8 eingeschalten (Motor 2)
                CCP9CON = 0b00001100;   //PWM9 eingeschalten (Motor 3)

                T0CONbits.TMR0ON = 1;   //Timer0 einschalten
                motorausf(1);

                T3CONbits.TMR3ON = 1;   //Timer3 einschalten
                motorausf(2);

                T5CONbits.TMR5ON = 1;   //Timer5 einschalten
                motorausf(3);

                Anlauf = 1;
                PWM = 1;

                WriteIns(0x80);
                WriteBuch('R'); //R
                WriteBuch('u'); //u
                WriteBuch('n'); //n
                WriteBuch('-'); //Space
                WriteBuch('O'); //O
                WriteBuch('u'); //u
                WriteBuch('t'); //t
                WriteBuch(' '); //Space
            }
        }


//----------------------------------------------------------------------------------------------------
//----------------------------------------------------------------------------------------------------

        //Einfahren des Fahrwerks
        if(1505 <= imp1alt && imp1alt <= 2000 && 1505 <= imp1neu && imp1neu <= 2000  && VBATlow == 0)
        {
            if(F1pos == 0 && F2pos == 0 && F3pos == 0)  //Vorgang nur starten, wenn das Fahrwerk in der Enposition "Ausgefahren" ist
            {
                TMR0H = F1impH;
                TMR0L = F1impL;
                TMR3H = F2impH;
                TMR3L = F2impL;
                TMR5H = F3impH;
                TMR5L = F3impL;

                eeprom_write(0x00, 1);
                F3pos = F2pos = F1pos = 1;
                Richt = 0;

                CCPR7L = 100 + 10 * runis1;
                CCPR8L = 100 + 10 * runis2;
                CCPR9L = 100 + 10 * runis3;

                CCP7CON = 0b00001100;   //PWM1 eingeschalten
                CCP8CON = 0b00001100;   //PWM2 eingeschalten
                CCP9CON = 0b00001100;   //PWM3 eingeschalten

                T0CONbits.TMR0ON = 1;   //Timer0 einschalten
                motoreinf(1);

                T3CONbits.TMR3ON = 1;   //Timer3 einschalten
                motoreinf(2);

                T5CONbits.TMR5ON = 1;   //Timer5 einschalten
                motoreinf(3);

                Anlauf = 1;
                PWM = 1;

                WriteIns(0x80);
                WriteBuch('R'); //R
                WriteBuch('u'); //u
                WriteBuch('n'); //n
                WriteBuch('-'); //Space
                WriteBuch('I'); //I
                WriteBuch('n'); //n
                WriteBuch(' '); //Space
                WriteBuch(' '); //Space
            }
        }

        
//------------------------------------------------------------------------------------------------------------
//------------------------------------------------------------------------------------------------------------

        Ueberstromabschaltung();

        if(motor1 == 0 && motor2 == 0 && motor3 == 0 && PWM == 1)
        {
            PWM = 0;
            __delay_ms(40);
            CCP7CON = 0;
            CCP8CON = 0;
            CCP9CON = 0;
        }

[Max H. (hartl192)]

Georg Donner schrieb:
> P1030957.JPG
> 5 MB, 0 Downloads
> P1030961.JPG
> 5 MB, 0 Downloads
Bildformate

[Georg D. (georgdonner)]

Sorry.
Wie kann ich die Fotos ändern?

[Georg D. (georgdonner)]

Bitte diesen Thread löschen. Ich habe einen neuen eröffnet, in dem die 
Fotos das richtige Format haben.

[Jörg W. (dl8dtl) (Moderator)]

Ich sehe keinen neuen Thread von dir, und ich hatte sie dann sowieso
schon runterskaliert.  Also eigentlich könnte es hier dann zu Sache
kommen.

[Georg D. (georgdonner)]

Okay, vielen Dank.

[Carsten M. (ccp1con)]

Na da hast du dir ja einen mega PIC ausgesucht!

Deine ISR ist nicht als high oder low gekennzeichnet. Ich weiß nicht, 
was der Compiler daraus macht. Better to tell him:

void interrupt high_priority your_ISR(void)
{
}

void interrupt low_priority your_low_ISR(void)
{
}

gibt es eine zweite ISR?
was machen TMR1 und TMR4?
die returns in der ISR sind unnötig und könnten stören.

[Georg D. (georgdonner)]

Hallo,
vielen Dank für deine Hilfe Carsten. Leier haben deine Vorschläge keine 
merkliche Verbesserung gebracht.

Den Timer 1 verwendet das ECCP1 Modul zum Auswerten der Pulsbreite des 
Empfängersignals. Den Timer 4 habe ich verwendet, um alle 250ms eine 
Messung des ADCs (Akkuspannung) auszulösen. Der TMR4 löst alle 10ms 
einen Low Interrupt aus und erhöht die Variable mess. Wenn die Variable 
mess den Wert 25 erreicht wird eine Messung der Akkuspannung im main 
gestartet.

Es gibt eine zweite ISR, diese habe ich richtig mit "interrupt 
low_priority ..." gekennzeichnet gehabt. Bei der High ISR habe ich das, 
wie von dir vorgeschlagen umgeändert. Ich konnte aber den Tests keinen 
Unterschied erkennen.
In der Low-ISR wird das Signal der Fernsteuerung ausgewertet, der TMR4 
Interrupt verarbeitet und der ADC Interrupt.

Die "returns" habe ich hingeschrieben, weil es in der Hilfe von MPLAB X 
auch so geschrieben wird. Ich habe die returns für die Tests einmal 
weggelassen, aber es gab keine Änderung.

Weiters habe ich bei Tests den verschiedenen CCP-Modulen 
unterschiedliche Timer zugeteilt (CCP7 -> TMR2; CCP8 -> TMR6; CCP9 -> 
TMR4). Für die Tests habe ich für die Messung der Akkuspannung (alle 
250ms) den TMR4 durch den TMR12 ersetzt, um ihn für das CCP9 frei zu 
bekommen. Bei diesen Tests habe ich eine deutliche Verbesserung 
feststellen können. Das Fahrwerk am Ausgang 2 fuhr, wenn das PWM 
eingeschalten war, zwar noch immer nicht exakt in die Endposition und 
schaltete zu früh ab, allerdings fuhr es jetzt weiter als vorher.

Nochmals vielen Dank für deine Hilfe, aber leider hält sich das Problem 
hartnäckig.

mfg
Georg Donner

#include "Definition.h"

void interrupt low_priority isr_low(void)
{
    if(CCP1IE == 1 && CCP1IF == 1)
    {
        capalt1 = capneu1;
        capneu1 = CCPR1H;
        capneu1 = capneu1 << 8;
        capneu1 = capneu1 + CCPR1L;

        if(CCP1M0 == 0)
        {
            imp1alt = imp1neu;
            if(capneu1 > capalt1)
                imp1neu = ((capneu1 - capalt1) / 4)+14;
            if(capneu1 < capalt1)
                imp1neu = ((65536 - capalt1 + capneu1) / 4) + 14;
        }

        if(CCP1M0 == 0)
        {
            CCP1M0 = 1;
        }
        else
        {
            CCP1M0 = 0;
        }

        CCP1IF = 0;
        return;
    }


    if(ADIE == 1 && ADIF == 1)
    {
        ADIF = 0;
        ADfin = 1;
        return;
    }


    if(TMR4IE == 1 && TMR4IF == 1) //Für die Tests habe ich das auf den TMR12 geändert
    {
        TMR4IF = 0;
        mess++;
        return;
    }
}