Standalone Setup (Without Home Assistant)

Complete guide for using Wala Works devices without Home Assistant. Control your devices through web interface, HTTP API, MQTT, or integrate with custom applications.

Why Use Standalone Mode?

Not everyone needs a full home automation platform. Standalone mode is perfect for:

Simple Setups - Control 1-2 devices without complexity
Custom Applications - Build your own control software
Embedded Systems - Integrate with Raspberry Pi, Arduino, PLC
Testing and Development - Prototype automation ideas
Learning - Understand device operation before full integration
Minimal Infrastructure - No server required, just WiFi

What You Get

Built-in Features

Web Interface - Control via any browser
HTTP REST API - Integrate with any programming language
MQTT Client - Publish/subscribe messaging (optional)
WebSocket - Real-time updates
mDNS Discovery - Find devices by name (motorwala.local)
OTA Updates - Update firmware over WiFi
Status LEDs - Visual feedback on device state

What You Don't Need

❌ Home Assistant server
❌ Subscription services
❌ Cloud accounts
❌ Complex configuration
❌ Additional hardware (except optional MQTT broker)

Quick Start (5 Minutes)

Step 1: Connect Device to WiFi

Power on device - LED will blink rapidly (setup mode)
Connect to device WiFi:
- Network name: MotorWala-XXXX or RelayWala-XXXX
- Password: setup12345 (default fallback AP)
Configure network:
- Browser auto-opens to http://192.168.4.1
- Select your WiFi network
- Enter password
- Optional: Set device name
- Click "Connect"
Wait for connection:
- Device joins your network (10-30 seconds)
- LED changes to solid (connected)
Find device IP:
- Check router DHCP leases
- Or use mDNS: http://motorwala.local
- Or use network scanner: nmap -sn 192.168.1.0/24

Step 2: Access Web Interface

Open browser and navigate to:

http://[DEVICE-IP]

Or using mDNS:

http://motorwala.local
http://relaywala.local

You'll see the device control panel - ready to use!

Web Interface

MotorWala Web Interface

The built-in web interface provides complete motor control:

┌─────────────────────────────────────────┐
│  MotorWala - Living Room Blinds         │
├─────────────────────────────────────────┤
│                                         │
│  Status: Idle                           │
│  Position: 50%                          │
│  Current: 0.5 A                         │
│                                         │
│  ┌─────────────────────────────────┐   │
│  │  [────●──────────────]          │   │
│  │       Position Slider            │   │
│  └─────────────────────────────────┘   │
│                                         │
│  [  Open  ]  [  Stop  ]  [  Close  ]   │
│                                         │
│  ┌───────────────────────────────┐     │
│  │ Quick Actions:                │     │
│  │ [ 0% ]  [ 25% ]  [ 50% ]      │     │
│  │ [ 75% ]  [ 100% ]             │     │
│  └───────────────────────────────┘     │
│                                         │
│  Limit Switches:                        │
│  Upper: ○ Not pressed                   │
│  Lower: ○ Not pressed                   │
│                                         │
│  [ Calibrate ]  [ Settings ]            │
└─────────────────────────────────────────┘

Features:

Position Slider - Drag to set precise position (0-100%)
Open/Close/Stop - Direct motor control
Quick Actions - Jump to common positions
Real-time Status - Live position and current display
Calibration - Automatic travel time measurement
Settings - Configure device parameters

RelayWala Web Interface

Control individual relays through web UI:

┌─────────────────────────────────────────┐
│  RelayWala - Living Room Controls       │
├─────────────────────────────────────────┤
│                                         │
│  Relay 1: Living Room Light             │
│  Status: ● ON                           │
│  [  Turn Off  ]                         │
│  ────────────────────────────────────   │
│                                         │
│  Relay 2: Kitchen Fan                   │
│  Status: ○ OFF                          │
│  [  Turn On  ]                          │
│  ────────────────────────────────────   │
│                                         │
│  Relay 3: Garage Door                   │
│  Status: ○ OFF (Momentary)              │
│  [  Trigger  ]                          │
│  ────────────────────────────────────   │
│                                         │
│  Relay 4: Water Pump                    │
│  Status: ○ OFF (Auto-off: 5min)         │
│  [  Turn On  ]                          │
│  ────────────────────────────────────   │
│                                         │
│  [EMERGENCY STOP]                       │
│                                         │
│  [ Settings ]  [ Schedule ]             │
└─────────────────────────────────────────┘

