Cours:Télémètre
Sommaire
Présentation du projet
Objectif
Ce projet consiste à réaliser un télémètre à ultrasons.
Notions de base
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
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
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 :
| 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 2313 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.
Description des fonctions secondaires
Organisation du travail :
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.
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
- où 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. |
|
| 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 !
Quelques conseils concernant la programmation de l'afficheur
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.
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++;
}
}
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++;
}
}
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 |
|---|---|---|---|---|---|---|---|
| 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 |
