Steuerung von vier Motoren mit Arduino Uno Board

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

    • Steuerung von vier Motoren mit Arduino Uno Board

      So, liebe Gemeinde.
      Da sich mein geplantes Projekt (siehe Überschrift) sich doch etwas von der Lichtersteuerung mittles Arduino in diesem Tread abhebt, werd ich das hier fortführen.
      Da ich auf die Bastelei der Mechaniken um die Geschütztürme meiner Bismarck zu bewegen, ehrlich gesagt, keine Lust habe, hab ich mich mit einem Arduino Nano beschäftigt und den Möglichkeiten die er bietet.
      Inzwischen bin ich, was die Programmierung betrifft, schon etwas weiter und hab inzwischen einen (mehr oder weniger) funktionierenden Sketch zusammengebastelt. Darüber lässt sich bisher über vier 3-Stufen-Taster (An-Aus-An) meiner Fernsteuerung insgesammt acht Ausgänge (jeweils zwei als entweder/oder)des Nano schalten. Die Taster hab ich genommen, da ich ja Schrittmotore ansteuern möchte.
      Der Sketch dazu sieht so aus:

      Spoiler anzeigen

      Quellcode

      1. //Variablen
      2. //RC-bezogen
      3. int cnt_CH_1 = 0; //Zähler Channel 1 für Interruptroutine
      4. int frqraw_CH_1 = 0; //Ãœbergabewert Channel 1 aus Interruptroutine
      5. int cnt_CH_2 = 0; //Zähler Channel 2 für Interruptroutine
      6. int frqraw_CH_2 = 0; //Ãœbergabewert Channel 2 aus Interruptroutine
      7. int cnt_CH_3 = 0; //Zähler Channel 3 für Interruptroutine
      8. int frqraw_CH_3 = 0; //Ãœbergabewert Channel 3 aus Interruptroutine
      9. int cnt_CH_4 = 0; //Zähler Channel 4 für Interruptroutine
      10. int frqraw_CH_4 = 0; //Ãœbergabewert Channel 4 aus Interruptroutine
      11. int Relais_1 = 6;
      12. int Relais_2 = 7;
      13. int Relais_3 = 8;
      14. int Relais_4 = 9;
      15. int Relais_5 = 10;
      16. int Relais_6 = 11;
      17. int Relais_7 = A0;
      18. int Relais_8 = A1;
      19. //Programmbezogen
      20. const int deadzone = 10;
      21. const int hlevel = 174; //höchste gelieferte Frequenz
      22. const int llevel = 115; //niedrigste gelieferte Frequenz
      23. const int glevel = 310; //Grenzlevel für Ergebnis
      24. void setup() {
      25. // Controller pins
      26. pinMode(A0, OUTPUT);
      27. pinMode(A1, OUTPUT);
      28. DDRD = 0b11000011; //Setzt D2-D5 als Eingang 0 und die restlichen als Ausgang 1
      29. cli(); // Clear interrupts Interrupts ausschalten
      30. // Register zurücksetzen
      31. TCCR1A = 0;
      32. TCCR1B = 0;
      33. TCNT1 = 0;
      34. OCR1A = 20; //Output Compare Register auf Vergleichswert setzen, war 20
      35. TCCR1B |= (1 << CS11); //Prescale 8
      36. // 16MHz/8=2MHz mit OCR1A=20 Interrupt alle 10µs
      37. TCCR1B |= (1 << WGM12); //CTC-Mode einschalten
      38. TIMSK1 |= (1 << OCIE1A); //Timer Compare Interrupt setzen
      39. sei(); // Set Interrupts Interrupts einschalten
      40. Serial.begin(9600); //serielle Verbindung etablieren
      41. }
      42. ISR(TIMER1_COMPA_vect) { //die Interruptroutine gibt ein Zehntel der Impulsbreite in µs zurück
      43. if (PIND & (1<<PD2)) { //Channel 1 rechts horizontal, das ist PIN D2
      44. cnt_CH_1++; //wenn Eingang High dann Zähler inkrementieren
      45. }
      46. else if (cnt_CH_1) { //wenn Eingang Low dann prüfen ob Zähler gestartet
      47. frqraw_CH_1 = cnt_CH_1 - 1; //wenn Zähler gestartet, stoppen und Wert übergeben
      48. cnt_CH_1 = 0; //Zähler zurücksetzen
      49. }
      50. if (PIND & (1<<PD3)) { //Channel 2 rechts vertikal, das ist PIN D3
      51. cnt_CH_2++; //wenn Eingang High dann Zähler inkrementieren
      52. }
      53. else if (cnt_CH_2) { //wenn Eingang Low dann prüfen ob Zähler gestartet
      54. frqraw_CH_2 = cnt_CH_2 - 1; //wenn Zähler gestartet, stoppen und Wert übergeben
      55. cnt_CH_2 = 0; //Zähler zurücksetzen
      56. }
      57. if (PIND & (1<<PD4)) { //Channel 3 links vertikal, das ist PIN D4
      58. cnt_CH_3++; //wenn Eingang High dann Zähler inkrementieren
      59. }
      60. else if (cnt_CH_3) { //wenn Eingang Low dann prüfen ob Zähler gestartet
      61. frqraw_CH_3 = cnt_CH_3 - 1; //wenn Zähler gestartet, stoppen und Wert übergeben
      62. cnt_CH_3 = 0; //Zähler zurücksetzen
      63. }
      64. if (PIND & (1<<PD5)) { //Channel 4 links horizontal , das ist PIN D5
      65. cnt_CH_4++; //wenn Eingang High dann Zähler inkrementieren
      66. }
      67. else if (cnt_CH_4) { //wenn Eingang Low dann prüfen ob Zähler gestartet
      68. frqraw_CH_4 = cnt_CH_4 - 1; //wenn Zähler gestartet, stoppen und Wert übergeben
      69. cnt_CH_4 = 0; //Zähler zurücksetzen
      70. }
      71. }
      72. void loop() {
      73. Serial.println(frqraw_CH_1); //Wert für Kanal 1 an Console senden
      74. Serial.println(frqraw_CH_2); //Wert für Kanal 2 an Console senden
      75. Serial.println(frqraw_CH_3); //Wert für Kanal 3 an Console senden
      76. Serial.println(frqraw_CH_4); //Wert für Kanal 4 an Console senden
      77. Serial.println(" ");
      78. Serial.println(" ");
      79. delayMicroseconds(16000); // Damit man überhaupt etwas sieht
      80. if (frqraw_CH_1 > 180)
      81. {
      82. digitalWrite(Relais_1, HIGH);
      83. digitalWrite(Relais_2, LOW);
      84. }
      85. else if (frqraw_CH_1 < 120)
      86. {
      87. digitalWrite(Relais_1, LOW);
      88. digitalWrite(Relais_2, HIGH);
      89. }
      90. else
      91. {
      92. digitalWrite(Relais_1, LOW);
      93. digitalWrite(Relais_2, LOW);
      94. }
      95. if (frqraw_CH_2 > 180)
      96. {
      97. digitalWrite(Relais_3, HIGH);
      98. digitalWrite(Relais_4, LOW);
      99. }
      100. else if (frqraw_CH_2 < 120)
      101. {
      102. digitalWrite(Relais_3, LOW);
      103. digitalWrite(Relais_4, HIGH);
      104. }
      105. else
      106. {
      107. digitalWrite(Relais_3, LOW);
      108. digitalWrite(Relais_4, LOW);
      109. }
      110. if (frqraw_CH_3 > 180)
      111. {
      112. digitalWrite(Relais_5, HIGH);
      113. digitalWrite(Relais_6, LOW);
      114. }
      115. else if (frqraw_CH_3 < 120)
      116. {
      117. digitalWrite(Relais_5, LOW);
      118. digitalWrite(Relais_6, HIGH);
      119. }
      120. else
      121. {
      122. digitalWrite(Relais_5, LOW);
      123. digitalWrite(Relais_6, LOW);
      124. }
      125. if (frqraw_CH_4 > 180)
      126. {
      127. digitalWrite(Relais_7, HIGH);
      128. digitalWrite(Relais_8, LOW);
      129. }
      130. else if (frqraw_CH_4 < 120)
      131. {
      132. digitalWrite(Relais_7, LOW);
      133. digitalWrite(Relais_8, HIGH);
      134. }
      135. else
      136. {
      137. digitalWrite(Relais_7, LOW);
      138. digitalWrite(Relais_8, LOW);
      139. }
      140. }
      Alles anzeigen

      In Arbeit: "Bismarck" in 1:200
      Geplant:
      " Prinz Eugen"
      "Admiral Graf Spee"
    • Allerdings möchte ich die Schrittmotore über ein Arduino Uno zzgl. Motor Shield steuern, daher hab ich einen weiteren Sketch angefangen, der allerdings bisher noch nicht fertig und mangels Hardware auch noch nicht getestet ist.

      Spoiler anzeigen

      Quellcode
      Quellcode bearbeiten
      1. #include <Wire.h>
      2. #include <Adafruit_MotorShield.h>
      3. Adafruit_MotorShield AFMS1 = Adafruit_MotorShield(0x60);
      4. Adafruit_MotorShield AFMS2 = Adafruit_MotorShield(0x61);
      5. Adafruit_StepperMotor *myMotor1 = AFMS1.getStepper(200, 1);
      6. Adafruit_StepperMotor *myMotor2 = AFMS1.getStepper(200, 2);
      7. Adafruit_StepperMotor *myMotor3 = AFMS2.getStepper(200, 1);
      8. Adafruit_StepperMotor *myMotor4 = AFMS2.getStepper(200, 2);
      9. //Variablen
      10. //RC-bezogen
      11. int cnt_CH_1 = 0; //Zähler Channel 1 für Interruptroutine
      12. int frqraw_CH_1 = 0; //Ãœbergabewert Channel 1 aus Interruptroutine
      13. int cnt_CH_2 = 0; //Zähler Channel 2 für Interruptroutine
      14. int frqraw_CH_2 = 0; //Ãœbergabewert Channel 2 aus Interruptroutine
      15. int cnt_CH_3 = 0; //Zähler Channel 3 für Interruptroutine
      16. int frqraw_CH_3 = 0; //Ãœbergabewert Channel 3 aus Interruptroutine
      17. int cnt_CH_4 = 0; //Zähler Channel 4 für Interruptroutine
      18. int frqraw_CH_4 = 0; //Ãœbergabewert Channel 4 aus Interruptroutine
      19. int Relais_1 = 6;
      20. int Relais_2 = 7;
      21. int Relais_3 = 8;
      22. int Relais_4 = 9;
      23. int Relais_5 = 10;
      24. int Relais_6 = 11;
      25. int Relais_7 = A0;
      26. int Relais_8 = A1;
      27. //Programmbezogen
      28. const int deadzone = 10;
      29. const int hlevel = 174; //höchste gelieferte Frequenz
      30. const int llevel = 115; //niedrigste gelieferte Frequenz
      31. const int glevel = 310; //Grenzlevel für Ergebnis
      32. void setup() {
      33. // Controller pins
      34. Serial.begin(9600); // set up Serial library at 9600 bps
      35. Serial.println("Stepper test!");
      36. AFMS1.begin();
      37. AFMS2.begin();
      38. // create with the default frequency 1.6KHz
      39. //AFMS.begin(1000); // OR with a different frequency, say 1KHz
      40. myMotor1->setSpeed(10); // 10 rpm
      41. myMotor2->setSpeed(10); // 10 rpm
      42. myMotor3->setSpeed(10); // 10 rpm
      43. myMotor4->setSpeed(10); // 10 rpm
      44. DDRD = 0b11000011; //Setzt D2-D5 als Eingang 0 und die restlichen als Ausgang 1
      45. cli(); // Clear interrupts Interrupts ausschalten
      46. // Register zurücksetzen
      47. TCCR1A = 0;
      48. TCCR1B = 0;
      49. TCNT1 = 0;
      50. OCR1A = 20; //Output Compare Register auf Vergleichswert setzen, war 20
      51. TCCR1B |= (1 << CS11); //Prescale 8
      52. // 16MHz/8=2MHz mit OCR1A=20 Interrupt alle 10µs
      53. TCCR1B |= (1 << WGM12); //CTC-Mode einschalten
      54. TIMSK1 |= (1 << OCIE1A); //Timer Compare Interrupt setzen
      55. sei(); // Set Interrupts Interrupts einschalten
      56. }
      57. ISR(TIMER1_COMPA_vect) { //die Interruptroutine gibt ein Zehntel der Impulsbreite in µs zurück
      58. if (PIND & (1<<PD2)) { //Channel 1 rechts horizontal, das ist PIN D2
      59. cnt_CH_1++; //wenn Eingang High dann Zähler inkrementieren
      60. }
      61. else if (cnt_CH_1) { //wenn Eingang Low dann prüfen ob Zähler gestartet
      62. frqraw_CH_1 = cnt_CH_1 - 1; //wenn Zähler gestartet, stoppen und Wert übergeben
      63. cnt_CH_1 = 0; //Zähler zurücksetzen
      64. }
      65. if (PIND & (1<<PD3)) { //Channel 2 rechts vertikal, das ist PIN D3
      66. cnt_CH_2++; //wenn Eingang High dann Zähler inkrementieren
      67. }
      68. else if (cnt_CH_2) { //wenn Eingang Low dann prüfen ob Zähler gestartet
      69. frqraw_CH_2 = cnt_CH_2 - 1; //wenn Zähler gestartet, stoppen und Wert übergeben
      70. cnt_CH_2 = 0; //Zähler zurücksetzen
      71. }
      72. if (PIND & (1<<PD4)) { //Channel 3 links vertikal, das ist PIN D4
      73. cnt_CH_3++; //wenn Eingang High dann Zähler inkrementieren
      74. }
      75. else if (cnt_CH_3) { //wenn Eingang Low dann prüfen ob Zähler gestartet
      76. frqraw_CH_3 = cnt_CH_3 - 1; //wenn Zähler gestartet, stoppen und Wert übergeben
      77. cnt_CH_3 = 0; //Zähler zurücksetzen
      78. }
      79. if (PIND & (1<<PD5)) { //Channel 4 links horizontal , das ist PIN D5
      80. cnt_CH_4++; //wenn Eingang High dann Zähler inkrementieren
      81. }
      82. else if (cnt_CH_4) { //wenn Eingang Low dann prüfen ob Zähler gestartet
      83. frqraw_CH_4 = cnt_CH_4 - 1; //wenn Zähler gestartet, stoppen und Wert übergeben
      84. cnt_CH_4 = 0; //Zähler zurücksetzen
      85. }
      86. }
      87. void loop() {
      88. if (frqraw_CH_1 > 180)
      89. {
      90. myMotor1->step(1, FORWARD, MICROSTEP);
      91. }
      92. else if (frqraw_CH_1 < 120)
      93. {
      94. myMotor1->step(1, BACKWARD, MICROSTEP);
      95. }
      96. if (frqraw_CH_2 > 180)
      97. {
      98. myMotor2->step(1, FORWARD, MICROSTEP);
      99. }
      100. else if (frqraw_CH_2 < 120)
      101. {
      102. myMotor2->step(1, BACKWARD, MICROSTEP);
      103. }
      104. if (frqraw_CH_3 > 180)
      105. {
      106. myMotor3->step(1, FORWARD, MICROSTEP);
      107. }
      108. else if (frqraw_CH_3 < 120)
      109. {
      110. myMotor3->step(1, BACKWARD, MICROSTEP);
      111. }
      112. if (frqraw_CH_4 > 180)
      113. {
      114. myMotor4->step(1, FORWARD, MICROSTEP);
      115. }
      116. else if (frqraw_CH_4 < 120)
      117. {
      118. myMotor4->step(1, BACKWARD, MICROSTEP);
      119. }
      120. }




      Da die Geschütztürme ja keine 360° fahren, muss ich also den Weg begrenzen, nur wie? Darüber hab ich bisher noch nicht viel gefunden. Möglich wären natürlich Endlagenschalter, eleganter würde ich aber eine Softwarelösung finden.
      Hat da jemand eine Idee wie sich das machen lässt?
      In Arbeit: "Bismarck" in 1:200
      Geplant:
      " Prinz Eugen"
      "Admiral Graf Spee"
    • Ein Endlagenschalter wirst du definitiv brauchen um den Startpunkt zu haben. den sobald die Schrittmotoren keinen Strom mehr haben kann man sie einfach drehen. Die zweite Begrenzung kannst du in der Software machen indem du die Schritte zählst und ab einen bestimmten wert Stops. Normal haben Schrittmotoren 200 Schritte pro Umdrehung bei Vollschritt (1.8 Grad pro Schritt) und 400 bei Halbschritt (0.9 Grad pro Schritt).

      Eine andere Möglichkeit wäre die Position mit einem Poti zu bestimmen, dann würde sogar ein normaler Getriebemotor reichen.

      Aber mal eine andere frage, warum nimmst du kein 270° oder 360° Servo?

      Und welche Motortreiber / Schrittmotortreiber verwendest du, hoffentlich keine L298.
    • Leider nein. Da der Mikrocontroller am Anfang ja nicht weiß ob er links oder rechts vom schalter ist. Deswegen muss der Taster entweder ganz nach links oder rechts. Dann fährt der Arduino den Motor einfach solange in die Richtung des Schalter bis er angekommen ist. Nun weiß er welche Position der Turm hat. Danach kann man die Türme ja automatisch in Mittelstellung fahren lassen und dann mit den Schaltern nach links oder rechts drehen. Solange die Motoren keine schritte verlieren weiß der Controller immer genau wie die Türme stehen.

      Hast du mal den genauen Namen oder Link zu dem Motor shield, den es ist wichtig das es richtige Schrittmotortreiber sind mit einstellbarer Strombegrenzung. Den sonst werden die Motoren nie sauber laufen, viel Strom verbrauchen und schön warm werden.
    • Es tut mir leid das zu sagen aber das sieht nicht gut aus.
      Der Chip auf dem bord ist nur eine Endstufe. Um den Schrittmotor zum "sauberen" laufen zu bringen müsste man den Strom der einzelnen halb-H-Brücken messen. Das würde theoretisch mit zusätzlichen Sens Wiederständern und PWM vom Arduino gehen aber dadurch das die beiden Treiber über einen I2C Port erweiteter angeschlossen ist geht das leider nicht. Zum testen mit niedriger Spannung (sonst raucht der Motor oder der Treiber durch den zu hohen Strom ab) würde das noch gehen. Die einfachste Lösung wären Motortreiber die Für Schrittmotoren Ansteuerung gedacht sind zu verwenden. Zum beispiel die DRV8825 aus den 3D Druckern, die gibst auch sehr günstig ca. 1,5€ pro stück. Man muss nur aufpassen das man die durch ESD (Statische Aufladung) nicht gleich zerschießt. Also lieber ein paar mehr bestellen. Über das Poti wird der maximal Strom eingestellt. Angesteuert werden die über Enable, Stepp und Direction. Mit Enable wird der Chip eingeschaltet. Mit einem Puls auf Stepp macht der Schrittmotor genau einen schritt. Über Direction sagt man in in welche Richtung er sich drehen soll zb. 1 = Links 0 = Rechst. Als Mirostep würde ich 1/16 oder 1/32 nehmen damit der Motor schön ruhig läuft ( bei 1/32 wären das 6400 Schritte pro Umdrehung).
    • Na du machst mir ja Spaß. Ein Motor Shield für Schrittmotore, an die man keine Schrittmotore anschließen kann, weil sonst das eine oder andere abraucht. Was für eine Farce
      Mal gucken, so teuer sind die Shields ja nicht. Entweder sie halten, oder sie halten nicht. Also immer schön die Temperaturen im Auge behalten.
      In Arbeit: "Bismarck" in 1:200
      Geplant:
      " Prinz Eugen"
      "Admiral Graf Spee"
    • Die Chinesen Schreiben halt viel drauf was quatsch ist. Man kann damit natürlich Schrittmotoren betreiben, aber halt nicht richtig. Im datenblatt des Treibers wird nicht einmal das Word Schrittmotor verwendet. Beim L298 schreiben die auch rein für Schrittmotoren aber wen man mal im Datenblatt nachschaut werkt man das der L298 das alleine gar nicht richtig kann (ist genau das gleiche wie bei dir) sonder nur in Verbindung mit dem L297 der dan über 2 Sense Widerstände den Strom mist und die Endstufe L298 dementsprechend steuert. Und dann gibst auch ICs die beides in einem haben, die Endstufe und den Controller. Einen richtigen Schrittmotortreiber erkennt man daran das der über Step un Dir angesteuert wird.

      Und wen man im Datenblatt von deinem IC weiter unten schaut sieht man, das der Treiber ohne Kühlung maximal 0.9A Dauerstrom macht.
    • Klassische Stepper-Treiber sind der A4988 (howtomechatronics.com/tutorial…a4988-driver-and-arduino/) oder DRV8825 (pololu.com/product/2133).

      Es gibt auch diese sehr billigen Stepper mit Getriebe und Treiberboard (bastelgarage.ch/schrittmotor-set-mit-motor-und-treiber). Durch das Getriebe bewegen die sich auch nicht so ohne weiteres von selbst. Damit könntest Du auf Endlagenschalter verzichten und einfach davon ausgehen, dass beim Einschalten die Geschütze in Neutralposition sind. Falls das einmal nicht stimmt, kannst Du die Geschütze auf Neutral drehen und dann einmal aus- und wieder einschalten. Die werden mit oder ohne eigene Treiberplatine angeboten und können auch mit den o.g. Treiberbausteinen kombiniert werden.

      Für vier Steppertreiber gibt es diese Boards: ebay.de/itm/3D-Printer-CNC-Shi…o-compatible/272676119211 oder als Variante mit drei Stepperreibern und einem Platz für einen Arduino Nano.

      Die billigen Steppertreiber sind manchmal recht laut - es gibt auch noch eine leisere Variante unter der Bezeichnung "Silent Stepstick" die allerdings etwas teurer sind.
    • Ich hab inzwischen etwas weiter gemacht. Als Endlagenschalter hab ich zu Hall-Sensoren gegriffen, da prellfrei. Da mir bisher immernoch die Hardware fehlt, hab ich mit meinem Nano etwas experimentiert um die Hall-Sensoren einzubinden. Dafür hab ich den Sketch von Mr. Medium aus diesem Tread benutzt und ihn etwas angepasst.
      Unter anderem werden über vier RC-Taster insgesammt acht Ausgänge geschaltet, wovon jeweils vier ein Hallsensor als Startpunkt haben.
      Da ich zur Visuallisierung insgesammt 8 LED's am Nano hatte, fehlten mir die digitalen Eingänge für alle vier Hall-Sensoren, daher sind im Skatch nur zwei Sensoren vorhanden, lassen sich aber recht einfach weitere einbinden.
      Hier mal das Programm.

      Spoiler anzeigen

      C-Quellcode

      1. /*** 4 Kanal ***
      2. *** RC Lichtsteuerung ***
      3. *** by Mr.Medium ***
      4. *** edit by Scouter */
      5. int Eingang1 = 2; //Empfängerkanal 1
      6. int Eingang2 = 3; //Empfängerkanal 2
      7. int Eingang3 = 4; //Empfängerkanal 3
      8. int Eingang4 = 5; //Empfängerkanal 4
      9. int Ausgang1 = 6; //Relais 1
      10. int Ausgang2 = 7; //Relais 2
      11. int Ausgang3 = 8; //Relais 3
      12. int Ausgang4 = 9; //Relais 4
      13. int Ausgang5 = A3; //Relais 5
      14. int Ausgang6 = A0; //Relais 6
      15. int Ausgang7 = A1; //Relais 7
      16. int Ausgang8 = A2; //Relais 8
      17. int Eingang5 = 10; //Hallsensor1
      18. int Eingang6 = 11; //Hallsensor2
      19. int Status1; //Hallsensor1 Status
      20. int Status2; //Hallsensor2 Status
      21. unsigned long duration1; //Pulslänge 1
      22. unsigned long duration2; //Pulslänge 2
      23. unsigned long duration3; //Pulslänge 3
      24. unsigned long duration4; //Pulslänge 4
      25. void setup(){
      26. pinMode(Eingang1,INPUT);
      27. pinMode(Eingang2,INPUT);
      28. pinMode(Eingang3,INPUT);
      29. pinMode(Eingang4,INPUT);
      30. pinMode(Eingang5,INPUT);
      31. pinMode(Eingang6,INPUT);
      32. pinMode(Ausgang1,OUTPUT);
      33. pinMode(Ausgang2,OUTPUT);
      34. pinMode(Ausgang3,OUTPUT);
      35. pinMode(Ausgang4,OUTPUT);
      36. pinMode(Ausgang5,OUTPUT);
      37. pinMode(Ausgang6,OUTPUT);
      38. pinMode(Ausgang7,OUTPUT);
      39. pinMode(A0,OUTPUT);
      40. pinMode(A1,OUTPUT);
      41. pinMode(A2,OUTPUT);
      42. pinMode(A3,OUTPUT);
      43. }
      44. void loop(){
      45. Ueberwachen_Eingang1();
      46. }
      47. void Ueberwachen_Eingang1()
      48. {
      49. duration1 = pulseIn(Eingang1,HIGH);
      50. Status1 = digitalRead(Eingang5);
      51. if(duration1>1700)
      52. digitalWrite(Ausgang1,HIGH);
      53. if((duration1<1700)&&(duration1>1200)||(Status1 == LOW))
      54. digitalWrite(Ausgang1,LOW);
      55. if(duration1<1300)
      56. digitalWrite(Ausgang2,HIGH);
      57. if((duration1>1200)&&(duration1<1700))
      58. digitalWrite(Ausgang2,LOW);
      59. Ueberwachen_Eingang2();
      60. }
      61. void Ueberwachen_Eingang2()
      62. {
      63. duration2 = pulseIn(Eingang2,HIGH);
      64. Status2 = digitalRead(Eingang6);
      65. if(duration2>1700)
      66. digitalWrite(Ausgang3,HIGH);
      67. if((duration2<1700)&&(duration1>1200)||(Status2 == LOW))
      68. digitalWrite(Ausgang3,LOW);
      69. if(duration2<1300)
      70. digitalWrite(Ausgang4,HIGH);
      71. if((duration2>1200)&&(duration1<1700))
      72. digitalWrite(Ausgang4,LOW);
      73. Ueberwachen_Eingang3();
      74. }
      75. void Ueberwachen_Eingang3()
      76. {
      77. duration3 = pulseIn(Eingang3,HIGH);
      78. if(duration3>1800)
      79. digitalWrite(Ausgang5,HIGH);
      80. if((duration3<1700)&&(duration3>1200))
      81. digitalWrite(Ausgang5,LOW);
      82. if(duration3<1200)
      83. digitalWrite(Ausgang6,HIGH);
      84. if((duration3>1200)&&(duration3<1700))
      85. digitalWrite(Ausgang6,LOW);
      86. Ueberwachen_Eingang4();
      87. }
      88. void Ueberwachen_Eingang4()
      89. {
      90. duration4 = pulseIn(Eingang4,HIGH);
      91. if(duration4>1800)
      92. digitalWrite(Ausgang7,HIGH);
      93. if((duration4<1700)&&(duration4>1200))
      94. digitalWrite(Ausgang7,LOW);
      95. if(duration4<1200)
      96. digitalWrite(Ausgang8,HIGH);
      97. if((duration4>1200)&&(duration4<1700))
      98. digitalWrite(Ausgang8,LOW);
      99. }
      Alles anzeigen

      Wer noch weitere Ideen hat, immer her damit.
      In Arbeit: "Bismarck" in 1:200
      Geplant:
      " Prinz Eugen"
      "Admiral Graf Spee"
    • Wenn Dir die IO-Ports ausgehen, gibt es digitale Expander, die zusätzliche Eingänge/Ausgänge zur Verfügung stellen. Das sind Bausteine, die z.B. acht eigene Ein/Ausgänge haben und deren Werte dann per I2C-Schnittstelle (benötigt zwei Pins) an den Arduino senden. Und da I2C ein Bussystem ist, kannst Du davon mehrere einsetzen ohne am Arduinoe mehr Pins zu benötigen.

      Hier findest Du mehr Infos und Beispiele:
      Gruß, Kai
    • Hallo Ralph,
      habe gerade deinen thread gefunden. Ich hatte einen ähnlichen thread zum Ansteuern eine Brasswinde mit Schrittmotor über Arduino gestartet, daher werde ich auf jeden Fall weiterverfolgen wie du das Thema insbesondere mit den Hall Sensoren in den Griff bekommst.
      Unterschied wird nur sein das die Türme naturgemäss nicht 360° drehen und meine Winde nach meiner Berechnung einen Drehbereich von etwa 15x360° schaffen soll.
      Gruß
      Gerald
      AUF DER WERFT
      2-Mast Schoner Emma C. Berry (Restaurierung)
      4-Mast Bark Archibald Russell (Restaurierung)
      IM HAFEN

      Micro Magic Carbon Edition
      IN PLANUNG
      Brigg Tre Kronor af Stockholm (1:25 Neubau)
      Y-857 (ex FL6) (Restaurierung)
      Bugsier 3 (Restaurierung)