Announcement: there is an English version of this forum on Hallo zusammen, ich möchte mir gerne eine Schaltung zur Spnnungsschaltung aufbauen, mir fehlt jedoch die Erfahrung und somit auch die Idee zur Umsetzung... Vielleicht könnt Ihr mir ja weiterhelfen! Folgendes Problem: Ich habe ein Arduinoboard so programmiert, dass es am PWM-Ausgang 0-5V ausgibt. Diesel Signal soll an ein Steuergerät angeschlossen werden, an dem momentan ein Poti angeschlossen ist.Also: Poti wird als Eingang an das Arduinoboard angeschlossen, Ausgang des Boards als Eingang des Steuergerät. Das Steuergerät hat nun aber 3 Anschlüsse: +, GND und das 0-5V-Signal, das Board jedoch nur 2 Anschlüsse: + und GND. Wie bekomme ich das Ganze ohne Spannungsverlust zusammen? Am Steuergerät müssen alle 3 Anschlüsse belastet werden, da es sonst eine Fehlermeldung ausgibt. Wer hat eine Idee? Grüße Yammi
:
Bearbeitet durch User
Hallo Yammi, hast Du schon mal an ein elektron. Pori gedacht? Wenn Deine Spannung und Dein Strom es zulassen ist es doch gut. Aber: kein PWM. Dafür SPI oder I²C. Gruß Thomas
Hallo, warum schreibst du nicht konkret, um was es geht. Noch besser sind Links auf Datenblätter oder Betriebsanleitungen. > Sven B. schrieb: > Wie bekomme ich das Ganze ohne Spannungsverlust zusammen? > Am Steuergerät müssen alle 3 Anschlüsse belastet werden, da es sonst > eine Fehlermeldung ausgibt. Die Belegung "gnd - Steuereingang - +Ub" deutet schon auf einen Spannungeingang hin, der eigentlich problemlos durch eine externe Steuerspannung zwischen "gnd - Steuereingang" ersetzt werden könnte. Warum jetzt alle Anschlüsse belastet sein müssen, ist unklar. Bist du sicher, das es so sein muß? Falls ja, dann belaste eben "+Ub" gegen "gnd" auch mit einem Widerstand in Größe des Poti-Nennwertes. Einige Sachen sind dabei zu prüfen "gnd" am Steuergerät muß gleich gnd am uC sein. Falls es da unterschiedliche Potentiale gibt, muß eine Seite Potentialfrei gemacht werden (galvanische Trennung der Stromversorgung). Am Steuereingang kann du das PWM-Signal legen, aber nicht direkt, sondern besser über einen Tiefpass, so dass die PWM zu einer Gleichspannung wird. Gruß Öletronika
Hallo zusammen, erst einmal vielen Dank für die schnellen, hilfreichen Antworten! Es geht hier in meinem Fall um ein Steuergerät meines Motorrads. Das Poti ist der Drosselklappensensor. Das Arduinoboard soll erst einmal provisorisch dazwischen geschaltet werden, Stichwort Leistungssteigerung. Der Vorschlag mit dem digitalen Widerstand hat mir gut gefallen. Die Frage ist nur, wie ich mein Programm auf dem Arduinoboard anpasse (SPI)... Momentan habe ich es so programmiert, dass eine Spannung ausgegeben wird. Ist hier jemand im Thema? Grüße Yammi
Hi Welchen Wert hat das Poti, hast Du ein gleichwertiges Digi-Poti bereits irgendwo ausgegraben und wenn Ja, wird Dieses per I2C oder SPI angesprochen? Dann gibst Du statt des PWM-Wertes (wohl eine Zahl 0-255 oder 0-1023) einen Wert an das Digi-Poti und Dieses verstellt den eigenen Widerstand wieder so, wie Du das gerne hättest. Netter Nebeneffekt: das Digi-Poti hat sogar direkt 3 Anschlüsse, da bekommt die Steuerbox gar nicht mit, daß Da nun 'wer anders' werkelt. (zumindest waren bei meinen Suchen die Digi-Potis immer mit 3 Kontakten herausgeführt) MfG
Hi Patrick, das Poti hat einen Wert von 5kOhm, das Programm für den Arduino ist bereits fertig und gibt am Ausgang die gewünschte Spannung aus, allerdings als PWM-Signal (256 Schritte). Das heißt mein Programm müsste noch auf serielle Ausgabe angepasst werden. Habe mir jetzt eine fertige DigiPoti-Platine bestellt, warte noch auf die Lieferung. Die Platine ist mit einem X9C103S bestückt, nicht flüchtiger Speicher. Ich hoffe der passt. Ich würde mich freuen, wenn mir jemand bei der Anpassung meines Programms behilflich sein könnte, da ich im Programmieren blutiger Anfänger bin. Viele Grüße Yammi
Anbei einmal das Programm:
1 | // Analog input pin that the potentiometer is attached to
|
2 | const int analogInPin = A0; |
3 | // Analog output pin that the LED is attached to
|
4 | const int analogOutPin = 9; |
5 | |
6 | // value read from the pot
|
7 | int sensorValue = 0; |
8 | // value output to the PWM (analog out)
|
9 | int outputValue = 0; |
10 | |
11 | void setup() { |
12 | |
13 | }
|
14 | |
15 | void loop() { |
16 | // Lesen des analogen Einganssignals:
|
17 | sensorValue = analogRead(analogInPin); |
18 | // Abfrage, ob Eingangsspannung > 1,8V:
|
19 | if (analogRead(analogInPin) > 368) |
20 | //Gebe am Ausgang 0,5V aus
|
21 | {analogWrite (analogOutPin, 102); |
22 | }
|
23 | // Ordne es dem Bereich des analogen Ausgangs zu:
|
24 | else
|
25 | {outputValue = map(sensorValue, 0, 1023, 0, 255 ); |
26 | // Gebe es am Ausgang aus:
|
27 | analogWrite(analogOutPin, outputValue); |
28 | }
|
29 | }
|
Gruß Yammi
Sven B. schrieb: > Die Platine ist mit einem X9C103S bestückt, nicht flüchtiger > Speicher. > Ich hoffe der passt. Naja, so wirklich ideal ist dieses Teil nicht. Du kannst den Wiper nicht direkt auf einen Wert setzen, sondern musst Einzelpulse für Up/Down erzeugen. D.h. beim Start muss das Poti erstmal ganz an einen Anschlag gefahren werden, und von da an sind nur relative Bewegungen möglich. Das birgt aber auch das Risiko, dass der Potiwert vom gewünschten Wert abweicht, wenn mal einzelne Pulse verloren gehen oder durch Störungen Pulse erzeugt werden (am Motorrad recht wahrscheinlich). Ein Bauteil mit I2C oder besser SPI Schnittstelle wäre hier besser geeignet.
Ok, habe ich nicht drauf geachtet. Werde mir dann ein DigiPoti mit SPI-Schnittstelle besorgen. Hat jemand eine Idee für die erforderliche Programmänderung? Gruß Yammi
Hi Das hängt dann vom Poti ab. Deine Eingangsgröße bleibt ja so, wie Sie bereits ist. Und dieser Wert wird dann auch nur auf's Poti angepasst und zu Diesem geschickt. Wenn das Poti statt 0-1023 0-255 haben möchte, reichte :4 (2x rechts shiften) oder eben die Umrechnung per map. Du wirst wohl Deinen PWM-Wert so beibehalten können, nur dann nicht als PWM, sondern als Wert ins Digi-Poti. MfG
So, habe den AD5160 ausgewählt, sollte passen. Er hat einen Clock-Pin, einen SDI-Pin und einen CS-Pin (neg.). Ich vermute, dass ich nun den gewünschten Wert, der über analogwrite ausgegeben werden soll, in ein serielles Datenwort umwandeln muss?! Muss ich die Frequenz des Potis auf die Frequenz des Arduinos anpassen? Fragen über Fragen... Gruß Yammi
1 | SPI.beginTransaction(SPISettings(150000, MSBFIRST, SPI_MODE0)); |
2 | digitalWrite(cs_pin, 0); |
3 | SPI.transfer(outputValue); |
4 | digitalWrite(cs_pin, 1); |
5 | SPI.endTransaction(); |
Habe mein Programm mal angepasst...habe die Befürchtung, dass noch etwas fehlt.. Ich denke ich muss noch die Ausgänge für die Ansteuerung des DigiPotis festlegen; das PWM-Signal würde weiterhin ausgegeben, habe ja noch einige Ausgänge für das DigiPoti frei.
1 | int analogInPin = A0; // Poti |
2 | int analogOutPin = 9; // PWM |
3 | |
4 | int sensorValue = 0; // Bereich der Eingangsspannung |
5 | int outputValue = 0; // Bereich der Ausgangsspannung |
6 | |
7 | void setup() { |
8 | |
9 | }
|
10 | |
11 | void loop() |
12 | {
|
13 | // Einlesen der Eingangsspannung
|
14 | sensorValue = analogRead(analogInPin); |
15 | // Abfrage, ob die eingelesene Spannung < 1,8V ist
|
16 | if (sensorValue < 368) |
17 | {
|
18 | //Falls ja,rechne die eingelesene Spannung um
|
19 | outputValue=map(sensorValue, 0, 1023, 0, 255 ); |
20 | SPI.beginTransaction(SPISettings(150000, MSBFIRST, SPI_MODE0)); |
21 | digitalWrite(cs_pin, 0); |
22 | SPI.transfer(outputValue); |
23 | digitalWrite(cs_pin, 1); |
24 | SPI.endTransaction(); |
25 | }
|
26 | else
|
27 | {
|
28 | // Gebe 0,5V am Ausgang aus
|
29 | outputValue= 25; |
30 | }
|
31 | // Gebe die Spannung am Ausgang aus
|
32 | analogWrite(analogOutPin, outputValue); |
33 | SPI.beginTransaction(SPISettings(150000, MSBFIRST, SPI_MODE0)); |
34 | digitalWrite(cs_pin, 0); |
35 | SPI.transfer(outputValue); |
36 | digitalWrite(cs_pin, 1); |
37 | SPI.endTransaction(); |
38 | }
|
Könnte mich jemand beim "Feinschliff" des Programms unterstützen?
So, ich habe mein Programm nochmal erweitert. An das Board wird nun ein Digitales Poti vom Typ MCP4131 mit 5k zum Einsatz. Ich habe die Pins folgendermaßen verbunden: CS neg. an Pin A10 SCK an Pin A13 SDI an Pin A11
1 | #include"SPI.h" |
2 | int slaveSelectPin=10; |
3 | int analogInPin = A0; // Poti |
4 | int analogOutPin = 9; // PWM |
5 | |
6 | int sensorValue = 0; // Bereich der Eingangsspannung |
7 | int outputValue = 0; // Bereich der Ausgangsspannung |
8 | |
9 | void setup() { |
10 | pinMode(slaveSelectPin, OUTPUT); |
11 | }
|
12 | |
13 | void loop() |
14 | {
|
15 | sensorValue = analogRead(analogInPin); // Einlesen der Eingangsspannung |
16 | if (sensorValue < 368) // Abfrage, ob die eingelesene Spannung < 1,8V ist |
17 | {
|
18 | outputValue=map(sensorValue, 0, 1023, 0, 255 ); //Falls ja,rechne die eingelesene Spannung um |
19 | }
|
20 | else
|
21 | {
|
22 | outputValue= 25; // Gebe 0,5V am Ausgang aus |
23 | }
|
24 | analogWrite(analogOutPin, outputValue); // Gebe die Spannung am Ausgang aus |
25 | SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0)); |
26 | digitalWrite(slaveSelectPin, 0); |
27 | SPI.transfer(outputValue); |
28 | digitalWrite(slaveSelectPin, 1), |
29 | SPI.endTransaction(); |
30 | }
|
Leider gibt das Poti ständig 5k aus; keine Reaktion... Hat jemand eine Idee?
Beitrag #4960705 wurde vom Autor gelöscht.
Sven B. schrieb: > digitalWrite(slaveSelectPin, 1), > SPI.endTransaction(); Versuche mal slaveSelect nach endTransaction() auf high zu setzen, also SPI.endTransaction(); digitalWrite(slaveSelectPin, 1),
Schade, funktioniert leider auch nicht. Habe auch noch einmal die Verdrahtung kontrolliert, alles soweit in Ordnung... Weiß jetzt irgendwie nicht mehr weiter
Du gibst den erwarteten Wert ja auch parallel an einem PWM Pin aus. Stimmt denn da die Spannung mit der Potistellung überein? Wie sieht die Beschaltung des Digitalpotis genau aus? Hast du ein (Speicher-)Oszi mit dem du die SPI Signal mal mitschneiden könntest (CS & CLK, MOSI & CLK)?
Die Spannung stimmt 100% überein, die Ausgabe eines Spannungssignals hatte ich zuerst programmiert. Anschließend die Ausgabe per SPI zugefügt. Zur Beschaltung: 1= CSneg. 2= SCK 3= SDI/SDO 4= Vss 8= Vdd 8= POB 9= POW 10=POA Leider steht mir kein Speicherossi zur Verfügung.
Beitrag #4961651 wurde vom Autor gelöscht.
Achso, ich hatte irgendwie noch gedacht, es geht um ein AD5160. Das MCP4131 benötigt eine geringfügig andere Software-Ansteuerung. Allerdings kann es sich bei der Pinbelegung nicht um ein MCP4131 handeln. Ist es ein MCP4241 oder ..51 oder ..61?
:
Bearbeitet durch User
Oh, sorry, hatte ich vergessen zu erwähnen...hatte mich für einen anderen IC entschieden... Also, es ist ein MCP4131-502E/SN linear flüchtig SOI
Ja, aber dann kannst du es ja wohl kaum so: Sven B. schrieb: > 1= CSneg. > 2= SCK > 3= SDI/SDO > 4= Vss > 8= Vdd > 8= POB > 9= POW > 10=POA angeschlossen haben. Wie auch immer. Dir ist bewusst, dass ein digitales "Potentiometer" nicht potentialfrei von seiner Versorgungsspannung betrieben werden kann? D.h. eines der Enden P0A oder P0B musst du auf GND legen, und am anderen Ende (oder am Wiper) darf keine höhere Spannung als Vdd angelegt werden. Auch müssen GND vom Arduino und dem Steuergerät zusammengelegt werden. Der folgende Code sollte das Poti korrekt ansteuern:
1 | #include "SPI.h" |
2 | |
3 | int slaveSelectPin = 10; |
4 | int analogInPin = A0; // potentiometer |
5 | int analogOutPin = 9; // PWM |
6 | |
7 | int sensorValue = 0; |
8 | int pwmValue = 0; |
9 | int potValue = 0; |
10 | |
11 | void setup() |
12 | {
|
13 | pinMode(slaveSelectPin, OUTPUT); |
14 | }
|
15 | |
16 | void loop() |
17 | {
|
18 | sensorValue = analogRead(analogInPin); |
19 | |
20 | // limit input value
|
21 | if (sensorValue > 368) // = 1.8V |
22 | sensorValue = 368; |
23 | |
24 | pwmValue = map(sensorValue, 0, 1023, 0, 255); |
25 | potValue = map(sensorValue, 0, 1023, 0, 128); |
26 | |
27 | analogWrite(analogOutPin, pwmValue); |
28 | |
29 | SPI.beginTransaction(SPISettings(1000000, MSBFIRST, SPI_MODE0)); |
30 | digitalWrite(slaveSelectPin, 0); |
31 | SPI.transfer(0x00); |
32 | SPI.transfer(potValue); |
33 | digitalWrite(slaveSelectPin, 1), |
34 | SPI.endTransaction(); |
35 | |
36 | delay(1); |
37 | }
|
:
Bearbeitet durch User
Danke, Joe F. für den Sketch. habs mal hochgeladen; leider keine Änderung, ich habe am Potiausgang ein Messgerät angeschlossen, der Wert bleibt fest bei 5k bzw. 2,5k, je nach Anschluss des Messgeräts. Vielleicht sollte ich mir mal ein neues DigiPoti bestellen...? Allerdings wir die Spannung jetzt nur noch bis 1,8V ausgegeben, ohne den Rücksprung auf fest 0,5V.
Schade, ich bin davon ausgegangen, dass ich durch ein DigiPoti eine Potenzialtrennung erhalte. Das Steuergerät arbeitet allerdings auch mit 5V, somit sollte die Verbindung der "GNDs" kein Problem darstellen.
Sven B. schrieb: > habs mal hochgeladen; leider keine Änderung, ich habe am Potiausgang ein > Messgerät angeschlossen, der Wert bleibt fest bei 5k bzw. 2,5k, je nach > Anschluss des Messgeräts. Das Messgerät ist ein Multimeter? Auch bei Messungen mit dem Multimeter muss ein Ende des Potentiometers immer mit GND verbunden sein, sonst kann das Digital-"Potentiometer" nicht funktionieren. Und das schwarze Messkabel des Multimeters geht dann auch an GND. Mache mal bitte eine Zeichnung, wie du alles genau verschaltet hast. Stromversorgung, Arduino, Digitalpotentiometer, Messgerät. > Vielleicht sollte ich mir mal ein neues DigiPoti bestellen...? Gleich 2 zu bestellen wäre vermutlich kein Fehler gewesen ;-) > Allerdings wir die Spannung jetzt nur noch bis 1,8V ausgegeben, ohne den > Rücksprung auf fest 0,5V. Ja, mein Fehler. Ersetze
1 | // limit input value
|
2 | if (sensorValue > 368) // = 1.8V |
3 | sensorValue = 368; |
durch
1 | if (sensorValue > 368) // > 1.8V? |
2 | sensorValue = 102; // 0.5V |
Nachtrag: Du könntest statt den Widerstand mit einem Messgerät zu messen auch das Digitalpotentiometer erstmal als Spannungsteiler verwenden. Verbinde P0A mit GND P0B mit +5V und miss dann die Spannung zwischen P0W und GND.
:
Bearbeitet durch User
Angehängte Dateien:
-
Zeichnung_2.png
15 KB
So, vorab schon mal die Zeichnung, so wie ich es mir vorgestellt hatte. Die Änderung des Sketches werde ich heute Abend ausprobieren.
Sven B. schrieb: > So, vorab schon mal die Zeichnung, so wie ich es mir vorgestellt hatte. Da fehlt noch die Verbindung zwischen GND vom Arduino/MC4131 und GND der Motorsteuerung!
Angehängte Dateien:
-
digipot.png
16 KB
Dietrich L. schrieb: > Da fehlt noch die Verbindung zwischen GND vom Arduino/MC4131 und GND der > Motorsteuerung! Genau, denn die "Standardverkabelung" fällt ja weg. Und diese GND Verbindung muss auch zum Testen hergestellt werden (s. Anhang, dicke schwarze Leitung). Baue mal auch noch einen Serienwiderstand in die SDI/SDO Leitung rein. Dieses schmutzige Teil "multiplext" die SDI Leitung auf eine sehr unkonventionelle Weise, und treibt zeitweise von der MCP4131 Seite gegen MOSI. Ein 2.2K Widerstand begrenzt den Strom in diesem Fall auf unschädliche 2mA.
:
Bearbeitet durch User
Vielen Dank erstmal für die Vorschläge. Habe die Masseverbindung hergestellt, einen 2,2k Widerstand habe ich erst morgen zur Hand. Ich messe zwischen POW und GND 2,5V fest, leider noch keine Änderung...
Ich glaub ich geb`s auf...Widerstand besorgt, immer noch keine Änderung. Werde mir wohl einen neues DigiPoti besorgen. Falls noch jemand eine Idee hat, immer gerne!
Angehängte Dateien:
-
digipot-b.png
14 KB
Es gibt halt sehr, sehr viele möglich Fehlerquellen. Von schlichtem "falsch angeschlossen", bis Digipot kaputt. Gut wäre, du könntest dir irgendwie mal ein Oszilloskop besorgen. Ansonsten, probiere doch mal aus das Digitalpotentiometer als Spannungsteiler zu benutzen (P0A an GND, P0B an +5V), und miss die Spannung am Schleifer mit einem Voltmeter. Ausserdem wäre ein 100nF Kondensator zwischen dem Vdd und dem Vss Pin direkt am MCP4131 sehr zu empfehlen. Vielleicht ist auch die Bitrate mit 1 MHz zu hoch für deinen Aufbau. Probiere es mal 10 KHz:
1 | SPI.beginTransaction(SPISettings(10000, MSBFIRST, SPI_MODE0)); |
2 | ^^^^^ |
Wenn du ein neues Digitalpotentiometer kaufst, nimm besser eines, bei dem DIN und DOUT auf getrennten Pins liegen (MCP4231). Dann könnte man auch per Software das Potentiometer auslesen - hilft beim Debuggen.
:
Bearbeitet durch User
Hallo Joe, danke für die Unterstützung. Der Spannungsteiler teilt zwar, aber genau in der Mitte und da bleibt er auch. Frequenzänderung ändert auch nichts daran. Werde mir die vorgeschlagenen Bauteile erst einmal beschaffen und einen neuen Versuch starten. Werde das Ergebnis dann zu gegebener Zeit bekannt geben. Grüße Sven
Warum meinen eigentlich immer alle fuer sowas ein Digitalpoti benutzen
zu muessen?
Das Drosselklappenpoti erzeugt ja schon eine sich veraenderdende
Spannung. Also hat das Steuergeraet einen Spannungseingang. Da kann man
doch wunderbar eine Digital nach Analogwandlung per PWM machen wie er es
am Anfang auch hatte. Also PWM vom Controller dann eine RC-Tiefpass
hinterher damit man eine Analoge Spannung erhaelt. Dann noch einen
Buffer mit einem OP damit die auch belastbar ist und dann ab damit ins
Steuergeraet. Das das Steuergeraet meckert wenn es kein Poti sieht ist
doch simpelst mittels Belastungwiderstand von rund 5 KOhm zu loesen
zwischen den beiden Kontakten wo die Potischleifbahn angeschlossen wird.
|-----+
PWM -------R------+---------+ + |
| | +--+-----Steuergeraet Schleifereingang
C +--+ - | |
| | |-----| | +-- Steuergeraet Schleifbahn
GND | | |
|-----------+ 5KOhm
|
+-- Steuergeraet Schleifbahn
|
GND
Hallo Helmut, vielen Dank, je einfacher, desto besser. Das war ja auch mein ursprünglicher Plan. Hatte mir erhofft, dass ich durch das DigPoti eine Potentialtrennung erreiche. Wurde hier aber eines besseren belehrt. Könntest Du (Ihr) mir denn bei der Auslegung des RC-Glieds und der Auswahl eines OPs behilflich sein? Würde gerne einen Spannungsabfall durch das RC-Glied weitestgehend vermeiden, da ja die Ausgangsspannung bis 1,8V 1:1 zur Eingangsspannung ausgegeben werden soll. Den Rest (0,5V) kann ich ja übers Programm anpassen. Gruß Sven
Ein Vorteil des Digitalpotentiomters ist: es reagiert schnell und liefert eine saubere Ausgangsspannung. Bei PWM muss man immer einen Kompromiss zwischen Reaktionsgeschwindigkeit und Welligkeit der Ausgangsspannung machen. Je "glatter" die Ausgangsspannung, desto länger dauert es, bis das RC-Glied die Soll-Spannung erreicht hat... Welche PWM Frequenz willst du denn nutzen, und wie schnell muss eine Änderung der Potistellung am Steuergerät ankommen (maximale Verzögerung)?
:
Bearbeitet durch User
Hallo Joe, die Frage kann ich Dir leider nicht beantworten, da ich die Eigenheiten des Steuergeräts nicht kenne; da hilft nur probieren. Wobei...selbst wenn die Ausgangsspannung durch das RC-Glied niedriger ausfällt, wäre es ja eigentlich kein Problem, da ich ja nicht die vollen 5V ausschöpfe sondern nur eine Ausgangsspannung bis max. 1,8V benötige. Das heißt ich müsste den Spannungsabfall am RC-Glied doch nur programmtechnisch um deren Wert kompensieren...? Und das ist auch der Grund, warum ich auf eine Potentialtrennung einen hohen Wert lege...ich möchte mir das Steuergerät nicht zerstören... Ich würde einfach mal mit PWM anfangen und wenn`s nicht funktioniert auf DigPoti und SPI umsteigen. Aber wie gesagt, mir fehlt ein wenig das "elektronische Hintergrundwissen". Gruß Sven
Sven B. schrieb: > Das heißt ich müsste den Spannungsabfall am RC-Glied doch nur > programmtechnisch um deren Wert kompensieren...? Da gibt es keinen Spannungsabfall nur weniger oder mehr Ripple drauf. Sven B. schrieb: > Und das ist auch der Grund, warum ich auf eine Potentialtrennung einen > hohen Wert lege. Kannst du weder hiermit noch durch ein Digitalpoti erreichen. Das erfordert mehr Aufwand. Da muss dann in allen fällen ein Optokoppeler zwischen geschaltet werden. Da dann auf der isolierten Seite auch Schaltungsteile liegen, auch noch einen DCDC wandler zur versorgung dieser Teile.
Ich glaube ich mache es mir mal ganz einfach; ich besorge mir einen DC/DC-Wandler sowie einem OP und schaue mal, ob die Motorsteuerung das Signal annimmt. Sollte sie nicht, kann ich ja immer noch ein RC-Glied davor schalten. Und wenn das auch nicht funktioniert, bin ich wieder bei meiner SPI-Schnittstelle...
Noch eine Frage...beim Elektronikversand werden OPs mit unterschiedlichen Verstärkertypen bzw. Eigenschaften/Einsatzgebieten angeboten. Was muss ich denn da für einen Typen nehmen?
Angehängte Dateien:
-
isolated-pwm.png
110 KB
Sven B. schrieb: > Ich glaube ich mache es mir mal ganz einfach; ich besorge mir einen > DC/DC-Wandler sowie einem OP und schaue mal, ob die Motorsteuerung das > Signal annimmt. Also mindestens den DC/DC Wandler kannst du dir glaube ich sparen. Dein Steuergerät möchte ja offenbar eh ein wenig belastet werden, um keine Fehlermeldung zu generieren. Ich hätte da noch einen Vorschlag für eine galvanische Trennung der PWM (siehe Anhang). Da du ja nicht den vollen 5V Bereich am Ausgang brauchst, könnte das so gehen. Im oberen Bereich wird es etwas unlinear, aber das ist auch oberhalb der 2.5V und man könnte es in Software herauskompensieren. Für die Simulation habe ich eine 2 KHz PWM genommen. +5V_A sind die 5V auf dem Arduinoboard. +5V_B die 5V vom Steuergerät. Die GNDs links und rechts der Optokoppler sind jeweils die GNDs vom Arduino und vom Steuergerät. Sie müssen/sollten nicht mehr zusammen gelegt werden.
:
Bearbeitet durch User
Angehängte Dateien:
-
isolated-pwm-b.png
60 KB
Für den Fall, dass der Arduino aus ist, ist ein zusätzlicher Widerstand (R9) noch zu empfehlen, um den Ausgang CTRL auf 0 runterzufahren.
:
Bearbeitet durch User
Echt klasse, vielen Dank an Euch für die Bemühungen. Ich werde mir dann mal eine Tüte Bauteile bestellen und die verschiedenen Möglichkeiten schaltungstechnisch aufbauen. Ich melde mich, wenn ich soweit bin !
Thread beobachten
Seitenaufteilung abschaltenBitte melde dich an um einen Beitrag zu schreiben. Anmeldung ist kostenlos und dauert nur eine Minute.
Bestehender Account
Schon ein Account bei Google/GoogleMail? Keine Anmeldung erforderlich!
Mit Google-Account einloggen
Mit Google-Account einloggen
Noch kein Account? Hier anmelden.