Archives de l’auteur : Hervé Mazelin

Sommaire L3-37

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

HALLOWING M0 EXPRESS

Mise à jour le 21/08/2020 – Rubrique traitant de la carte HALLOWING M0 EXPRESS . Cette carte permet la création de regards avec un ou deux yeux. Des programmes déjà réalisés pour cette carte sont en distribution libre. Cerise sur le gâteau vous pouvait développer des programmes avec Ide Arduino ou sur python.

Continuer la lecture →

Support pour FreeBox V5

Mise à jour le 01/08/2020 – les Freebox V5 sont sensibles aux fortes chaleurs . Nous avons donc étudié un système de refroidissement pouvant pallier ce problème.

Continuer la lecture →

Présentation et Utilisation de la carte ArbotiX-M

Mise à jour le 08/10/2020 : Dans cet article vous trouverez les caractéristiques principales de la carte ArbotiX-M .Ce contrôleur de robot polyvalent est une solution de contrôle avancée pour les actionneurs basés sur BIOLOID et DYNAMIXEL

Carte ArbotiX-M

Sommaire :

Description de la carte ArbotiX-M
- Spécifications techniques de la carte
- Compatibilité avec les servo Dynamixel suivant
- Information complementaire sur la carte ArbotiX-M
Explication de la partie Hardware de la carte
- Cablage des entrées analogiques
- Alimentation du bus pour les servomoteurs type RC
Téléchargez Arduino 1.0.6 et installez
Comment connaitre les macro de la bibliotheque Bioloid
Table de controle de la zone EEPROM et RAM du servomoteur AX-12
- 0-Donne le numéro de modèle du servomoteur R
- 2-Version du firmware R
- 3-Identifiant du servomoteur R/W
  - Explication de l’identifiant
  - Tutoriel sur le changement d’idenfiant
  - Code source
- 4-vitesse de communication série entre un contrôleur et le servo R/W
  - Tableau de la vitesse de transmission des servomoteurs Dynamixel
  - Tutoriel pour la modification de la vitesse de communication
  - Code source pour le Tutoriel
- 5-Délai de réponse du servo R/W
- 6-Limite d’angle dans le sens horaire R/W
- 8-Limite d’angle anti-horaire R/W
- 11-Limite de température interne maximale R/W
- 12-Limite de tension d’entrée minimale R/W
- 13-Limite de tension d’entrée maximale R/W
- 14-Couple maximal R/W
- 16-Sélectionnez les types de déclaration de statut R/W
- 17-LED pour alarme R/W
- 18-Informations sur les erreurs d’arrêt R/W
- 24-Activation et désactivation du couple R/W
- 25-Allumez ou éteignez la LED du DYNAMIXEL. R/W
- 26-27-Controle d’erreur de deplacement R/W
- 28-29-Pente de conformité R/W
- 30-Position de l’objectif R/W
- 32-Vitesse de deplacement R/W
- 34-Limite du couple R/W
- 36-Position actuelle de votre servomoteur R
- 42-obtenir la tension actuelle du servo. R
- 43-obtenir la température actuelle du servo R
- 44-Macro permettant de savoir si le servo a une commande enregistrée R
Pilotage de la led sur le servomoteur
Exemple utilisation des moteurs Dynamixel
A savoir sur l’utilisation des informations de cette article .
Retour au menu principal

Description de la carte ArbotiX-M

Ce contrôleur de robot polyvalent est une solution de contrôle avancée pour les actionneurs basés sur BIOLOID et DYNAMIXEL. En tant que microcontrôleur compatible Arduino, la carte contrôleur Arbotix bénéficie également d’une énorme communauté open source de bibliothèques et d’exemples. Depuis sa sortie en 2010, l’ArbotiX-M est rapidement devenu un favori parmi les constructeurs du monde entier, du loisir à la recherche de haut niveau.

Cette carte a été spécifiquement conçue pour contrôler les servomoteurs Dynamixel. La carte ArbotiX-M est plus qu’un remplaçant pour la carte de controle CM-5, il s’agit plutôt d’un outil de haut niveau dédié à la construction de robots plus sophistiqués.

Specifications techniques de la carte contrôleur robotique ArbotiX-M

microcontrôleur AVR 16 MHz (ATMEGA644p)
2 ports séries, 1 dédié aux servo-contrôleurs Dynamixel, l’autre au module radio XBEE
3 ports de style TTL DYNAMIXEL à 3 broches
28 E / S numériques, dont 8 peuvent également fonctionner comme entrées analogiques
Embases à 3 broches de style servo (gnd, vcc, signal) sur les 28 broches d’E / S
Cette carte nécessite un câble FTDI ou un FAI pour la programmation. Pour un câble FTDI, nous recommandons le câble Sparkfun FTDI – USB , vous pouvez également utiliser le programmeur AVR USB .
Avec une dimension de 7.11 x 7.11 cm (2.8″ x 2.8 « )

Compatibilité avec les servo Dynamixel suivant

AX-12A : Le servo robot AX-12A a la capacité de suivre sa vitesse, sa température, la position de l’arbre, la tension et la charge. De plus l’algorithme de contrôle utilisé pour maintenir la position de l’arbre sur l’actionneur ax-12 peut être ajusté individuellement pour chaque servo, vous permettant de contrôler la vitesse et la force de la réponse du moteur. Toute la gestion des capteurs et le contrôle de position sont gérés par le microcontrôleur intégré du servo. Cette approche distribuée laisse votre contrôleur principal libre d’effectuer d’autres fonctions.

AX-18A : Le servomoteur AX-18A est la prochaine étape par rapport servomoteur AX-12A, offrant près de deux fois la vitesse et 15% de couple en plus! Le servo robot AX-18A conserve le facteur de forme et toutes les mêmes caractéristiques que son prédécesseur: la possibilité de suivre sa vitesse, sa température, la position de l’arbre, la tension et la charge. L’algorithme de contrôle fonctionne de la méme façon que la version AX-12A

Compatibilité du moteur avec les cartes suivantes :
- Robot-contrôleur ArbotiX-M
- ROBOTIS CM-530
- ROBOTIS USB2DYNAMIXEL
- ROBOTIS CM-700
- ROBOTIS Open CM 9

AX-12W : Le servomoteur AX-12W de Robotis est une variante à roues du populaire AX-12A. Essentiellement, ce servo est un AX-12A avec un rapport d’engrenage inférieur, de sorte qu’un régime beaucoup plus élevé peut être atteint, ce qui le rend idéal pour une utilisation en mode roue par opposition au mode commun. Le servo robot AX-12W a la capacité de suivre sa température, sa tension et sa charge.L’algorithme de contrôle fonctionne de la méme façon que la version AX-12A , AX-18A

AX-12W Compatible carte ArbotiX-M -2

Tension de fonctionnement : 12V
Couple de décrochage : 2,0 kg-cm / 28 oz-in / 0,2 Nm
Vitesse à vide : 470 tr / min (mode roue)
Poids : 53g
Taille : 50 x 32 x 38 mm
Résolution : 0,29 °
Servos de résolution : 300 ° / 10 BITS
Compatibilité du moteur avec les cartes suivantes :
- Robot-contrôleur ArbotiX-M
- Module de controle Bioloid CM-5
- Adaptateur Robotis USB2Dynamixel

Information complementaire sur la carte ArbotiX-M

Vous ne pouvez pas programmer l’ArbotiX pendant qu’un XBee est branché sur l’ArbotiX ou l’UartSBee. Vous devez débrancher tout XBees de l’ArbotiX-M ou UartSBee pendant la programmation. En effet, le XBee et le câble FTDI sont connectés au même port série. Si vous souhaitez programmer la carte alors qu’un XBee est branché, vous devez utiliser la programmation ISP

Retour au sommaire

Explication de la partie Hardware de la carte

Cablage des entrée analogiques

Les broches analogiques font également office de broches d’E / S numériques. Vous pouvez y accéder dans l’IDE Arduino en adressant les broches numériques 24-31 pour accéder aux broches analogiques A0-A7.

Entrée analogique sur la carte Arbotix-M

Retour au sommaire

Alimentation du bus pour les servomoteurs type RC

