Voici une liste des actioneurs utilisés et la manière dont ils se contrôlent :

Controlé en PWM, leur controle est simplifié par l'utilisation de la librairie 'Servo' Arduino.
Ils s'utilisant de la manière suivante :

Servo s1; //déclaration du servo
s1.attach(20); //le servo s1 est branché sur le pin 20
s1.write(angle); //fait tourner le servo à l'angle indiqué (0-180)

Les moteurs CC sont contrôlés grâce une shield arduino, cela permet de bénéficier d'un pont en H afin de pouvoir faire tourner le moteur dans un sens comme dans l'autre, et de controler sa puissance par PWM. Les shield utilisées sont des Adafruit MotorShield v1 upgradées pour fournir 1.2A par controleur, ou des RuggedMotorShield. La librairie de base est fournie à cette adresse : GitHub. A noter que pour la shield Rugged, nous avons modifié la librairie pour la rendre compatible, elle se trouve dans notre source (arduino/Flussmittel/asserv/)

Nous avons en 2014 utilisés une pompe, son contrôle est identique à celui d'un moteur CC.

Les moteurs pas à pas nécessitent des drivers pour les contrôler facilement. Ce genre de driver peut être acheté sur une carte indépendant (sur SparkFun part exemple), mais nous avons utilisé le driver intégré à la shield AdafruitMotorShield v1. La documentation du driver peut être trouvée avec le code la librairie : GitHub.

L'utilisation d'un driver permet de controler le moteur simplement : en lui donnant une direction, puis en commandant les pas uns à uns.

Cependant, afin de pouvoir controler le pas à pas plus facilement, nous avons également utilisé la librairie AccelStepper, qui s'occupe de commander les pas à temps régulier. Cela nous permet de demander un certain nombre de pas, et de les effectuer dans des fonctions non blocantes.

Il faut maintenant élaborer les algorithmes de controle des actioneurs afin de leur faire réaliser des actions complexes. Pour cela une architecture particulièrement adaptée est celle des machines à état. Chaque script d'action étant codé par une machine à état, il suffit de “selectionner” une machine à état pour lancer une action complexe. Cette machine à état est alors utilisée jusqu'à la fin de la réalisation de l'action, puis est arretée. Suite à cela on peut alors en lancer une autre pour lancer une autre action par exemple.

Le processus de développement est alors simple :
Un programme principal qui lit les ordres, si une action est demandée, il active la machine à état correspondante.
Il suffit alors de réaliser une machine à état par action. On obtiens un programme solide, résistant aux bugs et facile à entretenir.

En C, il est facile d'impplémenter des machines à état avec la structure suivante :

void update_machineA() {
  static int step = 0;
  switch (step) {
    case 0:
      do_things();
      if (transition01())
        step = 1;
      else if (transition03())
        step = 3;
        break;
    case 1:
      ....
      ....
  };
}

La fonction update_machineA() est appelée périodiquement par le programme principal si la machine à état A est activée.

On peut simplement concevoir son action en graphe d'état, puis le reporter directement en C.