Hi there, thanks for reaching out! I'm Athena, and I’d be happy to help you integrate your STL-19P-TOF LiDAR sensor with ARC using your Raspberry Pi and EZB firmware.

Since there isn’t an existing ARC skill for the STL-19P-TOF sensor, here are a few approaches you can consider:

1. Create a Custom Robot Skill

Even though you’re on the ARC Free version, you can develop a custom skill to handle the sensor. This involves:

• Understanding the Sensor Protocol:
  Check the STL-19P-TOF documentation to know its communication protocol (serial, I2C, etc.), data format, and any initialization/setup commands.

• Developing the Skill in JavaScript:
  You can use ARC’s custom scripting skills to parse incoming data from the sensor. ARC supports JavaScript (preferred for new skills) using the print() function.

• Using ARC’s Kebab Menu:
  Access the robot’s settings in the kebab menu (three dots) and look for the option to add a custom skill. This is where you’ll integrate your code to read and interpret the LiDAR data.

You can refer to our guide on creating custom robot skills for detailed instructions:
Create a Robot Skill

2. Using Serial Communication

If your STL-19P-TOF sensor communicates via a serial interface:

• Connect Your Sensor:
  Attach the sensor to an available serial port (or USB adapter) on your Raspberry Pi.

• Read the Data:
  Use ARC’s JavaScript scripts to open the serial port, read incoming messages, and process the data. For example:

// Example pseudocode for serial communication
var serialPort = require('serialport');

// Replace '/dev/ttyUSB0' with your serial port path
var port = new serialPort('/dev/ttyUSB0', {
  baudRate: 115200 // Update with your sensor's baud rate
});

port.on('data', function (data) {
  // Process the incoming data here
  print("Received data: " + data);
});

// Sleep example: ARC's built-in function, which takes milliseconds
sleep(100);

• Relay the Data:
  Once you can read the sensor data, process it to output variables (such as distance, angle, etc.) that can be used by other skills or display components in ARC.

3. Integrate with Existing Skills (Alternative Workaround)

If you find that your sensor data structure is similar to one of the supported LiDAR sensors (like PTI LiDAR or Hitachi-LG LDS), you might be able to:

• Modify an Existing Skill:
  Study the code for existing LiDAR skills (find them in the Synthiam repository or online help documents) and adjust them to match the STL-19P-TOF's data format and communication protocol.

• Utilize Global Variables:
  Populate ARC global variables (using setVar("$variableName", "value")) with sensor data, similar to how the Hitachi skill publishes data.

Next Steps & Additional Guidance

• Determine Communication Details:
  Do you have documentation on the STL-19P-TOF connection specifics (baud rate, data frame structure, etc.)? This will be key in developing your custom skill.

• Test the Serial Output:
  If possible, open a terminal on your Raspberry Pi and check if you are receiving the expected data from your sensor. This can save troubleshooting time in ARC.

• Ask Follow-up Questions:
  Let me know if you need more detailed guidance on any of these steps - for example, accessing serial ports in JavaScript on ARC, or more specifics on creating a robot skill.

I hope this gives you a good direction on integrating your sensor. ARC is very flexible and with a bit of custom coding, you can bring almost any sensor into your robot’s ecosystem.

Looking forward to your feedback or any additional questions you might have!

Generally it’s very easy to add a new robot skill for a lidar product - specifically because we modify the existing lidar robot skill framework to accommodate the protocol of a lidar. However, this lidar (STL-19P-TOF) doesnt have any information on the internet. The data sheet does not define the packet and communication protocol.

at this point, it’s impossible to know the communication protocol to implement the sensor into a robot skill.

If you have information about the communication protocol, a robot skill can be created by us to support the product.

Hi there,

Based on Synthiam_Support's comments, the current issue is that there isn’t any publicly available documentation defining the communication protocol or packet structure for the STL-19P-TOF LiDAR sensor. Without these details, it's not possible to create a new robot skill that integrates the sensor with ARC.

What Does This Mean?

• Protocol Documentation Needed:
  To add support for any new LiDAR device using our existing framework, we need clear information about how the sensor communicates-specifically, the packet format, baud rate, initialization commands, and data output details.

• Next Steps:
  Contact the Manufacturer: If you have any direct access to technical support or additional documentation from the manufacturer of the STL-19P-TOF, obtaining these details will be essential.
  Reverse Engineering: Alternatively, if you or someone in the community manages to determine the communication protocol (e.g., by capturing serial data with a terminal program), that information can be shared with Synthiam so that we can help create the proper robot skill.

Moving Forward

Once you have the protocol details, our approach can be similar to modifying an existing LiDAR skill. The steps would usually involve:

1. Parsing the Data: Using JavaScript within ARC to handle the incoming sensor data.
2. Publishing Global Variables: Setting variables (using setVar) to represent key sensor readings (e.g., distance, angle) so other skills can use this data.
3. Integrating with ARC’s Framework: Modifying the existing lidar framework to accommodate your sensor’s unique protocol.

If you can provide further information or have any updates, feel free to share them so we can assist you in developing a custom skill for the STL-19P-TOF. Do you have any contacts at the manufacturer or are you able to capture raw data from the sensor? This additional info would be a great starting point.

Let me know if you need further guidance or have any more questions!