2 For Next Schleifen in kurzen Abständen laufen lassen?

    This site uses cookies. By continuing to browse this site, you are agreeing to our Cookie Policy.

    • 2 For Next Schleifen in kurzen Abständen laufen lassen?

      Hallo Bascom User. :thumbsup:

      Was für eine möglichkeit hab ich wenn,
      ich zwei "For Next" schleifen in kurzen Abständen laufen lassen will?
      Da ja, Microcontroller nicht 2 Sachen gleichzeit machen können wollte ich das es so kurz ist das es das Auge nicht mitbekommt.

      Was möchte ich tun?

      Ich habe einen LED Stripe und möchte das die erste LED angeht und die Letzte dann die 2te LED und die Vorletzte usw.
      Mir geht es hier um den richtigen denkansatz, vielleicht lieg ich ja auch komplett falsch.

      Was soll es werden?

      Vom Anfang und am Ende der Led sollen z.B. 4 Leds Nacheinander angehen, abwechselnd eine am Anfang eine am Ende des Ledstripes.

      Wie bei meinem Vorherigen Projekt möchte ich jetzt ein KnightRider Licht vom Anfang und eine vom Ende des Ledstripes rein laufen
      lassen so das sie sich in der Mitte treffen und wieder zurück laufen.

      Mir geht es nicht um das Programm, sondern wie ich es mit welchen möglichkeiten umsetzen kann.

      Hier mal mein vorheriges Projekt mit einem KnightRider Licht.

      Da verwende ich ja die For schleife um die ersten Leds mal an zu schalten wie folgt:

      BASCOM Source Code

      1. For Led_zaehler = 0 To Ledzahl - 50 Step 1 '4 LEDs nacheinander An machen
      2. R = 200 : G = 0 : B = 0 'Farbe festlegen
      3. Rb_setcolor Led_zaehler , Color(1) 'Farbe an LED zuweisen
      4. Rb_send 'An LED senden
      5. Waitms 30 'Warte
      6. Next Led_zaehler 'Gehe zur nächsten LED


      Hier beginne ich ja bei der LED 0

      und nun von dem ende des Ledstripes:

      BASCOM Source Code

      1. For Led_zaehler = Ledzahl - 1 To Ledzahl - 6 Step - 1 '4 LEDs nacheinander An machen
      2. R = 200 : G = 0 : B = 0 'Farbe festlegen
      3. Rb_setcolor Led_zaehler , Color(1) 'Farbe an LED zuweisen
      4. Rb_send 'An LED senden
      5. Waitms 30 'Warte
      6. Next Led_zaehler 'Gehe zur nächsten LED
      Wenn ich nun den Code untereinander schreibe werden die ja auch nacheinander abgearbeitet.

      BASCOM Source Code

      1. For Led_zaehler = 0 To Ledzahl - 50 Step 1 '4 LEDs nacheinander An machen
      2. R = 200 : G = 0 : B = 0 'Farbe festlegen
      3. Rb_setcolor Led_zaehler , Color(1) 'Farbe an LED zuweisen
      4. Rb_send 'An LED senden
      5. Waitms 30 'Warte
      6. Next Led_zaehler 'Gehe zur nächsten LED
      7. For Led_zaehler = Ledzahl - 1 To Ledzahl - 6 Step - 1 '4 LEDs nacheinander An machen
      8. R = 200 : G = 0 : B = 0 'Farbe festlegen
      9. Rb_setcolor Led_zaehler , Color(1) 'Farbe an LED zuweisen
      10. Rb_send 'An LED senden
      11. Waitms 30 'Warte
      12. Next Led_zaehler 'Gehe zur nächsten LED
      Display All
      Da ja in jeder Schleife ein Waitms ist werden zuerst die LED1 bis LED4 angeschaltet und dann erst am ende.

      Nun sollte das aber vom Anfang und vom Ende gleichzeit bzw. für das Auge nicht sichtbar angehen.

      Was für möglichkeiten habe ich da?

      Muß ich das ganze umschreiben oder gibt es da andere möglichkeiten?

      Ich hoff ich hab das gut und nachvollziehbar erklärt.

      Danke schon mal für eure Unterstützung a_58_b54cfdb4
    • Das ist wahrscheinlich der richtige Zeitpunkt, Wait zu verlassen und die Steuerung über einen Timer und dessen Interrupt zu machen. Hier gibt es bestimmt auch schon einige Beispiele, wie man das machen kann. Du könntest z.B. mal nach SoftPWM suchen, das ist ja ähnlich.

      Wobei du in diesem Fall das ja auch noch mit Wait machen kannst.
      Du setzt doch bei den Rainbow Befehlen nur eine Farbe einer bestimmten LED. Da wartest du etwas und setzt die nächste. Zwischen dem Warten könntest du doch eine LED links uns eine rechts setzen.
      Ich würde dazu keine For-Schleife verwenden sondern eher eine Do Loop Until
      Dort hast du dann zwei Zähler, einen für links einen für rechts. Die änderst du dann entsprechend und setzt die Farbe der LED. Dann warten und wenn du noch nicht fertig bist geht es wieder von vorne los.

      The post was edited 2 times, last by Franz ().

    • Franz wrote:

      Das ist wahrscheinlich der richtige Zeitpunkt, Wait zu verlassen und die Steuerung über einen Timer und dessen Interrupt zu machen. Hier gibt es bestimmt auch schon einige Beispiele, wie man das machen kann. Du könntest z.B. mal nach SoftPWM suchen, das ist ja ähnlich.

      Wobei du in diesem Fall das ja auch noch mit Wait machen kannst.
      Du setzt doch bei den Rainbow Befehlen nur eine Farbe einer bestimmten LED. Da wartest du etwas und setzt die nächste. Zwischen dem Warten könntest du doch eine LED links uns eine rechts setzen.
      Ich würde dazu keine For-Schleife verwenden sondern eher eine Do Loop Until
      Dort hast du dann zwei Zähler, einen für links einen für rechts. Die änderst du dann entsprechend und setzt die Farbe der LED. Dann warten und wenn du noch nicht fertig bist geht es wieder von vorne los.
      Hallo Franz. a_58_b54cfdb4

      Richtig, es wird wärend dem Ablauf nur eine farbe verwendet.

      Die Timer, SoftPWM und die Do Loop Until werde ich mir mal anschauen, danke.
    • Wasi wrote:

      möchte ich jetzt ein KnightRider Licht vom Anfang und eine vom Ende des Ledstripes rein laufen
      lassen so das sie sich in der Mitte treffen und wieder zurück laufen.
      Also ein Lauflicht, das nur zur Hälfte des Stripes läuft und dann wieder zurück und für die andere Hälfte des Stripes gespiegelt.
      Das ließe sich mit deiner For-Schleife noch erledigen.

      So ein Knight Rider lauflicht dimmt aber auch.
      Also musst du eine Variable für jede LED mitnehmen, die die Helligkeit enthält.
      Ein Bytearray.

      In deiner Do-Loop Schleife schaust du, welche LED gerade leuchten soll oder dunkel sein soll.
      Soll die LED hell sein, dann erhöhst du den Helligkeitswert dieser LED, wenn nicht, dann verringerst du ihn.
      nach spätestens 255 Durchläufen ist die LED dann komplett umgeschaltet..

      Ein Zähler zählt die Do-Loop-Durchläufe mit und bei, sagen wir, 160, schaltet die LED-Kette das Muster weiter.
      Ganz am Ende kommt ein einziges Waitms 5 hin, damit die LED in etwa 1,3 Sekunden durchdimmt.

      Statt des Waitms 5 kannst du auch einen Timer nehmen, aber ich würde mir das für ein anderes Projekt aufheben.
    • businski wrote:

      Franz wrote:

      Das ist wahrscheinlich der richtige Zeitpunkt, Wait zu verlassen und die Steuerung über einen Timer
      Hallo wasi
      Solltest du das mit Timer machen schau dir bitte diesen Beitrag an.
      bascomforum.de/index.php?threa…t=Ws2812%2Berror#post2860
      Leider funktioniert das bei mir ohne Disable Interrupts mit der neuen Version immer noch nicht. :(
      Gruß
      businski
      Danke für die Info.


      Pluto25 wrote:

      Warum nicht einfach in einer Schleife? Beide Leds setzen und dann das wait und weiter. Für die zweite einen errechneten Zähler . z.B Ledzaehler2=ledzahl-1-ledzaehler.
      Welchen Vorteil hätten Timer dabei?
      Das wäre natürlich super, für einen Anfänger wie mich hab ich mir das mit dem Timer mal angeschaut, aber da brauche ich wohl
      viel Zeit und verständniss um das alles zu begreifen. :/

      Michael wrote:

      Also ein Lauflicht, das nur zur Hälfte des Stripes läuft und dann wieder zurück und für die andere Hälfte des Stripes gespiegelt.Das ließe sich mit deiner For-Schleife noch erledigen.
      Au ja, das wäre a_42_02cc30b2


      Michael wrote:

      So ein Knight Rider lauflicht dimmt aber auch.
      Also musst du eine Variable für jede LED mitnehmen, die die Helligkeit enthält.
      Ein Bytearray.
      Ein Beispiell hatte ich heute im Netzt gefunden, von dir auch das vom Stk500.
      Aber Dimmen muß es nicht unbedingt, kann man ja dann eventuell später mit einbringen.

      Geht mir erstmal darum wie ich das dann in der For Schleife mit reinbekomme.

      In dem Code werden ja in der ersten For Schleife erstmal 5 LEDs nacheinander angeschaltet immer nach 60ms.
      In der 2ten For Schleife werde die 5 LEDs dann nach rechts bis zum ende des LEDs stripe durchgeschoben, da wäre ich dann aber schon zu weit.

      Ich muß also in der ersten For Schleife das mit einbringen.

      BASCOM Source Code

      1. For Led_zaehler = 0 To Ledzahl - 52 Step 1 '4 LEDs nacheinander An machen
      2. R = 200 : G = 0 : B = 0 'Farbe festlegen
      3. Rb_setcolor Led_zaehler , Color(1) 'Farbe an LED zuweisen
      4. Rb_send 'An LED senden
      5. Waitms 60 'Warte
      6. Next Led_zaehler 'Gehe zur nächsten LED
      7. Waitms 500
      8. For Led_zaehler = 0 To Ledzahl - 6 Step 1 '4 LEDs werden nach Rechts verschoben
      9. Rb_Shiftright Led_zaehler, 6 'Bewege nach rechts Start , 4LEDs +1 angeben
      10. Rb_send 'An LED senden
      11. Waitms 20 'Warte
      12. Next Led_zaehler
      Display All
      Ich weiß aber nicht wie ich das machen soll.
      Den mit Led_zaehler geb ich ja schon die LEDs vor.

      Wie muß ich den das machen?
    • Wasi wrote:

      Geht mir erstmal darum wie ich das dann in der For Schleife mit reinbekomme.
      gar nicht, falscher Ansatz.
      Mit der For-Schleife kanst du nur ein blinkendes Lauflicht machen und dein Programm ist währenddessen blockiert.


      Wasi wrote:

      Wie muß ich den das machen?
      Dein Lauflichtansatz ist schon verkehrt.

      Bei 10 LEDs:

      R = 200 : G = 0 : B = 0

      For Z = 0 to 9
      Rb_clearcolors 'erst löschen
      Rb_setcolor Z , Color(1)
      Temp = 9 - Z
      Rb_setcolor Temp , Color(1)
      Rb_send
      Waitms 150
      Next
    • Hi,

      wenn ich die Aufgabe richtig verstehe, dann möchtest du von je der Enden deines Streifens her, zum Zentrum hin die Led zuschalten.!?? Vorerst. Und dann soll's wie bei Hasselhoff wieder zurückschwingen... Also quasi Baywatch und KightRider in Einem. 8o

      Wie ich das sehe, ist der eignentliche Knobelpunkt die Ermittlung des zweiten Index auf Basis des ersten, durch die For-Schleife gebildeten Index.

      ...etwa so...

      i = LedAnzahl - led_zaehler
      i = i - 1

      Die halbe Miete sieht vom Prinzip dann vielleicht so aus:

      Source Code

      1. R = 200 : G = 0 : B = 0
      2. dim i as byte
      3. for Led_zaehler = 0 To 3
      4. Rb_setcolor Led_zaehler , Color(1) 'Farbe an LED zuweisen
      5. i = LedAnzahl - led_zaehler
      6. i = i - 1
      7. Rb_setcolor i , Color(1) 'Farbe an LED zuweisen
      8. Rb_Send
      9. next
      Display All
      In Zeile 6 und 9 bearbeitest du die Farbspeicher und in 10 schickst du es fort. Was noch fehlt ist die Löscherei der vorherig gesetzten LED.

      Viel Erfolg!

      Ich würde allerdings für diesen Fall auch mal mit RB_Color experimentieren. Dazu generierst du einfach ein Bitmuster und gibt das mit RB_Color an die entsprechenden Stellen.
    • Hallo @Wasi

      Nachdem ich deinen Post #1 gelesen habe, habe ich mich gefragt, ob es jetzt auch grundsätzlich darum geht, wie man mehrere Dinge gleichzeitig laufen lassen kann oder ob das jetzt nur auf den
      Knight-Rider-Effekt zu beziehen ist.
      Alle Vorredner haben schon Ansätze aufgezeigt, die sich alle sehr stark auf den Effekt beziehen.

      Ich möchte hier aber noch einen anderen Ansatz aufzeigen. Hierbei kann man das Prinzip auch auf andere Anwendungen übertragen, bei dem mehrere Prozesse gleichzeitig laufen sollen.

      Zu meinem Ansatz:

      Ich verwende einen Timer, der im 1ms Rythmus eine ISR aufruft. Dort teile ich mit 2 Variablen die Frequenz so, das für die Anwendung geeignete Intervalle herauskommen.
      Dafür habe ich die Variablen Count_Effekt und Count_Dimmen verwendet. Diese Variablen werden heruntergezählt.
      Bei 0 werden Flags gesetzt (Flag_Effekt und Flag_Dimmen), die dem Hauptprogramm signalisieren, welche Aufgabe ansteht. Dann werden die Werte für den nächsten Intervall gesetzt.

      Das Flag_Effekt sagt, dass das Lauflicht bewegt werden soll. In deinem Fall bedeutet das lediglich, dass du an dem Strip die entsprechenden 2 LED's aussteuern musst.
      Dabei wird unterschieden, welche LED's anzusteuern sind (Select Case Abfrage).

      Das Flag_Dimmen sagt, dass alle LED's abgedimmt werden sollen. Dazu musst du durch die Daten der Strips interieren und die Were (RGB) verringern.

      Im Code ist das schon angedeutet, wo was passieren soll.

      Einfluss auf die Geschwindigkeit des Lauflicht-Effekts und die Abdimm-Geschwindigkeit kannst du mit den Konstanten INTERVAL_EFFEKT und INTERVAL_DIMMEN nehmen.

      Im Code musst du noch die Ansteuerung der Strips ergänzen, Variablen dafür anlegen und natürlich die Lib einbinden.

      Viel Spaß beim Ausprobieren!

      BASCOM Source Code: Knight-Rider Effekt (Vorlage)

      1. ' Knight-Rider Effekt
      2. ' Prinzip-Ansatz mit LED'Strips
      3. ' Modul: KnightRider.bas
      4. ' Autor: Mitch64
      5. ' Erstellt: 09.10.2021
      6. $Regfile = "m8def.dat"
      7. $HWStack = 30
      8. $SWStack = 40
      9. $FrameSize = 40
      10. $Crystal = 8000000
      11. ' ----------------------------------------------
      12. ' Konfiguration des Effekts
      13. ' Hier kann eingestellt werden, wie schnell der
      14. ' Lauflicht-Effekt ablaufen soll, und wie
      15. ' schnell abgedimmt werden soll.
      16. ' Da der Timer2 mit 1kHz läuft und die
      17. ' Counter-Werte runter-gezählt werden,
      18. ' entsprechen die Werte ms.
      19. ' ----------------------------------------------
      20. Const INTERVAL_EFFEKT = 500 ' Geschwindigkeit des Lauf-Effekts
      21. Const INTERVAL_DIMMEN = 20 ' Geschwindigkeit des Abdimmens
      22. ' ----------------------------------------------
      23. ' interne Variablen, werden von
      24. ' ISR_Timer2 verwendet
      25. ' ----------------------------------------------
      26. Dim Count_Effekt as Word
      27. Dim Count_Dimmen as Word
      28. ' ----------------------------------------------
      29. ' Variable
      30. ' ----------------------------------------------
      31. Dim Effekt_Step as Byte ' Variable beinhalten den Schritt des Effekts
      32. ' ----------------------------------------------
      33. ' Flags, die anzeigen, ob das Lauflicht bewegt
      34. ' oder gedimmt werden soll.
      35. ' ----------------------------------------------
      36. Dim Flag_Effekt as Bit ' Lauf-Effekt
      37. Dim Flag_Dimmen as Bit ' Dimmen
      38. ' ----------------------------------------------
      39. ' Timer2 wird als Zeitbasis verwendet und
      40. ' generiert einen Interrupt alle 1ms (1kHz)
      41. ' und ruft damit die Routine ISR_Timer2 auf.
      42. ' ----------------------------------------------
      43. Config Timer2 = Timer , Prescale = 32 , CLEAR_TIMER = 1
      44. Compare2 = 250 - 1
      45. On OC2 ISR_Timer2
      46. Enable OC2
      47. Enable Interrupts
      48. ' ----------------------------------------------------------------------------
      49. ' Hauptschleife
      50. ' ----------------------------------------------------------------------------
      51. Do
      52. ' ----------------------------------------
      53. ' Hier wird der Lauflicht-Effekt gesteuert
      54. ' (Prozess 1)
      55. ' ----------------------------------------
      56. If Flag_Effekt = 1 then ' Lauflicht nächste LED anschalten
      57. Reset Flag_Effekt ' Flag löschen nicht vergessen!
      58. ' Hier muss noch unterschieden werden,
      59. ' welche LED nun anzusteuern ist. Diese
      60. ' wird dann voll ausgesteuert (max. Helligkeit)
      61. ' Das Abdimmen wird von der nachfolgenden
      62. ' Dimm-Routine (If Flag_Dimmen...) erledigt.
      63. ' Beispiel mit 7 LED's (LED1 ganz links, LED 7 ganz rechts)
      64. Select Case Effekt_Step
      65. Case 0 ' Effekt-Schritt 0
      66. ' LED1 und 7 aussteuern
      67. Incr Effekt_Step ' nächster Step
      68. Case 1 ' Effekt-Schritt 1
      69. ' LED2 und 6 aussteuern
      70. Incr Effekt_Step ' nächster Step
      71. Case 2 ' Effektschritt 2
      72. ' LED3 und 5 aussteuern
      73. Incr Effekt_Step ' nächster Step
      74. Case 3 ' Effekt-Schritt 3
      75. ' LED4 (mittige LED) aussteuern
      76. Incr Effekt_Step ' nächster Step
      77. Case 4 ' Effekt-Schritt 4
      78. ' LED3 und 5 aussteuern
      79. Incr Effekt_Step ' nächster Step
      80. Case 5 ' Effekt-Schritt 5
      81. ' LED2 und 6 aussteuern
      82. Incr Effekt_Step ' nächster Step
      83. Effekt_Step = 0 ' dann wieder von vorne
      84. End Select
      85. End If
      86. ' --------------------------------
      87. ' Hier wird das Abdimmen gesteuert
      88. ' (Prozess 2)
      89. ' --------------------------------
      90. If Flag_Dimmen = 1 then
      91. Reset Flag_Dimmen ' Flag löschen nicht vergessen
      92. ' Hier werden alle LED's in der Helligkeit reduziert.
      93. ' Werte die bereits auf 0 sind bleiben unberührt.
      94. ' Dadurch entsteht der Nachleucht-Effekt
      95. End If
      96. Loop
      97. ' ----------------------------------------------
      98. ' Die ISR_Timer2 wird regelmäßig (alle 1ms)
      99. ' aufgerufen. Sie bestimmt die Zeitpunkte, wann
      100. ' das Lauflich bewegt oder gedimmt werden soll.
      101. ' Dafür werden die Flags
      102. ' Flags_Effect und Flag_Dimm gesetzt.
      103. ' ----------------------------------------------
      104. ISR_Timer2:
      105. ' Intervall für Laufeffekt erzeugen
      106. If Count_Effekt = 0 then
      107. Set Flag_Effekt ' Flag setzen, Lauflicht soll bewegt werden
      108. Count_Effekt = INTERVAL_EFFEKT ' Effekt-Zähler rücksetzen
      109. Else
      110. Decr Count_Effekt
      111. End If
      112. ' Intervall für Abdimmen erzeugen
      113. If Count_Dimmen = 0 then
      114. Set Flag_Dimmen ' Flag setzen, es soll gedimmt werden
      115. Count_Dimmen = INTERVAL_DIMMEN ' Dimm-Zähler rücksetzen
      116. Else
      117. Decr Count_Dimmen
      118. End If
      119. Return
      Display All

      The post was edited 3 times, last by Mitch64: Fehler korrigiert ().

    • Mitch64 wrote:

      If Count_Effekt = 0 then
      Set Flag_Effekt ' Flag setzen, Lauflicht soll bewegt werden
      Count_Effekt = INTERVAL_EFFEKT ' Effekt-Zähler rücksetzen
      Else
      Decr Count_Effekt
      End If
      Nur zum Verständnis, wäre es nicht besser "Count_Effekt = INTERVAL_EFFEKT" in die Do Loop zu packen? Ich könnte mir vorstellen dass sonst Schritte übersprungen werden.

      Gruß, Martin
    • businski wrote:

      Wasi hattest du dir das Testprogramm von mir auf der Seite
      bascomforum.de/index.php?threa…t=Ws2812%2Berror#post2860 angeschaut?
      Unter Modus 5 sollte das stehen was du suchst.
      Hallo businski, ja, danke hab ich mir angeschaut, jedoch gerade keine Zeit mich da voll rein zu denken.
      Sieht aber mal gut aus.
      Bin momentan kurz angebunden. :|


      Michael wrote:

      Wasi wrote:

      Geht mir erstmal darum wie ich das dann in der For Schleife mit reinbekomme.
      gar nicht, falscher Ansatz.Mit der For-Schleife kanst du nur ein blinkendes Lauflicht machen und dein Programm ist währenddessen blockiert.


      Wasi wrote:

      Wie muß ich den das machen?
      Dein Lauflichtansatz ist schon verkehrt.
      Bei 10 LEDs:

      R = 200 : G = 0 : B = 0

      For Z = 0 to 9
      Rb_clearcolors 'erst löschen
      Rb_setcolor Z , Color(1)
      Temp = 9 - Z
      Rb_setcolor Temp , Color(1)
      Rb_send
      Waitms 150
      Next
      Hallo Michael, werde mir das mal wenn möglich am Montag anschauen, danke. :D


      walter99 wrote:

      zb
      y=numled -1
      for x=0 to numled/2-1
      rb_setcolor x....
      rb_setcolor y....
      rb_send
      y =y-1
      next x
      mfg
      Hallo walter99, so viele gute Ansätze.
      Das kann ja nur was werden.
    • Galahat wrote:

      Hi,

      wenn ich die Aufgabe richtig verstehe, dann möchtest du von je der Enden deines Streifens her, zum Zentrum hin die Led zuschalten.!?? Vorerst. Und dann soll's wie bei Hasselhoff wieder zurückschwingen... Also quasi Baywatch und KightRider in Einem.

      Wie ich das sehe, ist der eignentliche Knobelpunkt die Ermittlung des zweiten Index auf Basis des ersten, durch die For-Schleife gebildeten Index.

      ...etwa so...

      i = LedAnzahl - led_zaehler
      i = i - 1
      Hallo Galahat, ja das ist richtig, 2 KnightRider eine von links eine von rechts die treffen sich in der mitte und laufen dann wieder auf Augangs position zurück.
      Werde mich die nächsten Tage mal hinsetzen wenn Zeit ist, sind ja viele Infos eingetroffen.

      Mitch64 wrote:

      Hallo @Wasi

      Nachdem ich deinen Post #1 gelesen habe, habe ich mich gefragt, ob es jetzt auch grundsätzlich darum geht, wie man mehrere Dinge gleichzeitig laufen lassen kann oder ob das jetzt nur auf den
      Knight-Rider-Effekt zu beziehen ist.
      Alle Vorredner haben schon Ansätze aufgezeigt, die sich alle sehr stark auf den Effekt beziehen.

      Ich möchte hier aber noch einen anderen Ansatz aufzeigen. Hierbei kann man das Prinzip auch auf andere Anwendungen übertragen, bei dem mehrere Prozesse gleichzeitig laufen sollen.

      Zu meinem Ansatz:

      Ich verwende einen Timer, der im 1ms Rythmus eine ISR aufruft. Dort teile ich mit 2 Variablen die Frequenz so, das für die Anwendung geeignete Intervalle herauskommen.
      Dafür habe ich die Variablen Count_Effekt und Count_Dimmen verwendet. Diese Variablen werden heruntergezählt.
      Bei 0 werden Flags gesetzt (Flag_Effekt und Flag_Dimmen), die dem Hauptprogramm signalisieren, welche Aufgabe ansteht. Dann werden die Werte für den nächsten Intervall gesetzt.

      Das Flag_Effekt sagt, dass das Lauflicht bewegt werden soll. In deinem Fall bedeutet das lediglich, dass du an dem Strip die entsprechenden 2 LED's aussteuern musst.
      Dabei wird unterschieden, welche LED's anzusteuern sind (Select Case Abfrage).

      Das Flag_Dimmen sagt, dass alle LED's abgedimmt werden sollen. Dazu musst du durch die Daten der Strips interieren und die Were (RGB) verringern.

      Im Code ist das schon angedeutet, wo was passieren soll.

      Einfluss auf die Geschwindigkeit des Lauflicht-Effekts und die Abdimm-Geschwindigkeit kannst du mit den Konstanten INTERVAL_EFFEKT und INTERVAL_DIMMEN nehmen.

      Im Code musst du noch die Ansteuerung der Strips ergänzen, Variablen dafür anlegen und natürlich die Lib einbinden.

      Viel Spaß beim Ausprobieren!

      Hallo Mitch64, ich kann mich ja kaum noch Retten vor lauter guten Infos.
      Das schau ich mir aber auch noch an.
    • Vieleicht kannst damit was anfangen

      BASCOM Source Code

      1. $regfile = "m8adef.dat"
      2. $crystal = 8000000
      3. $hwstack = 64
      4. $swstack = 32
      5. $framesize = 32
      6. Config Rainbow = 1 , Rb0_len = 52 , Rb0_port = Portb , Rb0_pin = 0
      7. Dim Color(3) As Byte
      8. R Alias Color(_base) : G Alias Color(_base + 1) : B Alias Color(_base + 2)
      9. Const Numleds = 52
      10. Const Lum = 25 'helligkeit
      11. Dim N As Byte
      12. Dim Loop_counter As Byte 'farbe / led
      13. Dim Rnd_value As Byte 'zufallszahl
      14. Dim A As Byte 'stellenzäler
      15. Dim A1 As Byte 'stellenzäler
      16. Dim X As Byte
      17. Dim X2 As Byte
      18. '----[MAIN]--------------------------------------------------------------
      19. Rb_selectchannel 0 ' select first channel
      20. R = 20 : G = 15 : B = 0 ' define a color
      21. Rb_fillstripe Color(1) ' farbe für alles
      22. Wait 1
      23. Rb_clearcolors
      24. Rb_send
      25. Wait 1
      26. Do
      27. X = 1
      28. For X = 1 To 5
      29. R = Rnd(lum)
      30. R = R * 10
      31. G = Rnd(lum)
      32. G = G * 10
      33. B = Rnd(lum)
      34. B = B * 10
      35. A = 0
      36. A1 = 51
      37. For N = 1 To 26
      38. Rb_setcolor A , Color(1)
      39. Rb_setcolor A1 , Color(1)
      40. Rb_send
      41. Incr A
      42. Decr A1
      43. Waitms 50
      44. Next N
      45. Waitms 100
      46. R = Rnd(lum)
      47. R = R * 10
      48. G = Rnd(lum)
      49. G = G * 10
      50. B = Rnd(lum)
      51. B = B * 10
      52. For N = 1 To 26
      53. Rb_setcolor A , Color(1)
      54. Rb_setcolor A1 , Color(1)
      55. Rb_send
      56. Incr A1
      57. Decr A
      58. Waitms 50
      59. Next N
      60. Next X
      61. Waitms 100
      62. Loop
      Display All