I’ve been working on a new app, and I’d like to share a
little preview here on the blog.
I’ve already posted a couple of photos that show how it works.

As you can see in the screenshots, the Lock/Unlock button lets
you insert URLs that send MQTT commands to your hardware. Once received,
the hardware executes an action — for example, triggering a relay to switch on a lamp.

The app includes three forms:
The first one is for the timer URL. When you press the momentary
button, the link points to a web page designed to send two MQTT
messages: one immediately when the button is pressed, and another
after a delay that you can set directly in the URL. This way,
you can remotely trigger any kind of button.

The other two forms are dedicated to URLs for switching a
relay ON and OFF, controlled by the green and red buttons.

First approach to Quest sensor
for domotic and web 4.0

Experimental page — functional only with Meta Quest 3.

Today I started experimenting with the Meta Quest 3 sensors,
using hand tracking as an interface to control home automation
systems. The idea is to transform natural gestures into intelligent
commands, without the need for physical buttons or switches.
This connects directly to the concept of Web 4.0, where human–machine
interaction becomes increasingly immersive, contextual, and personalized.
It’s no longer just about browsing content, but about merging the physical
and digital worlds in real time, creating experiences where the web reacts
to the body and the environment.
As a next step, I will also try to approach a motor control system,
allowing me to control a walkeremoteboard through gestures. The goal is
to bring the same natural interaction logic into mobile robotics,
combining virtual reality with physical automation.
Stay tuned on this page for upcoming news and developments.

Html Gesture Page



<!DOCTYPE html>
<html>
<head>
  <meta charset="UTF-8">
  <title>Rilevamento Gesti Mani</title>
  <style>
    body {
      background-color: #222;
      color: white;
      text-align: center;
      font-family: Arial;
    }
    canvas {
      position: absolute;
      left: 0;
      top: 0;
      z-index: -1;
    }
    #output {
      margin-top: 480px;
      font-size: 1.5em;
    }
  </style>
</head>
<body>
  <h1>Rilevamento gesti - Mano Destra & Mano Sinistra</h1>
  <video id="video" playsinline style="display:none;"></video>
  <canvas id="outputCanvas" width="640" height="480"></canvas>
  <div id="output"></div>

  <script src="https://cdn.jsdelivr.net/npm/@mediapipe/hands/hands.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/@mediapipe/camera_utils/camera_utils.js"></script>
  <script src="https://cdn.jsdelivr.net/npm/@mediapipe/drawing_utils/drawing_utils.js"></script>

  <script>
    const videoElement = document.getElementById('video');
    const canvasElement = document.getElementById('outputCanvas');
    const canvasCtx = canvasElement.getContext('2d');
    const outputText = document.getElementById('output');

    function getGesture(landmarks) {
      // Controllo semplice: pollice alzato
      const thumbTip = landmarks[4];
      const thumbBase = landmarks[2];
      const indexTip = landmarks[8];

      if (thumbTip.y < thumbBase.y && indexTip.y > thumbBase.y) {
        return "Pugno chiuso,pollice alzato 👍";
        //eventuale funzione da inserire per triggerare un hardware(relay, motori ec..)
      } else {
        return "mano aperta ✊";
        //eventuale funzione da inserire per triggerare un hardware(relay, motori ec..)

      }
    }

    function onResults(results) {
      canvasCtx.save();
      canvasCtx.clearRect(0, 0, canvasElement.width, canvasElement.height);
      canvasCtx.drawImage(results.image, 0, 0, canvasElement.width, canvasElement.height);

      let textOutput = "";

      if (results.multiHandLandmarks && results.multiHandedness) {
        for (let i = 0; i < results.multiHandLandmarks.length; i++) {
          const landmarks = results.multiHandLandmarks[i];
          const handLabel = results.multiHandedness[i].label; // "Left" o "Right"

          window.drawConnectors(canvasCtx, landmarks, window.HAND_CONNECTIONS,
            {color: '#00FF00', lineWidth: 2});
          window.drawLandmarks(canvasCtx, landmarks, {color: '#FF0000', lineWidth: 1});

          const gesture = getGesture(landmarks);
          textOutput += `${handLabel === "Left" ? "Mano Sinistra" : "Mano Destra"}: ${gesture}<br>`;
        }
      }

      outputText.innerHTML = textOutput;
      canvasCtx.restore();
    }

    const hands = new Hands({
      locateFile: (file) => {
        return `https://cdn.jsdelivr.net/npm/@mediapipe/hands/${file}`;
      }
    });

    hands.setOptions({
      maxNumHands: 2,
      modelComplexity: 1,
      minDetectionConfidence: 0.7,
      minTrackingConfidence: 0.5
    });

    hands.onResults(onResults);

    const camera = new Camera(videoElement, {
      onFrame: async () => {
        await hands.send({image: videoElement});
      },
      width: 640,
      height: 480
    });
    camera.start();
  </script>
