Board profiles

A board profile is a .jhp file with the hardware of a board model: the chip, the bootloader, the display, the sound, the SD card and the I2C bus. It holds nothing from your project: no port, no network, no program.

With a profile you set up a board of the project, which holds the profile's hardware plus its name, its port, the network and the program it starts. From the project's board comes the boot.cfg, the file that travels to the board and that the VM reads when it starts.

	What it is	Where it is
Board profile	The hardware of a board model. It is valid for all your projects.	A `.jhp` in your user folder (see Factory profiles when you update).
Project board	A board of yours: the hardware of a profile, with its name, its port, the network and the program.	`Config/ESP32/device_profiles.json`, in the project.
`boot.cfg`	What the VM reads when it starts: the project's board, without what only the IDE uses.	`Build/flash/boot.cfg`, in the project, and in the board's file memory.

The boards that have a profile, in Supported boards.

ESP32 Tools

ESP32 Tools is the window for the project's boards. You open it with Build › Target › Manage boards... or with Config › Platform › ESP32.

At the top, Devices: the project's board you are working on (Device), its name (Name) and the New, Forget and Save Device buttons (see The boards of the project). Below, a line with its identifier, its chip and its last port: "Profile ID: … | Chip: … | Last COM: …".
Port and Baud: the board's port and the speed at which esptool writes to it; esptool is the tool the IDE writes boards with. Scan Ports looks for the ports, lists them in the Output and picks the one that looks most like a board: a USB one.
On the left, the pages: Hardware, Storage, Network, Display and Audio, under Configure, and Deploy, under Actions.

Page	What it has	Where it is explained
Hardware	The chip, the flash and the bootloader; the device name; the list of profiles. On the ESP32-S31, the USB keyboard.	Here, below
Storage	The program that starts (Application File), the SD card (SD Card), the space for the files (LittleFS Storage Check) and the I2C bus (I2C Bus).	The I2C bus, here; the rest, in Display, sound, SD and network
Network	WiFi, the time from NTP, and MQTT.	Display, sound, SD and network
Display	The display: controller, size, rotation, bus and pins.	Display, sound, SD and network
Audio	The sound: I2S or buzzer, and its pins.	Display, sound, SD and network
Deploy	The board's summary, and the buttons that write to it: Flash Firmware and Upload Program.	Flash the firmware and run

The Hardware page

Control	What it does
MCU model	The board's chip: ESP32, ESP32-S3, ESP32-P4 or ESP32-S31. It says which VM Flash Firmware writes and which chip esptool talks to.
Get Info	Reads the board's chip, flash memory and MAC, and writes them to the Output.
Flash Size	The size of the flash memory: 4 MB, 8 MB, 16 MB, 32 MB or Auto detect, the default. When it writes to the board, the IDE reads it from the board and puts it here.
Flash Mode	The bootloader that Flash Firmware writes. The options depend on the chip; the profiles have 40MHz-DIO on the ESP32 and the ESP32-P4, and 80MHz-DIO on the ESP32-S3 and the ESP32-S31.
USB keyboard	Only with the ESP32-S31: the keyboard on the USB-A port.
Device Name	The device's name. With WiFi, the board uses it as its name on the network. Generate makes it from the board's MAC.
MAC Address and Get MAC	The board's MAC: Get MAC reads it and puts it here.
Hardware Profiles	The list of profiles, with Apply, Import and Export (see Choose, import and export).

Get Info, Generate and Get MAC also replace Device Name with the one that comes from the MAC: a name that starts with ESP32, whatever the chip, followed by the MAC in hexadecimal, in another order. And if the MQTT Client ID is still the default one, or empty, they replace it with that same name.

What a profile holds

A profile is a JSON file. Each part goes to a page of ESP32 Tools:

In the profile	What it is	In ESP32 Tools
`target_chip`	The chip	Hardware › MCU model
`boot_config`	The bootloader and the writing speed	Hardware › Flash Mode and, at the top, Baud
`sdcard`	The SD card and its pins; on the ESP32-S31, also the pin that powers it	Storage › SD Card
`i2c`	The board's I2C bus: the port (0 or 1), SDA, SCL and the frequency (100000 or 400000)	Storage › I2C Bus
`tft`	The display	Display
`audio`	The sound	Audio
`usb_host`	The USB keyboard, only on the ESP32-S31	Hardware › USB keyboard

A profile doesn't hold Name, Port, Flash Size, Device Name, Application File or anything from the Network page. That's why you can give a profile to someone else: it doesn't carry your passwords.

The VM doesn't use the I2C bus. The scene editor's I2C gamepad uses it, opening the bus with those pins (see The I2C gamepad), and so does the I2C drivers manager, which puts them in the code it gives you. With -1 in SDA and SCL, the board has no bus.

This is the whole Binghe_ESP32_1.96 profile:

