0-5 V in PWM mit ATmega

stas0 · 25. Juli 2014

Guten Tag,
Also ich hab bei mir einige LED-Leisten die dimme ich zu zeit mit einem ATMega8
der meine 0-5v in PWM umwandelt.
Mein Problem ist jetzt das die Dimmstufen ziemlich ruckelig sind besonders im unteren Bereich.
Ich selber kenn mich fast gar nicht mit der Programmierung von µC aus.
Den jetzigen Code hat mir ein freundliches Mitglied von http://www.mikrocontroller.net geschrieben
ist aber schon über ein Jahr her.
Hab natürlich wieder nachgefragt, ob jemand mein Code editieren kann, hat sich aber keiner gemeldet.
Nur wurde mir geraten mich paar Monate damit zu beschäftigen, bis ich es selber kann. Leider habe ich nich die Zeit dafür.

Deswegen wollte ich hier mal nachfragen, ob jemand hier so freundlich ist und mein Code editieren kann.

Die LED,s sollen jetzt logarithmisch gedimmt werden. Wie hier beschrieben http://www.mikrocontroller.net/articles/LED-Fading.
Sollte mein Problem beheben oder ?

Hier der aktuelle code:

C

#define    PC1          1
#define    PC0          0
#include <avr/io.h>
#include <stdio.h>


unsigned char adc_read8(char channel);


int main(void)
{


  //PC4,5 output
  DDRB = (1<<DDB1) | (1<<DDB2);


  //TIMER 1
  ICR1 = 255;
  TCCR1A = (1<<COM1A1) | (1<<COM1B1) | (1<<COM1A0) | (1<<COM1B1) | (1<< WGM11);   //Fast PWM, TOP = ICR1, Clear on Compare Match
  TCCR1B = (1<<WGM13) | (1<<WGM12) | (1<<CS11) | (1<<CS10);  //Prescaler 64  //Fast PWM, Prescaler 256



  //ADC
  ADMUX = (1<<REFS0) | (1<<ADLAR);                    //VRef = AVCC
  ADCSRA = (1<<ADPS2) | (1<<ADPS1) | (1<<ADEN);       // 125 kHz @ 8 Mhz, ADC enabled
  ADCSRA |= (1<<ADSC);
  while (ADCSRA & (1<<ADSC));


  unsigned int i = 0;
  while(1)
  {
    if (~i)
    {
      OCR1A = 255-adc_read8(PC0);
      OCR1B = 255-adc_read8(PC1);;


    }
    i++;
  }
}


unsigned char adc_read8(char channel)
{
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
  ADCSRA |= (1<<ADSC);
  while (ADCSRA & (1<<ADSC));
  return ADCH;
}

Alles anzeigen

Vielen Dank im Voraus

Sabu · 25. Juli 2014

Grundsätzlich willst du mit 8 Bit dimmen. 8 Bit können max. 256 Stufen liefern (2^8 = 256). Selbst wenn du fast alle Werte auf den unteren Bereich verteilst, wirst du vermutlich immer Stufen sehen. Im unteren Bereich ist das Auge sehr empfindlich, was Helligkeitsunterschiede angeht. Daher wären mehr als 8 Bit besser.

Ansosnten müsstest du den Code zw. Zeile 31 und 32 auf logarithmisch ändern, also nicht x = 255 - adc_read() (linear), sondern irgendwas mit Wertezuordnung, wobei die Werte schon logarithmisch abgelegt sind. So'n AVR wird sich mit der Berechnung vom Logarithmen schwer tun. In dem Link zum LED-Fading stehen die Werte schon drin const uint16_t pwmtable_16[256] PROGMEM =

Also könnte man es vllt. so machen:
OCR1A = pwmtable_16[adc_read8(PC0)];

