main.cpp

00001 #include "mbed.h"
00002 #include "rtos.h"
00003 #include "HK.h"
00004 #include "slave.h"
00005 #include "beacon.h"
00006 #include "ACS.h"
00007 #include "fault.h"
00008 #include "slave.h"
00009 #include "mnm.h"
00010 
00011 Serial pc(USBTX, USBRX);
00012 
00013 //extern DigitalOut DRDY;
00014 InterruptIn interrupt(D9);
00015 InterruptIn master_reset(D8);
00016 
00017 
00018 Timer t;                                                        //To know the time of execution each thread
00019 Timer t1;
00020                                                        //To know the time of entering  of each thread
00021 Timer t2;
00022 Timer t3;
00023 Timer t4;
00024 
00025 
00026 
00027 
00028 
00029 
00030 Thread *ptr_t_hk_acq;
00031 Thread *ptr_t_acs;
00032 //Thread *ptr_t_acs_write2flash;
00033 Thread *ptr_t_bea;
00034 //Thread *ptr_t_bea_telecommand;
00035 //Thread *ptr_t_fault;
00036 Thread *ptr_t_i2c;
00037 Thread *ptr_t_wdt;  
00038 
00039 
00040 
00041 //I2CSlave slave(D14,D15);                       //configuring pins p27, p28 as I2Cslave
00042 
00043 
00044 DigitalOut data_ready(D10);
00045 int i2c_status=0;                                 //read/write mode for i2c 0 : write2slave, 1 : write2master
00046 int reset=0;
00047 int temp;
00048 
00049 typedef struct
00050 {
00051     char data[25];          // To avoid dynamic memory allocation
00052     int length;
00053 }i2c_data;
00054 
00055 
00056 
00057 
00058 
00059 
00060 //Mail<i2c_data,16> i2c_data_receive;
00061 Mail<i2c_data,16> i2c_data_send;
00062 
00063 //--------------------------------------------------------------------------------------------------------------------------------------------------
00064 //TASK 2 : HK
00065 //--------------------------------------------------------------------------------------------------------------------------------------------------
00066 
00067 char hk_data[25];
00068 extern SensorDataQuantised SensorQuantised;
00069 void T_HK_ACQ(void const *args)
00070 {
00071     
00072     while(1)
00073     {
00074         Thread::signal_wait(0x2);
00075         SensorQuantised.power_mode='3';
00076         printf("\n\rTHIS IS HK    %f\n\r",t1.read());
00077         t.start();
00078         FUNC_HK_FAULTS();
00079         FUNC_HK_POWER(SensorQuantised.power_mode);                                                   //The power mode algorithm is yet to be obtained
00080         FUNC_HK_MAIN();                                                             //Collecting HK data
00081         //thread_2.signal_set(0x4);
00082         //FUNC_I2C_SLAVE_MAIN(25);    
00083         FUNC_I2C_IR2CDMS();
00084         t.stop();
00085         printf("The time to execute hk_acq is %f seconds\n\r",t.read());
00086         t.reset();
00087     }
00088 }
00089 
00090 //---------------------------------------------------------------------------------------------------------------------------------------
00091 //TASK 1 : ACS
00092 //---------------------------------------------------------------------------------------------------------------------------------------
00093 
00094 int acs_pflag = 1;
00095 void T_ACS(void const *args)
00096 {
00097     float *mag_field;
00098     float *omega;
00099     float mag_field1[3];
00100     float omega1[1];
00101     float moment[3];
00102     float *mnm_data;
00103     while(1)
00104     {
00105         Thread::signal_wait(0x1);
00106         printf("\n\rTHIS IS ACS   %f\n\r",t1.read());
00107         t.start();
00108         mag_field= FUNC_ACS_MAG_EXEC();                              //actual execution
00109         omega = FUNC_ACS_EXEC_GYR();
00110         printf("\n\r gyr 1 value %f",omega[0]);
00111         mnm_data=EXECUTE_PNI(); //the angular velocity is stored in the first 3 values and magnetic field values in next 3
00112         printf("\n\rmnm gyro values\n"); //printing the angular velocity and magnetic field values
00113         for(int i=0; i<3; i++) 
00114         {
00115         printf("%f\t",mnm_data[i]);
00116         }
00117         printf("\n\r mnm mag values\n");
00118         for(int i=3; i<6; i++) {
00119         printf("%f\t",mnm_data[i]);
00120         }
00121         for(int i = 0 ; i<3;i++)
00122         {
00123             omega1[i] = mnm_data[i];
00124         }
00125         for( int i = 3;i<6;i++)
00126         {
00127             mag_field1[i-3] = mnm_data[i];
00128         }
00129         if(acs_pflag == 1)
00130         {
00131         FUNC_ACS_CNTRLALGO(mag_field1,omega1,moment);
00132         printf("\n\r control algo values ");
00133         for(int i=0; i<3; i++) 
00134         {
00135         printf("%f\t",moment[i]);
00136         }
00137         FUNC_ACS_GENPWM(moment);                     
00138         }
00139        
00140         t.reset();
00141     }
00142 }
00143 /*
00144 void T_ACS_WRITE2FLASH(void const *args)
00145 {
00146     while(1)
00147     {
00148         //printf("Writing in the flash\n\r");
00149         osEvent evt = q_acs.get();
00150         if(evt.status == osEventMail)
00151         {
00152             sensor_data *ptr = (sensor_data*)evt.value.p;
00153             FUNC_ACS_WRITE2FLASH(ptr);
00154             q_acs.free(ptr);
00155         }
00156         printf("Writing acs data in the flash\n\r");
00157     }
00158 }
00159 
00160 */
00161 //---------------------------------------------------BEACON--------------------------------------------------------------------------------------------
00162 
00163 int beac_flag=0;                                                            //To receive telecommand from ground.
00164 
00165 
00166 /*void T_BEA_TELECOMMAND(void const *args)
00167 {
00168     char c = pc.getc();
00169     if(c=='a')
00170     {
00171         printf("Telecommand detected\n\r");
00172         beac_flag=1;
00173     }
00174 }
00175 */
00176 
00177 void T_BEA(void const *args)
00178 {
00179     
00180     while(1)
00181     {
00182         Thread::signal_wait(0x3);
00183         printf("\n\rTHIS IS BEACON    %f\n\r",t1.read());
00184         t.start();
00185         
00186         
00187             
00188         FUNC_BEA();
00189             
00190         
00191         if(beac_flag==1)
00192         {
00193             Thread::wait(600000);
00194             beac_flag = 0;
00195         }
00196         
00197         printf("The time to execute beacon thread is %f seconds\n\r",t.read());
00198         t.reset();
00199     }
00200 }
00201 
00202 //---------------------------------------------------------------------------------------------------------------------------------------------------
00203 //TASK 4 : FAULT MANAGEMENT
00204 //---------------------------------------------------------------------------------------------------------------------------------------------------
00205 //Dummy fault rectifier functions
00206 
00207 extern SensorDataQuantised SensorQuantised;
00208 
00209 
00210 /*void T_FAULT(void const *args)
00211 {   
00212     Sensor.power_mode='0';
00213     while(1)
00214     {
00215         Thread :: signal_wait(0x2);
00216         FAULTS();
00217         POWER(Sensor.power_mode);
00218         //Sensor.power_mode++;            //testing ... should be removed
00219     }    
00220 }
00221 */
00222 /*-------------------------------------------------------------------------------------------------------------------------------------------
00223 -------------------------------------------------------WATCHDOG----------------------------------------------------------------------------*/
00224 DigitalOut trigger(PIN63);                                             // has to be changed
00225 void T_WDT(void const * args)
00226 {
00227     trigger = 1;
00228     while(true)
00229     {
00230         Thread::signal_wait(0x5);                               //signal set from scheduler or sthing. r RTOS timer nce the timing is finalized
00231         printf("\n\rEntered WD\n\r");
00232         trigger = !trigger;
00233     }
00234 }
00235 
00236 //---------------------------------------------------------------------------------------------------------------------------------------------------
00237 //TASK 5 : i2c data
00238 //---------------------------------------------------------------------------------------------------------------------------------------------------
00239 
00240 
00241 
00242 
00243 
00244 
00245 /*void FUNC_I2C_WRITE2CDMS(char *data, int length=1)
00246 {
00247        int slave_status = 1;
00248        //t2.stop();
00249        if(interrupt ==1)
00250        {
00251 
00252            if(slave.receive() == 0)
00253            t2.stop();
00254            //t4.stop();     
00255            //printf("\n\r %d ",slave.receive());  
00256            if( slave.receive()==1)
00257            {
00258                t2.stop();
00259                
00260                slave_status=slave.write(data,length);
00261                t3.stop();
00262             
00263             }
00264             else if( slave.receive()==3 ||  slave.receive()==2)
00265             {
00266                 t2.stop();
00267                 //t3.start();
00268                 slave_status=slave.read(data,length);
00269                 t3.stop();
00270             }
00271          
00272             
00273     }
00274            
00275             printf("\n\r%d\r",t2.read_us());
00276             t2.reset();
00277             printf("\n\r%d\r",t3.read_us());
00278             t3.reset();
00279      
00280 }*/
00281 /*   
00282 char data_send[25],data_receive;
00283 void T_I2C_BAE(void const * args)
00284 {
00285      //char data_send,data_receive;
00286     while(1)
00287     {
00288         Thread::signal_wait(0x4);
00289        // printf("\n\r entered thread");
00290         if(i2c_status == 0 )
00291         {
00292             wait_ms(20);
00293             FUNC_I2C_WRITE2CDMS(&data_receive,1);
00294   */             
00295             /*i2c_data * i2c_data_r = i2c_data_receive.alloc();
00296             i2c_data_r->data = data_receive;
00297             i2c_data_r->length = 1;
00298             i2c_data_receive.put(i2c_data_r);*/
00299    /*         printf("\n\r Data received from CDMS is %c \n\r",data_receive);
00300             FUNC_I2C_TC_EXECUTE(data_receive);                             // This has to be done from a differen thread
00301             
00302         }
00303         else if(i2c_status ==1)
00304         {
00305             osEvent evt = i2c_data_send.get();
00306             if (evt.status == osEventMail) 
00307             {
00308                 i2c_data *i2c_data_s = (i2c_data*)evt.value.p;
00309                 strcpy(data_send,i2c_data_s -> data);
00310                 wait_ms(29);
00311                 FUNC_I2C_WRITE2CDMS(data_send,25);
00312                 printf("\n\rData sent to CDMS is %s\n\r",data_send);
00313                 i2c_data_send.free(i2c_data_s);
00314                 i2c_status = 0;
00315                 
00316                 
00317             }
00318         }  
00319            
00320     }
00321 }
00322 
00323         
00324 */
00325 /*void FUNC_I2C_INT()
00326 {
00327    
00328    t2.start();
00329   // t3.start();
00330    ptr_t_i2c->signal_set(0x4);
00331    
00332      
00333 }*/
00334 
00335 void FUNC_I2C_IR2CDMS()
00336 { ;
00337 /*        data_ready=0; 
00338         //char data[25];
00339         //strcpy(data,"sakthi ");
00340         //strcat(data,"priya");
00341         strcpy(hk_data,SensorQuantised.Voltage);
00342         strcat(hk_data,SensorQuantised.Current); 
00343         strcat(hk_data,SensorQuantised.Temperature); 
00344         strcat(hk_data,SensorQuantised.PanelTemperature);
00345         strcat(hk_data,SensorQuantised.AngularSpeed);
00346         strcat(hk_data,SensorQuantised.Bnewvalue);
00347         char fdata[5] = {SensorQuantised.BatteryTemperature,SensorQuantised.faultpoll,SensorQuantised.faultir,SensorQuantised.power_mode};
00348 */
00349         /*strcat(hk_data,sfaultpoll);
00350         strcat(hk_data,sfaultir);
00351         strcat(hk_data,spower_mode);*/
00352   /*      strcat(hk_data,fdata);
00353         printf("\n\rhk data : %s\n\r",hk_data);
00354        
00355         //data = pcslave.getc();
00356         reset =0;
00357         i2c_status=1;
00358         i2c_data * i2c_data_s = i2c_data_send.alloc();
00359         strcpy(i2c_data_s->data,hk_data);
00360         i2c_data_s->length = 25;
00361         i2c_data_send.put(i2c_data_s); 
00362         data_ready=1;
00363         //temp = i2c_status; */
00364 }
00365     
00366 
00367 //------------------------------------------------------------------------------------------------------------------------------------------------
00368 //TELECOMMAND
00369 //------------------------------------------------------------------------------------------------------------------------------------------------
00370 void FUNC_I2C_TC_EXECUTE (char command)  
00371 { switch(command)
00372    {   case '0' : printf("command 0 executed");
00373        break;
00374        case '1' : printf("command 1 executed");
00375        break;
00376        case '2' : printf("command 2 executed");
00377        break;
00378        case '3' : printf("command 3 executed");
00379     }
00380 }  
00381    
00382 
00383 //------------------------------------------------------------------------------------------------------------------------------------------------
00384 //SCHEDULER
00385 //------------------------------------------------------------------------------------------------------------------------------------------------
00386 int beacon_sc = 3;
00387 uint16_t schedcount=1;
00388 void T_SC(void const *args)
00389 {
00390     //DRDY=0;
00391     printf("The value of i in scheduler is %d\n\r",schedcount);
00392     if(schedcount == 65532)                         //to reset the counter
00393     {
00394         schedcount = 0;
00395     }
00396     
00397     if(schedcount%1==0)
00398     {
00399      ptr_t_acs -> signal_set(0x1);
00400      ptr_t_wdt -> signal_set(0x5);
00401     }
00402     if(schedcount%2==0)
00403     {
00404        // ptr_t_fault -> signal_set(0x2);
00405        ptr_t_hk_acq -> signal_set(0x2);
00406         
00407     }
00408     if(schedcount%beacon_sc==0)
00409     {
00410         if(beac_flag==0)
00411         {
00412             
00413           ptr_t_bea -> signal_set(0x3);
00414         }
00415     }
00416     schedcount++;
00417 }
00418     
00419 //---------------------------------------------------------------------------------------------------------------------------------------------
00420 
00421 int main()
00422 {
00423     t1.start();
00424    
00425     //DRDY=0;
00426      printf("\nahoy\n");
00427      INIT_PNI();
00428      
00429      FUNC_ACS_MAG_INIT();
00430      FUNC_ACS_INIT_GYR();
00431      //slave.address(0x20);
00432 
00433     ptr_t_hk_acq = new Thread(T_HK_ACQ);
00434     ptr_t_acs = new Thread(T_ACS);
00435     //ptr_t_acs_write2flash = new Thread(T_ACS_WRITE2FLASH);
00436     ptr_t_bea = new Thread(T_BEA);
00437     //ptr_t_bea_telecommand = new Thread(T_BEA_TELECOMMAND);
00438     //ptr_t_fault = new Thread(T_FAULT);
00439  //   ptr_t_i2c = new Thread(T_I2C_BAE);
00440     //ptr_t_sc = new Thread(T_SC);
00441     ptr_t_wdt = new Thread(T_WDT);
00442   
00443     interrupt_fault();
00444     
00445     //ptr_t_fault -> set_priority(osPriorityRealtime);
00446     ptr_t_acs->set_priority(osPriorityAboveNormal);
00447     ptr_t_i2c->set_priority(osPriorityHigh);
00448     ptr_t_hk_acq->set_priority(osPriorityAboveNormal);
00449     //ptr_t_acs_write2flash->set_priority(osPriorityBelowNormal);
00450     ptr_t_bea->set_priority(osPriorityAboveNormal);
00451     //ptr_t_bea_telecommand->set_priority(osPriorityIdle);
00452     //ptr_t_sc->set_priority(osPriorityAboveNormal);
00453     ptr_t_wdt -> set_priority(osPriorityIdle);
00454     
00455   
00456    // ----------------------------------------------------------------------------------------------
00457     //printf("\n\r T_FAULT priority is %d",ptr_t_fault->get_priority()); 
00458     printf("\n\r T_ACS priority is %d",ptr_t_acs->get_priority());
00459     printf("\n\r T_HK_ACQ priority is %d",ptr_t_hk_acq->get_priority());
00460     //printf("\n\r T_ACS_WRITE2FLASH priority is %d",ptr_t_acs_write2flash->get_priority());
00461     printf("\n\r T_BEA priority is %d",ptr_t_bea->get_priority());  
00462     RtosTimer t_sc_timer(T_SC,osTimerPeriodic);
00463     t_sc_timer.start(10000);
00464     printf("\n\r%f\n\r",t1.read()); 
00465      
00466      
00467       
00468     //master_reset.fall(&FUNC_I2C_RESET);
00469    // interrupt.rise(&FUNC_I2C_INT);
00470        
00471     while(1)
00472     {   
00473         //Thread::wait(10000);
00474          //ir2master(); 
00475          //DRDY = 0;
00476         Thread::wait(5000);
00477     }
00478     
00479 }