La robotique est une nouvelle direction intéressante qui, apparemment, se développera davantage dans le cadre de cours scolaires informatique et technologie. L’essor de la robotique est en grande partie dû au fait qu’elle permet de répondre à la question : « Pourquoi apprend-on réellement la programmation ? » De plus, au cours de robotique, vous pourrez vous familiariser avec les concepts élémentaires de la théorie..

contrôle automatique

Cette page présente les simulateurs de programmation et les cartes Arduino développés par l'auteur. Ils peuvent être utiles dans les cas où, pour une raison quelconque, il n'est pas possible d'utiliser du matériel réel. Les simulateurs utilisent des fonctionnalités HTML5, ils ne fonctionneront donc que dans navigateurs modernes(il est préférable d'utiliser Google Chrome).

ou Mozilla Firefox

Nouvelles
maintenant également sur la chaîne Telegram 27 novembre 2015 La piste « embryon » a été ajoutée aux simulateurs (

M.V. Lazarev
, Orekhovo-Zuevo).
De nouveaux simulateurs ont été ajoutés - des robots LEGO avec deux, trois, quatre capteurs de lumière.

Langage de contrôle des robots

Pour contrôler les robots dans les simulateurs, un langage de programmation simple est utilisé, qui a reçu le nom de travail SiRoP (Programmation simple des robots).

Commande de robot avec capteur de lumière

Le capteur de lumière permet au robot de naviguer sur la surface de la table, par exemple, de se déplacer le long de la frontière entre les zones blanches et noires (le long du bord de la ligne noire). Une photodiode éclaire la surface, un photodétecteur « capte » les rayons réfléchis et mesure leur intensité.

La tâche la plus populaire de ce type consiste à se déplacer le long d'une ligne. À l'aide du simulateur, vous pouvez étudier diverses lois de contrôle : contrôle relais, proportionnel et même contrôle PID (proportionnel-intégral-dérivé).

Exemples de programmes pour un robot avec capteur de lumière

Tant que 1 (si capteur > 128 (moteur = 100 moteur = 0) sinon (moteur = 0 moteur = 100) attendre(10))

KP = 0,2 tandis que 1 ( u = kP*(capteur-128) moteur = 50 + u moteur = 50 - u attendez (20) )

Principal ( while 1 ( while capteur > 128 ( moteur = 100 moteur = 100 attendre (10) ) retour() tour() ) ) arrière ( moteur = -100 moteur = -100 attendre (260) ) tour ( moteur = -50 moteur = 50 attendre (50) )

Contrôle du robot avec deux capteurs de lumière

Deux capteurs de lumière permettent au robot de mieux naviguer et de rouler le long d'une ligne fine. Ils sont un peu avancés et s'étalent sur les côtés. Comme pour les problèmes mono-capteur, ce simulateur peut être utilisé pour étudier diverses lois de commande.

Exemples de programmes pour un robot avec trois capteurs de lumière

Commande de robot avec quatre capteurs de lumière

Quatre capteurs de lumière permettent au robot de mieux détecter les virages serrés. Des capteurs internes sont utilisés pour un réglage précis ; un contrôle proportionnel est utilisé pour eux. Deux capteur externe porté légèrement vers l’avant et étalé sur les côtés. Ils sont utilisés lorsqu'un virage serré est rencontré. Le gain pour le contrôle basé sur les lectures des capteurs de la paire externe est sélectionné supérieur à celui de la paire interne (voir. L. Yu. Ovsyanitskaya et al., Algorithmes et programmes pour le déplacement du robot Lego Mindstorms EV3 le long de la ligne, M. : « Pero », 2015).

Exemples de programmes pour un robot avec quatre capteurs de lumière

Tandis que 1 ( d0 = capteur > 128 d1 = capteur > 128 d2 = capteur > 128 d3 = capteur > 128 si d1 & !d2 ( moteur = 100 moteur = 0 ) si ! d1 & d2 ( moteur = 0 moteur = 100 ) si d1 == d2 ( moteur = 100 moteur = 100 ) si d0 & !d3 ( moteur = 30 moteur = 0 ) si!d0 & d3 ( moteur = 0 moteur = 30 ) attendre (10) )

