PIC18F bleibt bei Tastendruck hängen

[Andreas R. (blackpuma)]

Guten Abend,

Ich habe hier eine Schaltung welche über SPI einen A/D Wandler liest und 
den Messwert auf einer 7-Segment Anzeige ausgibt. Zusätzlich habe ich 
noch 3 Taster angeschlossen mit PullUps auf high. Bei Tastendruck wird 
der PIN auf GND gelegt. Eine SET ein UP und eine DOWN Taste. Damit kann 
ein Wert eingestellt werden um ein Relais bei einem bestimmten 
erreichten Wert ein/aus schaltet.

Timer1 wird verwendet um die Anzeige alle 20 ms zu aktualisieren. high 
priorit Interrupt.
Timer0 wird verwendet um alle 500ms eine Messung zu triggern. low 
priority Interrupt.

Das Program läuft super. Bis ich die Tasten verwenden möchte. Es 
funktioniert ein paar mal und dann bleibt das Programm stehen. Der Wert 
ändert sich nicht mehr und die Tasten haben auch keine Wirkung mehr.

Habt ihr schon mal solche Erfahrungen gemacht?

Danke
Andreas

[Vuvuzelatus (Gast)]

>Timer1 wird verwendet um die Anzeige alle 20 ms zu aktualisieren.
>Timer0 wird verwendet um alle 500ms eine Messung zu triggern.

Zwei Timer? Warum leitest Du das 500 ms-Interval nicht einfach aus den 
20 ms ab?

>dann bleibt das Programm stehen

Kann viel heißen. Ich würde als erstes prüfen, ob die Mainloop noch 
ausgeführt wird.

Was das Problem mit den Tasten betrifft, kannst Du davon ausgehen, dass 
es nicht am Controller liegt, sondern an der Beschaltung oder am Code, 
wobei letzteres sehr viel wahrscheinlicher ist.

[Andreas R. (blackpuma)]

Ich verwende 2 Timer weil die Wandlung recht lange dauert. Damit meine 
Anzeige nicht flimmert wird der low priority Interrupt vom high 
Interrupt unterbrochen.

Ich denke das alles stehen bleibt weil sich auch die Anzeige nicht mehr 
aktualisiert.

[Kein Name (Gast)]

Erfahrungen gesammelt - aber sicher doch!

Irgendwie lässt sich das Problem immer mit einer LED finden. Ein paar 
Befehle zum Ein-Ausschalten einbauen und die Stelle wo es hängt 
einkreisen.

Mit dem Pickit Debugger geht es aber 100 mal so schnell.

[Vuvuzelatus (Gast)]

>Ich verwende 2 Timer weil die Wandlung recht lange dauert. Damit meine
>Anzeige nicht flimmert wird der low priority Interrupt vom high
>Interrupt unterbrochen.

nixversteh Wieso spielt es ne Rolle, wie lange die Wandlung dauert? 
Wartest Du die etwa mit ner blockierenden Schleife ab? Oh, mir schwant 
Übles, denn genau das käme gut als Grund in Betracht, warum Du die 
Interrupt-durch-Interrupt-Unterbrechungsgeschichte brauchst. Sonst hätte 
ich keine Erklärung dafür, denn 20 ms sind ne Ewigkeit.

OK, da ich nicht weiß, was Du da gecodet hast, ist alles nur 
Spekulation. Davon will ich Dich lieber verschonen.

Gute Nacht.

[Andreas R. (blackpuma)]

Hallo,

Ich habe jetzt festgestellt das die Interrupts weiter laufen und die 
Hauptschleife den Geist aufgibt. Ich empfange am PC nach wie vor die 
Werte und das Display reagier auch immer noch.

Hier ist noch mein Code:

#include <p18f46k20.h>
#include <usart.h>
#include <delays.h>
#include <spi.h>
#include <stdlib.h>
#include <AD7793.h>
#include <Communication.h>
#include <timers.h>

