Archives de l’auteur : Hervé Mazelin

Robotis

Support WebCam V-3L

Mise à 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.

Sommaire : En cours de realisation

001 : Présentation
002 : Plan de montage
003 : Plan de montage B1
004 : Montage de l’ensemble
005 : Piece 001 – accessoire webcam
006 : Piece 002 – Socle
007 : Piece 003 – tablette
008 : Piece 004 – bras porte tablette
009 : Pièce 005-Targette
010 : Pièce 006 verrou tablette
011 : WebCam
012 : Documentation sur les inserts
013 : Mise en situation
Pour tout probléme
Retour au menu

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

Fiche 007 – Piece 003 – tablette – RedOhm

Retour au sommaire

008 – Piece 004 – bras porte tablette

Fiche 008 – Piece 004 – bras porte tablette – RedOhm

Retour au sommaire

009 – Pièce 005-Targette

Fiche 009 – Pièce 005-Targette RedOhm

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 .

Facebook Twitter Youtube

Grabcad Thingiverse Cults

Retour au sommaire

Servomoteur à rétroaction analogique

Mise à jour le 02/01/2021 : Etude sur le fonctionnement et la programmation d’un servomoteur à retour d’information

Continuer la lecture →

L3-37 version RC , Fiche de montage

Mise à jour le 11/12/2020 : Dans cet article vous retrouverez les fichiers à télécharger pour construire la tête et le buste du robot L3 -37 pour la version RC, mais aussi l’ensemble des fiches de montage pour y parvenir.

Continuer la lecture →

L3-37 : Tutoriel pour la version Dynamixel

Sommaire :

Matériel utile pour suivre les tutoriels
Modification de l’identifiant du servo
Etude des deplacements de la tête avec les servo Dynamixel
Pilotage d’un Dynamixel par le biais d’un potentiometre
Retour au menu

Matériel utile pour suivre les tutoriels

ArbotiX-M Robocontroller

Spécifications techniques du Robocontroller ArbotiX-M :

Microcontrôleur AVR 16 MHz (ATMEGA644p).
2 ports série, 1 dédié aux servo-contrôleurs Dynamixel, l’autre au module radio Xbee.
32 E / S, dont 8 peuvent fonctionner comme entrées analogiques.
Embases servo 3 broches (Gnd, Vcc, signal), sur les 8 entrées analogiques et sur les 8 E / S numériques.
Deux pilotes de moteur 1 A avec en-têtes moteur / encodeur combinés.
Module radio Xbee vendu séparément. Une installation typique nécessite 2 modules radio Xbee et un module explorateur Xbee pour vous permettre de contrôler votre robot à distance depuis votre ordinateur.
Ce contrôleur nécessite l’utilisation d’un câble FTDI ou ISP. Nous recommandons la carte de déploiement FTDI 3,3 V avec connecteur à 6 broches.
Avec des dimensions de 7,11 × 7,11 cm (2,8 « × 2,8 »), ce contrôleur a été conçu pour être utilisé avec les servomoteurs Dynamixel .

Ressources pour le Robocontroller ArbotiX-M

Le Robocontroller ArbotiX-M peut être utilisé avec l’environnement de développement Arduino. Un certain nombre de bibliothèques permettant de contrôler les servomoteurs AX-12 sont disponibles dans la liste de téléchargement ci-dessous.

Module joystick Gravity DFR0061

Module joystick Gravity DFRobot basé sur 2 potentiomètres (axes X et Y) et d’un bouton-poussoir pour des applications spécifiques. Il délivre deux sorties analogiques en fonction de la position des deux potentiomètres et une sortie logique en fonction du bouton-poussoir. Il est livré avec 3 cordons.

Alimentation : 5 Vcc
Sorties : 2 analogiques et 1 digitale
Dimensions : 37 x 32 x 25 mm

Référence DFRobot: DFR0061

Remarque: la nouvelle version du mappage des broches du port du capteur analogique a été modifiée comme ci-dessous :

Mappage du Joystik

Retour en haut de page

Etude des deplacements de la tête avec les servo Dynamixel

Materiel utile pour le tuto :

Un module ArbotiX-M Robocontroller

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 les mouvements de la tête.

