STM32 TIM4 Interrupt zur Ansteuerung LEDs ähnlich PL9834

Hallo,

ich arbeite mich in den STM32 mit dem STM32F4Discovery (407) ein (Coocox 
IDE 1.7.8).
Nun habe ich ein paar von den LEDs (siehe Anhang, voltage step down 
programmeable).
Da die mit 5V laufen, hab ich noch einen 74HCT125 zwischen geschaltet 
(siehe Anhang).

Da mein Interrupt-Ansatz zuerst nicht funktionierte, habe ich das ganze 
sehr banal angegangen.
Bitte nicht schlagen:

// STRIPE_PORT=GPIOD
// STRIPE_H = GPIO_Pin_0, H da im Ruhezustand H
// STRIPE_L = GPIO_PIN_1, L da im Ruhezustand L
// SHORT_DELAY = 35
void writeHalf(uint8_t intensity) {
  int i;
  uint32_t j;
  for(i=0;i<(8-intensity);i++) {
    GPIO_WriteBit(STRIPE_PORT, STRIPE_H, Bit_RESET);
    for(j=0;j<SHORT_DELAY;j++) {} // 4µs... als Short delay noch 288 
war...
    GPIO_WriteBit(STRIPE_PORT, STRIPE_H, Bit_SET);
    for(j=0;j<SHORT_DELAY;j++) {} // 4µs...
  }
  for(i=0;i<intensity;i++) {
    GPIO_WriteBit(STRIPE_PORT, STRIPE_L, Bit_SET);
    for(j=0;j<SHORT_DELAY;j++) {} // 4µs...
    GPIO_WriteBit(STRIPE_PORT, STRIPE_L, Bit_RESET);
    for(j=0;j<SHORT_DELAY;j++) {} // 4µs...
  }
}

Das ganze für 5 Leds im Hauptprogramm je LED 3 mal aufgerufen, Werte 
zwischen 0 und 8.
Alles super soweit, bekomme die Farben die ich möchte.

Also wieder ran an die Interrupt-Routine:
// HSE_VALUE = (uint32_T)8000000; PLL_M = 8; SystemInit() wird als 
erstes in main ausgeführt.
void initTimerLEDStripe() {
  RCC_APB1PeriphClockCmd(RCC_APB1Periph_TIM4, ENABLE);
  TIM_TimeBaseInitTypeDef tim4Def;
  NVIC_InitTypeDef nvicDef4;
  tim4Def.TIM_ClockDivision = TIM_CKD_DIV1;
  tim4Def.TIM_CounterMode = TIM_CounterMode_Up;
  // approx 0.6µs, da APB1 mit Teiler 4 und Multiplikator 2 = 84MHz
  tim4Def.TIM_Period = 4;
  tim4Def.TIM_Prescaler = 9;
  TIM_TimeBaseInit(TIM4, &tim4Def);

  TIM_ITConfig(TIM4, TIM_IT_Update, ENABLE);
  nvicDef4.NVIC_IRQChannel = TIM4_IRQn;
  nvicDef4.NVIC_IRQChannelCmd = ENABLE;
  nvicDef4.NVIC_IRQChannelPreemptionPriority = 0x0F;
  nvicDef4.NVIC_IRQChannelSubPriority = 0x0F;
  NVIC_Init(&nvicDef4);
  // Do nothing for the time beeing...

  TIM_Cmd(TIM4, DISABLE);
}

Hier die Interrupt-Routine und variablen. Ich habe den Ansatz gewählt, 
jede Zustandsänderung in einem Array zu hinterlegen.

struct ledStripeValue {
  BitAction action;
  uint16_t pin;
  GPIO_TypeDef* port;
};

volatile struct ledStripeValue ledValues[5*3*8*2];
volatile uint32_t counter = 0;

void TIM4_IRQHandler(void) {
  TIM_ClearITPendingBit(TIM4, TIM_IT_Update);
  if(counter < sizeof(ledValues)) {
    GPIO_WriteBit(ledValues[counter].port, ledValues[counter].pin, 
ledValues[counter].action);
    counter++;
  } else {
    counter++;
    if(counter > 26000) {
                       // Latch time 3ms done...
      TIM_Cmd(TIM4, DISABLE);
      counter = 0;
    }
  }
}

Hauptprogramm:

int main(void)
{
  SystemInit();
  init(); // TIM2 and TIM3 with 1ms interrupt, TIM2 counts uint32_t 
millisCounter up
  initTimer();

  GPIO_WriteBit(STRIPE_PORT, STRIPE_H, Bit_SET);
  GPIO_WriteBit(STRIPE_PORT, STRIPE_L, Bit_RESET);

  initTimerLEDStripe();
  initLEDStripe();

  while(1) {
    setOneLedRed(); // like initLEDStripe, only setting appripriate bits 
to H
    simpleDelay(1000); // wait a second
                initLEDStripe(); // Clear all LEDs
    simpleDelay(1000);
  }
}

Es passiert nix, rein gar nix. Mit dem Debugger - dem ich hierbei nicht 
wirklich traue - sieht es so aus, als wenn das Hauptprogramm priorität 
gegenüber der Interrupt-Routine hat.
Anscheinend zählt er nicht hoch. Er steht beim debuggen in der 
simpleDelay, der Brechpunkt in der Interrupt wird nur selten aufgerufen.

Ach ja, simpleDelay:
void simpleDelay(uint32_t ms) {
  uint32_t current = millisCounter;
  while( (millisCounter-current) <= ms) {
  }
}

Wenn ich so nachrechne, dann sollte es mit der Einfachmethode nicht 
gehen, For-Schleife wird 35 mal durchlaufen. Bei 168MHz wären das 0,2µs. 
Die LEDs brauchen aber angeblich 1µs.
Was mache ich falsch, wo ist mein Denkfehler? Werde daraus nicht schlau.

Besten Dank im voraus für jede Hilfe.

Jörg