Abonnez-vous à DeepL Pro pour traduire des fichiers plus volumineux.

Visitez www.DeepL.com/pro pour en savoir plus.

MINISTÈRE DE L'ÉDUCATION ET DE LA SCIENCE DE LA FÉDÉRATION DE

RUSSIE
federal state budgetary educational institution of higher education
"Université d'État de Togliatti"

INSTITUT DE L'ENERGIE ET DU GENIE ELECTRIQUE

(institut)
Électronique industrielle
(Président)
11.03.04 Électronique et nanoélectronique
(code et nom du domaine d'études, spécialité)
Électronique industrielle
(profil)

MÉMOIRE DE LICENCE

sur le manipulateur contrôlé par microcontrôleur

Étudiant D.Y. Zhuravsky

(prénom et nom) (signature personnelle)

Tête A.V. Pryadilov

(prénom et nom) (signature personnelle)

Consultants N.V. Andriukhina

(prénom et nom) (signature personnelle)

Permettre d'être défendu

Chef de département Candidat aux sciences techniques, professeur associé, A.A.

Shevtsov
(grade académique, titre, nom de famille et patronyme) (signature personnelle)

" " 20 г.

Togliatti 2018
 Annotation

Mots clés : bras manipulateur, servomoteur, carte microcontrôleur, port série.

Le mémoire de licence se compose de six parties principales, d'une conclusion et

d'une liste des sources utilisées. Le volume de la note explicative est de 48 pages, le
nombre d'images est de 41, la partie graphique consiste en 6 posters de format A1, la liste
des sources utilisées comprend 25 noms.
Le sujet du travail de qualification finale est le développement et la recherche d'un
stand de démonstration basé sur un bras-manipulateur robotisé. Les buts et objectifs du
projet sont formulés. Le schéma structurel de la conception du manipulateur est présenté.
Lors de la réalisation du travail de bachelor
tous les éléments du dispositif ont été sélectionnés et étudiés en profondeur : servomoteurs,
carte microcontrôleur. La majeure partie du projet a été consacrée à l'assemblage du
dispositif et à la création du code de programme pour le contrôle du manipulateur, avec un
débogage ultérieur. La particularité du logiciel développé est la possibilité de contrôler le
manipulateur à l'aide d'une souris et d'un clavier. Le logiciel de ce dispositif se compose de
deux parties : un programme chargé sur la carte du microcontrôleur et un programme de
terminal pour l'ordinateur qui lit la position de la souris et les frappes sur le clavier. Toutes
les informations sont envoyées et lues via le port série. Une évaluation de l'environnement
et de la sécurité du dispositif étudié est réalisée. Une partie distincte du document de
licence fournit des détails sur l'analyse économique réalisée et le coût des composants.

2
 Résumé

Mots-clés : bras-manipulateur, servomoteurs, carte microcontrôleur, port série. Le

mémoire de licence se compose de six parties principales, d'une conclusion et d'une

liste de références.
Le mémoire de licence se compose d'une note explicative de 48 pages, comprenant 41
dessins, la partie graphique de 6 affiches de format A1, et une liste de 25 références.

Le sujet du mémoire de licence est le développement et l'étude d'un stand de

démonstration basé sur un bras-manipulateur robotisé. Les buts et objectifs du projet sont
formulés. Un schéma structurel de la conception du manipulateur est présenté. Au
cours de l'exécution de la thèse de licence, tous les éléments du dispositif, tels que les
servomoteurs, la carte microcontrôleur, ont été sélectionnés et étudiés en profondeur. La
majeure partie du temps de travail du projet a été consacrée à l'assemblage du
dispositif et à la création d'un code de programme pour le contrôle du manipulateur
avec débogage ultérieur. Le logiciel de ce dispositif se compose de deux parties : un
programme chargé sur la carte microcontrôleur et un programme terminal pour
l'ordinateur, qui lit la position de la souris et appuie sur les touches du clavier. Toutes les
informations sont envoyées et lues par le port série. L'évaluation de
l'environnement et de la sécurité du dispositif étudié a été réalisée. La partie
spéciale du mémoire de licence donne des détails sur l'analyse économique effectuée et
les coûts des composants.

3
 Contenu

Introduction ..........................................................................................................................5
1. Statut de la question........................................................................................................10
1.1. Formuler le but et les objectifs du projet ..................................................................10
1.2. Analyse des données de base et des solutions connues ............................................10
2. Section du projet.............................................................................................................13
2.1. Conception du circuit et sélection des composants nécessaires...................................13
2.2. Développement de la conception des dispositifs ......................................................18
2.3. Fabrication pratique du dispositif .............................................................................19
3. Partie du programme ......................................................................................................23
3.1. Description de l'algorithme du dispositif..................................................................23
3.2. Développer la partie logicielle de l'appareil .............................................................28
4. Partie expérimentale .......................................................................................................40
4.1. Instructions pour l'utilisation de l'appareil................................................................40
4.2. Vérification et débogage de la partie logicielle de l'appareil....................................42
5. Un dispositif sûr et respectueux de l'environnement.......................................................43
6. Volet économique...........................................................................................................45
Conclusion..........................................................................................................................46
Liste des sources utilisées...................................................................................................47
Annexe A............................................................................................................................50
Annexe B............................................................................................................................53

4
 Introduction

L'homme moderne du XXIe siècle a grand besoin de ces "aides" indispensables dans
de nombreux domaines d'activité, tels que l'industrie, la médecine, la construction, la
recherche, la maison, etc.
des robots. C'est pourquoi la robotique s'est tellement développée ces dernières années. De
nombreux types de dispositifs robotiques ont été mis au point pour faciliter au maximum
l'exécution de certaines tâches,
améliorer de manière significative la qualité du travail effectué et réduire au minimum les
risques d'accidents.
la possibilité de blessures liées au travail, pouvant aller jusqu'à la mort. Un exemple d'un
tel dispositif est un bras robotisé.

Figure 1 - Bras robotique en production

Un bras robotisé est un dispositif qui imite des mouvements similaires à des
mouvements humains humain,conçu pour la mise en
œuvre
Il existe un large éventail de tâches, allant du simple déplacement d'objets dans l'espace à

5
la réalisation d'interventions chirurgicales complexes. Il existe de nombreux types de
manipulateurs qui

6
Ils se distinguent par le nombre de degrés de mobilité, les actionneurs utilisés, la capacité
de charge, la méthode de contrôle, la méthode d'installation, la capacité à être déplacé et
donc la méthode de déplacement. Toutes ces
les critères sont choisis en fonction de l'objectif du manipulateur. Ci-dessous
Les principaux types de manipulateurs, qui diffèrent par leur conception, sont énumérés :

Les manipulateurs cartésiens, qui sont des constructions composées d'axes

disposés perpendiculairement.
mouvements. Ce type de manipulateur présente une bonne rigidité structurelle en raison du
petit nombre de connexions. En même temps, l'inconvénient de ce type de manipulateur
est l'absence totale de flexibilité, ce qui limite considérablement ses performances dans les
domaines suivants
mouvement. Le bras SCARA a été conçu pour remédier à ces lacunes et, contrairement à
ses prédécesseurs, il présente une bonne flexibilité horizontale. Les manipulateurs décrits
ci-dessus ont trouvé leur application principalement dans les domaines suivants
dans l'usine d'assemblage.

Figure 2 - Manipulateur cartésien

7
 Les bras articulés sont des liens multiples qui forment un système de coordonnées
polaires. Ce type de manipulateur est très flexible, ce qui lui permet d'adopter n'importe
quelle position dans la zone de travail. Les bras articulés sont utilisés dans de nombreuses
applications : soudage, chirurgie mini-invasive, etc.

Figure 3 - Manipulateur articulé

Manipulateurs à tige parallèle. Les plus courants sont constitués de plusieurs circuits
cinématiques formant un parallélogramme. Ces dispositifs ont une grande précision, une
capacité de vitesse élevée et un énorme degré de liberté. Les manipulateurs de ce type sont
principalement utilisés pour le tri et l'emballage de produits finis.

8
 Figure 4 - Manipulateur de type parallèle

Cependant, tous les types de manipulateurs décrits ci-dessus constituent une chaîne
ouverte de maillons interconnectés, qui ont leurs propres noms, semblables aux noms des
parties du bras humain (épaule, avant-bras, coude),
main, doigts, articulation, etc.)

Figure 5 - Conception du manipulateur

9
 Les bras articulés sont particulièrement demandés aujourd'hui dans l'industrie, où les
