Maintenant que la mécanique et l'électronique contrôlant les moteurs sont réalisées, il reste à se concentrer sur l'organe qui va envoyer les commandes pour se déplacer. Je le nomme plus simplement "Cerveau" un terme que tout le monde comprend car c'est cet organe qui va faire en sorte que le robot réagisse de façon cohérente.

Afin de fournir plus de souplesse dans la programmation futur du robot mobile et pour le fun de faire quelque chose de complet, j'ai choisi de faire un cerveau qui pourrait communiquer en Bluetooth avec une entité "supérieure" comme un ordinateur, un GSM ou une tablette. Ceci de manière à offrir de nouvelle possibilité: comme celle de télécommander le robot ou de pouvoir prendre des décisions avec d'autres moyens de calcul ou d'avantage de ressources.

 

La base

Comme le reste du robot mobile est fait avec pas mal de récup', j'ai choisi dans le cadre de cette réalisation d'utiliser une carte de développement LPCXpresso, que le constructeur NXP distribuait gratuitement courant de l'année 2011, comme base du cerveau. C'est une bonne occasion de tester cette carte conçue autour du LPC1114, un microcontrôleur 32bits. Cette carte est disponible pour une trentaine d'euros mais rien n'oblige à utiliser le même kit, n'importe quel microcontrôleur équipé d'au moins 2 PWM indépendantes et d'une liaison UART ou encore une carte Arduino peut amplement faire l'affaire. Seule la programmation sera différente. L'avantage du kit proposé par NXP est de posséder un programmateur USB attaché à la carte de développement. Il suffit avec une petite scie de séparer les deux cartes afin d'avoir la carte de test et le programmateur indépendamment, et ce pour le même prix.

LPCXpresso Board

La communication Bluetooth

Le Bluetooth peut paraitre sorcier, créer soi-même une carte qui communique en utilisant la bande de fréquence du Bluetooth (2.4GHz) et en respectant le protocole de ce dernier n'est pas à la portée du premier venu. Personnellement, je ne me serais pas aventuré là dedans si je n'étais pas tombé sur un petit module sympa qui crée une liaison UART sur Bluetooth. Le module est disponible sur ebay ou directement en chine pour seulement quelques dollars (Recherchez à: Wireless Bluetooth RF Transceiver Module RS232 TTL). Le module intègre tous les composants pour créer la communication y compris une antenne dessinée directement sur le circuit. Il n'y a plus qu'à alimenter le composant en 3.3V et connecter les broches RX-TX à celle du microcontrôleur. Le composant possède des entrées/sorties alternatives que personnellement je n'ai pas encore explorées.

Module Bluetooth vers UART

Schema de cablage du module Bluetooth Uart

La carte cerveau

Considérant l'utilisation de la carte LPXpresso et du module Bluetooth<->UART, tous les deux alimentés en 3.3V, que la tension d'alimentation du robot issue de l'accu tourne aux alentours des 9V, la carte cerveau va posséder une petite alimentation pour générer du 3.3V et relier les circuits ensembles.

