EVIA Paradigma guide

EVIA Paradigma is visual programming: drag blocks from the palette onto the canvas, wire them together and press Run. The same program can be turned into C (C99, C11, C17) or C++ (C++98 to C++20) and compiled with Clang or GCC, or into code for Arduino and ESP32 boards.

The interface itself is in English, Russian or Armenian too: Settings > Interface language. Menus, buttons, the palette and the names on the blocks follow; the generated code and the compilers' messages stay in English. The change takes effect when EVIA Paradigma starts again.

1. Drag Start, a few blocks and End onto the canvas.
2. Drag from the small circle at the bottom of a block (its output port) to another block to wire them.
3. Double-click a block to edit its code.
4. Turn the mouse wheel over a diagram to zoom in and out toward the pointer.
5. Press Run (F5). Output appears in the panel below; the running block is highlighted.
6. Choose a Language in the toolbar and press Generate code (F7) to see, save, compile and run the program.

Look and language. View > Theme chooses the IntelliJ light theme, the Darcula dark theme or the setting of your system; it changes at once and is remembered. Above the topic list you can read this guide in English, Russian or Armenian.

Blocks

The Board blocks (Pin Mode, Digital Write, Digital Read, Analog Read, Analog Write, Delay, Millis, UART, SPI, I2C) are for microcontrollers; see Arduino and ESP32 boards.

Expressions

Values are numbers or text. Operators, from lowest to highest priority:

• ||   &&
• == != < <= > >= (texts compare alphabetically)
• + - (+ joins text if either side is text)
• * / %
• unary - and !, parentheses

Text uses double quotes and \", \\, \n escapes. A condition is true when it is a non-zero number or a non-empty text.

Classes and objects

A class bundles fields (data each object keeps) and methods (block programs that work on it). Create one with Edit > New Class, the palette's + New class, or select blocks and press Ctrl+G to turn them into a class.

• Fields tab: name and initial value of each field. Initial values are expressions and may use program variables and earlier fields. Inside methods a field is this.name.
• One tab per method: its name, parameters and body. The body starts at Enter and ends at an Exit. Each distinct Exit name becomes an output port of the calling block, e.g. yes / no. Parameters arrive as fields: a parameter n is read as this.n.
• Constructor: a method named init (button + Constructor). When an object is created its fields get their initial values first, then init runs once.

Drag a method from the Classes section of the palette onto the canvas to call it. Right-click the block, or double-click it, to choose the method, the object and the arguments. Blocks with the same object name share one object (and its fields); a block with no object name has an object of its own. Objects are created the first time they are used.

Modules

A module (*.eviam) is a file of classes that several programs can use.

• File > Export Classes as Module moves classes into a module file. The program then refers to the module, and saving the program also saves the module.
• File > Import Module adds the classes of a module to the open program.
• The class window shows where a class is stored.

Projects

File > New Project creates a folder with everything a program needs:

MyProject/
  MyProject.eviaproj   project settings
  main.evia            the main program
  modules/             class modules
  build/               generated code (not committed)
  README.md
  .gitignore

Open it again with File > Open Project (choose the folder or the .eviaproj file). In a project, modules are imported from and exported to modules/, and Generate code also writes build/<name>.c or .cpp. The project remembers its language.

Git and GitHub

The Git menu runs the git installed on your computer and uses the login it already has (Git Credential Manager, an SSH key or gh auth login). EVIA Paradigma never asks for or stores passwords or tokens.

• Initialize Repository: git init on branch main (new projects do this automatically when git is installed).
• Commit (Ctrl+K): saves the program and commits every change; the message editor has Vim keys.
• Connect to GitHub: enter owner/repo or a clone URL. Create repository on GitHub opens github.com in your browser with the name filled in; create it empty, then press OK.
• Push / Pull: send commits to GitHub / get new ones (fast-forward only, so nothing is merged behind your back).
• History shows the last commits; Open on GitHub opens the repository page.

Install git from git-scm.com if the menu says it is missing.

Generated code: C and C++

Generate code (F7) turns the whole program into one source file. Three drop-down lists in the toolbar (and in the code window) choose what you get; Run > Code Language and Mode has the same choices. Changing them in the code window generates the code again.

Every combination is tested to give the same output as the interpreter (with Fast values: for programs that run without errors). Right-click a block, a method or a class and choose View source code to see the code it became, highlighted, in the language you chose.

The code window can save the file, compile it and run it. For C it uses the matching C compiler (clang, gcc), the right -std= and -lm. Settings chooses the compiler: Clang (clang++ / clang) or GCC (g++ / gcc, version 13 or newer). On Windows EVIA Paradigma can install either one for you: llvm-mingw (Clang) or WinLibs (GCC, MinGW-w64). Visual Studio is not needed.

Arduino and ESP32 boards

Three more languages make code for microcontrollers. Both use fast values (numbers; text only in Print), and Print and Input go over the serial port at 115200 baud.

