Schaltvorgänge simulieren, ohne den Browser zu verlassen.

01 — Allgemein

Ein mixed-mode Simulator

LeSim simuliert leistungselektronische Schaltungen und die zugehörige Regelung gleichzeitig — vollständig im Browser, ohne Server-Rechenlast. Empfohlen: Chrome, Chromium, Firefox oder Edge. Je nach Modellumfang darf der Prozessor etwas Rechenleistung mitbringen.

02 — Beispiele

Schaltungsbibliothek

Rund 70 lauffähige Beispiele, gruppiert nach Baugruppe. Filter durchsucht Titel und Beschreibung.

03 — Eigene Simulation

KI baut dir eine lokale Kopie

Jede Beispielseite hat einen Button 🤖 KI-Kontext kopieren in der Steuerleiste. Ein Klick sammelt Seiten-Quelltext, aktuelles Schematic und die vollständige Block-API-Referenz — bei Seiten mit eigener Blockbibliothek auch deren Quellcode — und kopiert alles als fertigen Prompt in die Zwischenablage, inklusive Bauanleitung für eine lokal lauffähige Version.

Prompt in eine beliebige KI einfügen — getestet mit Gemini, DeepSeek und Claude. Die KI erzeugt daraus eine einzelne HTML-Datei: Engine wird weiterhin live von lesim.de geladen, das Schematic bringt die Datei aber selbst mit. Einmal gespeichert, läuft sie per Doppelklick, ganz ohne lokalen Server. Diese Datei lässt sich danach mit derselben KI iterativ weiter anpassen — andere Parameter, zusätzliche Elemente, andere Plots.

04 — Elektro-Mathematisches

Knotenpotentialanalyse

Zwei entkoppelte Zeitskalen in einer Simulation: der Netzwerklöser (KPA) arbeitet mit variabler Schrittweite zwischen dtMin und dtMax — halbiert dt, sobald ein Zustandswechsel bevorsteht, verdoppelt es nach sauberen Schritten. Die Regelungsblöcke (CTRL) laufen unabhängig davon mit fester Abtastrate dtCtrl. Jedes Element berechnet seinen Knotenstrom in KPA_solve() rein linear aus den aktuellen Knotenspannungen — der Zustand selbst wechselt erst in KPA_makeStateChange(), nachdem KPA_stateChangeAnnounced() bei minimaler Schrittweite einen Wechsel bestätigt hat. Nach jedem Schritt prüft validateBlocks() alle Werte auf NaN oder Infinity.

Faustregel: Sauberer Schritt → dt verdoppeln (bis dtMax). Zustandsänderung erkannt → dt halbieren (bis dtMin). War der vorherige Schritt bereits reduziert worden, bleibt dt unverändert. Grün markiert die Rechenpfade ohne Eingriff, Kupfer die Entscheidungspunkte, Rot die beiden Stellen, an denen dt tatsächlich angepasst wird.

KPA_solve: function(opt) {
  const c = this.Connectors;
  this.v = c[0].Knoten.Spannung
         - c[1].Knoten.Spannung;
  this.i = this.v / this.rx;   // v = i * R
  c[0].Knoten.StromSum += -this.i;
  c[1].Knoten.StromSum += +this.i;
},
// kein Zustand, keine Schaltereignisse:
KPA_stateChangeAnnounced: function(opt) {},
KPA_makeStateChange:      function(opt) {}

KPA_solve: function(opt) {
  const c = this.Connectors;
  this.v = c[0].Knoten.Spannung - c[1].Knoten.Spannung;
  if (this.s_state) {
    this.i = (this.v - this.vT) / this.rxOn;
  } else {
    this.i = this.v / this.rxOff;   // Leckstrom
  }
  c[0].Knoten.StromSum += -this.i;
  c[1].Knoten.StromSum += +this.i;
},

KPA_stateChangeAnnounced: function(opt) {
  this.t_state = this.s_state;
  // 1→0: Rueckstrom hat Raumladung ausgeraeumt
  if (this.s_state === 1 && this.i < -0.01) this.t_state = 0;
  // 0→1: Spannung uebersteigt Schwelle p_vT
  if (this.s_state === 0 && this.v >  this.vT) this.t_state = 1;
  return (this.s_state !== this.t_state);
},

KPA_makeStateChange: function(opt) {
  this.s_state = this.t_state;
}

KPA_solve: function(opt) {
  const c = this.Connectors;
  this.v = c[0].Knoten.Spannung
         - c[1].Knoten.Spannung;
  // impliziter Euler: L di/dt + R i = v
  this.i = (this.v * opt.dt + this.lx * this.s_i)
         / (this.rx * opt.dt + this.lx);
  c[0].Knoten.StromSum += -this.i;
  c[1].Knoten.StromSum += +this.i;
},

// Spulenstrom ist Zustand -- erst NACH dem Schritt fortschreiben,
// sonst waere KPA_solve() nicht mehr rein linear aus v:
KPA_finished: function(opt) {
  this.s_i = this.i;
},

// kein Schaltzustand, kein KPA_makeStateChange noetig:
KPA_stateChangeAnnounced: function(opt) {},
KPA_makeStateChange:      function(opt) {}

Gelöst wird mit sgmres() (Simplified GMRES) als Standardlöser. Schlägt die Konvergenz fehl, bereinigen OR.getABD() und OR.makeAxM() die Matrix für einen zweiten Versuch, bevor lu() als robuster, aber langsamerer Fallback einspringt — leistungselektronische Netzwerke erzeugen bei sehr kleinen Widerständen neben großen Leitwerten leicht schlecht konditionierte Matrizen. Auffällige Matrizen werden automatisch serverseitig gesichert (OR.saveMatrix()), zur späteren Analyse und Algorithmus-Optimierung.

05 — Dokumentation

Drei Schichten, klar getrennt

Anwendungsschicht (austauschbar, projektspezifisch), LESIM-Systemschicht (Zeitschrittschleife, Schaltplan, Standardblöcke) und Solver-Schicht (kennt weder Schaltplan noch Zeitschritte, löst ausschließlich A·x = b). Vollständige API-Referenz mit Mermaid-Diagrammen pro Modul.

06 — Download

Bibliotheken

Reines JavaScript, keine Abhängigkeiten. Seit der Aufteilung von lib_sym1.js modular in sys/elmLib/ organisiert.