Problem mit Soft-PWM ATtiny2313

[bubi (Gast)]

Hallo,

ich versuchem mit einem attiny 2313 4 Konstantstromquellen zu steuern.
Die Konstantstromquellen haben einen PWM Eingang der von 0 bis 2.5V 
steuerba ist. Dazu werwende ich das Beispiel aus der Wiki 
Titelhttp://www.mikrocontroller.net/articles/Soft-PWM#Intelligenter_L.C3.B6sungsansatz

aber ich bekomme an den entschprechenden Pins nich die gewinschte 
Spannung um die Konstantstromquellen zu steuern. Bitte um Hilfe.

/*
    Eine 8-kanalige PWM mit intelligentem Lösungsansatz
   aus dem Artikel Soft-PWM auf www.Mikrocontroller.net
 
*/
 
// Defines an den Controller und die Anwendung anpassen
 
#define F_CPU         8000000L           // Systemtakt in Hz
#define F_PWM         100L               // PWM-Frequenz in Hz
#define PWM_PRESCALER 8                  // Vorteiler für den Timer
#define PWM_STEPS     256                // PWM-Schritte pro Zyklus(1..256)
#define PWM_PORT      PORTB              // Port für PWM
#define PWM_DDR       DDRB               // Datenrichtungsregister für PWM
#define PWM_CHANNELS  8                 // Anzahl der PWM-Kanäle
 
// ab hier nichts ändern, wird alles berechnet
 
#define T_PWM (F_CPU/(PWM_PRESCALER*F_PWM*PWM_STEPS)) // Systemtakte pro PWM-Takt
//#define T_PWM 1   //TEST
 
#if ((T_PWM*PWM_PRESCALER)<(111+5))
    #error T_PWM zu klein, F_CPU muss vergrössert werden oder F_PWM oder PWM_STEPS verkleinert werden
#endif
 
#if ((T_PWM*PWM_STEPS)>65535)
    #error Periodendauer der PWM zu gross! F_PWM oder PWM_PRESCALER erhöhen.   
#endif
// includes
 
#include <stdint.h>
#include <string.h>
#include <avr/io.h>
#include <avr/interrupt.h>
#include <math.h> 
// globale Variablen
 
uint16_t pwm_timing[PWM_CHANNELS+1];          // Zeitdifferenzen der PWM Werte
uint16_t pwm_timing_tmp[PWM_CHANNELS+1];      
 
uint8_t  pwm_mask[PWM_CHANNELS+1];            // Bitmaske für PWM Bits, welche gelöscht werden sollen
uint8_t  pwm_mask_tmp[PWM_CHANNELS+1];        // ändern uint16_t oder uint32_t für mehr Kanäle
 
uint8_t  pwm_setting[PWM_CHANNELS];           // Einstellungen für die einzelnen PWM-Kanäle
uint8_t  pwm_setting_tmp[PWM_CHANNELS+1];     // Einstellungen der PWM Werte, sortiert
                                              // ändern auf uint16_t für mehr als 8 Bit Auflösung  
 
volatile uint8_t pwm_cnt_max=1;               // Zählergrenze, Initialisierung mit 1 ist wichtig!
volatile uint8_t pwm_sync;                    // Update jetzt möglich
 
// Pointer für wechselseitigen Datenzugriff
 
uint16_t *isr_ptr_time  = pwm_timing;
uint16_t *main_ptr_time = pwm_timing_tmp;
 
uint8_t *isr_ptr_mask  = pwm_mask;              // Bitmasken fuer PWM-Kanäle
uint8_t *main_ptr_mask = pwm_mask_tmp;          // ändern uint16_t oder uint32_t für mehr Kanäle
 
// Zeiger austauschen
// das muss in einem Unterprogramm erfolgen,
// um eine Zwischenspeicherung durch den Compiler zu verhindern
 
void tausche_zeiger(void) {
    uint16_t *tmp_ptr16;
    uint8_t *tmp_ptr8;                          // ändern uint16_t oder uint32_t für mehr Kanäle
 
    tmp_ptr16 = isr_ptr_time;
    isr_ptr_time = main_ptr_time;
    main_ptr_time = tmp_ptr16;
    tmp_ptr8 = isr_ptr_mask;
    isr_ptr_mask = main_ptr_mask;
    main_ptr_mask = tmp_ptr8;
}
 
// PWM Update, berechnet aus den PWM Einstellungen
// die neuen Werte für die Interruptroutine
 
