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 > General > 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 > C, C++ and Python 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.

Java, Kotlin and Android

Three more languages for computers and phones. Like Python, they have no goto: Structured flow writes nested if/else and while loops, and where the wiring is not block-structured (and always with Goto flow) the diagram becomes a state machine, one branch per block. Safe and Fast values work as in C++, with the interpreter's output, error messages and exit code.

Settings > Java and Kotlin: the JDK (found by itself from JAVA_HOME or PATH; Get downloads Eclipse Temurin) and kotlinc (Get downloads JetBrains' compiler). Settings > Android: the SDK folder (Android Studio's is found by itself; Get Android SDK... shows Google's licence and, once you accept it, downloads the platform, build-tools and adb from Google), the application id (for example am.evia.counter), the name under the icon and the phone. On the phone, turn on USB debugging: Settings > About phone, tap Build number seven times, then Developer options > USB debugging.

EVIA Paradigma builds the app itself with the SDK's tools in a few seconds, without Gradle. The folder it writes (the project's build/android, or EVIA Projects/Android/) is also an ordinary Android Studio project: File > Open and Run.

The phone's sensors. The Phone Sensor block (palette group Phone) stores a reading in a variable: ax = ACCEL_X. It reads ACCEL_X, ACCEL_Y, ACCEL_Z (m/s²), GYRO_X, GYRO_Y, GYRO_Z (rad/s), LATITUDE, LONGITUDE, ALTITUDE, GPS_ACCURACY and GPS_FIX (1 once the position is known). Run simulates a phone on a table; Language Android reads the real sensors, and an app that reads the position asks for the location permission. Delay and Millis work in Java, Kotlin and Android too. Examples: File > Open Example > Android Phones (Hello world, GPS viewer, Motion tester).

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 > 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 Boards, ESP32 Boards, PIC32 Boards and STM32 Boards have 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.

Packages and updates

The toolchains are packages of the EVIA server (evia.am): arduino-cli, avr-gcc with avrdude, the Arm GNU Toolchain, OpenOCD and the OSS CAD Suite. The first start of an installed copy asks which ones to fetch; Settings > Packages and Updates (or Help > Check for Updates) shows what is installed and what is available, and installs, updates or removes them. The Get buttons in Settings fetch one tool the same way. Every download is checked before it is used, and nothing needs administrator rights: the packages live in your own data folder.

A newer EVIA Paradigma is a package too: it installs next to the one you have and starts the next time (or at once with Restart Now). Nothing is uninstalled. On the command line: --packages, --install ID (or --install updates) and --remove ID.

Terminal (toolbar, or Help > Terminal) opens a real terminal on a board's serial port (UART: port, baud rate, what Enter sends, local echo) or on another computer over SSH (password or key). Each session gets a tab; close the tab before Upload, which needs the port.

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 > FPGA. 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.

Linux images

The Linux menu builds your own Linux for a BeagleBone Black or a Raspberry Pi 5 and writes it to an SD card. Choose a build system:

Linux > New Linux Image opens the window: the board, a folder (no spaces in its path), the host name, a root password, an SSH server, Python 3, more packages by the build system's names. Build Image downloads the sources the first time, applies the choices and builds; the output scrolls in the window. Menuconfig opens a terminal with the build system's own menu for everything else. Write to SD Card lists only SD cards and USB drives, asks twice, and asks for your password to write.

Everything is in the folder: evia-linux.json (the choices) and build.sh, which runs on its own too: ./build.sh all. The root password is kept in secrets/, readable only by you; the image gets only its hash. Without a password, root logs in without one (Buildroot, Yocto) or is asked to set one (OpenWrt).

The builds run on Linux (on Windows: WSL 2; on a Mac: a Linux virtual machine). Check This Computer lists what is missing and the command that installs it. On the board: a BeagleBone Black boots from the card when S2 is held at power-on; a Raspberry Pi 5 boots from it by itself. Then Terminal logs in over UART (115200) or SSH. On the command line: --linux DIR --system yocto --board bbb.

Sources as packages. Buildroot, Yocto (Poky and meta-raspberrypi) and OpenWrt (with the Image Builders for both boards) are packages of the EVIA server: Get Sources in the window, or Settings > Packages and Updates, group "Linux images". build.sh takes the sources from the installed package; without it, it downloads the same pinned files and checks their SHA-256. The build itself still downloads the compilers and packages it needs.

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