// CONFIG1H
#pragma config FOSC = HS        // Oscillator Selection bits (HS oscillator)
#pragma config FCMEN = OFF      // Fail-Safe Clock Monitor Enable bit (Fail-Safe Clock Monitor disabled)
#pragma config IESO = OFF       // Internal/External Oscillator Switchover bit (Oscillator Switchover mode disabled)

// CONFIG2L
#pragma config PWRT = ON        // Power-up Timer Enable bit (PWRT enabled)
#pragma config BOREN = OFF      // Brown-out Reset Enable bits (Brown-out Reset disabled in hardware and software)
#pragma config BORV = 30        // Brown Out Reset Voltage bits (VBOR set to 3.0 V nominal)

// CONFIG2H
#pragma config WDTEN = OFF      // Watchdog Timer Enable bit (WDT is controlled by SWDTEN bit of the WDTCON register)
#pragma config WDTPS = 32768    // Watchdog Timer Postscale Select bits (1:32768)

// CONFIG3H
#pragma config CCP2MX = PORTC   // CCP2 MUX bit (CCP2 input/output is multiplexed with RC1)
#pragma config PBADEN = OFF     // PORTB A/D Enable bit (PORTB<4:0> pins are configured as digital I/O on Reset)
#pragma config LPT1OSC = OFF    // Low-Power Timer1 Oscillator Enable bit (Timer1 configured for higher power operation)
#pragma config HFOFST = OFF     // HFINTOSC Fast Start-up (The system clock is held off until the HFINTOSC is stable.)
#pragma config MCLRE = ON       // MCLR Pin Enable bit (MCLR pin enabled; RE3 input pin disabled)

// CONFIG4L
#pragma config STVREN = ON      // Stack Full/Underflow Reset Enable bit (Stack full/underflow will cause Reset)
#pragma config LVP = OFF        // Single-Supply ICSP Enable bit (Single-Supply ICSP enabled)
#pragma config XINST = OFF      // Extended Instruction Set Enable bit (Instruction set extension and Indexed Addressing mode disabled (Legacy mode))

// DEFINITIONS
#define DIGIT4      PORTBbits.RB4
#define DIGIT3      PORTBbits.RB5
#define DIGIT2      PORTAbits.RA2
#define DIGIT1      PORTAbits.RA3

void high_isr(void);
void low_isr(void);
unsigned long GetRREF(void);
unsigned long GetRRTD(void);
unsigned long CalcTemp(void);

unsigned int On_1  = 300;
unsigned int Off_1 = 310;
int menu    = 0x00;
int counter = 0x00;
unsigned long Temperature = 0x00;

unsigned long CodeRREF = 0x00, CodeRRTD = 0x00;

/****************** Start Interrupt *********************/
/*
 * High interrupt vector
 */
#pragma code high_vector=0x08
void high_vector_interrupt (void)
{
_asm
GOTO high_isr
_endasm
}

/*
 * Low interrupt vector
 */
#pragma code low_vector=0x18
void low_vector_interrupt (void)
{
_asm
GOTO low_isr
_endasm
}

#pragma code /* return to the default code section */
/*
 * High priority interrupt routine
 */
#pragma interrupt high_isr
void high_isr (void)
{
    char buffer[20];
    unsigned int i;

    if ( PIR1bits.TMR1IF )       // check for TMR0 overflow
    {
        /* if menu is zero the temp is shown */
        if( menu == 0 )
        {
            ultoa( Temperature, buffer );

            i  = (unsigned int)buffer[2];
            i -= 48;
            PORTB = i;
            DIGIT1 = 1;
            Delay1KTCYx(10);
            DIGIT1 = 0;
            i  = (unsigned int)buffer[1];
            i -= 48;
            PORTB = i;
            DIGIT2 = 1;
            Delay1KTCYx(10);
            DIGIT2 = 0;
            i  = (unsigned int)buffer[0];
            i -= 48;
            PORTB = i;
            DIGIT3 = 1;
            Delay1KTCYx(10);
            DIGIT3 = 0;
        }

        /* if menu is 1 then the on temp is shown */
        if( menu == 1 )
        {
            ultoa( On_1, buffer );

            i  = (unsigned int)buffer[2];
            i -= 48;
            PORTB = i;
            DIGIT1 = 1;
            Delay1KTCYx(10);
            DIGIT1 = 0;
            i  = (unsigned int)buffer[1];
            i -= 48;
            PORTB = i;
            DIGIT2 = 1;
            Delay1KTCYx(10);
            DIGIT2 = 0;
            i  = (unsigned int)buffer[0];
            i -= 48;
            PORTB = i;
            DIGIT3 = 1;
            Delay1KTCYx(10);
            DIGIT3 = 0;
        }

        /* if menu is 2 then the off temp is shown */
        if( menu == 2 )
        {
            ultoa( Off_1, buffer );

            i  = (unsigned int)buffer[2];
            i -= 48;
            PORTB = i;
            DIGIT1 = 1;
            Delay1KTCYx(10);
            DIGIT1 = 0;
            i  = (unsigned int)buffer[1];
            i -= 48;
            PORTB = i;
            DIGIT2 = 1;
            Delay1KTCYx(10);
            DIGIT2 = 0;
            i  = (unsigned int)buffer[0];
            i -= 48;
            PORTB = i;
            DIGIT3 = 1;
            Delay1KTCYx(10);
            DIGIT3 = 0;
        }

        PIR1bits.TMR1IF = 0;      // clear interrupt flag
        WriteTimer1( 61785 );                   // every 20 ms @12MHz a Interrupt
    } // End TMR1IF

    
}

#pragma code /* return to the default code section */
/*
 *
 * low priority interrupt routine
 *
 * This starts the messure of the needed values
 *
 */
#pragma interrupt low_isr
void low_isr (void)
{
    char buffer[20];

    if (INTCONbits.TMR0IF)       // check for TMR0 overflow
    {
        CodeRRTD += GetRRTD();                  // calc average
        if( counter > 0 ) CodeRRTD /= 2;
        CodeRREF += GetRREF();                  // calc average
        if( counter > 0 ) CodeRREF /= 2;

        counter++;

        if( counter == 4 )
        {
            Temperature = CalcTemp();

            ultoa( Temperature, buffer );
            putsUSART( buffer );                // send to PC
            putrsUSART( "\r\n" );

            /* Turn on or off the heating */
            if( Temperature < On_1 )
            {
                PORTDbits.RD7 = 1;
            }
            if( Temperature > Off_1 )
            {
                PORTDbits.RD7 = 0;
            }

            CodeRREF = 0x00;
            CodeRRTD = 0x00;
            counter  = 0x00;
        }
    }
    INTCONbits.TMR0IF = 0;      // clear interrupt flag
    WriteTimer0( 18660 );                       // every 500 ms a Interrupt
}
/****************** END Interrupt *********************/
.
.
.
3 Methoden fehlen
.
.
.

/***********************************
 *
 * main program
 *
 **********************************/