void pwm_update(void) {
 
    uint8_t i, j, k;
    uint8_t m1, m2, tmp_mask;                   // ändern uint16_t oder uint32_t für mehr Kanäle    
    uint8_t min, tmp_set;                       // ändern auf uint16_t für mehr als 8 Bit Auflösung
 
    // PWM Maske für Start berechnen
    // gleichzeitig die Bitmasken generieren und PWM Werte kopieren
 
    m1 = 1;
    m2 = 0;
    for(i=1; i<=(PWM_CHANNELS); i++) {
        main_ptr_mask[i]=~m1;                       // Maske zum Löschen der PWM Ausgänge
        pwm_setting_tmp[i] = pwm_setting[i-1];
        if (pwm_setting_tmp[i]!=0) m2 |= m1;        // Maske zum setzen der IOs am PWM Start
        m1 <<= 1;
    }
    main_ptr_mask[0]=m2;                            // PWM Start Daten 
 
    // PWM settings sortieren; Einfügesortieren
 
    for(i=1; i<=PWM_CHANNELS; i++) {
        min=PWM_STEPS-1;
        k=i;
        for(j=i; j<=PWM_CHANNELS; j++) {
            if (pwm_setting_tmp[j]<min) {
                k=j;                                // Index und PWM-setting merken
                min = pwm_setting_tmp[j];
            }
        }
        if (k!=i) {
            // ermitteltes Minimum mit aktueller Sortiertstelle tauschen
            tmp_set = pwm_setting_tmp[k];
            pwm_setting_tmp[k] = pwm_setting_tmp[i];
            pwm_setting_tmp[i] = tmp_set;
            tmp_mask = main_ptr_mask[k];
            main_ptr_mask[k] = main_ptr_mask[i];
            main_ptr_mask[i] = tmp_mask;
        }
    }
 
    // Gleiche PWM-Werte vereinigen, ebenso den PWM-Wert 0 löschen falls vorhanden
 
    k=PWM_CHANNELS;             // PWM_CHANNELS Datensätze
    i=1;                        // Startindex
 
    while(k>i) {
        while ( ((pwm_setting_tmp[i]==pwm_setting_tmp[i+1]) || (pwm_setting_tmp[i]==0))  && (k>i) ) {
 
            // aufeinanderfolgende Werte sind gleich und können vereinigt werden
            // oder PWM Wert ist Null
            if (pwm_setting_tmp[i]!=0)
                main_ptr_mask[i+1] &= main_ptr_mask[i];        // Masken vereinigen
 
            // Datensatz entfernen,
            // Nachfolger alle eine Stufe hochschieben
            for(j=i; j<k; j++) {
                pwm_setting_tmp[j] = pwm_setting_tmp[j+1];
                main_ptr_mask[j] = main_ptr_mask[j+1];
            }
            k--;
        }
        i++;
    }
 
    // letzten Datensatz extra behandeln
    // Vergleich mit dem Nachfolger nicht möglich, nur löschen
    // gilt nur im Sonderfall, wenn alle Kanäle 0 sind
    if (pwm_setting_tmp[i]==0) k--;
 
    // Zeitdifferenzen berechnen
 
    if (k==0) { // Sonderfall, wenn alle Kanäle 0 sind
        main_ptr_time[0]=(uint16_t)T_PWM*PWM_STEPS/2;
        main_ptr_time[1]=(uint16_t)T_PWM*PWM_STEPS/2;
        k=1;
    }
    else {
        i=k;
        main_ptr_time[i]=(uint16_t)T_PWM*(PWM_STEPS-pwm_setting_tmp[i]);
        tmp_set=pwm_setting_tmp[i];
        i--;
        for (; i>0; i--) {
            main_ptr_time[i]=(uint16_t)T_PWM*(tmp_set-pwm_setting_tmp[i]);
            tmp_set=pwm_setting_tmp[i];
        }
        main_ptr_time[0]=(uint16_t)T_PWM*tmp_set;
    }
 
    // auf Sync warten
 
    pwm_sync=0;             // Sync wird im Interrupt gesetzt
    while(pwm_sync==0);
 
    // Zeiger tauschen
    cli();
    tausche_zeiger();
    pwm_cnt_max = k;
    sei();
}
 
// Timer 1 Output COMPARE A Interrupt
 
ISR(TIMER0_COMPA_vect) {
    static uint8_t pwm_cnt;                     // ändern auf uint16_t für mehr als 8 Bit Auflösung
    uint8_t tmp;                                // ändern uint16_t oder uint32_t für mehr Kanäle
 
    OCR0A += isr_ptr_time[pwm_cnt];
    tmp    = isr_ptr_mask[pwm_cnt];
 
    if (pwm_cnt == 0) {
        PWM_PORT = tmp;                         // Ports setzen zu Begin der PWM
                                                // zusätzliche PWM-Ports hier setzen
        pwm_cnt++;
    }
    else {
        PWM_PORT &= tmp;                        // Ports löschen
                                                // zusätzliche PWM-Ports hier setzen
        if (pwm_cnt == pwm_cnt_max) {
            pwm_sync = 1;                       // Update jetzt möglich
            pwm_cnt  = 0;
        }
        else pwm_cnt++;
    }
}
 
