3 PWM-Ausgänge am Attiny 2313

[PG (Gast)]

Guden,

ich möchte mit einem Attiny 2313 eine RGB-LED ansteuern. Es handelt sich 
um eine 10Watt-RGB-LED vom Chinamann, die über drei PWM-fähige KSQs 
getrieben werden soll. Die Auswahl der Farbe soll recht spartanisch über 
DIP-Schalter laufen, ich habe 9 DIP-Schalter vorgesehen, also soll es 4 
Stufen für jede Farbe geben.

Bsp:
0 Schalter für Rot = Rote PWM = 0%
1 Schalter für Rot = Rote PWM = 33%
2 Schalter für Rot = Rote PWM = 66%
3 Schalter für Rot = Rote PWM = 99%
...

Die Schalter werden atm nicht entprellt, das könnte ein Problem sein, 
aber ich denke eher das ich die Register falsch verwende.

Laut Datenblatt hat der µC 4 PWM-Ausgänge, ich bekomme es aber nicht auf 
die Reihe die Register so einzustellen das die 3 PWM-Signale aktiv sind.

Link zum Datenblatt: http://www.atmel.com/images/doc8246.pdf ab S. 99 
geht es um die fastPWM.

Ich möchte, wenn möglich, OC0A, OC1A und OC1B verwenden.

Mein Programmcode bisher:

#include <avr/io.h>
#include <util/delay.h>
#include <avr/interrupt.h>
#include <stdlib.h>
//
//#ifndef F_CPU
//#define F_CPU 1000000000UL
//#endif



