Soft PWM viel zu langsam

[Thomas (Gast)]

Hallo Ihr,

ich versuche seit gestern ein Soft-PWM Programm nach Vorbild aus dem 
Artikel hier, auf meinem Atmega 328p mit 16MHz zum Laufen zu bringen. 
Vorerst sollte lediglich ein PWM Signal mit jeweils unterschiedlichem 
Duty Cycle an 3 Pins anliegen.
Um zu sehen was an den Ausgängen passiert schließe ich dort testweise 
eine LED an.
Da alte Programme einwandfrei laufen und auch die Fuses richtig gesetzt 
sind, liegt es mit 95 prozentiger Sicherheit an Codefehlern.

Das Problem ist, dass an den Ausgängen zwar ein PWM Signal anliegt 
jedoch mit einer Frequenz im ein- bis zweistelligen Hertz Bereich. Das 
heißt etwa 100mal zu langsam.

Ich hoffe Ihr findet meinen dämlichen Fehler wieder mal und helft mir 
aus der Patsche.

Danke schonmal für die Mühe!

Hier mal der Code:

#define F_CPU 16000000UL 

#define F_PWM 100                       // PWM-Frequenz in Hz

#define PWM_STEPS 256UL                   // PWM-Schritte pro Zyklus(1..256)

#define PWM_PORT PORTD                  // Port für PWM
#define PWM_DDR DDRD                    // Datenrichtungsregister für PWM


#define T_PWM (F_CPU/(F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt


#include <avr/io.h>
#include <avr/interrupt.h>

volatile uint8_t red1=30;
volatile uint8_t green1=100;
volatile uint8_t blue1=200;

void timer_init(){
  
  //Timer 1 in CTC Mode with F_CPU
  TCCR1B |= (1<<WGM12) | (1<<CS10);
  TIMSK1 |= (1<<OCIE1A);   // Interrupt freischalten
  OCR1A=T_PWM;
  sei();                  // Interrupts global einschalten
  }

void io_init(){
  PWM_DDR = 0xff;  
  PWM_PORT=0;
  }



ISR(TIMER1_COMPA_vect) {
    static uint8_t pwm_cnt=0;
    uint8_t tmp=0;
 
    OCR1A += (uint16_t)T_PWM;
  
 
    if (red1 > pwm_cnt) tmp |= (1<<2);
    if (green1 > pwm_cnt) tmp |= (1<<3);
    if (blue1 > pwm_cnt) tmp |= (1<<4);

    PWM_PORT = tmp;                         // PWMs auf Port schreiben
  
    if (pwm_cnt==(uint8_t)(PWM_STEPS-1))
        pwm_cnt=0;
    else
        pwm_cnt++;
    
}
 
int main(void)
{  
  io_init();
  timer_init();
  
    while(1)
    {
        
    }
  
  return 0;
}

[Patrick B. (p51d)]

Du änderst deine PWM-Frequenz jedesmal, durch anpassen des OCR1A 
Registers (also den Max-Wert des Timers). Beim ersten Durchlauf zählt er 
bis T_PWM, dann wird der Timer auf 0 gesetzt und zählt beim 2. Interrupt 
auf 2*T_PWM, usw...

Ausserdem würdest du so die "unbenützen" oder anders verwendeten Pins 
von PortD ebenfalls manipulieren. Desswegen musst du zuerst den 
Registerwet speichern, und nur deine PWM-Pins behandeln.

Das sollte klappen:

#define PWM_PORT_VAL  PIND
#define PWM_PIN_1    2
#define PWM_PIN_2    3
#define PWM_PIN_3    4
ISR(TIMER1_COMPA_vect) {
    static uint8_t pwm_cnt=0;
    uint8_t tmp=PWM_PORT_VAL;        // Register retten
  
  // Löschen der Werte (nur PWM)
  temp &= ~((1<<PWM_PIN_1) | (1<<PWM_PIN_2) | (1<<PWM_PIN_3));
 
  // PWM Pins setzen
    if (red1 > pwm_cnt) tmp |= (1<<PWM_PIN_1);
    if (green1 > pwm_cnt) tmp |= (1<<PWM_PIN_2);
    if (blue1 > pwm_cnt) tmp |= (1<<PWM_PIN_3);

    PWM_PORT = tmp;                         // PWMs auf Port schreiben
  
    if (pwm_cnt==(uint8_t)(PWM_STEPS-1))    pwm_cnt=0;
    else                  pwm_cnt++;    
}

[Thomas (Gast)]

Dickes Dankeschön!!

Mir kam das doch gleich sehr merwürdig vor, dass ich in jedem Interrupt 
den Compare Wert addieren muss. Da will man einmal was genau nach 
Anleitung machen und das hat man dann davon.. :D

Das mit den Pins ist in meinem Anwendungsfall nicht besonders tragisch, 
da noch drei Weitere Pins für PWM benutzt werden und ich somit der Port 
nur rein zur PWM Erzeugung genutzt wird.
Aber danke für den Hinweis, kann ich bestimmt mal brauchen ;)

Läuft jetzt übrigens einwandfrei. Dankeschööön!!!!

[Patrick B. (p51d)]

Thomas schrieb:
> Mir kam das doch gleich sehr merwürdig vor, dass ich in jedem Interrupt
> den Compare Wert addieren muss. Da will man einmal was genau nach
> Anleitung machen und das hat man dann davon.. :D

Du hast auch den Timer anders initialisiert (CTC)... Im Beispielt zählt 
der Timer bis 0xFFFF, da macht das inkrementieren bedingt Sinn (der 
letzte Wert kann zufällig genau passen, muss aber nicht). Dorst sollte 
man darauf achten, dass T_PWM ein gerader Teiler von 256 oder 65536 ist. 
Ist dies nicht der Fall, dann ist die CTC Variante eindeutig die bessere 
und hier ist OCR fix.

[Axel S. (a-za-z0-9)]

Patrick B. schrieb:
> Du hast auch den Timer anders initialisiert (CTC)... Im Beispielt zählt
> der Timer bis 0xFFFF, da macht das inkrementieren bedingt Sinn (der
> letzte Wert kann zufällig genau passen, muss aber nicht). Dorst sollte
> man darauf achten, dass T_PWM ein gerader Teiler von 256 oder 65536 ist.

Nein. T_PWM muß kein Teiler des Zählumfangs sein. Denn bei der Addition 
auf das OCR passiert genau der gleiche wohldefinierte Überlauf wie beim 
Timer selber.