Tandberg 10X(D) Umbau Capstanmotor von Original zu Fälschung ...
#51
Hi Christian,

da hast du eine sehr schöne, sauber dokumentierte Arbeit hingelegt, und es hat Freude gemacht, da mitzulesen.

Im Vergleich zu meinem Projekt ist die Motortreiberei natürlich eine ganz andere, da hier ein DC-Motor mit Riemen und Schwungscheibe zum Einsatz kommt. Dafür gab es bei meinem Direct-Drive andere Schwierigkeiten ...

Auf jeden Fall prima, wie du das durchgezogen hast.

Freundliche Grüße,
Binse
Zitieren
#52
Hallo Binse,

Dankeschön !

Dir auf diesem Wege ebenfalls ein Dankeschön für die Unterstützung !! Wie auch nochmals Dankeschön an alle anderen "helfenden Hände" ! Insbesondere Bernd (Capstan) !!!!

Wenn denn jetzt die ein oder andere 10X/XD mit dem identischen "Problem" gerettet werden kann ist das Ziel aus meiner Sicht erreicht. Und das Rad wird nicht jeden Tag neu erfunden, einmal einen Lösungsansatz erarbeiten und gut ist .....

beste Grüße

Christian
Zitieren
#53
Hallo Christian 

Du hast da ein schönes Zukunftsicheres Projekt geschaffen. Meinen herzlichen Glückwunsch dafür.
Eine Frage hätte ich dazu.
Ich hab was von ESP32 gelesen. 
Selbst hab ich erst einmal mit Arduino Uno gearbeitet und ein Projekt realisiert. 
Würde dein Programm auch, mit Änderungen, darauf laufen?
Ich mache lieber Hardware.

Gruß Mani
Besonders gerne repariere ich meine Philips, Braun, Akai und TEAC Geräte Big Grin
Keine Hilfe bei fehlender Rückmeldung
Zitieren
#54
Hallo Mani,

erstmal Dankeschön !

Bzgl. der Frage ob es auch auf einem Standard-Arduino (AT-Mega-Chip) läuft - Antwort ala Radio Eriwan:

In der Therorie ja - in der Praxis nein - jedenfalls nicht OHNE ÄNDERUNGEN !

Folgender Anpassungsaufwand entsteht:

a) unterschiedliche Wertebereiche der internen A/D-Konverter
- der Wertebereich für das Pitch-Poti muss dann von 4095 auf 1023 angepasst werden - geht über die Konstante pitch_map_ende = 1023;
- der Wert für die maximale Duty-Cycle von 1023 auf 255 angepasst werden muss - geht über TandbergPID.SetOutputLimits(0,255);

b) PWM-Frequenz
- beim ESP32 beträgt sie 22 khz mit einer Auflösung von 10 Bit (1023)
- Arduino im Standard 490 bzw. 980 Hz (je nach genutzen Pin, Auflösung 8 Bit also 255)
- Arduino mit 22 khz betreiben erfordert Registerprogrammierung und es MUSS auf die Timer-Problematik geachtet werden (erfordert dann einen der drei Timer nur für PWM)
alternativ hierzu Nutzung externer Librarys wie PWM.h etc.

c) die PWM-Werte (Duty-Cyle) bei max. 255 geändert werden müssen (bestehende Werte durch 4 teilen)
- Initialwert für 9,5 ändern - geht über Konstante PWM_Wert_95 = 22;
- Initialwert für 19 ändern - geht über Konstante PWM_Wert_19 = 50;
- Initialwert für 38 ändern - geht über Konstante PWM_Wert_38 = 100;

d) Verwendung der LEDC-API beim ESP32
- diese API läuft NICHT auf einem klassischen NANO mit AT-Mega Chip !! Der ARDUINO NANO ESP32 unterstützt diese API.
- hieraus resultierend ist dann der API-Anteil ledcFade und ledcWrite anzupassen. ledcWrite kann bei Nutzung Standard-PWM-Frequenzen 490/980 Hz durch analogWrite() ersetzt werden. Für ledcFade sind gesonderte for-Schleifen zu codieren, in denen sowohl die Werte für Duty-Cycle als auch für Zeit in einem festen Intervall hochzusetzen sind, bis z.B. der Startwert des PWM-Signals (z.B. PWM_Wert_95 oder End-Zeit) erreicht ist. ledcAttach entfällt, da der Arduino im Standard nur nen Pin braucht ....

 ------------ Wege aus dieser "Misere:" -------------

Für die Standard-PWM-Frequenzen 490/980 Hz beim Arduino würde ich jetzt das "Progrämmle" anpassen inkl. der Umsetzung von ledcFade hin zu einer for-Schleife und sonstigen "Kleinkram".

Das so angepasste "Progrämmle" würde dann hier zugänglich gemacht werden.

Ebenso ist es kein Problem, jetzt mal den Arduino NANO ESP32 zuverwenden und mal zu schauen, wo sich dann noch Änderungen ergeben .... Das würde dann auch hier zugänglich gemacht werden.

Diese Thematik wurde ja schon mal in einem Beitrag erwähnt und es ist jetzt nicht das riesige Problem diese - auf ESP32 basierende Lösung - auf andere µComputer-Plattformen umzustricken.

Der Gedanke ist auch überhaupt nicht verkehrt und abwegig, weil damit ein "universeller" Ansatz entsteht - und das Rad nicht jeden Tag neu erfunden wird ! Einmal machen und gut ist !!

Da die momentan zur Verfügung stehende Zeit etwas durch andere Baustellen begrenzt ist, würde das nur "a bisserl" dauern ......

Alles auf Mal geht auch hier nicht - und "mal eben" dauert bekanntlicher Weise länger .....

beste Grüße

Christian

PS.: Entwickelt wurde die ESP32-Lösung ja auf einem Standard-Arduino-Mega-2560, nur eben halt ohne ledc-API Anteil. Somit ist die meiste "Arbeit" ja schon gemacht - nur ledcfade in eine for-Schleife umsetzen ......
Zitieren
#55
Einen besseren Service als den, welchen Christian hier stets abliefert, kann ich mir nicht vorstellen.
Ganz große Klasse !

Groetjes, Frank
Hau wech, den Schiet - aber sech mir, wohin


Zitieren
#56
Soderle liebe Mitbewohner/Mitbewohnerinnen/Mitbewohneres dieses Planeten

aufgrund aktueller Lieferengpässe von Ersatzteilen für andere Baustellen etwas Zeit gehabt:

WARNUNG AN ALLE NICHT-EDV'ler: Jetzt kommt computerchinesisch ..............

Also mal kurzerhand mit "Karl Irgendwen" (KI) konferiert anstelle sich selbst das Hirn zu zermatern bzgl. der Arduino (AT-Mega-Chip) -Thematik (Mann weiß ja wo geändert werden muss ...):

"Karl, als erstes baue den ESP32-Code so um, das er den Clean-Code-Ansprüchen genügt, prüfe auf Redundanzen und nochmals die Logik ....."

Karl nahm sich eine kurze Beratungszeit und dann kam die Antwort. Drübergeschaut, mit Karl diskutiert, Änderungen gemacht und siehe da, der gesamte Quellcode für den ESP32 ist sauber aufgedröselt, Loop-Sektion sauber lesbar, fast schon Lehrbuch .... So darf das bleiben !!!

Das Ergebnis ist als Anhang beigefügt.

"So, Karl, ESP32 ist erledigt. Jetzt bau das auf Arduino Nano AT-Mega-Chip um, PIN ändern, ersetze ledc-API insbesondere ledc-Fade, PWM-Frequenz ist Standard 490 Hz ...."

Kurze Beratungszeit, und Karl kam dann damit heraus ... Drübergeschaut, jau passt, aber include arduino.h kann weg - und Karl, die Library PID_v1.h ersetzen wir mal durch PID_v1_bc.h ....  "Alles klar" sprach Karl und nach kurzer Beratung dann die Antwort. Nochmals drübergeschaut, über den Compiler geschoben und NULL ERRORS.

Dankeschön Karl, das hat Zeit und Gehirnschmalz gespart !!!

Das Ergebnis ist als Anhang beigefügt.

----------------------------------------------------------------------------------------------

Somit liegen jetzt beide Software-Versionen der Motorregelung vor. Einmal ESP32 , einmal Standard Arduino. Und dabei wird es auch bleiben !! Die ESP-Version ist nochmals bereinigt bzw. aufgeräumt worden und sollte somit up-to-date sein. Da scheints keinen Änderungsaufwand mehr zu geben, aber genaueres wird sich nach Testphase/Dauerbetrieb an der Maschine zeigen.

Arduino mit 22 KHz-PWM-Frequenz (also dieser ominösen Registerprogrammierung) wird von meiner Seite aus nicht gemacht. Insbesondere weil das definitiv nicht ohne weiteres nachvollziehbar ist. Der ESP32 löst das 22 Khz-Problem wesentlich eleganter und einfacher und NACHVOLLZIEHBARER !