Pour pouvoir lire ses registres, il faut déverrouiller le couple afin pouvoir déplacer la base de la tête de L3 -37 manuellement Avant de se lancer dans l’explication du programme, nous allons vous faire une démonstration du déverrouillage et de la lecture des registres de déplacement par le biai du tuto ci-dessous .

Programme :

//
//
//*************************************************************
//* 
//* IDE Arduino 1.0.6
//*
//* Mesure de deplacement des moteurs dynamixel
//*  et verouillage du couple 
//*       
//* H-Mazelin
//* 29/10/2020
//*
//*************************************************************



//librairie qui permet d'implémentez le code de communication série
//de bas niveau pour communiquer avec le bus Bioloid.  
#include <ax12.h>

//Cette librairies vous permet interagir avec les servos AX et MX  
#include <BioloidController.h>


// definition de la vitesse de transmission 
// le debit en bauds détermine la vitesse de communication serie entre 
// le controleur et le servo Dynamixel
BioloidController bioloid = BioloidController(1000000);


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

{

 //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
  delay(5000);
  // Information a l'operateur de l'ouverture du port de communication 
  // sur le moniteur serie 
  Serial.println("========================================");
  Serial.println("Communication etablie");
  Serial.println("========================================");   

  // Lecture de la temperature du servo de droite actuel
  int temperature_d =ax12GetRegister(2,43,1);
  // Lecture de la temperature du servo de gauche actuel
  int temperature_g =ax12GetRegister(3,43,1);
  
  
  // Affichage de la lecture des registres contenant la temperature 
  Serial.print("Temperature du servo de droite : ");
   Serial.print(temperature_d);Serial.println(" Degres");    
  Serial.print("Temperature du servo de gauche : ");
   Serial.print(temperature_g);Serial.println(" Degres"); 
  Serial.print(" "); 
   Serial.println("Demarrage *********************");
  
// Procedure d'ecriture dans le registre 24 pour desactiver le couple 
//
// modification de la valeur 1 par la valeur 0
// 1 parametre : numero d'identifiant du servo
// 2 parametre : numero de registre a modifier 
// 3 parametre : Active ou desactive le couple 

 ax12SetRegister(2,24,0); 
  ax12SetRegister(3,24,0);
 Serial.println("Couple desactive sur le moteur de droite et de gauche");  
 
  
}

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

{ 

// Procedure de lecture pour la position du servo dans le registre 36
//
//
// 1 parametre : numero d'identifiant du servo
// 2 parametre : numero de registre a lire 
// 3 parametre : nombre d'octet a lire 

 int deplacement_d =ax12GetRegister(2,36,2);
  int deplacement_g =ax12GetRegister(3,36,2);
  
// Affichage de la lecture des registres contenant le deplacement 
 Serial.print("Deplacement du moteur de gauche : ");
  Serial.print(deplacement_g);Serial.print(" en points      "); 
   Serial.print("Deplacement du moteur de droite : ");
    Serial.print(deplacement_d);Serial.println(" en points      ");  
}

100

101

102

103

104

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

//*

//* IDE Arduino 1.0.6

//*

//* Mesure de deplacement des moteurs dynamixel

//* et verouillage du couple

//*

//* H-Mazelin

//* 29/10/2020

//*

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

//librairie qui permet d'implémentez le code de communication série

//de bas niveau pour communiquer avec le bus Bioloid.

#include <ax12.h>

//Cette librairies vous permet interagir avec les servos AX et MX

#include <BioloidController.h>

// definition de la vitesse de transmission

// le debit en bauds détermine la vitesse de communication serie entre

// le controleur et le servo Dynamixel

BioloidController bioloid = BioloidController(1000000);

* Un programme Arduino doit impérativement contenir cette fonction

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

* Elle sert à configurer globalement les entrées sorties

void setup ()

{

//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

delay(5000);

// Information a l'operateur de l'ouverture du port de communication

// sur le moniteur serie

Serial.println("========================================");

Serial.println("Communication etablie");

Serial.println("========================================");

// Lecture de la temperature du servo de droite actuel

int temperature_d =ax12GetRegister(2,43,1);

// Lecture de la temperature du servo de gauche actuel

int temperature_g =ax12GetRegister(3,43,1);

// Affichage de la lecture des registres contenant la temperature

Serial.print("Temperature du servo de droite : ");

Serial.print(temperature_d);Serial.println(" Degres");

Serial.print("Temperature du servo de gauche : ");

Serial.print(temperature_g);Serial.println(" Degres");

Serial.print(" ");

Serial.println("Demarrage *********************");

// Procedure d'ecriture dans le registre 24 pour desactiver le couple

// modification de la valeur 1 par la valeur 0

// 1 parametre : numero d'identifiant du servo

// 2 parametre : numero de registre a modifier

// 3 parametre : Active ou desactive le couple

ax12SetRegister(2,24,0);

ax12SetRegister(3,24,0);

Serial.println("Couple desactive sur le moteur de droite et de gauche");

}

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

