Archiv verlassen und diese Seite im Standarddesign anzeigen : [ERLEDIGT] Hilfe zum bau eines Roboterarms
Hi to@ll,
ich möchte gern klein Anfangen und erst mal ein Roboterarm mit 5 Servos bauen und programmieren in C.
Die Halterung werde ich aus den 3D Drucker erstellen/drucken.
So ähnlich wollte ichden Arm aufbauen: https://www.robotshop.com/en/lynxmotion-al5d-pltw-robotic-arm-kit.html (https://www.robotshop.com/en/lynxmotion-al5d-pltw-robotic-arm-kit.html)
Ziele:
Den Arm über die PC Tastatur per Wlan oder Bluetooth steuern (oder mit einen Android Handy evtl. auch interessant).
(Falls das für den Anfang zu komplex ist, dann per Kabel steuern und ein eigenen Tasterpanel erstellen).
Die Kommunikation zwischen Microcontroller und PC zum Programmierenauch kabellos.
Was benötige ich an Hardware?
Welche Software?
Ein Vorschlag:
Aus ähnlichem Anlass habe ich mir mal einen hobby robotic arm von Velleman gekauft. Der ist klein, aber genügt zum Probieren. Die Motoren sind klein und brauchen wenig Strom. Hier ist ein Video dazu: https://www.youtube.com/watch?v=HNpWsKflcMg
Gibt es noch immer beim C für knappe 30,- Eur (https://www.conrad.de/de/velleman-roboterarm-bausatz-ksr10-ausfuehrung-bausatzbaustein-bausatz-79655.html). Zusammenbauen muss man selber. Ist nicht alles 100%, aber zum Probieren und Kaputtspielen reicht das aus.
Später kann man ja zu Größerem und Teurerem oder zum Selbermachen übergehen.
Ich würde mit einem Arduino anfangen. Später dann vielleicht nur nodeMCU (kann WLAN, Websteuerung wäre möglich bzw. Android Handy).
es gibt zur Fernsteuerung auch Funk-Module, die die PS2-Konsole "drahtlos" verstehen können, die Pins dieses Moduls werden dann einfach mit einem Arduino und die Servos ebenfalls mit diesem Arduino verbunden (dPins):
http://www.techmonkeybusiness.com/using-a-playstation-2-controller-with-your-arduino-project.html
Ich habe so ein Teil vom Chinesen zusammen mit einem Roboterarm gekauft, wüsste aber auch gern, ob man das Funkmodul für die PS2 auch alleine kriegt. (In diem Set ist auch eine alternative Steuerplatine enthalten, die ganz ohne Arduino auskommt.)
https://www.ebay.de/itm/Assembled-6DOF-Robot-Arm-Mechanical-Robotic-Clamp-Claw-with-Servos-Controller/252317775624?hash=item3abf4fb708:g:1BQAAOSwMNxXWm9 o
Funktioniert bestens sogar mit einem Arduino Uno!
@Moppi
Danke für link und Vorschlag... ist für den Anfang zum testen eine gute, günstige Wahl.
Vielleicht kann man die Panelsteuerung später mit einen Arduino einbinden und darüber steuern.
@HaWe
Dein Link muss ich mir noch in ruhe durchlesen, sind interessant aus!
Das Ebayteil ist mir ehrlich gesagt etwas zu teuer für den Anfang.
@HaWe
Dein Link muss ich mir noch in ruhe durchlesen, sind interessant aus!
Das Ebayteil ist mir ehrlich gesagt etwas zu teuer für den Anfang.
völlig richtig, und es kommen ja nochmal Zoll und MWSt. drauf.
Einzige Vorteile: fertig aufgebaut und der PS2 WL-Controller samt Empfangsmodul mit dabei, darauf wollte ich eigentlich besonders aufmerksam machen zum Thema Fernsteuerung.
@HaWe
die Aufmerksamkeit für die Fernsteuerung hab ich :-).
Ich baue erst mal den Conrad Arm zusammen und dann schaue ich, welchen Arduino ich für den weitern Schritt benötige
@HaWe
die Aufmerksamkeit für die Fernsteuerung hab ich :-).
Ich baue erst mal den Conrad Arm zusammen und dann schaue ich, welchen Arduino ich für den weitern Schritt benötige
wenn du nur einfache Bewegungen machen willst um die Servos einzeln anzusteuern, dann reicht ein Uno oder ein Mega2560 (beide 8-bit AVR; Mega besser, da etwa 3-4x soviel RAM und 4x so viele Pins, ansonsten gleich schnell).
Wenn du komplizierte, komplexe Bewegungen machen willst zum automatisierten Ansteuern von 3D-Positionen (Kinematik, inverse Kinematik), dann brauchst du eher einen 32-bit ARM Prozessor, also einen Zero (M0) oder einen Due (M3), wegen der rechenintensiven Float-Berechnungen.
Viele Leute behaupten, die AVRs wären beser als Einstieg geeignet als die ARMs, ich selber kann das nicht bestätigen, aber manche Dinge sind leicht unterschiedlich in der Programmierung, das stimmt schon.
PS
für 5 oder mehr Servos brauchst du auch eine starke Zusatz-Spannungsquelle (6V, min. 5A).
@crusico
Diese Arme gibt es in unterschiedlichen Größen. Der Velleman von Conrad ist der Kleine. Im Video wird gezeigt, wie der auch eine Flasche hält, das geht mit dem kleinen Arm nicht. Aber der Aufbau ist identisch. Beim Zusammenbauen musst Du auf die Schräubchen achten. Am besten vorher ausspekulieren, welche wo genau hin gehören. Mir ist es so gegangen, dass ich einige wieder umschrauben musste. Von den Kleinen, wo die Servogehäuse verschraubt werden, gibt es zwei Typen, die passen, sind aber unterschiedliche Schrauben. Das merkt man, wenn man fast fertig ist und irgendwo was mit der Schraubenanzahl nicht passt. Das als Tip.
@HaWe
mehrere Servos parallel ansteuern lassen, sollte mit einen UNO reichen oder? Wenn ich das geschafft habe, baue ich später einen größeren Arm und dabei achte ich natürlich auf die Spannungsquelle. Gibt's schon Boards mit Uno und drahtlose Verbindung zum PC?
@Mppi
danke für den Tipp mit den Schrauben!
Wenn Du drahtlose Verbindung von Anfang an möchtest, könntest Du gleich ein nodeMCU nehmen. Die Programmierung der Ausgänge ist ähnlich einfach, wie beim Arduino. Zwar erfolgt die Programmierung des Boards auch per USB-Kabel (hochladen der Daten), aber Du kannst das Ding dann per WLAN steuern. nodeMCU hat ähnlich viele Ein-/Ausgänge wie Arduino Uno. Mehrere Servos parallel geht dann immer noch über Treiber-Bausteine, bzw. einfach mit einem Transistor (oder Mehreren parallel) an den Ausgängen der Boards. So muss der Strom dann nicht über das nodeMCU oder Arduino-Board laufen, was dann pro Servo schon mal bis 100mA oder etwas mehr sein könnten. Außerdem könntest Du so eine extra Spannung für die Servos wählen. Das nodeMCU wird bspw. nur mit 3.3V direkt oder 5V per USB-Kabel betrieben. Allerdings wärs beim nodeMCU an den Ausgängen kein Problem, dort kann man - trotz des anderen Logikpegels zum Arduino - einfach einen BC547 dran hängen und den Servo (über den offenen Collector gegen Masse) steuern. Ein BC547 macht max. 100mA Dauerstrom mit.
@HaWe
mehrere Servos parallel ansteuern lassen, sollte mit einen UNO reichen oder? Wenn ich das geschafft habe, baue ich später einen größeren Arm und dabei achte ich natürlich auf die Spannungsquelle. Gibt's schon Boards mit Uno und drahtlose Verbindung zum PC?
Wie gesagt, für die allerersten Anfangsschritte reicht ein UNO, aber alle die "üblichen" Arduinos haben nichts drahtloses, das musst du dann selber bauen und programmieren mit speziellen Funkmodulen.
Das wird aber kein Spaziergang im Park, das fängt schon mit den ganzen Potis/Joysticks für jede einzelne Achse an, d.h. du brauchst pro Achse 1 analogen Steuer-Eingang: das wird schon knapp mit einem Uno, besser dann doch ein Mega2560 (kostet aus China unter 10 EUR).
Ich würde dann Funkmodule auf UART-Basis empfehlen (HC05 Bluetooth etc), das ist noch mit am einfachsten.
PS,
WiFi finde ich extrem schwierig und außerdem ist es nach meiner Erfahrung nicht echtzeitfähig. Hinzu kommt, dass die zugehörigen ESP8266/ESP32 Module IMO nicht für Anfänger geeignet sind, die ESP8266 z.B. haben u.a. nur 1 analogen Eingang und auch zu viele untypische, nicht-standardmäßige Besonderheiten.
@HaWe
Irgendwie muss man sich herantasten und in das Thema reinwachsen. Die Servos kann man nur mit Strom an, Strom aus und Umpolung steuern. Sind im Grunde keine echten Servos. Nur Gleichstrommotoren, die in ein Getriebe verbaut werden.
also meine Servos von meinem Roboterarm werden mit pwm-Signalen auf die Ziel-Position gesteuert, in etwa so:
pwm 0 = -90°
pwm 127 = 0°
pwm 255 = +90°
(und alle Zwischenwerte)
per Potentiometer-Joystick, der an Analogports per analogRead von 0-1024 gelesen wird, kann man den Bereich auf 1/4 herunter-mappen und dann diesen Wert per analogWrite (pwm) auf die Servos geben, so geht das zumindest üblicherweise mit Arduino-Servo-Roboterarmen, und nur solche Typen würde ich nehmen.
@crusico:
dann achte am besten genau darauf, weche Servos verbaut sind bei dem, den du kaufen willst!
@HaWe
Nochmal: Das sind Getriebe mit Elektromotor. Guck doch mal das Video dazu an.
Wenn die Robotarme von deinem Link keine "richtigen" Servos haben, dann halte ich sie nicht für sinnvoll -
dann lieber solche Robotarme wie in meinem Link oben oder hier:
https://www.ebay.de/sch/i.html?_odkw=%28Roboterarm+%2C+%22robot+arm%22%2C+ %22Roboter+Arm%22%29+-Vellemann&_udlo=50&_udhi=200&_mPrRngCbx=1&_osacat=0&_from=R40&_trksid=m570.l1313&_nkw=%28Roboterarm+%2C+%22robot+arm%22%2C+%22Robot er+Arm%22%29+Arduino+-Vellemann&_sacat=0
insb. diesen von Saintsmart finde ich auch interessant, inkl. Arduino Mega, Robot Shield, Gyro und Fernsteuerung:
https://www.ebay.de/itm/SainSmart-6-Axis-Robot-Arm-Combo-kit-with-Remote-Control-for-Arduino-MEGA2560/222139808935?hash=item33b8907ca7:g:z9YAAOSw-itXrZJm
Die Motoren sind ungesteuert in der Geschwindigkeit. Die laufen immer mit voll Power. Aber durch die Übersetzung, lässt sich das trotzdem gut über die Zeit steuern. Sehr genaue Endpositionierung ist so nicht möglich, weil die Motoren lange nachdrehen. Allerdings könnte man das Plastikgetriebe fetten, dann wäre das mit dem Nachlauf der Motoren vielleicht sogar behoben, weil die Getriebe sehr leichtgängig sind.
Das ist und bleibt fürs Erste eine Spielerei.
Wie gesagt, ich finde einen mit echten Servos, die definierte Positionen anfahren können per pwm Befehl (wie von saintsmart) deutlich besser geeignet - muss der OP ntl einscheiden.
Ah so, das sind nur Getriebemotoren verbaut... für den Anfang reicht das. Später sollen es aber Servos sein. Erstmals den Mechanik Aufbau lernen und evtl. kann ich ja die Getriebemotoren gegen Servos umbauen.
@HaWe
der Mega2560 ist schon ein großes Board in Vergleich zu Uno oder nano. Gehts mit den kleinen auch?
Also heißt das, ich benötige als Hardware z.B.
-ein Arduino Uno + HC05 Bluetooth als Empfänger
-ein ISP Programmer mit HC05 Bluetooth als Sender
erst mal, das nachträgiche Austauschen wird u.U nicht so einfach möglich sein, denn die Servos haben eine ganz andere Achs-, Befestigungs-, Antriebs-Mechanik und -Geometrie. Auch die Steuerprogrammierung muss komplett anders sein.
Fang also besser gleich mit einem Servo-Robotarm an.
Und bevor du mit BT anfängst: bau die Steuerung erstmal mit Kabeln, BT kannst du später immer noch dazwischensetzen.
Der Mega2560 ist nicht nur von den Pins her sondern auch vom RAM besser ausgestattet und daher auch für Mehrachs-Roboter geeigneter, das wirst du schon brauchen.
Der Uno ist möglich für den Anfang, ansonsten schon sehr eingeschränkt - aber er kostet nun auch nicht die Welt.
Um einen Mega oder noch leistungsfähigere Boards wirst du aber wschl nicht herumkommen (der Due ist vom Board her dem Mega2560 sehr ähnich, aber etwa 10-20x so schnell und hat auch ca. 10x so viel RAM).
Aber viele Wege führen nach Rom - alles weitere wurde IMO auch bereits gesagt.
- - - Aktualisiert - - -
PS,
für Arduinos brauchst du keinen ISP Programmer, Arduinos haben die Programmer bereits per USB-Schnittstelle eingebaut, das macht das alles 1000x einfacher.
Na ja, deshalb fand ich den Film gut. Weil dort sieht man, wie alles zusammengebaut wird und wie es funktioniert. Aber anscheinend hat sich das auch keiner richtig angeschaut.
So gesehen, ist es technisch der einfachste Aufbau, den man sich für so einen Arm vorstellen kann. Es kommt immer drauf an, was man damit machen will. Mir ging es erst mal nur darum zu sehen, wie so ein Teil funktioniert, wenn es zusammengebaut ist. Da kann man verschiedene Dinge schon gut erkennen. Wie Statik so eines Arms und theoretisch möglicher Funktionsumfang, Aktionsradius. Dabei erkennt man dann auch die Schwächen und wird gewahr, was man noch benötigen würde, um es für einen bestimmten Zweck einsatzbereit zu machen. Man weiß einfach hinterher, worauf es ankommt. Also ein Lernobjekt, sozusagen. Deshalb habe ich das Teil eingepackt, zusammengebaut rumstehen.
Wenn man schon weiß, was man genau will, muss man sich einen Plan machen, welche Anforderungen an das Teil gestellt werden. Dafür allerdings muss man in etwa wissen, worauf es bei so einem Arm ankommt. Und dafür ist es nicht schlecht, wenn man Grundlagenwissen hat. Ich finde, wenn man weder vom Programmieren noch von Technik wirklich was versteht, dann ist so ein Teil ein guter Einstieg, wie übrigens auch der Arduino Uno. Und da wiederum kann ich das Arduino-Starter-Kit, was es auch bei C gibt. Das ist zwar etwas "teuer" aber man hat schon viele Teile dabei. Wie den Arduino Uno, Motortreiber (H-Brücke) oder Servomotor oder Gleichstrommotor, LEDs, Steckboard etc, etc. auch Steckkabel, USB-Kabel ... eben alles was man so braucht, auch Fotowiderstände sind dabei, Widerstände, Kondensatoren, Transistoren, Potentiometer usw. Sogar eine LCD-Anzeige. Alles ist genau erklärt. Man findet viele grundlegende Anwendungsbeispiele, für Sachen, die man immer wieder brauchen kann.
Den Arm habe ich am WE bekommen und zusammen gebaut, ist schon eine günstige/einfache Hardware. Ich werde es heute mal testen, ob alle funktioniert.
Einen Arduino Uno hatte ich die Tage günstig gesehen und bestell,ich denke, dass ich erst mal damit Anfangen werde und der ziel wird dann sein:
Denn vorhanden Controllpannel abklemmen und dort den Uno + 10 Taster einbauen. Wenn das klappt, dann weiter...
Für die Motorsteuerung kannst Du eine H-Brücke verwenden. Hier ist sowas erklärt, wie das aufgebaut ist und programmiert wird: https://www.arduino-tutorial.de/motorsteuerung-mit-einem-h-bridge-ic/
@Moppi
danke für den link...wie seht es aus, zwei der drei L293D´s kann ich auch mit den Uno betrieben oder? Weil auf den Bild sind 6 Pins mit PWM gekennzeichnet.. ich dachte, dass das Board Uno nur 3 PWM Ausgänge hat?
Achso, habe ich nicht gesehen, dass die am PWM hängen!
PWM benötigst Du nur zur Geschwindigkeitsregelung des Gleichstrommotors. Ansonsten kann man das auch einfach per AN/AUS steuern. Die PWM-Ausgänge kann man als einfache Ausgänge definieren und dann einfach mit LOW und HIGH steuern (also Strom an/ Strom aus).
Pro Steuerung eines Motors brauchst Du 3 Leitungen (Ausgänge).
Der Arduino hat 12 Ausgänge (ohne serielle Schnittstelle), das reicht aus für 4 Motoren.
5 Motoren hast Du. 4 für den Arm und 1 für den Greifer. Da müsstest Du noch einen Multiplexer dazwischenschalten. Darüber könntest Du auswählen welchen Motor Du steuern willst. Einen von zwei Motoren könntest Du dann immer wechselnd ansteuern. Die anderen 3 Motoren parallel dazu. Oder Du nimmst einen zweiten Arduino Uno und hängst schaltest den zusammen, mit dem andern Arduino.
Einen einfachen Multiplexer könnte man aus einem 74HC132 aufbauen, denke ich. Oder gleich einen SN74LS257BN nehmen.
33647
Wenn ich das richtig verstanden habe, wird das PWM-Signal an den Aktivierungspin 1 und 9 geführt. Pin 2 und 7 der H-Brücke sind für die Richtung zuständig. Wenn diese beide Pins auf HIGH oder LOW geschaltet sind, steht der Motor. Ergo könnte man auch einfach an einem L293D die Pins 1 und 9 zusammenschalten und einem PWM-Ausgang des Arduino zuführen. Damit gelangt das PWM-Signal an beide Seiten des IC gleichzeitig. Dann würde Pin2 und Pin 7, sowie Pin 10 und Pin 15 darüber entscheiden, welcher Motor läuft. Indem jeweils das eine Paar oder das andere Paar gemeinsam auf LOW oder HIGH geschaltet wird. Dann braucht man keine extra IC mehr.
ich sagte ja bereits: nimm einen Mega2560, der Uno ist zu wenig geeignet - was war daran nicht zu verstehen?
wenn du L293 Brücken nimmst, solltest du sie pro Motor mit in1,in2,pwm verkabeln, das sind schon 3 Pins pro Motor.
Da DC Motoren keine Stellung erkennen, brauchst du dafür nochmal 2 Pins für Rotationsencoder, also 5 Pins pro Motor.
Das macht bei 4 DOF 20 Pins, bei 5DOF 25 Pins: Das macht mit Unos ÜBERHAUPT KEINEN Sinn.
Servomotoren hingegen brauchen nur 1 pwm Pin pro Motor, die Stellung wird halbwegs genau automatisch angefahren, dafür reicht zur Not GERADE ein Uno.
Für UART (2), i2c (2) und SPI(3) ports gehen insgesamt nochmal insgesamt 7 Pins verlustig, und weitere einfache Schalter/Taster je 1 weiterer Pin.
Damit ist der Uno soweit ausgelastet, dass er Pin- und Speicher-mäßig bereits kurz vor dem Abgrätschen ist.
Und jetzt rate, warum ich das oben entsprechend empfohlen habe... :-/
Das heißt, wenn ich 5 Motoren steuern will, brauche ich 2 SN74LS257BN dahinter kommen dann noch 2 L293D?
nein, 3x L293D und 1 Arduino Mega.
@HaWe
Ok da mit Mega ist jetzt klar und muss mir noch einen besorgen.
Zur Zeit habe ich nur einen Uno hier lieg, damit lässt sich das so einfach nicht realisieren... schade
Oder 1 Arduino Uno und eine andere Beschaltung. Indem man die Akttivierungspins eines L293D zusammenschaltet. Dann braucht man pro L293D noch 5 Leitungen für 2 Motoren. 10 Leitungen für 4 Motoren. Und 13 Leitungen für 5 Motoren. Damit könnte man dann immer 3 Motoren, von 5, zur selben Zeit ansteuern.
11 Leitungen würden benötigt, wenn man alle Aktivierungspins zusammenschaltet.
mit Aktivierungspins zusammenschalten: das ist Murks!
Dann laufen die manchmal schon beim Booten unkontrolliert los.
Machs vernünftig!
Und steck keine unnütze Energie und Material in den Uno!
mit Aktivierungspins zusammenschalten: ....
Dann laufen die manchmal schon beim Booten unkontrolliert los.
Bitte mal erklären, warum die das tun sollen! Wenn die Ausgänge des Arduino undefiniert flackern würden, dann würden die so oder so unkontrolliert los laufen. Ob beim Uno oder beim Mega. Solange die Aktivierungspins nicht aktiviert sind, also kein High-Signal anliegt, laufen die Motoren sowieso nicht. Und solange die andern Eingänge dasselbe Signal erhalten, laufen die Motoren auch nicht. Außerdem reagieren die Motoren aufgrund ihrer natürlichen Trägheit so schnell auch nicht, dafür muss sich erst ein Magnetfeld aufbauen, was seine Zeit dauert.
Einen Uno hat er schon, einen Mega muss er erst kaufen.
Ist erfahrungsgemäß so bei L293 2-Pin-Steuerung statt 3-Pin-Steuerung.
Das ganze macht aber eh keinen Sinn ohne Rotationsencoder bzw. ohne Servos.
Aber murkst euch eben irgendwas zurecht, ich bin dann hier raus!
https://www.bing.com/images/search?view=detailV2&ccid=C28JEk0U&id=41547D992F30078E03CDA61E40D70D51DD2FAF38&thid=OIP.C28JEk0UEwRUM29giJ3ycgHaEj&mediaurl=https%3a%2f%2fwww.robomart.com%2fimage%2f catalog%2fRM0055%2f01.jpg&exph=298&expw=484&q=H-Bridge+IC+mit+4+Motoren&simid=608005971116952354&selectedIndex=67&ajaxhist=0
(https://www.bing.com/images/search?view=detailV2&ccid=C28JEk0U&id=41547D992F30078E03CDA61E40D70D51DD2FAF38&thid=OIP.C28JEk0UEwRUM29giJ3ycgHaEj&mediaurl=https%3a%2f%2fwww.robomart.com%2fimage%2f catalog%2fRM0055%2f01.jpg&exph=298&expw=484&q=H-Bridge+IC+mit+4+Motoren&simid=608005971116952354&selectedIndex=67&ajaxhist=0)Das habe ich in Netz gefunden, aber ich glaube, das es nicht das richtige ist oder? 2 Pins pro Motor...
Also ich höre mir gern zwei Meinungen an und wenn es machbar ist, teste ich die auch. Bitte nicht gegenseitig hier das Thema "erwärmen" Ich bin um jede Hilfe dankbar! Und ich möchte gern es richtig beigebracht bekommen.
Man kann immer mehrere Wege beschreiten. Entweder man macht etwas über Multiplexer, dann spart man I/O-Ports oder man macht es über Parallelanschaltung, dann benötigt man mehr I/O-Ports. was nun dazu kommt, ist, dass Du sicher noch Eingänge benötigen wirst. Deshalb käme man beim Arduino Uno nicht um einen Multiplexer für die Ausgänge herum. Bei den Eingängen kann es dann ähnlich aussehen. Bei einem Multiplexer legst Du immer zuerst eine Adresse an. Bei 2 Bit (2 Ausgänge) sind das 4 Zustände: 0-0, 0-1, 1-0, 1-1. Der Multilexer schaltet, je nach Auswahl, das Logiksignal des Eingangs auf einen von vier Ausgängen. Damit könnte man einen PWM-Ausgang auf 4 Ausgänge am Multiplexer durchschalten, mit 2 Adressleitungen. Würde man 3 Ausgänge zur Adressierung verwenden, wären das 8 Zustände: 0-0-0, 0-0-1, 0-1-0, 0-1-1, 1-0-0, 1-0-1, 1-1-0, 1-1-1. Damit könnte man ein PWM-Signal mit 3 Adressleitungen auf 8 Ausgänge durchschalten. Man würde mit 4 Ausgängen 8 ansteuern können, allerdings nicht gleichzeitig.
Der Arduino Mega hat einfach mehr Ein- und Ausgänge, so dass man keinen Umweg gehen müsste.
Bei Deinem Link oben, ist der Aktivierungspin auf HIGH gelegt, damit dreht der Motor entweder in die eine oder die andere Richtung, mit konstanter Drehzahl. Das wäre auch möglich! Dann hast Du pro Motor 2 Leitungen vom Arduino, das macht dann 10 Leitungen, bei 5 Motoren. 12 Leitungen hättest Du am Arduino Uno und dann noch die serielle Schnitstelle (Pin 0 und 1). Aber die Drehzahl ist dann nicht steuerbar. Das entspricht dann der manuellen Handhabung dieses einfachen Roboterarmes, nur dann über Arduino. Die Änderung der Motordrehzahl ist ja beim dem Arm eigentlich nicht vorgesehen. Wäre aber sicher: :cool: .
Ohne Steuerung der Drehzahl über PWM ist es dann noch etwas einfacher. Pro Motor legt man jeweils 2 Leitungen an den Arduino. Die Pins am Arduino müssen als Ausgang geschaltet sein. Bei 0-0 an den Asugängen des Arduino würde der Motor stehen, bei 1-1 an den Ausgängen des Arduino würde der Motor stehen. Bei 1-0 an den Ausgängen des Arduino würde er in eine Richtung drehen und bei 0-1 in die andere Richtung.
@Moppi,
Wenn man mit den Multiplexer nur einzeln und nicht parallel die Motoren ansteuern kann, kann ich diese Lösung für mein Vorhaben nicht gebrauchen.
Also bleibt nur noch der Maga + 3xL293d übrig oder?
Die drei L293D kannst Du auch am Arduino Uno betreiben. Wenn Du auf PWM verzichtest. Wie gesagt, das ist bei dem Arm ja nicht vorgesehen, dass der drehzahlgesteuert betrieben wird. Sondern nur mittels Motor An und Motor Aus, in die eine oder die andere Richtung. Zwei Leitungen für 5 Motoren = 10 Steuerleitungen. 12 I/O-Ports stehen am Uno zur Verfügung (ohne dem ser. Port). Du hast dann noch 2 I/O-Ports am Uno übrig. Und dazu noch 5 Analoge Eingänge zur Konvertierung Analoge Spannung in digitalen Wert. Die analogen Eingänge könnte man auch noch als Digitale missbrauchen. Denn wenn Du die ausliest, bekommst Du einen Wert, der der Höhe der angelegten Spannung entspricht. Ein digitales High-Signal am analogen Eingang entspricht dann einem Wert von größer 500. Ein digitales Low-Signal am Analogeingang entspricht dann einem Wert von kleiner 350. Meist sind die Unterschiede noch größer, so dass Low einem Wert von kleiner 10 entspricht und High einem Wert größer 800. Auf diese Weise hat man noch 5 Eingänge und 2 Ausgänge übrig. Ser. Schnittstelle sind nochmal 2 digitale I/O Ports.
Willst Du später noch Sensoren dran machen, könntest Du einen Arduino Mega nehmen. Um alles auf einem Board zu steuern. Der Mega hat schon 54 digitale I/O-Ports.
Hier sind mal alle Arduino Boards, Unterschiede beschrieben: https://www.generationrobots.com/blog/de/auswahl-arduino-board/
Du solltest auch mal ein Auge auf das Arduino Mega ADK werfen.
Für 5 Motoren mit PWM-Steuerung sind das 15 Ports. Dann bleiben noch 39 übrig. Die Analogen kommen noch dazu.
Wenn der Arm bewegt wird, brauchst Du maximal 4 Motoren davon. Der Fünfte ist für den Greifer (auf und zu).
Zur Verdeutlichung
Ich habe mal die Schaltung aufgebaut:
33648
In der ganzen Wuselei habe ich die wichtigen 2 Kabel in Grau gesteckt.
Grau: Das sind die beiden Datenkabel, mit denen der Arduino auf Pin#2 und Pin#7 den Motor steuert.
Orange: 5V vom Arduino zum IC und 5V zum Motor, als "+".
Rot: Kabel "+" vom Motor.
Schwarz: Kabel "-" vom Motor.
Braun: Aktivierungspin am IC, ist auf +5V angeschlossen, damit der Motor drehen kann.
Grün: "+" Versorgungsspannung für Motor.
Gelb: "-" Versorgungsspannung.
Blau: Masse "Ground" vom Arduino zur Außenbeschaltung.
Statt den Motor an 5V anzuschließen (links außen orangenes Kabel), kann man den auch an 9V oder 12V anschließen oder eine andere Spannung. Der Motor läuft übrigens nicht von alleine an, wenn das Board bootet, also an Spannung angeschlossen wird. Erst, wenn im Programm die Pins entsprechend auf LOW und HIGH gesetzt sind.
für den Arduino das Programmbeispiel:
void setup() {
pinMode(2, OUTPUT); // Port als Ausgang schalten
pinMode(7, OUTPUT); // Port als Ausgang schalten
}
void loop() {
//Motor steht
digitalWrite(2, LOW);
digitalWrite(7, LOW);
//Pause 5 sec
delay(5000);
//Motor Richtung 1
digitalWrite(2, HIGH);
digitalWrite(7, LOW);
//Pause 2 sec
delay(2000);
//Motor Richtung 2
digitalWrite(2, LOW);
digitalWrite(7, HIGH);
//Pause 2 sec
delay(2000);
}
Hier nochmal ein anderer Link: https://www.maxphi.com/dc-motor-interfacing-arduino-tutorial
Wechselnde Motorsteuerung
Um zwei Motoren abwechseln zu steuern, kann man Enable-Pin#1, vom L293D über einen Inverter ansteuern und den Enable-Pin#9 direkt. So geht dann ein Ausgang, des Arduino, direkt auf den Pin#9 oder #1 und außerdem an ein Nicht-Gatter. Das Nicht-Gatter geht am Ausgang auf den zweiten Enable-Pin, des L293D. Je nachdem, ob der Ausgang am Arduino dann LOW oder HIGH geschaltet ist, ist dann entweder der eine Motor oder der andere Motor, von zweien, aktiviert. So kann man zwei Motoren an einem L293D mit 3 Leitungen vom Arduino abwechselnd steuern.
33649
Wenn man nur einen Inverter benötigt, kann man den z.B. auch aus einem NPN-Transistor und mit zwei Widerständen aufbauen: Eingang über 1MOhm, an Basis Transistor; Kollektor Transistor über 10kOhm an +5V; Emitter Transistor an Ground; Ausgang ist dann direkt am Kollektor Transistor.
Wenn man den Greifer und einen anderen Motor nur im Wechsel ansteuert (was kein Problem darstellt und im Endergebnis nicht störend ist), dann braucht man 3 Leitungen, um zwei Motoren abwechselnd zu betreiben (statt 4 Leitungen). Auf obige Weise kann man weitere Motoren abwechseln betreiben. Man kann 4 Motoren betreiben, wovon jeweils 2 aktiv sind und benötigt 6 Steuerleitungen. Man kann 6 Motoren betreiben, wovon 3 aktiv sind und benötigt 9 Steuerleitungen.
Man könnte das bei zwei Motoren auf 3 Leitungen reduzieren, wenn jeweils nur ein Motor zur Zeit angesteuert wird.
Hierzu mein Vorschlag:
33650
Damit hätte man 3 Leitungen eingespart (3 Ausgänge am Arduino).
Ausgangsvervielfachung mit 74HC595
Da ich mich gerade mit dem Thema beschäftige, bin ich, nach sehr langer Zeit, wieder mal über Schieberegister gestolpert. Damit kann man mit 3 Steuerleitungen 8 digitale Ausgänge realisieren. Man kann, wenn man mehrere Schieberegister hintereinanderschaltet, auch mit 3 Leitungen dann 16, 24, 32, 40, 48, 56 oder noch mehr Ausgänge ansteuern. Dabei wird jeweils 1 Bit an das erste Schieberegister übergeben und mit einem Takt weiter geschoben. Nach entsprechender Taktzahl sind dann alle Bit im Register und werden mit einem weiteren Signal am 74HC595 an die Ausgänge des Schieberegisters übernommen (Latch-Schieberegister).
@Moppi,
vielen dank für die Tolle Erklärung!
Ich werde das erst mal so testen und Bericht erstatten, erst mal drei L293d bestellen und wenn ich dabei bin, werde ich auch einen Mega dazu bestellen.
Ich würde gern später das mit der Drehzahlsteuerung auch testen und dafür brauche ich ja einen Mega.
Das mit den Schieberegiester lass ich erst mal. Erst den ersten step machen...
Wenn das alles soweit klappt, wollte ich gern den Board mit einen bluetooth verdrahten und dann mit der App 'blynk' den Arm steuern. (sollte ja für klappen oder?)
Ich habe der Vollständigkeit halber verschiedene Wege aufgezeigt. Grundlagen braucht man immer. ;-) Richtig haarig wird es, wenn man RAM-Speicher ansteuert. Diese ICs haben meist 8-Daten-Pins, aber dafür umso mehr Adress-Pins (>16 Stück bspw.).
021aet04
18.09.2018, 18:05
Der L293 ist extrem alt. Ich würde modernere Alternativen suchen. Am Besten bei den Herstellern selbst (TI.com (http://www.TI.com), Linear.com (http://www.Linear.com),...) oder bei großen Distributoren, auch wenn du nicht dort bestellst oder bestellen kannst (RS-Components, Distrelec, TME,.....).
Ich arbeite gerade mit dem L6205 (ist aber auch nicht der neueste).
MfG Hannes
Habe oben nochmal eine Aktualisierung eingebracht: 2 Motoren mit 3 Arduino-Ausgängen.
Hier in diesem Thema muss man auch noch mal auf ein anderes Problem hinweisen, dass Anfänger nicht bedenken, weil sie es nicht wissen können:
Selbst mit GHz-Prozessoren ist Echtzeitsteuerung komplexer Anlagen, schwierig bis unmöglich. Sowohl Softwarearchitektur, als auch Hardwarearchitektur machen hier einen dicken Strich, mitten durch diese Ideenblase.
Wenn ich also ein Board mit möglichst vielen I/O-Ports verwende, kann ich zwar viel anschließen, aber noch lange nicht zur selben Zeit steuern. Wenn nun zu 5 Motoren, die sich zur selben Zeit bewegen sollen und auch aktiv gesteuert werden müssen, noch Sensoren hinzukommen, deren Werte man erfassen und dann vielleicht auch noch kompliziert berechnen will, ist die Leistungsgrenze schnell erreicht. Für solche Aufgaben verwendet man eher aktive, statt passive Aktoren/externer Baugruppen. Das heißt nichts anderes, als dass man lieber mehrere kleinere Controller einsetzt, von denen jeder seine Arbeit übernimmt (dass dann ziemlich in Echtzeit) als nur einen einzigen Controller, der alles selber erledigen soll. Verschiedene Sensorbaugruppen sind bereits so aufgebaut, dass ein Sensor und ein IC zur ersten Datenverarbeitung auf der Platine untergebracht sind, die dann mit einem Master-Controller (Arduino Uno / Mega oder PIC etc.) kommunizieren. Servomotoren gehören auch zu den aktiven Aktoren, weil sie zum Beispiel einen bestimmten Winkel selbstständig anfahren können, sie besitzen schon die notwendige Steuerungselektronik dazu. Ein Master-Controller setzt dann nur einen Befehl an den Motor ab und steuert ihn nicht mehr aktiv selber. Deshalb lieber mal mit wenig anfangen, sich reinfuchsen - lernen und verstehen - und sich dann ein System, dass man benötigt, zusammenstellen. Das nächste Problem entsteht schon, wenn man Controller alleine betreiben will, ohne umfangreiche, externe Beschaltung. Einen Controller vom Arduino Uno kann man noch einfach so auf eine Lochrasterplatine setzen. Bei einem Controller vom Arduino Mega wird es schon schwieriger. Kosten spielen hier auch eine Rolle. Wenn man darüber nachdenkt, wie man Aufgaben auf mehrere Controller verteilt, um Dinge möglichst in Echtzeit zu erledigen, wird man schnell feststellen, dass es für ganz ausgefallene Fälle sinnvoll ist, mehr I/O-Ports zu haben, dass man aber für die meisten Fälle mit weit weniger auskommt. Oben habe ich ja schon ein wenig aufgezeigt, wie man so Dinge auch schaltungstechnisch optimieren kann. Solche Vorgänge nennt man auch Planung oder Entwicklung. Das ist ganz normal und gehört zur "täglichen Arbeit". Und ist, wie schon gesagt, auch notwendig, um Ziele plangerecht zu erreichen.
Damit ist dieses Thema noch nicht abgearbeitet, aber soll hier erst mal von meiner Seite dazu genügen.
Gruß, Moppi
es geht mit der Simultanausführung auch schon viel einfacher, mit einem Mega2560 z.B. oder einem Due, und mit Rotationsencoder-Motoren, die man eh braucht, wenn man keine Servos hat:
PD-Steuerung (PID muss nicht unbedingt sein) pro Motor,
globale flags für jeden Motor (true für Ziel noch anzusteuern, false für "idle")
große while () Schleife für jede Simultanausführung:
wenn Zielencoder nicht erreicht ist, neuen Regelwert eingeben,
und wenn erreicht ist auf brake oder coast stellen und flag für diesen Motor auf "false" (Ziel erreicht).
while() Schleife laufen lassen, bis alle flags für alle Motoren auf false sind (alle Ziele erreicht, keine Steuerung mehr).
Das kann man in eine Funktion packen, der man alle Flags und Zielwerte übergibt, und die zurückmeldet (globaler Flag oder Rückgabewert), wenn alles fertig ist.
Alternative, ebenfalls erfolgreich probiert:
Multithreading mit Scheduler libs (gibt es von 2 verschiedenen Autoren (cmaglie oder mpatil) für ARM-MCUs und auch für beliebige ARMs+AVRs), pro Motor ein Scheduler thread,
threads laufen leer wenn Motor flag auf false steht, ansonsten wie oben.
Dass Motoren bei 2-Pin Steuerung unbeabsichtigt anlaufen passiert aber doch, allerdings nicht immer für alle Pins sondern nur für einige spezielle beim Bootvorgang, wenn die dann auf HIGH oder LOW gezogen werden.
Daher 3-Pin-Steuerung bei L298/L293-Steuerlogik, und die gibt es auch für andere H-Brücken mit anderen Chips von anderen Herstellern.
Aber wie gesagt: Servos sind viel einfacher, weil man
a) keine Encoder auslesen muss und man
b) keine H-Brücken braucht.
Guten (https://Guten) Morgen,
die L293d sind an Wochenende angekommen und ich habe mal ein Motor mit 2 Anschlüssen angeshlossen/getestet ohne Board.
Funktioniert.
Als nächstes werde ich das mal mit drei Anschlüsse (+PWM steuern) und Board mal testen...
Wenn das klappt, dann Platine Entwerfern für die drei L293d.
Gibt es schon fertige Platinen für drei L293d
So was:
https://www.ebay.de/itm/L293D-Motor-Shield-Modul-Antriebs-Schild-IC-Vorstand-fuer-Arduino-Mega-UNO-3230-/183392083438?oid=361452902602
für das Geld lohn es sich nicht selber eine zu entwickeln oder?(shit, ist nur 4 Motoren ausgelegt)
oder "leere" Platinen, die man auf den Board verbauen kann=?
Und wenn dieser Punkt auch geschafft ist, dann Bluetooth an Board verbauen.
Vorteile von Servos verstehe ich, aber erst mal diesen Arm mit Gleichstrommotoren steuern. Danach kommen die Servos
Guten (https://Guten)
Gibt es schon fertige Platinen für drei L293d
ich würde solche Dinger kaufen (hab sie auch selber) und nebeneinander montieren:
https://www.ebay.de/sch/i.html?_odkw=Arduino+%28L293%2C+L298%29&_udhi=1%2C80&_mPrRngCbx=1&_osacat=0&_from=R40&_trksid=m570.l1313&_nkw=Arduino+%28L293D%2C+L298%29&_sacat=0
Ah, das ist doch mal akzeptabel... also 3St.davon Skizze habe ich mal schon angefangen:
Lieferung dauert.. melde mich danach
piggituX
03.10.2018, 11:40
Moin Crusio,
den ebay link vom dem Shield ist die Alte Version 1 es gibt inzwischen ein neues Shield, vllt reicht das ja einfach schon aus :)
https://learn.adafruit.com/adafruit-motor-shield-v2-for-arduino?view=all
Wenn ansonsten die Dinger die HaWe schon gepostet hat, braucht zwar bissel mehr Platz aber tut es auch. Kann man ja schön Modular aufbauen, wegen Wartung :D
cya
So,
die Teile sind angekommen...ich werde die Tage diese verkabeln und dann schauen wir weiter
Schön dass es endlich weiter geht! :)
MfG
Projekt lag auf Eis... Jetzt mehr Zeit duchr Corona und versuche weiter zu basteln....
Hallo!
Immer dran bleiben.
Wie weit bist Du denn?
MfG
PS: diesen Arm gab es in zwei Ausführungen. Einmal zur Steuerung per PC und einmal per manueller Bedienung.
Hattest Du schon Fett in den Getrieben? Weil die Motoren lange Zeit nachlaufen. Eine genaue Positionierung wird dann schwer.
Wie letztes Post, noch am Anfang. :-(
Weiter Verkabel und erstmal den Mega 2560 genau anschauen. Die digital Ausgänge 22 bis 53 kann ich nehmen oder für die 18 Signale?
Ich verwende maximal den Arduino UNO. Ich besitze keinen Mega2560. Aber für die Arduinos gilt immer:
- es gibt I/O-Ports, die können PWM
- es gibt Ports, die können Digital
- es gibt Ports, die können Analog
- es gibt Ports, die können einen Interrupt auslösen, wenn am Eingang ein entsprechendes Signal anliegt
Welche Ports das sind, steht z.B. auf Arduino.cc. Dort ist, meist bei den Funktionen, eine Liste, welche Pins / Ports der Arduino Boards verwendet werden können und welche Besonderheiten es gibt.
So zum Beispiel für:
- analogWrite() / PWM: https://www.arduino.cc/reference/en/language/functions/analog-io/analogwrite/
- attachInterrupt() / interruptfähige Eingänge: https://www.arduino.cc/reference/en/language/functions/external-interrupts/attachinterrupt/
Außerdem sind bei den Boards die Pins beschriftet mit ihrer Funktion: Digital, Power, Analog-In, PWM usw. So, wie hier: https://www.circuitstoday.com/arduino-mega-pinout-schematics
Da der Mega genügend Pins hat, solltest Du keine Probleme haben, welche auszusuchen. Musst nur auf die Funktion achten.
MfG
Also soweit ist das Verstanden habe, kann ich die Digital Ports nehmen beim MEGA 2560. Ich habe mal grob aufgeschrieben welche ich dafür nehmen würde (siehe Bild)35324.
Die In/Out Ports kann ich ja nehmen oder?
Programm für erstmal ein Motor testen würde so aussehen:
//Variable deklarieren+++++++++++++++++++++++++++++++++++++++ ++++++++++
//IC1.............
//1.Motor
int 1MotorEin=22;
int 1MotorOut1=24;
int 1MotorOut2=26;
//2.Motor
int 2MotorOut3=28;
int 2MotorOut4=30;
int 2MotorEin=32;
//IC2.............
//3.Motor
int 3MotorEin=34;
int 3MotorOut1=36;
int 3MotorOut2=38;
//4.Motor
int 4MotorOut3=40;
int 4MotorOut4=42;
int 4MotorEin=44;
//IC3.............
//5.Motor
int 5MotorEin=46;
int 5MotorOut1=48;
int 5MotorOut2=50;
//Taster
//1.Motor
int Button1MotorRechts=31;
int Button1MotorLinks=33;
//Hardware Ein-/Ausgänge setzen++++++++++++++++++++++++++++++++++++++++++
void setup() {
pinMode(Button1MotorRechts, INPUT); // Port als Eingang schalten für 1 Motor Rechts Test
pinMode(Button1MotorLinks, INPUT); // Port als Eingang schalten für 1 Motor Links Test
pinMode(1MotorEin, OUTPUT); // Port als Ausgang schalten
pinMode(1MotorOut1, OUTPUT); // Port als Ausgang schalten
pinMode(1MotorOut2, OUTPUT); // Port als Ausgang schalten
pinMode(2MotorEin, OUTPUT); // Port als Ausgang schalten
pinMode(2MotorOut3, OUTPUT); // Port als Ausgang schalten
pinMode(2MotorOut4, OUTPUT); // Port als Ausgang schalten
pinMode(3MotorEin, OUTPUT); // Port als Ausgang schalten
pinMode(3MotorOut1, OUTPUT); // Port als Ausgang schalten
pinMode(3MotorOut2, OUTPUT); // Port als Ausgang schalten
pinMode(4MotorEin, OUTPUT); // Port als Ausgang schalten
pinMode(4MotorOut3, OUTPUT); // Port als Ausgang schalten
pinMode(4MotorOut4, OUTPUT); // Port als Ausgang schalten
pinMode(5MotorEin, OUTPUT); // Port als Ausgang schalten
pinMode(5MotorOut1, OUTPUT); // Port als Ausgang schalten
pinMode(5MotorOut2, OUTPUT); // Port als Ausgang schalten
}
void loop() {
if ((digitalRead(Button1MotorRechts)==HIGH) && (digitalRead(Button1MotorLinks)==LOW)) {
//1 Motor Drehrichtung Rechts
digitalWrite(1MotorEin, HIGH);
digitalWrite(1MotorOut1, HIGH);
digitalWrite(1MotorOut2, LOW);
} else {
//1Motor steht
digitalWrite(1MotorOut1, LOW);
digitalWrite(1MotorOut2, LOW);
}
delay(10); // Kleine Pause
if ((digitalRead(Button1MotorRechts)==LOW) && (digitalRead(Button1MotorLinks)==HIGH)) {
//1Motor Drehrichtung Links
digitalWrite(1MotorEin, HIGH);
digitalWrite(1MotorOut1, LOW);
digitalWrite(1MotorOut2, HIGH);
} else {
//1Motor steht
digitalWrite(1MotorOut1, LOW);
digitalWrite(1MotorOut2, LOW);
}
delay(10); // Kleine Pause
}
Frage: Benutze ich PWM? Mit PWM kann ich Motoren ansteuern (Umdrehungszahl). Einen Motor kann ich auch ohne PWM steuern, nur per Schalter.
Benutze ich kein PWM, dann stehen mir alle Digitalausgänge inkl. der PWM-Pins zur Verfügung.
"Die In/Out Ports kann ich ja nehmen oder?"
Nimm ein Steckbrett, stecke einen 330 Ohm-Widerstand darauf, stecke an den Widerstand eine große LED (~5mm Durchmesser) und das andere Bein gegen GND (ich meine das müsste das kürzere Bein sein). Das noch offene Ende vom Widerstand verbindest Du mit einem I/O-Pin am Arduino-Board. Beschreibe den Port mit "digitalWrite(Pin, HIGH)", nachdem Du "pinMode(Pin, OUTPUT)" ausgeführt hast. Wenn die LED hell aufleuchtet, kannst Du diesen Pin nehmen. Weil a) fungiert er dann als Digital-Pin und b) ist er hardwaretechnisch auch i.O.
Auf blauen Dunst ein Programm schreiben, würde ich nicht empfehlen. Es sei denn, Du hast schon viel Erfahrung damit. Denn funktioniert der doch schon recht große Programmcode dann nicht, fängt die Sucherei an. Daher würde ich empfehlen, Schritt für Schritt vorzugehen. Nicht einen riesen Schritt vor und 10 Kleine zurück. Also: Pin ausprobieren, wenn funktioniert notieren. Hast Du genügend Pins zusammen, eine Tabelle aufstellen, welcher Pin welche Funktion haben soll. Pin und Port haben beim Arduino übrigens unterschiedliche Bedeutungen. Ein Port (A,B,C,D ...) "beinhaltet" mehrere I/O-Pins. Dann nach den Notizen die Verkabelung durchführen und das Programm schreiben. Beim Verkabeln auch Schritt für Schritt vorgehen. Immer eine Sache anschließen und mit ein paar Codezeilen ausprobieren, wenn funktioniert, nächste Sache anschließen usw.
MfG
Step b step sicher... aber erstmal das Bord verbinden... Im Gerätemanager fehlen die 2.0 USB Treiber, ich finde leider noch kein passenden für win10
Die USB-Treiber sollten beim Motherboard dabei sein, auf einer CD. Kann man installieren.
War keine bei oder hab ich nicht mehr...ist ja fast 2 Jahre her...
021aet04
26.11.2020, 15:43
Da sollte ein Standardtreiber drauf sein. Bei den Originalen sind FTDI Treiber und bei den Klonen meist CH340 Treiber verbaut.
Das sind normale USB/UART Wandler.
PS: Code bitte in Code-Tags schreiben (#-Symbol bzw zwischen [ code ] und [ /code ] ohne Leerzeichen). Dann ist es leichter lesbar und schaut so aus.
Hier steht dein Code
Edit: Habe mich vertan, dachte es seinen die USB/UART Treiber, es fehlen aber die USB Treiber.
MfG Hannes
Ich habe noch CDs von Boards, die ich schon lange nicht mehr habe. :)
Mal im Netz suchen. Computer selbst gebaut? Mainboard-Bezeichnung aufschreiben. Auf Herstellerseite gehen, meist gibt es dort einen Button Support -> Treiber ... und eine Suche. Dort nach dem Mainboard suchen und Treiber herunter laden.
Wenn es ein gekaufter Computer ist, im Internet nach Modellbezeichnung suchen, um auf diesem Weg irgendwo an die Treiber zu kommen. Evtl. auf dem Computer irgendwo was finden (Hardware ....) wo eine Mainboardbezeichnung steht oder eine genaue Bezeichnung / Typ des Computers. Dann beim Hersteller auf die Webseite gehen und dort danach suchen.
MfG
https://www.ebay.de/itm/MEGA-2560-R3-Arduino-kompatibel-ATmega2560-16AU/181877749671?ssPageName=STRK%3AMEBIDX%3AIT&_trksid=p2057872.m2749.l2649
Diesen hier habe ich...
oberallgeier
26.11.2020, 16:11
.. Zwar weiß ich viel, doch möcht' ich alles wissen ..Vielleicht hilft dieser Link (https://www.makershop.de/ch340-341-usb-installieren/)? Sonst einfach gockeln nach ch341ser.zip download.
Danke! Die suche und Installation war erfolgreich.
oberallgeier
26.11.2020, 17:08
Danke .. erfolgreich.Gern *gg*......
So das Projekt ist fertig geworden... Mein Ziel ist erreicht. Leider konnte ich mit den Mega 2560 die Bluetooth Verbindung nicht aufbauen, aber mit einen Uno hat es geklappt. Der Roboterarm lässt sich jetzt mit den App Bluetooth Serial Controller steuern. Danke an alle die mitgeholfen haben. Jetzt kann ich das nächste Projekt angehen.
- - - Aktualisiert - - -
353353533635337
Der Code für den Uno:
#include <SoftwareSerial.h>
SoftwareSerial miBT(0, 1); // pin 0 RX, pin 1 TX
char DATO = 0;
int Motor1Out1=2;
int Motor1Out2=3;
int Motor2Out1=4;
int Motor2Out2=5;
int Motor3Out1=6;
int Motor3Out2=7;
int Motor4Out1=8;
int Motor4Out2=9;
int Motor5Out1=10;
int Motor5Out2=11;
int Motor6Out1=12;
int Motor6Out2=13;
void setup(){
miBT.begin(38400); // kommuniktion zwischen Uno und HC-05 auf 38400 eingestellt
pinMode(Motor1Out1, OUTPUT);
pinMode(Motor1Out2, OUTPUT);
pinMode(Motor2Out1, OUTPUT);
pinMode(Motor2Out2, OUTPUT);
pinMode(Motor3Out1, OUTPUT);
pinMode(Motor3Out2, OUTPUT);
pinMode(Motor4Out1, OUTPUT);
pinMode(Motor4Out2, OUTPUT);
pinMode(Motor5Out1, OUTPUT);
pinMode(Motor5Out2, OUTPUT);
pinMode(Motor6Out1, OUTPUT);
pinMode(Motor6Out2, OUTPUT);
}
void loop(){
if (miBT.available()){ // Abfrage ob Daten an HC-05 ankommen
DATO = miBT.read();
if (DATO == 'a')
digitalWrite(Motor1Out1, !digitalRead(Motor1Out1));
if (DATO == 'b')
digitalWrite(Motor1Out2, !digitalRead(Motor1Out2));
if (DATO == 'c')
digitalWrite(Motor2Out1, !digitalRead(Motor2Out1));
if (DATO == 'd')
digitalWrite(Motor2Out2, !digitalRead(Motor2Out2));
if (DATO == 'e')
digitalWrite(Motor3Out1, !digitalRead(Motor3Out1));
if (DATO == 'f')
digitalWrite(Motor3Out2, !digitalRead(Motor3Out2));
if (DATO == 'g')
digitalWrite(Motor4Out1, !digitalRead(Motor4Out1));
if (DATO == 'h')
digitalWrite(Motor4Out2, !digitalRead(Motor4Out2));
if (DATO == 'i')
digitalWrite(Motor5Out1, !digitalRead(Motor5Out1));
if (DATO == 'j')
digitalWrite(Motor5Out2, !digitalRead(Motor5Out2));
if (DATO == 'k')
digitalWrite(Motor6Out1, !digitalRead(Motor6Out1));
if (DATO == 'l')
digitalWrite(Motor6Out2, !digitalRead(Motor6Out2));
}
}
Powered by vBulletin® Version 4.2.5 Copyright ©2024 Adduco Digital e.K. und vBulletin Solutions, Inc. Alle Rechte vorbehalten.