Interrupt-Routine mit C und Timer1

[Bastian B. (hobby-pic)]

Hallo,

ich arbeite mich gerade in die µC-Geschichten ein.
Ein ganzschön komplexes und teilweise trockenes Thema.
So weit klappt alles ganz gut. Jetzt möchte ich aber mal eine 
Interrupt-Routine ausprobieren und eine LED mit dem 16bit Timer1 zum 
Blinken bringen.

Ich bin in ASM nicht besonders gut und es fällt mir sehr schwer die 
Erklärungen und Beispiele nach zu vollziehen.

Vielleicht gibt es ja hier einen Pfiffigen, der eine

"Keine Panink vor Mechanik"-mäßige Antwort hat :-)

Danke, Basti

Hier mein Ausgangspunkt. Müsste alles soweit konfiguriert sein.

Controller: PIC 18F2550
Programmierung: MPLAB IDE - C18-Compiler

//Testschaltung

//Includes
#include <p18f2550.h>
#include "delays.h"

//Config

#pragma config CPUDIV = OSC1_PLL2
#pragma config FOSC=HS
#pragma config FCMEN = OFF, IESO = OFF
#pragma config PWRT = ON
#pragma config BOR = OFF
#pragma config WDT = OFF
#pragma config LVP = OFF


//defines
#define  OUT1     LATBbits.LATB0
#define  OUT2     LATBbits.LATB1
#define  OUT3      LATBbits.LATB2
#define  OUT4    LATBbits.LATB3
#define  OUT5    LATBbits.LATB4
#define  OUT6    LATBbits.LATB5
#define  OUT7    LATBbits.LATB6
#define  OUT8    LATBbits.LATB7

#define  IN1      PORTAbits.RA0
#define  IN2      PORTAbits.RA1
#define  IN3      PORTAbits.RA2
#define   OUT9    LATAbits.LATA3
#define  OUT10    LATAbits.LATA4

//Declaration
#pragma code
void main (void)
{
  T1CON= 0b10110001;              //Timer1 aktivieren
  TMR1H=0;                  //High Byte T1
  TMR1L=0;                  //Low Byte T1
  ADCON1 = 0x0F;                  //Alle Port Pins auf digital gesetzt
  TRISA=0xE7;                   //PORTA Ein- und Ausgänge 
  TRISB=0;                   //PORTB - Ausgang
  PORTB=0;                  //PORTB auf Null setzen
  INTCON=0b10000000;              //
  PIE1=1;                    //bei Auslösen PIR1(bit0)=0 setzen

  while (1)
  {
    
  }  
}

[Fragezeichen (Gast)]

Bastian B. schrieb:
> Hier mein Ausgangspunkt. Müsste alles soweit konfiguriert sein.

Jetzt fehlt nur noch die Frage...

[Bastian B. (hobby-pic)]

Wie bekomme ich den Interrupt abgefragt?

[Peter D. (peda)]

Bastian B. schrieb:
> Wie bekomme ich den Interrupt abgefragt?

Im Example-Verzeichnis Deiner Compilerinstallation hast Du schon 
nachgeschaut?


Peter

[Bastian B. (hobby-pic)]

Wenn ich es richtig verstehe ist die Funktioniert die Interrupt-Routine 
wie eine Funktion.

Wie wird diese Funktion aufgebaut? Wie kann ich den Überlauf des Timers 
(PIR1(bit0)=1) genau in diesem Moment nutzen und wie kann ich ihn in 
mein Programm einarbeiten?

[Bastian B. (hobby-pic)]

Das Ziel ist es, dass der PORTB im Takt des interrupts von T1 hochzählt.

Klappt noch nicht.

Danke für die Hilfe.

//Testschaltung

//Includes
#include <p18f2550.h>
#include "delays.h"

//Config

#pragma config CPUDIV = OSC1_PLL2
#pragma config FOSC=HS
#pragma config FCMEN = OFF, IESO = OFF
#pragma config PWRT = ON
#pragma config BOR = OFF
#pragma config WDT = OFF
#pragma config LVP = OFF


//defines
#define  OUT1     LATBbits.LATB0
#define  OUT2     LATBbits.LATB1
#define  OUT3      LATBbits.LATB2
#define  OUT4    LATBbits.LATB3
#define  OUT5    LATBbits.LATB4
#define  OUT6    LATBbits.LATB5
#define  OUT7    LATBbits.LATB6
#define  OUT8    LATBbits.LATB7

#define  IN1      PORTAbits.RA0
#define  IN2      PORTAbits.RA1
#define  IN3      PORTAbits.RA2
#define   OUT9    LATAbits.LATA3
#define  OUT10    LATAbits.LATA4

void Test(void);              // Prototyp Serviceprogramm
#pragma code Timer=0xF9E      // Einsprung Adresse F9Eh für PIR1 Datenblatt S.66

void Timer (void)              // Hilfsfunktion        
{
 _asm GOTO Test _endasm       // Sprung nach Testfunktion
}

#pragma code                     // System Codebereich
#pragma interrupt Test        // Kennwort interrupt veranlasst



#pragma code
#pragma interrupt Test

void Test (void)
{
  PORTB++;
  PIR1=0;
}

void main (void)
{
  T1CON= 0b10110001;              //Timer1 aktivieren
  TMR1H=0;                  //High Byte T1
  TMR1L=0;                  //Low Byte T1
  ADCON1 = 0x0F;                  //Alle Port Pins auf digital gesetzt
  TRISA=0xE7;                   //PORTA Ein- und Ausgänge 
  TRISB=0;                   //PORTB - Ausgang (Dioden)
  PORTB=0;                  //PORTB auf Null setzen
  INTCON=0b10000000;              //
  PIE1=1;                    //bei Auslösen PIR1(bit0)=0 setzen

  while (1)
  {
    OUT9=1;                    //Funktionstest Diode
    OUT10=1;                  //Funktionstest Diode
  }  
}

[Bastian B. (hobby-pic)]

Muss ich die Funktion Test nochmal extra im main aufrufen.

Ich habe da ein riesen Verständnisproblem.

Kennt sich irgendwer mit Interrupts aus?

[Karl H. (kbuchegg)]

Bastian B. schrieb:
> Muss ich die Funktion Test nochmal extra im main aufrufen.

nein.

> Ich habe da ein riesen Verständnisproblem.

Seh ich auch so. Es ist vom Prinzip her viel einfacher als du denkst.

> Kennt sich irgendwer mit Interrupts aus?

Das Problem ist, dass ich die Syntax nicht kenne, die dein Compiler 
benutzt um Interrupt FUnktionen zu vereinbaren.

Aber für Timer generell kannst du dir das mal durchlesen:
http://www.mikrocontroller.net/articles/FAQ#Timer

WICHTIG: Das ist für einen anderen µC Typ! Das Prinzip ist bei deinem µC 
auch nicht anders. Daher: Wenn du das liest, achte nicht zu sehr auf die 
Details sondern auf das generelle Prinzip.

[Bastian B. (hobby-pic)]

Ich habe mir das durchgelesen und ich denke ich kann das Problem jetzt 
besser eingrenzen.


1. Ich möchte das Overflow Interrupt Flag Bit des Timer1 meines 18F2550 
abtasten.

TMR1IF nennt sich dieses Bit laut Datenblatt und ist das Bit0 im PIR1 
Register.

2. Ich möchte dass bei Auslösen dieses Interrups der PORTB einen 
aufwärts zählt.

Ich habe leider zu wenig Erfahrung um zu wissen wie man das umsetzt.

Hat da jemand vielleicht ein übersichtliches Beispielprogramm oder kann 
mir irgendwie anders helfen?

Danke, Basti

[Holger W. (holgerw)]

schau dir dochmal dieses Beispiel im C18 Verzeichnis an:

...\Program Files\Microchip\mplabc18\example\Interrupt\main.c

Holger

[EGS_TI (Gast)]

MPLAB_C18_Users_Guide ist auch empfehlenswert!

Seite 58+59 geben bspw. folgendes Preis:

