latest BAE code 10 dec

Dependencies:   FreescaleIAP mbed-rtos mbed

Fork of RAJANGAM_REVIEW_BAE_CODE by Team Fox

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers main.cpp Source File

main.cpp

00001 #include "mbed.h"
00002 #include "rtos.h"
00003 #include "pin_config.h"
00004 #include "ACS.h"
00005 #include "EPS.h"
00006 #include "BCN.h"
00007 Serial pc(USBTX,USBRX);
00008 
00009 #include "TCTM.h"
00010 #define tm_len 134
00011 #define tc_len 135
00012 #define batt_heat_low 20
00013 #define print 1
00014 #define PRINT2 1
00015 #define baby 1
00016 #define baby2 1
00017 #define SBC 1
00018 
00019 Timer timer_FCTN_ACS_GENPWM_MAIN;
00020 Timer timer_FCTN_ACS_CNTRLALGO;
00021 Timer timer_FCTN_BAE_INIT;
00022 Timer timer_FLASH_INI;
00023 Timer timer_FCTN_ACS_INIT;
00024 Timer timer_FCTN_EPS_INIT;
00025 Timer timer_FCTN_BCN_INIT;
00026 Timer timer_F_ACS;
00027 Timer timer_FCTN_ATS_DATA_ACQ;
00028 extern Timer timer_SENSOR_INIT;
00029 extern Timer timer_CONFIG_UPLOAD;
00030 extern Timer timer_SENSOR_DATA_ACQ;
00031 extern Timer timer_controlmodes;
00032 
00033 Timer timer_F_ESP;
00034 Timer timer_minMaxHkData;
00035 Timer timer_FCTN_APPEND_HKDATA;
00036 Timer timer_FCTN_EPS_HANDLE_CDMS_FAULT;
00037 Timer timer_FCTN_EPS_HANDLE_HW_FAULTS;
00038 Timer timer_FCTN_HK_MAIN;
00039 Timer timer_FCTN_BATTERYGAUGE_MAIN;
00040 Timer timer_FCTN_BATT_TEMP_SENSOR_MAIN;
00041 extern Timer timer_alertFlags;
00042 extern Timer timer_soc;
00043 extern Timer timer_FCTN_BATTERYGAUGE_INIT;
00044 
00045 Timer timer_F_BCN;
00046 Timer timer_FCTN_BCN_TX_MAIN;
00047 extern Timer timer_Init_BEACON_HW;
00048 extern Timer timer_Set_BCN_TX_STATUS_DISABLED;
00049 extern Timer timer_Set_BCN_TX_STATUS_SUSPENDED;
00050 extern Timer timer_Set_BCN_TX_STATUS_RF_SILENCE;
00051 extern Timer timer_Set_BCN_TX_STATUS_SUCCESS;
00052 extern Timer timer_Set_BCN_TX_STATUS_FAILURE;
00053 
00054 #define DISABLE_WDOG 0;
00055 
00056 void kick_WDOG()
00057 {
00058     SIM->SRVCOP=0x55;
00059     SIM->SRVCOP=0xAA;
00060     printf("\n\rkicked");
00061 }
00062 
00063 void init_WDOG()
00064 {
00065     SIM->COPC=0x0C;  
00066     kick_WDOG();
00067 }
00068 
00069 DigitalOut time_wdog(PIN68,0);// for determining the time between code
00070 
00071 //**********************************************GLOBAL RTOS TIMER*********************************************************//
00072 RtosTimer *BAE_STANDBY_STATUS_TIMER;
00073 
00074 //bcn heater rtostimers=============================================================================
00075 RtosTimer *HTR_OFF=NULL;
00076 RtosTimer *HTR_CYCLE=NULL;
00077 RtosTimer *HTR_DLY=NULL;
00078 
00079 //UPTIME  TIMERS
00080 Timer BAE_uptime;
00081 Timer I2C_last;
00082 
00083 void RETURN_UPTIME(float time, uint8_t *day,uint8_t *hour,uint8_t *min)
00084 {
00085     *day = time/(3600*24);
00086     time = (int)time % (3600*24);
00087     *hour = time/(3600);
00088     time = (int)time % (3600);
00089     *min = time/60;    
00090 }
00091 
00092 extern DigitalOut BTRY_HTR_ENABLE;
00093 int eps_btg_read_flag;  // flag to check I2C ack on reading from BTG
00094 int eps_btg_writ_flag;  // flag to check I2C ack on writing from BTG
00095 
00096 uint8_t HTR_CYCLE_COUNTS=0;         //Count of heater cycles
00097 uint8_t HTR_CYCLE_START_DLY=0;      //EPS_HTR_DLY_TIMER timer duration in minutes
00098 uint8_t HTR_ON_DURATION=0;          //EPS_HTR_OFF timer duration in minutes
00099 uint16_t HTR_CYCLE_PERIOD =0;       //EPS_HTR_CYCLE timer duration - MSB minutes, LSB seconds
00100 uint8_t HTR_CYCLE_COUNTER = 0 ; 
00101 
00102 uint32_t HTR_CYCLE_PERIOD_DECODER()    //To convert HTR_CYCLE_PERIOD to millisecs
00103 {
00104     uint8_t PERIOD_mins, PERIOD_secs;
00105     //pc.printf("\n\r FCTN_HTR_CYCLE_PERIOD");
00106     PERIOD_secs = HTR_CYCLE_PERIOD;
00107     PERIOD_mins = HTR_CYCLE_PERIOD >> 8;
00108     uint32_t period = 1000*((int)PERIOD_mins * 60 + (int)PERIOD_secs);
00109     
00110     return period;
00111 }
00112 
00113 void FCTN_EPS_HTR_CYCLE(void const *arg)
00114 {
00115     BTRY_HTR_ENABLE = 1;//assuming its active high check
00116     //pc.printf("\n\r on kar diya");
00117     //pc.printf("\n\r FCTN_EPS_HTR_CYCLE");
00118     //tim.reset();
00119     //tim.start();
00120     //HTR_OFF->start(((uint32_t)HTR_ON_DURATION)*1000);
00121     HTR_OFF->start((int)HTR_ON_DURATION*60*1000);
00122 }
00123 
00124 void FCTN_EPS_HTR_DLY(void const* arg)
00125 {
00126     BTRY_HTR_ENABLE = 1;
00127     HTR_CYCLE_COUNTER = 0;
00128     HTR_OFF->start(((int)HTR_ON_DURATION*60*1000));
00129     //pc.printf("\n\r on kar diya");
00130     //pc.printf("\n\r FCTN_EPS_HTR_DLY");
00131     //tim.start();
00132     HTR_CYCLE->start((uint32_t)HTR_CYCLE_PERIOD_DECODER);
00133 }
00134 
00135 void FCTN_EPS_HTR_OFF(void const *arg)
00136 {
00137     BTRY_HTR_ENABLE = 0;
00138     //tim.stop();
00139     //pc.printf("\n\r off kar diya");
00140     //pc.printf("\n\r the timer value is %f",tim.read());
00141     //tim.reset();
00142     if(HTR_CYCLE_COUNTS != 0xFF)
00143     {
00144         HTR_CYCLE_COUNTER++;
00145         if( HTR_CYCLE_COUNTER == (int)HTR_CYCLE_COUNTS)//HTR_CYCLE_COUNTS )
00146             HTR_CYCLE->stop();
00147     }
00148 }
00149 
00150 //====================================================================================================
00151 
00152 //fctn to pass the data to bcn long type
00153 //uint8_t CDMS_HK_data[134]; now implemented as LONG_HK_data[0][134];
00154 uint8_t LONG_HK_data[2][134];
00155 void FCTN_CDMS_HK_TC(uint8_t tc[])
00156 {
00157     for(int i=0;i<134;i++)
00158         LONG_HK_data[0][i] = tc[i];    
00159 }
00160 
00161 uint8_t BAE_STANDBY=0x07;// as Bcn Acs Eps last three bits BAE order ,  refer to switch off.//old convection now *****0***** means off
00162 
00163 void BAE_STANDBY_STATUS_RESET(const void* arg)
00164 {
00165     printf("\n\rBAE standby reset to 0x00");
00166     BAE_STANDBY=0x07;
00167 }
00168 
00169 
00170 /*no problem in first stopping and then starting even when for the first time*/
00171 void BAE_STANDBY_TIMER_RESET()
00172 {
00173     BAE_STANDBY_STATUS_TIMER->stop();
00174     BAE_STANDBY_STATUS_TIMER->start(30000);//20 min ie 20*60=1200 sec or 1200,000 milisec but for testing setting it to 30sec
00175 }
00176 
00177 extern void gen_I_TM();
00178 
00179 //***************  FLAGS ****************************//
00180 uint32_t BAE_STATUS = 0x00000000;
00181 uint32_t BAE_ENABLE = 0xFFFFFFFF;
00182 
00183 //i2c//
00184 char data_send_flag = 'h'; 
00185 //uint8_t BAE_MNG_I2C_STATUS = 0;
00186 
00187 //BAE
00188 uint8_t BAE_INIT_STATUS=0;
00189 uint8_t BAE_MNG_I2C_STATUS=0;
00190 
00191 
00192 //ACS
00193 uint8_t ACS_INIT_STATUS = 0;
00194 uint8_t ACS_DATA_ACQ_STATUS = 0;
00195 uint8_t ACS_ATS_STATUS = 0x73;
00196 uint8_t ACS_MAIN_STATUS = 0;
00197 uint8_t ACS_STATUS = 0;
00198 uint8_t ACS_DETUMBLING_ALGO_TYPE = 0;
00199 uint8_t ACS_ATS_ENABLE = 1;
00200 uint8_t ACS_DATA_ACQ_ENABLE = 1;
00201 uint8_t ACS_STATE = 3;
00202 
00203 extern uint16_t ACS_MM_X_COMSN;
00204 extern uint16_t ACS_MM_Y_COMSN;
00205 extern uint16_t ACS_MG_X_COMSN;
00206 extern uint16_t ACS_MG_Y_COMSN;
00207 extern uint16_t ACS_MM_Z_COMSN;
00208 extern uint16_t ACS_MG_Z_COMSN;
00209 
00210 extern uint8_t controlmode_mms;
00211 extern uint8_t B_SCZ_ANGLE;
00212 //BCN
00213 extern uint8_t BCN_FEN;
00214 extern void FCTN_BCN_FEN(void const *args);
00215 extern void LONG_BCN_DATA(uint8_t* );
00216 extern uint16_t gencrc16_for_me();//for calculating the crc of baehk data before sendingkk as including crc causes problem
00217 extern DigitalOut BTRY_HTR_ENABLE;
00218 
00219 
00220 Timeout timeout_bcn;
00221 /*long beacon data/sending*/
00222 /*be sure it is created in bcn.cpp*/
00223 
00224 //EPS
00225 uint8_t EPS_INIT_STATUS = 0;
00226 uint8_t EPS_BATTERY_GAUGE_STATUS = 0;
00227 uint8_t EPS_MAIN_STATUS = 0;
00228 uint8_t EPS_BTRY_TMP_STATUS = 0;/// to be diss
00229 uint8_t EPS_STATUS = 7; //invalid status
00230 uint8_t EPS_BTRY_HTR = 0;
00231 
00232 uint8_t EPS_BTRY_HTR_AUTO = 1;
00233 extern uint8_t EPS_SOC_LEVEL_12;
00234 extern uint8_t EPS_SOC_LEVEL_23;
00235 extern uint8_t EPS_BAT_TEMP_LOW;
00236 extern uint8_t EPS_BAT_TEMP_HIGH;
00237 extern uint8_t EPS_BAT_TEMP_DEFAULT;
00238 float EPS_BTRY_TMP_AVG;
00239 extern DigitalOut BTRY_HTR_ENABLE;
00240 
00241 //extern void FCTN_BATTERYGAUGE_MAIN(float*Battery_parameters);
00242 
00243 
00244 //**********************GLOBAL DECLARATIONS********************************//
00245 
00246 //CDMS
00247 //eps cdms fault
00248 uint8_t CDMS_SW_STATUS;
00249 DigitalIn CDMS_OC_FAULT(PIN79);
00250 //bool CDMS_SW_ENABLE;                            //Temp name for CDMS_RESET pin
00251 int CDMS_FAULT_COUNTER = 0;
00252 
00253 
00254 //BAE                                           new hk structure- everything has to changed based on this
00255 char BAE_chardata[74];
00256 // uint8_t LONG_HK_data[2][134];
00257 //uint8_t BAE_HK_data[134];  now known as LONG_HK_data[1][i];  
00258 uint8_t BAE_RESET_COUNTER;// INITIALIZATION or do you want to initialize evertime the main is reset? or is it same     
00259 uint16_t BAE_I2C_COUNTER = 0;//change/apply
00260 //uint8_t BAE_STANDBY=0x00;// as Bcn Acs Eps last three bits BAE order , 1old convection refer to switch off. chnaged now 0 means offfffffffff FU==
00261 
00262 //BCN
00263 //uint16_t BCN_TX_MAIN_COUNTER = 0;
00264 uint8_t BCN_LONG_MSG_TYPE = 1;
00265 
00266 DigitalIn BCN_TX_OC_FAULT(PIN80);
00267 int BCN_TX_FAULT_COUNTER;   
00268 
00269 //ACS
00270 uint16_t ACS_MAIN_COUNTER = 0;
00271 
00272 //eps hw faults
00273 //uint8_t ACS_TR_Z_SW_STATUS;
00274 DigitalOut ACS_TR_Z_ENABLE(PIN40,0);        //SWITCH
00275 DigitalIn ACS_TR_Z_OC_FAULT(PIN91);
00276 DigitalIn ACS_TR_Z_FAULT(PIN89);            //Driver IC fault
00277 int ACS_TR_Z_FAULT_COUNTER = 0;
00278 
00279 
00280 InterruptIn irpt_4m_mstr(PIN38);                                      //I2c interrupt from CDMS
00281 DigitalOut irpt_2_mstr(PIN4);                                        //I2C interrupt to CDMS
00282 
00283 
00284 
00285 
00286 //uint8_t ACS_TR_XY_SW_STATUS;
00287 DigitalOut ACS_TR_XY_ENABLE(PIN71,0);
00288 DigitalIn ACS_TR_XY_OC_FAULT(PIN77);
00289 DigitalIn ACS_TR_XY_FAULT(PIN83);            //Driver IC fault
00290 int ACS_TR_XY_FAULT_COUNTER = 0;
00291 
00292 //bool ACS_ATS1_ENABLE;
00293 DigitalIn ACS_ATS1_OC_FAULT(PIN39);
00294 int ACS_TS1_FAULT_COUNTER = 0;
00295 
00296 //bool ACS_ATS2_ENABLE;
00297 DigitalIn ACS_ATS2_OC_FAULT(PIN41);
00298 int ACS_ATS2_FAULT_COUNTER;
00299 
00300 //EPS
00301 int EPS_MAIN_COUNTER = 0;
00302 
00303 
00304 //GEN DEC FOR TESTING or to be DECIDED whre to ASSIGN HERE 
00305 const int addr = 0x20;                                            //slave address 
00306 Timer t_rfsilence;
00307 Timer t_start;
00308 /*defined as of now to check execution time*/
00309 /*remember to remove them*/
00310 Timer t_acs;
00311 Timer t_eps;
00312 //Timer t_tc;
00313 Timer t_tm;
00314 
00315 int power_flag_dummy=2;
00316 float data[6];
00317 
00318 
00319 //*************EXTERN PARA********
00320 
00321 //BAE
00322 
00323 extern BAE_HK_actual actual_data;
00324 extern BAE_HK_quant quant_data;
00325 extern BAE_HK_min_max bae_HK_minmax;
00326 extern BAE_HK_arch arch_data;
00327 
00328 
00329 //BCN
00330 extern uint8_t BCN_FEN;
00331 extern uint8_t BCN_TX_SW_STATUS;
00332 extern uint8_t BCN_SPND_TX;
00333 
00334 
00335 //TCTM
00336 extern uint8_t telemetry[tm_len];
00337 
00338 
00339 //ACS
00340 extern uint8_t ACS_TR_Z_SW_STATUS;
00341 extern uint8_t ACS_TR_XY_SW_STATUS;
00342 extern float gyro_data[3];
00343 extern float mag_data[3];
00344 extern float moment[3];
00345 extern float b_old[3];  // Unit: Tesla
00346 extern float db[3];
00347 extern uint8_t flag_firsttime;
00348 extern uint8_t ACS_MAG_TIME_DELAY;
00349 extern uint8_t ACS_DEMAG_TIME_DELAY;
00350 extern uint16_t ACS_Z_FIXED_MOMENT;
00351 
00352 int write_ack;
00353 int read_ack;
00354 char telecommand[tc_len];
00355 
00356 
00357 bool pf1check = 0;
00358 bool pf2check = 0;
00359 bool if1check = 0;
00360 bool if2check = 0;
00361 
00362 //ASSIGNING PINS//
00363 DigitalOut ATS1_SW_ENABLE(PIN90,1); // enable of att sens2 switch
00364 DigitalOut ATS2_SW_ENABLE(PIN61,0); // enable of att sens switch
00365 ////InterruptIn irpt_4m_mstr(PIN38);                                      //I2c interrupt from CDMS
00366 ////DigitalOut irpt_2_mstr(PIN4);                                        //I2C interrupt to CDMS
00367 I2CSlave slave (PIN1,PIN2);///pin1 pin2
00368 //DigitalOut batt_heat(PIN96);
00369 
00370 //ATS1_SW_ENABLE = 0;
00371 PwmOut PWM1(PIN93); //x                         //Functions used to generate PWM signal 
00372 PwmOut PWM2(PIN94); //y
00373 PwmOut PWM3(PIN95); //z                         //PWM output comes from pins p6
00374 
00375 //........faults
00376 //Polled Faults
00377 //DigitalIn pf1(PIN5);//Attitude Sensor 1 OC bar fault signal
00378 //DigitalIn pf2(PIN97);//Attitude Sensor 2 OC bar fault signal
00379 //DigitalIn pf3(PIN83);//Fault Bar for TRXY driver
00380  
00381  
00382 DigitalOut DRV_XY_EN(PIN82,0); // DRV XY en
00383 //DigitalOut TRXY_SW(PIN71,0);  //TR XY Switch
00384 DigitalOut DRV_Z_EN(PIN88,0);    //Sleep pin of driver z        //DISABLE  by default
00385 //DigitalOut TRZ_SW(PIN40,0);  //TR Z Switch
00386 
00387 DigitalOut CDMS_RESET(PIN7,1); // CDMS RESET
00388 
00389 DigitalOut CDMS_OC_ENA(PIN70,1);
00390 
00391 DigitalOut BCN_SW(PIN64,1); // PIN changed to 64 (previous 65 )              //IN TEMPORARY SBC
00392 //DigitalOut BCN_SW(PIN14,1);      //Beacon switch  //IN QM SBC, TO BE CHANGED
00393 
00394 //================================================================================
00395 //default flash array some filler bits added (detail in MMS file)
00396 //uint32_t ARR_INITIAL_VAL[8]={0x73532600,0x505A4141,0x1A1A1400,0x00000000,0x00000000,0x00000000,0xCBA20000,0x00000000};//to be done
00397 uint32_t ARR_INITIAL_VAL[8]={0x7C532600,0x505A4141,0x1A1A1400,0x001E0028,0x00030004,0x00320005,0xCBA2010A,0x00000000};//to be done
00398 
00399 void FLASH_INI()
00400 {
00401     uint32_t read[8]; 
00402     for(int i=0;i<8;i++)
00403         {  
00404             read[i] = FCTN_BAE_RD_FLASH_ENTITY(i);
00405             //printf("\n\r val is read after starting %x  ",read[i]);
00406         }
00407             
00408     if(read[0] == -1)
00409         for(int j=0;j<8;j++)
00410             {   
00411                 FCTN_BAE_WR_FLASH(j,ARR_INITIAL_VAL[j]); 
00412                 ACS_ATS_STATUS  = ARR_INITIAL_VAL[0]>>24;
00413                 ACS_TR_XY_SW_STATUS = ((uint8_t)(ARR_INITIAL_VAL[0]>>22))&0x03;
00414                 ACS_TR_Z_SW_STATUS = (ARR_INITIAL_VAL[0]>>20)&0x03;
00415                 ACS_STATE = (ARR_INITIAL_VAL[0]>>16)&0x0F;
00416                 //pc.pc.printf("\n\r acs state in starting is %x",ACS_STATE);
00417                 ACS_DETUMBLING_ALGO_TYPE = (ARR_INITIAL_VAL[0]>>15)&0x01;
00418                 BCN_TX_SW_STATUS = ((uint8_t)(ARR_INITIAL_VAL[0]>>14))&0x03;            //Need to verify, initial value must be 1
00419                 BCN_SPND_TX = ((uint8_t)(ARR_INITIAL_VAL[0]>>12))&0x01;
00420                 BCN_FEN = ((uint8_t)(ARR_INITIAL_VAL[0]>>11))&0x01;
00421                 BCN_LONG_MSG_TYPE = ((uint8_t)(ARR_INITIAL_VAL[0]>>10))&0x01;
00422                 EPS_BTRY_HTR_AUTO = ((uint8_t)(ARR_INITIAL_VAL[0]>>9))&0x03;//EPS_BATTERY_HEATER_ENABLE
00423                 //now one spares in telemetry[5]
00424                 
00425                 //updating the reset counter
00426                 BAE_RESET_COUNTER = ((uint8_t)(ARR_INITIAL_VAL[0]));
00427                 EPS_SOC_LEVEL_12 = (uint8_t)(ARR_INITIAL_VAL[1]>>24); 
00428                 EPS_SOC_LEVEL_23 = (uint8_t)(ARR_INITIAL_VAL[1]>>16);
00429                 ACS_MAG_TIME_DELAY = (uint8_t)(ARR_INITIAL_VAL[1]>>8);
00430                 ACS_DEMAG_TIME_DELAY = (uint8_t)ARR_INITIAL_VAL[1];
00431                         
00432                 EPS_BAT_TEMP_LOW = (uint8_t)(ARR_INITIAL_VAL[2]>>24);
00433                 EPS_BAT_TEMP_HIGH = (uint8_t)(ARR_INITIAL_VAL[2]>>16);
00434                 EPS_BAT_TEMP_DEFAULT = (uint8_t)(ARR_INITIAL_VAL[2]>>8);
00435                                                                             
00436                 ACS_MM_X_COMSN = (uint16_t)(ARR_INITIAL_VAL[3]>>16);                                                                
00437                 ACS_MM_Y_COMSN = (uint16_t)ARR_INITIAL_VAL[3];
00438                                                                             
00439                 ACS_MG_X_COMSN = (uint16_t)(ARR_INITIAL_VAL[4]>>16);
00440                 ACS_MG_Y_COMSN = (uint16_t)ARR_INITIAL_VAL[4];
00441                                                                         
00442                 ACS_MM_Z_COMSN = (uint16_t)(ARR_INITIAL_VAL[5]>>16);
00443                 ACS_MG_Z_COMSN = (uint16_t)ARR_INITIAL_VAL[5];
00444                                                                             
00445                 ACS_Z_FIXED_MOMENT = (uint16_t)(ARR_INITIAL_VAL[6]>>16);//assignvalues 
00446                                  
00447         } 
00448     else
00449        {
00450         for(int j=0;j<8;j++)
00451             {   
00452                 read[j] = FCTN_BAE_RD_FLASH_ENTITY(j);
00453             }
00454         ACS_ATS_STATUS  = read[0]>>24;
00455         ACS_TR_XY_SW_STATUS = ((uint8_t)(read[0]>>22))&0x03;
00456         ACS_TR_Z_SW_STATUS = (read[0]>>20)&0x03;
00457         ACS_STATE = (read[0]>>16)&0x0F;
00458         //pc.printf("\n\r acs state in starting is %x",ACS_STATE);
00459         ACS_DETUMBLING_ALGO_TYPE = (read[0]>>15)&0x01;
00460         BCN_TX_SW_STATUS = ((uint8_t)(read[0]>>13))&0x03;                       //Need to verify, initial value must be 1
00461         BCN_SPND_TX = ((uint8_t)(read[0]>>12))&0x01;
00462         BCN_FEN = ((uint8_t)(read[0]>>11))&0x01;
00463         BCN_LONG_MSG_TYPE = ((uint8_t)(read[0]>>10))&0x01;
00464         EPS_BTRY_HTR_AUTO = ((uint8_t)(read[0]>>9))&0x01;//EPS_BATTERY_HEATER_ENABLE
00465         //now one spares in telemetry[5]
00466         
00467         //updating the reset counter
00468         BAE_RESET_COUNTER = ((uint8_t)(read[0]))+1;
00469         read[0]=(read[0]&0xffffff00) | (uint32_t)BAE_RESET_COUNTER;
00470         FCTN_BAE_WR_FLASH(0,read[0]);
00471         pc.printf("\n\r reset counter %d",BAE_RESET_COUNTER);
00472         
00473                 
00474         EPS_SOC_LEVEL_12 = (uint8_t)(read[1]>>24); 
00475         EPS_SOC_LEVEL_23 = (uint8_t)(read[1]>>16);
00476         ACS_MAG_TIME_DELAY = (uint8_t)(read[1]>>8);
00477         ACS_DEMAG_TIME_DELAY = (uint8_t)read[1];
00478                 
00479         EPS_BAT_TEMP_LOW = (uint8_t)(read[2]>>24);
00480         EPS_BAT_TEMP_HIGH = (uint8_t)(read[2]>>16);
00481         EPS_BAT_TEMP_DEFAULT = (uint8_t)(read[2]>>8);
00482                                                                     
00483         ACS_MM_X_COMSN = (uint16_t)(read[3]>>16);                                                                
00484         ACS_MM_Y_COMSN = (uint16_t)read[3];
00485                                                                     
00486         ACS_MG_X_COMSN = (uint16_t)(read[4]>>16);
00487         ACS_MG_Y_COMSN = (uint16_t)read[4];
00488                                                                 
00489         ACS_MM_Z_COMSN = (uint16_t)(read[5]>>16);
00490         ACS_MG_Z_COMSN = (uint16_t)read[5];
00491                                                                     
00492         ACS_Z_FIXED_MOMENT = (uint16_t)(read[6]>>16);//assignvalues 
00493             
00494         }
00495     
00496 }
00497 //================================================================================
00498 
00499 
00500 
00501 /*****************************************************************Threads USed***********************************************************************************/
00502 Thread *ptr_t_i2c;
00503 
00504 
00505 /*********************************************************FCTN HEADERS***********************************************************************************/
00506 void FCTN_ISR_I2C();
00507 void FCTN_TM();
00508 void F_ACS();
00509 void F_EPS();
00510 void F_BCN();
00511 
00512 //I2C
00513 uint32_t pdir_tc1,pdir_tc2,pdir_tm1,pdir_tm2,pdir_ss1,pdir_ss2;//variables used to verify i2c working
00514 uint16_t crc16_check;
00515 void I2C_busreset()
00516 {
00517     PORTE->PCR[1] &= 0xfffffffb;
00518     PORTE->PCR[0] &= 0xfffffffb;
00519     I2C1->C1 &= 0x7f;
00520     SIM->SCGC4 &= 0xffffff7f;
00521     SIM->SCGC4 |= 0x00000080;
00522     I2C1->C1 |= 0x80;  
00523     PORTE->PCR[1] |= 0x00000004;
00524     PORTE->PCR[0] |= 0x00000004;    
00525     wait_ms(1);
00526 }
00527 
00528 //*******************************************ACS THREAD**************************************************//
00529 uint8_t iterP1;
00530 uint8_t iterP2;
00531 uint8_t iterI1;
00532 uint8_t iterI2;
00533 
00534 //FLOAT TO UINT_8 CONVERSION FUNCTION
00535 extern uint8_t float_to_uint8(float min,float max,float val);
00536 
00537 //#define print 0   
00538 
00539 void F_ACS()
00540 {
00541     ACS_MAIN_COUNTER++;
00542     //time_wdog = 1;   
00543     pc.printf("Entered ACS.\n\r");
00544 
00545     ACS_MAIN_STATUS = 1; //set ACS_MAIN_STATUS flag 
00546     //FLAG();
00547     
00548     PWM1 = 0;                     //clear pwm pins
00549     PWM2 = 0;                     //clear pwm pins
00550     PWM3 = 0;                     //clear pwm pins
00551     
00552     wait_ms(ACS_DEMAG_TIME_DELAY);
00553     ACS_DATA_ACQ_STATUS = (uint8_t) FCTN_ATS_DATA_ACQ();     
00554     
00555     //#if print
00556         //printing the angular speed and magnetic field values
00557         pc.printf("gyro values\n\r"); 
00558         for(int i=0; i<3; i++) 
00559             {
00560                 pc.printf("%f\n\r",actual_data.AngularSpeed_actual[i]);
00561             }
00562     
00563         pc.printf("mag values\n\r");
00564         for(int i=0; i<3; i++) 
00565             {
00566                 pc.printf("%f\n\r",actual_data.Bvalue_actual[i]);
00567             }
00568     //#endif
00569     
00570     for(int i=0;i<3;i++)
00571         {
00572             mag_data[i] = actual_data.Bvalue_actual[i]/1000000;
00573             gyro_data[i] = actual_data.AngularSpeed_actual[i]*3.14159/180;
00574         }
00575         
00576     float b_inclination = mag_data[2]/sqrt(mag_data[0]*mag_data[0]+mag_data[1]*mag_data[1]+mag_data[2]*mag_data[2]);
00577     
00578     if(b_inclination <0)
00579     {
00580         b_inclination = (-1)*b_inclination;
00581     }
00582     B_SCZ_ANGLE = (uint8_t)(b_inclination*16);
00583     if( b_inclination >= 16)
00584     {
00585         B_SCZ_ANGLE = 0x0F;
00586     }
00587     if(b_inclination <=0)
00588     {
00589         B_SCZ_ANGLE = 0x00;
00590     }
00591     //printf("POWER MODE is : %d\r\n",actual_data.power_mode);
00592     
00593     if(ACS_STATE == 0)                      // check ACS_STATE = ACS_CONTROL_OFF?
00594         {
00595             #if print
00596                 pc.printf("\n\r acs control off\n");
00597             #endif
00598             ACS_STATUS = 0;                // set ACS_STATUS = ACS_CONTROL_OFF
00599             ACS_MAIN_STATUS = 0;
00600             return;
00601         }
00602     else if((actual_data.power_mode<=2)||( (( ACS_STATE)&0x08) == 0x08))
00603         {
00604             //#if print
00605                 pc.printf("\n\r  \n\r");
00606             //#endif
00607             DRV_Z_EN = 0;
00608             DRV_XY_EN = 0;
00609             ACS_TR_Z_ENABLE = 0;
00610             ACS_TR_XY_ENABLE = 0;
00611             ACS_STATUS = 1;                    // set ACS_STATUS = ACS_LOW_POWER
00612             ACS_MAIN_STATUS = 0;
00613             return;
00614         
00615         }
00616     else if(ACS_TR_Z_SW_STATUS != 1)
00617         {
00618             pc.printf("\n\r Z disabled \n\r");
00619             DRV_Z_EN = 0;
00620             DRV_XY_EN = 0;
00621             ACS_TR_Z_ENABLE = 0;
00622             ACS_TR_XY_ENABLE = 0;
00623             ACS_STATUS = 2;                 // set ACS_STAUS = ACS_TRZ_DISABLED
00624             ACS_MAIN_STATUS = 0;
00625             return;       
00626         }
00627     else if(ACS_TR_XY_SW_STATUS != 1)
00628         {   
00629             pc.printf("\n\r Z only \n\r");              
00630             DRV_Z_EN = 1;
00631             DRV_XY_EN = 0;
00632              ACS_TR_Z_ENABLE = 1;
00633     ACS_TR_XY_ENABLE = 0;
00634             ACS_STATUS = 3;                 // set ACS_STAUS = ACS_TRXY_DISABLED , Z axis only
00635             moment[0] = 0;
00636             moment[1] = 0;
00637             moment[2] = ACS_Z_FIXED_MOMENT;                 // is a dummy value 
00638             
00639             //timer_FCTN_ACS_GENPWM_MAIN.start();
00640             FCTN_ACS_GENPWM_MAIN(moment) ;
00641             //timer_FCTN_ACS_GENPWM_MAIN.stop();
00642             //pc.printf("\n\r the timer_FCTN_ACS_GENPWM_MAIN is %f",timer_FCTN_ACS_GENPWM_MAIN.read());
00643             ACS_MAIN_STATUS = 0;
00644             return;
00645         }
00646     else if((ACS_DATA_ACQ_STATUS == 0)||(ACS_DATA_ACQ_STATUS == 1))
00647         {
00648             
00649             pc.printf("\n\r Z only no data \n\r");
00650             DRV_Z_EN = 1;
00651             DRV_XY_EN = 0;
00652              ACS_TR_Z_ENABLE = 1;
00653     ACS_TR_XY_ENABLE = 0;
00654             ACS_STATUS = 3;                 // set Set ACS_STATUS = ACS_DATA_ACQN_FAILURE , Z axis only
00655             
00656             moment[0] = 0;
00657             moment[1] = 0;
00658             moment[2] = ACS_Z_FIXED_MOMENT;                 // is a dummy value 
00659             
00660             //timer_FCTN_ACS_GENPWM_MAIN.start();
00661             FCTN_ACS_GENPWM_MAIN(moment) ;
00662             //timer_FCTN_ACS_GENPWM_MAIN.stop();
00663             //pc.printf("\n\r the timer_FCTN_ACS_GENPWM_MAIN is %f",timer_FCTN_ACS_GENPWM_MAIN.read());
00664             
00665             ACS_MAIN_STATUS = 0;
00666             return; 
00667         }
00668     else if((ACS_STATE == 1)||(ACS_STATE == 9))
00669         {
00670             pc.printf("\n\r Z only by state \n\r");
00671             DRV_Z_EN = 1;
00672             DRV_XY_EN = 0;
00673              ACS_TR_Z_ENABLE = 1;
00674     ACS_TR_XY_ENABLE = 0;
00675             ACS_STATUS = 3;                 // set ACS_STAUS = ACS_TRXY_DISABLED by ACS_STATE i.e Z axis only
00676             
00677             moment[0] = 0;
00678             moment[1] = 0;
00679             moment[2] = ACS_Z_FIXED_MOMENT;                 // 1.3 is a dummy value 
00680             FCTN_ACS_GENPWM_MAIN(moment) ;
00681                 
00682             ACS_MAIN_STATUS = 0;
00683             return;
00684         }
00685     else if(ACS_DATA_ACQ_STATUS == 2)           // MM only is available
00686         {
00687             pc.printf("\n\r MM only BDOT \n\r");
00688             DRV_Z_EN = 1;
00689             DRV_XY_EN = 1;
00690              ACS_TR_Z_ENABLE = 1;
00691     ACS_TR_XY_ENABLE = 1;
00692                               
00693             ACS_STATUS = 4;                 // set Set ACS_STATUS = ACS_BDOT_CONTROL
00694             ACS_DETUMBLING_ALGO_TYPE = 0x01;
00695             FCTN_ACS_CNTRLALGO(moment,mag_data,gyro_data,0x00,0x01,ACS_DETUMBLING_ALGO_TYPE);
00696             controlmode_mms=0x00;
00697             #if print    
00698                 pc.printf("\n\r Moment values returned by control algo \n");
00699             #endif
00700             for(int i=0; i<3; i++) 
00701                 {
00702                     pc.printf("%f\t",moment[i]);
00703                 }
00704             FCTN_ACS_GENPWM_MAIN(moment) ; 
00705             ACS_MAIN_STATUS = 0;
00706             return;  
00707         }
00708     else if((ACS_STATE == 2)||(ACS_STATE == 10))                     // Nominal mode
00709         {
00710             #if print
00711                 pc.printf("\n\r Nominal mode \n");
00712             #endif
00713             DRV_Z_EN = 1;
00714             DRV_XY_EN = 1;            
00715             ACS_TR_Z_ENABLE = 1;
00716     ACS_TR_XY_ENABLE = 1;
00717             
00718             //timer_FCTN_ACS_CNTRLALGO.start();   
00719             FCTN_ACS_CNTRLALGO(moment,mag_data,gyro_data,0x01,0x00,ACS_DETUMBLING_ALGO_TYPE);
00720             //timer_FCTN_ACS_CNTRLALGO.stop();
00721             //pc.printf("\n\r the timer_FCTN_ACS_GENPWM_MAIN is %f",timer_FCTN_ACS_CNTRLALGO.read());
00722             
00723             controlmode_mms = 0x01;
00724             #if print    
00725                 pc.printf("\n\r Moment values returned by control algo \n");
00726             #endif
00727             for(int i=0; i<3; i++) 
00728                 {
00729                     pc.printf("%f\t",moment[i]);
00730                 }
00731                 
00732             //timer_FCTN_ACS_GENPWM_MAIN.start();    
00733             FCTN_ACS_GENPWM_MAIN(moment) ;  
00734             //timer_FCTN_ACS_GENPWM_MAIN.stop();
00735             //pc.printf("\n\r the timer_FCTN_ACS_CNTRLALGO is %f",timer_FCTN_ACS_GENPWM_MAIN.read());
00736             
00737             ACS_MAIN_STATUS = 0;
00738             return; 
00739         }
00740     else if((ACS_STATE == 3)||(ACS_STATE == 11))                     // Auto Control
00741         {
00742             #if print
00743                 pc.printf("\n\r Auto control mode \n");
00744             #endif 
00745             DRV_Z_EN = 1;
00746             DRV_XY_EN = 1;
00747             ACS_TR_Z_ENABLE = 1;
00748     ACS_TR_XY_ENABLE = 1;              
00749             
00750             timer_FCTN_ACS_CNTRLALGO.start();   
00751             FCTN_ACS_CNTRLALGO(moment,mag_data,gyro_data,0x00,0x00,ACS_DETUMBLING_ALGO_TYPE);
00752             timer_FCTN_ACS_CNTRLALGO.stop();
00753             //pc.printf("\n\r the timer_FCTN_ACS_CNTRLALGO is %f",timer_FCTN_ACS_CNTRLALGO.read());
00754             
00755             controlmode_mms = 0x00;
00756             #if print
00757                 pc.printf("\n\r Moment values returned by control algo \n");
00758                 for(int i=0; i<3; i++) 
00759                     {
00760                         pc.printf("%f\t",moment[i]);
00761                     }
00762             #endif
00763             pc.printf("\r\n");
00764             timer_FCTN_ACS_GENPWM_MAIN.start();
00765             FCTN_ACS_GENPWM_MAIN(moment) ;// set ACS_STATUS in function
00766             timer_FCTN_ACS_GENPWM_MAIN.stop();
00767             //pc.printf("\n\r the timer_FCTN_ACS_GENPWM_MAIN is %f",timer_FCTN_ACS_GENPWM_MAIN.read());
00768             
00769             ACS_MAIN_STATUS = 0;
00770             return; 
00771         }
00772     else if((ACS_STATE == 4)||(ACS_STATE == 12))                     // Detumbling
00773         {
00774             pc.printf("\n\r Detumbling \n\r");
00775             DRV_Z_EN = 1;
00776             DRV_XY_EN = 1;
00777             ACS_TR_Z_ENABLE = 1;
00778     ACS_TR_XY_ENABLE = 1;       
00779             FCTN_ACS_CNTRLALGO(moment,mag_data,gyro_data,0x00,0x01,ACS_DETUMBLING_ALGO_TYPE);
00780             controlmode_mms = 0x00;
00781             FCTN_ACS_GENPWM_MAIN(moment) ;  
00782             ACS_MAIN_STATUS = 0;
00783             return; 
00784         }
00785     ACS_STATUS = 7;                    //INVALID_STATE
00786     DRV_Z_EN = 0;
00787     ACS_TR_Z_ENABLE = 0;
00788     ACS_TR_XY_ENABLE = 0;
00789     DRV_XY_EN = 0;    
00790     ACS_MAIN_STATUS = 0; //clear ACS_MAIN_STATUS flag 
00791 }
00792 
00793 
00794 //***************************************************EPS THREAD***********************************************//
00795 
00796 
00797 void F_EPS()
00798 {
00799       float eps_btry_temp;
00800       pc.printf("\n\rEntered EPS   %f\n\r",t_start.read());
00801       EPS_MAIN_STATUS = 1; // Set EPS main status
00802       EPS_MAIN_COUNTER++;
00803       
00804       timer_FCTN_BATT_TEMP_SENSOR_MAIN.reset();
00805       timer_FCTN_BATT_TEMP_SENSOR_MAIN.start();
00806       FCTN_BATT_TEMP_SENSOR_MAIN(actual_data.Batt_temp_actual);
00807       timer_FCTN_BATT_TEMP_SENSOR_MAIN.stop();
00808       
00809       pc.printf("Battery temperature %f %f\n\r" ,actual_data.Batt_temp_actual[0], actual_data.Batt_temp_actual[1]);
00810       EPS_BTRY_TMP_AVG = ( actual_data.Batt_temp_actual[0] + actual_data.Batt_temp_actual[1] )/2.0;
00811       if(abs(actual_data.Batt_temp_actual[0] - actual_data.Batt_temp_actual[1]) > 10)
00812       {
00813           EPS_BTRY_TMP_STATUS = 0;          //clear EPS_BTRY_TMP_STATUS
00814           eps_btry_temp = (float) EPS_BAT_TEMP_DEFAULT;
00815       }
00816       else   
00817       {
00818           EPS_BTRY_TMP_STATUS = 1;          //set EPS_BTRY_TMP_STATUS
00819           eps_btry_temp = EPS_BTRY_TMP_AVG;
00820       }
00821          
00822       if(EPS_BTRY_HTR_AUTO == 0)
00823           EPS_STATUS = 1;                   //EPS_BATTERY_HEATER_DISABLED
00824       else if( EPS_BTRY_TMP_STATUS == 0 )
00825       {
00826           BTRY_HTR_ENABLE = 0;
00827           EPS_BTRY_HTR = 0;
00828           EPS_STATUS = 0;                   //Set EPS_ERR_BATTERY_TEMP
00829       }
00830       else
00831       {
00832             if( EPS_BTRY_HTR == 1 && eps_btry_temp >= EPS_BAT_TEMP_HIGH )
00833             {
00834               BTRY_HTR_ENABLE = 0;
00835               EPS_BTRY_HTR = 0;
00836               EPS_STATUS = 4;               //Set EPS_BATTERY_HEATER_OFF
00837             }
00838             else if( EPS_BTRY_HTR == 0 && eps_btry_temp < EPS_BAT_TEMP_LOW )
00839             {
00840               BTRY_HTR_ENABLE = 1;
00841               EPS_BTRY_HTR = 1;
00842               EPS_STATUS = 5;               //Set EPS_BATTERY_HEATER_ON
00843             }
00844       }  
00845  
00846         unsigned short statusreg = read(REG_STATUS);
00847         if( EPS_BATTERY_GAUGE_STATUS == 0 ) reset();
00848         if( read(REG_STATUS)  & 0x0100 == 0x0100 )     //checking if Reset Indicator bit is set
00849         {
00850             pc.printf("REG_STATUS = %d\r\n",read(REG_STATUS));    
00851             FCTN_BATTERYGAUGE_INIT();
00852         } 
00853         timer_FCTN_BATTERYGAUGE_MAIN.reset();
00854         timer_FCTN_BATTERYGAUGE_MAIN.start();
00855         int BTG_MAIN_FLAG = FCTN_BATTERYGAUGE_MAIN(actual_data.Batt_gauge_actual, eps_btry_temp);
00856         timer_FCTN_BATTERYGAUGE_MAIN.stop();
00857         
00858         if( BTG_MAIN_FLAG == 1 )                      //Data not received
00859             {
00860               actual_data.power_mode = 0;
00861               EPS_BATTERY_GAUGE_STATUS = 0;           //clear EPS_BATTERY_GAUGE_STATUS 
00862             }
00863         else
00864             {
00865               FCTN_EPS_POWERMODE(actual_data.Batt_gauge_actual[1]);            //updating power level 
00866               EPS_BATTERY_GAUGE_STATUS = 1;           //set EPS_BATTERY_GAUGE_STATUS
00867             }
00868         
00869         timer_FCTN_HK_MAIN.reset();
00870         timer_FCTN_HK_MAIN.start();
00871         FCTN_HK_MAIN();
00872         timer_FCTN_HK_MAIN.stop();
00873        // pc.printf("ere");
00874        
00875         timer_FCTN_EPS_HANDLE_HW_FAULTS.reset();
00876         timer_FCTN_EPS_HANDLE_HW_FAULTS.start();
00877         FCTN_EPS_HANDLE_HW_FAULTS();
00878         timer_FCTN_EPS_HANDLE_HW_FAULTS.stop();
00879        
00880         timer_FCTN_EPS_HANDLE_CDMS_FAULT.reset();
00881         timer_FCTN_EPS_HANDLE_CDMS_FAULT.start();
00882         FCTN_EPS_HANDLE_CDMS_FAULT();
00883         timer_FCTN_EPS_HANDLE_CDMS_FAULT.stop();
00884         
00885         timer_FCTN_APPEND_HKDATA.reset();
00886         timer_FCTN_APPEND_HKDATA.start();
00887         FCTN_APPEND_HKDATA();
00888         timer_FCTN_APPEND_HKDATA.stop();
00889         
00890         timer_minMaxHkData.reset();
00891         timer_minMaxHkData.start();
00892         minMaxHkData();
00893         timer_minMaxHkData.stop();
00894         
00895         //pc.printf("ere");  
00896         EPS_MAIN_STATUS = 0; // clear EPS main status 
00897  
00898 }
00899  
00900 
00901 //**************************************************BCN THREAD*******************************************************************//
00902 
00903 void F_BCN()
00904 {
00905     pc.printf("\n\rEntered BCN   %f\n",t_start.read());
00906     //BCN_TX_MAIN_COUNTER=+1;  
00907     
00908     timer_FCTN_BCN_TX_MAIN.reset();
00909     timer_FCTN_BCN_TX_MAIN.start();
00910     FCTN_BCN_TX_MAIN();
00911     timer_FCTN_BCN_TX_MAIN.stop();
00912 }
00913 
00914 //**************************************************TCTM THREAD*******************************************************************//
00915 
00916 //===================================================================
00917 void T_TC(void const * args)
00918 {   
00919     while(1)
00920     {  
00921         Thread::signal_wait(0x4);
00922         wait_us(300);
00923                  
00924         BAE_MNG_I2C_STATUS =1 ;
00925         //I2C_last.reset();
00926         //I2C_last.start();
00927        // pc.printf("\n\r intrpet");
00928         if( slave.receive() == 0)
00929         {
00930             pdir_ss1=PTE->PDIR;                                         /////////edited
00931             irpt_2_mstr = 0;
00932             data_send_flag = 'h';                
00933             slave.stop();                
00934             if(((pdir_ss1 & 0x00000003)!=3))        //check if bus has freezed
00935             {                  
00936                 I2C_busreset();                                         /////////edited
00937             }
00938             pdir_ss2=PTE->PDIR;
00939             pc.printf("\n\rSlave not addressed");
00940             pc.printf("\n\rPTE->DIR = 0x%08X",pdir_ss1);                
00941             #if PRINT2
00942             pc.printf("\n\rPTE->DIR = 0x%08X",pdir_ss2);
00943             #endif
00944         }
00945         else if( slave.receive() == 1)                                     // slave writes to master
00946         {
00947             BAE_I2C_COUNTER++;                                                      //////////edited
00948            // pc.printf("\n\r writing....");// changed
00949             if(data_send_flag == 'h') //to be renamed as BAE_I2C_STATUS
00950             {
00951                 irpt_2_mstr =1;   
00952                 //pc.printf("\n\r hk ");                                  //wait till cdms code is changed
00953                 FCTN_APPEND_HKDATA();
00954                 uint8_t i2c_count =0;
00955                 //crc is already being added
00956                 write_ack=slave.write((char*)BAE_chardata,134);
00957                 wait_ms(1);    //for correct values of register to be updated
00958                 pdir_tm1=PTE->PDIR;
00959                 irpt_2_mstr = 0;                             
00960                 if(write_ack==0)// wait till cdms code is changed
00961                 {
00962                     /*checking the tc timings*/
00963                    // time_wdog = 1;
00964                     
00965                     while(((pdir_tm1 & 0x00000003)!=3)&& i2c_count<10)
00966                     {
00967                         wait_ms(1);
00968                         pdir_tm1=PTE->PDIR;
00969                         i2c_count++;
00970                     }                    
00971                     if(((pdir_tm1 & 0x00000003)==3))
00972                     {                  
00973                         pc.printf("\n\rWrite HK success");
00974                        // data_send_flag = 'h';
00975                         irpt_2_mstr = 0;
00976                         I2C_last.reset();
00977                         I2C_last.start();                                //////////edited
00978                     }
00979                     else
00980                     {
00981                         #if baby
00982                         pc.printf("\n\rWrite HK failed");
00983                         pc.printf("\n\rPTE->PDIR = 0x%08X",pdir_tm1);
00984                         #endif
00985                         wait_ms(20); //should be atleast 7ms for correct operation but fix this value as 20ms
00986                         I2C_busreset();
00987                         #if baby2
00988                         pdir_tm2 = PTE->PDIR;
00989                         pc.printf("\n\rPTE->PDIR = 0x%08X",pdir_tm2);
00990                         #endif                   
00991                     }
00992                 }
00993                 else
00994                 {                    
00995                     #if baby1
00996                     pc.printf("\n\rWrite Ack failed(HK)");
00997                     pc.printf("\n\rPTE->PDIR = 0x%08X",pdir_tm1);
00998                     #endif
00999                     I2C_busreset();
01000                     #if baby2
01001                     pdir_tm2 = PTE->PDIR;
01002                     pc.printf("\n\rPTE->PDIR = 0x%08X",pdir_tm2);
01003                     #endif
01004                 }
01005                 i2c_count=0;
01006             }
01007             else if (data_send_flag == 't') //else if(telecommand[1]&0xC0 == 't')
01008             {
01009                 uint8_t i2c_count =0;
01010                 write_ack=slave.write((char*)telemetry,134);                        ////////edited(size)
01011                 wait_ms(1);    //for correct values of register to be updated
01012                 pdir_tm1=PTE->PDIR;
01013                 irpt_2_mstr = 0;
01014                 data_send_flag = 'h'; 
01015                // pc.printf("\n\r h set here");              
01016                 if(write_ack==0)
01017                 {
01018                     while(((pdir_tm1 & 0x00000003)!=3)&& i2c_count<10)
01019                     {
01020                         wait_ms(1);
01021                         pdir_tm1=PTE->PDIR;
01022                         i2c_count++;
01023                     }                    
01024                     if(((pdir_tm1 & 0x00000003)==3))
01025                     {                  
01026                         pc.printf("\n\rWrite TM success");
01027                         I2C_last.reset();
01028                         I2C_last.start();
01029                     }
01030                     else
01031                     {
01032                         #if baby
01033                         pc.printf("\n\rWrite TM failed");
01034                         pc.printf("\n\rPTE->PDIR = 0x%08X",pdir_tm1);
01035                         #endif
01036                         wait_ms(20); //should be atleast 7ms for correct operation but fix this value as 20ms
01037                         I2C_busreset();
01038                         #if baby2
01039                         pdir_tm2 = PTE->PDIR;
01040                         pc.printf("\n\rPTE->PDIR = 0x%08X",pdir_tm2);
01041                         #endif
01042                     }
01043                 } 
01044                 else
01045                 {
01046                     #if baby
01047                     pc.printf("\n\rWrite Ack failed");
01048                     pc.printf("\n\rPTE->PDIR = 0x%08X",pdir_tm1);
01049                     #endif
01050                     I2C_busreset();
01051                     #if baby2
01052                     pdir_tm2 = PTE->PDIR;
01053                     pc.printf("\n\rPTE->PDIR = 0x%08X",pdir_tm2);                   
01054                     #endif
01055                 }
01056                 i2c_count=0;                  
01057             } 
01058            // else
01059            // pc.printf("\n\r hey something wrong");                  
01060         }
01061         else if( slave.receive()==3 ||  slave.receive()==2)             // slave read 
01062         {
01063             BAE_I2C_COUNTER++;
01064             
01065             /*checking the tc timings*/
01066             time_wdog = 1;
01067             
01068             uint8_t i2c_count = 0;            
01069             read_ack=slave.read((char *)telecommand,135);    //read() function returns acknowledgement
01070             wait_ms(1);
01071             pdir_tc1=PTE->PDIR;            
01072             if(read_ack==0)     //read() says it was successful
01073             {
01074                 while(((pdir_tc1 & 0x00000003)!=3)&& i2c_count<10)//checking if SDA and SCL lines are logic 0 and not more than 10 times(10ms)
01075                 {
01076                     wait_ms(1);
01077                     pdir_tc1=PTE->PDIR;
01078                     i2c_count++;
01079                 }                    
01080                 if(((pdir_tc1 & 0x00000003)==3))
01081                 {
01082                     //pc.printf("\n\n\rRead TC success");
01083                     if(telecommand[0] == 0x00)                          /////////////edited
01084                         {
01085                             FCTN_CDMS_HK_TC((uint8_t*) telecommand);        /////////////edited
01086                             data_send_flag = 'h';
01087                             pc.printf("\n\n\rRead LBCN QM is comming");
01088                             I2C_last.reset();
01089                             I2C_last.start();      
01090                         }                            
01091                     else                   
01092                     {
01093                         pc.printf("\n\r Read TC SUCESS");
01094                         FCTN_BAE_TM_TC((uint8_t*) telecommand);
01095                         data_send_flag = 't';
01096                         irpt_2_mstr = 1;
01097                         I2C_last.reset();
01098                         I2C_last.start();
01099                       
01100                     }
01101                 }
01102                 else     //either or both of SDA and SCL lines low
01103                 {
01104                     #if baby
01105                     pc.printf("\n\rRead TC failed");
01106                     pc.printf("\n\rPTE->PDIR = 0x%08X",pdir_tm1);
01107                     #endif
01108                     I2C_busreset();
01109                     #if baby2
01110                     pdir_tm2 = PTE->PDIR;                    
01111                     pc.printf("\n\rPTE->PDIR = 0x%08X",pdir_tm2);
01112                     #endif
01113                     gen_I_TM();
01114                     data_send_flag = 't';
01115                     irpt_2_mstr = 1;                                    /////////////added
01116                 }
01117             }
01118             else //read() says it was not successful
01119             {                
01120                 #if baby
01121                 pc.printf("\n\rRead Ack failed");
01122                 pc.printf("\n\rPTE->PDIR = 0x%08X",pdir_tm1);                
01123                 #endif
01124                 I2C_busreset();
01125                 #if baby2
01126                 pdir_tm2 = PTE->PDIR;
01127                 pc.printf("\n\rPTE->PDIR = 0x%08X",pdir_tm2);
01128                 #endif
01129                 //pc.printf("\n\r no data case");
01130                 gen_I_TM();
01131                 data_send_flag = 't';  
01132                 irpt_2_mstr = 1;                                            /////////////added
01133             }
01134             i2c_count = 0;
01135         }     
01136         BAE_MNG_I2C_STATUS=0;
01137     }
01138 }
01139 
01140 void FCTN_TM()
01141 { 
01142     data_send_flag = 't';
01143     pc.printf("\n\r Telemetry Generation \n");
01144     irpt_2_mstr = 1;   
01145 }
01146 
01147 
01148 //******************************************************* I2C *******************************************************************//
01149 
01150 void FCTN_I2C_ISR()
01151 {
01152     ptr_t_i2c->signal_set(0x4);
01153 }
01154 
01155 
01156 //***********************************************************FAULTS***************************************************************//
01157 
01158 uint8_t iter2=0,iter4 = 0; 
01159 
01160 void pollfault()
01161 {   
01162     //if (ACS_ATS1_OC_FAULT==0)                // OC_ATS1
01163     if(0)
01164         { 
01165             pf1check=1;
01166             actual_data.faultPoll_status |=0x01 ;
01167             ATS1_SW_ENABLE = 1;  // turn off ats1  // to be turned on next cycle in ACS
01168         }
01169     else 
01170         actual_data.faultPoll_status &= 0xFE;
01171     
01172     //if(ACS_ATS2_OC_FAULT==0)
01173     if(0)
01174         {   
01175             pf2check=1;
01176             actual_data.faultPoll_status |=0x02 ;
01177             ATS2_SW_ENABLE = 1;  // turn off ats2  // turn on in ACS
01178         }
01179     else 
01180         actual_data.faultPoll_status &= 0xFD;
01181  
01182     if (ACS_TR_XY_FAULT==0)
01183         {   
01184             actual_data.faultPoll_status |=0x04 ;
01185             DRV_XY_EN = 0;
01186             wait_us(1);
01187             DRV_XY_EN = 1;
01188         }
01189     else 
01190         actual_data.faultPoll_status &= 0xFB;
01191 }
01192   
01193 //------------------------------------------------------------------------------------------------------------------------------------------------
01194 //SCHEDULER
01195 //------------------------------------------------------------------------------------------------------------------------------------------------
01196 
01197 uint8_t schedcount=1;
01198 void T_SC(void const *args)
01199 {    
01200     #if print
01201         pc.printf("\n\r in scheduler");
01202     #endif
01203    /*if keeping thish many cases creates a problem then make 3 seperate flagvariable i.e bae_standby_acs so on that will make it easy.!!!*/
01204     if(schedcount == 13)                         //to reset the counter
01205         schedcount = 1;
01206     if(schedcount%1==0)
01207         {
01208             if( BAE_STANDBY==0x02 || BAE_STANDBY==0x03 || BAE_STANDBY==0x06 || BAE_STANDBY==0x07)
01209                 {
01210                     pc.printf("\n reahed here working till stage one acs");
01211                     pc.printf("\nSTATE IS !!!!!! = %x !!\n",ACS_STATE);
01212                     timer_F_ACS.reset();
01213                     timer_F_ACS.start();
01214                     F_ACS();
01215                     timer_F_ACS.stop();
01216                     /*pc.printf("\n\r timer_F_ACS is %f",timer_F_ACS.read());
01217                     pc.printf("\n\r timer_SENSOR_INIT is %f",timer_SENSOR_INIT.read());
01218                     pc.printf("\n\r timer_CONFIG_UPLOAD is %f",timer_CONFIG_UPLOAD.read());
01219                     pc.printf("\n\r timer_SENSOR_DATA_ACQ is %f",timer_SENSOR_DATA_ACQ.read());
01220                     pc.printf("\n\r timer_FCTN_ACS_GENPWM_MAIN is %f",timer_FCTN_ACS_GENPWM_MAIN.read());
01221                     pc.printf("\n\r timer_FCTN_ACS_CNTRLALGO is %f",timer_FCTN_ACS_CNTRLALGO.read());
01222                     pc.printf("\n\r timer_controlmodes is %f",timer_controlmodes.read());
01223                     */
01224                     //time_wdog = 0;
01225                 }
01226     
01227         }
01228     if(schedcount%4==0)
01229         {   
01230             if( BAE_STANDBY==0x01 || BAE_STANDBY==0x03 || BAE_STANDBY==0x05 || BAE_STANDBY==0x07)
01231                 {
01232                     pc.printf("\n reahed here working till stage one eps");
01233                     //time_wdog = 1;
01234                     timer_F_ESP.reset();
01235                     timer_F_ESP.start();
01236                     F_EPS();
01237                     timer_F_ESP.stop();
01238                     pc.printf("\n\r timer_F_ESP is %f",timer_F_ESP.read());
01239                    /* pc.printf("\n\r timer_FCTN_BATTERYGAUGE_INIT is %f",timer_FCTN_BATTERYGAUGE_INIT.read());
01240                     pc.printf("\n\r timer_alertFlags is %f",timer_alertFlags.read());
01241                     pc.printf("\n\r timer_soc is %f",timer_soc.read());
01242                     pc.printf("\n\r timer_FCTN_BATT_TEMP_SENSOR_MAIN is %f",timer_FCTN_BATT_TEMP_SENSOR_MAIN.read());
01243                     pc.printf("\n\r timer_FCTN_BATTERYGAUGE_MAIN is %f",timer_FCTN_BATTERYGAUGE_MAIN.read());
01244                     pc.printf("\n\r timer_FCTN_HK_MAIN is %f",timer_FCTN_HK_MAIN.read());
01245                     pc.printf("\n\r timer_FCTN_EPS_HANDLE_HW_FAULTS is %f",timer_FCTN_EPS_HANDLE_HW_FAULTS.read());
01246                     pc.printf("\n\r timer_FCTN_EPS_HANDLE_CDMS_FAULT is %f",timer_FCTN_EPS_HANDLE_CDMS_FAULT.read());
01247                     pc.printf("\n\r timer_FCTN_APPEND_HKDATA is %f",timer_FCTN_APPEND_HKDATA.read());
01248                     pc.printf("\n\r timer_minMaxHkData is %f",timer_minMaxHkData.read());
01249                     */
01250                 }
01251             //time_wdog = 0;
01252         }
01253     if(schedcount%6==0)
01254         {
01255             if(BAE_STANDBY==0x04 || BAE_STANDBY==0x05 || BAE_STANDBY==0x06 || BAE_STANDBY==0x07)
01256                 {    
01257                     pc.printf("\n reahed here working till stage one bcn");
01258                     //  time_wdog = 0;
01259                     timer_F_BCN.reset();
01260                     timer_F_BCN.start();
01261                     SHORT_HK_data_AQ();
01262                     F_BCN();
01263                     timer_F_BCN.stop();
01264                     /*pc.printf("\n\r timer_F_BCN is %f",timer_F_BCN.read());
01265                     pc.printf("\n\r timer_Init_BEACON_HW is %f",timer_Init_BEACON_HW.read());
01266                     pc.printf("\n\r timer_FCTN_BCN_TX_MAIN is %f",timer_FCTN_BCN_TX_MAIN.read());
01267                     pc.printf("\n\r timer_Set_BCN_TX_STATUS_SUCCESS is %f",timer_Set_BCN_TX_STATUS_SUCCESS.read());
01268                     pc.printf("\n\r timer_Set_BCN_TX_STATUS_FAILURE is %f",timer_Set_BCN_TX_STATUS_FAILURE.read());
01269                     pc.printf("\n\r timer_Set_BCN_TX_STATUS_DISABLED is %f",timer_Set_BCN_TX_STATUS_DISABLED.read());
01270                     pc.printf("\n\r timer_Set_BCN_TX_STATUS_SUSPENDED is %f",timer_Set_BCN_TX_STATUS_SUSPENDED.read());
01271                     pc.printf("\n\r timer_Set_BCN_TX_STATUS_RF_SILENCE is %f",timer_Set_BCN_TX_STATUS_RF_SILENCE.read());
01272                 */}
01273         }
01274     schedcount++;
01275     #if print
01276         printf("\n\r exited scheduler h");
01277         printf("\n\r time taken %f",t_start.read());
01278     #endif
01279 }
01280 
01281 
01282 Timer t_flag;
01283 
01284 
01285 void FLAG()
01286 {
01287     
01288 //I2C
01289     //if(BAE_MNG_I2C_STATUS == 1)
01290     //    BAE_STATUS = BAE_STATUS | 0x10000000;
01291     //else if(BAE_MNG_I2C_STATUS == 0)
01292     //    BAE_STATUS &= 0xEFFFFFF;
01293 
01294 //.............bae..................//
01295     if(BAE_INIT_STATUS == 1)
01296         BAE_STATUS = BAE_STATUS | 0x00000001; //BAE_STATUS |= 0x00000001;
01297     else if(BAE_INIT_STATUS == 0)
01298         BAE_STATUS &= 0xFFFFFFFE;
01299         
01300     if(BAE_MNG_I2C_STATUS == 1)   
01301         BAE_STATUS = BAE_STATUS | 0x00000002;
01302     if(BAE_MNG_I2C_STATUS == 0)   
01303         BAE_STATUS &= 0xFFFFFFFD;    
01304 
01305 //.............acs..................//    
01306     if(ACS_INIT_STATUS == 1)
01307         BAE_STATUS = BAE_STATUS | 0x00000080;  //set ACS_INIT_STATUS flag
01308     else if(ACS_INIT_STATUS == 0)
01309         BAE_STATUS &= 0xFFFFFF7F;              //clear ACS_INIT_STATUS flag 
01310     
01311     if(ACS_DATA_ACQ_STATUS == 1)
01312         BAE_STATUS =BAE_STATUS | 0x00000100;     //set ACS_DATA_ACQ_STATUS flag
01313     else if(ACS_DATA_ACQ_STATUS == 0)
01314         BAE_STATUS &= 0xFFFFFEFF;      //clear ACS_DATA_ACQ_STATUS flag    
01315     
01316     if(ACS_ATS_ENABLE == 1)
01317         BAE_ENABLE |= 0x00000004;
01318     else if(ACS_ATS_ENABLE == 0)
01319         BAE_ENABLE = BAE_ENABLE &0xFFFFFFFB | 0x00000004;
01320     
01321     if(ACS_DATA_ACQ_STATUS == 'f')
01322         BAE_STATUS |= 0x00000200;
01323     
01324     if(ACS_MAIN_STATUS == 1)
01325         BAE_STATUS = (BAE_STATUS | 0x00001000);     //set ACS_MAIN_STATUS flag
01326    else if(ACS_MAIN_STATUS == 0)
01327         BAE_STATUS &= 0xFFFFEFFF;     //clear ACS_MAIN_STATUS flag 
01328     
01329     if(ACS_STATUS == '0')
01330         BAE_STATUS = (BAE_STATUS & 0xFFFF1FFF);                // set ACS_STATUS = ACS_CONTROL_OFF
01331     else if(ACS_STATUS == '1')
01332         BAE_STATUS =(BAE_STATUS & 0xFFFF1FFF) | 0x00002000;                    // set ACS_STATUS = ACS_LOW_POWER
01333     else if(ACS_STATUS == '2')
01334         BAE_STATUS = (BAE_STATUS & 0xFFFF1FFF)| 0x00004000;                    // set ACS_STATUS = ACS_ZAXIS_MOMENT_ONLY  
01335     else if(ACS_STATUS == '3') 
01336         BAE_STATUS = (BAE_STATUS & 0xFFFF1FFF) | 0x00006000;                    // set ACS_STATUS = ACS_DATA_ACQ_FAILURE
01337     else if(ACS_STATUS == '4')
01338         BAE_STATUS = (BAE_STATUS & 0xFFFF1FFF) | 0x00008000;                    // set ACS_STATUS = ACS_NOMINAL_ONLY
01339     else if(ACS_STATUS == '5')
01340         BAE_STATUS =(BAE_STATUS & 0xFFFF1FFF) | 0x0000A000;                    // set ACS_STATUS = ACS_AUTO_CONTROL
01341     else if(ACS_STATUS == '6')
01342         BAE_STATUS =(BAE_STATUS & 0xFFFF1FFF) | 0x0000C000;                    // set ACS_STATUS = ACS_DETUMBLING_ONLY  
01343     else 
01344         BAE_STATUS =(BAE_STATUS & 0xFFFF1FFF) | 0x0000E000;                    // set ACS_STATUS = INVALID STATE 
01345         
01346     if(ACS_STATE == '0')
01347         BAE_ENABLE = (BAE_ENABLE & 0xFFFFFF8F);                                         //ACS_STATE = ACS_CONTROL_OFF
01348     else if(ACS_STATE == '2')
01349         BAE_ENABLE = ((BAE_ENABLE & 0xFFFFFF8F)| 0x00000020);                              //   ACS_STATE = ACS_ZAXIS_MOMENT_ONLY  
01350     else if(ACS_STATE == '3')
01351         BAE_ENABLE = ((BAE_ENABLE & 0xFFFFFF8F)| 0x00000030);                              //  set ACS_STATUS = ACS_DATA_ACQ_FAILURE
01352     else if(ACS_STATE == '4')
01353         BAE_ENABLE = ((BAE_ENABLE & 0xFFFFFF8F)| 0x00000040);                              //  ACS_STATE = ACS_NOMINAL_ONLY
01354     else if(ACS_STATE == '5')
01355         BAE_ENABLE = ((BAE_ENABLE & 0xFFFFFF8F)| 0x00000050);                              //    ACS_STATE = ACS_AUTO_CONTROL
01356     else if(ACS_STATE == '6')
01357         BAE_ENABLE = ((BAE_ENABLE & 0xFFFFFF8F)| 0x00000060);                             //ACS_STATE = ACS_DETUMBLING_CONTROL
01358         
01359 //...............eps......................//
01360     if (EPS_INIT_STATUS==1)                                  // Set EPS_INIT_STATUS
01361         BAE_STATUS |= 0x00010000;                     
01362     else if(EPS_INIT_STATUS==0)                              // Clear
01363         BAE_STATUS &= 0xFFFEFFFF;
01364 
01365 
01366     if (EPS_MAIN_STATUS==1)                              // Set EPS_MAIIN_STATUS
01367         BAE_STATUS |= 0x00040000;
01368     else if(EPS_MAIN_STATUS==0)                          // Clear
01369         BAE_STATUS &= 0xFFFBFFFF;
01370 
01371 
01372     if (EPS_BATTERY_GAUGE_STATUS==1)              // Set EPS_BATTERY_GAUGE_STATUS
01373         BAE_STATUS |= 0x00020000;
01374     else if(EPS_BATTERY_GAUGE_STATUS==0)          // Clear
01375         BAE_STATUS &= 0xFFFDFFFF;
01376 
01377     if (EPS_BTRY_TMP_STATUS==1)             // Set EPS_BATTERY_TEMP_STATUS
01378         BAE_STATUS |= 0x00080000;
01379     else if(EPS_BTRY_TMP_STATUS==0)       // Clear
01380         BAE_STATUS &= 0xFFF7FFFF;
01381 
01382     if (EPS_STATUS==0)
01383         BAE_STATUS = (BAE_STATUS & 0xFF8FFFFF);                             // Set EPS_ERR_BATTERY_TEMP
01384     else if (EPS_STATUS==1)
01385         BAE_STATUS = (BAE_STATUS & 0xFF8FFFFF)|0x00010000;           // Set EPS_BATTERY_HEATER_DISABLED
01386     else if (EPS_STATUS==2)
01387         BAE_STATUS = (BAE_STATUS & 0xFF8FFFFF)|0x00020000;           // Set EPS_ERR_HEATER_SWITCH_OFF
01388     else if (EPS_STATUS==3)
01389         BAE_STATUS = (BAE_STATUS & 0xFF8FFFFF)|0x00030000;          // Set EPS_ERR_HEATER_SWITCH_ON
01390     else if (EPS_STATUS==4)
01391         BAE_STATUS = (BAE_STATUS & 0xFF8FFFFF)|0x00040000;          // Set EPS_BATTERY_HEATER_OFF
01392     else if (EPS_STATUS==5)
01393         BAE_STATUS = (BAE_STATUS & 0xFF8FFFFF)|0x00050000;          // Set EPS_BATTERY_HEATER_ON   
01394     
01395     if(EPS_BTRY_HTR_AUTO == 1)
01396         BAE_ENABLE |= 0x00000080;
01397     else if(EPS_BTRY_HTR_AUTO == 0)
01398         BAE_ENABLE = BAE_ENABLE &0xFFFFFF7;    
01399     
01400     #if print
01401         pc.printf("\n\r BAE status %x BAE ENABLE %x ",BAE_STATUS,BAE_ENABLE); 
01402     #endif
01403 }
01404 
01405 
01406 void FCTN_BAE_INIT()
01407 {
01408     #if print
01409         printf("\n\r Initialising BAE _________________________________________________________________________________");
01410     #endif
01411     BAE_INIT_STATUS=1;
01412     FLAG();
01413     
01414     //..........intial status....//
01415     ACS_STATE = 4;
01416     ACS_ATS_ENABLE = 1;
01417     ACS_DATA_ACQ_ENABLE = 1;
01418     EPS_BTRY_HTR_AUTO = 1;
01419     actual_data.power_mode=3;
01420     
01421     //............intializing pins................//
01422     ATS1_SW_ENABLE = 1;
01423     ATS2_SW_ENABLE = 1;
01424 
01425     DRV_XY_EN = 1;
01426     DRV_Z_EN = 1;
01427     ACS_TR_Z_ENABLE = 1;
01428     ACS_TR_XY_ENABLE = 1;
01429 
01430     //time_wdog = 1;
01431     
01432     kick_WDOG();
01433     pc.printf("\n\r lvl1");
01434     
01435     //...........order mentioned in flow chart.................//
01436     timer_FCTN_BAE_INIT.reset();
01437     timer_FCTN_BAE_INIT.start();
01438     FCTN_ACS_INIT();
01439     timer_FCTN_BAE_INIT.stop();
01440     pc.printf("\n\r timer_FCTN_BAE_INIT is %f",timer_FCTN_BAE_INIT.read());
01441     
01442     timer_FCTN_EPS_INIT.reset();
01443     timer_FCTN_EPS_INIT.start();
01444     FCTN_EPS_INIT();
01445     timer_FCTN_EPS_INIT.stop();
01446     pc.printf("\n\r timer_FCTN_EPS_INIT is %f",timer_FCTN_EPS_INIT.read());
01447     
01448     timer_FCTN_BCN_INIT.reset();
01449     timer_FCTN_BCN_INIT.start();
01450     FCTN_BCN_INIT();
01451     timer_FCTN_BCN_INIT.stop();
01452     pc.printf("\n\r timer_FCTN_BCN_INIT is %f",timer_FCTN_BCN_INIT.read());
01453     
01454     //uint32_t data_flash=FCTN_BAE_RD_FLASH_ENTITY(0);/*sending the 0 entity as in mms tc/tm bae_reset_counter is present in first 32 bits */
01455     //uint32_t data_modify=data_flash & 0x000000FF;
01456     //data_modify +=1;
01457     //data_modify |=data_flash;
01458     //FCTN_BAE_WR_FLASH(0,data_modify);
01459     //#if print
01460     //    printf("\n\rthe number of reset %d",data_modify);
01461     //#endif
01462     BAE_INIT_STATUS=0;
01463     FLAG();
01464 }
01465 
01466 
01467 int main()
01468 {
01469     //BAE_uptime.reset();
01470     BAE_uptime.start();
01471     //time_wdog = 1;
01472     pc.printf("\n\r BAE Activated. Testing Version 1.2 \n");
01473     //FLASH_INI();
01474     
01475     time_wdog=1;
01476     timer_FCTN_BAE_INIT.start();
01477     FCTN_BAE_INIT();
01478     timer_FCTN_BAE_INIT.stop();
01479     pc.printf("\n\r timer_FCTN_BAE_INIT is %f",timer_FCTN_BAE_INIT.read());
01480     
01481     time_wdog=0;
01482     
01483     //time_wdog = 0;
01484 
01485     slave.address(addr);
01486     irpt_2_mstr = 0;
01487     
01488     ptr_t_i2c = new Thread(T_TC);
01489     ptr_t_i2c->set_priority(osPriorityHigh);////osPriorityRealtime
01490         
01491     irpt_4m_mstr.enable_irq();
01492     irpt_4m_mstr.rise(&FCTN_I2C_ISR);
01493     
01494     RtosTimer t_sc_timer(T_SC,osTimerPeriodic);               // Initiating the scheduler thread
01495     t_sc_timer.start(5000);
01496     t_start.start();
01497     
01498     #if print
01499         pc.printf("\n\rStarted scheduler %f\n\r",t_start.read()); 
01500     #endif
01501     /*if one defines it dynamically then one has to take care that the destuct function is calle everytime BAE resets otheriwse it will lead to memory leakage*/
01502     //BAE_STANDBY_STATUS_TIMER = new RtosTimer(BAE_STANDBY_STATUS_RESET,osTimerOnce);    
01503     /*static allocation*/
01504     RtosTimer STANDBY_TIMER(BAE_STANDBY_STATUS_RESET,osTimerOnce);
01505     BAE_STANDBY_STATUS_TIMER=&STANDBY_TIMER;
01506     
01507     RtosTimer bcn_start_timer(FCTN_BCN_FEN,osTimerOnce);
01508     /*later change it to 30 min 1800 seconds*/
01509     bcn_start_timer.start(20000);
01510    
01511    //BCN HTR TIMERS
01512     RtosTimer EPS_HTR_OFF_TIMER(FCTN_EPS_HTR_OFF, osTimerOnce);
01513     HTR_OFF=&EPS_HTR_OFF_TIMER;
01514     
01515     RtosTimer EPS_HTR_CYCLE_TIMER(FCTN_EPS_HTR_CYCLE, osTimerPeriodic);
01516     HTR_CYCLE=&EPS_HTR_CYCLE_TIMER;
01517     
01518     RtosTimer EPS_HTR_DLY_TIMER(FCTN_EPS_HTR_DLY,osTimerOnce);
01519     HTR_DLY=&EPS_HTR_DLY_TIMER;
01520     
01521     timer_FLASH_INI.start();
01522     FLASH_INI();
01523     timer_FLASH_INI.stop();
01524     pc.printf("\n\r timer_FCTN_BAE_INIT is %f",timer_FCTN_BAE_INIT.read());
01525    
01526 while(1);                                                   //required to prevent main from terminating
01527 
01528 }