Arduino Remote-Control — Comparison vs pfodWeb

Introduction

Putting a phone or PC interface in front of an Arduino-class device usually means picking a remote-control tool — and they take very different approaches: cloud dashboards, drag-and-drop GUI builders, self-hosted automation hubs, or protocols where the device itself defines the UI.
pfodWeb belongs to that last category: a browser-based client where the microcontroller emits the entire UI at runtime, no dashboard to build, and no cloud account.
This document surveys the main alternatives, groups them by how they work, compares them feature-by-feature against pfodWeb, and ends with a decision guide for choosing the right tool for a given project.

1. Device-defines-the-UI protocols

Both these are supported by designers (pfodDesigner and pfodWeb designer) that let you build the menu / display and specify the board pins to control and then generate complete Arduino sketches.
These pfodWeb examples are the main screen of the Europa Ice Sampling Prototype ,a simple menu, and a home Weather Station, a more advanced drawing menu item

2. Drag-and-drop GUI builders (you design the screen, bind to virtual pins)

• Blynk (2.0 / IoT) – widget dashboard, mobile + web, cloud-mandatory (Blynk Legacy was shut down — a well-known longevity cautionary tale).
• RemoteXY – visual editor generates Arduino code; BT/BLE/WiFi/cloud; free tier limits elements.
• Virtuino / Virtuino MQTT – Android SCADA-style panels; local BT/WiFi or MQTT.
• Bluetooth Electronics (keuwlsoft) – Android-only, BT/BLE panel designer.
• Adafruit Bluefruit Connect – fixed BLE UART/control-pad/plotter app.
• ArduinoStudio (arduinostudio.com) – browser, no-code visual sequence/logic editor + drag-and-drop custom UI, Firmata-based. Controls limited to Firmata protocol.

3. Cloud IoT dashboards (account + broker required)

• Arduino IoT Cloud – official, tight IDE integration, subscription tiers.
• Cayenne (myDevices) – drag-and-drop + rules engine, cloud.
• Thinger.io / ThingsBoard / Ubidots – open-source-ish platforms, server hosting.
• MQTT Dash / IoT MQTT Panel – generic MQTT clients, you run the broker.

4. Build-your-own / generic

• MIT App Inventor, Node-RED dashboard, Serial Bluetooth Terminal, Telegram/IFTTT bots.
• Electric UI – open-source (+ paid Pro/Cloud tiers) framework for building a custom desktop control app in React/JS; Electron app runs locally on Windows/Mac/Linux, talks to the device over USB-Serial or BLE using Electric UI's own binary messaging protocol (Arduino-side library provided). You code both the UI and the firmware-side message handling yourself — the device does not define the UI, the opposite of pfodWeb's model.

5. On-device display UI libraries (with optional remote viewing)

• LVGL (Light and Versatile Graphics Library) – open-source embedded graphics library (MIT). Runs on the MCU and drives a TFT/OLED/e-paper panel wired directly to the board. Rich widget set (buttons, sliders, labels, charts, tables, keyboards, arcs), themes, animations, and touchscreen support. UI coded in C/C++ or designed visually in SquareLine Studio (free community edition for non-commercial use; paid plans from ~$5/month). Primary use is a wired display, but three community remote-access paths exist:
  (1) LVGLRemoteServer – open-source UDP Wi-Fi project that captures screenshots and routes touch input so you can view and control the device from a desktop or browser without a physical display;
  (2) Emscripten/WebAssembly – LVGL compiles cleanly for the browser, used mainly for GUI testing and simulation on a desktop;
  (3) Custom WebSocket/VNC servers – LVGL exposes raw pixel data and event APIs, so developers build their own WebSocket or VNC-style servers to push screen updates and route touch events back to the MCU. All three remote approaches are DIY/community, not built-in.

Feature Comparison vs pfodWeb

(i) Note pfodApp implements 128bit auth, pfodWeb implementation to come.

Minimum Board Required

Charting & Data Logging

Only pfodWeb is "yes" across freeze/scroll/zoom and group/separate plots and local CSV logging — the others are cloud-bound, export-limited, or require you to wire/host the logging yourself.

Where pfodWeb Wins

1. Maximum Flexibility. The device's code can modify or replace the UI as it runs. Menus, lists of varying length, interactive elements can be generated on the fly by the code.
Also because the device completely defines the UI — change the Arduino sketch and every client updates automatically. Blynk/RemoteXY/Virtuino force you to maintain a separate dashboard and keep virtual-pin bindings in sync with firmware.
2. No cloud, no account, no vendor lifetime risk. Everything is local request/response. The Blynk Legacy shutdown stranded thousands of projects; pfodWeb projects can't be shut down by a third party.
3. One client, every transport. HTTP, Serial, Bluetooth Classic, BLE and TCP from the same browser page — most competitors are single-transport or cloud-only.
4. Self-contained from the device. The whole UI can live in the device's flash and be served over its own web server — works on an air-gapped network with nothing else installed.
5. Privacy/security by architecture. Optional pfod 128-bit challenge/response auth, and data never traverses a shared cloud.
6. Free, with rich primitives: hierarchical menus, interactive touch drawings, live charts, and CSV raw-data export.
7. No firmware coding required — pfodWeb includes a designer which lets you build menus and sub-menus, connect digital and analog pins, add charts and data logging, then generates a complete, ready-to-compile sketches (currently for Serial connections). The free Android pfodDesigner generates code for Bluetooth, BLE, WiFi and SMS for a wide variety of boards. The same generated code works with both pfodWeb and pfodApp.
8. Interactive touch UIs — Using drawing primitives (rectangles, labels, values) plus touchZones and touchActions you can create interfaces that respond immediately to mouse actions. Once build these controls can be reused, scaled and position to build the UI. See the pfodDwgControls library
9. Built-in real-time charting & data logging — pfodWeb Charting. pfodWeb streams live CSV data straight into an in-browser chart with an adjustable data-point window: plot any number of fields on individual axes or grouped together, on any number of separate plots, with the X-axis taken from any field (or none) and optionally formatted as time (mins:secs) for time-series or XY plots.
   Freeze the chart to stop it scrolling then zoom in — halve/double the displayed points, scroll along the X-axis, set Y min/max — while live data keeps accumulating in the background.
   Export the CSV and reload it into pfodWeb later for review (any CSV loads, not just ones pfodWeb saved), bookmark/save the chart plus connection and formatting config, and switch between multiple data streams — all locally, no cloud, on every transport. No competitor here offers this freeze/scroll/scale/group-and-separate plotting plus local CSV logging without a cloud or extra server.