</body>
</html>

Published by Michele Tavolacci on 09 August , 2025

Smart Home Relay Board from AliExpress

In this tutorial, we’ll take a look at a generic smart home relay board commonly
found on platforms like AliExpress. These boards are quite versatile, easy to program,
and can be integrated with platforms like Walkeremote for remote control and automation.

Overview of the Board

The board featured in this tutorial was purchased from AliExpress: in this Link It includes: Include WiFi (ESP8266)
4 relays, each controllable individually
Multiple power input options:
220V AC, 7–30V DC, 5V DC
Programming pinouts, compatible with FTDI adapters

Extra GPIOs, which can be used to control motors, sensors, or other peripherals
This makes it a great option for DIY home automation projects.

Programming the Board

The ESP8266 onboard makes it very easy to program this board using the Arduino IDE.
In this example,(video link and code Below) I’ve uploaded a
generic sketch that connects the board to
the Walkeremote platform, allowing for MQTT-based remote control via topics and
commands configured in the code.

Integration with Walkeremote platform

To control this board via the Walkeremote platform, simply flash
the provided code with your specific MQTT credentials (topics, command structure, etc.).
Once set up, you can easily control each relay remotely from any device connected to Walkeremote.

Resources

Youtube video demostration

Published by Michele Tavolacci on 27 july 2025

arduino sketch:


#include <ESP8266WiFi.h>
#include <PubSubClient.h>

// WiFi credentials
const char* ssid = "yourSidWiFi";
const char* password = "yourPasswordWiFi";

// MQTT broker
const char* mqtt_server = "brokerMqttLink";
const int mqtt_port = 1883; 
const char* mqtt_topic = "6653580bcf77af044070a45c"; //topic  from Demo page of walkeremote portal
const char* client_id = "mqttx_fa91203b";

// Mapping dei pin logici
const int pinD7 = 13;
const int pinD6 = 12;
const int pinD5 = 14;
const int pinD4 = 2;     // LED integrato
const int pinD1 = 5;
const int pinD0 = 16;

WiFiClient espClient;
PubSubClient client(espClient);

// Funzione per impostare i pin di controllo
void setup_pins() {
  digitalWrite(pinD1, HIGH);
  pinMode(pinD1 , OUTPUT);
  int pins[] = {pinD7, pinD6, pinD5, pinD0};
  for (int i = 0; i < 4; i++) {
    
        pinMode(pins[i], OUTPUT);       // Poi configura come output
     
    digitalWrite(pins[i], LOW);     // Imposta prima lo stato

  }
 
}

// Accende/spegne un pin in base al nome ricevuto
void handleCommand(String msg) {
  msg.trim();

  if (msg.endsWith("665357ec0c4b136d3773e5ca")) {
    if (msg == "4350665357ec0c4b136d3773e5ca") digitalWrite(pinD7, HIGH); //command copied from from walkeremote Demo account
    else if (msg == "5888665357ec0c4b136d3773e5ca") digitalWrite(pinD6, HIGH);
    else if (msg == "3395665357ec0c4b136d3773e5ca") digitalWrite(pinD5, HIGH);
    else if (msg == "3305665357ec0c4b136d3773e5ca") digitalWrite(pinD0, HIGH);
    //else if (msg == "onall") digitalWrite(pinD0+pinD5+pinD6pinD7, HIGH);
    //else if (msg == "onall") {
  //for (int i = 0; i < 4; i++) {
  //  digitalWrite(pins[i], HIGH);
  //}
//}
   else if (msg == "3311665357ec0c4b136d3773e5ca") digitalWrite(pinD7, LOW);
    else if (msg == "8380665357ec0c4b136d3773e5ca") digitalWrite(pinD6, LOW);
    else if (msg == "9983665357ec0c4b136d3773e5ca") digitalWrite(pinD5, LOW);
    else if (msg == "9903665357ec0c4b136d3773e5ca") digitalWrite(pinD0, LOW);
    // else if (msg == "offall") {
  //for (int i = 0; i < 4; i++) {
    //digitalWrite(pins[i], LOW);
  //}
  //}
  }
  Serial.print("Eseguito comando: ");
  Serial.println(msg);
}

void callback(char* topic, byte* payload, unsigned int length) {
  String msg;
  for (unsigned int i = 0; i < length; i++) {
    msg += (char)payload[i];
  }

  Serial.print("Messaggio ricevuto [");
  Serial.print(topic);
  Serial.print("]: ");
  Serial.println(msg);

  handleCommand(msg);
}

void setup_wifi() {
  delay(10);
  Serial.println();
  Serial.print("Connettendo al WiFi: ");
  Serial.println(ssid);

  WiFi.begin(ssid, password);
  int tentativi = 0;

  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
    tentativi++;
    if (tentativi > 30) {
      Serial.println("Errore WiFi. Riavvio...");
      ESP.restart();
    }
  }

  Serial.println("\nWiFi connesso. IP: " + WiFi.localIP().toString());
}

void reconnect() {
  while (!client.connected()) {
    Serial.print("Connessione al broker MQTT... ");
    if (client.connect(client_id)) {
      Serial.println("Connesso!");
      client.subscribe(mqtt_topic);
      Serial.println("Sottoscritto a: " + String(mqtt_topic));

      digitalWrite(pinD1, LOW);  // LED ON
    } else {
      Serial.print("Fallito, rc=");
      Serial.print(client.state());
      Serial.println(". Ritento in 5 secondi.");
     digitalWrite(pinD1, HIGH); // LED OFF
      delay(5000);
    }
  }
}

void setup() {
  Serial.begin(115200);
  setup_pins();
  setup_wifi();
  client.setServer(mqtt_server, mqtt_port);
  client.setCallback(callback);
}

void loop() {
  if (!client.connected()) {
    reconnect();
  }
  client.loop();
}

Published by Michele Tavolacci on 27 July , 2025

New Walkeremoteboard-mcp001-rev1

Easy to use yet offering advanced control capabilities, the Walkeremoteboard-mcp001-rev1 is designed to
effortlessly manage Relay, Stepper, Brushless, and wheel motors, accommodating voltages from 5V to 27V
with appropriate bridges. The onboard L293D driver facilitates direct usage of wheel motors,
while an integrated relay allows for convenient control of headlights.
With 10 auxiliary pinouts, users can activate additional functionalities via auxiliary controls,
already available in their own pilot station accessible on our website. Additionally, accessing your
pilot station is as simple as scanning the QR code on the board to obtain the email and password for login.

Moreover, with the new firmware, the board ensures it never loses internet connection. In the event of
disconnection while in operation, the motors will rotate in reverse for 20 seconds, allowing the board to
reconnect within the WiFi coverage area. Additionally, it's worth noting that
The Walkeremoteboard has been enhanced with the latest firmware,
which can be conveniently installed directly from the dedicated command page.
By clicking the OTA UPGRADE button, the button will flash for a few seconds,
and the Walkeremoteboard will have the multicolor LED turned off and the blue LED of
the microcontroller turned on. Once the OTA update operation is completed, the button on the
command page will stop flashing, displaying a green color with the "successfull" message.
The blue LED on the board will turn off, while the multicolor LED indicating the
connection to the server will be lit.

For first wifi setting connection CLICK HERE for Youtube tutorial

Published by Michele Tavolacci on 1 Agosto, 2024

Last Upgrade

Added the ability to monitor the battery status powering the walkeremoteboard through the
percentage displayed on the command page. An email will be sent from the board notifying the
user that the battery has reached a minimum threshold and needs back to the docking station
to recharge.