Espressif port of simplefoc

Antun_Skuric · January 23, 2024, 4:44pm

Hey guys,

Recently esp guys from espressif have partially ported the simplefoc library to thier main repo.
Here is the link:

They have made quite a few changes to the low-level code and main classes. I was wondering if someone has already tested their implementation and compared the performance.
It would be interesting to see some stats and maybe we can backpropagate some of their changes to the simplefoc as well.

Especially since their solution seems to be thread safe

Cheers,
Antun

runger · January 24, 2024, 3:30pm

Hmmm, I guess there is this code:

and this:

But I can’t really find huge changes - it doesn’t look like they changed that much in their fork of the library:

And the changes in their “component” are a bit hard to follow - it looks like they changed parts of BLDCDriver3PWM and implemented some sensor classes to use their APIs directly.

What am I missing?

Antun_Skuric · January 24, 2024, 4:44pm

You are right, there aren’t many differences.

They did implement the optimized sine and cosine funciton

github.com

espressif/esp-iot-solution/blob/262abf689b6a3ca302f8f8a197b4439098557369/components/motor/esp_simplefoc/port/esp/esp_app_fmath.cpp#L12


      
          * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
          *
          * SPDX-License-Identifier: Apache-2.0
          */
          
          #include <math.h>
          #include "common/foc_utils.h"
          #include "soc/soc_caps.h"
          #include "IQmathLib.h"
          
          float _sin(float a)
          {
             _iq iq_radians = _IQ(a);
             _iq result = _IQsin(iq_radians);
             return _IQtoF(result);
          }
          
          float _cos(float a)
          {
             _iq iq_radians = _IQ(a);
             _iq result = _IQcos(iq_radians);

As well as some different hendling of the low level pwm setting which might be more performant with respect to what we have. It is implemented in

github.com

espressif/esp-iot-solution/blob/master/components/motor/esp_simplefoc/port/esp/esp_hal_bldc_3pwm.cpp

/*
 * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <map>
#include "esp_hal_bldc_3pwm.h"

#ifdef CONFIG_SOC_MCPWM_SUPPORTED
#define MCPWM_TIMER_CLK_SRC MCPWM_TIMER_CLK_SRC_DEFAULT
#endif

std::vector<std::pair<DriverMode, std::tuple<int, int>>> HardwareResource = {
    {DriverMode::mcpwm, {0, 0}},
    {DriverMode::mcpwm, {1, 0}},
    {DriverMode::ledc, {0, 0}},
    {DriverMode::ledc, {1, 0}},
    {DriverMode::ledc, {2, 0}},
    {DriverMode::ledc, {3, 0}},

This file has been truncated. show original

But as you said their changes are very specific and not substantial, so they more seem to restrict than to restrict the usage of simplefoc than to enable new things.

When I saw it, I was wondering if someone has used it and see if there are some features that we should consider including as well.

Also they have this example applications of multiple motors running in real time os within one esp32.

github.com

espressif/esp-iot-solution/blob/master/components/motor/esp_simplefoc/test_apps/main/test_esp_simplefoc.cpp

/*
 * SPDX-FileCopyrightText: 2023 Espressif Systems (Shanghai) CO LTD
 *
 * SPDX-License-Identifier: Apache-2.0
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <string>
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "esp_log.h"
#include "esp_simplefoc.h"
#include "unity.h"

const char *TAG = "TEST";

TEST_CASE("test as5600", "[sensor][as5600]")
{

This file has been truncated. show original

I remember that people trying to use our library had troubles with it some time ago, and the Espresif guys seem to target exactly that kind of applications with their port. Since I’ve never tried it in my setups I was wondering if someone else did and is there some specific changes that we can integrate in our library to enable that.

These questions are just “a quick read” type of questions, I did not really go in detail of their implementation.

runger · January 25, 2024, 1:20pm

I agree, I think they want things to be easy to use for their customers.

I think they’re targeting the users of their Espressif IDE who code primarily against their Espressif APIs, and maybe don’t use Arduino at all, or not in the ESP32 product they’re working on.

And so Espressif is just quite pragmatic: in their Arduino core there is the whole FreeRTOS and Espressif APIs available in the background, and now they’re doing it the other way round too - Arduino libraries get wrapped with enough of a translation layer to make them work in Espressif IDE.

I saw that the newest versions of the Espressif cores (3.0?) have some breaking API changes. Some of the APIs we were using I think are completely replaced with new ones. I need to look into it more… Maybe their adaptation is already using the new APIs?

That’s great! We should time it to make sure it’s actually an optimisation (e.g. on STM32 CORDIC is fastest, but only if you don’t use the HAL functions, and deku’s LUT version is still faster than the arm_math.h m4 optimised version - so its worth checking that their optimisation is actually better). Then we could include it in the examples for people to use.

Another good find, and something we should include also as an example (or link to theirs?) because people have asked about this more than once already…

Jean-Nicolas_Durand · July 20, 2025, 6:46pm

Hello,
I’m trying to use the ESP-IDF SimpleFOC component, but I’m having trouble measuring current.
I can’t build my program using InLineCurrentSense or LowsideCurrentSense.
Do you know if current measurement is supported, or if I should resort to an Arduino environment?