void loop()

{

// Procedure de lecture pour la position du servo dans le registre 36

// 1 parametre : numero d'identifiant du servo

// 2 parametre : numero de registre a lire

// 3 parametre : nombre d'octet a lire

int deplacement_d =ax12GetRegister(2,36,2);

int deplacement_g =ax12GetRegister(3,36,2);

// Affichage de la lecture des registres contenant le deplacement

Serial.print("Deplacement du moteur de gauche : ");

Serial.print(deplacement_g);Serial.print(" en points ");

Serial.print("Deplacement du moteur de droite : ");

Serial.print(deplacement_d);Serial.println(" en points ");

}

Retour en haut de page

Pilotage d’un Dynamixel par le biais d’un potentiometre

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.

Materiel utile pour le tuto :

Un module ArbotiX-M Robocontroller
Module joystick Gravity DFR0061

//
//
//*************************************************************
//* 
//* IDE Arduino 1.0.6
//*
//* Exemple de pilotage d'un servo Dynamixel
//*  avec un joystick pour la tete de L3-37
//*       
//* H-Mazelin
//* 16/11/2020
//*
//*************************************************************



//librairie qui permet d'implémenter le code de communication série
//de bas niveau pour communiquer avec le bus Bioloid.  
#include <ax12.h>

//Cette librairie vous permet interagir avec les servos AX et MX  
#include <BioloidController.h>

// definition de la vitesse de transmission 
// le debit en bauds détermine la vitesse de communication serie entre 
// le controleur et le servo Dynamixel
BioloidController bioloid = BioloidController(1000000);

// broche sur lequel est branche le potentiometre
const int broche1 = A1;
const int broche7 = A7;

// variable contenant la valeur du potentiometre 
int valeurPotar1 = 0;
 int valeurPotar7 = 0;   
// valeur du potentiometre remis a l'echelle
int valeurPotar7_re = 0;
 int valeurPotar1_re= 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 ()

{

//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
  delay(5000);
// Information a l'operateur de l'ouverture du port de communication 
// sur le moniteur serie 
  Serial.println("========================================");
  Serial.println("Communication etablie");
  Serial.println("========================================");   

// Lecture de la temperature du servo de droite actuel
  int temperature_d =ax12GetRegister(2,43,1);
// Lecture de la temperature du servo de gauche actuel
  int temperature_g =ax12GetRegister(3,43,1);
  
  
// Affichage de la lecture des registres contenant la temperature 
Serial.print("Temperature du servo de droite : ");
 Serial.print(temperature_d);Serial.println(" Degres");    
  Serial.print("Temperature du servo de gauche : ");
   Serial.print(temperature_g);Serial.println(" Degres"); 
  Serial.print(" "); 
   Serial.println("Demarrage *********************"); 
}

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

{ 
// lecture de la valeur du potentiomètre (valeur entre 0 et 1023)  
  valeurPotar1=analogRead( broche1);
   valeurPotar7=analogRead( broche7);
// mise a l'échelle (valeur entre 0 et 300
// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.
// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination   
  valeurPotar7_re = map( valeurPotar7,0,1023,0,350);
   valeurPotar1_re = map( valeurPotar1,0,1023,0,350);


// Affichage de la valeur des potentiometre  
Serial.print("A7 - deplacement en x du potentiometre x -> ");
 Serial.println(valeurPotar7);
  Serial.print("A1 - deplacement en y du potentiometre x -> ");
   Serial.println(valeurPotar1);
// Affichage de la valeur re-etalonne des potentiometre  
Serial.print("A7 - Re-etalonne le deplacement en x du potentiometre -> ");
 Serial.println(valeurPotar7_re);
  Serial.print("A7 - Re-etalonne le deplacement en y du potentiometre -> ");
   Serial.println(valeurPotar1_re);
      


// envoie l'information de deplacement au servomoteur dynamixel340
   SetPosition(2,340+valeurPotar7_re);
// envoie l'information de deplacement au servomoteur dynamixel
// moteur de gauche   
   SetPosition(3,340+valeurPotar1_re); 


// Affichage du code pour le moteur x avec le calcul
Serial.print("Valeur de la position du moteur x => SetPosition(3,340+");
 Serial.print(valeurPotar7_re);
  Serial.println(");");
   Serial.print("Valeur du deplacement de moteur x => ");
    Serial.println(340 + valeurPotar7_re) ;
   
Serial.println("");
 Serial.print("Valeur de la position du moteur y => SetPosition(3,340+");
  Serial.print(valeurPotar1_re);
   Serial.println(");");
    Serial.print("Valeur du deplacement de moteur y => ");
     Serial.println(340 + valeurPotar1_re) ;  
  
   Serial.println("------------------");
   delay (100);
}

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

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

//*

//* IDE Arduino 1.0.6

//*

//* Exemple de pilotage d'un servo Dynamixel

//* avec un joystick pour la tete de L3-37

//*

//* H-Mazelin

//* 16/11/2020

//*

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

//librairie qui permet d'implémenter le code de communication série

//de bas niveau pour communiquer avec le bus Bioloid.

#include <ax12.h>

//Cette librairie vous permet interagir avec les servos AX et MX

#include <BioloidController.h>

// definition de la vitesse de transmission

// le debit en bauds détermine la vitesse de communication serie entre

// le controleur et le servo Dynamixel

BioloidController bioloid = BioloidController(1000000);

// broche sur lequel est branche le potentiometre

const int broche1 = A1;

const int broche7 = A7;

// variable contenant la valeur du potentiometre

int valeurPotar1 = 0;

int valeurPotar7 = 0;

// valeur du potentiometre remis a l'echelle

int valeurPotar7_re = 0;

int valeurPotar1_re= 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 ()

{

//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

delay(5000);

// Information a l'operateur de l'ouverture du port de communication

// sur le moniteur serie

Serial.println("========================================");

Serial.println("Communication etablie");

Serial.println("========================================");

// Lecture de la temperature du servo de droite actuel

int temperature_d =ax12GetRegister(2,43,1);

// Lecture de la temperature du servo de gauche actuel

int temperature_g =ax12GetRegister(3,43,1);

// Affichage de la lecture des registres contenant la temperature

Serial.print("Temperature du servo de droite : ");

Serial.print(temperature_d);Serial.println(" Degres");

Serial.print("Temperature du servo de gauche : ");

Serial.print(temperature_g);Serial.println(" Degres");

Serial.print(" ");

Serial.println("Demarrage *********************");

}

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

void loop()

{

// lecture de la valeur du potentiomètre (valeur entre 0 et 1023)

valeurPotar1=analogRead( broche1);

valeurPotar7=analogRead( broche7);

// mise a l'échelle (valeur entre 0 et 300

// Ré-étalonne un nombre d'une fourchette de valeur vers une autre fourchette.

// Ainsi, une valeur basse source sera étalonnée en une valeur basse de destination

valeurPotar7_re = map( valeurPotar7,0,1023,0,350);

valeurPotar1_re = map( valeurPotar1,0,1023,0,350);

// Affichage de la valeur des potentiometre

Serial.print("A7 - deplacement en x du potentiometre x -> ");

Serial.println(valeurPotar7);

Serial.print("A1 - deplacement en y du potentiometre x -> ");

Serial.println(valeurPotar1);

// Affichage de la valeur re-etalonne des potentiometre

Serial.print("A7 - Re-etalonne le deplacement en x du potentiometre -> ");

Serial.println(valeurPotar7_re);

Serial.print("A7 - Re-etalonne le deplacement en y du potentiometre -> ");

Serial.println(valeurPotar1_re);

// envoie l'information de deplacement au servomoteur dynamixel340

SetPosition(2,340+valeurPotar7_re);

// envoie l'information de deplacement au servomoteur dynamixel

// moteur de gauche

SetPosition(3,340+valeurPotar1_re);

// Affichage du code pour le moteur x avec le calcul

Serial.print("Valeur de la position du moteur x => SetPosition(3,340+");

Serial.print(valeurPotar7_re);

Serial.println(");");

Serial.print("Valeur du deplacement de moteur x => ");

Serial.println(340 + valeurPotar7_re) ;

Serial.println("");

Serial.print("Valeur de la position du moteur y => SetPosition(3,340+");

Serial.print(valeurPotar1_re);

Serial.println(");");

Serial.print("Valeur du deplacement de moteur y => ");

Serial.println(340 + valeurPotar1_re) ;

Serial.println("------------------");

delay (100);

}

