Tandberg 10X(D) Umbau Capstanmotor von Original zu Fälschung ...
#1
Die Vorgeschichte zu diesem Thread ist in nachfolgendem Thread zufinden:

10X(D) Capstanmotor

Hier denn jetzt der "Umbau" des Capstanmotors von Original zu Fälschung .....

Da in dem "Vorgeschichten-Thread" die benötigten Daten "lose" aufgeführt sind, zuerstmal die "Basics" nochmals auf einen Blick:

Die Servicemanuals zur 10X(D) schweigen sich hinsichtlich Motordrehzahlen, Tachofrequenzen aus - also nix zu finden .....

Hier hilft nur Rechnen anhand der vorgegebenen Abmessungen Capstanwelle, Schwungscheibendurchmesser, Durchmesser Motorpulley ....

Capstanwellendurchmesser: 5 mm
Capstanschwungscheibendurchmesser: 95 mm
Durchmesser Motorpulley: 34,5 mm

Berechnungsgrundlage ist 19 cm/s !

Umfang der Capstanwelle: 15,7 mm
d.h. für 19 cm/s werden 12,1 Capstanumdrehungen/Sekunde gebraucht
dies entspricht 726 Capstanumdrehungen/Minute

für 9,5 cm/s dann 363 Capstanumdrehungen/Minute
für 38 cm/s dann 1452 Capstanumdrehungen/Minute

Die Motordrehzahlen dann wie folgt:
Durchmessercapstanschwungscheibe / Durchmesser Motorpulley ergibt 2,75

folglich für 19 cm/s dann 726 * 2,75 = 1996,5 Motorumdrehungen/Minute

für 9,5 cm/s dann 998,25 Motorumdrehungen/Minute
für 38 cm/s dann 3993 Motorumdrehungen/Minute

Die Lichtschrankenimpulse pro Sekunde:
Zahnkranz 54 Zacken

daraus ergibt sich 54 * 12,1 = 653,4 Impulse/Sekunde bei 19 cm/s

für 9,5 cm/s dann 326,7 Impulse/Sekunde
für 19 cm/s dann 1306,8 Impulse/Sekunde

Das sind die rechnerischen Werte ! Die Nachkommastellen werden ignoriert !

Damit sind die Anforderungen an den DC-Motor zur Hälfte (Drehzahlbereich) definiert. Ferner stehen die Soll-Werte der Capstan- / Motorumdrehungen fest !!

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

Schaltungstechnisch wird der originale Capstanmotor aus einer gesonderten Netztrafowicklung mit 20 Volt AC versorgt. Diese AC-Spannung wird gleichgerichtet, so das nach Gleichrichtung ca. 28 Volt DC im Leerlauf vorliegen. Unter Last dann ca. 24 Volt DC.

Damit steht ein weiterer Motorparameter fest: 24 Volt DC Motor, Drehzahl max. 6000 Umdrehungen/Minute (Sicherheit einkalkulieren, nicht auf Kante bauen ...)
Weitere Parameter sind Stromaufnahme, Laufruhe und Abmessungen.

Gewählt wurde ein Motor mit 24 Volt DC, max. 7000 U/min, Stromaufnahme max. 2 A (Die braucht er nicht real !!! Im Betrieb ca. 500 Milliampere, passt zum Netztrafo) .
Aber Wellendurchmesser 8 mm !! Also kein Original-Motorpulley verwendbar .....Was sich noch rächen sollte ........

Schaltungstechnisch hat Tandberg auf der Motorregelung für den Capstanmotor hier noch ein Feature eingebaut: Eine Pitchfunktion !!

   

Diese muss zwar "extern" realisiert werden, aber schön wäre es ja wenn das beim Umbau nicht verloren geht .....

Wie realisiert sich jetzt hieraus eine neue Drehzahlregelung für den Capstanmotor ??

Mittels µComputer ala Arduino und Co ! Entsprechende Beispiele für passige "Regelsoftware" in Form eines PID-Reglers gibt es ja (wenn MANN sie versteht) ...

Insofern stand das grobe Konzept zur Realisierung des Umbaues fest:

DC-Motor 24 Volt, Spannungsversorgung aus der 20 Volt AC Wicklung, PWM-Ansteuerung Motor, Regelsoftware mittels PID-Regler auf Plattform Arduino, Beibehaltung des original Geschwindigkeitsschalters, externe Pitchfunktion .....

Problem Nummer EINS:
Im Standard erzeugt ein Arduino ein PWM-Signal mit 490 Hz. Was zu Motorpfeifen führen kann ..... also muss die PWM-Frequenz höher sein und somit nicht hörbar.
Diese Frequenz lässt sich zwar ändern, mit dem "unschönen" Nachteil, dass hier direkt ins Register des µComputers geschrieben wird ...... Nö, lass mal sein ..... 
DAS muss eleganter gehen .....
ESP32 und MINI D1 ESP32 haben eine höhere Taktfrequenz und somit können sie "hoch-frequente" PWM-Signale erzeugen OHNE Registerprogrammierung !! Einfach per Software.

Also fiel die Wahl des µComputers auf einen MINI D1 ESP32. Die PWM-Frequenz beträgt jetzt 22 Kilohertz !! Ohne Registerprogrammierung ! Weiterer Vorteil: Der Regelbereich des PWM-Signals wird "feinfühliger", da der zulässige Wertebereich des PWM-Signals erweitert wird.

Problem Nummer EINS gelöst ! Und auch genug Computer-Chinesisch ....

Problem Nummer ZWEI:
Die Lichtschranke an der Capstanschwungscheibe ! Diese erhält ihre Versorgungsspannung aus dem + 27Volt Netzteil der 10Xe. Bedingt durch die Wahl des ESP32 darf aber der Ausgang der Lichtschranke nicht über 3,3 Volt bei High liegen ...... also hier die Lichtschranke getauscht durch ein Exemplar das am ESP32 betrieben werden darf.

Problem Nummer ZWEI gelöst !

Der steinige Weg der Umsetzung:

Im ersten Ansatz den "neuen" Capstanmotor mit einem umschaltbaren PWM-Generator betrieben (also OHNE Regelung, aber PWM-Frequenz 22 khz) um zusehen, ob sich das a) so realisieren lässt und b) weitere Parameter wie Stromaufnahme etc. passen.

Zu a:
Es lässt sich so realisieren ! Der DC-Motor passt in die 10X, Laufruhe ist gegeben, Stromaufnahme überfordert den Netztrafo nicht, PWM-Pfeifen nicht hörbar (dank 22 khz).

Zu b:
Als Problem stellte sich das Motorpulley dar. Unterschiedliche Motorpulley erzeugten entweder ein unruhiges Laufbild oder der Riemen zog sich vom Pulley. Letztlich wurde das Original-Motorpulley an den neuen Achsdurchmesser des DC-Motors angepasst. Jetzt läuft es so wie soll !

An dieser Stelle nochmals ein dickes Dankeschön an Bernd (aka capstan) für die "Aufarbeitung" bzw. Neukonstruktion des Motorpulley!

Also als nächstes die Baustelle Software - Angstgegner bzw. Respekt vor dem Zeug. Zumal C-plusplus hier nicht gerade der "Liebling der Nation" ist ..... eher Fortran95 ....

An dieser Stelle ein Dankeschön an Binse (aka Selbstbauer) für das Überlassen seines Quellcodes für seine Motorensteuerung bei seinen Projekten. Nach Lesen und Verstehen wurde es Licht im Tunnel.

Mittlerweile ist der Software-Prototyp ebenfalls fertig und geht fehlerfrei über den Compiler. Ob er tut wie soll - we will see .....

Also ist jetzt Stand der Dinge:
- µComputer liegt vor
- Lichtschranke ist umgebaut
- Motorpulley wieder original
- Prototyp Software fertig inkl. externe Pitchfunktion
- MOSFET-Treiber Prototyp fertig
- neue Halteplatte für den DC-Motor fertig
- neuer Motor passt ins Gehäuse
- an PWM-Generator (ohne Regelung) funktioniert so wie gedacht

Die nächsten Schritte sind dann alles zusammenbauen und testen ! Zuerst Einzelkomponenten dann im Zusammenspiel.

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

An dieser Stelle nochmals ein ganz, ganz dickes Dankeschön an alle Beteiligten - ohne Hilfe wäre die Maschine ein Ersatzteillager geworden !!

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

to be continued

beste Grüße

Christian
Zitieren
#2
Ja, ich drücke die Daumen!

Gegen das PWM-Pfeifen sollte man das Signal erst mal durch einen Tiefpass schicken. Zwar hat eine "echte" PWM-Ansteuerung einer Last den Vorteil geringerer Verluste, aber die erzeugte beträchtlichen Hf-Leistung willst du in keinem Hifi-Gerät haben. Auch wenn sie leicht über dem Hörbereich liegt. Und ein passendes LC-Filter zu dimensionieren und zu bauen der das wirklich so gut wegfiltert wie ein simpler Tiefpass, das ist nicht trivial. Während ein aktiver 12 dB-Tiefpass auf vielleicht 50 Hz wirklich alles wegputzt und gegenüber der Motorträgheit nur eine ganz unbedeutende Regelverzögerung bedeutet. Übrigens: Performt dein µP wirklich standardmäßig auf 22 kHz bei PWM-Ausgabe mittels "analogwrite"? Hast du das geprüft? (Selbst wenn er nur 500 Hz macht: mit einem aktiven Filter dahinter gehts auch)

MfG
Binse
Zitieren
#3
Nur mal so nebenbei...

es heißt "Thread" und nicht "Threat"

