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.

    • Pluto25 wrote:

      Wasi wrote:

      Hier bekomme ich aber 2 Fehlermeldungen
      Der 328 hat zwei PWM Ausgänge am Timer2OC2A für Portb.3 oder OC2B wenn Portd.3 genutzt werden soll.
      Bei Dir werden die Ausgänge dabei nicht genutzt? - Dann ist es egal, such Dir einen aus (A oder B)
      Aaah ok, das wusste ich nicht das dieser code PWM Ausgänge benötigt, oder hab ich es überlesen ?(
      Laut Datenblatt sind es 6 PWM Ausgänge so wie ich das sehe.
    • Wasi wrote:

      Hier bekomme ich aber 2 Fehlermeldungen und weiß nicht wie ich die weg bekomme.

      Error : 117 Line : 54 Unknown interrupt [OC2]
      Error : 85 Line : 55 Unknown interrupt source [OC2]


      Pluto hat es bereits erwähnt.

      Du musst den Timer und die Interrupts dann so konfigurieren.

      BASCOM Source Code: Korrektur Timer-Konfiguration

      1. ' ----------------------------------------------
      2. ' Timer2 wird als Zeitbasis verwendet und
      3. ' generiert einen Interrupt alle 1ms (1kHz)
      4. ' und ruft damit die Routine ISR_Timer2 auf.
      5. ' ----------------------------------------------
      6. Config Timer2 = Timer , Prescale = 64 , CLEAR_TIMER = 1
      7. Compare2A = 125 - 1
      8. On OC2A ISR_Timer2
      9. Enable OC2A
      10. ' ----------------------------------------------
      Display All
      Zeile 7, 9 und 10 sind anzupassen.
    • Nein. TOSC sind Quarzanschlüsse. Verzeih Post 40 (Zu viele Infos). In Mitchs Code werden die Ausgänge nicht benützt, nur einer der möglichen OC2 Interrupts. Und da es zwei sind muß der Compiler wissen welchen er verwenden soll (A oder B). Die zugehörigen Ausgänge sind da nicht betroffen und können beliebig genutz werden.
      So auch die TOSC solange kein Quarz dran muß, können B.6 und B.7 für irgendwas genutzt werden
    • In etwa so sollte das laufen.

      BASCOM Source Code: Knight-Rider Effekt

      1. ' Knight-Rider Effekt
      2. ' Prinzip-Ansatz mit LED'Strips
      3. ' Modul: KnightRider.bas
      4. ' Autor: Mitch64
      5. ' Erstellt: 09.10.2021
      6. ' Geändert: 13.10.2021
      7. ' Version: 1.1
      8. '$Regfile = "m32def.dat"
      9. $Regfile = "m328pdef.dat"
      10. $HWStack = 30
      11. $SWStack = 40
      12. $FrameSize = 40
      13. $Crystal = 8000000
      14. Config Base = 0
      15. ' ----------------------------------------------
      16. ' Konfiguration des Effekts
      17. ' Hier kann eingestellt werden, wie schnell der
      18. ' Lauflicht-Effekt ablaufen soll, und wie
      19. ' schnell abgedimmt werden soll.
      20. ' Da der Timer2 mit 1kHz läuft und die
      21. ' Counter-Werte runter-gezählt werden,
      22. ' entsprechen die Werte ms.
      23. ' ----------------------------------------------
      24. Const INTERVAL_EFFEKT = 500 ' Geschwindigkeit des Lauf-Effekts
      25. Const INTERVAL_DIMMEN = 3 ' Geschwindigkeit des Abdimmens
      26. ' ----------------------------------------------
      27. ' Variable
      28. ' ----------------------------------------------
      29. Dim Effekt_Step as Byte ' Variable beinhalten den Schritt des Effekts
      30. ' ----------------------------------------------
      31. ' Flags, die anzeigen, ob das Lauflicht bewegt
      32. ' oder gedimmt werden soll.
      33. ' ----------------------------------------------
      34. Dim Flag_Effekt as Bit ' Lauf-Effekt
      35. Dim Flag_Dimmen as Bit ' Dimmen
      36. ' ----------------------------------------------
      37. ' interne Variablen, werden von
      38. ' ISR_Timer2 verwendet
      39. ' ----------------------------------------------
      40. Dim Count_Effekt as Word
      41. Dim Count_Dimmen as Word
      42. ' ----------------------------------------------
      43. ' Timer2 wird als Zeitbasis verwendet und
      44. ' generiert einen Interrupt alle 1ms (1kHz)
      45. ' und ruft damit die Routine ISR_Timer2 auf.
      46. ' ----------------------------------------------
      47. Config Timer2 = Timer , Prescale = 64 , CLEAR_TIMER = 1
      48. OCR2A = 125 - 1
      49. On OC2A ISR_Timer2
      50. Enable OC2A
      51. ' ----------------------------------------------
      52. ' LED-Strip
      53. ' ----------------------------------------------
      54. Const RainbowLeds = 7 ' Anzahl Strip-LED's
      55. Const RainbowLastIdx = RainbowLeds * 3 -1 ' Anzahl Bytes für Strip-Daten berechnen
      56. Config Rainbow = 1 , RB0_Len = RainbowLeds , RB0_Port = PortB , RB0_Pin = 7
      57. Dim Color(3) as Byte
      58. Red Alias Color(_base + 0)
      59. Green Alias Color(_base + 1)
      60. Blue Alias Color(_base + 2)
      61. Dim rbIndex as Byte ' Index RB-LED
      62. ' Farbe für die KnightLeds
      63. Red = 20
      64. Green = 255
      65. Blue = 255
      66. Enable Interrupts
      67. ' ----------------------------------------------------------------------------
      68. ' Hauptschleife
      69. ' ----------------------------------------------------------------------------
      70. Do
      71. ' ----------------------------------------
      72. ' Hier wird der Lauflicht-Effekt gesteuert
      73. ' (Prozess 1)
      74. ' ----------------------------------------
      75. If Flag_Effekt = 1 then ' Lauflicht nächste LED anschalten
      76. Reset Flag_Effekt ' Flag löschen nicht vergessen!
      77. ' Hier muss noch unterschieden werden,
      78. ' welche LED nun anzusteuern ist. Diese
      79. ' wird dann voll ausgesteuert (max. Helligkeit)
      80. ' Das Abdimmen wird von der nachfolgenden
      81. ' Dimm-Routine (If Flag_Dimmen...) erledigt.
      82. ' Beispiel mit 7 LED's (LED0 ganz links, LED6 ganz rechts)
      83. Select Case Effekt_Step
      84. Case 0 ' Effekt-Schritt 0
      85. ' LED0 und 6 aussteuern
      86. RB_AddColor 0 , Color(0)
      87. RB_AddColor 6 , Color(0)
      88. Incr Effekt_Step ' nächster Step
      89. Case 1 ' Effekt-Schritt 1
      90. ' LED1 und 5 aussteuern
      91. RB_AddColor 1 , Color(0)
      92. RB_AddColor 5 , Color(0)
      93. Incr Effekt_Step ' nächster Step
      94. Case 2 ' Effektschritt 2
      95. ' LED2 und 4 aussteuern
      96. RB_AddColor 2 , Color(0)
      97. RB_AddColor 4 , Color(0)
      98. Incr Effekt_Step ' nächster Step
      99. Case 3 ' Effekt-Schritt 3
      100. ' LED3 (mittige LED) aussteuern
      101. RB_AddColor 3 , Color(0)
      102. Incr Effekt_Step ' nächster Step
      103. Case 4 ' Effekt-Schritt 4
      104. ' LED2 und 4 aussteuern
      105. RB_AddColor 2 , Color(0)
      106. RB_AddColor 4 , Color(0)
      107. Incr Effekt_Step ' nächster Step
      108. Case 5 ' Effekt-Schritt 5
      109. ' LED1 und 5 aussteuern
      110. RB_AddColor 1 , Color(0)
      111. RB_AddColor 5 , Color(0)
      112. Incr Effekt_Step ' nächster Step
      113. Effekt_Step = 0 ' dann wieder von vorne
      114. End Select
      115. RB_Send ' geänderte Daten an Stripe senden
      116. End If
      117. ' --------------------------------
      118. ' Hier wird das Abdimmen gesteuert
      119. ' (Prozess 2)
      120. ' --------------------------------
      121. If Flag_Dimmen = 1 then
      122. Reset Flag_Dimmen ' Flag löschen nicht vergessen
      123. ' Hier werden alle LED's in der Helligkeit reduziert.
      124. ' Werte die bereits auf 0 sind bleiben unberührt.
      125. ' Dadurch entsteht der Nachleucht-Effekt
      126. For RbIndex = 0 to RainbowLastIdx ' Alle Felder im Strip durchgehen
      127. If Rainbow0_(RbIndex) > 0 then ' Wenn Wert > 0 dann
      128. Decr Rainbow0_(RbIndex) ' Wert dekrementieren
      129. End If
      130. Next
      131. RB_Send ' manipulierte Daten abschicken
      132. End If
      133. Loop
      134. ' ----------------------------------------------
      135. ' Die ISR_Timer2 wird regelmäßig (alle 1ms)
      136. ' aufgerufen. Sie bestimmt die Zeitpunkte, wann
      137. ' das Lauflich bewegt oder gedimmt werden soll.
      138. ' Dafür werden die Flags
      139. ' Flags_Effect und Flag_Dimm gesetzt.
      140. ' ----------------------------------------------
      141. ISR_Timer2:
      142. ' Intervall für Laufeffekt erzeugen
      143. If Count_Effekt = 0 then
      144. Set Flag_Effekt ' Flag setzen, Lauflicht soll bewegt werden
      145. Count_Effekt = INTERVAL_EFFEKT ' Effekt-Zähler rücksetzen
      146. Else
      147. Decr Count_Effekt
      148. End If
      149. ' Intervall für Abdimmen erzeugen
      150. If Count_Dimmen = 0 then
      151. Set Flag_Dimmen ' Flag setzen, es soll gedimmt werden
      152. Count_Dimmen = INTERVAL_DIMMEN ' Dimm-Zähler rücksetzen
      153. Else
      154. Decr Count_Dimmen
      155. End If
      156. Return
      Display All
    • Pluto25 wrote:

      Nein. TOSC sind Quarzanschlüsse. Verzeih Post 40 (Zu viele Infos). In Mitchs Code werden die Ausgänge nicht benützt, nur einer der möglichen OC2 Interrupts. Und da es zwei sind muß der Compiler wissen welchen er verwenden soll (A oder B). Die zugehörigen Ausgänge sind da nicht betroffen und können beliebig genutz werden.
      So auch die TOSC solange kein Quarz dran muß, können B.6 und B.7 für irgendwas genutzt werden
      Hallo @Pluto25,

      das hatte ich missverstanden, hier geht es rein um die Software und nicht die Hardware, wie ich das jetzt verstanden habe.
      Noch dazu muß ich einen PWM Ausgang benutzen, wenn ich das richtig verstanden habe?
      Dann werde ich den PD6 beim 328er verwenden, der ist noch frei.

      Mitch64 wrote:

      In etwa so sollte das laufen.
      Hallo @Mitch64,

      danke für deinen Einsatz, ich weiß mit solchen Anfängern wie mich hat man es nicht leicht.

      Deinen Code werde ich mir noch heute anschauen.
    • Hallo @Wasi

      Der Code hat noch ein paar Fehler. Vor der Hauptschleife musst du noch eine Anweisung
      RB_SelectChannel 0 ergänzen und in der Hauptschleife alle Anweisungen
      RB_AddColor durch RB_SetColor ersetzen.

      Ein Guter Freund testet evtl. noch den Code (Ich habe die Stips nicht da).
      Aber hier schon mal den geänderten Code

      BASCOM Source Code: Knight-Rider: Korrigierte Version 1.2

      1. ' Knight-Rider Effekt
      2. ' Prinzip-Ansatz mit LED'Strips
      3. ' Modul: KnightRider.bas
      4. ' Autor: Mitch64
      5. ' Erstellt: 09.10.2021
      6. ' Geändert: 13.10.2021
      7. ' Version: 1.2
      8. ' History
      9. ' Version 1.0: Erste gezeigte Version (Programm-Gerüst).
      10. ' Version 1.1: Code-Ergänzungen zum WS2812 Strip
      11. ' Version 1.2: RB_SelectChannel hinzugefügt.
      12. ' RB_AddColor in der Hauptschleife durch RB_SetColor ersetzt
      13. '$Regfile = "m32def.dat"
      14. $Regfile = "m328pdef.dat"
      15. $HWStack = 30
      16. $SWStack = 40
      17. $FrameSize = 40
      18. $Crystal = 8000000
      19. Config Base = 0
      20. ' ----------------------------------------------
      21. ' Konfiguration des Effekts
      22. ' Hier kann eingestellt werden, wie schnell der
      23. ' Lauflicht-Effekt ablaufen soll, und wie
      24. ' schnell abgedimmt werden soll.
      25. ' Da der Timer2 mit 1kHz läuft und die
      26. ' Counter-Werte runter-gezählt werden,
      27. ' entsprechen die Werte ms.
      28. ' ----------------------------------------------
      29. Const INTERVAL_EFFEKT = 500 ' Geschwindigkeit des Lauf-Effekts
      30. Const INTERVAL_DIMMEN = 3 ' Geschwindigkeit des Abdimmens
      31. ' ----------------------------------------------
      32. ' Variable
      33. ' ----------------------------------------------
      34. Dim Effekt_Step as Byte ' Variable beinhalten den Schritt des Effekts
      35. ' ----------------------------------------------
      36. ' Flags, die anzeigen, ob das Lauflicht bewegt
      37. ' oder gedimmt werden soll.
      38. ' ----------------------------------------------
      39. Dim Flag_Effekt as Bit ' Lauf-Effekt
      40. Dim Flag_Dimmen as Bit ' Dimmen
      41. ' ----------------------------------------------
      42. ' interne Variablen, werden von
      43. ' ISR_Timer2 verwendet
      44. ' ----------------------------------------------
      45. Dim Count_Effekt as Word
      46. Dim Count_Dimmen as Word
      47. ' ----------------------------------------------
      48. ' Timer2 wird als Zeitbasis verwendet und
      49. ' generiert einen Interrupt alle 1ms (1kHz)
      50. ' und ruft damit die Routine ISR_Timer2 auf.
      51. ' ----------------------------------------------
      52. Config Timer2 = Timer , Prescale = 64 , CLEAR_TIMER = 1
      53. OCR2A = 125 - 1
      54. On OC2A ISR_Timer2
      55. Enable OC2A
      56. ' ----------------------------------------------
      57. ' LED-Strip
      58. ' ----------------------------------------------
      59. Const RainbowLeds = 7 ' Anzahl Strip-LED's
      60. Const RainbowLastIdx = RainbowLeds * 3 -1 ' Anzahl Bytes für Strip-Daten berechnen
      61. Config Rainbow = 1 , RB0_Len = RainbowLeds , RB0_Port = PortB , RB0_Pin = 7
      62. Dim Color(3) as Byte
      63. Red Alias Color(_base + 0)
      64. Green Alias Color(_base + 1)
      65. Blue Alias Color(_base + 2)
      66. Dim rbIndex as Byte ' Index RB-LED
      67. ' Farbe für die KnightLeds
      68. Red = 20
      69. Green = 255
      70. Blue = 255
      71. RB_SelectChannel 0
      72. Enable Interrupts
      73. ' ----------------------------------------------------------------------------
      74. ' Hauptschleife
      75. ' ----------------------------------------------------------------------------
      76. Do
      77. ' ----------------------------------------
      78. ' Hier wird der Lauflicht-Effekt gesteuert
      79. ' (Prozess 1)
      80. ' ----------------------------------------
      81. If Flag_Effekt = 1 then ' Lauflicht nächste LED anschalten
      82. Reset Flag_Effekt ' Flag löschen nicht vergessen!
      83. ' Hier muss noch unterschieden werden,
      84. ' welche LED nun anzusteuern ist. Diese
      85. ' wird dann voll ausgesteuert (max. Helligkeit)
      86. ' Das Abdimmen wird von der nachfolgenden
      87. ' Dimm-Routine (If Flag_Dimmen...) erledigt.
      88. ' Beispiel mit 7 LED's (LED0 ganz links, LED6 ganz rechts)
      89. Select Case Effekt_Step
      90. Case 0 ' Effekt-Schritt 0
      91. ' LED0 und 6 aussteuern
      92. RB_SetColor 0 , Color(0)
      93. RB_SetColor 6 , Color(0)
      94. Incr Effekt_Step ' nächster Step
      95. Case 1 ' Effekt-Schritt 1
      96. ' LED1 und 5 aussteuern
      97. RB_SetColor 1 , Color(0)
      98. RB_SetColor 5 , Color(0)
      99. Incr Effekt_Step ' nächster Step
      100. Case 2 ' Effektschritt 2
      101. ' LED2 und 4 aussteuern
      102. RB_SetColor 2 , Color(0)
      103. RB_SetColor 4 , Color(0)
      104. Incr Effekt_Step ' nächster Step
      105. Case 3 ' Effekt-Schritt 3
      106. ' LED3 (mittige LED) aussteuern
      107. RB_SetColor 3 , Color(0)
      108. Incr Effekt_Step ' nächster Step
      109. Case 4 ' Effekt-Schritt 4
      110. ' LED2 und 4 aussteuern
      111. RB_SetColor 2 , Color(0)
      112. RB_SetColor 4 , Color(0)
      113. Incr Effekt_Step ' nächster Step
      114. Case 5 ' Effekt-Schritt 5
      115. ' LED1 und 5 aussteuern
      116. RB_SetColor 1 , Color(0)
      117. RB_SetColor 5 , Color(0)
      118. Incr Effekt_Step ' nächster Step
      119. Effekt_Step = 0 ' dann wieder von vorne
      120. End Select
      121. RB_Send ' geänderte Daten an Stripe senden
      122. End If
      123. ' --------------------------------
      124. ' Hier wird das Abdimmen gesteuert
      125. ' (Prozess 2)
      126. ' --------------------------------
      127. If Flag_Dimmen = 1 then
      128. Reset Flag_Dimmen ' Flag löschen nicht vergessen
      129. ' Hier werden alle LED's in der Helligkeit reduziert.
      130. ' Werte die bereits auf 0 sind bleiben unberührt.
      131. ' Dadurch entsteht der Nachleucht-Effekt
      132. For RbIndex = 0 to RainbowLastIdx ' Alle Felder im Strip durchgehen
      133. If Rainbow0_(RbIndex) > 0 then ' Wenn Wert > 0 dann
      134. Decr Rainbow0_(RbIndex) ' Wert dekrementieren
      135. End If
      136. Next
      137. RB_Send ' manipulierte Daten abschicken
      138. End If
      139. Loop
      140. ' ----------------------------------------------
      141. ' Die ISR_Timer2 wird regelmäßig (alle 1ms)
      142. ' aufgerufen. Sie bestimmt die Zeitpunkte, wann
      143. ' das Lauflicht bewegt oder gedimmt werden soll.
      144. ' Dafür werden die Flags
      145. ' Flags_Effect und Flag_Dimmen gesetzt.
      146. ' ----------------------------------------------
      147. ISR_Timer2:
      148. ' Intervall für Laufeffekt erzeugen
      149. If Count_Effekt = 0 then
      150. Set Flag_Effekt ' Flag setzen, Lauflicht soll bewegt werden
      151. Count_Effekt = INTERVAL_EFFEKT ' Effekt-Zähler rücksetzen
      152. Else
      153. Decr Count_Effekt
      154. End If
      155. ' Intervall für Abdimmen erzeugen
      156. If Count_Dimmen = 0 then
      157. Set Flag_Dimmen ' Flag setzen, es soll gedimmt werden
      158. Count_Dimmen = INTERVAL_DIMMEN ' Dimm-Zähler rücksetzen
      159. Else
      160. Decr Count_Dimmen
      161. End If
      162. Return
      Display All
    • Mitch64 wrote:

      Hallo @Wasi

      Der Code hat noch ein paar Fehler. Vor der Hauptschleife musst du noch eine Anweisung
      RB_SelectChannel 0 ergänzen und in der Hauptschleife alle Anweisungen
      RB_AddColor durch RB_SetColor ersetzen.

      Ein Guter Freund testet evtl. noch den Code (Ich habe die Stips nicht da).
      Aber hier schon mal den geänderten Code
      Hallo Mitch64,

      hab jetzt alle ersetzt und nutze erstmal die
      RB0_Port = Portb , RB0_Pin = 7
      damit sich keine Fehler einschleichen.

      Hab den
      Const INTERVAL_EFFEKT = 1000 ' Geschwindigkeit des Lauf-Effekts
      mal hoch gesetzt das man es besser sehen kann.

      Jeweils eine LED von Links und Rechts laufen in die Mitte und zurück und faden immer aus.
      Jedoch gehen teilweise die LEDs von 8 bis 14 auch sporadisch an und aus, aber nicht in dem Tempo des Laufeffekts, sonderm langsamer.
    • Die erstel LED's (1 bis 7) tun genau das was sie sollen.
      Die anderen LED's werden vom Code nicht angesteuert.
      Ich denke das ist ein Effekt, der mit dem Protokoll der Strips zusammen hängt.
      Jede Led schiebt ja die Daten an die nächste Led weiter.

      Da du 14 LED's dran hast (ich nehme an ab 1 gezählt), kannst du mal
      Den Config Rainbow auf 14 LED's ändern und nochmal versuchen.
    • Mitch64 wrote:

      Die erstel LED's (1 bis 7) tun genau das was sie sollen.
      Die anderen LED's werden vom Code nicht angesteuert.
      Ich denke das ist ein Effekt, der mit dem Protokoll der Strips zusammen hängt.
      Jede Led schiebt ja die Daten an die nächste Led weiter.

      Da du 14 LED's dran hast (ich nehme an ab 1 gezählt), kannst du mal
      Den Config Rainbow auf 14 LED's ändern und nochmal versuchen.
      Hab das jetzt

      Const RainbowLeds = 14

      so geändert.

      Die 7 LEDs werden weiter korrekt angesteuert und jetzt werden zusätzlich bis led 21 sporadisch LEDs an und aus geschaltet.


      Pluto25 wrote:

      Jetzt bin ich verwirrt :/

      Wasi wrote:

      Noch dazu muß ich einen PWM Ausgang benutzen
      Heißt das kein Ausgang benutzt wird? Richtig, demnach kann D.6 für irgendwas benützt werden.
      Wie oben geschrieben lass ich mal die Eingänge so wie sie bei Mitch64 angegeben sind um Fehler zu vermeiden.

      Ist also auf PB7 angeschlossen.
    • Wasi wrote:

      Hab das jetzt

      Const RainbowLeds = 14

      so geändert.

      Die 7 LEDs werden weiter korrekt angesteuert und jetzt werden zusätzlich bis led 21 sporadisch LEDs an und aus geschaltet.
      Du kannst mal versuchen bevor du RB_Send ausgibst, zuvor die Interrupts abzuschalten und gleich danach wieder an.

      Disable Interrupts
      RB_Send
      Enable Interrupt

      Sollte das nicht zum Ziel führen, dann lieht es eben an dem Protokoll.
      Behelfsweise musst du dann bei Const RainbowLeds die tatsächliche Anzahl angeschlossener LED's angeben.
      Oder du kürzt den Stip auf die erforderliche Länge.

      Du kannst den Code ja anpassen. Es hindert dich niemand daran! Fühl dich frei!


      An der Stelle mal ne Frage.
      Du spielst den Code in einen Arduino Uno rein? Weil der ja mit 16MHz getaktet wird und nicht mit 8. Vielleicht ist das der Grund für die flirrenden LED's
    • Mitch64 wrote:

      Du kannst mal versuchen bevor du RB_Send ausgibst, zuvor die Interrupts abzuschalten und gleich danach wieder an.

      Disable Interrupts
      RB_Send
      Enable Interrupt

      Sollte das nicht zum Ziel führen, dann lieht es eben an dem Protokoll.
      Behelfsweise musst du dann bei Const RainbowLeds die tatsächliche Anzahl angeschlossener LED's angeben.
      Oder du kürzt den Stip auf die erforderliche Länge.
      Ok, hab ich gemacht und jetzt geht es, hab auch ein LED mehr angegeben als vorhanden, da sonst der letzte auch noch angeht, hab anstatt 56, 57 LEDs angeben.

      Mit dem gekürzten Stripe Läuft alles Richtig.


      Mitch64 wrote:

      Du kannst den Code ja anpassen. Es hindert dich niemand daran! Fühl dich frei!
      Danke, mach ich. :D


      Mitch64 wrote:

      An der Stelle mal ne Frage.
      Du spielst den Code in einen Arduino Uno rein? Weil der ja mit 16MHz getaktet wird und nicht mit 8. Vielleicht ist das der Grund für die flirrenden LED's
      Nein, ich nutze den Atmega328p DIP 28 komplett nackt ohne Arduino, habe da noch welche in der Schublade. :D