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