18 réponses à ce sujet

[Newbies]

Salut tout le monde, je sais que je n'ai pas donné de nouvelles depuis un moment mais j'avais pas trop de temps avec le lycée et tout sa.

Bref, si je reviens c'est pour une bonne raisons. Je voudrais me lancer dans un projet qui poura ce faire vite étant donné que je posséde déjà tout les composants nécessaires a sa construction.

Le robot sera monté sur une base ronde et se déplacera a laide de deux moteurs pas a pasMon lien

Le robot se reperera dans sont environnement a l'aide de 2 capteurs US Mon lien ou 1 seul monté sur un petit servomoteur.

J'ai commancé a écrire le code mais je vais avoir besoin de votre aide.

Le code :

#include <Stepper.h>
#define ECHOPINcapteurdroit 13                          // Pin to receive echo pulse
#define TRIGPINcapteurdroit 12 
#define ECHOPINcapteurgauche 4                            // Pin to receive echo pulse
#define TRIGPINcapteurgauche 5


//declare variables for the motor pins
int motorPin1 = 8;    // Blue   - 28BYJ48 pin 1
int motorPin2 = 9;    // Pink   - 28BYJ48 pin 2
int motorPin3 = 10;    // Yellow - 28BYJ48 pin 3
int motorPin4 = 11;    // Orange - 28BYJ48 pin 4
                        // Red    - 28BYJ48 pin 5 (VCC)

int motorSpeed = 1200;  //variable to set stepper speed
int count = 0;          // count of steps made
int countsperrev = 512; // number of steps per full revolution
int lookup[8] = {B01000, B01100, B00100, B00110, B00010, B00011, B00001, B01001};
        

int stepCount = 0;  // number of steps the motor has taken

void setup() {
  Serial.begin (9600);
    pinMode(ECHOPINcapteurdroit, INPUT);
  pinMode(TRIGPINcapteurdroit, OUTPUT);
    pinMode(ECHOPINcapteurgauche, INPUT);
  pinMode(TRIGPINcapteurgauche, OUTPUT);
    pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
}

void loop() {
  int durationdroit;
  digitalWrite(TRIGPINcapteurdroit, LOW);                   
  delayMicroseconds(2);
  digitalWrite(TRIGPINcapteurdroit, HIGH);                 
  delayMicroseconds(10);
  digitalWrite(TRIGPINcapteurdroit, LOW);       
  durationdroit = pulseIn(ECHOPINcapteurdroit, HIGH);    
  int distancedroit = (durationdroit/2) / 29.1;
   Serial.print(distancedroit);
   Serial.println(" cm");  

  int distancegauche ;  
  digitalWrite(TRIGPINcapteurgauche, LOW);                   
  delayMicroseconds(2);
  digitalWrite(TRIGPINcapteurgauche, HIGH);                 
  delayMicroseconds(10);
  digitalWrite(TRIGPINcapteurgauche, LOW);       
  int durationgauche = pulseIn(ECHOPINcapteurgauche, HIGH);       
    distancegauche = (durationgauche/2) / 29.1;
   Serial.print(distancegauche);

}
      
     
  

Merci d'avance />/>/>/>

PS: Je posséde une arduino UNO R3

[Newbies]

Hop des news toutes fraiches, pour le code, j'ai changé pour un fonctionnement moins saccadé de mes moteurs (voir le message précédant). D’ailleurs, a propos j'ai encore besoin d'aide pour le nouveau code.
Sinon j'ai commencé a construire le châssis />/> je vous laisse en jugez !

Image(s) jointe(s)

• 
• 
• 
• 

[Mike118]

C'est un beau châssis =) bonne continuation pour la suite =)

[Newbies]

Merci Je comprend que le codes puissent vous paraitre long et chiant a lire donc je vais juste avoir besoin de vous pour modifier un morceau de code afin que je puisse l'utiliser.

Voila le code :

// This Arduino example demonstrates bidirectional operation of a
// 28BYJ-48, using a ULN2003 interface board to drive the stepper.
// The 28BYJ-48 motor is a 4-phase, 8-beat motor, geared down by
// a factor of 68. One bipolar winding is on motor pins 1 & 3 and
// the other on motor pins 2 & 4. The step angle is 5.625/64 and the
// operating Frequency is 100pps. Current draw is 92mA.
////////////////////////////////////////////////

