Catégorie:RobotGEII : Différence entre versions
(→{{Rouge|Carte ultrason (Alexandre.N)}}) |
(→{{Rouge|Carte ultrason (Vincent)}}) |
||
Ligne 211 : | Ligne 211 : | ||
={{Rouge|Carte ultrason (Vincent)}}= | ={{Rouge|Carte ultrason (Vincent)}}= | ||
+ | |||
+ | ={{Bleu|Conception de la carte ultrason}}= | ||
+ | |||
+ | La carte ultrason joue un rôle essentiel dans les déplacements de notre robot, elle est chargée de détecter les obstacles de manière précise et rapide afin d'informer le robot sur leur position pour qu'il puisse réagir et les éviter. | ||
+ | Pour détecter les obstacles nous utilisons le module HC-SR04 permettant l'acquisition d'une information de distance. | ||
+ | |||
+ | [[Fichier:HC-SR04.jpg|300px]] | ||
+ | |||
+ | *'''Présentation du module HC-SR04''' : Le HC-SR04 est un module ultrason permettant l'évaluation d'une distance de 2cm à 4m. La mesure est réalisée "sans contact". Le module est composé d'un émetteur et d'un récepteur ultrason ainsi qu'une électronique de contrôle. Le fonctionnement de ce module s'apparente à celui d'un sonar de sous marin et sa mise en œuvre est relativement simple car il est prêt à l'emploi et possède 4 pattes: un GND, un VCC, un triger pour effectuer la mesure et un Écho pour le résultat de la mesure. | ||
={{Bleu|Conception de la carte ultrason}}= | ={{Bleu|Conception de la carte ultrason}}= |
Version du 28 octobre 2015 à 14:27
Sommaire
- 1 Description et présentation du Projet
- 2 Carte ultrason (Alexandre.N)
- 3 Carte gestion des moteurs (Johan)
- 4 Carte ultrason (Vincent)
- 5 Conception de la carte ultrason
- 6 Conception de la carte ultrason
- 7 Comunication SPI arduino (Alexandre.L)
- 7.1 Principe de la communication SPI sur Arduino
- 7.2 Maintenant que le principe de fonctionnement de la liaison SPI est éclaircit, intéressons nous aux échanges de données:
- 7.3 Avec ces quelques bases, nous pouvons comprendre le programme Arduino suivant qui établit une communication quelques peu rudimentaire, mais qui illustre les fonctions Arduino utilisées pour créer une communication SPI:
- 7.4 Codeur et mesure
- 8 système de fin de course (ballon) (Maxime)
Description et présentation du Projet
Présentation du championnat
Structure du robot
Carte ultrason (Alexandre.N)
programme de test des capteurs US :
int trig = 36;
int echo = A9;
long lecture_echo;
long cm;
void setup()
{
pinMode(trig, OUTPUT);
digitalWrite(trig, LOW);
pinMode(echo, INPUT);
Serial.begin(9600);
}
void loop()
{
digitalWrite(trig, HIGH);
delayMicroseconds(10);
digitalWrite(trig, LOW);
lecture_echo = pulseIn(echo, HIGH);
cm = lecture_echo / 58;
Serial.print("Distance : ");
Serial.print(cm);
Serial.println(" cm");
delay(100);
}
programme final des capteur US :
#include <util/delay.h>
#define distUSmini 30
/* _Trigger_
37 - PC0
36 - PC1
35 - PC2
34 - PC3
33 - PC4
32 - PC5
31 - PC6
_Echo_
8 - PK0
9 - PK1
10 - PK2
11 - PK3
12 - PK4
13 - PK5
14 - PK6
*/
boolean toggle1 = 0;
volatile unsigned long t[8];
unsigned long tfin, tdebut, d;
volatile boolean recpt;
volatile boolean newmesure = false;
volatile char numCapt;
volatile uint8_t USmode;
void setup() {
Serial.begin(115200);
pinMode(37, OUTPUT);
pinMode(36, OUTPUT);
pinMode(35, OUTPUT);
pinMode(34, OUTPUT);
pinMode(33, OUTPUT);
pinMode(32, OUTPUT);
pinMode(31, OUTPUT);
cli();
TCCR2A = 0;
TCCR2B = 0;
OCR2A = 156;
TCCR2B |= (1 << WGM12);
TCCR2B |= (1 << CS11);
TCCR2B |= (1 << CS10);
TCCR2B |= (1 << CS12);
TIMSK2 |= (1 << OCIE1A);
PCICR |= 1 << PCIE2;
sei();
}
ISR(TIMER2_COMPA_vect)
{
static boolean start = true;
if (start == true)
{
if (USmode == 0) numCapt = 7;
if (USmode == 1) numCapt = 0;
if (numCapt != 7) //mode1
{
numCapt++;
if (numCapt == 2) numCapt = 0; //à retirer quand 7 capteurs
}
TCCR2B &= ~((1 << CS12) | (1 << CS10));
OCR2A = 150;
if (numCapt == 7) // mode0
{
PORTC = 0b01111111;
PCMSK2 = 0b01111111;
}
else
{
PORTC = 1 << numCapt;
PCMSK2 = 1 << numCapt;
}
}
else
{
PORTC = 0;
recpt = false;
TCCR2B |= ((1 << CS12) | (1 << CS10));
OCR2A = 30;
}
start = !start;
}
ISR(PCINT2_vect)
{
if (recpt == false)
{
tdebut = micros();
recpt = true;
}
else
{
tfin = micros();
if ((tfin - tdebut) > 50)
{
t[numCapt] = tfin - tdebut;
recpt = false;
newmesure = true;
}
}
}
void loop() {
setUSmode(0);
static unsigned long dateAffichage = 0, dateActuelle;
dateActuelle = millis();
if (newmesure == true)
{
//t = tfin - tdebut;
if ((dateActuelle - dateAffichage) > 200)
{
//if
dateAffichage = dateActuelle;
//d = t / 58;
Serial.print("Duree 0: ");
Serial.print(t[0], DEC);
Serial.println(" us.");
Serial.print("Duree 1: ");
Serial.print(t[1], DEC);
Serial.println(" us.");
Serial.print("Duree 2: ");
Serial.print(t[2], DEC);
Serial.println(" us.");
Serial.print("Duree 3: ");
Serial.print(t[3], DEC);
Serial.println(" us.");
Serial.print("Duree 4: ");
Serial.print(t[4], DEC);
Serial.println(" us.");
Serial.print("Duree 5: ");
Serial.print(t[5], DEC);
Serial.println(" us.");
Serial.print("Duree 6: ");
Serial.print(t[6], DEC);
Serial.println(" us.");
Serial.print("Duree 7: ");
Serial.print(t[7], DEC);
Serial.println(" us.");
}
newmesure = false;
}
}
void setUSmode(uint8_t mode)
{
if (mode == 0) {
USmode = 0;
//numCapt=7;
}
if (mode == 1) {
USmode = 1;
//numCapt=0;
}
}
Carte gestion des moteurs (Johan)
Carte ultrason (Vincent)
Conception de la carte ultrason
La carte ultrason joue un rôle essentiel dans les déplacements de notre robot, elle est chargée de détecter les obstacles de manière précise et rapide afin d'informer le robot sur leur position pour qu'il puisse réagir et les éviter. Pour détecter les obstacles nous utilisons le module HC-SR04 permettant l'acquisition d'une information de distance.
- Présentation du module HC-SR04 : Le HC-SR04 est un module ultrason permettant l'évaluation d'une distance de 2cm à 4m. La mesure est réalisée "sans contact". Le module est composé d'un émetteur et d'un récepteur ultrason ainsi qu'une électronique de contrôle. Le fonctionnement de ce module s'apparente à celui d'un sonar de sous marin et sa mise en œuvre est relativement simple car il est prêt à l'emploi et possède 4 pattes: un GND, un VCC, un triger pour effectuer la mesure et un Écho pour le résultat de la mesure.
Conception de la carte ultrason
La carte ultrason joue un rôle essentiel dans les déplacements de notre robot, elle est chargée de détecter les obstacles de manière précise et rapide afin d'informer le robot sur leur position pour qu'il puisse réagir et les éviter. Pour détecter les obstacles nous utilisons le module HC-SR04 permettant l'acquisition d'une information de distance.
- Présentation du module HC-SR04 : Le HC-SR04 est un module ultrason permettant l'évaluation d'une distance de 2cm à 4m. La mesure est réalisée "sans contact". Le module est composé d'un émetteur et d'un récepteur ultrason ainsi qu'une électronique de contrôle. Le fonctionnement de ce module s'apparente à celui d'un sonar de sous marin et sa mise en œuvre est relativement simple car il est prêt à l'emploi et possède 4 pattes: un GND, un VCC, un triger pour effectuer la mesure et un Écho pour le résultat de la mesure.
Comunication SPI arduino (Alexandre.L)
Principe de la communication SPI sur Arduino
Une liaison SPI (Serial Peripheral Interface) est un bus de données série synchrone, qui opère en Full-duplex. Les circuits communiquent selon un schéma maître-esclaves, où le maître s'occupe totalement de la communication. Plusieurs esclaves peuvent coexister sur un même bus, dans ce cas, la sélection du destinataire se fait par le Slave Select.
on dispose donc des pattes suivantes:
- MOSI : Master Output Slave Input, le maître parle l'esclave écoute
- MISO : Master Input Slave Output, le maître écoute, l’esclave parle
- SLK : Serial Clock, Horloge de synchronisation généré par le maître
- SS : Slave Select, utilisé si on dispose de plusieurs esclaves pour sélectionner avec lequel on communique
Maintenant que le principe de fonctionnement de la liaison SPI est éclaircit, intéressons nous aux échanges de données:
on notera que les données circulent de manière circulaire; le bit 7 du master arrive sur b0 du slave, tandis que b7 du slave est envoyé sur b0 du master. il y a un décalage des bits contenus dans le registre SPDR (registre qui stock les données recues et envoyées sur la liaison SPI).
Avec ces quelques bases, nous pouvons comprendre le programme Arduino suivant qui établit une communication quelques peu rudimentaire, mais qui illustre les fonctions Arduino utilisées pour créer une communication SPI:
la carte Arduino Uno que nous utilisons possède déjà des pattes dédiées à la communication SPI:
- MOSI : Pin 11
- MISO : Pin 12
- SCLK : Pin 13
- SS : Pin 10
- N'oublions pas de connecter les masses Arduino ensembles pour que la tension de référence soit la même
Programme maître:
// Written by Nick Gammon
// February 2011
#include <SPI.h>
void setup (void)
{
digitalWrite(SS, HIGH); // ensure SS stays high for now
// Put SCK, MOSI, SS pins into output mode
// also put SCK, MOSI into LOW state, and SS into HIGH state.
// Then put SPI hardware into Master mode and turn SPI on
SPI.begin ();
// Slow down the master a bit
SPI.setClockDivider(SPI_CLOCK_DIV8);
Serial.begin(115200);
} // end of setup
void loop (void)
{
char c,r;
// enable Slave Select
digitalWrite(SS, LOW); // SS is pin 10
// send test string
for (const char * p = "Hello, world!\n" ; c = *p; p++)
Serial.write(SPI.transfer (c));
Serial.write('\n');
// disable Slave Select
digitalWrite(SS, HIGH);
delay (1000); // 1 seconds delay
} // end of loop
Programme esclave:
// Written by Nick Gammon
// February 2011
#include <SPI.h>
char buf [100];
volatile byte pos;
volatile boolean process_it;
void setup (void)
{
Serial.begin (115200); // debugging
// turn on SPI in slave mode
SPCR |= bit (SPE);
// have to send on master in, *slave out*
pinMode(MISO, OUTPUT);
// get ready for an interrupt
pos = 0; // buffer empty
process_it = false;
// now turn on interrupts
SPI.attachInterrupt();
} // end of setup
// SPI interrupt routine
ISR (SPI_STC_vect)
{
static uint8_t i=0;
byte c = SPDR; // grab byte from SPI Data Register
// add to buffer if room
if (pos < sizeof buf)
{
buf [pos++] = c;
// SPDR=i;
// i++;
// example: newline means time to process buffer
if (c == '\n')
process_it = true;
} // end of room available
} // end of interrupt routine SPI_STC_vect
// main loop - wait for flag set in interrupt routine
void loop (void)
{
if (process_it)
{
buf [pos] = 0;
Serial.println (buf);
pos = 0;
process_it = false;
} // end of flag set
} // end of loop
Codeur et mesure
système de fin de course (ballon) (Maxime)
Pages dans la catégorie « RobotGEII »
Cette catégorie comprend 4 pages, dont les 4 ci-dessous.