Pour l'alimentation, en tenant compte que le robot fonctionne sur batterie, et que dès lors, gagner une cinquantaine de milli-ampère dans la consommation globale du robot est un plus dans l'autonomie, la carte intègre donc une petite alimentation à découpage step-down (tension de sortie inférieur à la tension d'entrée avec un rendement supérieur à 90%) dessinée autour d'un MC34063 (composant standard).  Il y a très peu de commentaire à faire autour du circuit, il doit tenir 3.3V avec une consommation maximum de 100-150mA (le module Bluetooth peut consommer jusqu'à 50mA, entre 50 et 100mA sont prévus pour alimenter les futurs capteurs). Globalement j'ai suivi les indications données dans le schéma d'exemple du datasheet pour une tension de sortie de 5V que j'ai ensuite vérifiées au travers des formules du document pour m'assurer qu'elles conviennent également pour une tension de sortie de 3.3V. Certaines valeurs mises dans le schéma dépassent largement les valeurs proposées. Comme déjà dit, j'ai pris les composants que j'avais sous la main. Je placerai avec le reste des documents téléchargeables en fin des articles, le fichier excel permettant de paramétrer l'alimentation.

Schema alimentation 3.3V

Le reste du circuit est très simple, les deux cartes (le module bluetooth et le board LXPXpresso) sont simplement cablées sur le même PCB. Je n'ai pas ajouté de capacité de découplage supplémentaire car elles sont déjà présentes sur chaque petite carte. Le header P4 permet de déporter quelques IO logiques et analogiques pour câbler par la suite des capteurs.

Schema du LPCXpresso Board

Le circuit imprimé n'est pas plus compliqué:

PCB du controleur du robot

Le code source

Le programme ci-dessous a été écrit pour le LPC1114E, il reçoit des commandes par UART indiquant le sens de rotation et la vitesse de chaque moteur. S'il ne reçoit pas de message au plus tard deux secondes après, il arrête les moteurs (sécurité en cas de perte de la communication). Ce programme permet uniquement de télécommander le robot, il faut le compléter lors de l'ajout de capteur pour prendre ces derniers en compte.

Logiciel du microcontrôleur du robot mobile 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134

#include "driver_config.h"
#include "target_config.h"
#include "uart.h"
#include "timer32.h"
#include "timer16.h"
#include "gpio.h"

extern volatile uint32_t timer32_0_counter;

volatile uint32_t period =48000;  //Valeur 1000 -> 48Khz PWM frequency; Donc 48000 -> 1KHZ
extern volatile uint32_t UARTCount;
extern volatile uint8_t UARTBuffer[BUFSIZE];

/* Main Program */

int main (void) {

	uint32_t speedr, speedl;
	uint8_t state = 0;

	/* Initialize 32-bits timer 0 pour dépasser après 10 ms
	 * et provoquer une incrémentation de timer32_0_counter
	 * */
	init_timer32(0, TIME_INTERVAL);
	enable_timer32(0);

	/* Initialize the PWM in timer16_1 enabling match1 output */
	 init_timer16PWM(1, period, MATCH0| MATCH1 , 0);
	 setMatch_timer16PWM (1, 1, 48000); // PIO 1.10
	 setMatch_timer16PWM (1, 0, 48000); // PIO 1.9

	/* La periode configurée dans timer16 va de 0 à 48000.
	 * En choisissant 48000 comme valeur pour la PWM, le duty-cycle de la PWM est 0%
	 * En choisissant 0 comme valeur pour la PWM, le duty-cycle de la PWM est de 100%
	 */
	 enable_timer16(1);

	 /* On divise la fréquence du Timer 16 pour avoir une PWM à 20Hz */

	 LPC_TMR16B1->PR  = 49; //49->20Hz

	/* Set 1.11 et 2.3 en output (Selection de la direction des moteurs) */
	 GPIOSetDir( 1, 11, 1 ); //1.11
	 GPIOSetDir( 2, 3, 1 );  //2.3

	 /* 9600 Bauds, défini dans config/target_config */
	 UARTInit(UART_BAUD);


	while (1)                                /* Loop forever */
	{
		/* On a reçu un message par l'uart */
		if ( UARTCount != 0)
		{
		  timer32_0_counter = 0; /* Reset du pseudo-Watchdog de la communication Uart */
		  LPC_UART->IER = IER_THRE | IER_RLS;			/* Disable RBR */

		  UARTSend( (uint8_t *)UARTBuffer, UARTCount ); /* Renvoie le message reçu (debug) */

		  /* traite le message (machine d'état) */
		  int i;
		  for (i=0; i<UARTCount; i++)
		  {
			  if (UARTBuffer[i] == 'R') // on traite le moteur de droite
			  {
				  state = 1;
			  }
			  else if (UARTBuffer[i] == 'L')// on traite le moteur de gauche
			  {
				  state = 2;
			  }
			  else if (UARTBuffer[i] == 'e') // fin du message
			  {
				  setMatch_timer16PWM (1, 1, speedl); // PIO 1.10
				  setMatch_timer16PWM (1, 0, speedr); // PIO 1.9  /period off
				  state = 0;
			  }
			  else if (state == 1){ // moteur de droite
				  state = 0;
				  speedr=0;
				  if (UARTBuffer[i]=='F') // Direction Avant
				  {
					GPIOSetValue( 1, 11, 0 );
					 state=3;
				  }
				  if (UARTBuffer[i]=='B') // Direction Arrière
				  {
					  GPIOSetValue( 1, 11, 1 );
					  state=3;
				  }
			  }
			  else if (state == 2){ // moteur de gauche
				  state = 0;
				  speedl=0;
				  if (UARTBuffer[i]=='F') // Direction Avant
				  {
					 GPIOSetValue( 2, 3, 0 );
					 state=4;
				  }
				  if (UARTBuffer[i]=='B') // Direction Arrière
				  {
					  GPIOSetValue( 2, 3, 1);
					  state=4;
				  }
			  }
			  else if (state == 3) // Extrait la vitesse droite du message
			  {
				  speedr=speedr*10;
				  speedr+=(UARTBuffer[i]-0x30);
			  }
			  else if (state == 4) // Extrait la vitesse gauche du message
			  {
				  speedl=speedl*10;
				  speedl+=(UARTBuffer[i]-0x30);
			  }
			  else if (state==0)
			  {
			  }
		  }

		  UARTCount = 0; // on a lu le message
		  LPC_UART->IER = IER_THRE | IER_RLS | IER_RBR;	/* Re-enable RBR */
		}

		if ( timer32_0_counter > 200 ){ //Pseudo watchdog software de la communication
			timer32_0_counter = 0;
			/* plus aucun message n'a été reçu depuis 2 sec calculé par timer32
			* On arrete le robot mobile
			*/
			setMatch_timer16PWM (1, 1, 48000); // PIO 1.10
			setMatch_timer16PWM (1, 0, 48000); // PIO 1.9  /period off
			}
	}
}

Quelques considérations supplémentaires

La base du robot mobile est dès à présent finie. Voici cependant quelques considérations supplémentaires:

  • En début de création, je n'avais pas idée de la batterie que j'allais utiliser, je comptais en acheter une avant de me rappeler que j'avais celle d'un petit hélicoptère. Pour la fixer, une méthode assez simple est d'utiliser un velcro (ou scratch), de coller une face sur le chassis du robot et l'autre face sur la batterie. De telle manière, la batterie peut être démontable facilement.
  • J'ai complètement oublié dans la réalisation de l'électronique des moteurs de placer un header mettant à disposition les 5V générés par le régulateur. Ce qui serait utile pour alimenter certains capteurs.
  • Je compte fixer les capteurs du robot en réalisant un module qui viendrait se fixer directement sur la vis avant (celle fixant la roue libre et le "cerveau"). Si le robot devait avoir une utilité bien précise, il serait préférable de prévoir les fixations adéquates directement sur le chassis.

Le robot mobile de roboticus

Téléchargement

Pour ceux que ça intéressent, voici une archive avec les différents documents (schéma, pcb, g-code, plan, fichiers de configuration, photos, code source) pour la réalisation du robot. Cette archive est disponible en téléchargement ici.

Et la suite

Dans le suite des articles (en cours d'écriture): l'utilisation du robot: