SimpleFOCStudio 2.0 a tunning and configuration tool

[JorgeMaker]

Hi all,

We have a new version of the SimpleFOC Studio app updated to work with SimpleFOC 2.1 thanks to @Antun_Skuric who took the previous version and pushed it to the next level

The main features are:

• Plug and play with the SimpleFOClibrary version 2.1
• Real-time tuning and configuration of the motors
• Real-time plotting and monitoring of motor variables
• Code generation for easier integration of the tuned parameters in your code
• Built on PyQt5 and a standardized SimpleFOCConnector interface that can be used as a gateway form python to the SimpleFOClibrary device as it is shown in the simple example.

JorgeMaker/SimpleFOCStudio

[Jason_Kirsons]

Woohoo - very nice!

Maybe you could add in the documentation that the letter listed here:

command.add(‘M’,doMotor,‘motor’);

Needs to be entered here:

( I was trying to enter it in “Conn ID” )

Good work!

[JorgeMaker]

Thanks for you suggestion, just modified the documentation

[Jason_Kirsons]

This is great, you can test out property changes really quick to see how they change performance.

I have a few ideas

1. Add a “Jog Dial”, eg:
   

In velocity mode, it has preset speeds. In angle mode, it has preset positions.
Then you could just click the button and sends the command to go to that speed/position.
This would make it even faster to see the effect of changing settings.

2. Custom commands:
   

Where you could specify a Name, Command, Value and Response text.

Then we could extend the commander interface on the controller to do things like change register settings for SPI devices.

3. Help
   Maybe a help button beside each setting where it links to the online docs explaining the setting, and what typical values might be.

Anyway, just some thoughts…

[JorgeMaker]

Thanks a lot for your suggestions @Jason_Kirsons … great ideas for the next version

[malem]

Hi @JorgeMaker,

Thanks for the simplefoc studio. I have it running and it helped me tune my pid.

I have a lot of experience with pyhton + Qt, and I was considering creating a new gui based on QtQML, which would bring a lot of flexibility.

What do you think?

I would, of course reuse as much stuff as possible.

[JorgeMaker]

@malem

nd I was considering creating a new gui based on QtQML, which would bring a lot of flexibility.

What do you think?

Thanks for your nice words I have never used QtQML … it would be nice to see a project like this, surely we can all learn something together:wink:

[Antun_Skuric]

Hey @JorgeMaker and @malem,

That sounds awesome!
I’d be in to support any further development as well both in python and on the library side. There is still a lot to optimize for the efficient communication, we should probably introcude the Verbose:::studio or Verbose:::python ( or Verbose:::echo_command similar to what @malem already suggested an approach for that in the PR) mode in the commander as well and echo the command instead of a lot of text that we need to parse. The same is true for the monitoring.
This would allow tuning multiple motors a bit more easily and less overhead in communication.

Now I’d like to suggest to you guys and everyone else that feels interested to try to use the same python connector class for both applications.
What do you think of making the python connector a separate repo and even a pip package?
This way we can easier support all the library changes that might occur.

[malem]

yeah a different package for the connector would, I think serve other people’s needs

Also, SimpleFOC-side, should/could we go async with the reporting?

The loop could be put on a timer, with the data to send out put in a buffer that is emptied interrupt-based.

just an idea…

I will try it later

[JorgeMaker]

I have pending to investigate the use of asyncio to implement the interface between the tool and SimpleFOC device.

[malem]

the bottleneck is more MCU-side.
I think it would be possible to prevent the monitoring from affecting the control loop.

The idea would be to setup a e.g. 10khz timer (like paul gould did) where the control loop happens and put readings in a FIFO buffer. Then buffer would then be emptied when the MCU idles, or interrupt based.
in the main loop() function, we could e.g. listen for commands

[runger]

Hey, my thoughts on this…

asyncio on the GUI side might be interesting for other reasons, although my impression is the GUI is very responsive despite the constant serial comms.

On the MCU side, I think there is a lot that could be done, but I think care should be taken to keep it separate from the “simple and generic” interface we have now. Any Arduino has a Serial object, but not all of them have timers that work in the same way, etc…

I know you like SAMD - I think on SAMD it should be possible to drive the SERCON using DMA, with almost no overhead to the main loop. But this will hardly be portable to other MCUs. So I think a good approach here could also be to write alternative “monitoring backends”, which can be kept separate from the main code (not wasting space and confusing the people not using them). The “pros” that want DMA-based monitoring for their MCU can then select from the available backends, or code their own.

I’m sure some people have been thinking about other channels than Serial (UDP on ESP32 for example, or MQTT, etc…). There could be backends for that too!

In terms of the existing SimpleFOC implementation, I would keep it simple, and keep it on Serial. This will be what 90% of users want when first testing it out, and what the less advanced users can realistically manage.

A possible optimization might be a binary mode for monitoring.
At the moment we send a bunch of 32 bit floats as ASCII. This incurs a penalty both in terms of ASCII conversion of the data, and sending some extra bytes.
I think converting to a binary format might improve the performance somewhat.
The ASCII format could be default, and we could keep it for the commander, but the binary format could be used by the monitoring when called from the SimpleFOC Studio…

[malem]

On the MCU side, I think there is a lot that could be done, but I think care should be taken to keep it separate from the “simple and generic” interface we have now. Any Arduino has a Serial object, but not all of them have timers that work in the same way, etc…

Agreed, also with your backend idea. the default could be a backend that synchroneously write via the configured Stream. I think it would still be doable to keep the FIFO idea without losing generality.

I know you like SAMD - I think on SAMD it should be possible to drive the SERCON using DMA, with almost no overhead to the main loop. But this will hardly be portable to other MCUs. So I think a good approach here could also be to write alternative “monitoring backends”, which can be kept separate from the main code (not wasting space and confusing the people not using them). The “pros” that want DMA-based monitoring for their MCU can then select from the available backends, or code their own.

Well it’s the dev board I have in stock, and my initial plan was to reproduce Paul Gould’s controller. Lots have happend since. I’m more and more interested with the SMT32G4. But yeah, I do want DMA-based/async monitoring. And I totally agree we should design a binary protocol. Another thing I’d like to see are timestamps which would become crucial it we go async

[runger]

@malem

I’m more and more interested with the SMT32G4.

Couldn’t agree more. I discovered it recently, and I’m now trying to decide between three chips for my next board design:

• RP2040
• STM32G4
• ESP32 Pico D4
  I’m happy to share once I’ve got something worth looking at

[malem]

@runger @JorgeMaker @Antun_Skuric

Just so you know, I’ve put quite a bit of effort on the data logging side. I chose to go separate way from the commander interface since I aim for real-time data logging performance, probably on a separate, outbound-only. data link. I won’t be needing SimpleFOCStudio’s connectors. I tried, but I then found a solution that’s both simpler and much, much higher performing. I should be ready for a little demo by monday or tuesday.

Beware, it’s Pyside6-only (pyqt5 is GPL, btw), uses QtQML, and it parses C-code sunch as “Arduino-FOC/src/common/foc_utils.h” to genrate parsers automatically. It’s going to be a bit nasty at first, but don’t worry, I hate nasty code.

for example, to send a struct from MCU, it becomes as simple as:

    Serial.println("PhaseCurrent_s");
    Serial.write((uint8_t*)(&pc), sizeof(pc));

from python side, my architectural aim is to have not a simple loc to add to support a new C struct.

I use pyclibrary to parse c structs definition, and then convert them to numpy structured arrays.

I have a POC, but I’m to proud to show it as it is

[JorgeMaker]

Hi @Jason_Kirsons ,

I had some time today and I have decided to implement your suggestion to add a Jogging control.

The fast reverse button reduces the current target by 2 times the specified increment, the reverse button reduces the current target by the specified increment … etc. Stop button, in angle control mode, sets the current angle as target angle and in velocity control sets the target to zero.

Regards

[Jason_Kirsons]

That’s great! I love it! It makes it so much quicker to use.

[JorgeMaker]

Hi @Jason_Kirsons,

Just got time to implement your second suggestion os something similar. Each custom command has a name and a value as yoy can see at the bellow.

Once you have defied each custom command in rder to execute each of them you have to select it and once selected press the space key (⎵) or right arrow key (→).

Regards

[Jason_Kirsons]

Hi @JorgeMaker

Thanks, I’ve tested with a few custom commands:

And then the controller has some custom commands (changing parameters from @runger 's DRV8316 driver)

void doCustom(char* cmd) { 
  switch(cmd[0]) {
    case 'S':
      printf("Slew Rate: %i\n", atoi(&cmd[1]));
      driver.setSlew((DRV8316_Slew)atoi(&cmd[1])); 
      break;
  }
}


command.add('Z', doCustom, (char*)"Custom");

It looks like it’s working well!

Would it be possible to save the custom commands in the JSON file when we save the config?

---

Also, is it possible to save this in the JSON? Or always default to “M”?

[JorgeMaker]

Hi @Jason_Kirsons,

You are right, It’s a bit annoying having to add the custom commands every time yo execute the application. I will add the functionality of being able to save custom commands in the JSON file and also saving the “M” o whatever parameter of the engine. When I have it done I will let you know, it is a minimal change that adds quite value