Cours:Télémètre

De troyesGEII
Aller à : navigation, rechercher

Ressources enseignant

Présentation du projet

Objectif

Ce projet consiste à réaliser un télémètre à ultrasons.

Notions de base

télémètre de chantier
transducteurs ultrasons

Un télémètre est un instrument qui permet de mesurer la distance séparant un observateur d'un point éloigné par des procédés optiques , acoustiques ou radioélectriques et qui est employé par exemple par les photographes, géomètres et géographes ainsi que dans l'armée et l'aviation.

L'ultrason (US) est une onde mécanique et élastique, diffusée par les gaz, les liquides, les tissus mous (chair, organes) ou les solides. La gamme de fréquences des ultrasons se situe entre 16 000 et 10 000 000 Hertz donc trop élevées pour être perçues par l'oreille humaine.

La mesure par ultrasons utilise un ensemble composé de deux transducteurs (un émetteur et un récepteur), parfois dans le même élément, associé à une électronique de contrôle.

Principe du télémètre

mesure par réflexion

Le télémètre à ultrason émet un signal à une fréquence en ultra-sonique et attend le retour d'un écho provoqué par la réflexion de l'onde émise. La distance est mesurée à partir de la vitesse de propagation de l'onde et du temps qui sépare la génération du signal et la réception de l'écho. La vitesse du son dans l'air est de 342 m/s à 20°C ( 331 m/s à 0° C).

Autres applications des ultrasons

contrôle de pièce par ultrasons
Echographie médicale

Les ultrasons sont utilisés pour mesurer les distances, mais aussi dans le domaine médical pour les échographies et industriel pour la recherche de défauts ( crack sur le dessin ) dans des pièces métalliques

Principe de mesure

Il est basé sur la mesure du temps écoulé entre l’émission et le retour de l’écho. Lors de la commande de mesure, le télémètre met le chronomètre à zéro puis commence l’émission d'une salve ultrasonique. L’onde ultrasonore se propage à la vitesse du son dans l’air environnant, soit 342m/sec. Dès qu’un obstacle est rencontré, l'écho revient vers le transducteur qui stoppe le chronomètre dès réception du signal. Le résultat sortant du chronomètre est proportionnel à la distance parcourue par l'onde. Il suffit donc de le convertir en mètres pour connaître la mesure, puis de l'afficher.




Cahier des charges technique :

Caratéristiques :

  • Commande de la mesure par appui sur bouton poussoir
  • affichage du résultat sur un écran LCD
  • alimentation autonôme
  • distance mesurée : de 1cm à 1 m
  • précision : +/- 1 mm

Principe de la mesure par ultrason :

Telemetre N1.jpg

PRODUIRE une SALVE : la salve sera produite par un appui sur un bouton poussoir.

Ses caractéristiques ( fréquence et amplitude )dépendront de celles du transducteur.

EMETTRE une onde US :
RECEVOIR une onde US :
DETECTER le premier écho : cette fonction assure l'élimination des échos suivants et/ou des parasites.

Le signal issu du récepteur est ensuite amplifié plusieurs dizaines de fois.

MESURER le temps : mesure le temps entre le signal émis et la réception de sa réverbération.
CONVERTIR en mètres :
AFFICHER le résultat : affiche la mesure sur un afficheur 4 digits.

Structure du télémètre

Le télémètre sera conçu autour d'une carte à micro-contrôleur ATtiny 261A et d'un module Emetteur/Récepteur à ultrason de type HC SR04. L'affichage de la mesure s'effectuera grâce à un afficheur 7 segments 4 digits CC04-41SURKWA.

module E/R ultrason

afficheur 4 digits

Description des fonctions secondaires

Principe avec module US.jpg

fonctionnement de l'émetteur/récepteur ultrason HC-SR04




Travail attendu

Objectif

L'objectif sera bien évidemment de terminer le projet de sorte qu'il réponde au cahier des charges décrit précédemment.

Pour ce faire, il conviendra de :

  • dimensionner les composants utilisés
  • tester les différents blocs fonctionnels
  • fabriquer la carte électronique
  • programmer les composants
  • valider le fonctionnement


Vous serez évalué sur la fabrication de la carte électronique, ainsi que sur un dossier qui devra :

  • détailler les différentes fonctions
  • expliquer les choix effectués (structure,composants ....)
  • utilisera des courbes ou mesures pour appuyer les explications
  • donnera une estimation (hors temps de conception) du coût de la carte électronique

Organisation du travail

Le travail s'effectuera en binôme sur 7 semaines suivant le calendrier ci-dessous :


n° de séance Détail de l'attendu
1 Étude théorique des fonctions
2 Étude des fonctions/programmes (tests)
3 Saisie Étude (validation) et saisie du schéma
4 Routage Validation du schéma et routage de la carte électronique
5 Fabrication Brasage des composants
6 Vérification Tests et dépannage de la carte
7 Programmation Mesure des performances de la carte réalisée


