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 
00009 #define DEFAULT_POW_MODE 0                                  //power mode initialization
00010 Serial pc(USBTX, USBRX);
00011 
00012 
00013 
00014 Timer t;                                                        //To know the time of execution each thread
00015 Timer t1;
00016                                                        //To know the time of entering  of each thread
00017 
00018 Thread *ptr_t_hk;                                       //every 20 seconds
00019 Thread *ptr_t_acs;                                      //every 10 seconds
00020 //Thread *ptr_t_acs_write2flash;
00021 Thread *ptr_t_bea;                                      //every 30 seconds
00022 //Thread *ptr_t_bea_telecommand;
00023 //Thread *ptr_t_fault;                                  //will be taken care by HK thread and interrupts
00024 Thread *ptr_t_i2c;                                      //for interprocessor communication
00025 Thread *ptr_t_exec_tc;                                  //Taking data from i2c mail box and execute the stuff
00026 
00027 
00028 //--------------------------------------------------------------------------------------------------------------------------------------------------
00029 //TASK 2 : HK
00030 //--------------------------------------------------------------------------------------------------------------------------------------------------
00031 
00032 
00033 extern SensorData Sensor;
00034 void t_hk(void const *args)
00035 {
00036     Sensor.power_mode = DEFAULT_POW_MODE;
00037     while(1)
00038     {
00039         Thread::signal_wait(0x2);
00040         
00041         printf("\nTHIS IS HK    %f\n",t1.read());
00042         //t.start();
00043         FAULTS();
00044         POWER(Sensor.power_mode);
00045         FUNC_HK_MAIN();                                                             //Collecting HK data
00046         //thread_2.signal_set(0x4);
00047        // FUNC_I2C_SLAVE_MAIN(24);                                                    //Put HK data to I2C thread instead
00048         
00049        // t.stop();
00050         //printf("The time to execute hk_acq is %f seconds\n",t.read());
00051         //t.reset();
00052     }
00053 }
00054 
00055 //---------------------------------------------------------------------------------------------------------------------------------------
00056 //TASK 1 : ACS
00057 //---------------------------------------------------------------------------------------------------------------------------------------
00058 /*typedef struct {
00059     float mag_field;
00060     float omega;
00061     } sensor_data;
00062   */  
00063 //Mail <sensor_data, 16> q_acs;                     //Will be taken care of by HK structure every 20 seconds
00064     
00065 /*void func_acs_readdata(sensor_data *ptr)
00066 {
00067     printf("Reading the data\n");
00068     ptr -> mag_field = 10;
00069     ptr -> omega = 3;
00070 }
00071 
00072 void func_acs_ctrlalgo()
00073 {
00074     printf("Executing control algo\n");
00075 }
00076 
00077 
00078 
00079 void func_acs_write2flash(sensor_data *ptr2)
00080 {
00081     printf("The magnetic field is %.2f T\n\r",ptr2->mag_field);
00082     printf("The angular velocity is %.2f rad/s\n\r",ptr2->omega);
00083 }*/
00084 
00085 int acs_pflag = 1;                                              //for executing acs power modes
00086 void t_acs(void const *args)
00087 {
00088     float *mag_field;
00089     float *omega;
00090     float *moment;
00091     while(1)
00092     {
00093         Thread::signal_wait(0x1);
00094         printf("\nTHIS IS ACS   %f\n",t1.read());
00095    //     t.start();
00096    //     sensor_data *ptr = q_acs.alloc();                     //done by HK instead
00097         
00098         //func_acs_readda=ta(ptr);
00099         mag_field= FUNC_ACS_MAG_EXEC();                              //actual execution
00100         omega = FUNC_ACS_EXEC_GYR();
00101         
00102         
00103         //q_acs.put(ptr);                                       //done by HK
00104         if(acs_pflag == 1)                                            //for the respective power mode
00105         {
00106         moment = FUNC_ACS_CNTRLALGO(mag_field,omega);
00107         FUNC_ACS_GENPWM(moment);                                      //Generating PWM signal.
00108         }
00109        
00110         //t.reset();
00111     }
00112 }
00113 
00114 /*void t_acs_write2flash(void const *args)                              //unwanted thread
00115 {
00116     while(1)
00117     {
00118         //printf("Writing in the flash\n");
00119         osEvent evt = q_acs.get();
00120         if(evt.status == osEventMail)
00121         {
00122             sensor_data *ptr = (sensor_data*)evt.value.p;
00123             func_acs_write2flash(ptr);
00124             q_acs.free(ptr);
00125         }
00126         printf("Writing acs data in the flash\n");
00127     }
00128 }*/
00129 
00130 
00131 //---------------------------------------------------BEACON--------------------------------------------------------------------------------------------
00132 
00133 int beac_flag=0;                                                            //To receive telecommand from ground.
00134 
00135 
00136 /*void t_bea_telecommand(void const *args)                                  //taken care of by t_exec_tc
00137 {
00138     char c = pc.getc();
00139     if(c=='a')
00140     {
00141         printf("Telecommand detected\n");
00142         beac_flag=1;
00143     }
00144 }
00145 */
00146 void t_bea(void const *args)
00147 {
00148     
00149     while(1)
00150     {
00151         Thread::signal_wait(0x3);
00152         printf("\nTHIS IS BEACON    %f\n",t1.read());
00153         //t.start();
00154         
00155         
00156             
00157         FUNC_BEA();
00158             
00159         
00160         /*if(beac_flag==1)                          //beacon standby can be doe to 
00161         {
00162             Thread::wait(600000);
00163             beac_flag = 0;
00164         }*/
00165         
00166         //printf("The time to execute beacon thread is %f seconds\n",t.read());
00167         //t.reset();
00168     }
00169 }
00170 
00171 //---------------------------------------------------------------------------------------------------------------------------------------------------
00172 //TASK 4 : FAULT MANAGEMENT
00173 //---------------------------------------------------------------------------------------------------------------------------------------------------
00174 //Dummy fault rectifier functions
00175 
00176 /*Mail<int,16> faults;
00177 
00178 void FUNC_FAULT_FUNCT1()
00179 {
00180     printf("\nFault 1 detected... \n");
00181 }
00182 
00183 void FUNC_FAULT_FUNCT2()
00184 {
00185     printf("\nFault 2 detected...\n");
00186 }
00187 
00188 void T_FAULT(void const *args)
00189 {
00190     while(1)
00191     {
00192         osEvent evt = faults.get();
00193         if(evt.status==osEventMail)
00194         {
00195             int *fault_id= (int *)evt.value.p;
00196             switch(*fault_id)
00197             {
00198                 case 1: FUNC_FAULT_FUNCT1();
00199                         break;
00200                 case 2: FUNC_FAULT_FUNCT2();
00201                         break;
00202             }
00203             faults.free(fault_id);
00204         }
00205     }
00206 }*/
00207 
00208 
00209 
00210 /*
00211 void T_FAULT(void const *args)
00212 {   
00213     Sensor.power_mode='0';
00214     while(1)
00215     {
00216         Thread :: signal_wait(0x2);
00217         FAULTS();
00218         POWER(Sensor.power_mode);
00219         //Sensor.power_mode++;            //testing ... should be removed
00220     }    
00221 }
00222 */
00223 //------------------------------------------------------------------------------------------------------------------------------------------------
00224 //SCHEDULER
00225 //------------------------------------------------------------------------------------------------------------------------------------------------
00226 int beacon_sc = 3;
00227 uint16_t schedcount=1;
00228 void t_sc(void const *args)
00229 {
00230     
00231     printf("The value of i in scheduler is %d\n",schedcount);
00232     if(schedcount == 65532)                         //to reset the counter
00233     {
00234         schedcount = 0;
00235     }
00236     
00237     if(schedcount%1==0)
00238     {
00239         ptr_t_acs -> signal_set(0x1);
00240     }
00241     if(schedcount%2==0)
00242     {
00243        // ptr_t_fault -> signal_set(0x2);
00244         ptr_t_hk -> signal_set(0x2);
00245         
00246     }
00247     if(schedcount%beacon_sc==0)
00248     {
00249         if(beac_flag==0)
00250         {
00251             
00252             ptr_t_bea -> signal_set(0x3);
00253         }
00254     }
00255     schedcount++;
00256 }
00257     
00258 //---------------------------------------------------------------------------------------------------------------------------------------------
00259 
00260 int main()
00261 {
00262     t1.start();
00263     
00264     ptr_t_hk = new Thread(t_hk);
00265     ptr_t_acs = new Thread(t_acs);
00266     //ptr_t_acs_write2flash = new Thread(t_acs_write2flash);
00267     ptr_t_bea = new Thread(t_bea);
00268     //ptr_t_bea_telecommand = new Thread(t_bea_telecommand);
00269     //ptr_t_fault = new Thread(T_FAULT);
00270     //ptr_t_sc = new Thread(t_sc);
00271 
00272    // ptr_t_fault -> set_priority(osPriorityRealtime);
00273     ptr_t_acs->set_priority(osPriorityHigh);
00274     ptr_t_hk->set_priority(osPriorityNormal);
00275     //ptr_t_acs_write2flash->set_priority(osPriorityBelowNormal);
00276     ptr_t_bea->set_priority(osPriorityAboveNormal);
00277     //ptr_t_bea_telecommand->set_priority(osPriorityIdle);
00278     //ptr_t_sc->set_priority(osPriorityAboveNormal);
00279     
00280   
00281    // ----------------------------------------------------------------------------------------------
00282     //printf("\n T_FAULT priority is %d",ptr_t_fault->get_priority()); 
00283     printf("\n T_ACS priority is %d",ptr_t_acs->get_priority());
00284     printf("\n T_HK_ACQ priority is %d",ptr_t_hk->get_priority());
00285     //printf("\n T_ACS_WRITE2FLASH priority is %d",ptr_t_acs_write2flash->get_priority());
00286     printf("\n T_BEA priority is %d",ptr_t_bea->get_priority());  
00287     RtosTimer t_sc_timer(t_sc,osTimerPeriodic);
00288     t_sc_timer.start(10000);
00289     printf("\n%f\n",t1.read()); 
00290         
00291     while(1)
00292     {   
00293         Thread::wait(10000);
00294         ;
00295     }
00296     
00297 }