capacités de levage élevées sont une exigence clé. Les manipulateurs pneumatiques et
hydrauliques sont bien adaptés à cette tâche. Parallèlement, les manipulateurs sont
également nécessaires pour d'autres applications où la capacité de levage est moins
importante, mais où une précision, une flexibilité et un contrôle élevés sont requis. Les
manipulateurs servo-motorisés, moins connus que leurs homologues hydrauliques et
pneumatiques, sont mieux adaptés à ce type d'applications. Ce type de manipulateur
commence tout juste à gagner en popularité et il n'existe pas beaucoup de solutions prêtes
à l'emploi qui répondent à toutes les exigences. Dans notre projet, nous utiliserons un bras
servo articulé, que nous examinerons en détail.

10
 1. État de la question

1.1.Formuler le but et les objectifs du projet

Objectif : Créer une carte de démonstration de bras robotique basée sur des
servomoteurs, concevoir et mettre en œuvre un moyen de contrôler le bras robotique.
Objectifs :
1. Analyser tout le matériel lié d'une manière ou d'une autre à notre sujet de diplôme.
2. Mettre en évidence tous les avantages et les inconvénients des solutions existantes.
3. Fabrication du dispositif.
4. Développement et débogage de la partie logicielle du dispositif.

1.2.Analyse des données de base et des solutions connues

Il existe actuellement très peu de solutions prêtes à l'emploi pour les manipulateurs à
servomoteur. Toutes les implémentations que j'ai examinées ont de nombreux points
communs : une conception à peu près identique utilisant des matériaux différents qui
influent sur le poids total de l'appareil, une conception similaire de l'appareil, une

conception de l'appareil et une conception de l'appareil.

microcontrôleurs. Il existe toutefois quelques différences mineures : différents
microcontrôleurs sont utilisés
Les servomoteurs influent sur le poids maximal que le bras peut soulever et sur le degré de
liberté maximal. Différentes options de préhension ont été mises en œuvre, de la ventouse
à la pince. Les variations varient également
Les solutions les plus prometteuses, à mon avis, sont les manipulateurs par les souris et les
claviers de l'entreprise. De toutes les solutions existantes, le projet le plus prometteur est, à

mon avis, celui des manipulateurs de l'entreprise

Ufactory, qui a réussi à obtenir un financement sur kickstarter.com et
a déjà introduit plusieurs modèles prêts à l'emploi. Leurs produits jouissent d'une grande

11
popularité

12
Les robots industriels sont demandés en raison de l'absence de concurrents dans leur gamme
de prix, alors que les robots industriels coûtent des dizaines de fois plus cher.

Figure 6 - Un des modèles de manipulateurs de Ufactory

L'équipe d'ingénieurs de Ufactory développe et améliore ses conceptions depuis

plusieurs années et a obtenu de très bons résultats. Il a été
La conception optimale des appareils et l'utilisation de matériaux de très haute qualité,
ainsi que le développement de logiciels libres de contrôle et de débogage de haute qualité
pour les manipulateurs, ont été créés. L'un des
Le principal avantage de ce robot est sa capacité d'apprentissage, ce qui lui permet d'être plus
efficace.
Une opportunité énorme pour les personnes ayant au moins quelques notions de
programmation, et pour ceux qui en sont loin, il y a la possibilité que le manipulateur
répète les mouvements de la main de l'hôte.

Outre uArm, il existe plusieurs autres options de manipulateurs sur le marché qui sont
inférieures à la solution ci-dessus pour une raison ou une autre, mais qui méritent tout de
même l'attention : le projet Dobot, qui a un penchant pour l'impression 3D, le projet Ctrl,
qui ressemble à un manipulateur industriel, réduit de plusieurs fois. Ces deux projets
présentent toutefois un inconvénient de taille pour
des appareils destinés principalement à un usage domestique, leur prix :

13
Dobot ($1400), Ctrl ($800). Il existe également un projet très bon marché appelé LittleArm
(60 $) 2C, qui consiste essentiellement à
petit manipulateur, visant à à l'enseignement enfants
les bases de la programmation et de la robotique.

Figure 7 - Modèles de manipulateurs Dobot et Ctrl

Après avoir analysé toutes les solutions évoquées ci-dessus, nous avons conclu que,
pour notre projet, nous devions utiliser des composants peu coûteux, facilement
disponibles et pouvant être rapidement et facilement modifiés en cas de besoin, et nous
avons choisi pour la commande, également utilisée dans le projet uArm, la méthode de la
souris et du manipulateur de clavier, parce qu'elle
offre une très large gamme de paramètres configurables, ce qui permet de réaliser un
système de contrôle très flexible.

14
 2. Section du projet

2.1.Conception de circuits et sélection des composants nécessaires

Pour créer le projet prévu, la première chose à faire est d'établir un schéma
fonctionnel afin d'avoir une idée aussi détaillée que possible des composants dont vous
avez besoin. Schéma fonctionnel
de l'appareil est illustré ci-dessous à la figure 11. La conception du diagramme a été réalisée
en
Le système de conception assistée par ordinateur KOMPAS-3D.

Figure 8 - Schéma fonctionnel de l'unité

Tout d'abord, nous devons décider comment nous allons faire fonctionner notre

15
manipulateur. Puisque nous voulons créer une cabine de démonstration,

16
qui peut être utilisé par tout le monde sans problème de recherche
Nous avons choisi d'utiliser une souris et un clavier pour contrôler le microcontrôleur via
un ordinateur, puisque nous n'avons pas besoin de piles pour le déplacer. Comme notre
carte de démonstration n'est pas mobile et n'a pas besoin de piles pour se déplacer, nous
avons choisi une alimentation pour ordinateur qui est idéale pour alimenter à la fois les
servos et le microcontrôleur. Pour la carte microcontrôleur, nous avons opté pour
l'Arduino Mega 2560, qui est entièrement compatible avec toutes les cartes
d'alimentation.
nécessaires à notre projet. Ce modèle peut être alimenté non
Cette carte est équipée d'un microcontrôleur ATmega2560 avec 256kB de mémoire pour
stocker le code du programme. Cette carte est équipée d'un microcontrôleur
ATmega2560 qui dispose de 256kB de mémoire pour stocker le code du programme.
Nous disposons également d'un grand nombre de broches d'E/S (16 analogiques et 54
numériques), d'un port USB et d'un UART. Il supporte la plupart des cartes d'extension, y
compris le Multiservo Shield qui peut également être utilisé dans notre banc d'essai. L'un
des principaux avantages de ce
L'environnement de programmation intégré Arduino IDE, mondialement connu, est la
plateforme. Il utilise un langage de programmation C/C++ simplifié, bénéficie d'un très
bon soutien de la part des développeurs et dispose d'une grande autonomie.
un grand nombre de bibliothèques qui sont constamment mises à jour.

17
Figure 9 - Arduino Mega 2560

18
 L'un des éléments les plus importants de notre unité est le servomoteur. Afin de
choisir le meilleur rapport prix/performance, nous avons examiné de nombreuses options.
Les principaux critères de sélection étaient les suivants : le type de mécanisme de retour
d'information, dans notre cas, le mécanisme de retour d'information, dans notre cas, le
mécanisme de retour d'information.
Dans ce cas, nous avons opté pour un servo numérique, un mécanisme métallique, un
couple élevé, une protection contre les chocs, une grande précision de positionnement, une
faible zone morte, un grand angle de rotation. Le servomoteur Tower Pro MG996R nous
a semblé le mieux adapté, car il présente un bon rapport qualité/prix.
caractéristiques à un prix relativement bas : poids 55g, couple 9,4 kgf-cm
(kilo-force par centimètre) à 4,8 V, 11 kgf-cm à 6 V, tension de fonctionnement : 5 - 7,3
V, vitesse de fonctionnement : 0,17 s/60º (5 V), 0,14 s/60º (6 V), mouvement mécanique,
un angle de rotation de 120 degrés. Pour notre projet, 5 de ces actionneurs sont nécessaires.

Figure 10 - Servomoteur Tower Pro MG996R

19
 Le schéma de câblage complet, ainsi que la liste des composants utilisés, sont
présentés dans la figure 11 ci-dessous. La disposition du schéma a été
Le projet a été réalisé avec le système de CAO KOMPAS-3D.

20
Figure 11 - Schéma de circuit avec liste des composants

21
 2.2. Développement de la conception des dispositifs

Notre objectif premier étant de créer une carte de démonstration à utiliser pour
l'apprentissage pratique de la programmation de manipulateurs, cela implique une
connexion rapide du dispositif, la possibilité de changer la configuration de l'équipement à
connecter,
La décision a été prise de construire une cabine entièrement ouverte, où le manipulateur et
tous les éléments qui l'accompagnent - alimentation électrique, tableau de connexion - se
trouveraient sur la même plate-forme,
carte de contrôle à microcontrôleur. Dans Compass 3D, vous avez créé une carte de contrôle à
microcontrôleur d'une valeur approximative de 1,5 million d'euros.
Le plan de notre stand, sur la base duquel l'appareil sera fabriqué.

Figure 12 - Schéma de la conception du futur dispositif

22
 2.3. Fabrication pratique du dispositif

Commençons donc à assembler l'appareil. Nous avons choisi une plaque de fibre de
verre comme plateforme pour notre stand, sur laquelle toutes les pièces seront placées,
jusqu'à l'alimentation. Pour alimenter notre manipulateur et notre carte de microcontrôleur,
nous avons pris une alimentation d'ordinateur ordinaire.

Figure 13 - Bloc d'alimentation

Nous nous sommes débarrassés des fils inutiles, ne laissant que quelques fils GND,
5V pour tous les servos et 12V qui pourrait être nécessaire dans de futurs projets où une
alimentation externe pour la carte arduino pourrait être nécessaire. Nous avons également
fabriqué un bouton d'alimentation pour faciliter la mise en marche et l'arrêt. Montage de
l'alimentation sur la plaque pré-peinte en noir. Directement
Pour l'assemblage du manipulateur lui-même, nous avons utilisé des pièces préfabriquées
en aluminium provenant du kit de construction en raison de leur légèreté et des trous de
fixation déjà réalisés.

23
 Figure 14 - Parties du cadre du manipulateur

Nous avons également trouvé une solution de préhension standard compatible avec
notre servomoteur, capable de saisir des objets de taille relativement importante et peu
coûteuse, ce qui facilite son remplacement en cas de défaillance.

Figure 15 - Poignée de bras

24
 Avec toutes les pièces en aluminium, le servo et la poignée assemblés
manipulateur. A l'origine, le manipulateur a été construit avec 6 servos, mais comme le
servo le plus bas, qui tient le reste de la structure, ne pouvait pas supporter le poids, il a été
décidé d'enlever un servo, responsable de la deuxième courbure supérieure du
manipulateur. Il a également été nécessaire de rallonger les fils des servos et du capteur
afin de les rendre suffisamment longs pour qu'ils puissent se déplacer librement le long de
la trajectoire du manipulateur. Vérification du bon fonctionnement de chaque servo.

Ensuite, il a été décidé de créer une carte séparée qui serait responsable de
l'alimentation commune et de la mise à la terre des servos. Nous avons également ajouté
des broches communes à la carte pour connecter les fils de signal des servos aux broches
d'entrée de la carte du microcontrôleur.

Figure 16 - Carte de connexion

25
 Placez le manipulateur assemblé, la carte de connexion et la carte de
microcontrôleur sur une plaque de carton de verre et regroupez tous les fils des servos en
un seul faisceau commun, en marquant chaque fil avec le numéro de servo correspondant,
afin de ne pas vous embrouiller avec le grand nombre de fils. Nous avons connecté tous les
fils aux connecteurs appropriés. Il a également été décidé d'ajouter un télémètre à ultrasons
à notre dispositif afin de pouvoir l'utiliser dans de futurs projets avec notre stand pour
contrôler la prise du manipulateur. L'assemblage du stand de démonstration est terminé.
Ci-dessous, une photo de l'appareil terminé.

Figure 17 - Support assemblé

26
 3. Partie logicielle

3.1. Description de l'algorithme du dispositif

En résumé, l'algorithme de l'appareil consiste à traiter les données provenant du

microcontrôleur de commande, du clavier, de la souris et des servomoteurs reliés entre eux
par une interface de transfert de données. Les données traitées sont normalisées et
renvoyées aux servomoteurs pour traitement. Les données traitées sont normalisées et
renvoyées aux servomoteurs pour traitement.
Pour une description plus détaillée de l'algorithme du dispositif, il est nécessaire
d'examiner le principe de fonctionnement et la conception de chaque composant associé à
l'interface de données.

Un servo-actionneur est un actionneur qui entraînera notre manipulateur. Un servo-

actionneur ou une servo-machine est un dispositif de rétroaction assez complexe par
rapport à un moteur électrique conventionnel. Il se compose d'un moteur à courant continu,
d'un réducteur, d'une électronique de commande et d'un potentiomètre. Le réducteur est
utilisé pour réduire la vitesse du moteur, ce qui permet de convertir un couple élevé en plus
de
faible en raison de l'interaction entre le pignon plus petit et le petit nombre de dents avec les
dents de l'arbre.
Un pignon plus grand avec un nombre de dents plus élevé. Le circuit électronique est
chargé de maintenir le retour d'information et d'obtenir et de comparer les valeurs
Le servomoteur est équipé de trois sorties : VCC - 5 volts (courant continu), GND - 5 volts
(courant continu), GND - 5 volts (courant continu), GND - 5 volts (courant continu). Le
servomoteur possède trois sorties : VCC - 5 volts (courant continu), GND - 5 volts (courant
continu).
terre, PWM (Pulse Width Modulation)/PWM (Pulse Width Modulation). -
sortie du signal de contrôle.

27
 Figure 18 - Conception du servomoteur

L'une des principales pièces du servomoteur est le potentiomètre, qui comporte trois
broches, dont les deux broches latérales sont alimentées, et entre chaque broche se trouve
une substance résistive qui permet au curseur de se déplacer,
connectée à la broche centrale à partir de laquelle la valeur de la tension est prise.

Figure 19 - Conception du potentiomètre dans le servomoteur

28
 L'arbre du servo est relié à l'arbre du potentiomètre, si nous tournons l'un, l'autre
tourne aussi. Lorsque nous tournons le bouton du potentiomètre dans le sens des aiguilles
d'une montre, du plus au moins, la résistance augmente et la tension diminue.
La tension sera réduite à un minimum, qui dépend de
résistance maximale du potentiomètre dans notre servomoteur, chaque servomoteur peut
avoir une résistance maximale différente pour le potentiomètre, mais la plupart des
modèles utilisent des potentiomètres de 5kOhm. Supposons que nous voulions faire
tourner notre servo de 75 degrés, à cette position la sortie du potentiomètre sera de 2 volts.
À un moment donné, la sortie du potentiomètre sera de 2 volts.
le temps que l'arbre se trouve dans une position de 10 degrés par exemple, ce qui est
conventionnellement égal à 0,3
volts. Pour tourner l'actionneur dans la position souhaitée, nous devons envoyer une
impulsion de commande à la carte de commande, qui contient l'information sur la position
dans laquelle nous voulons tourner l'arbre. Les composants électroniques de la carte de
commande interviennent en comparant la tension relevée sur le potentiomètre à la position
de l'arbre (0,3 volt) avec la valeur requise (2 volts), qui est parvenue à la carte de
commande. Si les lectures ne correspondent pas, le microprocesseur de la carte de contrôle
décide d'envoyer le signal d'alarme à la carte de contrôle.
L'arbre du potentiomètre peut être tourné dans la direction souhaitée jusqu'à ce que la
tension relevée sur le potentiomètre soit égale à la tension requise à 75 degrés. En d'autres
termes, la position
de l'arbre du potentiomètre dépend de la longueur de l'impulsion. Le sens de rotation est
déterminé par la plus courte des deux impulsions. Une partie du circuit de commande
produit un signal dont la durée est réglée par le potentiomètre et l'autre partie produit un
signal dont la durée est réglée par le potentiomètre.
compare les deux impulsions.

29
 Figure 20 - Diagramme des impulsions de commande du servomoteur

La plupart des servos utilisent la même fréquence d'impulsion d e 50 Hz (une

impulsion est envoyée et reçue toutes les 20 millisecondes) et la même largeur d'impulsion
: la limite inférieure de la largeur d'impulsion lorsque le servo est en position 0 degré est
de 544 microsecondes et la limite supérieure de 180 degrés est de 2400 microsecondes.
Connaissant
Grâce aux valeurs limites, nous pouvons définir la durée de l'impulsion pour n'importe
quelle position du servo. La bibliothèque standard Servo.h, qui sera utilisée dans notre
programme, ne contient que les valeurs limites couramment utilisées.
Dans le texte ci-dessus, j'ai mentionné des valeurs numériques externes provenant d'autres
systèmes de contrôle. Les valeurs numériques externes sont les paramètres que nous
pouvons modifier à l'aide de la souris et du clavier, et ces paramètres sont également
modifiés par le capteur à ultrasons. À cette fin, un programme terminal spécial a été écrit
un programme qui effectue des calculs et normalise les paramètres à partir des données
d'entrée
de la souris et du clavier pour une comparaison ultérieure avec les paramètres définis dans
les constantes d'une esquisse écrite séparément sur la plateforme arduino. Nous envoyons
ces valeurs externes aux servomoteurs, qui effectuent les opérations suivantes
que nous avons décrite en détail ci-dessus.

30
 Nous décrirons également brièvement le principe de fonctionnement du télémètre à
