Cours:Télémètre : Différence entre versions

De troyesGEII
Aller à : navigation, rechercher
(→‎{{Rouge|Organisation du travail :}})
Ligne 154 : Ligne 154 :
  
 
'''Travaillez en parallèle''' : distribuez vous le travail au sein du groupe afin d'être le plus efficace possible.<br />
 
'''Travaillez en parallèle''' : distribuez vous le travail au sein du groupe afin d'être le plus efficace possible.<br />
 +
 +
=={{Bleu| Quelques conseils concernant la programmation de l'afficheur}}==
 +
 +
==={{Vert|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 :
 +
 +
<source lang=c>
 +
#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);
 +
  }
 +
}
 +
</source>
 +
 +
 +
==={{Vert|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|Commencer par faire un compteur sur seulement 1 digit (donc de 0 à 9 !)}}
 +
 +
<source lang=c>
 +
#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++;
 +
  }
 +
}
 +
</source>
 +
 +
{{Todo|Encore un peu de travail et vous avez un compteur de 0 à 9999 : il faut penser à afficher alternativement unité, dizaine, centaine, millier !}}
 +
 +
<source lang=c>
 +
#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++;
 +
  }
 +
}
 +
</source>
 +
 +
{{Todo|Et enfin, on déclare une fonction affiche() qui permettra de rendre le programme plus lisible}}
 +
 +
<source lang=c>
 +
#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++;
 +
  }
 +
}
 +
</source>
  
  

Version du 29 janvier 2016 à 13:21

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

module E/R ultrason
microcontrôleur ATMEL

afficheur 4 digits

Description des fonctions secondaires

Principe avec module US.jpg

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




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


Il est vivement conseillé de répartir le travail au sein du groupe dès le début du projet et de tester 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).


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.

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 !

Étude du projet

L'étude consiste à proposer et à tester des structures répondant aux différentes fonctions.

Il est conseillé de s'inspirer des structures étudiées au premier semestre en électronique, en séances de TP ou en ER et de tester les structures au fur et à mesure.

Travaillez en parallèle : distribuez vous le travail au sein du groupe afin d'être le plus efficace possible.

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.

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
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
Récupérée de « http://wikigeii.iut-troyes.univ-reims.fr//index.php?title=Cours:Télémètre&oldid=7487 »