Features:

Individual Control - Toggle each relay independently
Status Indicators - Real-time ON/OFF state
Custom Labels - Name each relay for your setup
Emergency Stop - Turn off all relays instantly
Scheduling - Set timers and schedules (built-in)
Auto-off Timers - Relays auto-turn-off after delay

Settings Page

Configure device parameters:

Network Settings

Device Name: living-room-blinds
Hostname: motorwala.local

Network Configuration:
  Mode: DHCP (Automatic)
  # Or Static:
  IP Address: 192.168.1.100
  Subnet: 255.255.255.0
  Gateway: 192.168.1.1
  DNS: 8.8.8.8

WiFi:
  Connected to: HomeNetwork
  Signal: -45 dBm (Excellent)
  IP: 192.168.1.100
  MAC: AA:BB:CC:DD:EE:FF

Security Settings

Web Authentication:
  Enabled: No (Change recommended!)
  Username: admin
  Password: ****************

API Access:
  Token Authentication: Disabled
  Generate Token: [Generate]

HTTPS:
  Enabled: No (requires certificate)

⚠️ Security Recommendation: Enable web authentication if device accessible outside local network!

MotorWala Specific Settings

Motor Configuration:
  Type: Tubular Motor
  Voltage: 12V DC
  Speed: 50 (Range: 10-100)
  Direction: Normal / Reversed

Position Tracking:
  Full Travel Time: 30 seconds
  Calibration: Complete
  Current Position: 50%

Safety:
  Overcurrent Limit: 2.5 A
  Auto-stop on Limit: Enabled
  Timeout: 60 seconds

Behavior:
  Power-on Position: Last position
  Default Speed: 50%

RelayWala Specific Settings

Configure each relay individually:

Relay 1:
  Name: Living Room Light
  Icon: lightbulb
  Mode: Normal (stays on/off)
  Power-on State: Off
  Interlock: None

Relay 2:
  Name: Kitchen Fan
  Icon: fan
  Mode: Normal
  Power-on State: Restore last state
  Interlock: None

Relay 3:
  Name: Garage Door Open
  Icon: garage-open
  Mode: Momentary (1 second pulse)
  Power-on State: Off
  Interlock: Relay 4

Relay 4:
  Name: Garage Door Close
  Icon: garage
  Mode: Momentary (1 second pulse)
  Power-on State: Off
  Interlock: Relay 3

Mode Options:

Normal - Toggle on/off, stays in state
Momentary - Turns on briefly then off (for buttons/triggers)
Timed - Turns on for specified duration then off
Interlock - Cannot be on when specified relay is on

HTTP REST API

Control devices programmatically using HTTP requests.

API Endpoints

MotorWala API

Base URL: http://[DEVICE-IP]/api

Get Status

GET /api/status

Response:
{
  "device": "motorwala",
  "name": "Living Room Blinds",
  "version": "1.0.0",
  "uptime": 3600,
  "position": 50,
  "state": "idle",
  "current": 0.0,
  "limit_upper": false,
  "limit_lower": false
}

Control Motor

# Open blinds
POST /api/motor/open

# Close blinds
POST /api/motor/close

# Stop motor
POST /api/motor/stop

Set Position

POST /api/motor/position
Content-Type: application/json

{
  "position": 75
}

Response:
{
  "success": true,
  "target_position": 75,
  "current_position": 50,
  "estimated_time": 7.5
}

Get Motor Info

GET /api/motor/info

Response:
{
  "type": "tubular",
  "voltage": 12,
  "speed": 50,
  "travel_time": 30,
  "calibrated": true,
  "current_ma": 500,
  "max_current_ma": 2500
}

RelayWala API

Base URL: http://[DEVICE-IP]/api

Get Status

GET /api/status

Response:
{
  "device": "relaywala",
  "name": "Living Room Relays",
  "version": "1.0.0",
  "uptime": 7200,
  "relays": [
    {
      "id": 1,
      "name": "Living Room Light",
      "state": true,
      "mode": "normal"
    },
    {
      "id": 2,
      "name": "Kitchen Fan",
      "state": false,
      "mode": "normal"
    },
    {
      "id": 3,
      "name": "Garage Door",
      "state": false,
      "mode": "momentary"
    },
    {
      "id": 4,
      "name": "Water Pump",
      "state": false,
      "mode": "timed"
    }
  ]
}

Control Relay

# Turn relay on
POST /api/relay/1/on

# Turn relay off
POST /api/relay/1/off

# Toggle relay
POST /api/relay/1/toggle

Response:
{
  "success": true,
  "relay": 1,
  "state": true
}

Control Multiple Relays

POST /api/relays/set
Content-Type: application/json

{
  "relays": {
    "1": true,
    "2": false,
    "3": false,
    "4": true
  }
}

Emergency Stop

POST /api/emergency_stop

# Turns off all relays immediately

Response:
{
  "success": true,
  "relays_stopped": [1, 2, 3, 4]
}

Code Examples

Python

import requests

# Configuration
DEVICE_IP = "192.168.1.100"
BASE_URL = f"http://{DEVICE_IP}/api"

# Example 1: Control MotorWala
def open_blinds():
    response = requests.post(f"{BASE_URL}/motor/open")
    return response.json()

def set_position(position):
    """Set blinds position (0-100)"""
    data = {"position": position}
    response = requests.post(
        f"{BASE_URL}/motor/position",
        json=data
    )
    return response.json()

def get_status():
    response = requests.get(f"{BASE_URL}/status")
    return response.json()

# Example 2: Control RelayWala
def turn_on_relay(relay_id):
    response = requests.post(f"{BASE_URL}/relay/{relay_id}/on")
    return response.json()

def turn_off_relay(relay_id):
    response = requests.post(f"{BASE_URL}/relay/{relay_id}/off")
    return response.json()

def toggle_relay(relay_id):
    response = requests.post(f"{BASE_URL}/relay/{relay_id}/toggle")
    return response.json()

# Usage
if __name__ == "__main__":
    # Open blinds
    result = open_blinds()
    print(f"Opening blinds: {result}")

    # Wait for completion...
    import time
    time.sleep(30)

    # Set to 50%
    result = set_position(50)
    print(f"Setting position: {result}")

    # Turn on light
    result = turn_on_relay(1)
    print(f"Light: {result}")

JavaScript (Node.js)

const axios = require('axios');

const DEVICE_IP = '192.168.1.100';
const BASE_URL = `http://${DEVICE_IP}/api`;

// MotorWala control
async function openBlinds() {
  const response = await axios.post(`${BASE_URL}/motor/open`);
  return response.data;
}

async function setPosition(position) {
  const response = await axios.post(
    `${BASE_URL}/motor/position`,
    { position }
  );
  return response.data;
}

async function getStatus() {
  const response = await axios.get(`${BASE_URL}/status`);
  return response.data;
}

// RelayWala control
async function controlRelay(relayId, action) {
  const response = await axios.post(
    `${BASE_URL}/relay/${relayId}/${action}`
  );
  return response.data;
}

// Usage
async function main() {
  try {
    // Open blinds
    const result1 = await openBlinds();
    console.log('Opening blinds:', result1);

    // Wait 30 seconds
    await new Promise(resolve => setTimeout(resolve, 30000));

    // Set to 50%
    const result2 = await setPosition(50);
    console.log('Setting position:', result2);

    // Turn on relay 1
    const result3 = await controlRelay(1, 'on');
    console.log('Relay 1:', result3);
  } catch (error) {
    console.error('Error:', error.message);
  }
}

main();

Bash/cURL

#!/bin/bash

DEVICE_IP="192.168.1.100"
BASE_URL="http://${DEVICE_IP}/api"

# MotorWala functions
open_blinds() {
  curl -X POST "${BASE_URL}/motor/open"
}

close_blinds() {
  curl -X POST "${BASE_URL}/motor/close"
}

set_position() {
  local position=$1
  curl -X POST "${BASE_URL}/motor/position" \
    -H "Content-Type: application/json" \
    -d "{\"position\": ${position}}"
}