ultrasons HC-SR04, dont nous pourrions avoir besoin dans des projets futurs avec notre
appareil. Le télémètre à ultrasons utilise le principe du
l'écholocation, comme chez les chauves-souris. La carte du télémètre comporte deux
transducteurs piézoélectriques, l'un fonctionnant comme émetteur (haut-parleur) et l'autre
comme récepteur (microphone). Quatre broches sont utilisées pour connecter le capteur :
VCC - 5 volts
(DC), GND - terre, Trig - déclenchement (INPUT), Echo - écho (OUTPUT). Interface
La communication fonctionne comme suit : une brève impulsion de 10-15 microsecondes
est générée sur la broche Trig, après quoi un certain nombre de signaux de 40 kilohertz
sont générés à la sortie, qui seront envoyés vers un obstacle au moyen du haut-parleur. En
même temps, une unité logique de haut niveau de 150 microsecondes à 25 microsecondes
est générée sur la sortie Echo.
millisecondes. Dès que l'onde réfléchie par l'obstacle atteint le récepteur, un zéro logique
apparaît sur la sortie Echo. La distance de l'objet est directement proportionnelle à la
largeur du signal Echo. En d'autres termes, connaissant le temps pendant lequel l'unité
logique de haut niveau est présente sur la broche Echo, nous pouvons déterminer
la distance par rapport à un objet, à l'aide d'une formule spéciale.

31
 3.2. Développement de la partie logicielle du dispositif

La plate-forme logicielle de notre appareil comprendra deux parties :

1. Un programme de terminal écrit en C# (C Sharp) dans SharpDevelop 5.1, car

ce langage est idéal pour écrire rapidement des applications de bureau.

2. Programmes pour la carte de contrôle (sketch) écrits dans le programme

Arduino IDE, qui est spécialement conçu pour écrire des programmes pour les cartes
Arduino.

Le programme du terminal s'exécute sur le PC et l'esquisse est chargée sur la carte de

contrôle Arduino Mega.
Le programme pour conseil conseil de surveillance est est
L'algorithme séquentiel illustré ci-dessous.

32
 Figure 21 - Algorithme du programme de la carte de contrôle Examinez les

points principaux du code. Avec le code complet du programme, vous pouvez

voir l'annexe A.

Figure 22 - Fragment du code de programme de la carte de contrôle

Étant donné qu'un grand nombre de données seront impliquées dans la transmission
et la lecture du port série, nous devrions utiliser des tableaux de données. Un tableau de
données est une sorte de zone de mémoire divisée en un certain nombre de cellules
élémentaires, chacune ayant son propre numéro de séquence. Pour accéder à l'information
stockée dans une cellule donnée, il suffit de connaître son numéro. Dans notre cas, nous
avons besoin de deux tableaux de données unidimensionnels.
un tableau de type int. Le type de données int est utilisé pour stocker des données
numériques.
occupe 2 octets de mémoire. Chaque tableau est nommé data et value, et la taille de ces
tableaux est également indiquée. Le tableau de données a une taille de 9 éléments et le
tableau de valeurs a 4 éléments, ce qui indique au compilateur d'allouer 9*2=18 octets
pour les données et 4*2=8 octets pour les valeurs, c'est-à-dire que 2 octets sont alloués
pour chaque élément du tableau.

33
Figure 23 - Fragment du code de programme de la carte de contrôle

34
 Nous avons créé un objet de type Servo. Ce type d'objet a ses propres propriétés, qui
ont déjà été décrites pour nous dans la bibliothèque Servo.h incluse.

Figure 24 - Fragment du code de programme de la carte de contrôle

Nous définissons des constantes, qui seront en lecture seule, c'est-à-dire que nous ne
pouvons pas modifier la valeur des variables. Entre define et const int, nous avons choisi
cette dernière, car pour travailler avec des tableaux, nous devons utiliser const pour
plusieurs raisons principales : le compilateur signalera une erreur, en cas de
Lors de l'utilisation d'une constante d'un type différent, les mêmes règles de portée
s'appliquent aux constantes par opposition à define. Pour chaque servomoteur, 3
constantes sont définies, chacune d'entre elles se voyant attribuer une valeur responsable
de
l'angle de position maximale, minimale et de départ des actionneurs.

35
 Figure 25 - Fragment du code de programme de la carte de contrôle

Connectez chaque servo à l'entrée requise pour être contrôlé.

Figure 26 - Fragment du code de programme de la carte de contrôle

Comparer toutes les valeurs du port série avec les constantes, si toutes les
conditions sont remplies, la valeur correspondante de la valeur est écrite sur le port
correspondant.
Compare la valeur value[3] avec les constantes povorotzahvataMax et
povorotzahvataMin, si les conditions sont remplies, la valeur est écrite dans le port
Povorotzahvata (value[3].

36
 Figure 27 - Fragment du code de programme de la carte de contrôle

Compare data[8] avec 0x01, data[8] avec 0x10 (en référence au registre du
microprocesseur arduino qui stocke un entier) et compare zahvat avec zahvatMax et
zahvatMin, si toutes les conditions sont remplies, les valeurs des variables sont écrites sur
le port Zahvat, en ajoutant un dans le premier cas et en soustrayant un dans le second.

data[8] = 0 efface la valeur du 9ème membre du tableau de données.

Figure 28 - Fragment du code de programme de la carte de contrôle

ReadSerial est la fonction chargée de remplir le tableau de données en

hexadécimal. Activez le processus qui attend que les données apparaissent dans le tableau

37
Série (sur le port série à partir du programme de terminal, le paquet envoyé contient 11
octets). Si les données sont lues, le fragment de code suivant est exécuté. Le premier octet
est toujours 0xFF, le deuxième octet est toujours 0xAA. Ensuite, les 10 membres du
tableau provenant du port série sont remplis un par un.

Figure 29 - Fragment du code de programme de la carte de contrôle

Les valeurs des données sont normalisées : 1) soustraire les valeurs du quatrième
terme de la constante naklonnizhniiNormal, 2) ajouter la constante osnovaNormal à la
différence entre le premier et le deuxième terme, 3) ajouter la constante
naklonverhniiNormal à la différence entre le cinquième et le sixième terme, 4) ajouter la
constante povorotzahvataNormal à la différence entre le septième et le huitième terme.
En résumé, le code peut être décrit comme suit : les valeurs sont lues à partir du port
COM, normalisées et comparées aux constantes.

38
 Programme terminal.

Le code source du programme de terminal est une solution composée de plusieurs

parties. Considérons la partie qui lit les positions de la souris, les états des touches du
clavier et qui envoie ensuite toutes ces valeurs au port série.

Figure 30 - Algorithme du programme terminal

Le code complet du programme se trouve à l'annexe B.

39
 Figure 31 - Fragment du code du programme du terminal

Initialisation des variables int et attribution d'un littéral décimal.

Initialise les variables de type byte et leur attribue un littéral hexadécimal. Bool vérifie que
toutes les conditions logiques sont remplies. Nous avons également marqué les valeurs
maximale et minimale de chaque variable de type int.

Figure 32 - Fragment du code du programme du terminal

40
 Gestionnaire d'événements pour le déplacement du curseur de la souris. Ramène le
curseur au centre du formulaire.

Figure 33 - Fragment du code du programme du terminal

Gestionnaire d'événements pour l'appui sur une touche du clavier.

Figure 34 - Fragment du code du programme du terminal

Gestionnaire d'événements pour le relâchement de la touche du clavier.

41
 Dans le code source du programme de terminal présenté à l'annexe B, il existe un
certain nombre d'autres gestionnaires d'événements en plus de ceux mentionnés ci-dessus :
pression et relâchement des boutons gauche et droit de la souris, pression de la touche
Esc, expansion de la liste des ports disponibles, clic sur le bouton
le bouton "Exit", en appuyant sur le bouton " ?", etc.

Figure 35 - Fragment du code du programme du terminal

Cette méthode convertit le message d'une chaîne à un octet et écrit ensuite le message
reçu sur le port série.

Figure 36 - Fragment de code de programme du terminal

В cette méthode a lieu générer des messages pour écrire

sur le port série.

42
 Figure 37 - Fragment de code de programme du terminal

Cette méthode permet de lire les données du port série.

Figure 38 - Fragment de code de programme du terminal

Cette méthode prépare les messages à écrire sur le port série. La méthode
SendAsHex est appelée pour écrire les messages préparés sur le port série.
La solution assemblée est un programme composé de deux fenêtres.

43
 Figure 39 - Première fenêtre du programme du terminal

La première fenêtre permet de sélectionner le port série actif, de choisir le débit en

bauds et d'appeler l'aide. En appuyant sur le bouton "Run", la deuxième fenêtre apparaît.

Figure 40 - Deuxième fenêtre du programme du terminal

La deuxième fenêtre est directement responsable du contrôle du manipulateur, et

