HowTo: RGB Moodulator mit ATMEGA168 oder ATMEGA88

[synvox]

Hallöchen liebe Mädels und Jungs,

endlich ist es soweit, dass ich eine fertige Applikation auf Basis meines Hardware-PWM-Codes aus folgendem Beitrag hier reinstellen kann. Es hat etwas länger gedauert als geplant, aber dafür habe ich einiges an Funktionalität reinpacken können. Die ganze Applikation ist wieder mit BASCOM AVR programmiert und belegt compiliert 5548 Bytes im Flash des MC, weshalb diesmal der ATMEGA48 aussen vor bleibt (nur 4kB Flash).

Das Programm steuert die Farben zweier RGB Quellen unabhängig (6 PWM Kanäle). Es wird diesmal sowohl der Hue-Wert (Farbkreis) als auch die Saturation (Sättigung) gesteuert, so dass nun auch Pastelltöne inkl. Weiss möglich sind. Der Farbkreis ist in 1530 Schritte unterteilt, was effektiv 256 Werte pro RGB-Kanal ergibt, und die Sättigung hat eine Auflösung von 256 Werten. Die PWM-Frequenz beträgt ca. 2 kHz (höher als beim Vorprojekt wegen der erhöhten Werteupdate-Raten). Der PWM-Output kann global über einen Jumper auf invertierend oder nicht-invertierend gesetzt werden (wird bei Programmstart evaluiert), je nachdem wie man die LEDs anschliesst (direkt oder über Transistor, FET, Treiber etc.). Wenn bei Ausgang = 5V (1) die LED leuchtet, dann ist nicht-invertierend zu wählen, ansonsten wenn bei Ausgang = Masse (0) die LED leuchtet, dann ist invertierend zu wählen.
Über 5 Tasten wird der MC gesteuert. Mit der Prog.-Taste kann eines der 15 Programme (zyklisch) ausgewählt werden. Die Speed-Taste steuert die Geschwindigkeit in 8 Schritten (ca. 3 sek. bis ca. 6.5 min. für einen Rainbow-Durchlauf; jeweils verdoppelung von Schritt zu Schritt) zyklisch. Mit der Brightness-Taste wird global die Helligkeit in vier Schritten (100%, 50%, 25% und Aus) zyklisch eingestellt. Mit der Stop/Start-Taste für die jeweilige RGB-LED kann die Sequenz angehalten und wieder laufen gelassen werden.
Die Programmwechsel und Speed-Einstellungen wirken sich jeweils nur auf die RGB-LED aus, bei welcher die Sequenz läuft. So kann man Programm und Speed unabhängig für jede RGB-LED einstellen. Wenn beide Sequenzen laufen, so wirken sich Programmwechsel und Speedwechsel simultan auf beide RGB-LEDs aus (zum schnellen durchzappen).
Sind beide Sequenzen gestoppt, haben Programm- und Speed-Taste alternative Funktionen. Mit der Speed-Taste können in diesem Fall die aktuellen Werte für Programm und Speed beider RGB-LEDs sowie die globale Helligkeit im internen EEPROM (nichtflüchtiger Speicher) gespeichert werden. Als visuelle Bestätigung des Speichervorgangs gehen beide LEDs aus und flashen dann kurz einmal grün auf, bevor sie wieder in den ursprünglichen Zustand versetzt werden. Die Programm-Taste hat genau die entgegengesetzte Sekundärfunktion (wenn beide Sequenzen gestoppt sind). Sie liest dann die gespeicherten Werte aus dem EEPROM aus und versetzt die beiden RGB-LEDs in die entsprechenden Zustände (Programm, Speed, Helligkeit global). Die entsprechenden Programme starten dann von Anfang.
Beim Programmstart wird auch das EEPROM gelesen. D.h. dass beim Einschalten jeweils die zuletzt gespeicherten Einstellungen verwendet werden, ausser es ist noch nichts gespeichert (beim ersten Einschalten z.Bsp.), dann initialisieren sich beide RGB-LEDs mit Program 0, schnellster Geschwindigkeit und höchster globaler Helligkeit.

Zu den Programmen:
Erklärung zur Sättigung: 0% ergibt einfach weiss, unabhängig vom Hue-Wert (Farbkreis). Wenn man die Sättigung verringert ergibt sich also ein Effekt wie wenn man noch mit einer weissen LED überblenden würde.
0: Regenbogen vorwärts
1: Regenbogen vorwärts bei 75% Sättigung
2: Regenbogen vorwärts bei 50% Sättigung
3: Regenbogen vorwärts bei 25% Sättigung
4: Regenbogen rückwärts
5. Regenbogen alternierend (vorwärts <-> rückwärts)
6: Springen durch die 7 Grundfarben (rot, gelb, grün, cyan, blau, magenta und weiss)
7: Regenbogen vorwärts und bei jedem zweiten Durchgang gleichzeitig Überblenden zu Weiss und zurück
8: Regenbogen vorwärts und gleichzeitig sehr langsam (in 40 Regenbogen-Durchgängen) Überblenden zu Weiss und zurück
9: Rot <-> Grün gleitend
10: Grün <-> Blau gleitend
11: Blau <-> Rot gleitend
12: Springen durch zufällige Werte von Hue und Sättigung
13: Regenbogen vorwärts und gleichzeitig Springen durch zufällige Werte von Sättigung
14: Gleiten von Weiss zu einem zufälligen Hue-Wert und zurück (immer wieder)

