Mise à jour le 13/02/2022 .
Pilotage d’un moteur pas à pas avec frein
Pilotage d’un moteur pas à pas avec frein
.
Mise à jour le 14/06/2021 : La librairie SD sur Arduino permet de créer un fichier sur une carte SD , de lire et d’écrire ce même fichier .
Comment stocker des valeurs de plusieurs Octets
Mise à jour le 28/09/2021 : Comment traiter le stockage d’informations en mémoire EEPROM sur arduino avec l’instruction EEPROM.put.
Sommaire :
.
But du tutoriel |
.
Dans le cadre du projet Oryon nous avons une partie programmation pour le système d’apprentissage du cobot. Le principe de l’apprentissage et d’enseigner au cobot les mouvements que l’on souhaite qu’il réalise en le manipulant simplement, et d’enregistrer des différents mouvements dans une mémoire afin qu’il nous les restitue quand on lui demande
Pour que l’on utilise le mode d’apprentissage il faut déjà ecrire un programme qui nous permettra que ce mode nous retranscrive automatiquement les déplacements de celui-ci. Voici un petit programme qui nous permet déjà d’avoir un petit aperçu de ce mode de stockage. La difficulté sur arduino étend de récupérer les valeurs du convertisseur 10 bits et de stocker la valeur des 2 octets en une seule fois dans la mémoire.
Le but de cet exemple est de montrer aussi l’instruction EEPROM.put() qui écrit des données sur EEPROM ou en utilisant également EEPROM.update() qui écrit des données uniquement si elles sont différentes du contenu précédent des emplacements à écrire. Le nombre d’octets écrits est lié au type de données ou à la structure personnalisée de la variable à écrire.
.
Retour au sommaire
Principe de capture et d’ecriture en EEPROM de plusieurs octets |
.
.
.
Retour au sommaire.
Video sur l’ecriture de la mémoire EEPROM |
.
.
Retour au sommaire.
Programme pour l’ecriture et la lecture en EEPROM de plusieurs octets |
.
//
//
//******************************************************
//
//But : Lecture d'une valeur de 10 bits et enregistrement
// de celle-ci en memoire EEPROM
//
// Par H-Mazelin
// RedOhm
// Le 26/05/2021
//******************************************************
#include <EEPROM.h>
// le potentiomètre, branché sur la broche analogique 6
int potentiometre1 = 6;
//int address = 0 ;
int valeur_eeprom ;
// *************************************************************
// Declaration des entrees et des sorties pour l'enregistrement
const int Led_enregistrement = 25 ;
// déclaration de l'entrée du bouton branché sur la broche 15
// de votre carte Arduino
int bouton15 = 15;
// variable du type int pour stocker les valeurs de passage du bouton15
int bouton15v;
// *************************************************************
// Declaration des entrees et des sorties la lecture
const int Led_lecture = 26;
// déclaration de l'entrée du bouton branché sur la broche 16
// de votre carte Arduino
int bouton16 = 16;
// variable du type int pour stocker les valeurs de passage du bouton16
int bouton16v;
void setup() {
//****************************************
//Mise en service du port de com
//****************************************
//ouvre le port série et fixe le debit de communication à 9600 bauds
Serial.begin(9600);
// on attent que le port de communication soit pret
while (!Serial) {
;
}
//****************************************
//Configuration des entrees pour les boutons de selection
//****************************************
pinMode (bouton15,INPUT );
pinMode (bouton16,INPUT );
//****************************************
//Configuration des sorties pour les Led
//****************************************
pinMode (Led_enregistrement,OUTPUT );
pinMode (Led_lecture,OUTPUT );
}
void loop() {
// ****************************************************
// creation de la commande enregistrement
// ****************************************************
bouton15v = digitalRead(bouton15);
if (bouton15v == 1)
{
digitalWrite (Led_enregistrement,HIGH);
// appel de la fonction -> lecture de la position du servomoteur
lecture_position();
}
else if (bouton15v == 0)
{
digitalWrite (Led_enregistrement,LOW);
}
// ****************************************************
// creation de la commande de lecture
// ****************************************************
bouton16v = digitalRead(bouton16);
if (bouton16v == 1)
{
digitalWrite (Led_lecture,HIGH);
// appel de la fonction -> lecture de la memoire
lecture_memoire_et_pilotage_servomoteur();
}
else if (bouton16v == 0)
{
digitalWrite (Led_lecture,LOW);
}
}
// Creation de la fonction lecture_position
//
//*******************************************************
// Lecture des positions du servomoteur et enregistrement
//*******************************************************
//
void lecture_position()
{
Serial.println(" Attention lecture de la position et ecriture de la memoire dans 5 secondes : ");
delay (5000);
Serial.print ("");
Serial.println("c'est parti");
for (int i=0 ; i <= 32 ; i=i+2)
{
// conversion de la tension de la borne 6 et transfert de la valeur
// numerique dans la variable valeur_eeprom
valeur_eeprom=analogRead(potentiometre1);
delay(20);
Serial.print("ecriture a l'adresse : ");Serial.print(i);
Serial.print(" de la valeur => ");Serial.println(valeur_eeprom);
// EEPROM.put permet d'ecrire n'importe quel type de données ou objet dans l'EEPROM.
// la valeur de i permet de pointer l'adresse pour stocker la valeur
EEPROM.put (i,valeur_eeprom);
delay(200);
}
bouton15v == 0;
Serial.println("Fin d'enregistrement");
delay(2000);
}
//********************************
// Lecture de la memoire EEPROM
//********************************
//
// Creation de la fonction lecture_memoire_et_pilotage_servomoteur
void lecture_memoire_et_pilotage_servomoteur()
{
Serial.println("");
Serial.println(" Attention lecture de la memoire EEPROM dans 5 secondes");
delay (5000);
for (int i=0 ; i <= 32 ; i=i+2)
{
// lire un octet à partir de l'adresse specifie dans la variable i
EEPROM. get ( i , valeur_eeprom ) ;
delay (100);
Serial.print(i);
Serial.print("\t");
Serial.print(valeur_eeprom);
Serial.println();
}
delay(500);
bouton16v == 0;
Serial.println("Fin de lecture ");
}
.
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 .
.
Retour au sommaire
.
Mise à jour le 23/04/2021 : Voici les plans de montage du robot R2-D2 pour l’anneau 1 et la base .
Mise à jour le 23/04/2021 : Voici les plans de montage du robot R2-D2 pour le panneau arrière qui nous donne accès au système électronique du robot. Les fichiers n’appartiennent pas à RedOhm pour cela ,il faut s’inscrire sur le lien ci-dessous.
https://www.patreon.com/mrbaddeley
Sommaire :
|
003 – Panneau inferieur |
.
Retour au sommaire.
.
.
.
.
.
.
.
.
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 .
.
.
Les fichiers STL n’appartiennent pas à RedOhm pour cela ,il faut s’inscrire sur le lien ci-dessous.
https://www.patreon.com/mrbaddeley
Mise à jour le 03/03/2021 :
Sommaire :
Principe de fonctionnement |
.
Le but de ce tutoriel est de piloter un moteur pas à pas avec un joystick.
Nous verrons comment définir la valeur des positions de notre joystick pour créer un mouvement de marche avant ou de marche arrière et de conserver le couple maintien quand notre manipulateur est dans un état statique.
Dans le programme vous pourrez retrouver :
La création d’un générateur d’impulsion qui nous permettra de définir la vitesse et le déplacement du moteur pas à pas
La gestion du couple maintien par l’intermédiaire d’un bouton
Et enfin le pilotage du moteur pas à pas en avant et en arrière avec le joystick par l’intermédiaire de la borne DIR se trouvant sur notre driver
.
Retour au sommaire
Programme pour le pilotage d’un moteur pas à pas avec Arduino
|
.
//
//
//***********************************************************
// RedOhm
// le 06/02/2021
//
// Pilotage d'un moteur pas a pas avec joystick
//
// but :
// 1 - creation d'un generateur d'impulsion pour le deplacement
// et la vitesse du moteur ( avec la fonction micros() )
// 2 - Creation de la fonction debrayage du moteur
// 4 - Pilotage avec un Joystik
//
// Ce programme est un logiciel libre: vous pouvez le redistribuer
// et / ou le modifier
// Ce programme est distribué dans l'espoir qu'il vous sera utile,
// mais sans aucune garantie de fonctionnement
//
// Par: Mazelin Herve
// IDE Arduino 1.8.13
//**********************************************************
// Declaration des variables demarrage
// unsigned long-> déclare une variable de type long non signé
// pour la base de temps il y a 1 000 microsecondes dans une milliseconde
// et
// 1 000 000 microsecondes dans une seconde.
unsigned long demarrage = micros();
// Declaration des variables
// int -> declare une variable du type int (pour integer, entier en anglais)
// elles peuvent stocker des valeurs de - 32 768 à 32 767
int base_de_temps1 = 1 ;
// Affectation des sorties de la carte Ardunio pour le pilotage
// du driver DRI0043
// une impulsion montante ou descendante sur cette entrée fait
// avancer le moteur d’un pas. La tension de l’impulsion doit
// être de 4,5 à 5 V pour un état HAUT et 0 à 0,5 V pour un état BAS.
// La largeur d’impulsion doit être de minimum 2,5 μs pour un
// fonctionnement correct.
int PUL=12;
// Definit le sens de rotation en fonction de l'etat bas ou haut
int DIR=10;
// ce signal est utilisé pour permettre ou interdire l’utilisation du
// driver. Le moteur est hors tension
int ENA=11;
// déclaration de l'entrée du bouton branché sur la broche 15
// pour le debrayage du moteur
int bouton_debrayage = 15;
int bouton_debrayage_v;
// Declaration de pin pour le voyant marche avant vert
int voyant_vert_mar = 20;
// Declaration de pin pour le voyant marche arriere rouge
int voyant_rouge_arr = 21;
// declaration de l'entree analogique 6 pour l'axe x
int JoyStick_X = 6; // axe x
// declaration de la vitesse du joystick
int vitesse=0 ;
/*
* 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()
{
// Configure la broche spécifiée pour qu'elle se comporte soit en entrée,
// soit en sortie.
// Configuration des broches pour le driver
pinMode (PUL, OUTPUT);
pinMode (DIR, OUTPUT);
pinMode (ENA, OUTPUT);
// Configuration des broches pour les boutons et les voyants
pinMode(bouton_debrayage,INPUT);
pinMode(voyant_vert_mar,OUTPUT);
pinMode(voyant_rouge_arr,OUTPUT);
}
// Le programme principal s’exécute par une boucle infinie appelée Loop ()
void loop()
{
// *******************************************
// Demande de debrayage du moteur
// *******************************************
// debrayage du moteur de son driver
bouton_debrayage_v = digitalRead(bouton_debrayage);
if ( bouton_debrayage_v == 1 )
{
digitalWrite(ENA,LOW);
}
// ******* Fin de demande debrayage **********
// *******************************************
// Traitement du JoyStick
// *******************************************
int x;
// Lecture de l'entree analogique
x=analogRead(JoyStick_X);
if ((x>501)&&(x<518)&&(bouton_debrayage_v==0))
{
digitalWrite(voyant_vert_mar,LOW);
digitalWrite(voyant_rouge_arr,LOW);
digitalWrite(ENA,HIGH);
digitalWrite(DIR,HIGH);
digitalWrite(PUL,HIGH);
}
// si x est superieur a 520 les instructions comprises
// entre les accolades sont exécutées.
else if (x>520)
{
// Marche arriere
digitalWrite(voyant_vert_mar,LOW);
digitalWrite(voyant_rouge_arr,HIGH);
digitalWrite(ENA,HIGH);
digitalWrite(DIR,HIGH);
vitesse = map ( x,520,1023,3500,5);
deplacement();
}
// sinon si x est inferieur a 500 les instructions comprises
// entre les accolades sont exécutées.
else if (x<500)
{
// Marche avant
digitalWrite(voyant_rouge_arr,LOW);
digitalWrite(voyant_vert_mar,HIGH);
digitalWrite(DIR,LOW);
digitalWrite(ENA,HIGH);
vitesse = map ( x,500,0,3500,5);
deplacement();
}
// ***** Fin du traitement du JoyStick *********
}
//==============================================
//Fonction de deplacement du moteur
//==============================================
void deplacement()
{
// la ligne if effectue la difference entre le temps actuel et le
// temps de debut de boucle .
if (micros()-demarrage>vitesse)
{
//Inversion de la valeur de la variable memoire et envoie l'information
//a la broche
digitalWrite(PUL,base_de_temps1=!base_de_temps1);
// on reinitialise la variable demarrage avec le contenu de micros()
demarrage=micros();
}
}
.
Retour au sommaire
Vidéo pour le tuto |
.
.
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 .
Sommaire
2020/09/02 Changement de l’identifiant |
.
Le but de ce tutoriel est de vous initier aux changements de l’identifiant sur les servomoteurs dynamixel par le biais de la carte Arbotix-M . Cette carte est compatible avec l’IDE Arduino.
.
Retour au sommaire
2020/09/18 harmonisation de la vitesse de communication
|
.
Le but de ce tutoriel est de vous familiariser avec les commandes de changement de vitesse et d’identifiant pour les servomoteurs Dynamixel. Le problème est le suivant, la connexion d’un servomoteur MX-106 et d’un servo AX-12 sur la même carte. En sachant que ces deux servomoteurs ne possèdent pas la même vitesse de communication par défaut, et possèdent le même identifiant par défaut. Il faut donc changer la vitesse de communication dans un des servomoteurs pour que les deux fonctionnent sur le même réseau, et enfin que chacun des servomoteurs possède un identifiant propre.
.
.
Retour au sommaire.
2020/11/02 Lecture du registre de déplacement et de
|
.
Dans le cadre de ce tutoriel nous allons vous initiez à lire les registres se trouvant à l’intérieur du servomoteur qui nous permet de définir le déplacement de notre servo , ceci afin de déterminer la butée basse et haute que l’on devra appliquer par logiciel pour des deplacements future ainsi que le déverouillage du registre de couple .
.
.
Retour au sommaire
.
2021/01/03 Pilotage de moteur Dynamixel par Joystick |
.
Ce tutoriel a pour but de vous initier à la programmation des servomoteurs Dynamixel . Nous avons pris comme base la tête de L3 -37 qui est une réalisation de RedOhm pour vous expliquer l’étalonnage et le fonctionnement pour piloter celle-ci avec un joystick. Le tuto s’articule en 4 phases : la première étant la présentation de la base de la tête, le câblage d’un joystick et la carte contrôleur, vous avez aussi une explication sur le fonctionnement de la manette de jeu, et enfin une explication détaillée du programme. Vous pourrez récupérer le programme sur notre site RedOhm.fr celui-ci est abondamment commenté.
.
.
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 .
.
Retour au sommaireMise à jour le 27/12/2020 : Ce support de webcam peut être considéré comme un outil pour les passionnés de CAO et de DAO. Mais il peut être très utile pour faire de la photo macro ou bien d’autre utilisation.
002 – Plan de montage |
.
.
Retour au sommaire
003 – Plan de montage B1 |
.
.
Retour au sommaire
004 – Montage de l’ensemble |
.
.
Retour au sommaire
005 – Piece 001 – accessoire webcam |
.
.
Retour au sommaire
006 – Piece 002 – Socle |
.
.
Retour au sommaire
007 – Piece 003 – tablette |
.
.
Retour au sommaire
008 – Piece 004 – bras porte tablette |
.
.
Retour au sommaire
009 – Pièce 005-Targette |
.
.
Retour au sommaire
010 – Pièce 006 verrou tablette |
.
.
Retour au sommaire
011 – WebCam |
.
.
Retour au sommaire
012 – Insert |
.
.
Retour au sommaire
013 – Mise en situation |
.
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 .
.
Retour au sommaireMise à jour le 02/01/2021 : Etude sur le fonctionnement et la programmation d’un servomoteur à retour d’information