ecocommand.cpp

00001 /************************************
00002 Software del mbed para el Ecotron.
00003 (c) Miquel Carbonell Piqueres
00004 Diciembre de 2011.
00005 ************************************/
00006 /************************************
00007 Arhivo: ecocommand.cpp
00008 Clase para la interpretacion de comandos
00009 ************************************/
00010 
00011 #include "mbed.h"
00012 #include "ecocommand.h"
00013 
00014 
00015 char *estados[NUMESTADOS]={"OK","PARAMS","COMAND","FORCEBATT","LOBATT"};
00016 
00017 char *comandoRx[NUMCOMMANDSRX]={"$VM+VER?","$VM+CHKBAT=?","$VM+CHKBAT=ON","$VM+CHKBAT=OFF",
00018 "$VM+CHKBAT=","$VM+OUT#","$VM+OUT%","$VM+IN#?","$VM+IN%?","$VM+IN?","$VM+?","$VM+TX="};
00019 
00020 char *comandoTx[NUMCOMMANDSTX]={"IN#","IN%","H=1.0/S=0.1","OUT#","OUT%","STATUS("};
00021 
00022 
00023 ecocommand::ecocommand(){
00024 
00025     Estado=ESTADO_OK;
00026 }
00027 
00028 char *ecocommand::EstadoActual(){
00029 
00030     switch(Estado){
00031         case ESTADO_OK:
00032         case ESTADO_PARAMS:
00033         case ESTADO_COMAND:
00034         case ESTADO_FORCEBATT:
00035         case ESTADO_LOBATT:
00036             return estados[Estado];
00037     }
00038     return NULL;
00039 }
00040 
00041 char *ecocommand::InterpretarComando(char *c, entradas *e, salidas *s){
00042 
00043     int i=VerComandoRx(c);
00044     if (i==ERROR_COD){
00045         Estado=ESTADO_COMAND;
00046         return NULL;
00047     }
00048     switch (i){
00049         case COMANDO_VER:
00050             Estado=ESTADO_OK;
00051             sprintf(buffer,"H=1.0/S=1.0");
00052             break;
00053         case COMANDO_CHX:
00054         case COMANDO_CHN:
00055         case COMANDO_CHF:
00056         case COMANDO_CHK: //No hay bateria en la version actual.
00057             Estado=ESTADO_PARAMS;
00058             break;
00059         case COMANDO_OUD:
00060             i=NumSalida(c);
00061             Estado=ESTADO_OK;
00062             VerOpcionSalidaDigital(i,c,s);
00063             break;
00064         case COMANDO_OUA:
00065             i=NumSalida(c);
00066             Estado=ESTADO_OK;
00067             VerOpcionSalidaAnalogica(i,c,s);
00068             break;
00069         case COMANDO_IND:
00070             Estado=ESTADO_OK;
00071             VerEntradasDigitales(e);
00072             break;
00073         case COMANDO_INA:
00074             Estado=ESTADO_OK;
00075             VerEntradasAnalogicas(e);
00076             break;
00077         case COMANDO_INX:
00078             Estado=ESTADO_OK;
00079             VerEntradas(e);
00080             break;
00081         case COMANDO_TOT:
00082             Estado=ESTADO_OK;
00083             InformeGlobal(e,s);
00084             break;
00085         case COMANDO_TTX:
00086             Estado=ESTADO_OK;
00087             //Guardar el numero en flash.
00088             sprintf(buffer,"STATUS(OK)");
00089             break;
00090         default:
00091             Estado=ESTADO_COMAND;
00092     }
00093     switch (Estado){
00094         case ESTADO_COMAND:
00095             sprintf(buffer,"STATUS(COMAND)");
00096             break;
00097         case ESTADO_PARAMS:
00098             sprintf(buffer,"STATUS(PARAMS)");
00099             break;
00100         default:
00101             return buffer;
00102     }
00103     return buffer;
00104 }
00105 
00106 
00107 int ecocommand::VerComandoRx(char *c){
00108 
00109     int i;
00110     for (i=0; i<NUMCOMMANDSRX; ++i)
00111         if (!strcmp(c,comandoRx[i]))
00112             return i;
00113     return ERROR_COD;
00114 }
00115 
00116 /****
00117     Esta funcion averigua el numero de salida pasado
00118     como texto en el comando c. Si no es un numero valido
00119     devuelve ERROR_PARAMS.
00120 ****/
00121 int ecocommand::NumSalida(char *c){
00122 
00123     int i;
00124     char n[3];
00125     n[0]=c[8];
00126     n[1]=c[9];
00127     n[2]='\x0';
00128     i=atoi(n);
00129     if (i<=0)
00130         return ERROR_PAR;
00131     return i;
00132 }
00133 
00134 /****
00135     Devuelve la cadena correspondiente a las distintas
00136     opciones posibles de entrada como son "?", "=ON", "=OFF",
00137     para la salida numero i.
00138     Si la salida i no existe, devuelve null.
00139     Si las opciones no son vlaidas, devuelve null.
00140 ****/
00141 void ecocommand::VerOpcionSalidaDigital(int i,char *c, salidas *s){
00142 
00143     if (!strcmp(&c[10],"=?")){
00144         switch (s->VerSalidaDigital(i)){
00145             case E_NOTIPO:
00146             case E_NOEXIST:
00147                 Estado=ESTADO_PARAMS;
00148                 return;
00149             case ID_DIGITAL_ON:
00150                 Estado=ESTADO_OK;
00151                 sprintf(buffer,"OUT#%d=ON",i);
00152                 return;
00153             case ID_DIGITAL_OFF:
00154                 Estado=ESTADO_OK;
00155                 sprintf(buffer,"OUT#%d=OFF",i);
00156                 return;
00157             default:
00158                 Estado=ESTADO_PARAMS;
00159                 return;
00160         }
00161     }
00162     if (!strcmp(&c[10],"=ON")){
00163         if (s->PonSalidaDigital(i,true)){
00164             Estado=ESTADO_OK;
00165             sprintf(buffer,"OUT#%d=ON",i);
00166             return;
00167         }
00168         else{
00169             Estado=ESTADO_PARAMS;
00170             return;
00171         }
00172     }
00173     if (!strcmp(&c[10],"=OFF")){
00174         if (s->PonSalidaDigital(i,false)){
00175             Estado=ESTADO_OK;
00176             sprintf(buffer,"OUT#%d=OFF",i);
00177             return;
00178         }
00179         else{
00180             Estado=ESTADO_PARAMS;
00181             return;
00182         }
00183     }
00184     Estado=ESTADO_PARAMS;
00185 }
00186 
00187 
00188 void ecocommand::VerOpcionSalidaAnalogica(int i,char *c,salidas *s){
00189 
00190     int j;
00191     float f;
00192     if (!strcmp(&c[10],"=?")){
00193         j=s->VerSalidaAnalogica(i);
00194         switch (j){
00195             case E_NOTIPO:
00196             case E_NOEXIST:
00197                 Estado=ESTADO_PARAMS;
00198                 return;
00199             default:
00200                 Estado=ESTADO_OK;
00201                 sprintf(buffer,"OUT%%%d=%d",i,j);
00202                 return;
00203         }
00204     }
00205     f=atof(&c[11]); //f= valor requerido en la salida.
00206     if (s->PonSalidaAnalogica(i,f)){
00207         Estado=ESTADO_OK;
00208         sprintf(buffer,"OUT%%%d=%f.1",i,f);
00209         return;
00210     }
00211     Estado=ESTADO_PARAMS;
00212 }
00213 
00214  void ecocommand::VerEntradasDigitales(entradas *e){
00215 
00216     int i;
00217     char bufferLocal[8];
00218     sprintf(buffer,"IN#={");
00219     for (i=0; i<MAX_ENTRADAS; ++i)
00220         if (e->TipoEntrada(i)==ID_DIGITAL){
00221             if (e->VerEntradaDigital(i)==ID_DIGITAL_ON)
00222                 sprintf(bufferLocal,"%d=1",i);
00223             else
00224                 sprintf(bufferLocal,"%d=0",i);
00225             strcat(buffer,bufferLocal);
00226             if (i<MAX_ENTRADAS-1)
00227                 strcat(buffer,";");
00228         }
00229     strcat(buffer,"}");
00230 }
00231 
00232 void ecocommand::VerEntradasAnalogicas(entradas *e){
00233 
00234     int i;
00235     float f;
00236     char bufferLocal[8];
00237     sprintf(buffer,"IN%={");
00238     for (i=0; i<MAX_ENTRADAS; ++i)
00239         if (e->TipoEntrada(i)==ID_ANALOGICA){
00240             f=e->VerEntradaAnalogica(i);
00241             sprintf(bufferLocal,"%d=%f.1",i,f);
00242             strcat(buffer,bufferLocal);
00243             if (i<MAX_ENTRADAS-1)
00244                 strcat(buffer,";");
00245         }
00246     strcat(buffer,"}");
00247 }
00248 
00249 void ecocommand::VerEntradas(entradas *e){
00250 
00251     char bufferLocal[MAX_COD];
00252     VerEntradasDigitales(e);
00253     strcpy(bufferLocal,buffer);
00254     VerEntradasAnalogicas(e);
00255     strcat(bufferLocal,buffer);
00256     strcpy(buffer,bufferLocal);
00257 }
00258 
00259 void ecocommand::InformeGlobal(entradas *e, salidas *s){
00260 
00261     char bufferLocal[MAX_COD];
00262     int i;
00263     VerEntradas(e);
00264     strcpy(bufferLocal,buffer);
00265     for (i=0; i<MAX_SALIDAS; ++i){
00266         if (s->TipoSalida(i+1)==ID_DIGITAL){
00267             VerOpcionSalidaDigital(i+1,"$VM+OUT#nn=?",s);
00268             strcat(bufferLocal,buffer);
00269         }
00270         else{
00271             VerOpcionSalidaAnalogica(i+1,"$VM+OUT%nn=?",s);
00272             strcat(bufferLocal,buffer);
00273         }
00274         strcat(bufferLocal,";");
00275     }
00276     strcpy(buffer,bufferLocal);
00277 }