servo moteur halloween

Votre code est à moitié en italique parce que le logiciel du forum a interprété une partie de votre code (un [i]) comme étant une instruction de formatage ce qui rend le tout illisible

Lisez les posts épinglés en haut du forum et corrigez votre post en utilisant les balises de code

Sinon pour votre question c’est assez simple

while (valI == HIGH)
   {servo1();}

comme rien dans l’exécution de servo1() ne modifie valI, une fois rentré dans la boucle vous n’en sortez plus jamais...

bonjour à tous,

je travail avec damien sur son projet et je vais essayé d'expliqué de manière plus claire ce que l'on veut faire et où on veut allé :-)

donc à la base nous avons un sketch qui fonctionne bien, celui-ci nous à recevoir des données en generical serial depuis une raspberrypi, l'arduino reçoit les info et il allume des led.

voici le code:

int F = 6;
int G = 7;
int H = 8;



int i = 0;
int incomingByte[3];

void setup()
{
  Serial.begin(57600);


  pinMode(F, OUTPUT); // sortie digital sur la pin6
  pinMode(G, OUTPUT); // sortie digital sur la pin7
  pinMode(H, OUTPUT); // sortie digital sur la pin8




}

void loop()
{
  if (Serial.available() >= 3)
  {
    for (int i = 0; i < 3; i++)
    {
      incomingByte[i] = Serial.read();
    }                                      
    digitalWrite(F, incomingByte[0]);  // led1
    digitalWrite(G, incomingByte[1]);  // led2
    digitalWrite(H, incomingByte[2]);  // led3
    }
  }

maintenant le but et de pouvoir transformer les infos reçue en incomingbyte pour déclencher un sketch qui contrôle des servomoteur.

voici le code que j'avais essayé au départ (car celui de damien est une alternative en essayant de faire des boutons digital par des pontages entre pin) mais je pense qu'il y a moyen de faire beaucoup plus simple, c'est juste que nous sommes encore débutant avec l'arduino.

#include  

Servo myservo;  // créer un object servo pour controler le servo 
                

int pos = 0;    // variable pour controler la position du servo 

int A = 0;      // déclaration de la variable A

int led2 = 7;    // affectation de la led2 à la pin7
int led3 = 8;    // affectation de la led2 à la pin8


int i = 0;
int incomingByte[3];

void setup()
{
  Serial.begin(57600);

   myservo.attach(6); 

  pinMode(led2, OUTPUT);
  pinMode(led3, OUTPUT);



}

void loop()
{
  if (Serial.available() >= 3)
  {
    for (int i = 0; i < 3; i++)
    {
      incomingByte[i] = Serial.read();
    }                                       // Arduino pins
    A = incomingByte[0];  // affectation des données incomingbyte[0] à la variable A
    digitalWrite(led2, incomingByte[1]);  // led2
    digitalWrite(led3, incomingByte[2]);  // led3
    }
    
    
    if (A == HIGH)
    {servo1();} 
    
    
   
}
void servo1(){ 
  for(pos = 70; pos < 130; pos += 1)  // goes from 0 degrees to 180 degrees 
  {                                  // in steps of 1 degree 
    myservo.write(pos);              // tell servo to go to position in variable 'pos' 
    delay(50);                       // waits 15ms for the servo to reach the position 
  } 
  myservo.write(130);
  delay (2000);
  for(pos = 130; pos > 70; pos -= 1)     // goes from 180 degrees to 0 degrees 
  {                                
    myservo.write(pos);              // tell servo to go to position in variable 'pos' 
    delay(50);                       // waits 15ms for the servo to reach the position 
  } 
   }

voilà le problème, dés que le moteur s'enclenche, le reste ne suis pas et le moteur ne s'arrête pas.

j'espère avoir pu être claire et espérant avoir de l'aide pour nous aider à grandir dans le monde l'arduino.

un grand merci d'avance.

mick

bonjour

faire un traçage de la variable A sur la sortie série ... vous allez surement comprendre

bonjour jfs59,

