EVIA Paradigma

Zeichne ein Programm.
Wähle seine Sprache.

EVIA Paradigma ist visuelle Programmierung für alle, die sehen möchten, was die Maschine erhält. Das Diagramm ist das Programm; die Sprache ist eine Einstellung. Verbinde Blöcke auf einer Arbeitsfläche, führe sie aus und wähle dann, was daraus wird: C99 bis C++20 mit Clang oder GCC, ein Arduino-Sketch, Bare-Metal-C für einen AVR- oder PIC32-Chip oder SystemVerilog, Verilog oder VHDL für ein FPGA.

EVIA 0.6.7 herunterladen Quellcode auf GitHub

Windows und Linux; macOS-Versionen folgen später. Kostenlos und Open Source, MIT-Lizenz.

Blockdiagramm: Start, Set n = 3, eine For-Schleife von 1 bis n, die den Schritt ausgibt und c.add(i) für ein Counter-Objekt aufruft, danach c.show() und End.

      
Das Diagramm links, so wie der Generator es schreibt. Alle 32 Varianten geben dieselbe Ausgabe wie der integrierte Interpreter aus.

Was das Programm kann

Programme bestehen aus Blöcken und Verbindungen

Start, Set, Input, Print, If/Else, For, While und Do-While sind Blöcke; die Verbindungen dazwischen bestimmen den Ablauf. Drücke Run, und der gerade ausgeführte Block wird hervorgehoben. Ausdrücke verarbeiten Zahlen und Text mit && || !, Vergleichen und den üblichen Rechenoperationen.

Eine aus Blöcken verbundene For-Schleife und ihre Ausgabe: step 1, step 2, step 3.

Klassen, Objekte und Module

Eine Klasse hat Felder mit Anfangswerten, einen Konstruktor und Methoden. Jede Methode ist ein eigenes Blockdiagramm von Enter bis Exit. Jedes Exit wird zu einer Ausgabe des aufrufenden Blocks. Blöcke mit demselben Objektnamen verwenden dasselbe Objekt. Speichere Klassen als Module (.eviam) und importiere sie in andere Programme.

Klassenfenster für Counter: Registerkarten für Felder, Konstruktor und Methoden; die Methode add(x) addiert x zu this.total.

Ein Diagramm, vierzehn Sprachen

Ein Diagramm beschreibt, was ein Programm tut, nicht in welcher Sprache es geschrieben ist. Dieselbe Arbeitsfläche wird zu acht C- und C++-Standards, einem Arduino-Sketch, Bare-Metal-AVR- oder PIC32-C oder SystemVerilog, Verilog-2001 und VHDL für ein FPGA. Run führt das Diagramm selbst aus, damit du seine Ausgabe mit jeder Variante vergleichen kannst. Wenn ein Ziel einen Block nicht unterstützt, nennt der Fehler diesen Block, statt die Bedeutung des Programms unbemerkt zu ändern.

Das geöffnete Menü „Code Language and Mode“: C99 bis C++20, Arduino, AVR C, PIC32 C, SystemVerilog, Verilog-2001 und VHDL, darunter Ablauf und Werte.

Acht C- und C++-Standards, zwei Schreibweisen

Wähle in der Werkzeugleiste C99, C11, C17, C++98, C++11, C++14, C++17 oder C++20. Structured erzeugt if/else, Schleifen und switch; Goto macht aus jedem Block ein Label und aus jeder Verbindung einen Sprung. Safe-Werte behalten Text und alle Prüfungen des Interpreters bei; Fast-Werte sind einfache double-Werte ohne Laufzeitprüfungen. Die C-Laufzeit enthält nur, was dein Programm verwendet, und lässt sich daher sauber mit -Wall -Wextra -Wpedantic -Werror kompilieren.

Codefenster mit dem Programm in C11, kompiliert mit Clang und ausgeführt.

Den Code jedes Blocks anzeigen

Klicke mit der rechten Maustaste auf einen Block und wähle View source code: Die generierte Datei wird geöffnet und genau die Zeilen, aus denen der Block besteht, werden hervorgehoben. Das funktioniert auch für eine ganze Methode oder Klasse und in jeder gewählten Sprache. Compile & Run kompiliert den Code direkt mit Clang oder GCC; unter Windows installiert die App llvm-mingw oder WinLibs GCC für dich, Visual Studio ist nicht erforderlich.

Generierter C++-Code mit hervorgehobenen Zeilen des Blocks c.add(i), kompiliert mit Clang und ausgeführt.

Arduino- und ESP32-Boards

Pin Mode, Digital Write and Read, Analog Read and Write, Delay und Millis sind ebenfalls Blöcke. Ein Arduino-Sketch lässt sich für Uno, Nano, Mega 2560, Leonardo, Micro und Pro Mini sowie ESP32, ESP32-S2, -S3, -C3, -C6 und -H2 erstellen. UART, SPI, I2C und MQTT sind ebenfalls Blöcke. Run simuliert einen Uno auf deinem Computer und zeigt jede Pin-Änderung in der Ausgabe. So kannst du ein Programm ausprobieren, bevor ein Board auf deinem Schreibtisch liegt.

