TB6600, La création du train d’impulsion pour un moteur pas à pas avec Arduino.

Code n-1 : TB6600, La création du train d’impulsion pour un moteur pas à pas avec Arduino

Ce code est destiné à contrôler un moteur pas-à-pas à l’aide d’une carte Arduino. Il utilise les pins ENA, PULS et DIR pour contrôler la rotation du moteur.

La fonction setup() est exécutée une seule fois au démarrage de l’Arduino. Elle configure les pattes ENA, PULS et DIR en sortie.

La fonction loop() est exécutée en boucle sans fin après le démarrage de l’Arduino. Elle commence par récupérer le temps actuel en microsecondes. Cette fonction est basée sur le principe de génération d’impulsions qui permet de faire avancer le moteur d’un pas à chaque impulsion.

Si le temps écoulé depuis la dernière impulsion est supérieur ou égal à la valeur de la tempo stockée dans la variable TEMPO, la fonction inverse l’état de la broche PULS_PIN pour générer une impulsion et faire tourner le moteur pas-à-pas. La valeur de TEMPO contrôle la vitesse de rotation du moteur.

Ce code est un exemple de base pour contrôler un moteur pas-à-pas avec une carte Arduino. Il est possible de modifier le code pour ajouter des fonctionnalités supplémentaires, telles que le contrôle de la direction de rotation du moteur ou la gestion de la vitesse de rotation en fonction de l’entrée utilisateur.

Code n-2 : TB6600, personnaliser la fréquence de votre moteur pas-à-pas en temps réel

Le code présenté ici est un exemple de contrôle de la fréquence d’un moteur pas à pas à l’aide d’un driver TB6600 et d’une carte Arduino. Le principe est de générer des impulsions à une fréquence donnée pour faire tourner le moteur pas à pas.

Le code est organisé en trois parties principales : la déclaration des variables, le setup et son contenu, et enfin la fonction loop et son contenu. Nous allons les examiner chacune en détail.

Déclaration des variables

Le code commence par la déclaration des variables utilisées dans le programme. Les variables sont les suivantes :

ENA_PIN, PULS_PIN et DIR_PIN : ces variables contiennent les numéros des broches utilisées pour le contrôle du moteur.
TEMPO : cette variable contient la valeur de la tempo en microsecondes. Elle est initialisée à 250 µs.
tempsPrecedent : cette variable stocke le temps précédent en microsecondes, utilisé pour calculer le temps écoulé depuis la dernière impulsion.

Setup et son contenu

La fonction setup() est exécutée une seule fois au démarrage de l’Arduino. Elle initialise la communication série, configure les pattes en sortie pour le contrôle du Driver, valide le driver et définit la direction du moteur. Enfin, elle affiche un message pour demander à l’utilisateur de saisir une nouvelle valeur de tempo (train d’impulsions).

Fonction loop et son contenu

La fonction loop() est exécutée en boucle sans fin après le démarrage de l’Arduino. Elle récupère le temps actuel en microsecondes, lit les données disponibles sur la communication série et vérifie si une nouvelle valeur de tempo a été saisie. Si c’est le cas, elle met à jour la variable TEMPO avec cette nouvelle valeur.

Ensuite, la fonction loop() vérifie si la valeur du temps écoulé depuis la dernière impulsion est supérieure ou égale à la valeur de la tempo. Si tel est le cas, elle met à jour la variable tempsPrecedent avec le temps actuel et génère une impulsion en inversant l’état de la broche de pulsation.

Facebook Twitter Youtube

Grabcad Thingiverse Cults

Retour au sommaire

Arduino_les_fonctions_substring_et_length

Arduino – Les chaines de caracteres, les fonctions substring, lenght 2/10

Facebook Twitter Youtube

Grabcad Thingiverse Cults

Retour à la page

DFR0323 – Carte Bluno 2560

Mise à jour le 27/03/2022 : Module DFRobot Bluno constitué d’une carte 2560 compatible Arduino Mega et d’un module Bluetooth 4.0 (BLE) permettant le contrôle de ce module via votre smartphone par exemple (vérifier la compatibilité).

Continuer la lecture →

Led Neopixel leurs utilisations

Mise à jour le 09/03/2022 : leds adressables 8 mm Neopixel RGB basées sur le WS2811. Les leds peuvent se raccorder en série, ce qui permet de les commander de manière indépendante avec une seule sortie d’un microcontrôleur type Arduino ou compatible.

Continuer la lecture →

Convertisseur DFR0553 ADC 16 Bits

Mise à jour le 22/03/2022: Ce module Gravity basé sur un ADS1115 est un convertisseur analogique vers digital 16 bits contrôlé par le bus I2C. Il permet d’acquérir 4 signaux analogiques de capteurs ou modules vers un microcontrôleur.

Continuer la lecture →

Controle d’un moteur pas a pas comme un moteur asynchrone

Bonjour,
Cette page va bientôt être supprimée et remplacée par une nouvelle référence dédiée aux moteurs pas à pas. Vous trouverez désormais l’intégralité de la documentation technique (codes, schémas et tutoriels) à cette adresse :

[Lien]. https://www.redohm.fr/download/le-hub-ultime-des-tutos-sur-les-moteurs-pas-a-pas/

N’hésitez pas à consulter cette nouvelle page, qui s’inscrit dans un ensemble plus complet de ressources sur les moteurs pas à pas

Mise à jour le 18/02/2022 : Cet article a pour but de vous expliquer le fonctionnement d’un moteur pas-à-pas le plus simplement possible ,c’est à dire en utilisant un bouton qui va nous permettre de sélectionner la marche avant ou la marche arrière avec un potentiomètre nous permettant de définir la vitesse que l’on souhaite obtenir.

Continuer la lecture →

Augmenter le nombres de vos sorties PWM sur Arduino

Mise à jour le 19/11/2023 : Cet article traite d’une carte de commande qui vous permet d’augmenter le nombre de sorties pwm quand votre carte Arduino devient trop juste pour répondre à vos besoins.

Sommaire :

Information technique
Tutoriel sur la carte de chez Seeed
Exemple de schema
- Pilotage d’un servomoteur avec retour d’informations
- Pilotage de 2 servomoteurs avec des tensions d’alimentations différentes
- Pilotage de 2 servos avec une tension d’alimentation de 12V et utilisation de 2 régulateurs pour s’adapter à la tension de service des actionneurs
Exemple de programme.
Pour tout probléme
Retour au menu systeme Grove

Information technique

Carte de commande de chez Seeedstudio reference 108020102 possedant 16 canaux basée sur un PCA9685 permettant de contrôler jusqu’à 16 servomoteurs ou 16 leds via une liaison PWM. Ce module communique avec une carte Arduino ou compatible via le bus I2C.

Cette carte comporte jusqu’à 6 pontets à souder permettant de raccorder jusqu’à 64 PCA9685 sur un seul bus I2C. Une source d’alimentation externe est nécessaire pour les servomoteurs.

Caractéristiques:

Alimentation partie logique: 3,3 et 5 Vcc
Alimentation partie servomoteur: 2,3 à 5,5 Vcc
Commande: via le bus I2C
- Adresse I2C par défaut: 0x7f (configurable par pontet à souder)
- Compatible niveaux logiques 5 V
Sorties servos/leds: connecteur mâle au pas de 2,54 mm
Intensité maxi:
– 25 mA par led
– 400 mA au total pour tous les servos
Dimensions : 65x45x13mm

Retour au sommaire

Tuto

Retour au sommaire

Exemple de schema

Pilotage d’un servomoteur avec retour d’informations à l’aide de la carte SEEED référence 108020102

Augmentation des sorties pwm via la carte 108020102

Pilotage de 2 servomoteurs avec des tensions d’alimentations différentes à l’aide de la carte SEEED référence 108020102 .

Augmentation des sorties pwm via la carte 108020102 . Schema avec des tensions d’alimentations différentes

Schema de 2 servos avec une tension d’alimentation de 12V et utilisation de 2 régulateurs pour s’adapter à la tension de service des actionneurs à l’aide de la carte SEEED référence 108020102.

Augmentation des sorties pwm via la carte 108020102 . Pilotage de 2 servomoteurs avec une tension d’alimentation de 12V et utilisation de 2 régulateurs pour s’adapter à la tension de service des actionneurs

Retour au sommaire

Exemple de programme

//
//
// *********************************************
//
//
//
// Arduino avec
//         une commande 16 canaux pour servos
//      I2C - basé sur un PCA9685
//
// Code: Mazelin Herve
// RedOhm
// Le 11/12/2021
// *********************************************