Natürlich kannt man je nach Geschmack diese Programme verändern, weglassen und abhängig vom zur Verfügung stehenden Flash-Speicher weitere hinzufügen. Alle Programme sind in der Funktion Prog_call als If-Then-Blöcke programmiert. Wichtig dabei ist, dass die Länge eines Programmdurchlaufes maximal 65535 Schritte bzw. Zeiteinheiten (Zeiteinheit: min. ca. 2 ms, max. ca. 256 ms je nach Speed) beträgt. Man markiert das Ende eines Programmdurchlaufes mit dem Setzen der Variable Prog_call auf 1 (siehe Programme). Die Schrittzahl entnimmt man der Variable Curr_step und programmiert aufgrund dieser Zahl den Ablauf in Farbkreis-Wert (Hue_val, 0 - 1529) und Sättigung (Sat, 0 - 255). Die Variable Prog beinhaltet das aktuell eingestellte Programm, was man für die If-Then-Weichen nutzen kann (siehe Programme). Wichtig ist auch noch, dass man die Konstante Maxprog auf die höchste Programmnummer (Anzahl Programme - 1, da die Programme mit Nummer 0 beginnen) setzt.

Manch ein Programmierguru wird vielleicht anmerken: Weshalb ist denn der Programmierstil so unelegant ? Nun das hat grösstenteils seine Bewandnis in BASCOM selbst. Ich habe versucht, den Code auf Geschwindigkeit und resultierende Codelänge zu optimieren, ohne dabei total unübersichtlich zu werden. Z. Bsp. sind häufige Zugriffe auf Array-Variablen mittels dynamischem Index äusserst Uneffizient in Geschwindigkeit und Code-Länge. Deshalb minimiere ich solche Zugriffe und kopiere die Werte zur ausgiebigen Bearbeitung in einfache Variablen und dann wieder zurück. Ausserdem kann BASCOM keine komplexeren mathematischen Ausdrücke in einer Zeile auflösen, bzw. die Ergebnisse sind dann inkorrekt. Dadurch ist man gezwungen, mit Zwischenergebnissen resp. temporären Variablen zu arbeiten. Ferner vermeide ich so gut es geht Divisionen (Byte-Multiplikationen können bei den ATMEGA-Chips in nur zwei Taktzyklen ausgeführt werden, Divisionen nicht). Dies führt dann zu manch einem nicht ganz so offensichtlichem Berechnungstrick .

Ich hatte leider keine Zeit, noch Videos oder Bildeindrücke anzufertigen, aber ich habe den programmierten Chip in einem Testaufbau ausgiebig getestet. Der Code funktioniert fehlerlos. Die Farbverläufe sind butterweich (noch besser als beim Vorprojekt; grössere Hue-Auflösung: 1530 gegenüber 252, höhere Werteupdaterate und höhere PWM-Frequenz: 2 kHz gegenüber 245 Hz) und es ist zumindest bei den von mir für den Test verwendeten RGB-LEDs (Superflux) kein Anflug von Flackern festzustellen. Sobald ich mit dem Chip eine kleine Design-Mood-Leuchte zusammengebastelt habe, folgt natürlich ein weiteres HowTo, dann mit Bildern und Videos.

Noch ein kleiner Hinweis für alle, die per Darlington oder MOSFET High-Power-LEDs oder ganze LED-Gruppen steuern möchten: Bei einer PWM-Frequenz von ca. 2 kHz sind bei den extremen PWM-Werten (wie 1 und 254) die Pulse teilweise nur noch ca. 2 us (mikrosekunden) breit. Man sollte also darauf achten, dass man Transistoren verwendet, welche schnell genug schalten können (mindestens ca. 1MHz Bandbreite). Bei MOSFETs ist die Bandbreite meist nicht limitierend, aber da ergibt sich leider ein anderes Problem. Der Gate-Steuereingang eines MOSFET weist eine teilweise nicht unerhebliche Kapazität auf, welche bei solch kurzen Schaltzeiten zu kurzzeitig recht hohen Umladungsströmen am Gate-Eingang resp. am MC-Ausgang führen kann. Diese sollte man mit einem Widerstand zwischen MC-Ausgang und Gate-Eingang limitieren. 100 Ohm sollten bei einem AVR reichen. Dies begrenzt den Schaltstrom auf ca. 50 mA (ein AVR sollte bei solch kurzen Schaltzeiten bis 100 mA locker verkraften). Nun bildet aber der Begrenzungswiderstand mit der Gate-Kapazität ein RC-Glied (Lowpass-Filter in diesem Fall), welches die maximale Schaltfrequenz stark limitieren kann. Man sollte also bei der Auswahl des MOSFETs auf eine möglichst niedrige Gate-Kapazität achten. Ich selbst verwende für die meisten High-Power-LED-Anwendungen den IRLD110, welcher bis zu 1A bei 0.5 Ohm ON-Widerstand schalten kann bei 'nur' 250pF Gate-Kapazität. Dies führt bei 100 Ohm laut "R * C * 2 * Pi" noch zu keinerlei Problemen. Ausserdem ist er Logic-Level (schaltet ab ca. 3V voll durch) und wird im äusserst praktischen HEXDIP-Gehäuse angeboten. MOSFETs für sehr hohe Ströme mit extrem niedrigen ON-Widerständen haben nicht selten Gate-Kapazitäten von mehreren nF, was dann doch schon problematisch wird. Wenn man auf solche Schaltaufgaben nicht verzichten kann, dann sollte man einen MOSFET-Treiber (meist kleine Treiber-ICs) vor den POWER-MOSFET schalten.

Ok, nun genug der Erklärungen und der Theorie: Nachfolgend sind der Code und der Schaltplan meiner Testschaltung (kann man als Basis-Applikationsschaltung ansehen) angegeben. Ich wünsche allen, die sich dranwagen viel Erfolg . Bei Fragen einfach diesen Thread benutzen.

Gruss
Neni

[synvox]

Der Programmcode:

Code: Alles auswählen

