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