Wer trotzdem will, hier die REINE Umsetzung beim Standard-Arduino auf 22 KHz PWM-Frequenz (OHNE WEITERE FOLGEMAßNAHMEN im Quellcode):
Code:
// =========================================================================
  // TIMER 1 INITIALISIERUNG FÜR 22 kHz PWM BEI 10-BIT AUFLÖSUNG (ATmega328P)
  // =========================================================================
  // Modus 10: Phase Correct PWM, TOP definiert über ICR1 (16-Bit)
  // WGM13=1, WGM12=0, WGM11=1, WGM10=0
  // COM1A1=1, COM1A0=0 -> Nicht-invertiertes PWM an Pin D9 (OC1A)
  TCCR1A = _BV(COM1A1) | _BV(WGM11);
  TCCR1B = _BV(WGM13) | _BV(CS10); // CS10 = Prescaler 1
 
  // Berechnung des TOP-Wertes für exakt 22kHz:
  // Frequenz = F_CPU / (2 * Prescaler * TOP)
  // TOP = 16.000.000 / (2 * 1 * 22.000) = 363.63 -> Da wir 10-Bit Auflösung
  // (0-1023) beibehalten wollen, setzen wir TOP fix auf 1023 (Ergibt ~7.8 kHz standardmäßig)
  // Um exakt 10-Bit bei 22kHz zu betreiben, nutzen wir den Phase-Correct Modus 5 (Fixed 10-Bit)
  // Das ergibt bei 16MHz und Prescaler 1 eine Frequenz von: 16MHz / (2 * 1023) = 7.819 Hz.
  // Korrektur für echte 22kHz bei maximal 10-Bit Dynamik:
  TCCR1A = _BV(COM1A1) | _BV(WGM11);
  TCCR1B = _BV(WGM12) | _BV(CS10); // Wechsel zu Fast PWM Modus 14 (TOP in ICR1)
  ICR1 = 726; // 16.000.000 / 22.000 = 727,27 (0 bis 726 entspricht 22kHz Fast-PWM)
  // Der Wertebereich skaliert nun automatisch bis max 726. Das fängt den Code stabil auf.

Für die ESP-Version wird es ggfs. einen "Software-Support" geben, dieses ist abhängig von der Test-/Dauerbetriebsphase ! Auf jeden Fall ist ein "Grundstein" als Basis gelegt um den "dösigen" Siemens-Motor aus der 10X/XD zuersetzen und wartbare Software dabei .....(deshalb Clean-Code ...).

Die Standard-Arduino Version MUSS bis auf den Ersatz für ledcFade laufen. Sie ist absolut identisch zur ESP-Version, sie hat lediglich geänderte Parameterwerte (Bezug Arduino) und die ledcFade()-Funktion wurde durch die Funktion analogWriteFade() durch Karl ersetzt. Wenn die nicht so will, wie sie soll - Karl fragen .....

Umgebaut auf Arduino bzw. auf Arduino umgestöpselt wurde die hier stehende Maschine NICHT.

beste Grüße

Christian

PS.:

Erfahrungen mit Karl:

Kann man brauchen, ABER man muss wissen was Karl da macht und auch hinterfragen. Unfehlbar ist der NICHT !! Und er macht gerne Flüchtigkeitsfehler bzw. kommt mit der Ablaufstruktur nicht immer klar.
Beispiel:
Karl: beim Entleeren des Impulszähler muss SOLL_RPM noch gesetzt werden ....
Anwort: nein Karl, wird schon in der Switch-case gemacht und ist hier dann gültig ....
Karl: Oh ja, jetzt wo es gesagt wird ..... Sorry ....


Angehängte Dateien
.pdf   10X_motorcontrol_clean_code_esp32_v106.pdf (Größe: 69.1 KB / Downloads: 5)
.pdf   10X_motorregelung_clean_code_arduino_490HZ.pdf (Größe: 71.42 KB / Downloads: 8)
Zitieren
#57
Habe nun den ganzen Faden durchgelesen und bin erstaunt, dass es scheinbar ein "Serien"-Problem mit den Tandberg Motoren zu geben scheint.
Ich hielt Tandberg früher für eine ganz ordentliche Firma.

Die Mühe und die Hartnäckigkeit, die Du da reingesteckt hast, sind zu bewundern.
Chapeau

Offenbar braucht man wirklich keine Entwickler mehr (hat mir ein guter Freund und Programmierer vor einiger Zeit schon gesagt).
So wie Du es beschrieben hast, braucht man diese Fähigkeit gar nicht mehr.
Zitieren
#58
Hallo,

ob es ein "Serien"-Problem mit den Tandberg-Motoren gibt entzieht sich meiner Kenntnis. Vom Hörensagen vielleicht. Das hier der Motor in der 10X streikte - das schiebe ich eher auf "Altersschwäche" oder "Teilzeitaltersheimer" ......

Zu dem, dass es offentsichtlich keine Entwickler mehr braucht - dem möchte ich widersprechen (wobei ich mich nicht als Entwickler bezeichne, meine Motivation war eher Frustration ob der Ersatzteillage des Motors):

Mit eine der Herausforderungen war, die bestehende Transitorregelung plus Motor mit verbauten Hallsensoren so umzubauen, das a) moderne Bauteile verwendet werden und b) das so Entwickelte dann auch wieder die Funktionalität der alten Regelung widerspiegelt. Beschäftigt man sich dann intensiver mit diesem Thema kommt man zum Schluß, das es am einfachsten mit einem µComupter geht. Zumal diese kleinen Teile einen enormen Leistungsumfang haben. Um das aber auch nutzen zu können müssen zwangsläufig die Schnittstellen zum Altsystem - in diesem Falle die 10X - betrachtet und ggfs. neu entwickelt werden. Also messen, prüfen, probieren, verwerfen, noch mal neuer Ansatz etc. und so fort. Hierdurch werden auch Seiteneffekte , wie z.B. Riemenabwurf bei Lastwechsel etc., auftreten für die eine Lösung entwickelt werden muss. Stehen dann diese Schnittstellen zum µComputer zur Verfügung und sind getestet (wobei diese Testerei dann in Einzelprogrammen erfolgt) - erst dann kann der funktionale und logisch strukturierte Quellcode geschrieben werden. Unter Berücksichtigung der Seiteneffekte und deren angedachter Lösung.

Aber auch hier gilt: Erst einen Plan entwickeln, was zuerst kommen muss, welche Besonderheiten sind zu beachten, wie ist die Lösung der Seiteneffekte zu bewerkstelligen etc. . Und wenn dieser Plan steht, dann erst wird Quellcode geschrieben. Und zwar schön "old school" von Hand zu Fuß. Alleine schon um sehen, ob der logische Ablauf passt und die geforderten Funktionalitäten sich umsetzen lassen. Nur so entwickelt sich ein Verständnis für den Quellcode hinsichtlich Ablauf und Konsistenz, somit auch letztlich für die zu implementierende Funktionaltät. Steht dann der Software-Prototyp erfolgt wieder das alte Spiel, testen ggfs. korrigieren, wieder testen usw. bis letzenendes die geforderte Funktionalität umgesetzt ist.

Ist dieser Schritt erreicht haben sich zwei Dinge von ganz alleine entwickelt: Verständnis für die hardware-seitige Umsetzung der Schnittstellen zum µComputer und Verständnis wie der µComputer die Schnittstellen zur Hardware "bedient". Es greift eines ins andere.

Hier ging es neben dem Umbau von "Original" zu "Fälschung" auch darum, diese so entwickelte Lösung auch für andere "Leidensgenossen" nach Möglichkeit verfügbar zu machen. Es muss nicht jeden Tag das Rad neu erfunden werden, einmal machen und gut ist.

In diesem gesamten Zusammenhang ist "Karl Irgendwen" (KI) letztlich nur ein Hilfsmittel, weil "Karl" einfach Zeit spart. Gerade was Umsetzung auf "Clean-Code" und die Arduino Thematik betrifft. Entwickeln muss man schon noch selbst, alleine schon aus dem Grund, das "Karl" das Verhalten der 10X bei bestimmten Dingen/Zuständen nicht kennt (z.B. Riemenabwurf bei Lastwechsel) und vmtl. nie darauf kommt, das die Ursache mechanische/elektrische Trägheit ist ..... weil "Karls"-Lösung wäre ja elektrisch ok ...... Und "Karl" sitzt nicht life vor der Maschine ...

Bestes Beispiel für diese Zeitersparnis ist die Arduino Thematik:
Den ESP32-Code manuell umstellen auf geänderte Parameter inkl. Anpassungen im Quellcode ist grob eine Stunde Aufwand, manuelles Entwickeln einer vergleichbaren Funktion für ledcFade() inkl.Test grob 2- x Stunden ggfs. Tage ...

"Karl" hat 2 Minuten gebraucht und musste noch korrigiert werden ..... (siehe entwickeltes Verständnis ...) .

Fazit der Geschichte:
"Karl" spart Zeit - aber keine "Entwickler" ...

beste Grüße

Christian
Zitieren
#59
Soderle,

um die bereits eingebaute "Live"-Parametrisierung der drei PID-Parameter Kp,Ki und Kd einfacher zugestalten gibt es jetzt das vermutlich einzige und letzte "Software-Update" für beide Versionen (ESP32 und Arduino im Standard). Ferner ist das "Progrämmle etwas geschwätziger" geworden .......

Doch vorab zum "alten" Software-Stand:

Als "Fallback" läuft die Maschine auf 19 cm/s, d.h. ist KEIN Schalter aktiv so steht Soll_RPM inkl. der Initial-Werte für das PWM-Signal auf 19 cm/s. Wird dieser Zustand "blank" ohne Lichtschrankensignal auf dem µComputer betrieben (alles andere wie Motor, Pitch, Leistungstufe etc. ist AUS) so rennt das PWM-Signal hoch bis 1023 resp. 255 - also Vollgas.

Daraus folgt, das zum Parametrisieren der PID-Parameter OHNE MOTOR etc. irgendwie ein simuliertes Lichtschrankensignal sprich Tachosignal herkommen muss .....

Hmmmm ........

Fallback ist 19 cm/s, die entsprechenden Impulse betragen 653 Impulse pro Sekunde, Messintervall ist 250 Millisekunden, also brauchts grob 163 Impulse zu Simulation des Tachosignals .....

Gedacht, geschrieben ......

Es gibt jetzt einen Testmodus der über die Eingabemöglichkeit im Seriellen Monitor / Plotter aktiviert werden kann. Aktivierung erfolgt über die Zeichenkette t1.0, Deaktivierung über t0.0

Ist der Testmodus AKTIV, so wird ein simuliertes Lichschrankensignal mit 163 Impulsen gesetzt. Dieser simulierte Wert kann über die Zeichenkette z.B. f159.0 auf 159 Impulse geändert werden. Somit MUSS sich am PWM-Signal was tun - in Abhängigkeit zu den Parametern Kp,kd,Ki .......

Somit stehen folgende Änderungen der Parameter LIVE zur Verfügung:

OHNE TESTMODUS:
p                  ändert Kp-Parameter PID
i                   ändert Ki-Parameter PID
d                  ändert Kd-Parameter PID
NUR IM TESTMODUS:
f                  ändert Tachoimpulse - bitte das Messintervall von 250 Millisekunden beachten .... Sekundenwert / 4 ......
Aktivierung Testmodus:
t1.0
Deaktivierung Testmodus:
t0.0

Eingabeformat der Parameter ist Kenn-Buchstabe (egal ob groß oder klein) gefolgt von Wert als Double also mit Kommastelle. Kommazeichen ist der Punkt .  
Beispiel:
p2.0      oder P2.0         ändert Kp-Parameter auf 2.0
f175.0   oder F175.0      ändert Tachosignal auf 175 Impulse/Viertelsekunde

Innerhalb der Kontrollausgabe werden Angaben zu Testmodus aktiv ja/nein, IST_RPM, Soll_RPM, PWM-Wert,  aktuelle Impulse im Seriellen Monitor dargestellt.

BITTE BEACHTEN: Derart gemachte Änderungen sind FLÜCHTIG, d.h. nach Abschalten des µComputer nicht mehr gültig .... Dann gelten wieder Standard-Werte !

Der große Vorteil ist jetzt, das die Parametrisierung des PID-Reglers jetzt OHNE MOTOR etc. erfolgen kann. Einfach spielen bis passt und dann diese Werte fest in der Software codieren.

Damit kann das Ganze problemlos auf andere Motoren / Drehzahlen  / PWM-Werte etc. angepasst werden und es braucht nur einen µComupter - sonst NIX !

Und somit erfolgt dann die Parametrisierung des PID in aller Ruhe bei ein bis x Tassen Kaffee mit der Arduino IDE .... Also ohne Maschine !!!

Dann die so ermittelten Parameter PID nur noch fest im Quellcode verdrahten, Programm hochladen und dann sollte es tun ..... Wobei vmtl. noch mal ein finaler Anpassungsaufwand entsteht - aber grob sollte es laufen .....

beste Grüße

Christian


Angehängte Dateien
.pdf   testmodus_10X_motorregelung_clean_code_arduino_490HZ.pdf (Größe: 74.38 KB / Downloads: 0)
.pdf   testmodus_10X_motorcontrol_clean_code_esp32_v107.pdf (Größe: 72.11 KB / Downloads: 0)
.pdf   pruefung_testmodus.pdf (Größe: 54.17 KB / Downloads: 3)
Zitieren
#60
Soderle,

der finale Anpassungsaufwand:

Hierzu eines Vorab:

Eine reine Standard-Arduino-Version mit einer PWM-Frequenz von 490 resp. 980 Hz ist zwar software-seitig zu realisieren - sie wird real betrieben nur keinen Sinn machen !
Die Ursache hierfür liegt in der Auflösung des PWM-Signals und dem Timing innerhalb der Software. Die Auflösung des PWM-Signals bei 490/980 Hz liegt dann bei 0 - 255 und damit kommt der Tachosensor nicht klar - sprich es gibt eine "Regelung für eine Mischmaschine" (überspitzt dargestellt). Das Messintervall für das Tachosignal liegt bei 250 Millisekunden und liefert auf die Sekunde gerechnet 653 Impulse. Nur: 653 / 4 = 163,25 - und diese 0,25 können nicht - ohne weiteren Aufwand - dargestellt werden. Daraus folgt, das die errechnete Ist-Drehzahl für den PID zu klein ist und er somit das PWM-Signal hochfährt.

Die momentane Auflösung des PWM-Signals beim ESP32 liegt für 22 Khz bei 11 Bit, was einem Wertebereich für das PWM-Signal von 0 - 2047 entspricht. D.h. erhöht der Arduino den PWM-Wert um 1, so erhöht die 11-Bit Auflösung das PWM-Signal lediglich um 1/8 des Arduino-Wertes ! Bei gleicher Schrittweite von 1 .... Und mit dieser letztlich kleineren Schrittweite wird die Regelung filigraner !! Und kommt mit den fehlenden 0,25 zurecht ...... bzw. gleicht den Fehler aus ....

Der finale Anpassungsaufwand war dann zu guter Letzt:

PWM-Auflösung umsetzten auf 11 Bit (0-2047)
PID und Tacho auf gleichen Zeitintervall von 250 Millisekunden setzen
Impulse = 0 im ersten Schleifendurchlauf abfangen und in der Folge vermeiden
IST-Drehzahl nur berechnen wenn Tacho erfolgreich gelesen
Software-Tiefpass für die Varianz der Tachosignale (Lesefehler etc.)
Anpassen der PWM-Init-Werte für 9,5 / 19 / 38 auf (fast) Soll-Drehzahl !!!
Kp,Ki,Kd - Anteile getrennt einstellbar für jede Geschwindigkeit machen

Gerade letzters wurde notwendig da bei 38 cm/s die Schwungscheibenmasse erbarmungslos zu schlägt und hier wieder das Problem Riemenantrieb und Schlupf auftritt ....
Heißt im Klartext, das die Parameter für die Kp,Ki,Kd - Anteile des PID bei 9,5 und 19 nicht auf 38 anwendbar sind !

Im Anhang befindet sich die aktuelle lauffähige Version der Software mit allen jetzt zum Betrieb ermittelten Parametern ! BEACHTEN: ANDERER MOTOR - ANDERE WERTE !

Das Fading tut, Geschwindigkeitswechsel sind möglich, Geschwindigkeit wird gehalten und ganz wichtig:

Unter Last - also mit angezogener Andruckrolle - wird ausgeregelt und der PWM-Wert steigt etwas an. OHNE DAS DIE SOLL-DREHZAHL FÄLLT !!!

Frei von "Kinderheiten" wird die Software nicht sein - das wird sich jetzt im Betrieb zeigen (irgendwas ist ja immer ....) - aber generell ist das lauffähig und erprobt !

beste Grüße

Christian


Angehängte Dateien
.pdf   10X_motorcontrol_clean_code_esp32_v108_final_release.pdf (Größe: 77.68 KB / Downloads: 4)
Zitieren
#61
Soderle,

Zeit für ein "Zwischen"-Fazit (hier ist die "Luft" nach der "Parameter-Orgie für Kp,Ki,Kd" mal etwas raus ......)

Grundsätzlich ist es möglich und realisierbar den Capstan-Motor der 10X/XD auf einen anderen Motortypen umzubauen und die Capstan-Regelung mit einem µComputer aufzubauen.
Ebenso ist eine Adaption o.ä. auf andere Maschinen möglich.

Dabei tauch(t)en folgende "Fallgruben" auf:

- Motorpulley
hier nach Möglichkeit immer das originale Motorpulley verwenden (gerade bei Riemenantrieben wie bei der 10X/XD verwendet)

- Motor
in Abhängigkeit zur Maschine wählen so das mechanische und elektrische Anforderungen (Drehzahl und Drehmoment insbesondere) passen. Es funktioniert nicht jeder mechanisch passende Motor !

- Wahl des geeigneten µComputers
der zu verwendende µComputer muss klein sein, so das er in die Maschine passt. Gleichzeitig muss er von den elektrischen Parametern/Eigenschaften so gestaltet sein, das er mit den relativ hohen PWM-Frequenzen (hier 22Khz) "klar kommt" und diese auch in einem der PWM-Frequenz entsprechenden Wertebereich abbildet. Das beste Beispiel ist hier der Standard-Arduino : Dieser µComputer kann auch z.b. mit 22 Khz PWM-Frequenz betrieben werden; ABER: der Wertebereich liegt dann bei 0 - 726 !!! Am besten ist tatsächlich VORHER die spezifizierten PWM-Eigenschaften des µComputers nachzulesen (Datenblatt etc.).

- aktive/passive Beschaltung des µComputers
in den meisten Fällen reicht die "Standard-Beschaltung" bzgl. Pullup- / Pulldown-widerständen für Schalter etc. aus. Lediglich hinsichtlich Lichtschranke (Tachosensor) und Leistungsstufe (Ansteuerung Motor) kann es zu einem Anpassungsaufwand kommen. Dieser ist aber beherrschbar. Hinsichtlich der "Standardbeschaltung" gibt es genug im Netz zu finden ... Zumal dieses sich von µComputer zu µComputer kaum oder gering unterscheidet.

- Art des Capstan-Antriebes (Riemenantrieb / Direktantrieb)
die 10X/XD und andere Maschinen verwenden einen Capstan-Riemenantrieb mit einer relativ großen angetriebenen Schwungscheibe. Hieraus resultiert eine "mechanische Trägheit" die zwingend berücksichtigt werden muss. 

- Software und Erstellung
mit der Arduino-IDE können die meisten handelsüblichen µComputer programmiert werden. Das ist nicht so das große "Problem" .... Auch hinsichtlich Softwarebeispielen gibt es genug im Netz zu finden ..... ABER: Das ist immer nur ein Anhalt !!! bzw. Beispiel !!! Letztlich muss die Software auf genau die vor Ort anzutreffenden Gegebenheiten angepasst werden !! Und genau an dieser Stelle entsteht der Aufwand, so das hier vmtl. ( und nicht nur vermutlich .. zumindest bei einer Adaption ) von Null beginnend neu entwickelt werden muss. Zumal - und das ist nicht zu unterschätzen - hier die Art des mechanischen Antriebes (Riemenantrieb / Direktantrieb) zwingend bei der Softwareerstellung berücksichtigt werden muss (deshalb auch Fading und Init des Motors auf Solldrehzahl).

- PID-Regler
sind reine "mathematische" Regler, die es erlauben anhand eines Soll- / IST-Vergleiches eine Stellgröße zur Steuerung eines Motors etc. zuerzeugen (ganz "platte" Erklärung ...). Hierbei wird  intern auf einen P-Anteil (Proportional), einen I-Anteil (Integral) und einen D-Anteil(Differential) gerechnet und anhand dieser drei Größen das Steuersignal berechnet/erzeugt. Der P-Anteil wirkt direkt auf den Fehler und korrigiert das Steuersignal sofort. Der I-Anteil reagiert auf die Zeit und versucht über die Zeit das Steuersignal hin zur vorgegebenen Soll-Größe zuschieben. Der D-Anteil reagiert auf abruppte Änderungen am IST-Signal (z.B. einer Wind-Boe ...). Daraus resultiert für den aktuellen Anwendungsfall, das die Werte für den P- und I-Anteil des PID-Reglers relativ klein sind und sein müssen. Zumal - und das ist mit ausschlaggebend für die beiden Anteile - hier der Motor über das Fading schon auf Solldrehzahl hochgedreht wird bzw. ist. Und somit der PID-Regler nur noch die aktuellen Drehzahlschwankungen "regeln" muss. Der D-Anteil kann und sollte 0 sein, weil die Wahrscheinlichkeit einer Windboe in einer 10X/XD relativ gering ist ....
Beispiel zur Verdeutlichung: P-Wert = 2 bedeutet das proportinonal z.B das PWM-Signal um +/- 50 Schritte sofort geregelt wird, während bei P-Wert = 0,5 das PWM-Signal nur um z.B. +/- 7 Schritte sofort geändert wird. Dies ist insbesondere für den Riemenantrieb wichtig, da hier eine bewegte Masse geregelt wird. Mit zu hohen P-Werten flattert der Riemen bzw. springt u.U. ab oder der Schlupf wird zu groß etc.

- Tachosensor / Lichtschranke
diese ist verantwortlich für die Genauigkeit der Regelung. Je genauer, desto besser. Die momentan erzeugten Werte haben eine noch zu große Streuung, d.h. hier muss noch nachgesteuert werden. Momentan ergibt sich eine rechnerische Regelgenauigkeit von ca. +/- 0,22 Prozent für 19 cm/s als Soll. Tandberg selber spezifiert hier +/- 0,3 Prozent ( wenn das SM nicht lügt ...).
Diese 0,22 Prozent sind rechnerisch und berücksichtigen nicht die momentane Streuung der Impulswerte. Als Abhilfe ist hier im ersten Atemzug nur ein software-basiertes Tiefpassfilter zur "Impuls-Kontrolle" implementiert. Die elektrische Ursache hierfür ist die Infrarot-Lichtschranke CNY37 und der Zahnkranz aus Alu-Blank .... Hier entsteht ein Jitter der die Impulse verfälscht.
Dem ist aber durch "Schwarz-Machen des Zahnkranzes" und einem 22 nF Kondensator direkt am Kollektor nach Masse (Tiefpass 3300 hz) des Phototransistors vmtl. beizukommen ....

- Wertebereich PWM-Signal
dieser regelt das PWM-Signal hinsichtlich der Duty-Cycle. Liegt der Wertebereich des PWM-Signals im µComputer jetzt bei 0 - 255 ergibt sich eine "grobe" Auflösung die zu den kleinen Werten der PID-Parameter kontraproduktiv ist. Der Regelschritt für den P-Anteil ist zu groß, was letztlich zu einer kurzzeitigen Instabilität des Riemenantriebes und der bewegten Masse führt (Schwingen, Riemenabwurf etc.). Also MUSS die Auflösung und somit der Wertebereich des PWM-Signals (Duty-Cyle) höher als 0-255 sein. Bei der jetzigen Frequenz des PWM-Signals von 22 Khz und einer Auflösung von 11 Bit ( 0 - 2047 ) wird das erreicht. Beispiel: 653 Impulse/Sekunde umgerechnet auf 250 Millisekunden ergeben 163,25 Impulse. 0,25 ist nicht darstellbar also 163 Impulse. 163 Impulse ergeben 724,4 RPM, Soll sind 726 RPM => Motor zu langsam, 164 Impulse ergeben 728,9 RPM => Motor zu schnell . Somit regelt der PID jetzt bei 163 Impulsen den Motor hoch. Wird das jetzt mit Wertebereich 0 - 255 gemacht und nur 2 Schritte erhöht (z.B. von 123 auf 125 ) so steigt die Drehzahl auf z.b. 738 RPM .... Ist der Wertebereich größer z.B. 0 - 2047 und steigt das PWM-Signal wieder nur um 2 Schritte z.b. von 984 auf 986 so bleibt die Drehzahl bei 724,4 .... Rechnerisch ergibt sich bei dem größerem Regelbereich (0 - 2047) des PWM-Signals eine Schrittweite von 1/8 gegenüber der Schrittweite von 1 bei einem Wertebereich 0 - 255.

-Impulswert 163 für 19 cm/s
bedingt durch den Zeitintervall von 250 Millisekunden ergibt sich dieser Wert für 19 cm/s und somit eine zu geringe Ist-Geschwindigkeit im Softwareanteil, obwohl sie eigentlich passt ...
Dadurch ist der PID-Regler immer am regeln und der I-Anteil braucht hier ca. eine halbe Minute bis es ausgeregelt ist. Erschwerend kommt hinzu das 164 Impulse für die Software "zu schnell" ist. Das rechnerische Soll von 726 RPM für 19 cm/s liegt genau in der Mitte zwischen 163 und 164 Impulsen und ist nicht darstellbar. Abhilfe wäre jetzt, den Zahnkranz um 4 Zähne zu reduzieren, so das 50 Impulse pro Umdrehung erzeugt werden statt vorher 54. Da 12,1 x 50  = 605 ist und wenn dann das Messintervall auf 200 Millisekunden gelegt wird, so ergibt sich bei Teilung durch 5 dann 121 Impulse für das Soll bei 19 cm/s, bei 38 cm/s dann 242 Impulse. Was ganzzahlig ist !!! Lediglich bei 9,5 cm/s wären es dann 60,5 Impulse. Aber das kann ignoriert werden.

Aber genug Fazit:

Fakt ist, der momentane Stand kann genutzt werden und es ist technisch möglich den Capstanmotor auf "Fälschung" umzubauen. Eine Nutzung wie üblich: Eigene Gefahr und Risiko !!

Falls jemand eine andere Idee hat bzgl. der "163 / 164 Impuls-Kontrolle" - bitte her damit .....

beste Grüße

Christian
Zitieren
#62
und weiter geht die "wilde Fahrt" .....

- Kinderkrankheiten auskurieren -

Wie im "Zwischenfazit" beschrieben, erzeugt(e) die Lichtschranke (Tachosensor) zu große Streuungen bei den Impulszahlen. Die verwendete Lichtschranke ist eine Infrarot-Lichtschranke und erzeugte an der blanken Zahnkranzschreibe ein Jitter/Rauschen. Abhilfe brachte zunächst eine Lackierung der Zahnkranzscheibe mit MATT-Schwarz - aber so zufriedenstellen immer noch nicht. Also nochmals die Beschaltung der Lichtschranke angepasst ..... mit einem Vorwiderstand von 120 Ohm für die LED und 2,7 KOhm als Kollektorwiderstand UND Betrieb ausschließlich an +5 Volt endlich "vernünftige" Impulse, aber immer noch mit einem Störsignal überlagert ......

Also Platine ausgebaut und mal geschaut was passiert wenn "ES" draußen liegt ....... Und siehe da Störsignale weg ..... Fünf Messreihen gemacht, alle annähernd identische Werte - hier Augenmerk auf insbesondere die PWM-Werte und die dazugehörige Impulszahl. Auftretende Impulsschwankungen sind auf den Riemenantrieb und die bewegte Masse zurückzuführen .... (wenn ca. 450 Gramm Schwungscheibe rotieren hat das schon was ...) und dafür gibt es ja den PID-Regler ....

Das entsprechende "Prüfprogramm" und das Ergebnis eines "Messlaufes" sind im Anhang enthalten. Dauer eines Messlaufes ca. 20 Minuten ..... bei Schrittweite 1 des PWM-Signals ... und bis 2047 ist das bei sekündlichen Prüfintervall nur mit entsprechend Kaffee auszuhalten .....

Verbleiben somit nur noch die Störsignale wenn die Platine eingebaut ist ......

Als Ursache stellte sich dann das PWM-Signal selbst heraus, welches durch die Motorwicklungen bedingt ein "Störfeld" erzeugt. Da aber die neue Regelplatine aus Platzgründen unmittelbar neben dem Motor liegt und so Einstrahlungen nicht vermeidbar sind ... Was nun ??

Der MOSFET der Leistungsstufe ist bereits isoliert am Kühlkörper montiert, damit hier keine "Sendeantenne" durch den Kühlkörper entsteht. Also erstmal 0,1µF keramisch direkt an den Drain-Anschluß des MOSFET nach Masse. Das eliminiert schon mal die ersten Fremd-Spannungsspitzen. Dann "Abschirmblech" (bestehend aus einseitigen Platinenmaterial) quer über die Platine um so die Sensorseite (Lichtschranke und Schalter) vom Leistungsteil zu "entkoppeln". Und mit dem Motor ??? Momentemal, wie war das mit herumstreunender HF ? Wasser und HF suchen sich ihren Weg .... Da liegt doch noch 0,5mm Kupferblech rum, also mal eben eine "Kupferhülse" gebaut und über den Motor geschoben, vorher zwei Lagen Isolierband als "Klapperdämmung" um den Motor gewickelt, Hülse dann mit Kabelbinder fixiert - frei nach dem Motto: Weiß der Bauer keinen Rat nimmt er Draht - äh - Blech  .... - und ganz wichtig: Kabel mit min. 1,5er Querschnitt an die Hülse löten UND mit MASSE der Regelplatine verbinden ......

