Aus einer Rechteckspannung eine Trapezspannung verwirklichen

Moin.. ich bin neu hier, da ich mir vor einer Weile einen Arduino Uno zugelegt habe, um ein wenig zu Hause zu tüfteln.

Meine Programmierung sieht wie folgt aus:

#define DELAY 5
#define DELAY 1

int ledPinT1 = 6;
int ledPinT2 = 9;
int ledPinT3 = 10;
int ledPinT4 = 11;

void setup() {

pinMode (ledPinT1, OUTPUT);
pinMode (ledPinT2, OUTPUT);
pinMode (ledPinT3, OUTPUT);
pinMode (ledPinT4, OUTPUT);

}

void loop() {

digitalWrite (ledPinT1, HIGH);
digitalWrite (ledPinT4, HIGH);
delay(DELAY1);
digitalWrite (ledPinT1, LOW);
digitalWrite (ledPinT4, LOW);
delay(DELAY0);
digitalWrite (ledPinT2, HIGH);
digitalWrite (ledPinT3, HIGH);
delay(DELAY1);
digitalWrite (ledPinT2, LOW);
digitalWrite (ledPinT3, LOW);
delay(DELAY0);

}

Daraus erhalte ich ja eine ganz simple Rechteckspannung. Gibt es eine Möglichkeit daraus eine Trapezspannung zu generieren? Mit den gleichen Bedingungen, also: T1 und T4 sind gleichzeitig an, gehen gleichzeitig aus etc.

Besten Dank

foster_188: Moin.. ich bin neu hier, da ich mir vor einer Weile einen Arduino Uno zugelegt habe, um ein wenig zu Hause zu tüfteln.

Daraus erhalte ich ja eine ganz simple Rechteckspannung. Gibt es eine Möglichkeit daraus eine Trapezspannung zu generieren? Mit den gleichen Bedingungen, also: T1 und T4 sind gleichzeitig an, gehen gleichzeitig aus etc.

Hallo,

ich kann leider nicht erkennen, wo du etwas "heraus" bekommst.

Aktuell sollten deine Leds blinken, was sie aber nicht können, da der Sketch nicht funktioniert. Du musst erst die Variablen richtig deklarieren und auch mit Werten belegen.

Dann liefert dir der Arduino nur ein Rechtecksignal. Um eine Trapez zu erhalten, wird weitere Hardware benötigt.

Was genau möchtest du mit der "Trapezspannung" machen?

Dein Uno kann sowieso nur digitale Pegel 0/5V ausgeben, damit ist keine Trapezform möglich. Die Funktion analogWrite()ist dahingehend auch missverständlich, sie gibt dir ein pulsweitenmoduliertes, kein jedoch analoges Signal aus. Nun kennen wir deinen Anwendungszweck nicht, anhand der Variablenbezeichnungen in deinem Sketch gehe ich davon aus, dass du LEDs zum Leuchten bringen willst. Dass sie nicht blinken, sollen sie also ein- und ausfaden? Dann wiederum geht das mit analogWrite() - die PWM-Frequenz ist hoch genug, dass du kaum Flimmern sehen wirst.

Hallo,

um eine halbwegs analoge Spannung zu bekommen, solltest du ein RC-Glied ranhängen. Damit werden die PWM Pulse quasi "geglättet". Wird auch etwas träge. Oder Du hängst einen echten D/A Wandler ran. Damit kannste dann machen was du willst. Oder du hast zum Bsp. 8 digitale Pins frei, möglichst an einem Port, und baust dir einen 8Bit D/A Wandler mit Widerstandsnetzwerk nach. Die Frage ist dann nur wie langsam das wird.

Eigentlich kann das Programm nicht laufen

define DELAY 5

define DELAY 1

digitalWrite (ledPinT1, HIGH); digitalWrite (ledPinT4, HIGH); delay(DELAY1); digitalWrite (ledPinT1, LOW); digitalWrite (ledPinT4, LOW); delay(DELAY0);

da du weder DELAY0 noch DELAY1 einen Wert zugewiesen hast

ardubu:
Eigentlich kann das Programm nicht laufenda du weder DELAY0 noch DELAY1 einen Wert zugewiesen hast

Die Variablen sind nicht mal deklariert. Hatte ich aber schon geschrieben #1.

define DELAY1 5 // 5 ms Pause

define DELAY0 1 // 1 ms Pause

entschuldigt, so habe ich es stehen.