Retour en haut de page

Robot Golbotth8 fiche de montage

Mise à jour le 18/11/2020 :

Sommaire :

001 – Présentation
002 – Vue de face et arriere
003 – Vue de coté
004 – Eclaté vue de dessus
005 – Vue eclatée avec repérage des pieces
006 – Vue eclatée de coté avec repérage des pieces
007 – 008 – Tourelle
009 – 010 – Base tourelle
011 – 012 – Pièce g012 plateau pour châssis
013 – capot tourelle
014 – Pièce g018 calandre arrière
015 – Pièce g019 calandre avant
018 – Led 8 mm RGB Grove V2.0 104020048
019 – 19A – Télémètre à ultrasons Grove 101020010
Retour a la page principale

Ce petit robot est destiné à vous initier à la programmation, nous l’appellerons Golbotth8. La construction de cet engin passe déjà par l’impression 3D, vous trouverez l’ensemble des fichiers STL sur notre site ainsi que la matière que nous avons utilisée et les différents conseils techniques. Vous aurez la possibilité de suivre des tutoriels sur Arduino avec ce module. Nous avons surtout essayé de minimiser le coût de l’ensemble.

Retour au sommaire

002-Vue de face et arriere

Retour au sommaire

Retour au sommaire.

Retour au sommaire

Pièce g010 tourelle – RedOhm

Filament : Pla
Constructeur du filament : https://www.arianeplast.com/
Poids : 335 g
Couleur : bi-ton gris et rouge
Temps d’impression : 21h00
Layer :0.19mm
Température : 205°

Retour au sommaire

009 – 010 – Base tourelle

Retour au sommaire

011 – 012 – Pièce g012 plateau pour châssis

Pièce g012 plateau pour châssis – RedOhm

Retour au sommaire

013 – Pièce g013 capot tourelle

Retour au sommaire

014 – Pièce g018 calandre arrière

Filament : Pla
Poids : 111g
Couleur : gris
Temps d’impression : 7h47
Layer : 0.19mm
Qualité : haute
Densité : 40%
Température : 205°

Retour au sommaire

015 –

Retour au sommaire

016 –

Retour au sommaire

017 –

Retour au sommaire

018 – Led 8 mm RGB Grove V2.0 104020048

Retour au sommaire

019 – Télémètre à ultrasons Grove 101020010

Télémètre à ultrasons Grove 101020010

Ce module dispose d’un émetteur à ultrasons et d’un récepteur à ultrasons afin que vous puissiez le considérer comme un émetteur-récepteur à ultrasons. Familier avec le sonar, lorsque l’onde ultrasonore de 40 KHz générée par l’émetteur rencontre l’objet, l’onde sonore sera renvoyée et le récepteur peut recevoir l’onde ultrasonore réfléchie. Il suffit de calculer le temps entre l’émission et la réception, puis de multiplier la vitesse du son dans l’air (340 m / s) pour calculer la distance du capteur à l’objet.

Comment fonctionne le capteur de distance à ultrasons?

Voici un exemple simple de la façon dont un capteur à ultrasons fonctionne pour mesurer la distance:

Tout d’abord, l’émetteur (trig pin) envoie une onde sonore
L’objet capte l’onde, la renvoyant vers le capteur.
Le récepteur (broche d’écho) le capte

Le lien pour le principe de fonctionnement : https://www.redohm.fr/2017/10/grove-telemetre-a-ultrasons-grove-101020010/

Téléchargez la bibliothèque UltrasonicRanger depuis Github.

Retour au sommaire

020 –

Retour au sommaire

Etude pas a pas du robot L3-37

Mise à jour le 25/10/2020 : Le robot L3-37 sera reproductible par tous et une grande partie sera en impression 3D.Retrouvez l’ensemble des articles concernant le projet L3-37 sur notre site https://www.redohm.fr ou suivez-nous sur notre chaîne YouTube.( Projet OpenSource )

