fischertechnik community forum

Hallo zusammen,
ich baue das Hochregallager 9V und möchte es mit dem ftduino ansteuern.
Nun möchte ich den Zähler des ft Encodermotors auslesen und mir zusätzlich den Wert auf auf dem seriellen Monitor ansehen.
Der Wert so je nach Drehrichtung der Motors vorwärts oder rüchwärts Zählen, also so wie eine Achse. Die Positionen würde ich
dann über einen Vergleich anfahren.
Ist für mich aber alles neu. Habe mit dem Beispielprogramm "MotorBrake" schon probiert, aber bekomme es aber nicht hin.
Hat evt. jemand einen Programmcode für mich?

Die Encoder der fischertechnik-Motoren liefern keine Richtungsinformation. Daher ist es prinzipiell kaum möglich, die Position über mehrere Bewegungen zu verfolgen und daher führt die ftDuino-Bibliothek auch keinen entsprechenden Wert mit.

Wenn der Motor immer aus eigener Kraft bewegt wird (also außen z.B. niemand mit der Hand am Motor dreht), dann kann man ggf. davon ausgehen, dass er sich in die Richtung dreht, in der er auch gerade angetrieben wird. Dann kann man die Zählerwerte im Sketch passenbd addieren und subtrahieren. Aber völlig automatisch geht das mit den Encodern der ft-Motoren nicht.

Ein Beispiel-Sketch für das Hochregallager wird bei der ftDuino-Installation unter Beispiele/Ftduino/HighLevelRack mitgeliefert.

Man muss übrigens auch aufpassen, dass man den Zähler bei stehendem Motor nicht auswertet. Ein weiterer Nebeneffekt der simplen ft-Encoder ist nämlich, dass bei einer ungünstigen Motorstellung "zwischen zwei Schritten" haufenweise fälschliche Impulse vom Motor erzeugt werden können. Es gibt sogar 24V-Motoren von ft mit "richtigen" Encodern, die solche Probleme nicht haben. Aber die haben dann einen zusätzlichen zweiten Encoderausgang und sind leider nicht Bestandteil der normalen Baukästen.

Viele asiatische Getriebemotore haben einen Encoder "on board".
Vorschlag: Motor mit Getriebe wegschmeissen und irgendwie den Encoder
für Fischertechnik passend machen. Haben sogar Richtungserkennung.
Letztendlich viel billiger als Industrielösungen.
https://ecksteinimg.de/Datasheet/MO0107 ... blatt1.pdf
Nehme an, höhere Auflösung pro Umdrehung durch diametral magnetisierte Ring-
oder Rundmagnete.
Alte "Computermäuse ja, die mit der Kugel unten, hatten optische Encoder
mit Richtungserkennung. Meist sogar deren zwei und waren relativ preisgünstig.
Habe allerdings solch ein "Human-Interface" schon lange nicht mehr gesehen.

Nachtrag:
Ähnliches haben die Faulhaber- oder Maxxon- Motore angebaut. Geber sind nicht von Faulhaber selbst.
Gibt es von der Herstellerfirma auch als Teilesatz für entsprechend selbst konstruierte
Mechaniken. Leider weiß ich den Hersteller und die Preise nicht mehr.
Habe mal ein bischen geguugelt:
So sah erinnerungsmäßg der Teilesatz aus. Ob von Megatron oder nicht, ???
https://www.pressebox.de/pressemitteilu ... xid/911446
Könnnte sein, diesen Teilesatz als fertiges Modul zum Anbau statt mit 500 Imp/U mit 1024 Imp/U :
https://www.megatron.de/produkte/optisc ... r-spm.html
Allerdings u. a. mit 6mm, sollte kein Problem darstellen.

Danke Euch erst Mal.
Ich bin in der SPS Programmierung und verwende die Industriedrehgeber für schnelle Zäherkarten von
Siemens und Beckhoff. Nun möchte ich mich privat mit der ArduinoIDE etwas beschäftigen.
Das Beispielprogramm HighLevelRack ist viel zu kompliziert für mich und deshalb probierte ich die MotorBrake.
Dort werden die Zählimpulse bei gebremsten und ungebremsen Motor ausgegeben.
Wollte nun das Programm so anpassen, das bei Linkslauf der Zähler aufwärts und bei Rechtslauf abwärts zählt
und ich dann immer die Position habe.
Soll den Wert auch im seriellen Monitor anzeigen. Bekomme ich aber nicht hin und wäre für ein Beispiel dankbar.