int main(void) {
 
    // PWM Port einstellen
 
    PWM_DDR = 0xFF;         // Port als Ausgang
    // zusätzliche PWM-Ports hier setzen
 
    // Timer 1 OCRA1, als variablen Timer nutzen
 
    TCCR0A = (1<<WGM01); // CTC Modus
    TCCR0B |= (1<<CS01); // Prescaler 8            
    TIMSK |= (1<<OCIE0A);   // Interrupt freischalten
 
    sei();                  // Interrupts global einschalten
 

 uint8_t port [8];

     port[0] = 50;    //PWM wert für PB0 einstellen
    port[1] = 100;    //PWM wert für PB1 einstellen
    port[2] = 50;    //PWM wert für PB2 einstellen
    port[3] = 100;    //PWM wert für PB3 einstellen
    port[4] = 0;    //PWM wert für PB4 einstellen
    port[5] = 0;    //PWM wert für PB5 einstellen
    port[6] = 0;    //PWM wert für PB6 einstellen
    port[7] = 0;    //PWM wert für PB7 einstellen
  
      memcpy(pwm_setting, port, 8);
      pwm_update();


  while (1) 
    {
    
    }
    return 0;
}

[bubi (Gast)]

Oh ich glaube ich bin in faschem Forum sorry!!

[Jörg W. (dl8dtl) (Moderator)]

Hab's verschoben.

Vielleicht schreibst du ja erstmal, was du bekommst.  „PWM-Eingang,
der von 0 bis 2,5 V steuerbar ist“ ist ein Widerspruch in sich: eine
PWM ist ein digitales Signal, das man besser mit einem Oszilloskop
als einem Multimeter misst, 0 bis 2,5 V klingt nach
Steuergleichspannung.

[bubi (Gast)]

Entschuldigung es ist kein PWM eingang an der Konstantstromquelle 
sondern ein DIM-Anschluss der von 0-2,5V steuerba ist. Leider besitze 
ich kein Osziloskop und kann deswegen nur mit einem Multimeter die 
Spannung an den Pins messen PB0 = 3,3V , PB1 = 3,5V , PB2 = 3,3V PB3 = 
3,5V.

[Frank (Gast)]

Hast du Tiefpässe an den PWM Ausgängen um das Signal zu glätten?

[Frank (Gast)]

http://www.mikrocontroller.net/articles/Pulsweitenmodulation#DA-Wandlung_mit_PWM

[bubi (Gast)]

Nein habe ich nicht, werde asprobieren . Aber was ich nicht verstehe ist 
wiso veränder sich die Spannung an allen Pins auch wenn ich nur den Wert 
von von PWM am Pin 0 verändere. Ist es so richtig wie ich das mache oder 
habe ich da ein Denkfehler.

[Frank (Gast)]

Ohne Glättung kannst du an einem digitalen Pin garkeine analoge Spannung 
erzeugen.
Und erst recht nicht mit einem Multimeter messen!
--> Tiefpässe anschließen!

[bubi (Gast)]

ich habe nur 100nF Kondensatoren und 10kOhm Widerstände reicht das oder 
lieg ich da voll daneben ich verstehe das nicht do ganz

[Jörg W. (dl8dtl) (Moderator)]

bubi schrieb:
> ich habe nur 100nF Kondensatoren und 10kOhm Widerstände reicht das

10 kΩ · 100 nF = 1 ms Zeitkonstante.  Deine PWM sollte also wenigstens
einige Kilohertz als Taktfrequenz haben.  Im Code da oben stehen
jedoch 100 Hz drin.

> oder
> lieg ich da voll daneben ich verstehe das nicht do ganz

Naja, ein paar Grundlagen solltest du dir schon mal anlesen.
Pulsweitenmodulation: DA-Wandlung mit PWM wurde dir ja bereits
genannt.  Lesen musst du es schon selbst, vorlesen können wir es dir
schlecht.

[bubi (Gast)]

Ich habe jetzt ausgerechnet das bei einem Widerstand von 10kOhm einen 
Kondensator mit 5uF brauche:

$$RC = \frac{5V *10ms}{4*0,05*5V} = 50ms$$

$$C = \frac{50ms}{10kOhm} = 5uF$$

Verstehe ich das richtig das jeder Werd in dem Array für den jeweiligen 
Pin zuständig ist.

[Frank (Gast)]

Naja, ich würde mir mal überlegen ob ich nicht lieber versuche mit der 
PWM Frequenz hoch zu gehen.
Dann wird der Kondensator auch kleiner!

Ansonsten ist es neben dem Rippel auch immer eine Frage der Dynamik. 
Also wie schnell sich deine Gleichspannung ändern können soll.

[Frank (Gast)]

Und ja, Wert im Array port ist für den jeweiligen Pin.

[bubi (Gast)]

Ich habe die Tiefässe angeschlossen, aber jetzt wenn Werte im Array für 
die ersten 2 Pins übergebe kommt nur am Pin 1 ein Signal raus.

[bubi (Gast)]

Es funktioniert ich habe den Timer 1 genommen, dann bekomme ich an allen 
8 Pins PWM Signal.

Kann mir jemand erkleren wieso die PWM Frequenz steigt wenn ich den 
Timer0 nehme, oder wie ich die PWM Freqeunz ausrechnen kann (Bild2).

Vielen dank für die Antworten