il est également possible d'augmenter la vitesse du manipulateur. La colonne d'état
indique les positions actuelles de chaque actionneur

44
 4. Partie expérimentale

4.1. Instructions pour l'utilisation de l'appareil

1. Inspectez le support avant de l'utiliser pour vérifier qu'il n'est pas endommagé.

2. Branchez le cordon sur l'alimentation électrique.

3. Connectez la carte arduino à l'ordinateur.
4. Chargez le programme sur la carte de contrôle.
5. Exécutez le fichier du programme Manipulator control.exe.
6. Sélectionnez le port série concerné dans la première fenêtre du programme.
7. Cliquez sur le point d'interrogation dans la première fenêtre du programme pour
obtenir de l'aide.
8. Appuyez sur le bouton marche/arrêt du bloc d'alimentation.
9. Appuyez sur le bouton "Run" dans la première fenêtre du programme pour faire
fonctionner le manipulateur.
В apparaît fenêtre a lieu directement La fenêtre
apparaît et vous pouvez contrôler le manipulateur :
1) les mouvements de la souris sur l'axe x modifient la position du Servo
Naklonverhnii, l'axe y modifie la position du Servo Osnova.
2) En appuyant sur Q et E sur le clavier, on modifie la position du servo
Naklonnizhnii
3) les touches Z et X permettent de modifier la position du servo Povorotzahvata
4) les boutons gauche et droit de la souris sont responsables de la position du Servo
Zahvat
5) les boutons + et - permettent d'augmenter la vitesse des servos
10.Pour fermer la fenêtre de contrôle du manipulateur, appuyez sur la touche Esc du
clavier.
11. Pour fermer l'écran de démarrage, appuyez sur le bouton "Quitter".

45
12.Pour mettre fin à l'utilisation de l'appareil, vous devez également appuyer sur le
bouton marche/arrêt du bloc d'alimentation.
13.Une fois les travaux terminés, vérifiez que le support n'est pas endommagé. Si des
dommages sont constatés, il est interdit de continuer à utiliser l'appareil jusqu'à ce
que le défaut ait été corrigé.

46
 4.2. Vérification et débogage de la partie logicielle de l'unité

Vérification et débogage final de la partie logicielle. Lors de l'utilisation du

manipulateur, de petits mouvements saccadés des servomoteurs ont été observés, ce qui a
entraîné une oscillation de l'ensemble de la structure du manipulateur. Cela est dû au fait
que les servomoteurs ne fonctionnent pas avec une précision suffisante et qu'ils ne
réagissent pas aux petits angles de rotation. Dans l'esquisse, nous avons défini les valeurs
les plus stables des positions de départ, minimum et maximum de chaque servomoteur afin
d'éliminer les vibrations des servos et d'obtenir un fonctionnement plus régulier du
manipulateur. Dans le code du programme terminal, les valeurs optimales des variables de
chaque axe de contrôle et de la vitesse de contrôle de chacun des servomoteurs ont
également été trouvées et fixées expérimentalement, ce qui a permis de
contrôler avec autant de précision et de facilité que possible
manipulateur. Pour tester la stabilité du programme du terminal, pendant le
fonctionnement du manipulateur, le port COM actif d'Arduino a été soudainement
déconnecté de l'ordinateur, le manipulateur est resté dans la même position et n'a effectué
aucune action de son propre chef.

47
 5. Dispositif sûr et respectueux de l'environnement

Lors de l'assemblage et du fonctionnement de l'appareil étudié, divers équipements

ont été utilisés, au cours desquels certaines règles de sécurité doivent être respectées afin
d'éviter les situations d'urgence telles que les courts-circuits et, par conséquent, les
incendies : un contrôle complet de l'équipement de l'appareil a été effectué.
l'état des outils avant leur utilisation, en particulier l'état électrique
Si les câbles d'alimentation sont défectueux, n'utilisez pas l'appareil tant que le défaut n'a
pas été corrigé.

Lors de l'utilisation d'appareils électriques destinés à percer des trous et à découper

le matériel utilisé pour assembler l'appareil, il convient de surveiller attentivement l'état
des consommables (forets, disques, e t c . ) et de porter des équipements de protection
pour éviter les risques de blessures.
(lunettes ou masque de protection, gants et vêtements ajustés). Au
Si un défaut est détecté pendant l'utilisation, l'outil doit être débranché immédiatement.
Lors de l'utilisation du matériel de soudure, des mesures de sécurité doivent également être
respectées : ne pas toucher la panne du fer à souder, ne pas le laisser sans surveillance, le
tenir à l'écart des matériaux inflammables et utiliser un respirateur pour protéger les voies
respiratoires des fumées nocives. Le respirateur doit être remplacé après la date de
péremption indiquée dans les réglementations ou
lorsque les performances du respirateur sont considérablement réduites. À l'heure actuelle
Si le flux entre en contact avec la peau exposée, la zone affectée doit être soigneusement
rincée à l'eau. Si vous vous êtes brûlé en utilisant le fer à souder, consultez immédiatement
un médecin. Pour éviter les situations d'urgence, il convient également d'effectuer un
briefing sur la sécurité incendie avant d'utiliser l'appareil.
La pièce où l'appareil est monté et utilisé doit répondre à toutes les exigences de
SanPiN en matière de microclimat : température,

48
la ventilation, les niveaux d'humidité doivent être maintenus dans des limites acceptables.
Un bon éclairage répondant aux exigences du SNiP est particulièrement nécessaire pour

prévenir la fatigue et les blessures qui en résultent. Niveaux de bruit

et les vibrations de l'appareil conçu répond à toutes les normes et n'est en aucun cas une source
d'inquiétude.
affecte l'être humain. Notre projet utilise un ordinateur personnel pour contrôler le
manipulateur, d'où la présence d'un facteur nuisible tel que le rayonnement
électromagnétique, qui affecte négativement l'attention, la mémoire et la vision.

La conception du poste de travail doit permettre d'adopter une position confortable

lorsque l'on travaille avec le support, afin d'éviter la fatigue musculaire et le
développement de troubles musculo-squelettiques. Le moniteur doit être placé sur le lieu
de travail
devant les yeux de l'utilisateur entre 500 mm et 700 mm. Clavier et souris
doit être placé sur le plan de travail à une distance d'environ 200 mm du bord de la surface.
de la surface.

49
 6. Volet économique

Une estimation du coût des composants utilisés pour assembler ce projet est présentée
ci-dessous.

Figure 41- Tableau des coûts des composants

50
 Conclusion

Lors de la mise en œuvre du travail de qualification finale, une étude de toutes les
solutions existantes liées au thème de notre projet a été réalisée. Après avoir analysé tous les
avantages et inconvénients de chaque solution,
les options les plus prometteuses pour nous ont été sélectionnées. Sur la base des choix
effectués
La conception du banc d'essai a ensuite été développée et l'ensemble du processus
d'assemblage a été décrit. Ensuite, un schéma de la conception du banc a été élaboré et
l'ensemble du processus d'assemblage a été décrit. Le principe de fonctionnement de tous les
principaux composants impliqués dans l'appareil en question a été montré. Créé
le programme du terminal pour contrôler le manipulateur et le programme de la carte complète
Le code de base de ces programmes est décrit. Le code développé a été testé sur le modèle de
manipulateur construit et affiné par la suite. Un manuel détaillé pour le fonctionnement de la
cabine développée a été rédigé. Une évaluation de la sécurité et de l'environnement a
également été réalisée. Une estimation a été faite pour tous les composants impliqués dans
l'assemblage de l'appareil. Le travail de qualification final a permis d'obtenir de bons résultats
en ce qui concerne le contrôle du manipulateur. Le principal avantage est que le programme
développé peut être appliqué à d'autres dispositifs avec différentes variations dans la
conception et les composants utilisés. Toutefois, il convient de noter que le
des mouvements saccadés de la structure de la rampe, ceci est dû à la nature de la rampe.
des servomoteurs sélectionnés. Le manipulateur développé peut être utilisé efficacement
comme banc de démonstration pour étudier la cinématique, la dynamique et la
programmation des robots.

51
 Liste des sources utilisées

1. Principes fondamentaux du développement et de la programmation des systèmes

robotiques : tutoriel / Sorokin S.V., Soldatenko I.S. - Tver : Université d'État de Tver, 2017.
- 157 с.
2. Glibin E.S. Programming of electronic devices : electronic textbook / Glibin
E.S., Pryadilov A.V. - Togliatti : Publishing house of TSU, 2014.
3. Robots intégraux : une collection d'articles / G.E. Pozdniak - Moscou : Mir, 1973.
213 с. -

4. Robots industriels. Cinématique, dynamique, contrôle et gestion.

