-
Programm "ausdünnen"
Hallo Freunde.
Ich arbeite derzeit an einer RGB-LED-Steuerung und bin für meine Verhältnisse schon sehr weit gekommen.Nachdem ich zunächst versucht hatte, das Programm aus Schnipseln und/oder ganzen Programmen aus dem Internet aufzubauen, was jedoch gar nicht funktionierte, schrieb ich es von grundauf komplett neu, mit eigenen Ideen und eigener Programm-Struktur. So hab ich da wenigstens den Durchblick ^^.
Das Programm umfasst dabei ein Hauptmenü, in welchem 8 Farben, erzeugt durch Hardware-PWM, anwählbar sind. Bleibt man in diesem Menü, so ist die Farbe dauerhaft leuchtend. Per Tastendruck wird dann in ein Untermenü geschaltet, welches diese Farbe nun pulsieren lässt (Auf- und Abdimmen). Als letzte Option kann vom Hauptmenü noch ein dauerhaft rotierender Farbwechsel angewählt werden.
Jedes Unterprogramm umfasst eine eigene DO...LOOP-Schleife, weil ich das Problem hatte, dass die ausgewählten GOSUB-Unterprozeduren nur einmal durchliefen und dann das gesamte Programm einfach wieder im Menü bei Null anhielt. Selbst der Zähler war gelöscht.
Mit den DO...Loop funktionierte es nun, jedoch ist mir das Programm viel zu groß geworden.
Da ich keine einzelnen Farben als Variablen in die Schleife setzen kann:
Gibt es eine Möglichkeit, das Programm auszudünnen und wenn ja - welche? Ich muss dazu sagen, dass ich nicht so klug und schnell-verstehend bin. Ich muss die Befehle auch verstehen können, und es ist echt schwer, das für mich in Worte zu fassen.
Das Programm ist 4KB groß und passte gerade noch so per BASCOM-Freeware auf den Controller. Nun habe ich die Vollversion gekauft, jedoch habe ich noch weitaus mehr mit dem Programm vor, weshalb es zwingend schlanker werden muss.
Wenn jemand von euch eine gute Idee hat, vielleicht einen Befehl kennt, der mir helfen könnte (Gedankenanstöße mit Erläuterung, wie der Befehl vielleicht korrekt einzusetzen ist), dann her damit.
Bei Fragen, komme ich dann auf die Empfehlungen zurück und hoffe, dass ihr dann wieder für mich da seid.
Hier das Programm:
Code:
$regfile = "m8def.dat"
$crystal = 8000000
$hwstack = 40
$swstack = 32
$framesize = 60
Config Pinc.0 = Input
Config Pinc.1 = Input
Taster1 Alias Pinc.0
Taster2 Alias Pinc.1
Dim Zaehler As Word ' Zaehler für Rot oder/und Grün
Dim Zaehler2 As Word 'Zaehler, wenn eine Farbe nur teilweise dimmen soll
Dim Zaehler_blau As Word ' Zaehler ausschließlich für Blau, da Blau vorgeteilt werden muss (Zaehler läuft 4mal schneller)
Dim V As Byte ' Zählvariable zum Steuern durch das Farbauswahlmenü
Dim V2 As Byte ' Zählvariable zum Überspringen der Aufdimmung beim Color-Fading (Fading durch alle Farben)
Dim P As Bit ' Zählvariable zum Anwählen der Pulsor-Programme
Config Timer1 = Pwm , Pwm = 10 , Compare A Pwm = Clear Down , Compare B Pwm = Clear Down , Prescale = 64 ' Timer für Rot und Grün
Config Timer2 = Pwm , Compare Pwm = Clear Down , Prescale = 1 , Pwm = On , Prescale = 1 'Timer für Blau
Enable Timer0
Start Timer1
Start Timer2
Enable Interrupts 'Ein Überbleibsel, als ich noch einen zusätzlichen Wartetimer nutzte, wird demnächst aber rausgenommen
Pwm1a = 0
Pwm1b = 0
Rot Alias Pwm1a
Gruen Alias Pwm1b
Blau Alias Ocr2
Declare Sub Rot_fading
Declare Sub Orange_fading
Declare Sub Gelb_fading
Declare Sub Gruen_fading
Declare Sub Azur_fading
Declare Sub Blau_fading
Declare Sub Violet_fading
Declare Sub Weiss_fading
Declare Sub Color_fading
'**************************************
' ***** Hauptprogramm Teil I *****
'**************************************
Do
Debounce Taster1 , 0 , Subtaster1 , Sub
Debounce Taster2 , 0 , Subtaster2 , Sub
Loop
End
' ***** Hauptprogramm Teil II *****
Subtaster1:
V = V + 1
If V = 1 Then
Rot = 1023 ' ROT
Elseif V = 2 Then
Rot = 1023 : Gruen = 341 ' ORANGE
Elseif V = 3 Then
Rot = 1023 : Gruen = 1023 ' GELB
Elseif V = 4 Then
Rot = 0 ' GRÜN
Elseif V = 5 Then
Gruen = 1023 : Blau = 1023 ' AZUR
Elseif V = 6 Then
Gruen = 0 ' BLAU
Elseif V = 7 Then
Rot = 1023 ' VIOLET
Elseif V = 8 Then
Gruen = 1023 : Blau = 1023 ' WEISS
Elseif V = 9 Then
Rot = 0 : Gruen = 0 : Blau = 0
Do
Rot = 1023 : Gruen = 1023 : Blau = 1023 ' Das schnelle Aufblinken soll zeigen, dass sich hier ein Farbwechselmodus verbirgt.
Waitms 100 'Da ich erst seit ein paar Tagen die BASCOM-Vollversion habe, musste ich die 4K einhalten. So war es am schlankesten ^^
Rot = 0 : Gruen = 0 : Blau = 0
Waitms 100
If Taster1 = 0 Then Exit Do
If Taster2 = 0 Then Call Color_fading
Loop
Elseif V = 10 Then
Rot = 0 : Gruen = 0 : Blau = 0 : V = 0 ' ALLE LED AUS
End If
Return
Subtaster2:
P = 0
If Taster2 = 0 Then Toggle P 'Ab hier können die Unterprogramme angewählt werden. Sie lassen die gewählte Farbe pulsieren.
If V = 1 And P = 1 Then Call Rot_fading
If V = 2 And P = 1 Then Call Orange_fading
If V = 3 And P = 1 Then Call Gelb_fading
If V = 4 And P = 1 Then Call Gruen_fading
If V = 5 And P = 1 Then Call Azur_fading
If V = 6 And P = 1 Then Call Blau_fading
If V = 7 And P = 1 Then Call Violet_fading
If V = 8 And P = 1 Then Call Weiss_fading
Return
' (**** ACHTUNG **** Die FOR...Next-Schleife kann durch Zwischensetzen einer
' Bedingung direkt zwischen FOR...TO und der Schrittzeit (Waitms) abgebrochen
' werden!!! UNBEDINGT MERKEN!)
' Die 3 Zeilen hierrüber sind ein Merkzettel für mich wo und wie ich die FOR-NEXT zu jedem Zeitpunkt unterbrechen kann. Für mich ein echter Durchbruch!
Sub Rot_fading:
Do
For Zaehler = 1023 To 0 Step -2 '
If Taster1 = 0 Then Exit Sub ' **** ACHTUNG **** (Zählen noch zu der Anmerkung hierüber, sonst keine Bedeutung)
Waitms 10
Rot = Zaehler
Next Zaehler
Wait 1
For Zaehler = 0 To 1023 Step 2
If Taster1 = 0 Then Exit Sub ' **** ACHTUNG ****
Waitms 10
Rot = Zaehler
Next Zaehler
Wait 1
Loop
End Sub
Sub Orange_fading:
Do
For Zaehler = 1023 To 0 Step -2
Zaehler2 = Zaehler / 3
If Taster1 = 0 Then Exit Sub
Waitms 10
Rot = Zaehler : Gruen = Zaehler2
Next Zaehler
Wait 1
For Zaehler = 0 To 1023 Step 2
Zaehler2 = Zaehler / 3
If Taster1 = 0 Then Exit Sub
Waitms 10
Rot = Zaehler : Gruen = Zaehler2
Next Zaehler
Wait 1
Loop
End Sub
Sub Gelb_fading:
Do
For Zaehler = 1023 To 0 Step -2
If Taster1 = 0 Then Exit Sub
Waitms 10
Rot = Zaehler : Gruen = Zaehler
Next Zaehler
Wait 1
For Zaehler = 0 To 1023 Step 2
If Taster1 = 0 Then Exit Sub
Waitms 10
Rot = Zaehler : Gruen = Zaehler
Next Zaehler
Wait 1
Loop
End Sub
Sub Gruen_fading:
Do
For Zaehler = 1023 To 0 Step -2
If Taster1 = 0 Then Exit Sub
Waitms 10
Gruen = Zaehler
Next Zaehler
Wait 1
For Zaehler = 0 To 1023 Step 2
If Taster1 = 0 Then Exit Sub
Waitms 10
Gruen = Zaehler
Next Zaehler
Wait 1
Loop
End Sub
Sub Azur_fading:
Do
For Zaehler = 1023 To 0 Step -2
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms 10
Gruen = Zaehler : Blau = Zaehler_blau
Next Zaehler
Wait 1
For Zaehler = 0 To 1023 Step 2
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms 10
Gruen = Zaehler : Blau = Zaehler_blau
Next Zaehler
Wait 1
Loop
End Sub
Sub Blau_fading:
Do
For Zaehler = 1023 To 0 Step -2
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms 10
Blau = Zaehler_blau
Next Zaehler
Wait 1
For Zaehler = 0 To 1023 Step 2
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms 10
Blau = Zaehler_blau
Next Zaehler
Wait 1
Loop
End Sub
Sub Violet_fading:
Do
For Zaehler = 1023 To 0 Step -2
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms 10
Rot = Zaehler : Blau = Zaehler_blau
Next Zaehler
Wait 1
For Zaehler = 0 To 1023 Step 2
Zaehler_blau = Zaehler / 4
Waitms 10
Rot = Zaehler : Blau = Zaehler_blau
Next Zaehler
Wait 1
Loop
End Sub
Sub Weiss_fading:
Do
For Zaehler = 1023 To 0 Step -2
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms 10
Rot = Zaehler : Gruen = Zaehler : Blau = Zaehler_blau
Next Zaehler
Wait 1
For Zaehler = 0 To 1023 Step 2
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms 10
Rot = Zaehler : Gruen = Zaehler : Blau = Zaehler_blau
Next Zaehler
Wait 1
Loop
End Sub
' ***** Das Farbwechsel-Unterprogramm *****
Sub Color_fading:
Do
'--- Rot ---
Rot = 0 : Gruen = 0 : Blau = 0
For Zaehler = 0 To 1023 Step 2
If Taster1 = 0 Then Exit Sub
Waitms 10
Rot = Zaehler
Next Zaehler
Wait 1
V2 = 2
Gosub Rot_aufgedimmt
Rot_aufgedimmt:
'--- Orange ---
For Zaehler = 0 To 1023 Step 2
Zaehler2 = Zaehler / 3
If Taster1 = 0 Then Exit Sub
Waitms 10
Gruen = Zaehler2
Next Zaehler
Wait 1
'--- Gelb ---
For Zaehler = 323 To 1023 Step 2
If Taster1 = 0 Then Exit Sub
Waitms 10
Gruen = Zaehler
Next Zaehler
Wait 1
'--- Grün ---
For Zaehler = 1023 To 0 Step -2
If Taster1 = 0 Then Exit Sub
Waitms 10
Rot = Zaehler
Next Zaehler
Wait 1
'--- Weiß ---
For Zaehler = 0 To 1023 Step 2
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms 10
Rot = Zaehler : Blau = Zaehler_blau
Next Zaehler
Wait 1
'--- Azur ---
For Zaehler = 1023 To 0 Step -2
If Taster1 = 0 Then Exit Sub
Waitms 10
Rot = Zaehler
Next Zaehler
Wait 1
'--- Blau ---
For Zaehler = 1023 To 0 Step -2
If Taster1 = 0 Then Exit Sub
Waitms 10
Gruen = Zaehler
Next Zaehler
Wait 1
'--- Violet ---
For Zaehler = 0 To 1023 Step 2
If Taster1 = 0 Then Exit Sub
Waitms 10
Rot = Zaehler
Next Zaehler
Wait 1
'--- Übergang violet zu Rot ---
For Zaehler = 1023 To 0 Step -2
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms 10
Blau = Zaehler_blau
Next Zaehler
Wait 1
Gosub Rot_aufgedimmt
Loop
End Sub
-
Die Routinen für das Fading könnte man ggf, noch zusammenfassen. Es braucht dann aber den Indirekten Zugriff auf des Register. Wie das in BASIC geht weiß ich nicht.
Ein Versuch wäre ggf. eine Parameter mit Call by Reference.
-
Hallo stardust19322,
schau dir mal den Befehl "select case" an. Damit wäre es denke ich möglich schon sehr viel zusammen zu fassen.
Dazu die Interrupts für die zwei Taster nutzen um einmalig je eine Variable zu setzen die die Schleife abbricht oder auswählbar macht ob fading oder nicht fading.
V und V2 sind zwar sehr kurze Variablen, sie "sprechen" aber auch nicht - wenn du sie zb umbennenst in RGB_taster und Fading_taster dann sprechen sie schon etwas. Wenn du den Codeaufbau auf eine Select_Case inklusive dem Fading aufbaust dann könntest du damit sehr viel Code ein sparen. Die Farbenwahl würde ich direkt im case auswählen - also case 1 (soll rot sein), "rot = 1023, grün = 0, blau = 0". So bei jeder Farbwahl verfahren, dann braucht man kiene Rücksicht darauf beim programmieren nehmen, welche Farbe man in der if-Abfrage davor gewählt hatte. Das wäre dann das Hauptprogramm.
Da sich im Code die Anzahl der waits dadurch reduzieren müssten, wäre es möglich auch hier für die Wartezeiten Variablen zu vergeben. Ich habe zwei Zeiten gesehen - "wait 1" wird zu "wait waitms1000" oder "1sec" und waitms 10 wird zu "wait waitms10" oder "10msec" - damit hast du dann praktisch auch direkten Zugriff auf die Fadingzeiten und könntest diese dann auch mit manipulieren.
Das Fading würde ich versuchen so halten das die Bedingungen für den Durchlauf und auch der Step (2 oder -2) einfach ausgetauscht werden können. Ob das mit einem For-Next Konstrukt möglich ist sagt die Hilfe oder ein Versuch. Ich müsste es jetzt selbst nachlesen und/oder ausprobieren. Wenn es damit nicht möglich sein sollte zu tauschen, dann das Konstrukt auf etwas passendes ändern.
Diese Massnahme allein würden den Code innerhalb der beiden verschiedenen Fadings geschätzt schon auf über die Hälfte reduzieren.
Ich hoffe es wird dir helfen.
Viele Grüße
Jörg
-
Hallöle Hex ^^.
Danke sehr für deine ausführliche und hilfreiche Antwort.
An Select-Case habe ich schon gar nicht mehr gedacht. Als ich das Programm im Software-PWM-Modus aufbaute, musste ich diese Anweisung nutzen.
Fraglich ist nur, wie ich das zutreffende Ereignis (beispielsweise Case 3 = true) dann mit dem Fading-Unterprogramm verbinde. Aber das bekomme ich schon irgendwie hin.
Gestern wurde es bei mir ja sehr spät - konnte erst gegen halb 2 morgens in Bett, weil mich Fortschritte im Programmablauf extrem weit voran brachten. Da ich immer Probleme hatte, Variablen in die DO...LOOP zu übergeben, habe ich nun eine Möglichkeit gefunden, diese gänzlich zu entfernen, sodass nur noch eine Hauptschleife und entsprechende Subroutinen verblieben sind. Habe mir dazu ein Testprogramm geschaffen, in welchem nur 4 Möglichkeiten des Farb-Fadings auswählbar sind, um zu schauen, ob die Variablen auch sauber funktionieren. Die Farben blieben trotzdem noch alle erhalten.
Dazu konnte ich in einem ersten versuch erfolgreich eine 5-stufige Dimmfunktion einbauen. Allerdings muss ich noch (wie du bereits geschrieben hast, Hex) die Fading-Zeiten ändern, denn mit heruntersetzen der Helligkeit (Wurzel 1,5) beschleunigt sich das Pulsor-Verhalten, und das soll es nicht. Also muss ich die Zeiten mit 1,5 je Stufe zum Quadrat nehmen.
Ich denke, dass es machbar ist, die Step's komplett auf 1 zu setzen, im Gegenzug die Wartezeit je Takt verringern. Derzeit läuft der Takt mit einem 10ms-Delay, dafür werden aber nur alle 2 Takte gezählt, das Delay steht real also bei nur 5ms. Ich probiere noch ein wenig - dann geb ich dir/euch Bescheid.
Mit den Variablen-Namen halte ich mich auch recht kurz. Zeit ist zwar nicht Geld, jedoch tippt man sich auch schnell mal die Finger wund, wenn man 20mal die gleiche Variable vertippeln muss ^^
LG - Maik
-
Hallo Maik,
eigentlich ganz einfach wenn es in ein Unterprogramm laufen soll: case 3 = Gosub Unterprogramm (für Fall 3). Du kannst den case auch in innerhalb der angesprungenen Sub erneut auswerten sofern er sich noch nicht geändert hat. Und das kann man ja gut steuern ;)
Nur wenn man die Bedingungen der For-Nextschleife tauschen möchte - das gilt es ja mal zu prüfen ob es überhaupt geht, das zu Laufzeit zu ändern(?) - also hoch und runter zählen möchte, dann benötigt man irgendwie einen wechsel mit dem Stepper als Variable damit der Step negativ wird. Da gibt es z.b. die Lösung des
"stepwert = 1 (stepwert) *-1 " wird negativ oder eine Abzweigung den wert zu setzen.
Ich denke auch das es eine bessere Methode ist nicht mit einem Mischzustand im Zähler-/Timingbereich indirekt zu arbeiten - was jetzt also so 2er Steps z.b. betrifft. Damit holt man sich einfach zu viele unnötige Stolpersteine rein. Lieber den Zähler normal Zählen lassen - übrigens benötigt man den nicht beim hochzählen, weil er im Hintergrund auf 1 voreingestellt ist und dann ohne weiteres zu tun genutzt wird. Beim runterzählen benötigt man aber zwingend das Minus (-) vor der geschriebenen 1.
Ich finde die Idee mit dem zweiten Taster zu toggeln garnicht so schlecht. Wenn du darauf einen Interrupt legst, und innerhalb dessen toggelst, dann kannst du in dem ersten case für z.b. "rot" PWM mit if (Taster2 = 1) then...das Fading einleiten indem du hier gleich die 3 PWM-Wert auf Variablen setzt und dann dort heraus eine FadingSUB anspringst. Dieser eine Sub wird jetzt mit den drei PWM-Werten betrieben - und ob die jetzt hoch und anschliessend wieder runter zählt oder ob man da noch einige Codetricks anwenden kann spielt kaum noch eine Rolle. Der Übersicht halber die einfachst Art benutzen.
Warum wird der Zähler bei blau durch 4 geteilt?
Na, ich hoffe es hilft dir.
Viele Grüße
Jörg
-
Hallo Jörg.
Der Zähler für "Blau" wird aus dem Grund durch 4 geteilt, da dieser Zähler seltsamerweise 4mal schneller läuft als die Anderen. Bei der Farbanwahl fiel mir das erst gar nicht auf. Erst, als ich die Farben das erste Mal gemischt (Violet = rot und blau) faden ließ, überlief der blaue Zähler 3mal in beide Richtungen, also sowohl beim Aufdimmen als auch beim Abdimmen. Demzufolge Werte durch 4 geteilt und das funzt 1a. ^^
Hm, ich verstehe nicht ganz, was genau du mit deinem Vorschlag "Wait Waitms 10" meinst. Ich kann dies ja nicht hintereinander schreiben, denn dann meckert BASCOM und erwartet noch weitere Variablen.
Die Hauptschleife mit den Fallbedingungen "Select_Case" funktioniert bereits einwandfrei. Habe hinter jeder Leuchtfarbe eines Falls noch eine Variable gesetzt, welche mit dem Fall mitgesetzt wird. Somit leuchtet die entsprechende Farbe und ein zusätzlicher Merker bleibt im Hintegrund aktiv, von welchem dann auch das richtige Fading angesprungen werden kann.
Leider war es mir bislang nicht möglich, die Takt-Pausenzeiten in-program zu verlängern oder zu verkürzen, wodurch sich die Fading-Zeit ebenfalls verlängern oder verkürzen würde.
Ebenfalls keine Chance beim Ändern der Farbe innerhalb der Routine, egal wo ich ansetze:
Code:
For Zaehler = X To Y Step -2
If Taster1 = 0 Then Exit For
Waitms Schrittpause
Rot = Zaehler
Next Zaehler
Ich konnte zwar die Zeit für den Durchlauf eines Zyklus anpassen, jedoch nach Ablauf dieses Zyklus (einmal von X nach Y gezählt) stellten sich die Werte wieder auf den Basiswert zurück. Außerhalb der Sub kann ich jedoch auch keine Zeiten per Variable übergeben.
LG - Maik
-
Moin Maik,
ich freue mich das es bei dir schon Fortschritte gibt.
Mit "wait Waitms 10" (ohne Leerzeichen: Waitms10) meine ich eine Variable die sich "Waitms10" nennt ;) Sie ist sprechend und wird dann mit 10ms als Wartezeit inizialisiert. Du hast sie jetzt "Schrittpause" genannt, ist auch okay. Denk daran du hattest oben zwei verschiedene Pausenzeiten drin.
Ein "wait" gefolgt von einfachem "waitms" geht halt nicht, weil es beides Schlüsselwörter in Bascom sind. Deshalb kann man den Wert für wait in eine Variable packen, dann geht's ;)
Du hast in der Config vom Zähler Blau übrigens den Prescaler doppelt gesetzt - ob's was negatives oder garnichst weiter bewirkt kann ich nicht sagen, dazu bin ich bei dem Prescaler so auf Anhieb nicht sicher genug.
Ich denke mal das sich die Werte nicht von alleine auf den Basiswert zurückstellen/verändern. Sie müssen natürlich manuell programmtechnisch getauscht werden. Und es ist ja der "Zähler" der dann den neuen Wert aufnimmt, nicht x und y - die bleiben so wie sie sind wenn daran nichts geändert wird.
Es gibt aber grundsätzlich mehrere Möglichkeiten das zu lösen, also kann es sich auch lohnen an dieser Art Schleife dran zu bleiben muss aber nicht.
Jetzt fehlt eigentlich nur noch Dein aktuelles Programm ;)
Weiterhin viel Erfolg und Grüße aus dem Norden
Jörg
-
Hallo Jörg.
Ach das meintest du... ^^
Variablen zum Ersetzen der Zeitangabe hatte ich bereits versucht und es funktionierte eben nur außerhalb der For-Schleife. Allerdings war ich mit meinen Experimenten noch nicht vollständig durch. Ich möchte meinen, dass ich versuchte, die Dimmzeit On-The-Fly zu verändern, als während das entsprechende Programm lief, aber das ist ja nicht das, was ich erreichen möchte.
Denke, dass es ausreicht, wenn ich jeder Dimmphase eine eigene Zeitvariable zuweise - also fest zuweise. Diese wird dann vor dem Dimmprozess bereits aufgerufen. Allerdings kann dann nur während dem Konstant-Leuchtmodus gedimmt werden und nicht während des Pulsmodus, da im Pulsing die Zeit offensichtlich nicht verändert werden kann oder darf, sonst stoppt das Fading an der Stelle (Led bleibt halb leuchtend "stehen").
Hm - ich muss mir das Programm noch mal anschauen. Wenn der Prescaler dort doppelt gesetzt ist, dann wird einer entfernt. Schädlich sollte es wohl nur sein, wenn dieser 2te einen anderen Wert hat als der erste ^^.
Eine andere Art Schleife, um das Fading zu realisieren, hatte ich bereits einmal versucht (Ebenfalls eine Zählschleife mit Incr und Decr), jedoch konnte ich hier keine Zeiten ändern. Die zählten also so schnell, dass ich das nicht mal wirklich sehen konnte. Wäre natürlich super, wenn es eine "flexiblere" Variante zum Auf- und Abdimmen geben würde, bei der ich auch die Farben vor dem Aufruf des Unterprogramms tauschen kann, aber solange das nicht geht, bin ich an FOR-NEXT gebunden.
Werde die Tage mal alles zusammenstellen, was ich habe und brauche. Die Dimmfunktion mit den sazugehörigen Zeiten in das Testprogramm einbinden.
Später müsste ich noch alles auf den "Anwendungsfall" umschreiben, also alle Variablen ändern. Aus X = 1023 wird dann X = 0, aus Y = 0 wird Y = 1023 - und so auch mit allen Zwischenwerten, sonst leuchten die falschen Farben auf, und das Problem hatte ich beim ersten Versuch mit einer Prototypen-Platine.
LG - Maik
-
Hallo Maik,
Habe gerade nachgesehen, Bascom kennt Funktionen, diese werden mit Call aufgerufen.
Aufruf wäre dann z.B.
Call Fading(Rot, Gruen, Blau)
Die Fading-Funktion kann dann alle Farben und wird nur einmal benötigt.
Mit den Werten für die 3 Farben wird festgelegt, welche Farben angesteuert werden müssen.
MfG Peter(TOO)
-
Hallo Peter.
Danke erst einmal für deine Antwort. Leider funktioniert der Schritt jedoch nicht, jedenfalls nicht so, wie ich es mir wünschen würde. Sprich: Trotz Einbinden von Call-aufgerufenen Funktionen/Unterprogrammen kann nur die direkt in der FOR-Bedingung mit dem Zaehler in Verbindung gebrachte Farbe auch direkt angesteuert werden. Das siehst du oben in dem Programmablauf. Dort sind bereits die Call(ings) hinterlegt und rufen auch die Unterprozeduren auf.
Das Ganze hat allerdings auch einen Nachteil: Das Unterprogramm läuft dann nur EINMAL durch und stoppt anschließend. Selbst mit "While" hält das Programm dort an. Es bringt also nicht den gewünschten Effekt und ich müsste dennoch mit separaten DO-LOOP-Schleifen arbeiten, welche jedoch nur bedingt fremde Variablen annehmen.
LG - Maik
-
Code? Edit:
Durch den gosub aufruf am Ende von Color_fading sollte Dein Stack irgendwann überlaufen:
Ich habe es auf 22% bekommen. Keine Ahnung, ob es noch läuft :cool:
Code:
$regfile = "m8def.dat"
$crystal = 8000000
$hwstack = 80
$swstack = 64
$framesize = 60
Config Pinc.0 = Input
Config Pinc.1 = Input
Taster1 Alias Pinc.0
Taster2 Alias Pinc.1
Dim Zaehler As Word ' Zaehler für Rot oder/und Grün
Dim Zaehler2 As Word 'Zaehler, wenn eine Farbe nur teilweise dimmen soll
Dim Zaehler_blau As Word ' Zaehler ausschließlich für Blau, da Blau vorgeteilt werden muss (Zaehler läuft 4mal schneller)
Dim V As Byte ' Zählvariable zum Steuern durch das Farbauswahlmenü
Dim V2 As Byte ' Zählvariable zum Überspringen der Aufdimmung beim Color-Fading (Fading durch alle Farben)
Dim P As Bit ' Zählvariable zum Anwählen der Pulsor-Programme
Config Timer1 = Pwm , Pwm = 10 , Compare A Pwm = Clear Down , Compare B Pwm = Clear Down , Prescale = 64 ' Timer für Rot und Grün
Config Timer2 = Pwm , Compare Pwm = Clear Down , Prescale = 1 , Pwm = On , Prescale = 1 'Timer für Blau
Enable Timer0
Start Timer1
Start Timer2
Enable Interrupts 'Ein Überbleibsel, als ich noch einen zusätzlichen Wartetimer nutzte, wird demnächst aber rausgenommen
Pwm1a = 0
Pwm1b = 0
Rot Alias Pwm1a
Gruen Alias Pwm1b
Blau Alias Ocr2
Declare Sub Rot_fading
Declare Sub Orange_fading
Declare Sub Gelb_fading
Declare Sub Gruen_fading
Declare Sub Azur_fading
Declare Sub Blau_fading
Declare Sub Violet_fading
Declare Sub Weiss_fading
Declare Sub Color_fading
'**************************************
' ***** Hauptprogramm Teil I *****
'**************************************
Do
Debounce Taster1 , 0 , Subtaster1 , Sub
Debounce Taster2 , 0 , Subtaster2 , Sub
Loop
End
' ***** Hauptprogramm Teil II *****
Subtaster1:
V = V + 1
select case V
case 1
gosub r1023
' Rot = 1023 ' ROT
case 2
gosub r1023
gruen=341
' Rot = 1023 : Gruen = 341 ' ORANGE
case 3
gosub r1023
gosub g1023
' Rot = 1023 : Gruen = 1023 ' GELB
case 4
Rot = 0 ' GRÜN
case 5
gosub G1023
gosub b1023
' Gruen = 1023 : Blau = 1023 ' AZUR
case 6
Gruen = 0 ' BLAU
case 7
gosub r1023
' Rot = 1023 ' VIOLET
case 8
gosub G1023
gosub b1023
' Gruen = 1023 : Blau = 1023 ' WEISS
case 9
gosub allenull
Do
gosub r1023
gosub g1023
gosub b1023
' Rot = 1023 : Gruen = 1023 : Blau = 1023 ' Das schnelle Aufblinken soll zeigen, dass sich hier ein Farbwechselmodus verbirgt.
waitms 100 'Da ich erst seit ein paar Tagen die BASCOM-Vollversion habe, musste ich die 4K einhalten. So war es am schlankesten ^^
gosub allenull
waitms 100
If Taster1 = 0 Then Exit Do
If Taster2 = 0 Then Call Color_fading
Loop
case 10
gosub allenull
V = 0 ' ALLE LED AUS
end select
Return
r1023:
rot = 1023
return
g1023:
gruen = 1023
return
b1023:
blau = 1023
return
allenull:
Rot = 0 : Gruen = 0 : Blau = 0
return
pause:
waitms 10
return
pausel:
waitms 1000
return
Subtaster2:
P = 0
If Taster2 = 0 Then Toggle P 'Ab hier können die Unterprogramme angewählt werden. Sie lassen die gewählte Farbe pulsieren.
if p=1 then
gosub fadings
end if
Return
' (**** ACHTUNG **** Die FOR...Next-Schleife kann durch Zwischensetzen einer
' Bedingung direkt zwischen FOR...TO und der Schrittzeit (Waitms) abgebrochen
' werden!!! UNBEDINGT MERKEN!)
' Die 3 Zeilen hierrüber sind ein Merkzettel für mich wo und wie ich die FOR-NEXT zu jedem Zeitpunkt unterbrechen kann. Für mich ein echter Durchbruch!
fadings:
For Zaehler = 1023 To 0 Step -2 '
If Taster1 = 0 Then return ' **** ACHTUNG **** (Zählen noch zu der Anmerkung hierüber, sonst keine Bedeutung)
gosub fadecase
Next Zaehler
gosub pausel
For Zaehler = 0 To 1023 Step 2
If Taster1 = 0 Then return ' **** ACHTUNG ****
gosub fadecase
Next Zaehler
gosub pausel
return
fadecase:
gosub pause
select case v
case 1
gosub rz
case 2
gosub rgz
case 3
gosub grz
case 4
gosub gz
case 5
gosub bzbgz
case 6
gosub bzb
case 7
gosub rz
gosub bzb
case 8
gosub grz
gosub BZB
end select
return
' ***** Das Farbwechsel-Unterprogramm *****
Sub Color_fading:
Do
'--- Rot ---
Rot = 0 : Gruen = 0 : Blau = 0
For Zaehler = 0 To 1023 Step 2
If Taster1 = 0 Then Exit Sub
gosub pause
gosub rz
Next Zaehler
gosub pausel
V2 = 2
'Gosub Rot_aufgedimmt 'wozu?
Rot_aufgedimmt:
'--- Orange ---
For Zaehler = 0 To 1023 Step 2
gosub z2z3
If Taster1 = 0 Then Exit Sub
gosub pause
Gruen = Zaehler2
Next Zaehler
gosub pausel
'--- Gelb ---
For Zaehler = 323 To 1023 Step 2
If Taster1 = 0 Then Exit Sub
gosub pause
Gruen = Zaehler
Next Zaehler
gosub pausel
'--- Grün ---
For Zaehler = 1023 To 0 Step -2
If Taster1 = 0 Then Exit Sub
gosub pause
gosub rz
Next Zaehler
gosub pausel
'--- Weiß ---
For Zaehler = 0 To 1023 Step 2
gosub zbz4
If Taster1 = 0 Then Exit Sub
gosub pause
gosub rz
gosub BZB
Next Zaehler
gosub pausel
'--- Azur ---
For Zaehler = 1023 To 0 Step -2
If Taster1 = 0 Then Exit Sub
gosub pause
gosub rz
Next Zaehler
gosub pausel
'--- Blau ---
For Zaehler = 1023 To 0 Step -2
If Taster1 = 0 Then Exit Sub
gosub pause
gosub gz
Next Zaehler
gosub pausel
'--- Violet ---
For Zaehler = 0 To 1023 Step 2
If Taster1 = 0 Then Exit Sub
gosub pause
gosub rz
Next Zaehler
gosub pausel
'--- Übergang violet zu Rot ---
For Zaehler = 1023 To 0 Step -2
gosub zbz4
If Taster1 = 0 Then Exit Sub
gosub pause
gosub bzb
Next Zaehler
gosub pausel
goto Rot_aufgedimmt
Loop
End Sub
z2z3:
Zaehler2 = Zaehler / 3
return
zbz4:
Zaehler_blau = Zaehler / 4
return
grz:
gosub gz
rz:
Rot = Zaehler
return
bzbgz:
gosub bzb
gz:
Gruen = Zaehler
return
bzb:
Blau = Zaehler_blau
return
rgz:
gosub RZ
Gruen = Zaehler2
return
Man kann viel sparen, indem man gleichen Code in Subs auslagert.
-
Hallo Peterfido
und lieben vielen Dank für deine Mühen. Habe deine Mühen erst jetzt gesehen und konnte sie deshalb noch nicht ausprobieren. Es sind auch Befehle dabei, die ich erst einmal genauer unter die Lupe nehmen muss.
Gestern war ich fast den ganzen Tag mit der Funktions-Perfektionierung meines Programms beschäftigt. Es schien gegen 22h dann soweit zu sein - alles lief. Ich muss dazu sagen, dass ich einen Großteil neu schreiben musste, zudem musste ich ALLE Werte invertieren, eben wegen der negativen Kennlinie der LED.
Auf meinem Testboard bedeutet die Ziffer NULL, dass die LED aus ist, bei 1023 leuchtet sie hell auf. Auf dem Testboard hingegen ist es genau umgekehrt: NULL - die LED leuchtet voll, 1023 - die LED ist aus.
Und hier begann das Debakel, denn das Programm lief nur im Modus mit voller Helligkeit - beim Dimmen ging alles schief:
In exakt einem Teilabschnitt, nämlich dem Fading des ORANGE, leuchtete beim Start des Fadings Grün voll auf und dimmte nur ganz leicht herunter, während Rot brav der Anweisung des Programms folgte.
Was also machen?
Ich probierte wirklich sehr viel, schob die Variablen hin und her, invertierte den Zähler und hätte auf diesem Pfad bleiben sollen - doch kam aufgrund neuer, ins Leben zu rufender Hilfsvariablen immer wieder vom Weg ab.
Erst gegen halb 2h morgens hatte ich dann die Lösung und es funktionierte astrein:
Zunächst invertierte ich den Zählwert des Hauptzählers, denn die Farbe Orange wird aus Rot und Grün zusammengesetzt - und grün folgt dabei nur Orange. Grün darf dabei nur ein Drittel so hell leuchten als rot.
Das Programm zählte dabei von 0 (LED_AN) nach 1023 (LED_AUS). In einem ersten Versuch teilte ich diesen Wert sofort durch 3, was jedoch IMMER zu dem selben Produkt führte: 341. Es sollte aber erst von einem bestimmten Wert (z.B. 800) nach oben zählen.
Also invertierte ich den ersten Zählwert. 1023 - 0 = 1023, 1023 - 1023 = 0. Also wurde aus Null 1023 und aus 1023 wurde Null. Diesen Wert teilte ich nun durch 3 und somit konnte dieser nun beim Dimmen jeglichen Wert zwischen Null und 341 annehmen, jedoch fadete Grün nun exakt entgegengesetzt zu Rot: Wenn Rot 1023 erreichte, erreichte Grün Null. Da der Wert nun aber zwischen Null und 341 zählte, ich ihn aber zwischen 682 und 1023 brauchte, musste ich den neuen Wert erneut invertieren: 1023 - neuer Zählwert = Ergebniss für Orange.
Mit ein wenig Hilfe von Jörg, der mich in die richtige Richtung lenkte, konnte ich nun auch die Auf- und Abdimmzeiten entsprechend anpassen, denn beim Dimmen wird der Zählwert verkleinert, wodurch die LED schneller pulsiert, soll sie aber nicht.
Hier der komplette Codesatz:
Code:
$regfile = "m8def.dat"
$crystal = 8000000
$hwstack = 40
$swstack = 32
$framesize = 60
$baud = 9600
' Konfigurieren der Eingänge
Config Pinc.0 = Input
Config Pinc.1 = Input
Config Pinc.2 = Input
Config Pinc.3 = Input
' Umbenennen der Eingängen
Taster1 Alias Pinc.0 ' Farbwauswahl und Cancel aus Pulsing
Taster2 Alias Pinc.1 ' Pulsing-Anwahl
Taster3 Alias Pinc.2 ' Dunkler dimmen
Taster4 Alias Pinc.3 ' Heller dimmen
'Festlegen der Variablen
Dim Farbwahl As Byte
Dim Color As Byte
Dim Zaehler As Word
Dim Zaehler2 As Word
Dim Zaehler3 As Word
Dim Zaehler4 As Word
Dim Zaehler_blau As Word
Dim Schrittpause As Byte
Dim Brightness As Byte
Dim P As Bit
Dim X As Word
Dim X_orange As Word
Dim X_blau As Word
Dim Y As Word
Dim V2 As Byte
'Konfigurieren der Timer zu PWM-Ausgängen
Config Timer1 = Pwm , Pwm = 10 , Compare A Pwm = Clear Down , Compare B Pwm = Clear Down , Prescale = 64
Config Timer2 = Pwm , Compare Pwm = Clear Down , Prescale = 1 , Pwm = On , Prescale = 1
Enable Timer0
Start Timer1
Start Timer2
Enable Interrupts
Pwm1a = 0
Pwm1b = 0
'Festlegen der festen Zählvariable Y (Orange und Blau werden als Zählvariable flexibel definiert)
'X_orange = 682 Divisor für Helligkeitswerte = 1,5: 1 = 746, 2 = 871, 3 = 922, 4 = 956, 5 = 978
'X_blau = 768 Divisor für Helligkietswerte = 1,5: 1 = 853, 2 = 910, 3 = 947, 4 = 973, 5 = 989
Y = 1023
'Konfigurieren der Ausgangsvariablen
Rot Alias Pwm1a
Gruen Alias Pwm1b
Blau Alias Ocr2
Declare Sub Fading
'-------------------------------------------------------------------------------
' *******************************
' ***** Hauptprogramm *****
' *******************************
'-------------------------------------------------------------------------------
Do
Debounce Taster1 , 0 , Subtaster1 , Sub ' Startet Farbauswahl und Rückkehr in Farbauswahl
Debounce Taster2 , 0 , Subtaster2 , Sub ' Startet Fading-Modus
Debounce Taster3 , 0 , Subtaster3 , Sub ' Abdimmen der LED VOR dem Fading
Debounce Taster4 , 0 , Subtaster4 , Sub ' Aufdimmen der LED VOR dem Fading
'- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
' Hauptprogramm: Farbauswahlmenü
Select Case Farbwahl
Case 0 : Rot = Y : Gruen = Y : Blau = Y : Color = 0 ' ALLE LED AUS
Case 1 : Rot = X : Gruen = Y : Blau = Y : Color = 1 ' ROT
Case 2 : Rot = X : Gruen = X_orange : Blau = Y : Color = 2 ' ORANGE
Case 3 : Rot = X : Gruen = X : Blau = Y : Color = 3 ' GELB
Case 4 : Rot = Y : Gruen = X : Blau = Y : Color = 4 ' GRÜN
Case 5 : Rot = X : Gruen = X : Blau = X_blau : Color = 5 ' WEISS
Case 6 : Rot = Y : Gruen = X : Blau = X_blau : Color = 6 ' AZUR
Case 7 : Rot = Y : Gruen = Y : Blau = X_blau : Color = 7 ' BLAU
Case 8 : Rot = X : Gruen = Y : Blau = X_blau : Color = 8 ' VIOLET
Case 9 : Rot = X : Gruen = X : Blau = X_blau : Color = 9 ' COLOR-FADING
Waitms 150
Rot = Y : Gruen = Y : Blau = Y : Color = 9 ' Das schnelle Blinken soll die Bereitschaft zum Farbwechsel signalisieren (spart Speicherplatz)
Waitms 150
End Select
'- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
' Hauptprogramm: Dimm-Stufen (Variable Brightness wird ins Unterprogramm übergeben)
Select Case Brightness
Case 0 : X = 0 : X_orange = 682 : X_blau = 768 : Schrittpause = 6
Case 1 : X = 341 : X_orange = 746 : X_blau = 853 : Schrittpause = 9
Case 2 : X = 568 : X_orange = 871 : X_blau = 910 : Schrittpause = 13
Case 3 : X = 720 : X_orange = 922 : X_blau = 947 : Schrittpause = 20
Case 4 : X = 821 : X_orange = 956 : X_blau = 973 : Schrittpause = 30
Case 5 : X = 889 : X_orange = 978 : X_blau = 989 : Schrittpause = 45
End Select
Loop
End
'-------------------------------------------------------------------------------
' ***** Unterprogramme *****
'-------------------------------------------------------------------------------
Subtaster1: ' #### Farbauswahl ####
Incr Farbwahl
If Farbwahl = 10 Then Farbwahl = 0
Return
'- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Subtaster2: ' #### Aktivieren des Puls-Modus ####
If Taster2 = 0 Then Toggle P
If Color > 0 And P = 1 Then Call Fading
Waitms 100 ' Nach Start des Puls-Modus bleibt Variable "P" auf 1 stehen. Dadurch musste bei einem Abbruch des Pulsing-Mode und neuer Farbauswahl...
Toggle P ' ...immer einmal leer der Zähler P auf Null gesetzt werden. Nach dem Aktivieren des Fading wird "P" nun automatisch auf Null gesetzt.
Return
'- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Subtaster3: ' #### Test-Taster langsamer/dunkler ####
If Taster3 = 0 Then Brightness = Brightness + 1
If Brightness = 6 Then Brightness = 5 ' Wenn der Zähler den Wert 6 erreicht hat, wird dieser auf 5 zurück gestellt.
Return
'- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Subtaster4: ' #### Test-Taster schneller/heller ####
If Taster4 = 0 Then Brightness = Brightness - 1
If Brightness = -1 Then Brightness = 0 ' Trotz "Byte-Deklarierung" zählt der Zähler bei Tasten bis -1 und wird anschließend auf Null zurück gesetzt.
Return
'-------------------------------------------------------------------------------
' **** ACHTUNG **** Die FOR...NEXT-Schleife kann durch Zwischensetzen einer
' Bedingung direkt zwischen FOR...TO und der Schrittzeit (Waitms) abgebrochen
' werden!!! UNBEDINGT MERKEN!
Sub Fading:
If Taster3 = 0 Then Taster3 = 1 ' Setzt Taster3 während des Fadings außer Kraft
If Taster4 = 0 Then Taster4 = 1 ' Setzt Taster4 während des Fadings außer Kraft
'ROT
While Color = 1
For Zaehler = X To Y
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Rot = Zaehler
Next Zaehler
Waitms 100
For Zaehler = Y To X Step -1
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Rot = Zaehler
Next Zaehler
Waitms 10
Wend
'ORANGE
While Color = 2
For Zaehler = X To Y
Zaehler4 = 1023 - Zaehler ' Zählwert für Orange wird invertiert
Zaehler3 = Zaehler4 / 3 ' Invertierter Zählwert wird durch 3 dividiert (Fading nun invertiert zu Rot)
Zaehler2 = 1023 - Zaehler3 ' Neuer Zählwert wird erneut invertiert, (Fading nun parallel zu Rot)
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Rot = Zaehler : Gruen = Zaehler2
Next Zaehler
Waitms 100
For Zaehler = Y To X Step -1
Zaehler4 = 1023 - Zaehler
Zaehler3 = Zaehler4 / 3
Zaehler2 = 1023 - Zaehler3
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Rot = Zaehler : Gruen = Zaehler2
Next Zaehler
Waitms 10
Wend
'GELB
While Color = 3
For Zaehler = X To Y
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Rot = Zaehler : Gruen = Zaehler
Next Zaehler
Waitms 100
For Zaehler = Y To X Step -1
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Rot = Zaehler : Gruen = Zaehler
Next Zaehler
Waitms 10
Wend
'GRÜN
While Color = 4
For Zaehler = X To Y
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Gruen = Zaehler
Next Zaehler
Waitms 100
For Zaehler = Y To X Step -1
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Gruen = Zaehler
Next Zaehler
Waitms 10
Wend
'WEISS
While Color = 5
For Zaehler = X To Y
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Rot = Zaehler : Gruen = Zaehler : Blau = Zaehler_blau
Next Zaehler
Waitms 100
For Zaehler = Y To X Step -1
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms 10
Rot = Zaehler : Gruen = Zaehler : Blau = Zaehler_blau
Next Zaehler
Waitms 10
Wend
'AZUR
While Color = 6
For Zaehler = X To Y
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Gruen = Zaehler : Blau = Zaehler_blau
Next Zaehler
Waitms 100
For Zaehler = Y To X Step -1
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Gruen = Zaehler : Blau = Zaehler_blau
Next Zaehler
Wend
'BLAU
While Color = 7
For Zaehler = X To Y
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Blau = Zaehler_blau
Next Zaehler
Waitms 100
For Zaehler = Y To X Step -1
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Blau = Zaehler_blau
Next Zaehler
Wend
'VIOLET
While Color = 8
For Zaehler = X To Y
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Rot = Zaehler : Blau = Zaehler_blau
Next Zaehler
Waitms 100
For Zaehler = Y To X Step -1
Zaehler_blau = Zaehler / 4
Waitms Schrittpause
Rot = Zaehler : Blau = Zaehler_blau
Next Zaehler
Wend
'ALL COLOR FADING
' --- Rot ---
While Color = 9
Rot = Y : Gruen = Y : Blau = Y
For Zaehler = Y To X Step -1
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Rot = Zaehler
Next Zaehler
Waitms 1000
V2 = 2
Gosub Rot_aufgedimmt ' Der erste Abschnitt wird nur beim Start angesprungen, anschließend fährt das Programm im Unterprogramm fort
Rot_aufgedimmt:
'--- Orange ---
For Zaehler = Y To X_orange Step -1
Zaehler2 = Zaehler
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Gruen = Zaehler2
Next Zaehler
Waitms 1000
'--- Gelb ---
For Zaehler = X_orange To X Step -1
Zaehler2 = Zaehler
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Gruen = Zaehler2
Next Zaehler
Waitms 1000
'--- Grün ---
For Zaehler = X To Y
If Taster1 = 0 Then Exit Sub
Waitms 10
Rot = Zaehler
Next Zaehler
Waitms 1000
'--- Weiß ---
For Zaehler = Y To X Step -1
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Rot = Zaehler : Blau = Zaehler_blau
Next Zaehler
Waitms 1000
'--- Azur ---
For Zaehler = X To Y
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Rot = Zaehler
Next Zaehler
Waitms 1000
'--- Blau ---
For Zaehler = X To Y
If Taster1 = 0 Then Exit Sub
Waitms 10
Gruen = Zaehler
Next Zaehler
Waitms 1000
'--- Violet ---
For Zaehler = Y To X Step -1
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Rot = Zaehler
Next Zaehler
Waitms 1000
'--- Übergang violet zu Rot ---
For Zaehler = X To Y
Zaehler_blau = Zaehler / 4
If Taster1 = 0 Then Exit Sub
Waitms Schrittpause
Blau = Zaehler_blau
Next Zaehler
Waitms 1000
Gosub Rot_aufgedimmt
Wend
End Sub
Er ist exakt 4,5KB groß, kann also nur noch mit der Vollversion von BASCOM übertragen werden. Dafür ist er bereits für die Hardware-Anwendung, mit den Transistoren BC548 als Lastschalter konfiguriert.
Ob ich es noch ausdünnen werde, weiß ich noch nicht. Es bleibt noch genügend Platz für weitere Farben, welche ich einfach nur zwischenschieben brauche. Alle notwendigen Befehlssätze und Rechnungen sind bereits enthalten.
Ich bin zwar bei Weitem nicht auf dem Level der eingefleischten BASCOM-Nutzer mit jahrzehntelanger Erfahrung, aber trotzdem ein wenig stolz auf das, was ich möglich machen konnte - und bis auf 4 Taster gibt es keinen weiteren Schnickschnack ^^.
Warum ich keine fertige Steuerung für 12€ kaufe? Weil diese keinen Pulsing-Modus für einzelne Farben bietet, dafür eine Menge Blödsinn, den man nie braucht, es sei denn, man will eine Disco betreiben ^^ (Strobe-Modi, Strobe-Modi mit Pause). Zudem kann man den Dauer-Farbwechselmodus bei diesen käuflichen Steuerungen nicht abdimmen, was ich hier möglich machen konnte. Die Fadings sind zwar nur VOR dem Fading dimmbar, aber was gibts schon ohne Handicap ^^
Richtig: Jörg - der doppelte Prescaler hat keine Auswirkungen. Habe ihn noch nicht rausgenommen, schadet aber auch nicht.
Danke euch - und ich schaue mir das Codebeispiel nächste Woche genauer an.
LG - Maik
-
Hallo Freunde.
Das Einsetzen von Gosub-Befehlen statt immer wieder dasselbe zu Schreiben, scheint den Code tatsächlich zu verkleinern. Bei dem Restlichen blick ich ehrlich gesagt noch nicht ganz durch (die Farbendeklaration).
Ob das Programm mit den neuen Ansprungbefehlen für die Schrittpause als auch den Programmabbruch funktioniert, kann ich jedoch erst am Wochenende, frühestens jedoch am Freitag sagen.
Bei dem ganzen Gedusel ist mir doch tatsächlich noch neben der Dimmfunktion eine Funktion zur Beschleunigung oder Verzögerung ALLER Puls-Modi, also auch inklusive dem Color-Fading, eingefallen. Das Ganze wird wieder über einen Select_Case aufgebaut und verlängert die Wartezeit. Im Select_Case für die Dimmfunktion war ja nun bereits die Schrittpause als Waitms-Zeitvariable eingebaut. Diese habe ich nun in eine kleine Rechenaufgabe umgewandelt, damit das Produkt trotzdem auf dasselbe hinaus läuft.
Code:
Select Case Brightness
Case 0 : X = 1023 : X_orange = 341 : X_blau = 255 : Schrittpause = Wartezeit
Case 1 : X = 682 : X_orange = 277 : X_blau = 170 : Schrittpause = Wartezeit * 1.5
Case 2 : X = 455 : X_orange = 152 : X_blau = 113 : Schrittpause = Wartezeit * 2.17
Case 3 : X = 303 : X_orange = 101 : X_blau = 76 : Schrittpause = Wartezeit * 3.33
Case 4 : X = 202 : X_orange = 67 : X_blau = 50 : Schrittpause = Wartezeit * 5
Case 5 : X = 134 : X_orange = 45 : X_blau = 34 : Schrittpause = Wartezeit * 7.5
End Select
Select Case Speed
Case 0 : Wartezeit = 6
Case 1 : Wartezeit = 8
Case 2 : Wartezeit = 10
Case 3 : Wartezeit = 12
Case 4 : Wartezeit = 14
Case 5 : Wartezeit = 16
End Select
Im Programmablauf selbst wird dann später nur noch der Schrittpausen-Wert eingetragen.
LG - Maik
-
Hallo Maik,
guck mal wenn die Schrittpause = Wartezeit ist, warum hast du denn dann einmal die Wartezeit multipliziert und dann nochmal im anderen case umgeändert?
Kann man da nicht gleich den richtigen wert eintragen? Oder nur im zweiten case die Wartezeit anpassen?
Dann kannst du die nämlich eine ganze Variable (Schrittpause oder Wartezeit - jedenfalls wenn man jetzt nur den letzten codeausschnitt nimmt) sparen.
Und auch das hilft den Überblick in einem Programm nicht zu verlieren.
Aber vielleicht hab ich auch was übersehen und es ist so jetzt besser?
Viele Grüße
Jörg
-
Hallo Jörg.
Zugegeben - mein Fehler ^^. Du siehst ja nur einen Teilausschnitt.
Der fixe Grundwert war vorher ja die Schrittpause, jetzt ist es aber die "Wartezeit". Die Wartezeit stellt dabei das Grunddelay für die neue Funktion bereit, nämlich die LED bei gleich bleibender Helligkeit in unterschiedlichen Geschwindigkeiten zu faden. Angenommen, der "CASE 0"-Wert "6" steht für 6 Sekunden, so fadet die LED dann in 6 Sekunden einmal von hell nach dunkel und wieder nach hell. Im "CASE 3" steht der Wert 12 - die LED fadet dann doppelt so langsam, also in 12 Sekunden (fiktive Werte).
Dieser Grundwert stellt nun die Basis für die Dimmfunktion dar. Normal zählt der PWM-Zähler ja von 1023 nach Null und wieder zurück. Beim Dimmen wird der Wert aber vorgeladen, sagen wir auf 898 in "CASE 5". Dadurch würde die Zeit nun aber auch 5 mal schneller faden als sie soll, denn der Zeit-Basiswert bleibt ja im Grunde der gleiche, und genau das wollte ich ja kompensieren.
Darum habe ich die kleine Multiplikation ans Ende gesetzt. Im CASE 0 gibt es noch keine Dimmung, der Zähler zählt von Null angefangen, wodurch der Zeitwert direkt übernommen werden kann.
Die weiteren Ansprungmarken CASE 1-5 werden dann tangential zum Basiswert multipliziert (Quadrate von Faktor 1,5). Dadurch sollte die komplette Fadingzeit selbst beim Dimmen immer gleich der gewählten Geschwindigkeitskonstante sein.
Momentan ist es noch ein Trockenversuch, da ich leider mein Testboard nicht bei habe. Kann ich erst am WE ausprobieren ^^. Sollte dann aber auch die letzte Funktion sein, die ich in das Programm einbaue. Maximal, dass ich noch ein paar Farben hinzufüge, mehr aber auch nicht, sonst ist es zu überladen und hat das Flair käuflicher Disko-LED-Stripe-Steuerungen ;)
LG - Maik
