Perfiles de placa

Un perfil de placa es un fichero .jhp con el hardware de un modelo de placa: el chip, el arranque, la pantalla, el sonido, la tarjeta SD y el bus I2C. No lleva nada de tu proyecto: ni el puerto, ni la red, ni el programa.

Con un perfil preparas una placa del proyecto, que lleva el hardware del perfil y además su nombre, su puerto, la red y el programa que arranca. De la placa del proyecto sale el boot.cfg, el fichero que viaja a la placa y que la VM lee al arrancar.

	Qué es	Dónde está
Perfil de placa	El hardware de un modelo de placa. Vale para todos tus proyectos.	Un `.jhp` en tu carpeta de usuario (ver Los perfiles de fábrica al actualizar).
Placa del proyecto	Una placa tuya: el hardware de un perfil, con su nombre, su puerto, la red y el programa.	`Config/ESP32/device_profiles.json`, en el proyecto.
`boot.cfg`	Lo que lee la VM al arrancar: la placa del proyecto, sin lo que solo usa el IDE.	`Build/flash/boot.cfg`, en el proyecto, y en la memoria de ficheros de la placa.

Las placas que traen perfil, en Placas soportadas.

ESP32 Tools

ESP32 Tools es la ventana de las placas del proyecto. Se abre con Build › Target › Manage boards... o con Config › Platform › ESP32.

Arriba, Devices: la placa del proyecto con la que trabajas (Device), su nombre (Name) y los botones New, Forget y Save Device (ver Las placas del proyecto). Debajo, una línea con su identificador, su chip y su último puerto: «Profile ID: … | Chip: … | Last COM: …».
Port y Baud: el puerto de la placa y la velocidad a la que la graba esptool, la herramienta con la que el IDE graba las placas. Scan Ports busca los puertos, los lista en el Output y elige el que más parece una placa: uno USB.
A la izquierda, las páginas: Hardware, Storage, Network, Display y Audio, bajo Configure, y Deploy, bajo Actions.

Página	Qué tiene	Dónde se cuenta
Hardware	El chip, la flash y el arranque; el nombre del dispositivo; la lista de perfiles. En el ESP32-S31, el teclado USB.	Aquí, abajo
Storage	El programa que arranca (Application File), la tarjeta SD (SD Card), el espacio de los ficheros (LittleFS Storage Check) y el bus I2C (I2C Bus).	El bus I2C, aquí; lo demás, en Pantalla, sonido, SD y red
Network	La WiFi, la hora por NTP y MQTT.	Pantalla, sonido, SD y red
Display	La pantalla: controlador, tamaño, giro, bus y pines.	Pantalla, sonido, SD y red
Audio	El sonido: I2S o zumbador, y sus pines.	Pantalla, sonido, SD y red
Deploy	El resumen de la placa, y los botones que la graban: Flash Firmware y Upload Program.	Grabar el firmware y ejecutar

La página Hardware

Control	Qué hace
MCU model	El chip de la placa: ESP32, ESP32-S3, ESP32-P4 o ESP32-S31. Dice qué VM graba Flash Firmware y con qué chip habla esptool.
Get Info	Lee de la placa su chip, su memoria flash y su MAC, y lo escribe en el Output.
Flash Size	El tamaño de la memoria flash: 4 MB, 8 MB, 16 MB, 32 MB o Auto detect, que es lo de serie. Al grabar la placa, el IDE lo lee de ella y lo pone aquí.
Flash Mode	El arranque que graba Flash Firmware. Las opciones dependen del chip; los perfiles traen 40MHz-DIO en el ESP32 y el ESP32-P4, y 80MHz-DIO en el ESP32-S3 y el ESP32-S31.
USB keyboard	Solo con el ESP32-S31: el teclado del puerto USB-A.
Device Name	El nombre del dispositivo. Con WiFi, la placa lo usa como su nombre en la red. Generate lo hace con la MAC de la placa.
MAC Address y Get MAC	La MAC de la placa: Get MAC la lee y la pone aquí.
Hardware Profiles	La lista de perfiles, con Apply, Import y Export (ver Elegir, importar y exportar).

Get Info, Generate y Get MAC también cambian Device Name por el que sale de la MAC: un nombre que empieza por ESP32, con cualquier chip, y sigue con la MAC en hexadecimal, en otro orden. Y si el Client ID de MQTT sigue siendo el de serie, o está vacío, lo cambian por ese mismo nombre.

Qué lleva un perfil

Un perfil es un fichero JSON. Cada parte va a una página de ESP32 Tools:

En el perfil	Qué es	En ESP32 Tools
`target_chip`	El chip	Hardware › MCU model
`boot_config`	El arranque y la velocidad de grabación	Hardware › Flash Mode y, arriba, Baud
`sdcard`	La tarjeta SD y sus pines; en el ESP32-S31, también el pin que le da corriente	Storage › SD Card
`i2c`	El bus I2C de la placa: el puerto (0 o 1), SDA, SCL y la frecuencia (100000 o 400000)	Storage › I2C Bus
`tft`	La pantalla	Display
`audio`	El sonido	Audio
`usb_host`	El teclado USB, solo en el ESP32-S31	Hardware › USB keyboard

