Wiki Arobose - Nouvelles pages [fr]

Ubuntu personnalisée pour pcDuino

2013-11-25T15:42:56Z

Gdo :

Pré-requis :
* Une ubuntu >= 12.04
* Une carte micro-SD >= 2Go
* Une connexion à internet
* Télécharger le package [https://github.com/geonobot/make_deb_distro/releases/download/0.1/make-deb-distro-0.1.deb make-deb-distro]
* Télécharger le profil pour la pcduino : [https://github.com/geonobot/pcduino-profile/archive/master.zip pcduino-profile]

Pour pouvoir créer notre carte micro-SD prête à l'emploi pour pcDuino, nous allons utiliser un programme nommé make_deb_distro.
Celui-ci permet de créer une distribution Ubuntu ou Debian personnalisée pour différentes cibles, grâce à un système de profils.

Commencons par installer le package make-deb-distro :
<syntaxhighlight lang="bash">sudo dpkg -i make-deb-distro-0.1.deb
sudo apt-get -f install</syntaxhighlight>

Créez un répertoire, par exemple build/, et copiez y le profil de notre pcDuino que vous avez normalement téléchargé dans les pré-requis :
<syntaxhighlight lang="bash">mkdir build
cp pcduino-profile-master.zip build/
</syntaxhighlight>

Il faut maintenant décompresser l'archive du profil et entrer dans son répertoire :
<syntaxhighlight lang="bash">cd build
unzip pcduino-profile-master.zip
cd pcduino-profile-master</syntaxhighlight>

Il ne reste plus qu'à insérer notre carte micro-SD et à appeler notre programme make-deb-distro en lui indiquant notre profil et les options voulues :
<syntaxhighlight lang="bash">sudo make-deb-distro -a install -b /dev/mmcblk0 -c pcduino.conf -p "vim openssh-server language-pack-fr language-pack-fr-base isc-dhcp-client"</syntaxhighlight>

La première fois qu'elle est lancée, cette commande est très longue et dépend de la puissance de votre PC ainsi que de la qualité de votre connexion internet.
Une fois l'exécution terminée, la carte est prête à être utilisée sur la pcduino.

Pour des explications sur les options passée à notre commande, lancez la commande '''make-deb-distro --help''' :
<syntaxhighlight lang="bash">make-deb-distro --help
This script build custom Ubuntu/Debian distributions.

./make-deb-distro [-a <action>] [OPTIONS]

Options:
(-a|--action) <action> Action : install or uninstall.
(-b|--target-device) <device> Target device
(-c|--configuration) <file> Configuration file
(-d|--target-dir) <path> Bootstrap path
(-e|--excluded-packages) "<excluded-packages>" Packages to exclude from bootstrap process. List must be quoted.
(-f|--only-rootfs) Build rootfs only
(-h|--help) Display this help message
(-n|--distro-version) <distro-name> Debian/Ubuntu distribution name (same as host by default).
(-o|--deb-packages) "<deb-packages>" Local .deb packages. List must be quoted.
(-p|--packages) "<packages>" Distro packages to use. List must be quoted.
(--script-rootfs) <script> Launch your script after rootfs is created and all package installed.
(--script-prepare) <script> Launch your script to prepare the target device.
(/usr/share/make-deb-distro/scripts/profiles/default/prepare.sh by default)
(--script-burn) <script> Launch your script to burn rootfs on target device.
(/usr/share/make-deb-distro/scripts/profiles/default/burn.sh by default)
(-t|--target) <target> Target achitecture (same as host by default).
(-v|--verbose) Verbose mode</syntaxhighlight>

Donc si par exemple vous souhaitez rajouter un environnement graphique ubuntu, vous devrez modifier l'option '''-p''' en ajoutant le package '''ubuntu-desktop''' :
<syntaxhighlight lang="bash">sudo make-deb-distro -a uninstall -c pcduino.conf
sudo make-deb-distro -a install -b /dev/mmcblk0 -c pcduino.conf -p "vim openssh-server language-pack-fr language-pack-fr-base isc-dhcp-client ubuntu-desktop"</syntaxhighlight>

Toutes les options en ligne de commande peuvent être initialisées dans le fichier de conf passé en paramètre ('''pcduino.conf''').

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:26:32Z

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]]

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]]

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-10T14:35:20Z

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]]

Accueil

2013-06-01T18:08:51Z

Gdo :

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 depth=10>Sommaire</categorytree>'''

Main Page

2012-05-03T12:57:38Z

MediaWiki default :

'''MediaWiki has been successfully installed.'''

Consult the [//meta.wikimedia.org/wiki/Help:Contents User's Guide] for information on using the wiki software.

== Getting started ==
* [//www.mediawiki.org/wiki/Manual:Configuration_settings Configuration settings list]
* [//www.mediawiki.org/wiki/Manual:FAQ MediaWiki FAQ]
* [https://lists.wikimedia.org/mailman/listinfo/mediawiki-announce MediaWiki release mailing list]