Note:
if you want to control a single ESP32 robot/gadget, use this guide instead: https://www.robot-ma...ample/?p=111377
if you want to control multiple ESP32 robots/gadgets, continue.
This code allows control of multiple ESP32 robots or gadgets over WLAN using vigibot.
A raspberry is still required for the camera and needs to be on the same network. the serial data usually sent and received to an Arduino over UART ( https://www.robot-ma...cation-example/ ), is being sent over WLAN instead, allowing control of small robots or gadgets.
usage example: a pi with a camera watches an arena where multiple small ESP32 robots can be driven, the ESP32 bots do not have an on-board camera.
second usage example: open or close a door or toy controlled fron an ESP32.
2) the pi needs to create a virtual serial point that's accessible over WLAN from the ESP32. install socat and ncat on your raspberry:
sudo apt install socat ncat
3) create a new script:
sudo nano /usr/local/ncat_esp.sh
4) paste the following code:
#!/bin/bash
sudo socat pty,link=/dev/ttyVigi0,rawer,shut-none pty,link=/dev/ttySrv,rawer,shut-none &
while true
do
sleep 1
sudo ncat -l -k -4 --idle-timeout 15 7070 </dev/ttySrv >/dev/ttySrv
date
echo "restarting ncat"
done
5) add permissions
sudo chmod +x /usr/local/ncat_esp.sh
6) run the script
sudo /usr/local/ncat_esp.sh
7) insert your
- network info
- raspberry host IP
- vigibot NBpositions (if different from default)
into the following sketch and upload it to your ESP32 from the arduino IDE using a usb cable.
note: only one esp can send a reply, make sure `client.write();` is only being called on one ESP32, all others only listen without sending any data back. (i recommend that one ESP32 sends data back, this way the vigibot robot won't wake up if the ESP32 isn't connected properly, which makes it easier to notice that it isn't working.)
Spoiler
/*
Author: firened
File: vigibot_ESP32_slave_client.ino
Version:
V1.0 10.2020
V1.2 12.2020
Description:
Vigibot Pi to ESP32 over WLAN, based on the Arduino Uart example by Mike118.
check the robot-maker post for up to date setup instructions.
pinout GPIO:
*/
#include <WiFi.h>
#include <ESPmDNS.h>
const char* ssid = "your_ssid";
const char* pass = "your_pass";
const char * host = "192.168.1.63"; // ip or dns
const uint16_t port = 7070;
// Use WiFiClient class to create TCP connections
WiFiClient client;
// Meta Type :
typedef struct {
union {
struct {
int16_t x;
int16_t y;
};
int16_t coordonnees[2];
uint8_t bytes[4];
};
} Point;
typedef struct {
union {
struct {
int8_t x;
int8_t y;
int8_t z;
};
uint8_t bytes[3];
};
} Vitesses;
// CONFIG
#define NBPOSITIONS 2
#define FAILSAFE 250 // ms
// TTS
#define TTSBUFFERSIZE 255
uint8_t ttsBuffer[TTSBUFFERSIZE];
uint8_t ttsCurseur = 0;
// TX
#define TXFRAMESIZE (NBPOSITIONS * 4 + 17)
typedef struct {
union {
struct {
uint8_t sync[4]; // 4
Point positions[NBPOSITIONS]; // NBPOSITIONS * 4
uint16_t val16[2]; // 2 * 2
uint8_t choixCameras; // 1
Vitesses vitesses; // 3
uint8_t interrupteurs; // 1
uint8_t val8[4]; // 4
};
uint8_t bytes[TXFRAMESIZE];
};
} TrameTx;
// RX
#define RXFRAMESIZE (NBPOSITIONS * 4 + 9)
typedef struct {
union {
struct { // Sizes
uint8_t sync[4]; // 4
Point positions[NBPOSITIONS]; // NBPOSITIONS * 4
uint8_t choixCameras; // 1
Vitesses vitesses; // 3
uint8_t interrupteurs; // 1
};
uint8_t bytes[RXFRAMESIZE];
};
} TrameRx;
TrameTx trameTx;
TrameRx trameRx;
uint32_t lastTrameTimestamp = millis();
uint32_t lastSleepBeacon;
uint32_t lastConnectAttempt;
void setup()
{
Serial.begin(115200);
// We start by connecting to a WiFi network
Serial.print("Connecting to ");
Serial.println(ssid);
WiFi.mode(WIFI_STA);
WiFi.setSleep(false);
WiFi.config(INADDR_NONE, INADDR_NONE, INADDR_NONE); //required for hostname to take effect on ESP32 (workaround)
WiFi.setHostname("Vigibot_ESP_0");
WiFi.begin(ssid, pass);
while (WiFi.waitForConnectResult() != WL_CONNECTED) {
Serial.println("Connection Failed! Rebooting...");
delay(5000);
ESP.restart();
}
Serial.println("WiFi connected.");
Serial.println("IP address: ");
Serial.println(WiFi.localIP());
// add all your init here
}
void loop() {
while (WiFi.waitForConnectResult() != WL_CONNECTED) {
Serial.println("WLAN Connection Failed! reconnecting...");
WiFi.mode(WIFI_STA);
WiFi.begin(ssid, pass);
delay(10000);
}
checkClient();
if (readPiSerial()) {
// each time we receive a full trame run repeatedly:
// use values inside trameRx to tell your robot how to move ...
// trameRx.vitesses.x , trameRx.vitesses.y, trameRx.vitesses.z
// trameRx.positions[i].x trameRx.positions[i].y etc....
/*if (trameTx.interrupteurs & 0b00100000) { //testing purposes
trameRx.vitesses.y = 10;
}*/
//writePiSerial(); //make sure only one esp sends replies
lastTrameTimestamp = millis();
}
if ( millis() - lastTrameTimestamp > FAILSAFE ) {
if ((millis() - lastSleepBeacon > 10000) ) { // every 10 seconds
//writePiSerial(); // Beacon to say that the robot is alive
lastSleepBeacon = millis();
}
// Stop the robot in case the robot lost connection with the Pi
} else {
// put your main code here, to run repeatedly:
// avoid abstacle, run speed ...
}
//check for millis() overflow
if (millis() < lastSleepBeacon) {
lastSleepBeacon = millis();
}
if (millis() < lastConnectAttempt) {
lastConnectAttempt = millis();
}
}
void checkClient(){
static byte lastClientState = 2;
if (client.connected()) {
if (lastClientState != 0) {
lastClientState = 0;
Serial.println("Client connected.");
}
} else {
if (lastClientState == 0) { //if client is not actively connected anymore, stop and reconnect
lastClientState = 1;
// close the connection:
client.stop();
Serial.println("Client Disconnected.");
}
if ((millis() - lastConnectAttempt) > 5000) {
lastConnectAttempt = millis();
Serial.print("Connecting to ");
Serial.println(host);
if (!client.connect(host, port)) {
Serial.println("Connection failed. Waiting 5 seconds before retrying...");
}
}
}
}
bool readPiSerial() {
uint8_t current;
static uint8_t lastType = 0;
static uint8_t n = 0;
static uint8_t frame[RXFRAMESIZE];
while (client.available()) {
current = client.read();
//Serial.write(current); //debug
switch (n) {
case 0:
if (current == '$')
n = 1;
break;
case 1:
if (current != 'T' && lastType == 'T')
writeTtsBuffer('\n');
if (current == 'S' || current == 'T') {
lastType = current;
n = 2;
} else
n = 0;
break;
default:
frame[n++] = current;
if (n == RXFRAMESIZE) {
if (lastType == 'T') {
for (uint8_t i = 4; i < RXFRAMESIZE; i++) // Do not send the 4 sync data in tts
writeTtsBuffer(frame[i]);
} else if (lastType == 'S') {
for (uint8_t p = 0; p < RXFRAMESIZE; p++)
trameRx.bytes[p] = frame[p];
}
n = 0;
return true;
}
//break;
}
}
return false;
}
void writePiSerial() {
// Header, do not modify
trameTx.sync[0] = '$';
trameTx.sync[1] = 'R';
trameTx.sync[2] = ' ';
trameTx.sync[3] = ' ';
// modify the feedback according your need. By default we copy the trameRx content ...
for (uint8_t i = 0; i < NBPOSITIONS; i++) {
trameTx.positions[i].x = trameRx.positions[i].x;
trameTx.positions[i].y = trameRx.positions[i].y;
}
trameTx.val16[0] = 0; // Voltage (will be updated by Raspberry pi)
trameTx.val16[1] = 0; // Percent (will be updated by Raspberry pi)
trameTx.choixCameras = trameRx.choixCameras;
trameTx.vitesses.x = trameRx.vitesses.x;
trameTx.vitesses.y = trameRx.vitesses.y;
trameTx.vitesses.z = trameRx.vitesses.z;
trameTx.interrupteurs = trameRx.interrupteurs;
trameTx.val8[0] = 0; // CPU load (will be updated by Raspberry pi)
trameTx.val8[1] = 0; // Soc temp (will be updated by Raspberry pi)
trameTx.val8[2] = 0; // link (will be updated by Raspberry pi)
trameTx.val8[3] = 0; // RSSI (will be updated by Raspberry pi)
for ( uint8_t i = 0; i < TXFRAMESIZE; i++)
client.write(trameTx.bytes[i]);
}
void displayTtsBuffer (uint8_t * ttsBuffer, uint8_t bufferSize) {
// you can modify this function to display text on a screen depending on your hardware...
for ( uint8_t i = 0; i < bufferSize; i++) {
Serial.write(ttsBuffer[i]);
}
Serial.println("");
}
void writeTtsBuffer( uint8_t ttsChar) {
static uint8_t ttsCurseur = 0;
if ( ttsCurseur < TTSBUFFERSIZE && ttsChar != '\n') {
ttsBuffer[ttsCurseur] = ttsChar;
ttsCurseur ++;
}
if ( ttsCurseur == TTSBUFFERSIZE || ttsChar == '\n') {
displayTtsBuffer (ttsBuffer, ttsCurseur);
ttsCurseur = 0;
}
}
8) open the serial monitor to confirm a successful WLAN and TCP client connection.
9) test the pi <-> ESP connection by logging in as root in a new shell (needs root) :
su -
and sending a test text frame:
echo '$T hello from cli $n' > /dev/ttyVigi0
the arduino serial monitor now says "hello from cli "
10)if it works add it to start at boot:
sudo nano /etc/rc.local
and add
/usr/local/socat-esp.sh &
above the line "exit 0".
11) add an entry on the vigibot online remote control config -> SERIALPORTS -> 3 with value: "/dev/ttyVigi0"
12) set WRITEUSERDEVICE to "3"
13) if you set up an ESP32 to send data back:
set READUSERDEVICE to "3"
restart the client and wake your robot up, if it wakes up then everything works.
related notes:
you can add a dummy client from the command line, in case you want to check if the vigibot frames are made available:
sudo socat tcp:localhost:7070 -
similarly it's theoretically also possible to fetch this data from another computer or custom script/application.
there's an outage happening every few weeks or so, from which it doesn't recover.
it looks like ncat doesn't open the socat socket if there's too much data buffered. the workaround is to manually clear the socat socket using
J'avais dans l'idée de d'utiliser vigibot pour contrôler un projet à base d'ESPCam 32...
Le but étant de streamer non pas la video de la cam du pi mais celle de l'ESP cam... quitte à utiliser le PI comme passerelle et que ce soit lui qui s'ovvupe de commuter à video à consulter à la demande... un vigibot dans vigibot en somme
Je n'ai pas encore creusé... acr je n'ai le temps de rien, quasiment tous les projets sont en pause depuis 2 mois...
est-ce possible ?... en tout cas avec ce poste on s'en approche
L'idée serait de contrôler plusieurs devices lowcost constitués sur la même base et de passer de l'un à l'autre...
allez je balance un screenshot de la modélisation du projet en question (le proto du premier device), l'électronique est en cours d'assemblage / tests et le dev (V1) est fait à 90% :
pour le moment, le device heberge un serveur web et est donc contrôlé en direct avec un smartphone...
Hi Zav
i thought about that too, it would be cool.
i doubt an esp32 will be able to send a low latency video stream. i don't know though, haven't used a cam32 board yet.
a different option could be using an analog fpv cam like a runcam used on multicopters and send that video to a usb capture device on a raspberry pi.
fpv cameras can have a very small footprint, which is great for tiny robots where a pi doesn't fit onto.
is your cam 32 webview test already working? I'd love to hear about its latency, resolution and fps rate.
i don't have analog runcam because of low costs constraints... so i turned back to espcam 32 (6$ only)
i agree : low latency streaming is a little bit deception with espcam 32 so for the moment i only make one POOC and i will see the effectivity of the system...
i didnt made serious mesures but i think i have 5fps, perhaps 10fps with correct resolution (not 320p)
it is not very good but sufficient for my usage...
but, in an other hand, i observed stability issues (freeze) while connected to my computer with a ftdi module... wait to see with dedicated power supply system.
i totaly agree with you and think a realist way is to use some fpv cams, associated to esp in order pilot the devices from the PI... like Pascal conception for vigibot... but don't have the funds
