Support Arduino ESP32 v3.0 based on ESP-IDF v5.1

[ivankravets]

The ESP32 Core for Arduino 2.x is the most recent major version currently recommended for use with PlatformIO. The decision to discontinue support was made by the Espressif company, as indicated in their official statement: https://github.com/espressif/arduino-esp32/pull/8606

If you're an Espressif user who relies on PlatformIO for your projects, kindly share your thoughts in the comments below and cast your vote on this matter. Once we gather enough interest from the Espressif community, we plan to reach out to the Espressif company and request a reconsideration of support for PlatformIO.

[thijstriemstra]

I've been trying this with following config:

; see https://docs.espressif.com/projects/arduino-esp32/en/latest/installing.html#how-to-update-to-the-latest-code
[env:arduino-latest]
platform = https://github.com/platformio/platform-espressif32.git
board = az-delivery-devkit-v4
framework = arduino
platform_packages =
    framework-arduinoespressif32 @ https://github.com/espressif/arduino-esp32#master

but the build fails with KeyError: 'framework-arduinoespressif32-libs':

Processing arduino-latest (platform: https://github.com/platformio/platform-espressif32.git; board: az-delivery-devkit-v4; framework: arduino)
--------------------------------------------------------------------------------
Platform Manager: Installing git+https://github.com/platformio/platform-espressif32.git
git version 2.42.0
Cloning into '/home/runner/.platformio/.cache/tmp/pkg-installing-uz1yxjz0'...
Platform Manager: espressif32@6.4.0+sha.f6ec392 has been installed!
Tool Manager: Installing git+https://github.com/espressif/arduino-esp32#master
git version 2.42.0
Cloning into '/home/runner/.platformio/.cache/tmp/pkg-installing-kih232ry'...
Tool Manager: framework-arduinoespressif32@3.0.0+sha.bf822ef has been installed!
Library Manager: Installing fortyseveneffects/MIDI Library @ ^5.0.2
Unpacking 0% 10% 20% 30% 40% 50% 60% 70% 80% 90% 100%
Library Manager: MIDI Library@5.0.2 has been installed!
Verbose mode can be enabled via `-v, --verbose` option
CONFIGURATION: https://docs.platformio.org/page/boards/espressif32/az-delivery-devkit-v4.html
PLATFORM: Espressif 32 (6.4.0+sha.f6ec392) > AZ-Delivery ESP-32 Dev Kit C V4
HARDWARE: ESP32 240MHz, 520KB RAM, 4MB Flash
DEBUG: Current (cmsis-dap) External (cmsis-dap, esp-bridge, esp-prog, iot-bus-jtag, jlink, minimodule, olimex-arm-usb-ocd, olimex-arm-usb-ocd-h, olimex-arm-usb-tiny-h, olimex-jtag-tiny, tumpa)
PACKAGES: 
 - framework-arduinoespressif32 @ 3.0.0+sha.bf822ef 
 - tool-esptoolpy @ 1.40501.0 (4.5.1) 
 - toolchain-xtensa-esp32 @ 8.4.0+2021r2-patch5
Converting edrumulus.ino
/tmp/tmpj5gstour/src/edrumulus.ino:45: warning: "MYMIDI" redefined
 #  define MYMIDI                     usbMIDI

/tmp/tmpj5gstour/src/edrumulus.ino:39: note: this is the location of the previous definition
 #  define MYMIDI                     MIDI

/tmp/tmpj5gstour/src/edrumulus.ino:46: warning: "MIDI_CONTROL_CHANGE_TYPE" redefined
 #  define MIDI_CONTROL_CHANGE_TYPE   usbMIDI.ControlChange

/tmp/tmpj5gstour/src/edrumulus.ino:40: note: this is the location of the previous definition
 #  define MIDI_CONTROL_CHANGE_TYPE   midi::ControlChange

/tmp/tmpj5gstour/src/edrumulus.ino:47: warning: "MIDI_SEND_AFTER_TOUCH" redefined
 #  define MIDI_SEND_AFTER_TOUCH      sendAfterTouchPoly

/tmp/tmpj5gstour/src/edrumulus.ino:41: note: this is the location of the previous definition
 #  define MIDI_SEND_AFTER_TOUCH      sendAfterTouch

KeyError: 'framework-arduinoespressif32-libs':
  File "/opt/hostedtoolcache/Python/3.12.0/x64/lib/python3.12/site-packages/platformio/builder/main.py", line 173:
    env.SConscript("$BUILD_SCRIPT")
  File "/home/runner/.platformio/packages/tool-scons/scons-local-4.5.2/SCons/Script/SConscript.py", line 598:
    return _SConscript(self.fs, *files, **subst_kw)
  File "/home/runner/.platformio/packages/tool-scons/scons-local-4.5.2/SCons/Script/SConscript.py", line 285:
    exec(compile(scriptdata, scriptname, 'exec'), call_stack[-1].globals)
  File "/home/runner/.platformio/platforms/espressif32@src-5f117260f75b328038ec9d3fd0e14a68/builder/main.py", line 346:
    target_elf = env.BuildProgram()
  File "/home/runner/.platformio/packages/tool-scons/scons-local-4.5.2/SCons/Util/envs.py", line 242:
    return self.method(*nargs, **kwargs)
  File "/opt/hostedtoolcache/Python/3.12.0/x64/lib/python3.12/site-packages/platformio/builder/tools/piobuild.py", line 61:
    env.ProcessProgramDeps()
  File "/home/runner/.platformio/packages/tool-scons/scons-local-4.5.2/SCons/Util/envs.py", line 242:
    return self.method(*nargs, **kwargs)
  File "/opt/hostedtoolcache/Python/3.12.0/x64/lib/python3.12/site-packages/platformio/builder/tools/piobuild.py", line 121:
    env.BuildFrameworks(env.get("PIOFRAMEWORK"))
  File "/home/runner/.platformio/packages/tool-scons/scons-local-4.5.2/SCons/Util/envs.py", line 242:
    return self.method(*nargs, **kwargs)
  File "/opt/hostedtoolcache/Python/3.12.0/x64/lib/python3.12/site-packages/platformio/builder/tools/piobuild.py", line 342:
    SConscript(env.GetFrameworkScript(name), exports="env")
  File "/home/runner/.platformio/packages/tool-scons/scons-local-4.5.2/SCons/Script/SConscript.py", line 662:
    return method(*args, **kw)
  File "/home/runner/.platformio/packages/tool-scons/scons-local-4.5.2/SCons/Script/SConscript.py", line 598:
    return _SConscript(self.fs, *files, **subst_kw)
  File "/home/runner/.platformio/packages/tool-scons/scons-local-4.5.2/SCons/Script/SConscript.py", line 285:
    exec(compile(scriptdata, scriptname, 'exec'), call_stack[-1].globals)
  File "/home/runner/.platformio/platforms/espressif32@src-5f117260f75b328038ec9d3fd0e14a68/builder/frameworks/arduino.py", line 41:
    SConscript(
  File "/home/runner/.platformio/packages/tool-scons/scons-local-4.5.2/SCons/Script/SConscript.py", line 662:
    return method(*args, **kw)
  File "/home/runner/.platformio/packages/tool-scons/scons-local-4.5.2/SCons/Script/SConscript.py", line 598:
    return _SConscript(self.fs, *files, **subst_kw)
  File "/home/runner/.platformio/packages/tool-scons/scons-local-4.5.2/SCons/Script/SConscript.py", line 285:
    exec(compile(scriptdata, scriptname, 'exec'), call_stack[-1].globals)
  File "/home/runner/.platformio/packages/framework-arduinoespressif32/tools/platformio-build.py", line 40:
    FRAMEWORK_LIBS_DIR = platform.get_package_dir("framework-arduinoespressif32-libs")
  File "/opt/hostedtoolcache/Python/3.12.0/x64/lib/python3.12/site-packages/platformio/platform/_packages.py", line 32:
    pkg = self.get_package(name)
  File "/opt/hostedtoolcache/Python/3.12.0/x64/lib/python3.12/site-packages/platformio/platform/_packages.py", line 29:
    return self.pm.get_package(spec or self.get_package_spec(name))
  File "/opt/hostedtoolcache/Python/3.12.0/x64/lib/python3.12/site-packages/platformio/platform/_packages.py", line 21:
    owner=self.packages[name].get("owner"),
========================== [FAILED] Took 4.31 seconds ==========================

[ivankravets]

See the updated comment https://github.com/platformio/platform-espressif32/issues/1225#issue-1977204439

[Jason2866]

Adding Arduino 3.0.0 support is the only way to make the ESP32-C6 available for Arduino projects. The needed changes are not that many, i have added Arduino 3.0.x alpha support in my Fork and bulding Arduino and IDF projects with the C6 are working. We have ported Arduino project Tasmota to the C6 and it runs already surprisingly stable.

[Jason2866]

If you're an Espressif user who relies on PlatformIO for your projects, kindly share your thoughts in the comments below and cast your vote on this matter. Once we gather enough interest from the Espressif community, we plan to reach out to the Espressif company and request a reconsideration of support for PlatformIO.

@ivankravets Does this mean that Espressif has dropped any support? Looking in current Arduino 3.0.0 code (branch master) everything regarding Platformio support is there.

[VojtechBartoska]

Hello all,

I do work in Arduino Core ESP32 project as a Project Manager so I would like to clarify this from our Team point of view.

Please take a look on this comment in original Pull request.

We also update a warning note in our documentation which should be a bit confusing.

To not duplicate what is written in original PR, we will be glad if PlatformIO supports our latest version and we are open to any contributions.

@ivankravets Feel free to contact us any time directly, we will be happy to discuss this if you see any points we can do differently.

Thanks

[0x0fe]

Adding Arduino 3.0.0 support is the only way to make the ESP32-C6 available for Arduino projects. The needed changes are not that many, i have added Arduino 3.0.x alpha support in my Fork and bulding Arduino and IDF projects with the C6 are working. We have ported Arduino project Tasmota to the C6 and it runs already surprisingly stable.

@Jason2866 Do you know how i can setup the .ini file in a new project for using your 3.0.0 fork and 5.1 IDF at the same time (to keep the SDK menuConfig)?

[0x0fe]

@ivankravets there is something i dont understand, why is there a separate platformespressif32 core? It is based on arduinoespressif32, but always lags behind, and arduinoesp32 already lags behind IDF. So what is the point of this separate core? Why is PIO not using arduinoesp32 core as is directly?

I think a reason why many users use PIO is also to keep some of the arduinoesp32 APIs while having the possibility to modify the IDF SDK configuration (menuconfig) which is necessary in many cases and not possible in arduino, unless using the libbuilder (buggy and not convenient).

Maybe it would be wise for PIO to directly use arduinoesp32 core as is, and just focus on allowing users to run arduinoesp32 core along with IDF to keep access to menuconfig.

[mhaberler]

I am concerned about the viability of this repo long-term as folks like @Jason2866 have started to roll their own and this repo not catching up

I am currently using his https://github.com/tasmota/platform-espressif32/tree/Arduino/IDF5 branch and it works mostly great for me - even if I feel uneasy about relying on a private effort with unclear future - how do you see the longer-term perspective of your fork?

This fork has diverged from this repo massively - not sure this can brought back here easily

the other issue I have is the abysmal debugging experience esp32/pio/arduino compared to using straight IDF

[0x0fe]

@mhaberler i did the same yesterday and used https://github.com/tasmota/platform-espressif32/tree/Arduino/IDF5

platform = https://github.com/Jason2866/platform-espressif32.git#Arduino/IDF5
platform_packages = framework-arduinoespressif32 @ https://github.com/espressif/arduino-esp32.git#3.0.0-alpha2
framework = 
    arduino
    espidf
board = esp32dev

But then when building it complained of missing SPIFFS, i added it manually from previous version (in components directory) but then i get a dependancy error with esp_partition.h, despite it is well present in "components".

   17 | #include "esp_partition.h"
      |          ^~~~~~~~~~~~~~~~~
compilation terminated.
Compiling .pio\build\esp32dev\tcp_transport\transport.o
Compiling .pio\build\esp32dev\tcp_transport\transport_ssl.o
Compiling .pio\build\esp32dev\tcp_transport\transport_internal.o
*** [.pio\build\esp32dev\spiffs\esp_spiffs.o] Error 1
*** [.pio\build\esp32dev\spiffs\spiffs_api.o] Error 1

Did you met this issue too?

[Jason2866]

@0x0fe @mhaberler My fork has not the goal to be compatible to anything official. The fork is made for project Tasmota. Everything is optimized for that use. The sdkconfig settings differs a lot from the official espressif ones. There are components added and others are removed (for example SPIFFS). Breaking changes can and will happen. Imho no reason to be concerned about support of Arduino Espressif. Platformio always do a release when a RELEASED core is available. Core 3.0.0 is in ALPHA state!

Since project Tasmota is always in first row for new stuff, and is active in contributing to espressif Arduino Core, there was the need to have the development version of Arduino Core available with Platformio. Project Tasmota is only possible with Platformio. Thx again to the Team of Platformio (@ivankravets ) for this awesome IDE!!

The needed changes for Arduino 3.0 in Platformio are not many. A small job for @valeros

[0x0fe]

@Jason2866 oh, i see, that explains the error with SPIFFS

[mhaberler]

alpha stage - fair enough.

Now assume Core 3.0.0 gets released - does this have any bearing on the debugging situation?

who has the ticket to make that work?

I'm talking about openocd + gdb versions and matching debug configs which work - at least somewhat like Nordic Connect and Segger

I admit I am slightly confused about players and the who-does-what-and-why-not - I might be barking up the wrong tree (or repo) for that matter

[Jason2866]

@mhaberler Does debugging work in espressif IDF env setup? If yes imho Platformio has the job for the devices which are currently supported with IDF 5.1. Not saying it will be easy to solve or it will be done soon. The debug issue for the C6 is known and there is an open issue.

[mhaberler]

Did you met this issue too?

@0x0fe yes, same here `Failed to resolve component 'spiffs'

[mhaberler]

@mhaberler Does debugging work in espressif IDF env setup? If yes imho Platformio has the job for the devices which are currently supported with IDF 5.1. Not saying it will be easy to solve or it will be done soon. The debug issue for the C6 is known and there is an open issue.

you mean like command line/shell? yes, repeatably

[0x0fe]

@mhaberler It makes sense, well SPIFFS yo ucan add it manually from previous version but then you will get an error with esp_partition, and i am not sure where to re-enable the SPIFFS module and dependencies correctly.

[ivankravets]

I'm a bit confused. Why is there a separate platform-espressif32 core? It seems to be based on arduino-espressif32, but it always seems to lag behind...

https://github.com/platformio/platform-espressif32 isn't a core itself. It's a software piece that makes the PlatformIO Build API work seamlessly with Espressif 32 products within the PlatformIO ecosystem. If you check the source code of this repository, you'll find other integrations, like ESP-IDF. If we support Zephyr/ESP32, it'll also be found here.

Would it be smarter for PIO to directly use the arduinoesp32 core as it is?

We do use it directly (https://registry.platformio.org/tools/platformio/framework-arduinoespressif32). There's no common ground between Arduino IDE and PlatformIO. The "arduino" in PlatformIO is just a framework. PlatformIO supports over 10+ different frameworks. The reason many developers see PlatformIO as a "replacement for Arduino IDE" is due to source code compatibility and advanced project management with lots of configuration and collaboration features based on PlatformIO's unique declarative principles.

If you've tried another framework besides "arduino", you'd notice there's no difference in the configuration aspect. You and your team can focus on project development without wrestling with bootstrapping and collaboration issues.

Lastly, for a VSCode-based solution with native ESP32/Arduino core support, I recommend the Arduino IDE for VSCode extension backed by Microsoft. It's similar to Arduino IDE 2.0 but uses VSCode as the editor. Both leverage "arduino-cli", so the build system and workflows are the same.

[0x0fe]

@ivankravets I see, glue logic layer. the totally different versioning between these platforms and the cores they implement is rather annoying, though.

[mhaberler]

@ivankravets make me understand what your recommendation means - are you saying:

When I prefer to use VSCode, I should take the Microsoft Arduino extension for VSCode and drop Platformio?

[ivankravets]

@mhaberler, we value openness in our community and aim to give you the freedom to choose. If there's a newer version of the software not yet supported by PlatformIO, we won't hide it.

The current supported version is Arduino Core v2.x for ESP32. Our collaboration with Espressif, including discussions about renewal, is ongoing. It's worth noting that we have @VojtechBartoska, a project manager from Espressif, in this thread. We're all working together to ensure you receive the best features and support. We'll keep everyone posted on any updates to ensure a smooth continuation of our services.

[hoeken]

I can see there's a bit of political project stuff happening, but as an end-user, all I want to do is be able to use the latest Arduino framework. Consider this a vote of support for making that happen, however it needs to be.

[ivankravets]

PlatformIO is a commercial open-source project. In the past, it used to be a paid service before 2020, following a business-to-consumer (B2C) model. Unexpectedly, PlatformIO gained widespread popularity among millions of developers globally. Consequently, we shifted our strategy to make powerful tools for professional embedded development freely accessible to everyone.

The active development and maintenance of PlatformIO, along with its infrastructure, are now supported by technology partners dedicated to delivering an excellent developer experience. Espressif was one such partner, and we appreciate their long-standing collaboration.

Currently, Espressif has ceased support for new products in PlatformIO, but rest assured, we are committed to providing support for existing Espressif products integrated before this change, as per our technology licensing policy. Your projects won't face disruptions, and services will continue as usual.

If there's significant interest from Espressif customers in PlatformIO, we'll reach out to Espressif and explore the possibility of continuing our collaboration.

If you have any questions or need clarification, feel free to ask. We're here to provide all the answers you need.

[mhaberler]

ok, so Espressif jumped ship

@ivankravets what does that mean for the subject topic - Arduino3?

your wording would suggest to me "no new Espressif releases - be it Arduino or ESP-IDF, existing releases go on life support"

are you saying this repo stops at ESP-IDF 5.1.1/Arduino2 until Espressif changes its mind ?

[Jason2866]

@mhaberler Looks like: as long there is not enough feedback from Platformio users wanting actual espressif framework support, there is no good position from Platformio side to argument why espressif should invest money having Platformio support. espressif is thinking supporting the ArduinoIDE toy is enough :-(

[HaenZ33]

How can we provide enough feedback?? Do we need to start a poll? I agree with the term: Arduino-IDE toy...

[seankovacs]

The Arduino IDE is not a replacement for Platformio. Would be nice to have proper IDF5.1 support here, otherwise people will start looking for other chips. C6 is very late to the game and still doesn't provide what people want - true 5Ghz support. At the very least Espressif can be everywhere code wise.

[maciekish]

Any news on this please? Still waiting for C6 support :<

[Jason2866]

@maciekish No, there are two reasons.

• Core 3.0.0 is not released. Platformio did not support not released cores in the past. So why it should happen now?
• espressif canceled partnership with platformio, so no support for something new

[maciekish]

@maciekish No, there are two reasons.

• Core 3.0.0 is not released. Platformio did not support not released cores in the past. So why it should happen now?
• espressif canceled partnership with platformio, so no support for something new

Well, it looked released. I didn't dig that deep.

Is a partnership necessary? Can't the community figure this out?

[Jason2866]

I roll my own fork, but this will probably not merged here, since why should Platformio do that? PlatformIO is a company and the people working there needs to get paid (beside the fact the infrastructure too). Either the users do or companys who wants to see there products supported from Platformio. Nothing is possible for free

EDIT: Your link is correct the C6 is supported via IDF. Btw. from Platformio too.

[richievos]

I just went to my hardware closet and pulled out a dev esp32-h2 board I'd been saving. Weeks back I'd see comments about a new release of arduino/express frameworks with support for this, and I'd been waiting for a time slot to finally move forward with my Matter+Thread project. In researching it I now came across this thread.

I'm gutted to see the contents of this thread. I don't honestly know what to think in regards to either platformio or esp boards. The arduino IDE is not compatible with software development, and VSCode + PlatformIO offers a real experience and real tools. Arduino itself I could punt on, but there's so many libraries out there which depend on it, that completely going native ESP32 basically means roll-from-scratch everything. ESP boards are almost the standard IMO at this point, trying to find a different board set with a good form factor and low price is a huge momentum killer.

Together the 3 of these things fit together making IoT projects almost trivial. Losing parts of each of them basically means you either do minor toy projects or you have to be a sophisticated embedded software company with its own library stack.

Mega, huge, downer.

[philm001]

Hey guys,

I am currently working with the W5500 chips and using it in my application with the ESP32. My IDE is platform.io

It looks like that you have a ETH library that can be used to communicate with the chip. However, it is only available with the 3.0 version.

When I try to clone the commit that has the ETH library for the W5500 chip, I get the same errors as above. I have tried the latest development version of the platform to no avail.

What are my options to get this issue solved? My project for my client is hinging on using this chip as the PCB is in production. I don't want to use Arduino IDE for obvious reasons.

Should I fork a copy of v2.14 and manually add in the new ETH code? or has someone figured out a way to get it to work with the latest platform version?

[philm001]

Also, I read through the espressif comments here: https://github.com/espressif/arduino-esp32/pull/8606

It looks like that they are not dropping support per say as they never officially supported platform.io but rather updating the language of the docs to say that they don't officially support it.

[Jason2866]

@philm001 You should read the comment from Ivan Kravets in this thread (again). Clearly telling espressif canceled Partnership support. So no support for NEW stuff. About PHY W5500 support, only possible without conflicting with SPI with upcoming Arduino 3.0.0. If you can't wait use IDF 5.1.2. This version is supported from Platformio and does support the W5500.

Or do your own fork of Platformio for supporting Arduino 3.0.0.

[philm001]

@Jason2866 Hello, thank you for information. Can I get a link to IDF 5.1.2?

[Jason2866]

Use

platform = espressif32 @ 6.5.0
framework = espidf

[philm001]

Thank you

[philm001]

Hey guys, pardon my ignorance but what would it take for us to add in the compatibility ourselves?

Looking through the previouse releases, it appears that you need to add the SDK source files just like what you did in version 2.0.14. From what I can tell, everything is there. What else is missing?

[philm001]

For my application, I basically, updated the SDK Ethernet library to the most recent one (along with updating other needed files) and I was able to get everything the compile with the updated Ethernet library.

Now, I am getting some other SPI errors and the MCU crashes but that is a separate issue that I am working on.

Also, how are you guys testing the development of the alpha versions? I am assuming that there is some basic Arduino tests that you are running in Platform.IO?

[Jason2866]

@philm001 Forked the needed repos -> Arduino Lib Builder, Platformio Platform espressif32 and added changes to get it working for the needs of project Tasmota This means settings in Arduino Lib Builder are different and stripped stuff we don't need / use. The main breaking change is the remove of SPIFFS. Using LittleFS as better alternative. The actual Arduino master branch can be used with Platformio with this

platform = https://github.com/Jason2866/platform-espressif32.git

CI test are done too, and can be seen here https://github.com/Jason2866/platform-espressif32/actions Running the examples from folder examples

[philm001]

@Jason2866 Thanks Jason, I will explore this for my own application. However, my application utilizes the SPIFFS. What would it take to get SPIFFS to work with this Tasmota branch?

[Jason2866]

@Jason2866 Thanks Jason, I will explore this for my own application. However, my application utilizes the SPIFFS. What would it take to get SPIFFS to work with this Tasmota branch?

@philm001 You can take my Platformio Platform as boilerplate. Needed changes are in platform.json -> Reference your framework(s). You have to compile the Arduino framework with the original IDF 5.1 from espressif and fork espressif Arduino -> Needs change(s). Use this file tools else the framework will not be compatible with my Pio Platform. Fork my Arduino Lib Builder https://github.com/Jason2866/esp32-arduino-lib-builder remove in the *.sh files which does remove Libs and components you want to use! Adjust the Arduino CMakeLists.txt file accordingly. Add a valid package.json and version.txt (see my forks) to your IDF and Arduino fork. If you run in errors take a look in this commit https://github.com/tasmota/arduino-esp32/commit/413362d8e250eb73d8089274f34f3d5aa081aa91 Most changes are not needed! Our (working) IPv6 implementation differs from the WiP in espressif/ Arduino so most changes are related to this. Most others are for removing stuff.

It needs some work to get it going. You have to dive into. There is no guide for and no hand holding possible from my side.

[Johboh]

One alternative is to use the ESP-IDF framework directly (with their visual studio code extension), instead of platform IO. It's possible to add the arduino core as an ESP-IDF component if one has many arduino library dependencies. But for projects without that many arduino dependencies, it's usually not needed as libraries can be found in the component registry. I migrated five platform IO + arduino framework projects to use ESP-IDF directly as I needed functionally from ESP-IDF v5.2 (beta). I still use platform IO + arduino framework for simpler projects. Porting projects between different environments is not always an option of course, but in case someone is blocked there are always solutions.

[danalvarez]

[...] we plan to reach out to the Espressif company and request a reconsideration of support for PlatformIO.

Any plans on reaching out to espressif yet? I think the community has spoken about the huge interest behind this. ESP-IDF v4.4 is going EOL in July of this year (2024), so having stated support for arduino-esp32 v3.X.X would be great.

[ivankravets]

@danalvarez , we're currently awaiting a response from Espressif. Due to the holiday season, there might be a slight delay in communication.

[sgryphon]

as indicated in their official statement: espressif/arduino-esp32#8606

As an outsider, this seems to have gotten way out of hand.

From what I can see:

• ESP32 Arduino has a new version coming out, Platform IO doesn't support it yet
• ESP32 Arduino put up a pull request to remove the link the Platform IO from documentation, because users were confused when it didn't work with the latest. That is the official statement -- an in progress pull request.
• The pull request was changed to keep the link, but add a disclaimer for users to contact PlatformIO.
• I don't see anything in the linked statement about cancelling partnership, but some posts by PlatformIO seem to indicate this
• PlatformIO is waiting for feedback from users they want new ESP32 Arduino (i.e. the feedback in this thread), and for contact from ESP32.

There may be some contention over who does the work to update platformio/platform-espressif32 with the necessary changes, if neither ESP32 Arduino or PlatformIO want to do the change, maybe the community can step in and submit a PR? Is that the issue, that neither side want to put time into the change?

@Jason2866 I know it will take away from your existing Tasmota work, but if you already know the changes, can you make the minimum changes to get it working (no Tasmota staff) and submit a PR?

From the outside, it looks like a bunch of over reactions, and ESP32 Arduino changed the PR. Maybe the wording "not officially supported" is irking PlatformIO, but maybe that wording can be changed? Is that the issue.

Or, as hinted by some of the PlatformIO comments, have Espressif removed financial support from PlatformIO (not sure if this is true; it isn't directly stated, but not sure what 'partnership' means... there is nothing in the link official statement that indicates this)? If that is the case, then I guess it is outside the scope of a simple pull request.

[sgryphon]

I'll note that the latest version of Arduino ESP32 has integration builds that test PlatformIO.

So, the necessary changes to the integration are already in the Arduino ESP32 build scrips: https://github.com/espressif/arduino-esp32/blob/e4d6a8abf9fab7422e21f72d3aeb2e9c9484ab36/.github/scripts/install-platformio-esp32.sh#L35

At least for the error I am getting, "KeyError: 'framework-arduinoespressif32-libs':", it looks like the Arduino ESP32 integration test scripts have a fix up to extract the URL from "package_esp32_index.template.json"

There is a similar section in platform-espressif32 where if you are using an upstream version it dynamically extracts toolchain versions from "package_esp32_index.template.json": https://github.com/platformio/platform-espressif32/blob/ee1dd5a6c65a250dc5e3031c62e8c688f2665ce6/platform.py#L60

The function is self.configure_upstream_arduino_packages() and maybe just needs to add extracting the URL and downloading 'framework-arduinoespressif32-libs' (if it is there, i.e. an older custom version of 2.0 won't have the libs change).

I'm playing around with this in a fork, and might chat to the PR author of the integration test fixes: https://github.com/espressif/arduino-esp32/pull/7733

[Jason2866]

Or, as hinted by some of the PlatformIO comments, have Espressif removed financial support from PlatformIO (not sure if this is true; it isn't directly stated, but not sure what 'partnership' means... there is nothing in the link official statement that indicates this)? If that is the case, then I guess it is outside the scope of a simple pull request.

@sgryphon A PR which simply adds C2 functionality to existing IDF 5.1. support is not merged https://github.com/platformio/platform-espressif32/pull/1203 So for me it does look like any PR which enhances product support over the currently existing one is not accepted. And for me it is clearly written espressif canceled partnership. So no I don't invest time to migrate my changes to an PR. Since there are many changes regarding Tasmota and enhancements not only related to core 3.0. Don't burn my time for a PR which most probably not get merged for known reasons. Espressif has to decide if the want to see there newer MCUs supported in Platformio. It is that's easy. To be clear i do fully understand how Platformio is reacting. There is no free support for anything!

[sgryphon]

And for me it is clearly written espressif canceled partnership.

Maybe I am dumb or something, but I don't see any reference to partnership in the link posted, or cancelling. Maybe there is a different link?

The link referred to above as an official statement is a pull request: https://github.com/espressif/arduino-esp32/pull/8606

The PR only contains two small things, and only one of them is relevant. It doesn't mention anything about partnership or cancelling.

".. warning:: PlatformIO is not officially supported by Espressif. Please report any issues with PlatformIO directly to its developers on the official PlatformIO repositories <https://github.com/platformio>_."

Now, maybe you could interpret "not officially supported" as meaning you shouldn't use it... but from reading the discussion and context it means if a user wants support with PlatformIO they should contact PlatformIO, not Espressif.

This is much clearer after subsequent changes to the working, on the website installing section: https://docs.espressif.com/projects/arduino-esp32/en/latest/installing.html#installing-using-platformio

It now reads: "Warning Integration of the Arduino Core ESP32 project in PlatformIO is maintained by PlatformIO developers. Arduino Core ESP32 Project Team cannot support PlatformIO-specific issues. Please report these issues in official PlatformIO repositories."

So, even the wording of "not supported" has been changed to "Arduino Core ESP32 Project Tema cannot support PlatformIO-specific issues", and clarifies that the integration is maintained by PlatformIO (and I can see this repository is under the ownership of PlatformIO).

Maybe I have missed some statement that talks about cancelling partnership (a different link?), or maybe there are some deeper issues.

[Jason2866]

@sgryphon Post from Ivan Kravets https://github.com/platformio/platform-espressif32/issues/1225#issuecomment-1826363522