{
  "profile_version" : "1.0",
  "target_chip" : "ESP32",
  "boot_config" : {
    "bootloader_index" : 0,
    "bootloader_name" : "40MHz-DIO",
    "baud_rate_index" : 7
  },
  "sdcard" : {
    "enable" : false,
    "drive_master" : 0,
    "miso" : 2,
    "mosi" : 15,
    "sclk" : 14,
    "cs" : 13
  },
  "tft" : {
    "type" : "ST7789",
    "width" : 170,
    "height" : 320,
    "offset_x" : 35,
    "offset_y" : 0,
    "offset_rotation" : 0,
    "invert" : true,
    "spi_host_text" : "SPI 2 (VSPI)",
    "spi_mode_text" : "Mode 0",
    "freq_write_text" : "40 Mhz",
    "freq_read_text" : "16 Mhz",
    "dma_channel_text" : "Automatic",
    "use_lock" : true,
    "sclk" : 18,
    "mosi" : 23,
    "miso" : 19,
    "dc" : 2,
    "cs" : 15,
    "rst" : 4,
    "bl" : 32
  }
}

It has no audio and no i2c: when you apply it, the sound is left off and the board is left without an I2C bus.

Choose, import and export

The Hardware Profiles list, on the Hardware page, has the profiles in your user folder, in alphabetical order and without the extension. Below it, a line sums up the chosen one: the chip, the display, the SD card and the sound. For example, "ESP32 | Display: ST7789 170x320 SPI | SD: off | Audio: off".