Das mal eben auf die schnelle aus der Hüfte geschossen. Habe leider ein wenig Zeitdruck..... [Blockierte Grafik: http://home.arcor.de/kgenius/pix/icon_nerved.gif]

Fakrae · 25. Juli 2014

Ich habe mit diesen Werten hier sehr gute Erfahrungen gemacht mit meiner 8bit PWM-Dimmung:
0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 19, 24, 29, 35, 43, 52, 64, 78, 95, 116, 141, 172, 209, 255

Daraus folgt dieser Code:

Code

const uint8_t pwmtable[26]  PROGMEM = { 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 19, 24, 29, 35, 43, 52, 64, 78, 95, 116, 141, 172, 209, 255 }; Muss in Zeile 7

aus

Code

return ADCH; (Zeile 44) wird
return ADCH/10;

und aus

Code

OCR1A = 255-adc_read8(PC0);
OCR1B = 255-adc_read8(PC1);

wird

Code

OCR1A = 255-pwmtable[adc_read8(PC0)];
OCR1B = 255-pwmtable[adc_read8(PC1)];

Das ist jetzt mal ein sehr einfacher Ansatz - aber vielleicht gefällt er dir ja schon.

stas0 · 26. Juli 2014

Also erst mal vielen dank für eure Hilfe.

Hab grad den Code von Fakrae aufgespielt.
Aber irgendwie stimmt was nicht damit scheint noch ein Fehler drin zu sein.
Die LEDs Blinken in unsymmetrischen abständen und gehen dann aus.
Was muss ich noch ändern?

Hier ist der Code, den ich eingespielt habe:

C

/*
 * GccApplication7.c
 *
 * Created: 26.07.2014 11:42:16
 *  Author: PC
 */ 


#define PC1 1
#define PC0 0
#include <avr/io.h>
#include <stdio.h>
#include <avr/pgmspace.h>


unsigned char adc_read8(char channel);


const uint8_t pwmtable[26] PROGMEM = { 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 19, 24, 29, 35, 43, 52, 64, 78, 95, 116, 141, 172, 209, 255 };

int main(void)
{
    //PC4,5 output
    DDRB = (1<<DDB1) | (1<<DDB2);
    //TIMER 1
    ICR1 = 255;
    TCCR1A = (1<<COM1A1) | (1<<COM1B1) | (1<<COM1A0) | (1<<COM1B1) | (1<< WGM11); //Fast PWM, TOP = ICR1, Clear on Compare Match
    TCCR1B = (1<<WGM13) | (1<<WGM12) | (1<<CS11) | (1<<CS10); //Prescaler 64 //Fast PWM, Prescaler 256
    //ADC
    ADMUX = (1<<REFS0) | (1<<ADLAR); //VRef = AVCC
    ADCSRA = (1<<ADPS2) | (1<<ADPS1) | (1<<ADEN); // 125 kHz @ 8 Mhz, ADC enabled
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC));
    unsigned int i = 0;
    while(1)
    {
        if (~i)
        {
            OCR1A = 255-pwmtable[adc_read8(PC0)];
            OCR1B = 255-pwmtable[adc_read8(PC1)];;
        }
        i++;
    }
}
unsigned char adc_read8(char channel)
{
    ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC));
    return ADCH/10;
}

Alles anzeigen

Sabu · 27. Juli 2014

Der Fehler ist (u. a.) der, dass die Funktion adc_read8() einen Rückgabewert vom Typ 'char' hat und der Typ ist 8-Bit groß, kann also Werte von 0 bis 255 annehmen. Das sind 256 Werte. Der ADC wird auch real in dem Bereich Werte zurückliefern, kann auch sein, dass es nur 250 Werte sind (steht genauer im Datenblatt). Mit diesen 256 verschiedenen Werten greift das Programm auf eine Tabelle zu, die nur aus 26 Werten besteht (unsigned char pwmtable[26]). Was, wenn der ADC den Wert 83 zurück gibt? Dann wird auf das 83. Element der pwmtable[] zugegriffen und das gibt es nicht, bei 25 bzw. pwmtable[25] ist nämlich Schluss (0...25 = 26 Werte). Also musst du die Tabelle auf 250/256 Werte erweitern oder aber den Rückgabewert auf den Bereich 0 bis 25 runterskalieren. Ersteres wäre sinnvoller, weil hier die Abstufung feiner ist und du am meisten dabei rausholst. Mit runterskalieren geht die Genauigkeit phlöten. Sähe ungefähr so aus:

ADC-Wert im Bereich 0 bis 4 => Rückgabewert := 0
ADC-Wert im Bereich 5 bis 9 => Rückgabewert := 1
ADC-Wert im Bereich 10 bis 14 => Rückgabewert := 2
ADC-Wert im Bereich 15 bis 19 => Rückgabewert := 3
usw.

Das ist suboptimal. Wenn das Programm aber auf das 83. Element der Tabelle zugreifen will, wird irgendein Wert aus dem Speicher gelesen, der nicht zur Tabelle gehört (Speicherzugriffsfehler oder segmentation fault/access violation, endet schonmal im Programmabsturz). Dass können andere Konstanten sein oder wenn da nichts drin steht, 0xFF = 255. Und aus der Anweisung OCR1A = 255-pwmtable[adc_read8(PC0)] wird dann z. B. OCR1A = 255-pwmtable[83] => OCR1A = 255-255 => OCR1A = 0 => LED aus (vermutlich, oder an).