K1 = 0,2 k2 = 0,4 tandis que 1 ( u1 = capteur - capteur u2 = capteur - capteur moteur = 50+k1*u1+k2*u2 moteur = 50-k1*u1-k2*u2 wait(10) )

Piloter un robot avec un capteur de distance (sonar)

Le capteur de distance (sonar) permet de déterminer la distance jusqu'à l'obstacle le plus proche pendant que le robot est en mouvement. Il émet un signal ultrasonique et reçoit le signal réfléchi. Plus le temps entre les signaux émis et reçus est long, plus la distance est grande.

À l’aide d’un capteur de distance, le robot peut être programmé pour naviguer automatiquement dans un labyrinthe de forme connue mais de taille inconnue.

Ce problème est classique, idéologiquement simple, il peut être résolu plusieurs fois, et à chaque fois vous découvrirez quelque chose de nouveau par vous-même.

Il existe de nombreuses approches pour résoudre le problème du suivi de ligne. Le choix de l'un d'entre eux dépend de la conception spécifique du robot, du nombre de capteurs, de leur emplacement par rapport aux roues et entre eux.

Dans notre exemple, trois exemples de robot seront analysés sur la base du modèle pédagogique principal de Robot Educator.

Pour commencer, nous assemblons le modèle de base du robot éducatif Robot Educator, pour cela vous pouvez utiliser les instructions dans logiciel TEMPÊTES D'ESPRIT EV3.

De plus, par exemple, nous aurons besoin de capteurs de couleur de lumière EV3. Ces capteurs de lumière, comme aucun autre, sont les mieux adaptés à notre tâche ; lorsque nous travaillons avec eux, nous n'avons pas à nous soucier de l'intensité de la lumière environnante. Pour ce capteur, dans les programmes, nous utiliserons le mode lumière réfléchie, dans lequel la quantité de lumière réfléchie par le rétroéclairage rouge du capteur est estimée. Les limites des lectures du capteur sont respectivement de 0 à 100 unités, pour « aucune réflexion » et « réflexion totale ».

A titre d'exemple, nous analyserons 3 exemples de programmes permettant de se déplacer le long d'une trajectoire noire représentée sur un fond plat et clair :

· Un capteur, avec régulateur P.

· Un capteur, avec régulateur PC.

· Deux capteurs.

Exemple 1. Un capteur, avec régulateur P.

Conception

Le capteur de lumière est installé sur un faisceau idéalement situé sur le modèle.

Algorithme

Le fonctionnement de l'algorithme est basé sur le fait que, en fonction du degré de chevauchement du faisceau d'éclairage du capteur avec une ligne noire, les lectures renvoyées par le capteur varient progressivement. Le robot maintient la position du capteur de lumière sur le bord de la ligne noire. En convertissant les données d'entrée du capteur de lumière, le système de contrôle génère une valeur pour la vitesse de rotation du robot.

Puisque sur une trajectoire réelle, le capteur génère des valeurs sur toute sa plage de fonctionnement (0-100), 50 est sélectionné comme valeur vers laquelle le robot s'efforce. Dans ce cas, les valeurs transmises aux fonctions de rotation sont générées en. la plage -50 - 50, mais ces valeurs ne suffisent pas pour un virage serré de la trajectoire. Par conséquent, la plage devrait être élargie d'une fois et demie jusqu'à -75 - 75.

De ce fait, dans le programme, la fonction calculatrice est un simple contrôleur proportionnel. Dont la fonction ( (a-50)*1,5 ) dans la plage de fonctionnement du capteur de lumière, il génère des valeurs de rotation conformément au graphique :

Exemple de fonctionnement de l'algorithme

Exemple 2. Un capteur, avec régulateur PK.

Cet exemple est basé sur la même construction.

Vous avez probablement remarqué que dans l’exemple précédent le robot oscillait excessivement, ce qui ne lui permettait pas d’accélérer suffisamment. Nous allons maintenant essayer d'améliorer un peu cette situation.