faire le traçage de la variable A, je crois comprendre, je dois donc sortir les lectures de données de serial.begin par seria1.begin. mais pour connecter serial1.begin à mon pc j'utilise un adaptateur rs232? ou il y a un notre moyen?

merci

Même problème que je vous ai déjà mentionné en #6 - changer le nom de la variable ne fixe pas le problème..

Et moi pour ma part, vu que je n'ai pas le niveau pour commencer les serial print, j'ai beau tenter de modifier le code

while (valI == HIGH) {servo1();}

de mille et une facon mais rien ne se passe grrrrrrrrrr

j'ai tenter 30 facons differente de lui dire de se stopper mais rien n'y fait... toujours en me disant que la suivante sera la bonne mdr mais non concluant...

il ne nous manque que cela pour mettre enfin notre projet a execution tout en ayant les enfants du quartier sur le dos mdr. Je sais que donner la solution n'est pas dans vos habitudes, je sais que la meilleur facon d'apprendre est de rechercher , encore et encore ;-)

Mais une facon d'apprendre est aussi de recevoir la réponse avec les explications qui vont avec ce qui permet aussi de comprendre notre erreur et en tenir la lecon ;-)

alors si qq a ce niveau et se sent l'ame généreuse, se sentant l'envie d'aider deux pauvres petits malheureux mdr, ce serait , SUPER MEGA TROP TOP GENIAL mdr

allez, deja un grand merci de votre suivi et de votre aide deja apportée ;-)

Désolé j’avais mal lu hier soir et pas vu le if au lieu de while - vous relisez bien la donnée

La question est plutôt de savoir si c’est la bonne donnée versus ce que vous envoyez : des octets ou de entiers ? un entier c’est plusieurs octets donc si côté emettteur vous envoyez deux ou 4 octets pour un int, là côté récepteur vous n’en lisez qu’un seul par entier émis

La seconde question est sur le timing. si pour une raison quelconque votre arduino rate le premier octet envoyé il est décalé « à vie » sur la réception. il est généralement clé dans un protocole de communication d’indiquer le début (et éventuellement la fin) d’une trame de données. par exemple envoyer [‘#’ V1 V2 V3] et vous attendez d’avoir reçu le ‘#’ avant de lire les 3 valeurs dans l’ordre

Pouvez vous expliquer pourquoi vous avez besoin de RPI et de l’arduino?

bonjour j-m-l ,

ça fait plaisir de voir que je ne suis pas le seul matinal :-D

la rpi envoit des infos de type séquenceur musical. dans notre cas, c'est configurer pour des guirland normal donc normalement on/off il est possible que le programme envoie 255 pour ON est du 0 pour OFF car il possible avec d'autre configuration d'utiliser des guirlande rgb.

mais comment le savoir?

pour le timing le programme est 50 fps.

maintenant quand exécute le programme en enlevant le servo et faire fonctionné qu'avec des leds ça tourne nickel(bon timing) -> arduino reçoit l'info et il allume aussi vite les leds. mais dés que je remplace la led par le servo, il me fait la séquence servo1 quand on lui demande mais le programme ne s'arrête pas et il n'envoie pas l'info à la led2 ni led3...

voilà toutes les infos ;-)

merci à vous

rebonjour

encore une fois et cela a été dit plus haut il faut s’intéresser a ce que vous envoyé et a ce que vous recevez (type de la donnée) une lettre un groupe de lettre un chiffre ou autre chose (code hexa ....) et évidemment dans la comparaison ne pas comparer des cerises avec des bananes car même s'il y en a 1 kg de chaque c'est pas pour autant que la comparaison va donner une valeur vraie ou fausse ! il faut donc tracer le résultat de cette comparaison car a mon avis c'est la que ce trouve le problème des que vous recevez qq chose ca boucle et ca ne peut plus sortir car le résultat de la comparaison est toujours le même ...

if (A == HIGH)

qu' est ce que A ?

qu' est ce que HIGH ?

Vous voulez voir rapidement si c'est vraiment ca le problème

programmez une donnée arduino en entrée, un tirage au + et un petit bouton relié a la masse