P.S.
Hätte auch gern mit RoboPro angefangen und bin auch an "ftduino und RoboPro" von "fishfriend" sehr interessiert.

Hallo...
Die Geber verhalten sich scheinbar ähnlich wie alten Maussensoren.

Ich kenne da noch Geber, die eine Strichscheibe haben und über Profibus die Position ausgeben.
Bei anderen kann man zusätzlich über einen Taster die Nullposition festlegen.
Der Vorteil ist die Nullposition die immer gleich ist. Es gibt da keine Verschiebung oder vergessene Schritte.

Mit freundlichen Grüßen
fishfriend
Holger Howey

PS Ja das Projekt geht noch weiter.

Mit diesem Programmcode kann ich die Nachlaufimpulse des bremsenden Motors auslesen.
Aber wie kann ich die komplett gefahrene Strecke auslesen?
Kann evt. jemand für mich den Programmcode ergänzen?

------------------------------------------------------------------------------------------
//TXT-Encodermotor an M4 für drei volle Umdrehungen starten
ftduino.motor_counter(Ftduino::M4, Ftduino::LEFT, Ftduino::MAX, 190);
// warten bis der Motor stoppt
while(ftduino.motor_counter_active(Ftduino::M4));
// etwas länger warten, um dem Motor Zeit zum Nachlaufen zu geben
delay(500);
// Zählerstand ausgeben
Serial.println(ftduino.counter_get(Ftduino::C4));
----------------------------------------------------------------------------------------------

herbert1 hat geschrieben: ↑

22 Okt 2019, 13:13

Mit diesem Programmcode kann ich die Nachlaufimpulse des bremsenden Motors auslesen.
Aber wie kann ich die komplett gefahrene Strecke auslesen?

Die Gesamtstrecke ist 190 + Nachlaufimpulse. Tatsächlich setzt die ftDuino-Bibliothek den Zähler bei Start auf -190 und stoppt den Motor, wenn der Zähler 0 passiert. Und das wo er dann tatsächlich stehen bleibt zzgl. der gefahrenen 190 ist die Gesamtstrecke.

Danke für die Antwort.
Ich komme mit dem auslesen des Encoders nicht klar.
Ich möchte gern wenn der Motor läuft den Encoderwert lesen und dann in einer Variablen speichern,
am seriellen Monitor ausgeben und beim nächsten Motorlauf den Wert dazu addieren.
Komme aber mit dem Programmcode nicht klar.
Bekomme auch die Fehlermeldung (Mehrere Bibliotheken wurden für "FtduinoSimple.h" gefunden).
Kannst Du den Programmcode für mich mal korrigieren?

// ftduino.init();

bool M1_faehrt = false;
int x_move;
int x_pos = 0;

void setup() {
// Die Setup-Funktion wird einmal bei Start des Systems ausgeführt
pinMode(LED_BUILTIN, OUTPUT);
digitalWrite(LED_BUILTIN, HIGH);

// diee Bitrate ist im Falle des ftDuino bedeutungslos
Serial.begin(9200); // seriellen Port öffnen
while(!Serial);

//ftDuino-Timer, Interrupts etc starten
//ftduino.init();
}
void loop() {

if (ftduino.input_get(Ftduino::I1)){

M1_faehrt = true;
Serial.println("M1 An ...");
// Motor starten
ftduino.motor_set(Ftduino::M1, Ftduino::LEFT);
// interne rote LED einschalten
digitalWrite(LED_BUILTIN, true);
}
else {
ftduino.motor_set(Ftduino::M1, Ftduino::OFF);
// interne rote LED einschalten
digitalWrite(LED_BUILTIN, false);
M1_faehrt = false;
}

if (M1_faehrt){
ftduino.counter_set_mode(Ftduino::C1, Ftduino::C_EDGE_RISING);
ftduino.counter_clear(Ftduino::C1);

x_move = ftduino.counter_get(Ftduino::C1);
Serial.println (x_move);

// aktualisiere aktuelle X-Position
if(x_move > 0) x_pos += x_moved;
if(x_move < 0) x_pos -= x_moved;
}

}

So übersetzt er's. Ob's auch irgendwas sinnvolles tut habe ich nicht probiert.

Es macht aber wenig Sinn, Programme zu schreiben und von anderen debuggen zu lassen. Genau das ist die Fähigkeit, die man lernen muss. Das ist wie beim Autofahren. Da nützt es einem auch wenig, wenn man den Fahrlehrer fragt, ob er einen nicht bitte mal eben ans Ziel fahren kann.

Vielen Dank für Deine Hilfe.