Sommaire :

22/10/2020 : Quelques photo de l’Impression 3D du robot
24/10/2020 : Motorisation de la tête par des servomoteurs RC
25/10/2020 : Base de la tête de L3-37
02/11/2020 : Etude des deplacements de la tête avec les servo Dynamixel
26/11/2020 : La version L3-37 à servomoteur rc terminée
Retour au menu principal

25/10/2020 – Base de la tête de L3-37

22/10/2020 – Quelques photos de l’impression 3D du robot

Centre d’impression 3D

Retour en haut de page

24/10/2020 – Motorisation de la tête par des servomoteurs RC type
HSB-9380TH

Voici des fiches techniques un peu plus détaillées sur la motorisation par servomoteur RC. Bien conscient que les servomoteurs proposés ont un prix un peu élevé et qui pourrait bien évidemment repousser quelques passionnés, nous allons donc vous proposer une troisième plate-forme avec des servomoteurs du même constructeur mais avec un prix moindre. Nous choisirons donc le Hiltec HS 805BB. Nous sommes bien évidemment ouverts à d’autres propositions de servomoteurs en respectant un couple de fonctionnement de 20 kg.cm minimum. Au niveau du câblage et de la programmation, cela ne changera pas grand-chose.

L3-37-Version servomoteur RC – RedOhm

L3-37-Version servomoteur RC – RedOhm 001

L3-37-Version servomoteur RC – RedOhm 002

L3-37-Version servomoteur RC – RedOhm 003

Information complementaire sur le servomoteur HSB-9380TH

Electrique : Bien que compatible avec la plupart des dispositifs de radiocommande, la fonction de freinage par récupération des servos de la série HSB-93XX peut poser un problème si le dispositif ne peut pas accepter un reflux de courant. Les types d’appareils qui ne peuvent pas accepter ce reflux sont: les régulateurs de tension, les récepteurs Power Safe et certains circuits BEC, qu’ils soient autonomes ou intégrés dans un contrôle de vitesse électronique.

Mécanique arbre de sortie :

Les servos ont un arbre de sortie qui utilise généralement un profil cannelé afin de transférer le couple de l’arbre de sortie dans l’accessoire servo qui y est fixé. Ce profil cannelé est généralement classé en fonction du nombre de dents, cependant, il est possible que deux servo-cannelures très différentes aient le même nombre de dents car elles ne capturent pas le diamètre de la cannelure ou le profil de la dent. Par exemple, A15T et D15T ont tous deux 15 dents, mais le D15T est une taille de cannelure beaucoup plus grande que l’A15T. Les graphiques ci-dessous sont des représentations lâches des tailles de spline courantes que l’on trouve sur les servos amateurs. Si vous avez un servo que nous n’offrons pas sur le site, vous pouvez vérifier si votre servo a une spline qui correspond à l’un des profils de spline ci-dessous en comptant les dents et en mesurant la distance à travers la spline.

Données techniques HSB -9380 TH

Style d’arbre : H25T Spline
Gamme de tension : 6.0V – 7.4V
Vitesse à vide à 7,4 Volts : 0.14 sec/60°
Vitesse à vide à 6 Volts : 0.17 sec/60°
Couple de décrochage à 6 volts : 472 oz-in (34 kg.cm)
Couple de décrochage à 7,4 volts : 472 oz-in (34 kg.cm)
Plage de signal PWM maximale : 700-2300μsec
Travel per µs (Stock) : .075°/μsec
Rotation maximal : 120°
Amplitude d’impulsion : 3-5V
Température de fonctionnement : -20°C to +60°C
Rotation continue modifiable : oui
Direction avec / augmentation du signal PWM : Dans le sens des aiguilles d’une montre
Largeur de la bande morte : 2µs
Type de moteur : Brushless
type de rétroaction ; 5KΩ Potentiometer
Support d’arbre de sortie : roulements à billes doubles
Materiaux pour les engrenages : Titane (Hybrid MPD 1st Gear)
Rotation maximal ( reprogrammée ) : 205°

L3-37-Version servomoteur RC – RedOhm 005

Retour en haut de page

25/10/2020 – Base de la tête de L3-37

Base de la tête de L3-37 – RedOhm 001

Base de la tête de L3-37 – RedOhm 002

Retour en haut de page

