PWM von Intel in C übersetzen für C8051F340

[Ilja F. (Gast)]

Hallo Leute ich versuche das PWM-Measuaring Assembler Code von Intel in 
C zu übersetzen, so dass es im Mikrocontroller C8051F340 laufend kann. 
Aber bis jetzt habe ich nicht geschaft, da ich kenne mich nicht zu viel 
in C und die Code sollen in C geschrieben werden. Kann jemand mir 
helfen? oder Typs geben?
ich bedanke mich schon

hier die Assembler-Code:

; RAM locations to store capture values
CAPTURE DATA 30H
PULSE WIDTH DATA 32H
FLAG BIT 20H.0
;
ORG 0000H
JMP PCA INIT
ORG 0033H
JMP PCA INTERRUPT
;
PCA INIT: ; Initialize PCA timer
MOV CMOD, #00H ; Input to timer 4 1/12 X Fosc
MOV CH, #00H
MOV CL, #00H
;
; Initialize Module 0 in capture mode
MOV CCAPM0, #21H ; Capture positive edge first
; for measuring pulse width
;
SETB EC ; Enable PCA interrupt
SETB EA
SETB CR ; Turn PCA timer on
CLR FLAG ; clear test flag
;
; ********************************************************************************
; Main program goes here
; ********************************************************************************
;
; This example assumes Module 0 is the only PCA module
; being used. If other modules are used, software must
; check which module's event caused the interrupt.
;
PCA INTERRUPT:
CLR CCF0 ; Clear Module 0's event flag
JB FLAG, SECOND CAPTURE ; Check if this is the first
; capture or second
FIRST CAPTURE:
MOV CAPTURE, CCAP0L ; Save 16-bit capture value
MOV CAPTURE01, CCAP0H ; in RAM
MOV CCAPM0, #11H ; Change module to now capture
; falling edges
SETB FLAG ; Signify 1st capture complete
RETI
;
SECOND CAPTURE:
PUSH ACC
PUSH PSW
CLR C
MOV A, CCAP0L ; 16-bit subtract
SUBB A, CAPTURE
MOV PULSE WIDTH, A ; 16-bit result stored in
MOV A, CCAP0H ; two 8-bit RAM locations
SUBB A, CAPTURE01
MOV PULSE WIDTH01, A
;
MOV CCAPM0, #21H ; OptionalÐneeded if user wants to
CLR FLAG ; measure next pulse width
POP PSW
POP ACC
RETI

Ilja

[Bernhard S. (b_spitzer)]

Da ist doch kaum was drin... An Adresse 0x33 die ISR für die 
PCA-Einheit, das war's auch schon. Insgesamt ist der gegebene Code aber 
noch recht unvollständig.

In C in etwa so:

#include <controller-spezifisches.h>
bit Flag;
unsigned char Capture;     // oder braucht es hier einen INT??
unsigned char Pulse_Width; // alles als Globale Variablen deklariert....

void main (void)
{
// PCA INIT: ; Initialize PCA timer
 CMOD = 0x00; // Input to timer 4 1/12 X Fosc
 CH = 0x00;
 CL = 0x00;

// Initialize Module 0 in capture mode
 CCAPM0 = 0x21; // Capture positive edge first
                // for measuring pulse width

 EC = 1;        // Enable PCA interrupt
 EA = 1;
 CR = 1;        // Turn PCA timer on
 FLAG = 0;      // clear test flag

 while (1){}    // warte auf Interrupts
 // die Hauptschleife fehlt aber in dem obigen Ausschnitt!!

}

void ISR_PCA(void) interrupt 6 // nachschauen, wie das Dein Compiler haben will!!
{
  CCF0 =0;  // Clear Module 0's event flag
  if (FLAG==0) // Check if this is the first
  {            // capture or second
   // FIRST CAPTURE:
   CAPTURE = CCAP0L;   // Save 16-bit capture value
   CAPTURE01 = CCAP0H; // in RAM  ------ die wurde gar nicht deklariert!!
   CCAPM0 = 0x11;      // Change module to now capture
                       // falling edges
   FLAG = 1;           // Signify 1st capture complete 
   }
   else // SECOND CAPTURE:
   {
     Pulse_Width = CAPTURE - CCAP0L; // oder so ähnlich...
     Pulse_Width01 = CCAP0H - CAPTURE; // Pulse_Width01 ist nicht definiert!!
     CCAPM0 = 0x21;     // OptionalÐneeded if user wants to
     FLAG = 0;          // measure next pulse width
   }
}

Insgesamt ist die 16-Bit Subtraktion in C natürlich einfacher machbar. 
Schau, was in der Anwendung eigentlich wirklich gemacht werden soll! Der 
Rest ist dann Hausaufgabe.

[Ilja F. (Gast)]

Hallo Bernhard;
Zuerst Vielen Dank. Mein Mikrocontroller ist der C8051F340 von Silab.
Es sollte eigentlich nur die Pulse-Breite des Signal gemessen werden, 
also zwischen eine steigende und fallende Flanke. Ich werde sehr 
denkbar, wenn du Ideen hast um die Code zu vervollständigen. Ich arbeite 
auch daran.