EDITH: Habe da wohl Mist geschrieben... [Blockierte Grafik: http://home.arcor.de/kgenius/pix/icon_yawn.gif] schon speeeeht! Kukk mah auffe Uhr!

In der Funktion adc_read8()wird ja der Rüickgabewert auf den Bereich 0 bis 25 runterskaliert (Zeile 47), runden fällte wohl aus, weil 255 ÷ 10 = 25 sein wird. Wie auch immer, ich würde die PWM-Tabelle mit 256 Werten füllen und die gesamte Auflösung des ADC für die Dimmwerte benutzen. So wird nix verschenkt.

Counterfeiter · 27. Juli 2014

Wenn die Tabelle im Flash liegt (Progmem), dann musst du Flash Funktionen benutzen... da Flash und SRAM bei den Megas nicht im selbenAdressraum liegen...

Also entwieder die kleine Tabelle in den RAM oder die Funktion pgm_readbyt benutzen...

Hab hier totale darstellungsprobleme mit dem telefon... sorry für die RS :-/

Fakrae · 27. Juli 2014

Stimmt, da hast du natürlich völlig recht.

Zeile 36 und 37 müssen so aussehen:

Code

OCR1A = 255-pgm_read_word (& pwmtable[adc_read8(PC0)]);
OCR1B = 255-pgm_read_word (& pwmtable[adc_read8(PC1)]);

stas0 · 27. Juli 2014

Danke noch mal führ eure Mühe.
Hab eben Zeile 36 37 editiert. Geht aber immer noch nicht.
Beim Einschalten passiert jetzt gar nichts mehr bleibt alles dunkel.
Hast vielleicht noch mehr Vorschläge was ich versuchen soll.

Fakrae · 27. Juli 2014

Du kannst auch

C

#define PC1 1
#define PC0 0
#include <avr/io.h>
#include <stdio.h>
#include <avr/pgmspace.h>


unsigned int adc_read8(char channel);


int main(void)
{
    //PC4,5 output
    DDRB = (1<<DDB1) | (1<<DDB2);
    //TIMER 1
    ICR1 = 255;
    TCCR1A = (1<<COM1A1) | (1<<COM1B1) | (1<<COM1A0) | (1<<COM1B1) | (1<< WGM11); //Fast PWM, TOP = ICR1, Clear on Compare Match
    TCCR1B = (1<<WGM13) | (1<<WGM12) | (1<<CS11) | (1<<CS10); //Prescaler 64 //Fast PWM, Prescaler 256
    //ADC
    ADMUX = (1<<REFS0) | (1<<ADLAR); //VRef = AVCC
    ADCSRA = (1<<ADPS2) | (1<<ADPS1) | (1<<ADEN); // 125 kHz @ 8 Mhz, ADC enabled
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC));


unsigned int pwmtable[26] = { 0, 1,
 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 19, 24, 29, 35, 43, 52, 64, 78, 95, 
116, 141, 172, 209, 255 };


    unsigned int i = 0;
    while(1)
    {
        if (~i)
        {
            OCR1A = 255-pwmtable[adc_read8(PC0)];
            OCR1B = 255-pwmtable[adc_read8(PC1)];;
        }
        i++;
    }
}
unsigned int adc_read8(char channel)
{
    ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC));
    return (ADCH/10);
}

Alles anzeigen

versuchen - bleiben wir mit dem Array mal komplett im RAM und lassen mal die Charakters außen vor.

stas0 · 27. Juli 2014

Ja die LEDs dimmen jetzt aber sehr ruckelig schätze ma das sind nur die 26 stufen.

Wie komme ich auf die 255 Stufen?

Fakrae · 27. Juli 2014

Für 256 Stufen musst du hier { 0, 1, 2, 3, 4, 5, 6, 7, 9, 11, 13, 16, 19, 24, 29, 35, 43, 52, 64, 78, 95, 116, 141, 172, 209, 255 }
eben 256 Werte rein schreiben (aber bitte nicht 0,1,2,...,254,255 - das ist nicht logarithmisch ^^) und bei Zeile 43 das "/10" weglassen

Die werte kannst du bspw über die angehängte Exceltabelle berechnen lassen (Bei Steps 255 eintragen und dann eben am Ende so anpassen, dass kein Wert >255 vorkommt)

EDIT: und natürlich pwmtable[26] in pwmtable[256] ändern

stas0 · 27. Juli 2014

Danke Fakrae
Also habe jetzt die Tabelle wie du gesagt hast berechnet und eingefügt.
Dimmt aber immer noch in sehr sehr groben Stufen. Habt ihr noch mehr Ideen, was man machen kann??

Hier der aktuelle Code:

C

#define PC1 1
#define PC0 0
#include <avr/io.h>
#include <stdio.h>
#include <avr/pgmspace.h>
unsigned int adc_read8(char channel);
int main(void)
{
    //PC4,5 output
    DDRB = (1<<DDB1) | (1<<DDB2);
    //TIMER 1
    ICR1 = 255;
    TCCR1A = (1<<COM1A1) | (1<<COM1B1) | (1<<COM1A0) | (1<<COM1B1) | (1<< WGM11); //Fast PWM, TOP = ICR1, Clear on Compare Match
    TCCR1B = (1<<WGM13) | (1<<WGM12) | (1<<CS11) | (1<<CS10); //Prescaler 64 //Fast PWM, Prescaler 256
    //ADC
    ADMUX = (1<<REFS0) | (1<<ADLAR); //VRef = AVCC
    ADCSRA = (1<<ADPS2) | (1<<ADPS1) | (1<<ADEN); // 125 kHz @ 8 Mhz, ADC enabled
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC));
    unsigned int pwmtable[256] = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
        2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3 ,3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5,
        5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12,
        12, 13, 13, 13, 13, 14, 14, 14, 15, 15, 15, 16, 16, 16, 17, 17, 17, 18, 18, 19, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24,
        25, 25, 26, 26, 27, 28, 28, 29, 29, 30, 31, 31, 32, 33, 34, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
        50, 51, 52, 53, 54, 55, 57, 58, 59, 60, 62, 63, 65, 66, 67, 69, 70, 72, 74, 75, 77, 79, 80, 82, 84, 86, 88, 89, 91, 93, 96, 98,
        100, 102, 104, 107, 109, 111, 114, 116, 119, 121, 124, 127, 130, 133, 135, 138, 141, 145, 148, 151, 154, 158, 161, 165, 168, 172, 176, 180, 184, 188, 192, 196, 201, 205, 210, 214, 219, 224, 229, 234, 239, 244, 249, 254 };
    unsigned int i = 0;
    while(1)
    {
        if (~i)
        {
            OCR1A = 255-pwmtable[adc_read8(PC0)];
            OCR1B = 255-pwmtable[adc_read8(PC1)];;
        }
        i++;
    }
}
unsigned int adc_read8(char channel)
{
    ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC));
    return (ADCH);
}

Alles anzeigen

EDIT:
Der Sprung in der Tabelle von 1 zu 2 ist zu stark. Da fehlen die Zwischenschritte.
Hab ich die Tabelle so richtig gemacht?

Fakrae · 27. Juli 2014

Mit 8bit hast du keine Möglichkeit, den Sprung 1-> 2 weniger stark zu machen.

Ich hab jetzt nicht gezählt, aber wenn die Tabelle 256 Werte umfasst ist sie richtig

Es könnte auch sein, dass die ADC generell etwas grob auflöst, aber das kann ich von hier aus nicht sagen oder ändern.

Sabu · 27. Juli 2014

Zitat von stas0

Dimmt aber immer noch in sehr sehr groben Stufen. Habt ihr noch mehr Ideen, was man machen kann??

Ich zitiere mich mal selbst:

Zitat von Sabu

Grundsätzlich willst du mit 8 Bit dimmen. 8 Bit können max. 256 Stufen liefern (2^8 = 256). Selbst wenn du fast alle Werte auf den unteren Bereich verteilst, wirst du vermutlich immer Stufen sehen. Im unteren Bereich ist das Auge sehr empfindlich, was Helligkeitsunterschiede angeht. Daher wären mehr als 8 Bit besser.

Ergo, 8-Bit reichen nicht für eine nicht mehr sichtbare Abstufungn nicht aus. Soweit ich weiß sind dazu mindestens 10-Bit = 1024 Stufen notwendig. Es gibt eine Möglichkeit, mit einem 8-Bit AVR auch mehr als 8-Bit PWM zu erreichen. Schauste hier mal: http://www-user.tu-chemnitz.de…ikrocontroller/3PWM16.htm
Ist zwar in Assembler aber vllt. passt alles schon so wiedes haben willst.

EDITH: Schlage vor, dass du dir selber eine Lösung erarbeitest, so lernt man am meisten. Oder frag' mal Tante Guhgel.
Bzgl. ADC: Der hat eine maximale Auflösung von 10-Bit, also sollten 10-Bit vom ADC auch zu 10-Bit PWM werden.

Fakrae · 28. Juli 2014

Die Umwege von Sabu brauchen wir nicht zu gehen, weil der ATMega8 schon über einen 16bit Timer verfügt - ich werd mal bei Gelegenheit da rein schauen was wir genau ändern müssen.
(Der Timer1, der verwendet wird ist schon der 16bit Timer - aber hab grad keine Zeit mich da rein zu denken)