Engineering Library Series / Bulgakov A.G., Vorobyov V.A. - M. : SOLON-PRESS, 2008.
- 488 p. : ill.
5. Modélisation, planification des trajectoires et contrôle des mouvements des
robots-manipulateurs / Paul R. М. : Nauka, 1976. - 104 с.
6. Programmation des cartes Arduino micronotroller / Sommer W. - St.
Petersburg : BHW-Peterburg, 2012. - 256с.
7. Manuel C Sharp 6.0. Description complète de la langue, 6e éd. / Albahari D.,
Albahari B. - trad. de l'anglais - M. : I.D. Williams LLC, 2016 - 1040s.

8. Evstifeev A. V. AVR microcontrôleurs de la famille Mega. Manuel de

l'utilisateur. - Moscou, maison d'édition Dodeka-XXI, 2007. - 592 с.

9. Shpak Ю. А. Programmation en langage С pour AVR и

PIC. - Moscou : Dodeca-XXI, MK-Press, 2007.

10. Leçons de robotique. Conception, mouvement et contrôle. / Filippov S. A. - M. :

Laboratoire des connaissances, 2017. - 176 с.

11. Boutique en ligne de composants électroniques "Impulse". [Ressource

électronique]. Mode d'accès : https://www.impulsi.ru (04.06.2018).

52
 12. Manuel langage de programmation langage de programmation Arduino
[Ressource électronique]. Mode d'accès : http://arduino.ru/Reference

13. Manuel par C# [Ressource électronique]. Mode

accès : https://docs.microsoft.com/ru-ru/dotnet/csharp/language-reference

14. Guide de l'utilisateur HC-SR04 [Ressource électronique] : documentation. -

Mode d'accès : http://www.mpja.com/download/hc-sr04_ultra.modguide.pdf

15. MG996R Servo [Ressource électronique] : documentation. - Mode d'accès :

http://www.electronicoscaldas.com/datasheet/MG996R_Tower -Pro.pdf

16. Fiche technique Arduino Mega 2560 [Ressource électronique] : documentation.

-Mode d'accès : http://microelectronicos.com/datasheets/arduinomega2560.pdf

17. Comment domicile bureau manipulateur peut

aider в DIY [Electronic resource] : article. Mode d'accès :
https://geektimes.com/post/284962

18. Robotic Arm Inverse Kinematics on Arduino [Electronic resource] : forum.

Mode d'accès : https://www.circuitsathome.com/mcu/robotic-arm-inverse-kinematics-on-
arduino

19. Manipulateurs de bras [Ressource électronique]. https://www.ufactory.cc/#/en

20. Travailler avec le port série Arduino [Ressource électronique] : article. Mode
d'accès : http://www.customelectronics.ru/arduino-rabota-s-com-portom

21. Elias Eliot, Tihomir Latinovic, Dayal R. Parchi, J. Srinivas. Design,

Analysis and Fabrication of an Articulated Mobile Manipulator // Department of
Industrial Design National Institute of Technology, Rourkela Odisha, India, 2013.
URL : https://www.researchgate.net/publication/275770788

22. Paula Useche Murillo , Robinson Jimenez Moreno, Oscar F Avilés S. Individual
Robotic Arms Manipulator Control Employing Electromyographic Signals Acquired by Myo
Armbands // International Journal of Applied Engineering Research Volume 11, Number 23,

53
2016. URL : https://www.researchgate.net/publication/314079352

54
 23. Pieter Dijkshoorn. Concevoir a générique générique générique
pour les manipulateurs ARW manipulators // Université de Twente,
Enschede, Pays-Bas, novembre 2016. URL :
https://www.ram.ewi.utwente.nl/calendar/details/designing -a-generic-software-architecture-
for-arw-manipulators.html

24. Mohd Ashiq Kamaril Yusoffa, Reza Ezuan Saminb , Babul Salam Kader
Ibrahimc. Wireless Mobile Robotic Arm // Faculty of Electrical and Electronics Engineering,
Universiti Tun Hussein Onn Malaysia, Batu Pahat, Johor, Malaysia, 2012. URL :
https://www.researchgate.net/publication/271890997

25. Mohd Aliffa, Shujiro Dohtaa , Tetsuya Akagia, Hui Lia . Développement
d'un bras robotique pneumatique à structure simple et son contrôle à l'aide d'un contrôleur
embarqué à faible coût // Université des sciences d'Okayama 1 -1 Ridai-cho, Kita-Ku,
Okayama, Japon, 2012. URL : https://www.sciencedirect.com/science/artic
le/pii/S1877705812025398

55
 Annexe A

#include <Servo.h>

void readSerial(void) ;
void dataToNormal(void) ;

int data[9]
; int
value[4] ;

Servo Osnova ;
Servo Naklonnizhnii ;
Servo Naklonverhnii
; Servo
Povorotzahvata ;
Servo Zahvat ;

const int osnovaMin = 4 ;

const int osnovaMax = 175 ;
const int osnovaNormal = 80 ;

const int naklonnizhniiMin = 0 ;

const int naklonnizhniiMax = 180 ;
const int naklonnizhniiNormal = 90 ;

const int naklonverhniiMin = 0 ;

const int naklonverhniiMax = 180 ;
const int naklonverhniiNormal = 60 ;

const int povorotzahvataMin = 0 ;

const int povorotzahvataMax = 175
; const int povorotzahvataNormal = 90
;

const int zahvatMin = 25 ;

const int zahvatMax = 130
; const int zahvatNormal =
25 ;

56
int zahvat = zahvatNormal ;

void setup(){

57
 Osnova.attach(2) ;
Naklonnizhnii.attach(3)
;
Naklonverhnii.attach(4)
;
Povorotzahvata.attach(5)
; Zahvat.attach(6) ;

Zahvat.write(zahvatNormal) ;
Serial.begin(9600) ;
}

void loop(){
readSerial() ;
dataToNormal() ;

if ( (value[0] <= naklonverhniiMax) & (value[0] >= naklonverhniiMin) ){

Naklonverhnii.write(value[0])
}

if ( (value[1] <= osnovaMax) & (value[1] >= osnovaMin)

){ Osnova.write(value[1])
}

if ( (value[2] <= naklonnizhniiMax) & (value[2] >= naklonnizhniiMin) ){

Naklonnizhnii.write(value[2])
}

if ( (value[3] <= povorotzahvataMax) & (value[3] >= povorotzahvataMin) ){

Povorotzahvata.write(value[3])
}

if ( (data[8] == 0x01) & (zahvat <= zahvatMax) )

{ Zahvat.write(zahvat++) ;
données[8] = 0 ;
}

if ( (data[8] == 0x10) & (zahvat >= zahvatMin)

){ Zahvat.write(zahvat--)
données[8] = 0 ;
}

58
}

59
void readSerial(){
if (Serial.available() == 11)
if (Serial.read() == 0xFF)
if (Serial.read() == 0xAA){
data[0] = Serial.read() ;
data[1] = Serial.read() ;
data[2] = Serial.read() ;
data[3] = Serial.read() ;
data[4] = Serial.read() ;
data[5] = Serial.read() ;
data[6] = Serial.read() ;
data[7] = Serial.read() ;
data[8] = Serial.read() ;

data[9] = Serial.read() ;
}
}

void dataToNormal(){

// naklonnizhnii
value[0] = naklonnizhniiNormal - data[3] ;

//osnova
valeur[1] = données[0] - données[1] + osnovaNormal ;

//naklonverhnii
value[2] = data[4] - data[5] + naklonverhniiNormal ;

//povorotzahvata
value[3] = data[6] - data[7] + povorotzahvataNormal ;
}

60
 Annexe B

Formulaire 1

en utilisant System ;
using
System.Collections.Generic ;
using System.ComponentModel
; using System.Data ;
using System.Drawing ;
using System.Text ;
using System.Windows.Forms ;
using System.IO.Ports ;