Choose the board in the Board list next to the language (also in Settings). Build in the code window compiles for it; Upload builds and sends the program to the board on the serial port set in Settings.

MQTT. The network name, password, broker and topics are fixed texts, because they are written into the program when it is built. PIC32 C drives an ESP8266 or ESP32 module with AT firmware on UART2 (RB5/RB1 on the 28-pin chips, RF4/RF5 on the others), so Print keeps UART1. Arduino on an ESP32 board uses the board's own WiFi. Run answers from a broker on your computer: publishing to a topic you subscribed to brings the message back. An AVR board refuses the MQTT blocks (one serial port, which Print uses), and so does an FPGA. A message is a number, written as Print writes it; since -1 also means "nothing has arrived", MQTT Has Message tells a real -1 apart. MQTT can also go through the chip's own Ethernet port on the MX695F512L, the MX795F512L and the Ethernet Starter Kit II: set PIC32 MQTT over to Ethernet in Settings and the generated file becomes an application for an MPLAB X Harmony project, which brings the TCP/IP stack. That route is experimental: it compiles against stub headers here, but has never been built against real Harmony or run on a board, so the WiFi module is still the tested one.

MQTT over Ethernet (experimental). For the MX695F512L, the MX795F512L and the PIC32 Ethernet Starter Kit II, Settings > PIC32 MQTT over > Ethernet makes the generated file an application for an MPLAB X Harmony project: Harmony brings the TCP/IP stack, the project keeps its own configuration, clock and main(), and you call app_run() from it. Enable TCP, the DHCP and DNS clients, the Ethernet MAC driver and the board's PHY (LAN8740 on the starter kit). The address comes from DHCP, so the network name and password are not used. This path compiles against stub headers in the checks, but has not been built against real Harmony or run on a board: the WiFi module is the tested one.

Pins can be numbers, expressions or the board's names LED_BUILTIN, A0 ... A15; HIGH and LOW work in any expression. These names can't be used as variables.

The bus blocks work in Run and in all three board languages. Open a bus before using it; addresses are 7-bit and the numbers are decimal (80 is 0x50). On a PIC32 the pins are fixed per chip family and listed at the top of the generated code (the chip's own UART1, SPI and I2C1). Run simulates the buses: the UART's transmitter is wired to its receiver, so what UART Write sends comes back from UART Read (and also appears as output text), SPI's input is wired to its output, and one I2C device with 256 registers answers at address 80.

Run simulates an Arduino Uno: pin changes appear in the output as board [500 ms] pin 13 HIGH, time only moves forward in Delay (the main window also really waits, unless the speed slider is at full speed), a button on every input pin is pressed during the second half of each 2 seconds, and analog pins read a slow wave 0..1023..0. The program runs once, as if from setup(); afterwards the pins keep their state. File > Open Example > Arduino and ESP32 Boards has blink, button, fade, an analog meter, a Led class, and UART, SPI and I2C examples.

Desktop languages (C, C++) can't use the Board blocks; Generate code says which block to change.

FPGA: Artix-7 and GateMate

Three more languages, SystemVerilog, Verilog-2001 and VHDL (VHDL-2008), turn the same diagram into hardware. Every block becomes one state of a state machine and takes one clock cycle. Variables are signed 32-bit registers.

Pins are fixed when the design is built, so a pin must be a number or a name: LED0, SW3, BTNC, BTN0, JA1. A pin the board does not have is an error that lists the pins it has. A pin cannot be both read and written.

Whole numbers. Arithmetic wraps at 32 bits; / and % truncate toward zero, and dividing by 0 gives 0. Run uses double numbers, so 5 / 2 is 2.5 in Run and 2 on the FPGA. Not supported yet: classes, Input, Analog Read, SPI, I2C and text in variables (text works in Print).

Build and Upload. Artix-7: Vivado in batch mode, or the open-source flow (yosys, nextpnr-xilinx, Project X-Ray), chosen in Settings. GateMate: yosys, nextpnr-himbaechel, gmpack. Upload uses Vivado or openFPGALoader. The pin constraints are in the first comment of the file, and -o on the command line also writes a .xdc or .ccf file.

Tested: simulation against Run, and synthesis with open-source tools. Not tested: Vivado, openXC7 and real boards.

Examples are in File > Open Example > FPGA Boards.

Keyboard shortcuts

Vim keys

Code fields, the code window and the commit message editor use Vim keys (turn them off in Settings). Text starts in insert mode; Esc switches to normal mode.

• Moving: h j k l, w b e, 0 ^ $, gg G, %, f t
• Editing: i a I A o O, x, dd, cw, yy, p, u, Ctrl+R, .
• Visual: v, V; search: /text, n N, *
• Commands: :w accept/save, :q close, :wq, :s/a/b/g, :make compile and run (code window), :vim open in real Vim