je suis nouveau sur ce forum;
Je possède une carte arduino méga 2560 ainsi qu'un wave shield kit v1.1 adafruit, un second shiels servo permettant le contrôle d'une vingtaine de servomoteurs est encore entre les mains de la poste pour le moment.
j'ai eu un bts électronique il y a plusieurs années et je n'ai plus beaucoup pratiqué le hardware ni le software depuis trés longtemps.
Aux vues des caractéristiques de ma carte je me suis dit que je pourrais dépoussiérer un projet que j'ai laissé dans un placard depuis 1995 à savoir un robot type humanoïde partiellement autonome pouvant être commandé à distance (surtout pour le faire avancer et avoir des séquences préprogrammées)
comme logiciel je pense utiliser arduino 0023 avec ardublock mais j'ai un peu de mal pour le moment à trouver comment brancher tout mes servos et à les programmer pour les faire bouger de manière groupée ou séquentielle;
à savoir que celon arduino on pourrait brancher et contrôler jusqu'à 54 servos en utilisant ma carte;
est-il possible de brancher plusieurs shields sur une ardunio méga (je pense qu'en programmant un jeu d'adresses ça doit être jouable mais j'ai besoin de l'assistance de personnes plus expériementées que moi sur le hardware et le software arduino.
je développerai mon projet dans un autre message car je tenais à me présenter ainsi que mon petit projet dans un premier temps.
si vous avez déjà quelques idées ou tuyaux pour moi je suis preneur car j'en suis au point zéro quant à présent même si les idées fusent
merci à vous.
Bonjour,
il semble que ce soit un shield "passif", je vais devoir passer par les ports restant du méga pour le cabler partiellement ou la placer en gigogne au dessus du wave shield avec des séquencements logiciels sur les I/O pwm afin de tout faire cohabiter je pense.
je vais devoir me mettre sérieusement à la programmation.
j'ai vu ça et là que des programmes de contrôle de robot style robobuilder, giger et robonova pour ne citer qu'eux, j'aimerais réaliser ce type de robots avec quelques apports en mouvements et en fonctionnalités comme le bruitage perso avec le wave shield lors de certaines actions ainsi que d'autres à définir car déjà là j'ai du boulot.
j'ignore encore comment programmer les servos et surtout comment faire marcher mon futur robot en lui maintenant son équilibre quand c'est nécessaire (pour ça j'ai pensé à un gyro 2 ou 3 axes mais une chose à la fois)
Je pense que le mieux est d'explorer l'arduino méga et d'apprendre à lui faire contrôler les servos d'abord avec mon ordinateur sous windows puis tenter en autonome.
ensuite je commencerai à explorer l'univers des capteur et des interactions.
J'ai enfin reçu mon shield sensor,
ça a l'air sympas mais le problème reste entier pour le software;
j'ai veinement cherché un logiciel permettant le controle du robot du genre robophilo mais rien en gratuit =(
ardublock semble pas mal mais encore hors de porté pour moi.
quelqu'un saurait si il existe un logiciel dédié aux robots humanoïde où l'on peut modéliser soi même son robot (mouvement et emplacement des servomoteurs, ses interfaces externes tel relais et leds) ainsi que ses actionneurs externes style télécommande infrarouge multitouche avec une action définie par touche (voire une action différente par appui sur la même touche comme le déplacement dans un sens puis dans l'autre d'un servomoteur?
PROJET
création d'un robot humanoïde
Nombre de servomoteur à contrôler 30 minimum: - 2x6 servos pour les jambes (3xtourelle)
2x6 servos pour les bras(2xtourelle) dont 2 micro
servos pour le poignet et la main
2x1 servo par épaule pour un mouvement arrière style
homoplate
2 servos pour l'articulation de l'abdomen type tourelle
2 servos pour le mouvement de la tête (tourelle)
-actionnement multiple ou un par un des servos
-là j'abuse mais si possible enchainement de séquence de mouvements programmable par interface simple (style
dance, mouvement de karaté...)
-mode directionnel de marche par séquence (marche avant, arrière, tourne à droite, tourne à
gauche sur simple appui d'une touche un peu comme pour une voiture radiocommandée)
-interaction avec une carte pour générer des effets sonores définis (format wav)
-actionnement d'un relais (générateur de fumé 5V relié dessus)
-allumage extinction de 5 leds minimum ( voir si possible coordonner les effets sonores et lumineux,
si possible quelques leds de plus pour faire un regard de cylon (ou K2000)mais là je pense abuser un
peu :~)
matériel à utiliser: -une carte arduino MEGA2560
-une carte arduino UNO ( livrée avec un récepteur IR et une télécommande 21 touches)
-une carte adafruit wave shield 1.1 fonctionnant sur la carte UNO mais je pense qu'il
est possible de la faire fonctionner sur la carte MEGA moyennant quelques
modifications
-deux modules data RF 905 pour une transmission de donnée bi-directionelle
-1 module tx CDT-88 et un module rx CDR03A en 433MHZ
-des servomoteurs
-1 générateur de fumée 5v modélisme
-des boutons poussoirs et autres composants basics nécessaires (résistances, fils...)
-3 batteries au plomb 6V-1,2AH
-si c'est nécessaire je me procurerai un ou deux accéléromètre pour que le robot soit
stable debout et en marchant
le chassis du robot sera assemblé dès réception des pièces, je posterai la photo pour illustrer mon projet
je pense qu'il doit être possible de contrôler à distance la carte MEGA avec la carte UNO qui servirait de télécommande grâce à l'interface data unidirectionnelle 433MHZ ou bidirectionnelle avec le module RF905 (voir laisser le wave shield sur la carte UNO et transmettre les effets sonores à la carte MEGA qui sera équipée d'un haut parleur); pour les effets additionnels (relais, leds) la télécommande infrarouge sera suffisante je pense
Je pense avoir fait un premier grand tour assez complet, merci d'avance pour vos suggestions et vos réponses;
n'hésitez pas à me contacter en MP si ce projet vous interresse, si vous voulez des précisions ou si vous avez simplement des questions.
je tiens à préciser que je tiens mes modestes compétences en électronique et en bricolage à la disposition de toute personnes ayant besoin d'un coup de main; n'hésitez pas à me solliciter, je ferais de mon mieux pour trouver une solution au problème posé dans les délais les plus court.
je croise les doigts pour qu'un expert de la programmation en manque de défi passe par ce forum et lise ces lignes car ce projet me parait titanesque sans aide.
A mon avis il va falloir que tu développes ton propre soft ... Mais tu te lances effectivement dans un projet titanesque, surtout que tu n'as pas l'air d'être à l'aise avec des choses plus simples. Sinon sur le papier ça semble ok. Jte conseille dans un premier temps de te limiter à un membre, coordonner un être entier directement est pratiquement impossible. Et une fois que tu auras fait ça (ce qui va te demander beaucoup de temps à mon avis), voit pour lui ajouter les autres fonctions (bruit, fumée ...)
En effet, à moins de trouver une bonne âme ça va me prendre pas mal de temps pour mettre au point le soft si je ne trouve pas d'alternative.
j'ai utilisé les exemples ir relais pour la télécommande, servo et af wave, ça a plutôt bien fonctionné mais ça ne reste que des exemples.
pour commencer j'aimerais trouver un petit soft qui me permettrait d'enregistrer les différents codes de la télécommande IR puis d'utiliser chaques touches de manière séparée; ensuite un soft permettant de manoeuvrer les servomoteurs et autres sorties avec le même principe que le soft précédent.
première tentative de programmation simple: actionner deux servomoteurs et un relais avec 5 touches de ma télécommande infrarouge
voici mon premier code:
#include <IRremote.h>
#include <Servo.h>
Servo servo1;
Servo servo2;
int position1 = 90;
int position2 = 90;
int RECV_PIN = 11;
int RELAY_PIN = 4;
int LED_PIN = 13;
int current1;
int current2;
int codeValue;
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
Serial.begin(9600);
pinMode(RELAY_PIN, OUTPUT);
servo1.attach(6);
servo1.write(position1);
servo2.attach(2);
servo2.write(position2);
irrecv.enableIRIn();
}
void loop()
{
Serial.println(results.value, DEC);
if (irrecv.decode(&results))
{
codeValue = results.value;
switch (codeValue)
{
while (codeValue == 16716015); // touche 4 de la télécommande
current1 -=10;
servo1.write(current1);
while (codeValue == 16726215); // touche 6 de la télécommande
current1 +=10;
servo1.write(current1);
while (codeValue == 16718055); // touche 2 de la télécommande
current2 +=10;
servo2.write(current2);
while (codeValue == 16730805); // touche 8 de la télécommande
current2 -=10;
servo2.write(current2);
case 16726215: // touche 5 de la télécommande RELAY
digitalWrite(RELAY_PIN, HIGH);
delay ( 60000 );
digitalWrite(RELAY_PIN, LOW);
while (RELAY_PIN, HIGH); // clignotement de la LED 13 pendant le fonctionnement du relay
digitalWrite(LED_PIN, HIGH);
delay( 3000 );
digitalWrite(LED_PIN, LOW);
delay( 3000 );
irrecv.resume();
}
}
}
// By HEZEKIELS
ok je me suis inspiré des exemples et j'ai repris quelques séquences de l'ardublock pour structurer mes commandes mais bon il faut bien commencer par quelque part.
la compilation a fonctionné avec un petit cris de joie de ma part au passage )
à présent il n'y a plus qu'à UPLOADER sur la carte et à tester,
je réserve ça pour demain et je posterai le résultat.
si ça fonctionne correctement je pourrai commander plus de fonctions avec ma télécommande de PS2 qui compte 51 touches ( là je vais devoir faire un tableau avec toutes les touches et leur code);
je m'attaquerai ensuite à la partie sonorisation puis à la réalisation de l'hardware de mon projet partie par partie (merci encore à b@tto), pour finalement aboutir à mon robot humanoïde semi autonome voir plus si affinités mais pour le moment j'en suis encore trés loin.
J'en profite pour faire un méa culpa pour une erreur de débutant, ma carte arduino méga2560 ne peux contôler que 48 servos (ce qui est déjà pas mal pour mon projet) et non 54 comme je l'avais indiqué (enfin pas la carte seule en tout cas car je sais qu'il existe des extensions mais je pense avoir déjà assez à faire pour le moment)
@ bientôt
Edit de Jean-François : merci de mette le code entre les balises.
Bonjour Jean françois,
merci à vous, je ne savais pas comment mettre mon code en page sur le forum;
finalement le premier code nefonctionnait pas avec la carte, voici le code fonctionnel:
[
#include <IRremote.h>
#include <Servo.h>
Servo servo1; // créer un objet d'asservissement pour commander le servo1
Servo servo2; // créer un objet d'asservissement pour commander le servo2
int position1; // variable pour stocker la position1 d'asservissement
int position2; //variable pour stocker la position2 d'asservissement
int RECV_PIN = 11;
int RELAY_PIN = 4;
int LED_PIN = 12;
int current = 90; // position initiale servo1
int current1 = 90; //position initiale servo2
int codeValue; // code de la télécommande
IRrecv irrecv(RECV_PIN);
decode_results results;
void setup()
{
Serial.begin(9600);
pinMode(RELAY_PIN, OUTPUT);
pinMode(LED_PIN, OUTPUT);
servo1.attach(7);
servo2.attach(6);
irrecv.enableIRIn();
servo1.write(current);
servo2.write(current1);
}
void loop()
{
Serial.println(results.value, DEC);
if (irrecv.decode(&results))
{
codeValue = results.value;
switch (codeValue)
{
case 16716015: // touche 4 de la télécommande
current +=10;
servo1.write(current);
break;
case 16734885: // touche 6 de la télécommande
current -=10;
servo1.write(current);
break;
case 16718055: // touche 2 de la télécommande
current1 -=10;
servo2.write(current1);
break;
case 16730805: // touche 8 de la télécommande
current1 +=10;
servo2.write(current1);
break;
case 16726215: // touche 5 de la télécommande RELAY
{
digitalWrite(RELAY_PIN, HIGH);
{
digitalWrite(LED_PIN, HIGH);
delay ( 800 );
digitalWrite(LED_PIN, LOW);
delay ( 800 );
digitalWrite(LED_PIN, HIGH);
}
delay ( 9000 );
digitalWrite(RELAY_PIN, LOW);
digitalWrite(LED_PIN, LOW);
}
break;
}
irrecv.resume();
}
}
J'aimerais que les servos continuent dans leur mouvement tant que la touche de télécommande est appuyée et permettre de faire fonctionner les servos pendant que le relais et la led fonctionnent mais je ne vois pas encore comment, je n'arrive pas encore à faire clignoter la led pendant le fonctionnement du relais donc pour le moment elle reste allumée pendant que le relais est allimenté;
! voir loop comme une boucle infinie, le code ce trouvant dedans est bouclé constamment.
! la fonction delay bloque le code, rien ne peux ce passer durant ce delay, ici lors d'un appuis tu vas rester bloquer au minimum 10600 millis seconde (+ de 10 sec) lors d'un appuis, voir http://arduino.cc/en/Tutorial/BlinkWithoutDelay pour pallier à ça.
Pas de détection d'appuis continu possible, mais souvent les télécommande possède un code appuis mais la même touche possède un code relâchement, donc code appuis tu actives, code relâchement tu désactive, sinon une touche active et une autre désactive .
Donc ici détection d'un appuis, active le servo, une variable globale pour son statut, en dehors de ton switch grâce à cette variable dans un bloc conditionnel tu peux faire clignoter ta diode (mais sans utiliser la fonction delay) dans la fonction loop (bouclé constamment), ensuite soit détection d'un code relâchement ou autre bouton tu arrêtes tout.
j'avais pensé à l'appui sur une autre touche pour arrêter le relais mais je ne pensais pas que l'on pouvais employer plusieurs boucles de programmation.
Je vais explorer cette fonction ainsi que le reset software pour réinitialiser la carte à distance, merci du renseignement;
J'ai également ajouté la commande de 4 servos supplémentaires:
Demain je regarde de plus près la fonction loop pour libérer des octets;
Ensuite direction la sonorisation avec le WAVE SHIELD commandé de manière indépendante avec la télécommande puis fusion des deux programmes de base en faisant les aménagements nécessaire sur la pinmap;
pour éviter de bloquer les servomoteurs ou risquer d'endommager les servomoteur j'ai rajouter deux bornes software sur chaques commandes:
case 16716015: // touche 4 de la télécommande
current +=10;
if (current > 177) current = 175; // LIMITATION HAUTE DE COURSE SERVO POUR EVITER DE FORCER LE MECANISME
servo1.write(current);
break;
case 16734885: // touche 6 de la télécommande
current -=10;
if (current < 3) current = 5; // LIMITATION BASSE DE COURSE SERVO : ATTENTION, CES VALEURS VARIENT SELON LE TYPE DE SERVO UTILISE
servo1.write(current);
break;
le problème c'est que j'arrive à faire fonctionner une ou deux fois la carte quand j'ai de la chance puis plus rien; ça doit être basique comme problème (style des "{ }" à placer ou à déplacer) mais je ne vois pas où ça coince
j'ai repris une partie de mon précédent programme pour la télécommande que j'ai un peu modifié car le module wave shield utilise les I/O de la carte,
je me suis peut-être branché là où je ne devais pas;
