platform-espressif32 VS PlatformIO

[env:esp32-s3] platform = espressif32 ;https://github.com/platformio/platform-espressif32.git board = esp32-s3-devkitc-1 framework = arduino monitor_speed = 115200 lib_deps = ${common.lib_deps} build_flags = -D MONITOR_SPEED=115200 -D ARDUINO_USB_MODE=1 -D ARDUINO_USB_CDC_ON_BOOT=1 board_build.flash_mode = qio

[env:esp32-s3-devkitc-1-n16r8v] platform = https://github.com/platformio/platform-espressif32.git framework = arduino board = esp32-s3-devkitc-1-n16r8v board_build.filesystem = littlefs lib_extra_dirs = ~/Documents/Arduino/libraries build_unflags = -std=gnu++11 -fconcepts build_flags = -std=gnu++17 -fconcepts -DBOARD_HAS_PSRAM -mfix-esp32-psram-cache-issue monitor_speed = 115200 monitor_rts = 0 monitor_dtr = 0 monitor_filters = default time colorize esp32_exception_decoder

If you want, you can also copy the board definition file https://github.com/platformio/platform-espressif32/blob/develop/boards/esp32-s3-devkitc-1.json and create a custom one in your own repo (if it differs much from the esp32-s3-devkitc-1).

On the "Platforms" tab of the quick access toolbar, I can click on "platforms" (again) and see that I have version 6.0.1 of the Espressif 32 platform instaled. If I look at the release info, it seems that support for IDF v5.0 was added in Espressif 32 version 6.0.0.

board: esp32-s3-devkitc-1 #https://registry.platformio.org/platforms/platformio/espressif32/boards

This is probably the simplest next step before fully transitioning to ESP-IDF and dumping PlatformIO. Here's the PlatformIO example repo that does just this. https://github.com/platformio/platform-espressif32/tree/develop/examples/espidf-arduino-blink

Sounds like this might be a similar issue to this problem I ran into with the S3 and Platform.io?

esphome: name: myesp32c3 esp32: board: esp32-c3-devkitm-1 variant: esp32c3 framework: ### Arduino type: arduino version: dev platform_version: https://github.com/platformio/platform-espressif32.git#feature/arduino-upstream ### ESP-IDF # type: esp-idf ...

Yes this seemed to be it. I don't know what is the difference between "development platform" and "development framework" (IDF), but all I know is that the change that made thinfs slower happened in the former. And I know that because I reverted the version used inside Platform.io. Other than that, I have no idea what is happening in the background. I just use PlatformIO on VSC and have pretty basic programming skills.

platform = https://github.com/platformio/platform-espressif32.git#feature/arduino-upstream platform_packages = framework-arduinoespressif32 @ https://github.com/espressif/arduino-esp32.git#2.0.0

For the ESP32 in read mode, we've successfully developed a project using PlatformIO that accepts the key during build time and stores it in memory.

Check out Zephyr OS and Platform IO. Zephyr is part of the Linux foundation and has similarities to Linux with how it performs hardware abstraction (device tree). Platform IO integrates with other frameworks including mbed and Arduino.

PlatformIO together with avr-stub can be used to do source level debugging but there are some caveats.

Look into https://platformio.org/, it can abstract over a few RTOSes, and can show you which OSes work with which chips/boards.

If the HW looks like it works, you could also try alternate programming software. (e.g. TinyGo or PlatformIO)

You might have better luck with PlatformIO than the Arduino IDE; it's better at automatically choosing the serial port, though I can't say I've used it under Windows.

My other suggestion takes more work but will make your life oh so much better. Professionally I have used and highly recommend. https://platformio.org/ which is free!

Will you be doing embedded Linux? Embedded RTOS? Bare metal? Microcontrollers? SoC (say, FPGA with a hard processor core)?

You can do a lot with QEMU. https://bootlin.com/ has a lot of great, free training material.

https://bootlin.com/doc/training/embedded-linux-qemu/embedde...

is one of my favorites.

Learning to cross-compile, do embedded debugging, the process of booting an embedded system (which varies depending on the answers to the above questions), learning how to read a technical reference for the processor you’re using as well as for peripherals you’re likely to interact with - SPI, i2c, UART, maybe PCIe, are all handy skills. Learn a bit about JTAG, hardware, reading schematics, etc. Even being able solder is helpful.

There may be books (I had a great embedded Linux book when I started) but there are lots of online materials too. Check out https://platformio.org/

There are fun embedded boards and projects for microcontrollers too - micropython on an rpi pico, tinygo, eLua, etc.