Wiki Arobose - Contributions de l'utilisateur [fr]

XBee shield Arduino

2013-10-04T13:01:32Z

Ldoffe : XBee shield Arduino exemple d'utilisation

La [http://www.dfrobot.com/wiki/index.php/Xbee_Shield_For_Arduino_%28no_Xbee%29_%28SKU:DFR0015%29 shield Arduino Xbee] de DRFobot permet d'accueillir le [http://www.digi.com/fr/products/wireless/point-multipoint/xbee-series1-module module Xbee] de digi qui convertit les signaux Xbee en commande série.

== Shield XBee ==
Cette shield est une solution simple pour communiquer sans fil (ondes radio) en utilisant la liaison série de la Arduino.

Elle est équipée de 2 interrupteurs :

- RUN/PROG : La programmation de la Arduino via le cable USB utilise la liaison série. Pour éviter d'avoir à enlever la shield pour programmer la Arduino, il faut positionner l'interrupteur sur PROG. La liaison série entre la Arduino et la shield sera coupée et la shield ne perturbera pas la programmation. Quand la programmation de la Arduino est terminée, l'interrupteur devra être positionné sur RUN pour utiliser la communication Xbee du programme de la Arduino.

- XBEE/USB : En position XBEE, c'est la communication série via Xbee qui est activée. En position USB, c'est la communication série via USB qui est activée.

== Exemple ==

Nous utilisons une Arduino UNO (ATMEGA328P) avec la shield et un module Xbee S1. Nous envoyons des caractères au PC en utilisant un adaptateur Xbee/USB et un module Xbee S1. Ces caractères sont lus dans un terminal série.

=== Langage C ===

Dans un premier temps, nous allons configurer la liaison série. Le message envoyé contient 8 bits de données et 1 bit de stop sans contrôle de parité. La vitesse de transmission est de 9600 bauds. La fonction usart_0_transmit() permet d'envoyer un octet (caractère). La fonction principale envoie les 14 caractères « Hello World ! » en boucle toutes les 2 secondes.

<syntaxhighlight lang="c">
/* setup USART0
* speed : 9600 Baud
* 8-bits, no parity, 1-stop-bit */
void
usart_0_setup(void)
{
//#if F_CPU == 16000000UL
UBRR0 = 103; /* 9600 Baud at 16MHz */
// elsif F_CPU == 20000000UL
// UBRR1 = 129 /*9600 Baud at 20 MHz */
UCSR0A = 0;
UCSR0B = 0;

/* 8-bits, no parity, 1-stop-bit */
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);

DDRD |= (1 << PD1); /* initialize pin PD1 (TX) as output pin */
UCSR0B |= (1 << TXEN0); /* enable transmitter */
}

// transmit a char
void
usart_0_transmit(uint8_t data)
{
// wait for empty transmit buffer
while (!(UCSR0A & (1 << UDRE0)))
;
// put data info buffer, sends the data
UDR0 = data;
}

int
main(void)
{
uint8_t c[14] =
{ "Hello world !\n" };

usart_0_setup();

while (1)
{
for (uint8_t i = 0; i < 14; i++)
{
usart_0_transmit(c[i]);
}
_delay_ms(2000);
}
return 1;
}
</syntaxhighlight>

[[Category:Produits]]

GPS LEA-5H shield Arduino

2013-10-03T14:13:42Z

Ldoffe : GPS LEA-5H shield Arduino exemple d'utilisation

La shield GPS pour ARDUINO basée sur le module [http://www.u-blox.com/en/lea-5h.html LEA_5H] de U-BLOX permet une location fiable en extérieure. Couplé à une antenne GPS, le LEA-5H permet de recevoir les signaux satellites GPS et GALILEO.

Cette [http://www.dfrobot.com/wiki/index.php?title=DFRduino_GPS_Shield-LEA-5H_%28SKU:TEL0044%29 shield], proposée par DFRobot , permet une utilisation simple du module en intégrant les composants nécessaire à son utilisation (régulation de tension, résistances de pull-up pour la liaison i2c, led de power et fonctionnement, connecteur USB et antenne...).

== Communication ==
Le module LEA-5H intègre plusieurs mode de communication : USB, série, i2c.

Il suit la norme [http://fr.wikipedia.org/wiki/NMEA_0183 NMEA 0183] et envoie plusieurs trames GPS : RMC, VTG, GGA, GSA, GSV, GLL.
GGA est la plus courante, elle donne la position (latitude, longitude et altitude) du récepteur. Le détail des trames est expliquées [http://www.u-blox.com/images/downloads/Product_Docs/u-blox5_Protocol_Specifications%28GPS.G5-X-07036%29.pdf ici].

Toutes les trames sont envoyées à chaque demande sous forme de caractères ASCII. Le code de la trame est envoyée en tête en commençant par $ (par exemple, $GPGGA) puis chaque valeur séparée par une virgule (4825.2680,N,00110.3895,E). Si la valeur n'est pas disponible (perte de communication avec le satellite) elle n'est pas envoyée, seules les virgules permettent de connaître le paramètre ($GPGGA,,,,,,,,,).
.

=== USB ===
La shield peut être branchée à un ordinateur (port USB). Les données GPS sont directement transmises et peuvent être lues grâce à un terminal série (9600 bauds, 8 bits, 1 bit stop, sans parité). Les trames RMC, VTG, GGA, GSA, GSV et GLL sont envoyées environ toutes les secondes.

=== I2C ===
La liaison i2c se fait grâce à une ARDUINO.

==== Exemple Langage ARDUINO ====

Un exemple est expliqué [http://www.dfrobot.com/wiki/index.php?title=DFRduino_GPS_Shield-LEA-5H_%28SKU:TEL0044%29 ici].

==== Exemple Langage C ====

La liaison twi (i2c) et les fonctions sont expliquées [http://geonobotwiki.free.fr/doku.php?id=robotics:computing:communication_twi_entre_atmega ici]

Pour notre exemple, nous utilisons une carte ARDUINO UNO configurée en maitre. Le module GPS est utilisé en esclave à l'adresse 0x42.
Les trames GPS sont stockées à l'adresse 0xFF. Nous utiliserons la trame GGA pour afficher la position ( latitude, longitude et l'altitude) du récepteur GPS.

Nous avons créé une structure gps qui contient la latitude, longitude et l'altitude. Les données sont stockées sous forme de chaînes de caractères ASCII. Par exemple, pour une latitude de 48°45'2584, la chaine latitude contiendra le code ASCII de chaque valeur : 52 (pour 4), 56 (pour 8)...

Comme tous les formats de trames sont envoyés, il faut retrouver la trame GGA et identifier les paramètres qui nous intéresse. Pour commencer, on demande une lecture de 200 octets. Une fois reçus, la fonction gps_gpgga() parcourt le buffer pour retrouver la séquence $GPGGA. Quand l'entête a été retrouvée, il suffit de compter les virgules pour connaître le paramètre.
La fonction gps_print() permet d'envoyer les paramètres sur le port série pour les afficher dans un terminal.

<syntaxhighlight lang="c">
typedef struct
{
uint8_t latitude[9];
uint8_t dir_lat;
uint8_t longitude[11];
uint8_t dir_long;
uint8_t altitude[5];
} gps;

/* GPS GGA message */
gps
gps_gpgga(uint8_t *buffer)
{
gps g;
uint8_t gpgga[6] =
{ '$', 'G', 'P', 'G', 'G', 'A' };

uint8_t header = 0;
uint8_t j = 0, count = 0;

for (uint8_t i = 0; i < 200; i++)
{
if (!header)
{
if (buffer[i] == gpgga[j])
{
j++;
if (j == 6)
{
header = 1;
}
}
}
else
{
if (buffer[i] == ',')
{
count++;
j = 0;
}
else
{
switch (count)
{
case 1: // utc time
break;
case 2: // latitude
g.latitude[j] = buffer[i];
break;
case 3: // direction latitude
g.dir_lat = buffer[i];
break;
case 4: // longitude
g.longitude[j] = buffer[i];
break;
case 5: // direction longitude
g.dir_long = buffer[i];
break;
case 9: // altitude
g.altitude[j] = buffer[i];
break;
case 10: //
default:
break;
}
j++;
}
}
}
return g;
}

void
gps_print(gps g)
{
uint8_t lat[11] =
{ "latitude : " };
uint8_t lon[12] =
{ "longitude : " };
uint8_t alt[11] =
{ "altitude : " };

for (uint8_t i = 0; i < 11; i++)
{
usart_0_transmit(lat[i]);
}
for (uint8_t i = 0; i < 9; i++)
{
usart_0_transmit(g.latitude[i]);
}
usart_0_transmit(' ');
usart_0_transmit(g.dir_lat);
usart_0_transmit('\n');

for (uint8_t i = 0; i < 12; i++)
{
usart_0_transmit(lon[i]);
}
for (uint8_t i = 0; i < 11; i++)
{
usart_0_transmit(g.longitude[i]);
}
usart_0_transmit(' ');
usart_0_transmit(g.dir_long);
usart_0_transmit('\n');

for (uint8_t i = 0; i < 11; i++)
{
usart_0_transmit(alt[i]);
}
for (uint8_t i = 0; i < 5; i++)
{
usart_0_transmit(g.altitude[i]);
}
usart_0_transmit(' ');
usart_0_transmit('m');
usart_0_transmit('\n');
}

void
setup(void)
{
twi_master_setup();
usart_0_setup();
usart_0_transmitter_enable();
}

int
main(void)
{
gps g;
setup();
while (1)
{
uint8_t reg = 0xFF;
uint8_t buffer[200];
twi_read_bytes((0x42 << 1), &reg, 200, buffer);

g = gps_gpgga(buffer);

gps_print(g);
_delay_ms(2000);
}
return 1;
}
</syntaxhighlight>

[[Category:Produits]]

Accéléromètre-Gyroscope-Boussole 9 axes MPU-9150

2013-09-27T13:27:39Z

Ldoffe :

Le [http://www.invensense.com/mems/gyro/mpu9150.html MPU-9150], proposé par InvenSense, est un module permettant de détecter l'orientation sur 9 degré de liberté. Il est composé du [http://www.invensense.com/mems/gyro/mpu6050.html MPU-6050] qui contient un gyroscope 3 axes et un accéléromètre 3 axes et du [http://www.akm.com/akm/en/file/datasheet/AK8975.pdf AK8975] qui est une boussole numérique 3 axes.

== MPU-9150 ==
L'accéléromètre 3 axes mesure l'accélération linéaire suivant x, y et z. La mesure est en g.

Le gyromètre 3 axes mesure la vitesse angulaire autour des 3 axes x, y et z. La mesure est en °/s.

La boussole 3 axes mesure le champs magnétique sur x, y et z. La mesure est en µT.

La communication avec le MPU-9150 se fait par liaison i2c. L'adresse du module par défaut est 0x68. Il est cependant possible de modifier l'adresse (0x69) grace au cavalier à souder sur AD0.

Les nombreux registres accessibles permettent de configurer le MPU-9150 au besoin du système (précision du gyroscope et de l'accéléromètre...). Voir le document sur la [http://www.invensense.com/mems/gyro/documents/RM-MPU-9150A-00v4_2.pdf description des registres].

== Tests ==

Nous utilisons une carte ARDUINO UNO et le MPU-9150 monté sur la carte d'évaluation de [https://www.sparkfun.com/products/11486 Sparkfun]. Cette carte permet une utilisation facile du composant MPU-9150 en intégrant les condensateurs nécessaire à son utilisation et les résistances de pull up pour la liaison i2c.

Le câblage est très simple :

MPU91-50 / ARDUINO

GND → GND

VCC → +3.3V

SDA → A4

SCL → A5

Nous allons décrire quelques fonctions permettant de récupérer les données en x, y et z de l'accéléromètre, du gyroscope et la température.

=== Exemple langage ARDUINO ===
Un exemple est expliqué [http://playground.arduino.cc/Main/MPU-6050#sketch ici]

=== Exemple langage C ===

==== Liaison i2c ====
La liaison twi (i2c) et les fonctions sont expliquées [http://geonobotwiki.free.fr/doku.php?id=robotics:computing:communication_twi_entre_atmega ici]

Le MPU-9150 est configuré en esclave à l'adresse 0x68. La UNO est configurée en maitre.

==== Fonctions du MPU-9150 ====

===== Initialisation =====

Le capteur est par défaut en mode sleep. Pour le réveiller, il faut mettre à 0 le bit SLEEP du registre 107 – Power Management 1 (PWR_MGMT_1). Ce registre permet également d'activer le capteur de température (mettre le bit TEMP_DIS à 0).

Le tableau reg[2] contient l'adresse du registre PWR_MGMT_1 et la valeur à écrire dans le registre (ici 0 car nous voulons désactiver le mode sleep et activer le capteur de température).
Il faut configurer la liaison i2c en mode master.
La fonction twi_write_bytes permet d'envoyer des octets à un esclave. Ici on envoie 2 octets du tableau reg à l'adresse MPU9150_DEFAULT_ADDRESS.
Le décalage de l'adresse vient de fait que dans le MPU-9150 stocke son adresse sur les 7 bits de poids fort.

<syntaxhighlight lang="c">
#define MPU9150_DEFAULT_ADDRESS 0x68
#define MPU9150_ACCEL_XOUT_H 0x3B
#define MPU9150_TEMP_OUT_H 0x41
#define MPU9150_GYRO_XOUT_H 0x43
#define MPU9150_PWR_MGMT_1 0x6B

void
mpu9150_setup(void)
{
/* clear the SLEEP bit to start the sensor */
uint8_t reg[2] = {MPU9150_PWR_MGMT_1, 0};

twi_master_setup(); /* i2c to master mode */
twi_write_bytes((MPU9150_DEFAULT_ADDRESS << 1), 2, reg);
}
</syntaxhighlight>

===== Lecture de la température =====

La température est lue sur 2 octets à l'adresse MPU9150_TEMP_OUT_H (registres 65 (high) et 66 (low)). La valeur lue est une image de la température : Température en degré Celsius = valeur des registres / 340 + 35.

<syntaxhighlight lang="c">
/*
* @return temperature in degrees C = (TEMP_OUT signed / 340) + 35
* */
int16_t
mpu9150_read_temperature(void)
{
volatile uint8_t buffer[2] = { 0, 0 };
uint8_t reg = MPU9150_TEMP_OUT_H;

twi_read_bytes(MPU9150_DEFAULT_ADDRESS << 1, &reg, 2, buffer);

int16_t temperature;
temperature = ((buffer[0] << 8) + buffer[1]);
temperature /= 340;
temperature += 35;
return temperature;
}
</syntaxhighlight>

===== Lecture du gyroscope =====
On a définit une structure contenant les variables x, y et z pour stocker les valeurs sur les 3 axes.

<syntaxhighlight lang="c">
typedef struct
{
int16_t x;
int16_t y;
int16_t z;
} x_y_z;

x_y_z
mpu9150_read_gyroscope(void)
{
volatile uint8_t buffer[6];
uint8_t reg = MPU9150_GYRO_XOUT_H;

twi_read_bytes(MPU9150_DEFAULT_ADDRESS << 1, &reg, 6, buffer);

x_y_z gyro;
gyro.x = (buffer[0] << 8) + buffer[1];
gyro.y = (buffer[2] << 8) + buffer[3];
gyro.z = (buffer[4] << 8) + buffer[5];
return gyro;
}
</syntaxhighlight>

===== Lecture de l'accéléromètre =====
C'est le même modèle que la lecture du gyroscope.

<syntaxhighlight lang="c">
x_y_z
mpu9150_read_accelerometer(void)
{
volatile uint8_t buffer[6];
uint8_t reg = MPU9150_ACCEL_XOUT_H;

twi_read_bytes(MPU9150_DEFAULT_ADDRESS << 1, &reg, 6, buffer);

x_y_z accel;
accel.x = (buffer[0] << 8) + buffer[1];
accel.y = (buffer[2] << 8) + buffer[3];
accel.z = (buffer[4] << 8) + buffer[5];
return accel;
}
</syntaxhighlight>

===== Fonction de tests =====
La fonction principale demande les valeurs du capteur de température, du gyroscope et de l'accéléromètre et retourne les valeurs sur le port série.

<syntaxhighlight lang="c">
void
setup(void)
{
usart_0_setup();
usart_0_transmitter_enable();
mpu9150_setup();
}

int
main(void)
{
setup();
_delay_ms(1000);

while (1)
{
_delay_ms(1000);
int16_t t = mpu9150_read_temperature();

usart_0_transmit(t >> 8);
usart_0_transmit(t);

_delay_ms(1000);

x_y_z gyro = mpu9150_read_gyroscope();

usart_0_transmit(gyro.x >> 8);
usart_0_transmit(gyro.x);
usart_0_transmit(gyro.y >> 8);
usart_0_transmit(gyro.y);
usart_0_transmit(gyro.z >> 8);
usart_0_transmit(gyro.z);

_delay_ms(1000);

x_y_z acc = mpu9150_read_accelerometer();

usart_0_transmit(acc.x >> 8);
usart_0_transmit(acc.x);
usart_0_transmit(acc.y >> 8);
usart_0_transmit(acc.y);
usart_0_transmit(acc.z >> 8);
usart_0_transmit(gyro.z);
}
}
</syntaxhighlight>

[[Category:Produits]]

Accéléromètre-Gyroscope-Boussole 9 axes MPU-9150

2013-09-27T13:26:32Z

Ldoffe : Page créée avec « Le [http://www.invensense.com/mems/gyro/mpu9150.html MPU-9150], proposé par InvenSense, est un module permettant de détecter l'orientation sur 9 degré de liberté. Il e... »

Capteur US URM37

2013-09-02T13:46:33Z

Ldoffe : utilisation du capteur URM37 avec une ARDUINO UNO

Le capteur URM37 est un capteur de distance utilisant les ultrasons. Il a une portée de 4 à 500 cm avec une résolution de 1 cm. Ce capteur est également équipé d'un capteur de température (de -10 à 70 °C). Le principal avantage de ce capteur est de pouvoir contrôler directement un servomoteur dans le but de monter le capteur sur une tourelle pour faire un scanner. La précision de rotation du servomoteur est de 6°.

= Description des pins =

1. +VCC - +5V

2. GND - Masse

3. RST - Reset

4. PWM – sortie PWM

5. MOTO pour le contrôle d'un servomoteur

6. COMP/TRIG
COMP – En mode AUTO, la pin passe à 0 quand la distance détectée est plus petite que la distance seuil.
TRIG – En mode PWM, entrée trigger (pour déclencher une lecture)

7. NC

8. RXD - communication RS232, et TTL

9. TXD – communication RS232 et TTL

= Mode =
Ce capteur peut être utilisé selon 3 modes : communication série (TTL ou RS232), PWM ou TRIG AUTO. Le mode série est toujours activé et le capteur est toujours en attente d'une commande (configuration ou demande de lecture).

== Mode série ==
Ce mode très simple à mettre an œuvre permet de configurer les modes TRIG AUTO et PWM. Il sert également à lire la distance et la température.
=== RS232 / TTL ===
La liaison série peut être configurée en sortie RS232 (+12V / -12V) pour être utilisée directement avec un PC ou en sortie TTL (0V / +5V) pour être utilisée avec un microcontroleur. Les cavaliers J1, J2 et J3 permettent de changer la configuration de la liaison. La configuration est expliquée [http://www.dfrobot.com/wiki/index.php/URM37_V3.2_Ultrasonic_Sensor_%28SKU:SEN0001%29 ici].

Pour notre exemple, nous allons utiliser une ARDUINO UNO donc il faut donc configurer la liaison en sortie TTL.
=== Utilisation ===
Il faut brancher RX (pin 8) du capteur sur TX (pin 1) de la ARDUINO et TX (pin 9) du capteur sur RX (pin 0) de la ARDUINO. La sortie 5 MOTO du capteur doit être branchée sur l'entrée contrôle du servomoteur (fil orange).
=== Protocole série ===
La liaison série est configurée à 9600 baud avec 8 bits de données, 1 bit de stop et sans parité. Les trames envoyées ou reçues sont composées de 4 octets : commande + donnée1 + donnée2 + somme.
somme permet de contrôler que la trame envoyée ou reçue est correcte : on additionne sur 8 bits commande + donnée1 + donnée2.
Par exemple, la trame 0x44 + 0x02 + 0xAA donne une somme de 0xF0.
=== Commandes ===
==== Lecture de la température (16 bits) ====
Commande : 0x11＋NC＋NC＋Sum
Réponse : 0x11+High(temperature)+Low(temperature)+SUM
Remarques : La valeur de la température est sur 12 bits (4 bits faible de High et les 8 bits de Low). Les 4 premiers bits de High représente le signe. Si la température est positive, ils sont à 0. Si la température est négative ils sont à 1. La résolution est de 0,1.
Erreur : Si la lecture de la température est incorrecte, le capteur retourne 0x11+0xFF+0xFF+SUM
Exemple : 0x11 + 0x00 + 0xDC + 0x27 représente une température de 22°C (0xDC = 220)
0x11 + 0xF0 + 0x32 + 0x33 représente une température de -5°C (0x32 = 50)
==== Lecture de la distance (16 bits) ====
Commande : 0x22＋Degree＋NC＋SUM
Réponse : 0x22＋High(distance)＋Low(distance)+SUM
Remarques : Degree est un pas (de 0 à 46) qui correspond au degré de rotation du servomoteur (de 0 à 270°).
Si la lecture de distance est incorrecte, le capteur retourne 0x22+0xFF+0xFF+SUM.
Exemple : 0x22 + 0x03 + 0x00 + 0x25 est une demande de lecture de distance en plaçant le servo à 18°.
==== Lecture en EEPROM ====
Commande : 0x33＋Add＋NC＋SUM
Réponse : 0x33＋Add＋NC＋SUM
==== Ecriture en EEPROM ====
Cette écriture permet de configurer les modes PWM ou TRIG AUTO.
Commande : 0x44＋Add＋Data＋SUM
Réponse : 0x44＋Add＋Data＋SUM
Remarques : Les adresses (de 0x00 à 0x02) permettent de configurer les modes :
0x00 : distance seuil (Low)
0x01 : distance seuil (High)
0x02 : mode 0xAA pour TRIG AUTO et 0xBB pour PWM

Exemple : 0x44 + 0x02 + 0xBB + 0x01 configure le mode PWM.
=== Exemple Langage ARDUINO ===
Des exemples sont expliqués [http://www.dfrobot.com/wiki/index.php/URM37_V3.2_Ultrasonic_Sensor_%28SKU:SEN0001%29 ici].
=== Exemple Langage C ===
Dans un premier temps, il faut configurer la liaison série ( 9600 Baud, 8 bits de données, sans parité avec 1 bit de stop) et activer l’émission et la réception. Ensuite, il faut écrire les fonctions de base pour émettre et recevoir un octet.
<syntaxhighlight lang="c">
void
usart_0_setup(void)
{
DDRD &= ~(1 << PD0); /* initialize pin PD0 (RX) as input pin */
DDRD |= (1 << PD1); /* initialize pin PD1 (TX) as output pin */

UBRR0 = 103; /* 9600 Baud at 16MHz */

UCSR0A = 0;
UCSR0B |= (1 << RXEN0) | (1 << TXEN0);

/* 8-bits, no parity, 1-stop-bit */
UCSR0C = (1 << UCSZ01) | (1 << UCSZ00);
}

uint8_t
usart_0_receive(void)
{
// wait for data to be received
while (!(UCSR0A & (1 << RXC0)))
;
// get and return received data from buffer
//PORTB = 0xFF;
return UDR0 ;
}

// transmit a char
void
usart_0_transmit(uint8_t data)
{
// wait for empty transmit buffer
while (!(UCSR0A & (1 << UDRE0)))
;
// put data info buffer, sends the data
UDR0 = data;
}
</syntaxhighlight>

Ensuite, il faut écrire les fonctions du capteur pour pouvoir demander une lecture de distance et température.

urm37_send_command calcule la somme de la trame et envoie les 4 octets
<syntaxhighlight lang="c">
void
urm37_send_command(uint8_t command, uint8_t data1, uint8_t data2)
{
uint8_t sum = command + data1 + data2;
usart_0_transmit(command);
usart_0_transmit(data1);
usart_0_transmit(data2);
usart_0_transmit(sum);
}
</syntaxhighlight>
urm37_read_command receptionne la reponse du capteur et la stocke dans le tableau urm37_command
<syntaxhighlight lang="c">
void
urm37_read_command(void)
{
for (uint8_t i = 0; i < 4; i++)
{
urm37_command[i] = usart_0_receive();
}
}
</syntaxhighlight>

urm37_read_distance effectue une lecture en distance en précisant l'angle du servomoteur et retourne la distance. De même, urm37_read_temperature effectue une lecture de température et retourne la température du capteur.
<syntaxhighlight lang="c">
uint16_t
urm37_read_distance(uint16_t angle)
{
uint16_t distance = 0;

angle /= 6;
if (angle > 46)
{
angle = 46;
}
urm37_send_command(READ_DIST, angle, 0x00);

urm37_read_command();

distance = (urm37_command[1] << 8) + urm37_command[2];

return distance;
}

int16_t
urm37_read_temperature(void)
{
int16_t temperature;

urm37_send_command(READ_TEMP, 0x00, 0x00);
urm37_read_command();

if (urm37_command[1] >= 0xF0)
{
temperature = -(((urm37_command[1] - 0xF0) << 8) + urm37_command[2])
/ 10;
}
else
{
temperature = ((urm37_command[1] << 8) + urm37_command[2]) / 10;
}

return temperature;
}
</syntaxhighlight>

La fonction principale permet de faire une lecture de distance et de température toutes les secondes et de renvoyer les réponses sur le port série.
<syntaxhighlight lang="c">
void
setup(void)
{
usart_0_setup();
}

int
main(void)
{
unsigned int distance, temperature;

_delay_ms(1000); /* delay 1s */

while (1)
{
distance = urm37_read_distance(200);
_delay_ms(1000); // delay 1s

usart_0_transmit(distance);

/* uniquement en mode serie */
temperature = urm37_read_temperature();
_delay_ms(1000); /* delay 1s*/

usart_0_transmit(temperature);
}
}
</syntaxhighlight>

[[Category:Produits]]

Carte Romeo

2013-07-29T12:29:10Z

Ldoffe : /* Commande à distance */

La carte ROMEO de DFROBOT est une carte tout-en-un conçue pour faire ses premiers pas vers la robotique. Cette carte très simple d'utilisation permet de commander 2 moteurs, d'interfacer des capteurs et de piloter le robot à distance via un module X-bee. Elle est basée sur un microcontroleur ATMEGA32u4 (V2.0 R3).

Pour tester la carte ROMEO, nous avons utilisé la plateforme de développement Turtle 2WD de DFROBOT. Cette plateforme est équipée de 2 roues montées en direct sur 2 motoréducteurs.

== Commande des moteurs ==

Le moteur à courant continu est l'élément principal qui permet au robot de se déplacer. Sa vitesse est proportionnelle à la tension d'alimentation. Plus la tension est élevée plus le moteur va tourner rapidement. Il faut donc créer une tension continue variable pour faire varier la vitesse du moteur.

=== Signaux PWM ===
Les signaux PWM permettent de fournir une tension continue variable à partir de signaux numériques (0 et 5V). Le microcontroleur va générer un signal en forme de créneaux. En faisant varier le rapport cyclique, la tension moyenne va varier et le moteur va tourner plus ou moins vite.

=== Electronique ===
La carte ROMEO est équipée d'un module de commande pour moteur à courant continu (L298). Ce pont H va fournir la puissance nécessaire au moteur pour tourner. Le microcontroleur va fournir un signal PWM et un signal de direction pour chaque moteur.

=== Exemple de code ===
==== Langage Arduino ====
Le L298 utilise la pin 4 (M1 : direction) et 5 (E1 : PWM) pour le moteur 1 et la pin 6 (E2 : PWM) et 7 (M2 : direction) pour le moteur 2.

Un exemple avec le langage ARDUINO est expliqué [http://www.dfrobot.com/wiki/index.php/DFRduino_Romeo-All_in_one_Controller_V1.1%28SKU:DFR0004%29 ici]

==== Langage C ====
===== Fonctions PWM =====
Pour générer un signal PWM, le microcontroleur a besoin d'un timer interne. Il utilise le timer 3A pour E1 et le timer 4D pour E2.

Dans un premier temps, il faut initialiser les timers en mode PWM. Nous configurons le mode PWM avec des valeurs fréquemment utilisées pour la commande de moteurs.
<syntaxhighlight lang="c">
/* timer3 is used for phase-correct 8-bits PWM mode
and with clock prescaled to system clock divided by 64 */
void
pwm_3_setup(void)
{
/* set timer3 prescale factor to 64 */
TCCR3B = (1 << CS31) | (1 << CS30);
/* put timer3 in phase correct PWM mode */
TCCR3A = (1 << WGM30);
}

/* timer4 is used for phase and frequency correct 10-bits PWM mode
* and with clock prescaled to system clock divided by 64 */
void
pwm_4_setup(void)
{
TC4H = 0;
/* set timer4 prescale factor to 64 */
TCCR4B = (1 << CS42) | (1 << CS41) | (1 << CS40);
/* put timer 4 in phase and frequency correct PWM mode */
TCCR4D =(1 << WGM40);
/* not used */
TCCR4E = 0;
/* Set top to 0xFF */
OCR4C = 0xFF;
}
</syntaxhighlight>

Il faut activer les pins utilisées par le L298 (5:OC3A et 6:OC4D).
<syntaxhighlight lang="c">
/* enable OC4D (pin D6) as pwm output */
void
pwm_3A_enable(void)
{
/* enable PC6(OC3A) pin as output pin */
DDRC |= (1 << PORTC6);
/* enable OC3A pin as PWM pin */
TCCR3A |= (1 << COM3A1);
}

/* enable OC4D (pin D6) as pwm output */
void
pwm_4D_enable(void)
{
/* enable PD7 pin as output pin */
DDRD |= (1 << PORTD7);
/* enable OC4D pin as PWM pin */TCCR4C |= (1 << PWM4D);
TCCR4C |= (1 << COM4D1);
}
</syntaxhighlight>
Pour finir, il faut indiquer la valeur du PWM : cette valeur indique le temps haut du signal compris entre 0 et 255. Par exemple, pour avoir un signal carré (temps haut = temps bas), il faut avoir une valeur de 127. Ces valeurs sont écrites dans les registres OCRnx.

<syntaxhighlight lang="c">

/* write value a in PWM 3A */
void
pwm_3A_write(char a)
{
OCR3A = a;
}

/* write value a in PWM 4D */
void
pwm_4D_write(char a)
{
OCR4D = a;
}

</syntaxhighlight>

===== Fonctions moteur =====
Nous avons ensuite créer des fonctions qui permettent au robot d'avancer, reculer et tourner en précisant la vitesse (de 0 à 255).
<syntaxhighlight lang="c">

/* stop */
void
stop(void)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_4D_write(0);
pwm_3A_write(0);
}

/* advance
* speed from 0 to 255 */
void
advance(uint8_t m1_speed, uint8_t m2_speed)
{
PORTD |= (1 << PORT4); /* E1 (PD4) = 1 */
PORTE |= (1 << PORT6); /* E2 (PE6) = 1 */
pwm_3A_write(m1_speed);
pwm_4D_write(m2_speed);
}

/* back off
* speed from 0 to 255 */
void
back_off(uint8_t m1_speed, uint8_t m2_speed)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_3A_write(m1_speed);
pwm_4D_write(m2_speed);
}

/* turn left
* speed from 0 to 255 */
void
turn_left(uint8_t m1_speed, uint8_t m2_speed)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE |= (1 << PORT6); /* E2 (PE6) = 1 */
pwm_3A_write(m1_speed);
pwm_4D_write(m2_speed);

}

/* turn right
* speed from 0 to 255 */
void
turn_right(uint8_t m1_speed, uint8_t m2_speed)
{
PORTD |= (1 << PORT4); /* E1 (PD4) = 1 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_3A_write(m1_speed);
pwm_4D_write(m2_speed);
}
</syntaxhighlight>
Pour finir, la fonction principale main() et les fonctions setup() qui définissent l'état des pins (entrée ou sortie) et active les modules PWM.
<syntaxhighlight lang="c">
void
motor_setup(void)
{
/* Motor controller */
DDRD = (1 << PORTD4); /* E1 (PD4) as output pin */
DDRE = (1 << PORTE6); /* E2 (PE6) as output pin */

pwm_3_setup();
pwm_4_setup();

pwm_3A_enable();
pwm_4D_enable();
}

void
setup(void)
{
motor_setup();
}

int
main(void)
{
setup();
while (1)
{
turn_left(100);
//advance(200);
// stop();
}
return 0;
}
</syntaxhighlight>

== Communication XBee ==
Les modules Xbee de digi sont des modules de communication sans fils respectant la norme 802.15.4. Ces modules sont très simples à utiliser car ils convertissent les signaux Xbee en commande série.

La carte ROMEO est conçue pour recevoir un module Xbee lui permettant de communiquer à distance via sa liaison série. Le module est branché sur les pins 0 (RXD1) et 1 (TXD1) du microcontroleur utilisant l'USART 1.

=== Commande à distance ===
Nous allons utiliser ce module pour piloter le robot à distance à partir du PC en envoyant un caractère de commande à la carte ROMEO. Pour cela, il faut également un module et un adaptateur XBee USB pour le PC.

Dans un premier temps, nous allons configurer la liaison série. Le message envoyé contient 8 bits de données et 1 bit de stop sans contrôle de parité. La vitesse de transmission est de 9600 bauds.

<syntaxhighlight lang="c">
/* setup USART1
* speed : 9600 Baud
* 8-bits, no parity, 1-stop-bit */
void
USART_1_setup(void)
{
DDRD &= ~(1 << PD2); /* initialize pin PD2 (RX) as input pin */
DDRD |= (1 << PD3); /* initialize pin PD3 (TX) as output pin */

UBRR1 = 103; /* 9600 Baud at 16MHz */

UCSR1A = 0;

/* 8-bits, no parity, 1-stop-bit */
UCSR1C = (1 << UCSZ11) | (1 << UCSZ10);
}
</syntaxhighlight>

Il existe 2 solutions pour recevoir une donnée via la liaison série :
La première solution est très simple mais elle est bloquante. En effet, si aucune donnée n'est reçue (perte de communication), le programme va rester bloqué dans le « while » ce qui peut être gênant pour le système.

<syntaxhighlight lang="c">

void
USART_1_receiver_enable(void)
{
UCSR1B |= (1 << RXEN1);
}

unsigned char
USART_1_receive(void)
{
// wait for data to be received
while (!(UCSR1A & (1 << RXC1)))
;
// get and return received data from buffer
return UDR1 ;
}
</syntaxhighlight>

La seconde solution utilise les interruptions. La fonction ISR est exécutée seulement quand une donnée est reçue (flag levé). Le reste du temps, le programme est exécuté normalement sans attendre la réception d'une donnée.

<syntaxhighlight lang="c">
volatile char receive_char;

void
USART_1_receiver_interrupt_enable(void)
{
UCSR1B |= (1 << RXEN1);
/* enable interrupt on the RXC1 flag */
UCSR1B |= (1 << RXCIE1);
SREG |= (1 << SREG_I);
}

// receiver interrupt
ISR( USART1_RX_vect)
{
unsigned char dustbin = 0;

receive_char = UDR1;
}
</syntaxhighlight>

La fonction principale va tester le caractère reçu : 'a' pour avancer, 'b' pour reculer, 'r' pour tourner a droite, 'l' pour tourner à gauche et n'importe quel autre caractère pour s’arrêter.

<syntaxhighlight lang="c">
void
pin_setup(void)
{
/* Motor controller */
DDRD = (1 << PORTD4); /* PD4 as output pin */
DDRE = (1 << PORTE6); /* PE6 as output pin */
}

void
setup(void)
{
pin_setup();

pwm_3_setup();
pwm_4_setup();

pwm_3A_enable();
pwm_4D_enable();

USART_1_setup();
//USART_1_receiver_enable();
USART_1_receiver_interrupt_enable();
}

int
main(void)
{
//char c;
setup();

while (1)
{
//c = USART_1_receive();

switch (/*c*/receive_char)
{
case 'a':
advance(100);
break;
case 'b':
back_off(100);
break;
case 'r':
turn_right(100);
break;
case 'l':
turn_left(100);
break;
default:
stop();
break;
}
}
return 0;
}
</syntaxhighlight>

== Conversion analogique / numérique ==

Les capteurs que nous utilisons retourne généralement une information (tension) sous forme analogique. Pour exploiter cette information, le microcontroleur doit la convertir en signal numérique.

Le convertisseur analogique / numérique de l'ATMEGA32U4 est un convertisseur 10 bits soit une précision de 1024 points. En se basant sur une tension de référence (généralement la tension d'alimentation), il va, par approximation successive, définir la valeur numérique correspondante à la tension.

Dans un premier temps, nous allons configurer le convertisseur. Le microcontroleur a 6 entrées analogiques sur le port F qu'il faut configurer en entrée. La tension de référence pour effectuer la conversion est la tension d'alimentation Vcc = 5V.
<syntaxhighlight lang="c">
/* Voltage reference : Vcc
* Right adjust result
* and with clock prescaled to system clock divided by 1024 */
void
adc_setup(void)
{
/* initialize PORTF pins as input pin */
DDRF = 0x00;

/* set ADC prescale factor to 1024 */
ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);

/* Vcc is reference voltage */
ADMUX |= (1 << REFS0);

/* Set ADC to Free-Running Mode */
ADCSRB = 0;

/* adc enable */
ADCSRA |= (1 << ADEN);
}
</syntaxhighlight>

Ensuite, nous allons lire la valeur de chaque entrée en démarrant la conversion.
<syntaxhighlight lang="c">
void
adc_start_conversion(uint8_t pin)
{
//adc_enable(pin);
ADMUX = (1 << REFS0) | pin;
DIDR0 = (1 << pin);
ADCSRA |= (1 << ADSC); // adc start conversion
}

uint16_t
adc_read(uint8_t pin)
{
uint8_t low;
adc_start_conversion(pin);
while (ADCSRA & (1 << ADSC))
; // wait for result
low = ADCL; // must read LSB first
return (ADCH << 8) | low; // must read MSB only once!
}
</syntaxhighlight>

[[Category:Produits]]

Carte Romeo

2013-07-19T13:04:06Z

Ldoffe : /* Fonctions moteur */

La carte ROMEO de DFROBOT est une carte tout-en-un conçue pour faire ses premiers pas vers la robotique. Cette carte très simple d'utilisation permet de commander 2 moteurs, d'interfacer des capteurs et de piloter le robot à distance via un module X-bee. Elle est basée sur un microcontroleur ATMEGA32u4 (V2.0 R3).

Pour tester la carte ROMEO, nous avons utilisé la plateforme de développement Turtle 2WD de DFROBOT. Cette plateforme est équipée de 2 roues montées en direct sur 2 motoréducteurs.

== Commande des moteurs ==

Le moteur à courant continu est l'élément principal qui permet au robot de se déplacer. Sa vitesse est proportionnelle à la tension d'alimentation. Plus la tension est élevée plus le moteur va tourner rapidement. Il faut donc créer une tension continue variable pour faire varier la vitesse du moteur.

=== Signaux PWM ===
Les signaux PWM permettent de fournir une tension continue variable à partir de signaux numériques (0 et 5V). Le microcontroleur va générer un signal en forme de créneaux. En faisant varier le rapport cyclique, la tension moyenne va varier et le moteur va tourner plus ou moins vite.

=== Electronique ===
La carte ROMEO est équipée d'un module de commande pour moteur à courant continu (L298). Ce pont H va fournir la puissance nécessaire au moteur pour tourner. Le microcontroleur va fournir un signal PWM et un signal de direction pour chaque moteur.

=== Exemple de code ===
==== Langage Arduino ====
Le L298 utilise la pin 4 (M1 : direction) et 5 (E1 : PWM) pour le moteur 1 et la pin 6 (E2 : PWM) et 7 (M2 : direction) pour le moteur 2.

Un exemple avec le langage ARDUINO est expliqué [http://www.dfrobot.com/wiki/index.php/DFRduino_Romeo-All_in_one_Controller_V1.1%28SKU:DFR0004%29 ici]

==== Langage C ====
===== Fonctions PWM =====
Pour générer un signal PWM, le microcontroleur a besoin d'un timer interne. Il utilise le timer 3A pour E1 et le timer 4D pour E2.

Dans un premier temps, il faut initialiser les timers en mode PWM. Nous configurons le mode PWM avec des valeurs fréquemment utilisées pour la commande de moteurs.
<syntaxhighlight lang="c">
/* timer3 is used for phase-correct 8-bits PWM mode
and with clock prescaled to system clock divided by 64 */
void
pwm_3_setup(void)
{
/* set timer3 prescale factor to 64 */
TCCR3B = (1 << CS31) | (1 << CS30);
/* put timer3 in phase correct PWM mode */
TCCR3A = (1 << WGM30);
}

/* timer4 is used for phase and frequency correct 10-bits PWM mode
* and with clock prescaled to system clock divided by 64 */
void
pwm_4_setup(void)
{
TC4H = 0;
/* set timer4 prescale factor to 64 */
TCCR4B = (1 << CS42) | (1 << CS41) | (1 << CS40);
/* put timer 4 in phase and frequency correct PWM mode */
TCCR4D =(1 << WGM40);
/* not used */
TCCR4E = 0;
/* Set top to 0xFF */
OCR4C = 0xFF;
}
</syntaxhighlight>

Il faut activer les pins utilisées par le L298 (5:OC3A et 6:OC4D).
<syntaxhighlight lang="c">
/* enable OC4D (pin D6) as pwm output */
void
pwm_3A_enable(void)
{
/* enable PC6(OC3A) pin as output pin */
DDRC |= (1 << PORTC6);
/* enable OC3A pin as PWM pin */
TCCR3A |= (1 << COM3A1);
}

/* enable OC4D (pin D6) as pwm output */
void
pwm_4D_enable(void)
{
/* enable PD7 pin as output pin */
DDRD |= (1 << PORTD7);
/* enable OC4D pin as PWM pin */TCCR4C |= (1 << PWM4D);
TCCR4C |= (1 << COM4D1);
}
</syntaxhighlight>
Pour finir, il faut indiquer la valeur du PWM : cette valeur indique le temps haut du signal compris entre 0 et 255. Par exemple, pour avoir un signal carré (temps haut = temps bas), il faut avoir une valeur de 127. Ces valeurs sont écrites dans les registres OCRnx.

<syntaxhighlight lang="c">

/* write value a in PWM 3A */
void
pwm_3A_write(char a)
{
OCR3A = a;
}

/* write value a in PWM 4D */
void
pwm_4D_write(char a)
{
OCR4D = a;
}

</syntaxhighlight>

===== Fonctions moteur =====
Nous avons ensuite créer des fonctions qui permettent au robot d'avancer, reculer et tourner en précisant la vitesse (de 0 à 255).
<syntaxhighlight lang="c">

/* stop */
void
stop(void)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_4D_write(0);
pwm_3A_write(0);
}

/* advance
* speed from 0 to 255 */
void
advance(uint8_t m1_speed, uint8_t m2_speed)
{
PORTD |= (1 << PORT4); /* E1 (PD4) = 1 */
PORTE |= (1 << PORT6); /* E2 (PE6) = 1 */
pwm_3A_write(m1_speed);
pwm_4D_write(m2_speed);
}

/* back off
* speed from 0 to 255 */
void
back_off(uint8_t m1_speed, uint8_t m2_speed)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_3A_write(m1_speed);
pwm_4D_write(m2_speed);
}

/* turn left
* speed from 0 to 255 */
void
turn_left(uint8_t m1_speed, uint8_t m2_speed)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE |= (1 << PORT6); /* E2 (PE6) = 1 */
pwm_3A_write(m1_speed);
pwm_4D_write(m2_speed);

}

/* turn right
* speed from 0 to 255 */
void
turn_right(uint8_t m1_speed, uint8_t m2_speed)
{
PORTD |= (1 << PORT4); /* E1 (PD4) = 1 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_3A_write(m1_speed);
pwm_4D_write(m2_speed);
}
</syntaxhighlight>
Pour finir, la fonction principale main() et les fonctions setup() qui définissent l'état des pins (entrée ou sortie) et active les modules PWM.
<syntaxhighlight lang="c">
void
motor_setup(void)
{
/* Motor controller */
DDRD = (1 << PORTD4); /* E1 (PD4) as output pin */
DDRE = (1 << PORTE6); /* E2 (PE6) as output pin */

pwm_3_setup();
pwm_4_setup();

pwm_3A_enable();
pwm_4D_enable();
}

void
setup(void)
{
motor_setup();
}

int
main(void)
{
setup();
while (1)
{
turn_left(100);
//advance(200);
// stop();
}
return 0;
}
</syntaxhighlight>

== Communication XBee ==
Les modules Xbee de digi sont des modules de communication sans fils respectant la norme 802.15.4. Ces modules sont très simples à utiliser car ils convertissent les signaux Xbee en commande série.

La carte ROMEO est conçue pour recevoir un module Xbee lui permettant de communiquer à distance via sa liaison série. Le module est branché sur les pins 0 (RXD1) et 1 (TXD1) du microcontroleur utilisant l'USART 1.

=== Commande à distance ===
Nous allons utiliser ce module pour piloter le robot à distance à partir du PC en envoyant un caractère de commande à la carte ROMEO. Pour cela, il faut également un module et un adaptateur XBee USB pour le PC.

Dans un premier temps, nous allons configurer la liaison série. Le message envoyé contient 8 bits de données et 1 bit de stop sans contrôle de parité. La vitesse de transmission est de 9600 bauds.

<syntaxhighlight lang="c">
/* setup USART1
* speed : 9600 Baud
* 8-bits, no parity, 1-stop-bit */
void
USART_1_setup(void)
{
PORTD &= ~(1 << PORT2); /* initialize pin PD2 (RX) as input pin */
PORTD |= (1 << PORT3); /* initialize pin PD3 (TX) as output pin */

UBRR1 = 103; /* 9600 Baud at 16MHz */

UCSR1A = 0;

/* 8-bits, no parity, 1-stop-bit */
UCSR1C = (1 << UCSZ11) | (1 << UCSZ10);
}
</syntaxhighlight>

Il existe 2 solutions pour recevoir une donnée via la liaison série :
La première solution est très simple mais elle est bloquante. En effet, si aucune donnée n'est reçue (perte de communication), le programme va rester bloqué dans le « while » ce qui peut être gênant pour le système.

<syntaxhighlight lang="c">

void
USART_1_receiver_enable(void)
{
UCSR1B |= (1 << RXEN1);
}

unsigned char
USART_1_receive(void)
{
// wait for data to be received
while (!(UCSR1A & (1 << RXC1)))
;
// get and return received data from buffer
return UDR1 ;
}
</syntaxhighlight>

La seconde solution utilise les interruptions. La fonction ISR est exécutée seulement quand une donnée est reçue (flag levé). Le reste du temps, le programme est exécuté normalement sans attendre la réception d'une donnée.

<syntaxhighlight lang="c">
volatile char receive_char;

void
USART_1_receiver_interrupt_enable(void)
{
UCSR1B |= (1 << RXEN1);
/* enable interrupt on the RXC1 flag */
UCSR1B |= (1 << RXCIE1);
SREG |= (1 << SREG_I);
}

// receiver interrupt
ISR( USART1_RX_vect)
{
unsigned char dustbin = 0;

receive_char = UDR1;
}
</syntaxhighlight>

La fonction principale va tester le caractère reçu : 'a' pour avancer, 'b' pour reculer, 'r' pour tourner a droite, 'l' pour tourner à gauche et n'importe quel autre caractère pour s’arrêter.

<syntaxhighlight lang="c">
void
pin_setup(void)
{
/* Motor controller */
DDRD = (1 << PORTD4); /* PD4 as output pin */
DDRE = (1 << PORTE6); /* PE6 as output pin */
}

void
setup(void)
{
pin_setup();

pwm_3_setup();
pwm_4_setup();

pwm_3A_enable();
pwm_4D_enable();

USART_1_setup();
//USART_1_receiver_enable();
USART_1_receiver_interrupt_enable();
}

int
main(void)
{
//char c;
setup();

while (1)
{
//c = USART_1_receive();

switch (/*c*/receive_char)
{
case 'a':
advance(100);
break;
case 'b':
back_off(100);
break;
case 'r':
turn_right(100);
break;
case 'l':
turn_left(100);
break;
default:
stop();
break;
}
}
return 0;
}
</syntaxhighlight>

== Conversion analogique / numérique ==

Les capteurs que nous utilisons retourne généralement une information (tension) sous forme analogique. Pour exploiter cette information, le microcontroleur doit la convertir en signal numérique.

Le convertisseur analogique / numérique de l'ATMEGA32U4 est un convertisseur 10 bits soit une précision de 1024 points. En se basant sur une tension de référence (généralement la tension d'alimentation), il va, par approximation successive, définir la valeur numérique correspondante à la tension.

Dans un premier temps, nous allons configurer le convertisseur. Le microcontroleur a 6 entrées analogiques sur le port F qu'il faut configurer en entrée. La tension de référence pour effectuer la conversion est la tension d'alimentation Vcc = 5V.
<syntaxhighlight lang="c">
/* Voltage reference : Vcc
* Right adjust result
* and with clock prescaled to system clock divided by 1024 */
void
adc_setup(void)
{
/* initialize PORTF pins as input pin */
DDRF = 0x00;

/* set ADC prescale factor to 1024 */
ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);

/* Vcc is reference voltage */
ADMUX |= (1 << REFS0);

/* Set ADC to Free-Running Mode */
ADCSRB = 0;

/* adc enable */
ADCSRA |= (1 << ADEN);
}
</syntaxhighlight>

Ensuite, nous allons lire la valeur de chaque entrée en démarrant la conversion.
<syntaxhighlight lang="c">
void
adc_start_conversion(uint8_t pin)
{
//adc_enable(pin);
ADMUX = (1 << REFS0) | pin;
DIDR0 = (1 << pin);
ADCSRA |= (1 << ADSC); // adc start conversion
}

uint16_t
adc_read(uint8_t pin)
{
uint8_t low;
adc_start_conversion(pin);
while (ADCSRA & (1 << ADSC))
; // wait for result
low = ADCL; // must read LSB first
return (ADCH << 8) | low; // must read MSB only once!
}
</syntaxhighlight>

[[Category:Produits]]

Carte Romeo

2013-07-19T13:00:59Z

Ldoffe : /* Langage C */

La carte ROMEO de DFROBOT est une carte tout-en-un conçue pour faire ses premiers pas vers la robotique. Cette carte très simple d'utilisation permet de commander 2 moteurs, d'interfacer des capteurs et de piloter le robot à distance via un module X-bee. Elle est basée sur un microcontroleur ATMEGA32u4 (V2.0 R3).

Pour tester la carte ROMEO, nous avons utilisé la plateforme de développement Turtle 2WD de DFROBOT. Cette plateforme est équipée de 2 roues montées en direct sur 2 motoréducteurs.

== Commande des moteurs ==

Le moteur à courant continu est l'élément principal qui permet au robot de se déplacer. Sa vitesse est proportionnelle à la tension d'alimentation. Plus la tension est élevée plus le moteur va tourner rapidement. Il faut donc créer une tension continue variable pour faire varier la vitesse du moteur.

=== Signaux PWM ===
Les signaux PWM permettent de fournir une tension continue variable à partir de signaux numériques (0 et 5V). Le microcontroleur va générer un signal en forme de créneaux. En faisant varier le rapport cyclique, la tension moyenne va varier et le moteur va tourner plus ou moins vite.

=== Electronique ===
La carte ROMEO est équipée d'un module de commande pour moteur à courant continu (L298). Ce pont H va fournir la puissance nécessaire au moteur pour tourner. Le microcontroleur va fournir un signal PWM et un signal de direction pour chaque moteur.

=== Exemple de code ===
==== Langage Arduino ====
Le L298 utilise la pin 4 (M1 : direction) et 5 (E1 : PWM) pour le moteur 1 et la pin 6 (E2 : PWM) et 7 (M2 : direction) pour le moteur 2.

Un exemple avec le langage ARDUINO est expliqué [http://www.dfrobot.com/wiki/index.php/DFRduino_Romeo-All_in_one_Controller_V1.1%28SKU:DFR0004%29 ici]

==== Langage C ====
===== Fonctions PWM =====
Pour générer un signal PWM, le microcontroleur a besoin d'un timer interne. Il utilise le timer 3A pour E1 et le timer 4D pour E2.

Dans un premier temps, il faut initialiser les timers en mode PWM. Nous configurons le mode PWM avec des valeurs fréquemment utilisées pour la commande de moteurs.
<syntaxhighlight lang="c">
/* timer3 is used for phase-correct 8-bits PWM mode
and with clock prescaled to system clock divided by 64 */
void
pwm_3_setup(void)
{
/* set timer3 prescale factor to 64 */
TCCR3B = (1 << CS31) | (1 << CS30);
/* put timer3 in phase correct PWM mode */
TCCR3A = (1 << WGM30);
}

/* timer4 is used for phase and frequency correct 10-bits PWM mode
* and with clock prescaled to system clock divided by 64 */
void
pwm_4_setup(void)
{
TC4H = 0;
/* set timer4 prescale factor to 64 */
TCCR4B = (1 << CS42) | (1 << CS41) | (1 << CS40);
/* put timer 4 in phase and frequency correct PWM mode */
TCCR4D =(1 << WGM40);
/* not used */
TCCR4E = 0;
/* Set top to 0xFF */
OCR4C = 0xFF;
}
</syntaxhighlight>

Il faut activer les pins utilisées par le L298 (5:OC3A et 6:OC4D).
<syntaxhighlight lang="c">
/* enable OC4D (pin D6) as pwm output */
void
pwm_3A_enable(void)
{
/* enable PC6(OC3A) pin as output pin */
DDRC |= (1 << PORTC6);
/* enable OC3A pin as PWM pin */
TCCR3A |= (1 << COM3A1);
}

/* enable OC4D (pin D6) as pwm output */
void
pwm_4D_enable(void)
{
/* enable PD7 pin as output pin */
DDRD |= (1 << PORTD7);
/* enable OC4D pin as PWM pin */TCCR4C |= (1 << PWM4D);
TCCR4C |= (1 << COM4D1);
}
</syntaxhighlight>
Pour finir, il faut indiquer la valeur du PWM : cette valeur indique le temps haut du signal compris entre 0 et 255. Par exemple, pour avoir un signal carré (temps haut = temps bas), il faut avoir une valeur de 127. Ces valeurs sont écrites dans les registres OCRnx.

<syntaxhighlight lang="c">

/* write value a in PWM 3A */
void
pwm_3A_write(char a)
{
OCR3A = a;
}

/* write value a in PWM 4D */
void
pwm_4D_write(char a)
{
OCR4D = a;
}

</syntaxhighlight>

===== Fonctions moteur =====
Nous avons ensuite créer des fonctions qui permettent au robot d'avancer, reculer et tourner en précisant la vitesse (de 0 à 255).
<syntaxhighlight lang="c">
void
motor_setup(void)
{
/* Motor controller */
DDRD = (1 << PORTD4); /* E1 (PD4) as output pin */
DDRE = (1 << PORTE6); /* E2 (PE6) as output pin */

pwm_3_setup();
pwm_4_setup();

pwm_3A_enable();
pwm_4D_enable();
}

/* stop */
void
stop(void)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_4D_write(0);
pwm_3A_write(0);
}

/* advance
* speed from 0 to 255 */
void
advance(uint8_t m1_speed, uint8_t m2_speed)
{
PORTD |= (1 << PORT4); /* E1 (PD4) = 1 */
PORTE |= (1 << PORT6); /* E2 (PE6) = 1 */
pwm_3A_write(m1_speed);
pwm_4D_write(m2_speed);
}

/* back off
* speed from 0 to 255 */
void
back_off(uint8_t m1_speed, uint8_t m2_speed)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_3A_write(m1_speed);
pwm_4D_write(m2_speed);
}

/* turn left
* speed from 0 to 255 */
void
turn_left(uint8_t m1_speed, uint8_t m2_speed)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE |= (1 << PORT6); /* E2 (PE6) = 1 */
pwm_3A_write(m1_speed);
pwm_4D_write(m2_speed);

}

/* turn right
* speed from 0 to 255 */
void
turn_right(uint8_t m1_speed, uint8_t m2_speed)
{
PORTD |= (1 << PORT4); /* E1 (PD4) = 1 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_3A_write(m1_speed);
pwm_4D_write(m2_speed);
}
</syntaxhighlight>
Pour finir, les fonctions main() et setup()
<syntaxhighlight lang="c">

void
pin_setup(void)
{
/* Motor controller */
DDRD = (1 << PORTD4); /* PD4 as output pin */
DDRE = (1 << PORTE6); /* PE6 as output pin */
}

void
setup(void)
{
pin_setup();
pwm_3_setup();
pwm_4_setup();
pwm_3A_enable();
pwm_4D_enable();
}

int
main(void)
{
setup();
while (1)
{
turn_left(100);
//advance(200);
// stop();
}
return 0;
}
</syntaxhighlight>

== Communication XBee ==
Les modules Xbee de digi sont des modules de communication sans fils respectant la norme 802.15.4. Ces modules sont très simples à utiliser car ils convertissent les signaux Xbee en commande série.

La carte ROMEO est conçue pour recevoir un module Xbee lui permettant de communiquer à distance via sa liaison série. Le module est branché sur les pins 0 (RXD1) et 1 (TXD1) du microcontroleur utilisant l'USART 1.

=== Commande à distance ===
Nous allons utiliser ce module pour piloter le robot à distance à partir du PC en envoyant un caractère de commande à la carte ROMEO. Pour cela, il faut également un module et un adaptateur XBee USB pour le PC.

Dans un premier temps, nous allons configurer la liaison série. Le message envoyé contient 8 bits de données et 1 bit de stop sans contrôle de parité. La vitesse de transmission est de 9600 bauds.

<syntaxhighlight lang="c">
/* setup USART1
* speed : 9600 Baud
* 8-bits, no parity, 1-stop-bit */
void
USART_1_setup(void)
{
PORTD &= ~(1 << PORT2); /* initialize pin PD2 (RX) as input pin */
PORTD |= (1 << PORT3); /* initialize pin PD3 (TX) as output pin */

UBRR1 = 103; /* 9600 Baud at 16MHz */

UCSR1A = 0;

/* 8-bits, no parity, 1-stop-bit */
UCSR1C = (1 << UCSZ11) | (1 << UCSZ10);
}
</syntaxhighlight>

Il existe 2 solutions pour recevoir une donnée via la liaison série :
La première solution est très simple mais elle est bloquante. En effet, si aucune donnée n'est reçue (perte de communication), le programme va rester bloqué dans le « while » ce qui peut être gênant pour le système.

<syntaxhighlight lang="c">

void
USART_1_receiver_enable(void)
{
UCSR1B |= (1 << RXEN1);
}

unsigned char
USART_1_receive(void)
{
// wait for data to be received
while (!(UCSR1A & (1 << RXC1)))
;
// get and return received data from buffer
return UDR1 ;
}
</syntaxhighlight>

La seconde solution utilise les interruptions. La fonction ISR est exécutée seulement quand une donnée est reçue (flag levé). Le reste du temps, le programme est exécuté normalement sans attendre la réception d'une donnée.

<syntaxhighlight lang="c">
volatile char receive_char;

void
USART_1_receiver_interrupt_enable(void)
{
UCSR1B |= (1 << RXEN1);
/* enable interrupt on the RXC1 flag */
UCSR1B |= (1 << RXCIE1);
SREG |= (1 << SREG_I);
}

// receiver interrupt
ISR( USART1_RX_vect)
{
unsigned char dustbin = 0;

receive_char = UDR1;
}
</syntaxhighlight>

La fonction principale va tester le caractère reçu : 'a' pour avancer, 'b' pour reculer, 'r' pour tourner a droite, 'l' pour tourner à gauche et n'importe quel autre caractère pour s’arrêter.

<syntaxhighlight lang="c">
void
pin_setup(void)
{
/* Motor controller */
DDRD = (1 << PORTD4); /* PD4 as output pin */
DDRE = (1 << PORTE6); /* PE6 as output pin */
}

void
setup(void)
{
pin_setup();

pwm_3_setup();
pwm_4_setup();

pwm_3A_enable();
pwm_4D_enable();

USART_1_setup();
//USART_1_receiver_enable();
USART_1_receiver_interrupt_enable();
}

int
main(void)
{
//char c;
setup();

while (1)
{
//c = USART_1_receive();

switch (/*c*/receive_char)
{
case 'a':
advance(100);
break;
case 'b':
back_off(100);
break;
case 'r':
turn_right(100);
break;
case 'l':
turn_left(100);
break;
default:
stop();
break;
}
}
return 0;
}
</syntaxhighlight>

== Conversion analogique / numérique ==

Les capteurs que nous utilisons retourne généralement une information (tension) sous forme analogique. Pour exploiter cette information, le microcontroleur doit la convertir en signal numérique.

Le convertisseur analogique / numérique de l'ATMEGA32U4 est un convertisseur 10 bits soit une précision de 1024 points. En se basant sur une tension de référence (généralement la tension d'alimentation), il va, par approximation successive, définir la valeur numérique correspondante à la tension.

Dans un premier temps, nous allons configurer le convertisseur. Le microcontroleur a 6 entrées analogiques sur le port F qu'il faut configurer en entrée. La tension de référence pour effectuer la conversion est la tension d'alimentation Vcc = 5V.
<syntaxhighlight lang="c">
/* Voltage reference : Vcc
* Right adjust result
* and with clock prescaled to system clock divided by 1024 */
void
adc_setup(void)
{
/* initialize PORTF pins as input pin */
DDRF = 0x00;

/* set ADC prescale factor to 1024 */
ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);

/* Vcc is reference voltage */
ADMUX |= (1 << REFS0);

/* Set ADC to Free-Running Mode */
ADCSRB = 0;

/* adc enable */
ADCSRA |= (1 << ADEN);
}
</syntaxhighlight>