Das Blink-Beispiel mit Board-Blöcken in der Palette; die Ausgabe zeigt, wie der simulierte Pin 13 alle 500 ms umschaltet.

Ohne Arduino bis hinunter zu den Registern

AVR C erstellt Programme für ATmega328P, ATmega2560 oder ATmega32U4 ohne den Arduino-Kern: Ports, Timer, PWM, ADC und UART werden in lesbarem C eingerichtet. avr-gcc kompiliert das Programm auf etwa 4 KB; Upload überträgt es mit avrdude auf das Board. Jedes Beispiel wird im simavr-Simulator ausgeführt und mit dem Interpreter verglichen.

Neu in 0.5: PIC32 C bietet dasselbe für neun PIC32MX-Chips mit Microchips XC32. UART, SPI und I2C sind in Run und allen drei Board-Sprachen Blöcke. Der PIC32-Code wird mit Microchips Geräte-Headern geprüft, wurde aber noch nicht mit XC32 kompiliert oder auf einem Chip ausgeführt.

Neu in 0.6: FPGA-Unterstützung. SystemVerilog, Verilog-2001 und VHDL wandeln dasselbe Diagramm in Hardware für Artix-7- (Nexys A7, Arty A7, Basys 3) und Cologne-Chip-GateMate-Boards um. Die Ausgabe wird mit Run verglichen simuliert und mit Open-Source-Werkzeugen synthetisiert, aber noch nicht mit Vivado verarbeitet oder auf ein Board geladen.

Neu in 0.6.5: MQTT. Fünf Blöcke veröffentlichen die Zahlen eines Programms bei einem Broker und lesen Befehle zurück: auf einem PIC32MX mit WLAN-Modul an UART2, auf einem ESP32 mit dessen eigenem WLAN und in Run gegen einen Broker auf deinem Rechner. Der erzeugte Client wird gegen einen echten Broker geprüft; ein WLAN-Modul oder ein Chip war dabei nicht im Spiel. Dazu kommen zwei Beispiele, eines davon für das PIC32 Ethernet Starter Kit II. 0.6.7 — neu: MQTT kann beim MX695, beim MX795 und beim Starter Kit auch über den eigenen Ethernet-Anschluss des Chips hinausgehen, als Anwendung für ein MPLAB X Harmony-Projekt; das ist experimentell und wurde noch nicht gegen echtes Harmony gebaut. Auch die Oberfläche selbst ist jetzt auf Englisch, Russisch oder Armenisch, wählbar in den Einstellungen.

Das Blink-Programm als Bare-Metal-AVR-C, mit avr-gcc 14 für Arduino Uno kompiliert: 4032 Byte Code.

Arbeitsfläche mit der Maus zoomen und verschieben

Drehe über einem Diagramm am Mausrad, um den Zoom zwischen 25 % und 300 % zum Mauszeiger hin anzupassen. Blöcke, Text und Verbindungen bleiben scharf, und du kannst bei jeder Größe weiterarbeiten. Ctrl+0 setzt auf 100 % zurück, Ctrl+9 passt das ganze Diagramm ein. Neu in 0.6.1: Halte die mittlere Maustaste gedrückt und ziehe, um die Arbeitsfläche zu verschieben – aus einem leeren Bereich oder von einem Block aus.

Das Diagramm auf 161 Prozent vergrößert.

Projekte, Git und GitHub

File, New Project erstellt einen Ordner mit dem Programm, einem Modulordner, einer README und einem Git-Repository. Commit, push und pull findest du im Git-Menü; Connect to GitHub veröffentlicht das Projekt mit dem Konto, das dein Git bereits verwendet. Die App fragt niemals nach einem Passwort und speichert auch keines.

Dialog Connect to GitHub mit dem Repository-Namen sbrutyan01/CounterDemo.

Dein erstes Programm in acht Schritten

Die vollständige Anleitung mit allen Screenshots gibt es als PDF in sieben Sprachen: English, Русский, Հայերեն, Deutsch, 简体中文, 繁體中文, 日本語. Sie ist auch in der App unter Help, Tutorial und in der README verfügbar.

  1. Projekt erstellen

    File, New Project. Lasse Create a Git repository aktiviert.

  2. Schleife erstellen

    Ziehe Set, For und Print auf die Arbeitsfläche, verbinde sie und drücke Run.

  3. Klasse erstellen

    Edit, New Class: Füge Counter die Felder total und calls hinzu.

  4. Klasse verwenden

    Ziehe Counter.add(x) in die Schleife und nenne das Objekt c.

  5. Code anzeigen

    Klicke mit der rechten Maustaste auf einen Block und wähle View source code.

  6. Sprache auswählen

    Wechsle zu C11 oder einem beliebigen C++-Standard; der Code wird neu generiert.

  7. Commit und veröffentlichen

    Git, Commit und dann Connect to GitHub.

  8. Weiterlernen

    Module, Beispiele und die Anleitung (F1).

