This is essentially the point of MPA (Modal Pipe Architecture, our interprocess communications standard). We publish FIFOs to /run/mpa with the data (standard FIFOs use the filesystem as a handle, not for actually transferring the data, the kernel will pass the data directly from process to process). voxl-uvc-server will pull the data from the camera and write it out to a pipe in /run/mpa, which can easily be mounted in a docker image and read there. You can use the libmodal_pipe(or manually request a pipe and open the FIFO, though this will be less reliable than our extensively tested library) to read it in a docker image (or images as MPA allows numerous clients).

@Chad-Sweet
I'm trying to read some sensor data using UART/I2C, from within a Docker container.

I will look into libmodal_pipe , thanks.

@hmlow

Yes, PX4's obstacle avoidance and Collision Prevention are separate features. We only support the Collision Prevention functionality which is governed by the PX4 CP_DIST and similar parameters. Make sure the COM_OBS_AVOID parameter is OFF (0) in PX4

James

The emulator is meant to be a build environment and not for running code, this is likely the source of the issue, does your code encounter this problem when running on a voxl?

We have example Python code in voxl-modem to control the B2B GPIO

## All GPIO pins need to be exported before they can be used # def gpio_export(num): subprocess.call("echo " + num + " > /sys/class/gpio/export", stderr=FNULL, shell=True) ## Each GPIO has to have its direction set prior to use # @param num pin number # @param direction 'in' or 'out' # def gpio_direction_map(num, direction): subprocess.call("echo " + direction + " > /sys/class/gpio/gpio" \ + num + "/direction", stderr=FNULL, shell=True) ## Set a value to an 'out' gpio # def set_gpio(num, value): subprocess.call("echo " + value + " > /sys/class/gpio/gpio" + num + "/value", stderr=FNULL, shell=True) ## Reads a GPIO pin # @apram pin # pin number # @return # integer value [0,1] def gpio_read_int(pin_int): gpio_file = '/sys/class/gpio/gpio' + str(pin_int) + '/value' value = subprocess.check_output(['cat', gpio_file]).strip() return int(value)

@CY-1992 said in Building new docker image error - Cmake version not good:

ubuntu:20.04

Thanks @CY-1992 is working just fine!

@Eric-Katzfey OK good to know. Thanks for looking into that. Is there a good email I can reach out to discuss further with you?

@Philemon-Benner This is where the voxl-wifi source code lives for VOXL1: https://gitlab.com/voxl-public/voxl-sdk/utilities/apq8096-system-tweaks/-/blob/dev/scripts/voxl-wifi

Since you've already put in effort toward the resolution you could attempt to fork this repo, make your suggested tweaks and create a merge request so that the team could take a look!

Otherwise it may take a little bit longer for the team to take a chance to look into the bug

@Chad-Sweet Great, very exciting!

@tom Now it's working again, but might be worth a look, it's important that it always works. Parsing seems fine:

apq8096 detected... 'v2' len: 2 Initializing v2 modem... Waiting for ttyUSB2... ttyUSB2

Would love a solution to this too, having the same problem

With the updates to this page (specifically running the setup script voxl-configure-docker-support), this issue is resolved.

Thank you @Chad-Sweet for updating the page!

You can find the code for that TensorFlow Lite build here https://gitlab.com/voxl-public/voxl-sdk/third-party/qrb5165-tflite

There are just few patches applied to get it to build correctly. You could try rebasing it to 2.11

The pipes that voxl-camera-server publishes should be accessible in a Docker. You should be able to access them that way inside of a Docker. A voxl-mpa-to-ros2 service would be a good addition, we don't have that implemented yet.

With regards to camera server, the "types" that it takes define behavior more than actual reading of drivers. The underlying camera layer will deal with the actual querying of the sensor and using those drivers that you've posted, and the type in the camera server config file will define a few behaviors like resolutions, image format, allowable streams, etc, some of which are customizable in the config file.

The imx214 type in there is named as such because initially that was the only imx sensor that we used, and its behavior is applicable to (at the very least that we've tested) the 377 and 412 as well; and would likely work on some of the others that you've mentioned.

Hi, would there be any way to classify the feature points used for QVIO based on some metric so that voxl could be able to handle points that are from reflected surfaces.

I mean there could be some variable that measures the feature point as a potential point from reflection.

switch to wifi station mode - https://docs.modalai.com/wifi-setup/
It fixed for me

I believe you first need to enable SFTP functionality in ssh server on the drone, for example https://www.pcwdld.com/setup-sftp-server-on-ubuntu seems to provide instructions (i did not verify the correctness of the instructions).

A better solution, in my opinion, would be to use scp from your python client. You can copy the ssh key directly to the drone, so you don't have to enter the password in the script. Then you could call the scp command directly from Python using a system call or using Paramiko like in this example : https://stackoverflow.com/questions/250283/how-to-scp-in-python . Installing the ssh key on the drone will avoid storing plain text password on your PC.

Is there a reason why you are trying SFTP instead of SCP?