Hallo, ich möchte eine LED an meinem Atmega8 automatisch dimmen lassen. ich krieg das aber nicht so ganz hin. ich möchts ganz einfach mit delay programmieren, das sich bei jeder ms einfach erhöht. zeiten passen noch nicht so ganz. das ganze startet wenn ich an pc6 den schalter betätige. die leds hängen auf PortD. danke #define F_CPU 1000000UL #include <avr/io.h> #include <delay.h> uint16_t dimmzeit (void)// ich möcht das sich x mit jeder millisekunde um 10 erhöht bis es 1000 erreicht hat { unsigned char wert; unsigned char x; while (PINC&(1<<PINC5)); wert = x; for (x=1;x<=1000;x+10) _delay_ms(1); if (x=1000){x=1}; return wert; } int main(void) { Init(); DDRD = 0xFF; DDRC = 0x00; unsigned int x; while(1){ if (PINC&(1<<PINC5)){ PORTD= 0xFF; _delay_ms (1000); PORTD= 0x00; _delay_ms (x);} else { PORTD= 0x00;}} return 0; }
> das ganze startet wenn ich an pc6 den > schalter betätige. die leds hängen auf PortD. pc6 passt nicht zu dem Code unten. Dort wird pc5 verwendet. Originalcode etwas formatiert und kommentiert:
1 | #define F_CPU 1000000UL
|
2 | #include <avr/io.h> |
3 | #include <util/delay.h> // <=== |
4 | |
5 | // ich möcht das sich x mit jeder millisekunde
|
6 | // um 10 erhöht bis es 1000 erreicht hat
|
7 | |
8 | uint16_t dimmzeit (void) |
9 | {
|
10 | unsigned char wert; |
11 | unsigned char x; |
12 | |
13 | while (PINC&(1<<PINC5)); |
14 | |
15 | wert = x; |
16 | for (x=1;x<=1000;x+10) |
17 | _delay_ms(1); |
18 | |
19 | if (x=1000) // <=== ist wohl == gemeint |
20 | x = 1; |
21 | |
22 | return wert; |
23 | }
|
24 | |
25 | |
26 | int main(void) |
27 | {
|
28 | unsigned int x; |
29 | |
30 | Init(); |
31 | |
32 | DDRD = 0xFF; |
33 | DDRC = 0x00; |
34 | |
35 | while(1){ |
36 | if (PINC&(1<<PINC5)){ |
37 | PORTD = 0xFF; |
38 | _delay_ms (1000); // so grosses Argument (1000 ms = |
39 | // 1 Sekunde) funktioniert
|
40 | // nur bei avr-libc >= 1.6
|
41 | PORTD = 0x00; |
42 | _delay_ms (x); // zur Compilezeit undefiniertes Argument |
43 | // ist ein no-no!
|
44 | |
45 | } else { |
46 | PORTD = 0x00; |
47 | }
|
48 | }
|
49 | |
50 | return 0; |
51 | }
|
Für exakte Änderungen sind zuwenig Infos in der Frage. Wann sind die LEDS AN und wann AUS?. Soll das Dimmen nur bei gedrückter Taste laufen? Sind die LEDs vor dem Dimmen AN oder AUS? Hier wie man vielleicht vorgehen könnte:
1 | #define F_CPU 1000000UL
|
2 | #include <avr/io.h> |
3 | #include <util/delay.h> |
4 | |
5 | void dimmzeit(unsigned int x) |
6 | {
|
7 | while(x--) |
8 | _delay_ms(1); |
9 | }
|
10 | |
11 | int main(void) |
12 | {
|
13 | unsigned int x = 0; |
14 | |
15 | DDRD = 0xFF; // Alle PORTD Ausgang |
16 | DDRC = 0x00; // Alle PINC Eingang |
17 | |
18 | while(1) |
19 | {
|
20 | if ((PINC & (1<<PINC5))) |
21 | {
|
22 | PORTD = 0xFF; |
23 | _delay_ms (1000); |
24 | PORTD = 0x00; |
25 | x += 10; |
26 | dimmzeit(x); |
27 | if (x >= 1000) x = 0; |
28 | } else |
29 | PORTD = 0x00; |
30 | }
|
31 | |
32 | return 0; |
33 | }
|
hi, danke für die hilfe. kann ich den code auch irgendwie ändern, so dass ich die leds dimmen kann bis sie aus sind. also von ganz hell bis dunkel. probier nämlich schon seit drei stunden und den code von led-fadding kappier ich noch nicht so ganz. bin noch nicht so fit in c. danke mfg
öhm, nur kurz nen hinweis. der wertebereich von nem unsigned char ist 0-255 wenn ich nicht irre, wenn ihr jetzt eine schleife von 1 bis 100 laufen lasst, sollte das eigentlich nicht so richtig funktionieren.... hm
Ich würde das mal so angehen. Dimmen bedeutet, dass es erst mal möglich sein muss eine Led auf eine (fast) beliebige Helligkeitsstufe zu setzen. Daher würde ich damit mal anfangen: Eine Led auf eine bestimmte Helligkeitsstufe zu setzen. Da das ganze mit _delay_ms gemacht werden soll, ist als erstes mal eine Funktion notwendig, die eine bestimmte Zeit in ms abwarten kann.
1 | void Delay( uint8_t ms ) |
2 | {
|
3 | while( ms > 0 ) { |
4 | _delay_ms( 1 ); |
5 | --ms; |
6 | }
|
7 | }
|
Soweit so gut. Wie wird eine LED gedimmt? Sie wird dadurch gedimmt, dass das Verhältnis von Einschalt zu Ausschaltzeit variiert wird. Ist die Led lange ein aber nur kurz aus, dann leuchtet sie heller als wie wenn sie nur kurz ein aber lange aus ist. Das heist, in einer bestimmten Zeiteinheit x ist die Led y Zeiteinheiten ein und x-y Zeiteinheiten aus. Als Basiszeit nehme ich mal 50ms. D.h. die LED durchläuft so einen ein/aus Zyklus 20 mal in der Sekunde. Das wird zwar noch zu einem gewissen Flackern führen, ist aber fürs Testen erst mal gar nicht so schlecht und mit Millisekunden erst mal auch nicht anders machbar. Wir wollen ja auch genügend Helligkeits- stufen für die LED haben.
1 | void LedZyklus( uint8_t OnTime ) |
2 | {
|
3 | if( OnTime > 0 ) { |
4 | // Led ein
|
5 | PORTD = 0x00; |
6 | // OnTime abwarten
|
7 | Delay( OnTime ); |
8 | }
|
9 | |
10 | if( OnTime < 50 ) { |
11 | // Led aus
|
12 | PORTD = 0xFF; |
13 | // Aus-Zeit abwarten
|
14 | Delay( 50 - OnTime ); |
15 | }
|
16 | }
|
Ein Aufruf der Funktion LedZyklus dauert 50 Millisekunden (und ein paar Zerquetschte) und zwar unabhängig davon, wie 'hell' die Led leuchten soll. Das ist es mir schon mal wert, dafür ein Testprogramm zu schreiben um zu sehen, ob das auch funktioniert.
1 | int main() |
2 | {
|
3 | DDRD = 0xFF; // auf Ausgang |
4 | |
5 | while( 1 ) |
6 | LedZyklus( 10 ); // Led soll nur schwach leuchten |
7 | }
|
Wenn ich jetzt keinen Tippfehler gemacht habe, dann sollte die Led am Port D dunkel leuchten (flackern). Durch Variation der 10 beim Aufruf von LedZyklus sollten sich verschiedene Werte einstellen lassen. Ausprobieren! Bei einem Aufruf
1 | LedZyklus( 0 ); |
dürfte die Led überhaupt nicht leuchten, während sie bei
1 | LedZyklus( 50 ); |
mit voller Kraft leuchten sollte. Werte dazwischen führen zu verschiedenen Helligkeitsstufen. Das ist ja schon mal ein Anfang. Um die Led zu dimmen, genügt es daher, diesen Wert laufend zu ändern. Zb. indem man ihn in der Schleife variiert:
1 | int main() |
2 | {
|
3 | uint8_t UpDown; |
4 | uint8_t Level; |
5 | |
6 | DDRD = 0xFF; // alles auf Ausgang |
7 | |
8 | Level = 0; |
9 | UpDown = 0; |
10 | |
11 | while( 1 ) { |
12 | LedZyklus( Level ); |
13 | |
14 | if( UpDown == 0 ) { // Led soll heller werden |
15 | if( Level >= 50 ) // Obere Grenze erreicht ? |
16 | UpDown = 1; // Ja: Auf dunkler werden umschalten |
17 | else
|
18 | Level += 1; // Nein: Na dann mach sie heller |
19 | }
|
20 | |
21 | else { // Led soll dunkler werden |
22 | if( Level == 0 ) // Untere Grenze erreicht ? |
23 | UpDown = 0; // Ja: Auf heller werden umschalten |
24 | else
|
25 | Level -= 1; // Nein: Na dann mach sie dunkler |
26 | }
|
27 | }
|
28 | }
|
Damit sollte die Led dann eigentlich laufend dunkler/heller werden. Von da weg, ist es nur noch ein kleiner Schritt einen Taster mit einzubauen. Ich denke das Hauptproblem des OP ist dasselbe, dass viele Einsteiger haben: Ihr versucht immer zuviel in main() hinein- zupacken. Schreibt euch Funktionen für Teilaufgaben! Dadurch wird die Entwicklung sehr viel einfacher und auch wesentlich überschaubarer. In diesem konkreten Fall besteht der Trick darin, die effektive Helligkeitseinstellung von der Dimmerei zu trennen.
vielen Dank. Endlich hat mir das mal jemand verständlich erklärt. super. funktioniert auch prima
eine Frage noch. was bedeutet "--ms;". was besagt das? danke
@ roadrunner2008 (Gast)
>was bedeutet "--ms;".
Die Variable ms wird ums eins verringert.
Mfg
Falk
wie ist es dann möglich, dass ich zwei leds nacheinander heller bzw. dunkler werden. LED1 heller - LED1 dunkler - LED2 heller - LED2 dunkler hab bei LEDZyklus eine kopie gemacht für die zweite LED. und dieses dann nacheinander laufen lassen. doch bei mir laufen beide gleich los. hangt damit zusammen dass ich beides in eine while-schleife gepackt hab. wie kann ich das lösen?
Wenn du mein Programm weiterverwenden willst, dann kannst du das zb. so machen * Anstelle von einem Level, gibt es deren 2. Für jede Led eine eigene. Level1 und Level2 * Die Variable UpDown wird in ihrer Bedeutung etwas umgedreht. Anstelle von 2 Zuständen, bekommt sie jetzt 4. Dabei bedeutet 0 ... Led 1 soll heller werden 1 ... Led 1 soll dunkler werden 2 ... Led 2 soll heller werden 3 ... Led 2 soll dunkler werden Probleme wird es allerdings dadurch geben, dass du dann mit der Zykluszeit nicht mehr vernünftig hin kommen wirst. Mit Millieskunden wird das ohne heftiges Geblinke nichts mehr werden.
gibt es denn noch eine andere möglichkeit das zu programmieren.
Sicher. Die PWM mit Hardwareunterstützung machen. Entweder (wenns nur wenige Kanäle sind) einen Timer eine PWM erledigen lassen, oder einen Timer mit einer ISR zusammenspannen, die dann die einzelnen PWM Kanäle bedient. Das dimmen an sich geht dann wieder wie gehabt, zb durch delays (wenn der Proz sonst nichts zu tun hat). So wie es zb hier gemacht wurde http://www.mikrocontroller.net/articles/AVR-Tutorial:_SRAM
hab jetzt mal mein programm verändert aber es klappt nicht so ganz. liegt es daran dass ich in der while schleife nur 1 oder 0 lesen kann? Es leuchtet nur portD1 #define F_CPU 1000000UL #include <avr/io.h> #include <util/delay.h> void Delay( uint8_t ms ) { while( ms > 0 ) { _delay_us( 200 ); --ms; } } void LedZyklus1( uint8_t OnTime ) { if( OnTime > 0 ) { // Led ein PORTD = 0x00; // OnTime abwarten Delay( OnTime ); } if( OnTime < 120 ) { // Led aus PORTD = 0x01; // Aus-Zeit abwarten Delay( 120 - OnTime ); } } void LedZyklus2( uint8_t OnTime2 ) { if( OnTime2 > 0 ) { // Led ein PORTD = 0x00; // OnTime abwarten Delay( OnTime2 ); } if( OnTime2 < 120 ) { // Led aus PORTD = 0x02; // Aus-Zeit abwarten Delay( 120 - OnTime2 ); } } int main() { uint8_t UpDown; uint8_t Level; uint8_t Level2; DDRD = 0xFF; // alles auf Ausgang Level = 1; // da ich sonst probleme bekomm beim umschalten auf die zweite LED Level2 = 0; UpDown = 0; while(1){ while(Level >1 ){ LedZyklus1( Level ); { if( Level < 120 ) {Level += 1;} // Led1 soll heller werden if( Level >= 120 ) // Obere Grenze erreicht ? {Level -=1;} // Ja: Auf dunkler werden umschalten }return (Level); } while(Level <= 1){ LedZyklus2( Level2 ); { if( Level2 < 120 ) {Level2 += 1;} // Led2 soll heller werden if( Level2 >= 120 ) // Obere Grenze erreicht ? {Level2 -=1;} // Ja: Auf dunkler werden umschalten } return (Level); } } }
bin selber noch anfänger. aber ich hab dieses Programm gerade ausprobiert. Da ist zwar irgendwo noch ein Fehler drin, weil die LED's nicht langsam heller werden sondern gleich angehen. aber danach dimmen sie langsam und dies nacheinander. vielleicht kann jemand hier den code mal durchschauen, wo der Fehler liegt viel spass
1 | #define F_CPU 1000000UL
|
2 | #include <avr/io.h> |
3 | #include <util/delay.h> |
4 | |
5 | void Delay( uint8_t ms ) |
6 | {
|
7 | while( ms > 0 ) { |
8 | _delay_us( 200 ); |
9 | --ms; |
10 | }
|
11 | }
|
12 | |
13 | void LedZyklus1( uint8_t OnTime ) |
14 | {
|
15 | if( OnTime > 0 ) { |
16 | // Led ein
|
17 | PORTD = 0x00; |
18 | // OnTime abwarten
|
19 | Delay( OnTime ); |
20 | }
|
21 | |
22 | if( OnTime < 120 ) { |
23 | // Led aus
|
24 | PORTD = 0x01; |
25 | // Aus-Zeit abwarten
|
26 | Delay( 120 - OnTime ); |
27 | }
|
28 | }
|
29 | |
30 | void LedZyklus2( uint8_t OnTime2 ) |
31 | {
|
32 | if( OnTime2 > 0 ) { |
33 | // Led ein
|
34 | PORTD = 0x00; |
35 | // OnTime abwarten
|
36 | Delay( OnTime2 ); |
37 | }
|
38 | |
39 | if( OnTime2 < 120 ) { |
40 | // Led aus
|
41 | PORTD = 0x02; |
42 | // Aus-Zeit abwarten
|
43 | Delay( 120 - OnTime2 ); |
44 | }
|
45 | }
|
46 | |
47 | int main() |
48 | {
|
49 | uint8_t UpDown; |
50 | uint8_t Level; |
51 | uint8_t Level2; |
52 | |
53 | DDRD = 0xFF; // alles auf Ausgang |
54 | |
55 | Level = 0; // da ich sonst probleme bekomm beim umschalten auf die zweite LED |
56 | Level2 = 0; |
57 | UpDown = 0; |
58 | while(1){ |
59 | |
60 | while(Level <=120 ){ |
61 | |
62 | LedZyklus1( Level ); |
63 | Level += 1;} // Led1 soll heller werden |
64 | |
65 | while(Level =0 ){ |
66 | LedZyklus1( Level ); // Obere Grenze erreicht ? |
67 | Level -=1;} // Ja: Auf dunkler werden umschalten |
68 | |
69 | while(Level2 <= 120){ |
70 | LedZyklus2( Level2 ); |
71 | Level2 += 1;} // Led2 soll heller werden |
72 | |
73 | while(Level2 = 0){ |
74 | LedZyklus2( Level2 ); // Obere Grenze erreicht ? |
75 | Level2 -=1;}// Ja: Auf dunkler werden umschalten |
76 | }
|
77 | }
|
okay habs,
1 | #define F_CPU 1000000UL
|
2 | #include <avr/io.h> |
3 | #include <util/delay.h> |
4 | |
5 | void Delay( uint8_t ms ) |
6 | {
|
7 | while( ms > 0 ) { |
8 | _delay_us( 200 ); |
9 | --ms; |
10 | }
|
11 | }
|
12 | |
13 | void LedZyklus1( uint8_t OnTime ) |
14 | {
|
15 | if( OnTime > 0 ) { |
16 | // Led ein
|
17 | PORTD = 0x00; |
18 | // OnTime abwarten
|
19 | Delay( OnTime ); |
20 | }
|
21 | |
22 | if( OnTime < 120 ) { |
23 | // Led aus
|
24 | PORTD = 0x01; |
25 | // Aus-Zeit abwarten
|
26 | Delay( 120 - OnTime ); |
27 | }
|
28 | }
|
29 | |
30 | void LedZyklus2( uint8_t OnTime2 ) |
31 | {
|
32 | if( OnTime2 > 0 ) { |
33 | // Led ein
|
34 | PORTD = 0x00; |
35 | // OnTime abwarten
|
36 | Delay( OnTime2 ); |
37 | }
|
38 | |
39 | if( OnTime2 < 120 ) { |
40 | // Led aus
|
41 | PORTD = 0x02; |
42 | // Aus-Zeit abwarten
|
43 | Delay( 120 - OnTime2 ); |
44 | }
|
45 | }
|
46 | |
47 | int main() |
48 | {
|
49 | |
50 | uint8_t Level; |
51 | uint8_t Level2; |
52 | |
53 | DDRD = 0xFF; // alles auf Ausgang |
54 | |
55 | Level = 0; // da ich sonst probleme bekomm beim umschalten auf die zweite LED |
56 | Level2 = 0; |
57 | |
58 | while(1){ |
59 | |
60 | while(Level >0 ){ |
61 | LedZyklus1( Level ); // Obere Grenze erreicht ? |
62 | Level -=1;} // Ja: Auf dunkler werden umschalten |
63 | |
64 | while(Level <=120 ){ |
65 | |
66 | LedZyklus1( Level ); |
67 | Level += 1;} // Led1 soll heller werden |
68 | |
69 | while(Level2 > 0){ |
70 | LedZyklus2( Level2 ); // Obere Grenze erreicht ? |
71 | Level2 -=1;}// Ja: Auf dunkler werden umschalten |
72 | |
73 | |
74 | while(Level2 <= 120){ |
75 | LedZyklus2( Level2 ); |
76 | Level2 += 1;} // Led2 soll heller werden |
77 | |
78 | }
|
79 | }
|
roadrunner2008 wrote:
Standardfehler
Das hier
> while(Level =0 ){
ist kein Vergleich, sondern eine Zuweisung.
Du willst auch nicht auf gleich 0 vergleichen, sondern auf
ungleich 0
while( Level != 0 )
Ist das nur bei mir so, oder flackert die Led bei euch auch so? mfg
Hallo... Ich habe den C-Code von oben erweitert auf 4 LEDs und das Flackern entfernen können. Das ganze schaut schon ganz schön aus, jedoch ist es ein wenig unschön, dass die LEDs nur der Reihe nach an und aus "faden". Besserer wäre es, wenn man zwei LEDs hintereinander andimmen lassen kann und dass dann wenn die dritte angeht, die erste ausgeht... zeitgleich spielt keine rolle. So ungefähr: LED1 an, LED2 an, Led3 an, LED1 aus, LED4 an, LED2 aus, LED1 an.... etc. Ich weiss, dass dieses Thema schon ein paar Jährchen auf dem Rücken hat... aber vielleicht kann ja trotzdem noch einer helfen :) Hier noch mein C-Code:
1 | #define F_CPU 1000000UL
|
2 | #include <avr/io.h> |
3 | #include <util/delay.h> |
4 | |
5 | int ledzeit; |
6 | |
7 | ledzeit = 19; |
8 | |
9 | void Delay( uint8_t ms ) |
10 | {
|
11 | while( ms > 0 ) { |
12 | _delay_us( 400 ); |
13 | --ms; |
14 | }
|
15 | }
|
16 | |
17 | void LedZyklus1( uint8_t OnTime ) |
18 | {
|
19 | if( OnTime > 0 ) { |
20 | // Led ein
|
21 | PORTB = (0 << DDB4); |
22 | Delay( OnTime ); |
23 | }
|
24 | |
25 | if( OnTime < ledzeit ) { |
26 | // Led aus
|
27 | PORTB = (1 << DDB4); |
28 | Delay( ledzeit - OnTime ); |
29 | }
|
30 | }
|
31 | |
32 | void LedZyklus2( uint8_t OnTime2 ) |
33 | {
|
34 | if( OnTime2 > 0 ) { |
35 | // Led ein
|
36 | PORTB = (0 << DDB3); |
37 | Delay( OnTime2 ); |
38 | }
|
39 | |
40 | if( OnTime2 < ledzeit ) { |
41 | // Led aus
|
42 | PORTB = (1 << DDB3); |
43 | Delay( ledzeit - OnTime2 ); |
44 | }
|
45 | }
|
46 | |
47 | void LedZyklus3( uint8_t OnTime3 ) |
48 | {
|
49 | if( OnTime3 > 0 ) { |
50 | // Led ein
|
51 | PORTB = (0 << DDB2); |
52 | Delay( OnTime3 ); |
53 | }
|
54 | |
55 | if( OnTime3 < ledzeit ) { |
56 | // Led aus
|
57 | PORTB = (1 << DDB2); |
58 | Delay( ledzeit - OnTime3 ); |
59 | }
|
60 | }
|
61 | |
62 | void LedZyklus4( uint8_t OnTime4 ) |
63 | {
|
64 | if( OnTime4 > 0 ) { |
65 | // Led ein
|
66 | PORTB = (0 << DDB1); |
67 | Delay( OnTime4 ); |
68 | }
|
69 | |
70 | if( OnTime4 < ledzeit ) { |
71 | // Led aus
|
72 | PORTB = (1 << DDB1); |
73 | Delay( ledzeit - OnTime4 ); |
74 | }
|
75 | }
|
76 | |
77 | int main() |
78 | {
|
79 | |
80 | uint8_t Level; |
81 | uint8_t Level2; |
82 | uint8_t Level3; |
83 | uint8_t Level4; |
84 | |
85 | DDRB = 0b00011110; |
86 | |
87 | Level = 19; // kein Flackern der LEDs bei 19 |
88 | Level2 = 19; |
89 | Level3 = 19; |
90 | Level4 = 19; |
91 | |
92 | while(1){ |
93 | |
94 | while(Level >0 ){ |
95 | LedZyklus1( Level ); // Obere Grenze erreicht ? |
96 | Level -= 1;} // Ja: Auf dunkler werden umschalten |
97 | |
98 | while(Level <= ledzeit ){ |
99 | LedZyklus1( Level ); |
100 | Level += 1;} // Led1 soll heller werden |
101 | |
102 | while(Level2 > 0){ |
103 | LedZyklus2( Level2 ); // Obere Grenze erreicht ? |
104 | Level2 -= 1;} // Ja: Auf dunkler werden umschalten |
105 | |
106 | while(Level2 <= ledzeit){ |
107 | LedZyklus2( Level2 ); |
108 | Level2 += 1;} // Led2 soll heller werden |
109 | |
110 | while(Level3 > 0){ |
111 | LedZyklus3( Level3 ); // Obere Grenze erreicht ? |
112 | Level3 -= 1;} // Ja: Auf dunkler werden umschalten |
113 | |
114 | while(Level3 <= ledzeit){ |
115 | LedZyklus3( Level3 ); |
116 | Level3 += 1;} // Led3 soll heller werden |
117 | |
118 | while(Level4 > 0){ |
119 | LedZyklus4( Level4 ); // Obere Grenze erreicht ? |
120 | Level4 -= 1;} // Ja: Auf dunkler werden umschalten |
121 | |
122 | while(Level4 <= ledzeit){ |
123 | LedZyklus4( Level4 ); |
124 | Level4 += 1;} // Led4 soll heller werden |
125 | |
126 | }
|
127 | }
|
Habe dir hier mal kurz ein kleines Beispiel zusammen geschrieben für eine ADC wandlung und die dazu gehörige PWM. Unter Umständen könnte dir das helfen:
1 | void ADC_Init() { |
2 | ADCSRA |= (1 << ADEN) | (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0); // Aktiviere ADC, setze ADC Prescaler auf 128 |
3 | ADMUX |= (1 << REFS0); // Setze Referenzspannung auf AVCC |
4 | }
|
5 | |
6 | uint16_t ADC_Read(uint8_t channel) { |
7 | ADMUX = (ADMUX & 0xF0) | (channel & 0x0F); // Wähle den ADC Kanal |
8 | ADCSRA |= (1 << ADSC); // Starte die ADC Konvertierung |
9 | while (ADCSRA & (1 << ADSC)); // Warte bis die Konvertierung abgeschlossen ist |
10 | return ADC; // Gib den ADC-Wert zurück |
11 | }
|
12 | |
13 | void PWM_Init() { |
14 | TCCR0A = (1 << COM0A1) | (1 << WGM01) | (1 << WGM00); // Konfiguriere Timer 0 für Fast PWM Modus |
15 | TCCR0B = (1 << CS01); // Setze Prescaler auf 8 (entspricht einer PWM-Frequenz von F_CPU/8/256) |
16 | DDRD |= (1 << PD6); // Setze PD6 (Pin 6) als Ausgang für PWM |
17 | }
|
18 | |
19 | void SetPWM(uint8_t dutyCycle) { |
20 | OCR0A = dutyCycle; // Setze PWM Duty Cycle |
21 | }
|
[Mod: C-Tags eingefügt]
:
Bearbeitet durch Moderator
Stefan H. schrieb: > Habe dir hier mal kurz ein kleines Beispiel zusammen geschrieben Kaum 16 Jahre später nachdem der Thread ins Leben gerufen wurde. Ja, manchmal brauchen Entwicklungen halt a bisserl länger ....
Bitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.