' rgb_moodulator.bas by Neni
' Version 1.02
' Product: RGB Moodulator; Dual independent RGB-LED Moodlight Controller.
' Controls two independent RGB-LEDs with different Programs using HW-PWM.
' Works on ATMEGA168, ATMEGA88 (doesn't fit in ATMEGA48 with 4KB Flash).
' Frequency: 8MHz internal RC (remember to disable CKDIV8 fuse bit).
' OCR PWM Generation in inverted or non-inverted mode (selectable by jumper).
' Supports 5 Buttons for Program, Speed, Brightness and Stop/Start selection.
' Program button second function: recalls Program, Speed and Brightness from
' EEPROM when both RGBs are stopped.
' Speed button second function: stores current Program, Speed and Brightness
' to EEPROM when both RGBs are stopped.
' Recalls all values stored in EEPROM also on PowerUP.
' Copyright: Neni (neni@synvox.ch)

' $sim

$regfile = "m168def.dat"
$crystal = 8000000
$hwstack = 64
$swstack = 64
$framesize = 64

' The highest Light-Program number (Programs begin with 0)
Const Maxprog = 14

' Better human readable definition for the OCR Registers
Red_pwm1 Alias Ocr0a                                        'PWM-Output: Pin 12
Red_pwm2 Alias Ocr0b                                        'PWM-Output: Pin 11
Green_pwm1 Alias Ocr1al                                     'PWM-Output: Pin 15
Green_pwm2 Alias Ocr1bl                                     'PWM-Output: Pin 16
Blue_pwm1 Alias Ocr2a                                       'PWM-Output: Pin 17
Blue_pwm2 Alias Ocr2b                                       'PWM-Output: Pin 05

'The same for input port pins (buttons and jumpers)
Prog_button Alias Pinc.0                                    'Cycling through the programs
Speed_button Alias Pinc.1                                   'Cycling through the speed values in 8 steps
Bright_button Alias Pinc.2                                  'Cycling through the brightness values in 4 steps
Stop1_button Alias Pinc.3                                   'Toggles stop/start of RGB1
Stop2_button Alias Pinc.4                                   'Toggles stop/start of RGB2
Pwm_mode_jumper Alias Pinc.5                                'Selects inverted or non-inverted PWM-Output-Mode at PowerUP

' Set debounce delay for buttons to 30ms
Config Debounce = 30

' Program variables
Dim Step1 As Word , Step2 As Word
Dim Speed1 As Byte , Speed2 As Byte , Count1 As Byte , Count2 As Byte
Dim Prog1 As Byte , Prog2 As Byte , Brightness As Byte
Dim Red_pwm(2) As Byte , Blue_pwm(2) As Byte , Green_pwm(2) As Byte
Dim Red_pwm_c(2) As Byte , Blue_pwm_c(2) As Byte , Green_pwm_c(2) As Byte
Dim Progend1 As Byte , Progend2 As Byte
Dim Stop1 As Bit , Stop2 As Bit
Dim Hue(2) As Word , Saturation(2) As Byte

' EEPROM Variables
Dim E_dummy As Eram Byte                                    'skip location 0 in EEPROM
Dim E_prog1 As Eram Byte , E_prog2 As Eram Byte
Dim E_speed1 As Eram Byte , E_speed2 As Eram Byte
Dim E_brightness As Eram Byte

' Temporary variables (for calculations and copying)
Dim Temp_sat As Word , Hue_val As Word , Sat As Byte , Temp_b As Byte , Temp_w As Word
Dim Red As Byte , Green As Byte , Blue As Byte

' Predefined system variable for Rnd (Random) function (seeding)
Dim __rseed As Word

Declare Function Prog_call(byval Curr_step As Word , Byval Prog As Byte , Byval Index As Byte) As Byte
Declare Sub Color_set(byval Index As Byte)
Declare Sub Update_pwm
Declare Sub Eeprom_read_and_init
Declare Sub Eeprom_write

' Input/Output Ports initialization
' Port B initialization
' Func7=In Func6=In Func5=In Func4=In Func3=Out Func2=Out Func1=Out Func0=In
' State7=P State6=P State5=P State4=P State3=1 State2=1 State1=1 State0=P
Portb = &HFF
Ddrb = &H0E

' Port C initialization
' Func6=In Func5=In Func4=In Func3=In Func2=In Func1=In Func0=In
' State6=P State5=P State4=P State3=P State2=P State1=P State0=P
Portc = &HFF
Ddrc = &H00

' Port D initialization
' Func7=In Func6=Out Func5=Out Func4=In Func3=Out Func2=In Func1=In Func0=In
' State7=P State6=1 State5=1 State4=P State3=1 State2=P State1=P State0=P
Portd = &HFF
Ddrd = &H68

' Selects PWM-Mode
If Pwm_mode_jumper = 0 Then
   Temp_b = &HA1                                            'non-inverted mode
Else
   Temp_b = &HF1                                            'inverted mode
End If

' Timer/Counter 0 initialization
' Clock source: System Clock
' Clock value: 1000.000 kHz -> PWM-Freq ca. 2000Hz
' Mode: Phase correct PWM top=FFh
Tccr0a = Temp_b
Tccr0b = &H02
Tcnt0 = &H00
Ocr0a = &H00
Ocr0b = &H00

' Timer/Counter 1 initialization
' Clock source: System Clock
' Clock value: 1000.000 kHz -> PWM-Freq ca. 2000Hz
' Mode: Ph. correct PWM top=00FFh
' Noise Canceler: Off
' Input Capture on Falling Edge
' Timer 1 Overflow Interrupt: Off
' Input Capture Interrupt: Off
' Compare A Match Interrupt: Off
' Compare B Match Interrupt: Off
Tccr1a = Temp_b
Tccr1b = &H02
Tcnt1h = &H00
Tcnt1l = &H00
Icr1h = &H00
Icr1l = &H00
Ocr1ah = &H00
Ocr1al = &H00
Ocr1bh = &H00
Ocr1bl = &H00