Quelques conseils :

Répartissez le travail au sein du groupe dès le début du projet et testez les différentes fonctions programmées à l'aide d'une carte Arduino parallèlement à la fabrication (ne pas attendre que la carte soit terminée pour aborder la partie programmation).

Inspirez-vous des structures étudiées au premier semestre en électronique, en séances de TP ou en ER et testez les structures au fur et à mesure.


Étude du projet

Préambule

Le point le plus important à comprendre dans ce projet est l'organisation des différents composants autour d'un microcontrôleur.

Nous allons en quelque sorte greffer autour les composants nécessaires à la réalisation des différentes fonctions, telles que listées dans l'étude fonctionnelle.

Le microcontrôleur retenu est un attiny261A.

Question.jpg On vous demande de chercher les informations suivantes sur le microcontrôleur :

  • Nombre d'entrées/sorties disponibles
  • Nombre et position d'entrées analogiques

Todo.jpg Gardez sous le coude la datasheet de ce composant dont vous aurez besoin par la suite et attaquez la rédaction de votre rapport avec les informations demandées.

Module HC-SR04

Affichage des informations

Nous allons utiliser un afficheur 7 segments 4 digits qui sera relié au microcontrôleur.

Après avoir lu la page du site www.sonelec-musique.com et en sachant qu'il convient de conserver 3 entrées analogiques sur le µcontrôleur, proposer un schéma de principe permettant de piloter les afficheurs.

Todo.jpg Il convient désormais

  • d'adapter ce schéma à l'afficheur sélectionné
  • de calculer la valeur des résistances nécessaires.


Remarque : On rappelle ici que la seule alimentation disponible provient de l'USB donc 5V.


Todo.jpg Une fois le schéma choisit ainsi que la valeur des résistances calculées, vérifiez le fonctionnement à l'aide d'une carte arduino

Vous essaierez simplement de piloter individuellement les afficheurs afin de vérifier que vous pouvez :

  • afficher et éteindre chaque segment
  • piloter individuellement chaque digit
  • multiplexer suffisamment rapidement pour avoir une impression visuelle d'affichage simultané

Fabrication de la carte

Saisie du schéma

La relative simplicité de l'étude doit vous amener à approfondir votre réflexion sur le schéma de votre carte et notamment sur les points suivants :

  • comment allez-vous programmer le µcontrôleur ?
  • comment choisir les meilleurs pattes du µcontrôleur
  • placer la résistance de shunt


Quelques éléments de réponse :

ISP In System Programming : la plupart des µcontrôleurs modernes dont celui-ci sont programmables directement sur la carte (in situ).

Il faut donc prévoir le connecteur de programmation et le relier au composant en respectant l'ordre de câblage.

Vous utiliserez, comme Atmel le préconise, le connecteur ISP à 6 broches.

Avr isp.jpg
choix des pattes L'avantage d'utiliser un composant programmable est de pouvoir placer (dans une certaine mesure) les entrées et sorties où bon nous semble.

Attention cependant, il faut garder à l'esprit que le programme sera plus complexe à écrire s'il n'y a pas un minimum de réflexion.

Il est avantageux de placer les commandes de tous les segments [a,b,...,g] sur le même port. La commande du segment associé au point de l'afficheur pourra être sur un port différent.
Pins réservées La patte RESET principalement, ne peut servir qu'à cet usage !! Dans le cas contraire, vous ne pourrez plus reprogrammer le microcontrôleur.

Routage

Il est bien évident que vous devez essayer de respecter les conseils de bases pour réaliser une bonne carte électronique.

Rappelons également qu'une partie de ce dossier est dédiée aux contraintes de fabrication, qu'il convient sans doute à ce stade de relire !


Rappels pour préparation des calques

Via : 0.8 pour les trous et 1,25 pour le diamètre externe

Exports sous forme d'images :

  1. fond en blanc : Options -> user interface -> layout
  2. lancer ulp -> drill-aid vous propose Drill center diameter 0,3mm et c'est OK. Le remplissage se fait en couche 116 mais avec des hachures.
  3. Choisir cette couche 116 puis change -> Fillstyle en plein
  4. Choisir les couches Bottom (bleu) Pads vias et la 116
  5. File -> export -> Image donner un nom et choisir 1200 DPI et monochrome
  6. Idem pour Top (rouge) avec pads et vias (et éventuellement la 116)

Quelques conseils concernant la programmation de l'afficheur

Compilation

Vous utiliserez un éditeur de texte quelconque (gedit par ex) pour créer votre programme (fichier test.c par ex). L'étape de compilation s'effectuera en "ligne de commande" de la façon suivante :

avr-gcc -Wall -g -Os -mmcu=attiny261 -o test.o test.c
avr-objcopy -j .text -j .data -O ihex  test.o test.hex
avrdude -c avrisp2 -P usb -p t261 -U flash:w:"test.hex"

Premier test

L'objectif est ici de faire clignoter au moins un segment. Ceci permettra de vérifier au minimum :

  • que vous arrivez à programmer le µcontrôleur
  • qu'il est possible de commander un segment
  • que vous avez configuré la bonne fréquence d'horloge

Le programme ressemblera sans doute au suivant :

#define F_CPU xxxxxxxxxxUL
#include <avr/io.h>
#include <util/delay.h>
//déclaration des constantes et variables globales
 
int main(void)
{
   // déclaration des variables locales
 
   // phase de configuration du µcontrôleur (e/s, ... )
 
   // boucle infinie
   while(1)
   {
       // il y aura sans doute une attente quelque part !
       _delay_ms(xxx);
   }
}


Afficheur 7 segments

La première phase est réalisée, passons à des choses plus sérieuses ! Il faudrait maintenant exploiter les afficheurs et y afficher les différents symboles nécessaires (les chiffres en somme !).

Il va falloir écrire un tableau de transcodage comme vous l'avez déjà réalisé en informatique S1 ou en logique S1.

Todo.jpg Commencer par faire un compteur sur seulement 1 digit (donc de 0 à 9 !)

#define F_CPU xxxxxxxxxxUL
#include <avr/io.h>
#include <util/delay.h>
//déclaration des constantes et variables globales
 
const unsigned char aff7[10]={...};  /// tableau de transcodage qui donnera les valeurs à placer sur le port correspondant aux segements
 
int main(void)
{
   // déclaration des variables locales
   int i=0;
 
   // phase de configuration du µcontrôleur (e/s, ... )
 
   // on sélectionne l'un des digits
   PORTx = ... ;
 
   // boucle infinie
   while(1)
   {
       // il y aura sans doute une attente quelque part !
       _delay_ms(xxx);
       if (i==9) i=0; else i++;
   }
}

Todo.jpg Encore un peu de travail et vous avez un compteur de 0 à 9999 : il faut penser à afficher alternativement unité, dizaine, centaine, millier !

#define F_CPU xxxxxxxxxxUL
#include <avr/io.h>
#include <util/delay.h>
//déclaration des constantes et variables globales
 
const unsigned char aff7[10]={...};  /// tableau de transcodage qui donnera les valeurs à placer sur le port correspondant aux segements
 
int main(void)
{
   // déclaration des variables locales
   int i=0;
 
   // phase de configuration du µcontrôleur (e/s, ... )
 
   // boucle infinie
   while(1)
   {
       for (j=0;j<5;j++)  // donne la vitesse de comptage
       {
           // sélection unité et valeur à afficher
           PORTx = ... ;
           PORTy = aff7[i];
           _delay_ms(xxx);
           // sélection dizaine et valeur à afficher
           PORTx = ... ;
           PORTy = aff7[i];
           _delay_ms(xxx);
           ....
       }
       if (i==9) i=0; else i++;
   }
}

Todo.jpg Et enfin, on déclare une fonction affiche() qui permettra de rendre le programme plus lisible

#define F_CPU xxxxxxxxxxUL
#include <avr/io.h>
#include <util/delay.h>
//déclaration des constantes et variables globales
 
const unsigned char aff7[10]={...};  /// tableau de transcodage qui donnera les valeurs à placer sur le port correspondant aux segments
 
static void affiche(unsigned int n)
{
   // fonction d'affichage d'un nombre sur l'afficheur
   // il affichera successivement les unité puis dizaine, centaine et enfin millier
 
}
 
int main(void)
{
   // déclaration des variables locales
   int i=0,j;
 
   // phase de configuration du µcontrôleur (e/s, ... )
 
   // boucle infinie
   while(1)
   {
       for (j=0;j<5;j++)  // donne la vitesse de comptage
       {
           affiche(i);
       }
       if (i==9999) i=0; else i++;
   }
}

Composants utilisés

Nom Type Boîtier Librairie Eagle Référence eagle Documentation Fournisseur Référence
ATTINY261A µcontrôleur WSOIC20 atmelIUT ATTINY261A attiny261A.pdf Farnell 2443187
ISP barrette mâle sécable traversant con-lstb MA03-2
Connecteur support femelle pour HC-SR04 traversant con-lstb MA04-1
bp bouton poussoir CMS Troyesgeii SWITCH_6X6.5
CC04-41SURKWA afficheur 7 sgts 4 digits traversant atmelIUT CC04-41SURKWA af7sgt4dgts.pdf Farnell 2426180
Rx Résistances CMS rcl R1206 Farnell


Cx Condensateurs CMS rcl C1206 Farnell


CPOL Condensateurs 150µF 6.3V CMS rcl SMC_D Farnell


Xn Connecteur 2 bornes à vis con-wago-500 W237-102 Farnell