Performances de QuickStep

Base de temps

Pour les vitesses des moteurs, il est difficile de les exprimer en tr/mn ou en tr/s car cela dépend du nombre de pas par tour du moteur. Je donnerai quelques vitesses de rotations pour des moteurs donnés. Pour les moteurs fonctionnant en demi-pas ou en micro-pas, je garderai le terme de µs/pas pour ne pas alourdir, en considérant qu'un moteur 200pas/tr en mode demi-pas est vu par la bibliothèque comme un moteur de 400pas/tr.

La base de temps est le plus petit intervalle de temps entre deux pas des moteurs. Cela détermine la vitesse maximale des moteurs. Les moteurs peuvent tourner entre <base de temps>/pas et 255,996<base de temps>/pas. Par exemple pour une base de temps de 100µs, les moteurs peuvent tourner entre 100µs/pas et 25599,6µs/pas. Si les caractéristiques des différents moteurs sont renseignés (nombre de pas par tour et vitesse maximale souhaitée), la base de temps est choisie automatiquement pour permettre la rotation du moteur le plus exigent. Mais la connaissance de ces temps est importante.

Plus la base de temps est petite, plus on va passer de temps dans les interruptions, mais plus le moteur peut tourner vite. La base de temps peut être choisie entre deux limites.

La valeur minimale de la base de temps est imposé par le temps de calcul de la bibliothèque. Si on approche trop de ce minimum, les interruptions étant prioritaires, vont utiliser tout le temps disponible et il n'y en aura plus assez pour le programme principal. Cette valeur minimale peut être à peu près calculée ainsi:

Temps de base: 3,33µs
Rajouter 0,30µs par moteur utilisable
Rajouter 5,06µs par moteur qui tourne
Rajouter 1,00µs par moteur qui tourne dont on compte les pas en 32 bits
Rajouter 1,00µs par moteur qui utilise PREM_BOBINE et DEUX_BOBINE
Rajouter 0,30µs de plus par moteur qui utilise TROIS_BOBINE et QUATRE_BOBINE

Par exemple pour un seul moteur commandé par STEP seul avec un comptage des pas en 16 bits, la valeur minimale de la base de temps est de 3,38µs + 0,31µs + 5,06µs soit 8,69µs (on ne peut pas faire moins).

Pour deux moteurs commandé par les 4 bobines, mais dont un seul tourne avec un comptage des pas en 32 bits, la valeur minimale de la base de temps est de 3,38µs + 2ⅹ0,31µs + 5,06µs + 1,00µs + 1,00µs + 0,30µs soit 11,3µs.

Pour huit moteurs commandé par par STEP, tous avec un comptage des pas en 32 bits, la valeur minimale de la base de temps est de 3,38µs + 8ⅹ0,31µs + 8ⅹ5,06µs + 8ⅹ1,00µs soit 54,28µs.

Utiliser ou non UN_TOUR, VITESSE_MAXI, DIR, ENABLE, DEMI_PAS, NB_ORDRES_DANS_LA_PILE, NB_ORDRES_ACCELERATION ne change pas le temps minimum et donc la vitesse maximale.

Cela donne si on utilise que des moteurs commandés avec STEP comptages de pas en 16 bits les valeurs de la base de temps minimale en µs:

                    Nombre de moteurs en tout
12345678
8,89,19,49,710101111Si un seul moteur tourne à la fois
14141515151616Si 2 moteurs tournent à la fois
192020202121Si 3 moteurs tournent à la fois
2525252626Si 4 moteurs tournent à la fois
Base de temps
µs
30313131Si 5 moteurs tournent à la fois
363636Si 6 moteurs tournent à la fois
4141Si 7 moteurs tournent à la fois
46Si 8 moteurs tournent à la fois

Pour les mêmes moteurs en 200pas/tr et 16 micro-pas, les vitesses maximales correspondantes en tr/s sont les suivantes (multipliez par 60 pour les avoir en tr/mn, multipliez par 8 en mode demi-pas ou 16 pour le mode pas entier):

            Nombre de moteurs en tout
12345678
3634333231302929Si un seul moteur tourne à la fois
22222121202019Si 2 moteurs tournent à la fois
161615151515Si 3 moteurs tournent à la fois
1312121212Si 4 moteurs tournent à la fois
Vitesse maxi tr/s
Moteur 200pas/tr
16 µpas
10101010Si 5 moteurs tournent à la fois
8,88,78,6Si 6 moteurs tournent à la fois
7,67,6Si 7 moteurs tournent à la fois
6,7Si 8 moteurs tournent à la fois

La vitesse de rotation d'un 28BYJ-48 n'est pas limité par cette bibliothèque. Pour 8 de ces moteurs tournant en même temps 46µs/pas donnerait une vitesse de plus de 10tr/s.

