Smol Slime

Smol Slimes, also known as nRF Trackers, uses a protocol called Enhanced ShockBurst (ESB) on Nordic Semiconductor nRF52 and nRF54L series System-on-Chip (SoC). These are very power-efficient trackers, requiring a much smaller battery that can last from days to weeks compared to traditional ESP (WiFi) SlimeVR Trackers. A Receiver, or dongle, is required to bridge communication between trackers and the SlimeVR Server. This method does not work with Quest Standalone without using a computer for OSC.

Interested, have questions, or issues with this project? Chat with us in #smol-slimes on SlimeVR Discord!

Table of Contents

• 📡 Receiver Hardware
  • USB Dongles
  • Microcontroller Boards
• 🏃 Tracker Hardware
  • Microcontroller Boards
  • Inertial Measurement Units
  • Magnetometers
  • Sensor Modules
    • IMU Modules
    • IMU + Magnetometer Modules
  • Buttons
  • Switches
  • Batteries
• Schematics
• Software
• Firmware
  • Cloning Repositories
  • Building Firmware using nRF Connect for VS Code
    • Changing Board Defines
    • Adjusting settings in the Kconfig
  • Building Firmware Manually (Linux)
    • Setup Python Venv
    • Setup nRF Connect SDK code
    • Setup Zephyr SDK
    • Compiling Manually
    • Compiling with VS Code (Without Extensions)
  • Pre-Compiled Firmware for Default Pins
    • Latest Builds (Automated)
  • Flashing Boards with Adafruits UF2 Bootloader (SuperMini / XIAO)
    • Flashing the Bootloader
    • Flashing the Firmware using UF2
    • Flashing the Firmware using adafruit-nrfutil
  • Flashing Dongles with SoftDevice/Nordic Bootloader (eByte/Nordic)
    • Flashing using nRF Connect for Desktop
    • Flashing using nRF Util
• Firmware Setup
  • Accessing the Serial Console
  • Pairing Mode
    • Tracker
    • Receiver
  • Calibration
    • Basic
    • 6-Sided
    • Magnetometer
  • Updating Firmware
  • Console Commands
    • Receiver
    • Tracker
  • Button
  • LED Codes
  • Status Codes
• Protocols
  • Tracker -> Server
  • Tracker <-> Receiver
  • Tracker <-> Server
  • Receiver <-> Server
• Troubleshooting
  • Check Console Logs
    • Improving Logging
    • SWD Debugging
• Links
  • Discord
  • Firmware Source Code
• Community projects
  • Firmware
  • Hardware

📡 Receiver Hardware

It is essential to use boards equipped with high-quality antennas to ensure signal integrity and range. Hardware featuring PCB antennas is generally the best option for use as a receiver.

USB Dongles

These dongles feature a well-optimized PCB antenna. If you experience issues with signal integrity, it is advisable to use a USB extension cable.

Microcontroller Boards

These boards utilize antenna designs that are not optimized for range. If you are using the same boards for both trackers and receiver, they will likely perform poorly without modifications.

🏃 Tracker Hardware

Before you begin, determine how many trackers you may need.

Trackers are required to be equipped with a battery and an inertial measurement unit (IMU). A magnetometer is optional.

Buttons can be incorporated to control the tracker, while a slide switch can be utilized to physically disconnect the tracker's battery.

Microcontroller Boards

Inertial Measurement Units

• BMI270
• ICM-42688-P
• ICM-42688-V
• ICM-45686
• ISM330BX
• ISM330DHCX
• ISM330DLC
• LSM6DS3
• LSM6DS3TR-C
• LSM6DSL
• LSM6DSM
• LSM6DSO
• LSM6DSR
• LSM6DSV
• LSM6DSV16B

Magnetometers

• AK09940
• BMM150*
• BMM350*
• IIS2MDC
• IST8306
• IST8308
• LIS2MDL
• LIS3MDL*
• MMC5983MA

*Sensor driver has not been tested.

Sensor Modules

IMU Modules

Some of the supported sensor modules are described on the IMU Comparison page. Please note that the most common sensor modules are not supported.

IMU + Magnetometer Modules

Meia, a member of the SlimeVR Discord, produces and sells sensor modules with an onboard magnetometer. These modules are compatible with standard sensor modules, and their form factor is designed for stacked builds.

Buttons

Push buttons and momentary switches are utilized to control the tracker. The functions of this button—Reset, Calibration, Pairing, Deep Sleep, and entering DFU Mode—depend on the number of press combinations. A tracker can be equipped with either a reset button, a user-specified (SW0) button, or both.

The reset button is designed to support all functionalities. If an user-specified button (SW0) is defined, it will be utilized instead.

If a button is unavailable, tweezers can be used to short the pins for the initial tracker setup.

Switches

A slide switch can be used to physically disconnect a battery. Some boards have a high standby power draw and will require a switch.

If a switch is not utilized, a tracker can enter Deep Sleep mode by pressing and holding down the user-specified button (SW0).

Batteries

Most boards support a 3.7V Li-ion/LiPo battery. Typically, these batteries have a maximum charge rate of 1C, which corresponds to a one-hour charge time. Do not use a battery if its charge rating will be exceeded.

To extend the lifespan of the battery, a significantly lower charge rate of approximately 0.5C is recommended.

Schematics

Default SuperMini Build	Stacked 🥪 SuperMini Build1

Software

For those interested in building the firmware yourself:

• Git Client
• nRF Connect for Desktop with various integrated tools:
  • Programmer (for flashing Nordic and eByte Dongles only)
  • Serial Terminal (for sending commands to your Receiver/Trackers, see alternatives)
  • Toolchain Manager (for automatic setup of the toolchain for building firmware)
    • 2.9.0 (Inside Toolchain Manager) Do not use a newer version!
  • NOTE: Installing the Segger J-Link is not necessary for pre-defined boards.
• VS Code (For development purposes only)
  • nRF Connect for VS Code (Recommended)
    • Install within VS Code extension tab, see the video tutorial
    • You may either install the extension itself or the extension pack for additional development tools
  • You may also set up a manual build environment in VS Code as the extension is known to fail on some certain Linux distributions.
• SlimeVR Server
  • 0.13.2 or later version

You only need the following if you are using precompiled firmware:

• nRF Connect for Desktop (Programmer) for flashing Nordic or eByte Dongles only
• nRF Connect for Desktop (Serial Terminal) for sending commands to your Receiver/Trackers, see alternatives
• SlimeVR Server
  • 0.13.2 or later version

Firmware

Cloning Repositories

1. Open the Command Prompt by typing cmd in the Start Menu.
2. Navigate to the directory where you want to clone the repositories.. (Type "cd" followed by a space and then the full path to the desired folder or drive.)
3. Cloning SlimeNRF Receiver Repository.

git clone --single-branch --recurse-submodules -b master https://github.com/SlimeVR/SlimeVR-Tracker-nRF-Receiver.git

4. Cloning the SlimeNRF Tracker Repository.

git clone --single-branch --recurse-submodules -b master https://github.com/SlimeVR/SlimeVR-Tracker-nRF.git

Note: It is recommended to clone to a file path that does not contain whitespace or Unicode characters. You may encounter errors when building the firmware.

Building Firmware using nRF Connect for VS Code

1. Launch VS Code using the nRF Connect's Toolchain Manager.
2. Open the folder for one of the repositories.
3. Make any pin changes or necessary adjustments to boards\MANUFACTURER\BOARD_NAME.dts.
4. Click on the nRF Connect tab located on the left side of your screen, approximately halfway down.
5. Under "Applications" , click on "+ Add build configuration."
6. Select a preset from the "Board Target".
7. Scroll down and click the "Build Configuration" button.

Note: For trackers, settings can be found in the "nRF Kconfig GUI" under "Actions" and expand the "SlimeNRF" section.

Changing Board Defines

Board defines can be found in \boards\ for overlays (Boards within the Zephyr library), while custom boards are located in boards\MANUFACTURER\BOARD_NAME.dts.

1. Navigate to the board's .dts file.
2. The I2C (SCL/SDA) lines can be assigned to different pins. Ensure that you are using "High Frequency" pins and that you change the pins for both lines accordingly.
3. SW0 can be enabled by uncommenting (removing the // ) from the lines below the description comment. If you are using VS Code, you can select the lines and press Ctrl / if you are using VS Code. Additionally, redefine the GPIO pin if necessary.
4. The INT (int0-gpios) can be redefined in the Zephyr user section.
5. The CLK (clk-gpios) can be uncommented and redefined if you are using an IMU with an external clock or crystal oscillator, such as the ICM-42688 or ICM-45686.

Adjusting settings in the Kconfig

1. Navigate to the nRF Connect tab of VS Code.
2. Build the desired board once.
3. A section titled Actions should be displayed on the left navigation panel.
4. Select your built board under Applications, then scroll down to the Actions section.
5. Double-click nRF Kconfig GUI.
6. Scroll down to the SlimeNRF section.
7. Enable or disable any necessary configurations, or adjust them as needed.
8. Click the "Apply" button, then click the "Save to File" button.
9. If prompted to select a file to save, choose prj.conf.
10. Click the "Pristine Build" button located next to Build in the Actions section.

Building Firmware Manually (Linux)

This is only recommended if you are experiencing issues with nRF Connect for Desktops Toolchain Manager or nRF Connect for VS Code, as you will need to manually set up the toolchain.

Setup Python Venv

Using a virtual environment (venv) will keep all build tools for Zephyr, such as west, contained.
python3 -m venv ~/.venv/nrf52
source ~/.venv/nrf52/bin/activate (Run the setup whenever you use or modify it.)
pip3 install west

Setup nRF Connect SDK code

Please select an appropriate folder for installing the toolchain, such as ~/.toolchain-nrf52.
Then execute:
west init -m https://github.com/nrfconnect/sdk-nrf --mr v2.9.0 nrf52-sdk-2.9.0
cd nrf52-sdk-2.9.0
west update (This will download dozens of Git repositories; it may take some time.)
pip install -r zephyr/scripts/requirements-base.txt (Install the remaining requirements for building.)
west zephyr-export (This will register the necessary CMake files in your home directory.)
If you move this folder, you simply need to re-run the last command.

Setup Zephyr SDK

The nRF Connect SDK depends on the Zephyr SDK, so please return to your toolchain folder (e.g. ~/.toolchain-nrf52) to install it:
wget -q https://github.com/zephyrproject-rtos/sdk-ng/releases/download/v0.17.0/zephyr-sdk-0.17.0_linux-x86_64_minimal.tar.xz
tar xf zephyr-sdk-0.17.0_linux-x86_64_minimal.tar.xz -C .
cd zephyr-sdk-0.17.0
./setup.sh -c -t arm-zephyr-eabi (This will register the necessary CMake files in your home directory.)
If you move this folder, you simply need to re-run the last command.

Compiling Manually

Assuming your toolchain is installed in ~/.toolchain-nrf52 and you are in the firmware directory:

source ~/.venv/nrf52/bin/activate
source ~/.toolchain-nrf52/nrf52-sdk-2.9.0/zephyr/zephyr-env.sh
west build --board BOARD --build-dir build . -- -DNCS_TOOLCHAIN_VERSION=NONE -DBOARD_ROOT=.

Replace BOARD with your specific board (e.g. supermini_uf2/nrf52840 for the SuperMini, nrf52840dongle/nrf52840 for a dongle receiver).
The compiled firmware will be located at PROJECT_DIR/build/PROJECT_DIR/zephyr/zephyr[.hex|.uf2].

Compiling with VS Code (Without Extensions)

Assuming your toolchain is installed in ~/.toolchain-nrf52, use the following tasks, which should be placed in .vscode/tasks.json:

{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "Build",
            "type": "shell",
            "group": "build",
            "command": "source",
            "args": [
                "~/.venv/nrf52/bin/activate", "&&",
                "source", "~/.toolchain-nrf52/nrf52-sdk-2.9.0/zephyr/zephyr-env.sh", "&&",
                "west", "build", "--board", "BOARD", "--build-dir", "build",
                "${workspaceFolder}", "--",
                "-DNCS_TOOLCHAIN_VERSION=NONE", "-DBOARD_ROOT=${workspaceFolder}"
            ]
        },
    ]
}

Replace BOARD with your specific board (e.g. supermini_uf2/nrf52840 for the SuperMini, nrf52840dongle/nrf52840 for a dongle receiver).
The compiled firmware will be located at PROJECT_DIR/build/PROJECT_DIR/zephyr/zephyr[.hex|.uf2].

Pre-Compiled Firmware for Default Pins

Latest Builds (Automated)

Flashing Boards with Adafruits UF2 Bootloader (SuperMini / XIAO)

Flashing the Bootloader

1. You can download them here: https://github.com/adafruit/Adafruit_nRF52_Bootloader/releases
2. For the SuperMini, download update-nice_nano_bootloader-x.x.x_nosd.uf2. For the XIAO, download update-xiao_nrf52840_ble_sense_bootloader-x.x.x_nosd.uf2. (The appropriate non-Sense version does not update the bootloader.)
3. Connect the device to your computer using a USB data cable.
4. The device should initially start in DFU mode when new and without a bootloader. The LED should fade on and off.
5. If the device's LED is not fading on and off, press the reset button twice (or briefly short the RST and GND pins) twice within 0.5 seconds. If the device has existing SlimeNRF firmware, reset it four times.
6. Navigate to your Downloads folder and copy the UF2 file.
7. Navigate to the Mass Storage Drive (ex. NICENANO/XIAO-SENSE) from ThisPC.
8. Paste the file there, and the window should close, causing the device to reboot.

Flashing the Firmware using UF2

1. Connect the device to your computer using a USB data cable.
2. The device should initially start in DFU mode when new and without a bootloader. The LED should fade on and off.
3. If the device's LED is not fading on and off, press the reset button twice (or briefly short the RST and GND pins) twice within 0.5 seconds. If the device has existing SlimeNRF firmware, reset it four times.
4. Navigate to your local Receiver or Tracker repository, then go to build\REPOSITORY_NAME\zephyr\.
5. Copy zephyr.uf2 file.
6. Navigate to the Mass Storage Drive (ex. NICENANO/XIAO-SENSE) from ThisPC.
7. Paste the file there, and the window should close, causing the device to reboot.

Flashing the Firmware using adafruit-nrfutil

This uses the bootloaders serial protocol to flash it using command line tools.
See Adafruit nRF52 nrfutil Github Repo for install and usage instructions.
Recommended: Use a python venv to install the adafruit-nrfutil python tool.

Flashing Dongles with SoftDevice/Nordic Bootloader (eByte/Nordic)

This bootloader will appear as "Open DFU Bootloader" by Nordic Semiconductor. Currently, the only confirmed method for flashing firmware onto these devices is through nRF Connect for Desktop, though it should also be possible to use nRF Util (but it is more complex and practically equivalent).
NOTE: Installing the Segger J-Link is not required for this bootloader.
NOTE: On Linux, nRF Connect for Desktop installs nodeJS tools into ~/.nrfconnect-apps/, nRF Util installs binary tools into ~/.nrfutil/.

Flashing using nRF Connect for Desktop

1. Open "Programmer" in the nRF Connect.
2. Press the reset button, and the LED should begin to fade on and off, placing the device in DFU Mode. For eByte dongle, this is the right button. For Nordic dongle, it is the side button (not the round white button).
3. In the top left corner, select your Device.
4. Click on "Add File".
5. Navigate to your local Receiver repository, then select the file located at build\REPOSITORY_NAME\zephyr\zephyr.hex.
6. Click the "Write button".

Flashing using nRF Util

Not documented yet. Relevant documentation:

• device command documentation
• nrf5sdk pkg building guide

Firmware Setup

Accessing the Serial Console

You can interact with the firmware by connecting to the serial console it provides, which is used for pairing and calibration.
The following examples will utilize nRF Connect for Desktop; however, you may choose from a wide variety of alternative tools.
For example, by using the standard Linux screen utility, you can access the serial console as follows:
sudo screen /dev/ttyACMX 115200
You can determine which serial port to use by running sudo dmesg after connecting your nRF device.
For Windows, there are similar tools available, such as PuTTY that you can use to access a serial console.

Pairing Mode

Tracker

Method 1: Console

1. Launch nRF Connect for Desktop.
2. Open the Serial Terminal in nRF Connect.
3. Ensure that your tracker is connected to your computer using a cable.
4. In the top left corner, select your tracker from the Device menu.
5. Click the "Connect to Port" button.
6. Type pair into the console.

Method 2: Button

1. Press the Reset button (or short RST/GND pins) or the Function button (if SW0 is defined) three times.

The device's LED should blink once every second.

Receiver

1. Launch nRF Connect for Desktop.
2. Open the Serial Terminal in nRF Connect.
3. Ensure that your tracker is connected to your computer using a cable.
4. In the top left corner, select your dongle from the Device menu.
5. Click the "Connect to Port" button.
6. Type pair into the console.

The device's LED should blink once every second.

Once the trackers are paired, the LED indicator should stop blinking once per second. To exit pairing mode on the Receiver, type reboot in the console, or press the left button once on the eByte Dongle, or the round white button once on the Nordic Dongle.

Calibration

Basic

Method 1: Console

1. Launch nRF Connect for Desktop.
2. Open the Serial Terminal in nRF Connect.
3. Ensure that your tracker is connected to your computer using a cable.
4. In the top left corner, select your tracker under Devices.
5. Click the "Connect to Port" button.
6. Type calibrate into the console while the tracker is placed on a flat surface.
7. Wait for the logs to reboot and print out again.

Method 2: Button

1. Press the Reset or SW0 (Functional) button twice, then place the tracker on a flat surface and allow it to remain still for a few seconds.

6-Sided

1. Ensure that the power switch is turned on so that the tracker can operate on battery power when unplugged.
2. Launch the nRF Connect for Desktop.
3. Open the Serial Terminal in nRF Connect.
4. Ensure that your tracker is connected to your computer using a cable.
5. In the top left corner, select your tracker under Devices.
6. Click the "Connect to Port" button.
7. Enter the 6-side command in the console. (Currently, there is no button combination available to initiate this calibration.)
8. Follow the console log while rotating the sides on a flat surface. Leave the cable side for last.
9. When prompted for the final side, disconnect your USB cable and position the side with the USB port on a flat surface.
10. Wait a moment until the calibration is complete.

Magnetometer

1. Please note that this calibration is passively active and does not require any command or button press combination to initiate.
2. Rotate your tracker 360 degrees on each of the six sides of the tracker while it is placed on a flat surface.

Note: The LED will blink when you place it flat on each side and will blink continuously when it is ready to save.

Updating Firmware

1. If your receiver requires a firmware update, please do this first.
2. Open the Serial Terminal in nRF Connect's Serial Terminal.
3. Select your Receiver from the Device list.
4. Click the "Connect to Port" button.
5. Enter clear to unpair all of your trackers from the Receiver. The Receiver will automatically enter pairing mode.
6. Connect the tracker to your computer using a USB cable and ensure that the power switch is turned on. This allows the tracker to operate on battery power when unplugged for 6-Side calibration.
7. Select your tracker from the Device List.
8. Click the "Connect to Port" button.
9. Enter dfu to go into DFU Mode.
10. Copy the UF2 file to your tracker.
11. Enter 6-side to begin the 6-Side calibration.
12. After completing the 6-side calibration, enter calibrate to adjust the ZRO.
13. Enter pair to enter pairing mode.
14. Wait for the tracker to pair with the Receiver, and then disconnect.
15. Please repeat process for all trackers.
16. Select your Receiver from the Device list.
17. Click the "Connect to Port" button.
18. Enter reboot to exit pairing mode.

Console Commands

Receiver

• info - Get device information
• list - Get paired devices
• reboot - Soft reset the device
• pair - Enter pairing mode
• clear - Clear stored devices
• dfu - Enter DFU bootloader (only available if your device has one)
• uptime - Get device uptime
• meow - Meow!

Tracker

• info - Get device information
• reboot - Soft reset the device
• calibrate - Calibrate sensor ZRO
• 6-side - Calibrate 6-side accelerometer
• pair - Enter pairing mode
• dfu - Enter DFU bootloader (only available if your device has one)
• uptime - Get device uptime
• meow - Meow!

Button

• Reset - 1 Press
• Calibration - 2 Presses
• Pairing Mode - 3 Presses
• DFU Bootloader - 4 Presses
• Deep Sleep - Press and Hold

LED Codes

• 1 short blink per second - Pairing mode.
• 1 long blink per second - Low battery.
• 2, 3, 4 long blinks every 5 seconds - Error.
  • 2 blinks - Sensor error.
  • 3 blinks - Connection error.
  • 4 blinks - Hardware error.
• Fade on and off - DFU mode.
• Very short blink - Normal operation or wake on motion.
• While plugged in: Pulsing - Charging.
• While plugged in: Solid - Fully charged.

Status Codes

Status codes consist of one or more status values (added together) listed below:

• SYS_STATUS_SENSOR_ERROR - 1,
• SYS_STATUS_CONNECTION_ERROR - 2
• SYS_STATUS_SYSTEM_ERROR - 4
• SYS_STATUS_USB_CONNECTED - 8
• SYS_STATUS_PLUGGED - 16

Protocols

type    |id      |packet data                                                                                                                  |
0       |id      |proto   |batt    |batt_v  |temp    |brd_id  |mcu_id  |imu_id  |mag_id  |fw_date          |major   |minor   |patch   |rssi    | info
1       |id      |q0               |q1               |q2               |q3               |a0               |a1               |a2               | full precision quat
2       |id      |batt    |batt_v  |temp    |q_buf                              |a0               |a1               |a2               |rssi    | reduced precision quat
3       |id      |svr_stat|status  |resv                                                                                              |rssi    | status