//declare variables for the motor pins
int motorPin1 = 8;    // Blue   - 28BYJ48 pin 1
int motorPin2 = 9;    // Pink   - 28BYJ48 pin 2
int motorPin3 = 10;    // Yellow - 28BYJ48 pin 3
int motorPin4 = 11;    // Orange - 28BYJ48 pin 4
                        // Red    - 28BYJ48 pin 5 (VCC)

int motorSpeed = 1200;  //variable to set stepper speed
int count = 0;          // count of steps made
int countsperrev = 512; // number of steps per full revolution
int lookup[8] = {B01000, B01100, B00100, B00110, B00010, B00011, B00001, B01001};

//////////////////////////////////////////////////////////////////////////////
void setup() {
  //declare the motor pins as outputs
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
  Serial.begin(9600);
}

//////////////////////////////////////////////////////////////////////////////
void loop(){
  if(count < countsperrev )
    clockwise();
  else if (count == countsperrev * 2)
    count = 0;
  else
    anticlockwise();
  count++;
}

//////////////////////////////////////////////////////////////////////////////
//set pins to ULN2003 high in sequence from 1 to 4
//delay "motorSpeed" between each pin setting (to determine speed)
void anticlockwise()
{
  for(int i = 0; i < 8; i++)
  {
    setOutput(i);
    delayMicroseconds(motorSpeed);
  }
}

void clockwise()
{
  for(int i = 7; i >= 0; i--)
  {
    setOutput(i);
    delayMicroseconds(motorSpeed);
  }
}

void setOutput(int out)
{
  digitalWrite(motorPin1, bitRead(lookup[out], 0));
  digitalWrite(motorPin2, bitRead(lookup[out], 1));
  digitalWrite(motorPin3, bitRead(lookup[out], 2));
  digitalWrite(motorPin4, bitRead(lookup[out], 3));
}

Ce code permet de faire aller mon moteur dans un sens pendant un temps puis dans l'autre et je voudrais juste un code le plus simplifier possible pour le faire aller dans un sens ou dans l'autre pour faire un code du genre

if(distancedroit < 10)
{
  moteurdroit = sens horaire
  moteurgauche = sens antihoraire
}

else
{
  moteurdroit = sens horaire
  moteurgauche = sens horaire
}

Merci

[Mike118]

en faite si tu veux un truc du genre il faut que tu écrives toi même tes propre fonctions moteurdroit(t) et moteurgauche(t) qui elles vont ressembler au code que tu as mis au dessus.

Par contre évite les doublons ! Tu as déjà posté cette question ( presque la même ) ailleurs ...

[Newbies]

Voila, en cherchant un peutj'ai trouvé ce code

//declare variables for the motor pins
int motorPin1 = 8;	// Blue   - 28BYJ48 pin 1
int motorPin2 = 9;	// Pink   - 28BYJ48 pin 2
int motorPin3 = 10;	// Yellow - 28BYJ48 pin 3
int motorPin4 = 11;	// Orange - 28BYJ48 pin 4
                        // Red    - 28BYJ48 pin 5 (VCC)

int motorSpeed = 0;     //variable to set stepper speed
int potPin = 2; 	//potentiometer connected to A2
int potValue = 0; 	//variable to read A0 input


//////////////////////////////////////////////////////////////////////////////
void setup() {
  //declare the motor pins as outputs
  pinMode(motorPin1, OUTPUT);
  pinMode(motorPin2, OUTPUT);
  pinMode(motorPin3, OUTPUT);
  pinMode(motorPin4, OUTPUT);
  Serial.begin(9600);
}

//////////////////////////////////////////////////////////////////////////////
void loop(){

  potValue = analogRead(potPin);     // read the value of the potentiometer
  Serial.println(potValue);          // View full range from 0 - 1024 in Serial Monitor
  if (potValue < 535){               // if potentiometer reads 0 to 535 do this
    motorSpeed = (potValue/15 + 5);  //scale potValue to be useful for motor
    clockwise();                     //go to the ccw rotation function
  }
  else {                             //value of the potentiometer is 512 - 1024
    motorSpeed = ((1024-potValue)/15 + 5); //scale potValue for motor speed
    counterclockwise(); //go the the cw rotation function
  }
}