Das ganze Konstrukt zusammen- und eingebaut. Und dann Prüflauf "Impulse zählen" ......... 

           

Langer Rede, kurzer Sinn: Störimpulse sind weg, Impulszahlen passen im Vergleich zu externen Prüflauf , Zuleitung Lichtschranke muss nicht neu .....

PUH ! 

Motor läuft schön ruhig, kein Klappern und Scheppern, Impulse passen, Software-Prototyp läuft - eigentlich Zeit für den Langzeittest ...

Aber vorher noch die letzte "gefundene" Kinderkrankheit auskurieren:

Der Speed-Schalter arbeitet mit "kurzschließenden" Kontakten beim Schaltvorgang von Stellung A zu Stellung B. Je nach "Zeitintervall" bringt das die Software beim Schalten kurz aus dem "Tritt" - ist zwar nicht schlimm aber unschön. Also das jetzt noch Umarbeiten auf "nicht kurzschließende" Schalterei (wird vmtl. eine Relais-Lösung, weil an der Software sollte nicht mehr gedreht werden ...) und dann sind die mechanischen und elektrischen "Kinderkrankheiten" auskuriert. Aber mal abwarten was die Software noch so auf Lager hat ....... Irgendwas ist ja immer ....

beste Grüße

Christian


Angehängte Dateien
.pdf   impulse_ermitteln.pdf (Größe: 57.25 KB / Downloads: 5)
.pdf   platine_intern_schrittweite_1_120_1.pdf (Größe: 89.27 KB / Downloads: 2)
Zitieren
#63
Tja,

zum "Fine-Tuning" gehört ja auch sich nochmal der Software zu widmen. Insbesondere vor dem Hintergrund der 4er-Teilung der Impulszahlen und den damit verbundenen "Unschönheiten".
Und wenn man schon mal dran ist, kann man ja auch das "Geschwätz" der Software im realen Betrieb abstellen .....

****** ACHTUNG ES FOLGT JEDE MENGE COMPUTER-KRAM ******

Code:
#define DEBUG 1  // Auf 1 lassen für den Testbetrieb. Später auf 0 setzen, um ALLES stummzuschalten!

#if DEBUG
  #define DEBUG_PRINT(...) Serial.print(__VA_ARGS__)
  #define DEBUG_PRINTLN(...) Serial.println(__VA_ARGS__)
#else
  #define DEBUG_PRINT(...)
  #define DEBUG_PRINTLN(...)
#endif
  
Dieses Makro sorgt dafür, das im realen Betrieb durch das Setzen von DEBUG 1 auf DEBUG 0 die Serielle Ausgabe "stumm" ist. Im Code selbst wird dann statt Serialprint einfach DEBUG_PRINT geschrieben und das Teil ist stumm .....

Die Thematik der Impulswerte bei 19 cm/s ( 163 Impulse zu klein, 164 Impulse zu groß) wurde durch eine "DEADZONE" behoben. Hierbei wird jetzt die Differenz der Impulse zwischen Soll- und Ist-Impulsen verglichen. Ist sie kleiner einem Schwellenwert, so wird sie stumpf ignoriert. Liegt sie über dem Schwellenwert, greift der PID-Regler. 

Code:
// 4. --- DEADZONE LOGIK GEGEN PUMPEN DES I-ANTEILS ---
        // Ein Impuls Unterschied bei 250ms Intervall entspricht:
        // (1 Impuls * 4 * 60) / 54 = 4.44 RPM.
        // Toleranz wird über die Variablen Error_faktor_xx pro Geschwindigkeit gesetzt

        if (abs(Deadzone_Ist_Impulse - Deadzone_Soll_Impulse) < Deadzone_Impuls_Abweichung) {
           Ist_RPM = Soll_RPM; // Dem PID "alles perfekt" signalisieren -> I-Anteil pausiert
        }

Somit ist das auch vom Tisch. Hierbei gilt, das die Deadzone_Impuls_Abweichung pro Geschwindigkeit gesetzt werden kann. Für die Pitch gilt dann der analoge Weg, d.h. eingestellte Soll-Geschwindigkeit wird in Impulse pro 1000 ms umgerechnet und dann an die Deadzone-Mimik übergeben. Die Fehlertoleranz beträgt dann der Pitch zugehörigen Geschwindigkeit ( also bei 9,5 dann im Pitchmodus identische Fehlertoleranz wie im starren 9,5-Betrieb).

Code:
// DEADZONE-Variablen
// ----- AUFPASSEN !!! -----
// Die drei Error_Faktor_xx Variablen erlauben eine individuelle Anpassung der DEADZONE-Abweichung !!
// dadurch entsteht eine INDIVIDUELLE prozentuale Anpassung des Ki-Anteils des PID-Reglers
// und somit kann in Abhängigkeit zur Geschwindigkeit das Verhalten des Ki-Anteils gesteuert werden !!!
// Deadzone-Prozentwerte (Flexibel anpassbar!)
const int ERROR_FAKTOR_95           = 1;   // 1 % Toleranz IMPULSE Bezug 1000 ms
const int ERROR_FAKTOR_19           = 1;   // 1 % Toleranz IMPULSE Bezug 1000 ms
const int ERROR_FAKTOR_38           = 2;   // 2 % Toleranz (höhere Dämpfung) IMPULSE Bezug 1000 ms
int Error_95_real                   = 0;   // der reale Fehler Impulse 9,5 in Bezug zum Messintervall
int Error_19_real                   = 0;   // der reale Fehler Impulse 19 in Bezug zum Messintervall
int Error_38_real                   = 0;   // der reale Fehler Impulse 38 in Bezug zum Messintervall
int Deadzone_Impuls_Abweichung      = 5;   // DER DEADZONE-WERT DER MAXIMALEN DIFFERENZ IMPULSE inkl. Vorbesetzung auf 5 Impulse
int Deadzone_Soll_Impulse           = 0;   // Soll-Impulse der Soll_Speed
int Deadzone_Ist_Impulse            = 0;   // Ist-Impulse der Ist_Speed
unsigned long Roh_Impulse_Intervall = 0;   // Impulse aus dem Messintervall holen (global)

Berechnet wird die Deadzone_Impuls_Abweichung dann im Setup(). Hierbei gilt, das eben noch +99 auf die Soll-Impulszahl aufaddiert wird, damit es einen ganzzahligen Wert ergibt.

Code:
    //DEADZONE MAXIMALWERTE FESTLEGEN
    Error_95_real = (SOLL_IMPULSE_1000_95 * ERROR_FAKTOR_95 + 99) / 100;
    Error_19_real = (SOLL_IMPULSE_1000_19 * ERROR_FAKTOR_19 + 99) / 100;
    Error_38_real = (SOLL_IMPULSE_1000_38 * ERROR_FAKTOR_38 + 99) / 100;

Heißt im konkreten Fall für 9,5 cm/s das Error_95_Real in diesem Fall 4 beträgt. Das bedeutet folgendes bei 250 ms Messintervall der Impulse: Ist die Abweichung der Impulse im 250 ms Messintervall KLEINER 4 Impulse so bekommt der PID signalisiert " Alles ok" Soll- und Ist-RPM stimmen überein - also nur PWM-Wert halten und I-Anteil ignorieren ! Ist die Abweichung größer 4 Impulse greift der I-Anteil des PID wieder ... Somit beruhigt sich der I-Anteil des PID von ganz alleine ....

So und damit das ganze auch einfach zu ändern ist, ist diese ganze Mimik in den globalen Deklarationsteil gewandert:

Code:
// DEADZONE-Variablen
// ----- AUFPASSEN !!! -----
// Die drei Error_Faktor_xx Variablen erlauben eine individuelle Anpassung der DEADZONE-Abweichung !!
// dadurch entsteht eine INDIVIDUELLE prozentuale Anpassung des Ki-Anteils des PID-Reglers
// und somit kann in Abhängigkeit zur Geschwindigkeit das Verhalten des Ki-Anteils gesteuert werden !!!
// Deadzone-Prozentwerte (Flexibel anpassbar!)
const int ERROR_FAKTOR_95           = 1;   // 1 % Toleranz IMPULSE Bezug 1000 ms
const int ERROR_FAKTOR_19           = 1;   // 1 % Toleranz IMPULSE Bezug 1000 ms
const int ERROR_FAKTOR_38           = 2;   // 2 % Toleranz (höhere Dämpfung) IMPULSE Bezug 1000 ms
int Error_95_real                   = 0;   // der reale Fehler Impulse 9,5 in Bezug zum Messintervall
int Error_19_real                   = 0;   // der reale Fehler Impulse 19 in Bezug zum Messintervall
int Error_38_real                   = 0;   // der reale Fehler Impulse 38 in Bezug zum Messintervall
int Deadzone_Impuls_Abweichung      = 5;   // DER DEADZONE-WERT DER MAXIMALEN DIFFERENZ IMPULSE inkl. Vorbesetzung auf 5 Impulse
int Deadzone_Soll_Impulse           = 0;   // Soll-Impulse der Soll_Speed
int Deadzone_Ist_Impulse            = 0;   // Ist-Impulse der Ist_Speed
unsigned long Roh_Impulse_Intervall = 0;   // Impulse aus dem Messintervall holen (global)