' Timer/Counter 2 initialization
' Clock source: System Clock
' Clock value: 1000.000 kHz -> PWM-Freq ca. 2000Hz
' Mode: Phase correct PWM top=FFh
Assr = &H00
Tccr2a = Temp_b
Tccr2b = &H02
Tcnt2 = &H00
Ocr2a = &H00
Ocr2b = &H00

' reading Program variables from EEPROM and testing for valability
' Initialising the other Program variables
Call Eeprom_read_and_init

' Initialising seed value for Rnd
__rseed = Tcnt0

Do
   If Stop1 = 0 And Count1 >= Speed1 Then
      Progend1 = Prog_call(step1 , Prog1 , 1)
      Incr Step1
      If Progend1 = 1 Then Step1 = 0
      Count1 = 1
   End If
   If Stop2 = 0 And Count2 >= Speed2 Then
      Progend2 = Prog_call(step2 , Prog2 , 2)
      Incr Step2
      If Progend2 = 1 Then Step2 = 0
      Count2 = 1
   End If
   If Stop1 = 0 Then Incr Count1
   If Count1 > 128 Then Count1 = 1
   If Stop2 = 0 Then Incr Count2
   If Count2 > 128 Then Count2 = 1

   Debounce Prog_button , 0 , Set_program , Sub             'Program button
   Debounce Speed_button , 0 , Set_speed , Sub              'Speed button
   Debounce Bright_button , 0 , Set_brightness , Sub        'Brightness button
   Debounce Stop1_button , 0 , Set_stop1 , Sub              'Stop/Start button 1
   Debounce Stop2_button , 0 , Set_stop2 , Sub              'Stop/Start button 2

   Waitms 2
Loop

Set_program:
   __rseed = Tcnt0                                          'new Seed for Rnd
   If Stop1 = 0 Then
      Step1 = 0
      Count1 = 1
      Incr Prog1
      If Prog1 > Maxprog Then Prog1 = 0
   End If
   If Stop2 = 0 Then
      Step2 = 0
      Count2 = 1
      Incr Prog2
      If Prog2 > Maxprog Then Prog2 = 0
   End If
   ' when both lights are stopped then Program button recalls values from EEPROM
   If Stop1 = 1 And Stop2 = 1 Then Call Eeprom_read_and_init
Return

Set_speed:
   __rseed = Tcnt0                                          'new Seed for Rnd
   If Stop1 = 0 Then
      Count1 = 1
      Rotate Speed1 , Left , 1
   End If
   If Stop2 = 0 Then
      Count2 = 1
      Rotate Speed2 , Left , 1
   End If
   ' when both lights are stopped then Speed button stores values to EEPROM
   If Stop1 = 1 And Stop2 = 1 Then Call Eeprom_write
Return

Set_brightness:
   __rseed = Tcnt0                                          'new Seed for Rnd
   Incr Brightness
   If Brightness > 3 Then Brightness = 0
   Call Update_pwm
Return

Set_stop1:
   __rseed = Tcnt0                                          'new Seed for Rnd
   Toggle Stop1
Return

Set_stop2:
   __rseed = Tcnt0                                          'new Seed for Rnd
   Toggle Stop2
Return

