Chapitre zéro

Voila le premier exemple. Il est très modeste, faut bien commencer par quelque chose !

On n’utilise pas un Arduino Uno dans ce premier chapitre mais une carte DFRobot Romeo. Cette carte a l’avantage d’intégrer un contrôleur pour deux moteurs.

Un Arduino Uno seul n’est pas fait pour contrôler des moteurs, il faut le compléter par un shield (se place au dessus) ou des modules externes (Plus d’infos  ici )

 

Première chose à voir, les branchements :

– le câble USB relié au PC (le câble est du même type qu’un câble pour imprimante, c’est carré du côté de Dfrduino. Le PC peut-être sous Windows ou Linux. Si c’est un Mac, pas de pb non plus).

– l’alimentation : ici j’ai mis une alimentation 12v continu. [Très important : il faut repérer le pôle positif de l’alimentation : pour cela j’ai utilisé un voltmètre ; je repéré le fil du + avec un adhésif rouge . Le « + » doit être connecté &` la borne M_VIN, le « – » à la borne GND ; si on inverse on risque de bousiller le contrôleur ]

Sur la carte DFRduino Roméo, il est préférable de retirer le cavalier VIN=M_VIN ; de cette façon on dit qu’on ne veut pas que la carte puise son alimentation sur celle des moteurs. Sur la photo le cavalier est mis (regarder près de l’alim moteur), il est préférable de le retirer ; comme ça un pb ou une erreur dans l’alim moteur ne met pas en péril la carte. La carte est rusée… elle puisera alors son alim sur le port USB. Ainsi on sépare bien la source d’alimentation du moteur et celle de la carte. (Si on ne veut se passer du port USB pour alimenter la carte, on peut utiliser aussi une autre alim  et la brancher sur la prise jack (près du port USB). Voir le chapitre suivant pour plus de d&´tails)

– le moteur est connecté aux bornes M1 ; le sens de connexion n’a pas d’importance

Bon voici ce qu’on se propose de faire :

– mettre en marche le moteur
– le laisser tourner 5 secondes
– le stopper

//Premier programme sur DFRDuino Romeo V1.1

// Partie déclarations initiales

int E1 = 5; // Pin 5 controle de la vitesse du moteur M1

int M1 = 4; // Pin 4 controle du sens de rotation du moteur M1


void marche()
{
analogWrite (E1,100);
digitalWrite(M1,HIGH);
}

void arret()
{
digitalWrite(E1,LOW);
}

void attente()
{
delay(5000);
}

// Partie setup()

void setup() // executée une seule fois
{
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);

marche();
attente();
arret();
}

// Partie loop()

void loop(void) // executée en boucle
{

}


Bon, dire que c’est intuitif ça serait mentir. Je vais tenter de vous expliquer un peu tout ça en commençant par une approche technique et non informatique. ( Il y a beaucoup de choses de natures différentes à expliquer et je ne tente pas de tout faire d’un coup)

Voyons voir, la première chose à comprendre c’est que dans ce programme, on a mis des commentaires ; les morceaux de ligne qui suivent  //  sont juste là pour expliquer le programme, si on les retire ça fonctionne pareil !

	
	int E1 = 5; // Pin 5 controle de la vitesse du moteur M1
	
	int M1 = 4; // Pin 4 controle du sens de rotation du moteur M1
	
	

On lit dans la doc que le contact 5 contrôle la vitesse du moteur et le contact 4 son sens de rotation

	
	void marche()
	
	analogWrite (E1,100);
	digitalWrite(M1,HIGH);
	
	

Pour mettre le moteur en marche, on demande au contact E1 d’émettre un signal, nous verrons plus tard le sens du nombre 100. (Si rien ne se passe, remplacer 100 par 200 pour voir si ça va mieux)
On choisit le sens de rotation en envoyant sur le contact M1 un signal HIGH (soit 5v).

	
	void arret()
	
	digitalWrite(E1,LOW)
        
       

Pour arrêter le moteur, on envoie sur le contact E1 un signal LOW (soit 0 volts)

void attente()
{
delay(5000);
}
      
        

On attend 5000 ms soit 5 secondes

	
	void setup() // executée une seule fois
	
	pinMode(4, OUTPUT);
	pinMode(5, OUTPUT);
	
	marche();
	attente();
	arret();
	}
       

Toutes les déclarations préalables sont faites, on va mettre ça en musique maintenant.

On va décider que les contacts 4 et 5 sont utilisés en sortie
On va lancer la procédure marche
On va lancer la procédure attente
On va lancer la procédure arret

Ensuite le programme s’arrête. Concrètement, le moteur se met en route, tourne 5 secondes puis s’arrête.

Le fait de déclarer (ici décrire ce que font) les procédures marche, attente, arrêt, ne les exécute pas.

Pour qu’elles se lancent il faut les mettre dans la partie setup() ou, nous verrons plus tard, dans la partie loop(). Mises dans la partie setup, elles s’exécuteront une seule fois, mises dans la partie loop, elles s’exécuteront en boucle.

 

Voilà !

Chapitre zéro : deuxième version du programme


//P1 programme sur DFRDuino Romeo V1.1

int E1 = 5; // Pin 5 controle de la vitesse du moteur M1

int M1 = 4; // Pin 4 controle du sens de rotation du moteur M1


void marche(int a)
{
analogWrite (E1,a);
digitalWrite(M1,HIGH);
}

void arret(int d)
{
digitalWrite (E1,0);
delay(d);

}

void attente(int d)
{
delay(d);
}

void setup() // executée une seule fois
{
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);

}


void loop() // executée en boucle
{

marche(100);
attente(5000);
arret(1000);

marche(150);
attente(5000);
arret(1000);

marche(200);
attente(5000);
arret(1000);

marche(250);
attente(5000);
arret(1000);
}

Qu’est ce qui se passe ?

Maintenant, quand on appelle la procédure marche, on lui donne une valeur. On lance par exemple : marche(200); cette amélioration permet de faire varier la vitesse de rotation du moteur.

C’est la magie du PWM

Ce mode est très rusé.

Oui on délivre du courant au moteur que l’on pilote mais on fait fonctionner un moteur courant continu avec un courant qui n’est plus vraiment continu.

Pour varier la vitesse de rotation, le mode PWM, coupe à intervalles réguliers le courant. Selon la durée de cette coupure, on va tourner lentement (durées de coupures longues) ou vite (durées de coupures courtes). Ca se passe plusieurs centaines de fois par seconde et ça intervient de façon très régulière : on na pas l’impression que le moteur a des hoquets.

C’est la fonction AnalogWrite() qui permet cette modulation.

Une explication ici

Chapitre zéro : marche arrière


//P2 programme sur DFRDuino Romeo V1.1

int E1 = 5; // Pin 5 controle de la vitesse du moteur M1

int M1 = 4; // Pin 4 controle du sens de rotation du moteur M1



void marche_avant(int a)
{
analogWrite (E1,a);
digitalWrite(M1,HIGH);
}

void marche_arriere(int a)
{
analogWrite (E1,a);
digitalWrite(M1,LOW);
}

void arret(int d)
{
digitalWrite (E1,0);
delay(d);

}

void attente(int d)
{
delay(d);
}

void setup() // executée une seule fois
{
pinMode(4, OUTPUT);
pinMode(5, OUTPUT);

}


void loop() // executée en boucle
{

marche_avant(100);
attente(5000);
arret(1000);

marche_avant(200);
attente(5000);
arret(1000);

marche_arriere(100);
attente(5000);
arret(1000);

marche_arriere(200);
attente(5000);
arret(1000);
}

Pas grand chose de nouveau sur le programme : on remarque la nouvelle procedure marche_arriere.

Une précision sur analogWrite : la valeur maximum est 255, la valeur minimale 0 mais pour que le moteur tourne on ne peut pas descendre trop bas dans les valeurs. Pour le moteur que j’ai branché, la valeur 100 est un minimum pratique. En dessous le moteur « chante » mais ne tourne pas.

Autre remarque, le microcontroleur supporte 2A maxi en sortie. Pas de pb avec le moteur 6 vitesses mais d’autres plus costauds pourraient dépasser cette valeur.