In recent years, platforms such as Arduino have made it easier for makers and hobbyists to create “smart objects” and connected devices. However, there are some unique barriers when developing embedded systems that challenge non-professionals. We derive these barriers from existing literature on end-userdevelopment (EUD) in general and in particular EUD for embedded devices. In this paper, we present the first prototype of a tool that supports end users to overcome some of these barriers by addressing problems of missing information and lack of understanding as well as providing visibility and help in decomposition. Our prototype comprises enhanced functionality for the debugging and prototyping process of hardware by showing the current and past state of the embedded device, and allowing end users to remotely control it, when they want to focus on circuit design.
With the proliferation of Internet of Things (IoT), it has
more and more impact on the everyday life of average
citizen. This evolution implies that configuration,
understanding and programming of IoT technology is
getting more and more relevant for a diverse group of
people who are not traditional programmers. However,
the IoT ecosystem is complex and poses new
challenges to individualization of soft- and hardware [
End-user development (EUD) is defined by the aim of
developing “methods, techniques, and tools that allow
users of software systems, acting as non-professional
software developers, to create, modify or extend a
software artifact at some point” [
Developing embedded systems comes with its own
special challenges. In this paper, we focus on problems
with decomposition and problems with visibility.
Decomposition – one of the core goals of software
engineering – is the the idea that a problem should be
split up in “mind-sized bites” [
To pave the way for answering the research question, our approach tries to address the challenges of archiving decomposition and visibility only in relation to debugging and prototyping of the electrical circuit. For that, we developed a GUI application called Remotino. Remotino allows end users to remote control the digital and analog pins on the Arduino form a computer plugged into the Arduino board and to view the inputs on these pins. This way, users can see how the electrical circuit interacts with the Arduino microcontroller by viewing the input and they can test out their circuit by sending output. This helps with decomposition, as the user can focus purely on the electrical circuit first and does not need the ask himself the question, if the problem is hard- or software related. It also helps with visibility and observability in the prototyping phase.
To implement Remotino, we chose the Johnny-Five JavaScript library (http://johnny-five.io/) and the Electron application framework (http://electron.atom.io/). The Johnny-Five JavaScript consists of a server, which has to be installed on the Arduino and a client library, which sends commands to the server using the Firmata protocol (https://github.com/firmata/protocol). To provide a modern, cross platform GUI we chose the Electron framework, which is based on the Chrome Browser and allows the creation of native applications using web technologies.
In the user interface, we chose to represent each pin of the Arduino (besides the pins for the serial ports) as a separate row (see figure 2). As some Arduinos have more than 50 pins, users can filter the pins and only show pins which are digital only, allow analogue output, allow analog input (analog pins can always also be put in digital mode) or are enabled.
In order to send a value to a pin or to receive values from it, the pin needs to be “enabled” with using a checkbox. The pins can then be switched in different operation modes (digital in, digital out, analogue in, analogue out) depending on their capabilities. Remotino knows which pins support which modes and which microcontroller is attached to it as this information is made available by the Johnny-Five library. For each enabled pin, the current value is shown and the values of the last 10 seconds are plotted.
In future versions of our tool, we want to include the possibility to use pins that are not simple digital or analog pins. A first step in this is the support for serial ports. We are also working on an integrated event plot, which shows an overview of all enabled pins and visualizes when significant changes on these pins happen. Moreover, macro-recording and playback functionality is planned.
For further requirements analysis and evaluation of the usability and applicability, Remotino will be tested in the setting of a university course on embedded programming for students that have no high programming experience and that mainly focus rather on the design of the hardware artifacts than the programming itself. Based in this long-term evaluation we will be able to examine the appropriation of embedded systems based on Remotino.