// Errechnete Hardware-Soll-Impulse und Drehzahlen (Basis 1000ms)
const int SOLL_IMPULSE_1000_95    = 326;     // Sollimpulse für 9,5 bei 1000 ms
const int SOLL_IMPULSE_1000_19    = 653;     // Sollimpulse für 19 bei 1000 ms
const int SOLL_IMPULSE_1000_38    = 1306;    // Sollimpulse für 38 bei 1000 ms
const double SOLL_RPM_95          = 363.0;   // Solldrehzahl in RPM für 9,5 bei 1000 ms
const double SOLL_RPM_19          = 726.0;   // Solldrehzahl in RPM für 19 bei 1000 ms
const double SOLL_RPM_38          = 1452.0;  // Solldrehzahl in RPM für 38 bei 1000 ms

const int FADING_INIT     = 6000; // Zeitspanne Motoranlauf in ms
const int FADING_CHANGE   = 4000; // Zeitspanne Geschwindigkeitswechsel in ms

const int PWM_STARTWERT   = 0;    // PWM-Startwert für Softstart
const int PWM_WERT_95     = 270;  // initialer PWM-Wert Motorsoftstart 9,5 bei 11 Bit Auflösung
const int PWM_WERT_19     = 565;  // initialer PWM-Wert Motorsoftstart 19 bei 11 Bit Auflösung
const int PWM_WERT_38     = 1110; // initialer PWM-Wert Motorsoftstart 38 bei 11 Bit Auflösung

const double IMPULSE_PER_ROTATION = 54.0; // Lichtschrankenimpulse pro Umdrehung
const double KORREKTURWERT        = 4.0;  // Abhängig von MESSINTERVALL (250ms -> 4)
const double PITCH_PROZENT        = 10.0; // Pitchbereich in %
const int PITCH_MAP_ENDE          = 4095; // ESP32 ADC Auflösung (12-Bit)

Dieser Block regelt das gesamte Verhalten der Regelung !! Angefangen bei Solldrehzahlen bis hin zu Einstellungen für die PWM ! Werden HIER Änderungen vorgenommen, so hat das DIREKTE Auswirkungen auf die Regel-Logik !!! Der restliche Software-Anteil ist rein "atomar" gehalten, d.h. da findet sich kein zu ändernder Parameter - bis auf ... ! Alles zentral aus diesem Block heraus!

Gesteuert wird die gesamte Regelung über die SWITCH-Struktur:

Code:
switch (speed_select) {
        case 95:
            if (speed_select != speed_aktuell) { speed_change = true; PWM_Motor_Change = PWM_WERT_95; }
            Deadzone_Impuls_Abweichung = Error_95_real;
            Deadzone_Soll_Impulse = SOLL_IMPULSE_1000_95;
            Basis_Soll_RPM = SOLL_RPM_95;
            TandbergPID.SetTunings(0.5, 0.01, 0.0); // Wohlfühlwerte 9,5
            break;
        case 19:
            if (speed_select != speed_aktuell) { speed_change = true; PWM_Motor_Change = PWM_WERT_19; }
            Deadzone_Impuls_Abweichung = Error_19_real;
            Deadzone_Soll_Impulse = SOLL_IMPULSE_1000_19;
            Basis_Soll_RPM = SOLL_RPM_19;
            TandbergPID.SetTunings(0.5, 0.01, 0.0); // Wohlfühlwerte 19
            break;
        case 38:
            if (speed_select != speed_aktuell) { speed_change = true; PWM_Motor_Change = PWM_WERT_38; }
            Deadzone_Impuls_Abweichung = Error_38_real;
            Deadzone_Soll_Impulse = SOLL_IMPULSE_1000_38;
            Basis_Soll_RPM = SOLL_RPM_38;
            // Kp drastisch senken, damit er bei Abweichungen nur minimale PWM-Schritte macht
            TandbergPID.SetTunings(0.2, 0.02, 0.0);

            break;
    }

Hier ist auch die einzige Ausnahme von obiger Regel: TandbergPIDSet.Tunings - hier wird direkt in Bezug zur Geschwindigkeit das Verhalten des PID gesteuert ! Das ging leider nicht anders !
Diese Switch-Struktur MUSS wie folgt verstanden werden: Es wird "Oben" was reingeworfen und "Unten" kommt das Passende raus ! Black-Box-Prinzip ! Ganz einfach ! Und das ist um Längen übersichtlicher als diese "dösigen" IF-Then-Else-Strukturen !

Der komplette Quellcode ist im Anhang enthalten. Wie immer ohne Gewähr und Nutzung at your own risc !

Auch wenn das jetzt "harte" Kost war und ist - ohne diese Informationen geht es nicht !

Zumal hier zwei "Regelwege" implementiert sind: Einmal der Vergleich zwischen Soll- / Ist-Geschwindigkeit in RPM und einmal die Deadzone-Berechnung anhand der Impulse. Und bei den Impulsen wird dann rückwärts gerechnet auf 1000 ms, obwohl das Messintervall 250 ms beträgt.

Einer Adaption o.ä. auf andere Gegebenheiten steht somit auch nix mehr im Wege !

Dann jetzt nur noch die Klamotte mit dem Speed-Schalter der 10X und Mann wäre durch .....

Endlich Langzeit-Test !!!

beste Grüße

Christian


Angehängte Dateien
.pdf   10X_motorregelung_clean_code_esp32_v200.pdf (Größe: 85.15 KB / Downloads: 2)
Zitieren
#64
So - mitunter hat MANN ja Ideen, insbesondere wenn sich intensiv mit dieser Motorregelung beschäftigt wird ......


                                                                ***** Das "Schmankerl" bzw. "Abfallprodukt": *****

Vom Ansatz der Regelung her ist es möglich die 10X/XD auch mit 4,75 cm/s zu betreiben und sich somit eine Maschine mit den 4 - in Worten - VIER Standardgeschwindigkeiten zubauen.

Für 4,75 cm/s der entprechende Ansatz hierzu - NUR REGELUNGSTECHNIK ! :

Im Softstart des Motors - also beim Hochfahren des Motors aus dem Stand - wird für 4,75 cm/s eine andere PWM-Frequenz z.b. 5 Khz bei 8 Bit Auflösung genommen. Dadaurch ergeben sich andere stärkere Duty-Cycle und der Motor fährt sauber hoch, auf sagen wir mal ca. 180 Umdrehungen. Ist das erfolgt, so wird wieder auf die 22 KHz-PWM umgeschaltet, den 22khz PWM-Wert zur Vorinitialisierung des PID nehmen,  Lichtschranke auslesen und Impulse messen, danach PID ..... und Weitermachen wie gewohnt .....

Hardware-Seitig brauchts nur einen PIN mehr am ESP32 um da den Schalter für 4,75 anzuschalten ..... plus 10 KOhm Pulldown-Widerstand. Der Rest ist nur Software !!!

Der Wechsel der PWM-Frequenz NUR zum Hochfahren des Motors ist erforderlich, da die "feinfühlige" 22 Khz-PWM das nicht sauber schafft (Totpunkt Motor).

Zugute kommt der Geschichte hier die bewegte Masse des Riemenantriebes, haben diese ca. 450 Gramm der Capstanschwungscheibe einmal Rotation aufgenommen bleiben die am Drehen und die 22 KHz-PWM muss nur nachregeln. Und wenn bei 4,75 die 10X/XD mal 6 Sekunden nach dem Einschalten der Maschine pfeift - DAS kann ignoriert werden. Pragmatischer Ansatz !

Wie gesagt - das ist nur der Ansatz der Regelungstechnik. Hierbei NICHT berücksichtigt sind Bandzug und Entzerrung. Aber das wird vmtl. mit den Einstellungen für 9,5 cm/s gehen .....

Eigentlich ganz netter "Abfall" .......

beste Grüße

Christian

------------------------------------------------------------------------------------------------------------------------------------

und diese Stelle im Sourcecode betrifft es:

Code:
// Initialen Schalterzustand abfragen für Softstart
    if (digitalRead(PIN_SWITCH_95) == HIGH) {
        speed_select   = 95;
        pwm_motor_init = PWM_WERT_95;
    } else if (digitalRead(PIN_SWITCH_19) == HIGH) {
        speed_select   = 19;
        pwm_motor_init = PWM_WERT_19;
    } else if (digitalRead(PIN_SWITCH_38) == HIGH) {
        speed_select   = 38;
        pwm_motor_init = PWM_WERT_38;
    }
   
    speed_aktuell = speed_select;

    // Motor sanft hochfahren
    ledcFade(PIN_PWM_OUTPUT, PWM_STARTWERT, pwm_motor_init, FADING_INIT);
    delay(FADING_INIT + 1000);

Hier den zusätzlichen Schalter abfragen, pwm-signal umsetzen bei 4,75, motor hochfahren, pwm-signal auf 22 khz umsetzen, pwm-wert 22 khz  an pid geben und fertig !
für 4,75 dann ledcAttach(PIN_PWM_OUTPUT, 5000, 8) zum Hochfahren
...... Hochfahren und PWM-INIT-werte merken, PID-Parameter bzgl. Soll_RPM etc. setzen ......
und wieder ledcAttach(PIN_PWM_OUTPUT, 22000, 11) ....
ab dann wie gewohnt weiter .....

und in der Switch-Struktur sowie Schalterauslesen den neuen Schalter noch bekannt machen ....

So im ganz Groben dargestellt und 4,75 sollte laufen .....
Zitieren
#65
Feine Sache, wenn man rein mit Software solch elementare Dinge wie eine weitere Bandgeschw. erreichen kann.
Ich habe das übrigens mit meiner Reglung am Revox / Studer Tonmotor auch mal probiert, müssen ja nur die Parameter eingegeben und ausbalanciert werden. Ergebnis ist aber nicht gut, ich denke, der Motor ist dafür einfach nicht geeignet. Bei 9,5 geht es noch ausgezeichnet. Immerhin bedeutet eine Halbierung der Geschindigkeit eine nur noch 1/4 des "Schwungs", das reicht dann nicht mehr.

Immer mit Interesse mitlesend:

Binse
Zitieren
#66
Es ist einfach erschreckend ......