Chapter 5. Sample Application
The following sample application will flash LEDs connected to PORTB of a PIC18C452
microcontroller. The command line used to build this application is:
mcc18 -p 18c452 -I c:\mcc18\h leds.c
where c:\mcc18 is the directory in which the compiler is installed. This sample
application was designed for use with a PICDEM™ 2 demo board. This sample covers
the following items:
1. Interrupt handling (#pragma interruptlow, interrupt vectors, interrupt
service routines and context saving)
2. System header files
3. Processor-specific header files
4. #pragma sectiontype
5. Inline assembly

/* 1 */ #include <p18cxxx.h>
/* 2 */ #include <timers.h>
/* 3 */
/* 4 */ #define NUMBER_OF_LEDS 8
/* 5 */
/* 6 */ void timer_isr (void);
/* 7 */
/* 8 */ static unsigned char s_count = 0;
/* 9 */
/* 10 */ #pragma code low_vector=0x18
/* 11 */ void low_interrupt (void)
/* 12 */ {
/* 13 */ _asm GOTO timer_isr _endasm
/* 14 */ }
/* 15 */
/* 16 */ #pragma code
/* 17 */
/* 18 */ #pragma interruptlow timer_isr save=PROD
/* 19 */ void
/* 20 */ timer_isr (void)
/* 21 */ {
/* 22 */ static unsigned char led_display = 0;
/* 23 */

/* 24 */ INTCONbits.TMR0IF = 0;
/* 25 */
/* 26 */ s_count = s_count % (NUMBER_OF_LEDS + 1);
/* 27 */
/* 28 */ led_display = (1 << s_count++) - 1;
/* 29 */
/* 30 */ PORTB = led_display;
/* 31 */ }
/* 32 */
/* 33 */ void
/* 34 */ main (void)
/* 35 */ {
/* 36 */ TRISB = 0;
/* 37 */ PORTB = 0;
/* 38 */
/* 39 */ OpenTimer0 (TIMER_INT_ON & T0_SOURCE_INT & T0_16BIT);
/* 40 */ INTCONbits.GIE = 1;
/* 41 */
/* 42 */ while (1)
/* 43 */ {
/* 44 */ }
/* 45 */ }