https://de.wikipedia.org/wiki/Thread_(Internet)
Zitieren
#4
Bei 22Khz aus dem Controller hab ich Bauchschmerzen. 
Ich würde die PWM extern erzeugen und aus dem Prozessor nur die Regelspannung zuführen.
Ist wesentlich einfacher zu realisieren. 

Aber wenn du das so zuverlässig hin bekommst, warum nicht.

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

heute mal ein bischen Zeit gehabt (neben anderen Baustellen) und mal mit der Umsetzung angefangen. Sprich Motor montiert und an den externen PWM-Generator angeschlossen.

       

Ergebnis:

Das von Bernd angefertigte Motorpulley läuft super, Motor dreht, Drehzahl lässt sich über den Generator regeln, Riemen läuft ruhig und sauber (JUHU !!!)

Stromaufnahme im Leerlauf (ohne anliegende Andruckrolle) ca. 270 mA, mit anliegender Andruckrolle ca. 380 mA. Passt !!

ABER:
Wird die Geschwindigkeit abruppt umgeschaltet zieht es den Riemen runter ! Ursache ist die PWM. Das Regelverhalten der PWM ist zu schnell für die mechanische Trägheit des Konstruktes (zumindest am externen PWM-Generator). Sprich der Motor geht sofort auf die geänderte Drehzahl und die Capstanschwungscheibe kommt nicht nach ......

Das Problem wird als "Hausaufgabe" für die Software mitgenommen ..... Im Prinzip läuft das ggfs. auf ein "Fading" hinaus ... DAS wäre jetzt nicht das Problem ....

Parallel dazu die "Hausaufgabe" sich in die PWM-Dokumentation und deren Programmierung des ESP32 einzulesen. Weil statt dem klassischen analogWrite() hier statdessen ledcWrite() verwendet wird.

Nächster Schritt ist dann, die Lichtschranke zumontieren. Dann die Maschine sprich Motor auf 19 cm/s einstellen und die Funktion Lichtschranke testen, sprich einmal die Impulse für 19 cm/s auslesen/ermitteln und mit dem gerechneten Werten vergleichen ......

Berechnungsgrundlage ist und bleibt 19 cm/s !

Und dann geht es weiter ..... Alles schön schrittweise .....

Zumindest gehts schon mal so wie gedacht ! Und von diesem nachgefertigten Motorpulley bin ich immer noch begeistert .....

to be continued

beste Grüße

Christian

@BINSE

PWM beim ESP32 auf 22 khz stellen:
const uint32_t PWM_FREQ = 22000; // 22 Khz
const uint8_t PWM_RES = 10; // 10-Bit Auflösung Wertebereich 0-1023

PWM-Pin konfigurieren z.B. PWMPIN
ledcAttach(PWMPIN, PWM_FREQ, PWM_RES);

PWM-Signal auf Pin schreiben
ledcWrite(PWMPIN, 777);

Ich mess das aber nach .... sobald der ESP32 mit dran ist .....
Zitieren
#6
Moin,

das ist doch ein Gleichstrommotor, da könntest du doch ganz einfach durch einen Kurzschluss/kleinen Widerstand eine Bremse einbauen.

Gruß, Piet
Gruß
Piet
Zitieren
#7
Hi Christian,
Welche Lib einbinden für ledcAttach und ledcWrite? Welcher Pin ist als PWMPIN definiert?
MfG,
Binse
Zitieren
#8
Hallo,

die Idee mit dem Widerstand - mal abwarten wie sich das Ganze am PID-Regler verhält. Momentan ist ein PWM-"Generator" dran der feste, schaltbare Duty-Cycle hat .....

ledcWrite und Co. sind eine API (also kein extra include etc. erforderlich) und in der Arduino IDE enthalten. PWMPIN steht als Variable für einen PWM-fähigen PIN am ESP32 ..... Ich nutze hier Pin 25 .

beste Grüße

Christian
Zitieren
#9
So,

die Thematik Lichtschranke bzw. Tachosensor ließ mir keine Ruhe, weil damit steht oder fällt es ...  Also mal mutig dabei ...

   

Mit ein bischen Geschiebe (Anpassen Lichtschrankenhalter) und Schreiben eines "Programmes" für den Arduino ist die Geschichte "vom Tisch". Die Impulse der Lichtschranke werden ausgelesen, stehen somit zur weiteren Verarbeitung mittels µComputer zur Verfügung. D.h. der Tachosensor tut schon mal ......

Ist zwar noch ein bischen "Fine-Tuning" notwendig, aber es tut schon mal ...

Nächster Schritt ist dann, ein Referenzband 19 cm/s mit 1 khz abzuspielen und sich dann die ermittelten Impulse anschauen. Also die zuvor gemachten Berechnungen auf Stichhaltigkeit zu prüfen....

Ach so, der so geschaffene Quellcode für den Arduino wird dann auf den ESP32 portiert ..... Deshalb nicht wundern, wenn hier der Arduino anstelle des ESP32 genutzt wird.

Für das Problem der abruppten Lastwechsel zeichnet sich auch eine Software-Lösung, wenn erforderlich, ab:

Die Ledc-API beinhaltet die Anweisung ledcFade. Mittels dieser Anweisung besteht die Möglichkeit, die Duty-Cycle von einem Startwert hin zu einem Endwert innerhalb eines gesetzten Zeitintervalles ansteigen bzw. absteigen zulassen. Also, alles nur Software .......

beste Grüße

Christian
Zitieren
#10
Respekt, Christian.
Einfach nur toll, wie du die Probleme angehst.
Ich drücke dir die Daumen, dass weiterhin alles klappt und du den neuen Capstanmotor perfekt integriert bekommst.

Diverse 10X Besitzer werden es dir (hoffentlich) danken.

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


Zitieren
#11
Das wird schon was.
Er geht ein Problem nach dem anderen an.
Auf das fertige Ergebnis freue ich mich schon für ihn.

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

das "wildeste" sollte erledigt sein:

Die Lichtschranke oder auch der Tachosensor !

Im ersten Atemzug wurde eine Lichtschranke aus dem "Arduino-Zubehör" verwendet, die einen Abstand zwischen den Zinken von 10 mm hat. Das funktioniert zwar, erzeugt aber Impulszahlen die zu sehr streuen. Also keine näherungsweisen konstanten Werte .... Das war verbesserungswürdig. Zumal diese Lichtschranke mechanisch nicht so ohne weiteres in die Maschine geht. Das läuft auf einen neu anzufertigen Halter hinaus ...

Die Wahl fiel dann auf eine Lichtschranke CNY 37 bzw. TCST 2103. Hier beträgt der Abstand 3,1 mm und hat den Vorteil, das sie mechanisch in den original Halter geht. Ok, einmal kurz die Schlüsselfeile und passt .... Ist ein vertretbarer Aufwand !

Wobei, das müsste auch mit der originalen Lichtschranke gehen .... Mal schauen ...

Verschaltung dann relativ simpel: 180 Ohm Vorwiderstand für die LED, Lastwiderstand zwischen Kollektor und + Ub 2,2 KOhm, Signalabgriff für den µComputer dann am Kollektor und siehe da der µComputer zählt die Impulse. Das schöne: Läuft mit 5 Volt UND 3,3 Volt - also Thema ESP auch erledigt. Baustellenanzahl minus eins.

Und schon passen die Impulszahlen, wenn auch mit geringen Abweichungen pro Umlauf, aber das ist jetzt tolerabel.

So, dann grob 650 Impulse eingestellt und dann Band mit 19 cm/s und 1 Khz abgespielt und hierrüber die Impulsanzahl eingestellt ...... So dass am Ausgang (LINE-OUT) 1 khz vorhanden sind .....

Also die zuvor gemachten Berechnungen gegenprüfen:

Ergebnis: Für 19 cm/s braucht es 653 Impulse - und die werden geliefert, gezählt und können somit weiterverarbeitet werden ! Also stimmt die Berechnung !

Bei der Gelegenheit dann noch den "Impulsbereich" des Motors abgeprüft, sprich ob er im benötigten Impulsbereich auch zuverlässig dreht. Impulsbereich von 200 - 1600 Impulse dreht er einwandfrei. Somit ist 9,5 und 38 sauber abgedeckt ! 

Ist die Andruckrolle angezogen, so erhöht sich die Stromaufnahme bei 19 cm um ca. 40 mA. Also grob 200 mA Stromaufnahme Motor unter Last .... Alles im grünen Bereich.
Wichtig war, dass der Motor das dreht - und das tut er ....

Die Maschine stört sich auch nicht an dem neuen Motor. Logik läuft wie gewohnt (Vor- / Rückspulen, Play, Stop alles ok). Im Grunde hat die Maschine den Motortausch nicht mitgekriegt.

Die nächsten Schritte sind dann MOSFET-Leistungstreiber, dann die Pitch-Funktion und dann die große Baustelle Software .....

beste Grüße
Christian
Zitieren
#13
Hallo Christian,

ich bin begeistert wie du die Problematik angegangen bist und bisher erfolgreich durchgezogen hast.

Hut ab, Bernd
Zitieren
#14
tolle Arbeit!!

bei mir steht auch eine 10X mit kaputtem Motor
Gruß Ulf

TF-Berlin
Zitieren
#15
Erst mal Danke für die Blumen - aber fertig ist noch nicht .....

Aber bis hierhin schon mal ein Lichtschimmer am Horizont .....

So, dann heute nachmittag mal die "Nebenschauplätze" abgearbeitet. Auf PWM-Leistungstreiber fehlte heute mal die Motivation ....

Die "Nebenschauplätze" :

- Schalterverschaltung
- Pitch-Funktion
- Software dazu

   

