PWM mit ATMEGA168

[Tobias x. (dertobias)]

Hallo Commmunity,

ich habe mal wieder eine Frage, udn da mir bisher immer gut geholfen 
werden konnte, hoffe ich auch diesmal auf eure Hilfe:

Wie funktioniert das mit der PWM, damit ich eine LED Dimmen kann bei 
einem ATMEGA168.

Ich habe mir schon Applicationsnotes und andere Quellen über Software 
PWM mit einem ATMEGA durchgelesen, konnte aber kein ansatzweise 
laufendes Programm erstellen. um das mal zu testen.

Nun meine Frage, kann mir wer ein kleines Beispiel für eine Softwarepwm 
für den ATMEGA 168 zeigen und erklären? Es reicht völlig, wenn in diesem 
Beispiel nur 1 LED z.B. die led an PORTD PIN3 auf die hälfte gedimmt 
wird, wenn ich PORTB PIN0 auf 0V ziehe.

Vielen Dank

[... (Gast)]

Tobias xxx schrieb:
> Nun meine Frage, kann mir wer ein kleines Beispiel für eine Softwarepwm
> für den ATMEGA 168

Du kannst ein Programm für den ATmega8 hier aus dem Forum nehmen und 
mußt nur ein paar Registerbezeichnungen anpassen. Funktionieren tut der 
ATmega168 sonst sehr ähnlich.

[Tobias x. (dertobias)]

wo finde ich den so einen beispiel-code? finde mich noch nicht so recht 
zurecht. das Programm sollte auch in c sein, da ich assembler noch 
fremder bin als c.

Danke

[... (Gast)]

Tobias xxx schrieb:
> wo finde ich den so einen beispiel-code?

Über die Suchfunktion des Forums. Zu PWM finden sich ungefähr 13744 
Threads. Hast du da schon mal geguckt?

[Tobias x. (dertobias)]

JA aber irgendwie finde ich nur forenbeiträge. und da ist kein definitiv 
funktionierender code für mich gerade zu finden aber ich versuche es 
weiter

[... (Gast)]

Du mußt dir im Datenblatt nur den passenden PWM-Mode aus dem Datenblatt 
raussuchen und die Register entsprechend setzen. Der Rest läuft dann per 
Timer und PWM-Hardware des Prozessors selbständig. Zur Änderung des 
Tastverhältnis muß dann nur z.B. eines der Output Compare Register 
geändert werden.
z.B.
Beitrag "Ansteuerung einer RGB LED (PWM)"

Es geht natürlich auch per Software:
Beitrag "8-fach 12-Bit Soft-PWM LED-Dimmer für mega48"

[Tobias x. (dertobias)]

Hallo,

habe jetzt einen Code gefunden und umgeschrieben, womit ich alle meine 
LED'S Dimmen kann.
Der Code war für einen ATMEGA 8 und ich habe ihn schon soweit 
umgeschrieben, das er auf einem MEGA168 läuft.
Meine Frage ist jetzt, wo muss ich eingreifen, bzw. was ändern/löschen, 
damit die nicht wie es ja zu demo zwecken ist, die ganze zeit dimmen. 
sondern das ich die LEDS mit einem POTI am Analogeingang PC5 dimmen 
kann. Der Poti soll dann für Später einen Fototransiostor simulieren. 
Also die LEDS sollen dauerhaft an sein, udn durch den POTI gedimmt 
werden können.

Wäre klasse, wenn mir wer da helfen könnte.

[Tobias x. (dertobias)]

... schrieb:
> Es geht natürlich auch per Software:
> Beitrag "8-fach 12-Bit Soft-PWM LED-Dimmer für mega48"

Hier geht es doch wenn ich das richtig sehe um eine HArdware PWM 
anstelle iner Software pwm.

[Tobias x. (dertobias)]

Tobias xxx schrieb:
> Hallo,
>
> habe jetzt einen Code gefunden und umgeschrieben, womit ich alle meine
> LED'S Dimmen kann.
> Der Code war für einen ATMEGA 8 und ich habe ihn schon soweit
> umgeschrieben, das er auf einem MEGA168 läuft.
> Meine Frage ist jetzt, wo muss ich eingreifen, bzw. was ändern/löschen,
> damit die nicht wie es ja zu demo zwecken ist, die ganze zeit dimmen.
> sondern das ich die LEDS mit einem POTI am Analogeingang PC5 dimmen
> kann. Der Poti soll dann für Später einen Fototransiostor simulieren.
> Also die LEDS sollen dauerhaft an sein, udn durch den POTI gedimmt
> werden können.
>
> Wäre klasse, wenn mir wer da helfen könnte.

