Below is an overview of one approach for making your RPLIDAR A1 work wirelessly with ARC using a Raspberry Pi 4.

What’s Possible?

Yes, it is possible to run your RPLIDAR A1 on a Raspberry Pi 4 (connected via USB) and then stream its data over your WiFi network so that ARC (running on your Windows laptop) can receive and visualize the data. Although Synthiam’s RPLidar robot skill is normally used with a directly connected sensor, you can extend its capability by using a network solution such as UDP or TCP to pass data between the Pi and ARC.

Suggested Architecture

1. On the Raspberry Pi 4:

   • Connect the RPLIDAR A1 via USB.
     Use an existing Python library (or your custom script) to interface with the RPLIDAR. Many community examples are available for reading RPLIDAR data.
   • Stream the LIDAR Data:
     Write a script that reads the scan data from the sensor and then sends it over your WiFi network using UDP (or TCP). You might use Python’s socket library for this.
     For example, you can create a UDP client that broadcasts (or multicasts) each scan packet to a specified IP address/port.

2. On the Windows Machine Running ARC:

   • Receive the Data:
     Create or modify a custom ARC robot skill (or a script) that opens a UDP (or TCP) socket to listen for incoming LIDAR data.
   • Process & Visualize:
     Once the data is received, you can parse the stream and pass it along to ARC’s Navigation Messaging System (NMS) or directly use it to update your RPLIDAR display control.

Points to Consider

• Latency & Bandwidth:
  Ensure that your WiFi network is stable. UDP is lightweight (with no guarantee of packet delivery), so if you require guaranteed delivery you may choose TCP instead-keeping in mind that TCP adds a bit of latency.

• Custom Robot Skill:
  Although Synthiam does not have a builtin wireless RPLidar connector, you can build your own custom robot skill. You can use the robot skill Create robot skill documentation on the Synthiam site for guidance:
  How to Create a Robot Skill

• Scripting Language:
  ARC supports JavaScript or Python scripting (with a preference for using print() for output). Depending on your familiarity, you can choose one language to create the network receiver.

Sample Code Snippets

Below is an example of a simple Python script for the Raspberry Pi that reads (dummy) LIDAR data and sends it via UDP. (Replace the dummy data with your actual RPLidar reading implementation.)

import socket
import time
import json  # You can use another format if you prefer

# Configuration:
TARGET_IP = "192.168.1.100"  # Replace with your Windows machine IP running ARC
TARGET_PORT = 5005

# Create a UDP socket
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)

while True:
    # Replace the below with actual LIDAR data reading
    lidar_data = {
        "timestamp": time.time(),
        "scan": [ {"angle": angle, "distance": 100 + angle} for angle in range(0, 360, 10) ]
    }
    
    # Convert to JSON (or any format you prefer)
    message = json.dumps(lidar_data).encode('utf-8')
    
    # Send the data to the target
    sock.sendto(message, (TARGET_IP, TARGET_PORT))
    
    time.sleep(0.1)  # adjust the rate as needed

On the ARC side, you can create a custom robot skill (or use a script) to open a UDP socket and listen for incoming packets. Here’s an example in Python for ARC:

import socket
import json

# Configuration:
LISTEN_IP = "0.0.0.0"  # Bind to all interfaces
LISTEN_PORT = 5005

sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.bind((LISTEN_IP, LISTEN_PORT))

while True:
    data, addr = sock.recvfrom(4096)  # buffer size
    try:
        lidar_data = json.loads(data.decode('utf-8'))
        # Now you can process the lidar_data and update ARC’s variables or invoke a control command.
        print("Received LIDAR data:", lidar_data)
    except Exception as e:
        print("Error parsing data:", e)

Note: In ARC scripts, use print() to output to the console, and you can integrate this code into a custom robot skill’s script section.

Final Thoughts

• Integration with ARC:
  Once you have a reliable network stream, you can then update global variables or call ARC’s ControlCommand() functions (for example, to update NMS variables) using your received data.

• Further Assistance:
  If you need more assistance with creating or configuring a custom robot skill in ARC, let me know-which scripting language you’re more comfortable with (JavaScript or Python) and any specific challenges you face-and I’ll be happy to provide a more detailed walkthrough.

Feel free to ask any follow-up questions so we can refine the solution for your specific setup!

The lidar is a uart device that connects to a uart to usb converter. So you could use an esp32 as a bridge. There’s uart esp32 firmwares out there to bridge uart.

but - you’ll be introducing delay in the lidar scan. That delay May have significant issues with the slam positioning algorithm. It may require your robot to move slower.

the reason you don’t see lidar connected wireless is due to latency delays. Is there a reason you do not have the computer on the robot?

the benefits of having a computer on the robot are discussed in the getting started guide.

@athena - using two esp32, create firmware ardunio code for a client / server to transmit uart over wifi. This allows the PC to have a COM port for the esp32 that sends and receives data from the lidar’s esp32.

Below is one approach that many in our community have discussed. You can use two ESP32 boards - one working as a server attached to your LIDAR (reading its UART data) and one working as a client that bridges the wireless data back to your PC by exposing a virtual COM port. This setup lets you tunnel the LIDAR’s UART stream over WiFi.

Keep in mind, as DJ_Sures noted, that any wireless bridge can introduce latency that may affect your SLAM processing. You might have to adjust your robot’s speed or compensate for a slight delay. Synthiam’s Getting Started guide explains the benefits of having a computer on the robot, so if you’re forced to run wireless you’ll need to plan accordingly.

Below is an example of what the Arduino/ESP32 firmware might look like for both sides.

1. ESP32 Server Sketch (attached to the LIDAR)

This board reads from its UART (which must be wired to your RPLIDAR’s USBconverter output) and then sends the raw data over WiFi (using UDP here).

#include <WiFi.h>
#include <WiFiUdp.h>

// Replace with your WiFi settings
const char* ssid     = "Your_SSID";
const char* password = "Your_Password";

// IP and port info for the client, adjust as needed.
const char* clientIP = "192.168.1.XX"; // Set this to the IP address of your client ESP32
const unsigned int remotePort = 5005;

WiFiUDP udp;
 
// Use Hardware Serial 1 (pins may depend on your board configuration)
HardwareSerial mySerial(1);

void setup() {
  Serial.begin(115200);
  // Start the hardware serial (For example, use pins 16 and 17, check your ESP32 board)
  mySerial.begin(115200, SERIAL_8N1, 16, 17);
  
  // Connect to WiFi
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi ");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("Connected! Server IP: " + WiFi.localIP().toString());
}

void loop() {
  // Check for data from LIDAR
  if (mySerial.available()) {
    int len = mySerial.available();
    uint8_t buf[256];
    if (len > 256) len = 256; // limit buffer size

    int read = mySerial.readBytes(buf, len);
    
    // Send the data over UDP to the client
    udp.beginPacket(clientIP, remotePort);
    udp.write(buf, read);
    udp.endPacket();
  }
}

2. ESP32 Client Sketch (connected to the PC; it will provide a virtual COM port)

This sketch will join the same WiFi network, listen on the UDP port for incoming LIDAR data, and then simply write that data out to its Serial port (which can be used as a COM port on your PC). You may use a USB-to-serial driver on the ESP32 for this purpose.

#include <WiFi.h>
#include <WiFiUdp.h>

// Replace with your WiFi settings
const char* ssid     = "Your_SSID";
const char* password = "Your_Password";

const unsigned int localPort = 5005;  // Listen on the same port that the server sends data from

WiFiUDP udp;

void setup() {
  // This Serial is for communication with the PC
  Serial.begin(115200);
  
  // Connect to WiFi
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi ");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println("\nConnected! Client IP: " + WiFi.localIP().toString());
  
  // Start UDP
  udp.begin(localPort);
}

void loop() {
  int packetSize = udp.parsePacket();
  if (packetSize) {
    uint8_t buf[256];
    int len = udp.read(buf, 256);
    if (len > 0) {
      // Write received data to the PC over the ESP32’s USB-serial port.
      Serial.write(buf, len);
    }
  }
}

How This Helps in ARC

On the PC side, you’ll now have a virtual COM port (provided by your client ESP32) that carries the LIDAR data exactly as if the sensor were directly attached. You can then configure the RPLidar robot skill in ARC to communicate with that COM port. In ARC, the LIDAR skill will expect data from a serial device, and you can open and use that COM port as usual.

Additional tips:

• Use a reliable wireless channel to minimize packet loss or jitter.
• If UDP packet loss is an issue, you might consider a TCP-based approach (with care given to latency).
• The actual baud rate must match the LIDAR’s serial output.
• Adjust the buffer size and rate as needed based on real testing.
• These sketches are basic examples to get you started. Depending on your implementation, you might need errorchecking or additional commands (for flow control, etc.).

This is one way to create a client/server solution to bridge your LIDAR’s UART over WiFi so that ARC can work with it as if it were connected locally. Let me know if you need further details or if you run into any issues with the code or configuration!

@athena provide a tcp approach. Udp should not be used because it’s lossless.

Below is an example TCPbased solution using two ESP32 boards-one attached to your LIDAR (server) and one acting as a client connected to your PC (providing a virtual COM port). This approach uses WiFi’s builtin TCP reliability (ensuring packet order and delivery) so that you don’t run into transmission issues that can occur with UDP. Keep in mind that any wireless bridge may introduce some latency, so you may need to compensate for that in your SLAM algorithm.

Below are two example sketches:

