Building and programming with Thingy:53

You can program the Nordic Thingy:53 by using the images obtained by building the code in the nRF Connect SDK environment.

To set up your system to be able to build a firmware image, follow the Installation guide for the nRF Connect SDK.

Board targets 

The board targets of interest for Thingy:53 in the nRF Connect SDK are listed in the following table:

Component

Board target

nRF5340 SoC - Application core

thingy53/nrf5340/cpuapp for Cortex-M Security Extensions (CMSE) disabled

thingy53/nrf5340/cpuapp/ns for CMSE enabled

nRF5340 SoC - Network core

thingy53/nrf5340/cpunet

The nRF Connect SDK uses Sysbuild by default. When you choose thingy53/nrf5340/cpuapp or thingy53/nrf5340/cpuapp/ns as the board target when building a sample or application, you will generate firmware for both the application core and network core:

The application core firmware consists of MCUboot bootloader and an application image.
The network core firmware consists of network core bootloader (B0n) and application firmware of the network core.

The build process generates firmware in two formats:

Intel Hex file (merged.hex and merged_CPUNET.hex) - Used with an external debug probe. These file contains bootloaders and applications for each core.
Binary files (zephyr.signed.bin), containing signed application firmwares for the application and network core, respectively. For convenience, the binary files are bundled in dfu_application.zip, together with a manifest that describes them. You can use the binary files or the combined zip archive to update application firmware for both cores, with either MCUboot serial recovery or OTA DFU using Bluetooth® LE.

For more information about files generated as output of the build process, see Output build files (image files).

See the following sections for details regarding building and programming the firmware for Thingy:53 in various environments.

Building Wi-Fi applications on Thingy:53 

You can use the Nordic Thingy:53 with the nRF7002 Expansion Board (EB) for Wi-Fi development. Connect the nRF7002 EB to the P9 connector on Thingy:53.

To build for the nRF7002 EB with Thingy:53, use the thingy53/nrf5340/cpuapp board target with the CMake SHIELD variable set to nrf7002eb. For example, you can use the following command when building on the command line:

west build -b thingy53/nrf5340/cpuapp -- -DSHIELD=nrf7002eb

For the compatible Wi-Fi samples in the nRF Connect SDK, see the Wi-Fi samples section.

Programming methods for Thingy:53 

You can program the firmware on the Nordic Thingy:53 using an external debug probe and a 10-pin JTAG cable, using Visual Studio Code, command line, or the Programmer app from nRF Connect for Desktop. You can also program applications running on both the network and application core using the built-in MCUboot serial recovery mode, using the Programmer app from nRF Connect for Desktop or nRF Util.

Finally, you can use the Programmer app in nRF Connect for Desktop, the nRF Programmer mobile app for Android and iOS, or nRF Util to update the preloaded application images.

Firmware update using external debug probe 

You can program the firmware on the Nordic Thingy:53 using an external debug probe and a 10-pin JTAG cable. In such cases, you can program the Thingy:53 the same way as the nRF5340 DK.

The external debug probe must support Arm Cortex-M33 (such as the nRF5340 DK). You need a 10-pin 2x5 socket-to-socket 1.27 mm IDC (Serial Wire Debug (SWD)) JTAG cable to connect to the external debug probe.

This method is supported when programming with Visual Studio Code, command line, or the Programmer app from nRF Connect for Desktop.

See also Developing with nRF53 Series for additional information.

Firmware update using MCUboot bootloader 

Samples and applications built for Thingy:53 include the MCUboot bootloader that you can use to update the firmware out of the box. This method uses signed binary files app_update.bin and net_core_app_update.bin (or dfu_application.zip). You can program the precompiled firmware image in one of the following ways:

Use the MCUboot feature and the built-in serial recovery mode of Thingy:53. In this scenario, the Thingy is connected directly to your PC through USB. For details, refer to the MCUboot bootloader section.

See Programming Nordic Thingy prototyping platforms for details on how to program the Thingy:53 using the Programmer app from nRF Connect for Desktop.
Update the firmware over-the-air (OTA) using Bluetooth LE and the nRF Programmer mobile application for Android or iOS. To use this method, the application that is currently programmed on Thingy:53 must support it. For details, refer to the FOTA over Bluetooth Low Energy section. All precompiled images support OTA using Bluetooth.

See the Updating precompiled firmware section for the detailed procedures on how to program a Thingy:53 using the nRF Programmer mobile app for Android or iOS.

Building and programming using Visual Studio Code 

Complete the following steps to build and program using nRF Connect for VS Code:

Open nRF Connect for VS Code.
Complete the steps listed on the How to build an application page in the nRF Connect for VS Code documentation.

Program the sample or application:
1. Connect the Nordic Thingy:53 to the debug out port on a 10-pin external debug probe, for example nRF5340 DK, using a 10-pin JTAG cable.
  
  Nordic Thingy:53 connected to the debug port on a 10-pin external debug probe
2. Connect the external debug probe to the PC using a micro-USB cable.
3. Make sure that the Thingy:53 and the external debug probe are powered on. (On the Thingy:53, move the power switch SW1 to the ON position.)
4. Click Flash in the Actions View.

Building and programming on the command line 

You must Set up the command-line build environment before you start building an nRF Connect SDK project on the command line.

To build and program the source code from the command line, complete the following steps:

Start the toolchain environment in a terminal window.
Go to the specific directory for the sample or application.

For example, the directory path is ncs/nrf/applications/matter_weather_station when building the source code for the Matter weather station application.
Pull the sdk-nrf repository on GitHub as described in the Install the nRF Connect SDK code and toolchain and Updating the repositories sections. This is needed to make sure that you have the required version of the nRF Connect SDK repository.
Get the rest of the dependencies using west:
```
west update
```
Build the sample or application code as follows:
```
west build -b board_target -d destination_directory_name
```
The board target should be thingy53/nrf5340/cpuapp or thingy53/nrf5340/cpuapp/ns when building samples for the application core. The image for thingy53/nrf5340/cpunet will be built automatically. See Board targets for details.
Program the sample or application:
1. Connect the Nordic Thingy:53 to the debug out port on a 10-pin external debug probe, for example nRF5340 DK, using a 10-pin JTAG cable.
  
  Nordic Thingy:53 connected to the debug port on a 10-pin external debug probe
2. Connect the external debug probe to the PC using a micro-USB cable.
3. Make sure that the Nordic Thingy:53 and the external debug probe are powered on. (On the Thingy:53, move the power switch SW1 to the ON position.)
4. Use the following command to program the sample or application to the device:
```
west flash
```
The device resets and runs the programmed sample or application.