Catégorie:RobotGEII

De troyesGEII
Révision datée du 28 octobre 2015 à 14:46 par Bjacquot (discussion | contributions) (→‎{{Bleu|Conception de la carte ultrason}})
Aller à : navigation, rechercher


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;
  }

}

Capteur US.jpg

Carte gestion des moteurs (Johan)

Carte ultrason (Vincent)

Presentation

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.

HC-SR04.jpg

  • 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

Tout d'abord, pour la conception de cette carte, le module HC-SR04 n’étant pas répertorié par Eagle nous devons donc créer le composant, ainsi que son empreinte sur Eagle qui comportera la taille réelle du composant

Symbole du module HCSR04 Empreinte du module HCSR04

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.


SPI three slaves.svg.png

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:


SPI 8-bit circular transfer.svg.png

Todo.jpg 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:

Todo.jpg 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)

Sous-catégories

Cette catégorie comprend seulement la sous-catégorie ci-dessous.

R

Pages dans la catégorie « RobotGEII »

Cette catégorie comprend 4 pages, dont les 4 ci-dessous.

C

P

R

Récupérée de « http://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Catégorie:RobotGEII&oldid=6586 »