Driver Pololu 3133 ou Tic T834

Version
Télécharger 18
Taille du fichier 0.20 KB
Date de création 25 avril 2022
Télécharger

Mise à jour le 06/05/2022 : Article regroupant les tuto et les fichiers de la carte de commande Tic T834 de Pololu basée sur un circuit DRV8834 permettant le contrôle d'un moteur pas-à-pas bipolaire.

Sommaire.

Présentation de la carte .
Information technique .
Ensemble des schémas de câblage
Code et tuto pour le pilotage d'une carte Pololu 3133 en I2c
Pour tout probléme.
Retour au menu

Présentation de la carte Pololu 3133

Retour au sommaire

Information technique

Carte de commande multi-interfaces Tic T834 de Pololu basée sur un circuit DRV8834 permettant le contrôle d'un moteur pas-à-pas bipolaire. Ce driver peut être commandé via plusieurs interfaces telles que USB, I2C, série TTL, signal RC, analogique, etc et nécessite l'utilisation d'un logiciel disponible en téléchargement pour la configuration.

Cette carte dispose de plusieurs modes de fonctionnement "microsteps": pas complet, demi-pas, quart de pas, 1/8 de pas, 1/16 de pas ou 1/32 de pas. La vitesse maximale peut être de 50 000 pas/seconde et la vitesse minimale jusqu'à 1 pas toutes les 200 secondes. Un guide d'utilisation complet est disponible (uniquement en anglais) dans l'onglet ''fiche technique''.

Ce module peut être commandé via plusieurs interfaces :

Via une fiche micro-USB , pour une connexion directe à un ordinateur.
Série TTL en 5 Vcc pour une utilisation avec un microcontrôleur
I2C pour une utilisation avec un microcontrôleur
Signal RC (radio-commande)
Signal analogique pour une utilisation avec un potentiomètre
Entrée pour encodeur à quadrature à utiliser avec un encodeur rotatif
Entrées digitales STEP/DIR

Alimentation:
- partie moteur: 2,5 à 10,8 Vcc
- partie logique: aucune, régulateur 5 Vcc intégré
Sortie: 1,5 A par phase
Vitesse maxi: 50000 pas par seconde (suivant le moteur)
Compatibilité: Windows, MacOS, Linux (x86 et Raspberry Pi)
Dimensions: 38 x 27 x 11 mm
Poids: 5,1 g
Référence Pololu: 3133

Retour au sommaire

Schéma de cablage

Cliquez sur la photo pour visualiser les schémas de câblage

[Montrer sous forme de vignettes]

Code et tuto Arduino
pour le pilotage d'une carte Pololu 3133 en I2c

Code principal :

//
//
//=====================================================
// RedOhm
//
// Mise en service de la carte Pololu 3133 ou Tic T834
// Pilotage en I2c
//
// Lecture de la tension de service du driver
//  Lecture du courant de reglage
//   Mise sous tension par programme
//    deplacement du moteur dans les 2 sens
//     Pilotage de la deceleration
//
// Le 25/04/2022
// Herve Mazelin
//
// Documentation :https://pololu.github.io/tic-arduino
//=====================================================

// librairie pour le pilotage de la carte Pololu 3133 ou Tic T834
#include <Tic.h>
// creation de l'objet tic
TicI2C tic;


// Connection du bouton poussoir à la broche d'entrée 4
int bouton_poussoir_bleu = 4;
// Variable de lecture du bp bleu
int val_bouton_poussoir_bleu ;

// Connection du bouton poussoir à la broche d'entrée 5
int bouton_poussoir_rouge = 5;
// Variable de lecture du bp rouge
int val_bouton_poussoir_rouge ;


