[AVR] Probleme mit CTC Mode für BCM (OCR0A = 128 -> LED fast aus)

[Daniel (Gast)]

Hallo,

ich versuche gerade, LEDs per BCM (Binary Code Modulation) anzusteuern. 
Das klappt soweit auch, allerdings habe ich hier einen komischen Effekt, 
den ich mir nicht erklären kann.

Für die BCM nutze ich den Timer0 im CTC-Modus, als Prescaler habe ich 64 
eingestellt. Das Problem ist, dass bei diesem Prescaler-Wert die LEDs 
für den Wert OCR0A = 128 fast aus sind. Im Prinzip verhält sich der 
Timer so, als wäre er nur 7 Bit breit, d.h. OCR0A = 128 ~ 1. Ändere ich 
den Prescaler nun auf 8, so erhalte ich bei OCR0A = 128 die gewünschte 
Helligkeit, dafür flackern die LEDs aber, da nun die ISR viel zu häufig 
feuert und das Fading nicht hinterherkommt. Im Prinzip kann ich auch mit 
Werten von 0 bis 127 gut leben, ich würde aber gerne wissen, woher 
dieses Verhalten rührt. Kann mir da jemand hilfreich in die Seite 
treten? Mein Programm, wie es aktuell zum testen aussieht ist angehängt. 
Dort ist der Teil zum Faden aktuell auskommentiert und es werden nur 
fixe Helligkeitswerte verwendet, wobei für die Werte 128 die LED nur 
schwach glimmt.

Viele Grüße,
Daniel

/*
 * BCMTest.c
 *
 * Created: 18.12.2012 21:16:27
 *  Author: Commander
 */ 


#define F_CPU 8000000UL
#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>

// Zeitslots
volatile uint8_t gTime[8] = {1,2,4,8,16,32,64,128};
// BCM-Muster für jeden Zeitslot
volatile uint8_t gBcm[8];
// Helligkeit der LEDs
//volatile uint8_t gBrightness[8] = {0,8,16,24,32,40,48,56};
  
// LEDs 0 und 1 sind AUS, die übrigen leuchten wie gewünscht!
volatile uint8_t gBrightness[8] = {128,128,16,24,32,40,48,56};
  
// Aktueller Zeitslot
volatile uint8_t gPos = 0;

// Anzahl ISR-Aufrufe (für langsames Fading)
volatile uint8_t gTick = 0;

// Umwandeln der Helligkeiten in BCM-Muster
void encodeBrightness(uint8_t brightness[]) {
  uint8_t portbits = 0;
  
  // Iteriere über alle Bits
  for(uint8_t bitPos = 0; bitPos < 8; bitPos++) {
    portbits = 0;
    
    // Iteriere über alle die Helligkeiten aller LEDs
    for(uint8_t ledPos = 0; ledPos < 8; ledPos++) {
      // Falls Bit gesetzt
      if(gBrightness[ledPos] & (1 << bitPos)) {
        // Setze entsprechendes Bit im BCM-Muster
        portbits |= (1 << ledPos);
      }
    }
    
    // Weise BCM-Muster dem Zeitslot zu
    gBcm[bitPos] = portbits;
  }
}

// Initialisiere SPI
void initSPI() {
  // Ansteuerung erfolgt über PA3 bis PA5
  DDRA |= ((1 << DDA5) | (1 << DDA4) | (1 << DDA3));
  
  USICR = (1<<USIWM0)|(1<<USICS1)|(1<<USICLK)|(1<<USITC);
}

// Initialisiere Timer0, CTC Modus, Prescaler 64, Compare Match Interrupt enable
void initTimer() {
  TCCR0A = (1 << WGM01);
  TCCR0B |= (1 << CS01)|(1 << CS00);
  OCR0A = 1;
  TIMSK0 |= (1 << OCIE0A);
}

// Sende Wert per SPI an HC595
void sendSPI(uint8_t value) {
  PORTA |= (1 << PA3);
  USIDR = value;
  USISR |= (1 << USIOIF);
  
  while(!(USISR & (1 << USIOIF))) {
    USICR |= (1 << USITC);
    USICR |= (1 << USITC);
  }
  PORTA &= ~(1 << PA3);
}

int main(void)
{
  // Starte mit Zeitslot 2^0
  gPos = 0;
  
  // Initialisiere SPI
  initSPI();
  // Initialisiere Timer
  initTimer();
  // Interrupt enables
  sei();
  
  encodeBrightness(gBrightness);
    while(1)
    {  
    // Fade langsam hoch
    /*while(gTick < 16) {}
    gTick = 0;
    
    for(uint8_t i = 0; i < 8; i++) {
      gBrightness[i]++;
    }
    
    encodeBrightness(gBrightness);  */
    }
}

ISR(TIM0_COMPA_vect) {
  // Übertrage aktuelles BCM-Muster an HC595
  sendSPI(gBcm[gPos]);
  // Setze Länge des nächsten Zeitslots
  OCR0A = gTime[gPos];
  // Reset TCNT0
  TCNT0 = 0;
  
  // Gehe zum nächsten Zeitslot
  gPos++;
  gPos &= 7;
  
  // Erhöhe Ticks wenn ein Durchlauf beendet wurde
  /*if(gPos == 0) {
    gTick += 1;
  }*/
}

[Markus M. (adrock)]

Hi,

also auf die Schnelle finde ich keinen Fehler.

Hast Du das Programm mal im Debugger/Simulator laufen lassen? Wie ist 
das Verhalten nach dem Setzen der Ausgabedaten für Bit 7 (128)? 
Eigentlich sollte da ja gaaanz lange nichts passieren außer dem 
while(1).

Ciao...
Markus

[Daniel (Gast)]

Hallo,

sorry für die späte Antwort, aber Weihnachten und so ;) Ich habe das 
Ganze mal im Simulator laufen lassen, das verhalten ist dort eigentlich 
wie gewünscht. Beim letzten Zeitslot (128) wird der Wert 3 an den HC595 
übertragen und anschließend OCR0A auf 128 gesetzt. Demnach müssten also 
für 8192 Takte (128 * 64 Prescaler) die ersten beiden LEDs leuchten. Bei 
den übrigen Zeitslots sind die ersten beiden Bits immer 0, d.h. sie 
müssten für 8192 Takte aus sein. Macht für mich ein Tastverhältnis von 
1/2, so dass im Mittel 3mA durch die LEDs (low power) fließen müssten. 
Das entspricht aber nicht dem minimalen Glimmen, dass ich in der realen 
Schaltung sehe :-/

Gruß,
Daniel

[Daniel (Gast)]

Ok... ich habe jetzt gerade noch etwas Trial and Error gemacht. 
Auskommentieren von

TCNT0 = 0;

Führt zum gewünschten Ergebnis. Kann mir jemand erklären, woran das 
liegt? In dem moment, in dem ich TCNT0 auf 0 setze habe ich ja den neuen 
Wert für OCR0A schon geschrieben, d.h. es kann doch eigentlich kein 
zweiter, unerwarteter Interrupt auftreten, oder?

Viele Grüße,
Daniel