analyzer.cpp

00001 /*!
00002  *  \file analyzer.cpp
00003  *  \brief Class that analyzes the mouvement in C and C++
00004  *  \author Equipe P02
00005  *  \version 0.1
00006  *  \date 02/04/2014
00007  */
00008 
00009 #include "analyzer.h"
00010  
00011 Analyzer::Analyzer()
00012 {
00013 }
00014  
00015 Analyzer::~Analyzer()
00016 {
00017     allMouvement.clear();
00018 }
00019 
00020 void Analyzer::initialize()
00021 {
00022     DigitalOut reset(p8);
00023     
00024     reset = 0;
00025     wait(0.4);  // Reset xbee
00026     reset = 1;
00027     
00028     trame = new Trame(p13, p14);
00029     
00030     allMouvement[0x0002] = new Mouvement(0x0002, 0x0002, "Z vertical, vers le ciel", hand);
00031     allMouvement[0x0003] = new Mouvement(0x0003, 0x0003, "Z vertical, vers le ciel INVERSE", hand);
00032     allMouvement[0x0004] = new Mouvement(0x0004, 0x0004, "Z vertical, vers le sol", hand);
00033     allMouvement[0x0005] = new Mouvement(0x0005, 0x0005, "Z vertical, vers le sol INVERSE", hand);
00034     allMouvement[0x0006] = new Mouvement(0x0006, 0x0006, "Z horizontal", hand);
00035     allMouvement[0x0007] = new Mouvement(0x0007, 0x0007, "Z horizontal INVERSE", hand);
00036 
00037     allMouvement[0x0020] = new Mouvement(0x0020, 0x0020, "X vertical, vers le ciel", hand);
00038     allMouvement[0x0030] = new Mouvement(0x0030, 0x0030, "X vertical, vers le ciel INVERSE", hand);
00039     allMouvement[0x0040] = new Mouvement(0x0040, 0x0040, "X vertical, vers le sol", hand);
00040     allMouvement[0x0050] = new Mouvement(0x0050, 0x0050, "X vertical, vers le sol INVERSE", hand);
00041     allMouvement[0x0060] = new Mouvement(0x0060, 0x0060, "X horizontal", hand);
00042     allMouvement[0x0070] = new Mouvement(0x0070, 0x0070, "X horizontal INVERSE", hand);
00043 
00044     allMouvement[0x0200] = new Mouvement(0x0200, 0x0200, "Y vertical, vers le ciel", hand);
00045     allMouvement[0x0300] = new Mouvement(0x0300, 0x0300, "Y vertical, vers le ciel INVERSE", hand);
00046     allMouvement[0x0400] = new Mouvement(0x0400, 0x0400, "Y vertical, vers le sol", hand);
00047     allMouvement[0x0500] = new Mouvement(0x0500, 0x0500, "Y vertical, vers le sol INVERSE", hand);
00048     allMouvement[0x0600] = new Mouvement(0x0600, 0x0600, "Y horizontal", hand);
00049     allMouvement[0x0700] = new Mouvement(0x0700, 0x0700, "Y horizontal INVERSE", hand);
00050 }
00051  
00052 void Analyzer::setMinMax(signed char* values)
00053 {
00054     x.setMinMax(values[0]);
00055     y.setMinMax(values[1]);
00056     z.setMinMax(values[2]);
00057 }
00058  
00059 void Analyzer::checkMouvement()
00060 {
00061     bool deplacement[3] = {0};
00062     int code_mouvement = 0;
00063     
00064     deplacement[0] = x.isMouvement();
00065     deplacement[1] = y.isMouvement();          
00066     deplacement[2] = z.isMouvement();  
00067        
00068     // Mouvement en x
00069     if(deplacement[0])
00070     {
00071         if(x.initial > SEUIL_DETECTION)
00072         {
00073             code_mouvement |= 0x1 << 9; // 0010
00074         }
00075         else if(x.initial < -SEUIL_DETECTION)
00076         {       
00077             code_mouvement |= 0x2 << 9; // 0100
00078         }
00079         else
00080         {
00081             code_mouvement |= 0x3 << 9; // 0110
00082         }
00083         
00084         if(!x.sens)
00085         {
00086             code_mouvement |= 0x1 << 8; // 0xx1 
00087         }
00088     }
00089     
00090     // Mouvement en y  
00091     if(deplacement[1])
00092     {
00093         if(y.initial > SEUIL_DETECTION)
00094         {
00095             code_mouvement |= 0x1 << 5; // 0xxx 0010
00096         }
00097         else if(y.initial < -SEUIL_DETECTION)
00098         {
00099             code_mouvement |= 0x2 << 5; // 0xxx 0100
00100         }
00101         else
00102         {
00103             code_mouvement |= 0x3 << 5; // 0xxx 0110
00104         }
00105         
00106         if(!y.sens)
00107         {
00108             code_mouvement |= 0x1 << 4; // 0xxx 0yy1 
00109         }
00110     }
00111     
00112     // Mouvement en z
00113     if(deplacement[2])
00114     {
00115         if(z.initial > SEUIL_DETECTION)
00116         {
00117             code_mouvement |= 1 << 1; // 0xxx 0yyy 0010
00118         }
00119         else if(z.initial < -SEUIL_DETECTION)
00120         {
00121             code_mouvement |= 2 << 1; // 0xxx 0yyy 0100
00122         }
00123         else
00124         {
00125             code_mouvement |= 3 << 1; // 0xxx 0yyy 0110
00126         }
00127         
00128         if(!z.sens)
00129         {
00130             code_mouvement |= 1 << 0; // 0xxx 0yyy 0zz1
00131         }
00132     }
00133 
00134     map<int,Mouvement*>::iterator it;
00135     it = allMouvement.find(code_mouvement);
00136                                            
00137     if(it != allMouvement.end())
00138         it->second->sendData(trame);
00139 }
00140 
00141 void Analyzer::setInitial(signed char* init)
00142 {
00143     x.setInitial(init[0]);
00144     y.setInitial(init[1]);
00145     z.setInitial(init[2]);
00146 }
00147  
00148 extern "C" void *Analyzer_C_new()
00149 {
00150     return new Analyzer();
00151 }
00152  
00153 extern "C" void Analyzer_C_delete (void *analyzer)
00154 {
00155     Analyzer *an = (Analyzer*)analyzer;
00156     delete an;    
00157 }
00158 
00159 extern "C" void Analyzer_C_Initialize (void *analyzer)
00160 {
00161     Analyzer *an = (Analyzer*)analyzer;
00162     an->initialize();
00163 }
00164  
00165 extern "C" void Analyzer_C_setMinMax (signed char* values, void *analyzer)
00166 {
00167     Analyzer *an = (Analyzer*)analyzer;
00168     an->setMinMax(values);    
00169 }
00170  
00171 extern "C" void Analyzer_C_setInitial (signed char* init, void *analyzer)
00172 {
00173     Analyzer *an = (Analyzer*)analyzer;
00174     an->setInitial(init);    
00175 }
00176  
00177 extern "C" void Analyzer_C_checkMouvement (void *analyzer)
00178 {
00179     Analyzer *an = (Analyzer*)analyzer;
00180     an->checkMouvement();
00181 }
00182 
00183 extern "C" void Analyzer_C_setHand (bool h, void *analyzer)
00184 {
00185     Analyzer *an = (Analyzer*)analyzer;
00186     an->setHand(h);
00187 }