Hallo, Hier mein fertiges funktionierendes BASCOM Programm zum Steuern einer Vollfarb RGB-LED über die serielle Schnittstelle. Ich habe dazu ein PC Programm geschrieben welches mit enthalten ist. Der Quelltext ist einfach und kommentiert. Es wurde der Hardware PWM genommen mit Timer 1 und 2. Bei Fragen einfach posten. Ist für den ATmega8 kann aber leicht auf so ziemlich alle µC's mit 3 PWM Kanälen umgestrickt werden.
War ein kleiner Fehler im PC-Programm der aber keinen Einfluss auf die Funktion hatte. Es wurden nur die Zahlen an der Seite falsch angezeigt.
Hier mal ein besseres umfangreicheres Programm. Einstellbar sind: - 0-255 per Scrollleiste alle drei Grundfarben - Neu:Der Maximalwert jeder Farbe ist einstellbar um Hellere LEDs den anderen anzugleichen - Neu: Grundfarben per Knopfdruck
> Feedback wäre toll^^ BASCOM - bäh!!! Ansonsten, ziemlich einfaches programm. Gehe mal auch ungesehen davon aus, dass es gut funktioniert ;) Gibt's nicht viel zu sagen dazu - ausser natürlich das man es mit mehr Aufwand natürlich besser machen könnte (Tabelle um die LED logarithmisch an zu steuern, > 8 bit software PWM, mehrere LEDs) Bei der PC software wäre es toll, wenn man auch in HSV seine farbe wählen kann, eine farbvorschau wäre gut und wenn man den COM port wählen könnte wäre das auch super. Auch könntest du den source der PC software hier auch hoch laden.
Ich hab das mit Borland C++ Builder geschrieben. Daher müsste ich alle Dateien veröffentlichen nicht nur einen Source Code. Software PWM ist an sich ne super Idee. Hätte ich auch sofort gemacht, wenn ich gewusst hätte wie (weiß ich immer noch nicht). COM-Port Auswahl mache ich noch rein. Farbvorschau hatte ich auch geplant aber dazu fällt mir nur die Canvas Klasse ein und die habe ich noch nie verstanden obwohl ich mir 100 Mal durchgelesen habe wie die funktioniert. Den Logarythmus wollte ich auch per Tabelle machen aber dazu bräauchte ich ne Kurve von den LED's, die ich nicht habe :( Aber danke. War auf jedefall sehr konstruktiv.
PWM in software ist ganz einfach: 1) Einen Zähler bauen, der mit "highspeed" (je schneller, desto weniger Flackern der LED) hoch zählt bis zB 255 für 8 bit. Das kannst du in der Hauptschleife deines Programms machen 2) Den Zähler mit dem PWM Wert (zB Farbwert deiner LED) vergleichen. Wenn der Zähler unter dem PWM Wert ist leuchtet die LED, ist er dadrüber leuchtet sie nicht. Wieviel da mit BASCOM zu machen ist weiss ich nicht... sollte aber schon ein bischen was gehen. Für farbvorschau reicht es ja schon, wenn du die Hintergrundfarbe eines Fensterelements auf die mit den Slidern ausgewählte Farbe setzt.
> 1) ... Das kannst du in der Hauptschleife deines Programms machen Kann man. Ist aber in der Praxis keine so gute Idee. Denn dann kannst du in der Hauptschleife sonst nichts anderes mehr machen ohne, dass die LED unschön flackert, wenn diese zusätzliche Funktionalität zuschlägt. Besser ist es, diese PWM-Funktionalität in einen Timerinterrupt auszulagern. Dann hat man natürlich das Problem, dass der Timer die PWM-Frequenz noch mal runtersetzt. Mit einem Timer im CTC Modus hält sich dann auch die Verringerung der PWM Frequenz in Grenzen.
Warum sollte ich ein 8 Bit Software PWM machen? Dadurch gibts mehr Code und alles wird unübersichtlicher. Da ist der Hardware PWM wie ich finde besser geeignet. Mehrere LEDs brauche ich nicht. Eine RGB LED hat numal nur 3 davon. Vlt. Kommt ja noch die Erleuchtung warum Software PWM besser ist. Wegen HSV. Ich habe mir bei Wikipedia mal den HSV-Farbraum angeguckt. Durch die Umrechnung steige ich noch nicht so ganz durch. Ist komplizierter als ich dachte. Aber ich werde es weiter versuchen. Vieleicht hat ja noch jemand einen Tipp wegen der Umrechnung von HSV zu RGB dann kann man HSV einstellen und es wird in RGB umgewandlet und an den µC geschickt. Und Vlieleicht hat noch jemand einen Tipp zum logarithmus von LEDs damit ich ne Tabelle anlegen kann. Ich habe vor die Tabelle ins PC Programm zu machen nud nicht in den µC. Gruß Robin T.
Hallo. Ich wurde daruaf hingewiesen dass ich keine Angaben zur Hardware gemacht habe. Das tut mir leid. Ich dachte es wäre aud den Bascom Quelltext genug ersichtlich. Aber hier einmal die Anschlussbelegung. PORTB.1 = Anode-Rot PORTB.2 = Anode-Grün PORTB.3 = Anode-Blau Hoffe das hilft. Gruß Robin T.
Hast du noch diesen Quellcode in C++ den du geschrieben hast??
Das war mit C++ Builder. Da ist ein ganzer Ordner mit Projektdateien, Formdaten und Quellcode
Kannst du mir sagen wie die Daten, die über die RS232 Schnittstelle versendet werden, aussehen? Welche Informationen muss ich wie übertragen? Ich möchte mir nämlich in VisualBasic.net ein eigenes kleines Programm schreiben, dass einen automatischen Farbverlauf generiert.
Er überträgt: 0-255 0-255 0-255 Also jede Farbe in 255 Schritten durch ein Leerzeichen getrennt.
Vielen Dank :-) Ich werde das demnächst mal ausprobieren. Dein Programm für den ATmega8 finde ich klasse. Funktioniert bei mir einwandfrei.
bei mir bringt er beim compilieren einen assigment error bei compare2 = blau... was kann ich da machen??? Gruß Flo
LIGHT_MASTER wrote: > bei mir bringt er beim compilieren einen assigment error bei compare2 = > blau... > > was kann ich da machen??? > > Gruß Flo BASCOM programmier ich jetzt schon ne ganze Ewigkeit nicht mehr. Keine Ahnung was das heißt. Hab die Sprache komplett verlernt :)
das is jetz aber verdammt schlecht... ich bräuchte dieses programm wirklich dringend da ich damit meine wohnzimmerbeleuchtung realisieren will.... Gruß Flo
So... ich hab den Code jetz mal so gut ich konnte abgeändert.... was ich zuminderst rausgefunden hab ist, das du den dritten hardPWM Kanal falsch geschrieben hattest...du hast Compare2 statt OCR2 geschrieben aber er funktioniert immer noch nicht... vielleicht könntest du oder jemand anders nochmal drüber schauen warum er nicht funktioniert denn ich weis hier nicht mehr weiter... Danke schon mal im vorraus... Gruß Flo
Hallo Robin, Ich find das programm echt super, könnest du vieleicht den source code bzw denn entsprechenden ordner in ein zip datei packen und posten ? Ist doch in Visual Studio erstellt oder ? MFG Daniel
Daniel wrote: > Hallo Robin, > > Ich find das programm echt super, könnest du vieleicht den source code > bzw denn entsprechenden ordner in ein zip datei packen und posten ? > > Ist doch in Visual Studio erstellt oder ? > > MFG Daniel Erstellt habe ich das mit Borland C++ Builder 6. Leider ist der Sourcecode beim letzen PC säubern verloren gegangen. Gruß Robin T.
Weiß jemand wie ich die RGB Leds über usb steuern kann geht das auch mit diesem Program weil ich habe keinen <<<<druckerport mehr an meinem rechner würde mich echt über Zahlreiche mails freuen.
Parallelport? RS232 ist Seriell... Benutz im schlimmsten fall einen USB->RS232 Wandler :)
heyy leute, ich kenn mich in dem gebiet programmieren nicht soo gut aus, deswegen wollte ich fragen, ob einer von euch evtl ne skizze von der schaltung machen könnte, dh wie man was verkabet un welche hardware man soo braucht. Wäre darüber seht dankbar, Leon
@ robin anbei ein kleines selberprogrammiertes programm das hsv in rgb umwandelt. zusätzlich auch gleich die kommunikation mit dem µc mit rs232. gleiche sendereihenfolge wie in deiner software: 0-255 0-255 0-255 allso immer ein leerzeichen dazwischen. dein programm für den atmega8 hab ich getestet. funktioniert bei mir nicht. wie schaut es mit den fuses aus.? lg
Das ist ja schon ein super programm nur ich brauche sowas für den usb anschluss geht das auch oder ist sowas nicht machbar ich habe von sowas leider geine ahnugn aber ein paar wunderschöne led leisten. Und möchte die schön gestalten also vielleicht eine bauskizze der steuerung anbei oder was ich dafür benötige wäre echt super wenn mir da einer helfen könnte.
ich möchte RGB LEDs am pc steuern und brauche das Programm und eine Anleitung dafür und wissen wie ich die LEDs am pc Anschließe.Bitte schickt mir alle Infos und ein Programm an pascal.waleska@yahoo.de.Ich hoffe ihr hilft mir zahlreich bis dann.XD
Ich bin auch grad dabei mit RGBs zu bauen, funktioniert auch schon super. Aber nun hab ich euer Steuerprogsgesehen, und würde mir gerne mal den Source dazu ansehen, oder zumindest Infos wo ich Wissen darüber herbekomme^^ Lg Heiko
Heiko K. schrieb: > Ich bin auch grad dabei mit RGBs zu bauen, funktioniert auch schon > super. > Aber nun hab ich euer Steuerprogsgesehen, und würde mir gerne mal den > Source dazu ansehen, oder zumindest Infos wo ich Wissen darüber > herbekomme^^ > > Lg Heiko schau im ersten Eintrag im Anhang ist alles das du brauchst.
Es geht mir weniger um den Bascom Source sondern um das Programm in Windows ich möchte mir son Programm nachbauen, um damit meine Wohnzimmerbeleuchtung zu steuern lg Heiko
Das ist schon mal genau das was ich suche^^ Leider in C, und das kann ich kaum, hab mich aber nen bisschen eingelesen und den Code modifiziert. Meine Hardware ist bereits fertig deswegen musste ich den Code anpassen, bzw habe es versucht. Ich steuere nicht mit P-Channel sondern mit N-Channel Fets (IRLZ34N. Desweiteren habe ich Rot an PortB.1, Grün An PortB.2 und Blau an PortB.3 Ansonsten ist meine Hardware identisch, bis auf das ich zum Pegelwandeln von RX/TX keine Transistor verwende sondern den MAX232N. Da ich bisher noch nicht mit C gearbeitet habe, würde ich gerne hier mal fragen ob jemand diesen Code mal prüfen kann, ob ich das richtig gemacht habe =) lg Heiko
1 | #define F_CPU 8000000
|
2 | |
3 | #include <stdlib.h> |
4 | #include <avr/io.h> |
5 | #include <avr/pgmspace.h> |
6 | #include <inttypes.h> |
7 | #include <avr/delay.h> |
8 | #include <avr/interrupt.h> |
9 | #include <avr/signal.h> |
10 | |
11 | #define USART_BAUDRATE 9600
|
12 | #define BAUD_PRESCALE (((F_CPU / (USART_BAUDRATE * 16UL))) - 1)
|
13 | |
14 | #define bit_on(BYTE, BIT) BYTE |= 1 << BIT;
|
15 | #define bit_off(BYTE, BIT) BYTE &= ~(1 << BIT);
|
16 | |
17 | |
18 | |
19 | //########################### LED VARIABLEN
|
20 | //-------cluster1 variables
|
21 | //volatile int rinc, ginc, binc;
|
22 | volatile int rpwm, gpwm, bpwm, schritte; |
23 | volatile int time=0; |
24 | /*
|
25 | volatile int fadedelay, fade, fadetime, schritte;
|
26 | volatile int pressed, pressed2;
|
27 | */
|
28 | volatile char led_out=0; |
29 | |
30 | char i; |
31 | |
32 | int main (void) |
33 | {
|
34 | |
35 | // ############################USART VARIABLEN
|
36 | |
37 | |
38 | UCSRB |= (1 << RXEN) | (1 << TXEN); // Turn on the transmission and reception circuitry |
39 | UCSRC |= (1 << URSEL) | (1 << UCSZ0) | (1 << UCSZ1); // Use 8-bit character sizes |
40 | |
41 | UBRRL = BAUD_PRESCALE; // Load lower 8-bits of the baud rate value into the low byte of the UBRR register |
42 | UBRRH = (BAUD_PRESCALE >> 8); // Load upper 8-bits of the baud rate value into the high byte of the UBRR register |
43 | |
44 | UCSRB |= (1 << RXCIE); // Enable the USART Recieve Complete interrupt (USART_RXC) |
45 | sei(); // Enable the Global Interrupt Enable flag so that interrupts can be processed |
46 | |
47 | |
48 | |
49 | |
50 | |
51 | //############################### VARIABLEN INITIALISIEREN
|
52 | i=1; |
53 | |
54 | //--------initialisierung variable cluster1
|
55 | rpwm=255; |
56 | //rinc=1;
|
57 | |
58 | gpwm=255; |
59 | //ginc=1;
|
60 | |
61 | bpwm=255; |
62 | //binc=1;
|
63 | |
64 | //---------------fade variablen
|
65 | /*
|
66 |
|
67 | fadedelay=20;
|
68 | fade=1;
|
69 | fadetime=200;
|
70 | */
|
71 | |
72 | schritte=255; //Anzahl der PWM stufen (bei übertragung von einem Byte sollte es 255 sein. |
73 | |
74 | DDRB=0xFF; //Port B as Ausgang definieren |
75 | PORTB=0x00; |
76 | |
77 | DDRD = 0x00; //Port D as Eingan definieren |
78 | PORTD |= (1<<PD6) | (1<<PD7); |
79 | |
80 | //Timer0 8Bit setup , zuständig für die PWM
|
81 | bit_on(TCCR0, CS00); //Int. CLK |
82 | bit_off(TCCR0, CS01); |
83 | bit_off(TCCR0, CS02); |
84 | |
85 | /* Timer 2 wird nicht benötigt
|
86 | bit_on(TCCR2, CS01); //Int. CLK/1024
|
87 | bit_off(TCCR2, CS00);
|
88 | bit_on(TCCR2, CS02);
|
89 | */
|
90 | |
91 | TCNT0 = 0x00; //Timer-Reg. löschen |
92 | |
93 | bit_on(TIMSK, TOIE0); //Overflow-Int. enable |
94 | |
95 | |
96 | //#####################################################################
|
97 | |
98 | for (;;) // Loop forever |
99 | {
|
100 | |
101 | /*
|
102 | _delay_ms(20);
|
103 | |
104 | |
105 | |
106 | if (!( PIND & (1<<PD7)) && pressed2==0){
|
107 | fadetime=fadetime+50; pressed2 = 1;
|
108 | }
|
109 | |
110 | if ( PIND & (1<<PD7)) {
|
111 | pressed2=0;
|
112 | }
|
113 | |
114 | |
115 | |
116 | if (!( PIND & (1<<PD6)) && pressed==0){
|
117 | fade ^= (1<<0); pressed = 1;
|
118 | }
|
119 | |
120 | if ( PIND & (1<<PD6)) {
|
121 | pressed=0;
|
122 | }
|
123 | |
124 | |
125 | if(fadedelay>=fadetime && fade==1 ){
|
126 | |
127 | //-----------------cluster1
|
128 | |
129 | |
130 | gpwm=gpwm+ginc;
|
131 | if (gpwm>=schritte) ginc=-((TCNT2/80)+1);
|
132 | if (gpwm<=-60) ginc=(TCNT2/80)+1;
|
133 | |
134 | bpwm=bpwm+binc;
|
135 | if (bpwm>=schritte) binc=-((TCNT2/100)+1);
|
136 | if (bpwm<=-40) binc=(TCNT2/100)+1;
|
137 | |
138 | |
139 | fadedelay=0;
|
140 | |
141 | }
|
142 |
|
143 | fadedelay++;
|
144 | |
145 | */
|
146 | |
147 | } //for |
148 | |
149 | |
150 | //#####################################################################
|
151 | |
152 | |
153 | } //main |
154 | |
155 | // ################################### USART INTERRUPT ROUTINE
|
156 | |
157 | ISR(USART_RXC_vect) |
158 | {
|
159 | volatile int ReceivedByte; |
160 | |
161 | ReceivedByte = UDR; // Fetch the recieved byte value into the variable "ByteReceived" |
162 | |
163 | |
164 | if (i==1) rpwm = ReceivedByte; |
165 | |
166 | |
167 | if (i==2) gpwm = ReceivedByte; |
168 | |
169 | |
170 | if (i==3) { bpwm = ReceivedByte; i=0; } |
171 | |
172 | |
173 | UDR = ReceivedByte; // Echo back the received byte back to the computer |
174 | UDR = i; |
175 | i++; |
176 | |
177 | }
|
178 | |
179 | |
180 | |
181 | |
182 | SIGNAL(TIMER0_OVF_vect) // ############# PWM TIMER INTERRUPT ROUTINE |
183 | |
184 | {
|
185 | |
186 | TCNT0=128; |
187 | |
188 | time++; |
189 | |
190 | if(time>=schritte) time=0; |
191 | |
192 | //--------------------------Cluster1
|
193 | if(time>=rpwm) |
194 | {
|
195 | bit_on(led_out,1); |
196 | }
|
197 | |
198 | else
|
199 | {
|
200 | bit_off(led_out,1); |
201 | }
|
202 | |
203 | |
204 | if(time>=gpwm) |
205 | {
|
206 | bit_on(led_out,2); |
207 | }
|
208 | |
209 | else
|
210 | {
|
211 | bit_off(led_out,2); |
212 | }
|
213 | |
214 | |
215 | if(time>=bpwm) |
216 | {
|
217 | bit_on(led_out,3); |
218 | }
|
219 | |
220 | else
|
221 | {
|
222 | bit_off(led_out,3); |
223 | }
|
224 | |
225 | //---------ausgabe Port
|
226 | |
227 | PORTB = led_out; |
228 | }
|
Feines Programm von Florian! Um es zu testen, gibts hier einen Com-Port-Emulator, so dass man die Programmausgabe mit Hyperterminal empfangen kann. http://sourceforge.net/projects/com0com/ Man erstellt damit ein virtuelles Com-Port-Paar, der eine davon dient als Ziel für Florians Prog, der andere als Empfänger für Hyperterminal. Jedoch muss man das erstellte Paar abweichend vom vordefinierten Namen umbenennen, damit Florians Programm den Comport akzeptiert: Der Name muss mit "COM.." Anfangen
Hallo Leute, durch tagelange Google-Suche bin ich nun endlich hier gelandet und der Thread hier trifft ziemlich genau meinen Nerv! Ich suche eine Möglichkeit, mit der ich meine weißen LEDs (Aquariumbeleuchtung) Morgens um 9:00 Uhr binnen 30 Minuten automatisch von 0% auf 100% (oder 80%, oder ...) auf- und Abends wieder binnen 30 Minuten auf 0% abdimmen kann, bevor (evtl.) die Stromversorgung wieder abgeschaltet wird. Eventuell darf Mittags nochmal ein Programm laufen, bei dem eine Zeit lang die Helligkeit variiert (durchziehende Wolken oder so). Gibt es eine solche Möglichkeit das zu realisieren, ohne, dass ich mir tonnenweise furchtbar teure Controller oder sonstiges Zeug kaufen muss? Wenn jemand 'nen Tipp hätte, wäre ich echt dankbar!!!!! Viele Grüße Ralle
Hallo. Ich würde gerne das Nachbauen. Nur weiß ich leider nicht was ich brauche und wie ich die Hardware baue. Könnte mir bitte jemand per E-Mail eine genaue Anleitung schiken? Ich habe nicht also viel Ahnung davon. E-Mail: henry.herrgesell@hotmail.de Vielen Dank. Gruß Henry
Henry schrieb: > Hallo. > Ich würde gerne das Nachbauen. Nur weiß ich leider nicht was ich brauche > und wie ich die Hardware baue. Könnte mir bitte jemand per E-Mail eine > genaue Anleitung schiken? Ich habe nicht also viel Ahnung davon. Dann lerne es. Schliesslich willst du das bauen. AVR-Tutorial AVR-GCC-Tutorial
Ralle schrieb: > Hallo Leute, > > durch tagelange Google-Suche bin ich nun endlich hier gelandet und der > Thread hier trifft ziemlich genau meinen Nerv! > > Ich suche eine Möglichkeit, mit der ich meine weißen LEDs > (Aquariumbeleuchtung) Morgens um 9:00 Uhr binnen 30 Minuten automatisch > von 0% auf 100% (oder 80%, oder ...) auf- und Abends wieder binnen 30 > Minuten auf 0% abdimmen kann, bevor (evtl.) die Stromversorgung wieder > abgeschaltet wird. Eventuell darf Mittags nochmal ein Programm laufen, > bei dem eine Zeit lang die Helligkeit variiert (durchziehende Wolken > oder so). > > Gibt es eine solche Möglichkeit das zu realisieren, ohne, dass ich mir > tonnenweise furchtbar teure Controller oder sonstiges Zeug kaufen muss? > > Wenn jemand 'nen Tipp hätte, wäre ich echt dankbar!!!!! > > Viele Grüße > Ralle Was Du brauchst ist ein AVR ( Attiny2313 oder Atmega8 ) Ein LCD Display und evtl. ein paar Taster.( Kostenpunkt ca € 10 ) Wenn Du nicht programmieren kannst, dann musst was fertiges kaufen. Ausführliche Infos findest noch hier : http://www.ledstyles.de/index.php?form=Search&searchID=559771&highlight=aquarium oder fertiges zu kaufen gibt es hier : https://www.eiwomisa.de/website/shop-bausaetze/led-steuerung/mini-rgb-fader-v1x/aquarium-programm.html
Hey bin auf deinen Beitrag gestoßen und finde ihn echt klasse ich wollte dich fragen ob du mir ein gefallen tuhen kannst. Ich habe in mein Auto ein kleinen CAR-PC mit einem 7" Touchscreen TFT verbaut. Jetzt möchte ich über mein Touchscreen ein Farbrad so ähnlich wie im Anhang anklicken können um die Farben der RBG Led Strip´s zur indirekten Innenraumbeleuchtung zu verändern. Ich brauche nur das Programm für WINDOWS es soll dann einfach die R-G-B Werte von 1-255 ausgeben. Das Programmieren von dem ATmega ist kein Problem nur mit der WINDOWS Sache kenne ich mich nicht so gut aus das ich das hinbekommen würde :) Gruß Tjark
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.