Also, es geht im Großen und Ganzen um einen Schweißtransformator (Eisenkern, Primärwicklung, Sekundärwicklung ist das zu verschweißende Produkt (Stahlring)), dessen automatische Stromabschaltung ich auf einem Lochraster gelötet habe. Der Strom, welcher auf die Primärwicklung geht, wird durch ein LEM (Stromsensor) gemessen. Sobald die Spannung einen Grenzwert überschreitet soll kein Strommehr fließen. Dieses Signal geht auf zwei Halbbrücken (eine Vollbrücke, 4 IGBTs). Diese 4 IGBTs sind so geschaltet, dass der Eisenkern ein Magnetfeld aufbauen kann. Sprich der Strom fließt über T1 auf die Primärseite des Kerns und verlässt ihn durch T4. Im nächsten Moment werden beide Ts abgeschaltet und die nächsten beiden (T2, T3) öffnen. So wird ein Induktionsfeld aufgebaut. Es liegt hier also ein kontinuierliches Signal an, welches in 4 UND Gatter geht.

Das ArduinoBoard soll jetzt auch jeweils ein UND Gatter mit einem Signal versehen. Sodass zu einem Zeitpunkt 2 UND Gatter ein Signal zu 2 Ts sendet (2 Ts somit geöffnet sind). Und genau dieses Signal, vom ArduinoBoard soll jetzt wie eine Trapezspannung aufgebaut sein.

Ich hoffe, das war einigermaßen verständlich ;)

ich würde es mal so versuchen:

// an jedem ledPin ein RC-Glied
#define DELAY1 5   // 5 ms Pause
#define DELAY0 1   // 1 ms Pause
#define ledPinT1 6
#define ledPinT2 9
#define ledPinT3 10
#define ledPinT4 11

void setup() {

}

void loop() {

for (byte value=0;value<=255; value++)
     {analogWrite (ledPinT1,value);
      analogWrite (ledPinT4,value);}
delay(DELAY1);
for (byte value=255;value>=0; value--)
     {analogWrite (ledPinT1,value);
      analogWrite (ledPinT4,value);}
delay(DELAY0);
for (byte value=0;value<=255; value++)
     {analogWrite (ledPinT2,value);
      analogWrite (ledPinT3,value);}
delay(DELAY1);
for (byte value=255;value>=0; value--)
     {analogWrite (ledPinT2,value);
      analogWrite (ledPinT3,value);}
delay(DELAY0);
}

Nur bedenke bei der RC Berechnung, dass die PWM Pins unterschiedliche Frequenzen haben.

Vielen Dank ardubu, das klingt auf jeden Fall plausibel! Ich werde hier schreiben, wie das Ergebnis aussieht

Grüße

Foster

Ich könnte mir vorstellen, daß Du die Ansteuerung nicht richtig verstanden hast. Die Schaltung mit den vier IGBT sieht nach einer H-Brücke aus, und wenn die eine induktive Last treibt, dann wird der Strom durch den Trafo automatisch irgendwie trapezförmig. Bei Ansteuerung der Transistoren mit was anderem als einem Rechteck wird kaum mehr als der magische Rauch herauskommen :-]

Wie weit ist denn die Schaltung schon gediehen?

Ich habe nur 2 Halbbrücken zur Verfügung. Aber ja, diese parallel geschaltet ergibt eine H-Brücke. Warum sollten die IGBTs/Sicherung bei einer nicht-rechteckförmigen Spannung durchbrennen?

Ich bin kurz davor zu testen. Es geht quasie nur noch um die Ansteuerung der IGBTs.

Also, auf dem Oszilloskop ergab sich aus dem von ardubu beschriebenen Sketch eine schöne trapezförmige Spannung. Nun habe ich daran noch keine Last gelegt (Eisenkern mit 6 Primär- und 1 Sekundärwindnug), weil die trapezförmige Spannung schonwieder widerruflich ist.

Kann man mit dem Arduino Uno eine Schwenksteuerung der IGBTs ermöglichen? So, dass man diesen Spannungsverlauf auf der Primäseite des Eisenkerns bekommt:

http://www.et-inf.fho-emden.de/~elmalab/El_Antriebe/download/EA_3.pdf [SEITE 11]

Oder bin ich gerade auf dem Holzweg?

Danke für jegliche Antworten.

Jetzt wird es wirklich langsam Zeit für ein Schaltbild. Wieviele Wicklungen willst Du gleichzeitig ansteuern?

Ich glaube, so langsam dämmert mir die Bewandtnis mit dem "phase and frequency correct" PWM Modus! Damit sollte es möglich sein, die beiden Halbbrücken mit einer Pause dazwischen anzusteuern (OCxA und OCxB). Der Effekt entspricht dann dem Schwenkverfahren, nur etwas anders realisiert.

Ich glaube, ich habe gerade ein ziemlich gutes Buch vor mir liegen. Es soll eigentlich ohne PWM realisiert werden (wenn ich das richtuig verstanden habe). Ich hatte bis jetzt immer nur durch Arduino T1/T4 und T2/T3 der H-Brücke angesteuert. Wenn ich jedoch T1/T3 und T2/T4 zusätzlich ansteuere, fließt der Strom über Freilaufdioden und es entsteht tatsächlich soeine Spannung, wie in dem Link zu sehen ist.

Also hoffe ich. Mit dem Schaltbild ist es ein bisschen schwierig von den 2 Halbbrücken, weil ich diese nicht erstellt habe. Ich lade aber mal ein Bild von dem anderen Kram hoch, damit man sich darunter etwas Vorstellen kann - wenn ich zu Haus bin.

Die komplette Schaltung in 2 Ansichten + die Schaltung zur autom. Stromabschaltung

Scan0005.pdf (399 KB)

Scan0006.pdf (353 KB)

Scan0007.pdf (276 KB)

Die Freilaufdioden leiten nur, wenn der Strom durch die Spule wegen der EMK einfach nicht aufhören will, und die Transistoren wegen der falschen Stromrichtung nicht leiten können. Sie schützen damit lediglich die Transistoren, verzögern ansonsten nur das Abschalten.

Den bei Teilaussteuerung dargestellten Verlauf kann man mit zwei geeigneten PWM Signalen für T1/T4 und T2/T3 erzeugen. Falls es dafür noch keine Bibliothek gibt, reicht etwas Code mit direktem Zugriff auf die Timer-Register.

Mit dem folgenden Sketch bin ich weitesgehend zufrieden. Sprich, daraus bekomme ich meinen gewünschten Spannungsverlauf:

define DELAY0 4

define DELAY1 0.02

int ledPinT1 = 6; int ledPinT2 = 9; int ledPinT3 = 10; int ledPinT4 = 11;

void setup() {

pinMode (ledPinT1, OUTPUT); pinMode (ledPinT2, OUTPUT); pinMode (ledPinT3, OUTPUT); pinMode (ledPinT4, OUTPUT);

}

void loop() {

digitalWrite (ledPinT1, HIGH); digitalWrite (ledPinT4, HIGH);

delay(DELAY0);

digitalWrite (ledPinT4, LOW); delay(DELAY1); digitalWrite (ledPinT3, HIGH);

delay(DELAY0);

digitalWrite (ledPinT1, LOW); delay(DELAY1); digitalWrite (ledPinT2, HIGH);

delay(DELAY0);

digitalWrite (ledPinT3, LOW); delay(DELAY1); digitalWrite (ledPinT4, HIGH);

delay(DELAY0);

}

Nun stellt sich die Frage, ob ich daraus eine dynamische Stromregelung verfassen kann. Im Moment sieht es folgendermaßen aus: Sobald die Spannung im Eisenkern die Referenzspannung überschreitet, schaltet meine Schaltung alles ab. Gibt es hier eine Möglichkeit, das Programm so zu erweitern, dass die IGBTs selbstständig wissen, wie lange sie geöffnet sein müssen?

Gruß Foster

Es wäre schön, wenn Du Deinen Code in Code Tags </> einschließst, so wie jeder andere.

Die IGBT wissen garnichts, Du mußt ihnen genau sagen, was sie wann wie tun sollen. Eine Stromregelung erfordert - oh Wunder - einen Regler, der sich in Software z.B. als PID Regler implementieren läßt. Der Regler muß dann mit der Regelgröße (Stromstärke) versorgt werden, die er mit der Führungsgröße (gewünschter Strom) vergleicht und daraus die Stellgröße berechnet, die dann das Timing bestimmt. Die genauen Zusammenhänge mußt Du selbst austüfteln.

Einfacher wäre eine Steuerung, der man den Stellwert zwischen 0 und 100% vorgibt, und die dann dieses Tastverhältnis an die Treiber weitergibt. Dabei würde ich dringend zur Verwendung der PWM Hardware raten, sonst entweicht bei jedem kleinen Fehler im Programm der magische Rauch irgendwo. Und zu einer Schaltung, die beim Abschalten oder Umprogrammieren des Arduino sicherstellt, daß die Treiber alle abgeschaltet sind.

Wenn Du das hinbekommen hast, kannst Du Dir weitere Gedanken darüber machen, wie der Strom gemessen werden kann, und dann vom Regler in den Stellbereich umgerechnet werden kann.

Ich habe jetzt mit dem obigen Sketch meinen gewünschten Spannungsverlauf erreicht. Leider fehlt mir dir nötige Leistung. Auch mit einer niedrigeren Totzeit von DELAY0 1 // 1 ms. Daraus bekomme ich eine Frequenz von f= 250 Hz. Das ist zu wenig. Ich brauche eine Frequenz von > 1 kHz. Dies kann man doch mit der PWM ermöglichen. Nur habe ich leider gar keine Ahnung, wie ich das bewerkstelligen soll. Hat hier jemand eine Ahnung? Brauche ich dafür irgendwelche Hardware, zB. einen Analogwandler oder so? Hatte das nur mal aufgegriffen.

Vielen Dank.

Gruß Foster

Du könntest es mit delayMicroseconds versuchen. Würde ich aber auch nicht machen (s.o.).

Die nächst einfachere Lösung wäre ein Timer Interrupt, mit der Signalerzeugung im ISR.