vous remplacez if (A == HIGH) par le test de cette entrée ....

il est possible que le programme envoie 255 pour ON est du 0 pour OFF

Vous n'avez qu'un fil - comment envoie-t-il 255 ? une tension de 5V ?

faudrait mesurer

le fait que votre premier programme fait clignoter les LEDs ne vous dit pas qu'elle clignote correctement par rapport à ce que vous envoyez et dans l'ordre. à moins que vous ayez vérifié cela?

Hello,

Oui nous utilisons un prg qui nous permet de sequencer l'arret et la mise en route de nos leds. Donc si nous lui disons qu'elle doit allumer la led1 a 4sec et l'eteindre a 6secondes, ensuite allumer et eteindre la suivante telle que je le lui demande, tout se passe exactement comme je le demande et au moment ou je le demande.

Nous avons donc creer une sequence pour le servo en se disant BINGOOOOOOOOO

je vous dis pas l'ampleur de notre joie quand le servo s'est allumé et notre desillution lorsque celui-ci ne s'arretais plus lol...

D'ou notre appel à l'aide.

Deja un super grand merci de votre aide car je sais que ce n'est pas evident d'aider sans voir concretement le projet ;-)

Je vais voir avec Mickali pour vos propositions car cela sort reelement de mes competences ( je suis en apprentissage mdr) et je reviens vers vous pour vous en donner le resultat

Faudrait faire un petit programme avec software Serial qui écoute ce que dit le RPI et imprime sur votre PC comme ça vous saurez vraiment ce qu’il en est

il est aussi possible aussi de simuler le RPI en mode console et envoyer a l'arduino ce que le RPI est censé lui envoyer ce qui permet de mettre des traceurs 'console' dans tout le code

Tenez essayez ce code sur l'Arduino pour voir ce que vous recevez vraiment

Branchements:

Arduino pin 10 connectée au Tx du RPI Arduino pin 11 connectée au Rx du RPI GND de l'Arduino connecté au GND du RPI (vous l'aviez fait avant, hein?)

(si vous avez un MEGA car vous parlez de Serial1 plus haut alors pas la peine de prendre SoftwareSerial, faites juste #define RPISerial Serial1 et enlever la partie qui correspond à SoftwareSerial, et connectez bien sûr les fils du RPI aux pin de Serial1 (18 et 19))

Console série Arduino mise à 115200 bauds RPI émettant à 57600 bauds

#include 
SoftwareSerial RPISerial(10, 11); // RX, TX

//Le circuit:
// * Rx = pin 10 (connectée au Tx du RPI)
// * Tx = pin 11 (connectée au Rx du RPI)
// * Les GND reliés entre eux

void setup()
{
  Serial.begin(115200);   // On affiche sur la console série à 115200 bauds
  RPISerial.begin(57600); // le R-PI nous parle à 57600 bauds
}

void loop()
{
  static byte nbBytes = 0;
  
  if (RPISerial.available()) {
    byte b = RPISerial.read();
    if (b <= 0xF) Serial.print(F("0")); // on veut chaque octet sur 2 caractères
    Serial.print((byte) b, HEX);
    
    nbBytes++;

    if (nbBytes >= 9) {
      Serial.print(F("\n")); // assez sur cette ligne on passe à la suivante
      nbBytes = 0;
    }
    else 
    if ((nbBytes % 3) == 0) Serial.print(F("\t")); // on affiche des groupes de 3
    else Serial.print(F(" "));
  }
}

ça vous affichera par groupe de 3 octets dans la console Série Arduino ce que vous recevez vraiment et que vous interprétez pour le moment.

Copier / Coller ce que vous voyez en sortie et dites nous si c'est cohérent avec ce que vous êtes censé émettre

hello,

Ok , on va tester cela et revenons vers vous ;-)

Mille merci

bonjour j-m-l

j'ai testé, alors quand une info est envoyé de la pi " une lumière allumé" arduino me donne FF

donc dans le monitor serial quand la lampe 1 est allumée ça donne :

00 FF 00 00 FF 00 00 FF 00

lumière 2 allumé:

