File content as of revision 9:a9de938283f9:

#include "mbed.h"
#include "rtos.h"
#include "HK.h"
#include "slave.h"
#include "beacon.h"
#include "ACS.h"
#include "fault.h"
#include "pin_config.h"

#define DEFAULT_POW_MODE 0                                  //power mode initialization
Serial pc(USBTX, USBRX);

InterruptIn interrupt (PIN95);
InterruptIn master_reset(PIN99);
int reset =0;
int i2c_status=0;                                 //read/write mode for i2c 0 : write2slave, 1 : write2master
char data_send[40],data_receive;

Timer t;                                                        //To know the time of execution each thread
Timer t1;
                                                       //To know the time of entering  of each thread

Thread *ptr_t_hk;                                       //every 20 seconds
Thread *ptr_t_acs;                                      //every 10 seconds
//Thread *ptr_t_acs_write2flash;
Thread *ptr_t_bea;                                      //every 30 seconds
//Thread *ptr_t_bea_telecommand;
//Thread *ptr_t_fault;                                  //will be taken care by HK thread and interrupts
Thread *ptr_t_i2c;                                      //for interprocessor communication
Thread *ptr_t_exec_tc;                                  //Taking data from i2c mail box and execute the stuffread
Thread *ptr_t_wdt;                                      //Thread ofr watchdog implementation





//--------------------------------------------------------------------------------------------------------------------------------------------------
//TASK 2 : HK
//--------------------------------------------------------------------------------------------------------------------------------------------------

//char hk_data[100];
extern SensorData Sensor;
typedef struct{
char data[40];
}i2c_hk_data;
DigitalOut data_ready(D10);      //PIN NAME TO BE CHANGED

Mail<i2c_hk_data,16> i2c_hk_send;

    
void t_hk(void const *args)
{
    Sensor.power_mode = DEFAULT_POW_MODE;
    while(1)
    {
        Thread::signal_wait(0x2);
        
        printf("\nTHIS IS HK    %f\n",t1.read());
        //t.start();
        FAULTS();
        POWER(Sensor.power_mode);
        FUNC_HK_MAIN();
        reset =0;
        i2c_status = 1;
        data_ready = 0;
        char hk_data[40]={Sensor.Voltage[10],Sensor.Current[10],Sensor.Temperature[10],Sensor.PanelTemperature[2],Sensor.Vcell,Sensor.soc,Sensor.alerts,Sensor.crate,Sensor.faultpoll,Sensor.faultir,Sensor.power_mode};
        i2c_hk_data * i2c_hk_data_s = i2c_hk_send.alloc();
        strcpy(i2c_hk_data_s->data,hk_data);
        i2c_hk_send.put(i2c_hk_data_s);
        data_ready = 1;
        
                                                                   //Collecting HK data
        //thread_2.signal_set(0x4);
       // FUNC_I2C_SLAVE_MAIN(24);                                                    //Put HK data to I2C thread instead
        
       // t.stop();
        //printf("The time to execute hk_acq is %f seconds\n",t.read());
        //t.reset();
    }
}

//---------------------------------------------------------------------------------------------------------------------------------------
//TASK 1 : ACS
//---------------------------------------------------------------------------------------------------------------------------------------
/*typedef struct {
    float mag_field;
    float omega;
    } sensor_data;
  */  
//Mail <sensor_data, 16> q_acs;                     //Will be taken care of by HK structure every 20 seconds
    
/*void func_acs_readdata(sensor_data *ptr)
{
    printf("Reading the data\n");
    ptr -> mag_field = 10;
    ptr -> omega = 3;
}

void func_acs_ctrlalgo()
{
    printf("Executing control algo\n");
}



void func_acs_write2flash(sensor_data *ptr2)
{
    printf("The magnetic field is %.2f T\n\r",ptr2->mag_field);
    printf("The angular velocity is %.2f rad/s\n\r",ptr2->omega);
}*/