namespace MouseControl
{
public partial class Form1 : Form
{
bool IsReceiving = false ; // Créer une variable de type logique

public Form1 ()
{
InitializeComponent() ; // Appelle la méthode responsable de l'affichage du formulaire
}

private void SendAsHex(string) // Cette méthode convertit le message de String en Byte et

écrit ensuite le message reçu sur SerialPort.
{
int Len = str.Length ;
byte[] send = new byte[Len / 2] ;
int j = 0 ;
for (int i = 0 ; i < Len ; i = i + 2 , j++)
send[j] = Convert.ToByte(str.Substring(i, 2), 16) ;
serialPort1 .Write(send, 0, send.Length) ;
}

private string DelSpace(string str) // Cette méthode supprime les espaces du message.
La variable TempStr comporte toujours un nombre pair de caractères.
{
string TempStr = string.Empty ;
int Len = str.Length ;
for (int i = 0 ; i < Len ; i++)
{
if (str[i] != ' ')
TempStr += str[i] ;
}
Len = TempStr.Length ;
si (Len % 2 != 0)
TempStr = '0' + TempStr ;
return TempStr ;

61
}

62
 private void ReOpenPort() // Méthode de réouverture du port série
{
essayer
{
btClose_Click(null, null) ;
if (!serialPort1 .IsOpen)
btOpen_Click(null, null) ;
}
catch (Exception Err)
{
controlPanel .Close() ;
MessageBox.Show(Err.Message, "Contrôle du manipulateur") ;
}
}

private void Form1_Load (object sender, EventArgs e) // Cette méthode permet de récupérer les
noms de tous les ports maritimes disponibles.
{
essayer
{
foreach (string com in System.IO.Ports. SerialPort .GetPortNames())
this.cmPort.Items.Add(com) ;
cmPort.SelectedIndex = 0 ;
}
attraper
{
controlPanel .Close() ;
MessageBox.Show("No serial port found !", "Manipulator control") ;
}
}

private void OpenPort() // Cette méthode configure et ouvre le port

{
serialPort1 .WriteTimeout = 1000 ; //Temps d'écriture Set write timeout)
serialPort 1.ReadTimeout = 1000 ; //Read timeout, same there. Définir le délai de lecture) serialPort1
.NewLine = "\r\n" ; serialPort1.DataReceived += new
System.IO.Ports.SerialDataReceivedEventHandler( this.sComm_DataReceived) ;
serialPort1 .PortName = cmPort.Text ;
serialPort1 .BaudRate = int.Parse(cmBaudRate.Text) ;
serialPort1 .DataBits = 8 ;
serialPort1 .Parity = ( Parity)Enum.Parse(typeof(Parity), "None") ;
serialPort1 .StopBits = ( StopBits)Enum.Parse(typeof(StopBits), "1") ;
serialPort1 .Open() ;
}

private void ClosePort() // Cette méthode efface le port et le ferme ensuite.

{

serialPort1 .DataReceived -= this.sComm_DataReceived ; while (IsReceiving)

Application.DoEvents() ; /Traitement de la réception séquentielle des messages du système et
d'autres événements.

63
 serialPort1 .Close() ;

public static Form2 controlPanel = null ; // Créer une instance de la classe Form2

private void btOpen_Click(object sender, EventArgs e) // Gestionnaire d'événements pour le bouton

"Lancer".
{
essayer
{
OpenPort() ; // Appel de la méthode pour ouvrir le port

//Modifier la configuration du premier formulaire et créer et activer le second formulaire

if (serialPort1 .IsOpen)
{
btClose.Enabled = true ;
btOpen.Enabled = false ;
cmPort.Enabled = false ;
cmBaudRate.Enabled = false ;

si (controlPanel == null)
{
controlPanel = new Form2 (this) ;
controlPanel .Show() ;
}
autre
{
controlPanel .Activate() ;
}
}
}
catch (Exception er)
{
ClosePort() ;
MessageBox.Show("Failed to open port !" + er.Message, "Manipulator control") ;
}
}

private void cmPort_MouseDown(object sender, MouseEventArgs e) // Traite l'événement de dépliage de

la liste des ports disponibles
{
essayer
{
cmPort.Items.Clear() ;
foreach (string com in System.IO.Ports. SerialPort .GetPortNames())
this.cmPort.Items.Add(com) ;
}
attraper
{
controlPanel .Form2Closing() ;
MessageBox.Show("No serial port found !", "Manipulator control") ;

64
 }
}

// Unité de création de variables

int stateMachine = 0 ;
int t = 0 ;
public static byte rxBuf ;
public static int rxData ;
public static byte rxAdd ;
byte[] dataBuf = new byte[3] ;
// Fin du bloc de création de variables

private void sComm_DataReceived(object sender, SerialDataReceivedEventArgs e) // (Cette méthode

lit les données du port série)
{
essayer
{
rxBuf = ( byte)serialPort1 .ReadByte() ;
si (stateMachine == 0)
{
if (rxBuf == 0xff) stateMachine = 1 ;
else stateMachine = 0 ;
}
else if (stateMachine == 1)
{
if (rxBuf == 0xaa) stateMachine = 2 ;
else stateMachine = 0 ;
}
else if (stateMachine == 2)
{
dataBuf[t++] = rxBuf ;
if (t > 2) //reçoit 3 octets de données
{
rxAdd = dataBuf[0] ;
rxData = ( dataBuf[2] + ( dataBuf[1] << 8)) - 32768; //
controlPanel .set_data() ;
stateMachine = 0 ;
t=0;
}
}
}
catch (Exception Err)
{
controlPanel .Form2Closing() ;
MessageBox.Show(Err.Message, "Contrôle du manipulateur") ;
}
}

public void sendData(string input) // Cette méthode prépare les messages à écrire sur le port série.
{
essayer
{

65
 if (!serialPort1 .IsOpen)
btOpen_Click(null, null) ;

string TempStr = string.Empty ;

TempStr = input ;
TempStr = DelSpace(TempStr) ;
SendAsHex(TempStr) ; // Appeler la méthode SendAsHex pour écrire des messages préparés sur le
port série.
}
catch (Exception err)
{
controlPanel .Form2Closing() ;
MessageBox.Show(err.Message, "Contrôle du manipulateur") ;
}
}

public void btClose_Click(object sender, EventArgs e) // Gestionnaire d'événements pour le bouton

"Fermer le port".
{
ClosePort() ;
if (!serialPort1 .IsOpen)
{
btOpen.Enabled = true ;
btClose.Enabled = false ;
cmPort.Enabled = true ;
cmBaudRate.Enabled = true ;
}
}

private void exit_Click(object sender, EventArgs e) // Gestionnaire d'événements du bouton de sortie

{
btClose_Click(null, null) ;
this.Close() ;
}

private void logo_Click(object sender, EventArgs e) // Gestionnaire d'événements permettant

d'appuyer sur l'icône du programme dans le formulaire.
{
System.Diagnostics. Process.Start(") ;
}

private void button1_Click(object sender, EventArgs e) // gestionnaire de l'événement bouton

"
?" {
MessageBox.Show(
"Instructions de gestion：" + Environment.NewLine + " " +
Environment.NewLine +
"1. " + "Inclinaison du toit : W & S" + Environment.NewLine +
" + Environment.NewLine +
"2. " + "Pente inférieure : E & Q" + Environment.NewLine + "
+ Environment.NewLine +
"3. " + "Base : D & A" + Environment.NewLine +

66
 " + Environment.NewLine +
"4. " + "Rotation de la poignée : Z & X" +
Environment.NewLine + " " + Environment.NewLine +
"5. " + "Grip : LCM & PCM" + Environment.NewLine + "") ;
}

private void comPort_Click(object sender, EventArgs e)

{

}
}
}

Formulaire 2
en utilisant System ;
using
System.Collections.Generic ;
using System.ComponentModel
; using System.Data ;
using System.Drawing ;
using System.Linq ;
using System.Text ;
using System.Windows.Forms ;