00 00 FF 00 00 FF 00 00 FF

lumière 3 allumé:

FF 00 00 FF 00 00 FF 00 00

les 3 lumières allumé:

FF FF FF FF FF FF FF FF FF

et éteinds:

00 00 00 00 00 00 00 00 00

je ne sais pas comment interpréter ça...

encore merci pour ton aide

on dirait donc

  • qu'il n'y a pas de début ni de fin de trame

  • que le système envoie toujours trois groupes d'octets

  • le premier octet correspond à la lampe #3,

  • le deuxième octet correspond à la lampe #1,

  • le troisième octet correspond à la lampe #2

  • qu'il envoie un octet à 255 (0xFF) pour dire allumé

  • qu'il envoie un octet à 0 pour dire éteint

EN SUPPOSANT QUE 2 TRAMES CONSECUTIVES NE SOIENT PAS TROP RAPPROCHEES

En premier approche, si le RPI ne balance pas d'information trop souvent un code comme celui ci devrait vous faire quelque chose.

connectez ainsi

pin 6 --> Servo (et son alimentation bien sûr)

pin 7 --> Anode d'une LED --> une résistance adaptée (220Ω disons) --> GND

pin 8 --> Anode d'une LED --> une résistance adaptée (220Ω disons) --> GND

Pin 0 (Rx) --> Tx du RPI Pin 1 (Tx) --> Rx du RPI

GND Arduino --> GND RPI (important)

RPI configuré à 57600 bauds

(code tapé sans tester, je n'ai pas votre config)

#include 
Servo servo3;  // créer un object servo pour controler le servo

const byte servo3Pin = 6;
const byte led1Pin = 7;    // led1 pilotée par la pin 7
const byte led2Pin = 8;    // led2 pilotée par la pin 8


void setup()
{
  Serial.begin(57600);
  servo3.attach(servo3Pin);
  pinMode(led1Pin, OUTPUT);
  pinMode(led2Pin, OUTPUT);
}


void loop()
{
  if (Serial.available() >= 3) {
    byte incomingByte[3];
    for (int i = 0; i < 3; i++) {
      incomingByte[i] = (byte) Serial.read();
    }
    digitalWrite(led1Pin, (incomingByte[1] == 0xFF) ? HIGH : LOW);
    digitalWrite(led2Pin, (incomingByte[2] == 0xFF) ? HIGH : LOW);    
    if (incomingByte[0] == 0xFF) moveServo3();
  }
}


void moveServo3() {
  const byte minAngle = 70, maxAngle = 130;
  const unsigned int tickPause = 15;

  // goes from 70 degrees to 130 degrees in steps of 1 degree
  for (int pos = minAngle; pos <= maxAngle; pos += 1) {
    servo3.write(pos); // tell servo to go to position in variable 'pos'
    delay(tickPause);   // waits tickPause ms for the servo to reach the position
  }

  delay (2000);  // wait for 2 seconds here

  // and go back
  for (int pos = maxAngle; pos >= minAngle; pos -= 1) {
    servo3.write(pos); // tell servo to go to position in variable 'pos'
    delay(tickPause);   // waits tickPause ms for the servo to reach the position
  }
}

il est important que le RPI n'envoie pas d'infos trop souvent sinon vous allez rater des octets dans la transmission au bout d'un moment où alors ça va se désynchroniser car le buffer Série sera plein

La fonction qui bouge le servo dure 2*61* tickPause + 2s comme j'ai mis tickPause à 15ms ça fait 3830ms --> près de 4s

donc côté séquenceur, si le servo doit bouger, ne pas envoyer d'autre instruction avant 4s.

j-m-l

excuse moi j-m-l

je pense ne pas avoir était claire, les infos sont en continue du début à la fin de la séquence je vais mettre une photo du serial monitor pour éviter des erreurs.

les infos sont en continue et fluide du début à la fin.

22251114_10214621340706265_1064294183_o.jpg|1920x1440

mais elle défilent à quelles vitesse? super rapidement ou pas ?

--> à quelle fréquence le RPI balance les 3 octets?