Documentation — Arduino Controller

Arduino Controller is an Android application for managing, monitoring, and controlling embedded devices, such as Arduino boards and other compatible hardware.

From the app you can register your devices, watch what they send in real time, send them commands, and automate periodic queries, all from a single place. Communication can be established through three channels, depending on what best fits each project:

  • USB, for devices connected directly to the terminal.
  • TCP/IP, for devices reachable over the network (local or remote).
  • Bluetooth, for devices paired wirelessly.

Although it was born with Arduino boards in mind, the app works with any embedded device that meets the supported communication requirements. For USB, this includes devices that implement the USB CDC-ACM specification and USB-to-TTL converters based on CP210x. As long as the device respects the configured channel and parameters, Arduino Controller can work with it even if it is not an Arduino board.

The app is organized around four main features:

1. Devices

Registering and managing devices and their communication settings.

2. Serial Monitor

Reading the data stream in real time and sending commands manually.

3. Dashboard

A visual control panel built from tailored interactive widgets.

4. Processes TCP/IP

Asynchronous tasks that query the device in the background.

The last three features operate on a specific device and are opened from its detail screen, through the bottom navigation bar.

1. Devices

A device in Arduino Controller is the saved configuration that represents a physical board and, above all, the way to communicate with it. Registering a device is the app's starting point: once added, it remains available permanently so you can monitor it, control it from its dashboard, or assign background processes to it.

This feature covers the entire device lifecycle: listing, creating, viewing, editing, and deleting.

Device list

This is the app's initial screen and shows every device you have registered. It works as a navigation hub: from here you access any device's detail to manage it, and you also have the option to add a new one.

For devices configured over TCP/IP with the automatic connection check enabled, the list shows a visual indicator of their current status (connected / not connected), so you can see at a glance which ones are reachable without opening each of them.

Adding a device

This lets you register a new device. The process starts with the data common to any device type and continues with the fields specific to the chosen communication channel.

General data

  • Device alias: identifying name shown in the list and across the rest of the screens. It should be descriptive, especially if you will be managing several devices.

Communication type

When you select the communication type, the screen shows the specific parameters each one needs.

Intended for devices physically connected to the Android terminal.

  • UART driver, chosen according to the device's chip:
    • USB ACM, for devices that implement the USB CDC-ACM specification.
    • CP210x converter, for devices using USB-to-TTL converters based on CP210x.
  • Serial communication parameters, which must match those of the device:
    • Port speed (baud rate)
    • Data bits
    • Stop bits
    • Parity bits

Intended for devices reachable over the network, on the local network or remotely.

  • Host: IP address or server name of the device.
  • Port: port used to establish the connection.
  • Automatic connection check (enabled by default): the app automatically verifies whether the device is reachable and reflects its status through visual indicators on various screens, such as the list. It is also the communication type required to use the Processes feature.

Intended for devices paired wirelessly with the terminal.

  • If the device is already paired with the system, it will appear directly available for selection.
  • If it is not paired, use the "Discover device" button to find it, pair it, and assign it to the record you are creating.

Device details

Tapping a device in the list opens its detail screen, which acts as its operations center. From here you access the rest of the features through the bottom navigation bar —Serial Monitor, Dashboard, and Processes (the latter only on TCP/IP devices)— and you manage the device itself:

  • Edit: opens the same screen as adding a device, but with the data preloaded so you can modify it. This is what you'll use when a network device's IP or port changes, to adjust the serial parameters of a USB connection, or simply to rename the alias. Changes are applied to the existing device, without creating a new one.
  • Delete: removes the record permanently, including its associated configuration. Make sure before confirming, because to use that device again you would have to add it from scratch.

2. Serial Monitor

The Serial Monitor is the tool for direct, real-time interaction with the device. It reproduces the experience of a traditional serial monitor: it shows the data stream the device emits exactly as received and lets you send commands manually. It is the ideal feature for debugging, checking a board's behavior, reading sensor output, or testing commands before automating them in the dashboard or in a process.

It opens from the bottom navigation bar of the device's detail screen.

Connecting and capturing data

The basic workflow is as follows:

  1. Tap the "Connect" button to establish communication with the device.
  2. Once connected, the app automatically starts capturing data and displays everything the device sends in the log area.
  3. You can stop the capture at any time with the "Stop data capture" button, without closing the connection.

Sending commands

Beyond reading, the monitor lets you send commands to the device by typing and transmitting them from the screen itself. So the device interprets each command correctly, you can define the line ending added when sending:

  • No line ending
  • Newline (\n)
  • Carriage return (\r)
  • Both (\r\n — NL & CR)

The right option depends on how the device's firmware expects to receive the data.

Managing the log

During the session, the monitor also offers utilities to work with the received information:

  • Clear the logs to empty the screen and start a clean read.
  • Share the log with other system apps, for example to save it, email it, or analyze it outside the app.

3. Dashboard

The Dashboard is a visual, customizable control panel for each device. Instead of typing commands manually in the serial monitor, you build your own interface by adding interactive widgets, each associated with a message sent to the device when you use it. This lets you create tailored controls for every project: turning outputs on and off, adjusting values, triggering actions, or displaying information, with a clear, reusable interface.