void main( void )
{
    char buffer[20];

    /* 9600, */
    OpenUSART(USART_TX_INT_OFF &
            USART_RX_INT_OFF &
            USART_ASYNCH_MODE &
            USART_EIGHT_BIT &
            USART_BRGH_HIGH,
            77);

    /* SPI idle is high, FOSC/64,  */
    OpenSPI( SPI_FOSC_64, MODE_11, SMPMID );

    /* Open Timer 0 */
    OpenTimer0( TIMER_INT_ON &
                T0_16BIT &
                T0_SOURCE_INT &
                T0_PS_1_32 );

    /* Open Timer 1 */
    OpenTimer1( TIMER_INT_ON &
                T1_16BIT_RW &
                T1_SOURCE_INT &
                T1_PS_1_8 &
                T1_OSC1EN_OFF &
                T1_SYNC_EXT_OFF );

    RCONbits.IPEN      = 1;     // Enable priority on interrupts
    INTCONbits.GIEH    = 1;     // Enable high priority interrupt
    INTCONbits.GIEL    = 1;     // Enable low priority interrupt

    INTCONbits.PEIE    = 1;     // Enable peripherial interrupts

    INTCONbits.TMR0IE  = 1;     // Enable TMR0 interrupt
    INTCON2bits.TMR0IP = 0;     // TMR0 interrupt low priority

    PIE1bits.TMR1IE    = 1;     // TMR1 interrupt enable
    IPR1bits.TMR1IP    = 1;     // TMR1 interrupt high priority

    ANSEL  = 0x00;              // All Pins digital
    ANSELH = 0x00;              // All Pins digital

    TMR0H = 0x00;
    TMR0L = 0x00;

    TMR1H = 0x00;
    TMR1L = 0x00;

    TRISA            = 0x00;    // PortA output
    TRISB            = 0x00;    // PortB output
    TRISCbits.TRISC0 = 0;       // RC0/CS - output
    TRISCbits.TRISC4 = 1;       // RC4/SDI - input
    TRISCbits.TRISC5 = 0;       // RC5/SDO - output
    TRISCbits.TRISC3 = 0;       // RC3/CLK - output
    TRISDbits.TRISD0 = 1;       // Taster - input
    TRISDbits.TRISD1 = 1;       // Taster - input
    TRISDbits.TRISD2 = 1;       // Taster - input
    TRISDbits.TRISD3 = 1;       // Taster - input
    TRISDbits.TRISD6 = 0;       // D6 - output (LED)
    TRISDbits.TRISD7 = 0;       // D7 - output (LED)

    AD7793_Reset();
    /* Set AD to idle mode */
    AD7793_SetRegisterValue(AD7793_REG_MODE,            // MODE Reg
                            0b0100000000000000,         // Idle mode
                            2,                          // 2 byte register
                            1); // CS is modified by SPI read/write functions.

    DIGIT1 = 0;
    DIGIT2 = 0;
    DIGIT3 = 0;
    DIGIT4 = 0;

/*
 *
 * Start while
 *
 */
while( 1 )
{
    /* up button */
    if( !PORTDbits.RD0 && ( menu > 0 ) )
    {
        Delay1KTCYx(10);                    // Wake up time 1 ms
        while( !PORTDbits.RD0 );            // wait till release

        /* plus On temp */
        if( menu == 1 )
        {
            On_1++;
        }

       /* plus Off temp */
        if( menu == 2 )
        {
            Off_1++;
        }
    }

    /* set button */
    if( !PORTDbits.RD1 )
    {
        Delay1KTCYx(10);                    // Wake up time 1 ms
        while( !PORTDbits.RD1 );            // wait till release
        
        menu++;

        /* If in menu the Interrupt is disabled */
        if( menu > 0 )
        {
            INTCONbits.TMR0IE  = 0;     // Enable TMR0 interrupt
        }
        if( menu > 2 )
        {
            menu = 0;
            INTCONbits.TMR0IE  = 1;     // Enable TMR0 interrupt
        }
    }

    /* down button */
    if( !PORTDbits.RD2 && ( menu > 0 ) )
    {
        Delay1KTCYx(10);                    // Wake up time 1 ms
        while( !PORTDbits.RD2 );            // wait till release
        
        /* minus ON temp */
        if( menu == 1 )
        {
           On_1--;
        }

        /* minus Off temp */
        if( menu == 2 )
        {
            Off_1--;
        }
    }      // END down button

    if( !PORTDbits.RD3 )
    {
        Delay1KTCYx(10);                    // Wake up time 1 ms
        while( !PORTDbits.RD3 );            // wait till release
        
        PORTDbits.RD6 ^= 1;
    }

}   // END while( 1 );
}

BG
Andreas

[Vuvuzelatus (Gast)]

Delayschleifen (Delay1KTCYx) im ISR-Handler? Blockierendes Warten auf 
das Loslassen von Tasten?