1. ESP32 SERVER SKETCH
   (The LIDAR ESP32 reads the UART data from your LIDAR via the USB-to-UART converter and then sends that data over TCP.)

Make sure you adjust your WiFi settings, pin assignments (used for the hardware serial port), and the TCP port if needed.

#include <WiFi.h>

// Replace with your WiFi credentials
const char* ssid     = "Your_SSID";
const char* password = "Your_Password";

// Define the TCP server port
const uint16_t serverPort = 5005;

// Create a WiFiServer instance on serverPort
WiFiServer tcpServer(serverPort);

// Use a hardware serial port for the LIDAR (adjust rxPin and txPin as needed)
HardwareSerial lidarSerial(1);   // Typically Serial1 for ESP32

// Choose the appropriate UART pins for your ESP32 (update as needed)
const int rxPin = 16; 
const int txPin = 17;

void setup() {
  Serial.begin(115200);
  // Initialize hardware serial for LIDAR communication
  lidarSerial.begin(115200, SERIAL_8N1, rxPin, txPin);
  
  // Connect to WiFi
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("Connected! IP address: ");
  Serial.println(WiFi.localIP());
  
  // Start the TCP server
  tcpServer.begin();
  Serial.print("TCP server started on port ");
  Serial.println(serverPort);
}

void loop() {
  // Check if a client has connected
  WiFiClient client = tcpServer.available();
  if (client) {
    Serial.println("Client connected");
    // While the client remains connected...
    while (client.connected()) {
      // If any data is available from the LIDAR, send it over TCP
      if (lidarSerial.available()) {
        uint8_t buf[256];
        int len = lidarSerial.readBytes(buf, sizeof(buf));
        if (len > 0) {
          client.write(buf, len);
        }
      }
      // Optional: you can add a small delay
      delay(1);
    }
    Serial.println("Client disconnected");
    client.stop();
  }
}

2. ESP32 CLIENT SKETCH
   (This ESP32 connects to the same WiFi network, opens a TCP connection to the Server, and then writes any received data to its Serial port. When connected via USB to your PC, this Serial port will act as a virtual COM port.)

Adjust the WiFi credentials, server IP address (the LIDAR ESP32’s IP), and port as needed.

#include <WiFi.h>

// Replace with your WiFi credentials
const char* ssid     = "Your_SSID";
const char* password = "Your_Password";

// The IP address of the LIDAR ESP32 server - update with your server’s IP
const char* serverIP = "192.168.1.XX";  
const uint16_t serverPort = 5005;

WiFiClient tcpClient;

void setup() {
  // This serial communicates with your PC (virtual COM port)
  Serial.begin(115200);

  // Connect to WiFi
  WiFi.mode(WIFI_STA);
  WiFi.begin(ssid, password);
  Serial.print("Connecting to WiFi");
  while (WiFi.status() != WL_CONNECTED) {
    delay(500);
    Serial.print(".");
  }
  Serial.println();
  Serial.print("Connected! Client IP address: ");
  Serial.println(WiFi.localIP());

  // Connect to the LIDAR server
  Serial.print("Connecting to server at ");
  Serial.print(serverIP);
  Serial.print(":");
  Serial.println(serverPort);
  while(!tcpClient.connect(serverIP, serverPort)) {
    Serial.println("Connection failed, retrying...");
    delay(1000);
  }
  Serial.println("Connected to server via TCP!");
}

void loop() {
  // Check if data is available from the TCP connection
  if (tcpClient.available()) {
    uint8_t buf[256];
    int len = tcpClient.read(buf, sizeof(buf));
    if (len > 0) {
      // Write received data to the Serial (virtual COM port)
      Serial.write(buf, len);
    }
  }

  // Reconnect if the connection is lost
  if (!tcpClient.connected()) {
    Serial.println("TCP connection lost. Attempting to reconnect...");
    tcpClient.stop();
    while(!tcpClient.connect(serverIP, serverPort)) {
      Serial.println("Reconnection failed, retrying...");
      delay(1000);
    }
    Serial.println("Reconnected to server.");
  }
  
  delay(1);  // Minimal delay to allow proper processing
}

How This Helps with ARC
On your PC, you’ll now have a virtual COM port provided by the client ESP32.
In ARC, configure your RPLidar robot skill to read from that COM port as if the sensor were directly attached.
The TCP connection ensures reliable, ordered data delivery for processing LIDAR scans in your SLAM algorithm.

Additional Suggestions
Test the latency of your wireless link and adjust your robot’s SLAM settings or movement speed if needed.
Use error checking and consider buffer size adjustments based on your actual LIDAR data rate.
If you face connection issues, try also experimenting with different WiFi channels or even making one of the ESP32 boards the access point.

Feel free to ask for further assistance or clarification on any specific part of this setup!