Function Prog_call(byval Curr_step As Word , Byval Prog As Byte , Byval Index As Byte) As Byte
   Hue_val = Hue(index)
   Sat = Saturation(index)

   If Prog < 4 Then                                         'Rainbow with
      If Prog = 0 Then Sat = 255                            '100% Saturation
      If Prog = 1 Then Sat = 192                            'ca. 75% Saturation
      If Prog = 2 Then Sat = 128                            'ca. 50% Saturation
      If Prog = 3 Then Sat = 64                             'ca. 25% Saturation
      Hue_val = Curr_step
      If Curr_step >= 1529 Then
         Prog_call = 1
      Else
         Prog_call = 0
      End If
   Elseif Prog = 4 Then                                     'Rainbow reversed
      Sat = 255
      Hue_val = 1529 - Curr_step
      If Curr_step >= 1529 Then
         Prog_call = 1
      Else
         Prog_call = 0
      End If
   Elseif Prog = 5 Then                                     'Rainbow alternating
      Sat = 255
      If Curr_step < 1530 Then
         Hue_val = Curr_step
      Else
         Hue_val = 3060 - Curr_step
      End If
      If Curr_step >= 3059 Then
         Prog_call = 1
      Else
         Prog_call = 0
      End If
   Elseif Prog = 6 Then                                     'Stepping through the 7 basic colors
      Sat = 255                                             ' (red, yellow, green, cyan, blue, magenta and white)
      If Curr_step < 200 Then
         Hue_val = 0
      Elseif Curr_step < 400 Then
         Hue_val = 255
      Elseif Curr_step < 600 Then
         Hue_val = 510
      Elseif Curr_step < 800 Then
         Hue_val = 765
      Elseif Curr_step < 1000 Then
         Hue_val = 1020
      Elseif Curr_step < 1200 Then
         Hue_val = 1275
      Else
         Hue_val = 0
         Sat = 0
      End If
      If Curr_step >= 1399 Then
         Prog_call = 1
      Else
         Prog_call = 0
      End If
   Elseif Prog = 7 Then                                     'Rainbow with every second loop fading to white and back
      Sat = 255
      If Curr_step < 1530 Then
         Hue_val = Curr_step
      Else
         Hue_val = Curr_step - 1530
         Temp_sat = Hue_val \ 3
         If Temp_sat < 255 Then
            Sat = 255 - Temp_sat
         Else
            Sat = Temp_sat - 255
         End If
      End If
      If Curr_step >= 3059 Then
         Prog_call = 1
      Else
         Prog_call = 0
      End If
   Elseif Prog = 8 Then                                     'Rainbow with very slow fade to white and back
      Temp_sat = Curr_step \ 120
      Hue_val = Curr_step Mod 1530
      If Temp_sat < 255 Then
         Sat = 255 - Temp_sat
      Else
         Sat = Temp_sat - 255
      End If
      If Curr_step >= 61199 Then
         Prog_call = 1
      Else
         Prog_call = 0
      End If
   Elseif Prog = 9 Then                                     'Red - Green gliding
      Sat = 255
      Hue_val = Curr_step
      If Hue_val > 510 Then Hue_val = 1020 - Hue_val
      If Curr_step >= 1019 Then
         Prog_call = 1
      Else
         Prog_call = 0
      End If
   Elseif Prog = 10 Then                                    'Green - Blue gliding
      Sat = 255
      Hue_val = Curr_step + 510
      If Hue_val > 1020 Then Hue_val = 2040 - Hue_val
      If Curr_step >= 1019 Then
         Prog_call = 1
      Else
         Prog_call = 0
      End If
   Elseif Prog = 11 Then                                    'Blue - Red gliding
      Sat = 255
      Hue_val = Curr_step + 1020
      If Hue_val > 1530 Then Hue_val = 3060 - Hue_val
      If Curr_step >= 1019 Then
         Prog_call = 1
      Else
         Prog_call = 0
      End If
   Elseif Prog = 12 Then                                    'Stepping through random Hue and Saturation
      If Curr_step = 0 Then
         Hue_val = Rnd(1530)
         Sat = Rnd(256)
      End If
      If Curr_step >= 199 Then
         Prog_call = 1
      Else
         Prog_call = 0
      End If
   Elseif Prog = 13 Then                                    'Rainbow with stepping through random Saturation
      Temp_sat = Curr_step Mod 255
      If Temp_sat = 0 Then Sat = Rnd(256)
      Hue_val = Curr_step
      If Curr_step >= 1529 Then
         Prog_call = 1
      Else
         Prog_call = 0
      End If
   Else                                                     'fading from white to random Hue and back
      If Curr_step = 0 Then Hue_val = Rnd(1530)
      If Curr_step < 255 Then
         Sat = Curr_step
      Else
         Sat = 510 - Curr_step
      End If
      If Curr_step >= 509 Then
         Prog_call = 1
      Else
         Prog_call = 0
      End If
   End If

   Hue(index) = Hue_val
   Saturation(index) = Sat
   Call Color_set(index)
   Call Update_pwm
End Function

Sub Color_set(byval Index As Byte)
   Hue_val = Hue(index)
   Sat = Saturation(index)
   If Hue_val < 255 Then
      Temp_b = 255 - Hue_val
      Temp_w = Temp_b * Sat
      Temp_w = 65280 - Temp_w
      Red = 255
      Green = High(temp_w)
      Blue = 255 - Sat
   Elseif Hue_val < 510 Then
      Temp_b = Hue_val - 255
      Temp_w = Temp_b * Sat
      Temp_w = 65280 - Temp_w
      Red = High(temp_w)
      Green = 255
      Blue = 255 - Sat
   Elseif Hue_val < 765 Then
      Temp_b = 765 - Hue_val
      Temp_w = Temp_b * Sat
      Temp_w = 65280 - Temp_w
      Red = 255 - Sat
      Green = 255
      Blue = High(temp_w)
   Elseif Hue_val < 1020 Then
      Temp_b = Hue_val - 765
      Temp_w = Temp_b * Sat
      Temp_w = 65280 - Temp_w
      Red = 255 - Sat
      Green = High(temp_w)
      Blue = 255
   Elseif Hue_val < 1275 Then
      Temp_b = 1275 - Hue_val
      Temp_w = Temp_b * Sat
      Temp_w = 65280 - Temp_w
      Red = High(temp_w)
      Green = 255 - Sat
      Blue = 255
   Else
      Temp_b = Hue_val - 1275
      Temp_w = Temp_b * Sat
      Temp_w = 65280 - Temp_w
      Red = 255
      Green = 255 - Sat
      Blue = High(temp_w)
   End If
   Red_pwm_c(index) = Red
   Green_pwm_c(index) = Green
   Blue_pwm_c(index) = Blue
End Sub

Sub Update_pwm
   Red_pwm(1) = Red_pwm_c(1)
   Green_pwm(1) = Green_pwm_c(1)
   Blue_pwm(1) = Blue_pwm_c(1)
   Red_pwm(2) = Red_pwm_c(2)
   Green_pwm(2) = Green_pwm_c(2)
   Blue_pwm(2) = Blue_pwm_c(2)
   If Brightness < 3 Then
      Shift Red_pwm(1) , Right , Brightness
      Shift Green_pwm(1) , Right , Brightness
      Shift Blue_pwm(1) , Right , Brightness
      Shift Red_pwm(2) , Right , Brightness
      Shift Green_pwm(2) , Right , Brightness
      Shift Blue_pwm(2) , Right , Brightness
   Else
      Red_pwm(1) = 0
      Red_pwm(2) = 0
      Green_pwm(1) = 0
      Green_pwm(2) = 0
      Blue_pwm(1) = 0
      Blue_pwm(2) = 0
   End If
   Red_pwm1 = Red_pwm(1)
   Red_pwm2 = Red_pwm(2)
   Green_pwm1 = Green_pwm(1)
   Green_pwm2 = Green_pwm(2)
   Blue_pwm1 = Blue_pwm(1)
   Blue_pwm2 = Blue_pwm(2)
End Sub

