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