La base des 100µs

Ces 100µs est la résolution par défaut pour le softPWM et le temps minimum entre deux pas (ou micro-pas) pour les moteurs pas à pas. Avec 100µs on peut utiliser environ 14 softPWM ou bien 7 moteurs pas à pas tournant à maximum 10000 pas/s (ou encore un habile mélange des deux). C'est suffisant pour beaucoup d'applications.

Entre deux pas ou micro-pas on peut avoir entre 1 et 3600000 fois la base de temps. Avec 100µs, on peut avoir entre 100µ entre pas (10000 pas/s) et un pas par heure. Avec une base de temps de 1ms, on peut avoir un pas toutes les 10 heures.

la fonction MTtimeBase() permet de choisir la base de temps entre 12µs (si on veut aller vite) et 1ms (si on n'a pas besoin de vitesse et que l'on ne souhaite pas passer trop de temps dans la fonction d'interruption). Du fait de l'utilisation commune avec l'horloge système, la résolution est de 4µs. On peut donc choisir 12µs, 16µs, 20µs, 24µs... Si on demande 22µs, c'est le temps inférieur qui est mis en place (20µs), pour permettre un pas toutes les 22µs en moyenne.

MTtimeBase(100 micro_secondes); // Par défaut
MTtimeBase(10 micro_secondes); // Minimum
MTtimeBase(1024 micro_secondes); // Maximum

La base de temps système

La base de temps système permet d'utiliser micro(), millis() et delay(). Les fonctions delayMicroseconds(), _delay_ms() et _delay_us() utilisent quand à elles des boucles et dépendent très fortement du temps passé dans les interruptions. Elles seraient justes sans les interruptions. La base de temps système tournant à 1024µs (si le quartz était parfait), millis() s'incrémente parfois de 1, parfois de 2. La résolution de millis() est donc de 2ms. Cette base de temps est fixe, la modifier modifierait micro(), millis() et delay().

La bibliothèque MTobjects n'utilise pas cette horloge, et si on n'utilise pas les 3 fonctions, on peut la désactiver, ce qui économise du temps de calcul et permet par exemple de faire tourner un pas à pas plus vite.

MTstopDelayMillis(); // Désactive l'horloge système
MTstartDelayMillis(); // Réactive l'horloge système

Dès que l'on utilise un quelconque objet de MTobjects, ces fonctions sont accessibles. Il n'est donc pas utile de mettre un #include en plus.

Si on a besoin de millis() mais pas de micro() ou delay(), on peut aussi désactiver cette horloge et utiliser MTmillis() à la place.

Le partage du temps

Bien entendu pour que tout cela fonctionne, il ne faut pas dépasser certaines limites temporelles. Si ce n'est pas le cas, les pas à pas peuvent ne pas tourner à la bonne vitesse, les boutons peuvent ne plus être pris en compte...

Note sur les boutons: dans un fonctionnement normal, un bouton est pris en compte, mais son traitement peut être différé si le traitement des autres événements est long.

Voici les limites basse de la base de temps:
- sans aucun objet: 12µs
- si on laissé activée l'hologe système: ajouter 6µs (à vérifier, les mesures faites me diraient 0µs!)
- pour chaque MTsoftPWM: rajouter 6µs
- pour chaque MTulnStepper: rajouter 16µs
- pour chaque MTstepStepper: rajouter 12µs
- pour les autres objets: ne rien rajouter

Par exemple en désactivant l'horloge système:
- pour 7 MTstepStepper, la limite basse est de 12µs + 7*12µs = 96µs. On peut donc faire pour chaque moteur 1 pas toutes les 96µs (10400 pas/s), ou prendre une base de temps de 100µs si on fait moins de 10000pas/s... On peut bien sûr prendre une base de temps de 1ms si on fait moins de 1000 pas/s
- avec un seul MTStepStepper, la limite basse est de 24µs. on peut alors faire 1 pas toutes les 24µ soit environ 41666pas/s. Avec un moteur hybride de 200 pas/tr et en mode 16 micro-pas, cela fait 41666/ (200 * 16) = 13 tr/mn
- si on a 10 boutons, 2 MTsoftPWM et 3 pas à pas, et que l'horloge système n'est pas désactivée, il faut:
  12µs (base incompressible pour la bibliothèque)
  6µs (horloge système)
  0µs (10 boutons)
  2*6µs (2 MTsoftPWM)
  3*12µs (2 MTstepStepper)
  ━━━━━━━━━━━━━━━━━━━━━━━━
  66µs
Dans la plupart des cas, on ne change pas les 100µs par défaut.

Notez aussi qu'un moteur tournant à 1tr/s aurait besoin de 200 impulsion par tour en mode pas entier, mais si on utilise, comme je le conseille, le mode 16 micro-pas, il faut 3200 impulsions par tour. C'est donc utile d'avoir une bibliothèque permettant de donner un nombre d'impulsion par tout important. Un pas à pas à 200 pas par tour en mode 16 micro-pas (3200 impulsions par tour) et tournant à sa vitesse maximum (3000tr/mn soit 50tr/s) aurait besoin de 160000 impulsions par seconde (1 impulsion toutes les 6,25µs), ce que ne permet pas cette bibliothèque.

La hiérarchie des classes

Il y a trois classes de base:

Les trois classes de base permettent de donner régulièrement la main aux objets.

Les objets descendant de MTquickObjets ont besoin d'intervenir souvent (par défaut toutes les 100µs) et sont prioritaires. On y trouve par exemple la gestion de l'avance des pas à pas, la gestion du signal pour un PWM logiciel.
Les objets descendant de MTmediumObjets ont besoin d'intervenir régulièrement (toutes les 16ms) . C'est le cas des boutons que l'on doit visiter de temps en temps.
Les objets descendant de MTslowObjets permettent un traitement des événements. Les traitements peuvent démarrer toutes les 16ms si les traitement précédents sont terminés. Tous les objets utilisables descendent donc de cette classe.

Les boutons:

Les horloges:

Les PWM:

Les servomoteurs:

Les moteurs pas à pas:

Exemples

• Exemple 1: delay() pas si bloquant!
• Exemple 2: Minimum de MTtimeBase