Cours : Implantation de systèmes de contrôle, Option  SLE, ENSIMAG



Ce cours a pour but d'introduire la méthodologie de développement par modèle de systèmes de commande embarqués. Le cours contient un rappel des connaissances de base de l'automatique, des outils de conception, des langages de programmation embarquée. Sous forme d'un projet d'étude, en utilisant un robot LEGO Mindstorms NXT, les étudiants apprennent et pratiquent toutes les étapes de la chaîne de développement par modèle : modélisation, conception de contrôleur,  validation par simulation, et implantation du contrôleur dans le robot Mindstorms.

Enseignant Thao Dang, mail : Laboratoire  VERIMAG

Horaires et salle : Semestre 2, Jeudi, 11h15- 12h45, Salle E301

Plan détaillé du cours à consulter régulièrement
Update!!!

Documents
  1. Un cours d'introduction à l'automatique et au traitement du signal
  2. Matlab/Simulink
  3. Quelques documents sur Lustre  : cours Synchronous programming in Control, cours M2P Programmation synchrone, un tutorial de Lustre, et une page sur la recherche autour de Lustre
  4. Page sur le traducteur Simulink vers Lustre
  5. Robot LEGO Mindstorms NXT et NXC (Not Exactly C)
Videos des tests sur le robot

Le robot peut suivre une courbe complexe !






Plan

Semaine 1 Introduction au projet du cours (Transparents)
Semaine 2 Modélisation d'un robot mobile (par des équations differentielles), Construction du modèle Simulink

Semaine 3 Commande de robot suiveur de ligne
       - Objectifs de commande : suivre une ligne noire
       - Décomposer le problème, considérer d'abord le problème de commande pour mener le robot à un point en evitant les obstacles)
       - Solution en utilisant PIDs
Semaine 4
          Semaine 5
Outil S2L : traducteur Simulink vers Lustre, un manuel de S2L
Du fait des spécifités des outils disponibles, pour réaliser des expérimentations, on doit utiliser 2 platformes : Linux et Windows.
  1. Utiliser Simulink sous Windows pour créer un controleur en simulink, par exemple "controleur.mdl". Il faut ensuite transférer ce fichier vers une machine Linux (par exemple, Telesun)
  2. Sous Linux, utiliser le traducteur S2L pour traduire "controleur.mdl" vers un programme Lustre, "controleur.lus".
  3. Sous Linux, utiliser le compilateur lus2ec et ec2c pour compiler "controleur.lus". (Ce programme NXC ait besoin de quelques modifications pour adapter au robot. Cette manipulation peut etre faite manuellement).
  4. On revient a Windows et on utilise l'environnement Bricxcc pour compiler "controleur.nxc" et télécharger le code compilé dans le robot.


          Depuis semaine 6 : Compilation et de génération de code pour LEGO

Documents

Etapes de compilation et de génération de code NXC
     Supposons que le modèle Simulink du contrôleur est nommé controleur.mdl
On ne peut pas spécifier les nombres réels en NXC. Donc, il faut le prendre en compte dès l'étape de conception de contrôleur en Simulink (par exemple, convertir des nombres réels vers des entiers par certaine transformation).
Commande
Utiliser s2l pour traduire le modèle Simulink vers un programme Lustre par la commande : "s2l controleur.mdl -o  controleur.lus -mp". L'option -o est pour spécifier le nom du programme Lustre généré. L'option -mp pour spécifier que tous les flots de données utilisent la meme horloge.

Discrétisation de temps
L'outil s2l peut traduire seulement les blocs de Simulink en temps discret. En outre, des paramètres du modèle doivent satisfaire certaines conditions. Ceci est expliqué dans le manuel de s2l.
http://www-verimag.imag.fr/~tdang/M2/ss2lus0.01b/readme

Si le contrôleur est en temps continu, il faut faire une discrétisation. Il faut discrétiser seulement le controleur et pas le robot. Vous pouvez le faire a` la main (voir les TDs du semestre precedent), ou bien utiliser l'outil "Model discretizing" de Simulink.
Pour savoir comment discrétiser un bloc d'un modèle Simulink, lisez la partie "How to Discretize Blocks from the Simulink Model" <http://www.mathworks.com/access/helpdesk/help/toolbox/simulink/ug/f4-141391.html#f4-141593>

Version Simulink
L'outil s2l ne marche qu'avec les modele de SIMULINK de version 13. Il faut que le modele soit sauvegarde' sous la version 13 de SIMULINK.
Pour faire ceci, on fait "Save as" et choisit la version 13 de simulink. On va voir un message de Simulink si la conversion a ete faite avec succes.

Parametres de simulation
Les conditions sur les parametres de simulation sont precisees dans le document s2l-readme http://www-verimag.imag.fr/~tdang/M2/s2l-readme
Simulink2Lustre:

  -  Supported options  in .mdl models   (check  in the "Simulation
  parameters" box under "Simulation" menu,  once you have opened  a
  .mdl file):
      o The "solver" option must be set to "fixed-step, discrete"
      o The "mode" option must be set to "auto"
      o The "boolean logic signals" ("advanced" menu) flag must be
        set to on 
      o The "algebraic loop" flag ("diagnostics" menu) must be set
        to "error" 
  - Inputs  cannot    have   inherited sample times     unless  the
    --monoperiodic|-mp option is passed to s2l during translation.

Le programme main_node_name.ec2nxc contient la fonction "main_node_name_step" (qui définit des opérations d'un cycle du programme) et la fonction "main_node_name_I_c" qui lit des entrées.

On doit ensuite écrire un programme NXC dont la tache "task main()" appelle les fonctions main_node_name_I_c et main_node_name_step. Ce programme inclut "main_node_name.ec2nxc" par l'instruction #include "double_counter.ec2nxc".

          Exemple  (voir ce document pour plus de détails)

         /*
 Lustre output procs. must be defined by the user
before including the Lustre code.
The names and profiles can be deduced from the Lustre file:
<node-name>-O-<var-name>(<var-type>)
The implementation can be whatever you want...
(in this example, outputs are printed on the screen).

The names of inputs/outputs can be found in the NXC manual
*/
void main_node_name_O_x(int V) { NumOut(0, LCD_LINE3, V); }
void main_node_name_O_y(int V) { NumOut(0, LCD_LINE4, V); }

/* We define here the functions for reading inputs, which must be called before the step function, for example main_node_name_I_c
*/


/* Includes of the compiled Lustre code */

#include "main_node_name.ec2nxc"

task main () {
int cycles_counter = 0;
bool c = false;
while (cycles_counter < 3000) {
// Prepare and launch a step...
cycles_counter++;
c = !c;
main_node_name_I_c(c); // Read the inputs. This function must be called
at each cycle, before calling the step procedure.

main_node_name_step(); // The step function, which execute the operations of one cycle. This function is defined in "main_node_name.ec2nxc"
}
}