Environnement de Développement pour le Prototypage Rapide

Asservissement d'un Moteur à Courant Continu

Prise en main de l’environnement Pysimcoder

PROJET SOURCE

Le répertoire MCC_PYSIM contient :

PYSIMCODER : Environnement de Simulation python ‘simulink-like’, avec génération de code pour cible ( https://github.com/robertobucher/pysimCoder )
WORKSPACE_F411_MCC_STM32CUBEIDE : Projet Eclipse-stm32cubeIDE pour test sur cible STM32
RTScope.py : tracé de courbes à partir de mesures réalisées par la carte STM32

Pysimcoder permet donc dans un premier temps de réaliser un système sous forme de schémas blocs, de le tester ( tracé de courbes en simulation ), puis de générer un fichier correspondant à ces blocs afin de programmer une cible STM32.

Simulation

Ouvrir un terminal dans le répertoire PMSM_PYSIM/PYSIMCODER et taper :

$ bash pysim-run.sh

Dans pysimcoder, faire File–> Open, ouvrir mcc_sim.dgm

Nous retrouvons les éléments de notre système :

G(s) correspond à notre système en boucle ouverte identifié précédemment
pid_FLOAT est un correcteur numérique PI, avec les caractéristiques définies dans la partie précédente.
La période d’échantillonnage (1ms) est définie dans Settings.
Le bloc Saturation limite les variations du rapport cyclique à l’intervalle [-100 100]

Faire Simulation –> Simulate :; puis double cliquer sur Plot :

Nous avons l’évolution de la vitesse en fonction du temps pour une consigne donnée.

Test sur Cible

Génération du code pour la cible

Ouvrir maintenant mcc_target.dgm :

On retrouve une partie du schéma de simulation ; le scope et le modèle du moteur ont été retirés.
Les blocs jaunes ( pulse, speed, duty1 ) correspondent à des variables de notre programme microcontrôleur qui seront mis à jour avec les périphériques.
Les blocs bleus correspondent à des fonctions, qui seront appelées depuis le fichier généré par pysimCoder.

Faire Simulation –> Generate Code

Il se crée alors un répertoire mcc_target_gen, dans lequel se trouve mcc_target.c

Compilation, Chargement et Exécution

Ouvrons maintenant le workspace WORKSPACE_F411_MCC_CUBEIDE se trouvant dans MCC_PYSIM, avec le logiciel STM32CUBEIDE.

La tache fast_task met à jour les variables correspondant aux blocs jaunes, PYSIM_ISR(MODEL_NAME,ISR) permet d’appeler une fonction de PYSIMCODER/mcc_target_gen/mcc_target.c.
Si vous observez le makefile du projet, vous constaterez le chemin vers ce fichier, ainsi qu’à la bibliothèque des blocs pysimcoder.

REMARQUE : PysimCoder impose l’utilisation du type double.

main.c

extern double potentiometre_pysim;
extern double speed_pysim;
extern double duty1_pysim;
extern double pulse_pysim;

static void fast_task(void *pvParameters)
{
	for (;;)
	{
		HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 1);

		adc1_Get(&potentiometre);

		// MISE A JOUR INPUTS
		potentiometre_pysim=(double)potentiometre;
		pulse_pysim = (double)pulse;
		speed = quadEncoder_GetSpeedL();
		speed_pysim = (double)speed;

		PYSIM_ISR(MODEL_NAME,ISR); // FONCTION PYSIMCODER

		// MISE A JOUR OUTPUTS
		motor_SetDuty(100+(int)(duty1_pysim));

		HAL_GPIO_WritePin(GPIOC, GPIO_PIN_0, 0);
		xSemaphoreGive( xSemaphore_Slow);
		xSemaphoreTake( xSemaphore_Fast, portMAX_DELAY );
	}
}

Il suffit alors de compiler et de lancer la session de Debug. Le tracé avec RTScope.py redonne :

Asservissement en vitesse d'un Moteur à Courant Continu Annexes