DEV Community: Nutchanon Ninyawee

How to build ZED 2i Camera x ROS2 Foxy x Nvidia Jetson x Ubuntu 18.04 via Docker

Nutchanon Ninyawee — Wed, 15 Sep 2021 09:37:55 +0000

Hi robotics dudes,

TL;DR

Use this Dockerfile, I will later make it a github repo.

# Based on https://gitlab.com/nvidia/container-images/l4t-base/-/blob/master/Dockerfile.l4t
# https://github.com/dusty-nv/jetson-containers/blob/master/Dockerfile.ros.foxy
# https://github.com/codustry/jetson-containers/blob/master/Dockerfile.ros.foxy
ARG L4T_MINOR_VERSION=5.0
FROM codustry/ros:foxy-ros-base-l4t-r32.${L4T_MINOR_VERSION}

#
# ZED Jetson
# https://github.com/stereolabs/zed-docker/blob/master/3.X/jetpack_4.X/devel/Dockerfile
#
ARG ZED_SDK_MAJOR=3
ARG ZED_SDK_MINOR=5
ARG JETPACK_MAJOR=4
ARG JETPACK_MINOR=5

#This environment variable is needed to use the streaming features on Jetson inside a container
ENV LOGNAME root
ENV DEBIAN_FRONTEND noninteractive
RUN apt-get update -y && apt-get install --no-install-recommends  lsb-release wget less udev sudo apt-transport-https build-essential cmake openssh-server libv4l-0 libv4l-dev v4l-utils binutils xz-utils bzip2 lbzip2 curl ca-certificates libegl1 python3 -y && \
    echo "# R32 (release), REVISION: 5.0" > /etc/nv_tegra_release ; \
    wget -q --no-check-certificate -O ZED_SDK_Linux_JP.run https://download.stereolabs.com/zedsdk/${ZED_SDK_MAJOR}.${ZED_SDK_MINOR}/jp${JETPACK_MAJOR}${JETPACK_MINOR}/jetsons && \
    chmod +x ZED_SDK_Linux_JP.run ; ./ZED_SDK_Linux_JP.run silent skip_tools && \
    rm -rf /usr/local/zed/resources/* \
    rm -rf ZED_SDK_Linux_JP.run && \
    rm -rf /var/lib/apt/lists/*

#This symbolic link is needed to use the streaming features on Jetson inside a container
RUN ln -sf /usr/lib/aarch64-linux-gnu/tegra/libv4l2.so.0 /usr/lib/aarch64-linux-gnu/libv4l2.so


# # Configure Enviroment for ROS
RUN echo 'source /opt/ros/foxy/install/setup.bash' >> ~/.bashrc
# RUN echo "source /opt/ros/eloquent/setup.bash" >> ~/.bashrc
RUN echo 'source /usr/share/colcon_cd/function/colcon_cd.sh' >> ~/.bashrc
# RUN echo "export _colcon_cd_root=~/ros2_install" >> ~/.bashrc

# echo $LD_LIBRARY_PATH
RUN echo 'export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/usr/local/cuda-10.2/targets/aarch64-linux/lib/stubs:/opt/ros/foxy/install/lib' >> ~/.bashrc

WORKDIR /root/Downloads
RUN wget https://developer.nvidia.com/embedded/L4T/r32_Release_v5.0/T186/Tegra186_Linux_R32.5.0_aarch64.tbz2
RUN tar xf Tegra186_Linux_R32.5.0_aarch64.tbz2
RUN cd Linux_for_Tegra && \
    sed -i 's/config.tbz2\"/config.tbz2\" --exclude=etc\/hosts --exclude=etc\/hostname/g' apply_binaries.sh && \
    sed -i 's/install --owner=root --group=root \"${QEMU_BIN}\" \"${L4T_ROOTFS_DIR}\/usr\/bin\/\"/#install --owner=root --group=root \"${QEMU_BIN}\" \"${L4T_ROOTFS_DIR}\/usr\/bin\/\"/g' nv_tegra/nv-apply-debs.sh && \
    sed -i 's/LC_ALL=C chroot . mount -t proc none \/proc/ /g' nv_tegra/nv-apply-debs.sh && \
    sed -i 's/umount ${L4T_ROOTFS_DIR}\/proc/ /g' nv_tegra/nv-apply-debs.sh && \
    sed -i 's/chroot . \//  /g' nv_tegra/nv-apply-debs.sh && \
    ./apply_binaries.sh -r / --target-overlay
RUN rm -rf Tegra210_Linux_R32.4.4_aarch64.tbz2 && \
    rm -rf Linux_for_Tegra && \
    echo "/usr/lib/aarch64-linux-gnu/tegra" > /etc/ld.so.conf.d/nvidia-tegra.conf && ldconfig

WORKDIR /usr/local/zed
ENV CUDA_HOME=/usr/local/cuda
WORKDIR /root/ros2_ws/src/
RUN source /opt/ros/foxy/install/setup.bash && cd ../ && colcon build --symlink-install
RUN git clone https://github.com/stereolabs/zed-ros2-wrapper.git
RUN git clone https://github.com/ros/diagnostics.git && cd diagnostics && git checkout foxy
WORKDIR /root/ros2_ws
RUN source /opt/ros/foxy/install/setup.bash && source $(pwd)/install/local_setup.bash && rosdep update && \
    rosdep install --from-paths src --ignore-src -r --rosdistro ${ROS_DISTRO}  -y && \
    colcon build --symlink-install --cmake-args " -DCMAKE_BUILD_TYPE=Release" " -DCMAKE_LIBRARY_PATH=/usr/local/cuda/lib64/stubs" " -DCUDA_CUDART_LIBRARY=/usr/local/cuda/lib64/stubs" " -DCMAKE_CXX_FLAGS='-Wl,--allow-shlib-undefined'" && \
    echo source $(pwd)/install/local_setup.bash >> ~/.bashrc && \
    source ~/.bashrc

I wrote this in Sept, 2021. So, decision are made at this point in time.

After a painstaking week of making, this combination finally worked. I decided to share my journey in a compact way so that it saves humanity's time.

Why it is matter?

ROS2 Eloquent is out of LTS. ROS2 Foxy is the way to go.
Officially, ZED 2i has no launch file at Eloquent branch.

Why it is hard?

Lack of resources long the way
ROS2 Foxy is officially for Ubuntu 20.04 not 18.04
L4T Base image from NVIDIA is miss some .so that shouldn't be missed.
Internet examples are misleading.

Possible Solutions

There are 2 main ways of doing using docker and not using docker. For development iteration on Jetson Devices, docker is much faster for several reasons.

QEMU make it possible to dev locally fast, parallel build
Docker image could build at cloud to make image build faster due to the fast connection to internet(wget, apt install)
Able to inspect each layer individually.
Deploy faster than flash SD card, I use Balena. to deploy on Jetson NX Xavier. You are able to plug monitor, keyboard in as normal
100% Reproducible

Here is the list of what not work

Method 1: start with official SD card method, and try to upgrade OS version to the next LTS from Ubuntu 18.04 bionic to Ubuntu 20.04 focal. You will likely come out of Ubuntu 20.04 with corrupted apt system.
Method 2: start with base images which are not installed L4T It is hard to get right the installation of L4T along with cuda is complex. You should let professional handle that
Method 3: start off Ubuntu 20.04, you are basically run into the sea of storm. This place is too easy to install the ROS2 foxy, but you wouldn't be able to make Jetson/CUDA/L4T driver works.

The working method

Pieces of Jigsaw for this success that worth mention.

dusty-nv/jetson-containers - The starting base and very inspiring base image
ZED Docker ROS1 file - sample of working cmake-args
Azure/IntelligentEdgeHOL - this help me to know that /usr/lib/aarch64-linux-gnu/tegra is related to L4T 32.5 that is missing in l4t base docker.

Method 4: Stay at Ubuntu 18.04 and Build ROS2 Foxy to work on Ubuntu 18.04. I always turn away from the building ROS2, but This is the only way to make everything coexist in harmony.

finally just run

ros2 launch zed_wrapper zed2i.launch.py

TADA~ 😮🎉

Answer: How to pass parameters from main process to render processes in Electron

Nutchanon Ninyawee — Sun, 15 Dec 2019 19:11:50 +0000

answer re: How to pass parameters from main process to render processes in Electron

Dec 15 '19

Using query string along with win.loadFile(),

// main process or renderer process 1
data = {"age": 12, "healthy": true}

let win = new BrowserWindow({
        webPreferences: {
          nodeIntegration: true
        }
      });

win.loadFile("public/print.html", {query: {"data": JSON.stringify(data)}});

// renderer process 2
const querystring = require('querystring');
let query = querystring.parse(global.location.search);
let data =

…

Open Full Answer

[Rewrite]Link: Bidirectional Aliasing in Python

Nutchanon Ninyawee — Wed, 25 Sep 2019 18:56:41 +0000

Hihi~ Devs,

First of all, I would like to communicate that Python-Ideas is a very open place for your ideas and contributions.

Dear People in the discussion

This was my first time being here among Python Core Developers, Python-Ideas, a place to propose an idea before almost all PEPs starts here. It was a very constructive (and technical, of course) dialogue. Considering that I totally newbies to the development of the core language, I was impressed by those responses. I learned a lot of technical aspects of the language throughout the 3-day of conversation. And I know that there is still a lot to learn more!

The discussion(thread) at its 4-day becomes inactive now and will get abandoned soon. I would like to leave this idea to guys in any programming languages not limited to python. Here is my reconstructed proposal as a summary. The original proposal is here and the thread.

Link is a language feature that allows multiple variable names to always refer to the same underlying object define in a namespace.

Notation of Link

The notation of Link and even how to call it are open for changes.
For now, if the variable a link with b. I will denote as a >< b or link a, b. To unlink all, unlinks a. To unlink a variable, unlink a. Link can be inspected via links() like globals() and locals() To del and unlinks, use del_and_unlinks a. @link(a,b) as decorator for function linked parameter. To inspect the link of a variable, use aka(a).

Link can be chained.

a >< b >< c is same as

a >< b
b >< c

Link Behaviors

The behavior can be simplified as

a >< b
a = 1
print(b) # 1
b = 2
print(a) # 2

del a
print(b) # will raise NamedError, both were un-binded.

a = ['Cat', None]
assert a is b # True, both were rebinded.

More complex scenarios

Link after have assigned

When a set of names is link or chained link. Only one variable(or name) is allowed to have been assigned before. Otherwise, the link will be unsuccessful and raise a TooManyAssignError. Thus, Link doesn’t care the order of variables.

x = 5
x >< y # or `y >< x` would be ok

a = 1
b = 'foo'
a >< b # raise TooManyAssignError

Free Memory after unlinks

a >< b >< c
a = HighMemObject()

del a # free memory at once

b = HighMemObject()

unlinks b # unlink all but, all will keep referring to the `HighMemObject`.

del a # b, c still refer to the `HighMemObject`
del b # c still refer to the `HighMemObject`
del c # free memory

link is more-or-less like entanglement property in quantum physics.

Rationale

Language Smooth Shift [Newly Added 11/03/2020]

Suppose you are coming from another language like js. You can archive the faster transition with 'link'. I will provide some examples in String - str

"    Hi dude.      ".trim() // "Hi dude."
"COVID-19 symptoms are Fever, Cough, and Shortness of breath".includes("Fever") // true

str.trim >< str.strip
"    Hi dude.      ".trim() # "Hi dude."

str.includes >< str.contains
"COVID-19 symptoms are Fever, Cough, and Shortness of breath".includes("Fever") // True

Alter the variable name throughout a complex process

Easier to wrap your head around. If we can add another meaningful name. Less cognitive load for coder and reader. We rely on fewer comments to keep track of things.

I code what I mean, mean what I code.

students = School.list_students(year=4)
School.gruaduate(students)
students_graduated >< to_be_sentCertificates >< students

...

School.sendCertificates(students_graduated)

Allow snippet/partial read, without a need to track upper variable changes.

this also may favor a guy who codes on interactive environments like jupyter , del once and free mem. everywhere no need to keep track of variables to the same object.

import pandas as pd

df2train = pd.read_csv('train.csv') # VERY Large DataFrame
df >< df2train 

...

df >< df_didEDA

...

df2train >< df_preprocessed

...

df >< df_trained
...

aka(df) # df, df2train, df_didEDA, df_preprocessed, df_trained

del df # del once and free mem. everywhere! >//<

Simplify aliasing

Instead of using @property and @foo.setter decoration and define in __init__ like this.

class PackageManager:
    packages = ['requests', 'loguru']

    @property
    def installed(self):
        return self.packages

    @installed.setter
    def installed(self, value):
        self.packages = value

    def remove(self):
        ...

    def __init__(self, ...)
        ...
        self.uninstall = self.remove

# monkey patching
PackageManager.uninstall = lambda x: print('uninstalled')
PackageManager.remove = lambda x: print('uninstalled')

We can just

class PackageManager:
    uninstall >< remove
    installed >< packages
    packages = ['requests', 'loguru']

    def remove(): 
        ...

# Plus >//<, one-stop service monkey patching
PackageManager.uninstall = lambda x: print('uninstalled')

Change unintuitive/non-pythonic naming to a better name

Everyone has a different set of vocabulary. Code users may have a hard time to wrap their heads around certain unfamiliar vocabulary created by coders. Linked variables allow them to change to a new name while keeping full compatibility.

from selenium import webdriver

driver = webdriver.Firefox()
webdriver.find_element_by_name >< webdriver.get_element_by_name

elem = driver.get_element_by_name("q")

Multilingual Code

class Human:

    love >< 爱 >< любовь >< รัก >< 💞

    @link(you, вы, คุณ, 您)
    def love(self, you: 'Human'):
        self.soulmate = soulmate

    def code(self):
        return "import json"

    # link function name of similar term
    program >< code


# link class name of different languages
link Human, มนุษย์, 人的, человек, 👤

me = человек()
assert me.program() == me.code() # True


# monkey patch all at once!
人的.program = lambda x: "import this"
assert มนุษย์().program() == me.code() # True

[ProbablyTooAmbitiousException]Allow unnested naming on part of a specified object

I am not sure that this should be part of Link or not. Since not all objects able to assign back etc… The sample would be

house = {'resident': {'count': 12}}
house['resident']['number'] >< n_resident
n_resident = 3
print(house['resident']['number']) # print 3

del_and_unlink house

Implementation Idea

There are several discussions about it. I can’t grasp the mechanism in details. Here is the list

namespaces stuff-Chris Angelico and Andrew Barnert
alias_identifier and set behaviour-Richard Musil

In conclusion, it not as easy as it seems to me lol 😂. Not yet talking about performance, there is no solid implementation of this.

Similar Existing

C++ pointers to the same address auto & a = b
C preprocessor directive (#define) used to define macros.
Python Assignment/Chained Assignment: the same object in a snap moment.

Credit: Cover Photo by Vincent van Zalinge on Unsplash

[Python-Ideas] Link: Bidirectional Aliasing in Python

Nutchanon Ninyawee — Sun, 22 Sep 2019 07:30:59 +0000

Update Sept, 26 2019: I updated and rewrote this proposal, in a new article here.

I am not good at English wording. I will try my best to communicate the idea.

Link is a language feature that allows multiple variable names to always refer to the same underlying object define in a namespace.

For now, if the variable a link with b. I will denote as a >< b or link('a', 'b')

a = 2
a >< alpha # link 'a' with 'alpha'
b = 3
print(b**alpha) # print 9
alpha = 3
print(b**a) # print 27


class Human:
    def code(self):
        return "import json"

    # link function name of similar term
    program >< code


# link class name of different languages
link('Human','มนุษย์', '人的', 'человек', '👤')

me = человек()
assert me.program() == me.code() # True


# reassign function
人的.program = lambda x: "import this"
assert มนุษย์().program() == me.code() # True

The Good

Alter the variable name throughout a complex process

Easier to wrap your head around. If we can add another meaningful name. Less cognitive load for coder and reader. We rely on fewer comments to keep track of things.

I code what I mean, mean what I code.

students = School.list_students(year=4)
School.gruaduate(students)
students_graduated >< to_be_sentCertificates >< students

...

School.sendCertificates(students_graduated)

Allow snippet/partial read, without a need to track upper variable changes.

this also may favor a guy who codes on interactive environments like jupyter , explicit not-copy assignment

import pandas as pd

df_train = pd.read_csv('train.csv')
df >< df_train # avoid copy, ensure always the same DataFrame
df['meme_length'].hist()

Simplify aliasing

Instead of using @property and @foo.setter decoration and define in __init__ like this.

class PackageManager:
    packages = ['requests', 'loguru']

    @property
    def installed(self):
        return self.packages

    @installed.setter
    def installed(self, value):
        self.packages = value

    def remove(self):
        ...

    def __init__(self)
        ...
        self.uninstall = self.remove

We can just

class PackageManager:
    packages = ['requests', 'loguru']
    installed >< packages

    def remove(): 
        ...
    uninstall >< remove

Change unintuitive/non-pythonic naming to a better name

from selenium import webdriver

driver = webdriver.Firefox()
webdriver.find_element_by_name >< webdriver.search_element_using_name

elem = driver.search_element_using_name("q")

***Allow unnested naming on part of a specified object

I am not sure that this should be part of link or not. Since not all objects able to assign back etc… The sample would be

house = {'resident_num': 2}
house['resident_num'] >< n_resident
n_resident = 3
print(house['resident_num']) # print 3

Follow ‘The Zen of Python'

Simple is better than complex.
Flat is better than nested.
Namespaces are one honking great idea — let’s do more of those!

The Bad

Novel Idea, No previous implementation to learn from

I don’t see a feature like this in any of programing language. But present in a lot of human-being languages.

Not Follow ‘The Zen of Python'

In the face of ambiguity, refuse the temptation to guess.
There should be one — and preferably only one — obvious way to do it.

The Ugly

Need a System to help individual coders to read/write code

Let say 2 guys from a different country are coding the same script using different a language; English and Russian.
Although they both specify the linked variables explicitly. They will get dizzy soon since they have to look up back and forth a lot when they encounter foreign text. There should be a system to help them select their default language/vocabulary so they can understand code as if it was entirely coded by them.

Similar Existing

C pointers to the same address
C preprocessor directive (#define) used to define macros.
Bash Aliasing: one-direction aliasing
Python Assignment/Chained Assignment: same value in a snap moment.

I would like to know what you guys think. Will it affect your daily coding in a positive/negative way?