EchoPilot AI Documentation¶
Overview¶
The EchoPilot AI is a highly integrated vehicle control and edge computing system designed to power next-generation uncrewed systems. The EchoPilot AI supports computer vision, machine learning, autonomy, artificial intelligence and other advanced edge computing needs. The EchoPilot AI implements a STM32H7-based autopilot compatible with the popular Ardupilot and PX4 projects, and uses Pixhawk open-hardware connectivity standards.
The power of an advanced autopilot is seamlessly combined with high-performance computing (including AI and machine learning), IP networking, cloud connectivity and flexible low-latency hardware accelerated video encoding.
Autopilot Sensors
| Function | Part Number |
|---|---|
| IMU 1 | ICM42688P |
| IMU 2 | ICM42688P |
| IMU 3 | ICM42688P |
| Barometer 1 | ICP-20100 |
| Barometer 2 | ICP-20100 |
| Magnetometer | PNI RM3100 |
| Add-On INS | Standalone modules only via RS-232 |
The hardware is configured into a two board stack. The upper board is the EchoPilot AI board, and it contains the flight management unit, peripherals, sensors and Nvidia Jetson interface. The lower board is the Carrier Board, and it handles power regulation and connectors. Two high-density FX23L-80S-0.5SV 80-pin board-to-board connectors are used between the two boards. There is 10mm between boards.
This design philosophy achieves multiple goals :
- For integrated vehicle solutions, it is often desired to design a custom carrier board to add additional components, minimize cables/wiring and integrate power distribution. The EchoPilot AI's design allows you to optionally design a custom carrier board (using the provided Carrier Board as a reference design).
- A stacked solution minimizes X-Y size in exchange for moving into the Z axis, which is an acceptable compromise for most uncrewed vehicles.
- Moving the switching power regulators to the Carrier board reduces noise near the sensitive sensors on EchoPilot AI board and reduces the thermal load of the EchoPilot AI mainboard.
- A stacked design is more future proof, as peripherals can often be added to the Carrier Board without a re-design of the EchoPilot AI main board.
Quick Start Guide¶
Accessing the Jetson via the console¶
If you included a Jetson SOM in your purchase, it will have been flashed and tested at the factory. If you have a new Jetson module that is not flashed, please see XavierNX, Orinx NX and Orin Nano, and Nano instructions.
Warning
Do not run the Jetson SOM without a heat sink. The module may be damaged or performance throttled. See connecttech.com for recommended active and passive heat sinks and heat spreaders.
- Assemble the EchoPilot AI board with a Carrier Board, using 10mm standoffs between the two boards.
- If a Jetson Module is not already installed in the EchoPilot AI, install the module now.
- Attached a USB cable between your host computer and J15 (Console) on the EchoPilot AI Board
- In step 3, your host computer should have enumerated a virtual comm port. You will now need to find the name of the port.
Info
On Windows: Open Device Manager (Start → Control Panel → Hardware and Sound → Device Manager) Look in the Device Manager list, open the category "Ports", and note the COM port added USB Serial Port (COM?) (e.g., COM10).
On Linux: Run dmesg -w and then plug in unplug and replug in the USB cable. You should see the name of the device added, typically FTDI USB Serial device converter now attached to ttyUSB? (e.g., ttyUSB0).
Use a terminal program to connect to the Jetson's console at 115200 baud, 8N1.
Info
On Windows: We recommend Putty or TeraTerm.
On Linux: We recommend Picocom. Install with sudo apt-get install picocom. Use with picocom /dev/ttyUSB? -b 115200. To exit picocom, use Ctrl-a Ctrl-x.
Power the Carrier Board with 7-56VDC source capable of supplying up to 4A.
Warning
If using a bench supply with over-current protection, we recommend turning it OFF. The boot process requires short bursts of high current and over-current protection on some supplies will result in a failed boot. In most cases, if the Jetson fails to boot it is due to a poor power supply.
You should now see the boot messages in your console, and once boot is complete, you will see a login prompt.
Note
The default username is echopilot and the default password is echopilot
Success
At this point you are logged into the Jetson and can begin configuring the network, installing applications, etc.
Connecting to the FMU via the USB connector¶
- Attach a USB cable between the host computer and the FMU USB connector (J7).
- Start a ground control application on the host computer such as QGroundControl or Mission Planner.
Info
QGroundControl: Will automatically connect.
Mission Planner: Select the appropriate COM port at the top right, 115200, then click CONNECT.
Streaming telemetry over the network¶
As of September, 2023, EchoMAV is provisioning Jetson hardware with software which includes setting the Jetson to a static IP address, installing a web UI and configuring mavlink-router to stream telemetry from the autopilot to 10.223.1.10:14550 over UDP. If you have an earlier release or flash your own image, you can install the default software using the instructions here. The rest of the instructions below assume the Jetson module installed in your EchoPilot AI hardware has been provisioned using our software installation.
Default telemetry will stream to 10.223.1.10 using UDP (client mode) port 14550. This will allow automatic connection to common Ground Control Stations including QGroundControl and Mission Planner. For this to work, your host computer must be set to 10.223.1.10 and the EchoPilot AI must have a network connection between one of the Ethenret ports and the host computer
The telemetry endpoint can be easily changed by using the web UI at https://{IP_ADDRESS} (the recommendeded way), or more advanced users can use the command line by first gaining console access and then editing \etc\mavlink-router\main.conf. For example:
EchoPilot IP Addressing¶
The EchoPilot AI will be labeled from the factory with a static IP address in the 10.223.0.0/16 subnet such as 10.223.134.126 (for example). If you do not know the IP address, you may be able to access the system using the backdoor/alias IP of 192.168.154.0/24.
Using EchoMAV's software stack, the system's static IP address is calculated using the last two octets of the Jetson's eth0 interface MAC address with a netmask of 255.255.0.0 (/16). For example, given the MAC address of 00:30:1A:4E:A4:3E, the last two octets 0xA4 and 0x3E are onverted from hex to decimal and then assigned as the last two octets of the IP address. In this example, this MAC address would correspond to 10.223.164.62/16 because 0xA4 = 164 and 0x3E = 62. This IP address is printed on the label from the factory.
To access the Jetson module using IP, first set up your host computer to have a static IP address in the 10.223.0.0/16 subnet with any IP address OTHER than the address of the EchoPilot AI.
Info
On Windows: Open Device Manager (Windows Key + X → Press "W" → Click on "Change adapter options" → Right click, properties of the adapter connected to the EchoPilot AI → Highlight "Internet Protocol Version 4 (TCP/IPv4) and click Properties ). Select "Use the following IP address" and configure the IP address and Subnet mask. Then click OK → Close.
On Linux: Find the wired interface name, most typically this can be found using
$ ip ad
enp43s0: <NO-CARRIER,BROADCAST,MULTICAST,UP> mtu 1500 qdisc fq_codel state DOWN group default qlen 1000
link/ether 34:73:5a:e8:57:3f brd ff:ff:ff:ff:ff:ff
enp43s0. Use nmcli and the interface name found above set a static IP address (e.g. 10.223.1.10/16):
$ nmcli con add con-name "static-eth" ifname enp43s0 type ethernet ip4 10.223.1.10/16
$ nmcli con up "static-eth"
ens32 is shown below:
$ nmcli con show
NAME UUID TYPE DEVICE
enp43s0 ff9804db5-........ 802-3-ethernet --
static-eth a4b59cb4a-........ 802-3-ethernet ens32
$ nmcli con down enp43s0
nmcli to take down the static connection and restore the original. For example:
Note
If you do not know the IP address of your system, you can use the configuration IP "backdoor" alias of 192.168.154.0/24 to access the system. Ensure your host system is in the 192.168.0.0/24 subnet (any valid IP address not equal to 192.168.154.0 will work). Please refer to the instructions above for how to change your host IP address.
Board Components and Connectors¶
EchoPilot AI Mainboard¶
Carrier Board¶
Pinouts¶
For EchoPilot AI Mainboard Pinouts, refer to the EchoPilot AI Pinout Page.
For Standard Carrier Board Pinouts, refer to the Carrier Board Pinout Page.
Jetson IO Availability¶
The following Jetson IO pins are brought out to the B2B connector J5 and are available for customer use:
Note
*Changes to the direction and functionality of these pins may be possible based on the Jetson pinmux configuration.
| Jetson Pin | Direction | B2B (J5) | Voltage | Default Use | GPIO (Xavier) | GPIO (Orin NX Orin Nano) |
|---|---|---|---|---|---|---|
| PIN 218 | IO | 73 | +3.3V* | Iridium Ring | GPIO3_PCC.04 | GPIO3_PN.01 |
| PIN 240 | IO | 39 | +1.8V | SLEEP/WAKE | GPIO3_PEE.04 | GPIO3_PEE.04 |
| PIN 178 | IO | 38 | +1.8V | nMOD_SLEEP | NA | NA |
| PIN 197 | IO | 40 | +1.8V | I2S0_FS | GPIO3_PU.00 | GPIO3_PI.02 |
| PIN 124 | IO | 79 | +1.8V | GPIO O2 | GPIO3_PQ.03 | GPIO3_PP.06 |
| PIN 195 | IO | 37 | +1.8V | IS20_DIN | GPIO3_PT.07 | GPIO3_PI.01 |
| PIN 199 | IO | 76 | +1.8V | IS20_SCLK | GPIO3_PT.05 | GPIO3_PH.07 |
Note
*Pin 218 (Iridium Ring) is level-shifted from 1.8V to 3.3V prior to the B2B (J5) connector via a TXS0108ERGYR level translator.
The following Jetson IO is used internally by the EchoPilot AI:
Warning
*Changes to the pinmux affecting these pins may break functionality.
| Jetson Pin | Direction | Voltage | Use | Pin Description (Xavier) | Pin Description (Nano) |
|---|---|---|---|---|---|
| PIN 87 | I | +1.8V | Vbus Detect | USB_VBUS_EN0 | USB_VBUS_EN0 |
| PIN 130 | O | +1.8V | Camera Mux | GPIO3_PCC.03 | GPIO3_PI.00 |
| PIN 212 | I | +1.8V | M2 Alert | GPIO3_PQ.01 | GPIO3_PV.01 |
The following Jetson IO pins are brought out to the FAN (J38) connector:
| Jetson Pin | Direction | Voltage | Use | Pin Description (Xavier) | Pin Description (Nano) |
|---|---|---|---|---|---|
| PIN 230 | O | +5V | Fan PWM | GPIO3_PH.01 | GPIO3_PE.07 |
| PIN 208 | I | +5V | Fan Tachometer | GPIO3_PQ.02 | GPIO3_PZ.02 |
Mechanical Drawings and STEP Files¶
EchoPilot AI 3D Model (STEP) File Download (right click, save link as)
EchoPilot AI Universal Carrier Board 3D model (STEP) File Download (right click, save link as)
EchoPilot AI PWM Breakout Board 3D model (STEP) File Download (right click, save link as)
EchoPilot AI USB3 A Breakout Board 3D model (STEP) File Download (right click, save link as)
Vibration Isolation¶
Many commercial autopilots use foam vibration isolation on a daughterboard containing the IMUs. You'll notice the EchoPilot AI does not use this type of design and the IMUs are mounted directly to the circuit board. The reason for this is that we feel better vibration isolation can be achieved (if required) by leveraging the mass of the entire EchoPilot system (carrier board, main board and Jetson SOM) rather than the very small mass of an IMU daughterboard. For the types of vibrations encountered by large-prop multi-rotors and piston-based engines (50-90 Hz), the total mass of the EchoPilot system mounted on vibration silicone isolators or wire rope isolators are very effective. This design has the added benefits of protecting critical electronics from exposure to continuous vibrations.
An example of a typical vibration isolation mount is shown below:
Note
Note that for small and medium multi-rotors and electric planes, electric quadplanes and other vehicle types, vibration isolation is very rarely needed.
Using an NVMe SSD¶
The EchoPilot AI includes an M.2 Key-M slot for a size 2230 NVMe SSD. We recommend a PCIe Gen. 4 NVMe SSD, such as the Western Digital SN740 (SDDPTQD-1T00), Western Digital Industrial Series (SDBPTPZ-1T00-XI) or Kingston OM3PGP41024P-A0 for applications in the 0-70°C range. Please be aware that most consumer NVMe SSDs have a commercial temperature rating (0-70°C). We recommend industrial rated devices for high-risk or high-valued use in uncrewed systems.
The NVMe is power by a dedicated supply, 3A.
To add an NVMe SSD to an EchoPilot system, first power off the system and install the SSD using a M2x3mm wafer head screw.
Power on the sytem and gain console access.
Identify the NVMe SSD using:
Create a partiaion table using:
Create a new partition on the NVMe SSD:
Format the newly created partition:
Create a mount point directory:
Mount the NVMe SSD partition to the mount point directory:
Verify the NVMe SSD is mounted correctly by checking the file system:
Unique Board Identifier¶
Each EchoPilot AI includes an AT24CS01-STUM unique ID EEPROM attached to the Jetson I2C 1 port at address 0x58. This can be used to obtain a unique 128-bit identifier (serial number) for your board.
Below is an example python script you can use to read this serial number.
First install python3 wih smbus
Create a new fileserial.py with these contents:
import smbus
import sys
# usage, pass the i2c bus as the first argument, e.g. python3 serial_number 0
i2c_ch = int(sys.argv[1])
# address on the I2C bus
i2c_address = 0x58
# Register address
serial_num = 0x80
# Read serial number register
def read_serial():
# Read the serial register, a 16 byte block
val = bus.read_i2c_block_data(i2c_address, serial_num, 16)
return val
# Initialize I2C (SMBus)
bus = smbus.SMBus(i2c_ch)
try:
# Print out the serial number
print(bytes(read_serial()).hex())
except:
pass
Configure the Network¶
The EchoPilot AI has two 100Mbps Ethernet ports (ETH1 and ETH2). Upstream, these go to a network switch, so either one can be used to access the Jetson SOM. To interface using a standard RJ45 cable, use the included Ethernet adapter board and cable assembly connected as shown below. The make your own cable assembly, refer to the Pinout
EchoMAV's standard provisioning sets the Jetson module to a static IP address provided on the label with the device. There is also an alias ip of 192.168.253.0 which can be used if you do not know the static IP.
Configuring for DHCP¶
If you wish to use DHCP, follow the instructions below:
First gain console access via the USB connector. Once logged in via the console, modify the existing static connection (e.g. "static-eth0") to be DHCP:
sudo nmcli con mod static-eth0 ipv4.method auto
sudo nmcli con mod static-eth0 ipv4.gateway ""
sudo nmcli con mod static-eth0 ipv4.address ""
sudo nmcli con down static-eth0
sudo nmcli con up static-eth0
Configuring a Static IP Address¶
If you do not have a DHCP server, or you wish to assign a static IP address to the Jetson, follow the instructions below.
First gain console access via the USB connector. Once logged in via the console, delete the default connection, for example "Wired connection 1":
Set up a static connection calledstatic-eth0 with an IP of 10.223.1.10, a netmask of 255.255.0.0 and a gateway of 10.223.1.1. The values are just examples, please adjust to the desired settings for your network.
Bring up the new interface
To verify network connectivity, ping another device on the network, or to verify internet connectivity, ping a Google DNS server:
Other NetworkManager tips and tricks¶
Linux for Tegra uses networkmanager (nmcli) for its network interfaces. Below you will find a few commands for common network tasks. These examples are not intended for you to follow sequentially, these are common examples which will demonstrate most network configuration needs.
Show connections:
nmcli con show
Example: Delete the default connection ("Wired connection 1") and set up a static connection called static-eth0 with an IP of 172.20.1.100, a netmask of 255.255.0.0 and a gateway of 172.20.2.100:
sudo nmcli c delete "Wired connection 1"
sudo nmcli c add con-name static-eth0 ifname eth0 type ethernet ip4 172.20.1.20/16 gw4 172.20.2.100
sudo nmcli c up static-eth0
Example: Change IP address of static-eth0 connection to 192.168.1.4 with a 255.255.0.0 (/16) netmask:
Example: Change the gateway of static-eth0 connection to 192.168.1.1:
Example: Change the DNS of static-eth0 connection to 8.8.8.8:
Example: Take down/up of static-eth0:
static-eth0 connection: Example: Add a new connection called static-eth0 with IP 172.20.2.22/16 and gateway 172.20.2.100 on interface eth0:
Example: Add a persistent route so that multicast traffic to 224.x.x.x goes to the static-eth0 connection:
Example: Change the static-eth0 connection to remove static IP and enable DHCP (In this case, it would be clearer to delete the connection since it is named static-eth0 and call it something else, but for edification:
sudo nmcli con mod static-eth0 ipv4.address ""
sudo nmcli con mod static-eth0 ipv4.gateway ""
sudo nmcli con mod static-eth0 ipv4.method auto
sudo nmcli con reload static-eth0
Adding WiFi to the EchoPilotAI¶
The instructions below provide details on how to get WiFi working using a TP-Link AC1300 (Archer T3U) wireless network adapter. These instructions were developed using Jetpack 35.4.1, running Linux Kernel 5.10. If you are usinng a newer version, you will need a different branch for the driver install. Please refer to the driver's readme.
Connect the AC1300 to one of the USB3 connectors (J24 or J29 on the carrier board) using the provided cable and USB-A breakout board.
Clone and install the RTL8812BU driver¶
cd /tmp
sudo apt update
sudo apt update
sudo apt install -y build-essential dkms git bc
git clone -b v5.6.1 https://github.com/fastoe/RTL8812BU.git
cd RTL8812BU
make
sudo make install
sudo reboot
Verify you have a wlan0 device present¶
The output of this command should include wlan0, for example:lo no wireless extensions.
dummy0 no wireless extensions.
eth0 no wireless extensions.
l4tbr0 no wireless extensions.
rndis0 no wireless extensions.
usb0 no wireless extensions.
wlan0 IEEE 802.11AC ESSID:"EchoMAV" Nickname:"<WIFI@REALTEK>"
Mode:Managed Frequency:5.24 GHz Access Point: C8:9E:43:D5:C0:9C
Bit Rate:867 Mb/s Sensitivity:0/0
Retry:off RTS thr:off Fragment thr:off
Power Management:off
Link Quality=72/100 Signal level=65/100 Noise level=0/100
Rx invalid nwid:0 Rx invalid crypt:0 Rx invalid frag:0
Tx excessive retries:0 Invalid misc:0 Missed beacon:0
Use nmcli to set up your wireless connection¶
Replace SSID and PASSWORD below with your network information.
Verify the connection¶
Using networkmanager, you should now see a connection NAME matching your WiFi SSID and it should be green indicating the connection is established.
At this point, you have a WiFi connection. If your system still has a static network configuration, you may need to deactivate that connection or update your routing to ensure packets are routed over the new WiFi interface. For example, if you have an active static-eth0 interface, it can be deactivated using: You should now be routing internet packets via your WiFi connection. To check your connection speed, install and run Ookla's Speedtest tool:sudo apt-get install curl
curl -s https://packagecloud.io/install/repositories/ookla/speedtest-cli/script.deb.sh | sudo bash
sudo apt-get install speedtest
Configuring CAN on the Jetson¶
These instructions are a work in progress and may not be fully correct.
Modify /etc/modprobe.d/denylist-mttcan.conf and ensure the line blacklist mttcan is commented out. Reboot, then log in again and run sudo modprobe mttcan.
Streaming Telemetry from the Autopilot (Detailed)¶
The autopilot has a high-speed serial interface between the FMU/STM32H7 and the Jetson SOM. The Jetson UART1 (pins 203, 205) is connected to the autopilot's UART2. If EchoMAV has provisioned your board, or if you are using our Board Support Package, then the default parameters will be set automatically if you build the PX4 or Ardupilot firmware. However, to understand what parameters are used to enable MAVLink data flow between the FMU and Jetson, note the parameters used below. In both cases, you are enabling the autopilot serial port to receive MAVLink2 data and setting the baud rate to the appropriate value. A typical baud rate is 500000 kpbs, but you can use any baud rate you wish as long as the mavlink-router application sending/receiving MAVLink on the Jetson is configured to match. For factory provisioned devices, we set it to 500000.
For example, on ArduPilot set the following params and reboot:
For PX4, set the following params and reboot.MAV_1_CONFIG 102: Telem 2 ## Reboot after this change to expose additional parameters
MAV_1_RATE: 0
MAV_1_MODE 2: Onboard
SER_TEL2_BAUD: 500000 ## Reboot after this change
On the Jetson side, UART1 is typically enumerated /dev/ttyTHS0, although it could vary with different Jetson modules including /dev/ttyTHS1 and /dev/ttyTHS2.
For using the EchoPilot AI to route MAVLink data over a network, we pre-install and recommend MAVLink Router. For modules configured at the factory, we now provide mavlink-router installed by default and is configured to push telemetry via UDP to 10.223.1.10:14550
Should you need or want to install this independently, EchoMAV has an open-source installer which makes it easy to install MAVLink Router and configure it as a service which starts at boot. Please refer to the our installer repo https://github.com/EchoMAV/mavlink-router for instructions.
If you use the install repo above, please refer to the instructions there for configuration of the UART and destination IP address. Specifically edit etc\mavlink-router\main.conf with the appropriate settings.
If you have permission issues accessing /dev/ttyTHSX, please disable nvgetty and ensure you are a member of the dialout group, or just use our MAVLink Router Installer Repo along with make install and a reboot which sets these things up for you. Thes steps to disable nvgetty and add your account to the dialout group are shown below.
Note
Reboot to apply changes.
FMU Ports¶
The Flight Manamgenent Unit (FMU) is based on the FMUv5 design, and uses I2C, SPI and UART ports as defined in the table below.
| Port | Use | Connector Assignement |
|---|---|---|
| UART1 | GPS | Carrier Board J20 |
| UART2 | Telemetry to Jetson (Telem2) | NA (internal) |
| UART3 | External/User (Telem1) | Carrier Board J18 |
| UART4 | External/User (shifted to RS-232) | Carrier Board J32 |
| UART5 | Not Used | NA |
| UART6 | Remote ID | NA (internal) |
| UART7 | External/User (Debug) | EchoPilot J12 |
| UART6 | IO MCU | NA (internal) |
| SPI1 | ICM42688P #1 and #2 | NA (internal) |
| SPI2 | RM3100 and FRAM | NA (internal) |
| SPI3 | Not Used | NA |
| SPI4 | ICM42688P #3 and MS5611 #1 NA (internal) | |
| SPI5 | External/User | NA |
| SPI6 | MS5611 #2 | NA (internal) |
| I2C1 | GPS/Compass | Carrier Board J20 |
| I2C2 | External/User | Carrier Board J25 |
| I2C3 | Not Used | NA |
| I2C4 | Not Used | NA |
CAN Termination¶
The 2 CAN connections from the FMU (CAN1 and CAN2) and the 1 from the Jetson are driven by LTC2875 transceivers and contain termination resistors at the drivers. Should you desire to remove these termination resistors (e.g., you want to place the EchoPilot AI in the middle of a CAN chain rather than at the end), refer to the following:
| CAN | Resistor Label | Notes |
|---|---|---|
| FMU CAN1 | R19 | Near U4 and U45, size 0402 |
| FMU CAN2 | R9 | Near U3, size 0402 |
| JETSON CAN1 | R95 | Near U32, size 0402 |
Analog Input to the FMU (Voltage/Current Sense)¶
The EchoPilot AI FMU design provides 6 analog inputs to the STM32H743. Most often, these are used for voltage/current input for the battery systems onboard an uncrewed system. The Analog input pin mapping for each input is shown below. To use these inputs, change the parameters in ArduPilot or PX4 to the appropriate pins.
| Input Name | Carrier Board Connector | STM32H743 Pin | ArduPilot/PX4 Virtual Pin |
|---|---|---|---|
| Voltage Sense 1 | J13.2 | PA0 | 16 |
| Current Sense 1 | J13.3 | PA1 | 17 |
| Voltage Sense 2 | J13.4 | PA2 | 14 |
| Current Sense 2 | J13.5 | PA3 | 15 |
| Spare ADC 1 | J13.6 | PC4 | 4 |
| Spare ADC 2 | J13.7 | PA4 | 18 |
ArduPilot Setup for Voltage/Current¶
| Parameter | Value |
|---|---|
| BATT_VOLT_PIN | 16 |
| BATT_CURR_PIN | 17 |
| BATT2_VOLT_PIN | 14 |
| BATT2_CURR_PIN | 15 |
PX4 Setup for Voltage/Current¶
| Parameter | Value |
|---|---|
| BAT1_V_CHANNEL | 16 |
| BAT1_I_CHANNEL | 17 |
| BAT2_V_CHANNEL | 14 |
| BAT2_I_CHANNEL | 15 |
Remote ID Subsystem¶
The Remote ID system is based on an ESP32-C3 and is designed to work with the ArduRemoteID project and Open Drone ID standards.
ArduRemoteID is is an implementation of a MAVLink and DroneCAN OpenDroneID transmitter. It aims to provide a transmitter solution for the FAA standard RemoteID requirement, meeting the transmitter component of the ASTM F3586-22 Means of Compliance. It also aims to be compliant with the RemoteID regulation in the EU.
It is the responsibility of the user to configure the ArduRemoteID firmware in a way that it is compliant with the local RemoteID regulation. For instance, in the USA it is mandatory that UAV manufacturers submit a DoC (Declaration of Conformance) to the FAA where they state that their product is compliant with the RemoteID regulation.
To flash ArduRemote ID to the ESPS32-C3, you will need a TC2030-USB-NL cable from tag-connect.com and follow the flashing instructions from the AruRemoteID project.
The ESP32-C3 is connected to the FMU via UART6, aka Telem3 (pins PG9 (RX) and PG14 (TX) from the STM32H742). You will need to configure ArduPilot/PX4 to use this UART for RemoteID.
For building ArduRemoteID for the EchoPilot AI, the following pins will need to be defined for the hardware: