L298N per PWM ansteuern (hardwareseitig)

  • Hallo und einen guten Tag wünsche ich,

    ich stehe vor einem neue Problem und hoffe hier etwas Hilfe zu erhalten. Das Ihr nicht wisst was ich genau mache, hier ist der Link zu meinem laufenden Projekt: :thumbs1:
    Roboter_Python_X-BoxController

    Jetzt möchte ich, in Abhängigkeit von meinem Joystick eine PWM erzeugen. Da der Pi nur einen Hardware PWM Pin hat, wollte ich eine Art Controller hintendran packen, den ich z.B. mit i2c erreiche. Habe diesen hier gefunden. Wäre so einer geeignet, oder gibt es bessere Vorschläge?

    Was Schnittstellenkommunikation angeht bin ich nicht sehr erfahren. Deshalb hier auch die Frage ob das ganze für mich zu anspruchsvoll ist. Und wenn einer grade Lust hat würde ich mich über Unterstützung freuen. :shy: Ich will keineswegs das ihr mir die Arbeit abnehmt, wie hier oft bedauert wird.

    Als Motortreiber wird der bei mir verwendete L298N eingesetzt. Ich hatte mir auch überlegt, entweder über die EN oder IN das PWM Signal draufzugeben, aber so genau weiß ich es nicht :/.
    Ich bitte um Hilfe :helpnew:

    Liebe Grüße

    Neolinga

    Einmal editiert, zuletzt von RapidDawn12618 (28. Juli 2014 um 15:31)

  • Hi,

    den L298N steuerst Du, wie richtig vermutet, über ENA und ENB ...
    Da also die Jumper ab und dafür Kabel dran und ein PWM-Signal anlegen.
    Das Hardware-Teil kannst Du Dir schenken ...
    Das Signal selbst kannst Du relativ einfach mit z.B. der pigpio-Bibliothek erzeugen. Damit kannst Du problemlos Servos steuern und für eine Motorsteuerung reicht das Signal allemal ;) ...

    Über die Pins In1 und In2 bzw. In3 und In4 des L298N legst Du die Drehrichtung eines DC Motors fest.
    Du darfst halt nur ca. 500 mA pro Kanal nicht überschreiten ... sonst schmilzt Dir der L298N weg.

    cu,
    -ds-

  • Das sollte funktionieren. Wäre ich an deiner Stelle hätte ich jedoch anstatt dem Chip einen Arduino genommen. Diesen kannst Du so auch noch programmieren, falls Du noch weitere Aufgaben auslagern möchtest, nur mal so als Tip. Günstiger scheint es dann auch zu werden.

    Sonnabend ich es bei meinem Projekt auch gemacht. Der Arduino kümmert dich um den gröbsten Teil der Hardware Ansteuerung, der Pi bekommt dann alle Infos über I2C zugesandt.

    Grüße

  • hey ho dramshader,
    danke für die Antwort. Ja so hatte ich das ganze jetzt auch angeschlossen, mit IN1,... etc. nur wollte ich das ganze hardwaremäßig lösen weil ich von Software-PWM bis jetzt nicht sehr begeistert war :) . Aber wenn das reicht (für meine Bedürfnisse) dann belasse ich das. Ich lese mir deinen Link einmal durch und versuche ihn zu verstehen. Wenn es nicht klappt melde ich mich nochmal und hoffe auf weitere Unterstützung.

    Noch ein schönen (Feier)abend :)

    ___________

    hi tsag,
    hab nur noch nicht viel mit i2c bzw generell Schnittstellenkommuniktation zu tun gehabt. Glaubst du sowas kriegt man als Neuling hin?


    Liebe Grüße

    Neolinga

    Einmal editiert, zuletzt von RapidDawn12618 (28. Juli 2014 um 16:03)

  • hi tsag,
    hab nur noch nicht viel mit i2c bzw generell Schnittstellenkommuniktation zu tun gehabt. Glaubst du sowas kriegt man als Neuling hin?


    Liebe Grüße

    Neolinga

    Ja, I2C ist relativ simpel und massenhaft Tutorials gibt es auch dazu. Falls Du irgendwelche Probleme haben solltest, einfach Nachfragen ;)

  • Guten Abend,

    dreamshader: ich habe mir das ganze gründlich durchgelesen habe aber einige Fragen. Ich möchte gerne über GPIO23 und GPIO24 softwaremäßig das PWM Signal generieren. Am Anfang des Codes muss die Initialisierung mit

    Code
    pi = pigio.pi()

    erfolgen.

    brauch ich da dann:
    set_PWM_dutycycle
    set_PWM_frequency
    set_PWM_range

    Ich dachte das dass dann so Aussieht:

    Code
    user_gpio:= 24
    dutycycle:= x
    user_gpio:= 23
    dutycycle:= x

    Könnte mir das vielleicht irgendjemand etwas genauer erklären.:helpnew:

    Liebe Grüße

    Neolinga

    Einmal editiert, zuletzt von RapidDawn12618 (28. Juli 2014 um 19:40)

  • Software-PWM ist nicht nur träger sondern auch CPU+RAM belastender.

    Ich würd an deiner Stelle auch eher zu einem Arduino oder allgemein AVR Chip tendieren, was davon abhängig wäre was alles im Sketch untergebracht werden müsste... Da gäbe es ja unzählige Möglichkeiten, eben von einem Arduino NANO oder Arduino Pro Mini, oder Arduino UNO (mein Favorit), bis hin zu einzelnen AVR Chips die dann aber mit etwas Aufwand über einen anderen Programmer flashen musst (das flashen geht aber auch mit dem PI).
    Vorteil bei einem normalen Arduino (Nano usw) wäre eben das du diesen via USB ansprechen könntest. Aber auch I2C, SPI oder UART wäre kein Problem.

    Ich baue derzeit auch an einem Roboter -> RoPi. Allerdings etwas aufwändiger als die bisher hier vorgestellten Projekte :D
    Da nutze ich auch einen Arduino UNO an dem ein Motor-Driver, sowie weitere Sensoren, angeschlossen ist. Mein bisheriger Sketch verbraucht ca 11kB von verfügbaren 32kB, und der ist wie gesagt wesentlich umfangreicher als dein Vorhaben :)

  • Danke dir meigrafd, das war ja mein ursprünglicher Gedanke das ganze mit einem Controller zu machen. In meinem ersten Beitrag hab ich einen verlinkt. Ich habe wenig bis gar keine Erfahrung mit Mikrocontrollern und deren Kommunikation. Sollte ich mich von dreamshaders Vorschlag entfernen? Wenn ja dann bräuchte ich etwas unterstützung. Habe hier bei mir obig genanntes Board. Auch das SainSmart UNO R3 Board MEGA328P ATMEGA16U2 ist in meinem Besitz.

    Mein Programm ist in Python geschrieben (wie in meinem Thread angehängt).

    Wenn ich zu viel von euch verlange dann gebt einfach Bescheid.

    Liebe Grüße

    Neolinga

  • Naja kommt halt drauf an was du machen möchtest, dank Arduino-IDE ist es aber relativ einfach einen Microcontroller zu verwenden ;)

    Da du bereits einen UNO hast würde ich damit einfach mal rum probieren.
    Was du dann halt später brauchst ist das Paket python-serial sowie in deinem python Script ein entsprechender Abschnitt Befehle an den Arduino zu schicken. Aber zum Testen reicht es erstmal Arduino-IDE zu nutzen, da gibts nämlich einen sehr nützlichen "Serial Monitor" den du verwenden kannst um Ausgaben zu sehen und auch Eingaben abzuschicken.

    Du kannst Theoretisch jeden Pin des UNO's zu einem PWM Pin machen, der einzige Unterschied besteht in der Ansprache: anstatt digitalWrite(); nutzt du dann halt analogWrite();
    (digital kennt nur An oder Aus also 1 oder 0, analog aber auch Werte dazwischen also zB 0 bis 1024)

    Ein Sketch ist relativ übersichtlich aufgebaut. Oben bindet man mögliche Libraries ein, anschließend definiert man für gewöhnlich Parameter wie zB welche LED welcher Pin ist oder die Baudrate für Serial. Weiter unten folgt ein void setup() { } indem ein mal beim Strom AN sachen eingestellt werden, und dadrunter kommt ein void loop() { } der automatisch ständig aufgerufen wird (ich glaub alle 10 Millisekunden oder so..)
    Weitere Anweisungen usw kannst du selbstverständlich auch einbauen, eben vor dem loop()

    Das ganze sieht aus wie C . Ist es im Prinzip auch allerdings ein bisschen verändert und schon speziell, also nicht alles ist so wie bei normalem C sondern eben spezielles Arduino-C (wie zB die Verwendung von String anstelle von std:string)

    Ein möglicher Sketch könnte wie folgt aussehen:
    (nur ein Beispiel aus meinem Sketch!)

  • Guten Tag,
    erstmal vielen (heftigen) Dank :danke_ATDE: . Die Grundlagenerklärung hat mir schon etwas weitergeholfen. Bin grade auf der Suche, wie ich per usb mit dem raspberry kommunizieren kann. Hab aber noch nicht viel brauchbares gefunden. Bestimmt gibt es da viele Infos, muss sie nur noch zuordnen :) .
    Mich würde trotzdem dreamshaders Vorschlag interessieren. Vielleicht könnte mir jemand meine obigen Fragen kurz beantworten?
    Vielen Dank.

    Liebe Grüße

    Neolinga

  • Moin,

    ähm ... welche Frage(n) meinst Du? Hab ich da was überlesen :s
    USB-Kommunikation geht sicherlich, aber da muss ich passen. Das hab' ich noch nie gemacht und ich denke, das dürfte auch nicht so ganz lapidar sein (es sei denn, Du nimmst ein FTDI-Kabel, aber dann ist das ja eine rs232 und kein USB mehr).

    cu,
    -ds-

  • Bin grade auf der Suche, wie ich per usb mit dem raspberry kommunizieren kann.

    Du selber brauchst nicht über USB mit dem PI kommunizieren sondern nur der Arduino. Du steckst den Arduino-UNO einfach via USB an den PI, prüfst dann über den Befehl dmesg (bzw dmesg | tail -n5 um nur die letzten 5 Zeilen angezeigt zu kriegen) welchen Device-Name er zugewiesen gekriegt hat (überlicherweise /dev/ttyACM0) und kannst ihn dann darüber ansprechen bzw das was der Arduino schickt abrufen - vorausgesetzt du hast die richtige Baudrate eingestellt.. In meinem Beispiel oben verwende ich eine Baudrate von 38400, also müsstest du in deinem Python Script (oder dem Serial-Monitor) auch eine Baudrate von 38400 einstellen.

    Google einfach mal nach "python serial", da findest du dann genug Beispiele für pySerial usw. Zum Beispiel:

    Spoiler anzeigen

    Aber beginne erst mal damit Arduino-IDE auf deinem PC oder MAC zu installieren. Schließ dann den UNO über USB an deinen PC/MAC, starte dann Arduino-IDE und geh im Menü auf Tools -> Board -> Arduino Uno und dann erneut unter Tools -> Serieller Port -> COM3 oder ähnlich. Dann noch mal unter Tools -> Programmer -> AVR ISP
    Dann kannst du deinen Sketch flashen und anschließend oben rechts den Serial Monitor öffnen um Ausgaben zu sehen sowie Eingaben zu tätigen.

    //EDIT: ich hab im Beispiel python Code in der Zeile print("read data: " + response) ein Komma ans Ende eingefügt -> dadurch wird bewirkt das keine newline gemacht wird. Sieht besser aus :)

  • Juhu,

    dreamshader: Im Beitrag #6 :thumbs1:

    meigrafd: Danke dir echt hilfreich. Mein Problem ist das ich meine 2 USB Anschlüsse gerade in Verwendung habe (X-BoxController und WlanStick). Entweder ich entferne den wlanstick oder versuche doch den i2c Sprung. Wobei mir dieser glaube ich für den Moment noch zu kompliziert ist mit den ganzen 0x00 Adressen usw. :X

    Liebe Grüße

    Neolinga

  • Hi,

    ahh so ... ok, gesehen ...
    In Sachen Python kann ich da leider nicht viel dazu sagen, aber im Prinzip ist das schon so, wie Du im Beitrag #6 geschrieben hattest.
    Mit dem Range setzt Du afaik nur so eine Art Teiler/Faktor ...

    Je höher der DutyCycle umso kleiner die Pausen = höhere Drehzahl
    Höhere Freuenz = ebenfalls kleinere Pausen = ebenfalls höhere Drehzahl

    Du wirst da ein wenig mit DutyCycle und Frequency experimentieren müssen, um optimale Werte zu ermitteln ... aber mehr als die beiden Funktionen wirst Du da nicht brauchen. Also alles irgendwie kein Hexenwerk.

    Was hast Du da für einen L298N? Das ist vermutlich so eine kleine Platine ...
    So wie es aussieht kommst Du da sogar ohne Levelshifter/Spannungsteiler aus.

    cheers,
    -ds-

  • Du kannst auch anstatt HardwareSerial -> SoftwareSerial nutzen.
    HardwareSerial wäre eben über den USB-Port des Arduino's und SoftwareSerial wäre über von dir (fast) beliebig definierte Pins (UART). Ein Beschreibung dazu findest du hier: http://arduino.cc/en/pmwiki.php?n=Reference/SoftwareSerial
    Dazu müsstest du dann eben noch UART am RaspberryPI aktivieren, wie das geht ist > hier < beschrieben

  • Ok, danke euch.

    Habe mich dazu entschieden, das ganze mit dem Arduino UNO über USB zu versuchen. Dein Programm meigrafd sieht schon sehr "brauchbar" für mich aus. :)
    Zu Beginn werden pro Motor 3 Pins angesteuert. 2 Auf digitalen Ausgängen und einen mit spezieller PWM Funktion.
    Danach werden mit void xxx die einzelnen Funktionen bestimmt. (Zur besseren Übersicht)

    Die folgende "Hilfsfunktionen für die Serielle Kommunikation" verstehe ich auf anhieb noch nicht, wobei ich nicht weiß ob ich so etwas brauche, und zum Schluss das eigentliche Empfangen, was im void loop verlinkt wurde. Hab ich das so richtig zusammengefasst?
    Also als Übergabe hast du ja "Befehl:pwmzahl" übergeben. Dies wird in 3 Strings bzw char und int zerlegt und somit zugeordnet. (Finde ich persönlich eine ziemlich elegante Lösung :thumbs1:) Und dann werden die Befehle ausgeführt. Hier der von dir größtenteils übernommene und angepasste Code:

    Spoiler anzeigen

    Jedoch bringt mir dieser Code beim Verifizieren diese Fehlermeldung:


    Spoiler anzeigen

    Arduino: 1.5.7 (Windows 7), Board: "Arduino Uno"

    pwmmotor.ino: In function 'String splitString(String, char, int)':
    pwmmotor.ino:70:13: error: conversion from 'char' to 'String' is ambiguous
    pwmmotor.ino:70:13: note: candidates are:
    In file included from C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/Arduino.h:220:0,
    from pwmmotor.ino:19:
    C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/WString.h:61:2: note: String::String(const __FlashStringHelper*)
    String(const __FlashStringHelper *str);
    ^
    C:\Program Files (x86)\Arduino\hardware\arduino\avr\cores\arduino/WString.h:59:2: note: String::String(const char*)
    String(const char *cstr = "");
    ^
    pwmmotor.ino:79:16: error: converting to 'String' from initializer list would use explicit constructor 'String::String(char)'

    Ich bin gerade voll bei der Sache und um jeden Hinweis dankbar. Auch lese ich mich gerade in die Kommunikation seitens des Rasberry hinein. Hoffe das klappt so wie ich mir das vorstelle. Ach übgrigens, wenn ich etwas zu viel verlange oder euch etwas anderes stört gebt Bescheid. ---> Das finde ich besser als genervte oder keine Antworten :)

    Liebe Grüße

    Neolinga

    Einmal editiert, zuletzt von RapidDawn12618 (29. Juli 2014 um 19:38)

  • Guck mal in den Beitrag > hier < bzw da drunter. Dort hab ich zunächst ein Script für die Serielle Kommunikation zwischen Arduino und PI gepostet, inkl. SocketServer und dadrunter ist mein aktueller Sketch, der etwas optimiert ist :)

    Warum du die Fehlermeldungen kriegst weiß ich zZt auch nicht - allerdings benutzt du die Arduino-IDE BETA! Was BETA bedeutet weißt du hoffentlich :huh: Geh bitte auf Nummer sicher und benutzte nicht die Beta sondern die letzte stable -> 1.0.5

  • Juhu, danke meigrafd. Es lag tatsächlich an der BETA Version :). Hab mir jetzt das Programm weiter angepasst und für mich zurechtgestutzt.
    Es hapert aber noch an der Befehlübergabe Raspberry ---> Arduino.
    Der erforderliche Befehl (z.B. forward:255) soll ja als string übergeben werden.

    Nur habe ich als Befehlsübergabe nur:

    Code
    ser.write("abc")


    gefunden. Aber eigentlich sollte ich ja diese drei Teilstücke übergeben. Habe schon eine Trennung mit Kommata versucht aber erfolglos. Hier wird das auch gemacht.

    Hier mal die Fehlermeldung mit Hinweis auf zu viele Argumente in serwrite().

    Spoiler anzeigen
    Code
    root@raspberrypi:/home/pi# python analog.py
    Taste >START< auf Pad zum beenden druecken
    right
    [0, 2, 0, 0, 5, 5]
    Traceback (most recent call last):
      File "analog.py", line 74, in <module>
        ser.write("right:",richtung)
    TypeError: write() takes exactly 2 arguments (3 given)

    Die Baudrate ist auf 9600 gesetzt.

    Hier einmal noch der python code auf dem Raspberry Pi:

    Spoiler anzeigen


    Ich hoffe das Forum hier bleibst weiterhin so nett und hilft mir dabei. Am Anfang ist eine kurze Initialisierung wie auch bei dir meigrafd.


    #EDIT1: Habe habe die Variabelübergabe nun hingekriegt mit diesem Beispielcode :
    http://stackoverflow.com/questions/1131…-with-variables


    Liebe Grüße

    Neolinga

    Einmal editiert, zuletzt von RapidDawn12618 (30. Juli 2014 um 23:47)

  • Mein Arduino Sketch erwartet nach dem : noch eine Zahl die dann in value hinterlegt wird, egal ob die letztlich verwendet wird oder nicht. Du müsstest also ser.write("right:1") an den Arduino übergeben.

    Wie gesagt, versuch das erst mal über den Serial Monitor vom Arduino-IDE, wenn es dort funktioniert weißt du zum einen die erforderliche Syntax und zum anderen gäbs dann auch kein Grund wieso es nicht auch übers Python Script funktionieren sollte ;)

Jetzt mitmachen!

Du hast noch kein Benutzerkonto auf unserer Seite? Registriere dich kostenlos und nimm an unserer Community teil!