//////////////////////////////////////////////////////////////////////////////
//set pins to ULN2003 high in sequence from 1 to 4
//delay "motorSpeed" between each pin setting (to determine speed)

void counterclockwise (){
  // 1
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delay(motorSpeed);
  // 2
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delay (motorSpeed);
  // 3
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, LOW);
  delay(motorSpeed);
  // 4
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delay(motorSpeed);
  // 5
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, LOW);
  delay(motorSpeed);
  // 6
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin4, HIGH);
  delay (motorSpeed);
  // 7
  digitalWrite(motorPin1, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delay(motorSpeed);
  // 8
  digitalWrite(motorPin1, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin4, HIGH);
  delay(motorSpeed);
}

//////////////////////////////////////////////////////////////////////////////
//set pins to ULN2003 high in sequence from 4 to 1
//delay "motorSpeed" between each pin setting (to determine speed)

void clockwise(){
  // 1
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delay(motorSpeed);
  // 2
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delay (motorSpeed);
  // 3
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, LOW);
  delay(motorSpeed);
  // 4
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, HIGH);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, LOW);
  delay(motorSpeed);
  // 5
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, LOW);
  delay(motorSpeed);
  // 6
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, HIGH);
  digitalWrite(motorPin1, HIGH);
  delay (motorSpeed);
  // 7
  digitalWrite(motorPin4, LOW);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, HIGH);
  delay(motorSpeed);
  // 8
  digitalWrite(motorPin4, HIGH);
  digitalWrite(motorPin3, LOW);
  digitalWrite(motorPin2, LOW);
  digitalWrite(motorPin1, HIGH);
  delay(motorSpeed);
}

et avec celui la je devrait pouvoir me démerder pour le transformer

[Newbies]

Voila, je viens de finir le code, je suis pourtant sur qu'il ne vas pas marcher ( comme d'habitude^^ ).

Voila donc le code en question, attention trés trés long car je ne maitrise pas les fonctions permettant de rendre les choses plus compacts.

//declare variables for the motor pins
#include <Stepper.h>
#define trigPinD 1
#define echoPinD 2
#define trigPinG 3
#define echoPinG 4

int motorPin1D = 5;      // Blue   - 28BYJ48 pin 1
int motorPin2D = 6;      // Pink   - 28BYJ48 pin 2
int motorPin3D = 7;     // Yellow - 28BYJ48 pin 3
int motorPin4D = 8;  
int motorPin1G = 9;      // Blue   - 28BYJ48 pin 1
int motorPin2G = 10;      // Pink   - 28BYJ48 pin 2
int motorPin3G = 11;     // Yellow - 28BYJ48 pin 3
int motorPin4G = 12;     // Orange - 28BYJ48 pin 4
                        // Red    - 28BYJ48 pin 5 (VCC)
int motorSpeed = 0;     //variable to set stepper speed



//////////////////////////////////////////////////////////////////////////////
void setup() {
  //declare the motor pins as outputs
  pinMode(trigPinD, OUTPUT);
  pinMode(echoPinD, INPUT);
  pinMode(trigPinG, OUTPUT);
  pinMode(echoPinG, INPUT);
  pinMode(motorPin1D, OUTPUT);
  pinMode(motorPin2D, OUTPUT);
  pinMode(motorPin3D, OUTPUT);
  pinMode(motorPin4D, OUTPUT);
  pinMode(motorPin1G, OUTPUT);
  pinMode(motorPin2G, OUTPUT);
  pinMode(motorPin3G, OUTPUT);
  pinMode(motorPin4G, OUTPUT);
  Serial.begin(9600);
}

//////////////////////////////////////////////////////////////////////////////
void loop(){
  
  int durationD, distanceD;
  digitalWrite(trigPinD, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPinD, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPinD, LOW);
  durationD = pulseIn(echoPinD, HIGH);
  distanceD = (durationD/2) / 29.1;
  Serial.print(distanceD);
  Serial.println("cm");
  
  int durationG, distanceG;
  digitalWrite(trigPinG, LOW);
  delayMicroseconds(2);
  digitalWrite(trigPinG, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPinG, LOW);
  durationG = pulseIn(echoPinG, HIGH);
  distanceG = (durationG/2) / 29.1;
  Serial.print(distanceG);
  Serial.println("cm");
  
  if( distanceD < 10 ){
    tournerdroite();
  }
  else if( distanceG < 10){
    tournergauche();
  }
  else{
    toutdroit();
  }

}