// chargement de la librairie pour l'utilisation de carte 
#include "PCA9685.h"
// chargement de la librairie pour la communication I2C 
#include <Wire.h>

ServoDriver servo;

int a ;

// *********************************************************************
// Un programme Arduino doit impérativement contenir la fonction "setup"
// Elle ne sera exécutée une seule fois au démarrage du microcontroleur
// Elle sert à configurer globalement les entrées sorties
// *********************************************************************
void setup() {

  Serial.begin(9600);
  // on attent que le port de communication soit pret
  while (!Serial)
  { ;
  }

  Serial.println("communication en service");

  // join I2C bus (I2Cdev la bibliothèque ne le fait pas automatiquement)
  Wire.begin();

  servo.init(0x7f);
  // Décommentez cette ligne si vous devez utiliser un servo spécial
  // servo.setServoPulseRange(600,2400,180);


}


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

  // premier parametre le numero de servo
  // second parametre le deplacement en degrée
  servo.setAngle(16, 10);
  delay (500);
  servo.setAngle(13, 10);
  delay(1000);
  servo.setAngle(9, 0);
  delay(1000);
  servo.setAngle(8, 0);
  delay(1000);
  servo.setAngle(1, 0);
  delay(1000);

  // premier parametre le numero de servo
  // second parametre le deplacement en degrée
  servo.setAngle(13, 140);
  servo.setAngle(9, 250);
  servo.setAngle(8, 250);
  servo.setAngle(1, 250);
  delay(1000);
  servo.setAngle(16, 250);
  delay (500);
  
  for (int i = 0; i <= 4; i++)
  {
    a=a+20;
    servo.setAngle(13, 140-a);
    delay (250);
  }
  a=0;

}

// *********************************************

// Arduino avec

// une commande 16 canaux pour servos

// I2C - basé sur un PCA9685

// Code: Mazelin Herve

// RedOhm

// Le 11/12/2021

// *********************************************

// chargement de la librairie pour l'utilisation de carte

#include "PCA9685.h"

// chargement de la librairie pour la communication I2C

#include <Wire.h>

ServoDriver servo;

int a ;

// *********************************************************************

// Un programme Arduino doit impérativement contenir la fonction "setup"

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

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

// *********************************************************************

void setup() {

Serial.begin(9600);

// on attent que le port de communication soit pret

while (!Serial)

{ ;

}

Serial.println("communication en service");

// join I2C bus (I2Cdev la bibliothèque ne le fait pas automatiquement)

Wire.begin();

servo.init(0x7f);

// Décommentez cette ligne si vous devez utiliser un servo spécial

// servo.setServoPulseRange(600,2400,180);

}

// **********************************************************************

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

// **********************************************************************

void loop() {

// premier parametre le numero de servo

// second parametre le deplacement en degrée

servo.setAngle(16, 10);

delay (500);

servo.setAngle(13, 10);

delay(1000);

servo.setAngle(9, 0);

delay(1000);

servo.setAngle(8, 0);

delay(1000);

servo.setAngle(1, 0);

delay(1000);

// premier parametre le numero de servo

// second parametre le deplacement en degrée

servo.setAngle(13, 140);

servo.setAngle(9, 250);

servo.setAngle(8, 250);

servo.setAngle(1, 250);

delay(1000);

servo.setAngle(16, 250);

delay (500);

for (int i = 0; i <= 4; i++)

{

a=a+20;

servo.setAngle(13, 140-a);

delay (250);

}

a=0;

}

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 celles qui vous intéressent .

Facebook Twitter Youtube

Grabcad Thingiverse Cults

Retour à la page principal

Arduino & Sen0305 , le changement d’algorithmes

Dans ce code Arduino vous trouverez toutes les explications relatives à l’utilisation du changement de mode de fonctionnement de la caméra SEN0305 pour la reconnaissance faciale et la reconnaissnce d’objet .

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

Retour au changement d’algorithmes

Ecran Nextion : Fonctionnement d’un bouton poussoir fichier HMI

Description du tutoriel pour la tablette Nextion

