Arduino Mega 2560 mit Adafruit Motor Shield

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

    • Es funktioniert ! :) Der Motor dreht sich. Habe dazu ein kleines Demoprogramm gemacht. Dieses lässt den Motor am Ausgang M1 langsam in eine Richtung drehen, dann wird er wieder gebremst. 2 Sekunden Pause, dann wird er langsam wieder hochgefahren. Jedoch in die andere Richtung. 2 Sekunden Pause und das Ganze beginnt von vorne. Falls jemand ähnliche Probleme hat, stelle ich das Programm hier zur Verfügung:

      Source Code

      1. '***************************************************************************
      2. '* Arduino steuert Motor an M1 an *
      3. '* Motorshield von AdafruitHW-130 *
      4. '***************************************************************************
      5. $regfile = "m328pdef.dat"
      6. $framesize = 32
      7. $swstack = 32
      8. $hwstack = 64
      9. $crystal = 16000000 'Resonatorfrequenz
      10. $baud = 9800 'Baudrate (Übertragungsgeschwindigkeit)
      11. Baud = 9800
      12. Dim A as Byte
      13. dim Steuerbyte as Byte
      14. ' Ein/Ausgänge festlegen:
      15. Config Portb.3 = Output
      16. Config PortD.4 = Output
      17. Config PortD.7 = Output
      18. Config PortB.0 = Output
      19. Config PortB.4 = Output
      20. ' Alias Zuweisung
      21. DIR_CLK Alias PortD.4
      22. DIR_EN Alias PortD.7
      23. DIR_SER Alias PortB.0
      24. DIR_LATCH Alias PortB.4
      25. ' Timer Programmieren:
      26. Config Timer2 = PWM, Prescale = 1 , Compare A Pwm = Clear Up
      27. Do
      28. Gosub Linkslauf
      29. For A = 0 to 255 Step 1 ' Motor lanngsam hochfahren
      30. PWM2A = A
      31. Waitms 10
      32. next A
      33. For A = 255 to 0 Step -1 ' Motor langsam runterfahren
      34. PWM2A = A
      35. Waitms 10
      36. next A
      37. wait 2
      38. Gosub rechtslauf
      39. For A = 0 to 255 Step 1 ' Motor langsam hochfahren
      40. PWM2A = A
      41. Waitms 10
      42. next A
      43. For A = 255 to 0 Step -1 ' Motor langsam runterfahren
      44. PWM2A = A
      45. Waitms 10
      46. next A
      47. Wait 2
      48. Loop
      49. Linkslauf:
      50. ' M1 Ausgang dreht links:
      51. ' Shirftregister festlegen:
      52. Steuerbyte.5=0
      53. Steuerbyte.4=1
      54. DIR_EN=0
      55. Shiftout DIR_SER, DIR_CLK, Steuerbyte, 3
      56. DIR_LATCH=1
      57. DIR_LATCH=0
      58. return
      59. Rechtslauf:
      60. ' M1 Ausgang dreht rechts:
      61. ' Shirftregister festlegen:
      62. Steuerbyte.5=1
      63. Steuerbyte.4=0
      64. DIR_EN=0
      65. Shiftout DIR_SER, DIR_CLK, Steuerbyte, 3
      66. DIR_LATCH=1
      67. DIR_LATCH=0
      68. return
      Display All
    • tschoeatsch wrote:

      Pin1 vom IC1 geht an pwm2b, das ist ein PWM-Ausgang von timer2 und zwar Kanal2, prima.
      prima, meinen Fehler gefunden und korrigiert :thumbsup:
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Das regeln alles die bits im steuerbyte. Halt die bit-Nummern eruieren und die entsprechend im steuerbyte setzen, an den 595er schicken fertig. Mit pwm0b die Drehzahl steuern.
      Du kannst bis zu 4 Motoren in Drehrichtung umschaltbar und drehzahlgeregelt ansteuern.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Der 595er muss die Eingänge der Endstufen setzen. Diese hätte man auch einzeln an pins vom Arduino führen können, dann hätte man 8 pins gebraucht. Wenn man den 595er verwendet, braucht man nur 3 pins (den enable vom 595er könnte man fix auf gnd legen).
      Du musst dich also entscheiden, welche Endstufen du verwenden willst und welchen Pegel du an welchen Eingängen du brauchst.
      Beispiel: Motor am IC2, linke Seite, M3A und M3B sind die Eingänge, Pwm0b bestimmt die Drehzahl.
      M3A geht an den QA vom 595er, M3B an den QG. An QA liegt nach dem reinshiften das bit.7 vom Steuerbyte an, an QG bit.1.
      Also steuerbyte.7=0 und steuerbyte.1=1 gibt die eine Drehrichtung, steuerbyte.7=1 und steuerbyte.1=0 die andere Richtung.

      Der 595er bekommt durch das shiftout die bits des steuerbytes nacheinander in seinen Eingang rein und er legt diese bits nacheinander an seine Ausgänge an. Das ist jetzt sehr vereinfacht, aber so in etwa kann man seine Aufgabe beschreiben.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Die Ausgänge vom 595er sind von QA bis QH durchnummeriert. Mit dem ersten clock am 595er wird der Pegel am Eingang an die 'Stelle QA' gelegt. Anführungsstriche deshalb, weil sich am Ausgang noch nix tut. Mit dem nächsten clock, rutscht der Inhalt der Stelle A an die Stelle B und die Stelle A wird mit dem Pegel vom Eingang belegt. So geht es nacheinander zu. Wie eine Eimerkette, mit jedem clock werden die Eimer weiter gereicht, nach 8 clocks ist der erste Eimer an der Stelle H. Mit der Flanke am latch werden die Pegel an den Stellen an die Ausgänge gelegt, der Inhalt der Eimer zu den Ausgängen raus geschüttet.
      Da ich bei shiftout die Option LSB first gewählt habe, wird zuerst bit.0 eingeschoben, das eben nach 8 clocks am Ausgang QH landet. Das zuletzt eingeschobene bit.7 landet am Ausgang QA.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Vielen Dank für deine Erläuterung. Ich verstehe es einfach nicht. Mir raucht gerade der Kopf... :(

      Habe mir X mal den Schaltplan angesehen. Die Ausgänge A - H habe gefunden. DIR_Latch ist also der Eingang? Wohin diese geschaltet wird, bestimmt dann das Steuerbit?

      Also
      bit0= Ausgang QA
      Bit1= Ausgang QB
      Bit2= Ausgang QC
      Bit3= Ausgang QD
      Bit4= Ausgang QE
      Bit5= Ausgang QF
      Bit6= Ausgang QG
      Bit7= Ausgang QH

      Wo ich die PWM anlege und welche Ausgänge ich benötige ist mir soweit klar.
    • Dir_Ser ist der Eingang vom 595er 'ser' wie seriell. Das shiftout liefert ja die bits des Steuerbytes eins nach dem anderen, seriell, über den pin vom Arduino an den Eingang vom 595er. Und zwar mit bit.0 voraus. Das ist mit der Option '3' bei shiftout so festgelegt. Das bit, was zuerst in den 595er hineingeschoben wird landet dann am vom Eingang am weitesten entfernten Ausgang. Der ist hier mit QH bezeichnet. QA ist direkt beim Eingang, also landet da das bit, wenn ich nur eins hinein schieben würde, oder eben das letzte von einer ganzen Reihe, bei uns bit.7.
      Du musst also deine Liste umkehren, dann stimmt sie.
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------
    • Super, vielen Dank für Deine Erklärung. Ich glaube so langsam verstehe ich es. Das heißt würde ich nun z.B. M2A und M2B wollen, wäre das also:

      Steuerbit.6 - für M2A
      Steuerbit.3 - für M2B

      Eine Drehrichtung:
      Steuerbit.6 = 1
      Steuerbit.3 = 0

      Andere Drehrichtung:
      Steuerbit.6 = 0
      Steuerbit.3 = 1

      PWM wird dann hier über PWM2B gesendet.

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

    • Klasse, nun habe ich es wohl verstanden. Habe ein kleines Testprogramm geschrieben. Hier werden erst der Motor am Ausgang M1 in eine Richtung gedreht, 2 Sekunden Pause, dann in die andere Richtung gedreht. Wieder 2 Sekunden Pause, dann wird der Motor am Ausgang M2 gedreht. Ebenfalls wieder in eine Richtung, 2 Sekunden Pause, danach wieder in die andere Richtung.

      Für alle, die ebenfalls mit Arduino und diesem Motor Shield arbeiten. Hoffe es hilft euch vielleicht ein wenig. :)

      tschoeatsch, nochmal vielen Dank für Deine Hilfe ! ;) :)

      BASCOM Source Code

      1. '***************************************************************************
      2. '* Arduino steuert Motor an M1 an *
      3. '* Motorshield von AdafruitHW-130 *
      4. '***************************************************************************
      5. $regfile = "m328pdef.dat"
      6. $framesize = 32
      7. $swstack = 32
      8. $hwstack = 64
      9. $crystal = 16000000 'Resonatorfrequenz
      10. $baud = 9800 'Baudrate (Übertragungsgeschwindigkeit)
      11. Baud = 9800
      12. Dim A as Byte
      13. dim Steuerbyte as Byte
      14. ' Ein/Ausgänge festlegen:
      15. Config Portb.3 = Output
      16. Config PortD.4 = Output
      17. Config PortD.5 = Output
      18. Config PortD.7 = Output
      19. Config PortB.0 = Output
      20. Config PortB.4 = Output
      21. ' Alias Zuweisung
      22. DIR_CLK Alias PortD.4
      23. DIR_EN Alias PortD.7
      24. DIR_SER Alias PortB.0
      25. DIR_LATCH Alias PortB.4
      26. ' Timer Programmieren:
      27. Config Timer2 = PWM, Prescale = 1 , Compare A Pwm = Clear Up, Compare B PWM = Clear Up
      28. Do
      29. Gosub M1_Linkslauf
      30. PWM2A = 200
      31. Wait 2
      32. PWM2A = 0
      33. wait 2
      34. Gosub M1_rechtslauf
      35. PWM2A = 200
      36. Wait 2
      37. PWM2A = 0
      38. Wait 2
      39. Gosub M2_Linkslauf
      40. PWM2B = 200
      41. Wait 2
      42. PWM2B = 0
      43. wait 2
      44. Gosub M2_rechtslauf
      45. PWM2B = 200
      46. Wait 2
      47. PWM2B = 0
      48. Wait 2
      49. loop
      50. ' HIER BEFINDEN SICH DIE UNTERPROGRAMME FÜR DIE AUWAHL DER AUSGÄNGE UND RICHTUNG:
      51. M1_Linkslauf:
      52. ' M1 Ausgang dreht links:
      53. ' Shirftregister festlegen:
      54. Steuerbyte.5=0
      55. Steuerbyte.4=1
      56. DIR_EN=0
      57. Shiftout DIR_SER, DIR_CLK, Steuerbyte, 3
      58. DIR_LATCH=1
      59. DIR_LATCH=0
      60. return
      61. M1_Rechtslauf:
      62. ' M1 Ausgang dreht rechts:
      63. ' Shirftregister festlegen:
      64. Steuerbyte.5=1
      65. Steuerbyte.4=0
      66. DIR_EN=0
      67. Shiftout DIR_SER, DIR_CLK, Steuerbyte, 3
      68. DIR_LATCH=1
      69. DIR_LATCH=0
      70. return
      71. M2_Linkslauf:
      72. ' M2 Ausgang dreht links:
      73. ' Shirftregister festlegen:
      74. Steuerbyte.6=0
      75. Steuerbyte.3=1
      76. DIR_EN=0
      77. Shiftout DIR_SER, DIR_CLK, Steuerbyte, 3
      78. DIR_LATCH=1
      79. DIR_LATCH=0
      80. return
      81. M2_Rechtslauf:
      82. ' M2 Ausgang dreht rechts:
      83. ' Shirftregister festlegen:
      84. Steuerbyte.6=1
      85. Steuerbyte.3=0
      86. DIR_EN=0
      87. Shiftout DIR_SER, DIR_CLK, Steuerbyte, 3
      88. DIR_LATCH=1
      89. DIR_LATCH=0
      90. return
      Display All
    • bitte, gerne geschehen.
      Wenn dich jetzt am End' der Ehrgeiz packt, kannst du ja mal die Ansteuerung von einem stepper probieren. Nimm aber erst mal einen 'hochohmigen' ich meine damit einen, bei dem eine Betriebsspannung angegeben ist, zB. 12V. Ein Konstantstrom ist ja hier auf dem shield nicht vorgesehen, da er ja nicht gemessen werden kann. Du wirst aber auch bald merken, ein billige DRV8825-Modul ist einfach schöner und einfacher anzusteuern. :D
      Raum für Notizen

      -----------------------------------------------------------------------------------------------------

      -----------------------------------------------------------------------------------------------------