Sub Eeprom_read_and_init
   ' reading Program variables from EEPROM and testing for valability
   Prog1 = E_prog1
   Prog2 = E_prog2
   Speed1 = E_speed1
   Speed2 = E_speed2
   Brightness = E_brightness
   If Prog1 > Maxprog Then Prog1 = 0
   If Prog2 > Maxprog Then Prog2 = 0
   If Brightness > 3 Then Brightness = 0
   Select Case Speed1
      Case 1 : Nop
      Case 2 : Nop
      Case 4 : Nop
      Case 8 : Nop
      Case 16 : Nop
      Case 32 : Nop
      Case 64 : Nop
      Case 128 : Nop
      Case Else : Speed1 = 1
   End Select
   Select Case Speed2
      Case 1 : Nop
      Case 2 : Nop
      Case 4 : Nop
      Case 8 : Nop
      Case 16 : Nop
      Case 32 : Nop
      Case 64 : Nop
      Case 128 : Nop
      Case Else : Speed2 = 1
   End Select

   ' Initialising the other Program variables
   Step1 = 0
   Step2 = 0
   Count1 = 1
   Count2 = 1
   Stop1 = 0
   Stop2 = 0
End Sub

Sub Eeprom_write
   ' writing the Program variables to EEPROM and giving visual write-feedback
   Red_pwm1 = 0
   Red_pwm2 = 0
   Green_pwm1 = 0
   Green_pwm2 = 0
   Blue_pwm1 = 0
   Blue_pwm2 = 0

   E_prog1 = Prog1
   E_prog2 = Prog2
   E_speed1 = Speed1
   E_speed2 = Speed2
   E_brightness = Brightness

   Waitms 350

   Red_pwm1 = 0
   Red_pwm2 = 0
   Green_pwm1 = 255
   Green_pwm2 = 255
   Blue_pwm1 = 0
   Blue_pwm2 = 0

   Waitms 700

   Red_pwm1 = 0
   Red_pwm2 = 0
   Green_pwm1 = 0
   Green_pwm2 = 0
   Blue_pwm1 = 0
   Blue_pwm2 = 0

   Waitms 350

   Red_pwm1 = Red_pwm(1)
   Red_pwm2 = Red_pwm(2)
   Green_pwm1 = Green_pwm(1)
   Green_pwm2 = Green_pwm(2)
   Blue_pwm1 = Blue_pwm(1)
   Blue_pwm2 = Blue_pwm(2)
End Sub

[synvox]

Das Schaltbild der Test-Schaltung:

[Andy]

Supi...
Das nennt man ein How To !

Jetzt noch den Analogeingang Beschalten und die Programmfolge etc. über Sound zu steuern.
eventuell noch diverse Lauflichtfunktionen dazu und das ganze ist Perfekt. lol....

Aber sehr gut beschrieben und erklärt.
Supi weiter so.

[dedicated]

Respekt für die Arbeit

Die Transitor-Erklärung ist auch sehr hilfreich und informativ.

Danke dir Neni



mfg Martin

[Ilker21]

hatte schon drauf gewartet

einfach geil

thx
mfg ilker

[luckylu1]

echt ne super sache, alles prima, ohne beanstandungen!!!
wird ein guter einstieg für mich zu den µC´s, ich hoffe nur, das sich kein fehler ins programm eingeschlichen hat, dann steh ich nämlich "nackich in den erbsen"

vor langer zeit habe ich mal eine 4 kanal lichtorgel gebaut, mit integriertem lauflicht, mit schaltern zum programmieren, da waren etwa 200 bauteile und 2km draht drin, jetzt nimmt man einen µC und schon ist es gut, einfach toll.

gruss lu

[alexStyles]

*sich den Link mal speichert*
Wenn Ich dann mal einen dieser Atmega's hab wird das wohl als erstes ausprobiert
Sieht echt super aus...
Und vorallem extrem gut beschrieben ausführlich und so weiter...
Auch wenn Ich halt noch nicht wirklich alles "checke"
Das dürfte wohl das größte Problem sein für mich
MfG Alex

[Bond999]

Ich habe leider nicht viel gecheckt
Aber hört sich sehr sehr interessant an!
Wenn man nun sowas bauen möchte, was für Sachen braucht man da?
Vieleicht mal paar Links hier posten mit Preisen... so das ich weis wie teuer alleine die Steuerung ungefähr wäre.

Und dann habe ich noch ne frage und zwar, ist es möglich diesen Code in der Chromoflex einzufügen?

Oder geht das nicht?!

Mit freundlichen Grüßen

Thomas

[synvox]

Danke an alle für den positiven Feedback . Wenn man spürt, dass es die Gemeinde hier interessiert, schreibt sich so ein HowTo auch viel leichter .

@Bond999:
Naja, wenn man sich nicht sowieso schon mit Microcontrolling befasst und auch nicht plant, es künftig zu tun, dann ist es sicherlich zu viel Einsatz (sowohl zeitlich als auch finanziell), sich nur für genau dieses Projekt hier alles notwendige anzuschaffen (Programmiergerät, ev. Evaluationsboard, BASCOM-Compiler ...) und überall einzulesen.
Die Chromoflex ist ein Fertiggerät und bietet somit sicherlich den einfachsten Weg, eine RGB-Quelle zu steuern, ist aber auch deutlich weniger flexibel (trotz dem flex im Namen ) als ein Microcontroller, den man dann nach den eigenen Bedürfnissen programmiert.
Ich habe keine Chromoflex, nehme aber mal an, dass da ein eigenes Kommunikationsprotokoll implementiert ist, um sie via PC innerhalb vorgegebener Grenzen programmieren zu können (d.h. die Abläufe etc.). Eine Programmierung der Betriebssoftware des darin verbauten Microcontrollers (auch wenn es ein ATMEL Chip wäre) wird man wohl kaum vornehmen können. Kurz gesagt also, nein, mit diesem Code kann man keine Chromoflex programmieren.