Vielen Dank

[Guest (Gast)]

Offensichtlich sind Pulse Width und Capture 16bit unsigned int. Deswegen 
wir zunächst das C(arry) Flag ge-cleart und dann 2 subtraktionen 
gemacht.
Also vereinfacht sich der Interrupt zu

void ISR_PCA(void) interrupt 6 // nachschauen, wie das Dein Compiler haben will!!
{
  CCF0 =0;  // Clear Module 0's event flag
  if (FLAG==0) // Check if this is the first
  {            // capture or second
   // FIRST CAPTURE:
   CAPTURE = ((uint16_t)CCAP0H<<8) | CCAP0L;   // Save 16-bit capture value
   CCAPM0 = 0x11;      // Change module to now capture
                       // falling edges
   FLAG = 1;           // Signify 1st capture complete 
   }
   else // SECOND CAPTURE:
   {
     Pulse_Width = CAPTURE - ((uint16_t)CCAP0H<<8) | CCAP0L;
     CCAPM0 = 0x21;     // OptionalÐneeded if user wants to
     FLAG = 0;          // measure next pulse width
   }
}

[Ilja F. (Gast)]

Hallo Leute!!!
 Vielen Dank für eure Hilfe. Ich habe die Code wie folgt angepasst:

#include <c8051f340.h>
bit FLAG;
unsigned char CAPTURE;  
unsigned char CAPTURE01;   // oder braucht es hier einen INT??
unsigned char Pulse_Width;
unsigned char Pulse_Width01;
             // alles als Globale Variablen deklariert....


void port_init (void);
void pca_init (void);

 void main (void)
{

   port_init ();             //
   pca_init ();     
   PCA0MD &= ~0x40;                // Disable Watchdog Timer
   OSCICN |= 0x03;                 //             //
   EA=1;

// PCA INIT: ; Initialize PCA timer
 PCA0MD = 0x00; // Input to timer 4 1/12 X Fosc
 TH0 = 0x00;
 TL0 = 0x00;

 IE = 1;          // Enable PCA interrupt
 EA = 1;
 CR = 1;          // Turn PCA timer on
 

 while (1){ }            // warte auf Interrupts
           

}

void pca_init (void)
{
    PCA0CN    = 0x40;        //
    PCA0CPM0  = 0x21;        //Capture positive edge first   for measuring pulse width
  PCA0MD    = 0x00;          //
  EIE1= 0x10;            //
    FLAG=0;
}

void port_init (void)
{  P0SKIP = 0xff;              //
   P1SKIP = 0x03;             //
   XBR1   = 0x42;          //
   P1MDOUT |= 0x04;           //
}


void Int_0_ISR(void) interrupt 0
{
  CF =0;      // Clear Module 0's event flag
  if (FLAG==0) // Check if this is the first
  {      
      // capture or second
   // FIRST CAPTURE:
   CAPTURE = PCA0CPL0;       // Save 16-bit capture value
   CAPTURE01 = PCA0CPH0; 
   PCA0CPM0 = 0x11;          // Change module to now capture
                             // falling edges
   FLAG = 1;                 // Signify 1st capture complete 
   }
   else // SECOND CAPTURE:
   {
     Pulse_Width = CAPTURE - PCA0CPL0;
     Pulse_Width01 = PCA0CPH0 - CAPTURE; 
     PCA0CPM0 = 0x21;     // OptionalÐneeded if user wants to
     FLAG = 0;          // measure next pulse width
   }
}

Aber es funktioniert nicht!! kann Jemand mal schauen und mir helfen zu 
korrigieren oder anzupassen?
Vielen Dank.
Grüße

[Bernhard S. (b_spitzer)]

Ilja flecher schrieb:

  IE = 1;          // Enable PCA Interrupt
 void Int_0_ISR(void) interrupt 0

> Aber es funktioniert nicht!! kann Jemand mal schauen und mir helfen zu
Bei meinem AT89C5131 heisst das Freigabebit für den PCA-Interrupt EC. 
Die Zeile müsste also EC = 1; heissen.
Die ISR ist für den externen Interrupt 0, der müsste mit EX0=1; 
freigegeben sein. Eine ISR für den PCA (Interrupt 6) fehlt ganz.

[Bernhard S. (b_spitzer)]

Nachtrag:
IE = 1; kann je nach Inhalt der Include-Datei auch den externen 
Interrupt 0 freischalten. Bei neueren Derivaten heißen die 
Freigaberegister aber meist IEN0 und IEN1.
Mit IE = 1 setzt Du das gesamte Freigaberegister auf 0b00000001, danach 
EA auf 1 und es steht 0b10000001 drin. Also Ext0 ist frei und globale 
Freigabe.

[Lothar M. (Firma: Titel) (lkmiller) (Moderator)]

Ilja flecher schrieb:
> Aber es funktioniert nicht!!
Bitte hilfreiche, deutliche und klare Angaben:
WAS funktioniert nicht?
WIE hast du das festgestellt?
> while (1){ }
WAS erwartest du von diesem Code?