//////////////////////////////////////////////////////////////////////////////
//set pins to ULN2003 high in sequence from 1 to 4
//delay "motorSpeed" between each pin setting (to determine speed)

void tournerdroite(){
  // 1
  digitalWrite(motorPin1D, HIGH);
  digitalWrite(motorPin2D, LOW);
  digitalWrite(motorPin3D, LOW);
  digitalWrite(motorPin4D, LOW);
  delay(motorSpeed);
  // 2
  digitalWrite(motorPin1D, HIGH);
  digitalWrite(motorPin2D, HIGH);
  digitalWrite(motorPin3D, LOW);
  digitalWrite(motorPin4D, LOW);
  delay (motorSpeed);
  // 3
  digitalWrite(motorPin1D, LOW);
  digitalWrite(motorPin2D, HIGH);
  digitalWrite(motorPin3D, LOW);
  digitalWrite(motorPin4D, LOW);
  delay(motorSpeed);
  // 4
  digitalWrite(motorPin1D, LOW);
  digitalWrite(motorPin2D, HIGH);
  digitalWrite(motorPin3D, HIGH);
  digitalWrite(motorPin4D, LOW);
  delay(motorSpeed);
  // 5
  digitalWrite(motorPin1D, LOW);
  digitalWrite(motorPin2D, LOW);
  digitalWrite(motorPin3D, HIGH);
  digitalWrite(motorPin4D, LOW);
  delay(motorSpeed);
  // 6
  digitalWrite(motorPin1D, LOW);
  digitalWrite(motorPin2D, LOW);
  digitalWrite(motorPin3D, HIGH);
  digitalWrite(motorPin4D, HIGH);
  delay (motorSpeed);
  // 7
  digitalWrite(motorPin1D, LOW);
  digitalWrite(motorPin2D, LOW);
  digitalWrite(motorPin3D, LOW);
  digitalWrite(motorPin4D, HIGH);
  delay(motorSpeed);
  // 8
  digitalWrite(motorPin1D, HIGH);
  digitalWrite(motorPin2D, LOW);
  digitalWrite(motorPin3D, LOW);
  digitalWrite(motorPin4D, HIGH);
  delay(motorSpeed);
  
  digitalWrite(motorPin4G, HIGH);
  digitalWrite(motorPin3G, LOW);
  digitalWrite(motorPin2G, LOW);
  digitalWrite(motorPin1G, LOW);
  delay(motorSpeed);
  // 2
  digitalWrite(motorPin4G, HIGH);
  digitalWrite(motorPin3G, HIGH);
  digitalWrite(motorPin2G, LOW);
  digitalWrite(motorPin1G, LOW);
  delay (motorSpeed);
  // 3
  digitalWrite(motorPin4G, LOW);
  digitalWrite(motorPin3G, HIGH);
  digitalWrite(motorPin2G, LOW);
  digitalWrite(motorPin1G, LOW);
  delay(motorSpeed);
  // 4
  digitalWrite(motorPin4G, LOW);
  digitalWrite(motorPin3G, HIGH);
  digitalWrite(motorPin2G, HIGH);
  digitalWrite(motorPin1G, LOW);
  delay(motorSpeed);
  // 5
  digitalWrite(motorPin4G, LOW);
  digitalWrite(motorPin3G, LOW);
  digitalWrite(motorPin2G, HIGH);
  digitalWrite(motorPin1G, LOW);
  delay(motorSpeed);
  // 6
  digitalWrite(motorPin4G, LOW);
  digitalWrite(motorPin3G, LOW);
  digitalWrite(motorPin2G, HIGH);
  digitalWrite(motorPin1G, HIGH);
  delay (motorSpeed);
  // 7
  digitalWrite(motorPin4G, LOW);
  digitalWrite(motorPin3G, LOW);
  digitalWrite(motorPin2G, LOW);
  digitalWrite(motorPin1G, HIGH);
  delay(motorSpeed);
  // 8
  digitalWrite(motorPin4G, HIGH);
  digitalWrite(motorPin3G, LOW);
  digitalWrite(motorPin2G, LOW);
  digitalWrite(motorPin1G, HIGH);
  delay(motorSpeed);
}