int main(void)
{
  
  DDRB   |= (1 << PB2);                   // PWM output on PB2 - OC0A
  DDRB   |= (1 << PB3);                   // PWM output on B3 - OC1A
  DDRB   |= (1 << PB4);                   // PWM output on B4 - OC1B
  
   // Rot
   TCCR0A = (1<<COM0A1)|(1<<COM0A0)|(1<<WGM01)|(1<<WGM00);
   OCR0A  = 0x10;                          // initial PWM pulse width
   
   //Blau
    DDRB   |= (1 << PB3);                   // PWM output on PB2
    TCCR1A = (1 << COM1A1) | (1 << WGM00);  // phase correct PWM mode
    OCR1A  = 0x10;                          // initial PWM pulse width
   
   //Grün
    DDRB   |= (1 << PB4);                   // PWM output on PB2
    TCCR1B = (1 << COM1B1) | (1 << WGM00);  // phase correct PWM mode
    OCR1B  = 0x10;                          // initial PWM pulse width
   TCCR0B = (1 << CS01);   // clock source = CLK/8, start PWM
   //Rot
   PORTB |= (1 << PB1); // initializes the pull-up resistor on AVR pin PB1
   PORTB |= (1 << PB0); // initializes the pull-up resistor on AVR pin PB0
   PORTD |= (1 << PD6); // initializes the pull-up resistor on AVR pin PD2
   
   //Blau
   PORTB |= (1 << PB7); // initializes the pull-up resistor on AVR pin PB1
   PORTB |= (1 << PB6); // initializes the pull-up resistor on AVR pin PB0
   PORTD |= (1 << PB5); // initializes the pull-up resistor on AVR pin PD2
   
   //Grün
   PORTB |= (1 << PD3); // initializes the pull-up resistor on AVR pin PB1
   PORTB |= (1 << PD4); // initializes the pull-up resistor on AVR pin PB0
   PORTD |= (1 << PD5); // initializes the pull-up resistor on AVR pin PD2
   
   
   TCCR0B = (1 << CS01);   // clock source = CLK/8, start PWM
  
   unsigned char PWM_R = 0;    // 8-bit PWM value
   unsigned char PWM_G = 0;    // 8-bit PWM value
   unsigned char PWM_B = 0;    // 8-bit PWM value
   int Schalter[8] = {0,0,0,0,0,0,0,0};

     
    while(1)
    {
       // Schalter abfragen und Werte in Array ablegen
     // Rot
     if (bit_is_clear(PINB, PB1))
     { Schalter[0] = 1;}
     else { Schalter[0] = 0;}
            
     if (bit_is_clear(PINB, PB0))
     { Schalter[1] = 1;}
     else { Schalter[1] = 0;}
    
     if (bit_is_clear(PIND, PD6))
     { Schalter[2] = 1;}
     else { Schalter[2] = 0;}          
     
     //Blau
     if (bit_is_clear(PINB, PB1))
     { Schalter[0] = 1;}
     else { Schalter[0] = 0;}
     
     if (bit_is_clear(PINB, PB0))
     { Schalter[1] = 1;}
     else { Schalter[1] = 0;}
     
     if (bit_is_clear(PIND, PD6))
     { Schalter[2] = 1;}
     else { Schalter[2] = 0;}
     
     
     //Grün
     if (bit_is_clear(PINB, PB1))
     { Schalter[0] = 1;}
     else { Schalter[0] = 0;}
     
     if (bit_is_clear(PINB, PB0))
     { Schalter[1] = 1;}
     else { Schalter[1] = 0;}
     
     if (bit_is_clear(PIND, PD6))
     { Schalter[2] = 1;}
     else { Schalter[2] = 0;}
     
     //Bedingungen abfragen und Ergebnis an PWM übergeben
     //Rot     
     if (Schalter[0]==0 && Schalter[1]==0 && Schalter[2] == 0)  //000
     {  PWM_R = 0;   }
       
     if (Schalter[0]==1 && Schalter[1]==0 && Schalter[2] == 0)  //100
     {  PWM_R = 85;   }
     if (Schalter[0]==0 && Schalter[1]==1 && Schalter[2] == 0)  //010
     {  PWM_R = 85;   }
     if (Schalter[0]==0 && Schalter[1]==0 && Schalter[2] == 1)  //001
     {  PWM_R = 85;   }
       
     if (Schalter[0]==1 && Schalter[1]==1 && Schalter[2] == 0)  //110
     {  PWM_R = 170;   }
     if (Schalter[0]==0 && Schalter[1]==1 && Schalter[2] == 1)  //011
     {  PWM_R = 170;   }
     if (Schalter[0]==1 && Schalter[1]==0 && Schalter[2] == 1)  //101
     {  PWM_R = 170;   } 
       
     if (Schalter[0]==1 && Schalter[1]==1 && Schalter[2] == 1)  //111
     {  PWM_R = 255;   }  
     
     OCR0A  = PWM_R;       // write new PWM value
     
     //Blau
     if (Schalter[3]==0 && Schalter[4]==0 && Schalter[5] == 0)  //000
     {  PWM_B = 0;   }
     
     if (Schalter[3]==1 && Schalter[4]==0 && Schalter[5] == 0)  //100
     {  PWM_B = 85;   }
     if (Schalter[3]==0 && Schalter[4]==1 && Schalter[5] == 0)  //010
     {  PWM_B = 85;   }
     if (Schalter[3]==0 && Schalter[4]==0 && Schalter[5] == 1)  //001
     {  PWM_B = 85;   }
     
     if (Schalter[3]==1 && Schalter[1]==1 && Schalter[5] == 0)  //110
     {  PWM_B = 170;   }
     if (Schalter[3]==0 && Schalter[4]==1 && Schalter[5] == 1)  //011
     {  PWM_B = 170;   }
     if (Schalter[4]==1 && Schalter[4]==0 && Schalter[5] == 1)  //101
     {  PWM_B = 170;   }
     
     if (Schalter[0]==1 && Schalter[4]==1 && Schalter[5] == 1)  //111
     {  PWM_B = 255;   }
     
     OCR0A  = PWM_B;       // write new PWM value
     
     
     //Grün
     if (Schalter[6]==0 && Schalter[7]==0 && Schalter[8] == 0)  //000
     {  PWM_G = 0;   }
     
     if (Schalter[6]==1 && Schalter[7]==0 && Schalter[8] == 0)  //100
     {  PWM_G = 85;   }
     if (Schalter[6]==0 && Schalter[7]==1 && Schalter[8] == 0)  //010
     {  PWM_G = 85;   }
     if (Schalter[6]==0 && Schalter[7]==0 && Schalter[8] == 1)  //001
     {  PWM_G = 85;   }
     
     if (Schalter[6]==1 && Schalter[7]==1 && Schalter[8] == 0)  //110
     {  PWM_G = 170;   }
     if (Schalter[6]==0 && Schalter[7]==1 && Schalter[8] == 1)  //011
     {  PWM_G = 170;   }
     if (Schalter[6]==1 && Schalter[7]==0 && Schalter[8] == 1)  //101
     {  PWM_G = 170;   }
     
     if (Schalter[6]==1 && Schalter[7]==1 && Schalter[8] == 1)  //111
     {  PWM_G = 255;   }
     
     OCR0A  = PWM_G;       // write new PWM value
     
    }//while
}//main

