Voir la source de Capteur US URM37

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