• The bottom deployment pane is resizable now to see more/less output
• The output text in the deployment pane now might be copied or saved to a file with a single click
• When creating a link, you can press T, C, W to quickly place a Terminal, Constant, Tweak, or a Watch right under the cursor
• Press Ctrl+U for Upload
• Bus nodes are now more painless to point with the cursor

Under the hood

XOD devs finally managed to update the underlying platforms to get along with the time. In particular, Electron is updated to v10 and NodeJS to v12. Although this update is hardly noticeable, it is required to go on with further development. In any case, the update brings more performance and security.

As usual, the release includes other small improvements and enhancements. Read the full list on GitHub.

Get the new version of XOD from the downloads page or try it directly in your browser. If you have XOD installed already, click the update message when IDE starts.

XOD 0.37.0: Small Features and Big Underlying Update was originally published in XODlang on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hi, there! Today we release the new 0.36.0 version of the XOD visual programming language. The main topic of the update is Records. Sure, you know the basic data types used in XOD: numbers, booleans, pulses, strings. Many things are too complicated to be expressed in terms of a single basic value. But any such complicated thing might be decomposed into simpler things, and so on, and so on, until the basic values. XOD Records is the feature to combine the simpler types to form a new type.

It was possible earlier, actually, but you have had to dive into C++ to define such a type. Version 0.36.0 introduces a xod/patch-nodes/record marker node to group all the input values into a new supertype. Once you place this marker, a few more patches are generated to work with the new type.

What makes the records more interesting is the automatic generation of its JSON serializer. Now you can build complex nested JSON’s to interact with various web APIs easily.

Learn records in detail with the new guide article:

• Creating Records

As usual, the release includes other small improvements and enhancements. Read the full list on GitHub.

Get the new version of XOD from the downloads page or try it directly in your browser. If you have XOD installed already, click the update message when IDE starts.

XOD 0.36.0: Records and JSON Serialization was originally published in XODlang on Medium, where people are continuing the conversation by highlighting and responding to this story.

C++ syntax simplification

Those who tried to make own C++ node know that the code looks weird a bit at the first look. Yes, it’s C++ but with some foreign quirks like {{ GENERATED_CODE }}, strange rules to #include other libraries, etc.

We wanted to remove all that non-standard stuff completely with this update. But the reality of many-many-many edge cases did not allow to do so. We have to keep a few deviations. Nevertheless, we are sure that the new API/syntax is much more intuitive, welcoming, and simple to start with.

You can find the complete list of differences in the new guide article Migrating C++ nodes to v0.35. And just to get an idea how it affects the code, here’s an example.

Before:

{{#global}}
#include <LiquidCrystal_I2C.h>
{{/global}}

struct State {
    uint8_t mem[sizeof(LCD)];
    LCD* lcd;
};

{{ GENERATED_CODE }}

void evaluate(Context ctx) {
    State* state = getState(ctx);
    if (isSettingUp()) {
        state->lcd =
            new (state->mem) LCD(getValue<input_ADDR>(ctx));
    }

    state->lcd->printLine("Hello");
    state->lcd->printLine("World");
}

After:

#include <LiquidCrystal_I2C.h>

node {
    LCD lcd = LCD(const_input_ADDR);

    void evaluate(Context ctx) {
        lcd.printLine("Hello");
        lcd.printLine("World");
    }
};

Don’t worry if you rely on some C++ code in the previous API. It still works as is.

Port type is read-only now

Oh, this was a hard part. A massive rework of the program transpiler allowed XOD to have constant types. The value of a constant is set once during the program creation and can never change then. For now, the only constant type is Port, the one used to define pins through which a module is connected to the board. “And what’s the point?” — you might ask — “How this is better than a regular type?”

First, the value of such type is known at compile time. That means that XOD can fail the compilation with a clear error message if you set an incorrect port for a module instead of failing to do anything at runtime.

Second, it opens the doors for program optimization because many upstream nodes no longer raise runtime errors (no need to consume memory for error management). There’s no need to keep duplicate port values across an external library and the program storage. Dead code elimination might be more efficient. Etc, etc.

Third, we haven’t done it yet, but there could be other constant types like “buffer size”. The constant values are accessible at the compile-time and so might be used, for example, to allocate memory for an array statically and safely without touching the new operator.

arduino-cli compatibility updated

As you possibly know, XOD uses the arduino-cli tool to manage hardware packages, perform uploads, and interact with the boards in other ways. The used version is updated to 0.12 (latest at the moment), which brings compatibility with many new Arduino-boards to XOD. For example, XOD is now compatible with Arduino Nano Every and ESP32 out of the box.

As usual, the release includes other small improvements and enhancements. Read the full list on GitHub.

Get the new version of XOD from the downloads page or try it directly in your browser. If you have XOD installed already, click the update message when IDE starts.

XOD 0.35.0: C++ Optimizations, API Improvements, Wider Compatibility was originally published in XODlang on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hi there! The pandemic affected the development process making it slower a little bit. Nevertheless, the new 0.34.0 version of the XOD visual programming language is here. And it brings two major features: PC Internet tethering and support for graphic displays.

Internet tethering

I’m pretty sure you have used the feature of your mobile phone, which makes it a temporary Wi-Fi router for your laptop or buddy phone who ran out of the data limit. That feature is known as tethering.

XOD devs have made the similar feature but for devices. Your PC running XOD IDE now can share its internet access with a dumb board with no network connectivity features. Even if you got only good old Arduino Nano, you can start making an IoT-enabled device, test it, polish, and only after that buy a board that supports Internet connection natively to make the device truly autonomous.

Behind the scenes, the board keeps a UART connection with the computer running XOD IDE, thinking it talks to an ESP8266 AT-modem. XOD IDE emulates the modem protocol and performs WAN communication on behalf of the connected board.

The internet tethering feature works in the simulation mode as well. That is, you can try to start using internet services, such as XOD Cloud Feeds, without real hardware at all.

To get started with Internet tethering, read the new guide article:

• Sharing Internet from PC

Graphics

Another big thing of 0.34.0 is the support for graphics and graphic LCDs. This is a long-awaited functionality that we introduce only now because the graphics is tricky, especially on microcontrollers with poor resources, especially in the data-flow paradigm employed by XOD.

One of the main problems is RAM consumption. Many existing Arduino libraries take a straightforward approach and keep the whole image buffer in the dynamic memory. The size of the buffer depends on the size of the image and can be as large as several megabytes that is way too large to fit in many microcontrollers’ RAM. We wanted a smarter way. Let it be a bit slower, but save the precious memory.

Finally, after a series of failures, our devs have found a way to clearly and efficiently express and render graphic primitives. The main idea is keeping scene objects declarative and generative. For example, a circle holds only its center and radius, not the whole buffer of its pixels. The pixels are only computed right at the moment when a scene needs to be rendered and sent to the display. Besides that these moments are short, even during the scene rasterization, the whole buffer is not allocated in RAM: the rendering happens line-by-line, right as old Atari game machines did. In the case of 128×160 pixel display, such architecture requires a buffer for 128 pixels, not 128×160=20480 pixels.

As a result, three new items were added to the set of the standard libraries:

• xod/graphics — hardware-independent nodes to define a scene
• xod-dev/ssd1306-display — nodes to render the scene on a popular 128×64 monochrome OLED
• xod-dev/st7735-display — nodes to render the scene on color 160×128 displays backed by the ST7735 chip

The libraries form a solid basis for further development: introducing new shapes, fonts, and LCD models.

Dive into details of XOD graphics rendering with new guide articles:

• Graphics Library
• Loading Images
• SSD1306 Displays
• ST7735 Displays

As usual, the release includes other small improvements and enhancements. Read the full list on GitHub.

Get the new version of XOD from the downloads page or try it directly in your browser. If you have XOD installed already, click the update message when IDE starts.

XOD 0.34.0: Fake Internet and Real Graphics was originally published in XODlang on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hey there! Today we’re proud to announce the new release of the XOD visual programming language. As the title hints, the main feature here is an extended color support and features throughout the IDE.

First of all, you can now enter the color values as HEX literals (e.g., #FACE8D) and use a new color picker widget to select the hue. Check it out. It’s very neat!

Secondly, there are two new nodes to showcase those color capabilities. The tweak-color node allows you to adjust color values in real-time during debug or simulation sessions. The WS2812 library contains multiple nodes to control the popular DIY-hardware with NeoPixel addressable RGB LEDs on board, allowing for some spectacular LED animations with a low memory footprint.

You’ll find a comprehensive guide on the WS2812 nodes in a new article published by our devs:

• WS2812: Controlling NeoPixel RGB LEDs

Further optimization

XOD continues to expand its scope, but we’re still focused on maintaining the higher code efficiency. In fact, we planned a huge revamp in that regard, but were ultimately forced to pull the changes due to the unforeseen problems in rare scenarios. Still, some new features were added to optimize the size of generated C++ code, and you’ll see even more of them in future updates!

As usual, the release includes many other small improvements and enhancements. Read the full list on GitHub.

Get the new version of XOD from the downloads page or try it directly in your browser. If you have XOD installed already, click the update message when IDE starts.

XOD 0.33.0: Color the World was originally published in XODlang on Medium, where people are continuing the conversation by highlighting and responding to this story.

The main feature is interfacing with so-called XOD Cloud Feeds. What is it? It’s a feature that allows your devices to store data from sensors or logging events to the Internet. For example, you can track how temperature changes and when a window was being open and closed.

The data is arranged in feeds, which are something average between a log and table. The feeds belong to you. You are free to discover the history of records, apply date filters, and see the changes plotted as charts.

To get started with the feeds quickly, a couple of articles were written by XOD developers:

• Getting Started with Feeds
• Multiple Time Series

Features to fetch data from the feeds, as well as integrating with them via a generic API are coming soon.

For the time XOD Cloud Feeds are being tested, we place no restrictions on their usage volume.

Library search in IDE

Previously, when you hit “Add library” in XOD IDE, you were being forced to enter the exact name of a library you want to install. This is OK when you know what library solves your problem. However, it makes things more complicated than necessary when, for example, you know what hardware you want to drive but don’t know are there any libraries for that.

Now you can enter a query in the suggestion box and get the same library listing as you would get on https://xod.io/libs/ but right inside XOD IDE:

As usual, the release includes many other small improvements and enhancements. Read the full list on GitHub.

Get the new version of XOD from the downloads page or try it directly in your browser. If you have XOD installed already, accept the upgrade offer when IDE starts.

XOD 0.32.0: Cloud Feeds was originally published in XODlang on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hi there! It was a long time since the last XOD visual programming language release but finally, the new 0.31.0 version is here. It brings a few vectors of improvement.

UPD is now ACT

Skilled xoders know the standard pattern when nodes actually communicate to hardware on an UPD pin pulse. The UPD pin is by default set to “Loop” so that a piece of hardware continuously reflects the data coming on other value pins.

It works fine until you get a module that updates sloooowly. Take an I²C LCD as an example: the full update takes up to 50 ms. Updating such display over an over again even when the text stays intact (most of the time) comes to be entirely pointless. Moreover, that means the program has no chance to react to other things faster than once per 50 ms. Put several slow nodes in a single program, and it quickly becomes unresponsive.

To address the problem, if a node represents an actuator which reflects input data 1-to-1 on its own state, it now exposes a boolean ACT pin instead of the old pulse UPD pin. As long as ACT is true the hardware follows input value changes and updates precisely at the moments when it is necessary.

The new pattern also honors partial updates. For example, if only the text for line #2 has changed, only it will be redrawn. Line #1 will stay intact, saving the precious milliseconds for other good things.

The new pattern is based on a new node, which is unsurprisingly called act. Its usage is straightforward and you can apply the same principle to own hardware nodes

xod/common-hardware cleanup

Do you have a simple LED? A button? Sure, yes. Do you have a LIS331DH accelerometer? Probably no. But such things co-existed in a single library xod/common-hardware which seamlessly became a pile of random hardware nodes.

We found some common groups of nodes and moved them to various dedicated libs under xod-dev:

• HC-SR04 ultrasonic sensor nodes now live in xod-dev/hc-sr04
• IMU and MEMS STMicroelectronic chip drivers live in xod-dev/st-mems
• DHT11, DHT21, and other DHTs are now read with nodes under xod-dev/dht

The original xod/common-hardware became much leaner. We fixed it by adding a bunch of general-purpose hardware nodes :)

• relay — drive a mechanical relay
• pwm-load — drive a dimmable load or a PWM-compatible solid state relay, MOSFET transistor, or similar
• binary-sensor — read a sensor which outputs a stable 0 or 1
• mechanical-switch — read something like a reed switch or a float

JSON

JSON is arguably the most widespread format for communication with HTTP APIs. Previously the possibilities of parsing a JSON response to extract the necessary data were quite limited in XOD.

Our brave developers accepted the challenge and since now XOD offers a full-fledged xod/json library.

The most interesting aspect of the library is that it is very memory-efficient. The whole JSON data never stored in RAM completely: the necessary portions are extracted on fly, as raw characters go in.

To get a quick idea of how to parse a JSON-formatted string, see the new guide article:

• Reading JSON data

Throttle node

Making some real-world applications XOD devs come to a necessity of additional nodes in the standard library.

For example, the throttle node. Throttling is a mechanism often found in programming to limit the number of changes or requests. Now, a xoder can easily limit the frequency of sensor readings regardless of the incoming request rate by placing such node in-between.

Errors

After testing the new error mechanism introduced in 0.30.0 against more real-world cases, it became apparent that it contains some flaws. For example, the decision to remove all errors on pulse links at the end of a transaction was too premature.

Now, the behavior is more consistent. Pulses lose errors only when the nodes which raised them are re-evaluated. Also, we have fixed a few edge-cases and adjusted defer’s behavior when dealing with errors.

Memory optimization

With yet one pass of generated code re-organization, moving, and data packing, we get another RAM consumption saving. It highly depends on the program being compiled but in some cases gives 2.5× improvement when compared to the previous version.

As usual, the release includes many other small improvements and enhancements. Read the full list on GitHub.

Get the new version of XOD from the downloads page or try it directly in your browser. If you have XOD installed already, accept the upgrade offer when IDE starts.

XOD 0.31.0: Standard Library Improvements was originally published in XODlang on Medium, where people are continuing the conversation by highlighting and responding to this story.

All we’ve made since the last release was an error. Maybe, some functional programmers would say we did nothing… 🤣 OK, that’s my arguable humor🙄

Today we release the version 0.30.0 of the XOD visual programming language. It introduces a new concept: the errors. Errors are now a core part of the language having own rules and principles.

If you have experience in conventional programming, the new XOD mechanism is somewhat in the middle between Nothing’s/Optional’s/Maybe’s and exceptions seen in other programming languages.

In the XOD context, the errors free you up from all these ERR pulses which you probably never handled.

Now, errors can spread through the usual links and act like a virus which infects the program further and further causing its paralysis until a cure would be found (or not). What’s more interesting for a casual xoder, is that the errors are visualized in XOD IDE while debugging and simulation. No more guessing “why I see the static 0.00 on LCD?”

To understand and use the new concept, our devs published a couple of new guide articles:

• Errors
• Dealing with errors in C++

What else

You can now delete terminal nodes from a patch node even if some other patches have links to corresponding pins. XOD used to show an error and reject the operation in such cases, which was really annoying. Now you’ll get some broken patches which are easy to spot and fix.

An underlying platform was tweaked and upgraded a bit, so XOD IDE became snappier and a little lighter in size on the disk.

Some xoders had problems with running the debugger for ATmega32U4-based boards (Arduino Leonardo, Iskra Neo, Arduino Micro) on Windows OS. That’s fixed now.

A new convenience node xod/core/switch-case deserves mentioning too.

As usual, the release includes many other small improvements and enhancements. Read the full list on GitHub.

Get the new version of XOD from the downloads page or try it directly in your browser. If you have XOD installed already, accept the upgrade offer when IDE starts.

XOD 0.30.0: Errors was originally published in XODlang on Medium, where people are continuing the conversation by highlighting and responding to this story.

Hi there! I’m glad to announce the new release of the XOD visual programming language. This time our team laser-focused on docs rather than on features, and now XOD carries a brand new built-in tutorial. It is also available in the web version for quick exploration.

The previous version was created along with the first versions of IDE, and it is lacking an explanation of some concepts that we introduced recently. The new version fixes it. It is also structured better and split into four parts:

1. Welcome — XOD basics which you can try without any hardware by using the simulation mode
2. Hardware — Working with popular hardware
3. Patterns — Common XOD tasks and idioms
4. Creating patches — Learn how to develop own nodes

Hope you enjoy it.

What else

There’s an annoying problem reported many times in the community. A conflict appears when one tries to control a single physical device (such as servo or LCD) from multiple nodes at different moments. If hardware nodes’ update pulses are not managed very carefully, the hardware can act sporadically reacting to orders from multiple nodes at the same time.

XOD is young, and even its authors don’t know all possibilities and tricks. We thought a new concept is necessary to deal with the problem, but fortunately, we’ve found a pattern which likely solves the problem and does not require any new features. Meet Mutex!

Mutexes (stands for “mutually exclusive”) available as a new library xod/mutex which allows a node to lock a resource taking exclusive control over it until the lock would be explicitly released or revoked. A comprehensive article on this topic is yet to be written, but you can already get the idea from a chapter of the tutorial talking about the sequential movement of a servo.

As usual, the release includes many other small improvements and enhancements. Read the full list on GitHub.

Get the new version of XOD from the downloads page or try it directly in your browser. If you have XOD installed already, accept the upgrade offer when IDE starts.

XOD 0.29.0: New Tutorial was originally published in XODlang on Medium, where people are continuing the conversation by highlighting and responding to this story.

Whew! We tried to lock release time frame and vary scope while developing the XOD visual language starting from this year. And it gives expected benefits: the new 0.28.0 release is here. Well, we had to sacrifice some features we wanted to implement initially, however, the most prominent and important improvements were made.

Show me your values

The main thing which is rolled out by the XOD team is the new look for the patch board.

One serious flaw of the old visualization is that it hides the values bound to nodes’ pins which have no link attached. It makes the patch image incomplete: you cannot merely make a screenshot or print your program and understand it in full because the vital data is missing.

Even to read a program withing XOD IDE you have to click-click-click nodes and see the values associated with them.

With 0.28.0 the problem goes. Now XOD renders nodes exposing their pin labels as well as the bound values. Take a look:

Nice, eh?

You might think more details come at the expense of density. Yes, it is, but the effect is not so crucial. The UI designer worked hard to include the necessary data and keep the grid in place. Eventually, he got a clear variant which only takes extra 20% of horizontal space and does not ever alter the grid vertical rhythm: the nodes are a bit higher, but the gaps between rows are smaller.

We are sure the new layout will help to understand, share, and discuss your programs better.

What else

The previous release gave us all the tweak nodes. Unfortunately, it lacks pulse tweaks. This was addressed, and now you can use the new xod/debug/tweak-pulse node to generate some pulses in real-time by just clicking a button in the inspector.

Along with the pulse tweak, we’ve added a few more standard nodes:

• xod/math/min and xod/math/max — guess what they do
• xod/core/integrate-dt — integrates a numeric value over time

Another feature is that you can give arbitrary names to your C++ patch node pins, not necessarily a sequence valid as C++ variable name. You can even name your pin a 💩 although I don’t know whether it is a good idea.

Anyway, the symbols out of ASCII range get converted to character sequences like U1234 containing its code so the 💩 would become input_UD83D. To quickly understand what the final name a pin has in C++, the Quick Help sidebar is now functional when editing code. It lists all available symbol names in C++ terms: no more switching between the editor and patch to recall your names.

Tab management has been improved. The tab line is now scrollable when you open too many tabs. And, as in a browser, you can close a tab with a middle-click now.

Not the last, and not the least, the TAB key and focus issues finally resolved for the inspector sidebar. When you update a bound value for a pin, the input no longer loses its focus on pressing Enter: adjust the value as many times as you want and go on to the next input with the habitual TAB press.

As usual, the release includes many other small improvements and enhancements. Read the full list on GitHub.

Get the new version of XOD from the downloads page or try it directly in your browser. If you have XOD installed already, accept the upgrade offer when IDE starts.

XOD 0.28.0: More Detailed Patch Board was originally published in XODlang on Medium, where people are continuing the conversation by highlighting and responding to this story.