Button	What it does
Apply	Copies the chosen profile to the board you are editing, the one in Device: the chip, Flash Mode, Baud, the SD card, the I2C bus, the display and the sound (and on the ESP32-S31, the USB keyboard and the SD card's power). It doesn't touch its name, its port, Flash Size, Device Name or the network.
Import	The same as Apply, but with a `.jhp` from any folder. It doesn't add it to the list: to have it there, export it afterwards.
Export	Saves the hardware of the board you are editing to a `.jhp`. The dialog opens in your profile folder: saved there, the profile is in the list, already chosen.

Apply and Import change what the window shows, but don't save anything: click Save Device to save it in the project's board. The Output says "Hardware profile applied. Use Save Profile to persist it.": the button is Save Device.

If the profile is for another chip, MCU model changes with it, and so do the Flash Mode options.

Export with a name of your own

If you export with the name of a factory profile, you replace it, and the IDE no longer updates it in later versions (see the next section). Use a name of your own, like MyBoard_ST7789.jhp.

Factory profiles when you update

The factory profiles are the installation's, in Resources\HWProfiles (by default, C:\Program Files\JARU IDE\Resources\HWProfiles). The IDE works with a copy in your user folder, AppData\Local\JaruIDE\HWProfiles: it is the one the list shows and where Export saves.

Every time it starts, JARU IDE brings that copy up to date:

It copies the profiles you are missing, like the new ones of a version.
It replaces the ones that are still as an earlier version left them. It recognizes them by a fingerprint of their content: factory_versions.txt, next to the installation's profiles, keeps one for every version each profile has had.
It doesn't touch the ones you edited, or yours.
It deletes the copies of profiles that no longer exist or have been renamed, if you didn't edit them. One you edited stays, with its old name.

In 0.9.7, the profiles were renamed after the board's brand and model. The 0.9.6 ones are now called:

Up to 0.9.6	From 0.9.7
`Binghe_1_96`	`Binghe_ESP32_1.96`
`Diymore_2_8`	`Diymore_ESP32_2.8`
`FreeNove_FNK0086`	`Freenove_FNK0086`
`FreeNove_FNK0104`	`Freenove_FNK0104`
`Generic_SH8601Z_QSPI`	`Generic_SH8601Z_QSPI_(template)`
`LilyGoT4V1_3`	`LILYGO_T4_v1.3`
`LilyGoTWatchS3`	`LILYGO_T-Watch_S3`
`SC01Plus_i80`	`Wireless-Tag_WT32-SC01_Plus`
`WaveShareESP32P4_ST7701_4_3`	`Waveshare_ESP32-P4-WIFI6-Touch-LCD-4.3`
`WaveShareESP32P4_ST7703_720`	`Waveshare_ESP32-P4-WIFI6-Touch-LCD-4B`
`WaveShareESP32S3TouchAMOLED1_8`	`Waveshare_ESP32-S3-Touch-AMOLED-1.8`
`WaveShareS3LCD2_8`	`Waveshare_ESP32-S3-Touch-LCD-2.8`

JARU_JaruCade and Espressif_ESP32-S31-Korvo-1 are new in 0.9.7.

Your projects don't change when you update: each project board keeps its own copy of the hardware. The name of the profile it came from is only a reference.

The boards of the project

The project's boards are saved in the project itself, in Config/ESP32/device_profiles.json. Each one holds its name, its chip, its last port, Flash Size, the name of the profile it came from and its whole configuration: that of the Hardware, Storage, Network, Display and Audio pages.

Control	What it does
Device	Chooses which of the project's boards you work on. The one you choose becomes the active board.
Name	The board's name, the one shown in Device and in the Target menu.
New	Starts a new board. If your recent projects have saved boards, it first offers a menu: Empty profile, to start it from scratch, or From and a project's name, to copy one of its boards to this one. The copied one is saved at once.
Forget	Removes the chosen board from the project, after asking (“Forget device "…"?”).
Save Device	Saves the board as you see it on all the pages, makes it the active board and generates the `boot.cfg`. A new one without a name is called after its chip plus "profile", for example "ESP32-S3 profile".

If the project has no board, opening ESP32 Tools creates one, Default ESP32, with the default values, and the Output says "Default ESP32 device profile created for this project.".

The menu of the Target button, on the Build tab, lists the project's boards with their chip and their port, and Manage boards... opens ESP32 Tools. Choosing a board in Target also makes it the active board: the one ESP32 Tools shows and the one Run takes the program to (see The interface). And the other way round: if Target is a board, choosing another one in Device, saving one with Save Device or creating one with New puts it in Target too. With Target on Windows, what you choose in ESP32 Tools doesn't change it. If you use Forget to remove the board that is in Target, Run warns with "Target not available" and, when you open the project again, the button says Target: (missing): choose another board in Target.

When you close ESP32 Tools with unsaved changes, it asks first ("The ESP32 configuration has unsaved changes."): Yes saves them, like Save Device; No closes without saving them, and Cancel keeps the window open.

The examples that come with JARU IDE carry a board, JARU JaruCade. How to swap it for yours, in Supported boards.

The passwords go with the project

The Network page saves the WiFi and MQTT passwords as they are, in Config/ESP32/device_profiles.json and in the boot.cfg, inside the project. The boot.cfg also goes to the board. If you share the project or push it to Git, they go with it.

The `boot.cfg`

The boot.cfg is the file the board's VM reads when it starts: what the board is like (display, sound, SD card and network) and which program it starts. It is a JSON file.

The IDE generates it in Build/flash/boot.cfg, inside the project, from the active board as it is saved in the project, not from what the window shows. It generates it when you click Save Device, Upload Program, Check Storage and Run with a board in Target, before preparing the files, and says so in the Output: "Deployment configuration generated from active device profile:", with its path. Run and Upload Program take it to the board with the program (see Flash the firmware and run).

It holds the configuration of the project's board minus what only the IDE uses to write to it: the chip, the port, Baud, Flash Mode and Flash Size.

Part	What it holds	Where you change it
`dev_id`	The device's name.	Hardware › Device Name
`file_version`	The version of the format. The VM doesn't read it.	—
`jaru`	`jaru_app`: the program the VM starts, the name of the project's main file without the extension.	The IDE sets it
`sdcard`	Whether the SD card is used, whether it is the main drive, and its pins.	Storage › SD Card
`i2c`	The I2C bus. The VM doesn't read it (see What a profile holds). It is only there if the board has a bus.	Storage › I2C Bus
`tft`	The display.	Display
`audio`	The sound.	Audio
`wifi`	The WiFi network.	Network
`mqtt`	The MQTT broker.	Network
`ntp`	The time server.	Network
`usb_host`	The USB keyboard. Only on the ESP32-S31.	Hardware › USB keyboard

This is how the one in an example with the JaruCade starts. The IDE writes it on a single line; here it is laid out and cut short:

{
  "dev_id": "ESP32C11FB6082801",
  "file_version": "0.9.0",
  "jaru": {
    "jaru_app": "SpaceIntruders"
  },
  "sdcard": {
    "enable": false,
    "drive_master": 0,
    "miso": 2,
    "mosi": 15,
    "sclk": 14,
    "cs": 13
  },
  "i2c": {
    "port": 0,
    "sda": 11,
    "scl": 10,
    "freq": 400000
  },
  "tft": {
    "type": "ST7789",
    "width": 240,
    "height": 320,
    …

Don't edit it by hand: the IDE writes it again on every Run and every Upload Program. Change the board in ESP32 Tools.
What is missing from the file, the VM takes from its defaults.
The same file serves Windows. Run on Windows writes the Windows VM's configuration to Build/flash/boot.cfg (see The Windows configuration). Each Run leaves it as its target needs it.
If the board has no boot.cfg, or it is wrong, the VM doesn't start the program: what the serial monitor says then, in If the board does not start.

Known issues

Application File goes back to the main file. What you choose with ... in Application File doesn't last: Run, Upload Program and Check Storage change it to the project's main file before they start, so the board always starts the main program. To make it start another one, make that one the main file in the project.
Close the serial monitor before reading the board. Get Info, Generate, Get MAC and Check Storage use the board's port without moving the serial monitor aside, and if it is open on that port, they can't read the board. Close it first with Close Serial.

All the known issues of JARU, together, are in Known issues.

ESP32 Tools​

The Hardware page​

What a profile holds​

Choose, import and export​

Factory profiles when you update​

The boards of the project​

The boot.cfg​

Known issues​