Avoir ces quatre ports sur un bus d’alimentation séparé est idéal pour utiliser à la fois les servos RC et les servos DYNAMIXEL du même ArbotiX. La plupart des servos DYNAMIXEL ont besoin de 11-12V pour fonctionner, mais la plupart des servomoteurs RC fonctionnent à partir de 5-6v. Comme le régulateur 5v a une puissance de sortie limitée, il n’est pas judicieux d’alimenter les servomoteurs à partir du BUS 5v. En ajoutant une autre alimentation, il est facile d’alimenter en toute sécurité ses servos RC

Code pour le pilotage d’un servo RC et d’un servomoteur Dynamixel

//
//
//*************************************************************
//* 
//* IDE Arduino 1.0.6
//*
//* Exemple de pilotage d'un servo Dynamixel
//* et d'un servo Rc sur la meme carte 
//*       
//* H-Mazelin
//* 05/08/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  

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


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

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

  // associe le servomoteur a la broche 12   
  servo01.attach(12);


}

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

void loop()

{

// Exemple de mouvement du servomoteur 
// avec la commande SetPosition(identifiant,position)  
   SetPosition(2,250);
// Pilotage du servomoteur RC
   servo01.write (20);
    delay (2000);
// Pilotage du servomoteur Dynamixel
   SetPosition(2,800); 
// Pilotage du servomoteur RC retour en arriere a 170 degres     
   servo01.write(160); 
     delay (2000);
//
//
  
}

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

//*

//* IDE Arduino 1.0.6

//*

//* Exemple de pilotage d'un servo Dynamixel

//* et d'un servo Rc sur la meme carte

//*

//* H-Mazelin

//* 05/08/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

// Cette librairie permet à une carte ArbotiX-M de contrôler des servomoteurs

#include <Servo.h>

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

Servo servo01;

* 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(1000);

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

// sur le moniteur serie

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

Serial.println("Communication etablie");

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

// associe le servomoteur a la broche 12

servo01.attach(12);

}

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

void loop()

{

// Exemple de mouvement du servomoteur

// avec la commande SetPosition(identifiant,position)

SetPosition(2,250);

// Pilotage du servomoteur RC

servo01.write (20);

delay (2000);

// Pilotage du servomoteur Dynamixel

SetPosition(2,800);

// Pilotage du servomoteur RC retour en arriere a 170 degres

servo01.write(160);

delay (2000);

}

Retour au sommaire

Téléchargez Arduino 1.0.6 et installez

L’Arduino IDE est une application que vous pouvez utiliser pour programmer et interagir avec des microcontrôleurs basés sur Arduino comme l’ArbotiX-M. Les bibliothèques ArbotiX-M ont été minutieusement testées avec IDE Arduino 1.0.6. Les bibliothèques actuelle ne prenne pas en charge les anciennes versions d’Arduino (beta 18-23) ou Arduino 1.6. Les utilisateurs peuvent télécharger l’IDE Arduino compressé et le décompresser à l’emplacement de leur choix. Les utilisateurs de Windows peuvent également utiliser Windows Installer pour automatiser ce processus.

Retour au sommaire

Comment connaitre les macro de la bibliotheque Bioloid

Il est toujours très intéressant de connaître le contenu d’une bibliothèque et en l’occurrence du fichier d’en-tête. Quelquefois on peut passer à côté de certains codes ou macros qui sont très intéressantes.

De quoi est composée la bibliothèque.

C’est un dossier qui contient :

Le fichier d’entête. Repérable par « .h »
Le fichier sources. Repérable par « .cpp »
Le dossier « exemple ». Qui contient des codes sources des exemples.

Arduino
- libraries
  - Bioloid
    - ax12.ccp
    - ax12.h
    - BioloidController.cpp
    - BioloidController.h
    - keywords.txt

Quand vous avez trouvé l’emplacement du fichier « Bioloid.h », ouvrez-le.

A première vue, on a pas l’impression que ce fichier est un code programme car il est présenté sous format » texte ». De ce fait, il est exploitable par un éditeur de texte comme « NotePad », « WordPad » ou le « Bloc-notes ».

A savoir : N’apportez surtout pas de modifications à ce fichier et n’accepter jamais d’enregistrer d’éventuelles modifications car cela entraînerait à coup sûr un mauvais fonctionnement de la bibliothèque.

Vous pourrez constater que le fichier nous donne un grand nombre de macros et à droite des noms des macros vous avez le numéro de registre correspondant.

Retour au sommaire

Table de controle de la zone EEPROM et RAM du servo AX-12

Definition de la table de controle des servomoteurs.

La table de contrôle est une structure de données implémentée dans l’appareil. Les utilisateurs peuvent lire des données spécifiques pour obtenir l’état de l’appareil avec les paquets d’instructions de lecture, et modifier également les données pour contrôler l’appareil avec les paquets d’instructions WRITE.

Tableau de contrôle,données,adresse

La table de contrôle est une structure qui se compose de plusieurs champs de données pour stocker l’état ou pour contrôler le périphérique. Les utilisateurs peuvent vérifier l’état actuel de l’appareil en lisant des données spécifiques de la table de contrôle avec des paquets d’instructions de lecture. Les paquets d’instructions WRITE permettent aux utilisateurs de contrôler le périphérique en modifiant des données spécifiques dans la table de contrôle. L’adresse est une valeur unique lors de l’accès à des données spécifiques dans la table de contrôle avec des paquets d’instructions. Pour lire ou écrire des données, les utilisateurs doivent désigner une adresse spécifique dans le paquet d’instructions.

Zone EEPROM et RAM

La table de contrôle est divisée en 2 zones. Les données de la zone RAM sont réinitialisées à leurs valeurs initiales lorsque l’alimentation est réinitialisée (volatile). D’autre part, les données dans la zone EEPROM sont conservées même lorsque l’appareil est hors tension (non volatile).

.
AX_MODEL_NUMBER_L et AX_MODEL_NUMBER_H
Registre 0 et Registre 1 en EEPROM

Cette adresse stocke le numéro du modèle du servo Dynamixel.octet de poids faible

Adresse	Fonction	Exemple de lecture du registre	Objectif
0	Donne le numéro de modèle	ax12GetRegister (1, AX_MODEL_NUMBER_L, 1); ou ax12GetRegister (1,0,1);
0	Donne le numéro de modèle
Accès	-> Lecture	Valeur initiale en mémoire EEPROM ->	12

Exemple de code

//
//
   Serial.println("========================================"); 
// Cette adresse stocke le numéro de modèle de servomoteur DYNAMIXEL.  
// Déclare une variable de type int (pour integer, entier en anglais)
   int modele= ax12GetRegister (1, AX_MODEL_NUMBER_L, 1);
// ou l'ecriture ci dessous
// int modele= ax12GetRegister (1,0,1);
   Serial.print ("Modele de servomoteur : ");
     Serial.println (modele); 
//

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

// Cette adresse stocke le numéro de modèle de servomoteur DYNAMIXEL.

// Déclare une variable de type int (pour integer, entier en anglais)

int modele= ax12GetRegister (1, AX_MODEL_NUMBER_L, 1);

// ou l'ecriture ci dessous

// int modele= ax12GetRegister (1,0,1);

Serial.print ("Modele de servomoteur : ");

Serial.println (modele);

Retour au sommaire

AX_VERSION
Registre 2 en EEPROM

Cette adresse stocke la version du firmware du servomoteur Dynamixel.

Adresse	Fonction	Exemple de lecture du registre	Objectif
2	la version du firmware
Accès	-> Lecture

Retour au sommaire

AX_ID
Registre 3 en EEPROM

L’ID est une valeur unique dans le réseau pour identifier chaque DYNAMIXEL avec un paquet d’instructions. Les valeurs 0 ~ 252 (0xFC) peuvent être utilisées comme ID, et 254 (0xFE) sont occupées comme ID de diffusion. L’ID de diffusion (254, 0xFE) peut envoyer simultanément un paquet d’instructions à tous les DYNAMIXEL connectés.

Adresse	Fonction	Exemple d’ecriture dans le registre	Objectif
3	Lecture de l’identifiant
R/W

Exemple de code : Modification de l’identifiant du servo

//
//
// Registre 3 modifie l'identifiant du servo de 1 vers 2
//
// Procedure d'ecriture dans le registre 3 pour le changement d'identifiant
// Modification de la valeur par defaut 1 par l'identifiant 2
   ax12SetRegister(1, 3, 2);
    delay (100);
//

// Registre 3 modifie l'identifiant du servo de 1 vers 2

// Procedure d'ecriture dans le registre 3 pour le changement d'identifiant

// Modification de la valeur par defaut 1 par l'identifiant 2

ax12SetRegister(1, 3, 2);

delay (100);

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

//
//
//*************************************************************
//* 
//* IDE Arduino 1.0.6
//*
//* Lecture et ecriture du registre 3 (identifiant du servo)
//* But : 
//* Lecture de la valeur actuel dans le registre 3
//* Renplacement de la valeur par defaut par un nouvel identifiant
//* dans notre cas 2
//* Controle du remplacement 
//*
//* Par H-Mazelin le 02/08/2020
//*
//*************************************************************



//librairie qui permet d'utiliser 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>

// Vitesse par defaut pour les servo AX-12 = 1000000
BioloidController bioloid = BioloidController(1000000);

// ---------------------------------------------------------------------------
// Un programme Arduino doit impérativement contenir la fonction "setup"
// 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(1000);
  // Information a l'operateur de l'ouverture du port de communication 
  // sur le moniteur serie 
  Serial.println("========================================");
  Serial.println("Communication etablie");
  Serial.println("========================================"); 
  
  //
  //
  // Registre 3 modifie l'identifiant du servo de 1 vers 2
  //
  // Procedure d'ecriture dans le registre 3 pour le changement d'identifiant
  // Modification de la valeur par defaut 1 par l'identifiant 2
  
  // Enlever le mode commentaire pour activer le changement d'identifiant 
  // dans la ligne ci-dessous 
  ax12SetRegister(1, 3, 2);
  
   delay (100);
  //
}
void loop ()
{
 
  // Lecture de l'identifiant actuel
  int identifiant =ax12GetRegister(2,3,1);
  // Affichage de la lecture du registre contenant l'identifiant 
  Serial.print("le servo possede l'idenifiant suivant : ");
   Serial.println (identifiant);  
  delay(1000);
  

// 
  
  
// Exemple de mouvement du servomoteur 
// avec la commande SetPosition(identifiant,position)  
   Serial.println("lancement du programme sur le servo");  
    Serial.println("en bas ");
   SetPosition(2,250);
   delay(2000);
   Serial.println("en haut ");
   SetPosition(2,650);
   delay(2000);
   Serial.println("");
    
}

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

//*

//* IDE Arduino 1.0.6

//*

//* Lecture et ecriture du registre 3 (identifiant du servo)

//* But :

//* Lecture de la valeur actuel dans le registre 3

//* Renplacement de la valeur par defaut par un nouvel identifiant

//* dans notre cas 2

//* Controle du remplacement

//*

//* Par H-Mazelin le 02/08/2020

//*

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

//librairie qui permet d'utiliser 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>

// Vitesse par defaut pour les servo AX-12 = 1000000

BioloidController bioloid = BioloidController(1000000);

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

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

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

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

// sur le moniteur serie

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

Serial.println("Communication etablie");

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

// Registre 3 modifie l'identifiant du servo de 1 vers 2

// Procedure d'ecriture dans le registre 3 pour le changement d'identifiant

// Modification de la valeur par defaut 1 par l'identifiant 2

// Enlever le mode commentaire pour activer le changement d'identifiant

// dans la ligne ci-dessous

ax12SetRegister(1, 3, 2);

delay (100);

}

void loop ()

{

// Lecture de l'identifiant actuel

int identifiant =ax12GetRegister(2,3,1);

// Affichage de la lecture du registre contenant l'identifiant

Serial.print("le servo possede l'idenifiant suivant : ");

Serial.println (identifiant);

delay(1000);

// Exemple de mouvement du servomoteur

// avec la commande SetPosition(identifiant,position)

Serial.println("lancement du programme sur le servo");

Serial.println("en bas ");

SetPosition(2,250);

delay(2000);

Serial.println("en haut ");

SetPosition(2,650);

delay(2000);

Serial.println("");

}

Retour au sommaire

AX_BAUD_RATE
Registre 4 en EEPROM

Le débit en bauds détermine la vitesse de communication série entre un contrôleur et les servomoteurs Dynamixel.

Adresse

Fonction

Exemple d’ecriture dans le registre

Objectif

R/W

Fixe la vitesse de communication valeur par defaut 1M avec une marge d’erreur de 0.000%

ax12SetRegister(1,4,1);

Valeur par defaut 1M bauds

A savoir : moins de 3% de la marge d’erreur du débit en bauds n’affectera pas la communication UART.

//
//
// Registre 4 modifie la vitesse entre le controleur et les 
// servomoteur Dynamixel
//
// Procedure d'ecriture dans le registre 4 pour le changement de la vitesse
// de communication
// modification de la valeur 34 par la valeur 1
// 1 parametre : numero de identifiant du servo
// 2 parametre : numero du registre a modifie
// 3 parametre : valeur de la vitesse de transmission 
   ax12SetRegister(1,4,1);
   delay (500);

// Registre 4 modifie la vitesse entre le controleur et les

// servomoteur Dynamixel

// Procedure d'ecriture dans le registre 4 pour le changement de la vitesse

// de communication

// modification de la valeur 34 par la valeur 1

// 1 parametre : numero de identifiant du servo

// 2 parametre : numero du registre a modifie

// 3 parametre : valeur de la vitesse de transmission

ax12SetRegister(1,4,1);

delay (500);

Vitesse de transmission des servomoteurs Dynamixel

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.

//
//
//*************************************************************
//* 
//* IDE Arduino 1.0.6
//*
//* Fonctionnement d'un servomoteur Dynamixel MX-106
//* 1- modification de la vitesse de transmission
//*  2- de l'identifiant      
//*   3- insertion d'un servo AX-12
//*    4- fonctionnment de l'ensemble 
//*
//* RedOhm le 14/09/2020 par Herve Mazelin 
//* 
//*************************************************************


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


// En parenthese le vitesse de communication
// Servo AX12 = 1000000
// dans le registre du servo AX12 = 1 par defaut
// Servo MX-106 = 57142.9
// dands le registre du servo MX-106 = 34 par defaut
//
BioloidController bioloid = BioloidController(1000000);


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

// Registre 4 modifie la vitesse entre le controleur et les 
// servomoteur Dynamixel
//
// Procedure d'ecriture dans le registre 4 pour le changement de la vitesse
// de communication
// modification de la valeur 34 par la valeur 1
// 1 parametre : numero de identifiant du servo
// 2 parametre : numero du registre a modifie
// 3 parametre : valeur de la vitesse de transmission 
   //ax12SetRegister(1,4,1);
   //delay (500);

// Registre 3 modifie l'identifiant du servo de 1 vers 3
//
// Procedure d'ecriture dans le registre 3 pour le changement d'identifiant
// Modification de la valeur par defaut 1 par l'identifiant 3
   
   //ax12SetRegister(1, 3, 3);
   //delay (100);  
}


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

void loop ()
{
//
// Registre 3 donne l'identifiant MX-106   
//
  int identifiant = ax12GetRegister(3,3,1);
   Serial.print ("Registre 3: identifiant du MX-106 : "); 
    Serial.println (identifiant);
    delay(50);  
//
// Registre 4 donne la vitesse de transmission MX-106  
//
  int vitesse = ax12GetRegister(3,4,1);
   Serial.print ("Registre 4:Vitesse de transmission du MX-106 : "); 
    Serial.println (vitesse);
    delay(1000);
  

// Exemple de mouvement du servomoteur MX-106
// avec la commande SetPosition(identifiant,position) 
// Attention resolution du moteur 4096 
   Serial.println("             --------            ");
   Serial.println("lancement du programme sur le servo MX-106");
   Serial.println("A gauche");
   SetPosition(3,10);
   delay(2000);
   Serial.println("A droit");
   SetPosition(3,4080);
   delay(2000);
   Serial.println(""); 

     
// Exemple de mouvement du servomoteur ax-12
// avec la commande SetPosition(identifiant,position)  
   
   Serial.println("lancement du programme sur le servo AX-12");
   Serial.println("A gauche");
   SetPosition(2,200);
   Serial.println("A droit");
   delay(2000);
   SetPosition(2,850);
   Serial.println(""); 
     Serial.println("");     
  
}

100

101

102

103

104

105

106

107

108

109

110

111

112

113

114

115

116

117

118

119

120

121

122

123

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

//*

//* IDE Arduino 1.0.6

//*

//* Fonctionnement d'un servomoteur Dynamixel MX-106

//* 1- modification de la vitesse de transmission

//* 2- de l'identifiant

//* 3- insertion d'un servo AX-12

//* 4- fonctionnment de l'ensemble

//*

//* RedOhm le 14/09/2020 par Herve Mazelin

//*

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

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

// En parenthese le vitesse de communication

// Servo AX12 = 1000000

// dans le registre du servo AX12 = 1 par defaut

// Servo MX-106 = 57142.9

// dands le registre du servo MX-106 = 34 par defaut

BioloidController bioloid = BioloidController(1000000);

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

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

{

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

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

// sur le moniteur serie

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

Serial.println("Communication etablie");

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

// Registre 4 modifie la vitesse entre le controleur et les

// servomoteur Dynamixel

// Procedure d'ecriture dans le registre 4 pour le changement de la vitesse

// de communication

// modification de la valeur 34 par la valeur 1

// 1 parametre : numero de identifiant du servo

// 2 parametre : numero du registre a modifie

// 3 parametre : valeur de la vitesse de transmission

//ax12SetRegister(1,4,1);

//delay (500);

// Registre 3 modifie l'identifiant du servo de 1 vers 3

// Procedure d'ecriture dans le registre 3 pour le changement d'identifiant

// Modification de la valeur par defaut 1 par l'identifiant 3

//ax12SetRegister(1, 3, 3);

//delay (100);

}

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

void loop ()

{

// Registre 3 donne l'identifiant MX-106

int identifiant = ax12GetRegister(3,3,1);

Serial.print ("Registre 3: identifiant du MX-106 : ");

Serial.println (identifiant);

delay(50);

// Registre 4 donne la vitesse de transmission MX-106

int vitesse = ax12GetRegister(3,4,1);

Serial.print ("Registre 4:Vitesse de transmission du MX-106 : ");

Serial.println (vitesse);

delay(1000);

// Exemple de mouvement du servomoteur MX-106

// avec la commande SetPosition(identifiant,position)

// Attention resolution du moteur 4096

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

Serial.println("lancement du programme sur le servo MX-106");

Serial.println("A gauche");

SetPosition(3,10);

delay(2000);

Serial.println("A droit");

SetPosition(3,4080);

delay(2000);

Serial.println("");

// Exemple de mouvement du servomoteur ax-12

// avec la commande SetPosition(identifiant,position)

Serial.println("lancement du programme sur le servo AX-12");

Serial.println("A gauche");

SetPosition(2,200);

Serial.println("A droit");

delay(2000);

SetPosition(2,850);

Serial.println("");

}

Retour au sommaire

AX_TORQUE_ENABLE
Registre 24 en RAM

Adresse

Fonction

Exemple d’ecriture dans le registre

Objectif

R/W

pour activer / désactiver le couple au servo..

0 = Coupez le couple

1= le couple et verrouillez dans la zone RAM

Retour au sommaire

AX_LED
Registre 26 en RAM

Adresse

Fonction

Exemple d’ecriture dans le registre

Objectif

R/W

Macro pour activer / désactiver la LED sur le servo.

ax12SetRegister(1, 25, 1) ;

Allume la led

ax12SetRegister(1, 25, 0) ;

Retour au sommaire

AX_PRESENT_POSITION_L et AX_PRESENT_POSITION_H
Registre 36 et 37 en RAM

Position actuelle de votre servomoteur Dynamixel La plage de la valeur est 0 ~ 1023 (0x3FF) et l’unité est 0,29 [°].
ATTENTION : S’il est réglé sur Mode roue, la valeur ne peut pas être utilisée pour mesurer la distance de déplacement et la fréquence de rotation.

Adresse

Fonction

Exemple de lecture des registres

Objectif

Obtenir la position actuelle du servo

ax12GetRegister (1, AX_PRESENT_POSITION_L ,2);

…

Exemple de code.

//
// 
// Registre 36 et 27 vous donne la position actuelle de votre servo 
//
// registre donnant la valeur de la position actuelle du servomoteur
// La plage de la valeur est 0 ~ 1023 (0x3FF) et l'unité est 0,29 degre
// la taille de la memoire pour int est sur 2 octet soit 16 bits
   int position_l= ax12GetRegister (1, AX_PRESENT_POSITION_L ,2);
   Serial.print ("Position actuelle du servomoteur : ");
    Serial.println (position_l);
   //delay(100);  
//

// Registre 36 et 27 vous donne la position actuelle de votre servo

// registre donnant la valeur de la position actuelle du servomoteur

// La plage de la valeur est 0 ~ 1023 (0x3FF) et l'unité est 0,29 degre

// la taille de la memoire pour int est sur 2 octet soit 16 bits

int position_l= ax12GetRegister (1, AX_PRESENT_POSITION_L ,2);

Serial.print ("Position actuelle du servomoteur : ");

Serial.println (position_l);

//delay(100);

Retour au sommaire

AX_PRESENT_VOLTAGE
Registre 42 en RAM

C’est la valeur de la tension actuelle fournie. Cette valeur est 10 fois supérieure à la tension réelle. Par exemple, lorsque 10 V est fourni, la valeur des données est 100 (0x64) Si la valeur de la tension actuelle (42) est hors plage, le bit d’erreur de plage de tension (Bit0) du paquet d’état est renvoyé comme ‘1’ et l’alarme est déclenchée et définie. l’adresse 17 et réglez 1 sur le bit 0 de l’adresse 18.

Adresse	Fonction	Exemple de lecture du registre	Objectif
42	obtenir la tension actuelle du servo.	Ax12GetRegister (1, AX_PRESENT_VOLTAGE, 1)	Cette valeur est 10 fois superieur à la tension réelle il faut donc diviser la valeur par 10
	obtenir la tension actuelle du servo.	Ax12GetRegister (1, 42, 1)

Exemple de code pour lire la tension presente sur le servomoteur

// 
// Registre 42 pour obtenir la tension actuelle du servo. 
// 
// Macro pour obtenir la tension actuelle du servo.
// -> ax12GetRegister (1, AX_PRESENT_VOLTAGE, 1
// Lecture de la tension sur le servomoteur   
// Déclare la variable voltage de type "virgule-flottante",
// c'est à dire un nombre à virgule. 
  float voltage = (ax12GetRegister (1, AX_PRESENT_VOLTAGE, 1)) / 10.0;
// ou l'ecriture ci-dessous avec le numero de registre 
// float voltage = (ax12GetRegister (1, 42,1)) / 10.0;
   Serial.print("Registre42:Tension presente sur le servomoteur :");
    Serial.print (voltage);
      Serial.println (" volts.");
//

// Registre 42 pour obtenir la tension actuelle du servo.

// Macro pour obtenir la tension actuelle du servo.

// -> ax12GetRegister (1, AX_PRESENT_VOLTAGE, 1

// Lecture de la tension sur le servomoteur

// Déclare la variable voltage de type "virgule-flottante",

// c'est à dire un nombre à virgule.

float voltage = (ax12GetRegister (1, AX_PRESENT_VOLTAGE, 1)) / 10.0;

// ou l'ecriture ci-dessous avec le numero de registre

// float voltage = (ax12GetRegister (1, 42,1)) / 10.0;

Serial.print("Registre42:Tension presente sur le servomoteur :");

Serial.print (voltage);

Serial.println (" volts.");

Retour au sommaire

AX_PRESENT_TEMPERATURE
Registre 43 en RAM

Il s’agit de la température interne de DYNAMIXEL en Celsius.
La valeur des données est identique à la température réelle en degrés Celsius. Par exemple, si la valeur des données est 85 (0x55), la température interne actuelle est de 85 ° C.