Fakrae · 28. Juli 2014

Code

Der Code war falsch - für richtigen Code siehe Ende dieser Seite (10bit) oder auf Seite 2 (16bit)

Wenn du jetzt noch 1024 Werte in dein Array schreibst müsste es eigentlich besser abstufen können (Auflösung vervierfacht) - ich hoffe ich habe nichts zu ändern vergessen. Ich hoffe deine Platine ist auch gut genug aufgebaut, damit du die 10bit ADC auch benutzen kannst - der ist da nämlich durchaus etwas empfindlich was Spannungssschwankungen angeht.

EDIT:Fehlerhaft, siehe nächster Beitrag.

Counterfeiter · 28. Juli 2014

Der Atmega8 hat nur 1 KB SRAM... -> Tabelle passt nicht in den RAM (1024 x 2 Byte)

Fakrae · 28. Juli 2014

Wird Zeit, dass ich mich mal wieder mit den kleineren uC beschäftige - wenn ich immer mit den großen arbeite denke ich an solch "unwichtige" Sachen wie Speicherbeschränkungen gar nicht mehr

Okay, dann müssen wir wohl doch nach dem PROGMEM / pgm_read_byte schauen. Mit welchem Programm kompilierst du denn? Vielleicht wird da die Makrofunktion nicht unterstützt.

stas0 · 28. Juli 2014

Ich benutze Atmel Studio 6.2 müsste doch die Makrofunktion unterstützen oder?

Fakrae · 28. Juli 2014

Eigentlich schon, der benutzt mittlerweile auch den normalen GCC.
Okay, vielleicht hat er sich auch an dem "uint_8t" verschluckt. Versuchen wir mal das hier - natürlich wieder das Array entsprechend aufblasen (auf 1024 Werte).

C

#define PC1 1
#define PC0 0
#include <avr/io.h>
#include <stdio.h>
#include <avr/pgmspace.h>
unsigned int adc_read16(char channel);
const unsigned int pwmtable[1024] PROGMEM = { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 3, 3, 3, 3, 3, 3, 3 ,3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 5,
 5, 5, 5, 6, 6, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 10, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12,
 12, 13, 13, 13, 13, 14, 14, 14, 15, 15, 15, 16, 16, 16, 17, 17, 17, 18, 18, 19, 19, 19, 20, 20, 21, 21, 22, 22, 23, 23, 24, 24,
 25, 25, 26, 26, 27, 28, 28, 29, 29, 30, 31, 31, 32, 33, 34, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49,
 50, 51, 52, 53, 54, 55, 57, 58, 59, 60, 62, 63, 65, 66, 67, 69, 70, 72, 74, 75, 77, 79, 80, 82, 84, 86, 88, 89, 91, 93, 96, 98,
 100, 102, 104, 107, 109, 111, 114, 116, 119, 121, 124, 127, 130, 133, 135, 138, 141, 145, 148, 151, 154, 158, 161, 165, 168, 172, 176, 180, 184, 188, 192, 196, 201, 205, 210, 214, 219, 224, 229, 234, 239, 244, 249, 254 };
int main(void)
{
    //PC4,5 output
    DDRB = (1<<DDB1) | (1<<DDB2);
    //TIMER 1
    TCCR1A = (1<<COM1A1) | (1<<COM1B1) | (1<<COM1A0) | (1<<COM1B0) | (1<< WGM11) | (1<<WGM10); //10bit Fast PWM, TOP = 10bit (1023), Clear on Compare Match
    TCCR1B = (1<<WGM12) | (1<<CS11); //Prescaler 8 //Fast PWM @1Khz
    //ADC
    ADMUX = (1<<REFS0); //VRef = AVCC
    ADCSRA = (1<<ADPS2) | (1<<ADPS1) | (1<<ADEN); // 125 kHz @ 8 Mhz, ADC enabled
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC));

    unsigned int i = 0;
    while(1)
    {
        if (~i)
        {
unsigned int valueForPC0 = pgm_read_word(&pwmtable[adc_read16(PC0)]);
unsigned int valueForPC1 = pgm_read_word(&pwmtable[adc_read16(PC1)]);
            OCR1A = 1023-valueForPC0;
            OCR1B = 1023-valueForPC1;
        }
        i++;
    }
}
unsigned int adc_read16(char channel)
{
    ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC));
    return (ADC);
}

Alles anzeigen

0-5 V in PWM mit ATmega

Teilen

Benutzer online in diesem Thema