ecotron_es.cpp

00001 /************************************
00002 Software del mbed para el Ecotron.
00003 (c) Miquel Carbonell Piqueres
00004 Diciembre de 2011.
00005 ************************************/
00006 /************************************
00007 Arhivo: ecotron_es.cpp
00008 ************************************/
00009 
00010 #include "ecotron_es.h"
00011 
00012 DigitalIn di1(p8);      //Entradas digitales.
00013 DigitalIn di2(p9);
00014 DigitalIn di3(p10);
00015 DigitalIn di4(p11);
00016 DigitalIn di5(p12);
00017 DigitalIn di6(p13);
00018 DigitalIn di7(p14);
00019 DigitalIn di8(p15);
00020 DigitalIn di9(p16);
00021 DigitalIn di10(p17);
00022 DigitalIn di11(p18);
00023 DigitalIn di12(p19);
00024 
00025 AnalogIn ai1(p15);        //La entrada analogica 1 se solapa con la digital 8...
00026 AnalogIn ai2(p16);        //...y asi sucesivamente, actuando segun se le mande...
00027 AnalogIn ai3(p17);        //...en el programa principal.
00028 AnalogIn ai4(p18);
00029 AnalogIn ai5(p19);
00030 
00031 
00032 DigitalOut do1(p21);    //Salidas digitales.
00033 DigitalOut do2(p22);
00034 DigitalOut do3(p23);
00035 DigitalOut do4(p24);
00036 DigitalOut do5(p25);
00037 DigitalOut do6(p26);
00038 
00039 PwmOut ao1(p21);    //Salidas analogicas por PWM.
00040 PwmOut ao2(p22);
00041 PwmOut ao3(p23);
00042 PwmOut ao4(p24);
00043 PwmOut ao5(p25);
00044 PwmOut ao6(p26);
00045 
00046 //----------------------------------------------
00047 // ENTRADAS:
00048 //----------------------------------------------
00049 /**
00050     El contructor por defecto hace que todas las
00051     entradas configurables sean digitales.
00052 **/
00053 entradas::entradas() {
00054 
00055     int i;
00056     for (i=0; i<ENTRADAS_CONFIGURABLES; ++i)
00057         EntradasConfigurables[i]=DIGITAL;
00058 }
00059 
00060 /**
00061     Constructor con una matriz de boolean
00062     de tamanyo ENTRADAS_CONFIGURABLES, en
00063     la cual se especifica el tipo de entrada
00064     analogica o digital en su posicion adecuada.
00065 **/
00066 entradas::entradas(bool e[]){
00067 
00068     int i;
00069     for (i=0; i<ENTRADAS_CONFIGURABLES; ++i)
00070         EntradasConfigurables[i]=e[i];
00071 }
00072 
00073 /**
00074     Devuelve verdadero si la entrada e es digital,
00075     y falso en caso contrario.
00076 **/
00077 int entradas::TipoEntrada(int e){
00078 
00079     int NumDigitales=(MAX_ENTRADAS-ENTRADAS_CONFIGURABLES)+1;
00080     if ((e<=0)||(e>MAX_ENTRADAS))
00081         return E_NOEXIST;
00082     if ((e>0)&&(e<NumDigitales)) //Entradas 1..7 son digitales.
00083         return ID_DIGITAL;
00084     if (EntradasConfigurables[e-NumDigitales]==DIGITAL)
00085         return ID_DIGITAL;
00086     else
00087         return ID_ANALOGICA;    
00088 }
00089 
00090 /**
00091     Devuelve el estado de la entrada e.
00092     Si no existe devuelve E_NOEXIST.
00093     Si es analogica, devuelve E_NOTIPO.
00094 **/
00095 int entradas::VerEntradaDigital(int e){
00096 
00097     switch(e){
00098         case 1:
00099             if (di1)
00100                 return ID_DIGITAL_ON;
00101             else
00102                 return ID_DIGITAL_OFF;
00103         case 2:
00104             if (di2)
00105                 return ID_DIGITAL_ON;
00106             else
00107                 return ID_DIGITAL_OFF;
00108         case 3:
00109             if (di3)
00110                 return ID_DIGITAL_ON;
00111             else
00112                 return ID_DIGITAL_OFF;
00113         case 4:
00114             if (di4)
00115                 return ID_DIGITAL_ON;
00116             else
00117                 return ID_DIGITAL_OFF;
00118         case 5:
00119             if (di5)
00120                 return ID_DIGITAL_ON;
00121             else
00122                 return ID_DIGITAL_OFF;
00123         case 6:
00124             if (di6)
00125                 return ID_DIGITAL_ON;
00126             else
00127                 return ID_DIGITAL_OFF;
00128         case 7:
00129             if (di7)
00130                 return ID_DIGITAL_ON;
00131             else
00132                 return ID_DIGITAL_OFF;
00133         case 8:
00134             if (EntradasConfigurables[0]==DIGITAL)
00135                 if (di8)
00136                     return ID_DIGITAL_ON;
00137                 else
00138                     return ID_DIGITAL_OFF;
00139             else
00140                 return E_NOTIPO;
00141         case 9:
00142             if (EntradasConfigurables[1]==DIGITAL)
00143                 if (di9)
00144                     return ID_DIGITAL_ON;
00145                 else
00146                     return ID_DIGITAL_OFF;
00147             else
00148                 return E_NOTIPO;
00149         case 10:
00150             if (EntradasConfigurables[2]==DIGITAL)
00151                 if (di10)
00152                     return ID_DIGITAL_ON;
00153                 else
00154                     return ID_DIGITAL_OFF;
00155             else
00156                 return E_NOTIPO;
00157         case 11:
00158             if (EntradasConfigurables[3]==DIGITAL)
00159                 if (di11)
00160                     return ID_DIGITAL_ON;
00161                 else
00162                     return ID_DIGITAL_OFF;
00163             else
00164                 return E_NOTIPO;
00165         case 12:
00166             if (EntradasConfigurables[4]==DIGITAL)
00167                 if (di12)
00168                     return ID_DIGITAL_ON;
00169                 else
00170                     return ID_DIGITAL_OFF;
00171             else
00172                 return E_NOTIPO;
00173     }
00174     return E_NOEXIST;
00175 }
00176 
00177 /**
00178     Devuelve el estado de la entrada e.
00179     Si no existe devuelve E_NOEXIST.
00180     Si es digital, devuelve E_NOTIPO.
00181 **/
00182 float entradas::VerEntradaAnalogica(int e){
00183 
00184     switch (e){
00185         case 1:
00186             if (EntradasConfigurables[0]==DIGITAL)
00187                 return E_NOTIPO;
00188             else
00189                 return ai1;
00190         case 2:
00191             if (EntradasConfigurables[1]==DIGITAL)
00192                 return E_NOTIPO;
00193             else
00194                 return ai2;
00195         case 3:
00196             if (EntradasConfigurables[2]==DIGITAL)
00197                 return E_NOTIPO;
00198             else
00199                 return ai3;
00200         case 4:
00201             if (EntradasConfigurables[3]==DIGITAL)
00202                 return E_NOTIPO;
00203             else
00204                 return ai4;
00205         case 5:
00206             if (EntradasConfigurables[4]==DIGITAL)
00207                 return E_NOTIPO;
00208             else
00209                 return ai5;
00210     }
00211     return E_NOEXIST;
00212 }
00213 
00214 
00215 //----------------------------------------------
00216 // SALIDAS:
00217 //----------------------------------------------
00218 /**
00219     El contructor por defecto hace que todas las
00220     salidas configurables sean digitales.
00221 **/
00222 
00223 salidas::salidas(){
00224 
00225     InicializaSalidas();
00226 }
00227 
00228 /**
00229     Constructor con una matriz de boolean
00230     de tamanyo SALIDAS_CONFIGURABLES, en
00231     la cual se especifica el tipo de salida
00232     analogica o digital en su posicion adecuada.
00233 **/
00234 salidas::salidas(bool s[]){
00235 
00236     InicializaSalidas(s);
00237 }
00238 
00239 void salidas::InicializaSalidas(){
00240 
00241     int i;
00242     for (i=0; i<SALIDAS_CONFIGURABLES; ++i){
00243         SalidasConfigurables[i]=DIGITAL;
00244         PonSalidaDigital(i+1,false);
00245     }
00246 }
00247 
00248 void salidas::InicializaSalidas(bool s[]){
00249 
00250     int i;
00251     for (i=0; i<SALIDAS_CONFIGURABLES; ++i)
00252         SalidasConfigurables[i]=s[i];
00253     for (i=0; i<SALIDAS_CONFIGURABLES; ++i)
00254         if (SalidasConfigurables[i]==DIGITAL)
00255             PonSalidaDigital(i+1,false);
00256         else
00257             PonSalidaAnalogica(i+1,0);
00258 }
00259 
00260 /***
00261     Devuelve el tipo de salida.
00262     La llamada es con el numero de salida [1..MAX_SALIDAS]
00263 ***/
00264 int salidas::TipoSalida(int s){
00265 
00266     if ((s<=0)||(s>MAX_SALIDAS))
00267         return E_NOEXIST;
00268     if (SalidasConfigurables[s]==DIGITAL)
00269         return ID_DIGITAL;
00270     return ID_ANALOGICA;
00271 }
00272 
00273 /**
00274     Muestra el estado de la salida s.
00275     Si no existe devuelve E_NOEXIST.
00276     Si es analogica, devuelve E_NOTIPO.
00277 **/
00278 int salidas::VerSalidaDigital(int s){
00279 
00280     switch (s){
00281         case 1:
00282             if (SalidasConfigurables[0]==ANALOGICA)
00283                 return E_NOTIPO;
00284             else
00285                 if (do1)
00286                     return ID_DIGITAL_ON;
00287                 else
00288                     return ID_DIGITAL_OFF;
00289         case 2:
00290             if (SalidasConfigurables[1]==ANALOGICA)
00291                 return E_NOTIPO;
00292             else
00293                 if (do2)
00294                     return ID_DIGITAL_ON;
00295                 else
00296                     return ID_DIGITAL_OFF;
00297         case 3:
00298             if (SalidasConfigurables[2]==ANALOGICA)
00299                 return E_NOTIPO;
00300             else
00301                 if (do3)
00302                     return ID_DIGITAL_ON;
00303                 else
00304                     return ID_DIGITAL_OFF;
00305         case 4:
00306             if (SalidasConfigurables[3]==ANALOGICA)
00307                 return E_NOTIPO;
00308             else
00309                 if (do4)
00310                     return ID_DIGITAL_ON;
00311                 else
00312                     return ID_DIGITAL_OFF;
00313     }
00314     return E_NOEXIST;
00315 }
00316 
00317 
00318 /**
00319     Muestra el estado de la salida s.
00320     Si no existe devuelve E_NOEXIST.
00321     Si es digital, devuelve E_NOTIPO.
00322 **/
00323 int salidas::VerSalidaAnalogica(int s){
00324 
00325     float f;
00326     switch (s){
00327         case 1:
00328             if (SalidasConfigurables[0]==ANALOGICA)
00329                 f=ao1;
00330             else
00331                 return E_NOTIPO;
00332             break;
00333         case 2:
00334             if (SalidasConfigurables[1]==ANALOGICA)
00335                 f=ao2;
00336             else
00337                 return E_NOTIPO;
00338             break;
00339         case 3:
00340             if (SalidasConfigurables[2]==ANALOGICA)
00341                 f=ao3;
00342             else
00343                 return E_NOTIPO;
00344             break;
00345         case 4:
00346             if (SalidasConfigurables[3]==ANALOGICA)
00347                 f=ao4;
00348             else
00349                 return E_NOTIPO;
00350             break;
00351         default:
00352             return E_NOEXIST;
00353     }
00354     return (int)f*100;
00355 }
00356 
00357 /**
00358  Pone la salida digital s al valor b.
00359  Devuelve verdadero si Ok y falso si s
00360  no existe o no es digital.
00361 **/
00362 bool salidas::PonSalidaDigital(int s,bool b){
00363 
00364     if (s>MAX_SALIDAS)
00365         return false;
00366     switch (s){
00367         case 1:
00368             if (SalidasConfigurables[0]==ANALOGICA)
00369                 return false;
00370             else do1=b;
00371             break;
00372         case 2:
00373             if (SalidasConfigurables[1]==ANALOGICA)
00374                 return false;
00375             else do2=b;
00376             break;
00377         case 3:
00378             if (SalidasConfigurables[2]==ANALOGICA)
00379                 return false;
00380             else do3=b;
00381             break;
00382         case 4:
00383             if (SalidasConfigurables[3]==ANALOGICA)
00384                 return false;
00385             else do4=b;
00386             break;
00387         default:
00388             return false;
00389     }
00390     return true; //Todo OK.
00391 }
00392 
00393 /**
00394  Pone la salida analogica s al valor v.
00395  El valor v debe de estar dado en tanto por cien, es
00396  decir comprendido entre 0 y 100. Si no es as�,
00397  se manipula convenientemente.
00398  Devuelve verdadero si Ok y falso si s
00399  no existe o no es analogica.
00400 **/
00401 bool salidas::PonSalidaAnalogica(int s,float v){
00402 
00403     float i;
00404     if (v<0)
00405         i=0;
00406     else
00407         if (v>100)
00408             i=1;
00409         else
00410             i=v/100;    
00411     switch (s){
00412         case 1:
00413             if (SalidasConfigurables[0]==DIGITAL)
00414                 return false;
00415             else ao1=i;
00416             break;
00417         case 2:
00418             if (SalidasConfigurables[1]==DIGITAL)
00419                 return false;
00420             else ao2=i;
00421             break;
00422         case 3:
00423             if (SalidasConfigurables[2]==DIGITAL)
00424                 return false;
00425             else ao3=i;
00426             break;
00427         case 4:
00428             if (SalidasConfigurables[3]==DIGITAL)
00429                 return false;
00430             else ao4=i;
00431             break;
00432         default:
00433             return false;
00434     }
00435     return true; //Todo OK.
00436 }
00437 
00438 
00439 
00440