Posts made by Alex Kushleyev

@jcai, yes you are correct regarding the connections that will work on Voxl2 and Voxl2 mini.

Please reach out to https://modalai.com/contact and we will create a custom order for you. You should add a link to this thread. I will work with our team to get the right hardware for you.

You will need

• M0159
• M0181
• two specific coax cables between those teo boards (18cm length?).
• M0155 (assuming you already have M0161 with a coax, but is your M0161 connected to M0173 camera front end?

You should also get a tool for removing coax connectors - check at the bottom of this guide: https://docs.modalai.com/micro-coax-user-guide/ . I dont think we sell the tool, but it looks like the tool is out of stock (Mouser) - you will need it to disconnect your M0161 from M0173.. i will check if we can provide it.

Regarding length, it looks like the longest cable we sell is 18cm : https://www.modalai.com/products/mcbl-00084?variant=48956821733680 , and this is what i am using for testing Hadron.

Alex

@jcai

Please see the following images of the Hadron 640R adapters. Please note that the hardware is subject to change, but this is our current version.

M0159 : Plugs into the back of Hadron. it has two micro coax cable coming out and an optional USB plug for connecting to the "Boson" inside Hadron

As I mentioned before, you can access the Boson camera via USB or MIPI.

M0181 is the adapter for connecting M0159 to VOXL2 / VOXL2 mini:

It is also possible to split up the two coaxes and instead of using a single M0181 for dual camera connection, M0155 for OV64B (https://www.modalai.com/products/m0155) and M0162 for Boson (or use USB for Boson).

@jcai ,

Yes, i will provide the photos of the boards.

And yes, it should work with M0173 + M0161 but only on voxl2. M0173 takes up two camera connectors J6 and J7, so the Hadron would connect to J8.

Another option is to use M0161 with just M0155 coax adapter, since connecting a single camera to M0173 is an overkill. M0155 + M0161 would only use one camera connector, allowing you to use M0161 and Hadron on voxl2 mini.

I will double check both options.

Alex

@Jetson-Nano , can you please clarify which connector on VOXL2 is your Flight Core connected to (for uart communication) and whether you have any indication that the communication is established? Have you previously been able to connect to VOXL2 from QGC and access the Flight Core V2 while it has been connected to VOXL2?

Alex

@Jetson-Nano , is voxl-mavlink-server actually running? you can check using voxl-inspect-services.

Also, are you sure that your Flight Core V2 is connected to /dev/ttyHS1 , which would be implied by using autopilot_uart_bus: 1 . How exactly are you connecting it to VOXL2?

Alex

@nshahrestani , at this time we do not have another version of the CAD model to share - can you please try to use another tool to convert it for your needs?

Alex

@AndriiHlyvko,

I just ran into the same issue while testing Boson (in my case I was testing the 16-bit Boson streaming mode). The libuvc issue caused a crash, since i did not use a fixed version of libuvc. However, what actually caused the buffer overflow was the fact that Boson was reporting smaller buffer requirements for RAW16 during query (it was reporting width * height * 1.5 , just like for YUV, but actual frame size was width * height * 2, so uvc pipeline allocated smaller buffer and overflow happened with the full frame came in.

Was this the same issue with your Boson tests or did you experience something else?

Thanks!

Alex

@tkddnjs825 , since you already have M0062, you should be able to use it. As you already identified, J9 on M0062 has /dev/ttyHS2 Linux UART device.

You can also find more information here : https://docs.modalai.com/voxl2-external-flight-controller/ regarding configuring mavlink server.

It looks like you are doing the right things here. However, the use case for "autopilot_uart_bus" maybe different from what you need - in your case your autopilot (px4) is actually on VOXL2 and the uart connection is for the path to GCS.

You may need to modify mavlink server depending on what you want to pass on this UART connection.. This goes beyond my knowledge of mavlink server - please try to see if you can get it to work, otherwise post a follow up question with details of what you would need to be sent using the UART connection.

Alex

@tkddnjs825 ,

I believe option 1 should work for you, since you will get a standard uart (linux device /dev/ttyHS1 which is completely independent from PX4 running on VOXL). However you will need the additional adapter board (either M0141 or M0151 - either one will work). You will need to configure voxl-mavlink-server to use this UART port to stream the messages that you need (you may already know how to do it, i am not the expert in this part).

By the way, if you use M0141 adapter board, you will also get USB 2.0 standard plug and if you use M0151 you will get USB 3.0 (make sure to get the version with cables). So you could plug in a wifi dongle or more advanced usb-to-wifi device (such as alfa networks awus036ach or similar) and not use Jetson if you do not need it.

If you plug in the wifi adapter directly into VOXL2 (via M0141 or M0151) then you will not need the additional UART (but you will have it anyway)

If you do not wish to get any additional hardware, you should be able to use option 3 to set up the TCP bridge between VOXL2 and Jetson, but that requires more knowledge of networking.

Alex

@Judoor-0 , can you please clarify what you mean a "flat image" ?

Also, it seems you can convert the type to MONO16 right in toCvCopy call. Take a look at the implementation, which will automatically re-scale the data (from MONO8 to MONO16), so you will not lose any information (because in this case you will be upscaling, that is going from 8 bit to 16 bit): https://github.com/strawlab/vision_opencv/blob/master/cv_bridge/src/cv_bridge.cpp#L174

So you can probably just have:

cv_bridge::CvImagePtr cv_ptr = cv_bridge::toCvCopy(msg, sensor_msgs::image_encodings::MONO16);

// Publish the converted image
cv_bridge::CvImage out_msg;
out_msg.header = msg->header; // Keep the same header
out_msg.encoding = sensor_msgs::image_encodings::TYPE_16UC1;
out_msg.image = cv_ptr->image;
depth_pub_.publish(out_msg.toImageMsg());

or i think you can just do the following because toCvCopy will automatically copy the header and update the encoding for you:

cv_bridge::CvImagePtr cv_ptr = cv_bridge::toCvCopy(msg, sensor_msgs::image_encodings::MONO16);
depth_pub_.publish(cv_ptr->toImageMsg());

I have not tried running it, but hopefully should point you in the right direction!

Alex

Hi @scosgrove,

Thanks for the details.

On the DSP there is a dedicated HW block for each UART (similar for the UARTs connected to the application processor). All the UARTs supported on DSP have hardware FIFOs. Since you asked about the size:

• DSP UART2 has 64-byte low level FIFO on RX
• DSP UART6, 7 have 128-byte low level FIFO on RX

When fifo is close to filling up, there is an ISR that triggers on the DSP which transfers the data from FIFO to other memory, and then the data propagates to the user. I wonder if there is some issue when fifo is read while another byte is incoming into fifo at the same time.

Which uart port are you using for this test?

I can do some testing with bursts of 70-250 byte packets. In the past we have tested continuous data transfers of several KB but not at high rates. Also, what baud rate are you using now?

Alex

Agreed! thanks for noticing, Tom. Definitely should be tested on a recent SDK..

Alex

Thanks for clarifying regarding RB5 adapter. Unfortunately, camera connectors on RB5 and VOXL2 are not compatible, so you will not be able to use the gimbal right now.

I just checked with the team, here are some more details:

• Boson / Hadron support is in beta, not generally available yet but if you want to do beta testing, we can arrange it
• If you have a stock Hadron, you will need custom adapters to interface Hadron to VOXL2 (we support both OV64B and Boson using MIPI)
• So far we have tested the following resolutions / fps using OV64B:
  • 1920x1080 (1080p) up to 240fps
  • 4K60 (i believed this is a 2x2 binned version of 8K maximum resolution)
  • 8000x6000 9fps (this is slightly smaller than absolute max resolution 9248x6944 which we will try to enable).
  • we may be able to achieve 8K (7680x4320) at fps closer to 30, but this has not been implemented yet.
• support on voxl2 mini has also been tested (but limited testing so far)
• Boson should be able to do 640x512 60fps (but on some units we had to slow down to 30fps due to mipi timing issues, just FYI)

If you would like to get early access to the hardware adapters, let's make sure that we can support your use case, so please provide some more high-level information, such as:

• desired OV64b resolution / fps
• are you going to need Boson connection via MIPI as well (the boson that is part of Hadron). resolution / fps

Here is the configuration that we are currently testing

• the only difference between the two options is whether on VOXL2 side you have two separate connectors (which will take up two Jx ports on VOXL2) or a single connector for a single Jx camera port.

EDIT: M0159 also has a connector for USB2.0 that connects to Boson (provides the Linux serial and video interface, so you could run Boson over usb competely). Connector is JST SH (not standard USB plug)

In order to install M0159 on the back of Hadron, you may need to remove the adapter that is currently attached to it. M0159 plugs in to Hadron back plate - ready to plug state shown here :

None of these boards (M0159, M0181, M0162) are generally available yet (except for M0155). Let's first make sure that you are willing to experiment with this and then go from there.

Let me know if you have more questions about how the Hadron to VOXL2 connections will work.

Alex

@tkddnjs825 ,

The voxl-elrs utility only works if px4 is not running. Can you please confirm that it's not running on the voxl2 board where voxl-elrs is not working?

I will also forward this question to my colleagues who should have more info.

Alex

@jcai , can you please clarify the following:

Do you also have any other connectors for Hadron and cables (micro coax)?

M0159 adapter board is required, which plugs into the back of Hadron and exposes two separate micro coax connections, one for Boson and one for OV64B).

I just need to make sure that you have all the required hardware.

Alex

@Karl-pan , thank you, i will take a look shortly.

Alex

Hi @jcai,

I can help you with this. Can you please let me know which OV64B camera module you are using and where / how you are connecting to? (voxl2 or voxl2 mini and which camera connector, interposer, etc).

Alex

@vaibhavswami ,

Yes, you can do it the following way:

• make sure to power off VOXL2 before connecting / disconnecting cameras
• connect your M0084 cable to VOXL2 J6
• connect M0014 tracking camera to M0084 L (lower slot - this camera will be in slot 0)
• connect M0161 + M0155 to VOXL2 J7 (this camera will be in slot 2)

Then generate a config file for voxl-camera-server using:

camera-server-config-helper tracking:ov7251:0 hires:imx412:1

This should generate updated config file /etc/modalai/voxl-camera-server.conf

Also, make sure to copy the sensormodule files (camera drivers):

cp /usr/share/modalai/chi-cdk/ov7251/com.qti.sensormodule.ov7251_0.bin /usr/lib/camera/
cp /usr/share/modalai/chi-cdk/imx412/com.qti.sensormodule.imx412_2.bin /usr/lib/camera/

See the following doc page for more info about camera drivers : https://docs.modalai.com/voxl2-image-sensors/#image-sensor-drivers-overview

After that, if you run

voxl-camera-server -l

that should list all the cameras that have been detected. You may need to stop the camera server if it is already running in the background (systemctl stop voxl-camera-server)

After confirming both cameras have been detected, you can just re-start the camera server systemctl start voxl-camera-server.

Alex

Hi @Jetson-Nano, sorry i originally did not realize that you are running PX4 outside VOXL2. In this case px4-listener approach will not work.

However, in the case of PX4 running on flight core (v1 or v2), there is still communication between Flight Core and VOXL2. voxl-mavlink-server should be communicating with the Flight Core via UART and passing messages back and forth. Depending whether the forwarding of RC topic is enabled or not, voxl-mavlink-server would receive those messages (if enabled) and in that case they would be accessible on VOXL2.

@tom , can you please elaborate on how to double check if the RC message is set up to forward to voxl-mavlink-server from Flight Core (if not, how to enable it) and how to actually read that message?

Thanks!

Alex

Hello, @tkddnjs825

You have a few options:

1. Using an add-on board, either M0141 or M0151:

• https://docs.modalai.com/usb2-type-a-breakout-add-on/
• https://docs.modalai.com/voxl2-usb3-uart-add-on-datasheet/
• both boards expose connection to UART7 on the Application Processor, which is mapped to /dev/ttyHS1 and will behave as standard Linux UART high speed device (up to 2Mbit/s)

2. Using one of the DSP (SLPI) UARTs, but this only works if PX4 is not running:

• VOLX2 conector J19 exposes DSP UARTs 6 and 7
• https://docs.modalai.com/voxl2-connectors/#j19---external-sensors-2x-uart-2x-i2c
• px4 must not be running and you can use libqrb5165-io library to talk to one UART concurrently
• my guess is that this is not an option for you because already have VOXL ESC connected, so PX4 is probably already running

3. Using an ADB forward or reverse trick:

Host side setup

Set up reverse forwarding

adb reverse tcp:2222 tcp:3333
adb reverse --list   #just list the forwarded connections for confirmation

Create a python script for a simple tcp server to run on host

#! /usr/bin/python
# a simple tcp server
import socket,os
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)  
sock.bind(('127.0.0.1', 3333))  
sock.listen(5)  
while True:  
    connection,address = sock.accept()
    buf = connection.recv(1024)
    print(buf)
    #connection.send(buf)
    connection.close()

Run on host

python3 tcp_server.py

Run a simple test on voxl2

#install requires internet connection
apt install netcat

echo "Hello World!" | netcat 127.0.0.1 2222

(The message should print out on the host side, which means you just tested a TCP connection between voxl2 and your host).

# output on the server side
> python3 tcp_server.py 
b'Hello World!\n'

You can use this approach to create one or multiple TCP links between VOXL2 and another Linux board. You may be able to use PX4 directly and have PX4 on VOXL2 connect to a server on Jetson board or bridge the data to be forwarded to an external computer.

Alex