L’objectif de ce programme très simple, est d’allumer ou éteindre une LED chaque fois qu’un bouton est pressé sur la tablette Nextion. Ici, nous utilisons la bibliothèque officielle, créée par ITEAD, qui permet de déclarer précisément le composant « bouton ». Comme il s’agit d’un composant de type « Button », il est possible de déclarer une fonction de type callback* sur l’événement « pression sur le bouton ». * Cette fonction est ainsi appelée automatiquement par la librairie officielle, lors de l’exécution de sa propre fonction nexLoop (qui doit donc impérativement être appelée dans la fonction loop de Arduino).

Continuer la lecture →

Mini Spider S12 patte courte Version 02022017 : Spider 001

***

Nom du programme Spider 001

/*
 * 
 * 
 * RedOhm
 * 
 * Initialisation de mini spider
 * 
 * but : les pattes en bas et droite
 * enfin un petit bonjour pour nous confirmer
 * que le robot est en attente
 * 
 * 
 * Le 28/01/2017
 * H-Mazelin
 */

 



// Cette librairie permet à une carte Arduino de contrôler des servomoteurs
#include <Servo.h>


//Crée un objet de type "Servo", nommé -> servo_d1
  Servo servo_d1; 
//Crée un objet de type "Servo", nommé -> servo_d2
  Servo servo_d2;
//Crée un objet de type "Servo", nommé -> servo_d3
  Servo servo_d3;  
//Crée un objet de type "Servo", nommé -> servo_d4
  Servo servo_d4;
//Crée un objet de type "Servo", nommé -> servo_d5
  Servo servo_d5;
//Crée un objet de type "Servo", nommé -> servo_d6
  Servo servo_d6;
//Crée un objet de type "Servo", nommé -> servo_d7
   Servo servo_d7;
//Crée un objet de type "Servo", nommé -> servo_d8
   Servo servo_d8;      
//Crée un objet de type "Servo", nommé -> servo_d9
   Servo servo_d9;
//Crée un objet de type "Servo", nommé -> servo_d10
   Servo servo_d10;   
//Crée un objet de type "Servo", nommé -> servo_d11
   Servo servo_d11;
//Crée un objet de type "Servo", nommé -> servo_d12
   Servo servo_d12;

// variable du type int pour les deplacement des servomoteurs
// a droite 
 int initd=5;
// variable du type int pour les deplacement des servomoteurs
// a gauche 
  int initg=5;
// variable du type int pour les boucle for   
   int x;



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

// associe le servomoteur a la broche 2  
  servo_d1.attach(2,700,2000);
// associe le servomoteur a la broche 3  
  servo_d2.attach(3,700,2000);
// associe le servomoteur a la broche 4  
  servo_d3.attach(4,700,2000);
// associe le servomoteur a la broche 5  
  servo_d4.attach(5,700,2000);  
// associe le servomoteur a la broche 6  
  servo_d5.attach(6,700,2000);  
// associe le servomoteur a la broche 7  
  servo_d6.attach(7,700,2000);  
    
//associe le servomoteur a la broche 8  
  servo_d7.attach(8,700,2000);
//associe le servomoteur a la broche 9  
  servo_d8.attach(9,700,2000);
//associe le servomoteur a la broche 10  
  servo_d9.attach(10,700,2000);
//associe le servomoteur a la broche 11  
  servo_d10.attach(11,700,2000);  
//associe le servomoteur a la broche 12 
  servo_d11.attach(12,700,2000);  
//associe le servomoteur a la broche 13 
  servo_d12.attach(13,700,2000);   

// Appel de la fonction -> initialisation 
initialisation(); 
// pause pour le positionnement des servomoteurs 
delay(500);


// lancement d'un petit bonjour  
   servo_d1.write (175);
    for (x=0;x<2;x++){
     servo_d2.write (30);
      delay(500);
     servo_d2.write (150); 
      delay(500); 
 }
   
   servo_d2.write (90);
   delay(200);
   servo_d1.write (5);
   delay(500);
   servo_d1.write (175);
    for (x=0;x<2;x++){
     servo_d2.write (30);
      delay(500);
     servo_d2.write (150); 
      delay(500);    
 
    } 
    servo_d2.write (90);
    servo_d1.write (5);
}

// fin du bonjour 



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

  


  
}


// Initialisation spider