À notre contrôleur proportionnel, nous ajoutons également un simple contrôleur cubique, qui ajoutera une certaine flexibilité à la fonction du contrôleur. Cela réduira le balancement du robot près de la limite souhaitée de la trajectoire, ainsi que des secousses plus fortes lorsqu'il s'en éloigne.

Un contrôleur proportionnel est un dispositif qui exerce une action de contrôle u(t) sur un objet proportionnellement à son écart linéaire e(t) par rapport à un état donné x0(t) ;

e(t)=x0(t)-x(t), où x(t) est l'état à un instant donné ;

u(t)=ke(t), où k est le facteur d'amplification.
Autrement dit, plus le robot s'écarte de la trajectoire donnée, plus les moteurs doivent travailler activement pour le niveler.

Mouvement de ligne avec un capteur de lumière utilisant un contrôleur P

Le mouvement le long de la frontière du noir et du blanc peut également être construit sur le régulateur P. Bien qu'extérieurement, le problème semble pouvoir être résolu uniquement à l'aide d'un contrôleur de relais, puisque le système n'a que deux états visibles à l'œil humain : le noir et le blanc. Mais le robot voit tout différemment ; pour lui, il n'y a pas de frontière nette entre ces couleurs. On peut dire qu'il est myope et voit une transition dégradée de nuances de gris.

C'est ce qui vous aidera à construire un régulateur P.
En définissant l'état de fonctionnement comme les lectures du capteur de lumière, nous apprendrons à exercer un effet de contrôle proportionnel sur les moteurs selon la loi suivante :
e=s1-gris, où s1 correspond aux lectures actuelles du capteur et gray est la valeur définie.

Coefficient k (égal à dans cet exemple 2) doit être suffisamment petit (de 1 à 3). Un tel régulateur ne fonctionne efficacement que pour de petits angles de déviation, le robot doit donc être placé dans le sens du mouvement de manière à ce que le capteur soit du côté gauche de la ligne noire. Il est facile de remarquer que le mouvement le long de la ligne sur le régulateur P est fluide. et dans certaines zones de travail, il se déplace presque droit ou suit exactement les virages de la ligne.

Calibrage du capteur

Regardons le nombre 48 utilisé dans la formule. Il s'agit de la moyenne arithmétique de la lecture du capteur de lumière en noir et blanc, par exemple (40+56)/2=48. Cependant, les lectures des capteurs changent souvent en raison de diverses raisons: une surface différente, un changement dans l'éclairage global de la pièce, une légère modification du design, etc. Par conséquent, nous calibrerons le robot manuellement en déterminant les lectures du capteur de lumière en blanc et en noir.

Mouvement de ligne avec deux capteurs de lumière utilisant un contrôleur P
Il est assez difficile de naviguer correctement à une intersection avec un seul capteur de lumière. Si vous souhaitez le faire à une vitesse suffisamment élevée, vous avez besoin d'au moins deux capteurs placés à une distance de deux largeurs de ligne (ou plus).
Lors de la conduite, quatre états de capteurs sont possibles :

• les deux sur blanc - se déplaçant tout droit ;
• gauche (s1) pas sur noir, droite (s2) sur blanc - mouvement vers la gauche ;
• gauche sur blanc, droite sur noir - mouvement vers la droite ;
• tous deux en noir - tout droit.

Le coefficient k peut varier dans une plage assez large (de 1 à 20 ou plus) en fonction de la courbure de la ligne, de la maniabilité du robot et de l'écart entre le noir et le blanc sur le terrain.
Condition importante. L'auto-calibrage doit être effectué sur une surface monochrome et de préférence sous l'éclairage qui occupera la plus grande partie du trajet. Par exemple, si le robot se déplace le long d’une ligne noire sur un champ blanc, alors il doit être calibré sur un champ blanc. Ceux. La position du robot au démarrage devrait être la suivante :

Contrôleur proportionnel

Description

En contrôle automatique, l'action de contrôle u(t) est généralement fonction de l'erreur dynamique - l'écart e(t) de la variable contrôlée x(t) par rapport à sa valeur définie x0(t) :