Un perfil no lleva Name, Port, Flash Size, Device Name, Application File ni nada de la página Network. Por eso puedes pasar un perfil a otra persona: no lleva tus contraseñas.

El bus I2C no lo usa la VM. Lo usan el mando I2C del editor de escenas, que abre el bus con esos pines (ver El mando I2C), y el gestor de drivers I2C, que los pone en el código que te da. Con -1 en SDA y SCL, la placa no tiene bus.

Este es el perfil Binghe_ESP32_1.96 entero:

{
  "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
  }
}

Este no tiene audio ni i2c: al aplicarlo, el sonido queda apagado y la placa, sin bus I2C.

Elegir, importar y exportar

La lista Hardware Profiles, en la página Hardware, tiene los perfiles de tu carpeta de usuario, por orden alfabético y sin la extensión. Debajo, una línea resume el elegido: el chip, la pantalla, la tarjeta SD y el sonido. Por ejemplo, «ESP32 | Display: ST7789 170x320 SPI | SD: off | Audio: off».

Botón	Qué hace
Apply	Copia el perfil elegido a la placa que estás editando, la de Device: el chip, Flash Mode, Baud, la tarjeta SD, el bus I2C, la pantalla y el sonido (y en el ESP32-S31, el teclado USB y la corriente de la SD). No toca su nombre, su puerto, Flash Size, Device Name ni la red.
Import	Lo mismo que Apply, pero con un `.jhp` de cualquier carpeta. No lo añade a la lista: para tenerlo en ella, expórtalo después.
Export	Guarda en un `.jhp` el hardware de la placa que estás editando. El diálogo se abre en tu carpeta de perfiles: guardado allí, el perfil sale en la lista, ya elegido.

Apply e Import cambian lo que enseña la ventana, pero no guardan nada: pulsa Save Device para guardarlo en la placa del proyecto. El Output dice «Hardware profile applied. Use Save Profile to persist it.»: el botón es Save Device.

Si el perfil es de otro chip, MCU model cambia con él, y también las opciones de Flash Mode.

Exporta con un nombre tuyo

Si exportas con el nombre de un perfil de fábrica, lo sustituyes, y el IDE ya no lo pone al día en las versiones siguientes (ver la sección siguiente). Usa un nombre tuyo, como MiPlaca_ST7789.jhp.

Los perfiles de fábrica al actualizar

Los perfiles de fábrica son los de la instalación, en Resources\HWProfiles (de serie, C:\Program Files\JARU IDE\Resources\HWProfiles). El IDE trabaja con una copia en tu carpeta de usuario, AppData\Local\JaruIDE\HWProfiles: es la que enseña la lista y donde guarda Export.

Cada vez que arranca, JARU IDE pone al día esa copia:

Copia los perfiles que te faltan, como los nuevos de una versión.
Sustituye los que siguen tal como los dejó una versión anterior. Los reconoce por una huella de su contenido: factory_versions.txt, junto a los perfiles de la instalación, guarda la de cada versión que ha tenido cada perfil.
No toca los que has editado, ni los tuyos.
Borra las copias de los perfiles que ya no existen o han cambiado de nombre, si no las has editado. Una que hayas editado se queda, con su nombre de antes.

En la 0.9.7, los perfiles pasaron a llamarse con la marca y el modelo de la placa. Los de la 0.9.6 se llaman ahora así:

Hasta la 0.9.6	Desde la 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 y Espressif_ESP32-S31-Korvo-1 son nuevos en la 0.9.7.

Tus proyectos no cambian al actualizar: cada placa del proyecto guarda su propia copia del hardware. El nombre del perfil del que salió es solo una referencia.

Las placas del proyecto

Las placas del proyecto se guardan en el propio proyecto, en Config/ESP32/device_profiles.json. Cada una lleva su nombre, su chip, su último puerto, Flash Size, el nombre del perfil del que salió y toda su configuración: la de las páginas Hardware, Storage, Network, Display y Audio.

Control	Qué hace
Device	Elige con qué placa del proyecto trabajas. La que elijas pasa a ser la placa activa.
Name	El nombre de la placa, el que sale en Device y en el menú de Target.
New	Empieza una placa nueva. Si tus proyectos recientes tienen placas guardadas, primero ofrece un menú: Empty profile, para empezarla de cero, o From y el nombre de un proyecto, para copiar una de sus placas a este. La copiada se guarda al momento.
Forget	Quita la placa elegida del proyecto, después de preguntar («Forget device "…"?»).
Save Device	Guarda la placa como la ves en todas las páginas, la hace la placa activa y genera el `boot.cfg`. Una nueva sin nombre se llama como su chip más «profile», por ejemplo «ESP32-S3 profile».

Si el proyecto no tiene ninguna placa, al abrir ESP32 Tools se crea una, Default ESP32, con los valores de serie, y el Output dice «Default ESP32 device profile created for this project.».

El menú del botón Target, en la pestaña Build, lista las placas del proyecto con su chip y su puerto, y Manage boards... abre ESP32 Tools. Elegir una placa en Target la hace también la placa activa: la que enseña ESP32 Tools y a la que Run envía el programa (ver La interfaz). Y al revés: si Target es una placa, elegir otra en Device, guardarla con Save Device o crear una con New la pone también en Target. Con Target en Windows, lo que elijas en ESP32 Tools no lo cambia. Si quitas con Forget la placa que está en Target, Run avisa con «Target not available» y, al abrir otra vez el proyecto, el botón dice Target: (missing): elige otra placa en Target.

Al cerrar ESP32 Tools con cambios sin guardar, pregunta antes («The ESP32 configuration has unsaved changes.»): Yes los guarda, como Save Device; No cierra sin guardarlos, y Cancel deja la ventana abierta.

Los ejemplos que trae JARU IDE llevan una placa, JARU JaruCade. Cómo cambiarla por la tuya, en Placas soportadas.

Las contraseñas van con el proyecto

La página Network guarda las contraseñas de la WiFi y de MQTT tal cual, en Config/ESP32/device_profiles.json y en el boot.cfg, dentro del proyecto. El boot.cfg va también a la placa. Si compartes el proyecto o lo subes a Git, van con él.

El `boot.cfg`

El boot.cfg es el fichero que lee la VM de la placa al arrancar: cómo es la placa (pantalla, sonido, tarjeta SD y red) y qué programa arranca. Es un fichero JSON.

El IDE lo genera en Build/flash/boot.cfg, dentro del proyecto, a partir de la placa activa tal como está guardada en el proyecto, no de lo que enseña la ventana. Lo genera al pulsar Save Device, Upload Program, Check Storage y Run con una placa en Target, antes de preparar los ficheros, y lo dice en el Output: «Deployment configuration generated from active device profile:», con su ruta. Run y Upload Program lo llevan a la placa con el programa (ver Grabar el firmware y ejecutar).

Lleva la configuración de la placa del proyecto menos lo que solo usa el IDE para grabarla: el chip, el puerto, Baud, Flash Mode y Flash Size.

Parte	Qué lleva	Dónde se cambia
`dev_id`	El nombre del dispositivo.	Hardware › Device Name
`file_version`	La versión del formato. La VM no la lee.	—
`jaru`	`jaru_app`: el programa que arranca la VM, el nombre del fichero principal del proyecto sin la extensión.	Lo pone el IDE
`sdcard`	Si se usa la tarjeta SD, si es la unidad principal y sus pines.	Storage › SD Card
`i2c`	El bus I2C. La VM no lo lee (ver Qué lleva un perfil). Solo está si la placa tiene bus.	Storage › I2C Bus
`tft`	La pantalla.	Display
`audio`	El sonido.	Audio
`wifi`	La red WiFi.	Network
`mqtt`	El broker MQTT.	Network
`ntp`	El servidor de hora.	Network
`usb_host`	El teclado USB. Solo en el ESP32-S31.	Hardware › USB keyboard

Así empieza el de un ejemplo con la JaruCade. El IDE lo escribe en una sola línea; aquí está ordenado y cortado:

{
  "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,
    …

No lo edites a mano: el IDE lo vuelve a escribir en cada Run y en cada Upload Program. Cambia la placa en ESP32 Tools.
Lo que falta en el fichero, la VM lo toma de sus valores de serie.
El mismo fichero sirve para Windows. Run en Windows escribe en Build/flash/boot.cfg la configuración de la VM de Windows (ver La configuración de Windows). Cada Run lo deja como lo necesita su destino.
Si la placa no tiene boot.cfg, o está mal, la VM no arranca el programa: lo que dice entonces el monitor serie, en Si la placa no arranca.

Problemas conocidos

Application File vuelve al fichero principal. Lo que eliges con ... en Application File no dura: Run, Upload Program y Check Storage lo cambian por el fichero principal del proyecto antes de empezar, así que la placa arranca siempre el programa principal. Para que arranque otro, hazlo principal en el proyecto.
Cierra el monitor serie antes de leer la placa. Get Info, Generate, Get MAC y Check Storage usan el puerto de la placa sin apartar el monitor serie, y si está abierto en ese puerto, no pueden leerla. Ciérralo antes con Close Serial.

Todos los problemas conocidos de JARU, juntos, están en Problemas conocidos.

ESP32 Tools​

La página Hardware​

Qué lleva un perfil​

Elegir, importar y exportar​

Los perfiles de fábrica al actualizar​

Las placas del proyecto​

El boot.cfg​

Problemas conocidos​