Mittels PWM kann ein Servo Motor am Raspberry Pi gesteuert werden. Möchte man mehr als einen Servo Motor lenken, so kann man entweder für jeden der Servos einen GPIO nutzen oder ein Treiber Board wie das PCA9685 am Raspberry Pi anschließen, womit per I2C fast beliebig viele Motoren separat gesteuert werden können.
In Projekten wie einem Roboterarm ist ein solches Treiberboard für mehrere Servomotoren unumgänglich, auch da die Motoren einen recht hohen Strombedarf haben.
Zubehör
Je nach Stärke der Motoren wird die Stromversorgung über die GPIOs der Raspberry Pi’s nicht ausreichen. Daher solltest du über ein externes Netzteil nachdenken. Dies kann entweder ein einstellbares oder z.B. ein Schaltnetzteil mit 5V (wie hier verwendet) sein.
Folgendes Zubehör solltest du für dieses Tutorial haben:
- Raspberry Pi
- PCA9685 I2C Servo Board
- mehrere Servo Motoren (bspw. MG996R)
- ggf. externe Stromverbindung (z.B. 5V)
- ggf. Power Jack Adapter
- Jumper Kabel (ebay)
Achte bei deinem Netzteil, dass es genügend Power für alle Motoren hat. Wenn wir bspw. von 6 Motoren und ~500mA pro Motor ausgehen, so sollte es 3A liefern können. Da allerdings z.B. beim 6DOF Robot Arm nur selten alle 6 Motoren gleichzeitig laufen, sollte auch ein Netzteil mit weniger Stromstärke ausreichen.
Im Grunde ist die Anzahl der Motoren für dieses Projekt egal (bis zu 16 pro Board). Falls du vorläufig also nur einen Motor zur Hand hast, sollte dies dennoch ausreichen, da sich die Programmierung super einfach auf weitere Servos zu übertragen.
Raspberry Pi PCA9685 – I2C Adressierung
Das PCA9685 hat außerdem noch einige Lötkontakte, welche zum Festlegen der I2C Adresse gedacht sind. Ist kein Kontakt verlötet, so hat es die I2C Hex Adresse 0x40. Wenn mehrere dieser Boards verwendet werden sollen, muss jedes eine eigene Adresse bekommen. Dafür sind die Lötstellen, wobei die Nummerierung einem Binär Wert entspricht:
- A0 = 2^0 (bspw. 41)
- A1 = 2^1 (bspw. 42)
- …
Somit könnten theoretisch bis zu 2^6 (= 64) der Boards hintereinander geschaltet werden und alle über Ihre eigene Adresse angesprochen werden. Und jedes der Boards kann ebenfalls 16 Servos steuern. Das sollte in jedem Fall ausreichen. Mehr Details dazu findest du u.a. im Datenblatt.
PCA9685 Anschluss an den Raspberry Pi
Das PCA9685 Modul wird über den I2C Bus gesteuert (SDA und SCL). Der Bus wird über 3.3V mit Strom versorgt, wobei die Power für die Motoren aus einer anderen Quelle kommt.
| PCA9685 | Raspberry Pi |
|---|---|
| SCL | GPIO 3 / SCL (Pin 5) |
| SDA | GPIO 2 / SDA (Pin 3) |
| VCC / V | 3,3V (pin 1) |
| GND | GND (Pin 6) |
Die restlichen Pins (V+ und OE) bleiben unbelegt. Falls du mehr als ein I2C Modul nutzt, kannst du vom anderen Ende die anderen Module in Reihe anschließen.
Stärkere Servos wie der MG996R können bis zu 1.5A verbrauchen, weshalb eine externe Stromversorgung bei entsprechender Belastung bzw. bei mehreren Motoren sehr zu empfehlen. Bei einem oder zwei Servo Motoren kannst du die „externe“ Stromversorgung auch vom Raspberry Pi beziehen (üblicherweise wollen Servos ~5V). Der Strom reicht aber nicht für viele Servos, weshalb du z.B. beim Roboter Arm Projekt o.ä. auf eine externe Stromversorgung zurückgreifen solltest.
Installation der benötigten Tools
Öffne ein neues Terminal (z.B. per SSH) und gib folgendes ein:
sudo apt-get install build-essential python-dev python-smbus i2c-tools python-pip --yes
Falls Python3 genutzt werden soll, so müssen die Paketnamen natürlich entsprechend angepasst werden. Wir aktivieren zunächst I2C, sofern nicht schon geschehen:
sudo raspi-config
Unter „Interfacing Options“ -> „I2C“ wird es aktiviert. Wir schauen nun, ob das Board auch erkannt wird:
i2cdetect -y 1
Hier solltest du die Adresse des Boards sehen. Falls du die Adresspins verlötet hast, hast du ggf. eine andere Adressierung (wie oben beschrieben). Ansonsten sollte die Ausgabe folgend aussehen:
pi@raspberrypi:~ $ i2cdetect -y 1 0 1 2 3 4 5 6 7 8 9 a b c d e f 00: -- -- -- -- -- -- -- -- -- -- -- -- -- 10: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 20: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 30: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 40: 40 -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 50: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 60: -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- 70: 70 -- -- -- -- -- -- --
Anschließend installieren wir noch den Python Treiber für das Servo Board (wer den Code einsehen möchte bzw. lieber aus dem Repository installieren möchte, kann einen Blick in das GitHub Repo werfen). Einfacher ist es jedoch hiermit:
sudo pip install Adafruit-PCA9685
Beispiele & Erklärung zur Nutzung des PCA9685 am Raspberry Pi
Alle folgenden Befehle sind in der Python Konsole auszuführen (sudo python) oder in ein entsprechendes Python Skript zu schreiben.
Zunächst einmal müssen wir die Bibliothek einbinden:
|
1 |
import Adafruit_PCA9685 |
Als nächstes gilt es das PCA9685 Treiber Board zu initialisieren. Dabei hast du die Möglichkeit eine andere Adresse als 0x40 anzugeben, sofern gewünscht. Falls du den Parameter nicht angibst, wird automatisch 0x40 genommen:
|
3 |
pwm = Adafruit_PCA9685.PCA9685(address=0x40) |
Wie auch bei der gewöhnlichen PWM Steuerung über GPIOs müssen wir ebenfalls eine Frequenz angeben (in Hertz). Der Wert kann dabei zwischen 40 und 1000 liegen. Diese gilt für alle angeschlossenen Motoren:
|
5 |
pwm.set_pwm_freq(50) |
Die gesendeten Impulse sind natürlich abhängig von der Frequenz und müssen ggf. angepasst werden.
Der zweite wichtige Befehl ist jener, mit dem wir den Puls für einen angeschlossenen Servo Motor senden. Der erste Parameter ist dabei der Channel (zw. 0 und 15), der zweite und dritte Parameter ist die relative Pulslänge im Verhältnis zu 4096 (was 2^12 entspricht). Die Differenz der beiden Werte darf nicht größer als 4096 sein.
Um den Motor in Stellung zu bringen können wir bspw. folgendes eingeben:
|
7 |
pwm.set_pwm(0, 0, 150) |
Dabei wird lediglich die Differenz berechnet. Der obige Aufruf ist also äquivalent zu diesem:
|
7 |
pwm.set_pwm(0, 600, 750) |
Das Signal wird im folgend berechnet: Möchtest du ein Signal von bspw. 0.5ms (=0.0005s) bei einer Frequenz von 50Hz (ein Puls ist 20ms breit) ausgeben, so müsste der relative Wert ~100 sein (50Hz * 0.0005s * 4096 = 102.4). Die üblichen Pulslängen von Servos sind 0.5ms (0°) bis 2.5ms (180°). Dazwischen wird interpoliert.
Wie auch im Beispiel des einfachen Servos gilt, dass wir das „Ruckeln“ des Servos ausstellen können, sofern wir den Puls auf Null setzen:
|
9 |
pwm.set_pwm(0, 0, 0) |
Wenn du ein vordefiniertes Beispiel testen möchtest, kannst du dies ebenfalls:
wget https://raw.githubusercontent.com/adafruit/Adafruit_Python_PCA9685/master/examples/simpletest.py
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 |
# Simple demo of of the PCA9685 PWM servo/LED controller library. # This will move channel 0 from min to max position repeatedly. # Author: Tony DiCola # License: Public Domain from __future__ import division import time # Import the PCA9685 module. import Adafruit_PCA9685 # Uncomment to enable debug output. #import logging #logging.basicConfig(level=logging.DEBUG) # Initialise the PCA9685 using the default address (0x40). pwm = Adafruit_PCA9685.PCA9685() # Alternatively specify a different address and/or bus: #pwm = Adafruit_PCA9685.PCA9685(address=0x41, busnum=2) # Configure min and max servo pulse lengths servo_min = 150 # Min pulse length out of 4096 servo_max = 600 # Max pulse length out of 4096 # Helper function to make setting a servo pulse width simpler. def set_servo_pulse(channel, pulse): pulse_length = 1000000 # 1,000,000 us per second pulse_length //= 60 # 60 Hz print('{0}us per period'.format(pulse_length)) pulse_length //= 4096 # 12 bits of resolution print('{0}us per bit'.format(pulse_length)) pulse *= 1000 pulse //= pulse_length pwm.set_pwm(channel, 0, pulse) # Set frequency to 60hz, good for servos. pwm.set_pwm_freq(60) print('Moving servo on channel 0, press Ctrl-C to quit...') while True: # Move servo on channel O between extremes. pwm.set_pwm(0, 0, servo_min) time.sleep(1) pwm.set_pwm(0, 0, servo_max) time.sleep(1) |
sudo python simpletest.py
Dieses Beispiel setzt die definierten Minimum / Maximum Signale, wodurch der Motor hin und Her rotiert.
Übrigens: Nicht nur Servos können mit diesem Board gesteuert werden. Auch LEDs oder andere Module, welche PWM nutzen, können damit sehr einfach angesprochen werden.
73 Kommentare
Hallo,
vielen Dank für diesen Beitrag.
Zwei Fragen.
1. Die Frequenz hast Du in der Erklärung bei 50 Hz angenommen, im Beispielcoding ist der Wert dann aber 60 Hz (macht vielleicht nichts am Ergebnis aus, aber wollte das nur verstehen).
2. Die „Helper function“ wird nicht bei der Abarbeitung des Codes verwendet, oder?
Eine Anmerkung:
Wenn ein Servo z.B. das DS3218MG nur lahm ruckelt, dann liegt es daran dass das Netzteil mit z.B. 5V (800mA) zu schwach ist, dann helfen 6 V (1000 mA) wenn der PCA9685 verwendet wird.
Gruß
Dirk
Hallo Dirk,
stimmt beides. In meinem Beispiel habe ich 50Hz genommen, die von Adafruit nehmen 60Hz und rufen die helper Funktiong gar nicht auf.
Viele Grüße,
Felix
Hi Felix,
vielen Dank für Deine Antwort.
Gruß
Dirk
Guten Tag Felix,
ich hoffe du bist immer noch aktive und du wärst eventuell mir behilflich.
Das I2C Protokoll lässt auch den ADS1115 für Analogwerte zu.
Leider komme ich überhaupt nicht weiter. hättest du Zeit mich mal zu unterstützen?
Hallo Felix,
vielen Dank für das super Tutorial.
Ich warte noch auf meine Servos und dann werde ich etwas mit dem PCA9685 experimentieren.
Damit lassen sich sicher auch DC Motoren steuern oder?
Ja, wenn du es in Bezug auf Geschwindigkeit steuern meinst.
Ja, wenn du es in Bezug auf Geschwindigkeit steuern meinst.
Hey ho… auch noch einmal vielen Dank meinerseits für das Tutorial. Aber ich verzweifele langsam daran zu versuchen bei einem normalen DC Motor die Geschwindigkeit zu steuern. Kannst du mir ggf. eine kleine Unterstützung geben, wie man das macht?
Ich hatte es u.a. auch nach folgender Anleitung versucht, aber es haut nicht hin 🙁
https://learn.adafruit.com/micropython-hardware-pca9685-dc-motor-and-stepper-driver/circuitpython
Hallo Felix,
ich bin neu auf der Website. Bin Elektrotechniker im Ruhestand (seit 4 Monaten) und beschäftige mich seit ein paar Tagen mit Raspberry Pi. Ich habe die Hardware bestellt und warte darauf. Meine letzten Projekte (Zwei Roboterarme) hab ich mit Arduino realisiert. Deine Website in deutscher Sprache und zudem verständlich finde ich einfach toll. Bitte weiter so!
Hallo Erich,
danke und viel Erfolg bei deinem Projekt 🙂 Demnächst kommt auch eine Anleitung, wie man einen Roboter Arm über einen Xbox Controller fernsteuern kann.
LG, Felix
Grüße . eine schöne Seite hast du hier gebastelt. Total gut.
.
Ich beschäftige mich nun schon einige Zeit mit dem RPi3 und diesem PCA9658.
Jedoch kann ich mir keine Reim darauf machen wie man die Servos z.B.
per Tastaur oder beser noch über einen Joystick ansteuern kann.
Ich stelle mir vor das man eine bestimmte Taste eine bestimmte Zeit drückt und der Servo
ebnso lange in eine bestimmte Richtung dreht.
vieleicht könntest Du uns dazu einmal erleuchten.
für den 6DOF RoboterArm were das ein großer gewinn
LG Norbert
Mit Joystick ist es eigentlich ganz einfach: Im bestimmten Interval die Position abfragen und entsprechend den Servo aktualisieren. Ich habe das mit einem Xbox Controller bereits gemacht und es wird definitiv ein Tutorial folgen, in dem wir den Roboter Arm mit Controller bewegen.
wow danke für die schnelle Rückmeldung.
Ich stelle mir letztlich einen 3d joystick vor.
dein Controller-Tutorial sehe ich mir glei mal genauer an.
Danke und mach weiter so.
Grüße Norbert
Das in den Kommentaren verlinkte Video wurde von mir erstellt, als ich den Controller angeschlossen habe. Den Code gibt es auch bereits auf Github: https://github.com/tutRPi/Raspberry-Pi-6DOF-Robot-Arm-Xbox360-Control
Das Tutorial wird noch etwas dauern, aber du kannst den Code bereits nutzen 🙂
Guten Nachmittag
Nachdem ich mir die Nacht um die Ohren geschlagen habe fährt mein Pi.Bot.
(darauf soll der Greifarm später montirt werden)
nun ,über Tastatur und XRDP, Vor Zurück Rechts und Links.
(wie ich finde nicht schlecht für einen Anfänger)
nun werde ich versuchen deinen Code runterzuladen
Um mich damit auseinandersetzen.
Und versuchen diesen auf mein Projekt anzuwenden.
also auf den Joystick fertig los …
DAnke Norbert
hi ,bin neu hier coole sache habe gerade den Roboter arm bestelt.
Aber kleine frage wie stellt man den kanall ein (mein alter 9 Jahre , 3 klasse)
liebe grüsse Sebastian.
Hallo Sebastian,
welchen Kanal? Du meinst welcher Motor angesteuert wird? Mit der Adresse/Nummer (0-15).
PCA 9685 mit Python 3 nutzen
Hallo Felix,
erstmal Danke für das tolle Tutorial. Ich möchte den PCA 9685 mit Python 3 nutzen. Dazu heißt es:
„Falls Python3 genutzt werden soll, so müssen die Packetnamen natürlich entsprechend angepasst werden. “ Und da ist mein Problem: Ich kenne bis jetzt nur Python 3 und weiß nicht, wie genau ich die Packetnamen anpassen muss. Egal wo ich nachschlage, es heißt immer nur sinngemäß, die Bibliothek ist für Python 3 noch nicht vorhanden. Bis jetzt habe ich auch noch kein Beispiel für die Nutzung des PCA 9685 mit Python 3 gefunden.
Viele Grüße
Achim
Meinst du die Python (Dev) Tools, die du per apt-get installierst? Die gibt es in jedem Fall für Python3. Bei dem pip(3) Paket bin ich nicht sicher, dachte aber dass es verfügbar wäre (Adafruit).
Hallo Felix,
danke für die Antwort. Ehrlich gesagt, ich weiß nicht ob es um die Dev Tools geht oder um das pip(3) Packet. Ich versuche mein Problem mal so zu erklären: Ich habe die Bibliothek unter
/home/pi/servo/Adafruit_Python_PCA9685 installiert. Wenn ich dort unter examples
sudo python simpletest.py ausführe läuft es, wenn ich
sudo python3 simpletest.py versuche, geht es eben nicht. Meine Frage ist, was genau muss ich in simplest.py oder anderswo ändern?
Danke, viele Grüße
Achim
Hast du es mittels pip oder pip3 installiert? Ich glaube über pip. Führe das mal aus:
Hallo Felix,
super, genau das war’s!
Jetzt läuft es mit Python3 vom Terminal aus wie auch aus der IDLE für Python 3.
Ganz herzlichen Dank für die Unterstützung,
Achim
Vielen Dank.
Dies hat mir nach Stundenlangem Suchen endlich das erhoffte Ergebniss gebracht. 🙂
Hallo Felix,
angenommen ich habe auch pip statt pip3 benutzt, wenn ich nun einfach „sudo pip3 install Adafruit…“ benutzte kommt nur die Bemerkung dass das Modul schon installiert ist.
Muss ich die pip installation vorher mittels uninstall entfernen, oder funktioniert das auch so?
Gruß Klaus
Hi Felix,
I encounter some problem with this system when multiple servos were used.
Its all fine when:
1- Moving the servos individually
2- Moved the servos simultaneously but each servo has different pulse length
eg:
pwm.set_pwm(0, 0, 120)
pwm.set_pwm(4, 0, 530)
pwm.set_pwm(8, 0, 280)
3- Move the 2 servos from their current pulse length to the other servo pulse length
eg:
pwm.set_pwm(0, 0, 120)
pwm.set_pwm(4, 0, 120)
pwm.set_pwm(8, 0, 120)
Its become weird when:
1- Moved every servos from different current pulse length simultaneously with the same pulse length
eg:
pwm.set_pwm(0, 0, 300)
pwm.set_pwm(4, 0, 300)
pwm.set_pwm(8, 0, 300)
What happen are the servos will first move to the desired position then they start to stuttered and move their own like seeking for the correct position.
This situation can last up-to 1s till 5s until they actually stabilize and reach the desired position.
Really looking forward if you ever encounter this problem
For some pulses/angles, it is normal that the motors stutter. You could try to wait some ms before moving the next motor. Voltage is enough?
Hallo Felix,
was hältst Du von dem Adafruit 16 Channel Hat
https://learn.adafruit.com/adafruit-16-channel-pwm-servo-hat-for-raspberry-pi?view=all
im Vergleich zu der einfachen PCA9685-Platine, die Du hier beschrieben hast?
Adafruit schreibt, dass der Raspberry Pi Probleme hätte, exakte Pulse zu generieren und man die Arbeit besser diesem Hat überlassen sollte.
Wie siehst Du das? Gibt es mit der einfachen PCA9685-Platine Probleme bei der Feinjustierung eines Servos?
Ich hab den Adafruit Hat nicht getestet, aber vermute, dass er einen ähnlichen IC verwendet. Das mit dem Zucken am Pi stimmt – habe ich auch erlebt. Es gibt manche Pulslängen, bei denen die Servos „rattern“. Ob es am Servo oder an der Frequenz liegt, habe ich nicht nachgemessen.
Ja, das Adafruit Hat benutzt auch den PCA9685, hat aber noch einen eigenen Taktgeber.
Das Rattern erlebe ich bei meinem Lynxmotion Roboterarm AL5D auch, obwohl er über eine eigene, spezialisierte Steuerplatine SSC-32 gesteuert wird.
Lynxmotion schreibt dazu, dass das normal sei, da die Servos beständig nachgesteuert würden.
Aber mit der Ansteuerung jeder einzelnen Gradzahl des Servos an sich hast Du keine Probleme?
Nein, Probleme hatte ich keine. In meinem Roboterarm Projekt nutze ich dieses Board ja auch, dort war die Steuerung recht genau, mit der Einschränkung des „Ratterns“.
Auch relevant: Raspberry Pi mittels Xbox 360 Controller steuern (Video unten)
Das Beispiel läuft hervorragend. Ich hab da mal ne Frage
Kann man die Geschwindigkeit zwischen Min und Max Steuern?
Hallo Felix
ich habe mein Problem so gelöst:
for i in range(servo_anz): servo1_pos=int(servo1_pos+servo1_step) pwm.set_pwm(kanal1, 0, servo1_pos) time.sleep(v_zeit) servo2_pos=int(servo2_pos+servo2_step) pwm.set_pwm(kanal2, 0, servo2_pos) time.sleep(v_zeit)Hallo Felix
Kann ich 2 Servos parallel Steueren?
Klar, ggf. mit Threads.
Wie kann ich Threads unter Python programmieren
https://docs.python.org/2/library/threading.html
Hallo Felix,
Habe das Modul ordnungsgemäß angeschlossen und deinen simpletest.py installiert und ausgeführt jedoch tut sich nichts, kann es sein das der PCA9685 defekt ist?
Hallo Felix,
danke für deine ausführliche Beschreibung.
Es hat funktioniert.Probiere gleich mal mehrere Servos aus.
Gruß Uli
Hallo
wir haben ein „kleines“ Schulprojekt am Laufen und benötigen ein wenig Hilfe.
Das Skript funktioniert einwandfrei unser Problem ist es aber das der Motor weiter läuft bzw. sich weiter bewegt obwohl das Skript beendet wurde. Unsere Frage ist wie können wir diese Problem beheben? Wir haben schon versucht mit dem stop() befehl am Ende des Skriptes zu lösen aber hatten kein Erfolg.
Zusätzlich haben wir die Aufgabe die Motoren mittels Pfeiltasten zu steuern. Gibt es da eine Möglichkeit dies umzusetzen?
Mittels Pfeiltasten ist ähnlich zu diesem Tutorial.
Hallo Felix,
danke für diese coole Seite.
Ich habe ein Projekt bei dem ich auch Motoren einsetzen möchte und zwar will ich eine Art Schublade aus einem Gehäuse ausfahren lassen und anschließend aufrichten, ähnlich der Navigationssysteme in einem modernen Audi 😉
Ich hatte überlegt zeitlich verzögerte Motoren auzusteuern, also erst ein paar, dass die „Schublade“ an sich rausfährt und dann zwei, die das Aufrichten übernehmen. Ich muss dazu sagen, dass ich bisher nur den RaPi an sich habe und noch keine weiteren Komponeten gekauft habe…
Hast du vielleicht einen guten Tipp, was Komponenten angeht oder einen besseren Vorschlag für die Realisierung? Danke und viele Grüße
Peter
Hallo,
Funktioniert einwandfrei, möchte das pythonskript aber von einem C programm aufrufen und ausführen lassen. Die Daten zum steuern der servos sollen vom C Programm übergeben lassen werden.
Dachte mir das so:
.
.
.
# include
.
(hier steht der C Code)
.
Int Wert1;
Int Wert2;
Int wert3;
FILE* file_1 = fopen(„/home/pi simpletest.py – i Configuration.ini“) ;
Py_Initilize;
PyRun_SimpleFile(file_1, „/home/pi simpletest.py -i Configuration.ini“);
PY_Finalize();
.
.
.
Return;
(in Kommandozeile)
gcc Programm. C – o Programm – I/usr/include/python 2. 7 – lpython2. 7
Problem ist nur er erkennt python. h nicht an und ich weiß nicht wie ich die Werte in das pythonskript übertrage
Kann da jemand helfen?
Hallo Felix,
wenn ich das Beispiel Programm unter python 2 (IDLE) mit dem befehl “run” ausführe bekomme ich die Meldung “ traceback (most recent call last)
file home/pi/demo pca 9685.py, line 40, in module time sleep(1)
KeyboardInterrupt”
und es passiert nichts. Wo mache ich einen Fehler
Ich kenne diese Fehlermeldung nur, wenn man z.B. in PyCharm das Script abbricht. Das passiert auch, wenn man strg-d drückt. Vielleicht Tastatur verklemmt…
Hallo Felix,
deine Seite ist wirklich sehr hilfreich.
Allerdings habe ich ein Poblem. Ich habe einen Motopi auf meinen raspberry angeschlossen um 12 servos laufen zu lassen.
Das programm welches du oben zum testen hinterlassen hast, funktioniert bei mir aber leider nicht. Es gibt da wohl einen Fehler mit dem i2c-Tool.
Das Programm kann nicht ausgeführt werden, weil dieses i2c-tool nicht gefunden wird. Was kann ich tun, damit es gefunden wird, bzw wie kann ich es ggf. neu installieren?
Du würdest mir einen großen gefallen tun mir zu helfen. 🙂
Hi Felix
Ist es denn auch möglich, ein Servo via Potentiometer anzusteuern (natürlich per PCA9685)? Ich habe selbst schon etwas „herumexperimentiert“, bin aber zu keiner guten Lösung gekommen. Vielleicht ist es möglich, einen kleinen Beispielcode zu erhalten?
Du wärst mir eine große Hilfe.
Hi Felix,
Ist es denn auch möglich, die Position der Servos über ein Potentiometer zu regeln? Ich habe schon ein bisschen „herumexperimentiert“ aber nichts hat geklappt. Ich habe mich schon über andere Internetseiten Informiert aber ich habe keine Infos hierfür gefunden.
Es wäre super, wenn du mir hierzu helfen könntest und ggf. ein kleines Beispielprogramm gibst :-).
Hallo Zusammen,
ich bin absoluter Noob auf dem Gebiet der Programmierung. Habe mal mit Basic (war das glaube ich) ein Endlos-„Hallo. Klicke bitte nicht auf abbrechen…. Schade dass du auf Abbrechen geklickt hast“-Fenster programmiert. Das wars.^^
Ich habe mir den Rasp Zero W gekauft weil er klein und kompakt ist. Dieser soll (irgendwann mal) in einen selbst gedruckten Iron Man Helm / Anzug die benötigten Servos steuern.
Dafür wurde ebenfalls der PCA9685 angeschafft.
Dank der Anleitung eigentlich narrensicher… bis jetzt.
Sobald ich die Treiber über den Befehl „sudo pip install Adafruit-PCA9685“ installiere, steht dort, dass die Treiber schon aktuell sind. Ok
In Python dann weiter gemacht… Pustekuchen. In roter Schrift wird mir gesagt, dass etwas nicht korrekt ist.
Ok. Dann mal nachgeschaut (verwende Python 3) und jemand hat ebenfalls das Problem gehabt. Also „sudo pip3 install Adafruit-PCA9685“ eingegeben. Da kommt nichts mehr außer „Datei kann nicht installiert werden… oder so.“ Auf jeden Fall tut sich nichts. Sobald ich den Installationspfad von Github Repo eingebe sagt man mir nur, dass DIE Datei nicht geladen werden kann, DIE Datei ebenfalls nicht… usw.
Was kann das sein? Könnte es mit der nicht vorhandenen „Zusatzstromquelle“ zusammenhängen? Vielen Dank für eure Hilfe.
Gruß
Carsten
Hallo,
ich baue aktuell einen LKW mit Anhänger. Im LKW habe ich ein Adafruit PCA9685 verbaut mit dem ich Servos ansteuere. In den Anhänger soll ebenfalls ein PCA9685 eingebaut werden. Hierzu habe ich die beiden Adafruit Module miteinander verbunden und die Lötstelle A0 überbrückt. Die Beiden Adafruit-Module werden auch mit i2cdetect erkannt Adresse 40 und 41.
Für die Ansteuerung der Servos habe ich teile des Robotarmprogrammcodes genutzt. Das Modul wird ohne Adresse eingebunden.
from RobotArm.Robot import Robot
from Xbox import xbox
import time
import Adafruit_PCA9685
import RPi.GPIO as GPIO
pwm = Adafruit_PCA9685.PCA9685()
Ich habe nun 2 Varianten ausprobiert:
pwm1 = Adafruit_PCA9685.PCA9685(0x40)
pwm2 = Adafruit_PCA9685.PCA9685(0x41)
diese Variante führt zum Programmabbruch.
pwm = Adafruit_PCA9685.PCA9685(0x40)
pwm = Adafruit_PCA9685.PCA9685(0x41)
funktioniert auch nicht.
Ich hatte die Vorstellung, dass die Adressen und Channels automatisch strukturiert werden, sodass einmal Channel 0-15 und einmal Channel 16-31 zur Verfügung stehen.
Hat jemand einen guten Tipp für mich, wie ich das Problem mit Python 3 lösen kann?
Vielen Dank und schöne Grüße
Jens
Hallo Jens
ich bin derzeit auch dabei über einen Raspberry Fernsteuerungsignale einzulesen und umzusetzen.
Habe aber noch keinen Beitrag gefunden wie man die Signale ein liest die vom Empfänger kommen.
Hast du da ein Beispiel?
Dieses würde mir mit Sicherheit weiterhelfen.
Vielen Dank erst mal und melde dich bitte danke.
Hier noch der Fehlercode:
(‚Report logged‘, ‚SERVO::Move channel 0 to 50 percent. Value of 375‘)
Traceback (most recent call last):
File „control.py“, line 42, in
robot.servo.move_servo_to_percent(i, s)
File „/home/pi/XBox/RobotArm/components/Servo.py“, line 38, in move_servo_to_percent
self.move_servo(channel, value)
File „/home/pi/XBox/RobotArm/components/Servo.py“, line 28, in move_servo
self.pwm.set_pwm(channel, amount)
AttributeError: Servo instance has no attribute ‚pwm‘
Ich habs gelöst :))
Hallo, wo finde ich die Bibliotheken fuer den Robot02?
Wie kann man die Servos am Ende des Programms stromlos machen?
Du kannst die Stromzufuhr mit einem Transistor oder Relais kappen.
Danke für die Antwort, nur leider kenne ich mich mit beiden Varianten nicht aus. Habe heute im Internet recherchiert und finde leider nichts , wie die angeschlossen bzw. verbunden werden. Habe ehrlich gesagt etwas Angst,dass da was evtl. durchbrennen kann. Gibt es eventuell einen schaltplan oder Webseite wie man diese richtig anschließt? Vielen dank im Voraus
Hier ist beschrieben, wie du die Relais schaltest. Du kannst auch einfach 5V als Spannung nehmen (die Stromkreise sind getrennt): Raspberry Pi: Relais-Schalter per GPIO steuern
Ok hab es mir angeschaut. Ich sollte glaube besser mein Problem besser beschreiben. Und erstmal danke. Also ich benutze 7 servomotoren und diese sind über einen pca Modul geschaltet. Das Modul läuft über raspberry pi und pca wird bereits über externen Strom versorgt. Und jetzt möchte ich quasi am Ende eines durchlaufs eines Programms, die servomotoren Stromkosten machen ohne Stromkabel ziehen zu müssen. Vielen Dank im Voraus
Danke. Habe es mir angeschaut. Ich sollte mein Problem besser beschreiben. Sorry. Also , bei mir sind 7 servomotoren über ein pca Modul geschaltet und das Modul ist an RasPi angeschlossen. Das pca Modul wird extern mit Strom via Steckdose versorgt . Und ich möchte am Ende eines durchlaufs eines Programms die servomotoren Stromlos machen , ohne dabei Stecker ziehen zu müssen. Vielen Dank im Voraus
Hallo, ich habe folgendes Problem. Wenn ich pwm signal mit python vom servomotor auf 0 setze, passiert nichts.
Also ich gebe ein:
pwm. Set_pwm(buchstabe des motors, 0,0)
Ist quasi der Befehl.
Aber es passiert gar nichts.
Woran kann es liegen?
Er zeigt auch keinen Fehler an oder sonstiges
Ist die Verkabelung richtig? Poste bitte mal den gesamten Ausschnitt deines Skripts.
Hi Felix. Die Verkabelung ist richtig. Habe es mehrmals überprüft. Ist auch nach deinem Schema.
Danke dir für deine Bemühung. VG Herbert
import Adafruit_PCA9685 import time pwm = Adafruit_PCA9685.PCA9685(address=0x40) 1 = 0 2 = 1 3 = 3 4 = 4 pwm.set_pwm_freq(60) for i in range(0,1,1): pwm.set_pwm(1,0,350) pwm.set_pwm(2,0,150) pwm.set_pwm(3,0,210) pwm.set_pwm(4,0,340) time.sleep(1) w = True x = 150 while w is True: if x 150: pwm.set_pwm(3,0,x) x=x-1 time.sleep(0.005) if x == 150: w = False time.sleep(1) w = True x = 350 while w is True: if x 200: pwm.set_pwm(4,0,x) x=x-1 time.sleep(0.005) if x == 200: w = False time.sleep(1) time.sleep(1) pwm.set_pwm(1,0,0) pwm.set_pwm(2,0,0) pwm.set_pwm(3,0,0) pwm.set_pwm(4,0,0)Variablennamen müssen mit Buchstaben beginnen.
Hallo Felix, ich habe eine Frage zum dem time Sleep, was bedeutet in diesen Codeabschnitt time.sleep(0.005) ?
w= True x= 280 while w is True: if x > 130: pwm.set_pwm(a,0,x) x=x-1 time.sleep(0.005) if x == 130: w= FalseHallo Felix,
ich habe zwei LEDs angeschlossen und möchte diese per PWM ansteuern. Dank deines Skripts funktioniert es auch super, die Helligkeit kann dank Mosfet (vor der LED) prima reguliert werden.
Leider scheint sich das Modul bei jeder Anfrage zu resetten. Es schaltet kurz alle PWMs auf den Wert 0 und schreibt nur den Wert für den aktuellen PWM-Port.
So ist ist leider nicht möglich zwei oder mehrere LEDs unabhängig voneinander zu steuern.
Gibt es hier eine Lösung?
Moin, für die NOOBS wie mich die hier vielleicht noch ren kommen und die ein Problem an der stelle:
pwm = Adafruit_PCA9685.PCA9685(address=0x40)
haben. Updated das OS vom Raspi !
Habe jetzt das Aktuelle von 2021 drauf, damit hat Robi sich gleich bewegt. (Habe für die Lösung 3 Tage gesucht!)
Ansonsten danke für das Tutorial !
gruß Julian
Hey, wenn ich mit hilfe einer Schleife meine Servomotoren immer wieder ändere wie würde das dann ausehen.
Hallo ich habe ein Problem ich habe ein Adafruit PCA9685 Modul an einen Raspberry Pi 3 b über i2c angeschlossen und das Module wird mit 3,3v vom Raspberry Pi versorgt und mit 5v von einer externen Stromquelle. Beim Befehl i2cdetect -y 1 wird mir auch 0x40 und 0x70 wie im Tutorial angezeigt. Wenn ich den Code dann aber starte bewegt sich der Micro Servomotor SG 90 nicht, der am PCA9685 Modul angeschlossen ist. Mir wird aber auch keine Fehlermeldung angezeigt.
Code:
import Adafruit_PCA9685
import time
pwm =Adafruit_PCA9685.PCA9685(address=0x40)
pwm.set_pwm_freq(50)
pwm.set_pwm(0,0,150)
time.sleep(1)
pwm.set_pwm(0,0,0)
Hat jemand eine Idee was das Problem sein kann?
Kann man mit diesem Board auch Schrittmotoren betreiben?
Hallo Felix,
ich benötige zwei Servos die sich gleich bewegen sollen, also immer zur gleichen Zeit, die gleiche Strecke.
Der Einfachheit halber würde ich beide an dem gleichen PIN anschließen, wenn das so funktioniert.?
Gruß Klaus
Hallo,
Ich habe hier den Raspberry Pi 5 und versuche das Adafruit-PCA9685 Modul für Python3 zu installieren und komme nicht weiter.
sudo apt-get install build-essential python-dev python-smbus i2c-tools python-pip –yes
habe ich bereits ausgeführt. Mit i2cdetect -y 1 kann ich das Modul am i2c Bus sehen.
Damit ich das PCA9685 mit Python3 ansteuern kann brauche ich ja noch die Bibliotheken dafür. Die bekomme ich nicht installiert,
Gruß
Mathias
Hallo,
es fehlte was, aber ich bekomme immer die Fehlermeldung:
$ python servotest.py
Traceback (most recent call last):
File „/home/bonito/Desktop/Python/servo/servotest.py“, line 13, in
pwm = Adafruit_PCA9685.PCA9685()
^^^^^^^^^^^^^^^^^^^^^^^^^^
File „/usr/local/lib/python3.11/dist-packages/Adafruit_PCA9685-1.0.1-py3.11.egg/Adafruit_PCA9685/PCA9685.py“, line 74, in __init__
File „/usr/local/lib/python3.11/dist-packages/Adafruit_GPIO-1.0.4-py3.11.egg/Adafruit_GPIO/I2C.py“, line 65, in get_i2c_device
File „/usr/local/lib/python3.11/dist-packages/Adafruit_GPIO-1.0.4-py3.11.egg/Adafruit_GPIO/I2C.py“, line 57, in get_default_bus
RuntimeError: Could not determine default I2C bus for platform.
Kann mir jemand helfen ?
Mathias
Hallo,
das Problem ist inwischen gelöst…
Hier auf der Website
im Test Programm musste Zeile 17 pwm = Adafruit_PCA9685.PCA9685() auskommentiert werden und
Zeile 20 aktiviert werden und auf pwm = Adafruit_PCA9685.PCA9685(address=0x40, busnum=1) geändert werden.
Wieder den Wald vor lauter Bäumen nicht gesehen. Bin auch nicht drüber gestolpert. Erst als ich ein Hinweis bekam.
Gruß
Mathias