Gruss
Neni

[Bond999]

Vielen Dank für deinen Ausführlichen Text

Wie sieht es denn aus wenn man finanziel recht gut da steht und auch die Lust dazu hat sowas zu lernen.

Ich fange bald meine Ausbildung als Elektroniker an, da werde ich Programmieren lernen...
Da wäre es doch gut wenn ich schon vorab bisschen erfahrung davon habe

Oder etwa nicht?

MfG

Thomas


PS: Gibt es irgendwo nen Thread wo alles erklärt wird? z.B. wie man anfängt... die einfachsten dinge für den anfang..

[Fightclub]

wenn du jetzt noch bilder oder ein Video im Betrieb machst bin ich auch bereit dafür ordentlich Credits zu geben

[dedicated]

@bond999

Ab 30€ kannste schon mit Mikrocontroller anfangen

Bei Pollin gibts dsa Programmierboard für 15€
Die ATmegas 8-32 und tinys zwischen 1,50 und 3,95€
Platinen, Festspannungsregeler,Transitoren, Netzteile, Kabel 5-10€

Software:

Basic - Bascom AVR kostenlose Demoversion herunterladbar
C - WINAVR mit AVRlib kostenlos


Zum Mikrocontroller haben wir schon mehrere Themen(besonders die How²s von Pehu) hier im Forum:

1. Allgemeine Informationen zu Microcontrollern (AVR)

2. Die Inbetriebnahme des Boards mit dem Microcontroller

3. Verbindungseinstellungen und Verbindungsversuch mit BoardLetzten Beitrag anzeigen

4. Das erste Programm & Übertragung zum Microcontroller

5. Informationen zu einzelnen AVR-Microcontrollern-Typen

6. Grundstruktur und ein paar Grundbefehle (Basic-Sprache)

7. IF-Funktion und alltägliche Probleme, Interrupts

8. Interrupts, Variablen, und PWM mit Beispielen

9. Unterprogramme,Wiederholungsvorgänge optim., For-Schleife

2.1 Der Aufbau des Atmel Evaluationsboards von Pollin

DIY lightwriter | Propelle Clock

[Micrcontrolling] Fusebits einstellen

Pollinboard AVR Extension Platinen

Mini 3D-Cube [Prototyp halbfertig]

AVR Programmierung mit USB ISP -Alternative für Notebookuser

Problem mit Atmega32 als 8-Kanal-Lauflicht

mikrocontroller stroboskop

optimale PWM frequenz für LEDs

Fragen zu ICs


Zum Chromflex:

Den Code kannste wahrscheinlich nicht auf den µC des Chromoflex brennen.

Da ist ein Megawin MPC89E52AF drin.

Data-PDF






Mfg Martin

[synvox]

Naja, das Pollin-Board ist zwar konkurrenzlos günstig, aber ich finde die Auswahl an unterstützten Chips doch sehr limitierend. Praktisch keine der neueren AVR-Chips werden unterstützt. Das Board ist wohl auch ausserhalb der Pollin-Welt kaum bekannt bzw. verbreitet, so dass es von Programmier-Software von Drittherstellern nicht unterstützt wird. Man ist also auf das mitgelieferte Pony-Prog amgewiesen, wobei das Progrämmchen ja schön und gut ist, nur wird es seit mehr als einem Jahr nicht mehr upgedatet (keine Unterstützung für neuere Chips). Geiz ist also nicht in jedem Fall geil, finde ich .

Hat man ein paar Batzen mehr zur Verfügung, würde ich für einen Anfänger wärmstens das STK200 AVR Starter Kit von Kanda.com empfehlen: Link.
Der Vorteil ist dabei, dass eigentlich praktisch ALLE AVR Chips in 8-, 20-, 28- und 40-Pin DIP-Gehäusen programmiert werden können, auch wenn die integrierte Programmiersoftware möglicherweise nicht alle aktuellen Chips kennt. BASCOM bietet direkten Support für dieses Board in seinem Chip-Programmier-Modul, und BASCOM kennt nun wirklich fast alle neueren AVR-Chips. Das Board ist unter AVR-Hobbyisten und auch -Profis extrem verbreitet und wird auch von der ATMEL-eigenen Entwicklungsumgebung (AVR-Studio) unterstützt.

