=Paper=
{{Paper
|id=Vol-1602/paper2
|storemode=property
|title=Remotino: Supporting End-User Developers in Prototyping Embedded Devices
|pdfUrl=https://ceur-ws.org/Vol-1602/paper2.pdf
|volume=Vol-1602
|authors=Julian Dax,Thomas Ludwig,Volkmar Pipek
|dblpUrl=https://dblp.org/rec/conf/avi/Dax0P16
}}
==Remotino: Supporting End-User Developers in Prototyping Embedded Devices==
https://ceur-ws.org/Vol-1602/paper2.pdf
7
Remotino: Supporting End-User
Developers in Prototyping
Embedded Devices
Julian Dax Abstract
University of Siegen In recent years, platforms such as Arduino have made
57072 Siegen, Germany it easier for makers and hobbyists to create “smart
julian.dax@uni-siegen.de objects” and connected devices. However, there are
some unique barriers when developing embedded
Thomas Ludwig systems that challenge non-professionals. We derive
University of Siegen these barriers from existing literature on end-user-
57072 Siegen, Germany development (EUD) in general and in particular EUD for
thomas.ludwig@uni-siegen.de embedded devices. In this paper, we present the first
prototype of a tool that supports end users to overcome
Volkmar Pipek some of these barriers by addressing problems of
University of Siegen missing information and lack of understanding as well
57072 Siegen, Germany as providing visibility and help in decomposition. Our
volkmar.pipek@uni-siegen.de
prototype comprises enhanced functionality for the
debugging and prototyping process of hardware by
showing the current and past state of the embedded
Copyright is held by the author/owner(s). device, and allowing end users to remotely control it,
AVI, June 07–10, 2016, Bari, Italy when they want to focus on circuit design.
Author Keywords
Debugging; Prototyping; End-User-Development;
Appropriation; Internet of Things.
ACM Classification Keywords
D 2.5 Testing and Debugging: Testing tools
8
Introduction Decomposition – one of the core goals of software
With the proliferation of Internet of Things (IoT), it has engineering – is the the idea that a problem should be
more and more impact on the everyday life of average split up in “mind-sized bites” [6] in order to be
citizen. This evolution implies that configuration, solvable. The decomposition problem in embedded
understanding and programming of IoT technology is systems development is due to the fact that the
getting more and more relevant for a diverse group of “powerful separation of computation (software) from
people who are not traditional programmers. However, physicality (platform and environment), which has been
the IoT ecosystem is complex and poses new one of the central ideas enabling the science of
challenges to individualization of soft- and hardware [3] computing, does not work for embedded systems” [2].
as well as understanding the hardware in relation to its
context [5]. The maker community has developed This separation problem is what makes decomposition
various hard- and software-systems in recent years hard to archive. When debugging embedded systems,
which make working with electronics and programmers oftentimes face the challenge, that they
microcontrollers easier for non-professional do not know if the bug they are trying to fix is soft- or
programmers than before (e.g. Arduino, hardware related [5]. To answer this question,
https://www.arduino.cc/). While IoT and embedded programmers need to decompose the integrated,
systems are not synonymous, they are an important embedded system into the hard- and the software
piece of the IoT ecosystem. components in their head. They need to make sure that
either the soft- or the hardware works correctly.
EUD for Embedded Systems
End-user development (EUD) is defined by the aim of The second major reason why developing embedded
developing “methods, techniques, and tools that allow systems is so challenging is the lack of visibility and
users of software systems, acting as non-professional observability. It is a well-known problem in embedded
software developers, to create, modify or extend a systems development, that the internal state of the
software artifact at some point” [4]. EUD asks how hard and -software system is largely invisible to the
end-users can be provided with support to incorporate developer [7]. Booth and Stumpf [1] studied non-
and adapt software artifacts to their work practice. With professional Arduino programmers and called this
regard to EUD, there is an ongoing discourse focusing problem the “information barrier”. Programmers do not
on studying appropriation as well as how to design know which state the program and the electric circuit is
support for these kinds of activities. A common insight in at a given time and they have only very limited ways
is that it is important for end users to learn how they to find it out (debuggers are not available in the
operate their machines [5]. Arduino platform). Observing, how the state of the
embedded system changes over time is especially
Developing embedded systems comes with its own difficult. Our research question was therefore how to
special challenges. In this paper, we focus on problems support end users in understanding and debugging
with decomposition and problems with visibility. embedded systems.
9
Research Approach the server using the Firmata protocol
To pave the way for answering the research question, (https://github.com/firmata/protocol). To provide a
our approach tries to address the challenges of modern, cross platform GUI we chose the Electron
archiving decomposition and visibility only in relation to framework, which is based on the Chrome Browser and
debugging and prototyping of the electrical circuit. For allows the creation of native applications using web
that, we developed a GUI application called Remotino. technologies.
Remotino allows end users to remote control the digital
and analog pins on the Arduino form a computer User Interface
plugged into the Arduino board and to view the inputs In the user interface, we chose to represent each pin of
on these pins. This way, users can see how the the Arduino (besides the pins for the serial ports) as a
electrical circuit interacts with the Arduino separate row (see figure 2). As some Arduinos have
microcontroller by viewing the input and they can test more than 50 pins, users can filter the pins and only
out their circuit by sending output. This helps with show pins which are digital only, allow analogue output,
decomposition, as the user can focus purely on the allow analog input (analog pins can always also be put
electrical circuit first and does not need the ask himself in digital mode) or are enabled.
the question, if the problem is hard- or software
Figure 1: The test setup we used In order to send a value to a pin or to receive values
related. It also helps with visibility and observability in
for our Application. It consists of from it, the pin needs to be “enabled” with using a
an Arduino Mega, 11 LEDs, a the prototyping phase.
checkbox. The pins can then be switched in different
potentiometer and 4 push
operation modes (digital in, digital out, analogue in,
buttons. The LEDs are used to Implementation
test digital and analog output. analogue out) depending on their capabilities. Remotino
To implement Remotino, we chose the Johnny-Five
Analog and digital input can be knows which pins support which modes and which
JavaScript library (http://johnny-five.io/) and the
tested with the potentiometer microcontroller is attached to it as this information is
and the push buttons Electron application framework
made available by the Johnny-Five library. For each
respectively. (http://electron.atom.io/). The Johnny-Five JavaScript
enabled pin, the current value is shown and the values
consists of a server, which has to be installed on the
of the last 10 seconds are plotted.
Arduino and a client library, which sends commands to
10
Figure 2: A screenshot of Remotino showing enabled analog in- and output pins
Future Work programming for students that have no high
In future versions of our tool, we want to include the programming experience and that mainly focus rather
possibility to use pins that are not simple digital or on the design of the hardware artifacts than the
analog pins. A first step in this is the support for serial programming itself. Based in this long-term evaluation
ports. We are also working on an integrated event plot, we will be able to examine the appropriation of
which shows an overview of all enabled pins and embedded systems based on Remotino.
visualizes when significant changes on these pins
happen. Moreover, macro-recording and playback References
functionality is planned. 1. Booth, T. and Stumpf, S. End-user experiences of
visual and textual programming environments for
Arduino. Lecture Notes in Computer Science
For further requirements analysis and evaluation of the (including subseries Lecture Notes in Artificial
usability and applicability, Remotino will be tested in Intelligence and Lecture Notes in Bioinformatics),
the setting of a university course on embedded (2013), 25–39.
11
2. Henzinger, T. and Sifakis, J. The embedded
systems design challenge. Proceedings of the 14th
International Symposium on Formal Methods (FM),
Lecture Notes in Computer Science, (2006).
3. Kubitza, T. and Schmidt, A. Towards a Toolkit for
the Rapid Creation of Smart Environments. In P.
Díaz, V. Pipek, C. Ardito, C. Jensen, I. Aedo and A.
Boden, eds., End-User Development SE - 21.
Springer International Publishing, 2015, 230–235.
4. Lieberman, H., Paternò, F., Klann, M., and Wulf, V.
End-user development: An emerging paradigm.
End User Development SE - 1 9, (2006), 1–8.
5. Ludwig, T., Stickel, O., Boden, A., and Pipek, V.
Towards Sociable Technologies: An Empirical Study
on Designing Appropriation Infrastructures for 3D
Printing. Designing Interactive Systems, (2014),
835–844.
6. Papert, S. Mindstorms: Children, computers and
powerful ideas. New Ideas in Psychology 1, (1983),
87.
7. Vermeulen, B. Functional debug techniques for
embedded systems. IEEE Design and Test of
Computers 25, 3 (2008), 208–215.