type    |id      |packet data                                                                                                                  |
64      |id      |addr                                                 |resv                                                                   | pairing data from tracker
65      |id      |addr                                                 |addr_rcv                                             |channel |resv    | pairing data to tracker
66      |id      |addr                                                 |time                                                                   | timing data to tracker (why addr?)
67      |id      |addr                                                 |cmd_data                                                               | some command to tracker? (need to be part of timing?)

type    |id      |packet data                                                                                                                  |
128     |id      |addr                                                 |cmd_data                                                               | some command to tracker? (field too large?)
128     |id      |addr                                                 |ack                                                                    | acknowledge?

type    |id      |packet data                                                                                                                  |
192     |id      |resv                                                                                                                         | 192+ should be some interaction b/w receiver and server
254     |resv                                                                                                                                  | filler, this packet is ignored by the server
255     |id      |addr                                                 |resv                                                                   | tracker id association

Troubleshooting

Check Console Logs

1. Launch nRF Connect for Desktop.
2. Open the Serial Terminal in nRF Connect.
3. Ensure that your tracker is connected to your computer using a cable.
4. In the top left corner, select your tracker under Devices.
5. Click the "Connect to Port" button.

Improving Logging

• In order to change the log level you see (e.g., LOG_DBG instead of just LOG_INF), you may need to edit the LOG_MODULE_REGISTER macro at the top of the relevant module or file you are interested in and then recompile the firmware.
  

• If you need to view the logs prior to connecting to the serial console, you may need to explicitly initiate the logging backend by adding the following code snippet in the main function of main.c:

  const struct log_backend *backend = log_backend_get_by_name("log_backend_uart");
  log_backend_enable(backend, backend->cb->ctx, CONFIG_LOG_MAX_LEVEL);
  

  Additionally, add the following include to the top of the main.c file:
  

  #include <zephyr/logging/log_ctrl.h>
  

• If you notice that the logs are truncated at a certain point, the buffer size may be insufficient. This issue has not been fully resolved yet, as simply increasing CONFIG_LOG_BUFFER_SIZE in prj.conf does not appear to be effective.

SWD Debugging

• Instructions for the Raspberry Pi, Raspberry Pi Pico, ST-Link V2, and other debuggers will be added in the future. Resource: https://github.com/joric/nrfmicro/wiki/Bootloader

J-Link, nRF52/nRF52840 Development Kit, and OB-ARM Debugger

1. Install J-Link Software and Documentation Pack: https://www.segger.com/downloads/jlink/#J-LinkSoftwareAndDocumentationPack
2. Download Bootloader HEX File for your device (SuperMini - nice_nano_bootloader-x.x.x_sxxx_x.x.x.hex, XIAO - xiao_nrf52840_ble_sense_bootloader-x.x.x_sxxx_x.x.x.hex): https://github.com/adafruit/Adafruit_nRF52_Bootloader/releases
3. Connect Debugger to SWD IO, CLK, and GND Pins. (It is safer to power up your device by plugging into USB instead of using the VDD pin)

Flashing/Fixing bricked bootloader

1. Launch "J-Flash Lite."
   • Target Device: NRF52840_XXAA
   • Target Interface: SWD
   • Speed: 4000
2. Click the "OK" button.
3. Click on the "..." button and select the downloaded HEX file.
4. Click the "Program Device" button.

RTT/Debugging

1. Launch "RTT Viewer."
   • Connection to J-Link: USB
   • Specify Target Device: NRF52840_XXAA
   • Force go on connect: Checked
   • Target Interface & Speed: SWD / 4000 hKz
   • RTT Control Block: Auto Detect
2. Click the "OK" button.

Recommended Hardware/Tools

OB-ARM Debugger: https://www.aliexpress.us/item/3256806507382540.html

Pogo Pin Test Clip (1.5mm Pitch, 4P, Single Row): https://www.aliexpress.us/item/3256805646654844.html

Note: This clip is designed exclusively for SuperMini. While there are less expensive clips available, they do not convert the pins from a 1.5mm pitch to a 2.54mm pitch suitable for Dupont wires.

Links

Discord

SlimeVR Discord: https://discord.gg/SlimeVR

Firmware Source Code

Community projects

Firmware

Hardware

Created by Shine Bright ✨, Depact and Seneral