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 InterruptIn interrupt(D9);                                      //I2c interrupt from CDMS
00014 DigitalOut data_ready(D10);                                     //Sends interrupt to CDMS
00015 
00016 Timer t;                                                        //To know the time of execution each thread
00017 Timer t1;                                                       //To know the time of entering  of each thread
00018 Timer t2;                                                       //To check the time sync in i2c communication
00019 Timer t3;                                                       //To know the time taken by i2c read/write function
00020 
00021 /*****************************************************************Threads USed***********************************************************************************/
00022 Thread *ptr_t_hk_acq;
00023 Thread *ptr_t_acs;
00024 Thread *ptr_t_bea;
00025 Thread *ptr_t_i2c;
00026 Thread *ptr_t_wdt;  
00027 
00028 /****************************************************************configuring I2c*********************************************************************************/
00029 I2CSlave slave(PIN72,PIN71);                                        //configuring pins p27, p28 as I2Cslave
00030 
00031 int i2c_status=0;                                               //read or write mode for i2c 0: write2slave 1: write2master
00032 typedef struct                                                  //structure of i2c data 
00033 {
00034     char data[25];                          
00035     int length;
00036 }i2c_data;
00037 
00038 
00039 //Mail<i2c_data,16> i2c_data_receive;
00040 Mail<i2c_data,16> i2c_data_send;
00041 
00042 //--------------------------------------------------------------------------------------------------------------------------------------------------
00043 //TASK 2 : HK
00044 //--------------------------------------------------------------------------------------------------------------------------------------------------
00045 
00046 char hk_data[25];
00047 extern SensorDataQuantised SensorQuantised;
00048 void T_HK_ACQ(void const *args)
00049 {
00050     
00051     while(1)
00052     {
00053         Thread::signal_wait(0x2);
00054         SensorQuantised.power_mode='3';                          //default power mode(dummy)
00055         printf("\n\rTHIS IS HK    %f\n\r",t1.read());
00056         t.start();
00057         FUNC_HK_FAULTS();                                        // !Actual fault management is not implemented
00058         FUNC_HK_POWER(SensorQuantised.power_mode);               // !The power mode algorithm is yet to be obtained
00059         FUNC_HK_MAIN();                                          //Collecting HK data
00060         FUNC_I2C_IR2CDMS();                                      //sending HK data to CDMS
00061         t.stop();
00062         printf("The time to execute hk_acq is %f seconds\n\r",t.read());
00063         t.reset();
00064     }
00065 }
00066 
00067 //---------------------------------------------------------------------------------------------------------------------------------------
00068 //TASK 1 : ACS
00069 //---------------------------------------------------------------------------------------------------------------------------------------
00070 
00071 int acs_pflag = 1;
00072 void T_ACS(void const *args)
00073 {
00074     float mag_field[3];
00075     float omega[3];
00076     float *mnm_data;
00077     float mag_field1[3];
00078     float omega1[3];
00079     float tauc1[3];
00080     float moment[3];
00081     while(1)
00082     {
00083         Thread::signal_wait(0x1);
00084         printf("\n\rEntered ACS   %f\n",t1.read());
00085         t.start();
00086         FUNC_ACS_MAG_EXEC(mag_field); 
00087         printf("\n\r check");
00088          for(int i=0; i<3; i++) 
00089             {
00090             printf("%f\t",mag_field[i]);
00091             }                         
00092         FUNC_ACS_EXEC_GYR(omega);
00093         acs_pflag =1;                       //to be removed later 
00094         omega[0] = 1.0;
00095         omega[1] = 1.0;
00096         omega[2] = 1.0;
00097         
00098        
00099        
00100        /* mnm_data=EXECUTE_PNI(); //the angular velocity is stored in the first 3 values and magnetic field values in next 3
00101         printf("\n\rmnm gyro values\n"); //printing the angular velocity and magnetic field values
00102         for(int i=0; i<3; i++) 
00103         {
00104             printf("%f\t",mnm_data[i]);
00105         }
00106         printf("\n\r mnm mag values\n");
00107         for(int i=3; i<6; i++) 
00108         {
00109             printf("%f\t",mnm_data[i]);
00110         }
00111         for(int i = 0 ; i<3;i++)
00112         {
00113             omega1[i] = mnm_data[i];
00114         }
00115         for( int i = 3;i<6;i++)
00116         {
00117             mag_field1[i-3] = mnm_data[i];
00118         }
00119         */
00120         if(acs_pflag == 1)
00121         {
00122            
00123             FUNC_ACS_CNTRLALGO(mag_field,omega,tauc1);
00124             printf("\n\r control algo values ");
00125             for(int i=0; i<3; i++) 
00126             {
00127                 printf("%f\t",tauc1[i]);
00128             }
00129             moment_calc (tauc1, mag_field,moment);
00130             printf("\n\r moment values ");
00131             for(int i=0; i<3; i++) 
00132             {
00133                 printf("%f\t",moment[i]);
00134             }
00135             FUNC_ACS_GENPWM(moment);                   
00136         }
00137         t.reset();
00138     }
00139 }
00140 
00141 //---------------------------------------------------BEACON--------------------------------------------------------------------------------------------
00142 
00143 int beac_flag=0;                                                            //To receive telecommand from ground.
00144 
00145 
00146 /*void T_BEA_TELECOMMAND(void const *args)
00147 {
00148     char c = pc.getc();
00149     if(c=='a')
00150     {
00151         printf("Telecommand detected\n\r");
00152         beac_flag=1;
00153     }
00154 }
00155 */
00156 
00157 void T_BEA(void const *args)
00158 {
00159     
00160     while(1)
00161     {
00162         Thread::signal_wait(0x3);
00163         printf("\n\rTHIS IS BEACON    %f\n\r",t1.read());
00164         t.start();
00165         FUNC_BEA();
00166         if(beac_flag==1)
00167         {
00168             Thread::wait(600000);
00169             beac_flag = 0;
00170         }
00171         printf("The time to execute beacon thread is %f seconds\n\r",t.read());
00172         t.reset();
00173     }
00174 }
00175 
00176 
00177 
00178 extern SensorDataQuantised SensorQuantised;
00179 
00180 /*-------------------------------------------------------------------------------------------------------------------------------------------
00181 -------------------------------------------------------WATCHDOG----------------------------------------------------------------------------*/
00182 DigitalOut trigger(PIN63);                                             // has to be changed
00183 void T_WDT(void const * args)
00184 {
00185     trigger = 1;
00186     while(true)
00187     {
00188         Thread::signal_wait(0x5);                               //signal set from scheduler or sthing. r RTOS timer nce the timing is finalized
00189         printf("\n\rEntered WD\n\r");
00190         trigger = !trigger;
00191     }
00192 }
00193 
00194 //---------------------------------------------------------------------------------------------------------------------------------------------------
00195 //TASK 5 : i2c data
00196 //---------------------------------------------------------------------------------------------------------------------------------------------------
00197 
00198 void FUNC_I2C_WRITE2CDMS(char *data, int length=1)
00199 {
00200     int slave_status = 1;
00201     if(interrupt ==1)
00202     {
00203         if(slave.receive() == 0)
00204             t2.stop();
00205         if( slave.receive()==1)
00206         {
00207             t2.stop();
00208             t3.start();
00209             slave_status=slave.write(data,length);
00210             t3.stop();
00211         }
00212         else if( slave.receive()==3 ||  slave.receive()==2)
00213         {
00214             t2.stop();
00215             t3.start();
00216             slave_status=slave.read(data,length);
00217             t3.stop();
00218         }
00219     }
00220     printf("\n\r%d\r",t2.read_us());
00221     t2.reset();
00222     printf("\n\r%d\r",t3.read_us());
00223     t3.reset();
00224 }
00225    
00226 char data_send[25],data_receive;
00227 void T_I2C_BAE(void const * args)
00228 {
00229      while(1)
00230     {
00231         Thread::signal_wait(0x4);
00232         if(i2c_status == 0 )
00233         {
00234             wait_ms(23);
00235             FUNC_I2C_WRITE2CDMS(&data_receive,1);
00236             /*i2c_data * i2c_data_r = i2c_data_receive.alloc();
00237             i2c_data_r->data = data_receive;
00238             i2c_data_r->length = 1;
00239             i2c_data_receive.put(i2c_data_r);*/
00240             printf("\n\r Data received from CDMS is %c \n\r",data_receive);
00241             FUNC_I2C_TC_EXECUTE(data_receive);                             // This has to be done from a differen thread
00242             
00243         }
00244         else if(i2c_status ==1)
00245         {
00246             osEvent evt = i2c_data_send.get();
00247             if (evt.status == osEventMail) 
00248             {
00249                 i2c_data *i2c_data_s = (i2c_data*)evt.value.p;
00250                 strcpy(data_send,i2c_data_s -> data);
00251                 wait_ms(29);
00252                 FUNC_I2C_WRITE2CDMS(data_send,25);
00253                 printf("\n\rData sent to CDMS is %s\n\r",data_send);
00254                 
00255                 i2c_data_send.free(i2c_data_s);
00256                 i2c_status = 0;
00257             }
00258         }  
00259            
00260     }
00261 }
00262 
00263         
00264 
00265 void FUNC_I2C_INT()
00266 {
00267    
00268    t2.start();
00269   // t3.start();
00270    ptr_t_i2c->signal_set(0x4);
00271    
00272      
00273 }
00274 
00275 void FUNC_I2C_IR2CDMS()
00276 {
00277         data_ready=0; 
00278         //char data[25];
00279         strcpy(hk_data,"hk_Data");
00280         strcat(hk_data,SensorQuantised.Voltage);
00281         strcat(hk_data,SensorQuantised.Current); 
00282         strcat(hk_data,SensorQuantised.Temperature); 
00283         strcat(hk_data,SensorQuantised.PanelTemperature);
00284         strcat(hk_data,SensorQuantised.AngularSpeed);
00285         strcat(hk_data,SensorQuantised.Bnewvalue);
00286         char fdata[5] = {SensorQuantised.BatteryTemperature,SensorQuantised.faultpoll,SensorQuantised.faultir,SensorQuantised.power_mode};
00287 
00288         /*strcat(hk_data,sfaultpoll);
00289         strcat(hk_data,sfaultir);
00290         strcat(hk_data,spower_mode);*/
00291         strcat(hk_data,fdata);
00292         printf("\n\r hk data being sent %s ",hk_data);
00293         //for(int i=0;i<100000000000;i++)
00294         //;
00295             
00296         /*for(int d=0;d<23;d++)                          //was written just to check hk data
00297         {
00298             if(hk_data[d]>10)
00299             printf("\n\rhk data : %d\n\r",hk_data[d]);
00300         }   */ 
00301        
00302         //data = pcslave.getc();
00303         
00304         i2c_status=1;
00305         i2c_data * i2c_data_s = i2c_data_send.alloc();
00306         strcpy(i2c_data_s->data,hk_data);
00307         i2c_data_s->length = 25;
00308         i2c_data_send.put(i2c_data_s); 
00309         data_ready=1;
00310         //temp = i2c_status;
00311 }
00312     
00313 
00314 //------------------------------------------------------------------------------------------------------------------------------------------------
00315 //TELECOMMAND
00316 //------------------------------------------------------------------------------------------------------------------------------------------------
00317 void FUNC_I2C_TC_EXECUTE (char command)  
00318 { switch(command)
00319    {   case '0' : printf("command 0 executed");
00320        break;
00321        case '1' : printf("command 1 executed");
00322        break;
00323        case '2' : printf("command 2 executed");
00324        break;
00325        case '3' : printf("command 3 executed");
00326     }
00327 }  
00328    
00329 
00330 //------------------------------------------------------------------------------------------------------------------------------------------------
00331 //SCHEDULER
00332 //------------------------------------------------------------------------------------------------------------------------------------------------
00333 int beacon_sc = 3;
00334 uint16_t schedcount=1;
00335 void T_SC(void const *args)
00336 {
00337     //DRDY=0;
00338     printf("The value of i in scheduler is %d\n\r",schedcount);
00339     if(schedcount == 65532)                         //to reset the counter
00340     {
00341         schedcount = 0;
00342     }
00343     
00344     if(schedcount%1==0)
00345     {
00346      ptr_t_acs -> signal_set(0x1);
00347      //ptr_t_wdt -> signal_set(0x5);
00348     }
00349     if(schedcount%2==0)
00350     {
00351        // ptr_t_fault -> signal_set(0x2);
00352        //ptr_t_hk_acq -> signal_set(0x2);
00353         
00354     }
00355     if(schedcount%beacon_sc==0)
00356     {
00357         if(beac_flag==0)
00358         {
00359             
00360           //ptr_t_bea -> signal_set(0x3);
00361         }
00362     }
00363     schedcount++;
00364 }
00365     
00366 //---------------------------------------------------------------------------------------------------------------------------------------------
00367 
00368 int main()
00369 {
00370     t1.start();
00371     printf("\n\rIITMSAT BAE Activated \n");
00372     INIT_PNI();                                       // Initializing mnm blue
00373     FUNC_ACS_MAG_INIT();                              // Initializing magnetometer
00374     //FUNC_ACS_INIT_GYR();                              // Initializing Gyroscope
00375     slave.address(0x20);                              // setting slave address for BAE for I2C communication
00376 
00377     ptr_t_hk_acq = new Thread(T_HK_ACQ);
00378     ptr_t_acs = new Thread(T_ACS);                    
00379     ptr_t_bea = new Thread(T_BEA);
00380     ptr_t_i2c = new Thread(T_I2C_BAE);
00381     //ptr_t_sc = new Thread(T_SC);
00382     ptr_t_wdt = new Thread(T_WDT);
00383   
00384     interrupt_fault();                      // Dummy function called when a fault interrupt is detected
00385     
00386     ptr_t_acs->set_priority(osPriorityAboveNormal);
00387     ptr_t_i2c->set_priority(osPriorityHigh);
00388     ptr_t_hk_acq->set_priority(osPriorityAboveNormal);
00389     ptr_t_bea->set_priority(osPriorityAboveNormal);
00390     //ptr_t_sc->set_priority(osPriorityAboveNormal);
00391     ptr_t_wdt -> set_priority(osPriorityIdle);
00392     
00393   
00394    // ----------------------------------------------------------------------------------------------
00395     printf("\n\r T_ACS priority is %d",ptr_t_acs->get_priority());
00396     printf("\n\r T_HK_ACQ priority is %d",ptr_t_hk_acq->get_priority());
00397     printf("\n\r T_BEA priority is %d",ptr_t_bea->get_priority());  
00398     RtosTimer t_sc_timer(T_SC,osTimerPeriodic);
00399     t_sc_timer.start(10000);
00400     printf("\n\r%f\n\r",t1.read()); 
00401      
00402    // interrupt.rise(&FUNC_I2C_INT);                             //interrupt received from CDMS
00403     while(1)                                                   //required to prevent main from terminating
00404     {   
00405         Thread::wait(5000);
00406     }
00407     
00408 }