Dein Programm ist - sorry - ein Beispiel dafür, wie man's nicht machen 
sollte. Mein Rat: Tu Dir was Gutes und schreibs neu. Erzeuge Dir mit 
einem (Hardware-)Timer einen 5 ms-Interrupt (*). Der reicht für alles. 
Weitere (Hardware-)Timer brauchst Du nicht. Alle längeren Zeiten zählst 
Du einfach über Software-Counter ab. Keine Delayschleifen, keine 
Wartegeschichten; beides ist strikt verboten.

Das entsprechende Konzept heißt kooperatives Multitasking. Wie das 
funktioniert, kannst Du z. B. hier nachlesen:

http://www.mikrocontroller.net/articles/Multitasking#Kooperatives_Multitasking

Wenn Du es schaffst, was nicht schwer ist, wenn Du das Prinzip 
verstanden hast, wirst Du am Schluss wahrscheinlich über das Ergebnis 
erstaunt sein: Obwohl in Deinem Programm nirgendwo mehr irgendein Delay 
etc. vorkommt, erfüllt es seine Aufgabe genau wie gewünscht - 
hundertprozent flimmerfreies Display inklusive ;-) Wegen seiner 
einfachen Struktur kannst Du sein Verhalten nachvollziehen und 
voraussagen, Du kannst etwaige Fehler im Code relativ schnell finden und 
korrigieren, und Du kannst es leicht ändern und erweitern. Alles sehr 
willkommene Eigenschaften, meinst Du? Stimmt. Besser gesagt: Ihr Wert 
kann gar nicht hoch genug geschätzt werden. Deshalb ziehen erfahrene 
Programmierer das kooperative Multitasking allen Alternativen vor, 
solange dem keine gewichtigen Gründe entgegenstehen.

(*) Damit kommst Du bei drei Digits auf eine Display-Refreshrate von 
1/(3*5 ms) = 66 Hz. Das ist ein brauchbarer Wert.

[Peter D. (peda)]

Andreas Riegebauer schrieb:
> Das Program läuft super. Bis ich die Tasten verwenden möchte.

Tastenpins direkt in Mainloop abfragen -> ganz schlecht.

Tasten brauchen Entprellen + Flankenerkennung.
Beides geht am besten mit einem Timerinterrupt.

[Andreas R. (blackpuma)]

Ich werde es versuchen das Programm umzuschreiben.

Ich weiß allerdings nicht ganz wie. Ich habe mir den Artikel 
durchgelesen. Den Timer auf die 5 ms zu stellen ist kein Problem. Aber 
soll ich das so machen wie im Beispiel das ich die Hauptschleife jede ms 
ausführen lasse oder den Code auch in der Interrupt routine lassen? Bzw. 
was in den Interrupt stecken und was in der Hauptschleife lassen?


Wieso ist das Abfragen der Tasten in der Hauptschleife schlecht? Wo 
sonst?

BG
Andreas

[Frank M. (frank_m35)]

Eine Interrupt-Routine sollte so klein und so schnell wie möglich sein. 
Keine Delays, keine komplexen Berechnungen, keine großen Ausgaben, das 
alles gehört in die Main Loop.

Am besten, denke ich, ist es du beginnst mit der Tastenentprellung, ohne 
irgendwas anderes. Dadurch musst du einen Timer richtig verwenden, und 
hast eine gute Basis um weiter aufzubauen.
Funktioniert alles kannst du das Display hinzufügen. Ein Counter den du 
im Timer hochzählst gibt dir eine Zeitbasis nach der du dich in deiner 
Main Loop richten kannst. Überprüfe einfach den Counter und update das 
Display in der Main Loop wenn ein bestimmter Wert erreicht ist (setz den 
Counter jedes mal zurück, sodass er von vorne beginnt zu zählen)
Dann implementiere den A/D Wandler in der Main Loop. Da er eine Weile 
zum Wandeln braucht musst du auf das Ergebnis warten. Aber nicht indem 
du das Programm, wie momentan, anhälst. Stattdessen starte die Wandlung, 
lass dein Programm weiter arbeiten und nach 100ms oder so liest du den 
Wert ein. Alles kannst du wieder mit dem Counter der im Timer 
inkrementiert wird bewerkstelligen.
Somit solltest du kein einziges Delay verwendet haben.