Hatte leider vergessen, den CODE anzuhängen:

// Software-PWM by PoWl - 25.10.08
// [e-mail]

// ATmega168 @ 8Mhz

#include <avr/io.h>
#include <avr/interrupt.h>
#include <util/delay.h>
#include <stdbool.h>


// Sinustabelle für Demo
const uint8_t sinetable[] = {
128, 131, 134, 137, 140, 143, 146, 149, 152, 155, 158, 162, 165, 167,
170, 173, 176, 179, 182, 185, 188, 190, 193, 196, 198, 201, 203, 206,
208, 211, 213, 215, 218, 220, 222, 224, 226, 228, 230, 232, 234, 235,
237, 238, 240, 241, 243, 244, 245, 246, 248, 249, 250, 250, 251, 252,
253, 253, 254, 254, 254, 255, 255, 255, 255, 255, 255, 255, 254, 254,
254, 253, 253, 252, 251, 250, 250, 249, 248, 246, 245, 244, 243, 241,
240, 238, 237, 235, 234, 232, 230, 228, 226, 224, 222, 220, 218, 215,
213, 211, 208, 206, 203, 201, 198, 196, 193, 190, 188, 185, 182, 179,
176, 173, 170, 167, 165, 162, 158, 155, 152, 149, 146, 143, 140, 137,
134, 131, 128, 124, 121, 118, 115, 112, 109, 106, 103, 100, 97, 93,
90, 88, 85, 82, 79, 76, 73, 70, 67, 65, 62, 59, 57, 54, 52, 49, 47,
44, 42, 40, 37, 35, 33, 31, 29, 27, 25, 23, 21, 20, 18, 17, 15, 14,
12, 11, 10, 9, 7, 6, 5, 5, 4, 3, 2, 2, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 2, 2, 3, 4, 5, 5, 6, 7, 9, 10, 11, 12, 14, 15, 17, 18, 20,
21, 23, 25, 27, 29, 31, 33, 35, 37, 40, 42, 44, 47, 49, 52, 54, 57,
59, 62, 65, 67, 70, 73, 76, 79, 82, 85, 88, 90, 93, 97, 100, 103,
106, 109, 112, 115, 118, 121, 124 };



// -------------------------- 8-Bit PWM --------------------------- //
// An - 254 Graustufen - Aus

#define CHANNELS 12

uint8_t pwm_mask_PORTC_A[CHANNELS + 1];
uint8_t pwm_mask_PORTD_A[CHANNELS + 1];
uint8_t pwm_timing_A[CHANNELS + 1];

uint8_t pwm_mask_PORTC_B[CHANNELS + 1];
uint8_t pwm_mask_PORTD_B[CHANNELS + 1];
uint8_t pwm_timing_B[CHANNELS + 1];

uint8_t *ptr_PORTC_main = &pwm_mask_PORTC_A;
uint8_t *ptr_PORTD_main = &pwm_mask_PORTD_A;
uint8_t *ptr_timing_main = &pwm_timing_A;

uint8_t *ptr_PORTC_isr = &pwm_mask_PORTC_B;
uint8_t *ptr_PORTD_isr = &pwm_mask_PORTD_B;
uint8_t *ptr_timing_isr = &pwm_timing_B;

uint8_t pwm_value[CHANNELS];
uint8_t pwm_queue[CHANNELS];

volatile uint8_t pwm_cycle;
volatile bool pwm_change;

uint8_t pwm_pin[CHANNELS] = { PC0, PC1, PC2, PC3, PC4, PD0, PD1, PD2, PD3, PD4, PD6, PD7 };

uint8_t **pwm_port[CHANNELS] = {
  &ptr_PORTC_main,
  &ptr_PORTC_main,
  &ptr_PORTC_main,
  &ptr_PORTC_main,
  &ptr_PORTC_main,
  &ptr_PORTD_main,
  &ptr_PORTD_main,
  &ptr_PORTD_main,
  &ptr_PORTD_main,
  &ptr_PORTD_main,
  &ptr_PORTD_main,
  &ptr_PORTD_main
};


