mikrocontroller.net

Forum: Mikrocontroller und Digitale Elektronik Soft-PWM flackert


Autor: Marcel Holle (multiholle)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Ich habe nach dem Tutorial hier im Forum ein Soft-PWM für meine 4 LEDs 
geschrieben. Das funktioniert jetzt einigermaßen, allerdings noch nicht 
ganz perfekt: Die LEDs flackern beim Dimmen. Ich habe für die PWM-Werte 
jeweils 2er-Arrays als Dubblebuffer verwendet. cur gibt immer den 
aktuellen Wert für die ISR an.

Ist evtl. die ISR zu rechenaufwendig, oder wo liegt das Problem?

main.c
/*** INCLUDE ******************************************************************/
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <inttypes.h>
#include "leds.h"
#include "speaker.h"

/*** DEFINE *******************************************************************/
#define F_CPU         20000000L
#define F_PWM         100L
#define PWM_PRESCALER 1
#define PWM_CHANNELS  8
#define PWM_STEPS     256
#define T_PWM         (F_CPU / (PWM_PRESCALER * F_PWM * PWM_STEPS))

/** VARS/CONSTS ***************************************************************/
volatile uint8_t sync;
uint8_t cur = 0;
uint8_t pwm_count[2];
uint16_t pwm_timing[PWM_CHANNELS + 1][2];
uint8_t pwm_mask[PWM_CHANNELS + 1][2];

uint16_t pwm_table[32]  PROGMEM = {0, 1, 2, 2, 2, 3, 3, 4, 
                                   5, 6, 7, 8, 10, 11, 13, 16, 
                                   19, 23, 27, 32, 38, 45, 54, 64, 
                                   76, 91, 108, 128, 152, 181, 215, 255};



/** FUNCTIONS *****************************************************************/
ISR(TIMER1_COMPA_vect) {
  static uint8_t pwm = 0;
  OCR1A +=  pwm_timing[pwm][cur ^ 1];
  if (pwm == 0)
    leds_set(pwm_mask[pwm][cur ^ 1]);
  else
    leds_off(pwm_mask[pwm][cur ^ 1]);
  pwm++;
  if (pwm == pwm_count[cur ^ 1] + 1) {
    sync = 1;   
    pwm = 0;
  }
}

void leds_pwm_set(uint8_t pwm_setting_unsorted[]) {
  uint8_t i, j, k;
  uint8_t pwm_setting[PWM_CHANNELS];

  // mask
  pwm_mask[0][cur] = 0;
  for (i = 0; i < PWM_CHANNELS; i++) {
    pwm_setting[i] = pgm_read_word(pwm_table + pwm_setting_unsorted[i]);
    if (pwm_setting[i] != 0) 
      pwm_mask[0][cur] |= (1 << i);
    pwm_mask[i + 1][cur] = (1 << i);
  }

  // sort pwm_settings (bubblesort)
  for (i = PWM_CHANNELS - 1; i > 0; i--) {
    for (j = 0; j < i; j++) {
      // swap
      if (pwm_setting[j] > pwm_setting[j + 1]) {
        // swap pwm_settings
        uint8_t tmp_pwm_setting = pwm_setting[j];
        pwm_setting[j] = pwm_setting[j + 1];
        pwm_setting[j + 1] = tmp_pwm_setting;
        // swap masks
        uint8_t tmp_mask = pwm_mask[j + 1][cur];
        pwm_mask[j + 1][cur] = pwm_mask[j + 2][cur];
        pwm_mask[j + 2][cur] = tmp_mask;
      }
    }
  }

  // join same values, remove zero values
  pwm_count[cur] = PWM_CHANNELS;
  i = 0;
  while (pwm_count[cur] > i) {
    while (pwm_count[cur] > i && (pwm_setting[i] == pwm_setting[i + 1] || pwm_setting[i] == 0)) {
      if (pwm_setting[i] != 0)
        pwm_mask[i + 2][cur] |= pwm_mask[i + 1][cur];
      for (k = i; k < pwm_count[cur] + 1; k++) {
        pwm_setting[k] = pwm_setting[k + 1];
        pwm_mask[k + 1][cur] = pwm_mask[k + 2][cur];
      }
      pwm_count[cur]--;
    }
    i++;
  }
  if (pwm_setting[i] == 0)
    pwm_count[cur]--;

  // calc timings
  pwm_timing[0][cur] = T_PWM * pwm_setting[0];
  for (i = 1; i < pwm_count[cur]; i++) {
    pwm_timing[i][cur] = T_PWM * (pwm_setting[i] - pwm_setting[i - 1]);
  }
  pwm_timing[cur][pwm_count[cur]] = T_PWM * (PWM_STEPS - 1 - pwm_timing[cur][pwm_count[cur] - 1]);

  // swap
  sync = 0;
  while (sync == 0);

  cli();
  cur ^= 1;
  sei();
}