Bin für jede Hilfe dankbar, die Abfrage der Bedingungen für die Schalter 
ist zwar nicht elegant, sollte aber funktionieren, mit 3 Schaltern und 
einer PWM hab ich es schonmal zum Laufen bekommen.

Sollte jemand das komplette Pinout brauchen, bitte melden.
Ich verwende Atmel Studio und den AVR-Dragon zum Programmieren des µC.

Danke für eure Hilfe, Grüße, PG

[Ralf G. (ralg)]

Was mir als erstes auffällt:

- Die Initialisierung der Timer geht ziemlich durcheinander
- Bit 'CS01' wird an zwei verschiedenen Stellen gesetzt.
- Bit 'COM1B1' ist nicht in 'TCCR1B' ansprechbar. Mit diesem Befehl 
setzt du dort dann das Bit5, welches reserviert ist, und lt. Datenblatt 
immer '0' sein muss.

Die Register 'TCCRxA' und 'TCCRxB' gehören zur Initialisierung des 
Timers! Da gibt es keine Zuordnung zu 'OCxA' und 'OCxB'.

[Εrnst B. (ernst)]

PG schrieb:
> TCCR1A = (1 << COM1A1) | (1 << WGM00);  // phase correct PWM mode

TCCR1A hat kein "WGM00"-Bit. Und du wolltest Fast PWM, kein phase 
correct?

> TCCR1B = (1 << COM1B1) | (1 << WGM00);

TCCR1B hat weder ein COM1B1 noch ein WGM00 bit.

==> Datenblatt Seite 111 und folgende.

Überprüf doch mal alle deine Register, ob du auch die richtigen Bits 
setzt.

[Wolfgang (Gast)]

PG schrieb:
> Die Schalter werden atm nicht entprellt, das könnte ein Problem sein, ...

Warum?
Verwendest du irgendwo eine sequentielle Steuerung?

[c-hater (Gast)]

PG schrieb:

> mit 3 Schaltern und
> einer PWM hab ich es schonmal zum Laufen bekommen.

Kunststück, das war ja wohl genau der Teil des Codes, den du 
"raubkopiert" und offensichtlich komplett nicht verstanden hast.

Was dann praktisch automatisch dazu geführt hat, dass deine Erweiterung 
auf drei Kanäle in jeder Beziehung völliger Bullshit geworden ist.

Also: lies das verdammte Datenblatt und versuche den kopierten Code auch 
zu verstehen. Als Gradmesser für das Wachsen deines Verständnisses 
kannst du das EIGENSTÄNDIGE Erreichen der von dir gewünschten Funktion 
nehmen...

Und wenn du damit durch bist (falls es je so weit kommen sollte), dann 
kannst du auch gleich noch C lernen und den Code mit den Features 
optimieren, die C so bietet, insbesondere der Nutzung von Funktionen für 
ähnliche oder identische Programmteile...

[M. K. (sylaina)]

PG schrieb:
> Ich möchte, wenn möglich, OC0A, OC1A und OC1B verwenden.

Das ist auf jeden Fall möglich. Hier mal ein Beispiel dazu

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

int main(void){
  // PWM-Portpins auf Ausgang schalten
  DDRB |= (1 << PB2)|(1 << PB3)|(1 << PB4);
  // Timer0 einstellen fuer Fast-PWM
  TCCR0A |= (1 << WGM01)|(1 << WGM00);
  // Normaler PWM-Mode, d.h. Ausgang High bis Zaehlwert erreicht, dann Low
  TCCR0A |= (1 << COM0A1);
  // fest vorgegebene Duty-Cycles
  // fuer OC0A
  OCR0A = 200;
  // Timer1 einstellen fuer PhaseCorrect-PWM
  TCCR1A |= (1 << WGM11)|(1 << WGM10);
  // Normaler PWM-Mode, d.h. Ausgang High bis Zaehlwert erreicht, darüber Low
  TCCR1A |= (1 << COM1A1)|(1 << COM1B1);
  // fest vorgegebene Duty-Cycles
  // fuer OC1A
  OCR1A = 30;
  // fuer OC1B
  OCR1B = 127;

  // Timer starten
  TCCR0B |= (1 << CS00);
  TCCR1B |= (1 << CS12)|(1 << CS01);
  for(;;){
    // Main-Loop
  }
  // wird nie erreicht
  return 0;
}