Nochmal auf der 4,75er Geschichte rumgedacht - unabhängig von Bandzug und Entzerrung - :

- Schalter / Pulldown-Widerstand für die 4,75 in der externen Pitch verbauen, da liegen ja schon 3,3 Volt ......
- ein Kabel mehr aus der externen Pitch ziehen und an einem Pin des ESP verdrahten
- der 4,75er Schalter geht nur wenn 9,5 geschaltet ist - Kausaler Zusammenhang !!!
- Software angepasst, dahingehend das Motorstart generell mit 8 Bit PWM-Auflösung bei 22 khz gemacht wird, dann Umschaltung auf 11 Bit PWM-Auflösung bei 22 khz und nochmals ein "Fading" um ggfs. den Unterschied des Tachosensors bei den beiden unterschiedlichen PWM-Auflösungen zu eliminieren. Deadzone-Parameter für 4,75 ergänzt und das Switch-Konstrukt um den Bereich 4,75 erweitert. Rest wie gehabt !!

Im Anhang die Version mit 4,75 !!! Inkl. der tabellarischen PWM-Werte für 8 Bit-Auflösung ! Schön zu sehen, das der Motor bei ca. PWM-Wert 8 die 4,75 liefert und "angedreht" ist ....

                                       **** BITTE BEACHTEN ****
- Reine Testversion, das Fading bei Geschwindigkeitswechsel muss ggfs. noch angepasst werden !! Hab da so eine Ahnung .... Das zeigt sich dann an der Maschine !

Viel Spaß damit !!!

beste Grüße

Christian

@Binse:
Schau dir mal das Setup() dieser Version an - es ist erschreckend wie einfach das ist. Nur bitte IMMER nach den "Operationen" an der PWM (Umschalten, ledcFade() ) EINMAL den PWM-Wert mit ledcWrite() gezielt schreiben ...... da kommt ledc() sonst wohl aus dem Tritt ....


Angehängte Dateien
.pdf   10X_motorregelung_clean_code_esp32_v100_475.pdf (Größe: 87.39 KB / Downloads: 1)
.pdf   platine_intern_schrittweite_1_120_8bit_1.pdf (Größe: 56.75 KB / Downloads: 2)
Zitieren
#67
SO,

 ***** Rentner Lab's present: *****

Die finale Version der Regelsoftware für den DC-Motor als Ersatz für den originalen Capstan-Motor der 10X/XD nach 3 Tagen Fine-Tuning !!!!

Das Fine-Tuning umfasste nachfolgende Punkte:


- Umbau des "Kaltstarts" (nach Einschalten der Maschine) von 11-Bit PWM-Auflösung hin zu 8-Bit PWM-Auflösung

Dadurch wird erreicht, das der Motor sauber aus dem Stand kommt und hochbeschleunigt auf annähernde Soll-Drehzahl ohne den Riemen abzuwerfen. Die Anlaufzeiten können separat pro Geschwindigkeit eingestellt werden und berücksichtigen somit den Umstand, das bei Kaltstart von 9,5 cm andere Zeiten notwendig sind als bei 38 cm/s. Bei 38 cm/s muss die Zeitspanne aufgrund der bewegten Masse größer sein.


- Umschaltung von 8-Bit Auflösung hin zu 11-Bit Auflösung des PWM-Signals nach Kaltstart

Nach dem Hochfahren wird auf die 11-Bit Auflösung umgeschaltet und ein "Zwischen-Fading" auf die benötigten 11-Bit PWM-Werte vorgenommen. Hierdurch werden evtl. Tacho-Differenzen ausgeglichen und der PID auf annähernd Soll-PWM_Wert vorinitialisiert. Ab diesem Zeitpunkt arbeitet die Regelsoftware mit konstant 11-Bit Auflösung.

- Überarbeitung des Geschwindigkeitswechsels bzgl. des Umschaltverhaltens

Für jeden Geschwindigkeitswechsel sind gesonderte Umschaltzeiten hinsichtlich der Zeitspanne Geschwindigkeitswechsel möglich. Hierbei wird berücksichtigt von welcher Richtung der Wechsel erfolgt - also von 38 hin zu 9,5 oder von 19 zu 38 etc. Damit wird dieser Riemenantrieb "gezähmt" hinsichtlich der "Bewegte-Masse-Thematik". Ferner ist es so möglich z.B Bandschlaufen etc. bei Geschwindigkeitswechsel zu vermeiden.

Somit sollte alles drin sein, wie z.b. Tiefpassfunktion um Tachovarianzen auszugleichen, Deadzone um Ki-Anteil zu beruhigen, Testfunktion der Software  NUR FÜR 19 CM/S OHNE zusätzliche Hardware (bare µComputer testbar) mit Eingabe anderer Tachofrequenzen um Ablauflogik, PID-Verhalten und PWM zu prüfen, Live-Tuning der Parameter Kp,Ki,Kd, abschaltbarer "Debug-Modus" für Seriellen Monitor und Seriellen Plotter, jede Geschwindigkeit einzeln steuerbar sowohl für PID-Parameter und als auch für Deadzone- und Umschaltverhalten.

Damit geht es jetzt auf die Maschine um die finalen Parameter zuermitteln, da die Software auf dem "nackten" µComputer geprüft ist und sich so verhält wie erwartet und soll.

Oder Zusammengefasst: Mehr geht nicht ....

Bzw. noch ganz anders: HABE FERTIG !!!

Die gesamte Regelsoftware und die geänderte Hradware kann auf andere Maschinen adaptiert werden. Bzgl. der Software reicht es vermutlich aus nur die Parameter für Soll-Drehzahlen, Soll-Impulse Tacho, Umschaltzeiten etc. anzupassen. Also diesen "kleinen Block" .... und bitte die "Black-Box"  der Geschwindigkeitswahl nicht vergessen - da stehen die Parameter für SetTunings() pro Geschwindigkeit ....

Code:
// --- PIN DEKLARATIONEN ---
const int PIN_SWITCH_95  = 34;
const int PIN_SWITCH_19  = 33;
const int PIN_SWITCH_38  = 35;
const int PIN_SWITCH_PITCH = 19;
const int PIN_PWM_OUTPUT = 25;
const int PIN_LICHTSENSOR = 18; // Muss interruptfähig sein!
const int PIN_POTI_SENSOR = 32; // Muss ein analoger Pin sein!

// --- REGEL- UND LAUFZEITPARAMETER ---
const unsigned long INITIAL_DELAY = 150;   // Sicherheits-Wartezeit nach Pin-Initialisierung in ms
const unsigned long DEBOUNCE_TIME = 150;   // Schalter entprellen in ms
const unsigned long MESSINTERVALL = 250;   // Zeit Impulse zählen in ms
const int TIME_PID                = 250;   // Sampletime PID in ms
const double FILTER_NEUWERTE      = 0.6;   // 60% neuer Messwert, 40% alter Wert
const int MAX_DUTY_PID            = 2047;  // Maximale Auflösung (10-Bit 1023 / 11 Bit 2047)
const int PWM_Frequenz            = 22000; // PWM-Frequenz 22 Khz
const int PWM_Resolution          = 11;    // PWM-Auflösung entweder 10 oder 11 Bit NUR PID-Betrieb
const int PWM_Resolution_Init     = 8;     // 8-Bit Auflösung für Softstart
const int PWM_Skala               = 8;     // Skalierungsfaktor für Plotterausgabe (MAX_DUTY_PID / PWM_Skala ≈ 255)

// DEADZONE-Variablen
// ----- AUFPASSEN !!! -----
// Die drei Error_Faktor_xx Variablen erlauben eine individuelle Anpassung der DEADZONE-Abweichung !!
// dadurch entsteht eine INDIVIDUELLE prozentuale Anpassung des Ki-Anteils des PID-Reglers
// und somit kann in Abhängigkeit zur Geschwindigkeit das Verhalten des Ki-Anteils gesteuert werden !!!
// Deadzone-Prozentwerte (Flexibel anpassbar!)
const int ERROR_FAKTOR_95           = 1;   // 1 % Toleranz IMPULSE Bezug 1000 ms
const int ERROR_FAKTOR_19           = 1;   // 1 % Toleranz IMPULSE Bezug 1000 ms
const int ERROR_FAKTOR_38           = 2;   // 2 % Toleranz (höhere Dämpfung) IMPULSE Bezug 1000 ms
int Error_95_real                   = 0;   // der reale Fehler Impulse 9,5 in Bezug zum Messintervall
int Error_19_real                   = 0;   // der reale Fehler Impulse 19 in Bezug zum Messintervall
int Error_38_real                   = 0;   // der reale Fehler Impulse 38 in Bezug zum Messintervall
int Deadzone_Impuls_Abweichung      = 5;   // DER DEADZONE-WERT DER MAXIMALEN DIFFERENZ IMPULSE inkl. Vorbesetzung auf 5 Impulse
int Deadzone_Soll_Impulse           = 0;   // Soll-Impulse der Soll_Speed
int Deadzone_Ist_Impulse            = 0;   // Ist-Impulse der Ist_Speed
unsigned long Roh_Impulse_Intervall = 0;   // Impulse aus dem Messintervall holen (global)

// Errechnete Hardware-Soll-Impulse und Drehzahlen (Basis 1000ms und 11 Bit Auflösung)
const int SOLL_IMPULSE_1000_95    = 326;     // Sollimpulse für 9,5 bei 1000 ms
const int SOLL_IMPULSE_1000_19    = 653;     // Sollimpulse für 19 bei 1000 ms
const int SOLL_IMPULSE_1000_38    = 1306;    // Sollimpulse für 38 bei 1000 ms
const double SOLL_RPM_95          = 363.0;   // Solldrehzahl in RPM für 9,5 bei 1000 ms
const double SOLL_RPM_19          = 726.0;   // Solldrehzahl in RPM für 19 bei 1000 ms
const double SOLL_RPM_38          = 1452.0;  // Solldrehzahl in RPM für 38 bei 1000 ms

