buzzer.h

00001 #ifndef BUZZER_H
00002 #define BUZZER_H
00003 
00004 #include "mbed.h"
00005 
00006 //Instanciation du GPIO.
00007 DigitalOut buzz(PB_8);      //Sortie digital pour le buzzer.
00008 
00009 
00010 //Class Buzzer regroupant les diférents paramétres utile à la génération du signal du buzzer.
00011 class Buzzer{
00012     public :
00013     
00014     //Déclaration des atributs
00015     int TsilenceMs;                                             //Variable temps de silence entre les bips. 
00016     typedef enum {BipInit, BipUp, BipDown, Silent} defetat;     //Définie les état possible du buzzer
00017     defetat etat;                                               //Variable d'état du buzzer
00018     Timer t;                                                    //Timer
00019     int i;                                                      //Nombre de pulsation par bip
00020     
00021     Buzzer(){
00022         TsilenceMs=100;
00023         etat = BipInit;
00024         t.reset();
00025         i=0;
00026     }
00027 
00028     //Déclaration des methodes
00029     void changeMode(int value);         //Changement du nombre de bips en fonction de la distance
00030     void run();                         //Lancement du buzzer
00031 };      
00032 
00033 /*
00034 Buzzer::Buzzer(){
00035     TsilenceMs=100;
00036     etat = BipInit;
00037     t.reset();
00038     i=0;
00039 }
00040 */
00041 
00042 /* 
00043  * Initialisation des différents modes de fonctionnement :
00044  * 
00045  *   0 < d <  25  --> 0 : 5 b/s
00046  *  25 < d <  50  --> 1 : 4 b/s
00047  *  50 < d < 100  --> 2 : 3 b/s
00048  * 100 < d < 150  --> 3 : 2 b/s
00049  * 150 < d < 200  --> 4 : 1 b/s
00050  * 200 < d        --> 5 : 0 b/s
00051  
00052  fonction bip : (400µs+400µs)*50 = 40ms
00053  -> timer sur interruption en fonction du temps à attendre avant le prochain bip
00054         0 --> 5 b/s --> TsilenceMs 0,16s
00055         1 --> 4 b/s --> TsilenceMs 0,21s
00056         2 --> 3 b/s --> TsilenceMs 0,29s
00057         3 --> 2 b/s --> TsilenceMs 0,46s
00058         4 --> 1 b/s --> TsilenceMs 0,96s
00059         5 -->           TsilenceMs 1s
00060  
00061  */
00062 
00063 
00064 //**********Modifie la valeur du temps de silence entre 2 bips en fonction de la distance.************//
00065 //
00066 //Variable value correspond à la distance mesurée en cm.
00067 //
00068 void Buzzer::changeMode(int value){
00069     if(value<=25){                      //0
00070         TsilenceMs=160;
00071     }else if(value>25 && value<=50){    //1
00072         TsilenceMs=210;
00073     }else if(value>50 && value<=100){   //2
00074         TsilenceMs=290;
00075     }else if(value>100 && value<=150){   //3
00076         TsilenceMs=460;
00077     }else if(value>150 && value<=200){  //4
00078         TsilenceMs=960;
00079     }else{                              //5
00080         TsilenceMs=1000000000;
00081     }
00082 }
00083 
00084 /*
00085 Si la valeur sort de son intervalle de fonctionnement,
00086 on modifie le mode de fonctionnement courant.
00087 
00088 fonction bip : (400µs+400µs)*50 = 40ms
00089  -> timer sur interruption en fonction du temps à attendre avant le prochain bip
00090         0 --> 5 b/s --> silence 0,16s
00091         1 --> 4 b/s --> silence 0,21s
00092         2 --> 3 b/s --> silence 0,29s
00093         3 --> 2 b/s --> silence 0,46s
00094         4 --> 1 b/s --> silence 0,96s
00095         5 -->           silence 1s
00096 
00097 Etat : BipInit
00098         Timer t Start
00099         Bip=0
00100         i=0
00101         Etat = BipUp
00102 Etat : BipUp
00103         si (t>=400µs && i<50)
00104             bipCarreUp
00105             i++
00106             Etat = BipDown
00107             t Restart
00108         si (i>=50) Etat = Silence;
00109             t Restart
00110 Etat : BipDown
00111         si (t>=400µs && i<50)
00112             bipCarreUp
00113             i++
00114             Etat = BipUp
00115             t Restart
00116         si (i>=50) Etat = Silence;
00117             t Restart
00118 Etat : Silence
00119         si (t>=Tsilence)
00120             Etat=BipInit
00121 
00122 */
00123 
00124 void Buzzer::run(){ // paramètre : t (Timer), i, etat
00125     switch(etat){
00126         
00127         case BipInit :
00128             buzz=0;
00129             i=0;
00130             etat = BipUp;
00131             t.start();
00132             break;
00133             
00134         case BipUp :
00135             if(t.read_us()>=400 && i<50){
00136                 buzz=1;
00137                 i++;
00138                 etat = BipDown;
00139                 t.reset();
00140                 t.start();
00141             }
00142             if(i>=50){
00143                 etat = Silent;
00144                 t.reset();
00145                 t.start();
00146             }
00147             break;
00148             
00149         case BipDown :
00150             if(t.read_us()>=400 && i<50){
00151                 buzz=0;
00152                 i++;
00153                 etat = BipUp;
00154                 t.reset();
00155                 t.start();
00156             }
00157             if(i>=50){
00158                 etat = Silent;
00159                 t.reset();
00160                 t.start();
00161             }
00162             break; 
00163             
00164         case Silent :
00165             if(t.read_ms()>=TsilenceMs){
00166                 etat=BipInit;
00167             }
00168             break;
00169             
00170         default :
00171             etat = BipInit;
00172             break;
00173     }
00174 }
00175 
00176 
00177 #endif