02/11/2020 : Etude des deplacements de la tête avec les servo Dynamixel

Dans le cadre du projet L3 -37, nous utilisons deux sortes de motorisations pour piloter la tête du robot ou des moteurs de type RC (souvent utilise en modélisme ) ou bien des moteurs du type Dynamixel.

Dans le cadre de ce tutoriel qui ne traite que des moteurs Dynamixel, 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 les mouvements de la tête.

Retour en haut de page

26/11/2020 : La version L3-37 à servomoteur rc terminée

Voici donc la version L3 -37 à servomoteur RC terminé on peut cependant regretter un petit manque de résolution sur la tête qui ne fait pas ressortir des courbes suffisamment fluides. Pour cela nous allons modifier la résolution de nos fichiers STL ce qui permet de s’approcher au mieux des surfaces du modèle 3D en revanche ce procédé augmente la taille du fichier STL. Vous aurez donc le choix entre télécharger la version standard ou la version haute résolution.

Retour en haut de page

0. 2/11/2020 : Etude des deplac

ements de la tête avec les servo Dynamixel

L3-37 nos tuto en vidéo

Sommaire :

2020/10/21 : Présentation de L3-37
2020/11/02 : L3-37 Pilotage de la tete d’un robot
Retour au menu Vidéo

2020/10/21 : Présentation de L3-37

Voici donc une brève présentation de la tête du robot L3 -37. Ce robot sera construit en plusieurs parties. Nous allons commencer déjà par la tête et un début de buste pour qu’il puisse avoir déjà une certaine utilité ne serait-ce que pour la programmation ou bien servir d’instrument d’interfaçage en domotique. Dans cette présentation qui fait office de tutoriels ,vous avez une explication bien que sommaire des différentes étapes de construction de la tête. Pour tout autre information comme les fichiers STL, les programmes, les schémas ,vous aurez ces informations sur notre site. Je vous rappelle aussi que ce projet est open source.

Retour au sommaire

2020/11/02 : L3-37 Pilotage de la tete d’un robot

Dans le cadre du projet L3 -37, nous utilisons deux sortes de motorisations pour piloter la tête du robot ou des moteurs de type RC souvent utilise en modélisme ) ou bien des moteurs du type Dynamixel .

Retour au sommaire

Sommaire L3-37

Mise à jour le 25/10/2020 :

Continuer la lecture →

Arduino : Coder la fonction d’un télerupteur

Mise à jour le 09/10/2020 : Ce tutoriel vous explique comment coder un télerupteur sur Arduino. 2 types de fonctionnement vous sont proposés.

Sommaire :

Principe de fonctionnement de la fonction
Programme support pour le tutoriel
Informations utiles pour la compréhension du code
Pour tout problème
Retour au menu principal .

Principe de fonctionnement de la fonction

2 types de fonctionnement vous sont proposés.

le premier étant le modèle standard : Lorsque l’on appuie sur le bouton poussoir, une impulsion met le télérupteur au travail, il ferme le circuit jusqu’à ce qu’une nouvelle impulsion l’ouvre et ainsi de suite. Les informations électriques qui font changer l’état du télérupteur sont du type front montant.
Il vous est donc proposé dans le programme fourni dans cet article ,un ensemble de codes composés de six lignes qui vous permet de créer cette fonction.

Telerupteur changement d’état sur le front montant

Deuxième montage. Lorsqu’on appuie sur le bouton poussoir, une impulsion met le télérupteur au travail met sur le front descendant. Il faut donc relâcher le bouton pour que le télérupteur soit actif. Lorsque nous avons une nouvelle impulsion toujours sur le front descendant le système se remet à l’état de repos et ainsi de suite.
Il vous faudra donc mettre une ligne en commentaire pour générer cette fonction dans le code fourni .

telerupteur changement d’état sur le front descendant

Retour au sommaire

Programme support pour le tutoriel

//
//
//************************************************
//
//RedOhm
//le 20/09/2020
//H-Mazelin
//
//Creation d'un telerupteur  
//
//
//IDE Arduino 1.8.10 
//************************************************

// déclaration de l'entrée du bouton branché sur la broche 6
// de votre carte Arduino 
int bouton6 = 6;
 
// variable du type int pour stocker les valeurs de passage du bouton6
int bouton6v;

// creation d'une memoire_2 et forçage a 0 de la variable 
// etat du telerupteur 
int memoire_2=0;