void initialisation()
 {
  
  // position des pattes en bas 
  initd=5;
  initg=175;
    
  servo_d1.write (initd);
   servo_d9.write (initd);
    servo_d11.write (initd); 
 
  servo_d5.write (initg);
    servo_d3.write (initg);  
      servo_d7.write (initg);
  
  
  // position des pattes au centre 
  servo_d2.write (90);
     servo_d4.write (90);
       servo_d6.write (90);
        servo_d8.write (90);   
         servo_d10.write (90);    
          servo_d12.write (90);    
  

 }

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

146

147

148

149

150

151

152

153

154

155

156

157

158

159

160

161

162

163

164

165

* RedOhm

* Initialisation de mini spider

* but : les pattes en bas et droite

* enfin un petit bonjour pour nous confirmer

* que le robot est en attente

* Le 28/01/2017

* H-Mazelin

// Cette librairie permet à une carte Arduino de contrôler des servomoteurs

#include <Servo.h>

//Crée un objet de type "Servo", nommé -> servo_d1

Servo servo_d1;

//Crée un objet de type "Servo", nommé -> servo_d2

Servo servo_d2;

//Crée un objet de type "Servo", nommé -> servo_d3

Servo servo_d3;

//Crée un objet de type "Servo", nommé -> servo_d4

Servo servo_d4;

//Crée un objet de type "Servo", nommé -> servo_d5

Servo servo_d5;

//Crée un objet de type "Servo", nommé -> servo_d6

Servo servo_d6;

//Crée un objet de type "Servo", nommé -> servo_d7

Servo servo_d7;

//Crée un objet de type "Servo", nommé -> servo_d8

Servo servo_d8;

//Crée un objet de type "Servo", nommé -> servo_d9

Servo servo_d9;

//Crée un objet de type "Servo", nommé -> servo_d10

Servo servo_d10;

//Crée un objet de type "Servo", nommé -> servo_d11

Servo servo_d11;

//Crée un objet de type "Servo", nommé -> servo_d12

Servo servo_d12;

// variable du type int pour les deplacement des servomoteurs

// a droite

int initd=5;

// variable du type int pour les deplacement des servomoteurs

// a gauche

int initg=5;

// variable du type int pour les boucle for

int x;

// Un programme Arduino doit impérativement contenir la fonction "setup"

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

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

void setup() {

// associe le servomoteur a la broche 2

servo_d1.attach(2,700,2000);

// associe le servomoteur a la broche 3

servo_d2.attach(3,700,2000);

// associe le servomoteur a la broche 4

servo_d3.attach(4,700,2000);

// associe le servomoteur a la broche 5

servo_d4.attach(5,700,2000);

// associe le servomoteur a la broche 6

servo_d5.attach(6,700,2000);

// associe le servomoteur a la broche 7

servo_d6.attach(7,700,2000);

//associe le servomoteur a la broche 8

servo_d7.attach(8,700,2000);

//associe le servomoteur a la broche 9

servo_d8.attach(9,700,2000);

//associe le servomoteur a la broche 10

servo_d9.attach(10,700,2000);

//associe le servomoteur a la broche 11

servo_d10.attach(11,700,2000);

//associe le servomoteur a la broche 12

servo_d11.attach(12,700,2000);

//associe le servomoteur a la broche 13

servo_d12.attach(13,700,2000);

// Appel de la fonction -> initialisation

initialisation();

// pause pour le positionnement des servomoteurs

delay(500);

// lancement d'un petit bonjour

servo_d1.write (175);

for (x=0;x<2;x++){

servo_d2.write (30);

delay(500);

servo_d2.write (150);

delay(500);

}

servo_d2.write (90);

delay(200);

servo_d1.write (5);

delay(500);

servo_d1.write (175);

for (x=0;x<2;x++){

servo_d2.write (30);

delay(500);

servo_d2.write (150);

delay(500);

}

servo_d2.write (90);

servo_d1.write (5);

}

// fin du bonjour

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

void loop() {

}

// Initialisation spider

void initialisation()

{

// position des pattes en bas

initd=5;

initg=175;

servo_d1.write (initd);

servo_d9.write (initd);

servo_d11.write (initd);

servo_d5.write (initg);

servo_d3.write (initg);

servo_d7.write (initg);

// position des pattes au centre

servo_d2.write (90);

servo_d4.write (90);

servo_d6.write (90);

servo_d8.write (90);

servo_d10.write (90);

servo_d12.write (90);

}