//  Un programme Arduino doit impérativement contenir cette fonction
//  Elle ne sera exécutee une seule fois au démarrage du microcontroleur
//  Elle sert à configurer globalement les entrées sorties
void setup()
{
  delay (7000);

  // initialisation de la connexion série
  // IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.
  Serial.begin(9600);
  // on attent que le port de communication soit pret
  while (!Serial) {
    ;
  }

  // Configurer I2C..
  Wire.begin();

  // Donnez au Tic le temps de démarrer.
  delay(20);

  // En mode de contrôle série/I2C/USB, cette commande provoque
  // l'effacement de l'erreur de violation de démarrage sécurisé
  // pendant 200 ms. S'il n'y a pas d'autres erreurs, cela permet
  // au système de démarrer.
  tic.exitSafeStart();

  // on déclare le bouton poussoir bleu en entrée
  pinMode ( bouton_poussoir_bleu , INPUT);

  // on déclare le bouton poussoir rouge en entrée
  pinMode ( bouton_poussoir_rouge , INPUT);

  // ======== Controle de la tension sur le driver

  // obtient la mesure actuelle de la tension VIN, en millivolts.
  // float:Déclare la variable tension_en_tic de type "virgule-flottante".
  float tension_en_tic = tic.getVinVoltage();
  // transformation de la valeur de millivolts en volts
  tension_en_tic = tension_en_tic / 1000;
  // Affichage de la valeur de tension d'entrée du tic
  Serial.print ("Tension d'entrée driver Tic => ");
  Serial.print (tension_en_tic);
  Serial.println (" Volts");

  // Obtient la limite de courant de la bobine du moteur pas à pas en milliampères.
  // float:Déclare la variable reglage_courant_moteur_tic de type "virgule-flottante".
  float reglage_courant_moteur_tic = tic.getCurrentLimit();
  // transformation de la valeur de milliampéres en amperes
  reglage_courant_moteur_tic = reglage_courant_moteur_tic / 1000;
  // Affichage du reglage du courant du tic
  Serial.print ("Reglage courant moteur => ");
  Serial.print (reglage_courant_moteur_tic);
  Serial.println (" Ampere");

  //Activation du driver
  tic.energize();
  // Affichage de l'information de mise en activation du driver
  Serial.println ("Activation du driver ");
  // Création du ligne vide
  Serial.println (" ");

}
// ============= Fin du setup ==================================

// Envoie une commande "Reset command timeout" au Tic.
// Nous devons appeler ceci au moins une fois par seconde,
// ou bien un délai d'attente de commande erreur se produira.
// Délai d'expiration de la commande par défaut du Tic
// est de 1000 ms, mais il peut être modifié ou désactivé
// dans le Tic centre de contrôle.
// Pour le tuto j'ai devalidé cette fonction dans tic Control Center
void resetCommandTimeout()
{
  tic.resetCommandTimeout();
}



// Retarde le nombre spécifié de millisecondes afin
// que son mouvement ne soit pas interrompu par des erreurs.
void delayWhileResettingCommandTimeout(uint32_t ms)
{
  uint32_t start = millis();
  do
  {
    resetCommandTimeout();
  }
  while ((uint32_t)(millis() - start) <= ms);
}

// Le programme principal s’exécute par une boucle infinie appelée Loop ()
void loop()
{

  val_bouton_poussoir_rouge = digitalRead (bouton_poussoir_rouge);
  if (val_bouton_poussoir_rouge == HIGH )
  {
    rouge();
  }

  val_bouton_poussoir_bleu = digitalRead (bouton_poussoir_bleu);
  if (val_bouton_poussoir_bleu == HIGH )
  {
    bleu();
  }

}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

124

125

126

127

128

129

130

131

132

133

134

135

136

137

138

139

140

141

142

143

144

145

//=====================================================

// RedOhm

// Mise en service de la carte Pololu 3133 ou Tic T834

// Pilotage en I2c

// Lecture de la tension de service du driver

// Lecture du courant de reglage

// Mise sous tension par programme

// deplacement du moteur dans les 2 sens

// Pilotage de la deceleration

// Le 25/04/2022

// Herve Mazelin

// Documentation :https://pololu.github.io/tic-arduino

//=====================================================

// librairie pour le pilotage de la carte Pololu 3133 ou Tic T834

#include <Tic.h>

// creation de l'objet tic

TicI2C tic;

// Connection du bouton poussoir à la broche d'entrée 4

int bouton_poussoir_bleu = 4;

// Variable de lecture du bp bleu

int val_bouton_poussoir_bleu ;

// Connection du bouton poussoir à la broche d'entrée 5

int bouton_poussoir_rouge = 5;

// Variable de lecture du bp rouge

int val_bouton_poussoir_rouge ;

// Un programme Arduino doit impérativement contenir cette fonction

// Elle ne sera exécutee une seule fois au démarrage du microcontroleur

// Elle sert à configurer globalement les entrées sorties

void setup()

{

delay (7000);

// initialisation de la connexion série

// IMPORTANT : le terminal côté PC doit être réglé sur la même valeur.

Serial.begin(9600);

// on attent que le port de communication soit pret

while (!Serial) {

;

}

// Configurer I2C..

Wire.begin();

// Donnez au Tic le temps de démarrer.

delay(20);

// En mode de contrôle série/I2C/USB, cette commande provoque

// l'effacement de l'erreur de violation de démarrage sécurisé

// pendant 200 ms. S'il n'y a pas d'autres erreurs, cela permet

// au système de démarrer.

tic.exitSafeStart();

// on déclare le bouton poussoir bleu en entrée

pinMode ( bouton_poussoir_bleu , INPUT);

// on déclare le bouton poussoir rouge en entrée

pinMode ( bouton_poussoir_rouge , INPUT);

// ======== Controle de la tension sur le driver

// obtient la mesure actuelle de la tension VIN, en millivolts.

// float:Déclare la variable tension_en_tic de type "virgule-flottante".

float tension_en_tic = tic.getVinVoltage();

// transformation de la valeur de millivolts en volts

tension_en_tic = tension_en_tic / 1000;

// Affichage de la valeur de tension d'entrée du tic

Serial.print ("Tension d'entrée driver Tic => ");

Serial.print (tension_en_tic);

Serial.println (" Volts");

// Obtient la limite de courant de la bobine du moteur pas à pas en milliampères.

// float:Déclare la variable reglage_courant_moteur_tic de type "virgule-flottante".

float reglage_courant_moteur_tic = tic.getCurrentLimit();

// transformation de la valeur de milliampéres en amperes

reglage_courant_moteur_tic = reglage_courant_moteur_tic / 1000;

// Affichage du reglage du courant du tic

Serial.print ("Reglage courant moteur => ");

Serial.print (reglage_courant_moteur_tic);

Serial.println (" Ampere");

//Activation du driver

tic.energize();

// Affichage de l'information de mise en activation du driver

Serial.println ("Activation du driver ");

// Création du ligne vide

Serial.println (" ");

}

// ============= Fin du setup ==================================

// Envoie une commande "Reset command timeout" au Tic.

// Nous devons appeler ceci au moins une fois par seconde,

// ou bien un délai d'attente de commande erreur se produira.

// Délai d'expiration de la commande par défaut du Tic

// est de 1000 ms, mais il peut être modifié ou désactivé

// dans le Tic centre de contrôle.

// Pour le tuto j'ai devalidé cette fonction dans tic Control Center

void resetCommandTimeout()

{

tic.resetCommandTimeout();

}

// Retarde le nombre spécifié de millisecondes afin

// que son mouvement ne soit pas interrompu par des erreurs.

void delayWhileResettingCommandTimeout(uint32_t ms)

{

uint32_t start = millis();

{

resetCommandTimeout();

}

while ((uint32_t)(millis() - start) <= ms);

}

// Le programme principal s’exécute par une boucle infinie appelée Loop ()

void loop()

{

val_bouton_poussoir_rouge = digitalRead (bouton_poussoir_rouge);

if (val_bouton_poussoir_rouge == HIGH )

{

rouge();

}

val_bouton_poussoir_bleu = digitalRead (bouton_poussoir_bleu);

if (val_bouton_poussoir_bleu == HIGH )

{

bleu();

}

Retour au sommaire

Onglet : 01_bleu

//
// cycle bouton bleu

void bleu()
{
  Serial.println ("Demarrage cycle bouton bleu ");

  // Avance de 200 pas par seconde
  tic.setTargetVelocity(2000000);
  // pendant 5 secondes
  delayWhileResettingCommandTimeout(5000);


  // Décélérez jusqu'à l'arrêt.
  tic.setTargetVelocity(0);
  delayWhileResettingCommandTimeout(1000);

  // Déplacez-vous en sens inverse à 100 pas par seconde
  tic.setTargetVelocity(-1000000);
  // pendant 4 secondes.
  delayWhileResettingCommandTimeout(4000);

  // Décélérez jusqu'à l'arrêt.
  tic.setTargetVelocity(0);
  delayWhileResettingCommandTimeout(1000);

  // Avance de 400 pas par seconde
  tic.setTargetVelocity(4000000);
  // pendant 3 secondes
  delayWhileResettingCommandTimeout(3000);

// cycle bouton bleu

void bleu()

{

Serial.println ("Demarrage cycle bouton bleu ");

// Avance de 200 pas par seconde

tic.setTargetVelocity(2000000);

// pendant 5 secondes

delayWhileResettingCommandTimeout(5000);

// Décélérez jusqu'à l'arrêt.

tic.setTargetVelocity(0);

delayWhileResettingCommandTimeout(1000);

// Déplacez-vous en sens inverse à 100 pas par seconde

tic.setTargetVelocity(-1000000);

// pendant 4 secondes.

delayWhileResettingCommandTimeout(4000);

// Décélérez jusqu'à l'arrêt.

tic.setTargetVelocity(0);

delayWhileResettingCommandTimeout(1000);

// Avance de 400 pas par seconde

tic.setTargetVelocity(4000000);

// pendant 3 secondes

delayWhileResettingCommandTimeout(3000);

Retour au sommaire

Onglet : 02_rouge

//
// cycle bouton rouge

void rouge()

{
  Serial.println ("Demarrage cycle bouton rouge ");

  // Avance de 200 pas par seconde
  tic.setTargetVelocity(2000000);
  // pendant 2 secondes
  delayWhileResettingCommandTimeout(2000);

  // Décélérez jusqu'à l'arrêt.
  tic.setTargetVelocity(0);
  delayWhileResettingCommandTimeout(1000);

  // Déplacez-vous en sens inverse à 100 pas par seconde
  tic.setTargetVelocity(-1000000);
  // pendant 1 seconde.
  delayWhileResettingCommandTimeout(1000);

  // Décélérez jusqu'à l'arrêt.
  tic.setTargetVelocity(0);
  delayWhileResettingCommandTimeout(1000);
}

// cycle bouton rouge

void rouge()

{

Serial.println ("Demarrage cycle bouton rouge ");

// Avance de 200 pas par seconde

tic.setTargetVelocity(2000000);

// pendant 2 secondes

delayWhileResettingCommandTimeout(2000);

// Décélérez jusqu'à l'arrêt.

tic.setTargetVelocity(0);

delayWhileResettingCommandTimeout(1000);

// Déplacez-vous en sens inverse à 100 pas par seconde

tic.setTargetVelocity(-1000000);

// pendant 1 seconde.

delayWhileResettingCommandTimeout(1000);

// Décélérez jusqu'à l'arrêt.

tic.setTargetVelocity(0);

delayWhileResettingCommandTimeout(1000);

}

Retour au sommaire

Pour tout probléme

Pour tout problème de téléchargement ou pour nous suivre sur les réseaux sociaux voici les plateformes sur lesquelles nous éditons.
Cliquez sur celle qui vous intéresse .

Facebook Twitter Youtube

Grabcad Thingiverse Cults

Nous avons mis aussi à votre disposition un groupe RedOhm sur Facebook ou vous trouverez un maximun de documentation technique .

Retour au sommaire

Présentation de la carte Pololu 3133

Information technique

Schéma de cablage

Code et tuto Arduino pour le pilotage d'une carte Pololu 3133 en I2c

Pour tout probléme

Code et tuto Arduino
pour le pilotage d'une carte Pololu 3133 en I2c