// etat precedent du bouton et forçage a 0 de la variable 
int etat_bouton6v=0 ;




// --------------------------------------------------------------------
// 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() {
//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); 

// Configure la broche spécifiée pour qu'elle se comporte soit en entrée, 
// soit en sortie.Dans notre cas en entrée pour le bouton6
  pinMode(bouton6,INPUT);

}

void loop() {
  


bouton6v = digitalRead(bouton6);

// Creation un telerupteur 
// Compare la variable à gauche avec la valeur ou la variable
// à droite . Renvoie l'information vraie lorsque les deux
// variables ne sont pas égales. 
   if (bouton6v!=etat_bouton6v)
    {
       if (!bouton6v)
      {
        //Inversion de la valeur de la variable memoire 
        memoire_2=!memoire_2;
      } 

       //si vous placez la ligne de code en commentaire 
       //alors le telerupteur fonctionnera sur les fronts
       //descendant des boutons poussoirs 
       //
       //Inversion de la valeur de la variable memoire 
       memoire_2=!memoire_2;
     
    }
// operation consitant a memoriser l'anciennne valeur de la 
// variable     
etat_bouton6v=bouton6v;



//======= Creation des offset pour le chronogramme ======== 
//
// affichage de la position du bouton 2
//
// ci joint le lien pour le tuto traitant de la fonction
// chronogramme
// https://www.youtube.com/watch?v=MBTEkbA6soI
//
bouton6v=bouton6v+2;



  Serial.print(bouton6v);
   Serial.print(",");
    Serial.print(memoire_2);
     Serial.println();


}

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

//RedOhm

//le 20/09/2020

//H-Mazelin

//Creation d'un telerupteur

//IDE Arduino 1.8.10

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

// déclaration de l'entrée du bouton branché sur la broche 6

// de votre carte Arduino

int bouton6 = 6;

// variable du type int pour stocker les valeurs de passage du bouton6

int bouton6v;

// creation d'une memoire_2 et forçage a 0 de la variable

// etat du telerupteur

int memoire_2=0;

// etat precedent du bouton et forçage a 0 de la variable

int etat_bouton6v=0 ;

// --------------------------------------------------------------------

// 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() {

//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);

// Configure la broche spécifiée pour qu'elle se comporte soit en entrée,

// soit en sortie.Dans notre cas en entrée pour le bouton6

pinMode(bouton6,INPUT);

}

void loop() {

bouton6v = digitalRead(bouton6);

// Creation un telerupteur

// Compare la variable à gauche avec la valeur ou la variable

// à droite . Renvoie l'information vraie lorsque les deux

// variables ne sont pas égales.

if (bouton6v!=etat_bouton6v)

{

if (!bouton6v)

{

//Inversion de la valeur de la variable memoire

memoire_2=!memoire_2;

}

//si vous placez la ligne de code en commentaire

//alors le telerupteur fonctionnera sur les fronts

//descendant des boutons poussoirs

//Inversion de la valeur de la variable memoire

memoire_2=!memoire_2;

}

// operation consitant a memoriser l'anciennne valeur de la

// variable

etat_bouton6v=bouton6v;

//======= Creation des offset pour le chronogramme ========

// affichage de la position du bouton 2

// ci joint le lien pour le tuto traitant de la fonction

// chronogramme

// https://www.youtube.com/watch?v=MBTEkbA6soI

bouton6v=bouton6v+2;

Serial.print(bouton6v);

Serial.print(",");

Serial.print(memoire_2);

Serial.println();

}

Retour au sommaire

Informations utiles pour la compréhension du code

! = Opérateurs de comparaison

Compare la variable à gauche avec la valeur ou la variable à droite de l’opérateur. Renvoie true lorsque les deux opérandes ne sont pas égaux. Veuillez noter que vous pouvez comparer des variables de différents types de données, mais que cela pourrait générer des résultats imprévisibles, il est donc recommandé de comparer des variables du même type de données incluant le type signé / non signé.

Syntaxe = x != y;

Paramètres :
x: variable. Autorisé types de données: int, float, double, byte, short, long.
y: variable ou constante. Autorisé types de données: int, float, double, byte, short, long.

!

Ce symbole peut être utilisé pour inverser la valeur booléenne

Syntaxe = x = !y;

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

Retour au sommaire