//////////////////////////////////////////////////////////////////////////////
//set pins to ULN2003 high in sequence from 4 to 1
//delay "motorSpeed" between each pin setting (to determine speed)

void tournergauche(){
  // 1
  digitalWrite(motorPin1G, HIGH);
  digitalWrite(motorPin2G, LOW);
  digitalWrite(motorPin3G, LOW);
  digitalWrite(motorPin4G, LOW);
  delay(motorSpeed);
  // 2
  digitalWrite(motorPin1G, HIGH);
  digitalWrite(motorPin2G, HIGH);
  digitalWrite(motorPin3G, LOW);
  digitalWrite(motorPin4G, LOW);
  delay (motorSpeed);
  // 3
  digitalWrite(motorPin1G, LOW);
  digitalWrite(motorPin2G, HIGH);
  digitalWrite(motorPin3G, LOW);
  digitalWrite(motorPin4G, LOW);
  delay(motorSpeed);
  // 4
  digitalWrite(motorPin1G, LOW);
  digitalWrite(motorPin2G, HIGH);
  digitalWrite(motorPin3G, HIGH);
  digitalWrite(motorPin4G, LOW);
  delay(motorSpeed);
  // 5
  digitalWrite(motorPin1G, LOW);
  digitalWrite(motorPin2G, LOW);
  digitalWrite(motorPin3G, HIGH);
  digitalWrite(motorPin4G, LOW);
  delay(motorSpeed);
  // 6
  digitalWrite(motorPin1G, LOW);
  digitalWrite(motorPin2G, LOW);
  digitalWrite(motorPin3G, HIGH);
  digitalWrite(motorPin4G, HIGH);
  delay (motorSpeed);
  // 7
  digitalWrite(motorPin1G, LOW);
  digitalWrite(motorPin2G, LOW);
  digitalWrite(motorPin3G, LOW);
  digitalWrite(motorPin4G, HIGH);
  delay(motorSpeed);
  // 8
  digitalWrite(motorPin1G, HIGH);
  digitalWrite(motorPin2G, LOW);
  digitalWrite(motorPin3G, LOW);
  digitalWrite(motorPin4G, HIGH);
  delay(motorSpeed);
  
  digitalWrite(motorPin4D, HIGH);
  digitalWrite(motorPin3D, LOW);
  digitalWrite(motorPin2D, LOW);
  digitalWrite(motorPin1D, LOW);
  delay(motorSpeed);
  // 2
  digitalWrite(motorPin4D, HIGH);
  digitalWrite(motorPin3D, HIGH);
  digitalWrite(motorPin2D, LOW);
  digitalWrite(motorPin1D, LOW);
  delay (motorSpeed);
  // 3
  digitalWrite(motorPin4D, LOW);
  digitalWrite(motorPin3D, HIGH);
  digitalWrite(motorPin2D, LOW);
  digitalWrite(motorPin1D, LOW);
  delay(motorSpeed);
  // 4
  digitalWrite(motorPin4D, LOW);
  digitalWrite(motorPin3D, HIGH);
  digitalWrite(motorPin2D, HIGH);
  digitalWrite(motorPin1D, LOW);
  delay(motorSpeed);
  // 5
  digitalWrite(motorPin4D, LOW);
  digitalWrite(motorPin3D, LOW);
  digitalWrite(motorPin2D, HIGH);
  digitalWrite(motorPin1D, LOW);
  delay(motorSpeed);
  // 6
  digitalWrite(motorPin4D, LOW);
  digitalWrite(motorPin3D, LOW);
  digitalWrite(motorPin2D, HIGH);
  digitalWrite(motorPin1D, HIGH);
  delay (motorSpeed);
  // 7
  digitalWrite(motorPin4D, LOW);
  digitalWrite(motorPin3D, LOW);
  digitalWrite(motorPin2D, LOW);
  digitalWrite(motorPin1D, HIGH);
  delay(motorSpeed);
  // 8
  digitalWrite(motorPin4D, HIGH);
  digitalWrite(motorPin3D, LOW);
  digitalWrite(motorPin2D, LOW);
  digitalWrite(motorPin1D, HIGH);
  delay(motorSpeed);
}
void toutdroit(){
  digitalWrite(motorPin1D, HIGH);
  digitalWrite(motorPin2D, LOW);
  digitalWrite(motorPin3D, LOW);
  digitalWrite(motorPin4D, LOW);
  delay(motorSpeed);
  // 2
  digitalWrite(motorPin1D, HIGH);
  digitalWrite(motorPin2D, HIGH);
  digitalWrite(motorPin3D, LOW);
  digitalWrite(motorPin4D, LOW);
  delay (motorSpeed);
  // 3
  digitalWrite(motorPin1D, LOW);
  digitalWrite(motorPin2D, HIGH);
  digitalWrite(motorPin3D, LOW);
  digitalWrite(motorPin4D, LOW);
  delay(motorSpeed);
  // 4
  digitalWrite(motorPin1D, LOW);
  digitalWrite(motorPin2D, HIGH);
  digitalWrite(motorPin3D, HIGH);
  digitalWrite(motorPin4D, LOW);
  delay(motorSpeed);
  // 5
  digitalWrite(motorPin1D, LOW);
  digitalWrite(motorPin2D, LOW);
  digitalWrite(motorPin3D, HIGH);
  digitalWrite(motorPin4D, LOW);
  delay(motorSpeed);
  // 6
  digitalWrite(motorPin1D, LOW);
  digitalWrite(motorPin2D, LOW);
  digitalWrite(motorPin3D, HIGH);
  digitalWrite(motorPin4D, HIGH);
  delay (motorSpeed);
  // 7
  digitalWrite(motorPin1D, LOW);
  digitalWrite(motorPin2D, LOW);
  digitalWrite(motorPin3D, LOW);
  digitalWrite(motorPin4D, HIGH);
  delay(motorSpeed);
  // 8
  digitalWrite(motorPin1D, HIGH);
  digitalWrite(motorPin2D, LOW);
  digitalWrite(motorPin3D, LOW);
  digitalWrite(motorPin4D, HIGH);
  delay(motorSpeed);
  
   digitalWrite(motorPin1G, HIGH);
  digitalWrite(motorPin2G, LOW);
  digitalWrite(motorPin3G, LOW);
  digitalWrite(motorPin4G, LOW);
  delay(motorSpeed);
  // 2
  digitalWrite(motorPin1G, HIGH);
  digitalWrite(motorPin2G, HIGH);
  digitalWrite(motorPin3G, LOW);
  digitalWrite(motorPin4G, LOW);
  delay (motorSpeed);
  // 3
  digitalWrite(motorPin1G, LOW);
  digitalWrite(motorPin2G, HIGH);
  digitalWrite(motorPin3G, LOW);
  digitalWrite(motorPin4G, LOW);
  delay(motorSpeed);
  // 4
  digitalWrite(motorPin1G, LOW);
  digitalWrite(motorPin2G, HIGH);
  digitalWrite(motorPin3G, HIGH);
  digitalWrite(motorPin4G, LOW);
  delay(motorSpeed);
  // 5
  digitalWrite(motorPin1G, LOW);
  digitalWrite(motorPin2G, LOW);
  digitalWrite(motorPin3G, HIGH);
  digitalWrite(motorPin4G, LOW);
  delay(motorSpeed);
  // 6
  digitalWrite(motorPin1G, LOW);
  digitalWrite(motorPin2G, LOW);
  digitalWrite(motorPin3G, HIGH);
  digitalWrite(motorPin4G, HIGH);
  delay (motorSpeed);
  // 7
  digitalWrite(motorPin1G, LOW);
  digitalWrite(motorPin2G, LOW);
  digitalWrite(motorPin3G, LOW);
  digitalWrite(motorPin4G, HIGH);
  delay(motorSpeed);
  // 8
  digitalWrite(motorPin1G, HIGH);
  digitalWrite(motorPin2G, LOW);
  digitalWrite(motorPin3G, LOW);
  digitalWrite(motorPin4G, HIGH);
  delay(motorSpeed);
}

