Posts by aron93

Quote from VeryPrivat

Da bräuchten wir mehr Details zu Deiner Hardware und damit meine ich nicht den Raspberry Pi Modell 3.

- Welcher Motor (DC/Schrittmotor oder sogar BLDC?)

- Welchen Treiber verwendest Du?

- Welche Spannungsquelle ?

- Fährt der Motor unter Last an oder nur im Leerlauf?

Vermutlich könnten wir Dir noch konkretere Antworten geben, wenn Du uns sagst, was Du eigentlich vor hast...

Display More

ist ein Schrittmotor. Hier der Link dazu

https://de.aliexpress.com/item…e5-441f-ad2e-53f4e10a3644

An den Motor Treiber (HBS-57) habe ich eine 24V/10A Spannungsquelle angeschlossen. Mit dem Raspberry gehe ich auf Control Eingänge des Treibers. Der Motor fährt unter Last an.

Ich habe in vielen Artikeln über schrittmotoren von Beschleunigungsrampen gelesen und bin mir jetzt unsicher, ob ich das auch benötige. Ich vermute mal, dass man beim anfahren ohne irgendeiner Last an der Motoröle keine Rampe benötigt, oder?

Gruß Aron

Hallo Raspberry-Pi Forum,

Ich verwende ein Raspberry-Pi Model 3 um einen Motor anzusteuern. Dabei gebe ich dem Motor-Treiber Pulse mit bestimmten Frequenzen. Nun habe ich eher eine allgemeine Frage. Brauche ich bestimmte Beschleunigungsrampen, die stetig die Geschwindigkeit bis auf die endgeschwindigkeit erhöhen? Oder kann ich einfach sofort die entsprechende Frequenz der Impulse für die Drehzahl übergeben?

Gruß Aron

Quote from unimatrix

Schau mal hier.

https://forum.codesys.com/viewtopic.php?t=6692

bg ux

Danke für die Hilfe. Es klappt jetzt einwandfrei. Mein Problem war noch, dass ich Count:=0; im Programmteil so initialisiert habe und deshalb Count bei jedem Durchlaufen wieder auf 0 ist. Vielen Dank:)

Hallo Raspberry-Pi-Forum,

ich sitze nun schon den ganzen Tag an einem kleinen Code und komme nicht weiter. Ist echt frustrierend. Ich möchte eine Variable Count alle 5 Sekunden um 1 hochzählen, bis diese den Wert FinalCount erreicht hat. Habe es mit einer Zeitverzögerung innerhalb einer For-Schleife versucht zu realisieren, aber leider funktioniert es überhaupt nicht. Sobald ich das Programm in Codesys starte springt der Wert von Count sofort auf den Wert von Final-Count. Welchen groben Denkfehler habe ich hier als Anfänger? Ist mein Vorhaben überhaupt realisierbar?

FinalCount:=5000;

FOR Count:=0 TO FinalCount-1 BY 1 DO
    delay.PT:=T#5S;
    delay.IN:=TRUE;
    delay();

    IF delay.Q=TRUE THEN (*Wenn Timer abgelaufen*)
           Count:=Count+1;
        delay.IN:=FALSE;
    END_IF            
END_FOR

Grüße

Quote from schnasseldag

Hallo aron93,

für eine Low-Levelsteuerung auf Impulsbasis ist CODESYS der falsche Ansatz. Eienrseits, weil Du bereits auf einem blanken Linux keine zeitlich sauberen Signalfolgen ausgeben kannst (Thema Linux Scheduler), zweitens, weil Dir die CODESYS Runtime mit ihrem eigenen Prozeßmodell nochmals einen Knüppel zwischen die Beine haut, was das Threading anbelangt. Die CODESYS Runtime verrät nämlich nicht, wie sie Ihre Prozesse im Detail scheduled. Das verwässert das Konzept des Linux-Scheduling nochmals.

