MSP430G2553 PWM LED-Dimmer verhalten

[Mathias Z. (matziz198)]

Hallo schon wieder,

ich versuch einen, per Drehgeber einstellbaren, PWM LED-Dimmer zu 
basteln. Drehgeber funktioniert. Die PWM läuft, lässt sich jedoch nicht 
einstellen. Der Initialwert von CCR1 liegt beim Starten an, die LED 
leuchtet leicht. Wenn ich am Encoder drehe geht die LED für ca. 1s auf 
volle Helligkeit und danach bleibt sie aus bis ich wieder drehe.
Ich habe schon etliche Varianten versucht das CCR1 während der Laufzeit 
zu ändern. Ähnliches Verhalten jedoch kein dimmen.

Ich seh den Fehler nicht. Hier der Code:

#include "io430.h"
#include "intrinsics.h"


typedef signed   int    int8;
typedef unsigned int    uint8;
typedef signed   short  int16;
typedef unsigned short  uint16;
typedef signed   long   int32;
typedef unsigned long   uint32;


#define PHASE_A   (P1IN & BIT4)         // P1.4 als Eingang Encoder
#define PHASE_B   (P1IN & BIT5)         // P1.5 als Eingang Encoder

volatile int8 enc_delta;                // -128 ... 127
static int8 last;

const uint16 pwm_table[64] = {
     0,    0,    2,    4,    8,   14,   21,   30,   41,   54, 
    69,   86,  106,  127,  151,  178,  206,  238,  271,  308, 
   347,  388,  433,  480,  530,  583,  638,  697,  758,  823, 
   890,  961, 1035, 1111, 1191, 1274, 1361, 1450, 1543, 1639, 
  1739, 1841, 1947, 2057, 2170, 2286, 2406, 2530, 2657, 2787, 
  2921, 3059, 3200, 3345, 3494, 3646, 3802, 3962, 4125, 4293, 
  4464, 4639, 4817, 5000
};

static uint8 pwm_index = 7;


void encode_init( void )
{
  int8 new;
 
  new = 0;
  if( PHASE_A )
    new = 3;
  if( PHASE_B )
    new ^= 1;                           // convert gray to binary
  last = new;                           // power on state
  enc_delta = 0;
}

int8 encode_read1( void )               // read single step encoders
{
  int8 val;
 
  __disable_interrupt();
  val = enc_delta;
  enc_delta = 0;
  __enable_interrupt();
  return val;                           // counts since last call
}


// Watchdog Timer interrupt service routine used for Encoder
#pragma vector=WDT_VECTOR
__interrupt void watchdog_timer(void)
{
  int8 new, diff;
 
  new = 0;
  if( PHASE_A )
    new = 3;
  if( PHASE_B )
    new ^= 1;                           // convert gray to binary
  diff = last - new;                    // difference last - new
  if( diff & 1 ){                       // bit 0 = value (1)
    last = new;                         // store new as next last
    enc_delta += (diff & 2) - 1;        // bit 1 = direction (+/-)
  }
}


void main( void )
{
  WDTCTL = WDT_MDLY_0_5;                // Set Watchdog Timer interval to ~0.5ms
  IE1 |= WDTIE;                         // Enable WDT interrupt
    
  BCSCTL1 = CALBC1_1MHZ;                // 1 MHz clock
  DCOCTL = CALDCO_1MHZ;
    
  P1SEL = 0x00;                         // Port 1 als GPIO nutzen
  P1REN |= (BIT4 + BIT5);               // P1.4 und P1.5 Resistor enabled
  P1OUT |= (BIT4 + BIT5);               // P1.4 und P1.5 Pullup enabled
  P1DIR |= BIT6;                        // P1.6 output (green LED)
  P1SEL |= BIT6;                        // P1.6 = TA0.1 (timer A's output)
  
  TACTL = TASSEL_2 + MC_1;              // Source Timer A from SMCLK (TASSEL_2), up mode (MC_1)
                                        // Up mode counts up to TACCR0
  TACCTL1 = OUTMOD_7;                   // OUTMOD_7 = CCR1 reset/set output when the timer counts to TACCR1
  TACCR0 = 5000;                        // PWM period = 1 MHz / 5000 = ~200 Hz
  TACCR1 = pwm_table[7];                // Initial CCR1 (= brightness)
    
  int8 val = 0;
 
  encode_init();
  __enable_interrupt();
 
  for(;;)
  {
    val += encode_read1();
    
    if(val > 0)                         // Encoder linksdrehung
    {                                   // grün dunkler (LED1)
      if (pwm_index > 1)
      {
        pwm_index--;
        TACCR1 = pwm_table[pwm_index];
      }
      else {TACCR1 = pwm_table[0];}
      val--;
    }                                 
        
    if(val < 0)                         // Encoder rechtsdrehung
    {                                   // grün heller (LED1)
      if (pwm_index < 62)
      {
        pwm_index++;
        TACCR1 = pwm_table[pwm_index];
      }
      else {TACCR1 = pwm_table[63];}
      val--;
    }                   
  }
}

[Mathias Z. (matziz198)]

Kann es sein das dass TACCR1 nur in einem Interrupt veränderbar ist? 
Oder muss man den Timer während der Änderung anhalten? Wobei ich auch 
schon Beispiele gesehen habe die auf dem selben Prinzip, welches ich 
benutze, basieren.

[Peter D. (pdiener)]

    if(val < 0)                         // Encoder rechtsdrehung
    {                                   // grün heller (LED1)
      if (pwm_index < 62)
      {
        pwm_index++;
        TACCR1 = pwm_table[pwm_index];
      }
      else {TACCR1 = pwm_table[63];}
      val--;  <-------------------------------- Das sollte doch hochzählen
    }

Ich denke, der Fehler liegt darin, dass val noch weiter runter zählt, 
wenn es negativ ist. Siehe oben.

Grüße,

Peter

[Mathias Z. (matziz198)]

Ja, das wars. Der Wald und die Bäume :)

Danke!!!