Adresse	Fonction	Exemple lecture du registre	Objectif
43	obtenir la température actuelle du servo.	ax12GetRegister (1, AX_PRESENT_TEMPERATURE, 1)	la valeur donné est identique a la temperature réelle
43	obtenir la température actuelle du servo.	ax12GetRegister (1, AX_43, 1)

Exemple de code

//   
//
//Macro pour obtenir la température actuelle du servo.
//Déclare une variable de type int (pour integer, entier en anglais)
   int temperature = ax12GetRegister (1, AX_PRESENT_TEMPERATURE, 1);
//ou l'ecriture ci-dessous 
//int temperature = ax12GetRegister (1, 43, 1);  
      Serial.print ("Temperature actuelle en degres celsius : ");
       Serial.print (temperature);
         Serial.println ("") ; 
//

//Macro pour obtenir la température actuelle du servo.

//Déclare une variable de type int (pour integer, entier en anglais)

int temperature = ax12GetRegister (1, AX_PRESENT_TEMPERATURE, 1);

//ou l'ecriture ci-dessous

//int temperature = ax12GetRegister (1, 43, 1);

Serial.print ("Temperature actuelle en degres celsius : ");

Serial.print (temperature);

Serial.println ("") ;

Retour au sommaire

AX_REGISTERED_INSTRUCTION
Registre 44 en RAM

Adresse	Fonction	Exemple lecture du registre	Objectif
44	Macro permettant de savoir si le servo a une commande enregistrée	ax12GetRegister (1, AX_REGISTERED_INSTRUCTION,1); OU ax12GetRegister (1, 44,1);	Valeur = 0 L’instruction REG_WRITE n’est pas reçue
			Valeur = 1 L’instruction REG_WRITE est reçue

Exemple de code

//
//
// Macro permettant de savoir si le servo a une commande enregistrée.
// 0 = aucune commande enregistrée 1 = commande enregistrée
// Déclare une variable de type int (pour integer, entier en anglais)
    int commande_enregistree =  ax12GetRegister (1, AX_REGISTERED_INSTRUCTION,1);    
// ou l'ecriture ci-dessous
// int commande_enregistree =  ax12GetRegister (1, 44,1);
    Serial.print ("Commande enregistree : ");
    if (commande_enregistree=1) 
    {
     Serial.println ("oui");  
    }  
    else 
    {
    Serial.println ("non");
    }
//

// Macro permettant de savoir si le servo a une commande enregistrée.

// 0 = aucune commande enregistrée 1 = commande enregistrée

// Déclare une variable de type int (pour integer, entier en anglais)

int commande_enregistree = ax12GetRegister (1, AX_REGISTERED_INSTRUCTION,1);

// ou l'ecriture ci-dessous

// int commande_enregistree = ax12GetRegister (1, 44,1);

Serial.print ("Commande enregistree : ");

if (commande_enregistree=1)

{

Serial.println ("oui");

}

else

{

Serial.println ("non");

}

Retour au sommaire

AX_PAUSE_TIME

Adresse	Fonction	Exemple d’ecriture dans le registre	Objectif
45

Retour au sommaire

AX_MOVING

Adresse	Fonction	Exemple lecture du registre	Objectif
46

Retour au sommaire

Pilotage de la led sur le servomoteur avec la carte ArbotiX-M

//
//
//*************************************************************
//* 
//* IDE Arduino 1.0.6



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



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

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

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

{
  //Commande pour allumer la led sur le servo 
  //ax12SetRegister(1, 25, 1); 
  //1=> Correspond à l’adresse du servo cible
  //25=> Numéro de registre
  //1=> forçage de la variable a 1 la led s’allume 
  ax12SetRegister(1, 25, 1);
  delay(300);
  //Commande pour eteindre la led sur le servo 
  //ax12SetRegister(1, 25, 0); 
  //1=> Correspond à l’adresse du servo cible
  //25=> Numéro de registre
  //1=> forçage de la variable a 0 la led s’eteint 
  ax12SetRegister(1, 25, 0);
  delay(300);

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

//*

//* IDE Arduino 1.0.6

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

//#include <BioloidController.h>

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

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

#include <ax12.h>

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

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

{

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

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

// sur le moniteur serie

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

Serial.println("Communication etablie");

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

}

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

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

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

void loop()

{

//Commande pour allumer la led sur le servo

//ax12SetRegister(1, 25, 1);

//1=> Correspond à l’adresse du servo cible

//25=> Numéro de registre

//1=> forçage de la variable a 1 la led s’allume

ax12SetRegister(1, 25, 1);

delay(300);

//Commande pour eteindre la led sur le servo

//ax12SetRegister(1, 25, 0);

//1=> Correspond à l’adresse du servo cible

//25=> Numéro de registre

//1=> forçage de la variable a 0 la led s’eteint

ax12SetRegister(1, 25, 0);

delay(300);

Retour au sommaire

Exemple utilisation des moteurs Dynamixel

Robot hexapode

Retour au sommaire

Lien utile pour la carte contrôleur Arbotix

Fournisseur :

https://www.trossenrobotics.com/p/arbotix-robot-controller.aspx

Information technique :

Déscription de la table de contrôle du servo AX-12+,AX-12A par Robotis :

A savoir sur l’utilisation des informations de cette article

Les informations sur les caractéristiques et spécificités de la carte ArbotiX-M et ses interfaces associées qui sont fournis sur cette page correspondent aux informations des fiches techniques du constructeur si malgré le soin apporté à la réalisation de cet article une erreur s’est glissée dans ces lignes nous ne pourrions en être tenu responsable.

Les programmes , schémas et autres que ceux donnés par le constructeur font parti des montages utiles à nos applications si malgré le soin apporté à nos montages une erreur s’est glissée dans ces lignes nous ne pourrions en être tenu responsable .

L’ensemble des informations techniques de cet article a été utilisé pour nos applications, elles vous sont fournies comme un exemple de document de travail. Mais nous ne pourrions être tenu responsables d’une mauvaise utilisation de celle-ci.

Retour au sommaire

Etude et reflexion sur le projet CareBot’s

Sommaire :

Présentation,étude et réflexion.
Stérilisation du robot reflexion de Sergio
Osram contre le virus
Materiel utile pour le moment
- Caméra thermique
Pour tout probléme.
Retour au menu principal

Présentation ,étude et réflexion.

Avant projet 2020/04/27

Ce projet est né pendant la pandémie du coronavirus. Nous avons donc imaginé un robot capable d’aller près du malade et d’avoir une interaction avec celui-ci. Il devrait avoir aussi la possibilité de pouvoir prendre la température du malade. L’infirmière ou l’aide-soignante pourrait piloter ce robot avec des lunettes Fpv.
On pourrait s’interroger : ce robot n’arrive-t-il pas tardivement dans cette période ? Et bien, non, car malheureusement, nous aurons toujours un virus qui traîne et qui sera contagieux.

Ce robot est prévu surtout pour le personnel soignant afin d’éviter de rentrer dans l’enceinte de la personne contaminée, évidemment, je ne parle pas de soins, mais plutôt, quand on veut avoir une interaction avec le patient sans être obligé à chaque fois de revêtir le matériel de protection, masques, lunettes, blouses et j’en passe.

Vous allez me dire « ce robot CareBot’s possède un air de déjà vu, eh bien, oui, nous avons repris le projet Nestor qui était bien abouti et nous avons juste modifié son enveloppe et quelques capteurs afin qu’il soit plus adapté à ce genre d’opération.

Ce petit robot possède un système d’interaction automatique pour que le malade ne se sente pas seul.

Le soignant pourra piloter le robot avec un système de lunettes FPV dans la chambre du malade tout en étant en sécurité à l’extérieur de l’enceinte. Le robot possèdera aussi une caméra thermique qui éventuellement pourrait surveiller la température du patient. Bien évidemment, on pourra rajouter autant de capteurs que nécessaire pour l’adapter éventuellement à des situations diverses et variées. On peut imaginer que toutes ces informations pourraient être monitorées vers un système de récupération de données externes

La priorité sur ce type de matériel ?
• Il devra utiliser du matériel électronique déjà existant afin de diminuer le temps d’études.
• Le prix de l’ensemble de ce robot ne devra pas excéder 6000 €

Ce projet est open source comme tout ce que construit RedOhm. Les informations concernant ce projet seront disponibles gratuitement sur notre site.

Si des personnes voulaient se joindre à l’étude, aux lignes directrices, donner leur avis sur le sujet, ils seront les bienvenus.

Stérilisation du robot

Idee de Sergio : Certaines lampes UV près du corps du robot aideraient à stériliser les environnements.

Je vous remercie de votre commentaire qui traite de la désinfection ou de la stérilisation du robot quand il va sortir de la chambre. Avec mon équipe nous avons réfléchi un petit moment sur votre commentaire et il est vrai qu’il faut impérativement qu’à chaque fois que le robot sort d’une chambre, il faut pouvoir le désinfecter pour éviter surinfection de la chambre voisine ou du personnel soignant. Donc, passé cette évidence nous sommes entrain d’imaginer une enceinte robotique équipée de certains systèmes de désinfection pour traiter le robot concerné. On peut imaginer un système à ultraviolet avec une certaine longueur d’onde pour éventuellement stériliser le robot. Il est pour le moment difficilement concevable de traiter le robot par pulvérisation d’alcool car trop explosif et inflammable.

C’est une idée à creuser surtout que nous avons quelque retour d’info sur la sensibilité de ce virus qui ne sont pas encore prouvés, mais à l’étude.

Bill Bryan, un expert en science et technologie auprès du ministère de la Sécurité intérieure a présenté des données chiffrées. Selon ces dernières, une demi-vie du virus, soit le temps nécessaire pour réduire sa puissance de moitié, dure 18 heures avec une température comprise entre 21 et 24 degrés Celsius et avec 20% d’humidité sur une surface non-poreuse (une poignée de porte par exemple). En revanche, cette demi-vie serait ramenée à 6 heures quand le taux d’humidité monte à 80% et à seulement quelques minutes quand la lumière du soleil s’y ajoute.

Lien utile :

Introduction à la méthode de désinfection par les UV.
Désinfection par rayonnement Ultra-violet par Lenntech .

Retour au sommaire

Osram contre le virus

Osram propose les tubes AirZing Pro dont le rayonnement UV-C garantit la destruction de virus, notamment le Covid-19 avec 99 % de succès. Nous allons donc étudier si ce type de matériel peut rentrer dans l’enceinte de décontamination du futur robot

La lumière UV-C invisible désinfecte efficacement l’air et les surfaces

Le rayon UV-C détruit à 99.9% l’ADN et l’ARN des bactéries, des virus et des moisissures, sans ajout de produits chimiques.
Un micro-organisme (bactéries ou virus) qui est exposé à un rayonnement de 253,7 nm absorbe les photons et subit une transformation telle que la cellule ne peut ni se multiplier ni survivre. Les micro-organismes sont endommagés et ne peuvent donc plus se multiplier.

Diffusion à 360° autour du tube. Traitement efficace au bout de 30 minutes consécutives minimum.

La surface de couverture (environ entre 10 et 40 m² maxi pour un tube placé à 2.5m de haut) dépend de la hauteur dont le tube de lumière UV-C est installé, la largeur et la longueur de la pièce, et des obstacles qui bloquent la diffusion de la lumière.

Attention ce rayonnement est très nocif pour l’homme.
La désinfection par UV-C doit absolument être effectuée la pièce vide (sans présence humaine ou animale). C’est pour cela que l’appareil est équipé s’un détecteur de présence infrarouge qui retarde l’allumage de 30 secondes de la lumière UV-C et coupe instantanément l’alimentation si une présence est détectée.

Lien utile distributeurs :

sonodistrib.com
soundlightup.com

Information technique : Osram.com

Retour au sommaire

Materiel utile pour le moment

Caméra thermique

Une caméra thermique enregistre les différents rayonnements infrarouge (ondes de chaleur) émis par les corps et qui varient en fonction de leur température. Contrairement à l’imaginaire populaire, une caméra thermique ne permet pas de voir derrière une paroi ou un obstacle. Elle reproduit la chaleur emmagasinée par un corps, ou montre le flux thermique d’une paroi en raison d’un foyer se trouvant à l’arrière.

Bien que la longueur d’onde du rayonnement infrarouge dépende de la température, les caméras thermiques ont en général un seul canal (comme une caméra qui filme en « noir et blanc »), et les caméras se contentent de produire une image de l’intensité du rayonnement, qui permet également d’apprécier la température de la source. La couleur produite par la caméra est une fausse couleur, obtenue en associant une couleur à l’intensité reçue, afin de faciliter la lecture directe de la température : à chaque couleur de l’image correspond une température.Voila pour le principe de fonctionnement .

Caméra FPV pour le pilotage par lunette en immersion

Le pilotage en immersion (en anglais, first-person view ou FPV) est un procédé qui consiste à diriger un systeme radiocommandé avion, drone , hélicoptère, voiture, etc.) par l’intermédiaire d’une caméra sans fil et d’un écran ou de lunettes/masques vidéo.

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.

Arduino Nano 33 BLE

Mise à jour le 25/04/2020 – Rubrique traitant de la carte Arduino Nano 33 BLE ABX00034-R sur les caractéristiques techniques , trucs et astuces , exemple de programme etc …

Continuer la lecture →

Protégé : Camera OpenMV

Attendre l’appui d’une touche avec la boucle While

Mise à jour le 08/03/2020 : Explications et applications de la boucle while et do-while, dans le fonctionnement et la validation d’un bouton poussoir pour continuer l’exécution d’un programme

Continuer la lecture →

Domotique : Création d’un hygromètre

Mise à jour le 15/02/2020 :

Construction d’un hygromètre – RedOhm –

Sommaire .

Définition et utilité d’un hygromètre
- Définition d’un hygromètre
- Principaux modèles hygromètre
- Capteur d’impédance variable avec le modéle capacitif
- Humidite ou mauvaise humidité pour qui ?
  - Les effets de l’humidité sur la santé
  - Stockage de filament pour l’impression 3D.
Choix pour notre application du capteur d’humidité et de T° Grove 101020019
Fourniture pour la réalisation de hygromèdre
Schéma de cablage de l’hygromètre
Programme de gestion des afficheurs et pilotage du relais d’asservissement
Lien utile et information technique
En cours de réalisation
Retour au menu

Définition et utilité d’un hygromètre

Définition d’un hygromètre

Un hygromètre est un appareil qui sert à mesurer l’humidité relative de l’air (l’hygrométrie relative). Ces appareils utilisent la température de condensation de la vapeur d’eau dans l’air (appelée point de rosée), des modifications de la capacité ou de la résistance électrique pour mesurer les différences d’humidité. Le premier hygromètre brut fut inventé par le polymathe de la Renaissance italienne Leonard de Vinci en 1480. En 1755, Jean-Henri Lambert a créé une version plus moderne et en 1783, Horace Bénédict de Saussure, physicien et géologue suisse, inventa le premier hygromètre utilisant le cheveu humain pour mesurer l’humidité.

Principaux modèles hygromètre

bobine de papier métallique
A cheveux
A condensation
Hygromètre capacitif
Hygromètre résistif

Capteur d’impédance variable avec le modéle capacitif

On mesure la capacité d’un condensateur dont le diélectrique est hydrophile. Pour mesurer l’humidité de l’air, on utilise généralement l’oxyde d’aluminium comme diélectrique. Le condensateur doit avoir une armature poreuse pour faciliter le passage de l’air dans le diélectrique. On utilise une électrode craquelée pour obtenir cette caractéristique. Un pont de Sauty relie les différentes cellules. Le pont est ensuite alimenté par un courant alternatif de haute fréquence (une fréquence élevée favorise une plus faible consommation d’énergie). La tension ainsi générée nous indique le pourcentage d’humidité. Cette technique de mesure offre des performances correctes (±2 % d’erreur) pour une gamme variant entre 5 et 99 % d’humidité relative³.

Cette méthode s’applique aussi aux solides. La capacité diélectrique de l’eau est de 80 et celle des solides est généralement inférieure à 5. La caractéristique diélectrique influencera donc la capacité électrique. En comparant la capacité d’un échantillon sec et d’un échantillon humide, on obtient une droite. On peut alors trouver le pourcentage d’humidité dans notre solide selon sa capacité.

Humidité ou mauvaise humidité pour qui ?

L’humidité relative de l’air est l’expression en pourcentage de la quantité de vapeur d’eau contenue dans l’air. Un intérieur trop humide ou trop sec n’est pas recommandé car il est dangereux pour votre santé, mais également celle de vos animaux et plantes. Il faut être vigilent notamment en hiver : par exemple, un chauffage qui tourne à plein régime est souvent synonyme d’assèchement de l’air. Il est donc important de connaître les valeurs critiques de l’humidité relative et ce qui régit le subtil équilibre entre température et humidité.

Les effets de l’humidité sur la santé

Un logement trop humide, une teneur en eau trop élevée a des répercussions sur la santé , comme les maladies respiratoires , les douleurs articulaires , des problèmes de circulation

Pour plus d’information : passeportsante.net

Stockage de filament pour l’impression 3D.

Dans le cas de l’impression 3D, plus particulièrement sur les filaments, la concentration d’humidité excessive peut provoquer une longue liste de problèmes

Dégradation des filaments: Les filaments hygroscopiques sont susceptibles d’absorber une grande partie de l’eau, car les molécules d’eau se lient aux molécules des polymères, formant ainsi des liens intermoléculaires forts. Ces liaisons peuvent entraîner des micro-ruptures internes qui affaiblissent la structure même du filament.

Obstruction de l’extrudeur / HotEnd: L’humidité concentrée dans le filament lors du chauffage dans le HotEnd s’évapore, provoquant des trous à l’intérieur du filament, ce qui en fait une pâte bouchant le Barrel (Heat Break) ou la busel (Nozzle). Ce problème est très courant lorsque l’on utilise des filaments de nylon présentant des taux d’humidité élevés (>20 %).

Retour au sommaire.

Choix pour notre application du capteur d’humidité et de T° Grove 101020019

Ce capteur de température et d’humidité (version pro DHT22) compatible Grove utilise une thermistance CTN et un capteur capacitif et délivre une sortie digitale. Sa précision est supérieure à celle du capteur SEN11301P.

Descriptif du module 101020019

Interface : compatible Grove
Alimentation : 3,3 à 6 Vcc
Consommation : 1,5 mA
Plage de mesure température : -40°C à 80°C (±0,5°C)
Plage de mesure pour humidité : 5 à 99% HR (±2%)
Temps de réponse : 6 à 20 secondes
Dimensions : 40 x 20 x 11 mm
Connectique non compatible : avec Tinker Kit
Référence Seeedstudio : 101020019 (remplace SEN51035P)

Information complementaire :

Impact de l’exposition aux produits chimiques.
Le capteur d’humidité capacitif possède une couche chimique qui, avec la prolifération de produits chimiques, peut modifier sa sensibilité. Une forte concentration de pollution chimique, comme l’éthanol, entraînera une destruction progressive de la couche sensible du capteur jusqu’à sa mise hors service.

Influence de la température sur le capteur.
L’installation de ce capteur doit être autant que possible éloignée des composants électroniques qui sont source de chaleur.

Impact de la lumière.
Une exposition prolongée au soleil ou un fort rayonnement ultraviolet aura pour effet de dégrader les performances du capteur.

Dépassement des capacités physique du capteur.
Placé dans des conditions de travail extrême ou des limites du capteur, pour que celui-ci puisse revenir dans les plages de conditions de fonctionnement normale, il faut maintenir deux heures dans des conditions d’humidité de 45 ℃ et <10% HR (sec); suivi par des conditions d’humidité de 20-30 ℃ et> 70% HR à maintenir plus de cinq heures.

Précautions de câblage.
La qualité du fil de signal affectera la qualité de la sortie de tension, il est recommandé d’utiliser un câble blindé de bonne qualité.

Retour au sommaire

Fourniture pour la réalisation de hygromètre

Capteur d’humidité et de T° Grove 101020019 – 1 piece

Ce capteur de température et d’humidité (version pro DHT22) compatible Grove utilise une thermistance CTN et un capteur capacitif et délivre une sortie digitale.

Capteur d’humidité et de T° Grove 101020019 piece pour l’hygromètre- RedOhm –

Capteur de T° et d’humidité DHT22

Le capteur de température et d’humidité DHT22 (ou RHT03) communique avec un microcontrôleur via un port série. Le capteur est calibré et ne nécessite pas de composants supplémentaires pour pouvoir être utilisé .
Conseil de RedOhm : Vous devrez placer une résistance de 10 kohms entre le VCC et la broche de données pour améliorer le signal de transmission de données.

Capteur d’humidité et de T° DTH22 pour l’hygromètre

Afficheur LCD I2C RGB Gravity DFR0464 – 2 pieces

Afficheur LCD 2 x 16 caractères noirs à rétro-éclairage RGB se raccordant via le bus I2C sur un microcontrôleur. Le rétro-éclairage RGB propose 16 millions de couleurs et différents effets paramétrables via le programme Arduino.

Afficheur LCD I2C RGB Gravity DFR0464

Multiplexeur I2C ADA2717 – 1 piece

Module multiplexeur basé sur un TCA9548A permettant de raccorder jusqu’à 8 modules I2C avec la même adresse sur le même bus I2C d’un microcontrôleur.

Multiplexeur I2C ADA2717 piece pour l’hygromètre- RedOhm –

Module relais Grove 103020005 ou equivalent

Ce module relais compatible Grove agit comme un interrupteur normalement ouvert et permet de commuter des charges plus élevées que ce que permettent les cartes Arduino ou compatibles.

Module relais Grove 103020005

Caractéristiques:

Interface : compatible Grove
Pouvoir de coupure : 10 A/30 Vcc
Indicateur de contact : led
Dimensions : 42 x 24 x 20 mm
Température de service : 0°C à +40°C
Référence Seeedstudio : 103020005

Retour au sommaire

Schéma de cablage de l’hygromètre

Module seeed schema de principe-V2 de l’hygromètre

Module seeed schema de principe-V2 de l’hygromètre – RedOhm –

Module DTH22 seul schéma de principe de l’hygromètre

Module DTH22 seul schema de principe de l’hygromètre – RedOhm –

Ignorez simplement la broche 3, elle n’est pas utilisée. Vous devrez placer une résistance de 10 kohms entre le VCC et la broche de données.

Schéma de principe pour le cablage du DTH22 seul

Schéma de principe pour le cablage du DTH22 seul – RedOhm –

Retour au sommaire.

Programme de gestion des afficheurs et pilotage du relais d’asservissement

//
//

// ***************************************************
// *   Programme réalisé  par RedOhm                 *
// *                                                 *
// *      Utilisation d'un capteur de temperature    *
// *      et d'humidité et affichage sur plusieurs   *
// *      écrans par l'intermédiaire d'un            *
// *      multiplexeur I2C et pilotage d'une         *
// *      sortie suivant un seuil                    *
// *                                                 *
// *                                                 *
// *                                                 *
// *  Programmation IDE 1.8.10                       *
// *  Le 08/02/2020                                  *
// *  J.Lucquin & H.Mazelin                          *
// ***************************************************


// Inclusion la bibliothèque pour le fonctionnement I2C
#include <Wire.h>  //bibliothèque I2C

//bibliothèque afficheur dfrobot
#include "DFRobot_RGBLCD.h" 

//bibliothèque capteur humidité et temp 
#include "DHT.h" 


 
// DHT 22  (AM2302) def type capteur humidité&temp
#define DHTTYPE DHT22   
// port de liaison
#define DHTPIN 2  
//Adresse du multiplexeur TCA9548A sur la carte arduino 
//cablage de la partie physique A0,A1 et A2 forcage à la masse  
#define TCAADDR 0x70 
 

// on met en place le capteur hum&temp
DHT dht(DHTPIN, DHTTYPE);   

 //16 caractères sur 2 lignes d'affichage (on met en place l'écran)
DFRobot_RGBLCD lcd(16,2);  

//valeur de la sortie du contacteur pour votre equipement
bool contact=0;  

//affectation de la broche pour le relais  
int relais1 = 8; 




// ---------------------------------------------------------------------------
// 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() 
{
     
      //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); 
      
      // Initialise la library Wire et se connecte au bus I2C 
      // en tant que maître
      Wire.begin(); 
  
// ouverture du port 2 du multiplexeur à l'adresse 0x70 
tcaselect (2);  
      // initialisation de ecran 2 temperature
      lcd.init(); 
      // aller a programme de fermeture du port ouvert 
     fermeture_du_port();

tcaselect (5);
       // initialisation de ecran 5 Hydrometre      
      lcd.init(); 
      // aller a programme de fermeture du port ouvert 
      fermeture_du_port();
  
    //initialise le capteur t&hum
    dht.begin(); 
    
    // Configure la broche spécifiée sur arduino pour
    // qu'elle se comporte ou en entrée ou en sortie,
    // ici le contacteur en sortie
    pinMode(relais1, OUTPUT);
}




// ----------------------------------------------------------------------
// Le programme principal s’exécute par une boucle infinie appelée Loop () 
// ----------------------------------------------------------------------
void loop() 
{
    // creation d'un tableau pour les variables temperature et humidité 
    float temp_hum_val[2] = {0};
    // La lecture de la température et de l'humidité du capteur prend 250 milisecondes
    // La mise à jour des valeurs peut aller jusqu'à 2 secondes    
    if(!dht.readTempAndHumidity(temp_hum_val)){

  // appel du sous programme pour l'ouverture du port du multiplexeur 
  tcaselect (2);
  lcd.setCursor(0,0);
  lcd.print("Temperature");
  lcd.setCursor(0,1);
  lcd.print(temp_hum_val[1]);
  lcd.print("C");
  // Affichage de la couleur de fond d'ecran en fonction de la 
  // valeur 
  lcd.setRGB(temp_hum_val[1], 100-temp_hum_val[1], 0);                  
  // appel du sous programme pour la fermeture du port 
  fermeture_du_port();



  // appel du sous programme pour l'ouverture du port du multiplexeur 
  tcaselect (5);
  lcd.setCursor(0,0);
  lcd.print("Humidite ");
  lcd.setCursor(0,1);
  lcd.print(temp_hum_val[0]);
  lcd.print("%");
  // Affichage de la couleur de fond d'ecran en fonction de la 
  // valeur  
  if (temp_hum_val[0] <= 15) lcd.setRGB(0, 100, 0);                  
  else lcd.setRGB (100,0,0);
  // appel du sous programme pour la fermeture du port 
  fermeture_du_port();


// gestion du contact d'asservissement 
if (temp_hum_val[0] <= 15)
{contact=0;}
else (contact=1);
// force la sortie a 1
digitalWrite(relais1, contact);
    }  
}

// fonction transmission multiplexeur avec selection du canal en variable
void tcaselect(uint8_t i) {  
 
  if (i > 7) return;
  //l'adresse du multiplexeur TCA9548A ici 0x70
  Wire.beginTransmission(TCAADDR);  
  // Envoie de byte au bus selectionné
  Wire.write(1 << i); 
  // on arrête la communication avec le multiplexeur             
  Wire.endTransmission();           
  
}



void fermeture_du_port()
{
  delay (100);
  //l'adresse du multiplexeur TCA9548A ici 0x70
  Wire.beginTransmission(TCAADDR);
  Wire.write(0); 
  // fin de transmission 
  Wire.endTransmission();
  
}

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

166

167

168

169

170

171

172

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

// * Programme réalisé par RedOhm *

// * *

// * Utilisation d'un capteur de temperature *

// * et d'humidité et affichage sur plusieurs *

// * écrans par l'intermédiaire d'un *

// * multiplexeur I2C et pilotage d'une *

// * sortie suivant un seuil *

// * *

// * Programmation IDE 1.8.10 *

// * Le 08/02/2020 *

// * J.Lucquin & H.Mazelin *

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

// Inclusion la bibliothèque pour le fonctionnement I2C

#include <Wire.h> //bibliothèque I2C

//bibliothèque afficheur dfrobot

#include "DFRobot_RGBLCD.h"

//bibliothèque capteur humidité et temp

#include "DHT.h"

// DHT 22 (AM2302) def type capteur humidité&temp

#define DHTTYPE DHT22

// port de liaison

#define DHTPIN 2

//Adresse du multiplexeur TCA9548A sur la carte arduino

//cablage de la partie physique A0,A1 et A2 forcage à la masse

#define TCAADDR 0x70

// on met en place le capteur hum&temp

DHT dht(DHTPIN, DHTTYPE);

//16 caractères sur 2 lignes d'affichage (on met en place l'écran)

DFRobot_RGBLCD lcd(16,2);

//valeur de la sortie du contacteur pour votre equipement

bool contact=0;

//affectation de la broche pour le relais

int relais1 = 8;

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

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

{

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

// Initialise la library Wire et se connecte au bus I2C

// en tant que maître

Wire.begin();

// ouverture du port 2 du multiplexeur à l'adresse 0x70

tcaselect (2);

// initialisation de ecran 2 temperature

lcd.init();

// aller a programme de fermeture du port ouvert

fermeture_du_port();

tcaselect (5);

// initialisation de ecran 5 Hydrometre

lcd.init();

// aller a programme de fermeture du port ouvert

fermeture_du_port();

//initialise le capteur t&hum

dht.begin();

// Configure la broche spécifiée sur arduino pour

// qu'elle se comporte ou en entrée ou en sortie,

// ici le contacteur en sortie

pinMode(relais1, OUTPUT);

}

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

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

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

void loop()

{

// creation d'un tableau pour les variables temperature et humidité

float temp_hum_val[2] = {0};

// La lecture de la température et de l'humidité du capteur prend 250 milisecondes

// La mise à jour des valeurs peut aller jusqu'à 2 secondes

if(!dht.readTempAndHumidity(temp_hum_val)){

// appel du sous programme pour l'ouverture du port du multiplexeur

tcaselect (2);

lcd.setCursor(0,0);

lcd.print("Temperature");

lcd.setCursor(0,1);

lcd.print(temp_hum_val[1]);

lcd.print("C");

// Affichage de la couleur de fond d'ecran en fonction de la

// valeur

lcd.setRGB(temp_hum_val[1], 100-temp_hum_val[1], 0);

// appel du sous programme pour la fermeture du port

fermeture_du_port();

// appel du sous programme pour l'ouverture du port du multiplexeur

tcaselect (5);

lcd.setCursor(0,0);

lcd.print("Humidite ");

lcd.setCursor(0,1);

lcd.print(temp_hum_val[0]);

lcd.print("%");

// Affichage de la couleur de fond d'ecran en fonction de la

// valeur

if (temp_hum_val[0] <= 15) lcd.setRGB(0, 100, 0);

else lcd.setRGB (100,0,0);

// appel du sous programme pour la fermeture du port

fermeture_du_port();

// gestion du contact d'asservissement

if (temp_hum_val[0] <= 15)

{contact=0;}

else (contact=1);

// force la sortie a 1

digitalWrite(relais1, contact);

}

// fonction transmission multiplexeur avec selection du canal en variable

void tcaselect(uint8_t i) {

if (i > 7) return;

//l'adresse du multiplexeur TCA9548A ici 0x70

Wire.beginTransmission(TCAADDR);

// Envoie de byte au bus selectionné

Wire.write(1 << i);

// on arrête la communication avec le multiplexeur

Wire.endTransmission();

}

void fermeture_du_port()

{

delay (100);

//l'adresse du multiplexeur TCA9548A ici 0x70

Wire.beginTransmission(TCAADDR);

Wire.write(0);

// fin de transmission

Wire.endTransmission();

}

Retour au sommaire

lien utile et information technique

Fournisseur :

Capteur d’humidité et de T° Grove 101020019 : gotronic
Multiplexeur I2C ADA2717 : gotronic / boutique.semageek
Afficheur LCD I2C RGB Gravity DFR0464 : gotronic

Information technique :

Définition et principe de fonctionnement d’un hygromètre : wikipedia
Probleme d’humidité pour l’impression 3D : filament2print

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