[R1D1]

Salut,

J'ai une question bien bête : pourquoi tu n'utilises aucune des fonctions de la lib "Stepper.h" que tu inclues pourtant en haut ? Je ne l'ai jamais essayé, mais je pense que tu perdrais moins de temps à comprendre son fonctionnement qu'à essayer de tout recoder. Réinventer la roue, ça t'apprend comment faire une roue, mais c'est quand même plus simple et plus efficace d'utiliser la roue toute faite ...

Pour ce qui est de ton code, il y a sûrement de la factorisation à faire, avec une boucle sur les valeurs d'un tableau pour la rotation du moteur pas à pas par exemple. De la même manière, il est sûrement possible de regrouper tournerdroit et tournergauche avec un argument.
Honnêtement, un code comme ça, ça ne donne pas envie de lire pour ceux qui ne le connaissent pas, et c'est particulièrement pas pratique pour toi (même si tu le connais plus que nous).

[Newbies]

Merci pour ta reponse, j'avais dejas trouver une version reduite de celle la mais je n'ai pas reussi a l'utiliser. Je vais dejas essayer de faire bouger ce tas de ferraille

Voila la fonctions que je n'ai pas reussi a comprendre :

int lookup[8] = {B01000, B01100, B00100, B00110, B00010, B00011, B00001, B01001};
void setOutput(int out)
{
  digitalWrite(motorPin1, bitRead(lookup[out], 0));
  digitalWrite(motorPin2, bitRead(lookup[out], 1));
  digitalWrite(motorPin3, bitRead(lookup[out], 2));
  digitalWrite(motorPin4, bitRead(lookup[out], 3));

[R1D1]

Je ne vois pas ce que tu ne comprends pas qui n'est pas expliqué ici : Doc Stepper Arduino. Il y a même un exemple avec le câblage et le code !

Voila la fonctions que je n'ai pas reussi a comprendre :

int lookup[8] = {B01000, B01100, B00100, B00110, B00010, B00011, B00001, B01001};
void setOutput(int out)
{
  digitalWrite(motorPin1, bitRead(lookup[out], 0));
  digitalWrite(motorPin2, bitRead(lookup[out], 1));
  digitalWrite(motorPin3, bitRead(lookup[out], 2));
  digitalWrite(motorPin4, bitRead(lookup[out], 3));

Qu'est-ce que tu n'as pas compris dans cette fonction ? La seule difficulté est de savoir lire la doc : http://arduino.cc/en/Reference/BitRead , comprendre ce qu'on fait quand on veut commander un moteur pas à pas, et savoir que HIGH équivaut à 1 et LOW équivaut à 0.

Et voir que l'exemple ne permet de commander qu'UN SEUL moteur (en tout cas écrit comme ça). La question à se poser, c'est : qu'est-ce qui est spécifique à mon moteur, et que je dois changer si je veux en commander un autre ?

[Newbies]

J'avais un code encore plus simple pour les moteurs pas a pas classique mais il vesait buger mes moteur

Voila ce fameux code

#include <Stepper.h>

const int stepsPerRevolution = 200;  // change this to fit the number of steps per revolution
// for your motor


// initialize the stepper library on pins 8 through 11:
Stepper myStepper(stepsPerRevolution, 8,9,10,11);            

int stepCount = 0;  // number of steps the motor has taken

void setup() {
  // nothing to do inside the setup
}

void loop() {
  // read the sensor value:
  int sensorReading = analogRead(A0);
  // map it to a range from 0 to 100:
  int motorSpeed = map(sensorReading, 0, 1023, 0, 100);
  // set the motor speed:
  if (motorSpeed > 0) {
    myStepper.setSpeed(motorSpeed);
    // step 1/100 of a revolution:
    myStepper.step(stepsPerRevolution/100);
  } 
}

Sinon, j'ai essayer de mettre le code dans mon robot et comme d'habitude, il ne se passe rien... Même les contrôleurs de mes moteurs ne s'allume pas alors qu'il sont correctement allimenté ( enfin, je crois ).

Une idée quelqu'un ?

[Newbies]

bon, après avoir démontés entièrement mon robot pour trouvé ce qui allait j'ai enfin trouvé le problème. Enfaite ce sont mes contrôleurs qui ne marche plus alors qu'il marchais très bien avant que je les mettent sur le robot... J'ai essayer avec pleins de code différent et toujours rien. Quelqu’un a t il une idée ?

Merci encore;)

[Mike118]

Enfaite ce sont mes contrôleurs qui ne marche plus alors qu'il marchais très bien avant que je les mettent sur le robot... J'ai essayer avec pleins de code différent et toujours rien. Quelqu’un a t il une idée ?

Merci encore;)

