https://hackaday.com/2017/08/13/visual-development-with-xod/
This looks interesting:
If you program microcontrollers like the Arduino, you should check out XOD and see how you like visually creating software.
The software is open source and currently, can target the Arduino or Raspberry Pi.
Some alternative visual programming tools:
– LabVIEW RT or Matlab Simulink – both very powerful, very stable, closed source and very expensive
– Scilab Xcos – powerful, unstable, open source, free
– MyOpenLab – enough power, stable, open source, free
Visual tools already covered on this blog:
- Scratch - http://www.epanorama.net/newepa/2016/03/01/scratch-visual-programming/
- Node-Red - http://www.epanorama.net/newepa/2015/11/10/node-red/
- many other at http://www.epanorama.net/newepa/2013/11/11/visual-programming-for-arduino/
10 Comments
Tomi Engdahl says:
XOD is a Visual Programming Language for Arduino, Raspberry Pi, and other Maker Boards
http://www.cnx-software.com/2017/06/02/xod-is-a-visual-programming-language-for-arduino-raspberry-pi-and-other-maker-boards/
When you think about visual programming on the Raspberry Pi or Arduino board, Scratch may come to mind, but some developers have decided to create their own visual programming language working for Arduino, Raspberry Pi, and other boards. Meet XOD, pronounced ksəud.
Tomi Engdahl says:
XOD: A New And Open Source Visual Programming Language For Arduino, Raspberry Pi, Etc.
https://fossbytes.com/xod-programming-language-raspberry-pi-arduino/
However, when it comes to hardware tinkering, programming knowledge is a must. To take care of this issue, developers have been trying to create what’s called visual programming languages. Many of them are already popular, including the likes of Node-Red and NoFlo, and others are budding.
One such new visual programming language for Raspberry Pi, Arduino, and other development boards is XOD. In an email sent to Fossbytes, the creators of XOD programming language told that they’ve added graphical functionality and functional reactive principles. XOD language, XOD IDE, and library sources will be open sourced and published on GitHub once it’s launched.
Compared to other visual programming languages like Node-Red and NoFlo, differs is execution environment. “Node-RED and NoFlo require a full-fledged computer that is capable of running NodeJS programs. At least Raspberry Pi. XOD can be run on much more constrained devices such as microcontrollers and low-end Arduino’s,” XOD creators told me.
It should be noted that XOD is a lower-level programming language. Another thing, XOD is able to let the user build up some missing node using other nodes, without switching to textual programming.
Tomi Engdahl says:
XOD, a new visual programming language for Arduino, Raspberry Pi and other development cards
https://diyprojects.io/xod-new-visual-programming-language-arduino-raspberry-pi-development-cards/
XOD is a new visual programming language project by assembling function blocks. XOD is more modern and simpler than the Scratch project on Raspberry Pi. XOD is still in the development stage. It will be offered as open source software. The source code will be available on GitHub from the day of its release. At launch XOD will be able to manage the GPIO of the Raspberry Pi as well as the Arduino. The development team hopes to create enough enthusiasm among Makers and developers to quickly add other platforms. Hopefully we can quickly develop for Espressif ESP8266 and ESP32 platforms.
Creating a project is similar to Labview’s National Instrument or Node-RED from IBM. Blocks are placed on a board. Each block has inputs / outputs. The blocks are then connected to each other by wires which transmit the data, the commands or the states.
Tomi Engdahl says:
Raspberry Pi gets new visual programming language
https://www.electronicsweekly.com/blogs/distribution-world/raspberry-pi-gets-new-visual-programming-language-2017-06/
A Russian software development team has developed a new programming language which uses visuals and graphics to simplify the programming of Raspberry Pi and Arduino boards.
The language is based on functional reactive programming principles and graphical functionality has been added.
The plan is to publish the XOD language, XOD IDE, and library sources on GitHub once launched.
Tomi Engdahl says:
Yep, this is the point. And it’s not up to change text programming to some graphical widgets, it’s different approach, XOD is data flow concept. In textual programming, you start from real user problem, then decompose it, imagine code abstracts and some kind architecture and then operate with these abstracts to solve problem. In XOD you operate with Nodes and links which correspond to real world more closely.
Source: https://www.reddit.com/r/raspberry_pi/comments/6elqod/another_visual_language_for_raspberry_pi/
Tomi Engdahl says:
XOD — A New Visual Programming Language for Arduino
https://blog.hackster.io/xod-a-new-visual-programming-language-for-arduino-7bc911cdb27
over the last few years visual tools seem to be going through a renaissance. This is being driven, at least in part, by the growing popularity and the communities that have formed up around two very different visual tools, Node-RED and Scratch.
Enter XOD, a new visual programming language for the Arduino, which has just been released into the wild by its creators.
The project is still in very early days, and support for Arduino libraries and other hardware is somewhat limited, and while it shows promise
Right now the visual blocks map closely to the underlying code. However this problem may be resolved with time as “composite” nodes can by connecting two (or more) existing nodes. In other words, you can build small (but higher level) logical blocks which you can then distribute to other XOD users.
XOD will however face stiff competition, as both Node-RED and Scratch support Arduino to different degrees.
However both Node-RED and Scratch require special sketches to be loaded onto the board. Node-RED uses Firmata, and the S4A fork of Scratch that supports the Arduino uses a custom sketch. This means that your laptop has to stay attached to the Arduino—and here XOD is different.
One thing I like a lot about the XOD approach is that it generates native code for the target platform. There’s a lot of boiler plate code in its automatically generated sketches, but there’s no need for Firmata, or an attached laptop to control the board. It runs on the Arduino as if it was programmed with native tools.
The XOD core language, development environment, and standard libraries are all available on GitHub. Alternatively the development environment can be run directly in the browser, or downloaded to your desktop.
https://github.com/xodio/xod
Tomi Engdahl says:
http://www.cnx-software.com/2017/06/02/xod-is-a-visual-programming-language-for-arduino-raspberry-pi-and-other-maker-boards/
XOD programs are stored in regular JSON files. And each module is stored in its own file. The JSONs are pretty-printed. So XOD project source files are quite diff/git-friendly.
Furthermore, there is a CLI that lets you perform some actions (transpile, publish, install) from the terminal without even running visual IDE. It should make XOD suitable for server environments.
Interop is done with native modules mechanism. For any module, you can write down its native implementation in C++ or JS (depends on the target platform). Of course, you may include 3-rd party native libraries there. In such way, you effectively can quickly create a thin wrapper for the library of your choice to bring it to XOD ecosystem.
Probably 80% of the code written for microcontrollers is amenable to this type of development tool. For the remaining 20% if XOD supports creation of custom nodes, 80% of the remaining 20% is probably amenable.
Visual programming is not new and has been used in the real world for decades so solve real production problems. I’ve seen LabView used to build very complicated control systems.
No sure if it’s already in XOD, but a very useful module would be a code block with inputs and output(s) where developer could write code using a scripting language, like a subset of JavaScript, when needed.
I currently use a very powerful visual development environment called Boomi to create very complex system integrations.
Tomi Engdahl says:
xod-js
This package is a part of the XOD project.
The package provides functions that transpile XOD projects into JavaScript code.
https://www.npmjs.com/package/xod-js
https://github.com/xodio/xod
Tomi Engdahl says:
https://hackaday.com/2018/01/07/afroman-teaches-intro-to-servos-builds-laser-turret/
Tomi Engdahl says:
Visuino
Graphical Development Environment for Arduino controller type boards
https://hackaday.io/project/21388-visuino
Arduino and Arduino compatible controller boards have become a favorite way to control automate and animate many Maker’s projects.
Connecting sensors, actuators, and displays to Arduinos is easy and fun. Programming the boards however has proven challenging for many Makers. The Arduino IDE is simple, and easy to use, however it offers very little aside from basic code editing functionality. Programming the Arduinos for anything more complex than blinking LED or reading a sensor, requires fair programming knowledge and has proven obstacle to many Makers, preventing them from making their dream projects.
It has become a common practice for Makers to look around for ready project, and if they find one copy and paste the code, if not simply give up. Coding has proven an obstacle to the world of creativity.
To solve this, Visuino It is designed in such a way that it allows anyone without any programming experience or knowledge to intuitively visually program Arduinos.
Viduino is designed around the concept of software components. Each component represents ready to use functionality. Some of the components represent and are designed to control real hardware such as Sensor, Motor or Servo, others are representing pure software functionality such as signal generator, filter, mathematical function, or communication protocol.
The components have connection points called “Pins”, and the Pins can be connected with “Wires” sending data between the components. Each component can have one or more pins capable of sending and receiving different data types.
Visuino also includes components for sending multiple data channels through the Serial Port, and the Visuino IDE has Scope and Visual Instruments that can display the multichannel data, allowing the Maker to monitor and display simultaneously multiple sensors or data points from the project.
In the spirit of Open Source development, all Arduino libraries for Visuino has been made Open Source and are available on Bitbucket:
https://bitbucket.org/mitov/visuino-libraries
and Sourceforge:
https://sourceforge.net/projects/visuino-components/