ComSpi.cpp

00001 
00002 #include "ComSpi.h"
00003 
00004 ComSpi::ComSpi(PinName mosi, PinName miso, PinName sclk, PinName _unused) : SPI(mosi,miso,sclk,_unused)
00005 {
00006     // m_com = new SPI(mosi,miso,sclk,_unused);
00007     //m_regPortUse=0;
00008     //m_regPortLost=0;
00009     m_demuxPos=0;
00010     demuxIsUse=false;
00011     chainedListFirst = 0;
00012     chainedListLast = 0;
00013     flagSPI.getBytes = 0;
00014     //result = 0;
00015     counterData = 0;
00016     counterTotale = 0;
00017     /*for(int i=0;i<MAXTABLE;i++)
00018     {
00019         bufferSend[i] = 0;
00020         bufferReceive[i] = 0;
00021     }
00022     bufferSend[0] = SYNC;*/
00023 }
00024 
00025 struct module_t* ComSpi::createModule(void) {
00026     if(chainedListFirst == 0) {
00027         chainedListFirst = new module_t ;
00028         chainedListLast = chainedListFirst;
00029     } else {
00030         chainedListLast->next = new module_t;
00031         chainedListLast = chainedListLast->next;
00032     }
00033     chainedListLast->next = 0;
00034     return chainedListLast;
00035 }
00036 
00037 ComSpi::ComSpi(PinName mosi, PinName miso, PinName sclk, PinName demuxA, PinName demuxB, PinName demuxC, PinName demuxD, PinName demuxEnable)
00038     : SPI(mosi,miso,sclk), m_demuxA(demuxA), m_demuxB(demuxB), m_demuxC(demuxC), m_demuxD(demuxD), m_demuxEnable(demuxEnable)
00039 {
00040     m_demuxPos=0;
00041     demuxIsUse=true;
00042     format(8,0);//16,0); //recente modification
00043 }
00044 
00045 ComSpi::~ComSpi()
00046 {
00047     //pt deleter les pointeur mais sa ser pas vrm a grand chause
00048     //if(m_com)
00049     // delete(m_com);
00050 }
00051 void ComSpi::change_demux(void)
00052 {
00053     if(demuxIsUse) {
00054         DigitalOut pinDemuxA(m_demuxA);
00055         DigitalOut pinDemuxB(m_demuxB);
00056         DigitalOut pinDemuxC(m_demuxC);
00057         DigitalOut pinDemuxD(m_demuxD);
00058         DigitalOut pinDemuxEnable(m_demuxEnable);//,1);
00059 //wait(1);
00060         pinDemuxEnable=0;
00061 //wait(1);
00062         if(m_demuxPos & 1) pinDemuxA=1; //0b0001
00063         else pinDemuxA=0;
00064         if(m_demuxPos & 2) pinDemuxB=1; //0b0010
00065         else pinDemuxB=0;
00066         if(m_demuxPos & 4) pinDemuxC=1; //0b0100
00067         else pinDemuxC=0;
00068         if(m_demuxPos & 8) pinDemuxD=1; //0b1000
00069         else pinDemuxD=0;
00070 //wait(1);
00071         // pinDemuxEnable=1;
00072         //wait(1);
00073     }
00074 }
00075 char ComSpi::next_demux(void)
00076 {
00077     char result = (char)-1;
00078 
00079     if(demuxIsUse) {
00080         (m_demuxPos == 15)? m_demuxPos=0:m_demuxPos++;
00081         change_demux();
00082         result = m_demuxPos;
00083     }
00084     return result;
00085 }
00086 char ComSpi::back_demux(void)
00087 {
00088     char result = (char)-1;
00089 
00090     if(demuxIsUse) {
00091         (m_demuxPos == 0)? m_demuxPos=15:m_demuxPos--;
00092         change_demux();
00093 
00094         result = m_demuxPos;
00095     }
00096     return result;
00097 }
00098 char ComSpi::get_demux(void)
00099 {
00100     char result = (char)-1;
00101     if(demuxIsUse)
00102         result=m_demuxPos;
00103     return   result ;
00104 }
00105 unsigned char spiCurrentState;
00106 int ComSpi::write(int value)
00107 {
00108     DigitalOut pinDemuxEnable(m_demuxEnable);
00109     //DigitalOut pinDemuxEnable(m_demuxEnable,0);
00110     int a;
00111     pinDemuxEnable=1;
00112     /*   switch(spiCurrentState)
00113     {
00114        case 0:
00115        a= SPI::write(0x12);
00116        spiCurrentState++;
00117        break;
00118        default:
00119        a= SPI::write(0xF5);
00120        spiCurrentState =0;
00121        break;
00122     }*/
00123     wait_us(5);
00124     a= SPI::write(value);
00125     wait_us(5);
00126     pinDemuxEnable=0;
00127     sneekpeek.append(1,value);
00128     wait_us(1000);
00129     return a;
00130 }
00131 
00132 
00133 bool ComSpi::send(char portID,unsigned char adresseModule,string *flag,string *data)
00134 {
00135     bool result=false;
00136     string formatedDataSend;
00137     string formatedDataReceive;//DEBUG_COMPACT
00138     char settingMaster = 0;
00139     char settingSlave = 0;
00140 
00141     debug(DEBUG_SEND| DEBUG_COMPACT, "\n\r   -Debut du send. ");
00142 
00143     debug(DEBUG_SEND, "\n\r    -Debut set demux. ");
00144 
00145     if(portID < 1) portID = 0;
00146     else if(portID > 16) portID = 16;
00147     debug(DEBUG_SEND| DEBUG_COMPACT, "\n\r     -Change PORT. %02d",portID);
00148     m_demuxPos = portID;
00149     change_demux();
00150 
00151     debug(DEBUG_SEND, "\n\r    -Fin set demux. ");
00152 
00153     // Sync //
00154     debug(DEBUG_SEND, "\n\r    -Debut Sync. ");
00155     formatedDataSend.append(1,SYNC);
00156     debug(DEBUG_COMPACT, "\n\r    -SYNC ADDED: %02X ",formatedDataSend[0]);
00157     debug(DEBUG_SEND, "\n\r    -Fin Sync. ");
00158 
00159     // Address //
00160     debug(DEBUG_SEND, "\n\r    -Debut Address. ");
00161     formatedDataSend.append(1,adresseModule);
00162     debug(DEBUG_COMPACT, "\n\r    -ADDR ADDED: %02X, %02X ",formatedDataSend[0],formatedDataSend[1]);
00163     debug(DEBUG_SEND, "\n\r    -Fin Address. ");
00164 
00165     // PFB //
00166     debug(DEBUG_SEND, "\n\r    -Debut PFB. ");
00167     // if(flag != 0)
00168     // {
00169     switch(flag->size()) {
00170         case 1:
00171             if(flag->at(0) == 0) formatedDataSend.append(1,0<<6); //0 byte
00172             else          formatedDataSend.append(1,1<<6); //1 byte
00173             break;
00174 
00175         case 2:
00176             formatedDataSend.append(1,2<<6); //2 byte
00177             break;
00178 
00179         case 3:
00180             formatedDataSend.append(1,3<<6); //3 byte
00181             break;
00182 
00183         default:
00184             formatedDataSend.append(1,0<<6); //cas impossible //0 byte
00185             break;
00186     }
00187     //}
00188     debug(DEBUG_COMPACT, "\n\r    -PFB ADDED: %02X, %02X, %02X ",formatedDataSend[0],formatedDataSend[1],formatedDataSend[2]);
00189     debug(DEBUG_SEND, "\n\r    -Fin PFB. ");
00190 
00191     // gestion ACK/NAK
00192     debug(DEBUG_SEND, "\n\r    -Debut ACK/NAK. ");
00193     formatedDataSend.at(formatedDataSend.length()-1) |= (NOACK << 4);
00194     debug(DEBUG_COMPACT, "\n\r    -ACK ADDED: %02X, %02X, %02X ",formatedDataSend[0],formatedDataSend[1],formatedDataSend[2]);
00195     debug(DEBUG_SEND, "\n\r    -Fin ACK/NAK. ");
00196 
00197     // NDB //
00198     debug(DEBUG_SEND, "\n\r    -Debut NDB. ");
00199     switch(data->size()) {
00200         case 1:
00201             formatedDataSend.at(formatedDataSend.length()-1) |= 1;
00202             break;
00203 
00204         case 2:
00205             formatedDataSend.at(formatedDataSend.length()-1) |= 2;
00206             break;
00207 
00208         case 3:
00209             formatedDataSend.at(formatedDataSend.length()-1) |= 3;
00210             break;
00211 
00212         default:
00213             formatedDataSend.at(formatedDataSend.length()-1) |= 0;
00214             break;
00215     }
00216     //debug(DEBUG_COMPACT, "\n\r    -NDB ADDED: %02X, %02X, %02X ",formatedDataSend[0],formatedDataSend[1],formatedDataSend[2]);
00217     debug(DEBUG_SEND, "\n\r    -Fin NDB. ");
00218 
00219     settingMaster = formatedDataSend[formatedDataSend.length()-1];
00220 
00221     // flag //
00222     debug(DEBUG_SEND, "\n\r    -Debut flag. ");
00223     if(flag->size() != 0) {
00224         formatedDataSend.append(*flag);
00225         //debug(DEBUG_COMPACT, "\n\r    -FLAG ADDED: %02X, %02X, %02X, %02X ",formatedDataSend[0],formatedDataSend[1],formatedDataSend[2],formatedDataSend[3]);
00226     }
00227     debug(DEBUG_SEND, "\n\r    -Fin flag. ");
00228 
00229 //ici tu envoi deja ton premier stuf
00230 
00231 
00232 //debug(DEBUG_SLIM, "\n\r    -settingMaster : %X , %i, %X ",settingMaster, (2+(settingMaster>>6)),formatedDataSend[(2+(settingMaster>>6))] );
00233 
00234 
00235 
00236     for(int retryLoop=0; (retryLoop<3) && (!result); retryLoop++) {
00237         wait_us(3000);
00238         debug(DEBUG_SEND|DEBUG_COMPACT, "\n\r      -Tentative: %d \n\r",retryLoop);
00239         formatedDataReceive.clear();
00240         settingSlave =0;
00241         counterTotale =0;
00242         sneekpeek.clear();
00243         //Send Data
00244 //        debug(DEBUG_SEND, "\n\r    -Debut Send Data. ");
00245 //        debug(DEBUG_SEND|DEBUG_COMPACT, "\n\r     -Send: ");
00246 //        for (unsigned i=0; i<formatedDataSend.length(); ++i) debug(DEBUG_SEND |DEBUG_COMPACT, "%02X,",formatedDataSend.at(i));
00247 
00248         //int twoBytesArray;
00249         //twoBytesArray = (formatedDataSend[0]<<8)|(formatedDataSend[1]);
00250         //twoBytesArray=write(twoBytesArray);
00251 
00252         for(int i = 0; (i < formatedDataSend.length()) && (i<=(2+(settingMaster>>6))); ++i) {
00253             formatedDataReceive.append(1,write(formatedDataSend[i]));//debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM, "\n\r -A:%i ",i);
00254             debug(DEBUG_SEND |DEBUG_COMPACT, " %02X,",formatedDataSend.at(i));
00255             wait_us(3000);
00256         }
00257 
00258         if(formatedDataReceive[0] == SYNC) {
00259             debug(DEBUG_COMPACT, "\n\r    -Receve transmission. ");
00260             //!!!!!!!! Problem ici write dans un mais pas lautre
00261             //wait_us(3000);
00262             if(retryLoop == 0) {
00263                 formatedDataSend.append(1,0);//2,0); cest une patch tempo parce que je trouve pas ou il manque la donner
00264             }
00265             formatedDataReceive.append(1,write(0));
00266             // debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM, "\n\r -B: ");
00267 
00268             settingSlave = formatedDataReceive[formatedDataReceive.length()-1];
00269             debug(DEBUG_COMPACT, "\n\r       -settingSlave %02X",settingSlave);
00270             debug(DEBUG_COMPACT, "\n\r        -append %02X time(s)",settingSlave>>6);
00271             if(retryLoop == 0) {
00272                 /*switch(formatedDataReceive[formatedDataSend.length()-1] >> 6) {
00273                     case 1:
00274                         formatedDataSend.append(1,0); //1 byte
00275                         break;
00276 
00277                     case 2:
00278                         formatedDataSend.append(2,0); //2 byte
00279                         break;
00280 
00281                     case 3:
00282                         formatedDataSend.append(3,0); //3 byte
00283                         break;
00284 
00285                         //default:
00286                         //    formatedDataSend.append(1,0<<6); //0 byte
00287                         //    break;
00288                 }*/
00289                 formatedDataSend.append(settingSlave>>6,0);
00290             }
00291 
00292             int bufferFlag = 0;
00293 
00294             for(int i = (settingMaster>>6); i != 0; i--) { //ici on remplie le buffer des data du flag
00295                 // je considere avec erreur que il nexiste pas de flag plus grand que 2 bytes (facilite le code de depart)
00296                 //!!! Pt metre fonct stein qui tronc de debut a fin pour remplacer les linge dessous.
00297                 bufferFlag = bufferFlag<<8;
00298                 bufferFlag += formatedDataSend[2+i];
00299             }
00300 
00301             counterTotale = ((2+(settingMaster>>6))+1);
00302             counterTotale = counterTotale+(settingSlave>>6)+abs((settingMaster & 0x0F) - (settingSlave & 0x0F));
00303             debug(DEBUG_COMPACT, "\n\r    -Calcule: %02X=((2+(%02X))+1)+(%02X)+abs((%02X)-(%02X))",(((2+(settingMaster>>6))+1)+(settingSlave>>6)+abs((settingMaster & 0x0F) - (settingSlave & 0x0F))),(settingMaster>>6),(settingSlave>>6),(settingMaster & 0x0F),(settingSlave & 0x0F));
00304             //debug( "\n\r    -size : %02X",counterTotale);
00305             debug( DEBUG_COMPACT,"\n\r    -size : %02X ,  %02X",formatedDataSend.size(),counterTotale);
00306             if(retryLoop == 0) {
00307                 
00308                 if(formatedDataSend.size()<=counterTotale) {
00309                     formatedDataSend.append(counterTotale+1-formatedDataSend.size(),0);
00310                 }
00311                 else{
00312                     debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM,         "\n\r     -Probleme de receive: ");
00313                     for (unsigned i=0; i<formatedDataReceive.length(); i++) debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM, "%02X,",formatedDataReceive.at(i));
00314                     debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM,         "\n\r     -Probleme de send: ");
00315                     for (unsigned i=0; i<formatedDataSend.length(); i++) debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM, "%02X,",formatedDataSend.at(i));
00316                     }
00317             }
00318 
00319             debug(DEBUG_COMPACT, "\n\r    -size : %02X ,  %02X",formatedDataSend.size(),counterTotale);
00320             switch(bufferFlag) { //plus facile pour savoir ce que tu doit tatenre a recevoire
00321                 case 1://Request Init Info
00322                     if(retryLoop == 0) {
00323                         //formatedDataSend.append(1,1<<6); //1 byte flag
00324                         //formatedDataSend.append(settingSlave & 0x0F,0);
00325                         //chek pour comment avoir un address
00326                         /*if(formatedDataSend.size()<counterTotale) {
00327                             formatedDataSend.append(counterTotale+1-formatedDataSend.size(),0);
00328                         }*/
00329                     }
00330                     //verifier si la fonction fait ce quil edt suposer
00331 
00332                     /*for(int i = ((2+(settingMaster>>6))+1); i < formatedDataSend.length()-1; ++i) { //on envoi le reste des data
00333                         formatedDataReceive.append(1,write(formatedDataSend[i]));
00334                         //debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM, "\n\r -C:%i ",i);
00335                     }*/
00336 
00337                     //templatePtr =searchAddr(0);
00338                     // 1 byte flag + 3 byte de data
00339                     //bufferSend[4] = (1<<6) + 3;//[2+(bufferReceive[2]>>6)+1] = (1<<6);
00340 
00341 
00342                     //if((templatePtr->next)==0)
00343                     //    bufferSend[5] = 0b101;//bufferReceive[2+(bufferReceive[2]>>6)+1+bufferReceive[2+(bufferReceive[2]>>6)+1]] = 0b101;
00344                     //else
00345                     //    bufferSend[5] = 0b10;
00346 
00347                     //bufferSend[6] = templatePtr->basicInfo.osnapRegisterB.getByte;
00348                     //bufferSend[7] = templatePtr->basicInfo.osnapRegisterC.getByte;
00349                     //bufferSend[8] = templatePtr->basicInfo.osnapRegisterD.getByte;
00350                     break;
00351 
00352                 case 2: //Slave contient un/des autre(s) module(s) sans adresses
00353                     break;
00354 
00355                 case 3: //Flag Critique
00356                     break;
00357 
00358                 case 4: //Flag Alerte
00359                     break;
00360 
00361                 case 5: //Slave ne contient plus de module sans adresse
00362                     break;
00363 
00364                 case 6: //Master request address update
00365                     break;
00366 
00367                 default: //Get update (normale)
00368                     //if(retryLoop == 0) {
00369                     //    formatedDataSend.append(abs((settingMaster & 0x0F) - (settingSlave & 0x0F)),0);//je considere que cest fait apres avoire ajouter les data a nous
00370                     //    }
00371                     break;
00372             }
00373             // pas sur si cest une bonne ider mais sa peut peut etre regrouper tout les flags
00374             for(int i = ((2+(settingMaster>>6))+1); i < formatedDataSend.length()-1; ++i) { //on envoi le reste des data
00375                         formatedDataReceive.append(1,write(formatedDataSend[i]));
00376                         //debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM, "\n\r -C:%i ",i);
00377                     }
00378             //counterTotale = 2+(bufferReceive[2]>>6)+1;
00379             //counterTotale = counterTotale+(bufferSend[counterTotale]>>6)+abs((bufferReceive[2] & 0x5F) - (bufferSend[counterTotale] & 0x5F));
00380 
00381 
00382 
00383             // Envoie le reste si liker //
00384             // DATA //
00385             unsigned short templateValue=0;
00386             if(retryLoop == 0) {
00387                 // CRC //
00388                 debug(DEBUG_SEND, "\n\r    -Debut CRC16. ");
00389                 //CRC16* templateCRC;
00390                 //templateCRC = new CRC16();
00391                 //!!!utiliser string cest plus simple
00392 
00393 
00394                 //char templateTable[formatedDataSend.length()+1];
00395                 //for (unsigned i=0; i<formatedDataSend.length()+1; ++i) templateTable[i]=0;
00396                 //for (unsigned i=0; i<formatedDataSend.length(); ++i) templateTable[i]=formatedDataSend[i];
00397                 //debug(DEBUG_SEND, "\n\r     - envoi au crc: %02X,%02X,%02X,%02X,%02X,%02X ",templateTable[0],templateTable[1],templateTable[2],templateTable[3],templateTable[4],templateTable[5],templateTable[6]);
00398 
00399                 // templateValue = /*templateCRC->*/calculateCRC16(templateTable,formatedDataSend.size()-1); //atention pt un probleme de sortie du range
00400                 //templateValue = /*templateCRC->calculateCRC16*/CRC16_BUYPASS(formatedDataSend.c_str(),formatedDataSend.size()); //atention pt un probleme de sortie du range
00401                 templateValue =CRC16_BUYPASS(sneekpeek.c_str(),sneekpeek.size()); //patch
00402 
00403                 formatedDataSend.append(1,templateValue>>8);
00404                 formatedDataSend.append(1,templateValue & 0xFF);
00405             }
00406             formatedDataReceive.append(1,write(formatedDataSend[formatedDataSend.size()-2]));//templateValue>>8));
00407             //debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM, "\n\r -D: ");
00408             formatedDataReceive.append(1,write(formatedDataSend[formatedDataSend.size()-1]));//(templateValue & 0xFF));
00409             //debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM, "\n\r -E: ");
00410 
00411 
00412 
00413             ///////////////////////
00414 
00415             //avant faut calculer les dernier byte grace a la version 2.0
00416             /*for(int i = 0; i < formatedDataSend.length(); ++i) {
00417                 formatedDataReceive.append(1,write(formatedDataSend[i]));
00418             }*/
00419 
00420             // verification du CRC slave
00421             // CRC //
00422             templateValue = CRC16_BUYPASS(formatedDataReceive.c_str(),formatedDataReceive.size()-2);// utiliser les data de setting slave
00423 
00424             if(((templateValue>>8)==(formatedDataReceive.at( formatedDataReceive.length()-2))) &&
00425                     ((templateValue&0xFF)==(formatedDataReceive.at( formatedDataReceive.length()-1)))) {
00426                 result=true;
00427             } else {
00428                 result=false;
00429             }
00430             //templateValue=((formatedDataReceive.at( formatedDataReceive.length()-2)) << 8);
00431             //templateValue|=formatedDataReceive.at(formatedDataReceive.length()-1);
00432 
00433             // for (unsigned i=0; i<formatedDataReceive.length()-2; ++i) {
00434             //     templateValue-=formatedDataReceive[i];
00435             // }
00436             // debug(DEBUG_SEND, "\n\r    -CRC==0? value: %i. ", templateValue);
00437             // (templateValue==0)? result=true:result=false;
00438         }
00439         debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM, "\n\r     -Send   : ");
00440         for (unsigned i=0; i<formatedDataSend.length(); i++) debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM, "%02X,",formatedDataSend.at(i));
00441         debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM, "\n\r     -real   : ");
00442         for (unsigned i=0; i<sneekpeek.length(); i++) debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM, "%02X,",sneekpeek.at(i));
00443         debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM,         "\n\r     -Reveive: ");
00444         for (unsigned i=0; i<formatedDataReceive.length(); i++) debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM, "%02X,",formatedDataReceive.at(i));
00445         debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM,         "\n\r     -Sneekpe: ");
00446         /*for (unsigned i=0; i<sneekpeek.length(); i++)*/
00447         debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM, "%04X,",CRC16_BUYPASS(formatedDataReceive.c_str(),formatedDataReceive.size()-2));//sneekpeek.at(i));
00448         debug(DEBUG_SEND|DEBUG_COMPACT|DEBUG_SLIM, "\n\r-Sneekpe: %04X,",CRC16_BUYPASS(formatedDataSend.c_str(),formatedDataSend.size()-2));//sneekpeek.at(i));
00449         
00450 
00451     }//templateValue = /*templateCRC->*/calculateCRC16(formatedDataSend.c_str(),formatedDataSend.size()-1);sneekpeek
00452 ///////////////////////
00453 //    // old //
00454 //
00455 //    // data //
00456 //    debug(DEBUG_SEND, "\n\r    -Debut data. ");
00457 //    if(data->size() != 0) {
00458 //        formatedDataSend.append(*data);
00459 //        debug(DEBUG_COMPACT, "\n\r    -DATA ADDED: %02X, %02X, %02X, %02X, %02X ",formatedDataSend[0],formatedDataSend[1],formatedDataSend[2],formatedDataSend[3],formatedDataSend[4]);
00460 //    }
00461 //    debug(DEBUG_SEND, "\n\r    -Fin data. ");
00462 //
00463 //    // CRC //
00464 //    debug(DEBUG_SEND, "\n\r    -Debut CRC16. ");
00465 //    //CRC16* templateCRC;
00466 //    //templateCRC = new CRC16();
00467 //    unsigned short templateValue;
00468 //    char templateTable[34];
00469 //    for (unsigned i=0; i<34; ++i) templateTable[i]=0;
00470 //    for (unsigned i=0; i<formatedDataSend.length(); ++i) templateTable[i]=formatedDataSend[i];
00471 //    debug(DEBUG_SEND, "\n\r     - envoi au crc: %02X,%02X,%02X,%02X,%02X,%02X ",templateTable[0],templateTable[1],templateTable[2],templateTable[3],templateTable[4],templateTable[5],templateTable[6]);
00472 //
00473 //    templateValue = /*templateCRC->*/calculateCRC16(templateTable,formatedDataSend.size()-1); //atention pt un probleme de sortie du range
00474 //
00475 //    formatedDataSend.append(1,templateValue>>8);
00476 //    formatedDataSend.append(1,templateValue & 0xFF);
00477 //
00478 //    // if(templateCRC)
00479 //    //    delete templateCRC;
00480 //    debug(DEBUG_COMPACT, "\n\r    -DATA ADDED: %02X, %02X, %02X, %02X, %02X, %02X, %02X ",formatedDataSend[0],formatedDataSend[1],formatedDataSend[2],formatedDataSend[3],formatedDataSend[4],formatedDataSend[5],formatedDataSend[6]);
00481 //    debug(DEBUG_SEND, "\n\r    -Fin CRC16. ");
00482 //
00483 //    //Send Data
00484 //    debug(DEBUG_SEND, "\n\r    -Debut Send Data. ");
00485 //    debug(DEBUG_SEND|DEBUG_COMPACT, "\n\r     -Send: ");
00486 //    for (unsigned i=0; i<formatedDataSend.length(); ++i) debug(DEBUG_SEND |DEBUG_COMPACT, "%02X,",formatedDataSend.at(i));
00487 //
00488 //    int twoBytesArray;
00489 //   twoBytesArray = (formatedDataSend[0]<<8)|(formatedDataSend[1]);
00490 //
00491 //    for(int i=0; (i<3) && (!result); i++) {
00492 //        debug(DEBUG_SEND|DEBUG_COMPACT, "\n\r      -Tentative: %d",i);
00493 //
00494 //        twoBytesArray=write(twoBytesArray);
00495 //
00496 //        if(twoBytesArray>>8 == SYNC) {// twoBytesArray ==(Sync)//+(PFB+ACK+NDB))
00497 //            // Envoie le reste si liker si liker //
00498 //            debug(DEBUG_SEND|DEBUG_COMPACT, "\n\r    -Debut Traitement de l'information. ");
00499 //            debug(DEBUG_SEND|DEBUG_COMPACT, "\n\r     -Receive: %02X",twoBytesArray);
00500 //
00501 //            formatedDataReceive.clear();
00502 //            formatedDataReceive.append(1,twoBytesArray>>8);
00503 //            formatedDataReceive.append(1,twoBytesArray & 0xFF);
00504 //
00505 //    for (unsigned i=2; i<formatedDataSend.length(); ++i) {
00506 //        twoBytesArray = formatedDataSend[i];
00507 //        i++;
00508 //        if(i<formatedDataSend.length())
00509 //            twoBytesArray = (twoBytesArray<<8) + formatedDataSend[i];
00510 //
00511 //        twoBytesArray=write(twoBytesArray);
00512 //        formatedDataReceive.append(1,twoBytesArray>>8);
00513 //        formatedDataReceive.append(1,twoBytesArray&0xFF);
00514 //    }
00515 //
00516 //    // CRC //
00517 //    unsigned short templateValue=1;
00518 //    templateValue=formatedDataReceive.at(formatedDataReceive.length()-2) << 8;
00519 //    templateValue|=formatedDataReceive.at(formatedDataReceive.length()-1);
00520 //
00521 //    for (unsigned i=0; i<formatedDataReceive.length()-2; ++i) {
00522 //        templateValue-=formatedDataReceive[i];
00523 //    }
00524 //    debug(DEBUG_SEND, "\n\r    -CRC==0? value: %i. ", templateValue);
00525 //    (templateValue==0)? result=true:result=false;
00526 //}
00527 //}
00528 //debug(DEBUG_SEND, "\n\r    -Fin Send Data. ");
00529 //
00530 
00531 
00532 
00533 
00534     if(result) {
00535         // Traitement de l'information //
00536         debug(DEBUG_SEND, "\n\r    -Debut Traitement de l'information. ");
00537         debug(DEBUG_SEND, "\n\r     -Receive: ");
00538         for (unsigned i=0; i<formatedDataReceive.length(); ++i)debug(DEBUG_SEND|DEBUG_COMPACT, "%02X,",formatedDataReceive.at(i));
00539 
00540         // flag //
00541         flag->clear();
00542         if((settingSlave>>6) != 0) {
00543             //string str = formatedDataReceive.substr( ((2+(settingMaster>>6))+1+1),(settingSlave>>6));
00544             flag->append(formatedDataReceive.substr( ((2+(settingMaster>>6))+1+1),(settingSlave>>6)));// = &str;
00545 
00546             //debug(DEBUG_SLIM,         "\n\r         -flag get: ");
00547             //for (unsigned i=0; i<str.length(); i++) debug(DEBUG_SLIM, "%02X,",str.at(i));
00548         }
00549         //twoBytesArray=formatedDataReceive[2];
00550         //!!!!! wtf is that cest claire que sa pete la com
00551         /*string::iterator it=formatedDataReceive.begin()+3;
00552 
00553         switch(settingSlave>>6) {
00554             case 1:
00555                 flag->append(1,*it);
00556                 it++;
00557                 break;
00558 
00559             case 2:
00560                 flag->append(1,*it);
00561                 it++;
00562                 flag->append(1,*it);
00563                 it++;
00564                 break;
00565 
00566             case 3:
00567                 flag->append(1,*it);
00568                 it++;
00569                 flag->append(1,*it);
00570                 it++;
00571                 flag->append(1,*it);
00572                 it++;
00573                 break;*/
00574 
00575         /*default:
00576             formatedDataSend.append(1,0<<6);
00577             break;*/
00578         // }
00579 
00580         // ACK/NAK
00581         //
00582 
00583         // NDB //
00584         data->clear();
00585         if((settingSlave&0x0F) != 0) {
00586             //string str = formatedDataReceive.substr( ((2+(settingMaster>>6))+1+(settingSlave>>6)+1),(settingSlave&0x0F));
00587             data->append(formatedDataReceive.substr( ((2+(settingMaster>>6))+1+(settingSlave>>6)+1),(settingSlave&0x0F)));
00588 
00589             //debug(DEBUG_SLIM,         "\n\r         -data get: ");
00590             //for (unsigned i=0; i<str.length(); i++) debug(DEBUG_SLIM, "%02X,",str.at(i));
00591         }
00592         //!!!!! same shit faut rebild la chose en bas
00593         /* switch(settingSlave&0xFF) {
00594              case 1:
00595                  data->append(1,*it);
00596                  it++;
00597                  break;
00598 
00599              case 2:
00600                  data->append(1,*it);
00601                  it++;
00602                  data->append(1,*it);
00603                  it++;
00604                  break;
00605 
00606              case 3:
00607                  data->append(1,*it);
00608                  it++;
00609                  data->append(1,*it);
00610                  it++;
00611                  data->append(1,*it);
00612                  it++;
00613                  break;*/
00614 
00615         /*default:
00616 
00617             break;*/
00618         //}
00619     }
00620 
00621     debug(DEBUG_SEND, "\n\r    -Fin Traitement de l'information. ");
00622     debug(DEBUG_SEND|DEBUG_COMPACT, "\n\r   -Fin du send. ");
00623     return result;
00624 }