Der "Versuchsaufbau" mit
- Lichtschranke (Tachosensor)
- Speed-Schalter
- Schalter für Pitchfunktion
- Poti für Pitchfunktion
- und "HOCHWICHTIG" : 6 Widerstände zur Pegelanpassung bzw. Lichtschrankenbeschaltung ....
- alles am Arduino verklemmt und Software geschrieben .....

Ergebnis: ES LÄUFT !! Fehlt jetzt nur noch PWM-Leistungstreiber und der Softwareanteil PID-Regler .

Zur Pitchfunktion:
Diese ist schaltbar ausgelegt und der Stellbereich des Potis liefert saubere Werte, die nach Umrechnung auf den benötigten Bereich stabil bleiben. D.h. selbst bei Vari-Speed greift dann der PID-Regler. Also "freie" Geschwindigkeit einstellbar, die dann mittels des PID-Reglers konstant gehalten wird. Wesentlich anders hat Tandberg das auch nicht umgesetzt .....

Und bei der Gelegenheit festgestellt, das Speed- und Pitchschalter innerhalb der Software nicht entprellt werden müssen (permanentes Abfragen der Schalter ...). Spart Tipperei ......

Für den Pitch-Regler gilt identisches: Dieser wird permanent abgefragt und erst wenn das Poti "stillsteht" wird dieser Wert an den nachfolgenden Softwareanteil (PID-Regler) übergeben.

Nachfolgend das Code-Beispiel für die Pitch-Funktion:

Code:
// Potiwerte einlesen

poti_wert = analogRead(poti_pin);
    Serial.print("Poti_ROH_wert ");
    Serial.println(poti_wert);
// poti mappen
poti_skaliert = map(poti_wert, 0, 1023, 320, 400);
poti_endwert = constrain(poti_skaliert, 320, 400);
    Serial.print("Poti_SKALIERTER_wert ");
    Serial.println(poti_endwert);
// Arduino Wertebereich 0-1023
// ESP32 Wertebereich 0-4095

Bitte beachten: Bei der Pitchfunktion wird mit Umdrehungen/Sekunde gerechnet und nicht mit Impulse Lichtschranke pro Sekunde !!
Die Impulse pro Sekunde sind auf RPM umgerechnet !!!
Also läuft die Pitch im Wertebereich +/- 10 Prozent der Sollumdrehungen !!

So und jetzt noch den Leistungstreiber und die PWM-Klamotte  ----   aber in aller Ruhe ......

beste Grüße

Christian
Zitieren
#16
Sieht gut aus!
Und macht Spaß, das mitzulesen ...

Freundliche Grüße
Binse
Zitieren
#17
Heuer ist dann "Buchführungstag" - sprich das bis hierhin prototypische Entwickelte mal schriftlich zu fixieren. MANN wird ja älter ....

Also mal die "Nebenschauplätze" in Form von Schaltbildern dokumentiert. Wie sagte mein alter Chef immer: "Gute Doku ist das halbe Leben" ....

   

Im Einzelnen:

Die notwendige +5 Volt-Versorgung für den µComputer wird aus den +27 Volt gewonnen, die von der Netzteilplatine A5 zum Motorcontrolboard A13 gehen. Die benötigten + 24 Volt für den Motor werden dann aus den 20 Volt AC des Netztrafos gewonnen. Also wie im Original die Trennung der Spannungsversorgungen Motorregelung und Motorantrieb. Die Entwickler bei Tandberg haben sich da wohl was bei gedacht .....

Steckverbinder P3 geht im Ist vom Speedschalter zum alten Motorcontrolboard A13. Diese Verbindung wird jetzt einfach mit Pulldown-Widerständen versehen und geht dann an die "Schalt-Pin" des µComputers. Bestehende Verkabelung benutzen ist hier die Intention .....

Die Lichtschranke bekommt eine neue vieradrige Verbindung !!! Im Original ist diese dreiadrig. Somit werden alle Anschlüsse der Lichtschranke zur neuen Motorregelung geführt ! Die Vorwiderstände der Lichtschranke sitzen dann direkt mit auf der Motorregelung !

Die Vorwiderstände der Lichtschranke sitzen aus folgendem Grunde mit auf der Motorregelung:
Im "Standard" werden meistens 10 KOhm als "Lastwiderstand" für den Phototransistor genommen. Das funktioniert auch, aber nur wenn die Lichtschranke als "langsamer Schalter" genutzt wird. Die gelieferten Pegel für Ein/Aus liegen dann bei 5 bzw. 0 Volt. Wird dieses Konstrukt jetzt als Tachosensor mittels Zahnkranz betrieben, so liegen die Pegel für Ein/Aus bei 5 / 2,8 Volt. Und jetzt der Gag dabei: Die Schaltschwelle zwischen High/Low liegt beim Arduino wie auch beim ESP32 bei ca. 2 Volt für Umschaltung High/Low ...... Und für Low kommen jetzt 2,8 Volt ... D.h. es wird niemals LOW und somit werden keine Impulse gezählt !! Das war ein Tag suchen .......

Werden jetzt besagte 10 KOhm auf 2,2 KOhm verkleinert, so sinkt der Spannungswert für "Aus" an der Lichtschranke und es wird auch ein LOW erzeugt und Impulse gezählt !!
Auf den Bolzen komm mal einer ..... Nur zum Wahnsinnig werden ..... Oder anders formuliert: Alles hängt von einem Widerstand ab .......

Die Pitchanschlüsse werden zunächst nur auf einen vierpoligen Steckverbinder auf der neuen Motorregelung geführt. Ab hier kann das dann optional nach Außen geführt werden. Also wie im Original. Hier wird sich die "Eigenart" des µComputers zu Nutze gemacht, das Schaltereingänge des µComputers bei keinem Signal anliegend auf  "LOW" liegen .... Zur Sicherheit wird aber in der Software genau dieser PIN per default auf  "LOW" initialisiert. D.h. erst wenn dieser PIN über die externe Pitch - hier Schalter "Pitch EIN" - auf  "HIGH" geschaltet wird funktioniert die Pitch auch. Und erst dann werden die Spannungswerte des Poti gelesen ..... Aber das ist Software .....

Kurzes Wort noch zu den Pulldown-Widerständen (10 KOhm):
Dadaurch wird erreicht, das bei nicht geschalteten Zustand der Schalter der Pegel am entsprechenden PIN des µComputers verlässlich auf "LOW" liegt. Wird der Schalter geschaltet, so geht der Pegel auf "HIGH" und der Schalter ist aktiv. Und - Nebeneffekt - so werden stabile Schaltzustände gewährleistet und innerhalb der Software brauchts kein Beachten, ob die internen Pulldown/Up-Widerstände aktiviert werden müssen oder nicht. Und es muss sich nicht in der Software mit "invertierender Logik" rumgeärgert werden. Schalter Ein = HIGH und bei Invertierung der Logik wäre dann Schalter Ein = LOW ......

Zielvorstellung ist dann, das alles auf einer Platine samt µComputer und Leistungstreiber zusammenzufassen und letztlich nur noch "Strippen" verdrahten .....

So, jetzt mal schauen wo das Schaltbild vom Leistungstreiber sich hin verzogen hat und dann mal den an das Bestehende "dran-tüdeln" .....

beste Grüße

Christian
Zitieren
#18
Und damit das Wochenende zufrieden abgeschlossen werden kann:

   

Die MOSFET-Leistungsstufe tut auch ......

--------------------------------- Streichen Anfang -----------------
Allerdings mit einem "klitzekleinem" Haken, der lediglich in der Software berücksichtigt werden muss:

Statt wie üblich:

 --- pwmpin, pwmwert sind Variablen ---

analogWrite(pwmpin, pwmwert);  muss der pwmwert wie folgt kodiert werden (nur wenn Invertierung Dutycycle erforderlich):

//KORREKTUR analogWrite(pwmpin, (255-pwmwert));  , falls das Signal mal invertiert werden muss !! //KORREKTUR !!

Aber damit kann man leben !! Alternativ H-Brücke mit L298 .... mal schauen .....

---------------------------- Streichen ENDE ---------------------------

Also, dann in Ruhe mal alles zusammenstecken, austesten und dann Platine bauen .....

Es wird !!

beste Grüße

Christian
Zitieren
#19
Mal eben fix bisserl Zeit gehabt und mal den L298N als Leistungstreiber an den Motor gehängt und das Verhalten zum anderen Leistungstreiber verglichen .....

Fazit:

Der L298 braucht noch zwei zusätzliche Steuerleitungen ( liegt in der Natur der Dinge da eine H-Brücke mit implementiert ist) und kann maximal 2 Ampere verkraften .....

Der andere Leistungstreiber ist ein reiner Leistungstreiber OHNE H-Brücke. Also zwei Kabel und somit 2 Pin am µComputer weniger ..... Und der kann maximal 10 Ampere ab (bei entsprechender Kühlung)  ....

Die Software zeigt keinen Unterschied zwischen den beiden Leistungstreibern auf - und: Das PWM-Signal muss NICHT invertiert werden !! Weiß einer, was das gestern war ....

D.h. es wird der Leistungstreiber von gestern genommen ! Der L298 ist mir persönlich zu dicht "auf Kante", zumal es durchaus nicht abwegig ist, dass der Motor mal richtig Strom zieht und sich der L298 dann in die "ewigen Jagdgründe" verabschiedet .....

Also jetzt das ganze zusammenbauen und testen !!

Die Schaltung des anderen Leistungstreibers ist im beigefügten Anhang Kapitel 5.2 beschrieben. Entsprechende Modifikationen für 24 Volt sind gemacht !! Und er geht auch am ESP32 !! 

beste Grüße

Christian


Angehängte Dateien
.pdf   arduino_driving_power_mosfet.pdf (Größe: 936.96 KB / Downloads: 23)
Zitieren
#20
Weil es einem ja doch keine Ruhe lässt .......

Das Ganze mal zusammengesteckt als "wilder Drahtverhau", also µComputer, Tachosensor (Lichtschranke), Schalter, Pitch-Poti und Leistungstreiber. Also die komplette Hardware !!

   

Die Bildqualität bitte ich jetzt mal zu entschuldigen .....

and here are the results .... :

- Impulse werden gelesen
- Schalter tun so wie sollen
- Pitch-Poti tut so wie soll
- Motor reagiert auf das PWM-Signal

Oder anders formuliert: 

 ****************** DER DRAHTVERHAU TUT WIE GEDACHT !!! *****************

So, bevor die Euphorie überschwappt:

- abruppter Lastwechsel von z.b. 9,5 auf 19 führt zu "Antriebsriemenverlust", sprich er springt ab.

Sprich HIER MUSS die Trägheit der originalen Motorregelung nachgebaut werden.
DAS ist aber ein Softwareproblem und muss dort entsprechend gelöst bzw. beachtet werden !! Lösung haben wir ja ....(ledcfade, bzw. while-Schleife).

D.h. jetzt:
- Werkbank aufräumen
- Platine für die Hardware machen
- dann Platine einbauen und verkabeln
- Software schreiben und dabei viel testen .....

Im Grundsatz funktioniert es so wie gedacht (endlich mal ein Plan der aufgeht ...) , ab jetzt ist alles nur noch Software .....

beste Grüße

Christian
Zitieren
#21
Ein abschließender Test fehlte noch, damit das Software-Schreiben etwas fixer geht:

Die Zuordnung von Impulse/Sekunde zu benötigtem PWM-Wert (sprich DutyCycle):

   

Also kurzerhand die Impulszählroutine genommen und am Ende der Routine den PWM-Wert schrittweise um 5 erhöht, so dass die Impulse/Sekunde dem annäherenden PWM-Wert zugeordnet werden können. Beginnend bei 0 ..... also Motorstillstand ....

Basis ist der Arduino, Wertebereich dann 0 - 255;  für den ESP32 dann diesen Wert grob mal 4 nehmen (Wertebereich 0-1023).

Nebeneffekt: Der Motor dreht verlässlich über den benötigten Impulsbereich von ca. 200 - 1800 Impulse/Sekunde ....

Somit ist die "Hardware" komplett erledigt !!

beste Grüße

Christian
Zitieren
#22
So, dann heute mal "Malen nach Bauteilen" gemacht und die Platine entworfen.

   

Platinenabmessungen: 157 x 80 mm ist somit kleiner als das Original-Board A13 und dürfte dann mit einem Alu-Montage-Blech in die 10X passen (Befestigungspunkte dann die beiden 4 mm Löcher vom Kühlkörper des Board A13).

Die Sensorik (Tacho/Poti Vari-Speed) und Schalter können wahlweise mit 3,2 oder 5 Volt versorgt werden. Die 5 Volt-Versorgung wird aus den 27 Volt gewonnen und die Eingangspannung für den ua7805 dann mittels 5 Dioden 1N4xxx in Durchlassrichtung auf ca. 24 Volt gelegt (alternativ Vorwiderstand). Die 3,2 Volt werden mittels 3 Dioden in Durchlassrichtung aus den 5 Volt gewonnen (war einfacher als Vorwiderstand). Somit ist der maximale Eingangspegel ESP32 von 3,3 Volt sichergestellt ....

LED der Lichtschranke läuft auf 5 Volt, Phototransitor Betrieb mit 5 oder 3,2 Volt möglich. Alternativ kann der Phototransistor fest mit 5 Volt betrieben werden und im Nachgang dann ein Spannungsteiler 10K/20K um auf 3,3 Volt zukommen .....

Spannunsversorgung ESP32 mittels USB-C Kabel aus den + 5Volt .....

24 Volt Netzteil ist mit drauf, ebenso der MOSFET-Leistungstreiber ....

Messpunkte in die entsprechenden Leitungen zum ESP gelegt ....

Beim ESP32 sind nur die Pin beschaltet und "bestückt" die gebraucht werden:
Pin 18 Tachosensor
Pin 19 Schalter Pitch
Pin 25 PWM-Ausgang
Pin 32 Poti Pitch (analoger Eingang)
Pin 33 Schalter 9,5
Pin 34 Schalter 19
Pin 35 Schalter 38
sowie die beiden GND-Pin ....

Dann jetzt mal Platine belichten / ätzen / bohren / bestücken / einbauen / verdrahten .... und dann durchmessen ....

beste Grüße

Christian
Zitieren
#23
Trotz der Hitze mal die Platine gebaut:

   

Alles drauf:

- 5 Volt Versorgung mit Aufbereitung für 3,3 Volt
- 24 Volt Versorgung für Motor
- Spannungsteiler 5 Volt auf 3,3 Volt für Tachosensor (Lichtschranke wird auf 5 Volt belassen und Signal dann über Spannungsteiler abgegriffen)
- Pull-Down Widerstände Schalter
- Pitch Abzweig
- MOSFET-Leistungsstufe
- ESP32
- Messpunkte

Dann jetzt durchmessen und einbauen / testen ......

Und noch ein bischen "Schirmung" um den ESP32 / Leistungsstufe bauen (aus einseitigen Platinenmaterial das auf Masse verbunden wird - irgendwie erscheint das sinnvoll)

Also nur noch Software ...... So der Plan .....

Die Platine ist KLEINER als die ursprüngliche Motorregelung - sollte also problemlos in die Maschine gehen ....

beste Grüße

Christian
Zitieren
#24
Da kannst du ja eigentlich sofort eine kleine Serie auflegen, Christian ?
Sehr, sehr geil ist das !

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


Zitieren
#25
Ich finde es sensationell und beispielhaft wie Christian, im Gegensatz zu anderen großen Ankündigungen hier im Forum, dieses Projekt angegangen und bisher erfolgreich durchgezogen hat.
Dies ist auch eines der wenigen komplexeren Projekte, welches von Ankündigung bis Ende erfolgreich zum Abschluss gebracht wurde, ich liebe es.

Dazu gehört schon ein gehörig Maß an Ausdauer und Willenskraft und vor allem fundiertem Fachwissen und Umsetzungsvermögen, um trotz Widrigkeiten nicht aufzugeben.
Ich bin vom erfolgreichen Abschluss des Projektes überzeugt und wünsche Christian weiterhin viel Glück, Kraft und alles Gute.

Bernd
Zitieren
#26
Hallo Jungs, 

Bernds Laudatio kann ich mich nur voll und ganz anschließen! Was Christian hier abliefert, 

ist GANZ GROSSES TONBAND-KINO!  thumbsup
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
#27
Hallo,

ich danke ganz herzlich für die Blumen, aber noch ist ja nicht fertig ......

Es zeigte sich mal wieder der Unterschied zwischen Theorie und Praxis:

Das "Platinchen" zunächst an die + 27 Volt gehängt und die benötigten Spannungen geprüft:

5 Volt-Zweig mit 4,95 Volt im Leerlauf ok - passt !
3,3 Volt-Zweig mit 4,2 Volt im Leerlauf - das passt nicht, obwohl drei Dioden in Durchlassrichtung davor ...... Was soll das jetzt ???

Leerlauf heißt, es fließt kein Strom durch die Dioden ..... Und somit stimmt der Spannungsabfall an den Dioden nicht .....
Was nun ?? Kurzerhand diese Diodenstrecken mit einem Widerstand belastet und siehe da - mit 3,3 KOhm als "Lastwiderling" stellen sich wundersamer Weise 3,25 Volt im Leerlauf ein ...
Was einem Srom von ca . 1 Milliampere durch die Diodenstrecke entspricht. Aber die Nummer mit belasteten/unbelasteten Spannungsquellen ist ja immer wieder spannend .....

Daraus resultiert jetzt folgendes:

Diese Platine wird jetzt eingebaut und die Funktionen/Zusammenspiel/Software getestet - allerdings OHNE Pitch-Funktion zunächst ....

Dann geht es nochmal an's "Platinenmachen" und die 3,3 Volt-Erzeugung wird mit einem Spannungsregler 3,3 Volt gemacht. Insbesondere vor dem Hintergrund, das in der externen Pitch noch eine "Betriebsanzeigen-LED" drin ist, die nen Milliamperchen brauch - und nicht das genau dann - wenn die Pitch geschaltet ist - die 3,3 Volt absacken ..... (weil höherer Strom durch die Diodenstrecke, damit geänderter Innenwiderstand).

Sozusagen "Final Platinen Release" dann ....

Und für das reine Austesten der Software wird die Pitch nicht benötigt !

So langsam zeichnet sich eine wieder funktionierende 10X ab ......

beste Grüße

Christian
Zitieren
#28
Weiterhin interessant und spannend!
Viel Erfolg,
Binse
Zitieren
#29
Heuer war dann mal "Metall-Tag" :

Als erstes war die externe Pitch dran - die wird zwar momentan nicht benötigt, aber fertig ist fertig

       

Die Pitch ist ein Alu-Gehäuse in den Abmessungen 162 x 102 x 56 mm gewandert, damit die "hochkomplexe und technisch anspruchsvolle" Schaltung da auch rein passt ....

