Code de recherche

Leçon 102 : Utilisation du ZK-5DA pour contrôler deux moteurs DC de 4A

Leçon 102 : Utilisation du ZK-5DA pour contrôler deux moteurs DC de 4A

Dans ce tutoriel, nous allons explorer comment utiliser le module de pilote de moteur ZK-5DA pour contrôler deux moteurs à courant continu de 4A. Ce module est basé sur la puce TA6586, qui offre un contrôle efficace des moteurs avec une faible chute de tension et une dissipation de chaleur. À la fin de ce tutoriel, vous serez en mesure de démarrer, d'arrêter et de contrôler la vitesse des moteurs de manière efficace. Pour des éclaircissements supplémentaires, n'oubliez pas de consulter la vidéo à (dans la vidéo à 08:55).

Matériel expliqué

Le composant principal de ce projet est le module de pilote de moteur ZK-5DA. Il utilise la puce TA6586, qui permet un contrôle efficace de deux moteurs CC. Cette puce est conçue pour gérer jusqu'à 4A de courant par moteur tout en maintenant une faible chute de tension, ce qui aide à réduire la génération de chaleur pendant le fonctionnement.

En plus du pilote de moteur, vous aurez besoin d'une carte Arduino pour envoyer des signaux de contrôle au module. L'Arduino définira la direction et la vitesse des moteurs en utilisant des signaux PWM (Modulation de Largeur d'Impulsions). Connecter les moteurs aux terminaux appropriés sur le module de pilote permet un contrôle directionnel et des ajustements de vitesse.

Détails de la fiche technique

FabricantRZ Semiconductor
Numéro de pièceTA6586
Tension de fonctionnement3-14 V
Courant de pointe9 A
Courant continu5 A
Courant de veille< 2 µA
Chute de tension400 mV à 4 A
Plage de température-25 à 85 °C
PaquetPaquet IC standard
Remarques / variantesArrêt thermique, protection contre les surintensités

  • Assurez une dissipation de chaleur adéquate pour un fonctionnement continu au-dessus de 3 A.
  • Utilisez des broches compatibles PWM pour le contrôle de la vitesse.
  • Vérifiez les valeurs de tension avant de connecter les moteurs.
  • Faites attention à la polarité du câblage pour éviter d'endommager le moteur.
  • Surveillez la température pendant le fonctionnement pour éviter la surchauffe.

Instructions de câblage

ZK-5AD_TA6586_wiring-_mor_tan_5V

Pour câbler le module de pilote de moteur ZK-5DA, commencez par connecter l'alimentation. Connectez le pôle positif de votre source d'alimentation au terminal '+' du pilote de moteur et le pôle négatif au terminal '-'. Les deux moteurs seront connectés aux bornes de sortie, qui sont étiquetées pour plus de clarté.

Pour les connexions Arduino, utilisez les broches habilitées PWM : connectez la broche3au broche de contrôle pour le moteur 1, et la broche5au deuxième broche de contrôle pour le moteur 1. De même, connectez la broche6au pin de contrôle pour le moteur 2, et le pin9au deuxième broche de contrôle pour le moteur 2. Enfin, assurez-vous que toutes les masses sont reliées entre elles.

Exemples de code et guide étape par étape

Le code commence par définir les broches pertinentes et initialiser le moniteur série pour le débogage. Les fonctions de contrôle du moteur, telles queM1etM2, gérer les directions et les vitesses du moteur.

const int D0=9; // Motor 1 PWM pin
const int D1=6; // Motor 1 direction pin
const int D2=5; // Motor 2 PWM pin
const int D3=3; // Motor 2 direction pin

Ici, les broches sont configurées pour contrôler les moteurs à l'aide de signaux PWM. Lesetupla fonction initialise ces broches en tant que sorties.

void loop() {
  M2(CW, 80); // Motor 2 runs clockwise at 80% speed
  delay(3000); // Wait for 3 seconds
  brake(2); // Apply brake to motor 2
  delay(1000); 
}

Cet extrait montre la boucle principale du programme, où le moteur 2 est réglé pour tourner dans le sens des aiguilles d'une montre à 80 % de sa vitesse pendant 3 secondes avant d'appliquer le frein.brakeLa fonction arrête le moteur lorsqu'elle est appelée.

void M1(bool direction, int speed) {
  int pwm = map(speed, 0, 100, 0, 255); // Map speed to PWM range
  if (direction == CW) {
    analogWrite(D0, pwm);
    analogWrite(D1, LOW);
  } else {
    analogWrite(D1, pwm);
    analogWrite(D0, LOW);
  }
}

LeM1La fonction prend la direction et la vitesse comme entrées, mappe la vitesse à une valeur PWM, et règle les broches appropriées pour contrôler la direction de rotation du moteur. LedebugPrintla fonction est appelée pour afficher l'état actuel dans le moniteur série.

Pour le code complet, n'oubliez pas de vérifier en dessous de l'article (dans la vidéo à 08:55).

Démonstration / À quoi s'attendre

Lorsque vous exécutez le code, attendez-vous à ce que les moteurs commencent à tourner dans les directions spécifiées à la vitesse définie. Le code inclut le freinage et des ajustements de vitesse, permettant un contrôle dynamique. Si les moteurs ne réagissent pas comme prévu, vérifiez vos connexions de câblage et assurez-vous que les broches correctes sont configurées dans le code. De plus, faites attention à la surchauffe, en particulier lorsque vous tirez de forts courants, comme indiqué lors du test (dans la vidéo à 23:23).

Horodatages vidéo

  • 00:00 Introduction
  • 03:16 Fiche technique vue
  • 06:34 Explication du câblage
  • 08:55 Code expliqué
  • 14:28 Démonstration : Contrôle Moteur
  • 17:22 Démonstration : Test de courant maximal
  • Test de chute de tension à 3A, 4A et 5A
  • 26:28 Remarques de conclusion

Images

TA6586_ZK5Ad_image
TA6586_ZK5Ad_image
ZK-5AD_TA6586_wiring-_mor_tan_5V
ZK-5AD_TA6586_wiring-_mor_tan_5V
power_adapter
power_adapter
408-Lesson 102: Using ZK-5DA to control two DC motors, each 4A
Langue: C++
/*
 * Lesson 102: Using ZK-5DA to control 2 DC motors, each 4A
 * 
 * Full video details: https://youtu.be/W_Wm28nQAYA
 * Video timing:
00:00 Introduction
03:16 Datasheet viewed
06:34 Wiring explained
08:55 Code explained
14:28 Demonstration: Motor control
17:22 Demonstration: Maximum current test
23:23 Voltage drop test at 3A, 4A, and 5A
26:28 Conclusion remarks

 * Written by Ahmad Shamshiri for Arduino Step by Step Course by Robojax
 * www.Robojax.com
 * on Mar 22, 2022 

 * 
 * This code is part of Arduino Step by Step Course which starts here:  https://youtu.be/-6qSrDUA5a8
 * 
 * For the library for this code, visit http://robojax.com/
 * 
If you found this tutorial helpful, please support me so I can continue creating 
content like this. Make a donation using PayPal or a credit card: https://bit.ly/donate-robojax 
 * This code is "AS IS" without warranty or liability. Free to be used as long as you keep this note intact.
 * This code has been downloaded from Robojax.com
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <https://www.gnu.org/licenses/>.
 */

 
 //all pins must be PWM enabled pins with ~ printed beside them
const int D0=9;//~
const int D1=6;
const int D2=5;
const int D3=3;

bool CW = true;
bool CCW = false;


bool debug = false;

void setup() {
  Serial.begin(9600);
  Serial.println("Robojax TA6586 Motor Control");
 pinMode(D0, OUTPUT);
 pinMode(D1, OUTPUT);
 pinMode(D2, OUTPUT);
 pinMode(D3, OUTPUT);  
 
 
}

void loop() {
  // * Full video details: https://youtu.be/W_Wm28nQAYA
  M2(CW, 80);//motor 1 runs CW at 80% speed
  M1(CW, 100); //motor 1 runs CW at 100% speed
  delay(3000);//wait for 3 seconds
  brake (2);//apply brake to motor 2
  delay(1000);  
  
  M2(CCW, 60);//motor 2 runs CCW at 60% speed
  delay(3000);//wait for 3 seconds
  brake (2);//apply brake to motor 2
  brake (1);//apply brake to motor 1
  delay(3000);//wait for 3 seconds
  for(int i=0; i<=100; i++)
  {
    M1(CCW, i);//run motor 1 to CCW direction with i% speed
    delay(100);
  }
  delay(2000);
  brake (2);//apply brake to motor 2
  delay(3000); delay(3000);//wait for 3 seconds}
}//loop ends

/*
 *  M1(bool direction,int speed)
 * @brief runs motor 1 
 * @param direction is CW or CCW, 
 * @param speed is an integer between 0 to 100

 * @return returns none
 * Written by Ahmad Shamshiri for robojax.com
 * on Mar 22, 2022 
 * Full video details: https://youtu.be/W_Wm28nQAYA
 */
void M1(bool direction,int speed)
{
  int pwm=map(speed, 0, 100, 0, 255);
  if(direction == CW)
  {
   analogWrite(D0,pwm);
   analogWrite(D1,LOW);   
  }else{
   analogWrite(D1,pwm);
   analogWrite(D0,LOW);     
  }
  debugPrint(1, direction, speed, false); 
}//M1 end


/*
 *  M2(bool direction,int speed)
 * @brief runs motor 2 
 * @param direction is CW or CCW, 
 * @param speed is an integer between 0 to 100

 * @return returns none
 * Written by Ahmad Shamshiri for robojax.com
 * on Mar 22, 2022 
 * Full video details: https://youtu.be/W_Wm28nQAYA
 */
void M2(bool direction,int speed)
{
  int pwm=map(speed, 0, 100, 0, 255);
  if(direction == CW)
  {
   analogWrite(D2,pwm);
   analogWrite(D3,LOW);   
  }else{
   analogWrite(D3,pwm);
   analogWrite(D2,LOW);     
  } 
  debugPrint(2, direction, speed, false);    
}//M2 ends


/*
 *  brake(int motor)
 * @brief applies brake to a motor
 * @param motor is an integer (1 or 2)

 * @return returns none
 * Written by Ahmad Shamshiri for robojax.com
 * on Mar 22, 2022 
 * Full video details: https://youtu.be/W_Wm28nQAYA
 */
void brake(int motor)
{
   if(motor == 1)
  {
   analogWrite(D0,HIGH);
   analogWrite(D1,HIGH);   
  }else{
   analogWrite(D2,HIGH);
   analogWrite(D3,HIGH);     
  }
  debugPrint(motor, true,  0, true);  
}//brake ends


/*
 * debugPrint(int motor, bool direction, int speed, bool stop)
 * @brief prints debugging information
 * @param motor is an integer (1 or 2)
 * @param direction is CW or CCW
 * @param speed is an integer from 0 to 100
 * @param stop is true or false; if true, the word "stop" is printed

 * @return returns none
 * Written by Ahmad Shamshiri for robojax.com
 * on Mar 22, 2022 
 * Full video details: https://youtu.be/W_Wm28nQAYA
 */
void debugPrint(int motor, bool direction, int speed, bool stop)
{
  if(debug)
  {
      Serial.print("Motor: ");
      Serial.print(motor);
    if(stop && motor>0)
    {
      Serial.println(" Stopped");
    }else{
      if(direction)
      {
      Serial.print(" CW at ");
      }else{
       Serial.print(" CCW at ");     
      }
      Serial.print(speed);       
      Serial.println(" %");    
    }
  }//debug
  
}

//not used but can be used to apply brake on both motors
void fullBrake()
{
 brake(1);
 brake(2); 

}

Ce dont vous pourriez avoir besoin

Ressources et références

Fichiers📁

Fiche technique (pdf)