# RelayWala functions
turn_on_relay() {
  local relay_id=$1
  curl -X POST "${BASE_URL}/relay/${relay_id}/on"
}

turn_off_relay() {
  local relay_id=$1
  curl -X POST "${BASE_URL}/relay/${relay_id}/off"
}

# Usage
open_blinds
sleep 30
set_position 50
turn_on_relay 1

Arduino/ESP32

#include <WiFi.h>
#include <HTTPClient.h>

const char* ssid = "YourWiFi";
const char* password = "YourPassword";
const char* deviceIP = "192.168.1.100";

void setup() {
  Serial.begin(115200);

  // Connect to WiFi
  WiFi.begin(ssid, password);
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("Connected!");

  // Control MotorWala
  openBlinds();
  delay(30000);
  setBlindsPosition(50);

  // Control RelayWala
  turnOnRelay(1);
}

void openBlinds() {
  HTTPClient http;
  String url = String("http://") + deviceIP + "/api/motor/open";

  http.begin(url);
  int httpCode = http.POST("");

  if (httpCode == 200) {
    String response = http.getString();
    Serial.println("Blinds opening: " + response);
  }
  http.end();
}

void setBlindsPosition(int position) {
  HTTPClient http;
  String url = String("http://") + deviceIP + "/api/motor/position";
  String payload = "{\"position\": " + String(position) + "}";

  http.begin(url);
  http.addHeader("Content-Type", "application/json");
  int httpCode = http.POST(payload);

  if (httpCode == 200) {
    Serial.println("Position set to " + String(position));
  }
  http.end();
}

void turnOnRelay(int relayId) {
  HTTPClient http;
  String url = String("http://") + deviceIP + "/api/relay/" +
               String(relayId) + "/on";

  http.begin(url);
  int httpCode = http.POST("");

  if (httpCode == 200) {
    Serial.println("Relay " + String(relayId) + " turned on");
  }
  http.end();
}

void loop() {
  // Your code here
}

MQTT Integration

For advanced integrations, use MQTT for pub/sub messaging.

Setup MQTT Broker

Option 1: Mosquitto on Raspberry Pi

# Install Mosquitto
sudo apt-get update
sudo apt-get install mosquitto mosquitto-clients

# Create password file
sudo mosquitto_passwd -c /etc/mosquitto/passwd mqtt-user

# Configure
sudo nano /etc/mosquitto/mosquitto.conf

Add to config:

listener 1883
allow_anonymous false
password_file /etc/mosquitto/passwd
persistence true
persistence_location /var/lib/mosquitto/
log_dest file /var/log/mosquitto/mosquitto.log

Start broker:

sudo systemctl start mosquitto
sudo systemctl enable mosquitto

Option 2: Cloud MQTT Broker

Use hosted broker (e.g., CloudMQTT, HiveMQ):

Sign up for free tier
Note broker URL, port, credentials
Use in device configuration

Configure Device MQTT

In device settings web interface:

MQTT Configuration:
  Enabled: Yes
  Broker: 192.168.1.50
  Port: 1883
  Username: mqtt-user
  Password: your-password
  Client ID: motorwala-living-room

Topics:
  Command: motorwala/living-room/command
  State: motorwala/living-room/state
  Position: motorwala/living-room/position

Connection:
  Keep Alive: 60 seconds
  QoS: 1
  Retain: Yes

MQTT Topics

MotorWala Topics

Command Topic: motorwala/[device-name]/command

# Open
mosquitto_pub -h 192.168.1.50 -u mqtt-user -P password \
  -t "motorwala/living-room/command" -m "OPEN"

# Close
mosquitto_pub -h 192.168.1.50 -u mqtt-user -P password \
  -t "motorwala/living-room/command" -m "CLOSE"

# Stop
mosquitto_pub -h 192.168.1.50 -u mqtt-user -P password \
  -t "motorwala/living-room/command" -m "STOP"

Position Topic: motorwala/[device-name]/set_position

# Set to 75%
mosquitto_pub -h 192.168.1.50 -u mqtt-user -P password \
  -t "motorwala/living-room/set_position" -m "75"