Line 1: This line includes the generic processor header file. The correct processor is
selected via the -p command-line option. (See Section 2.5.1 “System Header
Files” and Section 2.10 “Processor-specific Header Files”)
Line 10: For PIC18 devices, the low interrupt vector is found at 000000018h. This line of
code changes the default code section to the absolute code section named
low_vector located at address 0x18. (See Section 2.9.1 “#pragma
sectiontype” and Section 2.9.2.3 “Interrupt Vectors”)
Line 13: This line contains inline assembly that will jump to the ISR. (See
Section 2.8.2 “Inline Assembly” and Section 2.9.2.3 “Interrupt Vectors”)
Line 16: This line returns the compiler to the default code section. (See Section 2.9.1
“#pragma sectiontype” and Table 2-6)
Line 18: This line specifies the function timer_isr as a low-priority interrupt service
routine. This is required in order for the compiler to generate a RETFIE instruction
instead of a RETURN instruction for the timer_isr function. In addition, it
ensures that PROD special function register will be saved. (Section 2.9.2
“#pragma interruptlow fname / #pragma interrupt fname” and
Section 2.9.2.4 “ISR Context Saving”)
Line 19-20: These lines define the timer_isr function. Notice that it does not take any
parameters, and does not return anything (as required by ISRs). (See
Section 2.9.2.2 “Interrupt Service Routines”)
Line 24: This line clears the TMR0 interrupt flag to stop the program from processing the
same interrupt multiple times. (See Section 2.10 “Processor-specific Header
Files”)
Line 30: This line demonstrates how to modify the special function register PORTB in C.
(See Section 2.10 “Processor-specific Header Files”)
Line 36-37: These lines initialize the special function registers TRISB and PORTB. (See
Section 2.10 “Processor-specific Header Files”)
Line 39: This line enables the TMR0 interrupt, setting up the timer as an internal 16-bit
clock.
Line 40: This line enables global interrupts. (See Section 2.10 “Processor-specific
Header Files”)

[Bastian B. (hobby-pic)]

Danke erstmal für die Hilfe.

Ich habe da nochmal etwas versucht.

PIC 18F2550, PORTB (Diodenleiste) soll aufwärts zählen.

Ergebnis: Bei PORTB tut sich nichts.
          RA3 wird aus unerfindlichen Gründen angesteuert

Es wäre echt super, wenn jemand nochmal über den übersichtlichen 
Quelltext schaut und etwas findet.

Danke, Basti

//Testschaltung

//Includes
#include <p18f2550.h>
#include "delays.h"

//Config

#pragma config CPUDIV = OSC1_PLL2
#pragma config FOSC=HS
#pragma config FCMEN = OFF, IESO = OFF
#pragma config PWRT = ON
#pragma config BOR = OFF
#pragma config WDT = OFF
#pragma config LVP = OFF

unsigned char j=0;
//defines
#define  OUT1     LATBbits.LATB0
#define  OUT2     LATBbits.LATB1
#define  OUT3      LATBbits.LATB2
#define  OUT4    LATBbits.LATB3
#define  OUT5    LATBbits.LATB4
#define  OUT6    LATBbits.LATB5
#define  OUT7    LATBbits.LATB6
#define  OUT8    LATBbits.LATB7

#define  IN1      PORTAbits.RA0
#define  IN2      PORTAbits.RA1
#define  IN3      PORTAbits.RA2
#define   OUT9    LATAbits.LATA3  //Dieser Ausgang wird aus irgendwelchen Gründen angesteuert
#define  OUT10    LATAbits.LATA4

void Test(void);              // Prototyp Serviceprogramm
#pragma code Timer=0x0008      // Interrupt to CPU Vector to Location 0008h (DB S.98)

void Timer (void)              // Hilfsfunktion        
{
 _asm GOTO Test _endasm       // Sprung nach Testfunktion
}

#pragma code                     // System Codebereich
#pragma interrupt Test        // Kennwort interrupt veranlasst


void Test (void)
{
    j=1; 
}

void main (void)
{
  
  T1CON= 0b10110001;              //Timer1 aktivieren
  TMR1H=0;                  //High Byte T1
  TMR1L=0;                  //Low Byte T1
  ADCON1 = 0x0F;                  //Alle Port Pins auf digital gesetzt
  TRISA=0xE7;                   //PORTA Ein- und Ausgänge 
  TRISB=0;                   //PORTB - Ausgang (Dioden)
  PORTB=0;                  //PORTB auf Null setzen
  PORTA=0;                  //PORTA ausschalten
  INTCON=  0b000000001;            //Interrupts zulassen
  PIE1=  0b000000001;            //bei Auslösen PIR1[bit0(TMR1IF)]=0 setzen

  while (1)
  {
    if (j==1)
    {
      PIR1=0;                //PIR-Register 0 setzten, damit TMR1IF=0
      PORTB++;              //PORTB aufzählen
      j=0;                //globale Hilfsvariable zurücksetzen
    }   
  }  
}

[schner (Gast)]

volatile!

[HolgerW (Gast)]

Also mal auf die schnelle was getestet, aber Achtung, ist PortC und ein 
anderer PIC, den hatte ich gerade passend auf dem Board.
Musst du also nochmal etwas anpaassen (Include/ Config)

Holger

//Testschaltung

#include    <p18F4420.h>            // for TRIS and PORT declarations
#include    <stdlib.h>

#pragma     config OSC  = HSPLL     // PLL ein

#pragma     config LVP  = OFF
#pragma     config MCLRE= OFF       // kein Reseteingang

unsigned char j=0;
unsigned char i=0;

//defines

void InterruptHandlerHigh(void);
void InterruptHandlerLow(void);
//----------------------------------------------------------------------------
// High priority interrupt vector (legacy interrupt)
#pragma code InterruptVectorHigh = 0x08
void
InterruptVectorHigh (void)
{
  _asm goto InterruptHandlerHigh  _endasm
}
// Low priority interrupt vector
#pragma code InterruptVectorLow = 0x18
void
InterruptVectorLow (void)
{
  _asm  goto InterruptHandlerHigh  _endasm
}
//----------------------------------------------------------------------------
// High priority interrupt routine (legacy interrupt)

#pragma code
#pragma interrupt InterruptHandlerHigh

void InterruptHandlerHigh ()
{
   PIR1bits.TMR1IF=0;                  // IRQ Flag zurücksetzen
   j=1;
   
}
                

void main (void)
{   
  TMR1H=0;                  //High Byte T1
  TMR1L=0;                  //Low Byte T1
   
  TRISC=0;
  
  ADCON1= 0xff;       // Configure A/D or digital inputs
  CMCON = 0x07;       // Configure comparators for digital input
  
  T1CONbits.TMR1ON = 1;   // Timer 1 on
  PIE1bits.TMR1IE=1;      // IRQ enable
  INTCONbits.PEIE = 1;    // periphäre Interrups erlauben
  INTCONbits.GIE = 1;     // Interrupts generell erlauben
  
  while (1)
  {      
    if (j==1)
    { 
      i++;     
      PORTC=i;              //PORTB aufzählen      
      j=0;                //globale Hilfsvariable zurücksetzen
    }   
  }  
}

[Bastian B. (hobby-pic)]

Oh Mann. Manchmal steht auch einfach mal ne "0" zuviel im Raum herum :-)

