Silicon Labs C8051F310 LED Blinken lassen

[Silicon (Gast)]

Hallo,

ich möchte mit dem oben genannten Controller eine LED unter Nutzung 
eines Timers im Sekundentakt blinken lassen:

//-----------------------------------------------------------------------------
// Includes
//-----------------------------------------------------------------------------
#include <c8051f310.h>                    // SFR declarations

unsigned long ms;

//-----------------------------------------------------------------------------
// 16-bit SFR Definitions for 'F33x
//-----------------------------------------------------------------------------

sfr16 TMR2RL   = 0xca;                    // Timer2 reload value
sfr16 TMR2     = 0xcc;                    // Timer2 counter
//-----------------------------------------------------------------------------
// Global CONSTANTS
//-----------------------------------------------------------------------------

#define SYSCLK       24500000         // SYSCLK frequency in Hz

sbit LED = P0^3;                          // LED='1' means ON

//-----------------------------------------------------------------------------
// Function PROTOTYPES
//-----------------------------------------------------------------------------
void SYSCLK_Init (void);
void PORT_Init (void);
void Timer2_Init (void);
void Timer2_ISR (void);
void ADC0_Init (void);
void ADC0_ISR (void);

//-----------------------------------------------------------------------------
// MAIN Routine
//-----------------------------------------------------------------------------
void main (void) {

  unsigned long wait;

   ms=0;
   wait=0;

   // disable watchdog timer
   PCA0MD &= ~0x40;                       // WDTE = 0 (clear watchdog timer
                                          // enable)

   SYSCLK_Init ();                        // Initialize system clock to
                                          // 24.5MHz
   PORT_Init ();                          // Initialize crossbar and GPIO
   Timer2_Init ();                 // Init Timer2 

   EA = 1;                                // enable global interrupts
   while (1) {                            // spin forever
    if( (ms-wait) < 1000 ) {
      LED=~LED;
      wait=ms;
    }
    
   }
}

//-----------------------------------------------------------------------------
// SYSCLK_Init
//-----------------------------------------------------------------------------
//
// This routine initializes the system clock to use the internal 24.5MHz
// oscillator as its clock source.  Also enables missing clock detector reset.
//
void SYSCLK_Init (void)
{

   OSCICN = 0xC3;                         // configure internal oscillator for
                                         
   RSTSRC = 0x04;                         // enable missing clock detector
}

//-----------------------------------------------------------------------------
// PORT_Init
//-----------------------------------------------------------------------------
//
// Configure the Crossbar and GPIO ports.
// P0.3 - LED (push-pull)
//
void PORT_Init (void)
{

   XBR0     = 0x00;                       // no digital peripherals selected
   XBR1     = 0x40;                       // Enable crossbar and weak pull-ups
   P0MDOUT |= 0x08;                       // enable LED as a push-pull output
}

//-----------------------------------------------------------------------------
// Timer2_Init
//-----------------------------------------------------------------------------
//
// Configure Timer2 to 16-bit auto-reload and generate an interrupt
//
void Timer2_Init (void)
{
   TMR2CN  = 0x00;                        // Stop Timer2; Clear TF2;
                                          // use SYSCLK/12 as timebase
   CKCON  &= ~0x20;                       // Timer2 clocked based on T2XCLK;

   TMR2RL  = -SYSCLK/12/1000;              // Init reload values
   TMR2    = 0xffff;                      // set to reload immediately
   ET2     = 1;                           // enable Timer2 interrupts
   TR2     = 1;                           // start Timer2
}


//-----------------------------------------------------------------------------
// Interrupt Service Routines
//-----------------------------------------------------------------------------

//-----------------------------------------------------------------------------
// Timer2_ISR
//-----------------------------------------------------------------------------
// This routine changes the state of the LED whenever Timer2 overflows.
//
void Timer2_ISR (void) interrupt 5
{
   TF2H = 0;                              // clear Timer2 interrupt flag
   ms++;
}

Die LED verhält sich ganz komisch. Sie ist die meiste Zeit an und geht 
ab und zu aus. Sieht jemand den Fehler?

Viele Grüße

[Silicon (Gast)]

Ok ich habe es gerade selber gefunden:

if( (ms-wait) > 1000 ) {

muss es heißen. Sind die Datentypen ansonsten ausreichend groß?

[Jim M. (turboj)]

if( (ms-wait) < 1000 ) {

Da würde ich ein

if( (ms-wait) >= 1000 ) {

draus machen.

[Wilhelm F. (Gast)]

Silicon schrieb:

> Sind die Datentypen ansonsten ausreichend groß?

Das sieht doch soweit gut aus.

Größere Datentypen auf einem 8-Bitter, wie z.B. ein 
32-bit-Millisekundenzähler im Timer-Interrupt, erzeugen natürlich auch 
viel mehr Code bzw. Laufzeit.

Schau dir das Assembler-Listing an, dann weißt du, was ich meine.

[Jim M. (turboj)]

Der Zugriff auf ms ist nicht atomar. Das kann dann gar lustige Effekte 
im Zusammenspiel mit dem Interrupt geben.

[Wilhelm F. (Gast)]

Jim Meba schrieb:

> Das kann dann gar lustige Effekte
> im Zusammenspiel mit dem Interrupt geben.

Na ja, wenn in verschiedenen Programmteilen die selbe Variable verwendet 
wird. Dann muß man gegebenenfalls über die Bearbeitungsdauer einen 
Interrupt sperren.

Sorry, ich sah das jetzt bei näherem Hinsehen auch erst.

[Silicon (Gast)]

Jim Meba schrieb:
> Der Zugriff auf ms ist nicht atomar. Das kann dann gar lustige Effekte
> im Zusammenspiel mit dem Interrupt geben.

Was meinst du damit?

[Wilhelm F. (Gast)]

Silicon schrieb:

> Was meinst du damit?

Deine Variable wird im Hauptprogramm verwendet. Jetzt stell dir vor, 
genau mitten drin schlägt der Timer-Interrupt zu, und verändert 
seinerseits die Variable. Meinst du, da käme noch was manierliches bei 
raus, wenn die Variablenbearbeitung im Hauptprogramm dann weiter geführt 
wird?

[Silicon (Gast)]

Ok und volatile sollte ich die Variable wahrscheinlich auch noch 
deklarieren ist mir gerade eingefallen.

Also wenn ich drei Dateien habe:

funcctions.h
functions.c
main.c


Dann habe ich in:

functions.h:
extern volatile unsigned long ms;

functions.c:
volatile unsigned long ms;

und in der main.c greife ich dann darauf zu.

Nur wie genau gestalte ich den atomaren Zugriff? Ich kann ja nicht für 
die komplette Verzweigung den Interrupt deaktivieren.

[Wilhelm F. (Gast)]

Silicon schrieb:

> Nur wie genau gestalte ich den atomaren Zugriff?

Im Hauptprogramm hast du eine Anweisung in C-Code stehen, die die 
Millisekunden-Variable auswertet.

Jetzt könnte mitten in der Auswertung der Timer-Interrupt dazwischen 
schlagen, und diese Variable ändern.

Denn im Assemblercode hast du für die Bearbeitung der 
Millisekunden-Variable eine ganze Menge Assemblercode stehen, anders als 
die eine Zeile in C.

Also muß man folgendes machen: Im Main-Programm unmittelbar vor 
Bearbeitung der Variablen den Timer-Interrupt sperren, und ihn 
unmittelbar nach dem Befehl wieder frei geben.

[troll (Gast)]

atomar <-- klick

[Silicon (Gast)]

Ich bearbeite ms doch aber nicht im Hauptprogramm, sondern werte sie nur 
aus.

[Wilhelm F. (Gast)]

Silicon schrieb:
> Ich bearbeite ms doch aber nicht im Hauptprogramm, sondern werte sie nur
> aus.

Schau dir genau den Assemblercode an, den der Befehl

wait=ms;

macht.

Schlägt dort mitten in der Befehlsbearbeitung ein Timer-Interrupt 
herein, wird deine Variable ms geändert, und in wait steht nur Mist.

[Silicon (Gast)]

Ja aber beim Vergleichen wird ms ja auch ausgewertet. Muss ich das dann 
so schreiben:

  ET2 = 0;
  tmp=ms-wait;
  ET2 = 1;
    if( tmp >= 1000 ) {
      LED=~LED;
    //...
    // noch mehr code
    //...

    ET2 = 0;
      wait=ms;
    ET2 = 1;
    }

[Wilhelm F. (Gast)]

Silicon schrieb:
> Ja aber beim Vergleichen wird ms ja auch ausgewertet. Muss ich das dann
> so schreiben:
>
>

>   ET2 = 0;
>   tmp=ms-wait;
>   ET2 = 1;

>     ET2 = 0;
>       wait=ms;
>     ET2 = 1;
>     }

Das sieht schon besser aus. Interruptsperrung vor der 
Variablenauswertung, und Interruptfreigabe nach der Variablenauswertung.

[Silicon (Gast)]

Silicon schrieb:
> Dann habe ich in:
>
> functions.h:
> extern volatile unsigned long ms;
>
> functions.c:
> volatile unsigned long ms;
>
> und in der main.c greife ich dann darauf zu.

Ok danke! War das jetzt eigentlich auch richtig gedacht?

[Wilhelm F. (Gast)]

Silicon schrieb:

> Ok danke! War das jetzt eigentlich auch richtig gedacht?

Also, du mußt grundsätzlich Variablen davor schützen, falls sie auch an 
einer anderen Stelle, Interrupts, noch mal geändert werden.

Du hast dir immer noch nicht den Assemblercode angeschaut, oder? An 
jeder Stelle des Assemblercodes kann ein Interrupt statt finden, und das 
ist oft mitten in einem einzigen C-Befehl, der aus mehreren 
Assemblerbefehlen besteht.