State Topic: motorwala/[device-name]/state

# Subscribe to state updates
mosquitto_sub -h 192.168.1.50 -u mqtt-user -P password \
  -t "motorwala/living-room/state"

# Output: OPEN, CLOSED, MOVING, IDLE

Position Feedback: motorwala/[device-name]/position

# Subscribe to position updates
mosquitto_sub -h 192.168.1.50 -u mqtt-user -P password \
  -t "motorwala/living-room/position"

# Output: 0-100 (percentage)

RelayWala Topics

Command Topic: relaywala/[device-name]/relay/[1-4]/set

# Turn on relay 1
mosquitto_pub -h 192.168.1.50 -u mqtt-user -P password \
  -t "relaywala/living-room/relay/1/set" -m "ON"

# Turn off relay 1
mosquitto_pub -h 192.168.1.50 -u mqtt-user -P password \
  -t "relaywala/living-room/relay/1/set" -m "OFF"

# Toggle relay 2
mosquitto_pub -h 192.168.1.50 -u mqtt-user -P password \
  -t "relaywala/living-room/relay/2/set" -m "TOGGLE"

State Topic: relaywala/[device-name]/relay/[1-4]/state

# Subscribe to relay 1 state
mosquitto_sub -h 192.168.1.50 -u mqtt-user -P password \
  -t "relaywala/living-room/relay/1/state"

# Output: ON or OFF

All Relays: relaywala/[device-name]/all

# Turn off all relays
mosquitto_pub -h 192.168.1.50 -u mqtt-user -P password \
  -t "relaywala/living-room/all" -m "OFF"

MQTT Code Examples

Python with paho-mqtt

import paho.mqtt.client as mqtt
import time

BROKER = "192.168.1.50"
PORT = 1883
USERNAME = "mqtt-user"
PASSWORD = "your-password"

# Callbacks
def on_connect(client, userdata, flags, rc):
    print(f"Connected with result code {rc}")
    # Subscribe to state topics
    client.subscribe("motorwala/living-room/position")
    client.subscribe("relaywala/living-room/relay/+/state")

def on_message(client, userdata, msg):
    print(f"{msg.topic}: {msg.payload.decode()}")

# Create client
client = mqtt.Client()
client.username_pw_set(USERNAME, PASSWORD)
client.on_connect = on_connect
client.on_message = on_message

# Connect
client.connect(BROKER, PORT, 60)
client.loop_start()

# Control devices
def open_blinds():
    client.publish("motorwala/living-room/command", "OPEN")

def set_blinds_position(position):
    client.publish("motorwala/living-room/set_position", str(position))

def turn_on_relay(relay_id):
    client.publish(f"relaywala/living-room/relay/{relay_id}/set", "ON")

def turn_off_relay(relay_id):
    client.publish(f"relaywala/living-room/relay/{relay_id}/set", "OFF")

# Example usage
open_blinds()
time.sleep(30)
set_blinds_position(50)
turn_on_relay(1)

# Keep running
while True:
    time.sleep(1)

Node.js with mqtt.js

const mqtt = require('mqtt');

const client = mqtt.connect('mqtt://192.168.1.50', {
  username: 'mqtt-user',
  password: 'your-password'
});

client.on('connect', () => {
  console.log('Connected to MQTT broker');

  // Subscribe to topics
  client.subscribe('motorwala/living-room/position');
  client.subscribe('relaywala/living-room/relay/+/state');
});

client.on('message', (topic, message) => {
  console.log(`${topic}: ${message.toString()}`);
});

// Control functions
function openBlinds() {
  client.publish('motorwala/living-room/command', 'OPEN');
}

function setBlindsPosition(position) {
  client.publish('motorwala/living-room/set_position', position.toString());
}

function controlRelay(relayId, state) {
  client.publish(
    `relaywala/living-room/relay/${relayId}/set`,
    state ? 'ON' : 'OFF'
  );
}

// Example usage
openBlinds();
setTimeout(() => setBlindsPosition(50), 30000);
setTimeout(() => controlRelay(1, true), 35000);

Scheduling and Automation

Built-in Scheduler

Devices include basic scheduling features:

Access Scheduler