Dein erstes FPGA-Programm in vier Schritten

Dasselbe Blink-Diagramm wird zu Hardware für Artix-7- und GateMate-Boards. Das vollständige Tutorial (Schritt 10) ist im PDF oben; die Anleitung enthält ein FPGA-Thema (F1).

  1. Sprache und Board auswählen

    Sprache: SystemVerilog, Verilog-2001 oder VHDL. Board: Nexys A7, Arty A7, Basys 3 oder ein GateMate-Board.

  2. Blink-Beispiel öffnen

    File, Open Example, FPGA Boards, Blink. Pins haben Namen wie LED0, SW3, BTNC und JA1.

  3. Code generieren

    Drücke F7. Die Pin-Zuordnungen stehen im ersten Kommentar; die Kommandozeile schreibt sie in eine separate Datei.

  4. Kompilieren und hochladen

    Vivado oder die Open-Source-Werkzeuge werden in Settings ausgewählt. Upload programmiert das Board.

java -jar evia-paradigma.jar --gen examples/fpga/blink.evia --lang sv --board nexys-a7-100t -o blink.sv
# writes blink.sv and blink.xdc
java -jar evia-paradigma.jar --gen examples/fpga/blink.evia --lang vhdl --board olimex-gatemate -o blink.vhd
# writes blink.vhd and blink.ccf

In der Simulation mit dem Interpreter verglichen und mit Open-Source-Werkzeugen synthetisiert. Noch nicht mit Vivado ausgeführt oder auf ein echtes Board geladen.

EVIA Paradigma 0.6.7 herunterladen

Jeder Installer enthält eine eigene Java-Laufzeitumgebung; weitere Installationen sind nicht nötig. Zum Kompilieren des generierten Codes brauchst du Clang oder GCC (unter Windows richtet die App einen der beiden Compiler ein).

SystemDateiHinweise
Windows 10 / 11, x64 EVIA-Paradigma-0.6.7-windows-x64.exe Noch nicht digital signiert: Wähle bei der SmartScreen-Warnung More info und dann Run anyway.
Ubuntu 22.04+ / Debian 12+ evia-paradigma_0.6.7_amd64.deb sudo apt install ./evia-paradigma_0.6.7_amd64.deb
Jedes System mit Java 25 evia-paradigma-0.6.7.jar java -jar evia-paradigma-0.6.7.jar

Alle Releases und Versionshinweise

Mit dem eigenen Interpreter getestet

Bei jeder Änderung generiert CI jedes Beispiel- und Testprogramm in allen 32 Kombinationen aus Sprache, Ablauf und Werten, kompiliert es mit Warnungen als Fehler, führt es aus und vergleicht stdout, stderr und Exit-Code mit dem Interpreter.

UmgebungCompilerIdentisch mit dem Interpreter
Linux, alle 8 C- und C++-StandardsClang 23416 von 416
Linux, alle 8 C- und C++-StandardsGCC 13416 von 416
Windows, C99, C17, C++98, C++14, C++20llvm-mingw Clang 23, statisch260 von 260
Windows, C99, C17, C++98, C++14, C++20WinLibs GCC 16, statisch260 von 260
Board-Beispiele, Bare-Metal-AVR-C in simavr (ATmega328P, 2560, 32U4)avr-gcc 1430 von 30
Arduino-Uno- und Mega-2560-Sketches in simavrarduino-cli, arduino:avr15 von 15
FPGA-Designs in Simulation (SystemVerilog, Verilog-2001, VHDL)Icarus Verilog, GHDL27 von 27

Die Arduino-Sketches werden auch für alle 12 Boards einschließlich ESP32 kompiliert (70 Builds, keine Warnungen). Die PIC32-Beispiele werden nur auf Syntax geprüft, anhand der Geräte-Header von Microchip (144 von 144). Jedes FPGA-Beispiel und jeder Test wird mit yosys für Artix-7 synthetisiert; GateMate-Designs werden platziert, geroutet und zu Bitstreams gepackt. Vivado, openXC7 und echte Boards gehören nicht zu CI. Außerdem werden die App, Module, Projekte, Git sowie Zoomen und Verschieben in einem echten Fenster geprüft. Siehe GitHub Actions. Der MQTT-Client wird auf dem Build-Rechner übersetzt und gegen einen echten Broker geprüft.

Dokumentation

java -jar evia-paradigma.jar --run program.evia
java -jar evia-paradigma.jar --gen program.evia --lang c11 -o program.c
clang -std=c11 -O2 -o program program.c -lm