Peux tu mettre un lien pointant sur les caractéristiques de ton contrôleur de moteur ?

[Newbies]

Ce sont des contrôleur a base de ULN2003. Voila une fiche technique très détaillée Mon lien

[Mike118]

Ce sont des contrôleur a base de ULN2003. Voila une fiche technique très détaillée Mon lien

Comment est ce que tu testes ton module pour savoir si il fonctionne ou pas ?
Et est ce que tu as un voltmètre ou un petit moteur à courant continu ?

[Newbies]

Comment est ce que tu testes ton module pour savoir si il fonctionne ou pas ?

J'ai un moteur pas à pas ( le même que dans le lien que je t'ai passé). J'arrivais à l'utiliser avec le contrôleur et maintenant, il ne fait que vibrer et ne tourne plus.

Et est ce que tu as un voltmètre ou un petit moteur à courant continu ?

Oui, j'ai un voltmètre. Ce contrôleur peut contrôler des moteurs a courant continu ? Je pensais qu'il était réserve au petit moteur pas a pas

[Mike118]

J'ai un moteur pas à pas ( le même que dans le lien que je t'ai passé). J'arrivais à l'utiliser avec le contrôleur et maintenant, il ne fait que vibrer et ne tourne plus.



Oui, j'ai un voltmètre. Ce contrôleur peut contrôler des moteurs a courant continu ? Je pensais qu'il était réserve au petit moteur pas a pas />