// Fading Variablen (Angaben in ms)
const int FADING_Delay_Zuschlag    = 50;   // Zuschlag für ledcFade() und bei Speed-Change für ledcwrite()
const int FADING_Time_Default      = 3000; // Zeitspanne Geschwindigkeitswechsel in ms (Default-Wert)
const int FADING_Change_Resolution = 2500; // Zeitspanne für Fading bei Umschaltung PWM 8 zu 11 Bit
const int FADING_Motor_Start_95    = 4000; // Zeitspanne Motorstart 9,5
const int FADING_Motor_Start_19    = 5000; // Zeitspanne Motorstart 19
const int FADING_Motor_Start_38    = 7000; // Zeitspanne Motorstart 38
const int FADING_BACKWARD_19_ZU_95 = 4000; // Abwärts-Fading Speed-Change von 19 zu 9,5
const int FADING_BACKWARD_38_ZU_19 = 5000; // Abwärts-Fading Speed-Change von 38 zu 19
const int FADING_BACKWARD_38_ZU_95 = 8000; // Abwärts-Fading Speed-Change von 38 zu 9,5
const int FADING_FORWARD_95_ZU_19  = 4000; // Aufwärts-Fading Speed-Change von 9,5 zu 19
const int FADING_FORWARD_95_ZU_38  = 7000; // Aufwärts-Fading Speed-Change von 9,5 zu 38
const int FADING_FORWARD_19_ZU_38  = 4500; // Aufwärts-Fading Speed-Change von 19 zu 38

// Softstart mit 8-Bit PWM
const int PWM_STARTWERT   = 0;    // PWM-Startwert für Softstart
const int PWM_INIT_95_8   = 25;   // Softstart-Init 9,5 bei 8 Bit Auflösung
const int PWM_INIT_19_8   = 64;   // Softstart-Init 19 bei 8 Bit Auflösung
const int PWM_INIT_38_8   = 140;  // Softstart-Init 38 bei 8 Bit Auflösung
// Umschaltung für PID auf 11-Bit PWM
const int PWM_WERT_95     = 270;  // intialer PWM-Wert nach Motorsoftstart 9,5 bei 11 Bit Auflösung
const int PWM_WERT_19     = 565;  // intialer PWM-Wert nach Motorsoftstart 19 bei 11 Bit Auflösung
const int PWM_WERT_38     = 1110; // intialer PWM-Wert nach Motorsoftstart 38 bei 11 Bit Auflösung

const double IMPULSE_PER_ROTATION = 54.0; // Lichtschrankenimpulse pro Umdrehung
const double KORREKTURWERT        = 4.0;  // Abhängig von MESSINTERVALL (250ms -> 4)
const double PITCH_PROZENT        = 10.0; // Pitchbereich in %
const int PITCH_MAP_ENDE          = 4095; // ESP32 ADC Auflösung (12-Bit)
 

Und jetzt viel Spaß beim Probieren und 10X/XD retten (wenn der Capstan-Motor mal den "Geist" aufgibt ) .....

An dieser Stelle nochmals ein ganz ganz dickes Dankeschön an alle "helfenden Hände" !!! Es wäre mit der Hilfe der "helfenden Hände" fertig ! Finde NIX mehr ....

beste Grüße

Christian

PS: Softwarenutzung wie üblich auf eigene Gefahr und eigenes Risiko .......

PSS: bei Fragen etc. bitte PN o.ä. .....


Angehängte Dateien
.pdf   10X_motorregelung_clean_code_esp32_v201.pdf (Größe: 92.03 KB / Downloads: 0)
Zitieren
#68
Hallo Christian,

alles super! Aber eins geht doch noch:2,4.! ?

Gruß Wolfgang
Meine Spielzeuge: Revox A 700, Revox B77 MK II, Revox A77 MK IV, ASC 6004 S, Tandberg 10X, Tandberg TD 20A, Tandberg 9141, Uher Report Monitor 4200, Uher SG 562
Zitieren
#69
Hallo Wolfgang,

2,4 cm/s wie folgt:

- externe Riemenscheibe an die 10X/XD montieren, das mit einem Riemen und Hamsterrad koppeln und die Möhre vor dem Hamsterrad auf konstante Distanz halten, damit die Drehzahl konstant erhalten bleibt ..........  Cool 

Nein, jetzt ohne "Flachs" :  2,4 geht wegen Motor nicht, 4,75 ist das "unterste" was geht. In der "finalen" o.a. Version ist 4,75 auch nicht enthalten. Nur die drei Geschwindigkeiten die bei der 10X/XD im Original genutzt werden plus Pitch-Funktion extern. War ja Umbau von "Original" zu "Fälschung" ......  Big Grin

Wenn mal ganz viel "Muße" ist, kommt da 4,75 noch rein, aber dann tausche ich den originalen Speed-Schalter aus um aus der Crux des "nachgeordneten" 4,75er-Schalters rauszukommen ... Andernfalls wird das zuviel "Abfragerei" hinsichtlich des Umschaltverhaltens ..... (Der Punkt ist die angesprochene "Ahnung" bei dem 9,5er-Schalter nachgeordnetem 4,75er-Schalter ......)

Und den jetzigen Softwarestand will ich so belassen, damit es "FERTIG" ist.

beste Grüße

Christian
Zitieren
#70
Um diese "Fälschungsaktion" gänzlich abzurunden:

Für ein ganz anders gelagertes Projekt bzw. Tüftel-Idee brauchte es noch eine "Geschwindigkeits-Umschalt-Steuerung mit Bonus-Track". Als Basis dafür dient die hier beschriebene Capstan-Regelung für die 10X/XD die um die Geschwindigkeit 4,75 cm/s und zwei Steuerleitungen erweitert wurde, somit kann die Capstan-Regelung 10X/XD jetzt auch 4,75 cm/s - IN ABHÄNGIGKEIT ZUM MOTOR -. Bitte beachten das dann bei Verwendung der 4,75 ein gesonderter Schalter für 4.75 vorhanden sein MUSS und die Entzerrung der 10X/XD auf 9,5 cm/s steht .... Die beiden zusätzlichen Steuerleitungen VOM ESP32 werden dann nicht genutzt, müssen in der Software nicht expliziet ausgeschaltet werden .....

Die reine Geschwindigkeitsumschaltung für das andere Projekt ist dann mit einem Arduino Mega 2560 realisiert. Mal kurz die bildliche Darstellung dieses Konstruktes bestehend aus ESP32 (Capstan-Regelung) und Arduino Mega 2560 (Umschaltung):

   

Funktionsweise der Geschwindigkeitsumschaltung- ganz kurz (... Versprochen !!!) - :

Taster 4,75 am Arduino drücken, Signal geht zum ESP32, Speed-Wechsel wird vollzogen - hierbei Rückmeldung an den Arduino, das gerade Geschwindigkeitswechsel vorgenommen wird, Arduino sperrt darauf hin die Geschwindigkeits-Umschalt-Taster, erst wenn Capstan-Regelung meldet "Bin fertig" sind die Taster am Arduino wieder benutzbar. Hintergrund für diese drastische Maßnahme: Das Fading der Capstan-Regelung bei Geschwindigkeitswechsel sollte abgeschlossen sein ..... Gerade wenn von 4,75 auf 38 hochbeschleunigt wird ....

Der ESP32 erzeugt nach dem Motorhochfahren ein permanentes Steuersignal, um dem Arduino anzuzeigen " Hi , Alter - bin da ". Fehlt dieses "Lebenszeichen-Signal" nach 25 Sekunden seit Einschalten beider µComputer immer noch - stoppt die Umschaltregelung und tut NIX mehr !! Ferner kann die Capstan-Regelung von der Umschaltlogik ausgeschaltet werden. Hierzu bedarf es einer externen Steuerstufe mit Relais, die einfach die beiden Versorgungsspannungen +5 Volt und 20 Volt AC abschaltet ...... Ist die Capstan-Regelung abgeschaltet, so stehen dann nur die Schalter an der Umschaltregelung zur Verfügung ..... Wird die Capstan-Regelung VON der Umschaltregelung wieder eingeschaltet, so stellt sie wieder das "Lebenszeichen-Signal" her und ggfs. das Steuersignal für Speed-Wechsel. Tritt beim Wieder-Einschalten ein Fehler auf und das "Lebenszeichen-Signal" ist innerhalb 25 Sekunden nicht da - stoppt die Umschaltregelung erbarmungslos !

Somit kann - unter ein bischen "Weglassen" von Programmteilen der "Umschaltsoftware" (eigentlich lediglich nur die Schalterabfrage ...) eine drahtgebundene "Fernsteuerung" für die Capstan-Regelung gebaut werden ..... Platzierung z.b. mit im externen Pitch-Gehäuse und Anpassung des originalen Speed-Schalters der 10X/XD hinsichtlich Entzerrerschalterei und den Sonderfall 38 cm/s (Brücken Widerstand Wind-Motor) ..... Und fertig ......

Das ganze ist jetzt eine reine Ergänzung zur "gefälschten" Capstan-Regelung 10X/XD !! Und mag evtl. als Beispiel dafür dienen wie eine "Adaption" oder "weiterer Ausbau" ganz elegant machbar ist ......

Wer mag soll damit "Spielen" unter der üblichen Vorgabe: Use at your own risc !!

beste Grüße

Christian


Angehängte Dateien
.pdf   castan_regelung_475_extern_control_v201.pdf (Größe: 96.2 KB / Downloads: 2)
.pdf   Steuerung_ Geschwindigkeitstaster_mit_Funktionen.pdf (Größe: 75.83 KB / Downloads: 1)
Zitieren


Gehe zu:


Benutzer, die gerade dieses Thema anschauen: 1 Gast/Gäste