void pwm_update(void)
{
  pwm_change = 0;

  // Sortieren mit InsertSort

  for(uint8_t i=1; i<CHANNELS; i++)
  {
    uint8_t j = i;

    while(j && pwm_value[pwm_queue[j - 1]] > pwm_value[pwm_queue[j]])
    {
      uint8_t temp = pwm_queue[j - 1];
      pwm_queue[j - 1] = pwm_queue[j];
      pwm_queue[j] = temp;

      j--;
    }
  }

  // Maske generieren

  for(uint8_t i=0; i<(CHANNELS + 1); i++)
  {
    ptr_PORTC_main[i] = 0;
    ptr_PORTD_main[i] = 0;
    ptr_timing_main[i] = 0;
  }

  uint8_t j = 0;

  for(uint8_t i=0; i<CHANNELS; i++)
  {
    // Sonderfall "ganz AUS" ausschließen:
    //  - Pins garnicht erst anschalten
    //  - Pins die vorher "ganz AN" waren müssen trotzdem noch deaktiviert werden, deshalb nur folgendes in der if
    if(pwm_value[pwm_queue[i]] != 0)
    {
      (*pwm_port[pwm_queue[i]])[0] |= (1 << pwm_pin[pwm_queue[i]]);
    }

    // Sonderfall "ganz AN" ausschließen:
    //  - Nicht in Timing-Tabelle übernehmen da sonst die Pointer niemals getauscht werden
    //  - Pins die "ganz AN" sind müssen nicht abgeschaltet werden
    if(pwm_value[pwm_queue[i]] != 255)
    {
      (*pwm_port[pwm_queue[i]])[j + 1] |= (1 << pwm_pin[pwm_queue[i]]);

      ptr_timing_main[j] = pwm_value[pwm_queue[i]];
    }

    if(pwm_value[pwm_queue[i]] != pwm_value[pwm_queue[i + 1]])
    {
      j++;
    }
  }

  /*
  // Der ISR etwas Arbeit abnehmen
  for(uint8_t i=1; i<(CHANNELS + 1); i++)
  {
    ptr_PORTC_main[i] = ~ptr_PORTC_main[i];
    ptr_PORTD_main[i] = ~ptr_PORTD_main[i];
  }
  */

  pwm_change = 1;
}


int main(void)
{
  // PWM initialisieren
  for(uint8_t i=0; i<CHANNELS; i++)
  {
    pwm_queue[i] = i;
  }

  DDRC = 0b00011111;
  DDRD = 0b11011111;
  DDRB = 0x00;


  // Timer für PWM
  OCR1A = 255;
  TIMSK1 = (1 << OCIE1A) | (1 << OCIE1B);
  TCCR1B = (1 << WGM12) | 4;

  sei();


  uint8_t pos = 0;

  while(1)
  {
    for(uint8_t i=0; i<CHANNELS; i++)
    {
      pwm_value[i] = sinetable[(uint8_t) (pos + i * 20)];
    }

    pwm_update();
    pos++;

    _delay_ms(5);
  }
}



ISR(TIMER1_COMPA_vect)
{
  pwm_cycle = 0;

  PORTC |= ptr_PORTC_isr[0];
  PORTD |= ptr_PORTD_isr[0];

  OCR1B = ptr_timing_isr[0];
}



ISR(TIMER1_COMPB_vect)
{
  pwm_cycle++;

  PORTC &= ~ptr_PORTC_isr[pwm_cycle];
  PORTD &= ~ptr_PORTD_isr[pwm_cycle];

  if(ptr_timing_isr[pwm_cycle] != 0)
  {
    OCR1B = ptr_timing_isr[pwm_cycle];
  }
  else if(pwm_change)
  {
    pwm_change = 0;

    uint8_t *temp_ptr;

    temp_ptr = ptr_PORTC_main;
    ptr_PORTC_main = ptr_PORTC_isr;
    ptr_PORTC_isr = temp_ptr;

    temp_ptr = ptr_PORTD_main;
    ptr_PORTD_main = ptr_PORTD_isr;
    ptr_PORTD_isr = temp_ptr;

    temp_ptr = ptr_timing_main;
    ptr_timing_main = ptr_timing_isr;
    ptr_timing_isr = temp_ptr;
  }
}