e(t) = x0(t) – x(t).

Il s'agit du principe Polzunov-Watt de régulation par déviation, ou principe de feedback. L'expression mathématique de la dépendance fonctionnelle de l'action de contrôle souhaitée u0(t) sur les quantités mesurées par le contrôleur est appelée loi ou algorithme de contrôle discuté ci-dessus.

Un contrôleur proportionnel est un dispositif qui exerce un effet de contrôle sur un objet proportionnellement à son écart par rapport à un état donné :

Ici k est le gain du contrôleur.

L'état donné x0 est généralement appelé point de consigne, et l'écart par rapport à celui-ci e est appelé résidu. Dans ce qui suit, par souci de précision, nous désignerons le résidu par l'abréviation err (de mot anglais"erreur" - erreur).

Contrôle du moteur

Un guerrier expérimenté ne balancera pas une épée comme le fait un robot sur un contrôleur de relais. Nous devons proposer un algorithme qui maintiendra le moteur tenant l'épée dans une position strictement fixe (Fig. 7.1). Le régulateur P vous y aidera.

Soit e ​​1 - les lectures du capteur de vitesse 1 sur le moteur A - une variable réglable. Le réglage x0 = 45, et le résidu e = 45 – e 1. Alors l'action de contrôle sur le moteur est donnée par la formule

u = k ∙ (45 – e 1).

Ici, k est le facteur de gain, par exemple 5, qui améliorera la réponse du moteur même avec de petits écarts par rapport au point de consigne.

1 Ne confondez pas la désignation mathématique du résidu e (de l'erreur) avec les lectures de l'encodeur e 1 (de l'encodeur), une variable d'environnement Robolab prédéfinie.

S'il y a un écart dans côté positif une entrée de commande négative sera appliquée au moteur, et vice versa. Cette commande peut être appliquée au moteur dans un cycle avec un court délai de 1 à 10 ms pour soulager le contrôleur (Fig. 7.8).

Riz. 7.8. Algorithme de contrôle du moteur utilisant un contrôleur proportionnel.

Si le facteur de gain passe de 5 à 100, notre contrôleur proportionnel commencera à agir comme un relais, provoquant de fortes fluctuations dues à l'effet de dépassement.

Le langage RobotC n'a pas une notation aussi pratique pour les lectures d'encodeur que dans Robolab, donc le programme semble un peu plus long :

int k=5, u; nMotorEncoder=0 ; tandis que (vrai)

u=k*(45-nMotorEncoder); moteur = vous ;

De plus, pour délivrer un « coup d'épée », il suffit d'avoir une variable au lieu du nombre 45 et de modifier sa valeur de l'extérieur, par exemple à partir d'une tâche parallèle. Ceci est abordé dans la section sur les robots batteurs du chapitre 8.

Construisons maintenant un régulateur qui contrôle non seulement la position statique du moteur, mais également la vitesse de son mouvement. Suivant la logique de l'algorithme, la consigne, qui jusqu'à présent était constante et n'a pas changé, devrait commencer à évoluer vers une augmentation ou une diminution. En obéissant au régulateur, le moteur le suivra inévitablement. L'outil le plus simple pour augmenter continuellement la valeur de consigne est une minuterie.

Le contrôleur NXT dispose de quatre minuteries intégrées, chacune pouvant mesurer le temps en dixièmes, centièmes et millièmes de seconde. Maîtrisons le premier timer, qui effectue 10 « astuces » par seconde.

"Kov". Dans Robolab, il est désigné T1 ou Timer100ms1, et dans RobotC, il s'agit de timer100.

Faisons dépendre l'angle de déviation du moteur alpha, spécifié dans l'exemple précédent en 45, des lectures du temporisateur avec le coefficient d'accélération k 2 :

alpha = k2 ∙ T1.

L'action de contrôle restera la même avec le facteur d'amplification k 1 :

u = k 1 ∙ (alpha – e 1).

En bref, dans le programme en langage Robolab, nous appliquerons l'action de contrôle directement sur le moteur, après avoir préalablement initialisé le timer.

Riz. 7.9. Le contrôle de la vitesse du moteur est d'un tour par seconde.

Le coefficient k 2 = 36 détermine qu'en une seconde la valeur alpha augmente jusqu'à 360, ce qui correspond à un tour complet du moteur :

int k1=2, k2=36, u, alpha ; nMotorEncoder=0 ; EffacerTimer(T1); tandis que (vrai)

alpha=minuterie100*k2 ; u=k1*(alpha-nMotorEncoder); moteur = vous ;

En utilisant la division entière, telle qu'adoptée en langage C (et dans Robolab) pour les variables de type entier, il est possible d'obtenir un changement discret d'angle, c'est-à-dire l'incrémente une fois par seconde :

alpha = T 1 / 10 ∙ k 2.

Avec un coefficient k 2 = 60, le mouvement du faisceau correspondra au mouvement de la trotteuse sur le cadran de la montre. Mais ce n'est pas suffisant

perceptible. Pour plus de clarté, vous pouvez définir k2 = 30, puis la flèche fera un tour complet en 12 « ticks » de 30 degrés chacun. Soyez prudent avec la séquence des opérations de division et de multiplication d'entiers : changer leur ordre ou « réduire » modifiera certainement le résultat (Fig. 7.10).

Riz. 7.10. Imitation accélérée du mouvement d'une aiguille d'horloge.

Et enfin, un exemple de batteur mathématique. Au lieu d’avancer constamment, l’aiguille oscillera d’avant en arrière sous le contrôle du régulateur P. L'opération de division avec un reste, qui en C est désigné par le signe %, y contribuera. Le reste d'un entier non négatif divisé par 2 sera toujours 0 ou 1 :

alpha = T 1% 2 ∙ k 2.

En augmentant l'écart de k 2 = 15 fois, nous obtenons un point de consigne alpha oscillant, qui forcera le contrôleur à déplacer le moteur 5 fois par seconde, soit de 0º ou de 15 degrés. Les changements dans le programme sont mineurs. Regardons un exemple dans RobotC :

int k1=3, k2=15, u, alpha ; nMoteurEncodeur=0 ; EffacerTimer(T1); tandis que (vrai)

alpha=minuterie100%2*k2 ; u=k1*(alpha-nMotorEncoder); moteur = vous ;

Ce prototype de batteur arrive sur la table à intervalles réguliers. L’essentiel est de commencer dans la bonne position. En utilisant les mathématiques entières, vous pouvez définir un modèle rythmique plus complexe, par exemple (Tableau 7.1) :

alpha = T 1% 5% 2 ∙ k 2.

centre = S3.

Le coefficient est déterminé dans le cycle :

k 1 = c + (S 3 - centre) / k 2.

Riz. 7.36. Déplacement le long de la ligne sur un contrôleur proportionnel à coefficient flottant.

La loi de contrôle de gain qui en résulte peut être appliquée non seulement à la composante proportionnelle, mais également à toute autre composante, ainsi qu'à l'action de contrôle dans son ensemble (Fig. 7.36).

Contrôleur PID

Le contrôleur proportionnel-intégral-dérivé (PID) est l'un des plus populaires et est utilisé dans un grand nombre d'appareils des plus différents types, qui nécessitent une réponse rapide et une précision de positionnement du système. Comme son nom l'indique, ce régulateur est constitué de la somme de trois composants et est représenté graphiquement sur la Fig. 7.37.

Riz. 7.37. Circuit de contrôleur PID.

Ceci est un diagramme simplifié. La valeur de l'erreur dynamique e (t) est fournie à l'entrée du contrôleur et l'action de contrôle u (t) est générée à la sortie :

La composante proportionnelle, représentée sur le diagramme sous forme de triangle, est chargée de positionner le système dans un état donné. Dans certains cas, cela peut provoquer un dépassement avec des auto-oscillations ultérieures. Autrement dit, le régulateur P peut en faire « trop » et le robot commencera à dériver d'un côté à l'autre.

La composante intégrale accumule l'expérience négative (résume les erreurs) et produit un effet compensatoire. Avec des écarts minimes, la composante proportionnelle « s'affaiblit » et la composante intégrale, en raison de son augmentation rapide par sommation, aide à « atteindre » la valeur contrôlée jusqu'au point de consigne.

Le composant différentiel (composant D) surveille le taux de changement de l'état du système et empêche un éventuel dépassement. Dans certains cas, la composante D a un signe opposé à celui proportionnel, et dans d'autres, elle coïncide.

La composante proportionnelle nous est déjà familière, la composante différentielle est décrite dans le chapitre 6 précédent. Passons à la composante intégrale. Cette composante est déterminée dynamiquement, additionnée à la valeur précédente :

je = je + ki × e(t) × dt.

La signification physique de la quantité e (t) × dt est qu'elle est

proportionnelle à la durée pendant laquelle le système est en état d'erreur. Puisque le coefficient k i est pris entre parenthèses, on peut parler de la valeur i comme la somme des durées d'erreur. Ainsi, on trouve l'intégrale par sommation.

Considérons l'utilisation d'un contrôleur PID en utilisant l'exemple d'un robot en équilibre sur deux roues. Ce problème classique peut être résolu de différentes manières en utilisant différents capteurs. Dans l'exemple proposé, un capteur de lumière est utilisé et forme la plus simple Contrôleur PID. Cependant, pour stabiliser le robot, il faudra utiliser des lectures de capteurs plus précises.

Format brut

Les données du capteur entrent dans le contrôleur NXT sous forme brute et non traitée. Tous les capteurs transmettent système opérateur une valeur numérique de 0 à 1023, qui est ensuite traitée par le pilote correspondant et réduite à une forme plus compréhensible (distance 0...255, éclairage 0...100, toucher 0 ou 1, etc.). Mais les données peuvent être reçues directement, sans passer par le pilote. Ce format brut est habituellement appelé RAW (de l'anglais « raw »). Dans certains cas, cela peut être utilisé pour obtenir une plus grande précision. Par exemple, la plage des valeurs du capteur de lumière peut augmenter d'environ 10 fois. C'est cette opportunité qui est utilisée davantage.

Vous pouvez recevoir des données au format RAW dans Robolab et RobotC. Pour ce faire, le capteur est initialisé en conséquence et les données en sont lues à l'aide d'une variable prédéfinie spéciale.

Robot équilibriste

La conception du robot Segway est illustrée à la Fig. 7.38 : contrôleur positionné verticalement, roues rapprochées et capteur de lumière orienté vers le bas. L'algorithme sera un peu plus compliqué.

Le principe de stabilisation d’un Segway en position équilibrée est le suivant. Si le robot se penche en avant, la lecture du capteur de lumière augmente en raison de la lumière réfléchie. En réponse à cela, une action de contrôle est générée, forçant le robot à avancer et à reprendre ainsi une position verticale.

Lors du recul, les lectures du capteur diminuent et le robot commence à reculer. La composante proportionnelle est responsable de tout cela. Le rôle des composants intégraux et différentiels est joué par l'assurance contre les dépassements.

Riz. 7.38. Robot Segway équilibrant.

Sur la fig. 7.39 montre l'algorithme dans Robolab. La majeure partie est occupée par l’initialisation des variables. Pour améliorer la précision, non seulement les données du capteur sont lues au format RAW, mais la plupart des variables sont déclarées au format réel float. L'algorithme PID lui-même est en boucle.

Riz. 7.39. L'algorithme de l'équilibreur est basé sur un contrôleur PID.

Suivant la tradition de déplacement le long de la ligne, nous utilisons la variable grise comme point de consigne - les lectures moyennes du capteur de lumière en position d'équilibre. Le nouveau paramètre d'échelle spécifie la mise à l'échelle de l'action de contrôle. Il s'agit essentiellement d'un facteur d'atténuation car la valeur produite par le régulateur est trop élevée pour les moteurs NXT. Il serait possible de l'ajouter à l'intérieur des coefficients existants, mais pour RobotC ce paramètre sera différent, mais les coefficients seront les mêmes.

Avec les coefficients donnés, le robot se stabilise bien sur un linoléum ou un bureau uni et clair. Autrement dit, il n'a pas besoin blanc surfaces. Pour lancer, vous devez régler avec précision le Segway en position d'équilibre. Si le robot démarre avec une certaine inclinaison vers l'avant ou vers l'arrière, il commencera immédiatement à se déplacer dans la direction de l'inclinaison.

Un exemple similaire dans RobotC est légèrement différent pour plusieurs raisons. Premièrement, les performances de NXT avec le firmware de cet environnement sont environ 1,4 fois supérieures à celles de Robolab, le facteur d'échelle devrait donc être augmenté. Deuxièmement, les valeurs RAW sont transférées vers dans le bon ordre et vous devrez régler les moteurs en marche arrière ou simplement appliquer une action de contrôle négative :

int gray=SensorRaw ; int erreur, erreur=0 ;

flotteur kp=25, ki=350, kd=0,3 ; échelle flottante = 14 ;

flotteur dt=0,001 ; flotter p, je = 0, d, u ; tandis que (vrai)

err= gris-SensorRaw ; //Déviation de signe opposé p=kp*err;

je=je+ki*err*dt; d=kd*(erreur-erreur)/dt; erreur=erreur; u=(p+i+d)/échelle ; moteur = vous ; moteur = vous ; attendre1Msec(1);

Éléments de la théorie de l'automatisme à l'école1

Une tâche méthodologique importante et intéressante consiste à « jeter un pont » entre les domaines de connaissance d'un spécialiste et d'un étudiant, en aidant les écoliers à voir les perspectives d'une future spécialité, c'est-à-dire effectuer une orientation professionnelle et les étudiants voient l'applicabilité pratique de leur connaissances professionnelles. Pour obtenir un effet similaire, des méthodes de calcul des régulateurs ont été développées à l'aide d'outils mathématiques qui ne vont pas au-delà programmes scolaires en mathématiques et en physique. En particulier, au lieu de équations différentielles des différences sont utilisées, qui correspondent bien à la nature discrète de l'interaction entre l'objet et le contrôleur dans le contrôle informatique.

Considérons, par exemple, le problème de la construction de contrôleurs proportionnels (P) et proportionnels-dérivés (PD) dans le problème du contrôle du mouvement d'un robot mobile le long d'un mur. Notons x t la distance entre le robot et le mur, par θt - l'angle de cap du robot, et par u t - l'action de contrôle du moment avec le numéro de série t, respectivement, où t = 0, 1, 2, ... - nombre de moments de changement

rhénium. On pense que l'interrogation des capteurs et les changements dans l'ampleur de l'action de contrôle sont effectués à intervalles égaux de temps h. Pour les tâches de contrôle des robots Lego NXT, il est naturel de supposer que l'action de contrôle fait la différence vitesses angulaires rotation des roues, proportionnelle au taux de changement de l'angle de cap :

En supposant que les écarts de trajectoire par rapport à la valeur nominale θt =0 sont faibles et que la vitesse moyenne du robot est constante : vt=v, la dynamique des changements dans les variables d'état du robot peut être décrite en première approximation. équations linéaires déclare :

où g = h2vr / b.

Fixons la distance souhaitée au mur x*> 0 et déterminons l'objectif de contrôle (CT) par la relation

Introduisons maintenant naturellement au niveau substantiel le concept de stabilité asymptotique en tant que propriété des solutions du système (4), garantissant l'atteinte de la valeur cible (5) dans des conditions initiales assez peu différentes de celles cibles. Il est facile de voir que pour u t = 0, la solution de l’équation (4) est n’importe quelle valeur constante x t = x*. Mais comme l'équation (4), correspondant au modèle d'un double intégrateur (double additionneur), n'a pas la propriété de stabilité asymptotique, le centre de contrôle (5) à gestion constante n’est pas atteint. Cela se démontre facilement analytiquement en résumant un certain nombre de