Ensuite, nous allons lire la valeur de chaque entrée en démarrant la conversion.
<syntaxhighlight lang="c">
void
adc_start_conversion(uint8_t pin)
{
//adc_enable(pin);
ADMUX = (1 << REFS0) | pin;
DIDR0 = (1 << pin);
ADCSRA |= (1 << ADSC); // adc start conversion
}

uint16_t
adc_read(uint8_t pin)
{
uint8_t low;
adc_start_conversion(pin);
while (ADCSRA & (1 << ADSC))
; // wait for result
low = ADCL; // must read LSB first
return (ADCH << 8) | low; // must read MSB only once!
}
</syntaxhighlight>

[[Category:Produits]]

Robot suiveur de ligne

2013-07-19T12:56:47Z

Ldoffe : robot suiveur de ligne

Un robot suiveur de ligne est un robot mobile qui va se déplacer en suivant une ligne (par exemple une ligne noire sur fond blanc). C'est un robot autonome très simple à concevoir.

== Matériel ==
Pour réaliser ce robot, nous avons besoin d'un chassis, d'une carte de commande et de capteurs :

* un chassis [http://www.dfrobot.com/wiki/index.php?title=2WD_Mobile_Platform_for_Arduino_%28SKU:ROB0005%29| Turtle 2WD] de DRFobot
* une [[Carte Romeo]] de DFRobot basée sur un ATMEGA32U4 et qui intègre un étage de puissance pour contrôler les 2 moteurs CC
* un [[Capteur niveau de gris DFR0022]] de DFRobot

== Principe général ==
Le robot doit suivre la ligne noire grâce aux capteurs niveau de gris. Si le capteur détecte du noir, le robot va tout droit. Si le capteur détecte du blanc, le robot a dévié de la ligne et doit donc corriger sa trajectoire.

== Tests ==

=== Robot avec un seul capteur ===
Pour commencer, nous allons installer un seul capteur sur notre robot.

==== Principe ====
Avec un seul capteur, il faut placer le robot à cheval sur la ligne (blanc à gauche et noir à droite). Si le capteur détecte du blanc, le robot doit corriger en allant à droite et inversement si le capteur détecte du noir, le robot doit corriger en allant sur la gauche. Si le capteur détecte une nuance entre les deux, le robot va tout droit.

==== Programme ====
Les fonctions sur le convertisseur analogique / numérique et le déplacement du robot sont expliqués [[carte Romeo| ici]].
La valeur du blanc est 55 et celle du noir est 260. On estime que la nuance de gris pour aller tout droit se situe entre 130 et 170. En dessous de cette nuance (inférieur à 130), le robot se dirige vers le blanc et doit tourner vers la droite en ralentissant son moteur droit. Au dessus de cette nuance (supérieur à 170), le robot se dirige vers le noir et doit tourner vers la gauche en ralentissant son moteur gauche.

<syntaxhighlight lang="c">

void
setup(void)
{
adc_setup();
motor_setup();
}

int
main(void)
{
setup();

while (1)
{
int niveau_gris = adc_read(0);

if ((niveau_gris >= 130) && (niveau_gris <= 170))
{
// avance
advance(100, 100);
}
else if (niveau_gris < 130) // blanc
{
// corrige a droite
advance(50, 100);
}
else // noir (gris > 170)
{
// corrige a gauche
advance(100, 50);
}
}
}

</syntaxhighlight>

==== Conclusion ====
Cette solution fonctionne très bien mais si le robot perd le bord de la ligne, il va tourner en rond sans jamais la retrouver. Pour éviter ce problème, il faut placer plusieurs capteurs en ligne.

[[Category:Tutoriels]]

Capteur niveau de gris DFR0022

2013-07-19T11:46:25Z

Ldoffe : capteur niveau de gris DFR0022

Ce capteur niveau de gris de DFRobot retourne une tension analogique image de la couleur détectée. Il est composé d'une led et d'une photo-résistance.

== Principe ==

La lumière émise par la led va plus ou moins se réfléchir selon la couleur rencontrée. Le blanc va réfléchir totalement la lumière alors que le noir va l'absorber. La photo-résistance est un composant dont la résistance interne varie en fonction de la lumière captée. Plus la lumière est intense moins sa résistivité est élevée. La tension de sortie va donc varier en fonction de la nuance de gris.

Nous avons mesurer 0.26V pour du blanc et 1.36V pour du noir.

== Utilisation ==

Ce capteur peut être utilisé pour faire un [[robot suiveur de ligne]].

== Tests ==

Nous avons testé ce capteur avec la [[Carte Romeo]] de DRFobot en utilisant le convertisseur analogique / numérique 10 bits (1024) avec une tension de référence Vcc (5V). Le principe et les fonctions du convertisseur sont expliqués [[Carte Romeo |ici]].

Le capteur est branché sur A5(ADC0).

'''Attention''' : le cable fournit avec le capteur ne correspond pas au brochage de la ROMEO. Il faut inverser la masse (noir) et alimentation (rouge) sur le connecteur noir allant sur la carte.

=== Langage ARDUINO ===
Un exemple avec le langage ARDUINO est expliqué [http://www.dfrobot.com/wiki/index.php?title=DFRobot_Grayscale_Sensor_%28SKU:DFR0022%29 |ici].

=== Langage C ===
Le programme est très simple. Il faut configurer le convertisseur analogique / numérique puis lire l'entrée analogique. "niveau_gris" contient la valeur qui correspond au niveau de gris. Plus elle est élevée, plus la couleur est foncée.
<syntaxhighlight lang="c">

void
setup(void)
{
adc_setup();
}

int
main(void)
{
setup();

while (1)
{
int niveau_gris = adc_read(0);
}
}

</syntaxhighlight>

[[Category:Produits]]

Accéléromètre MMA7361

2013-07-10T19:01:25Z

Ldoffe : A protégé « Accéléromètre MMA7361 » (‎[edit=sysop] (infini) ‎[move=sysop] (infini))

Un accéléromètre est un capteur qui permet de mesurer l'accélération linéaire d'un objet mobile. C'est un capteur utile pour un robot. Il va pouvoir par exemple détecter les chocs ou une pente. Couplé à un gyroscope (mesure de la vitesse angulaire), il devient un composant de la centrale inertielle qui permet de localiser le robot.

== Accéléromètre 3 axes MMA7361 ==

Ce module est basé sur l'accéléromètre 3 axes MMA7361 de Freescale. Il est possible de régler la précision entre 2 valeurs. En effet, un interrupteur permet de choisir une précision de 1,5g (800mV/g) ou de 6g (206mV/g). Ce capteur ratiométrique retourne une tension analogique proportionnelle à l'accélération et à la tension d'alimentation Vcc.

La tension retournée est comprise entre 0 et 3,3V (alimentation du MMA7361). Elle est centrée sur 1,65V qui correspond à 0g théorique. Cette valeur peut légèrement changer selon le capteur. Il est donc préférable de mesurer cette valeur.

== Tests ==

Nous avons tester ce capteur avec la [[Carte Romeo]] en utilisant le convertisseur analogique / numérique 10 bits (1024) avec une tension de référence Vcc (5V). Le principe et les fonctions du convertisseur sont expliqués [[Carte Romeo |ici]]

L'axe X est branché sur A5 (ADC0), Y sur A4 (ADC1) et Z sur A3 (ADC4). Nous choisissons une précision de 1,5g (800mV/g).

'''Attention''' : le cable fournit avec le capteur ne correspond pas au brochage de la ROMEO. Il faut inverser la masse (noir) et alimentation (rouge) sur le connecteur noir allant sur la carte.

=== Exemple de code ===

==== Langage Arduino ====

Un exemple avec le langage ARDUINO est expliqué [http://www.dfrobot.com/wiki/index.php/Triple_Axis_Accelerometer_MMA7361_%28SKU:_DFR0143%29 |ici]
==== Langage C ====

Dans un premier temps, nous allons lire la valeur sur l'entrée analogique. Puis nous allons définir l'accélération pour chaque axe en tenant compte de la précision et de la valeur du 0.

<syntaxhighlight lang="c">
#define VALUE_ZERO_G 1.7
#define SENSIBILITY 0.8

void
setup(void)
{
adc_setup();
}

int
main(void)
{
int adc_x, adc_y, adc_z;
double acc_x, acc_y, acc_z;

setup();

while (1)
{
/* X-axe */
adc_x = adc_read(0);

acc_x = (double) (adc_x * 5) / 1023;
acc_x -= VALUE_ZERO_G;
acc_x /= SENSIBILITY;

/* Y-axe */
adc_y = adc_read(1);

acc_y = (double) (adc_y * 5) / 1023;
acc_y -= VALUE_ZERO_G;
acc_y /= SENSIBILITY;

/* Z-axe */
adc_z = adc_read(4);

acc_z = (double) (adc_z * 5) / 1023;
acc_z -= VALUE_ZERO_G;
acc_z /= SENSIBILITY;
}
return 0;
}

</syntaxhighlight>

[[Category:Produits]]

Carte Romeo

2013-07-10T19:01:04Z

Ldoffe : A protégé « Carte Romeo » (‎[edit=sysop] (infini) ‎[move=sysop] (infini))

La carte ROMEO de DFROBOT est une carte tout-en-un conçue pour faire ses premiers pas vers la robotique. Cette carte très simple d'utilisation permet de commander 2 moteurs, d'interfacer des capteurs et de piloter le robot à distance via un module X-bee. Elle est basée sur un microcontroleur ATMEGA32u4 (V2.0 R3).

Pour tester la carte ROMEO, nous avons utilisé la plateforme de développement Turtle 2WD de DFROBOT. Cette plateforme est équipée de 2 roues montées en direct sur 2 motoréducteurs.

== Commande des moteurs ==

Le moteur à courant continu est l'élément principal qui permet au robot de se déplacer. Sa vitesse est proportionnelle à la tension d'alimentation. Plus la tension est élevée plus le moteur va tourner rapidement. Il faut donc créer une tension continue variable pour faire varier la vitesse du moteur.

=== Signaux PWM ===
Les signaux PWM permettent de fournir une tension continue variable à partir de signaux numériques (0 et 5V). Le microcontroleur va générer un signal en forme de créneaux. En faisant varier le rapport cyclique, la tension moyenne va varier et le moteur va tourner plus ou moins vite.

=== Electronique ===
La carte ROMEO est équipée d'un module de commande pour moteur à courant continu (L298). Ce pont H va fournir la puissance nécessaire au moteur pour tourner. Le microcontroleur va fournir un signal PWM et un signal de direction pour chaque moteur.

=== Exemple de code ===
==== Langage Arduino ====
Le L298 utilise la pin 4 (M1 : direction) et 5 (E1 : PWM) pour le moteur 1 et la pin 6 (E2 : PWM) et 7 (M2 : direction) pour le moteur 2.

Un exemple avec le langage ARDUINO est expliqué [http://www.dfrobot.com/wiki/index.php/DFRduino_Romeo-All_in_one_Controller_V1.1%28SKU:DFR0004%29 ici]

==== Langage C ====
Pour générer un signal PWM, le microcontroleur a besoin d'un timer interne. Il utilise le timer 3A pour E1 et le timer 4D pour E2.

Dans un premier temps, il faut initialiser les timers en mode PWM. Nous configurons le mode PWM avec des valeurs fréquemment utilisées pour la commande de moteurs.
<syntaxhighlight lang="c">
/* timer3 is used for phase-correct 8-bits PWM mode
and with clock prescaled to system clock divided by 64 */
void
pwm_3_setup(void)
{
/* set timer3 prescale factor to 64 */
TCCR3B = (1 << CS31) | (1 << CS30);
/* put timer3 in phase correct PWM mode */
TCCR3A = (1 << WGM30);
}

/* timer4 is used for phase and frequency correct 10-bits PWM mode
* and with clock prescaled to system clock divided by 64 */
void
pwm_4_setup(void)
{
TC4H = 0;
/* set timer4 prescale factor to 64 */
TCCR4B = (1 << CS42) | (1 << CS41) | (1 << CS40);
/* put timer 4 in phase and frequency correct PWM mode */
TCCR4D =(1 << WGM40);
/* not used */
TCCR4E = 0;
/* Set top to 0xFF */
OCR4C = 0xFF;
}
</syntaxhighlight>

Il faut activer les pins utilisées par le L298 (5:OC3A et 6:OC4D).
<syntaxhighlight lang="c">
/* enable OC4D (pin D6) as pwm output */
void
pwm_3A_enable(void)
{
/* enable PC6(OC3A) pin as output pin */
DDRC |= (1 << PORTC6);
/* enable OC3A pin as PWM pin */
TCCR3A |= (1 << COM3A1);
}

/* enable OC4D (pin D6) as pwm output */
void
pwm_4D_enable(void)
{
/* enable PD7 pin as output pin */
DDRD |= (1 << PORTD7);
/* enable OC4D pin as PWM pin */TCCR4C |= (1 << PWM4D);
TCCR4C |= (1 << COM4D1);
}
</syntaxhighlight>
Pour finir, il faut indiquer la valeur du PWM : cette valeur indique le temps haut du signal compris entre 0 et 255. Par exemple, pour avoir un signal carré (temps haut = temps bas), il faut avoir une valeur de 127. Ces valeurs sont écrites dans les registres OCRnx.

<syntaxhighlight lang="c">

/* write value a in PWM 3A */
void
pwm_3A_write(char a)
{
OCR3A = a;
}

/* write value a in PWM 4D */
void
pwm_4D_write(char a)
{
OCR4D = a;
}

</syntaxhighlight>

Nous avons ensuite créer des fonctions qui permettent au robot d'avancer, reculer et tourner en précisant la vitesse (de 0 à 255).
<syntaxhighlight lang="c">
/* stop */
void
stop(void)
{
pwm_4D_write(0);
pwm_3A_write(0);
}

/* advance
* speed from 0 to 255 */
void
advance(char speed)
{
PORTD |= (1 << PORT4); /* E1 (PD4) = 1 */
PORTE |= (1 << PORT6); /* E2 (PE6) = 1 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}

/* back off
* speed from 0 to 255 */
void
back_off(char speed)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}

/* turn left
* speed from 0 to 255 */
void
turn_left(char speed)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE |= (1 << PORT6); /* E2 (PE6) = 1 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}

/* turn right
* speed from 0 to 255 */
void
turn_right(char speed)
{
PORTD |= (1 << PORT4); /* E1 (PD4) = 1 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}
</syntaxhighlight>
Pour finir, les fonctions main() et setup()
<syntaxhighlight lang="c">

void
pin_setup(void)
{
/* Motor controller */
DDRD = (1 << PORTD4); /* PD4 as output pin */
DDRE = (1 << PORTE6); /* PE6 as output pin */
}

void
setup(void)
{
pin_setup();
pwm_3_setup();
pwm_4_setup();
pwm_3A_enable();
pwm_4D_enable();
}

int
main(void)
{
setup();
while (1)
{
turn_left(100);
//advance(200);
// stop();
}
return 0;
}
</syntaxhighlight>

== Communication XBee ==
Les modules Xbee de digi sont des modules de communication sans fils respectant la norme 802.15.4. Ces modules sont très simples à utiliser car ils convertissent les signaux Xbee en commande série.

La carte ROMEO est conçue pour recevoir un module Xbee lui permettant de communiquer à distance via sa liaison série. Le module est branché sur les pins 0 (RXD1) et 1 (TXD1) du microcontroleur utilisant l'USART 1.

=== Commande à distance ===
Nous allons utiliser ce module pour piloter le robot à distance à partir du PC en envoyant un caractère de commande à la carte ROMEO. Pour cela, il faut également un module et un adaptateur XBee USB pour le PC.

Dans un premier temps, nous allons configurer la liaison série. Le message envoyé contient 8 bits de données et 1 bit de stop sans contrôle de parité. La vitesse de transmission est de 9600 bauds.

<syntaxhighlight lang="c">
/* setup USART1
* speed : 9600 Baud
* 8-bits, no parity, 1-stop-bit */
void
USART_1_setup(void)
{
PORTD &= ~(1 << PORT2); /* initialize pin PD2 (RX) as input pin */
PORTD |= (1 << PORT3); /* initialize pin PD3 (TX) as output pin */

UBRR1 = 103; /* 9600 Baud at 16MHz */

UCSR1A = 0;

/* 8-bits, no parity, 1-stop-bit */
UCSR1C = (1 << UCSZ11) | (1 << UCSZ10);
}
</syntaxhighlight>

Il existe 2 solutions pour recevoir une donnée via la liaison série :
La première solution est très simple mais elle est bloquante. En effet, si aucune donnée n'est reçue (perte de communication), le programme va rester bloqué dans le « while » ce qui peut être gênant pour le système.

<syntaxhighlight lang="c">

void
USART_1_receiver_enable(void)
{
UCSR1B |= (1 << RXEN1);
}

unsigned char
USART_1_receive(void)
{
// wait for data to be received
while (!(UCSR1A & (1 << RXC1)))
;
// get and return received data from buffer
return UDR1 ;
}
</syntaxhighlight>

La seconde solution utilise les interruptions. La fonction ISR est exécutée seulement quand une donnée est reçue (flag levé). Le reste du temps, le programme est exécuté normalement sans attendre la réception d'une donnée.

<syntaxhighlight lang="c">
volatile char receive_char;

void
USART_1_receiver_interrupt_enable(void)
{
UCSR1B |= (1 << RXEN1);
/* enable interrupt on the RXC1 flag */
UCSR1B |= (1 << RXCIE1);
SREG |= (1 << SREG_I);
}

// receiver interrupt
ISR( USART1_RX_vect)
{
unsigned char dustbin = 0;

receive_char = UDR1;
}
</syntaxhighlight>

La fonction principale va tester le caractère reçu : 'a' pour avancer, 'b' pour reculer, 'r' pour tourner a droite, 'l' pour tourner à gauche et n'importe quel autre caractère pour s’arrêter.

<syntaxhighlight lang="c">
void
pin_setup(void)
{
/* Motor controller */
DDRD = (1 << PORTD4); /* PD4 as output pin */
DDRE = (1 << PORTE6); /* PE6 as output pin */
}

void
setup(void)
{
pin_setup();

pwm_3_setup();
pwm_4_setup();

pwm_3A_enable();
pwm_4D_enable();

USART_1_setup();
//USART_1_receiver_enable();
USART_1_receiver_interrupt_enable();
}

int
main(void)
{
//char c;
setup();

while (1)
{
//c = USART_1_receive();

switch (/*c*/receive_char)
{
case 'a':
advance(100);
break;
case 'b':
back_off(100);
break;
case 'r':
turn_right(100);
break;
case 'l':
turn_left(100);
break;
default:
stop();
break;
}
}
return 0;
}
</syntaxhighlight>

== Conversion analogique / numérique ==

Les capteurs que nous utilisons retourne généralement une information (tension) sous forme analogique. Pour exploiter cette information, le microcontroleur doit la convertir en signal numérique.

Le convertisseur analogique / numérique de l'ATMEGA32U4 est un convertisseur 10 bits soit une précision de 1024 points. En se basant sur une tension de référence (généralement la tension d'alimentation), il va, par approximation successive, définir la valeur numérique correspondante à la tension.

Dans un premier temps, nous allons configurer le convertisseur. Le microcontroleur a 6 entrées analogiques sur le port F qu'il faut configurer en entrée. La tension de référence pour effectuer la conversion est la tension d'alimentation Vcc = 5V.
<syntaxhighlight lang="c">
/* Voltage reference : Vcc
* Right adjust result
* and with clock prescaled to system clock divided by 1024 */
void
adc_setup(void)
{
/* initialize PORTF pins as input pin */
DDRF = 0x00;

/* set ADC prescale factor to 1024 */
ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);

/* Vcc is reference voltage */
ADMUX |= (1 << REFS0);

/* Set ADC to Free-Running Mode */
ADCSRB = 0;

/* adc enable */
ADCSRA |= (1 << ADEN);
}
</syntaxhighlight>

Ensuite, nous allons lire la valeur de chaque entrée en démarrant la conversion.
<syntaxhighlight lang="c">
void
adc_start_conversion(uint8_t pin)
{
//adc_enable(pin);
ADMUX = (1 << REFS0) | pin;
DIDR0 = (1 << pin);
ADCSRA |= (1 << ADSC); // adc start conversion
}

uint16_t
adc_read(uint8_t pin)
{
uint8_t low;
adc_start_conversion(pin);
while (ADCSRA & (1 << ADSC))
; // wait for result
low = ADCL; // must read LSB first
return (ADCH << 8) | low; // must read MSB only once!
}
</syntaxhighlight>

[[Category:Produits]]

Accéléromètre MMA7361

2013-07-10T14:36:47Z

Ldoffe : /* Langage C */

Accéléromètre MMA7361

2013-07-10T14:35:20Z

Ldoffe : Page créée avec « Un accéléromètre est un capteur qui permet de mesurer l'accélération linéaire d'un objet mobile. C'est un capteur utile pour un robot. Il va pouvoir par exemple dét... »

Un accéléromètre est un capteur qui permet de mesurer l'accélération linéaire d'un objet mobile. C'est un capteur utile pour un robot. Il va pouvoir par exemple détecter les chocs ou une pente. Couplé à un gyroscope (mesure de la vitesse angulaire), il devient un composant de la centrale inertielle qui permet de localiser le robot.

== Accéléromètre 3 axes MMA7361 ==

Ce module est basé sur l'accéléromètre 3 axes MMA7361 de Freescale. Il est possible de régler la précision entre 2 valeurs. En effet, un interrupteur permet de choisir une précision de 1,5g (800mV/g) ou de 6g (206mV/g). Ce capteur ratiométrique retourne une tension analogique proportionnelle à l'accélération et à la tension d'alimentation Vcc.

La tension retournée est comprise entre 0 et 3,3V (alimentation du MMA7361). Elle est centrée sur 1,65V qui correspond à 0g théorique. Cette valeur peut légèrement changer selon le capteur. Il est donc préférable de mesurer cette valeur.

== Tests ==

Nous avons tester ce capteur avec la [[Carte Romeo]] en utilisant le convertisseur analogique / numérique 10 bits (1024) avec une tension de référence Vcc (5V). Le principe et les fonctions du convertisseur sont expliqués [[Carte Romeo |ici]]

L'axe X est branché sur A5 (ADC0), Y sur A4 (ADC1) et Z sur A3 (ADC4). Nous choisissons une précision de 1,5g (800mV/g).

'''Attention''' : le cable fournit avec le capteur ne correspond pas au brochage de la ROMEO. Il faut inverser la masse (noir) et alimentation (rouge) sur le connecteur noir allant sur la carte.

=== Exemple de code ===

==== Langage Arduino ====

Un exemple avec le langage ARDUINO est expliqué [http://www.dfrobot.com/wiki/index.php/Triple_Axis_Accelerometer_MMA7361_%28SKU:_DFR0143%29 |ici]
==== Langage C ====

Dans un premier temps, nous allons lire la valeur sur l'entrée analogique. Puis nous allons définir l'accélération pour chaque axe en tenant compte de la précision et de la valeur du 0.

<syntaxhighlight lang="c">
void
setup(void)
{
adc_setup();
}

int
main(void)
{
int adc_x, adc_y, adc_z;
double acc_x, acc_y, acc_z;

setup();

while (1)
{
/* X-axe */
adc_x = adc_read(0);

acc_x = (double) (adc_x * 5) / 1023;
acc_x -= VALUE_ZERO_G;
acc_x /= SENSIBILITY;

/* Y-axe */
adc_y = adc_read(1);

acc_y = (double) (adc_y * 5) / 1023;
acc_y -= VALUE_ZERO_G;
acc_y /= SENSIBILITY;

/* Z-axe */
adc_z = adc_read(4);

acc_z = (double) (adc_z * 5) / 1023;
acc_z -= VALUE_ZERO_G;
acc_z /= SENSIBILITY;
}
return 0;
}

</syntaxhighlight>

[[Category:Produits]]

Carte Romeo

2013-07-10T12:42:53Z

Ldoffe : /* Communication XBee */

La carte ROMEO de DFROBOT est une carte tout-en-un conçue pour faire ses premiers pas vers la robotique. Cette carte très simple d'utilisation permet de commander 2 moteurs, d'interfacer des capteurs et de piloter le robot à distance via un module X-bee. Elle est basée sur un microcontroleur ATMEGA32u4 (V2.0 R3).

Pour tester la carte ROMEO, nous avons utilisé la plateforme de développement Turtle 2WD de DFROBOT. Cette plateforme est équipée de 2 roues montées en direct sur 2 motoréducteurs.

== Commande des moteurs ==

Le moteur à courant continu est l'élément principal qui permet au robot de se déplacer. Sa vitesse est proportionnelle à la tension d'alimentation. Plus la tension est élevée plus le moteur va tourner rapidement. Il faut donc créer une tension continue variable pour faire varier la vitesse du moteur.

=== Signaux PWM ===
Les signaux PWM permettent de fournir une tension continue variable à partir de signaux numériques (0 et 5V). Le microcontroleur va générer un signal en forme de créneaux. En faisant varier le rapport cyclique, la tension moyenne va varier et le moteur va tourner plus ou moins vite.

=== Electronique ===
La carte ROMEO est équipée d'un module de commande pour moteur à courant continu (L298). Ce pont H va fournir la puissance nécessaire au moteur pour tourner. Le microcontroleur va fournir un signal PWM et un signal de direction pour chaque moteur.

=== Exemple de code ===
==== Langage Arduino ====
Le L298 utilise la pin 4 (M1 : direction) et 5 (E1 : PWM) pour le moteur 1 et la pin 6 (E2 : PWM) et 7 (M2 : direction) pour le moteur 2.

Un exemple avec le langage ARDUINO est expliqué [http://www.dfrobot.com/wiki/index.php/DFRduino_Romeo-All_in_one_Controller_V1.1%28SKU:DFR0004%29 ici]

==== Langage C ====
Pour générer un signal PWM, le microcontroleur a besoin d'un timer interne. Il utilise le timer 3A pour E1 et le timer 4D pour E2.

Dans un premier temps, il faut initialiser les timers en mode PWM. Nous configurons le mode PWM avec des valeurs fréquemment utilisées pour la commande de moteurs.
<syntaxhighlight lang="c">
/* timer3 is used for phase-correct 8-bits PWM mode
and with clock prescaled to system clock divided by 64 */
void
pwm_3_setup(void)
{
/* set timer3 prescale factor to 64 */
TCCR3B = (1 << CS31) | (1 << CS30);
/* put timer3 in phase correct PWM mode */
TCCR3A = (1 << WGM30);
}

/* timer4 is used for phase and frequency correct 10-bits PWM mode
* and with clock prescaled to system clock divided by 64 */
void
pwm_4_setup(void)
{
TC4H = 0;
/* set timer4 prescale factor to 64 */
TCCR4B = (1 << CS42) | (1 << CS41) | (1 << CS40);
/* put timer 4 in phase and frequency correct PWM mode */
TCCR4D =(1 << WGM40);
/* not used */
TCCR4E = 0;
/* Set top to 0xFF */
OCR4C = 0xFF;
}
</syntaxhighlight>

Il faut activer les pins utilisées par le L298 (5:OC3A et 6:OC4D).
<syntaxhighlight lang="c">
/* enable OC4D (pin D6) as pwm output */
void
pwm_3A_enable(void)
{
/* enable PC6(OC3A) pin as output pin */
DDRC |= (1 << PORTC6);
/* enable OC3A pin as PWM pin */
TCCR3A |= (1 << COM3A1);
}

/* enable OC4D (pin D6) as pwm output */
void
pwm_4D_enable(void)
{
/* enable PD7 pin as output pin */
DDRD |= (1 << PORTD7);
/* enable OC4D pin as PWM pin */TCCR4C |= (1 << PWM4D);
TCCR4C |= (1 << COM4D1);
}
</syntaxhighlight>
Pour finir, il faut indiquer la valeur du PWM : cette valeur indique le temps haut du signal compris entre 0 et 255. Par exemple, pour avoir un signal carré (temps haut = temps bas), il faut avoir une valeur de 127. Ces valeurs sont écrites dans les registres OCRnx.

<syntaxhighlight lang="c">

/* write value a in PWM 3A */
void
pwm_3A_write(char a)
{
OCR3A = a;
}

/* write value a in PWM 4D */
void
pwm_4D_write(char a)
{
OCR4D = a;
}

</syntaxhighlight>

Nous avons ensuite créer des fonctions qui permettent au robot d'avancer, reculer et tourner en précisant la vitesse (de 0 à 255).
<syntaxhighlight lang="c">
/* stop */
void
stop(void)
{
pwm_4D_write(0);
pwm_3A_write(0);
}

/* advance
* speed from 0 to 255 */
void
advance(char speed)
{
PORTD |= (1 << PORT4); /* E1 (PD4) = 1 */
PORTE |= (1 << PORT6); /* E2 (PE6) = 1 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}

/* back off
* speed from 0 to 255 */
void
back_off(char speed)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}

/* turn left
* speed from 0 to 255 */
void
turn_left(char speed)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE |= (1 << PORT6); /* E2 (PE6) = 1 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}

/* turn right
* speed from 0 to 255 */
void
turn_right(char speed)
{
PORTD |= (1 << PORT4); /* E1 (PD4) = 1 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}
</syntaxhighlight>
Pour finir, les fonctions main() et setup()
<syntaxhighlight lang="c">

void
pin_setup(void)
{
/* Motor controller */
DDRD = (1 << PORTD4); /* PD4 as output pin */
DDRE = (1 << PORTE6); /* PE6 as output pin */
}

void
setup(void)
{
pin_setup();
pwm_3_setup();
pwm_4_setup();
pwm_3A_enable();
pwm_4D_enable();
}

int
main(void)
{
setup();
while (1)
{
turn_left(100);
//advance(200);
// stop();
}
return 0;
}
</syntaxhighlight>

== Communication XBee ==
Les modules Xbee de digi sont des modules de communication sans fils respectant la norme 802.15.4. Ces modules sont très simples à utiliser car ils convertissent les signaux Xbee en commande série.

La carte ROMEO est conçue pour recevoir un module Xbee lui permettant de communiquer à distance via sa liaison série. Le module est branché sur les pins 0 (RXD1) et 1 (TXD1) du microcontroleur utilisant l'USART 1.

=== Commande à distance ===
Nous allons utiliser ce module pour piloter le robot à distance à partir du PC en envoyant un caractère de commande à la carte ROMEO. Pour cela, il faut également un module et un adaptateur XBee USB pour le PC.

Dans un premier temps, nous allons configurer la liaison série. Le message envoyé contient 8 bits de données et 1 bit de stop sans contrôle de parité. La vitesse de transmission est de 9600 bauds.

<syntaxhighlight lang="c">
/* setup USART1
* speed : 9600 Baud
* 8-bits, no parity, 1-stop-bit */
void
USART_1_setup(void)
{
PORTD &= ~(1 << PORT2); /* initialize pin PD2 (RX) as input pin */
PORTD |= (1 << PORT3); /* initialize pin PD3 (TX) as output pin */

UBRR1 = 103; /* 9600 Baud at 16MHz */

UCSR1A = 0;

/* 8-bits, no parity, 1-stop-bit */
UCSR1C = (1 << UCSZ11) | (1 << UCSZ10);
}
</syntaxhighlight>

Il existe 2 solutions pour recevoir une donnée via la liaison série :
La première solution est très simple mais elle est bloquante. En effet, si aucune donnée n'est reçue (perte de communication), le programme va rester bloqué dans le « while » ce qui peut être gênant pour le système.

<syntaxhighlight lang="c">

void
USART_1_receiver_enable(void)
{
UCSR1B |= (1 << RXEN1);
}

unsigned char
USART_1_receive(void)
{
// wait for data to be received
while (!(UCSR1A & (1 << RXC1)))
;
// get and return received data from buffer
return UDR1 ;
}
</syntaxhighlight>

La seconde solution utilise les interruptions. La fonction ISR est exécutée seulement quand une donnée est reçue (flag levé). Le reste du temps, le programme est exécuté normalement sans attendre la réception d'une donnée.

<syntaxhighlight lang="c">
volatile char receive_char;

void
USART_1_receiver_interrupt_enable(void)
{
UCSR1B |= (1 << RXEN1);
/* enable interrupt on the RXC1 flag */
UCSR1B |= (1 << RXCIE1);
SREG |= (1 << SREG_I);
}

// receiver interrupt
ISR( USART1_RX_vect)
{
unsigned char dustbin = 0;

receive_char = UDR1;
}
</syntaxhighlight>

La fonction principale va tester le caractère reçu : 'a' pour avancer, 'b' pour reculer, 'r' pour tourner a droite, 'l' pour tourner à gauche et n'importe quel autre caractère pour s’arrêter.

<syntaxhighlight lang="c">
void
pin_setup(void)
{
/* Motor controller */
DDRD = (1 << PORTD4); /* PD4 as output pin */
DDRE = (1 << PORTE6); /* PE6 as output pin */
}

void
setup(void)
{
pin_setup();

pwm_3_setup();
pwm_4_setup();

pwm_3A_enable();
pwm_4D_enable();

USART_1_setup();
//USART_1_receiver_enable();
USART_1_receiver_interrupt_enable();
}

int
main(void)
{
//char c;
setup();

while (1)
{
//c = USART_1_receive();

switch (/*c*/receive_char)
{
case 'a':
advance(100);
break;
case 'b':
back_off(100);
break;
case 'r':
turn_right(100);
break;
case 'l':
turn_left(100);
break;
default:
stop();
break;
}
}
return 0;
}
</syntaxhighlight>

== Conversion analogique / numérique ==

Les capteurs que nous utilisons retourne généralement une information (tension) sous forme analogique. Pour exploiter cette information, le microcontroleur doit la convertir en signal numérique.

Le convertisseur analogique / numérique de l'ATMEGA32U4 est un convertisseur 10 bits soit une précision de 1024 points. En se basant sur une tension de référence (généralement la tension d'alimentation), il va, par approximation successive, définir la valeur numérique correspondante à la tension.

Dans un premier temps, nous allons configurer le convertisseur. Le microcontroleur a 6 entrées analogiques sur le port F qu'il faut configurer en entrée. La tension de référence pour effectuer la conversion est la tension d'alimentation Vcc = 5V.
<syntaxhighlight lang="c">
/* Voltage reference : Vcc
* Right adjust result
* and with clock prescaled to system clock divided by 1024 */
void
adc_setup(void)
{
/* initialize PORTF pins as input pin */
DDRF = 0x00;

/* set ADC prescale factor to 1024 */
ADCSRA |= (1 << ADPS2) | (1 << ADPS1) | (1 << ADPS0);

/* Vcc is reference voltage */
ADMUX |= (1 << REFS0);

/* Set ADC to Free-Running Mode */
ADCSRB = 0;

/* adc enable */
ADCSRA |= (1 << ADEN);
}
</syntaxhighlight>

Ensuite, nous allons lire la valeur de chaque entrée en démarrant la conversion.
<syntaxhighlight lang="c">
void
adc_start_conversion(uint8_t pin)
{
//adc_enable(pin);
ADMUX = (1 << REFS0) | pin;
DIDR0 = (1 << pin);
ADCSRA |= (1 << ADSC); // adc start conversion
}

uint16_t
adc_read(uint8_t pin)
{
uint8_t low;
adc_start_conversion(pin);
while (ADCSRA & (1 << ADSC))
; // wait for result
low = ADCL; // must read LSB first
return (ADCH << 8) | low; // must read MSB only once!
}
</syntaxhighlight>

[[Category:Produits]]

Carte Romeo

2013-06-28T11:51:52Z

Ldoffe : /* Commande des moteurs */

La carte ROMEO de DFROBOT est une carte tout-en-un conçue pour faire ses premiers pas vers la robotique. Cette carte très simple d'utilisation permet de commander 2 moteurs, d'interfacer des capteurs et de piloter le robot à distance via un module X-bee. Elle est basée sur un microcontroleur ATMEGA32u4 (V2.0 R3).

Pour tester la carte ROMEO, nous avons utilisé la plateforme de développement Turtle 2WD de DFROBOT. Cette plateforme est équipée de 2 roues montées en direct sur 2 motoréducteurs.

== Commande des moteurs ==

Le moteur à courant continu est l'élément principal qui permet au robot de se déplacer. Sa vitesse est proportionnelle à la tension d'alimentation. Plus la tension est élevée plus le moteur va tourner rapidement. Il faut donc créer une tension continue variable pour faire varier la vitesse du moteur.

=== Signaux PWM ===
Les signaux PWM permettent de fournir une tension continue variable à partir de signaux numériques (0 et 5V). Le microcontroleur va générer un signal en forme de créneaux. En faisant varier le rapport cyclique, la tension moyenne va varier et le moteur va tourner plus ou moins vite.

=== Electronique ===
La carte ROMEO est équipée d'un module de commande pour moteur à courant continu (L298). Ce pont H va fournir la puissance nécessaire au moteur pour tourner. Le microcontroleur va fournir un signal PWM et un signal de direction pour chaque moteur.

=== Exemple de code ===
==== Langage Arduino ====
Le L298 utilise la pin 4 (M1 : direction) et 5 (E1 : PWM) pour le moteur 1 et la pin 6 (E2 : PWM) et 7 (M2 : direction) pour le moteur 2.

Un exemple avec le langage ARDUINO est expliqué [http://www.dfrobot.com/wiki/index.php/DFRduino_Romeo-All_in_one_Controller_V1.1%28SKU:DFR0004%29 ici]

==== Langage C ====
Pour générer un signal PWM, le microcontroleur a besoin d'un timer interne. Il utilise le timer 3A pour E1 et le timer 4D pour E2.

Dans un premier temps, il faut initialiser les timers en mode PWM. Nous configurons le mode PWM avec des valeurs fréquemment utilisées pour la commande de moteurs.
<syntaxhighlight lang="c">
/* timer3 is used for phase-correct 8-bits PWM mode
and with clock prescaled to system clock divided by 64 */
void
pwm_3_setup(void)
{
/* set timer3 prescale factor to 64 */
TCCR3B = (1 << CS31) | (1 << CS30);
/* put timer3 in phase correct PWM mode */
TCCR3A = (1 << WGM30);
}

/* timer4 is used for phase and frequency correct 10-bits PWM mode
* and with clock prescaled to system clock divided by 64 */
void
pwm_4_setup(void)
{
TC4H = 0;
/* set timer4 prescale factor to 64 */
TCCR4B = (1 << CS42) | (1 << CS41) | (1 << CS40);
/* put timer 4 in phase and frequency correct PWM mode */
TCCR4D =(1 << WGM40);
/* not used */
TCCR4E = 0;
/* Set top to 0xFF */
OCR4C = 0xFF;
}
</syntaxhighlight>

Il faut activer les pins utilisées par le L298 (5:OC3A et 6:OC4D).
<syntaxhighlight lang="c">
/* enable OC4D (pin D6) as pwm output */
void
pwm_3A_enable(void)
{
/* enable PC6(OC3A) pin as output pin */
DDRC |= (1 << PORTC6);
/* enable OC3A pin as PWM pin */
TCCR3A |= (1 << COM3A1);
}

/* enable OC4D (pin D6) as pwm output */
void
pwm_4D_enable(void)
{
/* enable PD7 pin as output pin */
DDRD |= (1 << PORTD7);
/* enable OC4D pin as PWM pin */TCCR4C |= (1 << PWM4D);
TCCR4C |= (1 << COM4D1);
}
</syntaxhighlight>
Pour finir, il faut indiquer la valeur du PWM : cette valeur indique le temps haut du signal compris entre 0 et 255. Par exemple, pour avoir un signal carré (temps haut = temps bas), il faut avoir une valeur de 127. Ces valeurs sont écrites dans les registres OCRnx.

<syntaxhighlight lang="c">

/* write value a in PWM 3A */
void
pwm_3A_write(char a)
{
OCR3A = a;
}

/* write value a in PWM 4D */
void
pwm_4D_write(char a)
{
OCR4D = a;
}

</syntaxhighlight>

Nous avons ensuite créer des fonctions qui permettent au robot d'avancer, reculer et tourner en précisant la vitesse (de 0 à 255).
<syntaxhighlight lang="c">
/* stop */
void
stop(void)
{
pwm_4D_write(0);
pwm_3A_write(0);
}

/* advance
* speed from 0 to 255 */
void
advance(char speed)
{
PORTD |= (1 << PORT4); /* E1 (PD4) = 1 */
PORTE |= (1 << PORT6); /* E2 (PE6) = 1 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}

/* back off
* speed from 0 to 255 */
void
back_off(char speed)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}

/* turn left
* speed from 0 to 255 */
void
turn_left(char speed)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE |= (1 << PORT6); /* E2 (PE6) = 1 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}

/* turn right
* speed from 0 to 255 */
void
turn_right(char speed)
{
PORTD |= (1 << PORT4); /* E1 (PD4) = 1 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}
</syntaxhighlight>
Pour finir, les fonctions main() et setup()
<syntaxhighlight lang="c">

void
pin_setup(void)
{
/* Motor controller */
DDRD = (1 << PORTD4); /* PD4 as output pin */
DDRE = (1 << PORTE6); /* PE6 as output pin */
}

void
setup(void)
{
pin_setup();
pwm_3_setup();
pwm_4_setup();
pwm_3A_enable();
pwm_4D_enable();
}

int
main(void)
{
setup();
while (1)
{
turn_left(100);
//advance(200);
// stop();
}
return 0;
}
</syntaxhighlight>

== Communication XBee ==
Les modules Xbee de digi sont des modules de communication sans fils respectant la norme 802.15.4. Ces modules sont très simples à utiliser car ils convertissent les signaux Xbee en commande série.

La carte ROMEO est conçue pour recevoir un module Xbee lui permettant de communiquer à distance via sa liaison série. Le module est branché sur les pins 0 (RXD1) et 1 (TXD1) du microcontroleur utilisant l'USART 1.

=== Commande à distance ===
Nous allons utiliser ce module pour piloter le robot à distance à partir du PC en envoyant un caractère de commande à la carte ROMEO. Pour cela, il faut également un module et un adaptateur XBee USB pour le PC.

Dans un premier temps, nous allons configurer la liaison série. Le message envoyé contient 8 bits de données et 1 bit de stop sans contrôle de parité. La vitesse de transmission est de 9600 bauds.

<syntaxhighlight lang="c">
/* setup USART1
* speed : 9600 Baud
* 8-bits, no parity, 1-stop-bit */
void
USART_1_setup(void)
{
PORTD &= ~(1 << PORT2); /* initialize pin PD2 (RX) as input pin */
PORTD |= (1 << PORT3); /* initialize pin PD3 (TX) as output pin */

UBRR1 = 103; /* 9600 Baud at 16MHz */

UCSR1A = 0;

/* 8-bits, no parity, 1-stop-bit */
UCSR1C = (1 << UCSZ11) | (1 << UCSZ10);
}
</syntaxhighlight>

Il existe 2 solutions pour recevoir une donnée via la liaison série :
La première solution est très simple mais elle est bloquante. En effet, si aucune donnée n'est reçue (perte de communication), le programme va rester bloqué dans le « while » ce qui peut être gênant pour le système.

<syntaxhighlight lang="c">

void
USART_1_receiver_enable(void)
{
UCSR1B |= (1 << RXEN1);
}

unsigned char
USART_1_receive(void)
{
// wait for data to be received
while (!(UCSR1A & (1 << RXC1)))
;
// get and return received data from buffer
return UDR1 ;
}
</syntaxhighlight>

La seconde solution utilise les interruptions. La fonction ISR est exécutée seulement quand une donnée est reçue (flag levé). Le reste du temps, le programme est exécuté normalement sans attendre la réception d'une donnée.

<syntaxhighlight lang="c">
volatile char receive_char;

void
USART_1_receiver_interrupt_enable(void)
{
UCSR1B |= (1 << RXEN1);
/* enable interrupt on the RXC1 flag */
UCSR1B |= (1 << RXCIE1);
SREG |= (1 << SREG_I);
}

// receiver interrupt
ISR( USART1_RX_vect)
{
unsigned char dustbin = 0;

receive_char = UDR1;
}
</syntaxhighlight>

La fonction principale va tester le caractère reçu : 'a' pour avancer, 'b' pour reculer, 'r' pour tourner a droite, 'l' pour tourner à gauche et n'importe quel autre caractère pour s’arrêter.

<syntaxhighlight lang="c">
void
pin_setup(void)
{
/* Motor controller */
DDRD = (1 << PORTD4); /* PD4 as output pin */
DDRE = (1 << PORTE6); /* PE6 as output pin */
}

void
setup(void)
{
pin_setup();

pwm_3_setup();
pwm_4_setup();

pwm_3A_enable();
pwm_4D_enable();

USART_1_setup();
//USART_1_receiver_enable();
USART_1_receiver_interrupt_enable();
}

int
main(void)
{
//char c;
setup();

while (1)
{
//c = USART_1_receive();

switch (/*c*/receive_char)
{
case 'a':
advance(100);
break;
case 'b':
back_off(100);
break;
case 'r':
turn_right(100);
break;
case 'l':
turn_left(100);
break;
default:
stop();
break;
}
}
return 0;
}
</syntaxhighlight>

[[Category:Produits]]

Carte Romeo

2013-06-28T09:44:36Z

Ldoffe : /* Langage C */

Accueil

2013-06-25T19:34:37Z

Ldoffe :

Bonjour et Bienvenue sur le Wiki d'Arobose.

Vous pouvez y trouver des tutoriels sur la Robotique et des explications sur les produits de la Boutique, des exemples, des librairies Arduino, bref plein de solutions, d'idée et de techniques pour créer, améliorer votre robot.

Admin

'''<categorytree mode=pages>Sommaire</categorytree>'''

Accueil

2013-06-25T19:27:59Z

Ldoffe :

Carte Romeo

2013-06-25T19:21:36Z

Ldoffe :

Accueil

2013-06-25T19:20:31Z

Ldoffe :

Catégorie:Produits

2013-06-25T19:13:26Z

Ldoffe :

Présentation, Détails techniques, exemples d'utilisation de produits proposés sur notre site.

[[Category:Sommaire]]

Carte Romeo

2013-06-25T19:10:32Z

Ldoffe :

Carte Romeo

2013-06-25T19:09:56Z

Ldoffe :

Catégorie:Produits

2013-06-25T19:07:39Z

Ldoffe :

Présentation, Détails techniques, exemples d'utilisation de produits proposés sur notre site.

[[Catégorie:Sommaire]]

Carte Romeo

2013-06-25T19:07:18Z

Ldoffe :

Carte Romeo

2013-06-25T19:05:49Z

Ldoffe :

Carte Romeo

2013-06-25T19:01:47Z

Ldoffe :

<categorytree mode=pages>Produits</categorytree>
La carte ROMEO de DFROBOT est une carte tout-en-un conçue pour faire ses premiers pas vers la robotique. Cette carte très simple d'utilisation permet de commander 2 moteurs, d'interfacer des capteurs et de piloter le robot à distance via un module X-bee. Elle est basée sur un microcontroleur ATMEGA32u4 (V2.0 R3).

Pour tester la carte ROMEO, nous avons utilisé la plateforme de développement Turtle 2WD de DFROBOT. Cette plateforme est équipée de 2 roues montées en direct sur 2 motoréducteurs.

== Commande des moteurs ==

Le moteur à courant continu est l'élément principal qui permet au robot de se déplacer. Sa vitesse est proportionnelle à la tension d'alimentation. Plus la tension est élevée plus le moteur va tourner rapidement. Il faut donc créer une tension continue variable pour faire varier la vitesse du moteur.

=== Signaux PWM ===
Les signaux PWM permettent de fournir une tension continue variable à partir de signaux numériques (0 et 5V). Le microcontroleur va générer un signal en forme de créneaux. En faisant varier le rapport cyclique, la tension moyenne va varier et le moteur va tourner plus ou moins vite.

=== Electronique ===
La carte ROMEO est équipée d'un module de commande pour moteur à courant continu (L298). Ce pont H va fournir la puissance nécessaire au moteur pour tourner. Le microcontroleur va fournir un signal PWM et un signal de direction pour chaque moteur.

=== Exemple de code ===
==== Langage Arduino ====
Le L298 utilise la pin 4 (M1 : direction) et 5 (E1 : PWM) pour le moteur 1 et la pin 6 (E2 : PWM) et 7 (M2 : direction) pour le moteur 2.

Un exemple avec le langage ARDUINO est expliqué [http://www.dfrobot.com/wiki/index.php/DFRduino_Romeo-All_in_one_Controller_V1.1%28SKU:DFR0004%29 ici]

==== Langage C ====
Pour générer un signal PWM, le microcontroleur a besoin d'un timer interne. Il utilise le timer 3A pour E1 et le timer 4D pour E2.

Dans un premier temps, il faut initialiser les timers en mode PWM. Nous configurons le mode PWM avec des valeurs fréquemment utilisées pour la commande de moteurs.
<syntaxhighlight lang="php">
/* timer3 is used for phase-correct 8-bits PWM mode
and with clock prescaled to system clock divided by 64 */
void
pwm_3_setup(void)
{
/* set timer3 prescale factor to 64 */
TCCR3B = (1 << CS31) | (1 << CS30);
/* put timer3 in phase correct PWM mode */
TCCR3A = (1 << WGM30);
}

/* timer4 is used for phase and frequency correct 10-bits PWM mode
* and with clock prescaled to system clock divided by 64 */
void
pwm_4_setup(void)
{
TC4H = 0;
/* set timer4 prescale factor to 64 */
TCCR4B = (1 << CS42) | (1 << CS41) | (1 << CS40);
/* put timer 4 in phase and frequency correct PWM mode */
TCCR4D =(1 << WGM40);
/* not used */
TCCR4E = 0;
/* Set top to 0xFF */
OCR4C = 0xFF;
}
</syntaxhighlight>

Il faut activer les pins utilisées par le L298 (5:OC3A et 6:OC4D).
<syntaxhighlight lang="php">
/* enable OC4D (pin D6) as pwm output */
void
pwm_3A_enable(void)
{
/* enable PC6(OC3A) pin as output pin */
DDRC |= (1 << PORTC6);
/* enable OC3A pin as PWM pin */
TCCR3A |= (1 << COM3A1);
}

/* enable OC4D (pin D6) as pwm output */
void
pwm_4D_enable(void)
{
/* enable PD7 pin as output pin */
DDRD |= (1 << PORTD7);
/* enable OC4D pin as PWM pin */TCCR4C |= (1 << PWM4D);
TCCR4C |= (1 << COM4D1);
}
</syntaxhighlight>
Nous avons ensuite créer des fonctions qui permettent au robot d'avancer, reculer et tourner en précisant la vitesse (de 0 à 255).
<syntaxhighlight lang="php">
/* stop */
void
stop(void)
{
pwm_4D_write(0);
pwm_3A_write(0);
}

/* advance
* speed from 0 to 255 */
void
advance(char speed)
{
PORTD |= (1 << PORT4); /* E1 (PD4) = 1 */
PORTE |= (1 << PORT6); /* E2 (PE6) = 1 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}

/* back off
* speed from 0 to 255 */
void
back_off(char speed)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}

/* turn left
* speed from 0 to 255 */
void
turn_left(char speed)
{
PORTD &= ~(1 << PORT4); /* E1 (PD4) = 0 */
PORTE |= (1 << PORT6); /* E2 (PE6) = 1 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}

/* turn right
* speed from 0 to 255 */
void
turn_right(char speed)
{
PORTD |= (1 << PORT4); /* E1 (PD4) = 1 */
PORTE &= ~(1 << PORT6); /* E2 (PE6) = 0 */
pwm_4D_write(speed);
pwm_3A_write(speed);
}
</syntaxhighlight>
Pour finir, les fonctions main() et setup()
<syntaxhighlight lang="php">
void
setup(void)
{
pin_setup();
pwm_3_setup();
pwm_4_setup();
pwm_3A_enable();
pwm_4D_enable();
}

int
main(void)
{
setup();
while (1)
{
turn_left(100);
//advance(200);
// stop();
}
return 0;
}
</syntaxhighlight>

Catégorie:Produits

2013-06-25T18:59:03Z

Ldoffe :

Présentation, Détails techniques, exemples d'utilisation de produits proposés sur notre site.

[[Carte Romeo]]

[[Catégorie:Sommaire]]