3 Kanal PWM Lauflicht

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

    • 3 Kanal PWM Lauflicht

      Hallo zusammen,

      ich versuche gerade, ein 3 Kanal PWM Lauflicht auf Basis des Knight Rider Programms von Michael zu programmieren. Leider habe ich noch das Problem, dass die LED´s direkt hell einschalten. Es sollte eigentlich so sein, dass die 1. LED langsam aufleuchtet. Wenn diese 100 % hat, beginnt die 2. aufzuleuchten und die 1. LED wird dunkler. Wenn die 2. LED 100% hat, sollte die 3. LED langsam anfangen zu leuchten und dann wieder von vorne. Die LED´s werden im Kreis angeordnet. Dadurch entsteht dann der Effekt einer "drehenden" Leuchte.

      Bin für jede Hilfe dankbar ! :)

      BASCOM Source Code

      1. $regfile = "attiny25.dat"
      2. $crystal = 8000000
      3. $hwstack = 32
      4. $swstack = 24
      5. $framesize = 16
      6. Dim A As Byte
      7. Dim B As Byte
      8. Dim Z As Byte
      9. Dim X As Byte
      10. Dim Zeit As Word
      11. Dim Richtung As Bit
      12. Dim Led(3) As Byte
      13. Config Portb = Output
      14. Config Timer0 = Timer , Prescale = 1024
      15. Enable Timer0
      16. Enable Interrupts
      17. On Timer0 Timer0_interrupt
      18. A = 1
      19. Portb = 0
      20. Waitms 200
      21. Do
      22. 'nächste LED alle 0,1 sec
      23. If Zeit > 170 Then
      24. Led(a) = 255 'LED "aufladen"
      25. A = A + 1
      26. If A = 4 Then
      27. A = 1
      28. End If
      29. Zeit = 1
      30. End If
      31. Z = Z + 1
      32. 'Soft PWM
      33. 'Vergleich zwischen frei laufendem Zähler Z und LED()-Wert
      34. For B = 1 To 3
      35. If Led(b) > Z Then
      36. B = B - 1
      37. Portb.b = 0
      38. Else
      39. B = B - 1
      40. Portb.b = 1
      41. End If
      42. B = B + 1
      43. Next
      44. Loop
      45. '----------------
      46. Timer0_interrupt:
      47. Timer0 = 200
      48. ' Prescale = 64 + Timer0 = 6 = 500Hz
      49. ' Bei LED-Startwert von 255 ist nach 0,51 Sekunden ausgedimmt
      50. Zeit = Zeit + 1
      51. For X = 1 To 3
      52. If Led(x) > 0 Then
      53. Led(x) = Led(x) - 1 'LEDs "entladen"
      54. End If
      55. Next
      56. Return
      Display All

      The post was edited 1 time, last by Sven Loeffler ().

    • Das aktuelle Programm schaltet die aktuelle LED ein, indem sie sie auf einen PWM Wert von 255 setzt.
      Der Timer reduziert den Wert wieder, die LED dimmt aus.

      Man müsste also den PWM-Wert jeder LED erst auffüllen bis 255 und dann wieder leeren.
      Wenn so ein Rundumlicht etwa eine Sekunde pro Umdrehung braucht, müsste das Auf- und Abdimmen also nicht länger als diese Zeit brauchen dürfen.

      In der Hauptschleife könnte ein Zähler laufen, der immer von 1 bis 3 zählt, so wie jetzt auch.
      mit einem Waitms, welches den Durchlauf in etwa dieser Zeit schafft.

      Im Timer wird die PWM gemacht.
      Ist der Zähler auf 1, wird die erste LED hoch gedimmt und die dritte herunter.
      Ist der Zähler auf 2, wird die zweite LED hoch gedimmt und die erste herunter usw.
      Das kann man noch zusammenfassen und natürlich dürfen die Variablenbereiche nicht verlassen werden.

      Es gibt auch noch andere Ansätze, vielleicht kommen noch Ideen hier im Forum.
    • Hi, habe für Jemanden ein Lauflicht für eine Rundumleuchte an einem RC-Trecker gebastelt, da es auf einem Picaxe laufen sollte wurde es ohne pwm gemacht, so ein PICAXE ist nicht der schnellste ;-). Und weil es so schön war wurde es auf einen AVR umgesetzt, es sieht recht gut aus und der Trecker-Besitzer ist zu Frieden.

      Mit den Variablen:
      * Z_ab
      * Z_LED
      * Z_Spanne
      * G_Spanne
      und dem Poti kann man das Verhalten beeinflussen.

      Das Programm:

      BASCOM Source Code

      1. ' Compiler: Bascom-Demo 2.0.7.5
      2. ' Dateiname: Rundumlicht A8 mit Poti.avr
      3. ' Funktion: ein Rundumlicht mit 4 LEDs, mit ausglimmender LED
      4. ' Datum: Start 10.02.2020 Stand 04.03.2020
      5. ' Von: Naubaddi foto-schubser@arcor.de
      6. '
      7. ' Atmega8 (C.6 RESET)
      8. '
      9. ' +----v----+
      10. ' RESET C.6 | 1 28| C.5 ADC5/SCL
      11. ' RXD D.0 | 2 27| C.4 ADC4/SDA
      12. ' TXD D.1 | 3 26| C.3 ADC3
      13. ' INT0 D.2 | 4 25| C.2 ADC2
      14. ' INT1 D.3 | 5 24| C.1 ADC1
      15. ' XCK/T0 D.4 | 6 23| C.0 ADC0
      16. ' VCC | 7 22| GND
      17. ' GND | 8 21| AREF
      18. ' XTAL1/TOSC1 B.6 | 9 20| AVCC
      19. ' XTAL2/TOSC2 B.7 |10 19| B.5 SCK
      20. ' T1 D.5 |11 18| B.4 MISO
      21. ' AIN0 D.6 |12 17| B.3 MOSI/OC2
      22. ' AIN1 D.7 |13 16| B.2 SS/OC1B
      23. ' ICP1 B.0 |14 15| B.1 OC1A
      24. ' +---------+
      25. '
      26. ' --- Mikrocontroler Daten -------------------------------------------------------------------------------------
      27. $regfile = "m8def.dat"
      28. $crystal = 8000000
      29. $hwstack = 30
      30. $swstack = 30
      31. $framesize = 30
      32. ' &HFF, &HE1, &HD9, &HFF ' 1MHz
      33. $PROG &HFF, &HE4, &HD9, &HFF ' 8MHz
      34. ' --- Deklaration ----------------------------------------------------------------------------------------------
      35. config portb = output
      36. config portc = output
      37. config portd = output
      38. config adc = single , prescaler = auto , reference = avcc
      39. config portc.0 = input
      40. ' --- Variablen, Alias -----------------------------------------------------------------------------------------
      41. LED_1 alias portb.0
      42. LED_2 alias portd.0
      43. LED_3 alias portc.5
      44. LED_4 alias portb.1
      45. dim an as word ' an-Zeit der LED im Zyklus
      46. dim aus as word ' aus-Zeit der LED im Zyklus
      47. dim Z_Spanne as word ' Zeitspanne für das Absenken der Helligkeit
      48. dim Z_ab as word ' Zeit bis zum nächsten Absenken der Helligkeit
      49. dim Z_LED as word ' Zeit bis die nächste LED an der Reihe ist
      50. const Faktor = 2 ' mit dem Faktor 2 die 0 - 1024 umwandeln in 0 - 512
      51. dim Potiwert as word ' der Wert des Potis
      52. dim G_Spanne as word ' die Grundspanne für das absenken der Helligkeit
      53. ' --- Vorbelegung der Variablen und Alias ----------------------------------------------------------------------
      54. Z_ab = 1
      55. Z_LED = 11
      56. Z_Spanne = 999
      57. G_Spanne = 487
      58. ' --- Programm Anfang ------------------------------------------------------------------------------------------
      59. do
      60. Potiwert = getadc(0)
      61. Z_Spanne = Potiwert / Faktor
      62. Z_Spanne = Z_Spanne + G_Spanne
      63. LED_2 = 1 : waitms Z_LED
      64. for an = Z_Spanne to 0 step -10
      65. aus = Z_Spanne - an
      66. LED_1 = 1 : waitus an : LED_1 = 0 : waitus aus : waitms Z_ab
      67. next an
      68. LED_3 = 1 : waitms Z_LED
      69. for an = Z_Spanne to 0 step -10
      70. aus = Z_Spanne - an
      71. LED_2 = 1 : waitus an : LED_2 = 0 : waitus aus : waitms Z_ab
      72. next an
      73. LED_4 = 1 : waitms Z_LED
      74. for an = Z_Spanne to 0 step -10
      75. aus = Z_Spanne - an
      76. LED_3 = 1 : waitus an : LED_3 = 0 : waitus aus : waitms Z_ab
      77. next an
      78. LED_1 = 1 : waitms Z_LED
      79. for an = Z_Spanne to 0 step -10
      80. aus = Z_Spanne - an
      81. LED_4 = 1 : waitus an : LED_4 = 0 : waitus aus : waitms Z_ab
      82. next an
      83. loop
      84. ' --- Programm Ende --------------------------------------------------------------------------------------------
      85. end
      86. ' --------------------------------------------------------------------------------------------------------------
      Display All
      Das Video:
      Trecker mit Rundumlicht

      Grüßle, Naubaddi
    • Vielen Dank für eure Tipps.

      Nabaddi, das schaut auch interessant aus. :) Tolle Arbeit. Bei nur 3 LED´s ist das PWM aber ganz wichtig.

      Michael, könntest du mir vielleicht ein kleines Demoprogramm mit nur einer LED welche auf und abgedimmt wird schreiben ? Ich verstehe noch nicht ganz genau, wie die LED auf - und abgedimmt wird. Dann würde ich versuchen, aus diesem Programm, eines für 3 LED´s zu schreiben.
    • Morjen, warum ist bei 3 LEDs pwm so wichtig? Wer oder was die LED dimmt ist doch egal.

      Für eine LED ohne pwm:

      Source Code

      1. $regfile = "m8def.dat"
      2. $crystal = 8000000
      3. $hwstack = 30
      4. $swstack = 30
      5. $framesize = 30
      6. config portb.0 = output
      7. LED alias portb.0 ' Ausgang für die LED
      8. dim an as word ' die an-Zeit für die LED
      9. dim aus as word ' die aus-Zeit für die LED
      10. dim Schritt as word ' die Schritte beim Dimmen
      11. dim dimmen as word ' für die for-Schleife
      12. Schritt = 3
      13. do
      14. waitms 333
      15. for dimmen = 0 to 1023 step Schritt
      16. an = dimmen : aus = 1023 - dimmen
      17. LED = 1 : waitus an : LED = 0 : waitus aus
      18. next dimmen
      19. for dimmen = 0 to 1023 step Schritt
      20. an = dimmen : aus = 1023 - dimmen
      21. LED = 1 : waitus aus : LED = 0 : waitus an
      22. next dimmen
      23. loop
      24. end
      Display All
      Grüßle, Naubaddi
    • Irgendwann in Jahr 2009 hatte ich mal den KIT-Effekt mit dem Abdimmen der LED's in Bascom programmiert.
      Mit 2 Potis kann man die Lauf-Geschwindigkeit und die Abdimm-Geschwindigkeit unabhängig voneinander einstellen.

      Dafür habe ich eine Software-PWM mit einem Timer erstellt.
      Ein 2. Timer setzt ein Flag, wann Zeit ist abzudimmen.
      Dieses Flag wird in der Hauptschleife abgefragt und der PWM-Wert entsprechend reduziert.

      Bitte entschuldigt, wenn der Code etwas schlecht kommentiert ist. Aber das war aus meinen Bascom-Anfängen, und da hatte ich noch nicht das Programmier-Niveau wie heute.

      Davon gibt's auch ein Video, ist aber zu groß für den Upload. Fotos hatte ich damals keine gemacht. War auch alles nur auf dem Steckbrett aufgebaut.
      Dafür gibts aber ein Schaltbild.

      BASCOM Source Code: KITT-Effekt

      1. $regfile = "m8def.dat"
      2. $crystal = 8000000
      3. $hwstack = 32
      4. $swstack = 8
      5. $framesize = 24
      6. ' Pins konfigurieren
      7. LED_01 Alias Portd.0 ' PWM-Ausgänge für LED (oder Treiber)
      8. LED_02 Alias Portd.1
      9. LED_03 Alias Portd.2
      10. LED_04 Alias Portd.3
      11. LED_05 Alias Portd.4
      12. LED_06 Alias Portb.6
      13. LED_07 Alias Portb.7
      14. LED_08 Alias Portd.5
      15. LED_09 Alias Portd.6
      16. Config LED_01 = Output ' PWM-Ausgänge als Ausgang konfigurieren
      17. Config LED_02 = Output
      18. Config LED_03 = Output
      19. Config LED_04 = Output
      20. Config LED_05 = Output
      21. Config LED_06 = Output
      22. Config LED_07 = Output
      23. Config LED_08 = Output
      24. Config LED_09 = Output
      25. Const PWMCount_Max = 63 ' PWM-Max-Wert (Auflösung)
      26. Dim TmrCount as Byte ' Zähler für PWM-Aufrufe
      27. Dim PWM_01 as Byte ' Werte für die 9 PWM-Kanäle
      28. Dim PWM_02 as Byte
      29. Dim PWM_03 as Byte
      30. Dim PWM_04 as Byte
      31. Dim PWM_05 as Byte
      32. Dim PWM_06 as Byte
      33. Dim PWM_07 as Byte
      34. Dim PWM_08 as Byte
      35. Dim PWM_09 as Byte
      36. Dim AfterGlow as Byte ' Nachleuchtdauer Einstellwert (Max-Wert)
      37. Dim _AfterGlow_Count as Byte ' Verzögerung Nachleuchteffekt (Zähler)
      38. Dim Motion_Step as Byte
      39. Dim Flags as Byte
      40. Const fMotionChange = 6 ' Flag=1, dann Effekt-Bewegung
      41. Dim tmpWord as Word
      42. AfterGlow = 100 ' Hier Nachleuchtdauer einstellen (0..255)
      43. Config ADC = Single , Prescaler = 32 , Reference = AVCC
      44. Config Timer1 = Timer , Prescale = 1024 , Clear Timer = 1
      45. Compare1A = 2000
      46. Config Timer2 = Timer , Prescale = 8 , Clear Timer = 1
      47. ocr2 = 156 - 1
      48. On oc1a ISR_Timer1
      49. On OC2 ISR_Timer2
      50. Enable OC1A
      51. Enable OC2
      52. Enable Interrupts
      53. ' --------------------------------------------------------
      54. ' Hauptschleife
      55. ' --------------------------------------------------------
      56. do
      57. nop
      58. if Flags.fMotionChange = 1 then ' Flag=1, dann Bewegungs-Routine aufrufen
      59. Gosub _MotionSet_02 ' Aufruf der Bewegungs-Routine
      60. Flags.fMotionChange = 0 ' Flag zieder auf NULL
      61. tmpWord = GetADC(1) ' Nachleuchtdauer Einstellbar machen
      62. shift tmpWord , right , 2
      63. AfterGlow = low(tmpWord)
      64. tmpWord = GetADC(0) ' Bewegungsgeschwindigkeit
      65. tmpWord = tmpWord + 20
      66. tmpWord = tmpWord * 8
      67. Compare1A = tmpWord
      68. End if
      69. loop
      70. End
      71. ISR_Timer1:
      72. Set Flags.fMotionChange ' Flag setzen, Effekt-Bewegung erforderlich
      73. Return
      74. ' --------------------------------------------------------
      75. ' PWM-Routine
      76. ' --------------------------------------------------------
      77. ISR_Timer2:
      78. If TmrCount = 0 then
      79. TmrCount = PWMCount_Max
      80. Reset LED_01 ' wenn TmrCounter=0, dann Counter auf Max. setzen (PWMCount_Max)
      81. Reset LED_02 ' und alle Ports ausschalten
      82. Reset LED_03
      83. Reset LED_04
      84. Reset LED_05
      85. Reset LED_06
      86. Reset LED_07
      87. Reset LED_08
      88. Reset LED_09
      89. Else ' Wenn TmrCounter>0
      90. If PWM_01 = TmrCount then Set LED_01
      91. If PWM_02 = TmrCount then Set LED_02
      92. If PWM_03 = TmrCount then Set LED_03
      93. If PWM_04 = TmrCount then Set LED_04
      94. If PWM_05 = TmrCount then Set LED_05
      95. If PWM_06 = TmrCount then Set LED_06
      96. If PWM_07 = TmrCount then Set LED_07
      97. If PWM_08 = TmrCount then Set LED_08
      98. If PWM_09 = TmrCount then Set LED_09
      99. Decr TmrCount
      100. End If
      101. If _AfterGlow_Count = 0 then ' Nachleucht-Routine
      102. _AfterGlow_Count = AfterGlow
      103. If PWM_01 > 0 then Decr PWM_01
      104. If PWM_02 > 0 then Decr PWM_02
      105. If PWM_03 > 0 then Decr PWM_03
      106. If PWM_04 > 0 then Decr PWM_04
      107. If PWM_05 > 0 then Decr PWM_05
      108. If PWM_06 > 0 then Decr PWM_06
      109. If PWM_07 > 0 then Decr PWM_07
      110. If PWM_08 > 0 then Decr PWM_08
      111. If PWM_09 > 0 then Decr PWM_09
      112. Else
      113. Decr _AfterGlow_Count
      114. End If
      115. Return
      116. ' --------------------------------------------------------
      117. ' Effekt-Routine
      118. ' --------------------------------------------------------
      119. _MotionSet_02:
      120. Select Case Motion_Step
      121. Case 0
      122. PWM_09 = PWMCount_Max
      123. Case 1
      124. PWM_08 = PWMCount_Max
      125. Case 2
      126. PWM_07 = PWMCount_Max
      127. Case 3
      128. PWM_06 = PWMCount_Max
      129. Case 4
      130. PWM_05 = PWMCount_Max
      131. Case 5
      132. PWM_04 = PWMCount_Max
      133. Case 6
      134. PWM_03 = PWMCount_Max
      135. Case 7
      136. PWM_02 = PWMCount_Max
      137. Case 8
      138. PWM_01 = PWMCount_Max
      139. Case 9
      140. PWM_02 = PWMCount_Max
      141. Case 10
      142. PWM_03 = PWMCount_Max
      143. Case 11
      144. PWM_04 = PWMCount_Max
      145. Case 12
      146. PWM_05 = PWMCount_Max
      147. Case 13
      148. PWM_06 = PWMCount_Max
      149. Case 14
      150. PWM_07 = PWMCount_Max
      151. Case 15
      152. PWM_08 = PWMCount_Max
      153. End Select
      154. incr Motion_Step
      155. If Motion_Step > 15 then Motion_Step = 0
      156. Return
      Display All
      Files
    • Naubaddi wrote:

      Wer oder was die LED dimmt ist doch egal.
      Ich dachte, die LEDs sollten sich beim Dimmen überschneiden? Also wenn die eine herunter dimmt, soll die nächste schon hochdimmen.
      Vielleicht sagt @Sven Loeffler noch was dazu?

      Mitch64 wrote:

      Video, ist aber zu groß für den Upload
      Dafür gibt es Youtube ;)
      Einfach den Link aus der Youtube Adresszeile hier einfügen.
    • Hi, ja so ein K.I.T.T. Lauflicht ist nett, so etwas habe ich in einem fahrbaren 1:24er Slotcar mit Tonausgabe vor einiger Zeit gebastelt:
      K.I.T.T. in 1:24

      Oder Meine Version:
      MF1 Lauflicht


      Damit man die Geschwindigkeit beim Dimmen einstellen kann hier eine Version mit Poti:

      BASCOM Source Code

      1. $regfile = "m8def.dat"
      2. $crystal = 8000000
      3. $hwstack = 30
      4. $swstack = 30
      5. $framesize = 30
      6. config adc = single , prescaler = auto , reference = avcc
      7. config portc.0 = input ' Eingang für ein Poti
      8. config portb.0 = output ' Ausgang für die LED
      9. LED alias portb.0
      10. dim Potiwert as word ' der Wert des Potis
      11. dim dimmen as word ' für die for-Schleife
      12. dim an as word ' die an-Zeit für die LED
      13. dim aus as word ' die aus-Zeit für die LED
      14. dim minimal as word ' der minimal-Wert für die for-Schleife
      15. minimal = 33
      16. do
      17. Potiwert = getadc(0)
      18. if Potiwert < minimal then : Potiwert = minimal : endif
      19. waitms 333
      20. for dimmen = 0 to Potiwert
      21. an = dimmen : aus = Potiwert - dimmen
      22. LED = 1 : waitus an : LED = 0 : waitus aus
      23. next dimmen
      24. for dimmen = 0 to Potiwert
      25. an = dimmen : aus = Potiwert - dimmen
      26. LED = 1 : waitus aus : LED = 0 : waitus an
      27. next dimmen
      28. loop
      29. end
      Display All

      Grüßle, Naubaddi
    • Also in der Hauptschleife soll gezählt werden, von 1 bis 3.
      Am besten ohne Wait-Befehle, weil in der Hauptschleife soll auch die Software-PWM laufen, so schnell wie möglich, damit nichts flimmert.

      Das Zählen soll aber konstant sein, ebenso die Dimmgeschwindigkeit, also braucht es einen Timerinterrupt.
      Hier bietet sich Timer0 an, 8 Bit Breite reichen.

      Wenn der Timer einen Prescaler von 64 hat, dann läuft er bei 8MHz Takt mit 125kHz, dann laden wir ihn mit 131, das gibt 1kHz Timerfrequenz.

      Im Timer kommt jetzt unser Entscheidungsbaum.
      Ist der Zähler 1 dann wird LED1 hochgedimmt und LED3 runter
      Ist der Zähler 2 dann wird LED2 hochgedimmt und LED1 runter
      Ist der Zähler 3 dann wird LED3 hochgedimmt und LED2 runter
      Für das Dimmen bekommt jede LED natürlich eine Byte-Variable zugewiesen.


      Zusätzlich zählen wir im Timer einen Timerzähler hoch.


      Im Hauptprogramm wird dieser Timerzähler ausgewertet und bei einem Stand von z.B. 200 wird er gelöscht und unser 1 bis 3 Zähler wird eins vor getaktet. Das ergibt dann eine Zeit von 0,6 Sekunden für eine Umdrehung der Rundumleuchte.


      Jetzt kommt noch die Software-PWM in der Hauptschleife:

      Ein dritter Zähler (Typ Byte) wird bei jedem Durchlauf inkrementiert.

      Es kommt zu einem Vergleich der LED-Variablen aus dem Timer und dem freilaufendem 3.Zähler.


      Ist die LED-Variable größer als der 3.Zähler, dann ist die entsprechende LED eingeschaltet, ansonsten ist sie aus.

      Das ganze natürlich für jede der 3 LEDs


      Das Programm kommt ganz ohne Waits aus, nur so wird auch die maximale PWM-Frequenz erreicht, weil ja alle restliche Prozessorzeit die PWM bedient wird.
    • Hi,

      Michael wrote:

      ...dann laden wir ihn mit 131...
      wie werden die 131 an den Timer0 übergeben?
      Ansonsten läuft das Programm nach Deiner Beschreibung, was nicht funktioniert sind 200 beim Timerzähler dann kommen die LEDs aus dem Takt. Eine Möglichkeit wäre ich habe irgendwas falsch verstanden, ist im Programm etwas was ich falsch gemacht habe?

      BASCOM Source Code

      1. ' Compiler: Bascom-Demo 2.0.7.5
      2. $regfile = "attiny85.dat"
      3. $crystal = 8000000
      4. $hwstack = 32
      5. $swstack = 32
      6. $framesize = 32
      7. config timer0 = Timer , Prescale = 64
      8. enable timer0
      9. on timer0 Timer_0
      10. Enable Interrupts
      11. config portb = output
      12. LED_1 alias portb.0
      13. LED_2 alias portb.1
      14. LED_3 alias portb.2
      15. dim T_Zeit as byte
      16. dim LED as byte
      17. dim soft_PWM as byte
      18. dim dimm_1 as byte
      19. dim dimm_2 as byte
      20. dim dimm_3 as byte
      21. do
      22. incr soft_PWM
      23. if dimm_1 > soft_PWM then : LED_1 = 1 : else : LED_1 = 0 : endif
      24. if dimm_2 > soft_PWM then : LED_2 = 1 : else : LED_2 = 0 : endif
      25. if dimm_3 > soft_PWM then : LED_3 = 1 : else : LED_3 = 0 : endif
      26. if T_Zeit = 255 then
      27. T_Zeit = 0
      28. incr LED : if LED > 3 then LED = 1
      29. endif
      30. loop
      31. end
      32. Timer_0:
      33. incr T_Zeit
      34. select case LED
      35. case 1 : incr dimm_1 : decr dimm_3
      36. case 2 : incr dimm_2 : decr dimm_1
      37. case 3 : incr dimm_3 : decr dimm_2
      38. end select
      39. return
      Display All
      Grüßle, Naubaddi
    • Naubaddi wrote:

      wie werden die 131 an den Timer0 übergeben?
      Wie sonst auch, man weist den Wert einfach zu
      Timer0 = 131
      Ich schrieb ja von 1kHz Timerfrequenz, die erreichst du bei 8MHz mit diesem Wert.

      Bei 16MHz wie in meiner Testumgebung muss der Timer den Wert 6 bekommen, oder einen Teiler von 256 und den Wert 193, was nicht genu 1kHz ergibt.

      Naubaddi wrote:

      was nicht funktioniert sind 200 beim Timerzähler dann kommen die LEDs aus dem Takt.
      sie werden halt nicht ganz hell, oder ganz dunkel.
      Das Programm kann natürlich den Timer schneller takten und dann die 200 entsprechend höher setzen (und die Variable T_zeit als Word deklarieren) Dann können die LEDs die ganze Helligkeit abfahren.
      Mein Text diente nur als Beispiel.


      Naubaddi wrote:

      ist im Programm etwas was ich falsch gemacht habe?
      Ich sehe keine Sicherheiten, einfach inkrementieren oder dekrementieren geht natürlich nicht.
      Da muß immer eine Abfrage davor, ob der Bereich überschritten wird.
      Auch das Incr Led würde ich nach der Abfrage, ob Überlauf droht, einfügen. Wär ja doof, wenn der Timer gleich nach dem Incr zuschlägt ;)

      Es ist auch sinnvoll, die nicht bediente LED im Timer auch zu dekrementieren, damit sie aus gehen kann.

      Ansonsten finde ich es gut, dass du das umsetzen konntest, das lässt mich hoffen, dass es bei Sven auch klappt. Wie du siehst, geht es ganz ohne Wait und gleichzeitiges Dimmen mehrere LEDs.
    • Hi,
      alle incr und decr wurden abgesichert.

      Michael wrote:

      Wie sonst auch, man weist den Wert einfach zu
      Timer0 = 131
      Auch erledigt, jetzt steht timer0 = 131 direkt am Anfang bei Timer_0:. Es stand vorher direkt nach enable timer0, kleiner Denkfehler meinerseits.

      Michael wrote:

      Es ist auch sinnvoll, die nicht bediente LED im Timer auch zu dekrementieren, damit sie aus gehen kann.
      Auch erledigt, dann sollte es so O.K. sein:


      BASCOM Source Code

      1. ' Compiler: Bascom-Demo 2.0.7.5
      2. $regfile = "attiny85.dat"
      3. $crystal = 8000000
      4. $hwstack = 32
      5. $swstack = 32
      6. $framesize = 32
      7. config timer0 = Timer , Prescale = 64
      8. enable timer0
      9. on timer0 Timer_0
      10. Enable Interrupts
      11. config portb = output
      12. LED_1 alias portb.0
      13. LED_2 alias portb.1
      14. LED_3 alias portb.2
      15. dim T_Zeit as byte
      16. dim LED as byte
      17. dim soft_PWM as byte
      18. dim dimm_1 as byte
      19. dim dimm_2 as byte
      20. dim dimm_3 as byte
      21. do
      22. if soft_PWM > 254 then soft_PWM = 0 : incr soft_PWM
      23. if dimm_1 > soft_PWM then : LED_1 = 1 : else : LED_1 = 0 : endif
      24. if dimm_2 > soft_PWM then : LED_2 = 1 : else : LED_2 = 0 : endif
      25. if dimm_3 > soft_PWM then : LED_3 = 1 : else : LED_3 = 0 : endif
      26. if T_Zeit > 254 then
      27. T_Zeit = 0
      28. if LED > 2 then LED = 0 : incr LED
      29. endif
      30. loop
      31. end
      32. Timer_0:
      33. timer0 = 131
      34. incr T_Zeit
      35. select case LED
      36. case 1
      37. if dimm_1 > 254 then dimm_1 = 0 : incr dimm_1
      38. if dimm_3 < 1 then dimm_3 = 255 : decr dimm_3
      39. if dimm_2 > 1 then decr dimm_2
      40. case 2
      41. if dimm_2 > 254 then dimm_2 = 0 : incr dimm_2
      42. if dimm_1 < 1 then dimm_1 = 255 : decr dimm_1
      43. if dimm_3 > 1 then decr dimm_3
      44. case 3
      45. if dimm_3 > 254 then dimm_3 = 0 : incr dimm_3
      46. if dimm_2 < 1 then dimm_2 = 255 : decr dimm_2
      47. if dimm_1 > 1 then decr dimm_1
      48. end select
      49. return
      Display All
      Grüßle, Naubaddi
    • Naubaddi wrote:

      if soft_PWM > 254 then soft_PWM = 0 : incr soft_PWM
      Was machst du da für Abfragen?
      Der freilaufende Zähler Soft_pwm soll überlaufen, da darfst du nichts abfragen.

      Naubaddi wrote:

      if dimm_1 > 254 then dimm_1 = 0 : incr dimm_1
      Auch hier, du willst doch nur inkrementieren, wenn 255 noch nicht erreicht ist.
      Stattdessen incrementierst du immer und fängst von vorne an, wenn du fast fertig bist.

      If Dimm_1 < 255 Then Incr Dimm_1

      sonst nichts.


      Naubaddi wrote:

      if LED > 2 then LED = 0 : incr LED
      Hier hatte ich geschrieben, dass die Gefahr des Timereingriffs besteht. Der Wert könnte auf einmal Null sein.

      Ich habe es so gelöst:

      If Index >= 3 Then
      Index = 1
      Else
      Incr Index
      End If

      Wenn du die Befehle in eigene Zeilen schreibst statt sie mit Doppelpunkten zu trennen, dann wird es übersichtlicher.
    • War das eine schwere Geburt, falsch verstanden, falsch gedacht und englisch Kenntnisse die fast 0 sind ansonsten ist die BASCOM-Reference sehr gut :-).

      Michael wrote:

      If Dimm_1 < 255 Then Incr Dimm_1
      erledigt, und der freilaufende läuft wieder über ;-).

      If Index >= 3 Then
      Index = 1
      Else
      Incr Index
      End If

      wurde zu

      if LED > 2 then
      LED = 1
      else
      incr LED
      endif

      Danke für Deine Geduld :thumbup: .

      Grüßle, Naubaddi
    • Nur der Vollständigkeit halber, möchte ich hier nochmal den vollen Code posten. Damit alles etwas davon haben. So funktioniert das Programm einwandfrei. Vielen Dank für Eure Hilfe !

      BASCOM Source Code

      1. ' ******************************************************************************
      2. ' * *
      3. ' * 3 Kanal Rundumlicht mit PWM *
      4. ' * *
      5. ' * ****************************************************************************
      6. $regfile = "attiny25.dat"
      7. $crystal = 8000000
      8. $hwstack = 32
      9. $swstack = 32
      10. $framesize = 32
      11. Config Timer0 = Timer , Prescale = 64
      12. Enable Timer0
      13. On Timer0 Timer_0
      14. Enable Interrupts
      15. Config Portb = Output
      16. Led_1 Alias Portb.0
      17. Led_2 Alias Portb.1
      18. Led_3 Alias Portb.2
      19. B1 Alias Portb.4
      20. B2 Alias Portb.3
      21. Dim T_zeit As Byte
      22. Dim Led As Byte
      23. Dim Soft_pwm As Byte
      24. Dim Dimm_1 As Byte
      25. Dim Dimm_2 As Byte
      26. Dim Dimm_3 As Byte
      27. Do
      28. If Soft_pwm > 254 Then Soft_pwm = 0 : Incr Soft_pwm
      29. If Dimm_1 > Soft_pwm Then : Led_1 = 0 : Else : Led_1 = 1 : End If
      30. If Dimm_2 > Soft_pwm Then : Led_2 = 0 : Else : Led_2 = 1 : End If
      31. If Dimm_3 > Soft_pwm Then : Led_3 = 0 : Else : Led_3 = 1 : End If
      32. If T_zeit > 254 Then
      33. T_zeit = 0
      34. If Led > 2 Then Led = 0 : Incr Led
      35. End If
      36. Loop
      37. End
      38. Timer_0:
      39. Timer0 = 195
      40. Incr T_zeit
      41. Select Case Led
      42. Case 1
      43. If Dimm_1 > 254 Then Dimm_1 = 0 : Incr Dimm_1
      44. If Dimm_3 < 1 Then Dimm_3 = 255 : Decr Dimm_3
      45. If Dimm_2 > 1 Then Decr Dimm_2
      46. Case 2
      47. If Dimm_2 > 254 Then Dimm_2 = 0 : Incr Dimm_2
      48. If Dimm_1 < 1 Then Dimm_1 = 255 : Decr Dimm_1
      49. If Dimm_3 > 1 Then Decr Dimm_3
      50. Case 3
      51. If Dimm_3 > 254 Then Dimm_3 = 0 : Incr Dimm_3
      52. If Dimm_2 < 1 Then Dimm_2 = 255 : Decr Dimm_2
      53. If Dimm_1 > 1 Then Decr Dimm_1
      54. End Select
      55. Return
      Display All