Aller au contenu


Photo
- - - - -

Base de mon 1er Robot


95 réponses à ce sujet

#61 Astondb8-RX

Astondb8-RX

    Habitué

  • Membres
  • PipPip
  • 295 messages

Posté 23 mai 2011 - 11:22

Bon et bien fini les schémas et les plans sur la commette.

La base de mon 1er Robot, la voilà.



De face






De dos






Plus qu'a le programmer.

Cela devrait aller assez vite puisque j'ai déjà tout testé (à l'exception du capteur infrarouge qui est monté à l'avant.



Donc, résumons



Deux moteurs (connectés aux PWM de l'Arduino)

Deux µrupteurs (pour le faire tourner en cas d'obstacle)

Un capteur infrarouge (pour gérer la vitesse en fonction de la distance))

Ce capteur a une portée de 20 à 120cm. Plus l'obstacle est loin plus la vitesse est rapide, plus il est près plus le robot ralenti.

Un Eccran LCD Monochrome (pour afficher la vitesse des deux moteurs) ça ce n’est pas encore programmé non plus.

Une pile 9v (pour rendre mon Robot autonome).



Reste à installer

Deux photodiodes pour qu'il se dirige vers la plus forte source de lumière.

Ouis au fur et à mesure de mes moyens et de ma capacité à les programmer est petites choses comme

Des capteurs pour qu'il suive des lignes au sol

Une télécommande infrarouge pour lui faire changer soit de direction soit de programme en cours de déplacement

Puis nous verrons comment faire en sorte qu'il sache ou il se trouve dans un espace défini.



Voila

Au travail et au code.....



#62 Astondb8-RX

Astondb8-RX

    Habitué

  • Membres
  • PipPip
  • 295 messages

Posté 23 mai 2011 - 02:01

Voilà le câblage que j'ai réalisé avant de commencer à programmer.






Les deux rupteurs

Reliés à la masse (Masse commune d'un coté)

Le 1er relié à la pin Num 11

Le 2em relié à la pin Num 12



Le Télémètre IR

Brocge 1 Pin Ana 5

Broche 2 GND

Broche 3 +5v



Moteurs

Reliés les deux aux Broches Moteur 1 et 2 d'une carte Shield PWM

Cette carte Shield PWM Reliée au +5v et à la masse.



Si je ne me suis pas trompé, cela devrait marcher.

Qu'en pensez vous ?



Cdlt

Yves







#63 Esprit

Esprit

    Membre chevronné

  • Membres
  • PipPipPipPip
  • 1 503 messages
  • Gender:Male
  • Location:Belgique
  • Interests:La robotique !

Posté 23 mai 2011 - 03:10

Je n'ai pas vraiment le temps de vérifier tout le câblage, juste une question :
Ton schéma, tu l'as fais avec quel programme ?

#64 Astondb8-RX

Astondb8-RX

    Habitué

  • Membres
  • PipPip
  • 295 messages

Posté 23 mai 2011 - 03:34

Pas grave si tu n'as pas le temps de contrôler le Schéma (qui a été fait avec MS Visio). De toutes les façons, ça marche.
Enfin les moteurs tournent ce qui est déjà pas mal.
Il recule au lieu d'avancer, mais je modifie ça avec le code (ce serait plus simple de le faire avec le câblage, mais ça me fait de l'exercice.
Sinon, je vais aussi réduire la taille de mes photos. Je ne me suis pas vraiment rendu compte de la taille (et donc du poids. Mais nous les mecs nous avons toujours un problème avec la taille (bon ça vas je sors)

#65 Astondb8-RX

Astondb8-RX

    Habitué

  • Membres
  • PipPip
  • 295 messages

Posté 23 mai 2011 - 04:40

Bon 1er code 1ere difficultés.

Voilà le code (il est complétement commenté donc simple à comprendre ce que j'ai voulu faire)
Oui mais voilà, cela ne marche plus.

1er programme de Mon-Robot_1
Ce programme fait tourner les roues en marche avant
si l'un des deux µrupteurs est fermé, les roues passent en sens inverse pendant 1 seconde
*/

int pwm_a = 3; //Controle du PWM du moteur 1 sur la Pin Num 3
int pwm_b = 11; //Controle du PWM du Moteur 2 sur la pin Num 11
int dir_a = 12; //Controle de direction du moteur 1 Sur la pin Num 12
int dir_b = 13; //Controle de direction du moteur 1 Sur la pin Num 13
int Sw_1 = 10; //Controle du switcj de direction du moteur 1 Sur la pin Num 10
int Sw_2 = 9; //Controle du switch de direction du moteur 2 Sur la pin Num 9


void setup()
{
pinMode(pwm_a, OUTPUT); //Declare la pin 3 en sortie
pinMode(pwm_b, OUTPUT); //Declare la pin 11 en sortie
pinMode(dir_a, OUTPUT); //Declare la pin 12 en sortie
pinMode(dir_b, OUTPUT); //Declare la pin 13 en sortie
pinMode(Sw_1, INPUT); //Declare la pin 10 en entrée
pinMode(Sw_2, INPUT); //Declare la pin 9 en entrée


analogWrite(pwm_a, 10); //Demarre le moteur 1 en vitesse lente (10/255)
analogWrite(pwm_b, 10); //Demarre le moteur 2 en vitesse lente (10/255)


}

void loop()
{
if (digitalRead(Sw_1 = HIGH)); //Condition si Switch 1 Fermé
digitalWrite(dir_a, HIGH); //Sens de rotation du moteur 1 inversé
digitalWrite(dir_b, LOW); //Sens de rotation du moteur 1 inversé
delay(1000); // Les moteurs tournent 1 seconde

if (digitalRead(Sw_2 = HIGH)); //Condition si Switch 2 Fermé
digitalWrite(dir_a, HIGH); //Sens de rotation du moteur 1 inversé
digitalWrite(dir_b, LOW); //Sens de rotation du moteur 1 inversé
delay(1000); // Les moteurs tournent 1 seconde

digitalWrite(dir_a, LOW); //Sens de rotation du moteur 1 Normal
digitalWrite(dir_b, HIGH); //Sens de rotation du moteur 2 Normal
//delay(1000); // Les moteurs tounent 1 seconde

// digitalWrite(dir_a, HIGH); //Sens de rotation du moteur 1 inversé
//digitalWrite(dir_b, LOW); //Sens de rotation du moteur 1 inversé
//delay(1000); // Les moteurs tournent 1 seconde

//analogWrite(pwm_a, 150); //Demarre le moteur 1 en vitesse rapide (150/255)
//analogWrite(pwm_b, 150); //Demarre le moteur 2 en vitesse rapide (150/255)
//delay(1000); // Les moteurs tounent 1 seconde

//digitalWrite(dir_a, LOW); //Sens de rotation du moteur 1 Normal
//digitalWrite(dir_b, HIGH); //Sens de rotation du moteur 2 Normal
//delay(1000); // Les moteurs tournent 1 seconde

//analogWrite(pwm_a, 100); //Demarre le moteur 1 en vitesse moyene (100/255)
//analogWrite(pwm_b, 100); //Demarre le moteur 2 en vitesse moyene (100/255)
//delay(1000); // Les moteurs tournent 1 seconde
}[/code]

Alors que ce code fonctionnait

int pwm_b = 11; //PWM moteur 2
int dir_a = 12; //direction moteur 1
int dir_b = 13; //direction moteur 2


void setup()
{
pinMode(pwm_a, OUTPUT); //Declare la Pin en Sortie
pinMode(pwm_b, OUTPUT); //Declare la Pin en Sortie
pinMode(dir_a, OUTPUT); //Declare la Pin en Sortie
pinMode(dir_b, OUTPUT); //Declare la Pin en Sortie

analogWrite(pwm_a, 100);
analogWrite(pwm_b, 100);

}

void loop()
{
digitalWrite(dir_a, LOW);
digitalWrite(dir_b, LOW);

delay(1000);

analogWrite(pwm_a, 100);
analogWrite(pwm_b, 100);

delay(1000);

digitalWrite(dir_a, LOW); //Inverse la direction du moteur 1
digitalWrite(dir_b, HIGH); //Inverse la direction du moteur 2

delay(1000);

analogWrite(pwm_a, 50);
analogWrite(pwm_b, 50);

delay(1000);
}[/code]

C'est pourtant la même base..
Mais en plus, j'ai un buzzer qui sonne. Je ne savais même pas qu'il y avait un buzzer sur la Uno...

Donc question,
quelles sont les lignes qui posent problème ?
Pourquoi ce buzzer sonne ?
Et d’où vient il ?

Merci pour vos réponses.

Cdlt
Yves

#66 Black Templar

Black Templar

    Membre

  • Membres
  • PipPipPipPip
  • 1 430 messages
  • Gender:Male
  • Location:Lille

Posté 23 mai 2011 - 04:48

Salut !

Une PWM à 4% (0.2V), c'est peut être pas assez pour faire tourner les moteurs ?? Essaye d'augmenté la valeur pour voir ??
Si ça ne marche toujours pas, essaye de rajouter ces deux lignes dans la fonction 'void loop()'
analogWrite(pwm_b, 10); //Demarre le moteur 2 en vitesse lente (10/255)[/code]

++
Black Templar

#67 Astondb8-RX

Astondb8-RX

    Habitué

  • Membres
  • PipPip
  • 295 messages

Posté 23 mai 2011 - 05:16

Donc oui tu as raison.

J'ai essayé 3àn qui ne marche pas non plus.
Mais 100 fonctionne très bien.
Donc effectivement, il y a un seuil sous lequel il n'est pas possible de descendre.

Et quand on réfléchi à comment travaille un PWM, il est évident que si le moteur n'est pas alimenté suffisamment longtemps, il ne pourra pas démarrer.

Cela n'explique pas ce Buzzer mais bon. Il a stoppé dès que les moteurs ont démarré.

Sinon, mes moteurs tournent très bien.
Mais là ce sont mes If qui ne fonctionnent pas.
Normalement (si j'ai bien codé ce qui ne semble pas être le cas), les moteurs devraient passer en sens inverse lorsque l'un des deux Switchs est fermé.

#68 lordcuty

lordcuty

    Habitué

  • Membres
  • PipPip
  • 298 messages

Posté 23 mai 2011 - 05:34

remplaces
digitalWrite(dir_a, HIGH); //Sens de rotation du moteur 1 inversé
digitalWrite(dir_b, LOW); //Sens de rotation du moteur 1 inversé
delay(1000); // Les moteurs tournent 1 seconde
[/code]
par
digitalWrite(dir_a, HIGH);  //Sens de rotation du moteur 1 inversé 
digitalWrite(dir_b, LOW);  //Sens de rotation du moteur 1 inversé 
delay(1000);    // Les moteurs tournent 1 seconde
}[/code]

#69 Hexa Emails

Hexa Emails

    Habitué

  • Membres
  • PipPip
  • 439 messages
  • Gender:Male

Posté 23 mai 2011 - 07:17

Bonjour astondb, félicitations pour ce robot!

les "buzzer" sont tes moteurs :) ils se comportent comme un haut parleur qui reçoit un signal électrique ( ton PWM à 480 Hz )
c'est une des raison pour lesquelles on essaye de hacher à 20kHz en général.

#70 Astondb8-RX

Astondb8-RX

    Habitué

  • Membres
  • PipPip
  • 295 messages

Posté 23 mai 2011 - 07:22

Bon il est vrai que ton code semble mieux formulé que le miens.
Toutefois, Les Switchs ne font toujours pas le travail demandé.

Pour bien voir ce qui se passe, j'ai changé quelque peux l'action des switchs en leur faisant aussi changer de vitesse.
Mais rien n'y fait...

Voilà donc mon nouveau code.

1er programme de Mon-Robot_1
Ce programme fait tourner les roues en marche avant
si l'un des deux µrupteurs est fermé, les roues passent en sens invers pendant 1 seconde
*/

int pwm_a = 3; //Controle du PWM du moteur 1 sur la Pin Num 3
int pwm_b = 11; //Controle du PWM du Moteur 2 sur la pin Num 11
int dir_a = 12; //Controle de direction du moteur 1 Sur la pin Num 12
int dir_b = 13; //Controle de direction du moteur 1 Sur la pin Num 13
int Sw_1 = 10; //Controle du switcj de direction du moteur 1 Sur la pin Num 10
int Sw_2 = 9; //Controle du switch de direction du moteur 2 Sur la pin Num 9


void setup()
{
pinMode(pwm_a, OUTPUT); //Declare la pin 3 en sortie
pinMode(pwm_b, OUTPUT); //Declare la pin 11 en sortie
pinMode(dir_a, OUTPUT); //Declare la pin 12 en sortie
pinMode(dir_b, OUTPUT); //Declare la pin 13 en sortie
pinMode(Sw_1, INPUT); //Declare la pin 10 en entrée
pinMode(Sw_2, INPUT); //Declare la pin 9 en entrée


analogWrite(pwm_a, 30); //Demarre le moteur 1 en vitesse lente (10/255)
analogWrite(pwm_b, 30); //Demarre le moteur 2 en vitesse lente (10/255)


}

void loop()
{
analogWrite(pwm_a, 150); //Demarre le moteur 1 en vitesse lente (10/255)
analogWrite(pwm_b, 150); //Demarre le moteur 2 en vitesse lente (10/255)

digitalWrite(dir_a, LOW); //Sens de rotation du moteur 1 Normal
digitalWrite(dir_b, HIGH); //Sens de rotation du moteur 2 Normal
//delay(1000); // Les moteurs tounent 1 seconde

if (digitalRead(Sw_1) == HIGH) //Condition si Switch 1 Fermé
{
digitalWrite(dir_a, HIGH); //Sens de rotation du moteur 1 inversé
digitalWrite(dir_b, LOW); //Sens de rotation du moteur 1 inversé
analogWrite(pwm_a, 100); //Demarre le moteur 1 en vitesse lente (10/255)
analogWrite(pwm_b, 100); //Demarre le moteur 2 en vitesse lente (10/255)
delay(500); // Les moteurs tournent 1 seconde
}

if (digitalRead(Sw_2) == HIGH) //Condition si Switch 2 Fermé
{
digitalWrite(dir_a, HIGH); //Sens de rotation du moteur 1 inversé
digitalWrite(dir_b, LOW); //Sens de rotation du moteur 1 inversé
analogWrite(pwm_a, 200); //Demarre le moteur 1 en vitesse lente (10/255)
analogWrite(pwm_b, 200); //Demarre le moteur 2 en vitesse lente (10/255)
delay(500); // Les moteurs tournent 1 seconde
}
}[/code]

J'ai contrôlé le câblage des switchs.
Commun a la masse
Sw_1 pin 10
Sw_2 pin 9

Testé à l’ohmmètre, je sonne bien entre GND et 10 quand je ferme le Sw_1 et entre GND et 9 quand je ferme Sw_2

Une idée ?

Cdlt
Yves


#71 Hexa Emails

Hexa Emails

    Habitué

  • Membres
  • PipPip
  • 439 messages
  • Gender:Male

Posté 23 mai 2011 - 07:24

tu as mis de résistances de pull up? :p
car tu n'as pas activé le pull up interne je me trompe?

#72 Astondb8-RX

Astondb8-RX

    Habitué

  • Membres
  • PipPip
  • 295 messages

Posté 23 mai 2011 - 08:59

effectivement, le problème viens de là.

Comme je ne sais pas encore activer le Pullup je vais mettre une résistance en dur.

Merci à vous tous

Cdlt
Yves

#73 Hexa Emails

Hexa Emails

    Habitué

  • Membres
  • PipPip
  • 439 messages
  • Gender:Male

Posté 23 mai 2011 - 09:03

il faut juste mettre digitalWrite(pin, 1);
après avoir déclaré comme entrée.

mais une résistance en dur fonctionne très bien ^^

#74 Astondb8-RX

Astondb8-RX

    Habitué

  • Membres
  • PipPip
  • 295 messages

Posté 23 mai 2011 - 10:21

Comme ça ?

{
pinMode(pwm_a, OUTPUT); //Declare la pin 3 en sortie
pinMode(pwm_b, OUTPUT); //Declare la pin 11 en sortie
pinMode(dir_a, OUTPUT); //Declare la pin 12 en sortie
pinMode(dir_b, OUTPUT); //Declare la pin 13 en sortie
pinMode(Sw_1, INPUT); //Declare la pin 10 en entrée
digitalWrite(pin, 1); // PullUp
pinMode(Sw_2, INPUT); //Declare la pin 9 en entrée
digitalWrite(pin, 1); // pullUp


analogWrite(pwm_a, 30); //Demarre le moteur 1 en vitesse lente (10/255)
analogWrite(pwm_b, 30); //Demarre le moteur 2 en vitesse lente (10/255)
Serial.begin(9600);

}[/code]


#75 Black Templar

Black Templar

    Membre

  • Membres
  • PipPipPipPip
  • 1 430 messages
  • Gender:Male
  • Location:Lille

Posté 23 mai 2011 - 10:33

Plutôt comme ça je suppose :

digitalWrite(Sw_1, HIGH); // PullUp
pinMode(Sw_2, INPUT); //Declare la pin 9 en entrée
digitalWrite(Sw_2, HIGH); // pullUp[/code]

;)

#76 Astondb8-RX

Astondb8-RX

    Habitué

  • Membres
  • PipPip
  • 295 messages

Posté 24 mai 2011 - 12:38

OK
Merci à vous...

HIGH est 1 sont identique mais le compilateur ne reconnait qu'une seule syntaxe ou il reconnait les deux ?
Car Alexis semblait sur de lui.

Je test ça demain. et je testerais les deux formes (juste pour savoir)

En fait, je pensais réussir à faire marcher les deux switchs aujourd’hui.
Pour demain, j'avais prévu de mettre en place le télémétré.

C'est un télémètre Sharp travaillant sur des distances allant de 30 à 150 cm.
Il à trois broches
Vcc 5v
GND Masse
Vo Tension analogique de 0.25 à 2.55v

Son câblage est donc simple
Vcc sur la broche 5v
GND sur la broche GND
Vo sur un pin analogique déclarée en INPUT.

Je voudrais l'utiliser de façon a ce que lorsque la tension Vo est >= à 2.55v la vitesse des moteurs soit au maximum (soit 255/255) et la vitesse des moteurs diminue proportionnellement à Vo jusqu'à le vitesse minimum (qui est de 75/255 selon les tests que j'ai fais) donc 75/255 = 0.25V

Il s'agit donc d'une tension variable à analyser comme nous le ferions avec un potentiomètre connecté sur une pin Analogique non ?
la tension est maximum (5v) lorsque le Pot est au max et la tension est de 0v lorsque le Pot est au mini.

Mais bon j'ai trouvé pas mal de chose, mais rien qui corresponde réellement à ce que je veux faire.

Je continu donc mes recherches...

Le plus proche est ce code.

Analog input, analog output, serial output

Reads an analog input pin, maps the result to a range from 0 to 255
and uses the result to set the pulsewidth modulation (PWM) of an output pin.
Also prints the results to the serial monitor.

The circuit:
* potentiometer connected to analog pin 0.
Center pin of the potentiometer goes to the analog pin.
side pins of the potentiometer go to +5V and ground
* LED connected from digital pin 9 to ground

created 29 Dec. 2008
Modified 4 Sep 2010
by Tom Igoe

This example code is in the public domain.

*/

// These constants won't change. They're used to give names
// to the pins used:
const int analogInPin = A0; // Analog input pin that the potentiometer is attached to
const int analogOutPin = 9; // Analog output pin that the LED is attached to

int sensorValue = 0; // value read from the pot
int outputValue = 0; // value output to the PWM (analog out)

void setup() {
// initialize serial communications at 9600 bps:
Serial.begin(9600);
}

void loop() {
// read the analog in value:
sensorValue = analogRead(analogInPin);
// map it to the range of the analog out:
outputValue = map(sensorValue, 0, 1023, 0, 255);
// change the analog out value:
analogWrite(analogOutPin, outputValue);

// print the results to the serial monitor:
Serial.print("sensor = " );
Serial.print(sensorValue);
Serial.print("\t output = ");
Serial.println(outputValue);

// wait 10 milliseconds before the next loop
// for the analog-to-digital converter to settle
// after the last reading:
delay(10);
}[/code][/code][/code]

Mais je cherche de l'Analogique / numérique
et ca c'est ce l'Analogique / Analogique

dlt
Yves








Cdlt
Yves

#77 Hexa Emails

Hexa Emails

    Habitué

  • Membres
  • PipPip
  • 439 messages
  • Gender:Male

Posté 24 mai 2011 - 06:04

rapidement, juste avant de partir bosser (il en faut!)

la différence entre ton code et celui de black est que tu avais oublié de mettre le numéro de pin (tu avais laissé "pin" comme j'avais mis). 1 et HIGH fonctionnent aussi bien si mes souvenirs sont bons.

En fait tu mets à 1 ton entrée (comme si c'était une sortie), après l'avoir déclarée comme une entrée.

pour ton Sharp, un simple "if" peut fonctionner normalement. Le bout de code que je t'avais filé (compte bille à hystérésis) peut t'aider.

#78 Astondb8-RX

Astondb8-RX

    Habitué

  • Membres
  • PipPip
  • 295 messages

Posté 24 mai 2011 - 05:34

Bon et bien voilà du code qui fonctionne.

Ce programme fait tourner les roues en marche avant
si l'un des deux µrupteurs est fermé, la roue opposée au coté du µrupteur tourne en sens inverse pendant 1 seconde
Un télémètre règle la vitesse des roues en marche avant
Plus le Télémètre est proche d'un obstacle plus la vitesse réduit
Plus l'obstacle est loin du télémètre plus les moteurs tournent vite.
la vitesse des roues en marche arrière est fixée à 75 soit la vitesse minimum

1er programme de Mon-Robot_1
Code du 24/06/11
Reste à mieux régler les valeurs du Télémetre
*/

int pwm_a = 3; //Controle du PWM du moteur 1 sur la Pin Num 3
int pwm_b = 11; //Controle du PWM du Moteur 2 sur la pin Num 11
int dir_a = 12; //Controle de direction du moteur 1 Sur la pin Num 12
int dir_b = 13; //Controle de direction du moteur 1 Sur la pin Num 13
int Sw_1 = 10; //Controle du switcj de direction du moteur 1 Sur la pin Num 10
int Sw_2 = 9; //Controle du switch de direction du moteur 2 Sur la pin Num 9
int varSpeed = 255;

void setup()
{
pinMode(pwm_a, OUTPUT); //Declare la pin 3 en sortie
pinMode(pwm_b, OUTPUT); //Declare la pin 11 en sortie
pinMode(dir_a, OUTPUT); //Declare la pin 12 en sortie
pinMode(dir_b, OUTPUT); //Declare la pin 13 en sortie
pinMode(Sw_1, INPUT); //Declare la pin 10 en entrée
digitalWrite(Sw_1, HIGH); // PullUp
pinMode(Sw_2, INPUT); //Declare la pin 9 en entrée
digitalWrite(Sw_2, HIGH); // pullUp



analogWrite(pwm_a, varSpeed); //Demarre le moteur 1 en vitesse lente (10/255)
analogWrite(pwm_b, varSpeed); //Demarre le moteur 2 en vitesse lente (10/255)
Serial.begin(9600);

}

void loop()
{
int val = analogRead(0);
val = map(val, 0, 1023, 75, 255);
analogWrite(pwm_a, varSpeed); //Demarre le moteur 1 en vitesse lente (10/255)
analogWrite(pwm_b, varSpeed); //Demarre le moteur 2 en vitesse lente (10/255)
varSpeed = val*2;
digitalWrite(dir_a, HIGH); //Sens de rotation du moteur 1 Normal
digitalWrite(dir_b, HIGH); //Sens de rotation du moteur 2 Normal
//delay(1000); // Les moteurs tounent 1 seconde
Serial.print(digitalRead(Sw_1));
Serial.print(digitalRead(Sw_2));
Serial.print(digitalRead(varSpeed));
/*
Serial.print(digitalRead(pwm_a));
Serial.print(digitalRead(pwm_b));
Serial.print(digitalRead(dir_a));
Serial.print(digitalRead(dir_b));
*/


if (digitalRead(Sw_1) == LOW) //Condition si Switch 1 Fermé
{
digitalWrite(dir_a, LOW); //Sens de rotation du moteur 1 inversé
digitalWrite(dir_b, HIGH); //Sens de rotation du moteur 1 inversé
varSpeed = 75;
analogWrite(pwm_a, varSpeed); //Demarre le moteur 1 en vitesse lente (10/255)
analogWrite(pwm_b, varSpeed); //Demarre le moteur 2 en vitesse lente (10/255)
delay(500); // Les moteurs tournent 1 seconde
Serial.print(digitalRead(Sw_1));
Serial.print(digitalRead(Sw_2));
Serial.print(digitalRead(varSpeed));
/*
Serial.print(digitalRead(pwm_a));
Serial.print(digitalRead(pwm_b));
Serial.print(digitalRead(dir_a));
Serial.print(digitalRead(dir_b));
*/


}

if (digitalRead(Sw_2) == LOW) //Condition si Switch 2 Fermé
{
digitalWrite(dir_a, HIGH); //Sens de rotation du moteur 1 inversé
digitalWrite(dir_b, LOW); //Sens de rotation du moteur 1 inversé
varSpeed = 75;
analogWrite(pwm_a, varSpeed); //Demarre le moteur 1 en vitesse lente (10/255)
analogWrite(pwm_b, varSpeed); //Demarre le moteur 2 en vitesse lente (10/255)
delay(500); // Les moteurs tournent 1 seconde
Serial.print(digitalRead(Sw_1));
Serial.print(digitalRead(Sw_2));
Serial.print(digitalRead(varSpeed));
/*
Serial.print(digitalRead(pwm_a));
Serial.print(digitalRead(pwm_b));
Serial.print(digitalRead(dir_a));
Serial.print(digitalRead(dir_b));
*/
}


// digitalWrite(dir_a, HIGH); //Sens de rotation du moteur 1 inversé
//digitalWrite(dir_b, LOW); //Sens de rotation du moteur 1 inversé
//delay(1000); // Les moteurs tournent 1 seconde

//analogWrite(pwm_a, 150); //Demarre le moteur 1 en vitesse rapide (150/255)
//analogWrite(pwm_b, 150); //Demarre le moteur 2 en vitesse rapide (150/255)
//delay(1000); // Les moteurs tounent 1 seconde

//digitalWrite(dir_a, LOW); //Sens de rotation du moteur 1 Normal
//digitalWrite(dir_b, HIGH); //Sens de rotation du moteur 2 Normal
//delay(1000); // Les moteurs tournent 1 seconde

//analogWrite(pwm_a, 100); //Demarre le moteur 1 en vitesse moyene (100/255)
//analogWrite(pwm_b, 100); //Demarre le moteur 2 en vitesse moyene (100/255)
//delay(1000); // Les moteurs tournent 1 seconde
}[/code]

Bon c'est pas mal pour un début
Mais je dos avouer encore avoir des problèmes avec le Télémètre.
La plage de vitesse n'est pas suffisante.
Pour que cela fonctionne un peux mieux, je multiplie la valeur de la variable "val" par 2 (cette variable règle la vitesse des moteurs et est renseignée par la sortie analogique du télémètre).

Si vous avez une idée pour régler ce problème, je suis preneur.

Cdlt
Yves

#79 Black Templar

Black Templar

    Membre

  • Membres
  • PipPipPipPip
  • 1 430 messages
  • Gender:Male
  • Location:Lille

Posté 24 mai 2011 - 07:32

Salut !

Qu'est-ce qui te gênes dans la valeur du télémètre ???

Ton télémètre de renvois des valeurs comprises entre combien et combien ??
Tu trouves que ton robot ne va pas assez vite quand il est loin des obstacles ?? Ou qu'il va trop vite lorsqu'il est proche des obstacles ??

#80 Astondb8-RX

Astondb8-RX

    Habitué

  • Membres
  • PipPip
  • 295 messages

Posté 24 mai 2011 - 08:05

Entre 0.25 et 2.55v
mais j'ai trouvé
Ça venais du fait que je tester avec le port USB. Donc pas suffisamment de courant
Ça marche nickel avec une pile 9v
Ça coute juste plus cher... lol




Répondre à ce sujet



  


1 utilisateur(s) li(sen)t ce sujet

0 members, 1 guests, 0 anonymous users