Aller anfang ist schwer, Arduino Lichtsteuerung

    Diese Seite verwendet Cookies. Durch die Nutzung unserer Seite erklären Sie sich damit einverstanden, dass wir Cookies setzen. Weitere Informationen

    • Aller anfang ist schwer, Arduino Lichtsteuerung

      Guten Tag
      Ich habe aus diversen Tutorials und x Stunden lesen einen Sketch erstellt zusammengefügt u.s.w.

      Mein Ziel ist es aus einem Nano 7 pwm Känäle auszulesen und diese dann in einzelnen Funktionen an die Beleuchtungssteuerung weiterzugeben.
      Alle Kanäle werden in Schlaufe abgefragt und ich kann das auch auf dem Seriellen Monitor mitverfolgen.
      Problen:
      Sobald ich eine If einfüge wird Kanal 8 nicht mehr ausgewertet und die Schlaufe läuft nur noch im Secunden Takt.
      Kann mir da bitte jemand auf die Sprünge helfen?


      Quellcode

      1. /*
      2. Modellschiff Nino RC Mehrkanal Licht Steuerung Futaba.
      3. */
      4. int PWM1 = 2; // Kanal 1 Schalter Fernbedienung J1
      5. int PWM3 = 3; // Kanal 3 Schalter Fernbedienung SE
      6. int PWM4 = 4; // Kanal 4 Schalter Fernbedienung SA
      7. int PWM5 = 5; // Kanal 5 Schalter Fernbedienung SB
      8. int PWM6 = 6; // Kanal 6 Schalter Fernbedienung SG
      9. int PWM7 = 7; // Kanal 7 Schalter Fernbedienung SD
      10. int PWM8 = 8; // Kanal 8 Schalter Fernbedienung SC
      11. int Led1 = A0; // Standlicht
      12. int Led2 = A1; // Fahrlicht
      13. int Led3 = A2; // Funktion?
      14. int Led4 = A3; // Funktion?
      15. int Led5 = A4; // Funktion?
      16. int Led6 = A5; // Funktion?
      17. int Led7 = A6; // Armaturen
      18. int Led8 = A7; // Ambiente
      19. int Led9 = 9; // Funktion?
      20. int Led10 = 10; // Funktion?
      21. int Led11 = 11; // Funktion?
      22. int Led12 = 12; // Funktion?
      23. int Led13 = 13; // Funktion?
      24. void setup() {
      25. pinMode(PWM1, INPUT);
      26. pinMode(PWM3, INPUT);
      27. pinMode(PWM4, INPUT);
      28. pinMode(PWM5, INPUT);
      29. pinMode(PWM6, INPUT);
      30. pinMode(PWM7, INPUT);
      31. pinMode(PWM8, INPUT);
      32. Serial.begin(115200);
      33. pinMode(Led1, OUTPUT);
      34. pinMode(Led2, OUTPUT);
      35. pinMode(Led3, OUTPUT);
      36. pinMode(Led4, OUTPUT);
      37. pinMode(Led5, OUTPUT);
      38. pinMode(Led6, OUTPUT);
      39. pinMode(Led7, OUTPUT);
      40. pinMode(Led8, OUTPUT);
      41. pinMode(Led9, OUTPUT);
      42. pinMode(Led10, OUTPUT);
      43. pinMode(Led11, OUTPUT);
      44. pinMode(Led12, OUTPUT);
      45. pinMode(Led13, OUTPUT);
      46. }
      47. void loop() {
      48. int pwm1 = pulseIn(PWM1, HIGH); // PWM Kanal 1 Lesen
      49. int pwm3 = pulseIn(PWM3, HIGH); // PWM Kanal 3 Lesen
      50. int pwm4 = pulseIn(PWM4, HIGH); // PWM Lesen 4 Lesen
      51. int pwm5 = pulseIn(PWM5, HIGH); // PWM Lesen 5 Lesen
      52. int pwm6 = pulseIn(PWM6, HIGH); // PWM Lesen 6 Lesen
      53. int pwm7 = pulseIn(PWM7, HIGH); // PWM Lesen 7 Lesen
      54. int pwm8 = pulseIn(PWM8, HIGH); // PWM Lesen 8 Lesen
      55. Serial.print (" PWM Kanal 1:"); // Name im Serial Monitor
      56. Serial.print (pwm1);
      57. Serial.print (" PWM Kanal 3:"); // Name im Serial Monitor
      58. Serial.print (pwm3);
      59. Serial.print (" PWM Kanal 4:"); // Name im Serial Monitor
      60. Serial.print (pwm4);
      61. Serial.print (" PWM Kanal 5:"); // Name im Serial Monitor
      62. Serial.print (pwm5);
      63. Serial.print (" PWM Kanal 6:"); // Name im Serial Monitor
      64. Serial.print (pwm6);
      65. Serial.print (" PWM Kanal 7:"); // Name im Serial Monitor
      66. Serial.print (pwm7);
      67. Serial.print (" PWM Kanal 8:"); // Name im Serial Monitor
      68. Serial.println (pwm8);
      69. if (pwm1 >= 800 && pwm1 <= 1450)
      70. digitalWrite(Led1, HIGH);
      71. else
      72. digitalWrite(Led1, LOW);
      73. if ( pwm1 >= 1450 && pwm1 <= 1550 )
      74. digitalWrite(Led2, HIGH);
      75. else
      76. digitalWrite(Led2, LOW);
      77. if ( pwm1 >= 1550 && pwm1 <= 2000 )
      78. digitalWrite(Led1, HIGH);
      79. if (pwm3 > 900 ) // Funktion Kanal 3
      80. digitalWrite(Led3, LOW);
      81. digitalWrite(Led4, LOW);
      82. if (pwm3 > 1200)
      83. digitalWrite(Led3, HIGH);
      84. if (pwm3 > 1700) //
      85. digitalWrite(Led4, HIGH);
      86. if (pwm4 > 900 ) // Funktion Kanal 4
      87. digitalWrite(Led5, LOW);
      88. digitalWrite(Led6, LOW);
      89. if (pwm4 > 1200)
      90. digitalWrite(Led5, HIGH);
      91. if (pwm4 > 1700)
      92. digitalWrite(Led6, HIGH);
      93. if (pwm5 > 900 ) // Funktion Kanal 5
      94. digitalWrite(Led7, LOW);
      95. digitalWrite(Led8, LOW);
      96. if (pwm5 > 1200)
      97. digitalWrite(Led7, HIGH);
      98. if (pwm5 > 1700)
      99. digitalWrite(Led8, HIGH);
      100. if (pwm6 > 900 ) // Funktion Kanal 6
      101. digitalWrite(Led9, LOW);
      102. digitalWrite(Led10, LOW);
      103. if (pwm6 > 1200)
      104. digitalWrite(Led9, HIGH);
      105. if (pwm6 > 1700) //
      106. digitalWrite(Led10, HIGH);
      107. if (pwm7 > 900 ) // Funktion Kanal 7
      108. digitalWrite(Led11, LOW);
      109. digitalWrite(Led12, LOW);
      110. if (pwm7 > 1200)
      111. digitalWrite(Led11, HIGH);
      112. if (pwm7 > 1700)
      113. digitalWrite(Led12, HIGH);
      114. if (pwm8 > 900 ) // Funktion Kanal 7
      115. digitalWrite(Led11, LOW);
      116. digitalWrite(Led12, LOW);
      117. if (pwm8 > 1200)
      118. digitalWrite(Led11, HIGH);
      119. if (pwm8 > 1700)
      120. digitalWrite(Led12, HIGH);
      121. }
      Alles anzeigen
    • Moin,
      ist Zeile 73 so korrekt? Die unterscheidet sich von den vorherigen.
      Kann es außerdem sein dass bei pwm7 und pwm8 die gleiche Aktion erfolgt?

      Ich bin in C++ nicht sehr bewandert, jedoch würde ich einige der If-Bedingungen mit else koppeln. Dadurch fallen etliche Abfragen weg und der Code läuft schneller.
      In Fahrt: Dulcibella "Paddy", Robbe Double Dragon, Robbe Atlantis "Mistral" ----- In Pflege: die Küken der BrushlessEnte
      Weisheiten des Dekans: "Der Tiefgang sollte generell nicht größer sein als die Seitenhöhe."
      Google-Map Modellgewässer
    • Was Du machst ist prinzipiell nicht falsch, aber extrem inperformant.

      Erst einmal solltest Du alle if-Abfragen, die sich auf einen Kanal beziehen, in if - else if umschreiben. Sonst werden immer alle drei Abfragen durchlaufen (sprich, auch wenn die erste Bedingung schon zutrifft, werden die beiden folgenden auch noch einmal geprüft). Das kostet Zeit.

      Spätestens wenn man mehrere Kanäle liest, macht man die Auswertung von PWM-Signalen über sogenannte Interrupts.
      Grob gesagt ist Deine Methode in etwa so, als ob Du auf Nachrichten von acht Leuten wartest und immer hintereinander zu jeder Person gehst und fragst, ob sie eine Nachricht für Dich hat. Logisch, dass Du (bzw. der Prozessor) keine Zeit mehr für irgendwas ha(s)t. Interrupt wäre dann, dass Du mit allen acht vereinbart hast, dass sie zu Dir kommen, wenn sie etwas für Dich haben.

      Programmiertechnisch ist das etwas komplexer, aber Du kannst einfach eine fertige Bibliothek nehmen, die Dir die Detailarbeit abnimmt, z.B. github.com/xkam1x/Arduino-PWM-Reader

      Hier ist auch noch einmal die Methode beschrieben: benripley.com/diy/arduino/thre…-pwm-signal-with-arduino/


      Auch das Ausgeben von Daten per Serial kostet (im Vergleich) sehr viel Zeit. Gerade bei zeitkritischen Sachen immer nur das Ausgeben, was gerade benötigt wird.

      Du kannst Dir es auch etwas einfacher machen, indem Du im Definitionsbereich des Sketches folgendes notierst:


      #define DEBUG#ifdef DEBUG
      #define DEBUG_PRINT(x) Serial.println (x)
      #else
      #define DEBUG_PRINT(x)
      #endif
      an den Stellen, wo Du etwas ausgeben möchtest schreibst Du an Stelle der Serial.print-Anweisung:

      DEBUG_PRINT(x)x ist das, was Du ausgeben möchtest.

      Wenn Du jetzt oben die erste Zeile #define DEBUG auskommentierts sind alle Prints auf einmal ausgeschaltet.

      Gruß, Kai
    • Buenas tardes de de España.
      Hace un tiempo aquí en el foro ya se publico algo al respecto, es un tema bastante interesante.

      Arduino Nano - Lichtsteuerung

      Un saludo a todos

      Guten Tag aus Spanien.
      Vor einiger Zeit wurde hier im Forum bereits etwas darüber veröffentlicht, es ist ein sehr interessantes Thema.

      Arduino Nano - Lichtsteuerung

      Grüße an alle
    • lab schrieb:



      Programmiertechnisch ist das etwas komplexer, aber Du kannst einfach eine fertige Bibliothek nehmen, die Dir die Detailarbeit abnimmt, z.B. github.com/xkam1x/Arduino-PWM-Reader

      Hier ist auch noch einmal die Methode beschrieben: benripley.com/diy/arduino/thre…-pwm-signal-with-arduino/


      Auch das Ausgeben von Daten per Serial kostet (im Vergleich) sehr viel Zeit. Gerade bei zeitkritischen Sachen immer nur das Ausgeben, was gerade benötigt wird.

      Du kannst Dir es auch etwas einfacher machen, indem Du im Definitionsbereich des Sketches folgendes notierst:


      #define DEBUG#ifdef DEBUG
      #define DEBUG_PRINT(x) Serial.println (x)
      #else
      #define DEBUG_PRINT(x)
      #endif
      an den Stellen, wo Du etwas ausgeben möchtest schreibst Du an Stelle der Serial.print-Anweisung:

      DEBUG_PRINT(x)x ist das, was Du ausgeben möchtest.

      Wenn Du jetzt oben die erste Zeile #define DEBUG auskommentierts sind alle Prints auf einmal ausgeschaltet.

      Gruß, Kai
      Besten dank für deine bemühungen. Ich spüre dass du in der Arduino Materie soweit bist wie ich gerne wäre!
      Ich habe viele Verschiedene PWM sachen getestet, und mein wissen steht gefühlt immer noch recht weit unten.
      Bei der Variante mit dem Arduino PWM Reader kam ich auch nicht weiter. Ich hatte immer die Meldung das die .h Datei fehlt. IM Downloadbereich habe ich diese auch nicht gefunden.
      Wie gesagt nach vielen versuchen habe ich nun diesen Sketch. Leider ist genau wie du es vorhergesagt hast jedoch der Speicher am Anschlag sobald ich weitere Kanäle in die if schreiben möchte.
      Bitte helfe mir da nochmals auf die Sprünge.

      Quellcode

      1. // RC Emfänger auslesen mit Arduino Nano
      2. int Led1 = 9; // Pin 9 steht für Led1 bereit
      3. int Led2 = 10; // Pin 10 steht für Led2 bereit
      4. int Led3 = 11; // Pin 11 steht für Led3 bereit
      5. int Led4 = 12; // Pin 12 steht für Led4 bereit
      6. int Led5 = 13; // Pin 13 steht für Led5 bereit
      7. int Led6 = A0; // Pin A0 steht für Led6 bereit
      8. int Led7 = A1; // Pin A1 steht für Led7 bereit
      9. int Led8 = A2; // Pin A2 steht für Led8 bereit
      10. int Led9 = A3; // Pin A3 steht für Led9 bereit
      11. int Led10 = A4; // Pin A4 steht für Led10 bereit
      12. int Led11 = A5; // Pin A5 steht für Led11 bereit
      13. int Led12 = A6; // Pin A6 steht für Led12 bereit
      14. int Led13 = A7; // Pin A7 steht für Led13 bereit
      15. double channel[7]; // Summe einzulesender PWM Kanäle
      16. void setup() {
      17. pinMode(2, INPUT); // Pin 2 ist ein Eingang für PWM Signal Kanal 1
      18. pinMode(3, INPUT); // Pin 3 ist ein Eingang für PWM Signal Kanal 1
      19. pinMode(4, INPUT); // Pin 4 ist ein Eingang für PWM Signal Kanal 1
      20. pinMode(5, INPUT); // Pin 5 ist ein Eingang für PWM Signal Kanal 1
      21. pinMode(6, INPUT); // Pin 6 ist ein Eingang für PWM Signal Kanal 1
      22. pinMode(7, INPUT); // Pin 7 ist ein Eingang für PWM Signal Kanal 1
      23. pinMode(8, INPUT); // Pin 8 ist ein Eingang für PWM Signal Kanal 1
      24. Serial.begin(115200); // Starte Serieller Monitor mit Baudrate 115200
      25. pinMode(Led1, OUTPUT); // Pin 9 ist ein Ausgang für Led1
      26. pinMode(Led2, OUTPUT); // Pin 10 ist ein Ausgang für Led2
      27. pinMode(Led3, OUTPUT); // Pin 11 ist ein Ausgang für Led3
      28. pinMode(Led4, OUTPUT); // Pin 12 ist ein Ausgang für Led4
      29. pinMode(Led5, OUTPUT); // Pin 13 ist ein Ausgang für Led5
      30. pinMode(Led6, OUTPUT); // Pin A0 ist ein Ausgang für Led6
      31. pinMode(Led7, OUTPUT); // Pin A1 ist ein Ausgang für Led7
      32. pinMode(Led8, OUTPUT); // Pin A2 ist ein Ausgang für Led8
      33. pinMode(Led9, OUTPUT); // Pin A3 ist ein Ausgang für Led9
      34. pinMode(Led10, OUTPUT); // Pin A4 ist ein Ausgang für Led10
      35. pinMode(Led11, OUTPUT); // Pin A5 ist ein Ausgang für Led11
      36. pinMode(Led12, OUTPUT); // Pin A6 ist ein Ausgang für Led12
      37. pinMode(Led13, OUTPUT); // Pin A7 ist ein Ausgang für Led13
      38. }
      39. void loop() {
      40. channel[0] = pulseIn(2, HIGH); // Lese Kanal 1 an D2
      41. channel[1] = pulseIn(3, HIGH); // Lese Kanal 2 an D3
      42. channel[2] = pulseIn(4, HIGH); // Lese Kanal 3 an D4
      43. channel[3] = pulseIn(5, HIGH); // Lese Kanal 4 an D5
      44. channel[4] = pulseIn(6, HIGH); // Lese Kanal 5 an D6
      45. channel[5] = pulseIn(7, HIGH); // Lese Kanal 6 an D7
      46. channel[6] = pulseIn(8, HIGH); // Lese Kanal 7 an D8
      47. Serial.print("K 1 "); // Schreibe Kanalnummer K1
      48. Serial.print(channel[0]); // Schreibe Wert in channel 0
      49. Serial.print(" K 2 "); // Schreibe Kanalnummer K2
      50. Serial.print(channel[1]); // Schreibe Wert in channel 1
      51. Serial.print(" K 3 "); // Schreibe Kanalnummer K3
      52. Serial.print(channel[2]); // Schreibe Wert channel 2
      53. Serial.print(" K 4 "); // Schreibe Kanalnummer K4
      54. Serial.print(channel[3]); // Schreibe Wert in channel 3
      55. Serial.print(" K 5 "); // Schreibe Kanalnummer K5
      56. Serial.print(channel[4]); // Schreibe Wert in channel 4
      57. Serial.print(" K 6 "); // Schreibe Kanalnummer K6
      58. Serial.print(channel[5]); // Schreibe Wert in channel 5
      59. Serial.print(" K 7 "); // Schreibe Kanalnummer K7
      60. Serial.println(channel[6]); // Schreibe Wert in channel 6 und neue schreibe eine neue Linie
      61. // Funktion Kanal 1 (Umschaltung Fahrlicht Positionslicht inkl Zeitverzögerung)
      62. if ( channel[0] >= 1450 && channel[0] <= 1550){ //Funktion Stand
      63. digitalWrite(Led2, LOW);
      64. digitalWrite(Led1, HIGH);
      65. }
      66. else
      67. {
      68. digitalWrite(Led2, HIGH); //Funktion Fahren
      69. digitalWrite(Led1, HIGH);
      70. }
      71. // Funktion Kanal 2 (Beleuchtung Aus/ 1x Ein 2x Ein)
      72. if (channel[1] >= 800 && channel[1] <= 1550){ //Funktion Stellung Aus
      73. digitalWrite(Led3, LOW);
      74. }
      75. if ( channel[1] >= 1450 && channel[1] <= 1550){ //Funktion Stellung Mitte
      76. digitalWrite(Led3, HIGH);
      77. digitalWrite(Led4, LOW);
      78. }
      79. if (channel[1] >= 1550 && channel[1] <= 2000) { //Funktion Stellung Oben
      80. digitalWrite(Led4, HIGH);
      81. }
      82. // Funktion Kanal 3 (Beleuchtung Aus/ 1x Ein 2x Ein)
      83. if (channel[2] >= 800 && channel[2] <= 1550){ //Funktion Stellung Aus
      84. digitalWrite(Led5, LOW);
      85. }
      86. if ( channel[2] >= 1450 && channel[2] <= 1550){ //Funktion Stellung Mitte
      87. digitalWrite(Led5, HIGH);
      88. digitalWrite(Led6, LOW);
      89. }
      90. if (channel[2] >= 1550 && channel[2] <= 2000) { //Funktion Stellung Oben
      91. digitalWrite(Led6, HIGH);
      92. }
      93. }
      Alles anzeigen
    • Hallo Arno,

      gegen Speichermangel kann ich leider auch nichts machen - der Ansatz ist das Problem.

      Vielleicht noch einmal ein Hnweis zu der PWM-Bibliothek. Auf der Github-Seite findest Du einen großen grünen Button "Code". Damit kannst Du die Bibliothek als ZIP herunterladen. Dann gehst Du in die Arduino-IDE und wählst im Menü "Sketch - Bibliothek einbinden - .ZIP Bibliothek hinzufügen" Darüber lädst Du das heruntergeladene ZIP. Dann pastest Du den Code "Solo Example" in den Editor und kompilierst ihn (mit dem "Häkchen-Icon"). Genau das habe ich gerade einmal testweise gemacht und es hat problemlos funktioniert. Das Prinzip der Bibliotheken ist, dass die eigentliche Komplexität nicht in dem sichtbaren Code ist, sondern in der nicht angezeigten .h oder hier .hpp Datei. Die muss aber dafür vorher über den Bibliotheksmanager installiert werden. Viele Bibliotheken kann man direkt über den Manager installieren, aber einige eben auch manuell per ZIP.

      Ich hoffe, das hilft Dir erst einmal einen Schritt weiter. Wenn der Test mit dem einfachen Beispiel geklappt hat, versuchst Du das zweite Beispiel und passt es für Dich an.

      Wenn Du dann noch wie in meinem vorherigen Post die mehrfachen if-Abfragen durch "else if" ersetzt - bzw. die dritte Option dann nur noch mit "if" , sollte es gehen.

      Nur Mut - aller Anfang ist schwer aber das Erfolgserlebnis am Ende lohnt die Mühe :)

      Gruß, Kai
    • Hoi Kai
      In deine Ratschläge habe ich nochmals einige Zeit investiert und sehr viel dazulernen können.

      Wie es der Titel schon sagt bin ich in diesem gebiet eher neuling und versuchte zu verstehen was du meinst.
      Schlussendlich entschied ich mich jedoch für eine variante ohne Lib,weil ich sonst leider zuwenig durchblicken kann.

      Ich musste dafür den Kompromiss eingehen weniger Kanäle einzulesen. Das ist nicht weiter schlimm weil ich sonst fast zu wenig ausgänge hätte.

      Nun habe ich 4 Kanäle und das scheint ganz gut zu funktionieren.
      Der erste unterscheidet sich weil das Fahrlicht automatisch mit dem Gasgeben einschalten soll, und beim ausschalten ca eine Minute gehalten werden soll. Die zeit ist etwas ungenau, für diesen zweck jedoch würde es ausreichen.
      Soll ich den Seriellen Monitor für den definitifen einbau ausschalten?

      Sei so lieb und schaue mir nochmals über den Code. Du bist ein guter Lehrer:)

      Quellcode

      1. // Projekt Modellschiff für zum einlesen von 4 RC Kanälen. A. Wilhelm 18.2.2021
      2. int LedStatus = LOW; // Funktion für Zeitverzögerung Led 2
      3. int Led1 = 9; // Pin 9 steht für Led1 bereit
      4. int Led2 = 10; // Pin 10 steht für Led2 bereit
      5. int Led3 = 11; // Pin 11 steht für Led3 bereit
      6. int Led4 = 12; // Pin 12 steht für Led4 bereit
      7. int Led5 = 13; // Pin 13 steht für Led5 bereit
      8. int Led6 = A0; // Pin A0 steht für Led6 bereit
      9. int Led7 = A1; // Pin A1 steht für Led7 bereit
      10. int Led8 = A2; // Pin A2 steht für Led8 bereit
      11. int Led9 = A3; // Pin A3 steht für Led9 bereit
      12. int Led10 = A4; // Pin A4 steht für Led10 bereit
      13. int Led11 = A5; // Pin A5 steht für Led11 bereit
      14. int Led12 = A6; // Pin A6 steht für Led12 bereit
      15. int Led13 = A7; // Pin A7 steht für Led13 bereit
      16. double channel[4]; // Gesamtsumme einzulesender Kanäle
      17. unsigned long LED_timestore; // Speicher für Systemzeit
      18. void setup() {
      19. pinMode(2, INPUT); // Pin 2 Eingang PWM Kanal 1
      20. pinMode(3, INPUT); // Pin 3 Eingang PWM Kanal 2
      21. pinMode(4, INPUT); // Pin 4 Eingang PWM Kanal 3
      22. pinMode(5, INPUT); // Pin 5 Eingang PWM Kanal 4
      23. Serial.begin(115200); // Starte Serieller Monitor
      24. pinMode(Led1, OUTPUT); // Pin 9 Ausgang Led1
      25. pinMode(Led2, OUTPUT); // Pin 10 Ausgang Led2
      26. pinMode(Led3, OUTPUT); // Pin 11 Ausgang Led3
      27. pinMode(Led4, OUTPUT); // Pin 12 Ausgang Led4
      28. pinMode(Led5, OUTPUT); // Pin 13 Ausgang Led5
      29. pinMode(Led6, OUTPUT); // Pin A0 Ausgang Led6
      30. pinMode(Led7, OUTPUT); // Pin A1 Ausgang Led7
      31. pinMode(Led8, OUTPUT); // Pin A2 Ausgang Led8
      32. pinMode(Led9, OUTPUT); // Pin A3 Ausgang Led9
      33. pinMode(Led10, OUTPUT); // Pin A4 Ausgang Led10
      34. pinMode(Led11, OUTPUT); // Pin A5 Ausgang Led11
      35. pinMode(Led12, OUTPUT); // Pin A6 Ausgang Led12
      36. pinMode(Led13, OUTPUT); // Pin A7 Ausgang Led13
      37. }
      38. void loop() {
      39. channel[0] = pulseIn(2, HIGH); // Lese Kanal 1
      40. channel[1] = pulseIn(3, HIGH); // Lese Kanal 2
      41. channel[2] = pulseIn(4, HIGH); // Lese Kanal 3
      42. channel[3] = pulseIn(5, HIGH); // Lese Kanal 4
      43. Serial.print(" Zeit "); // Schreibe Kanalnummer K1
      44. Serial.print(LED_timestore);
      45. Serial.print(" K 1 "); // Schreibe Kanalnummer K1
      46. Serial.print(channel[0]); // Schreibe Wert in channel 0
      47. Serial.print(" K 2 "); // Schreibe Kanalnummer K2
      48. Serial.print(channel[1]); // Schreibe Wert in channel 1
      49. Serial.print(" K 3 "); // Schreibe Kanalnummer K3
      50. Serial.print(channel[2]); // Schreibe Wert channel 2
      51. Serial.print(" K 4 "); // Schreibe Kanalnummer K4
      52. Serial.println(channel[3]); // Schreibe Wert channel 3 und schreibe neue Linie
      53. // Funktion Zeitverzögerung für Led 2 (Fahrlicht aus wenn Schiff im Hafen)
      54. if (LedStatus == LOW) {
      55. if (millis() - LED_timestore> 90000 ) { // Wartezeit
      56. digitalWrite(Led2, HIGH);
      57. LED_timestore = millis();
      58. LedStatus = HIGH;
      59. }
      60. } else {
      61. if (millis() - LED_timestore> 0) {
      62. digitalWrite(Led2, LOW);
      63. LedStatus = LOW;
      64. }
      65. }
      66. // Funktion Kanal 1 (Beleuchtung Aus/ 1x Ein 2x Ein)
      67. if ( channel[0] >= 1450 && channel[0] <= 1550){ //Funktion Stand
      68. digitalWrite(LedStatus, LOW);
      69. digitalWrite(Led1, HIGH);
      70. }
      71. else
      72. {
      73. digitalWrite(Led2, HIGH); //Funktion Fahren
      74. digitalWrite(Led1, HIGH); //Ist immer auf EIN
      75. }
      76. // Funktion Kanal 2 (Beleuchtung Aus/ 1x Ein 2x Ein)
      77. if (channel[1] >= 800 && channel[1] <= 1550){ //Funktion Stellung Aus
      78. digitalWrite(Led3, LOW);
      79. }
      80. if ( channel[1] >= 1450 && channel[1] <= 1550){ //Funktion Stellung Mitte
      81. digitalWrite(Led3, HIGH);
      82. digitalWrite(Led4, LOW);
      83. }
      84. if (channel[1] >= 1550 && channel[1] <= 2000) { //Funktion Stellung Oben
      85. digitalWrite(Led4, HIGH);
      86. }
      87. // Funktion Kanal 3 (Beleuchtung Aus/ 1x Ein 2x Ein)
      88. if (channel[2] >= 800 && channel[2] <= 1550){ //Funktion Stellung Aus
      89. digitalWrite(Led5, LOW);
      90. }
      91. if ( channel[2] >= 1450 && channel[2] <= 1550){ //Funktion Stellung Mitte
      92. digitalWrite(Led5, HIGH);
      93. digitalWrite(Led6, LOW);
      94. }
      95. if (channel[2] >= 1550 && channel[2] <= 2000) { //Funktion Stellung Oben
      96. digitalWrite(Led6, HIGH);
      97. }
      98. // Funktion Kanal 4 (Beleuchtung Aus/ 1x Ein 2x Ein)
      99. if (channel[3] >= 800 && channel[3] <= 1550){ //Funktion Stellung Aus
      100. digitalWrite(Led7, LOW);
      101. }
      102. if ( channel[3] >= 1450 && channel[3] <= 1550){ //Funktion Stellung Mitte
      103. digitalWrite(Led7, HIGH);
      104. digitalWrite(Led8, LOW);
      105. }
      106. if (channel[3] >= 1550 && channel[3] <= 2000) { //Funktion Stellung Oben
      107. digitalWrite(Led8, HIGH);
      108. }
      109. }
      Alles anzeigen
    • @Arnowomo Hasst du dir mal die Referenz zu pulseIn angeschaut? Das steht folgendes:

      Beschreibung
      Liest einen Wert von einem vorgegebenen Digitalpin ein, entweder HIGH oder LOW. Wenn value z.B. HIGH ist,wartet pulseIn() darauf,dass der Pin auf den Wert HIGH wechselt, startet einen Timer und wartet anschließend darauf,dass der Pin wieder auf LOW wechselt. Daraufhin stoppt pulseIn() den Timer. Gibt die Länge des Impulses in Mikrosekunden zurück.Stoppt und gibt 0 zurück, wenn ein bestimmter Timeout erreicht wird.
      Das Timing der Funktion wurde empirisch getestet und wird vermutlich bei einem längeren Impuls falsch messen. Die Funktion funktioniert mit Impulsen der Länge von 10 Mikrosekunden bis 3 Minuten.

      Mit anderen Worten, die Funktion wirkt blockierend auf deinen Programmablauf. Ich würde hier zumindest einen Timout Wert angeben (der ist optional). Schau dazu hier.


      ich bin dein Programm nur kurz durchgegangen. Grobe Schnitzer habe ich aber keine gefunden. Was ich aber änderen würde ist das hier:

      C-Quellcode

      1. double channel[4]; // Gesamtsumme einzulesender Kanäle
      Es ist hier unnötig einen double Datentyp (floating point) zu gebrauchen. Der return Wert von pulseIn ist "nur" unsigned int. Und weiter ist es aus meiner Sicht auch nicht nötig, dass du einen Array brauchst denn einen indexierten Zugriff habe ich im Code nämlich nicht gesehen.


      Und noch ein letzter Tip. Gewöhne dir an den Code so zu schreiben, dass er wie ein normaler Text lesbar ist. Konkret heisst das, wenn Variablen und Funktionen aussagekräftige Namen haben, braucht es meist keinen Kommentar mehr im Code weil er selbsterklärend ist. Im Schnitt wird 90% der Zeit in der der Quellcode bearbeitet wird Code gelesen und nicht geschrieben. :kaf2: Meine Erfahrung aus der Praxis hat gezeigt, dass über die Lebensdauer von Code die Kommentare immer weniger zutreffen, da nicht nur Code sondern auch der Kommentar angepasst werden muss. Also doppelte Arbeit.

      Viel Erfolg und Spass bei deinem Projekt!

      Gruss Mathias
    • Hallo Arno,

      hm - hast Du den Sketch schon getestet? Die Zeitverzögerung kann mMn. so nicht funktionieren.

      Einmal verwendest Du:

      C-Quellcode

      1. digitalWrite(LedStatus, LOW);

      und willst eigentlich der Variable den Wert LOW ("0") zuweisen.
      Das würde man einfach so schreiben:

      C-Quellcode

      1. LedStatus = LOW;
      Außerden setzt Du in Z. 73 die LED auf HIGH - wolltest Du sie nicht ausschalten?

      Die if-Schleifen überlappen sich - das funktioniert zwar, ist aber verwirrend und auch nicht performant.
      Du könntest so etwas schreiben:

      C-Quellcode

      1. // Funktion Kanal 2 (Beleuchtung Aus/ 1x Ein 2x Ein)
      2. if (channel[1] >= 800 && channel[1] < 1450){ //Funktion Stellung Aus
      3. digitalWrite(Led3, LOW);
      4. }
      5. else if ( channel[1] >= 1450 && channel[1] <= 1550){ //Funktion Stellung Mitte
      6. digitalWrite(Led3, HIGH);
      7. digitalWrite(Led4, LOW);
      8. }
      Das Ziel ist es, dass die LEDs leuchten, wenn der Knüppel auf "Mitte" steht?

      Dann weiterhin viel Spaß und Lernerfolg, Kai
    • Hoi Kay
      1. Ja den Code habe ich getestet. Bis auf die Zeitungenauikeit funktioniert der auch gut.

      • 83 Funktion Kanal 1 (Beleuchtung Aus/ 1x Ein 2x Ein)
      • 84 if ( channel[0] >= 1450 && channel[0] <= 1550){ //Funktion Stand
      • 85 digitalWrite(LedStatus, LOW);
      • 86 digitalWrite(Led1, HIGH);


      Erklärung:
      Das ist der Block der Gas Knüppelstellung Mitte (84) . Hier wird nur der Led Status auf Low gesetzt. Nicht das Led2 selber.
      Detail:
      Ist die Knüppelstellung nicht in der mitte wird Led2 direkt via "else" "Zeile 90" Eingeschaltet.

      Damit das ausschalten zeitverzögert wird wähle ich nun beim ausschalten die LedStatus funktion. die nach einer bestimmten Zeit das Led2 ausschaltet.

      Die Fahrbeleuchtung soll ja nicht bei jedem kleinen "Gas Stellung mite" gleich aus gehen.

      Gruss Arno
    • Solche Fragen sind schon gut. Genau damit lerne ich weiter. Ich meinte das digitalWrite(LedStatus, LOW); Als Start Befehl gebraucht wird.
      Werde alles oben beschriebene dieses Wochenende nochmals genau hinterfragen. Danke für deine Hilfe, dank Dir bin ich nun ein kleines Stück weiter.

      Privat:
      Ich kann keine Fremdsprachen! Und meine Fähikeit auswendig zu lernen hält sich auch in grenzen. Daher ist das vorhaben für mich eine sehr grosse Herausforderung.

      Was man aber mit Arduino alles machen kann ist so reizvoll dass ich bereit bin diesen Weg zu gehen. Sei mir also nicht böse wenn ich plötzlich wieder einen Anfänger Fehler einbaue:)