Wenn Geld wirklich keine Rolle spielt, und vor allem wenn man schon etwas Erfahrung gesammelt hat und eigentlich kein Evaluationsboard mehr braucht, sondern nach einem 'echten' Programmiergerät 'für wahre Männer' lechzt , dann würde ich ohne mit der Wimper zu zucken die Geräte von Elnec (http://www.elnec.com) empfehlen, und zwar das T51Prog2, wenn man vor allem AVR- und MCS-Microcontroller programmieren will. Dafür müsste man dann schon so um die 250€ hinblättern, dann gibt es aber auch wirklich keine Grenzen mehr im AVR-Chip-Universum . Die Software wird monatlich aktualisiert, so dass praktisch bei Release eines neuen Chips von Atmel dieser auch unterstützt wird. Ich selbst nenne den SmartProg2 (ein Multichip-Programmiergerät, nicht nur für Microcontroller verschiedenster Hersteller, sondern auch für Eprom-, EEprom-, Flash-Speicher- und sogar ein paar Programmierbare-Logik-Bausteine geeignet) derselben Firma mein Eigen. Für nur schlappe ca. 500€ kann man sich den zu Hause ins Regal stellen und die Frauen beeindrucken .

Was die Compiler-Software angeht, so würde ich schon empfehlen, nach einer Testphase mit der Demoversion die Vollversion von BASCOM-AVR zu kaufen (die Demo ist auf 4kB Codelänge beschränkt). Es kostet 79€, ist aber einer der besten Basic-Compiler für eine Microcontroller-Serie, der mir je untergekommen ist. Ich habe noch den kommerziellen CodeVision-AVR C-Compiler, und der generierte Code von BASCOM ist in Punkto Codelänge und Geschwindigkeit dem des C-Compilers praktisch ebenbürtig, wenn man etwas auf die Programmierweise achtet. Deshalb verwende ich fast nur noch BASCOM für meine Projekte, vor allem auch weil einem durch die vielen schon vorhandenen Befehle und Funktionen viel Handarbeit abgenommen wird.

So, ich denke, das sollte vorerst mal als Infotainment reichen .

Grüsse
Neni

[synvox]

Nachtrag: Hihi, ich scheine das Pferd aufgescheucht zu haben. Kaum schreib ich was zu PonyProg, was sehen meine Augen auf der entsprechenden Website??. Jaa, es gibt doch tatsächlich wieder mal ein Update für PonyProg (2.07a BETA). Damit werden nun auch die ATMEGA48, 88 und 168 unterstützt, zwar noch 'untested', aber immerhin. Eine gute Nachricht also für alle Pollin-Board-Besitzer hier, denn ATMEGA48/88/168 sind programmiertechnisch pinkompatibel mit dem ATMEGA8, die Unterstützung der vorgenannten Chips scheiterte auf dem Pollin-Board bisher nur mangels entsprechend angepasster Programmiersoftware.

Hier der Link zum Update.

Ich stehe aber dennoch zu meiner Aussage bezüglich Pollin-Board und STK200 von oben. Was andere Chip-Typen und auch künftige Entwicklungen angeht, ist man mit dem STK200 für etwas mehr Mammon einfach auf der sichereren Seite.

Gruss
Neni

[Ilker21]

synvox köntest du vll mal ein video reinstellen von dem ganzen durchlauf
möcht den code am liebsten übernehmen aber ich weis nicht wie das jetzt asschaut
die erste variante war ja schon ziemlich geil
aber ein video von der hier wär auch nicht schlecht

mfg ilker

[Fightclub]

synvox, könntest du uns vllt den gefallen tun und die compilierten Files irgendwo hochladen? weil die meisten hier wohl die bascom demo benutzen und sicher nicht jeder die 79€ für die vollversion hinlegen möchte.

[Andy]

Ich hatte das Problem mit der Demo schon mal in einem anderen Thread angesprochen.

Wer sich diesem Problem der Demo entledigen will sollte einfach ne PM an mich schicken, dann bekommen wir das Prob in den Griff.

[synvox]

So Leute,

euer Wunsch ist mir Befehl .

Ich habe also mal schnell ein Video gemacht und auch kurz eine einfache HTML-Seite zusammengezwirbelt, auf welcher sich ein Teil der Beschreibung von oben, das Schaltbild, Links zum BASCOM-Quelltext, aber auch zu den fertig compilierten Dateien (für die meisten hier dürfte die Datei im Binärformat die richtige sein) und die Links zum Video (im Quicktime-MOV- und AVI-Format) befinden.

Den ganzen Firlefanz habe ich auf meinen Webserver geschmissen:

-> RGB Moodulator Webseite

Wie im Text auf der Seite zum Video schon gesagt, kann ich mein Handy nicht überreden, bei der Video-Aufnahme auf die Helligkeitsanpassungen und Weissabgleiche zu verzichten. Also sind die Farben im Video nicht mit den tatsächlichen Gegebenheiten zu vergleichen. Immerhin bekommt man aber einen Eindruck von der Weichheit der Übergänge ohne Flackern und so.

Gruss
Neni

[alexStyles]

Auf der Seite selbst kann man es wirklich alles gut lesen also richtig praktisch mein Ich so eine Seite dafür extra
Vielleicht kannst du mit ein paar Credits was anfangen
Ich gebe dir einfach mal 100 Credits als ein kleines Zeichen meiner Dankbarkeit denn diese RGB Steuerung ist echt was schönes ...Ich kenne mich ja sonst nicht gerade so aus mit BASCOM und dieser ganzen Programmierung
Was jetzt noch schön wäre , wären Bilder von der Schaltung und vielleicht ein Layout

MfG Alex

[synvox]

Naja, gelayoutet ist noch nichts . Ich habe die Testschaltung erstmal auf einem Steckbrett (sieht man auch im Video) aufgebaut. Es soll zwar dann endgültig eine kleine Design-Mood-Leuchte (mit zwei Seoul Z-Power P1 oder P5 full color RGB-LEDs) als Geschenkidee daraus geben, aber eben, Eile mit Weile .

uups... hätt ich jetzt fast noch vergessen... vielen Dank für die Credits natürlich .

Gruss
Neni

[Fightclub]

für dieses wirklich ausführliche Tutorial 200 Credits

[synvox]

Vielen Dank Fightclub für die Credits .

Gruss
Neni

[sleeping-head]

es wäre bestimmt auch möglich das ganze mit ner Fernbedienung zu steuern !!!

Hat vielleicht jemand ne idee wie man so was umsetzen könnte?
Weil ich möchte es in nächster Zeit mal nachbauen.


ach und kann ich das ganze auf nem evaluationsboard von pollin programmieren oder brauch ich da ein anderes dafür ??

[djjoke]

ich habe die Schaltung mal in eagle gerootet.

Die Schaltung ist nun mit den 5 Tastern und den 6 5mm LED´s 4x4cm groß.



Wer möchte eine solche Platine haben?? werde Sie mal testweise herstellen lassen.

Denke, dass sie so ca. 8€ + Versand kosten werden.

Einfach bei mir melden....