Als nächstes dann Alu-Winkel in den Abmessungen 160 x 80 mm mit 20 mm Biegekante getüftelt. Dann Anpassung für den angedachten Platz gemacht ( Biegekante in Teilen wieder mechanisch entfernt und einen Auschnitt gemacht, damit der Winkel nicht mit der Chassisstrebe kollidiert ........

Dann die "Passprobe" mit montierter Platine und schon mal die Leitungen der Spannungszuführungen ( + 27 Volt, 20 Volt AC ) gesteckt. Das passt schon mal ......

   

Passt rein - mit Luft !!!

       

Und gleich die ToDo-Liste aktualisiert für das "Final Platinen Release":

Platine kann kleiner, Schraubverbinder für Motor um 90 Grad drehen, Siebelko 2200µF nicht mehr axial sondern radial (kommt mit der Höhe hin ...).
Halteblech "vernünftig" machen (Muster ist jetzt ja da ...)

Next Step:

Platine samt Halter noch mal raus, Tachosensor und Steckverbinder P3 anschließen, dann testen ....

Langsam sieht Mann wie es werden soll ..........

beste Grüße

Christian
Zitieren
#30
So, fast der "finale" Schritt ......

   

Tachosensor und Speedschalter (über Steckverbinder P3 - "Altkabel" ) sind montiert und verkabelt. Anschluß eben fix über Adapter gemacht.
USB C Kabel mit dem Rechner verbunden und der µComputer läuft auch schon mal .....

Somit kann der "finale" Schritt starten: Software !! Mal sehen was das gibt .....

Bevor ich mich da jetzt intensiv mit auseinandersetze folgendes:

Der "Drahtverhau" sprich die ganze Testerei erfolgte auf Basis Arduino. Ziel ist aber die Nutzung des MINI D1 ESP32. Das bedeutet jetzt folgendes:

Die "Hardware" - also die Platine unterstützt die drei µComputer Arduino, MINI D1 ESP8266 und MINI D1 ESP32. Deswegen ist da auch dieser "Klimmzug" mit den 3,3 Volt implementiert worden. Weil, um das zu ermöglichen, muss folgendes beachtet werden: 
Arduino Eingangspegel an den Pin max. 5 Volt
MINI D1 ESP8266 und MINI D1 ESP32 Eingangspegel an den Pin max. 3.3 Volt

Für alle 3 µComputer sind die Pulldown- / Pullup Widerstände mit je 10 KOhm identisch und fest verbaut. Somit verbleibt nur die Umschaltung (je nach verwendeten µComputer) von 5 auf 3,3 Volt für die Eingangs-/Steuer - Pin. Und das erledigt eine simple Drahtbrücke entweder zu 5 oder 3,3 Volt UND Anpassung des Vorwiderstandes der LED (Betriebsanzeige) in der Pitch.

Der Tachosensor (Lichtschranke) wird fest mit 5 Volt betrieben und je nach µComputer geht das Tachosignal über einen Spannungsteiler (um auf besagte 3,3 Volt zukommen). Dieser Spannungsteiler ist beim Einsatz Arduino überflüssig und er wird dann nicht bestückt bzw. ein Widerstand (10 kOhm) wird gebrückt.

Für die Softwareseite bedeutet das jetzt folgendes:

Arduino benutzt die ganzzahligen Wertebereiche von 0 - 255 für das PWM-Signal und das Spannungssignal der Pitch (diese µComputer sind so frei das sie ein analoges Signal in ein digitales wandeln ... Spart Rechnerei ..)
ESP32 nutzt hierfür 2 unterschiedliche ganzzahlige Wertebereiche, einmal 0-1023 für das PWM-Signal (PWM-Signal 22khz und 10 Bit Auflösung) und 0-4095 für das Pitchsignal.

Aus diesem Grunde (Wertebereiche) erfolgte auch der abschließende "Test" beim Arduino Zuordnung Impulszahl Tachosensor zu PWM-Wert, damit sich für den ESP32 eine "Hausnummer" ergibt (Arduino-Wert * 4) ......

Daraus resultiert beim Einsatz ESP32 eine wesentlich höhere Auflösung und somit vmtl. bessere Regelmöglichkeit ..... We will see .....

Hinsichtlich der Codierung gibt es da noch Unterschiede:
Bei Arduino und MINI D1 ESP8266 wird analogWrite() zur Steuerung des PWM-Pin genutzt, beim MINI D1 ESP32 ledcWrite(). Ferner bietet die API ledc die Möglichkeit mittels ledcFade() das PWM-Signal in einem definierten Zeitrahmen von Wert A zu Wert B an- / absteigen zulassen. Damit wird dann die "Trägheit" der original Motorregelung nachempfunden.

Beim Arduino resp. MINI D1 ESP8266 wird das vmtl. nur über While()-Schleifen gehen ... 

Diese beiden Punkte (Wertebereich und Fade-Funktionalität) sind dann im Code zuberücksichtigen !!! Was zur Folge hat, das es zwei Software-Versionen benötigt. Einmal ESP32 und einmal Arduino / MINI D1 ESP8266 ...... Wenn es nicht sogar 3 Versionen sind .....

BEGINN OFF TOPIC

Eigentlich war ich nur "angekäst" ob des defekten Capstanmotors der 10X und es widerstrebte mir zu tiefst die Maschine als Ersatzteilträger zu nutzen. Nur weil es keinen Motor mehr gibt .... Da muss es doch eine Lösung für geben !
Was jetzt vmtl. bei rauskommt ist eine Art "Universallösung" die sich auch auf andere Maschinen / Anwendungsfälle übertragen lässt und nicht auf die 10X/XD festgelegt ist. Nach den bisherigen gemachten Erfahrungen beschränkt sich der Änderungsbedarf lediglich auf Motor, Anpassung der Motor-Leistungsstufe auf evtl. andere Motorspannung und Tachosensor. Der Software ist es egal welchen Motor sie antreiben soll .............. Hauptsache sie treibt an .......

Ende OFF TOPIC

So, dann gehen wir mal Software schreiben ..........

beste Grüße

Christian
Zitieren
#31
Soderle,

kurzer Zwischenstand zur "Software" , nebenbei gibt es noch andere Baustellen, so dass nicht immer Zeit ist ......

Das Problem der "Trägheitsnachbildung" hat sich vmtl. erledigt ......

Die Auswertung der geschalteten Geschwindigkeit erfolgt mittels einer SWITCH-Anweisung (SWITCH CASE) und dann innerhalb des gewählten CASE widerum eine SWITCH-Anweisung die die aktuelle Geschwindigkeit auswertet und anhand dessen die "Fading-Routine" aufruft.

Damit sind auch alle Kombinationen erledigt, z.B. Ist 9,5 cm Soll 38 cm bzw. Ist 19 cm Soll 9,5 cm usw. und so fort .....

Dafür brauchts zwei Variablen:

speed_select = die geschaltete Geschwindigkeit
speed_aktuell = aktuelle Geschwindigkeit

Also absolut kein Hexenwerk .......

Anbei der Auszug aus dem Code ("Zwischen-Entwicklungs-Stand"), der soweit tut ..... (Compiler murrt nicht und Ausgaben entsprechen der Logik ...)
Code:
// Speed-Schalter / Pitch auswerten und Soll-RPM setzen
// dabei speed_aktuell berücksichtigen .....
switch (speed_select)
{
  case 95:
    switch (speed_aktuell)
    {
      case 19:
        Serial.println("Speed war aktuell 19 ");
        // serial.println durch ledcfade ersetzen !
        break;
      case 38:
        Serial.println("Speed war aktuell 38 ");
        // serial.println durch ledcfade ersetzen !
        break;
      default:
      Serial.println("Speed ist aktuell 9,5 ");
        break;  
    }
    speed_aktuell = 95;
    if (pitch_select){
      Poti_Rohwert = analogRead(Poti_Sensor);
      Skalierter_Poti_Wert = map(Poti_Rohwert, 0, 4095, 320, 400);
      Poti_Endwert = constrain(Skalierter_Poti_Wert, 320, 400);
      Soll_RPM = (int)Poti_Endwert;
      Serial.println("Pitch Speed 9,5 ");
    }
    else { Soll_RPM = SollRPM_95;
    Serial.println("Soll Speed 9,5 ");
    }
    break; 
  case 19:
    switch (speed_aktuell)
    {
      case 95:
        Serial.println("Speed war aktuell 9,5 ");
        // serial.println durch ledcfade ersetzen !
        break;
      case 38:
        Serial.println("Speed war aktuell 38 ");
        // serial.println durch ledcfade ersetzen !
        break;
      default:
      Serial.println("Speed ist aktuell 19 ");
        break;  
    }
    speed_aktuell = 19;
    if (pitch_select){
      Poti_Rohwert = analogRead(Poti_Sensor);
      Skalierter_Poti_Wert = map(Poti_Rohwert, 0, 4095, 653, 800);
      Poti_Endwert = constrain(Skalierter_Poti_Wert, 653, 800);
      Soll_RPM = (int)Poti_Endwert;
      Serial.println("Pitch Speed 19 ");
    }
    else { Soll_RPM = SollRPM_19;
    Serial.println("Soll Speed 19 ");
    }
    break;
  case 38:
    switch (speed_aktuell)
    {
      case 95:
        Serial.println("Speed war aktuell 9,5 ");
        // serial.println durch ledcfade ersetzen !
        break;
      case 19:
        Serial.println("Speed war aktuell 19 ");
        // serial.println durch ledcfade ersetzen !
        break;
      default:
      Serial.println("Speed ist aktuell 38 ");
        break;  
    }
    speed_aktuell = 38;
    if (pitch_select){
      Poti_Rohwert = analogRead(Poti_Sensor);
      Skalierter_Poti_Wert = map(Poti_Rohwert, 0, 4095, 1307, 1597);
      Poti_Endwert = constrain(Skalierter_Poti_Wert, 1307, 1597);
      Soll_RPM = (int)Poti_Endwert;
      Serial.println("Pitch Speed 38 ");
    }
    else { Soll_RPM = SollRPM_38;
    Serial.println("Soll Speed 38 ");
    }
    break;
  default:
    break;
}

Innerhalb dieser Routine wird dann auch gleich die Pitch-Funktion mit ausgewertet ...... und die Soll-Geschwindigkeit gesetzt ....

Wie gesagt, damit sollte das Problem der "Trägheitsnachbildung" erledigt sein ....

Nächster Schritt ist dann den Tachosensor einbinden und last but not least die PWM-Klamotte .....

Und alles schön schrittweise testen .... das dauert am längsten .....

beste Grüße

Christian
Zitieren
#32
Gefällt mir was du machst und wie du es machst.
Einzelne Blöcke schreiben und testen, wenn fertig dann zur nächsten Aufgabe. 
Deine Steuerung kannst du dann auch auf andere Maschinen adaptieren.

Gruß Mani
Besonders gerne repariere ich meine Philips, Braun, Akai und TEAC Geräte Big Grin
Keine Hilfe bei fehlender Rückmeldung
Zitieren
#33
...Moin!
...mir gefällt diese "pedantische" arbeitsweise auch sehr, ist schön übersichtlich, und die Möglichkeit einer portierung auf andere Maschinen, mir fallen da die Grundig TS Geräte ein, zeichnet sich ab thumbsup

...da werden sich wohl einige freuen, das die Maschinen eventuell einen zweiten Frühling bekommen.


...mfg, Fränky
...ich sammel Punkte...
...man hat mir schon immer bescheinigt, das ich nen Knall(frosch) hab Big Grin
Zitieren
#34
Diese "pedantische" Heransgehensweise trägt weiter ihre Früchte ......

Der Tachosensor - sprich Lichtschranke - wird ja an +5 Volt betrieben und der benötigte Pegel für den µCompi wird dann über einen Spannungsteiler zur Verfügung gestellt. Das tut ebenfalls wie gedacht ...... Impulse werden vom ESP32 gelesen, in RPM umgerechnet und können ab da weiterverarbeitet werden .....


.png   esp32_schalter_tacho.png (Größe: 13.23 KB / Downloads: 661)

Langsam nimmt es Gestalt und Formen an .....

Dann bleibt jetzt nur noch die PWM-Klamotte zu "implementieren/codieren" .... und einmal Platine neu machen, damit die 3,3 Volt-Versorgung auf ein Stabi-IC umgestellt wird. Die Geschichte mit den 3 x 1N4004 in Durchlassrichtung als "Vorwiderstand" für die 3,3 Volt gefällt nicht. Da kommt jetzt ein Stabi-IC MCP1826S33 rein. Der Vogel kommt mit 4 - 6 Volt Eingangsspannung klar und wird aus dem ua7805 versorgt. Letztlich "versorgen" muss er die Pulldown-Widerstände, die Pitch und ggfs. die erste Transistorstufe des MOSFET-Leistungstreibers (aber nur die Basis-Ansteuerung) .... Also nen Kilo-Ampere Stromaufnahme wird es nicht werden .....

Momentan benötigt die Platine ca. 20 mA Stromaufnahme (wobei das Meiste vom ua7805 und der Lichtschranke gezogen wird). Kommt jetzt die Pitch mit geschätzt 20 mA für die LED und noch nen schlankes Milliampärchen für den ersten Transistor der MOSFET-Leistungsstufe dabei, landet man bei ca. 41 Milliampere Stromaufnahme für die Peripherie total. Also mit 50 mA für die notwendige Peripherie kommt man hin .... Dazu kommt der ESP32 mit ca. 70 mA (ohne WLAN/WIFI-Funktionalität !!!). Macht in Summe ca. 120 mA Stromaufnahme ....
Da der ua7805 mittels 5 x 1N4004 in Durchlassrichtung betrieben ca. 24 Volt am Eingang "sieht" produziert er eine Abwärme von ca. 2,2 Watt (27 - 3 = 24 ; 24 - 5 = 19; 19 * 0,12 = 2,28). Kleiner Kühlkörper reicht dann aus ........

Somit wird das Netzteil der 10X, hier der + 27 Volt Zweig, wohl kaum in die Knie gehen ...... Zumal das Originalboard A13 ja auch eine "gewisse" Stromaufnahme hatte .....

Zumal der Motor selbst und die MOSFET-Leistungsstufe aus den 20 Volt AC separat versorgt werden. Sind also autark zubetrachten !

So, dann jetzt mal ausprobieren ob die Basis des ersten Transistors der MOSFET-Leistungsstufe 3,3 Volt oder 5 Volt haben will ....... (mit 5 Volt tut sie, aber mit 3,3 ???)
Danach weiter mit Software und PWM ...... und Platine überarbeiten nicht vergessen ...... Irgendwas ist ja immer ....

beste Grüße

Christian
Zitieren
#35
Irgendwas ist ja immer ......

Also mal mutig die PWM-Klamotte in der Software aktiviert, MOSFET-Leistungstufe dran, PWM-Ausgang dran, Motor angeklemmt, 24 Volt aus dem Labornetzteil drangehängt und mal geschaut was so passiert:

NIX !!!

außer das ein BC337 Rauchzeichen gab .......... Und NULL Motordrehen .

Also Ursachenforschung angesagt:

Die Klamotte des rauchenden BC337 erstmal wohlwollend ignoriert ......

PWM-Ausgang des µCompi an eine externe, identische Leistungsstufe gehängt ( ist ja vom Probieren noch vorhanden ), Motor und 24 Volt dran. Eingeschaltet und siehe da 24 Volt bleiben 24 Volt und keine Rauchzeichen. PWM-Signal mit ESP-Pegel 3,3 Volt dran - Motor dreht nicht .... 24 Volt vorhanden, Null Stromaufnahme

Mit Scopen PWM-Signal geprüft - jeep, ist da ..... Wird nachvollziehbar an- und abgeschaltet. µCompi/Software also ok.

Bleibt festzuhalten:
Betrieb der Leistungsstufe mit 5 Volt-Pegel läuft (siehe Probeaufbau mit Arduino), mit 3,3 Volt Pegel tut es nicht ..... Also mal wieder die Klamotte mit den Pegeln .....

Der Gedanke ist jetzt:

Bevor die Leistungsstufe jetzt neu konzipiert wird, erstmal mit einem Pegel-Konverter zu experimentieren. Gebraucht wird ein unidirektionaler, nicht invertierender "Level-Shifter" der das PWM-Signal anhebt. Und zwar nur wenn die Leistungsstufe mit den ESP-Prozessoren betrieben wird. Mit Arduino läuft sie ja. Kann vmtl. auch nicht die Welt werden.

Dann gibt es jetzt erstmal eine "interne Beratungspause" .....

Wäre ja auch zu schön gewesen wenn es auf Anhieb läuft ...... Irgendwas ist immer !

beste Grüße

Christian
Zitieren
#36
Beratung abgeschlossen:

   

Tut mit 22 khz und invertiert nicht ! Selbst bei einem Eingangspegel von 2 Volt kommen da 5 Volt Ausgangspegel raus ..... (Wenn mein HM303 nicht lügt ...)

Damit sollte die Leistungsstufe arbeiten können ...

So, dann jetzt Platine neu machen und weiter austesten ......

beste Grüße

Christian
Zitieren
#37
Der 10K im Treiber/Level-Shifter könnte zu hochohmig sein. So ein MOSFET hat ja eine nicht unerhebliche Gatekapazität.

Gruß Ulrich
Zitieren
#38
Ja, der Teufel lauert immer im Detail...
Wenn ich das richtig sehe, kommt ja der hier https://tonbandforum.de/attachment.php?aid=94772 beschriebene Motortreiber zum Einsatz, da wird er Mosfet ja niederohmig angesteuert, die Gatekapazität sollte sich da nicht wesentlich negativ bemerkbar machen, das wäre sonst bereits bei 5 V Ansteuerung aus dem Arduino aufgefallen (die Schaltverluste durch Verflachung der Impulsflanken würden zu starker Erwärmung der Mosfets führen). Wichtig ist, daß die Treiberstufe genug Basisstrom bekommt, um bis in die Sättigung durchzusteuern, das war bei 3.3 V Einspeisung wohl nicht gegeben. Aus ebendiesem Grund würde ich den Collektorwiderstand des 5 V Schalters im Levelshifter allerdings auch kleiner machen, mit 1K sollte da genügend Strom rauskommen, um den Treiber durchzusteuern.

Gruß Holger
Zitieren
#39
Ich danke für die Tip's mit den Widerständen beim Level-Shifter !!!

Die gesamte Leistungsstufe wird eh stückweise bzw. schrittweise beginnend ab ESP-Ausgang aufgebaut und getestet. Der Rest der Mimik läuft ja soweit. Ist "nur" diese dösige Leistungsstufe die am Arduino problemlos läuft. Aber das ist wohl die bekannte Klammotte das Dinge die am Arduino problemlos funktionieren nicht zwingend am ESP laufen .....

Wenn das mit Level-Shifter abgetan ist ist die Welt ja wieder in Ordnung (zumal der Aufwand ja überschaubar ist) ..... und der Rest Software kann fertiggestellt werden.

Das werde ich morgen/übermorgen sehen - neues Platinenlayout ist soeben fertig. Also morgen dann "Platinen-Mach-Tag" .....

Nochmal Danke für die Tip's !

beste Grüße

Christian
Zitieren
#40
Soderle,

"Platinen-Mach-Tag" beendet und bis auf den Level-Shifter und die Leistungsstufe schon mal fertig bestückt (na ja, es fehlt da noch die Bestückung mit aktiven Komponenten ....).
Die Ausgangsspannungen aus den Stabi-IC sind gemessen und passen.

Die neue Platinenversion ist in den Abmessungen identisch zur ersten Version, aber die Komponenten sind insgesamt etwas "komprimierter" verteilt, da es durch den radialen Siebelko Platz gab. Auf jeden Fall passt jetzt der USB-C Stecker für den ESP .....

Ach so, damit es auch keinen Fehler bei der Verkabelung der Steckverbinder gibt, die weißen Steckverbinder sind neu (Pitch / Tachosensor) und die originalen Tandberg-Verbinder sind "Alt-Bestand" ...... mit identischer Belegung gem. Sevicemanual .... 

   

Und dann auch die "Buchführung" aktualisiert:

   

Mehr ist es nicht ! Bitte beachten das der Pulldown-Widerstand für den Pitch-Schalter mit auf der Platine sitzt ! Dadurch wird der Anschluss-Pin des µCompi verlässlich auf "LOW" gelegt, auch wenn die Pitch nicht angeschlossen ist. Sicher ist sicher ! Für die Arduino-Version entfallen der Spannungsteiler Tachosensor, Level-Shifter und die Peripherie (Schalter/Pitch) wird dann auf +5 Volt gebrückt.

Als nächstes dann testen wie sich Level-Shifter und Leistungsstufe jetzt benehmen ......

beste Grüße

Christian
Zitieren
#41
Soderle,

das "Benehmen" der Leistungsstufe:

- schlicht untragbar -

Aber der Reihe nach:

Den Level-Shifter in Betrieb genommen und mit Kollektorwiderständen von 3,3 K (erste Stufe 3,3 auf 3,3) und 1 K (zweite Stufe 3,3 auf 5) versehen. Kurz durchgeprüft - ok. Tut.
Dann den ESP dran und die Leistungsstufe - kein Abrauchen von Bauteilen aber NULL Motordrehen. Also Scopen an und geprüft ob das PWM-Signal anliegt. Eingang Leistungsstufe ist PWM-Signal da, Ausgangsseitig ( Drain MOSFET) NIX .....

Was nun ???

Kurzerhand den Arduino rausgekramt, kleines Prüfprogrämmle geschrieben, Leistungsstufe an den Arduino gehängt und TUT !!!
Prüfprogrämmle für den ESP32 angepasst. ESP an die Leistungsstufe und - NIX - !!!! PWM-Signal liegt an, lässt sich ändern aber NULL PWM-Signal am Drain MOSFET ......

Hier das Prüfprogrämmle:

Code:
const int pwmpin = 25; // ESP32
// const int pwmpin = 9; // Arduimo
int pwmwert = 0;

const uint32_t PWM_FREQ = 22000; // 22 khz
const uint8_t PWM_RES = 10; // 10-Bit Auflösung, Wertebereich 0 - 1023

void setup() {
// pinMode(pwmpin,OUTPUT); // Arduino
ledcAttach(pwmpin, PWM_FREQ, PWM_RES); // ESP32

}

void loop() {
  // put your main code here, to run repeatedly:
pwmwert = pwmwert + 5;
    
//    if(pwmwert == 250){pwmwert=0;} // Arduino

    if(pwmwert == 1020){pwmwert=0;} // ESP32
    ledcWrite(pwmpin,pwmwert); //ESP32
// analogWrite(pwmpin,pwmwert); // Arduino  

  delay(1000);
}

Faxen dicke !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!

Kurzerhand einen IRFZ44N genommen, 2 BC337 dabei, 4 Widerstände und ne Diode, zusammengelötet und getestet ........

   

Wieso dreht der Motor jetzt und vorne hängt ein ESP32 dran ....  PWM-Signal liegt am Eingang an UND am Drain MOSFET ... Motor lässt sich regeln .........

Ist nicht schön aber tut !

Somit wäre bis auf den Softwareanteil die Geschichte Umbau Capstan durch !

Softwareseitig ist nur noch die PWM-Geschichte (hier speziell das Fading) inkl. PID zu codieren. Leistungsstufe nochmal überarbeiten und als MOSFET einen IRLZ44 verwenden. Der schaltet auf Logikpegel 5 Volt und nicht wie der IRFZ erst ab 7 Volt ........ Dann kann der Level-Shifter direkt den IRLZ44 antreiben und es wird das Umsetzten auf 24 Volt-Pegel entfallen.

So der Plan !!!

Grundsätzlich ist der Umbau somit soweit abgeschlossen - bis auf Restarbeiten ......

Die 10X braucht also nicht ins Ersatzteillager !!! Ziel erreicht !!


BEGINN OFF TOPIC

Ich mache dann noch ne Art "Doku" fertig bestehend aus den Teilen Hardware und Software, so das es ggfs. auf andere Maschinen angepasst werden kann ....

ENDE OFF TOPIC


Ich hätte dann mal (fast) fertig !!

beste Grüße

Christian
Zitieren
#42
Na, ist doch wunderbar! (Die 2. Treiberschaltung sieht irgendwie übersichtlicher aus ...) Feine Sache, ich gratuliere!

Freundliche Grüße,
Binse
Zitieren
#43
Kann dein IRLZ 24V am Gate? Glaube ich nicht. 
Ich würde da noch Schutzschaltungen vorsehen.
Ansonsten gute Gesamtleistung.

Gruß Mani
Besonders gerne repariere ich meine Philips, Braun, Akai und TEAC Geräte Big Grin
Keine Hilfe bei fehlender Rückmeldung
Zitieren
#44
Bzgl. der Leistungsstufe MOSFET IRLZ44N:

   

Aufbau wie folgt:

1 x BC337-40 als Puffer für das PWM-Signal vom ESP32
1 x BC337-40 als Level-Shifter von 3,3 auf 5 Volt Pegel
1 x IRLZ44N als Leistungstreiber, weil der hat Logikpegel 5 Volt am Gate !!

Bedingt durch die Pufferstufe wird das PWM-Signal NICHT invertiert, was das Software-Schreiben einfacher macht ... (Muss nicht invertiert gedacht werden .....).

So der Plan ....

Der Rest der "Geschichte" (Schalter, Pitch, Tachosensor, Spannungsversorgung) läuft ja und die Software ist auch soweit durch - bis auf den finalen Anteil PID. Aber das ist nun auch kein "Hexenwerk" (mehr). Library einbinden, neue Instanz erzeugen und letztlich die neue Instanz PID "arbeiten" lassen. Da wird mit Sicherheit noch Parametrisierung des PID kommen, aber das ist ja eigentlich nur Softwareanpassung ....

Wie bereits erwähnt, es wird noch eine "Umbauanleitung/Doku" geschrieben und dann hier zur Verfügung gestellt. Aber das wird nen Moment dauern .....

Aber erstmal die "Restarbeiten" erledigen.

beste Grüße

Christian
Zitieren
#45
So funktioniert das.
In Beitrag 148 lag das Gate noch über 10k an 24V!!!

Gruß Mani
Besonders gerne repariere ich meine Philips, Braun, Akai und TEAC Geräte Big Grin
Keine Hilfe bei fehlender Rückmeldung
Zitieren
#46
So, die leidigen Restarbeiten - zuerst die "Buchführung" auf Stand bringen:

Teil 1 Restarbeiten - Buchführung

   

Das ist der gesamte getestete "Hardware-Bedarf" (ohne µComputer).

Die Leistungstufe ist getestet und läuft mit PWM-Signalen von 5 Volt und 3,3 Volt Signalpegel. Zubeachten ist dort lediglich, dass die beiden Kollektorwiderstände der BC337 bei einer PWM-Frequenz bis ca. 1 Khz auf 1 KOhm vergrößert werden können. Für 22 Khz PWM-Frequenz sollten es dann 470 Ohm sein, da die Geschichte dann mehr Strom zieht / benötigt.

Die Hardware ist so konzipiert, das sowohl µComputer mit 5 Volt Pegel als auch 3,3 Volt Pegel genutzt werden können.

Teil 2 Restarbeiten - Platine und Verkabelung

Aus der 10X/XD werden 1:1 übernommen:

P3 vom Motorcontrolboard und der Steckverbinder für die 20 Volt AC.

Die Leitungen der Lichtschranke/Tachosensor werden jetzt vieradrig statt vorher dreiadrig zur Platine geführt. Der erforderliche Kabeltausch hierfür geht ohne weiteren Ausbau/Lösen weiterer Komponenten. Der Halter für die Lichtschranke/Tachosensor wird wie im Original übernommen und auch so wieder montiert (Lichtschranke an einem der beiden Montageflansche ca. 1 mm in der Stärke verkleinern). Die Spannungszuführung der + 27 Volt vom Originalnetzteil endet jetzt in einem Platinenschraubverbinder (statt fest verlötet im Original).

Somit kann die Platine OHNE Lötkolben ein- bzw. ausgebaut werden. Damit wird ein modularer Aufbau beibehalten, so wie es sich generell durch die 10X/XD zieht. Bedingt durch die zusätzlich auf der Platine integrierten Messpunkte für die benötigten Signale/Schaltspannungen kann die Platine komplett autark außerhalb der 10X/XD getestet werden. Das war mir persönlich extrem wichtig !

bis hierhin soweit erstmal ......

beste Grüße

Christian
Zitieren
#47
Weiter geht es mit "Resten" .....

Teil 3 Restarbeiten - Halteblech für Platine und Einbau

Für die Montage der Platine musste ja noch ein neues Halteblech her ... Also mal fix eines aus 1,5 mm Alu-Blech gestrickt.

   

So sieht es dann montiert aus:

   

Und dann rein in die Maschine ......

   

Passt rein mit satt Luft .... In Teilen schon verkabelt .... Die Kabellängen der Originalverkabelung samt Steckverbinder für P3, 20 Volt AC und die + 27 Volt passen !

Eingebaut wurde die Platinenversion 03. Diese Version wurde notwendig, weil sich die Leistungsstufe nochmals geändert hat (siehe vorherige Beiträge).
Im Gegensatz zum originalen Motorcontrolboard diesmal Bauteileseite oben .... Die Befestigung erfolgt über die beiden M4-Gewinde im Chassis für den Kühlkörper des originalen Boards. Das bot sich an.

   

Und hier mal der Größenvergleich. Links Original, rechts Fälschung ... Fälschung zeigt Platinenversion 02, aber im Vergleich zur 03er-Version sind die Abmessungen identisch. Die 03er-Version ist nur wesentlich kompakter aufgebaut, so das der USB-C-Stecker nicht mehr 5 mm über den Platinenrand übersteht .....

So kann es wohl bleiben !

Bis hierhin erstmal soweit, letzter Rest ist die Software ....

beste Grüße

Christian
Zitieren
#48
Soderle,

Restarbeiten Teil 4 - Software und Dokumentation

Nachdem die letzten 3 Tage nur an Software und Doku gearbeitet wurde - HABE FERTIG !!!

Die Doku ist an diesen Beitrag angehängt und für die Allgemeinheit.

Ich denke da ist alles drin, sollten da "böse Fehler" drin sein - niemand ist allwissend. Insofern erbitte ich dann um Korrektur. Ansonsten sollte sie ausreichen um als "Anhalt" für eine Adaption auf andere Maschinen auszureichen bzw. andere 10X/XD bei Motorversagen zu "heilen". Zumindest ist der gesamte "Umbauprozess" dargestellt, inkl. Teileliste etc.

Es gilt: Gebrauch auf eigene Gefahr und eigenes Risiko !

Der Quellcode ist nochmals gesondert angehängt. Auch hier gilt: Gebrauch auf eigene Gefahr und eigenes Risiko !

Der entwickelte Quellcode ist weitestgehend unabhängig von der verwendeten externen Hardware (Motor, Tachosensor etc.) geschrieben und allgemeingültig gehalten. Deshalb ist da auch ein dicker Block mit Konstanten drin, die das Verhalten der Software steuern. werden diese Konstanten geändert, ändert sich das weitere Verhalten der Software. Das wurde bewußt so gemacht, damit eine Adaption nicht an einem profanem Stück Software scheitert .....

Die Maschine läuft wieder und es sind hier jetzt nur noch die finalen Parameter für den PID-Regler zu ermitteln (alles auf Mal ging nicht ....)

Nochmals ein dickes dickes Dankeschön an alle "helfenden Hände" !!! Ohne diese wäre ich aufgeschmissen gewesen ....

Ansonsten viel Spaß mit Doku und Quellcode .....

Da ich als Hilfe beim Codieren der Software (cpp ist immer noch nicht mein Fall ...) Karl Irgendwen (KI) genutzt habe hier Karl's Meinung:

   

beste Grüße

Christian

PS.. Wer bessere Ideen/Vorschläge/Verbesserungen hat - her damit !


Angehängte Dateien
.pdf   Der_Drehzahl_Professor.pdf (Größe: 1.94 MB / Downloads: 13)
.pdf   sourcecode_10X_motorcontrol_v104.pdf (Größe: 75.29 KB / Downloads: 7)
Zitieren
#49
...Moin!

..ich verfolge das schon von Anbeginn, daher auch meine Frage, eventuell hab ichs überlesen: Huh

...du hast erwähnt, das der Riemen am Anfang immer beim Geschwindigkeitwechsel abgelaufen ist, wie verhält es sich beim abschalten der Maschine? ...läuft der Motor sanft aus, oder bremst er doch übermäßig?

...mfg, Fränky
...ich sammel Punkte...
...man hat mir schon immer bescheinigt, das ich nen Knall(frosch) hab Big Grin
Zitieren
#50
Hallo Fränky,

der Motor fährt bei Abschalten der Maschine schön sanft runter OHNE Riemenverlust.

Generelle Verhaltensweise/Steuerung des Motors und somit des Riemens:

 - Maschine anschalten -
Motor steht
PWM-Pin ist auf NULL gesetzt, also NULL Signal
kurzes Delay (150 ms)
initialen PWM-Wert setzen (in Abhängigkeit zur Geschwindigkeit)
Motor von 0 auf initialen PWM-Wert hochdrehen innerhalb von 4 Sekunden
Zuschlag 1 Sekunde, damit Motor sich synchronisiert
initialen PWM-Wert an PID-Regler übergeben (damit der nicht von Null rechnet und die Regeldifferenz zu groß wird und somit dann abruppt hochdreht ....)
dann normal mit Regelung weitermachen und Soll-Drehzahlen an den PID geben
aktuellen PWM-Wert des PID merken
Riemen springt nicht !

 - Geschwindigkeitswechsel -
PID ausschalten
Fading der aktuellen Geschwindigkeit (steht ja im gemerkten PWM-Wert) hin zum initialen PWM-Wert der neuen Geschwindigkeit innerhalb 3 Sekunden plus 500 ms Zuschlag
Soll-Drehzahl neu setzen
initialen PWM-Wert der NEUEN Geschwindigkeit an PID übergeben (Vorbesetzen wegen Overflow-Gefahr ...)
Impulszähler vom Müll befreien (der läuft im Hintergrund ja noch mit und zählt munter. Irgendwas ist ja immer .... ). Wird das nicht gemacht stürzt der PID wegen Overflow ab ......
PID anschalten
Zeitintervall neu setzen
und weiter mit Regelung machen
aktuellen PWM-Wert des PID merken
Riemen springt nicht !

 - Pitch -
IMMER nur zur gewählten Geschwindigkeit möglich
die untere bzw. obere Drehzahlgrenze wird anhand der Soll-Drehzahl gesetzt und im Programm errechnet !! Änderung des Pitch-Bereiches über die Variable pitch_faktor z.b. von 10 auf 15 Prozent ....
KEIN Fading !! Da innerhalb des gesetzten Soll-Drehzahlbereiches .....
Poti-Wert wird in RPM umgerechnet und als Soll-Drehzahl an den PID übergeben
und weiter mit Regelung machen
aktuellen PWM-Wert des PID merken
Riemen springt nicht !

- Maschine ausschalten
Motor fährt langsam runter, da PWM-Pin noch aktiv und langsam (wenn Millisekunden langsam sind ...) runterfährt (alle Spannungen gegen Null laufen)
Riemen springt nicht !

- Impulszählerei
Tachoimpulse werden im Intervall von 250 ms gelesen
Ergebnis mal Korrekturwert ( hier 4) nehmen (ist z.B. Intervall 500 ms so ist Korrekturwert 2), weil es MUSS auf 1000 ms gerechnet werden
dann auf RPM umrechnen
als IST-Drehzahl dem PID übergeben

- PID
Sampletime ist 100 ms
Wertebereich PID für PWM 0 - 1023

Werte für kp,ki,kd bitte selbst eruieren - das ist Motorenabhängig .... und zwar sowas von .....
An den drei Werten nicht verzweifeln - die haben extremen Einfluss auf das Verhalten der Regelung. Und somit auf den PWM-Wert !!!

Wenn partout nix geht, kp,ki,kd auf 0.0 setzen (Motor muss dann stehen) und NUR  kp in Einer-Schritten erhöhen (also 1.0, dann 2.0 usw.). Solange bis der Motor kurz vor Schwingen ist, dann Wert für kp halbieren und mit ki weitermachen, allerdings in 0.01er Schritten .....

Die Ermittlung dieser drei Werte kann ganz schön nervig werden ! Und dafür braucht es Zeit und Ruhe .....

Bedingt durch das Fading bei Maschinenstart wird auch der Anlaufstrom des Motors begrenzt bzw. klein gehalten so das das Netzteil nicht in die Knie geht.

Zur Pitch und deren Verhalten:

Die Pitch ist NUR AKTIV, wenn sie mittels eines EXTERNEN Schalters eingeschaltet wird !! Hardwareseitig ist der entsprechende IO-Pin des µComputer mit einem PULLDOWN-Widerstand versehen. D.h. hier herrscht nun mal logisch und elektrisch LOW ! Im Quellcode wird dieser Pin auf logisch HIGH abgefragt und nur wenn da ein HIGH-Signal (also externer Schalter AN) anliegt ist die Pitch aktiv. Die Pitch regelt sich so lange bis das Poti nicht mehr gedreht wird und somit die geänderte Soll-Drehzahl festgelegt ist.

Auf ein Fading an dieser Stelle kann verzichtet werden, da der Drehzahlbereich im Toleranzrahmen liegt ohne das der Riemen springt.

Beispiel:
Soll-Drehzahl für 19 cm/s ist 726 RPM ; Pitchbereich +/- 72,6 RPM
PWM-Wert für Solldrehzahl ist ca. 197
PWM-Wert untere Grenze Pitch ist ca. 189
PWM-Wert obere Grenze Pitch ist ca. 205

und das kann der Riemenantrieb ab !

beste Grüße

Christian

PS.: Alle eben angesprochenen Werte sind im Quellcode an EINER Stelle zusammen aufgeführt, so das ein zentraler Änderungsblock für andere Maschinen/Motoren/Drehzahlen etc. gegeben ist und nicht in den "Untiefen" des Quellcodes gesucht werden muss. Das erschien als äußerst sinnvoll !! Rechnen kann das Progrämmle von alleine , sozusagen built-in-feature ......
Zitieren


Gehe zu:


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