Besten Dank Holger. Dein Programm hat sehr geholfen.

Hier mein fertiges Programm für Menschen mit gleichem Problem

//Testschaltung

//Includes
#include <p18f2550.h>
#include "delays.h"

//Config

#pragma config CPUDIV = OSC1_PLL2
#pragma config FOSC=HS
#pragma config FCMEN = OFF, IESO = OFF
#pragma config PWRT = ON
#pragma config BOR = OFF
#pragma config WDT = OFF
#pragma config LVP = OFF

unsigned char j=0, i=0;


//defines


void Test(void);              // Prototyp Serviceprogramm

//Interrupts

#pragma code Timer=0x0008      // Interrupt to CPU Vector to Location 0008h (DB S.98)
void High (void)              // Hilfsfunktion        
{
 _asm goto Test _endasm       // Sprung nach Testfunktion
}

#pragma code Low = 0x18
void Low (void)
{
  _asm  goto Test  _endasm
}

//Interrupt-Routine

#pragma code                     // System Codebereich
#pragma interrupt Test        // Kennwort interrupt veranlasst

void Test ()
{
    PIR1bits.TMR1IF=0;
  j=1; 
}

void main (void)
{
  

  TMR1H=0;                  //High Byte T1
  TMR1L=0;                  //Low Byte T1
  ADCON1 = 0x0F;                  //Alle Port Pins auf digital gesetzt
  TRISA=0xE7;                   //PORTA Ein- und Ausgänge
  CMCON = 0x07;                //Komparatoreingänge deaktivieren
  TRISB=0;                   //PORTB - Ausgang (Dioden)
  PORTB=0;                  //PORTB auf Null setzen
  PORTA=0;                  //PORTA ausschalten
  T1CON=  0b10110001;              //Timer1 aktivieren (16bit)
  INTCON=  0b11000000;              //Interrupts zulassen
  PIE1=  0b00000001;              //bei Auslösen PIR1[bit0(TMR1IF)]=0 setzen


  while (1)
  {
    if (j==1)
    {
      i++;
      PORTB=i;              //PORTB aufzählen
      j=0;                //globale Hilfsvariable zurücksetzen
    }   
  }  
}

[Holger W. (Gast)]

statt PORTB sollte man besser LATB verwenden, das ist mir untergegangen.
Ich würde dir raten von Anfang an die Bezeichnung der Bits zu verwenden 
sonst musst du immer wieder nachsehen wie die Bedeutung war:

PIE1=  0b00000001;

Wenn du mehrere Interupts hast musst du natürlich auch noch abfragen 
welder aufgetreten ist, also

if (PIR1bits.TMR1IF=1) ....

bzw. auch noch mit dem Enable Bit verknüpfen

 if ((PIR1bits.TMR1IF=1) & (PIE1bits.TMR1IE=1) ...

[Bastian B. (hobby-pic)]

alles klar. werde ich machen.

Danke nochmal