Configuration.c

00001 #include "System.h"
00002 
00003 LocalFileSystem LocalFS("local"); 
00004 
00005 CHAR LineBuf[128];
00006 
00007 //Voltage Divider for the Li_poly Battery
00008 float R17,R15;
00009 #define R17_DEFAULT  (float)(10000.0)
00010 #define R15_DEFAULT  (float)(10000.0)
00011 
00012 //Voltage Divider for input voltage measurement
00013 float R2,R4;
00014 #define R2_DEFAULT  (float)(100000.0)
00015 #define R4_DEFAULT  (float)(3300.0)
00016 
00017 //Voltage Divider for current voltage measurement (to the 16-bit ADC)
00018 float R6,R7;
00019 #define R6_DEFAULT (float) (10000.0)
00020 #define R7_DEFAULT  (float)(10000.0)
00021 
00022 //Voltage Divider for current voltage measurement (to the 12-bit ADC)
00023 float R8,R9;
00024 #define R8_DEFAULT  (float)(5100.0)
00025 #define R9_DEFAULT  (float)(10000.0)
00026 
00027 //value of the 2.5Voltage reference
00028 float U1_VREF;
00029 #define U1_VREF_DEFAULT    (float)(2.5)
00030 
00031 //value of the MBED Voltage reference
00032 float MBED_VREF;
00033 #define MBED_VREF_DEFAULT    (float)(3.3)
00034 
00035 //value of the input diode drop
00036 float INPUT_DIODE_DROP;
00037 #define INPUT_DIODE_DROP_DEFAULT   (float)(0.601)
00038 
00039 
00040 //used for self current 
00041 float R22;
00042 #define R22_DEFAULT 0.5
00043 
00044 float R18;
00045 #define R18_DEFAULT 200
00046 
00047 float R19;
00048 #define R19_DEFAULT 200
00049 
00050 float R20;
00051 #define R20_DEFAULT 10000
00052 
00053 
00054 //Parameters for the ACS576 Current Sensor
00055 
00056 float ACS576_VOFFSET;
00057 #define ACS576_VOFFSET_DEFAULT              (2.5)
00058 
00059 float ACS576_ISCALE; 
00060 #define ACS576_ISCALE_DEFAULT              (25.0)
00061 
00062 float ACS576_ISCALE_ADJUST; 
00063 #define ACS576_ISCALE_ADJUST_DEFAULT         (1.0)
00064 
00065 float ACS576_IOFFSET_TRIM; 
00066 #define ACS576_IOFFSET_TRIM_DEFAULT        (0.0)
00067 
00068 //Used to correct the input voltage measurement
00069 float  VSCALE_ADJUST; 
00070 #define VSCALE_ADJUST_DEFAULT        (1.0)
00071 
00072 float  VOFFSET_ADJUST; 
00073 #define VOFFSET_ADJUST_DEFAULT        (0.0)
00074 
00075 //Sampling Parameters
00076 float   SAMPLE_RATE;
00077 DWORD   WRITE_BLOCK_THRESH;
00078 
00079 CHAR ID[MAX_ID_LENGTH+1];
00080 #define ID_DEFAULT "No ID"
00081 
00082 void LoadDefaults()
00083 {
00084     strcpy(ID,ID_DEFAULT);
00085 
00086     VOFFSET_ADJUST = VOFFSET_ADJUST_DEFAULT;
00087     VSCALE_ADJUST  = VSCALE_ADJUST_DEFAULT;
00088     
00089     R17 = R17_DEFAULT;
00090     R15 = R15_DEFAULT;
00091 
00092     R2 = R2_DEFAULT;
00093     R4 = R4_DEFAULT;
00094 
00095     R6 = R6_DEFAULT;
00096     R7 = R7_DEFAULT;
00097     
00098     R8 = R8_DEFAULT;
00099     R9 = R9_DEFAULT;
00100     
00101     R18 = R18_DEFAULT;
00102     R19 = R19_DEFAULT;
00103     R20 = R20_DEFAULT;
00104     R22 = R22_DEFAULT;
00105     
00106     U1_VREF = U1_VREF_DEFAULT;
00107     MBED_VREF = MBED_VREF_DEFAULT;
00108     
00109     INPUT_DIODE_DROP =  INPUT_DIODE_DROP_DEFAULT;
00110     
00111     ACS576_VOFFSET = ACS576_VOFFSET_DEFAULT;
00112 
00113     ACS576_ISCALE =  ACS576_ISCALE_DEFAULT;
00114     ACS576_ISCALE_ADJUST = ACS576_ISCALE_ADJUST_DEFAULT;
00115     
00116     ACS576_IOFFSET_TRIM = ACS576_IOFFSET_TRIM_DEFAULT;
00117     
00118     SAMPLE_RATE = SAMPLE_RATE_DEFAULT;
00119     WRITE_BLOCK_THRESH = WRITE_BLOCK_THRESH_DEFAULT;
00120 }
00121 
00122 void ExportConfigurationSettings()
00123 {
00124     FILE *MyConfigFile = fopen("/local/config.txt","w");
00125     
00126     
00127     fprintf(MyConfigFile,"ACS576_ISCALE_ADJUST = %.3f  \r\n",ACS576_ISCALE_ADJUST); 
00128     fprintf(MyConfigFile,"ACS576_IOFFSET_TRIM = %.3f  \r\n",ACS576_IOFFSET_TRIM);
00129     
00130     fprintf(MyConfigFile,"VSCALE_ADJUST = %.3f  \r\n",VSCALE_ADJUST);
00131     fprintf(MyConfigFile,"VOFFSET_ADJUST = %.3f  \r\n",VOFFSET_ADJUST);
00132     
00133     fprintf(MyConfigFile,"R17 = %.1f  \r\n",R17);
00134     fprintf(MyConfigFile,"R15 = %.1f  \r\n",R15);
00135 
00136     fprintf(MyConfigFile,"R2 = %.1f  \r\n",R2);
00137     fprintf(MyConfigFile,"R4 = %.1f  \r\n", R4);
00138 
00139     fprintf(MyConfigFile,"R6 = %.1f  \r\n",R6);
00140     fprintf(MyConfigFile,"R7 = %.1f  \r\n",R7);
00141     
00142     fprintf(MyConfigFile,"R8 = %.1f  \r\n",R8);
00143     fprintf(MyConfigFile,"R9 = %.1f  \r\n",R9);
00144     
00145     fprintf(MyConfigFile,"R18 = %.1f  \r\n",R18);
00146     fprintf(MyConfigFile,"R19 = %.1f  \r\n",R19);
00147     fprintf(MyConfigFile,"R20 = %.1f  \r\n",R20);
00148     fprintf(MyConfigFile,"R22 = %.1f  \r\n",R22);
00149     
00150     fprintf(MyConfigFile,"U1_VREF = %.3f  \r\n",U1_VREF);
00151     fprintf(MyConfigFile,"MBED_VREF = %.3f  \r\n",MBED_VREF);
00152     
00153     fprintf(MyConfigFile,"INPUT_DIODE_DROP = %.3f  \r\n",INPUT_DIODE_DROP);
00154     
00155     fprintf(MyConfigFile,"ACS576_VOFFSET = %.3f  \r\n",ACS576_VOFFSET);
00156 
00157     fprintf(MyConfigFile,"ACS576_ISCALE = %.3f  \r\n", ACS576_ISCALE_DEFAULT);
00158    
00159     
00160     fprintf(MyConfigFile,"SAMPLE_RATE = %.1f  \r\n",SAMPLE_RATE);
00161     fprintf(MyConfigFile,"WRITE_BLOCK_THRESH = %d  \r\n",WRITE_BLOCK_THRESH);
00162   
00163     fprintf(MyConfigFile,"ID = %s    \r\n",ID);
00164   
00165   
00166     fclose(MyConfigFile);
00167 }
00168 
00169 //This is a very "static implementation.  Just does string compares.  Would be nice to have a table like feature in the future
00170 void  ParseKeyValue(const CHAR *Key,const CHAR *Value)
00171 {
00172     WORD i;
00173     
00174      if(!strcmp(Key,(CHAR *)"R17"))
00175     {
00176         R17 = atof(Value);
00177         PrintfEnqueue(&PCBackDoorTx,"R17 assigned a value of %.3f",R17);
00178     }
00179     else if(!strcmp(Key,"R15"))
00180     {
00181         R15 = atof(Value);
00182         PrintfEnqueue(&PCBackDoorTx,"R15 assigned a value of %.3f",R15);
00183     }
00184     else if(!strcmp(Key,"R2"))
00185     {
00186         R2 = atof(Value);
00187         PrintfEnqueue(&PCBackDoorTx,"R2 assigned a value of %.3f",R2);
00188     }
00189     else if(!strcmp(Key,"R4"))
00190     {
00191         R4 = atof(Value);
00192         PrintfEnqueue(&PCBackDoorTx,"R4 assigned a value of %.3f",R4);
00193     }
00194     else if(!strcmp(Key,"R6"))
00195     {
00196         R6 = atof(Value);
00197         PrintfEnqueue(&PCBackDoorTx,"R6 assigned a value of %.3f",R6);
00198     }
00199     else if(!strcmp(Key,"R7"))
00200     {
00201         R7 = atof(Value);
00202         PrintfEnqueue(&PCBackDoorTx,"R7 assigned a value of %.3f",R7);
00203     }
00204     else if(!strcmp(Key,"R8"))
00205     {
00206         R8 = atof(Value);
00207         PrintfEnqueue(&PCBackDoorTx,"R8 assigned a value of %.3f",R8);
00208     }
00209     else if(!strcmp(Key,"R9"))
00210     {
00211         R9 = atof(Value);
00212         PrintfEnqueue(&PCBackDoorTx,"R9 assigned a value of %.3f",R9);
00213     }
00214     else if(!strcmp(Key,"U1_VREF"))
00215     {
00216         U1_VREF = atof(Value);
00217         PrintfEnqueue(&PCBackDoorTx,"U1_VREF assigned a value of %.3f",U1_VREF);
00218     }
00219     else if(!strcmp(Key,"MBED_VREF"))
00220     {
00221         MBED_VREF = atof(Value);
00222         PrintfEnqueue(&PCBackDoorTx,"MBED_VREF assigned a value of %.3f",MBED_VREF);
00223     }
00224     else if(!strcmp(Key,"INPUT_DIODE_DROP"))
00225     {
00226         INPUT_DIODE_DROP = atof(Value);
00227         PrintfEnqueue(&PCBackDoorTx,"INPUT_DIODE_DROP assigned a value of %.3f",INPUT_DIODE_DROP);
00228     }
00229     else if(!strcmp(Key,"ACS576_VOFFSET"))
00230     {
00231         ACS576_VOFFSET = atof(Value);
00232         PrintfEnqueue(&PCBackDoorTx,"ACS576_VOFFSET assigned a value of %.3f", ACS576_VOFFSET);
00233     }
00234     else if(!strcmp(Key,"ACS576_ISCALE"))
00235     {
00236         ACS576_ISCALE = atof(Value);
00237         PrintfEnqueue(&PCBackDoorTx,"ACS576_ISCALE assigned a value of %.3f", ACS576_ISCALE);
00238     }
00239      else if(!strcmp(Key,"ACS576_ISCALE_ADJUST"))
00240     {
00241         ACS576_ISCALE_ADJUST = atof(Value);
00242         PrintfEnqueue(&PCBackDoorTx,"ACS576_ISCALE_ADJUST assigned a value of %.3f", ACS576_ISCALE_ADJUST);
00243     }
00244     else if(!strcmp(Key,"ACS576_IOFFSET_TRIM"))
00245     {
00246         ACS576_IOFFSET_TRIM = atof(Value);
00247         PrintfEnqueue(&PCBackDoorTx,"ACS576_IOFFSET_TRIM assigned a value of %.3f",  ACS576_IOFFSET_TRIM);
00248     }
00249     else if(!strcmp(Key,"R18"))
00250     {
00251         R18 = atof(Value);
00252         PrintfEnqueue(&PCBackDoorTx,"R18 assigned a value of %.3f",  R18);
00253     }
00254     else if(!strcmp(Key,"R19"))
00255     {
00256         R19 = atof(Value);
00257         PrintfEnqueue(&PCBackDoorTx,"R19 assigned a value of %.3f",  R19);
00258     }
00259     else if(!strcmp(Key,"R20"))
00260     {
00261         R20 = atof(Value);
00262         PrintfEnqueue(&PCBackDoorTx,"R20 assigned a value of %.3f",  R20);
00263     }
00264     else if(!strcmp(Key,"R22"))
00265     {
00266         R22 = atof(Value);
00267         PrintfEnqueue(&PCBackDoorTx,"R22 assigned a value of %.3f",  R22);
00268     }
00269     else if(!strcmp(Key,"VSCALE_ADJUST"))
00270     {
00271         VSCALE_ADJUST = atof(Value);
00272         PrintfEnqueue(&PCBackDoorTx,"VSCALE_ADJUST assigned a value of %.3f",  VSCALE_ADJUST);
00273     }
00274     else if(!strcmp(Key,"VOFFSET_ADJUST"))
00275     {
00276         VOFFSET_ADJUST = atof(Value);
00277         PrintfEnqueue(&PCBackDoorTx,"VOFFSET_ADJUST assigned a value of %.3f",  VOFFSET_ADJUST);
00278     }
00279     else if(!strcmp(Key,"SAMPLE_RATE"))
00280     {
00281         SAMPLE_RATE = atof(Value);
00282          
00283            if(SAMPLE_RATE < MIN_SAMPLE_RATE || SAMPLE_RATE > MAX_SAMPLE_RATE)
00284            {
00285                PrintfEnqueue(&PCBackDoorTx,"Illegal SAMPLE_RATE of %.1f was specified. %.1f is being used",SAMPLE_RATE,SAMPLE_RATE_DEFAULT);
00286                 SAMPLE_RATE = SAMPLE_RATE_DEFAULT;
00287             }
00288             else
00289             {
00290                     PrintfEnqueue(&PCBackDoorTx,"SAMPLE_RATE assigned a value of %.1f",  SAMPLE_RATE);
00291             }
00292     }
00293     
00294     else if(!strcmp(Key,"WRITE_BLOCK_THRESH"))
00295     {
00296          WRITE_BLOCK_THRESH = (DWORD)atof(Value);
00297          
00298            if(WRITE_BLOCK_THRESH < MIN_WRITE_BLOCK_THRESH|| WRITE_BLOCK_THRESH > MAX_WRITE_BLOCK_THRESH)
00299            {
00300                 PrintfEnqueue(&PCBackDoorTx,"Illegal WRITE_BLOCK_THRESH of %d was specified. %d is being used\r\n",WRITE_BLOCK_THRESH,WRITE_BLOCK_THRESH_DEFAULT);
00301                 PrintfEnqueue(&PCBackDoorTx,"WRITE_BLOCK_THRESH must be between %d and %d",MIN_WRITE_BLOCK_THRESH, MAX_WRITE_BLOCK_THRESH); 
00302              
00303                 WRITE_BLOCK_THRESH = WRITE_BLOCK_THRESH_DEFAULT;
00304             }
00305             else
00306             {
00307                     PrintfEnqueue(&PCBackDoorTx,"WRITE_BLOCK_THRESH assigned a value of %d",  WRITE_BLOCK_THRESH);
00308             }
00309     }
00310     else if(!strcmp(Key,"ID"))
00311     {
00312         if(strlen(Value)>MAX_ID_LENGTH)
00313         {
00314              PrintfEnqueue(&PCBackDoorTx,"ID must be %d characters or less.  Truncating...",  MAX_ID_LENGTH); 
00315              for(i=0;i<MAX_ID_LENGTH;i++)
00316              {
00317                 ID[i] = Value[i];
00318                 ID[MAX_ID_LENGTH] = NULL;
00319              }         
00320         } 
00321         else
00322         {
00323           strcpy(ID,Value);
00324         }     
00325       
00326         PrintfEnqueue(&PCBackDoorTx,"ID assigned a value of %s",  ID);  
00327     }
00328     else
00329     {
00330         PrintfEnqueue(&PCBackDoorTx,"%s key is not recognized parameter",Key);
00331     }
00332    
00333     PrintfEnqueue(&PCBackDoorTx,"\r\n");
00334 
00335 }
00336 
00337 void LoadConfiguration()
00338 {
00339     WORD CurrentLine = 1;
00340     
00341     LoadDefaults();
00342 
00343     SmartSwitch_SetBackLightColor(3,3,3);
00344     GFX_FullDisplayBufferClear(&BackBuffer);
00345     GFX_DrawString(&BackBuffer,"Loading Config",0,0,&Font3x5);
00346     GFX_DumpRenderContextToPhysicalScreen(&BackBuffer);
00347     
00348     FILE *MyConfigFile = fopen("/local/config.txt","r");
00349     
00350     if(!MyConfigFile)
00351     {
00352         PrintfEnqueue(&PCBackDoorTx,"Could not open configuration files. Using Defaults....\r\n");
00353         wait(1);
00354         return;
00355     }
00356     
00357     PrintfEnqueue(&PCBackDoorTx,"Config file found.  Parsing.....\r\n\r\n");
00358   
00359     while(fgets(LineBuf,sizeof(LineBuf),MyConfigFile))
00360     {
00361        if(KeyValueSplit(LineBuf,Key,Value))
00362        {
00363              ParseKeyValue(Key,Value);
00364        }
00365        else
00366        {
00367            PrintfEnqueue(&PCBackDoorTx,"No valid key=value pair on line %d\r\n",CurrentLine);
00368        }
00369        
00370        CurrentLine++;
00371     }
00372     
00373     fclose(MyConfigFile);
00374     
00375     PrintfEnqueue(&PCBackDoorTx,"\r\n\r\n>");
00376 }
00377 
00378 
00379