int main(void) {
  leds_init();
  
  // set timer prescaler to F_CPU/8
    TCCR1B |= (1 << CS00);
  // enable output compare interrupt
    TIMSK1 |= (1 << OCIE1A);
  // enable global interrupts
  sei();

  uint8_t vals[] = {31, 31, 0, 0, 0, 0, 0, 0};
  uint8_t i = 0;
  while (1) {
    vals[i]--;
    vals[(i + 2) % 4]++;
    
    if (vals[i] == 0)
      i = (i + 1) % 4;    

    leds_pwm_set(vals);
    _delay_ms(20);
  }
}

leds.c
#include <avr/io.h>
#include "leds.h"

void leds_init(void) {
    // set leds outputs
    DDRC |= 1 << PC4;
    DDRD |= 1 << PD3 | 1 << PD6 | 1 << PD7;
    
    // turn all leds off
    PORTC &= ~(1 << PC4);
    PORTD &= ~(1 << PD3 | 1 << PD6 | 1 << PD7);
}

void leds_set(uint8_t state) {
    // led 1
  if (state & (1 << 0))
        PORTC |= 1 << PC4;
  else
        PORTC &= ~(1 << PC4);

    // led 2
    if (state & (1 << 1))
        PORTD |= 1 << PD3;
    else
        PORTD &= ~(1 << PD3);

    // led 3
    if (state & (1 << 2))
        PORTD |= 1 << PD6;
    else
        PORTD &= ~(1 << PD6);

    // led 4
    if (state & (1 << 3))
        PORTD |= 1 << PD7;
    else
        PORTD &= ~(1 << PD7);
}

void leds_on(uint8_t mask) {
    // led 1
  if (mask & (1 << 0))
        PORTC |= 1 << PC4;

    // led 2
    if (mask & (1 << 1))
        PORTD |= 1 << PD3;

    // led 3
    if (mask & (1 << 2))
        PORTD |= 1 << PD6;

    // led 4
    if (mask & (1 << 3))
        PORTD |= 1 << PD7;
}

void leds_off(uint8_t mask) {
    // led 1
  if (mask & (1 << 0))
        PORTC &= ~(1 << PC4);

    // led 2
    if (mask & (1 << 1))
        PORTD &= ~(1 << PD3);

    // led 3
    if (mask & (1 << 2))
        PORTD &= ~(1 << PD6);

    // led 4
    if (mask & (1 << 3))
        PORTD &= ~(1 << PD7);
}

Autor: Marcel Holle (multiholle)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Das flackern der LEDs tritt nicht auf, wenn ich nur einen PWM-Wert 
anzeige. Wenn ich aber eine Animation erstelle, flackern die LEDs. 
Irgendwas stimmt da mit der synchronisation nicht, aber was?

Autor: Marcel Holle (multiholle)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Keiner eine Idee?

Autor: Sam .. (sam1994)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Sollte dein Code fehlerfrei sein, dann ist dein SOFT-PWM zu langsam.

Autor: R2D2 (Gast)
Datum:

Bewertung
0 lesenswert
nicht lesenswert
Den Code hab ich mir jetzt nicht genau angeschaut, da bräuchte ich zu 
viel Zeit. Hier mal eine Idee was sein könnte: Wenn du den neuen Wert 
zum falschen Zeitpunkt schreibst gibt es evtl. einen Timer-Zyklus in dem 
nicht richtig geschalten wird.

Beispiel:
Alter Wert: 100
Neuer Wert: 50
Aktueller Timerwert: 75

Der Timer ist schon am neuen Wert vorbei, hat aber noch nicht 
geschalten, weil der alte Wert ja größer war. Deshalb dauert es erst mal 
einen Timerüberlauf lang bis die PWM wieder richtig arbeitet.

Ich übernehme neue Werte deshalb immer nur im Timer-Overflow-IRQ.

Antwort schreiben

Die Angabe einer E-Mail-Adresse ist freiwillig. Wenn Sie automatisch per E-Mail über Antworten auf Ihren Beitrag informiert werden möchten, melden Sie sich bitte an.

Wichtige Regeln - erst lesen, dann posten!

  • Groß- und Kleinschreibung verwenden
  • Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

Formatierung (mehr Informationen...)

  • [c]C-Code[/c]
  • [avrasm]AVR-Assembler-Code[/avrasm]
  • [code]Code in anderen Sprachen, ASCII-Zeichnungen[/code]
  • [math]Formel in LaTeX-Syntax[/math]
  • [[Titel]] - Link zu Artikel
  • Verweis auf anderen Beitrag einfügen: Rechtsklick auf Beitragstitel,
    "Adresse kopieren", und in den Text einfügen




Bild automatisch verkleinern, falls nötig
Bitte das JPG-Format nur für Fotos und Scans verwenden!
Zeichnungen und Screenshots im PNG- oder
GIF-Format hochladen. Siehe Bildformate.
Hinweis: der ursprüngliche Beitrag ist mehr als 6 Monate alt.
Bitte hier nur auf die ursprüngliche Frage antworten,
für neue Fragen einen neuen Beitrag erstellen.

Mit dem Abschicken bestätigst du, die Nutzungsbedingungen anzuerkennen.