buzzer.h

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