int acs_pflag = 1;                                              //for executing acs power modes
void t_acs(void const *args)
{
    float *mag_field;
    float *omega;
    float *moment;
    while(1)
    {
        Thread::signal_wait(0x1);
        printf("\nTHIS IS ACS   %f\n",t1.read());
   //     t.start();
   //     sensor_data *ptr = q_acs.alloc();                     //done by HK instead
        
        //func_acs_readda=ta(ptr);
        mag_field= FUNC_ACS_MAG_EXEC();                              //actual execution
        omega = FUNC_ACS_EXEC_GYR();
        
        
        //q_acs.put(ptr);                                       //done by HK
        if(acs_pflag == 1)                                            //for the respective power mode
        {
        moment = FUNC_ACS_CNTRLALGO(mag_field,omega);
        FUNC_ACS_GENPWM(moment);                                      //Generating PWM signal.
        }
       
        //t.reset();
    }
}

/*void t_acs_write2flash(void const *args)                              //unwanted thread
{
    while(1)
    {
        //printf("Writing in the flash\n");
        osEvent evt = q_acs.get();
        if(evt.status == osEventMail)
        {
            sensor_data *ptr = (sensor_data*)evt.value.p;
            func_acs_write2flash(ptr);
            q_acs.free(ptr);
        }
        printf("Writing acs data in the flash\n");
    }
}*/


//---------------------------------------------------BEACON--------------------------------------------------------------------------------------------

int beac_flag=0;                                                            //To receive telecommand from ground.


/*void t_bea_telecommand(void const *args)                                  //taken care of by t_exec_tc
{
    char c = pc.getc();
    if(c=='a')
    {
        printf("Telecommand detected\n");
        beac_flag=1;
    }
}
*/
void t_bea(void const *args)
{
    
    while(1)
    {
        Thread::signal_wait(0x3);
        printf("\nTHIS IS BEACON    %f\n",t1.read());
        //t.start();
        
        
            
        FUNC_BEA();
            
        
        /*if(beac_flag==1)                          //beacon standby can be doe to 
        {
            Thread::wait(600000);
            beac_flag = 0;
        }*/
        
        //printf("The time to execute beacon thread is %f seconds\n",t.read());
        //t.reset();
    }
}

//---------------------------------------------------------------------------------------------------------------------------------------------------
//TASK 4 : FAULT MANAGEMENT
//---------------------------------------------------------------------------------------------------------------------------------------------------
//Dummy fault rectifier functions

/*Mail<int,16> faults;

void FUNC_FAULT_FUNCT1()
{
    printf("\nFault 1 detected... \n");
}

void FUNC_FAULT_FUNCT2()
{
    printf("\nFault 2 detected...\n");
}

void T_FAULT(void const *args)
{
    while(1)
    {
        osEvent evt = faults.get();
        if(evt.status==osEventMail)
        {
            int *fault_id= (int *)evt.value.p;
            switch(*fault_id)
            {
                case 1: FUNC_FAULT_FUNCT1();
                        break;
                case 2: FUNC_FAULT_FUNCT2();
                        break;
            }
            faults.free(fault_id);
        }
    }
}*/



/*
void T_FAULT(void const *args)
{   
    Sensor.power_mode='0';
    while(1)
    {
        Thread :: signal_wait(0x2);
        FAULTS();
        POWER(Sensor.power_mode);
        //Sensor.power_mode++;            //testing ... should be removed
    }    
}
/*-------------------------------------------------------------------------------------------------------------------------------------------
-------------------------------------------------------WATCHDOG----------------------------------------------------------------------------*/
DigitalOut trigger(PIN63);                                             // has to be changed
void T_WDT(void const * args)
{
    trigger = 1;
    while(true)
    {
        Thread::signal_wait(0x5);                               //signal set from scheduler or sthing. r RTOS timer nce the timing is finalized
        printf("\nEntered WD\n");
        trigger = !trigger;
    }
}
//------------------------------------------------------------------------------------------------------------------------------------------------
//SLAVE
//------------------------------------------------------------------------------------------------------------------------------------------------
typedef struct
{
    char data;          // To avoid dynamic memory allocation
}i2c_data;
Mail<i2c_data,16> i2c_data_receive;                  //to be uncommented when receiving data


void FUNC_INT()
{
   reset = 0;
   ptr_t_i2c->signal_set(0x4);  
}

