Arduino Steuerung für die Hellenic Spirit (Rettungsboot Hebekran)

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

    • Buenas noches.
      Y tenga cuidado también con la potencia de los motores, lo mas normal es que no los pueda controlar y alimentar directamente con Arduino, tendrá que poner algo entre Arduino y el motor, como un ESC UBEC, o un controlador de motores pololu l298n ( dronebotworkshop.com/dc-motors-l298n-h-bridge/ ), o un sombrero controlador de motores, ( store.arduino.cc/arduino-motor-shield-rev3 )
      ya que arduino no tendrá potencia suficiente para mover y controlar los motores
      Un saludo desde España

      Gute Nacht.
      Und seien Sie auch mit der Leistung der Motoren vorsichtig, das Normalste ist, dass Sie nicht direkt mit Arduino steuern und speisen können, Sie müssen etwas zwischen Arduino und dem Motor setzen, als ESC UBEC, oder eine Motorsteuerung pololu l298n ( dronebotworkshop.com/dc-motors-l298n-h-bridge/), oder eine Hutmotorsteuerung, ( store.arduino.cc/arduino-motor-shield-rev3).
      da Arduino nicht genug Energie hat, um die Motoren zu bewegen und zu steuern.
      Grüße aus Spanien
    • Hier nun mit leichter (hust) Verspätung das erste Programm.

      Das Programm ist noch unvollständig, da wir erst mal eine Arbeitsgrundlage brauchen. Die Funktion ist einfach. Es wird über den Pin 2 (INT0) das PPM Signal eingelesen. Entsprechend wird dann über die serielle Console der Befehl ausgegeben. Es erfolgt eine failsafe Erkennung, wenn länger als 0,5s kein PPM Signal eingegangen ist. Normalerweise sollte Dein RC-System so programmiert werden, das bei failsafe neutral, also 1,5ms ausgegeben werden.

      C-Quellcode: hebekran.ino

      1. /*
      2. * L2HF.de
      3. * project-id 19021 (rc-schiffe.com Hebekran)
      4. * Hardware Arduino UNO 16Mhz
      5. * r 0.1.23 first public (erste Diskussionsgrundlage)
      6. */
      7. #include <Arduino.h>
      8. // i/o Ports bezogen auf den UNO
      9. #define PPM_PIN 2 // WICHTIG!!! In der ISR wird der PIN direkt angesprochen, also dort anpassen bei Bedarf
      10. #define PIN_MOTOR_1 2
      11. #define PIN_MOTOR_2 3
      12. #define PIN_MOTOR_1_REV 8
      13. #define PIN_MOTOR_2_REV 8
      14. #define PIN_ENDSCHALTER_1 4
      15. #define PIN_ENDSCHALTER_2 5
      16. #define PIN_ENDSCHALTER_3 6
      17. #define PIN_ENDSCHALTER_4 7
      18. #define PPM_IN_MID 1500
      19. #define PPM_IN_LOW 500
      20. #define PPM_IN_HIGH 2500
      21. #define PPM_RANGE 50 // Nullpunkt (PPM_IN_MID - PPM_RANGE) bis (PPM_IN_MID + PPM_RANGE)
      22. // ppm Eingang
      23. uint8_t ppmCnt = 99;
      24. uint8_t ppmCntLast = 0;
      25. volatile uint16_t ppmLen = 0;
      26. volatile uint8_t ppmInput = 0;
      27. unsigned long millisTemp;
      28. unsigned long millisTemp2;
      29. uint8_t cmdOld = 4;
      30. uint8_t motorRevOn = 0;
      31. uint8_t fs = 0;
      32. // Ablausteuerung cmdStep
      33. /*
      34. * 0 relais an oder aus
      35. * 1 motor an
      36. * 2 motor aus, weil endschalter
      37. * 3 warten 1s motor an
      38. * 4 motor aus, weil endschalter
      39. */
      40. uint8_t cmdStep = 0;
      41. /*
      42. *
      43. */
      44. ISR( TIMER1_OVF_vect)
      45. {
      46. // wird heute nicht benoetigt aber ...
      47. } // ISR TIMER1_OVF_vect
      48. /*
      49. * ISR liest ppm ein
      50. */
      51. ISR( INT0_vect)
      52. {
      53. static uint16_t tcstart;
      54. uint16_t tc = TCNT1; // nur wenig ticks verlieren, daher zwischen speichern
      55. if ( PIND & (1 << PIND2)) // Wechsel von low auf high
      56. tcstart = tc; // Messung starten
      57. else // ende
      58. { // Wechsel von high auf low Pegel
      59. ppmLen = (tc - tcstart) / 2;
      60. ++ppmInput;
      61. }
      62. } // ISR INT0_vect
      63. /*
      64. * ppmGetCmd
      65. * liefert fuer ppmIn die Befehle 0=neutral, 1=vor usw
      66. */
      67. uint8_t ppmGetCmd( void)
      68. {
      69. uint16_t pLen;
      70. cli(); // atomarer Zugriff
      71. pLen = ppmLen;
      72. ppmCnt = ppmInput;
      73. sei();
      74. if( (pLen < PPM_IN_LOW - PPM_RANGE) || (pLen > PPM_IN_HIGH + PPM_RANGE))
      75. return 3; // irgendwo im nirgendwo
      76. if( pLen < PPM_IN_MID - PPM_RANGE)
      77. return 2; // ppm_low
      78. if( pLen > PPM_IN_MID + PPM_RANGE)
      79. return 1; // ppm_mid
      80. return 0; // neutral
      81. } // ppmGetState
      82. /*
      83. * setup
      84. * klassisches init
      85. */
      86. void setup()
      87. {
      88. // Ausgaenge Motoren
      89. pinMode( PIN_MOTOR_1, OUTPUT);
      90. digitalWrite( PIN_MOTOR_1, LOW);
      91. pinMode( PIN_MOTOR_2, OUTPUT);
      92. digitalWrite( PIN_MOTOR_2, LOW);
      93. Serial.begin( 115200);
      94. Serial.println( "start the engine...");
      95. // Eingang ppm
      96. pinMode( PPM_PIN, INPUT_PULLUP); // Eingang PPM -> INT0
      97. // Eingaenge Endschalter
      98. pinMode( PIN_ENDSCHALTER_1, INPUT_PULLUP);
      99. pinMode( PIN_ENDSCHALTER_2, INPUT_PULLUP);
      100. pinMode( PIN_ENDSCHALTER_3, INPUT_PULLUP);
      101. pinMode( PIN_ENDSCHALTER_4, INPUT_PULLUP);
      102. // Ausgaenge Motor-Richtung
      103. pinMode( PIN_MOTOR_1_REV, OUTPUT);
      104. digitalWrite( PIN_MOTOR_1_REV, LOW);
      105. pinMode( PIN_MOTOR_2_REV, OUTPUT);
      106. digitalWrite( PIN_MOTOR_2_REV, LOW);
      107. // 16bit timer1
      108. TCCR1A = 0;
      109. TCCR1B = (1 << CS11);
      110. TCCR1C = 0;
      111. TIMSK1 = (1 << TOIE1);
      112. TIFR1 = (1 << TOV1);
      113. // ISR fuer ppmIn aktivieren
      114. EICRA = (1<<ISC00);
      115. EIMSK = (1<<INT0);
      116. sei(); // showtime irqs aktivieren
      117. millisTemp2 = millis();
      118. } // setup
      119. /*
      120. * main loop
      121. * the endless summer
      122. */
      123. void loop()
      124. {
      125. uint8_t cmd;
      126. if( ppmInput != ppmCntLast) // neues ppm-Signal?
      127. {
      128. cmd = ppmGetCmd();
      129. ppmCntLast = ppmCnt;
      130. fs = 0;
      131. if( cmd != cmdOld)
      132. {
      133. Serial.print( "cmd: ");
      134. Serial.println( cmd);
      135. cmdOld = cmd;
      136. }
      137. millisTemp2 = millis();
      138. switch( cmd)
      139. {
      140. case 3 : // undefiniert
      141. case 0 : // neutral -> alles aus
      142. digitalWrite( PIN_MOTOR_1, LOW); // Motor 1 aus
      143. digitalWrite( PIN_MOTOR_2, LOW); // Motor 2 aus
      144. break;
      145. case 1 : // ausfahren
      146. digitalWrite( PIN_MOTOR_1_REV, LOW);
      147. digitalWrite( PIN_MOTOR_2_REV, LOW);
      148. millisTemp = millis();
      149. motorRevOn = 1;
      150. break;
      151. case 2 : // einfahren
      152. digitalWrite( PIN_MOTOR_1_REV, HIGH);
      153. digitalWrite( PIN_MOTOR_2_REV, HIGH);
      154. millisTemp = millis();
      155. motorRevOn = 1;
      156. break;
      157. } // switch cmd
      158. } // neuer Befehl (cmd)
      159. else
      160. if( (millis() - millisTemp2 > 500) && ( !fs))
      161. {
      162. fs = 1;
      163. Serial.println( "failsave");
      164. }
      165. if( cmd == 1) // ausfahren
      166. {
      167. // fehlt noch komplett
      168. } // if
      169. if( cmd == 2) // einfahren
      170. {
      171. // fehlt noch komplett
      172. } // if neues PPM Ereignis
      173. } // loop
      Alles anzeigen

      Das Programm ist etwas untypisch für Arduino, da die Hardware des Controllers teilweise direkt angesprochen wird und das Programm als eine Art Zustandsautomat geschrieben ist. Wichtig ist am Anfang, das Du es zum laufen bringst. Danach kann ich die restlichen Teile posten.

      Viel Erfolg
      Dateien