Salut, je reviens vers vous pour une petite question...
Nous alors donc commander un moteur pap pour la direction horizontale, de ce coté là pas de problème...
Par contre est-il facile de commander un servomoteur Hitec HS-485HB depuis un microcontroleur ou est-il indispensable de passer par une carte de contrôle style Aurduino ??
Bonjour,
Grace au ciel, il n'est jamais indispensable de passer par un Arduino : ce n'est qu'un outil simplifiant la programmation (en fait ce n'est qu'un AVR soudé sur une platine avec un qyartz et un régulateur de tension. Plus une interface et un programme rebdant la programmation simple), mais tu trouveras sur le net des routines de commande de servo-moteur adaptées à tous les µC (AVR, MSP, Pic, 80C...)
D'ailleurs, Il me semble que flowcode, à partir de la V4 propose une routine de commande de servo-moteur.
Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.
Donc en fait le plus simple pour nous je pense va être d'utiliser un µC pour le codage, relié à deux autres plus petits dédiés chaqun à l'un des moteurs... comme ca on pourra plus facilement corriger nos erreurs que si l'on avait utilisé un seul pic avec un programme GIGANTESQUE...
Votre avis ?
Plus sale, à coup sûr.
Plus simple, même pas sûr : comment vas-tu discuter entre les µC ?
- avec une liaison type I²C, SPI ? ok, mais il te faut l'apprendre. C'est fun, mais demande un peu de temps (encore qu'avec flowcode...) ;
- avec une liaison parallèle ? là, c'est vraiment pas propre : ça te demande quelque-chose comme 16broches du 1er µC et 8 sur chaque petit, pour quelque-chose de pas forcément idéal : que se passe-t-il si les petits µC viennent lire l'état de la commande au moment ou celle-ci change ? On ne sait pas, tu risques d'avoir des saut de position. C'est modifiable par soft, mais plutôt lourd.
Non, vraiment : le mieux est d'utiliser un unique µC, avec un unique programme, mais bien structuré. La taille du programme fait un peu peur ? commence par écrire un simple algorithme :
Et ensuite, tu crées chaque macro :Code:début initialisation tant que 1 ... SI il faut mettre le servo-moteur axe x en position 1 mettre le servo-moteur axe x en position 1 SINON ne rien faire FIN SI ... fin tant que fin
Initialisation,
servo-moteur axe x en position 1...
Là, c'est structuré et simple à écrire. petite difficulté : utiliser à bon escient les différentes variables entre les macros. Pour ça, le mieux est de faire une feuille sur laquelle tu écris le nom de toutes les variables et ce à quoi elles servent exactement.
Pour ça, il faut déjà réfléchir au fonctionnement global du programme. Comment vas-tu faire ? La difficulté, ici, c'est que ce n'est pas linéaire : il ne suffit pas de faire tourner l'axe de x° pour passer d'un carré à l'autre...
Dernière modification par Antoane ; 02/12/2011 à 07h11.
Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.
En fait les 8 abscisses et les 8 ordonnées arriveraient dans un programme de sortie tout simple, donnant alors 225 positions différentes (il me semble avoir expliqué plus haut dans la page pourquoi 225), de là, si par exemple je suis à l'origine, pour la position 45 il faudrait que je puisse dire d'une part à mon moteur pap de se déplacer de X pas à droite, et à mon servo d'aller vers le haut pendant Y secondes.
Ensuite ce que nous n'avons toujours pas réussi à comprendre cela serait de savoir comment calculer la position instantanée pour ne pas avoir besoin de revenir à l'origine à chaque changement de position.
De plus le prof m'a aujourd'hui avoué que la version de Flowcode au lycée est la version étudiant (logique en même temps)... dons obligé de coder en C ou Basic (chose ou personne du groupe ne connais RIEN) !! Lequel est le plus simple.
(A moins que l'on ne télécharge un Flowcode craqué, mais comme l'on doit tout expliquer dans le dossier écrit, la présence du mot "craqué" est plutot dangeureuse ^^ )
PS: Le transfert du programme sur le µC se fera à l'aide d'une platine MATRIX je sais pas si ça a une importance...
Merci pour tes réponses au fait
C'est ce que j'avais expliqué post 20 :Ensuite ce que nous n'avons toujours pas réussi à comprendre cela serait de savoir comment calculer la position instantanée pour ne pas avoir besoin de revenir à l'origine à chaque changement de position.
Tu déduis de la position de départ et des mouvements effectués depuis le début ta position actuelle.Sans capteur :
Tu sais où tu dois aller (en (46,58)), tu sais où tu es (en (13,42)) car, depuis le début, tu calcules ta position en temps réel, en fonction de tes déplacements. Tu sais donc qu'il faut que tu te déplace de 33 vers la gauche et de 16 vers le bas. Tu sais donc qu'il faut envoyer 330 pas au moteur pas à pas n°1 et 160 au n°2. C'est plutôt moins précis car tu accumules l'erreur, qu'il y a risque de faire sauter un pas... Mais tu n'as pas besoin de capteur, et ça, c'est vraiment un plus.
Le gros inconvénient est que tu intègres l'erreur, donc ça s'accumule.
Je ne connais pas la version étudiant, mais la version démo permet déjà de faire pas mal de choses. Pas d'utiliser les routines servo-moteur cependant, il te faudra les réécrire ou les trouver sur le net.la version de Flowcode au lycée est la version étudiant (logique en même temps)... dons obligé de coder en C ou Basic (chose ou personne du groupe ne connais RIEN) !! Lequel est le plus simple.
Dernière modification par Antoane ; 04/12/2011 à 11h06.
Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.
Salut à tous...
J'ai une petite question pour les spécialistes du codage !
Est-il possible de coder à partir de valeurs contenues dans un tableau sous Flowcode ou en C ?
Je m'explique, nous voudrions pouvoir affecter à chaque position une macro et le nombre de fois qu'il faudrait la réaliser suivant la position à laquelle on veut aller.
Nous aurions pu le faire en lignes, mais sachant qu'au total on a 225 positions le programme serait lourd.
Le principe serait par exemple dans un déplacement horizontal: Si je suis à la position 1 (origine) et que je veut aller à la position 225, se déplacer vers la droite (utilisation de la Macro 1) puis réaliser 224 fois cette opération (boucle); il faudrait donc insérer un calcul dans la case correspondant au "nombre de pas depuis l'origine" - "le nombre de pas effectués" de manière à ce que si je veut maintenant aller à la position 224 le programme calcule "223"-"224"=-1 et effectuerai don un déplacement négatif (Vers la gauche: Macro 2) et une seule fois.
Désolé pour le pavé j'ai essayé d'être le plus clair possible.
Bonjour,
Je ne comprend pas. Mais pour ce que j'ai compris ton idée ne me parait pas très bonne :
- programme très lourd : 225 macros !
- difficultés pour faire évoluer le programme
- complexité (mais comme j'ai pas vraiment compris... pas facile de juger)
Ta macro 1 ne devrait-elle pas plutôt représenter "se déplacer d'un cran vers la droite" ? et tu fais une boucle qui fait tourner la macro 1 un nombre de fois égal à position où on est - position ou on veux aller. Sachant que si c'est négatif, c'est la macro 2 qui est utilisée : aller à droite. C'est simple, clair et rapide à coder.
On est d'accord qu'une macro, c'est un morceau de programme, écrit lorsque tu programmes le pic et qui ne variera jamais dans sa vie ? 225positions, ok mais pour chaque position, il y a 224 posibilitées de déplacement. Donc tu compte créer 225*224 macroJe m'explique, nous voudrions pouvoir affecter à chaque position une macro et le nombre de fois qu'il faudrait la réaliser suivant la position à laquelle on veut aller.?
Au passage, il me semble que dans un PIC, tu es limité à "une pile" de 8 macros, c'est à dire que si tu es dans le programme principal, d'où tu appelles la macro1, d'où tu appelles la macro 2, d'où tu appelles ... la macro 10 ; et bien ton programme ne sera pas capable de revenir de lui-même à la macro 9, puis à la 8... jusqu'au programme principal; ca ne marche que jusqu'à la macro 7 *.
C'est pas clair car ce n'est pas clair dans mon esprit, mais j'ai pas le temps de chercher. Demande à Google de te parler de la "pile d'appel" d'un PIC
Et je ne sais pas si Flowcode gère ça (mais j'en doute).
* et une routine compte probablement pour 1.
Dernière modification par Antoane ; 13/01/2012 à 10h10.
Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.
J'aurai en fait 4 macros dans mon programme:2 pour l'axe horizontal ("déplacer d'1 pas vers la gauche" et "déplacer d'1 pas vers la droite") et de même 2 pour l'axe vertical.
En considérant ma 1ère position (origine) tout en bas à gauche d'un tapis de dalle (quadrillage d'une feuille par exemple) et ma position 225 en haut à droite, si le tapis détecte un signal sur la plaque X, il m'indique la position 200 par exemple, il lui faudra exécuter 200 fois (simplifié) la macro de déplacement vers la droite.
EXPLICATION:
Pour simplifier je ne m'occuperai ici que de l'axe des abscisses:
J'appliquerai en fait un calcul à partir de valeurs définies à l'origine. Soit la position 1 de coordonnées x1=0 et la position 200 de coordonnées x2=200 (ces valeurs sont établies à l'origine ! )
Pour savoir quelle macro appliquer et combien de fois l'exécuter, j'effectue le calcul suivant: "abscisses de la position voulue" - "abscisses de la position précédente" correspond ici à "200" - "0" = "+200"
Le "+" m'indique donc que c'est la macro de "déplacement vers la droite" qu'il faut utiliser et le "200" qu'il faudra la répéter 200 fois.
Maintenant j'introduis une 3ème position, la numéro 17 d'abscisses x3=17 tout en conservant les actions précédentes. La 200ème position devient alors en quelques sortes ma nouvelle origine temporaire et j'effectue toujours le même calcul: "17" - "200" = "-183" (je dois alors utiliser la macro de "déplacement vers la gauche" car présence du signe moins, et répéter celle-ci 183 fois)
J'ai essayé d'être le plus compréhensible possible... si il y a encore un point flou demande moi ;D
Entièrement d'accord.
Par contre, comment gères-tu al 2D (abscisse et ordonnée) ?
:deepseul
Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.
En fait notre tapis est un quadrillage de 64 dalles espacées entre elles d'environ 2 cm. On a donc un tapis de 8 dalles par 8 dalles.
Avec des petites cartes et des diodes nous avons fait en sorte que nous détections lorsqu'une personne marche sur une dalle un signal sur les X et un sur les Y (on ne détecte pas une dalle mais une ligne au final). Cela permet de pouvoir par exemple quand une personne marche sur 2 dalles en même temps la position intermédiaire à éclairer.
Du coup j'aurai une 5ème macro dans mon programme qui aura pour rôle de combiner les signaux obtenus en une position entre 1 et 225.
(exple: si la ligne 6 et la ligne 7 sont activées, le programme en conclura que c'est la ligne imaginaire 6,5 qui est activée; en même temps il calculera de même les ordonnées avant de combiner les deux lignes obtenues pour trouver la position exacte).
Pour les positions regarde la pièce jointe
Sans voir ta PJ :
Tu comptes synchroniser les déplacements en x et y ?
par exemple, si il faut faire 10 à droite et 5 vers l'avant, tu fais 2 à droite, 1 vers l'avant, 2 à droite, 1 vers l'avant ou bien 10 à droite puis 5 verse l'avant... ou bien ?
Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.
Premièrement, j'ai ceci: un PIC 16F876A, un moteur pap bipolaire 4 fils(abscisses), un servomoteur(ordonnées), les 8 entrées abscisses et les 8 entrées ordonnées.
Le moteur bipolaire 4 fils nécessite une commande avec 8 transistors, mais je n'aurait alors plus de pattes sur mon pic pour la commande du servo... donc soit mon premier µC gérerait directement le servo et enverrait des infos à un autre µC pour la commande du moteur pap, soit il faudra acheter un pic avec plus de ports entrées/sorties.
L'idéal serait de pouvoir actionner les deux moteurs en même temps afin d'avoir un déplacement le plus fluide possible.
Le plus simple est de prendre un plus gros µC. En pas cher, répandu et facile à programmer, il y a par exemple le 16F877A.
Sinon, si tu as un peu de temps, tu peux utiliser des "ports expenders", qui utilisent une liaison série pour sortir des données en parallèle.
Le PCF8574a (http://www.nxp.com/documents/data_sheet/PCF8574.pdf) le fait à partir d'une liaison I²C (flowcode connait toutes les routines)
Un registre à décalage permet de faire qqch de similaire sans le protocole I²C.
Voir sinon un 74HC245, associé à des bascules D : simple d'utilisation, il suffit d'une mise de 8 bit. Ensuite, chaque bit du µC supplémentaire apporte 8 bits en sortie (ou en entrée).
Pour le pas à pas, tu peux simplement le commander sur 2 fils : une horloge et une commande de sens. Il suffit ensuite de générer la bonne séquence pour alimenter les différentes phases, par exemple à l'aide d'un 4017...
Se sont parmi les techniques les plus répandues et les plus simples à mettre en œuvre.
Dernière modification par Antoane ; 15/01/2012 à 13h56.
Deux pattes c'est une diode, trois pattes c'est un transistor, quatre pattes c'est une vache.