En générale si le moteur vibre c'est que tu envois pas la bonne séquence de commande. Et le fait que le moteur vibre en général c'est un meilleur signe que le fait que le moteur ne bouge pas un poil ^^

Concernant ta question : si tu envois les bonnes séquences ton contôlleur, tu peux contrôller ou bien un moteur pas à pas ou bien deux moteur à courant continu...

[Newbies]

En générale si le moteur vibre c'est que tu envois pas la bonne séquence de commande. Et le fait que le moteur vibre en général c'est un meilleur signe que le fait que le moteur ne bouge pas un poil ^^

Enfaite, il ne vibre ( autrement il reste immobile ) que quand je met le + a l'endroit indiquer en violet sur le schéma ce que je n'avais pas a faire quand il marchais correctement. De plus les leds témoin ne s'allume plus quand je branche l'alimentation ce qui, je crois, était le cas avant.

Concernant ta question : si tu envois les bonnes séquences ton contôlleur, tu peux contrôller ou bien un moteur pas à pas ou bien deux moteur à courant continu...

Ah, cool, je savais pas />

[Newbies]

Bon, j'ai résolut le mystère du contrôleur. Enfaite, il fallait lié a l'aide d'un petit jumper les deux pins entouré en violet sur le schéma précédant.

C'est maintenant au tour des capteurs de deconner, au même titre que les contrôleur, il fonctionnait trés bien avant.
Pour le test, j'ai utiliser un code qui, par l'intermediare du moniteur série, me donne la distance en cm.
Avant, il marchais trés bien, et maintenant il affiche 0 cm tout le temps ou des chiffre aléatoires.

Voila le code.

#define trigPin 12
#define echoPin 13

void setup() {
  Serial.begin (9600);
  pinMode(trigPin, OUTPUT);
  pinMode(echoPin, INPUT);
   
}

void loop() {
 int duration, distance,pos=0,i;
  digitalWrite(trigPin, LOW); 
  delayMicroseconds(2);
  digitalWrite(trigPin, HIGH);
  delayMicroseconds(10);
  digitalWrite(trigPin, LOW);
  duration = pulseIn(echoPin, HIGH);
  distance = (duration/2) / 29.1;
   Serial.print(distance);
   Serial.println(" cm");
}