void FUNC_RESET()
{
   reset = 1;
}


void T_I2C_BAE(void const * args)
{
    //char data_send,data_receive;
    while(1)
    {
        Thread::signal_wait(0x4);
        printf("\n entered thread\n\r");
        if(i2c_status == 0 && reset !=1)
        {
            
            FUNC_I2C_WRITE2CDMS(&data_receive,1);
            i2c_data * i2c_data_r = i2c_data_receive.alloc();
            i2c_data_r->data = data_receive;
            
            i2c_data_receive.put(i2c_data_r);
            printf("\n Data received from CDMS is %c\n\r",data_receive);
            i2c_data_receive.free(i2c_data_r);                              // This has to be done from a differen thread
            
        }
        else if(i2c_status ==1 && reset !=1)
        {
            osEvent evt = i2c_hk_send.get();
            if (evt.status == osEventMail) 
            {
                i2c_hk_data *i2c_hk_data_s = (i2c_hk_data*)evt.value.p;
                strcpy(data_send,i2c_hk_data_s -> data);
                FUNC_I2C_WRITE2CDMS(data_send,40);
                printf("\nData sent to CDMS is %s\n\r",data_send);
                i2c_hk_send.free(i2c_hk_data_s);                           //This has to be done in a different thread
                i2c_status = 0;
                //temp = i2c_status;
            }
        } 
         
    }
}


//------------------------------------------------------------------------------------------------------------------------------------------------
//SCHEDULER
//------------------------------------------------------------------------------------------------------------------------------------------------
int beacon_sc = 3;
uint16_t schedcount=1;
void t_sc(void const *args)
{
    
    printf("The value of i in scheduler is %d\n",schedcount);
    if(schedcount == 65532)                         //to reset the counter
    {
        schedcount = 0;
    }
    
    if(schedcount%1==0)
    {
        ptr_t_acs -> signal_set(0x1);
    }
    if(schedcount%2==0)
    {
       // ptr_t_fault -> signal_set(0x2);
        ptr_t_hk -> signal_set(0x2);
        
    }
    if(schedcount%beacon_sc==0)
    {
        if(beac_flag==0)
        {
            
            ptr_t_bea -> signal_set(0x3);
        }
    }
    schedcount++;
}
    
//---------------------------------------------------------------------------------------------------------------------------------------------

int main()
{
    t1.start();
    
    ptr_t_hk = new Thread(t_hk);
    ptr_t_acs = new Thread(t_acs);
    
    ptr_t_bea = new Thread(t_bea);
    ptr_t_wdt = new Thread(T_WDT);
    ptr_t_i2c = new Thread(T_I2C_BAE);

   // ptr_t_fault -> set_priority(osPriorityRealtime);
    ptr_t_acs->set_priority(osPriorityHigh);
    ptr_t_hk->set_priority(osPriorityNormal);
    //ptr_t_acs_write2flash->set_priority(osPriorityBelowNormal);
    ptr_t_bea->set_priority(osPriorityAboveNormal);
    ptr_t_i2c->set_priority(osPriorityAboveNormal);
    //ptr_t_bea_telecommand->set_priority(osPriorityIdle);
    //ptr_t_sc->set_priority(osPriorityAboveNormal);
    ptr_t_wdt -> set_priority(osPriorityIdle);
    
  
   // ----------------------------------------------------------------------------------------------
    //printf("\n T_FAULT priority is %d",ptr_t_fault->get_priority()); 
    printf("\n T_ACS priority is %d",ptr_t_acs->get_priority());
    printf("\n T_HK_ACQ priority is %d",ptr_t_hk->get_priority());
    //printf("\n T_ACS_WRITE2FLASH priority is %d",ptr_t_acs_write2flash->get_priority());
    printf("\n T_BEA priority is %d",ptr_t_bea->get_priority());  
    RtosTimer t_sc_timer(t_sc,osTimerPeriodic);
    t_sc_timer.start(10000);
    printf("\n%f\n",t1.read()); 
    
    interrupt.rise(&FUNC_INT);
    master_reset.fall(&FUNC_RESET);
        
    while(1)
    {   
        Thread::wait(10000);
        ;
    }
    
}