Professioneller geht es vermutlich durch einen externen Interrupt den 
der Wandler auslösen kann (RDY Pin) und dir signalisiert wann die 
Wandlung abgeschlossen ist. Das ist aber eine Erweiterung und kann 
später realisiert werden.

Noch was: Du hast den AD7793 laut Code, der hat zwei Modi, Single 
Measurement und Continuous Measurement. Wenn du nicht Batteriebetrieben 
bist, d.h. Stromsparen musst, so kannst du doch auch einfach den 
Continous Modus (Standardmäßig aktiviert) benutzen. Dadurch musst du 
nicht die Wandlung starten, da er ständig eine Wandlung durchführt. D.h. 
du musst einfach nur alle 500ms den Wert auslesen, sonst nichts. Das 
macht dir das Leben einfacher.

[Vuvuzelatus (Gast)]

>Aber soll ich das so machen wie im Beispiel das ich die Hauptschleife jede
>ms ausführen lasse oder den Code auch in der Interrupt routine lassen? Bzw.
>was in den Interrupt stecken und was in der Hauptschleife lassen?

Gut! Das Stellen dieser Frage zeigt, dass Du schon viel verstanden 
hast.

Wenn Du nirgendwo mehr ein Delay hast, bleiben nur noch die "echten" 
Berechnungen übrig. Da das vermutlich nur wenige einfache sind, wird 
Dein µC damit unter allen Umständen (d. h. auch bei der umfangreichsten 
Berechnung, die jemals auftreten kann) sehr schnell fertig sein - 
wahrscheinlich innerhalb von Millisekundenbruchteilen. Wenn das 
zutrifft, kannst Du alles in der Main oder alles im Timerinterrupt 
laufen lassen, oder die Aufgaben nach gusto aufteilen - es spielt keine 
Rolle. Ich würde dann einfach alles in der Main erledigen, unter 
Verwendung eines passenden Sleep-Modus.

Etwas anders siehts aus, wenn nicht garantiert ist, dass der µC die 
Berechnungen immer in 5 ms schafft. Dann gehört der Berechnungsteil in 
die Main, und in die Timer-ISR kommt alles, was die Ein-/Ausgabe des 
Programms betrifft, also das Einlesen der Tasten, und das Refreshen des 
Displays (aber nicht mehr!). Die Timer-ISR behält ihren 5 ms-Takt, aber 
die Main wird mit einem langsameren Takt versorgt, z. B. nur 40 ms, 
erzeugt durch softwaremäßige 1:8-Teilung des 5 ms-Taktes. Damit bekommst 
Du zwei Ausführungslevel in Deinem Programm: Einen "weichen", das ist 
die mit mäßiger Frequenz vor sich hintuckernde, timingUNkritische, 
unterbrechbare Mainloop für den Berechnungskram, und einen "harten", das 
ist die Timer-ISR für alle I/O-Angelegenheiten, die timingkritisch sind 
und/oder schnell laufen sollen (bei Dir der Refresh des LED-Displays). 
Der Timer-Interrupt kann und wird dann die Mainloop unterbrechen, wenn 
es erforderlich ist - das ist der Clou an der Sache.

Buenas noches.

[Peter D. (peda)]

Andreas Riegebauer schrieb:
> Wieso ist das Abfragen der Tasten in der Hauptschleife schlecht? Wo
> sonst?

Weil Du keine Kontrolle darüber hast, wann und wie oft die Mainloop den 
Pin abfragt.
Dauert die Mainloop mal länger, geht der Tastendruck verloren.
Dauert sie kurz, siehst Du mehrere Tastendrücke (Preller).

Nur mit einem Timerinterrupt kannst Du definierte Entprellintervalle 
erzeugen. Und darin setzt Du dann ein Flag, daß ein Tastendruck erkannt 
wurde.
Das Main kann nun dieses Flag lesen und löschen, wann es ihm paßt. Es 
kriegt nur genau ein Event je Druck und verliert keinen Druck.