It opens from the bottom navigation bar of the device's detail screen, and each device keeps its own independent dashboard. As with the serial monitor, the device must be connected for widgets to send commands and receive data.

Building the panel

The dashboard has an edit mode for composing and organizing the panel:

  1. Add widgets to the panel.
  2. Configure each widget according to its type: name, send or receive templates, and their values.
  3. Order or rearrange the widgets as needed.
  4. Delete the ones you no longer need.

Once saved, the configuration stays associated with the device and is ready to use.

Widget data

When adding a widget, several fields are requested. Some are common to all types and others depend on the chosen type and on how the widget relates to the device: there are actuator widgets (they send commands), widgets that reflect readings from sensors (they receive data), and widgets that do both.

  • Widget type: determines the widget's behavior and appearance. It can be Button, Switch, Slider, or Text display. (all)
  • Widget name: identifying label shown on the panel. (all)
  • Send template: text pattern used to compose the message sent to the device. The $VAL placeholder marks the position where the widget's value is inserted before sending (the slider's value or, on a switch, the active or inactive value depending on the position). Actuator widgets only. (Button, Switch, Slider)
  • Line break: allows you to select an end-of-line character when sending a command. Only in actuator widgets. (Button, Switch, Slider)
  • Receive template: text pattern the app uses to locate and extract a value within the message the device sends. The $VAL placeholder marks the position of the value to extract. Sensor-reading widgets only. (Switch, Slider, Text display)
  • Minimum value and Maximum value: limits of the range the control can select. (Slider)
  • Active value: value that semantically represents the "On" state. (Switch)
  • Inactive value: value that semantically represents the "Off" state. (Switch)

The following table summarizes which fields apply to each widget type:

Field Button Switch Slider Text display
Widget type ✓✓✓✓
Widget name ✓✓✓✓
Send template ✓✓✓—
Line break ✓✓✓—
Receive template —✓✓✓
Minimum / Maximum value ——✓—
Active / Inactive value —✓——

Widget types

Button Actuator

Sends a one-off message each time it is pressed, defined in its send template. Ideal for specific actions: resetting the board, triggering an event, or running a routine.

  • Widget name
  • Send template: message sent when pressed (usually fixed text, without $VAL).
  • Line break
Switch Actuator + sensor

A two-position state (on / off): when toggled it sends the message from its send template and, in addition, can reflect the device's actual state from its receive template. Useful for on/off outputs, such as a relay or an LED.

  • Widget name
  • Send template: the $VAL placeholder is replaced by the active or inactive value depending on the position.
  • Line break
  • Receive template: pattern with $VAL to extract from the message the value that reflects the state.
  • Active value: value associated with the "On" state.
  • Inactive value: value associated with the "Off" state.
Slider Actuator + sensor

Sends a value within a defined range (minimum and maximum value) through its send template and, optionally, reflects a value received from the device from its receive template. Suitable for continuous magnitudes: light intensity, motor speed, or servo position.

  • Widget name
  • Send template: the $VAL placeholder is replaced by the selected value.
  • Line break
  • Receive template: pattern with $VAL to extract from the message the value it reflects.
  • Minimum value and Maximum value: range limits.
Text display Sensor

A read-only widget: shows information received from the device —such as a sensor reading or a status— interpreting it according to its receive template.

  • Widget name
  • Receive template: pattern with $VAL indicating which value from the received message is shown.

Using the dashboard

With the device connected, you simply interact with the widgets: pressing a button sends its send template, toggling a switch sends the message for the new position, and moving a slider transmits the selected value. In addition, widgets with a receive template (switch, slider, and text display) reflect the information coming from the device, so the panel can show the actual state of whatever it controls. This way, the dashboard adds a layer of visual control and monitoring over the same communication channel (USB, TCP/IP, or Bluetooth) that the rest of the app uses.

Upcoming improvements

4. Processes TCP/IP only

Processes let you launch asynchronous tasks that run in the background, querying the device periodically without needing to keep the app open. Once started, a process runs autonomously, which makes it ideal for monitoring or collecting readings from a device over time without depending on having the app in the foreground.

It is accessed from the bottom navigation bar of the device's detail screen, just like the serial monitor and the dashboard, and each device manages its own processes.

Availability

This feature is available exclusively for devices with TCP/IP communication. USB or Bluetooth devices do not support processes, since they rely on a physical or proximity-based connection that cannot be maintained autonomously in the background. A network connection, on the other hand, does allow the task to keep operating even when the app is not in the foreground.

Configuring a process

When creating a process, you define the query that will be made to the device and the frequency with which the reading will repeat while the process is active.

Each process also supports an auto-reconnect option to make the task more robust: if communication with the device fails, the process automatically tries to re-establish the connection up to a configurable retry limit. If that limit is reached without success, the process stops retrying.

Background execution

Processes are launched on demand. Once started, the process:

  • Begins running in the background.
  • Queries the device's data periodically, according to the configured settings.
  • Keeps running even if the app is closed, thanks to the TCP/IP connection.
  • On a communication failure, automatically retries the reconnection until the configured retry limit is exhausted.

On this page