Web interface → Settings → Schedule

Create Schedule

Example: Close blinds at sunset

Schedule 1:
  Name: Close at Sunset
  Type: Time-based
  Time: 18:30
  Days: Monday-Friday
  Action: Close blinds
  Enabled: Yes

Example: Turn off pump after 5 minutes

Schedule 2:
  Name: Pump Auto-off
  Type: Duration-based
  Trigger: When relay 4 turns on
  Duration: 5 minutes
  Action: Turn off relay 4
  Enabled: Yes

External Automation

Using Cron Jobs

Run HTTP API calls on schedule:

# Edit crontab
crontab -e

# Add schedules
# Close blinds at 6:30 PM every day
30 18 * * * curl -X POST http://192.168.1.100/api/motor/close

# Open blinds at 7:00 AM on weekdays
0 7 * * 1-5 curl -X POST http://192.168.1.100/api/motor/open

# Turn off relay 1 at midnight
0 0 * * * curl -X POST http://192.168.1.100/api/relay/1/off

Using Python Script

import schedule
import requests
import time

DEVICE_IP = "192.168.1.100"

def open_blinds():
    requests.post(f"http://{DEVICE_IP}/api/motor/open")
    print("Blinds opened")

def close_blinds():
    requests.post(f"http://{DEVICE_IP}/api/motor/close")
    print("Blinds closed")

def turn_off_lights():
    requests.post(f"http://{DEVICE_IP}/api/relay/1/off")
    print("Lights turned off")

# Schedule tasks
schedule.every().monday.at("07:00").do(open_blinds)
schedule.every().day.at("18:30").do(close_blinds)
schedule.every().day.at("23:00").do(turn_off_lights)

# Run scheduler
while True:
    schedule.run_pending()
    time.sleep(60)

Using Node-RED

Install Node-RED:
```
npm install -g node-red
node-red
```
Access: http://localhost:1880

Create Flow:

[Inject: Daily at 7 AM] → [HTTP Request: Open blinds]
[Inject: Daily at 6:30 PM] → [HTTP Request: Close blinds]

HTTP Request Node Config:

Method: POST
URL: http://192.168.1.100/api/motor/open

Advanced Use Cases

Integration with Raspberry Pi

Use Raspberry Pi as controller:

#!/usr/bin/env python3
"""
Smart Blinds Controller with Light Sensor
Opens/closes blinds based on ambient light
"""
import requests
import time
import board
import adafruit_tsl2591

# Configuration
MOTORWALA_IP = "192.168.1.100"
LIGHT_THRESHOLD = 50  # lux
CHECK_INTERVAL = 60  # seconds

# Initialize light sensor
i2c = board.I2C()
sensor = adafruit_tsl2591.TSL2591(i2c)

def get_light_level():
    lux = sensor.lux
    return lux

def open_blinds():
    url = f"http://{MOTORWALA_IP}/api/motor/open"
    requests.post(url)
    print("Blinds opened (bright outside)")

def close_blinds():
    url = f"http://{MOTORWALA_IP}/api/motor/close"
    requests.post(url)
    print("Blinds closed (dark outside)")

# Main loop
current_state = None

while True:
    light = get_light_level()
    print(f"Light level: {light:.2f} lux")

    if light > LIGHT_THRESHOLD and current_state != "open":
        open_blinds()
        current_state = "open"
    elif light < LIGHT_THRESHOLD and current_state != "closed":
        close_blinds()
        current_state = "closed"

    time.sleep(CHECK_INTERVAL)

Voice Control with Google Assistant (via IFTTT)

Create IFTTT account: https://ifttt.com
Create Applet:
- If This: Google Assistant
  - Phrase: "Close the living room blinds"
- Then That: Webhooks
  - URL: http://[YOUR-PUBLIC-IP]/api/motor/close
  - Method: POST

Setup Port Forwarding (or use ngrok for testing):

# Using ngrok for testing
ngrok http 192.168.1.100:80
# Use ngrok URL in IFTTT webhook

Mobile App Integration

Shortcuts (iOS)

Open Shortcuts app
Create new shortcut: "Close Blinds"
Add action: "Get contents of URL"
- URL: http://192.168.1.100/api/motor/close
- Method: POST
Add to Home Screen

Tasker (Android)

Install Tasker
Create Task: "Close Blinds"
Add Action: Net → HTTP Post
- Server:Port: 192.168.1.100:80
- Path: /api/motor/close
Create Widget for home screen

Troubleshooting

Can't Access Web Interface

Check network connection:

# Ping device
ping 192.168.1.100
ping motorwala.local

# Check if web server running
curl -I http://192.168.1.100

Solutions:

Verify device powered on (LED solid)
Confirm device on same network
Check firewall not blocking port 80
Try IP address instead of mDNS name
Factory reset if persistent issues

API Returns Errors

Common HTTP error codes:

400 Bad Request - Invalid JSON or parameters
401 Unauthorized - Authentication required
404 Not Found - Endpoint doesn't exist
500 Internal Server Error - Device error

Debug with verbose curl:

curl -v -X POST http://192.168.1.100/api/motor/open

MQTT Not Connecting

Test broker connection:

# Test from device network
mosquitto_sub -h 192.168.1.50 -p 1883 \
  -u mqtt-user -P password -t test

# In another terminal
mosquitto_pub -h 192.168.1.50 -p 1883 \
  -u mqtt-user -P password -t test -m "hello"

Solutions:

Verify broker IP and port correct
Check username/password
Ensure firewall allows port 1883
Check broker logs: sudo tail -f /var/log/mosquitto/mosquitto.log
Try without authentication first

Device Unresponsive

Check power supply - Adequate voltage and current
Reboot device - Power cycle or via web interface
Check WiFi - Signal strength adequate
View logs - Settings → System → Logs
Factory reset - Hold reset button 30 seconds

Security Best Practices

Network Security

Use VLAN - Isolate IoT devices
Firewall rules - Limit access to device ports
No port forwarding - Don't expose directly to internet
VPN for remote access - Use WireGuard or similar

Device Security

Enable authentication - Settings → Security
Change default passwords - Don't use "admin/admin"
Update firmware regularly - Check for updates monthly
Use HTTPS - If accessing outside local network
Strong WiFi password - WPA3 if available

API Security

# Enable token authentication
API Settings:
  Token Auth: Enabled
  Token: ww_abc123def456ghi789

# Use in requests
curl -H "Authorization: Bearer ww_abc123def456ghi789" \
  http://192.168.1.100/api/status

Next Steps

Configuration Guide - Advanced settings
API Reference - Complete API documentation
Tutorials - Practical examples
FAQ - Common questions

Need help? Visit our support page or check the documentation

Standalone Setup (Without Home Assistant)

Why Use Standalone Mode?

What You Get

Built-in Features

What You Don't Need

Quick Start (5 Minutes)

Step 1: Connect Device to WiFi

Step 2: Access Web Interface

Web Interface

MotorWala Web Interface

RelayWala Web Interface

Settings Page

Network Settings

Security Settings

MotorWala Specific Settings

RelayWala Specific Settings

HTTP REST API

API Endpoints

MotorWala API

Get Status

Control Motor

Set Position

Get Motor Info

RelayWala API

Get Status

Control Relay

Control Multiple Relays

Emergency Stop

Code Examples

Python

JavaScript (Node.js)

Bash/cURL

Arduino/ESP32

MQTT Integration

Setup MQTT Broker

Option 1: Mosquitto on Raspberry Pi

Option 2: Cloud MQTT Broker

Configure Device MQTT

MQTT Topics

MotorWala Topics

RelayWala Topics

MQTT Code Examples

Python with paho-mqtt

Node.js with mqtt.js

Scheduling and Automation

Built-in Scheduler

Access Scheduler

Create Schedule

External Automation

Using Cron Jobs

Using Python Script

Using Node-RED

Advanced Use Cases

Integration with Raspberry Pi

Voice Control with Google Assistant (via IFTTT)

Mobile App Integration

Shortcuts (iOS)

Tasker (Android)

Troubleshooting

Can't Access Web Interface

API Returns Errors

MQTT Not Connecting

Device Unresponsive

Security Best Practices

Network Security

Device Security

API Security

Next Steps

On This Page