Das macht drei PWM-Ausgangsignale (ungeprüft, Tippfehler können drin 
sein), vielleicht kannst du darauf aufbauen, TE.

[PG (Gast)]

Vielen Dank für all die Tipps und Hinweise!
Ich hab schon verstanden das ich die Infos aus dem Datenblatt kriegen 
muss, aber das ist nicht so einfach wenn man wenig Erfahrung damit hat.

Ich schaue mir das Setzen der Register für Timer und Waveforms nochmal 
an und melde mich dann.

Das man den Code mit Funktionen sehr viel kürzer machen kann wenn man 
dreimal das selbe machen will ist klar, aber ich wollte erst die drei 
PWMs zum Laufen kriegen und wissen das es überhaupt das macht was ich 
will, bevor ich ewig Zeit investiere um schöne Funktionen zu schreiben, 
für jemanden der super in C ist mag das unverständlich sein und die 
Lesbarkeit nicht unbedingt erhöhen, aber  ich mache nun mal einen 
Schritt nach dem Anderen.

Grüße, PG

[Feldkurat K. (feldkurat)]

PG schrieb:
> Ich hab schon verstanden das ich die Infos aus dem Datenblatt kriegen
> muss, aber das ist nicht so einfach wenn man wenig Erfahrung damit hat.

Es gibt in den AVR-Datenblättern den Abschnitt "Register Summary", in 
dem man sämtliche Register und die darin enthaltenen Bits auf einen 
Blick findet. Das ist sehr hilfreich, wenn man alles "von Hand" 
einstellen will, um sicherzugehen, daß der Kontroller auch wirklich das 
macht, was man von ihm erwartet.

-Feldkurat-

[my2ct (Gast)]

PG schrieb:
> Ich hab schon verstanden das ich die Infos aus dem Datenblatt kriegen
> muss, aber das ist nicht so einfach wenn man wenig Erfahrung damit hat.

Das Wort "Erfahrung" hat was mit erfahren zu tun. Das passiert genau 
dann, wenn man sich selber damit beschäftigt - liest, versteht ein 
bisschen, probiert, versteht.

[Feldkurat K. (feldkurat)]

my2ct schrieb:
> Das passiert genau
> dann, wenn man sich selber damit beschäftigt - liest, versteht ein
> bisschen, probiert, versteht.

Diese Schleife muß man nur ab und zu verlassen, um ein Polling auf 
Kaffee oder Mittagessen zu machen.

:)

-Feldkurat-

[c-hater (Gast)]

PG schrieb:

> Ich hab schon verstanden das ich die Infos aus dem Datenblatt kriegen
> muss, aber das ist nicht so einfach wenn man wenig Erfahrung damit hat.

Ja, das ist so. Dagegen hilft aber eben nur eins: LERNEN. Und genau 
das kann man nur selber tun, da helfen keine dümmlichen Anfragen in 
irgendwelchen Foren.

Das heißt natürlich nicht, dass Foren nutzlos sind, denn selbst bei 
tatsächlich vorhandenem Willen und Fähigkeit zum Lernen, stößt man hin 
und wieder auf scheinbar unlösbare Probleme. Meistens dann, wenn 
irgendwelche Dokumentation unvollständig oder gar schlicht falsch ist 
oder man den entscheidenden Knackpunkt einfach nur übersehen hat...
Aber manchmal auch dann, wenn man sich verrannt hat und über die eigenen 
Fehler immer wieder hinwegliest, obwohl sie für praktisch jeden anderen 
sofort sichtbar sind, weil der eben den nötigen Abstand hat...

Solche Probleme zu lösen, dafür sind Foren da. Nicht dafür, dass Dumme 
und Faule ihre Anwendungen für lau programmiert bekommen...