Trade-offs (vs the cloud platforms)

• No turnkey "control from anywhere." Cloud tools (Blynk, Arduino Cloud) give internet access with a login out of the box; pfodWeb needs you to provide the path to the device (LAN, VPN, port-forward).
• No built-in rules engine / push notifications / fleet management / multi-user dashboards — those are cloud-platform strengths.
• pfodProxy needed for Serial, Bluetooth and Tcp/IP socket connection. HTTP connections work directly from the browser. The advantage of pfodProxy is that any browser since 2017 can be used.
• UI is functional, not a themed drag-and-drop widget gallery. The device defines layout; you trade pixel-level dashboard polish for never having to build or maintain a dashboard.

Bottom Line

Choose pfodWeb when you want a no-install, no-account, locally-controlled, instantly-updatable UI that the device itself defines — ideal for direct local control, privacy-sensitive or air-gapped setups, and avoiding cloud-vendor lock-in/shutdown.
Choose a cloud platform (Blynk / Arduino Cloud / Cayenne) when remote-from-anywhere access, automation rules, push alerts, and managed fleets matter more than locality and self-sufficiency.
RemoteXY/Virtuino/Bluetooth Electronics sit in between — local-capable but you still hand-build and maintain the GUI separately from the firmware.
Electric UI sits at the developer end of that same spectrum — no drag-and-drop, no device-defined UI; you code a custom desktop app (React) and the firmware-side comms yourself, in exchange for full control and built-in real-time plotting.

When to Choose Which for Remote Control and Data Logging

Quick rule of thumb:

• Local, instant, self-defining UI, no infrastructure → pfodWeb.
• You have an older machine/browser → pfodWeb.
• Interactive real-time charting + local CSV logging, no cloud → pfodWeb.
• Remote-from-anywhere + managed cloud features → Blynk / Arduino Cloud.
• Self-hosted home-automation hub already in place → ESPHome + Home Assistant.
• Custom integration/logic layer between hardware and dashboard → Node-RED.
• Cheap local hand-built panel, no cloud → RemoteXY / Virtuino / Bluetooth Electronics.
• Browser no-code: build the logic + a shareable custom panel (Firmata, hosted) → ArduinoStudio.
• Rich GUI on a display physically attached to the device, no phone/browser → LVGL.
• Code your own desktop control app (React) with built-in real-time plotting → Electric UI.

Sources

• RemoteXY – Remote control Arduino
• RemoteXY vs Blynk IoT comparison
• RemoteXY vs Virtuino MQTT comparison
• Blynk – Low-Code IoT Platform
• Free IoT platform comparison: Blynk, Cayenne, ThingsBoard
• Top 10 IoT Dashboards – DIY Usthad
• pfodApp V3 and pfodDevices – Forward Computing
• Arduino for Beginners controlled by pfodApp (no coding)
• pfodDesigner V3 – free Android app, builds menus/charts and generates complete sketches (Google Play)
• pfodWeb Designer – local browser-based GUI builder (Node.js), generates a complete pfod Arduino sketch
• pfodWeb Charting – real-time charting, freeze/scroll/scale, group/separate plots, CSV logging
• Blynk SuperChart widget (cloud charts; raw CSV export needs PLUS/PRO)
• RemoteXY Online Graph (live only, phone-side history, no CSV export)
• Arduino Cloud – export historical data as CSV (emailed link)
• Bluetooth Electronics (keuwlsoft) – rolling graph, no built-in logging
• Home Assistant history CSV export request / HACS History Explorer card
• Cayenne (myDevices) – dashboard line graphs + Download Chart Data (CSV)
• Thinger.io – data buckets, dashboard charts, CSV/JSON/ARFF export
• ArduinoStudio – browser no-code Arduino logic + UI builder (Firmata)
• ArduinoStudio pricing – Freemium / Hobby $9/mo / Pro $19/mo (UI editor is paid)
• LVGL – Light and Versatile Graphics Library (open-source, MIT)
• LVGL documentation – widgets, porting, display drivers
• SquareLine Studio – visual GUI designer for LVGL (free community / paid plans)
• LVGLRemoteServer – open-source UDP Wi-Fi remote view/control for LVGL (screenshot + touch simulation)
• LVGL Emscripten / WebAssembly simulator – run LVGL GUI in a browser
• Electric UI – build a custom React-based desktop control app for hardware