namespace MouseControl
{
public partial class Form2 : Form
{
int xCount = 0 ; // initialiser la variable de type int et lui affecter un littéral décimal.
int yCount = 0
; int zCount = 0
; int rCount = 0
;
int xCount_lst = 0 ;
int yCount_lst = 0
; int zCount_lst = 0
; int rCount_lst = 0
; int speed = 44 ;
int centre = 100 ;
yte buttonData = 0x00 ; // initialiser la variable byte et lui
assigner un littéral hexadécimal //H->L 4:Xbutton2(+) 3:Xbutton1( -) 2:Droite 1:Milieu 0:Gauche
octet keyData = 0x00 ; // H->L 5 :- 4:+ 3:D 2:A 1:S 0:W
octet buttonData_lst = 0x00 ;
bool release_flag = true ; // vérifie les conditions logiques

int xCountMax = 110; // valeur maximale de la variable int

xCountMin = -110; // valeur minimale de la variable int
yCountMax = 90 ;
int yCountMin = -10 ;
int zCountMax = 60 ;
int zCountMin = -100 ;
int rCountMax = 110 ;

67
int rCountMin = -110 ;

68
 public Form1 parent ;
public Form2 (Form1 parent) // Constructeur pour initialiser les composants du formulaire et créer des
gestionnaires d'événements
{
InitializeComponent() ;
this.parent = parent ;
this.MouseMove += new System.Windows.Forms.MouseEventHandler( Form2_MouseMove )
; this.MouseDown += new System.Windows.Forms.MouseEventHandler( Form2_MouseDown)
; this.MouseUp += new System.Windows.Forms.MouseEventHandler( Form2_MouseUp) ;
this.KeyDown += new System.Windows.Forms.KeyEventHandler( Form2_KeyDown) ;
this.KeyUp += new System.Windows.Forms.KeyEventHandler( Form2_KeyUp ) ;
}

private void Form2_MouseMove (object sender, MouseEventArgs e) // Gestionnaire d'événements

pour le déplacement du curseur. Ramène le curseur au centre du formulaire.
{
int min = centre - (45-speed) ;
int max = centre + ( 45-speed) ;
int x = Cursor .Position.X - this.Left - 3 ;
int y = Cursor .Position.Y - this.Top - 23 ;
if (x < min || x > max || y < min || y >
max)
{
Cursor .Position = new System.Drawing. Point(this.Left + centre + 3, this.Top + centre + 23) ;
}

si (x < min) xCount-- ;

si (x > max) xCount++
; si (y < min) yCount++
; si (y > max) yCount--
;

private void Form2_MouseDown(object sender, MouseEventArgs e) // Gestionnaire d'événements pour

le bouton de la souris
{

if (e.Button == MouseButtons.Left)
{
buttonData &= 0xfd ;

buttonData |= 0x01 ;
}
if (e.Button == MouseButtons.Left && e.Clicks == 2)
{
buttonData &= 0xfe ;
buttonData |= 0x02 ;
}
if (e.Button == MouseButtons.Middle)
{
buttonData |= 0x04 ;
}

69
if (e.Button == MouseButtons.Middle && e.Clic ks == 2)
{

70
 buttonData |= 0x08 ;
}
if(e.Button == MouseButtons.Right)
{
buttonData |= 0x10
; r_label.Text = "*" ;
}
if (e.Button == MouseButtons.Right && e.Clicks == 2)
{
buttonData |= 0x20 ;
}
if (e.Button == MouseButtons.XButton1)
{
speed = --speed < 1 ? 1 : speed ;
label11.Text = Convert.ToString(speed)
;
}
if (e.Button == MouseButtons.XButton2)
{
speed = ++ speed > 50 ? 50 : speed ;
label11.Text = Convert.ToString(speed)
;
}
}

private void Form2_MouseUp(object sender, MouseEventArgs e) // Gestionnaire de l'événement de

relâchement du bouton de la souris
{
if (e.Button == MouseButtons.Left)
{
buttonData &= 0xfc ;
}
if (e.Button == MouseButtons.Middle)
{
buttonData &= 0xf3 ;

}
if (e.Button == MouseButtons.Right)
{
buttonData &= 0xcf ;
r_label.Text = " " ;

}
}
private void Form2_Load(object sender, EventArgs e) // Positionner le curseur à l'endroit souhaité sur
le formulaire
{
Cursor .Clip = new Rectangle(this.Location.X + 33, this.Location.Y + 53, 130, 130) ;
}

private void exit_bt_Click(object sender, EventArgs e) // (gestionnaire d'événement du bouton

Esc)
{

71
Form1.controlPanel = null ;
Cursor .Clip = Rectangle.Empty ;

72
 this.parent.btClose_Click(null, null) ;
this.Close() ;
}

public void set_data()

{
switch (Form1.rxAdd)
{
case 0x01 : xCountMax = Form1.rxData ; break
; case 0x02 : xCountMin = Form1.rxData ;
break ; case 0x03 : yCountMax = Form1.rxData
; break ; case 0x04 : yCountMin =
Form1.rxData ; break ; case 0x11 : xCount =
Form1.rxData ; break ; case 0x12 : yCount =
Form1.rxData ; break ; default : break ;
}
}

private void sendData() // Cette méthode génère des messages à écrire sur le port série.
{
this.parent.sendData("ff") ;
this.parent.sendData("aa") ;
this.parent.sendData((((xCount >> 8) & 0x00FF ).ToString("x")) ;
this.parent.sendData((xCount & 0x00FF ).ToString("x")) ;
this.parent.sendData((((yCount >> 8) & 0x00FF ).ToString("x")) ;
this.parent.sendData((yCount & 0x00FF ).ToString("x")) ;
this.parent.sendData((((zCount >> 8) & 0x00FF ).ToString("x")) ;
this.parent.sendData((zCount & 0x00FF ).ToString("x")) ;
this.parent.sendData(((rCount >> 8) & 0x00FF ).ToString("x"))
; this.parent.sendData((rCount & 0x00FF ).ToString("x")) ;
this.parent.sendData(buttonData.ToString("x") ;
}

private void timer1_Tick (object sender, EventArgs e) // Gestionnaire d'événements de la minuterie

{
essayer
{
if (xCount_lst != xCount || yCount_lst != yCount || zCount_lst != zCount || rCount_lst != rCount
|| ( buttonData & 0xff) != 0x00)
{
xCount = xCount < xCountMin ? xCountMin : xCount ;
xCount = xCount > xCountMax ? xCountMax : xCount ;
yCount = yCount < yCountMin ? yCountMin : yCount ;
yCount = yCount > yCountMax ? yCountMax : yCount ;
zCount = zCount < zCountMin ? zCountMin : zCount ;
zCount = zCount > zCountMax ? zCountMax : zCount ;
rCount = rCount < rCountMin ? rCountMin : rCount ;
rCount = rCount > rCountMax ? rCountMax : rCount ;

label4.Text = Convert.ToString(xCount)
; label5.Text =
Convert.ToString(yCount) ; label1.Text
= Convert.ToString(zCount) ;

73
 label20.Text = Convert.ToString(rCount) ;
sendData() ;

xCount_lst = xCount ;
yCount_lst = yCount ;
zCount_lst = zCount ;
rCount_lst = rCount ;
buttonData_lst = buttonData ;
}
}
catch (Exception Err)
{
MessageBox.Show("Timing errors !" + Err.Message, "MouseControl" ) ;
timer1.Enabled = false ;
Form2Closing() ;
}
}

private void Form2_KeyDown(object sender, KeyEventArgs e) // Gestionnaire d'événements de pression

de touches
{
switch (e.KeyData)
{
cas Keys.Oemplus :
speed = ++ speed > 50 ? 50 : speed ;
label11.Text = Convert.ToString(speed)
;
break ; // Augmenter la réduction de la vitesse
case Keys.OemMinus :
speed = --speed < 1 ? 1 : speed ;
label11.Text = Convert.ToString(speed)
; break ;
cas Keys.W : // up Naklonverhnii
keyData |= 0x01 ;
yCount += 1 ;
break ;
cas Keys.S : // vers le bas Naklonverhnii
keyData |= 0x02 ;
yCount -= 1 ;
break ;
cas Keys.D : // droite Osnova
keyData |= 0x08 ;
xCount += 1 ;
break ;
cas Keys.A : // gauche Osnova
keyData |= 0x04 ;
xCount -= 1 ;
break ;
cas Keys.Q : // down Naklonnizhnii
buttonData &= 0x7f
; buttonData |=
0x40 ; zCount -= 1 ;
pause ;

74
cas Keys.E : // haut Naklonnizhnii

75
 buttonData &= 0xbf
; buttonData |=
0x80 ; zCount += 1 ;
pause ;

case Keys.Z : // gauche Povorotzahvata

buttonData &= 0x7f
; buttonData |=
0x50 ; rCount -= 1 ;
pause ;
case Keys.X : // droite Povorotzahvata
buttonData &= 0xbf
; buttonData |=
0x90 ; rCount += 1 ;
pause ;

}
}

private void Form2_KeyUp(object sender, KeyEventArgs e) //

Gestionnaire de l'événement de relâchement des touches
{

if (e.KeyData == Keys.Z || e.KeyData == Keys.X)

{
buttonData &= 0x3f ;
// label1.Text = " None " ;
}
if (e.KeyData == Keys.Q || e.KeyData == Keys.E)
{
buttonData &= 0x2f ;
//label1 .Text = "None" ;
//r_label .Text = "F" ;
}

si (e.KeyData == Keys.W)
{
keyData &= 0xfe ;
}
si (e.KeyData == Keys.S)
{
keyData &= 0xfd ;
}
si (e.KeyData == Keys.D)
{
keyData &= 0xf7 ;
}
si (e.KeyData == Keys.A)
{
keyData &= 0xfb ;
}
}

76
 private void Form2_FormClosing (object sender, FormClosingEventArgs
e) // Méthode privée pour fermer le formulaire
{
timer1.Enabled = false ;
Form1.controlPanel = null ;
Cursor .Clip = Rectangle.Empty ;
this.parent.btClose_Click(null, null) ;
}

public void Form2Closing() // Méthode publique pour fermer le formulaire

{
timer1.Enabled = false ;
Form1.controlPanel = null ;
Cursor .Clip = Rectangle.Empty ;
this.parent.btClose_Click(null, null) ;
this.Close() ;
}

private void label1_Click (object sender, EventArgs e)

{

private void label20_Click(object sender, EventArgs e)

{

private void groupBox1_Enter (object sender, EventArgs e)

{

}
}
}

77
78