Eine halbwegs brauchbare Lösung (wenn's denn unbedingt ein Raspi sein muß) könntest Du erzielen, wenn Du ein externes C-Programm schreibst, welches den Low-Levelteil der Pulsausgabe übernimmt und dieses über CODESYS als eternes Programm aufrufst (siehe SysProcessExecuteCommand). So ähnlich mache ich das auch in meinem CODESYS-Treiber zum Bitbangen eines 433MHz Sender Modules. Wie das am Ende unter Codesys aussieht, kannst Du >>> hier <<< entnehmen. Der Mechanismus des Aufrufes eines externen Programmes ist >>> hier<<< skizziert.

Besser wäre es jedoch, man überließe die Pulsgenerierung einem Arduino und spräche diesen per Raspi (z.B. seriell) an. Entweder kümmert man sich dann selbst um die Impulserzeugung oder installiert eine Marlinsoftware und verwendet die G-Code Befehlsschnittstelle. Beim letzten Ansatz hätte man allfällige Probleme von Beschleunigung, Geschwindigkeit, relativer/absoluter Positionierung, Endschalter... gleich mit erschlagen. M.E. der schnellste und sauberste Weg, einer technischen Umsetzung. Will man lernen, dann gehen auch die Wege der manuellen Arduino-Programmierung oder auch das direkte Steuern vom Raspi.

Schöne Grüße und viel Erfolg,

schnasseldag

Display More

Danke für die ausführliche Antwort. Ich werde mich mit den 2 Ideen mal beschäftigen und schauen wie ich das in meinem Projekt realisieren könnten. Besten Dank für den guten Input.

Gruß

Aron

Quote from bombom

Wenn ich dich richtig verstehe, dann übergibst du einem Programm wann und wie schnell es an eine bestimmte Position fahren soll. Das Problem dabei ist nun, du bekommst keine Rückmeldung wann das Ziel erreicht wurde? Gibt es keine Möglichkeit, dass dir MoveToPosition das Ende mitteilt?

der Code zu move position ist oben im Anhang. Ja genau ich habe keinen Encoder, der mir Auskunft gibt wann mein Ziel erreicht ist. Deshalb versuche ich es über die Zeit machen (bei bekannter Drehzahl und absolutwinkel) . Die Ungenauigkeit, die bei auftretenden Schnittveruste entstehen kann, nehme ich in Kauf.

Gibt es eine andere Möglichkeit die zeitverzögerung zu realisieren?

Quote from bombom

Mir ist nicht ganz klar, für was du eine Zeitverzögerungsbaustein brauchst. Welches IC?

Ich Versuche gerade einen Funktionsbaustein in Codesys zu programmieren. Als Input-Variablen dienen Speed, AbsoluteAngle und Enable. Mit Enable soll der Baustein einfach leicht aktiviert und dekativiert werden. Mit Speed möchte ich eine Drehzahl in U/min vorgeben mit der Schrittmotor drehen soll. Mit der Variable AbsoluteAngle soll man dann in der Lage sein, ein Winkel zu wählen, den der Motor dann bzgl. der Anfangsposition abfahren soll. Das ganze soll dann in einem Dauerversuch stattfinden, dass heißt der Motor soll Absolutwinkel mit vorgegeben Geschwindigkeit anfahren und dann mittels einem Richtungswechsel wieder zur Anfangsposition zurückfahren. Diese Richtungswechsel sollen dann beliebig lange durchgeführt werden.

Meine Idee zur Realisierung habe ich im ersten Post beschrieben. In Speed gibt man eine Drehzahl in U/min ein, die dann durch einen Programmteil in ein entsprechendes Puls-Signal mit der benötigten Frequenz umgesetzt wird. Der Absolutwinkel der abgefahren werden soll ergibt sich aus einer gewissen Anzahl an Schritten des Motors (0,9°/Schritt).

Im Program berechne ich die benötigte Anzahl der Schritte zur Erreichung des Absolutwinkels mit der Formel
Anzahl benötigter Impulse = Absolutwinkel / Schrittauflösung ([°] / [°/Steps]). Die Frequenz der Impulse für die Drehzahlsteuerung kann ich sehr leicht durch folgende Formel berechnen f = (Soll-Drehzahl * Schrittauflösung)/60 ([U/min] / [Steps/Rev.]).

Da nun die Anzahl der benötigten Impulse und die Frequenz mit dem die Impulse eingehen bekannt ist, kann ich nun eine Zeit [s] berechnen, die der Schrittmotor braucht, um den Absolutwinkel zu erreichen. t = Anzahl benötigter Impulse / f [s]

Meine Idee war es nun, in einer Schleife diesen Richtungswechsel (Anfangsposition-AbsoluteAngle) in einer Schleife zu realisieren. Indem ich an dem Direction eingang, ständig zwischen TRUE und FALSE wechsle. Da aber erst die Zeit t ablaufen muss, bis der Motor den Absolutwinkel erreicht hat möchte ich da eine Zeitverzögerung einbauen, die dann genau das realisiert. Bin mir aber nicht sicher, ob das eine elegante Lösung ist.

Aber es klappt leider nicht so wie ich das möchte. Ist da meine ganze herangehensweise mit dem Umrechnen der Formeln einfach schlecht? Gibt es andere Möglichkeiten?

Danke für eure Hilfe.

IF EnableMoveToPosition=TRUE THEN
    IF Speed<=19 THEN
        GVL.byPWM0Ctrl0.0:=TRUE;        //Frequency-Mode
        GVL.byPWM0Ctrl0.1:=TRUE;

        GVL.byPWM0Ctrl0.5:=FALSE;        //Prescaler
        GVL.byPWM0Ctrl0.6:=TRUE;
        GVL.byPWM0Ctrl0.7:=TRUE;

        GVL.wPWM0A:=REAL_TO_WORD(f_CPU/(2*Prescaler8*400*Speed/60));        //Umrechnung von Drehzahl U/min in U/s beachten
    
        nReal:=(f_CPU/(2*Prescaler8*400*GVL.wPWM0A))*60;                    //Reale-Drehzahl in [U/min] mit gerundeten 
                                                                                X bzw. PWMOA

    ELSIF Speed>19 THEN
        GVL.byPWM0Ctrl0.0:=TRUE;        //Frequency Mode
        GVL.byPWM0Ctrl0.1:=TRUE;

        GVL.byPWM0Ctrl0.5:=TRUE;        //Prescaler
        GVL.byPWM0Ctrl0.6:=FALSE;
        GVL.byPWM0Ctrl0.7:=FALSE;
    
        GVL.wPWM0A:=REAL_TO_WORD(f_CPU/(2*Prescaler1*400*Speed/60));    //Umrechnung von Drehzahl U/min in U/s beachten
        
    
        nReal:=(f_CPU/(2*Prescaler1*400*GVL.wPWM0A))*60;                //Reale-Drehzahl in [U/min] mit gerundeten X bz                                                                            w. PWMOA
    END_IF
END_IF

NumberOfPulsesRequired:=AbsoluteAngle/0.9;            //Anzahl Pulse die für gewünschten Absolutwinkel gesendet werden                                                             müssen
f_PWM:=(nReal*400)/60;                                //PWM-Frequenz die aufgrund Drehzahl gesendet wird
CalculatetedTime:=NumberOfPulsesRequired/f_PWM;
MyTime:=REAL_TO_TIME(CalculatetedTime*1000);        //*1000, da Argument bei REAL-TO_TIME in [ms] angegeben werden muss

GVL.byPWM0Ctrl0.3:=TRUE;                            //Kanal-A aktivieren

//Schleife zur Realisierung des Richtungswechsels nach der CalculatedTime
WHILE EnableMoveToPosition=TRUE DO                    
    timer1:=TRUE;
    TON_0(IN:=timer1, PT:=MyTime);
    Direction:=TRUE;
    timer1:=FALSE;
    
    timer2:=TRUE;
    TON_0(IN:=timer2, PT:=MyTime);
    Direction:=FALSE;
    timer2:=FALSE;
    
    timer3:=TRUE;
    TON_0(IN:=timer3, PT:=MyTime);
    timer3:=FALSE;
END_WHILE

Quote from hunter_spike

Mit codesys hab ich noch nicht gearbeitet. Tut mir Leid.

Kannst trotzdem mal Deinen Quelltext hier rein setzen.

An Deiner Stelle würde ich das Prog erstmal mit 10 HZ laufen lassen. Da sehe ich noch keine Probleme. Wenn es damit läuft kannst Du anfangen die Drehzahl nochzuregeln.

15kHz sind bei Deinem Motor 37,5U/sec =2.250 U/min. Richtig? Einen so schnellen Schrittmotor hab ich noch nicht gesehen....

ja genau. Ist die max. Drehzahl, die der Hersteller angibt.

Anbei der Code-Teil. Die oberen Zeilen befassen sich nur mit der Konfiguration des PWM-Kanals und habe ihn deshalb rausgeschnitten. Die Variable MyTime ist die mit der Formel t = Anzahl benötigter Impulse / f berechnete Zeit, diese übergebe ich einen TOn-Zeitverzögerungsbaustein. Die Boolsche Variable Direction ist mit dem Direction Eingang des MotorTreibers verbunden. False bedeutet rechtsdrehend und true linksdrehend.

Ich versuche das wiederholte hin und her drehen mit einer while-Schleife zu realisieren. Zu Beginn ist Direction False und der Motor dreht rechts. Mit dem TON-Zeitverzögerungsbaustein möchte ich nun Direction so lange false gesetzt lassen bis dieser die gewünschten Steps erreicht hat. Nach dem abgelaufenen TON wird dann Direction auf True gesetzt und soll dann in die anderen Richtung wieder zurückfahren mit gleicher Schrittanzahl. Dies soll sich dann beliebig oft wiederholen. Wenn ich das nun simuliere passiert überhaupt nicht was ich möchte.

Quote from hunter_spike

15 kHz ist glaube ich schon eine Hausnummer. Da brauchst Du schon eine hohe Versorgungsspannung um die Induktivitäten der Motorwicklungen zu überwinden.

Außerdem mußt Du den Motor langsam beschleunigen. Sonnst ist die Massenträgheit der bewegten Masse zu hoch und der Motor verliert Schritte.

ja die 15 kHz ist schon das maximale, aber das werde ich glaube ich nicht benötigen. Im Nennbetrieb liegt die Frequenz bei so 10kHz. Ja da hast du recht, ich muss mir auf jeden Fall noch Gedanken machen, wie ich die Beschleunigungsrampen am besten umsetzte. Hast du da eine Faustregel dafür?

Wie findest du die Lösung, die ich oben Beschrieben habe? Ich möchte nicht komplett 360Grad drehen sondern z.B. nur 180Grad. Er soll dann zwischen 90 und -90 Grad sich hin und herbewegen mit einer Geschwindigkeit, die ich vorgebe. Ich habe das in codeys versucht, aber es hat nicht so funktioniert. Habe die Zeit (s. Oben) berechnet und eine while Schleife auch wenn aufgebaut. Zunächst setzte ich den direction Eingang des Motor Treibers true (rechtsstehend). Mit einem TON lasse ich die berechnete Zeit ablaufen. Nachdem setzte ich den direction wieder auf false (linksstehend). Lasse den TON wieder ablaufen und setzte danach direction wieder auf true und alles beginnt wieder von vorne.

Die Schleife macht leider nicht, das was ich möchte. Vorallem der TON funktioniert nicht wirklich.

Hallo Raspberry-Pi Forum,

für mein Projekt besitze ich einen Schrittmotor mit einer Auflösung von 400 Steps/Rev. (0,9 °/Step). Es handelt sich hierbei um einen NEMA 23, der mittels dem Driver HBS57 als closed-loop stepper ausgeführt ist. Hier der Link zu dem Motor. https://de.aliexpress.com/item…e5-441f-ad2e-53f4e10a3644  

Mein Ziel ist es nun, dass mein Schrittmotor einen gewissen Absolutwinkel (Anzahl an Schritten) mit einer definierten Geschwindigkeit (Drehzahl) abfährt. Darüber habe ich mir schon Gedanken gemacht und habe eine Lösung ausgearbeitet. Ich bin mir aber unsicher, ob diese Lösung eine "schöne" und effektive Lösung ist. Ich möchte diese euch kurz aufzeigen und eure Meinung dazu hören.

Ich möchte in meinem Programm den Absolutwinkel [°] und die Drehzahl [U/min] vorgeben, diese dienen als bekannt.

Die Anzahl der Impulse, die mein Schrittmotor verfahren muss ergibt sich, indem der gewollte Absolutwinkel durch die Schrittauflösung des Motors geteilt wird.

Anzahl benötigter Impulse = Absolutwinkel / Schrittauflösung
[°] / [°/Steps]

Die Drehzahl des Motors wird über die Frequenz der 5V-Pulse am Treiber Eingang bestimmt. Drehzahl des Motors ist proportional zu der Frequenz der Impulse am Pul- Eingang des Treibers. Über die Soll-Drehzahl, die ich vorgeben möchte kann ich die Frequenz [Hz] der Impulse mit folgender Formel berechnen.

f = (Soll-Drehzahl * Schrittauflösung)/60

[U/min] / [Steps/Rev.]

Da nun die Anzahl der benötigten Impulse und die Frequenz mit dem die Impulse eingehen bekannt ist, kann ich nun eine Zeit [s] berechnen. Durch die Division der benötigten Impulse und der Frequenz der Impulse weiß ich, wie lange ich die Pulse am Eingang des Treibers des Motors anlegen muss, bis die benötigte Anzahl an Schritten und so den Absolutwinkel erreicht sind.

t = Anzahl benötigter Impulse / f

Ich würde das dann so realisieren. Ich würde nach ablaufen der oben berechneten Zeit eine boolsche Variable auf True setzen und dadurch den Ausgang der Impuls-Signale abschalten.

Eine weitere Überlegung von mir war, das Impulssignal zusätzlich an einem Eingang anzulegen und mittels einem Timer die steigenden Flanken zu zählen. Problem hierbei leider ist, dass die Eingänge max. eine Frequenz von 400 Hz erkennen können. Die Impuls-Signale die an den Treiber des Motors gesendet werden, haben bis zu 15 kHz.

Das waren meine Ideen zu dem Thema. Ich bin mir nicht sicher wie genau diese ist und wie viel Abweichungen im Betrieb entstehen könnten.

Könnt ihr mit eurer Erfahrung und Know How einschätzen, ob dieses Vorgehen möglich ist. Habt ihr vielleicht eine bessere Herangehensweise?

Vielen Dank für eure Antworten.

Gruß Aron

Vielen Dank für die vielen Antworten, Bemerkungen und Einschätzungen. Haben mir auf jeden Fall geholfen. Ich werde es nun versuchen mit einem weiteren uC umzusetzen. Sollten dazu noch weitere Fragen aufkommen, werde ich mich melden.

Gruß Aron

Quote from hyle

Hast Du Dir schon Gedanken darüber gemacht, welches Treiberboard für den Motor am RPi verwendet werden soll?

Als Steuerung verwende ich den PiXtend-V2-S, ist ein Erweiterungs-Board für den Raspberry-pi 3+. Kennst du den? Hier den link dazu.
https://www.pixtend.de/pixtend…/pixtend-v2-s-controller/

Das Board kommuniziert über SPI-Bus mit dem Erweiterungs-Board, dadurch kann ich dann über den Raspberry-Pi auf die ganzen Eingänge und Ausgänge auf dem Board zugreifen. Das Board besitzt Ausgänge mit denen Impulse mit unterschiedlichen Frequenzen erzeugt werden können und diese gebe ich auf die Puls-Eingänge des Motor-Treibers.

Hier der Link zum Motor: https://de.aliexpress.com/item…e5-441f-ad2e-53f4e10a3644  

Der Motor-Treiber ist der HBS57. Ein chinesisches Produkt.

Nochmal zu dem Thema Encoder-Signalerfassung. Leider kann ich mit den Eingänge des PiXtend-Boards Impulse mit sehr hohen Frequenzen nicht erfassen, da die SPI-Kommunikation zwischen dem Board und dem Raspberry-Pi „zu langsam“ ist. Der Raspberry bekommt nur alle 2,5ms Daten von dem erweiterungsboard. Das reicht für die hohen Frequenzen des encoders nicht. Ich habe aber noch einen weiteren rasperry-Pi 3+ daheim rumliegen und habe mir überlegt, ob ich diesen zur signalerfassung der Encoder Signale verwenden kann. Dieser würde dann die Daten an meine Steuerung übergeben.
Deswegen habe ich zu Beginn die Frage gestellt, ob der Raspberry-Pi die Encoder Signale erfassen könnte oder ob ich nach einer anderen Lösung suchen muss.

Quote from Gnom

Wenn du die Steuersignale und die Rückmeldung des Drehgebers in einen passenden Zähler-IC fütterst, könntest du die Differenz als Zahl am Ausgang sehen. Mit einem µC sollte das aber auch gehen.

Das mit dem Zähler und der Differenz ist eine gute Idee. Habe ich da auch nicht das Problem, dass ich die schnellen Signalwechsel dann auch erkennen muss.

Meinst du, dass ich mir einen weiteren µC raussuche, der in der Lage ist die Signale zu verarbeiten und dann mit meinem Raspberry kommuniziert?

Quote from Gnom

Woran bemisst du denn die Solldrehzahl, wenn dein billiges chinesisches Produkt dir keine Infos liefert? Wenn du feststellen willst, ob er zu langsam läuft, musst du doch erst mal wissen, wie schnell er laufen SOLL. Wer weiß, welche Beschleunigungsrampen die Steuerung fährt und ob sie vielleicht schon auf Abweichungen mit Änderung der Solldrehzahl reagiert. Bei Closed Loop erreicht er ja eh den Zielpunkt. Inwiefern ist denn da für dich die Drehzahl relevant? Wenn Schritte verloren gehen, ist ja entweder der Antrieb falsch ausgelegt oder irgendwas kaputt, so dass der Motor blockiert wird. Zudem fährst du bei Closed Loop ja eine Position an. Wenn du nicht gerade einen langen Spindelantrieb hast, sind die Fahrzeiten ja relativ gering. Was genau willst du denn dann mit der Geschwindigkeitsmessung eigentlich feststellen?

Wie schnell dreht denn der Motor? Wenn er langsam dreht, sollte die Erfassung der Drehgeberimpulse mit einem µC (oder evtl. direkt mit dem Pi) kein großes Problem sein. Wenn er sehr schnell dreht, solltest du vielleicht mit einer geringeren Auflösung arbeiten - ein Hallsensor der bei jeder Umdrehung (oder auch halbe/viertel) ein Signal liefert, ginge vielleicht auch.

Sorry für die Verwirrung. Ja es ist ein bisschen nervig, dass ich von dem Herstellen keine Auskunft bekomme. Habe mir nochmal ein paar Gedanken gemacht. Die Soll-Drehzahl kann man sich eigentlich sehr leicht ausrechnen. Die Drehzahl vom Schrittmotor kann alleine durch die Frequenz des PWM-Signals geändert werden. Durch die bekannte Schrittauflösung meines Motors (400 Schritte/Umdrehung oder 0,9°/Schritt) kann ich mit Hilfe der Frequenz eines PWM-Signals zurück rechnen. So kann ich die Drehzahl aus den unterschiedlichen Frequenzen berechnen.

Z.B. wenn ich ein PWM-Signal mit f=1000Hz anlege erhalte ich eine Drehzahl von 150 U/min. Frequenz von 1000Hz bedeutet, dass ich 1000 Impulse pro Sekunde sende, wobei ein Puls einem Schritt entspricht. Also erhalte ich mit

1000 Impulse/s = 2*400 Impulse/s + 200 Impulse/s

2,5 Umdrehung/s. Wenn ich das mit 60 multipliziere komme ich auf die 150U/min. Habe diese Werte eben auch überprüft. Stimmt auch so ohne einer Last am Motor. So kann ich für alle mögliche Frequenzen die entsprechende Drehzahl berechnen. Wenn das bekannt ist, kann ich auch Soll-Drehzahlen vorgeben.

Mir ist bewusst, dass der closed-loop seine Endposition am Ende erreicht, indem er übersprungene Schritte nachholt. Aber zum jetzigen Zeitpunkt interessiert mich nur die Drehzahl. Der Schrittmotor soll unter der Wirkung von Momenten und Axial-Kräften eine möglichst konstante Drehzahl fahren. Zum Einsatz kommt der Motor in Dauerversuchen, bei denen er mehrere Tage durchläuft.

Gruß Aron

Quote from bombom

Welche Bezeichnung hat der Motor, denn mir scheint, dass du da einiges zusammen würfelst.

Es ist ein Nema-23.

https://de.aliexpress.com/item…e5-441f-ad2e-53f4e10a3644

Quote from Gnom

Bei einem Schrittmotor bestimmst du doch die Drehzahl durch die Ansteuerung. Der Encoder wird gewöhnlich nur für die Positionsbestimmung gebraucht - und auch das eigentlich nur für den Fall, dass Schritte verloren gehen.

Was ist denn der Hintergrund deiner Aufgabe? Wieso kannst du dich nicht einfach auf die Positionierung durch die Motorschritte verlassen?

Hier gibts einen C-Code für die Auswertung eines Drehgebers. Wenn du das in einem Mikrocontroller programmierst, hast du eine zuverlässige Erfassung der Drehgeberwerte, die du dann weiter auswerten kannst.

Danke für die schnellen Antworten. Der Schrittmotor ist in der Tat ein Closed-Lopp-Schrittmotor und sorgt dafür, dass Schritte nicht ausgelassen werden. Bin ein bisschen neu in der Materia und bin mir da ein bisschen unsicher. Der Schrittmotor ist billiges chinesisches Produkt, die mir leider keine Auskunft geben können, welches PWM-Signal welche Drehzahl am Motor entspricht.

Die Grundidee zu der Regelung war, dass es doch sein kann, dass der Motor nicht die Soll-Drehzahl erreicht wenn hinreichend große Lasten an der Motorwelle anliegen. Oder ist eine Drehzahl-Regelung bereits durch den Closed-Lopp hinfällig?

Danke für eure Hilfe:)

Hallo Raspberry-Pi Forum,

ich möchte mit Hilfe meines Raspberry-Pi 3+ Model eine Drehzahlregelung für einen Schrittmotor realisieren. Mein Problem liegt bereits schon bei der Drehzahlerfassung des Schrittmotors. Der Schrittmotor enthält einen Encoder der 5V-Rechtecksignale sendet. Zudem besitzen die Rechtecksignale einen sehr hohen Frequenzbereich von 0-35kHz. Nun ist die Frage, ob der Raspberry-Pi in Kombination mit einem Pyhton- oder C-Programm in der Lage ist, diese schnellen Signalwechsel zu erkennen. Durch zählen der Impulse möchte ich am Ende auf die Drehzahl des Schrittmotors kommen.

Danke für die Antworten.

Gruß Aron