La valeur maximale de la base de temps est (quasi) imposée par le timer utilisé. Elle est de 16ms pour un timer 8 bits (timer 0 et timer 2), et de 4s pour le ou les timers 16 bits. Cela fait un temps maximal entre deux pas de 4s avec un timer 8 bits et un pas toutes les 17mn avec un timer 16 bits.

Voici le chronogramme obtenu avec un seul moteur, en mode 16 bits, avec STEP:

En haut l'impulsion STEP de 2,625µs, en bas la visualisation de la partie code de l'interruption. Quand l'interruption est terminée, il y a restitution du contexte, puis immédiatement derrière une nouvelle interruption qui doit sauvegarder le contexte avant que le code proprement dit ne commence. La fonction d'interruption complète dure en fait bien 8,688µs. C'est donc le temps minimum entre deux impulsion STEP. On voit bien que STEP est géré pendant l'interruption.

quickStepRotation

La durée de cette fonction n'intervient pas directement sur les vitesses de rotation, tant qu'elle a le temps de s'exécuter. Son temps d'exécution peut être important si on enchaîne des mouvements rapides, car il faut les calculer. le temps d'exécution peut se calculer; C'est environ:

quickStepRotation:
75µs + 150µs/palier

Sans accélérations quickStepRotation dure 75µs environ (c'est son temps minimal) et si on utilise 255 par d'accélération, quickStepRotation(nbPas, vitesse, acceleration_sur N pas_ou_micro_pas, deceleration_sur N pas_ou_micro_pas); va durer environ 76ms (2ⅹ255 paliers).

Taille du code

Les valeurs sont données pour un programme faisant tourner le moteur un tour dans un sens, une seconde d'arrêt, un tour dans l'autre sens, une seconde d'arrêt. Le programme est le suivant:

// Version 2.0.0

//###############################################################
//###############################################################
//####                                                       ####
//####                     Olivier Pécheux                   ####
//####                    Olivier@Pecheux.fr                 ####
//####                   (33) +6 69 77 82 58                 ####
//####         http://arduino.dansetrad.fr/QuickStep         ####
//####                                                       ####
//###############################################################
//###############################################################

// Ce programme fait tourner un moteur hybride 200 pas par tour
// en mode 16 micro-pas, avec le cycle: un tour dans un sens, une
// seconde d'arrêt, un tour dans l'autre sens, une seconde
// d'arrêt.

#include "QuickStep.h"

void setup()
{
  quickStepInit(); // Obligatoire pour utiliser QuickStep
}

void loop()
{ 
  // Un tour dans un sens, une seconde d'arrêt
  quickStepRotationX(UN_TOUR_X, 1 RPS, UN_TOUR_X, UN_TOUR_X);
  quickStepWaitX(); // Attente de la fin de l'aller
  delay(1000);
  
  // Un tour dans l'autre sens, une seconde d'arrêt
  quickStepRotationX(-UN_TOUR_X, 1 RPS, UN_TOUR_X, UN_TOUR_X);
  quickStepWaitX(); // Attente de la fin du retour
  delay(1000);
}

La taille du code se calcule à peu près ainsi (si il y a deux nombres, le premier est pour le mode comptage des pas sur 32 bits, le second est pour le mode comptage des pas sur 16 bits:

                      octets de code   octets de donnée
Taille de base:                 2633              220 
Par moteur:                    964/840           36/28
Par DIR:                        18/16
Par ENABLE:                       2
Par PREM_BOBINE:                 24                1
Par TROIS_BOBINE:                30                1
Par DEMI_PAS:                    30
Par INVERSION:                  16/6
Par ORDRES_DANS_LA_PILE:                          6/4
Par NB_ORDRES_ACCELERATION:   1002/986

Attention: c'est 1002 octets en plus si on utilise les accélérations quel que soit le nombre de paliers, mais c'est 4 ou 6 octets de données par ordre dans la pile. Si on configure #define NB_ORDRES_DANS_LA_PILE_X 127, cela rajoute 127 fois 4 ou 6 octets.

Il faut en gros compter 2630 octets de code + 1000/900 octets par moteur et pour les données 220 octets + 30 octets par moteur ainsi que 6/4 octets de données par ordre dans la pile. C'est cette dernière qui est importante. Avec une Uno/Nano pour 8 moteurs, cela fait déjà 460 octets, et on ne peut guère dépasser 1000 octets pour les piles, soit 170 ordres si on compte en 32 bits, et 250 ordres si on compte en 16 bits. Cela fait une moyenne de 20 ou 30 ordres par moteur.

Pour un programme un tour - 1 seconde - retour - 1 seconde, avec des moteurs commandés par STEP, comptage en 32 bits, et une pile d'ordre de 3 sans accélérations, cela donne un programme de 3634 octets de code et 263 octets de donnée pour un seul moteur, 4604 octets de code et 272 octets de données pour deux moteurs.

SurVitesseMaxi   <<