Closed Nicogene closed 4 years ago
Nicogene
commented
4 years ago As expected, qt mcu is part of the commercial qt. For now I have installed a 10-days trial, but in case it show as valuable tool we might ask some licenses, I think that under these circumstances they can give us for free.
cc @maggia80 @pattacini @vtikha @marcoaccame
marcoaccame
commented
4 years ago there is also: https://www.embedded-wizard.de/ i dont know it, but our reference for arm compilers, and very good developers as well, have suggested it.
La libreria grafica di cui le ho parlato, (a mio giudizio) la migliore sul mercato nonche' la piu' completa, e' la Embedded Wizard di Tara. https://www.embedded-wizard.de/
It comes free of use w/ a watermark. the distributor is however very keen to help.
but first let's see if it any good.
Nicogene
commented
4 years ago Qt is for free for research purpose, but it has some components available only under the commercial license. I've installed a 10-days trial, but I think that we could try to contact them through this link and given the nature of our project they might give us some free licenses(cc @maggia80).
I am quite optimistic that our board is supported, since their examples on the stm32 board are
STM32F769i-DISCO
STM32F7508-DK(cc @marcoaccame @MrAndrea)
Installing the 10days trial I have also some precompiled binaries of the examples, I can upload them in the code branch, in this way who has the board(@marcoaccame) can try to deploy it on our board.
This is just a preliminary analysis since I don't have the board, and I cannot test it, but following what they say, this framework it is lightweight, and it works also on bare-metal, i.e. in absence of a OS.
Btw it supports RTOS.
:warning: This section will be updated.
After watching this webinar, specific for deployment on stm32 boards, I'd say yes.
All the development is done through qt-creator and simply you have to specify different target toolchains once compiling.
It is supported the debugger through gdb.
In the webinar the gui is done with qml, that is a qt scripting language, that is a sort of json with some javascript logic.
I am not sure that also not-qml based guis are supported(I'd say yes).
The workflows seems to be the same of the standard gui programming with qt, with the signals and slots logic.
They provide a framework just for front-end, all the back-end logic, the communication with the hardware has to be done using the vendor APIs(stm32 for example).
:warning: It is a preliminary analysis.
It seems pretty easy to use, and pretty fast to give it a try in order to see if it fits our need
cc @pattacini @vtikha
vtikha
commented
4 years ago @Nicogene great! let's organise and work on this together.
marcoaccame
commented
4 years ago i like this approach. let's investigate it.
marcoaccame
commented
4 years ago just to summarize a brief chat we have justa had w/ @Nicogene:
marcoaccame
commented
4 years ago just talked w/ mr marx from qt and explained to him our interest in their technology and the limit of the 10-days evaluation period in our agile working method.
he said that for the building of the prototype they can help us to extend the period. also, an italian representative fro northen italy will call me to explain details of how to collaborate in teh short term (i read: building the prototype) and in the long term (i read: how much we should pay for license fees when the product becomes commercial).
Antoine Marx
Customer Success Executive
+33 7 89 37 91 51Hi, just some more info on the Qt MCU solution.
Qt MCU is a GUI centric solution which produces an executable where the GUI engine is run in bare metal mode and there are hooks to actions towards the HW. They are working on a solution which integrates Free RTOS but the main program will be driven by the GUI in the same way as now.
I am looking forward to talk w/ a person from Qt to verify this understanding of mine.
I followed the webinar and I paid attention on how to interface the GUI to the MPU platform, then I listened carefully the Q&A at the end. Here is what I understood.
from the video:
I did not see any use of the GUI inserted into a main() program which init HW, starts control loop, init the GUI, ticks the GUI with the rate and scheduling policy the user chooses. So I listen carefully the Q&A, turned the subtitles on and:
it is not possible to run the GUI from a main().
if run in bare metal mode (the only one available at date on webinar, march 2020) then it is the code of QT MCU which ticks the GUI and manages the signals and slots of Qt.
they are working at integrating Free RTOS, but the paradigm they say will be: it start the main genartaed by Qt MCU which drive the GUI and there will be C++ API to start other threads.
marcoaccame
commented
4 years ago I have talked to a Senior Account Manager for Italy. They can surely give us an evaluation licence longer than 10 days. He however says that the Qt MCU is a paying product. The costs are some thousands (i recall 5000 EURO) per year per developer plus there is a royalty fee per device. They start numbers > 30K. He didn't say how much.
I also had a contact w/ a Pre-Sales Engineer for technical aspects. It comes out that the development on Qt MCU is Qt-centric. You cannot call the GUI library from your application but you must do the other way round: you develop the GUI and then from it you can call some functions which customise and run your application.
Questions to Qt
Answers from Qt I got response for your questions from our MCU product team and a question for ‘ticks’ refresh implementation:
It is better explore alternatives
marcoaccame
commented
4 years ago From https://www.embedded-wizard.de/ I have downloaded what we need to develop on our board together with some examples.
I has an editing program which allows generate the GUI and then to link it to the ARM keil compiler we are using.
I have used a ready GUI which I have executed on the board.
The working mode is easy: from the main.c there are initialisation functions and there is one function that is regularly called. I have tried to execute the tick less frequently and at 10 Hz the GUI still works fine.
int main( void )
{
/* initialize system */
EwBspSystemInit();
/* initialize console interface for debug messages */
EwBspConsoleInit();
/* initialize Embedded Wizard application */
if ( EwInit() == 0 )
return 0;
EwPrintSystemInfo();
/* process the Embedded Wizard main loop */
#define MARCO_CHANGES
#if defined(MARCO_CHANGES)
for(;;)
{
EwProcess();
HAL_Delay(100);
}
#else
while( EwProcess())
;
#endif
/* de-initialize Embedded Wizard application */
EwDone();
/* terminate the system */
EwBspSystemDone();
return 0;
}
maggia80
commented
4 years ago great! Let's go for Embedded Wizard.
Is there a way to start working on a prototype development IDE? where designing the GUI and generate the code for the STM32?
cc: @vtikha , @Nicogene
Nicogene
commented
4 years ago Embedded Wizard is free only for education/evaluation/prototyping purposes.
The free version has the watermark and a limit on the complexity of the project (The used number of bitmaps, fonts, classes, etc. define the complexity).
See their pricing section for further information.
It is possible to deploy on the laptop (target WIN32) and on our board. It has also a sort of "dry-run" mode implemented with the variant classes, in order to fast prototype and test the UI without having to interface to the board every time.
@marcoaccame checked here that it is possible to define with which period refresh the gui and then reserve the right amount of the memory
I followed all their "Quick tour" tutorial and I managed to create a gui for a coffe machine 😅 .
I'd say that it is not difficult to use, it is only a little bit strange for me for the user experience. But we can train or ask help to learn how to use it properly.
The code of the logic that you write inside the Embedded Wizard Studio is chora.
It seems pretty similar to c#, with some new directives like native.
In particular native is used to specify a part of the code that has to remain as it is in the generation phase(usually it includes the function calls to the hardware, aka the back-end).
E.g. this was the code to be executed pressing the brewing button:
native ( aCoffeeStrength )
{
/* Implement here your C code to start the brewing process in
the device. If necessary predeclare the C functions intended
to be used here. For example: */
extern void YourDevice_StartBrewing( int aStrength );
YourDevice_StartBrewing( aCoffeeStrength );
}It generates c code that can be imported in keil, @marcoaccame tested one of their examples successfully on the board.
It seems pretty easy to use, and pretty fast to give it a try in order to see if it fits our need.
@vtikha and me will try to check their oscilloscope example, modify it in order to have a first prototype of our gui.
cc @maggia80
Nicogene
commented
4 years ago We decided to proceed with Embedded Wizard for now, closing.
The purpose of this issue is to examine the available tools for programming GUIs on micro.
@marcoaccame managed to draw some simple shapes using the native gui library (see https://github.com/icub-tech-iit/ventilator/issues/3#issuecomment-605447816) , please correct me if I am wrong.
For now the alternatives are the Qt library, that it supports also the deployment on microcontroller(see https://www.qt.io/qt-for-mcus), and the Embedded Wizard library.
I'd use these criteria: