bae integrated final (may be)

Dependencies:   mbed-rtos mbed

Fork of BAE_FRDMTESIN2 by Seeker of Truth ,

Embed: (wiki syntax)

« Back to documentation index

Show/hide line numbers slave.cpp Source File

slave.cpp

00001 /*******************Below is an old version**********************************************************************************************/
00002 /* Added fault to hk structure and being sent through I2C. Need to verify the format */
00003 /*#include "slave.h"
00004 #include "HK.h"
00005  
00006 extern struct SensorData Sensor;
00007 I2CSlave slave(PTC9,PTC8);                       //configuring pins p27, p28 as I2Cslave
00008 Serial screen (USBTX,USBRX);
00009 void write_to_master(char send)                           //function to write data to master
00010         {
00011            int acknowledge; 
00012            int loopvariable4=1;
00013            while(loopvariable4)
00014            {
00015            acknowledge = slave.write(send);    //sending the byte to master
00016            if(acknowledge==1)
00017             {
00018               screen.printf(" acknowledge %d sent %u \n",acknowledge,send);
00019               loopvariable4=0;
00020             }
00021            } 
00022         }
00023         
00024  
00025  
00026  
00027 void FUNC_I2C_SLAVE_MAIN(int iterations)
00028 {
00029     
00030     screen.printf("\nSlave entered\n");
00031     slave.address(slave_address);                           //assigning slave address
00032     slave.stop();
00033     char Switch_Variable;
00034     
00035     
00036     int loopvariable1=1;
00037     int loopvariable2=0;
00038     int loopvariable3=1;
00039 //initialising dummy sensor data                         
00040     
00041     while(loopvariable1)
00042     { 
00043 //to read data from master       
00044     if(slave.receive()==WriteGeneral)                   //checking if slave is addressed to write
00045     {
00046       slave.stop();
00047       Switch_Variable=slave.read();                   //receiving data
00048       screen.printf("switch variable=%d\n",Switch_Variable);
00049       slave.stop();                          //reset slave to default receiving state
00050       loopvariable1=0;
00051 //to interpret and write data to master       
00052       switch(Switch_Variable)
00053       {
00054 
00055        
00056        case 1:   printf("\nEntered switch\n"); 
00057                    while(loopvariable3)
00058                   {
00059                      if(slave.receive()==ReadAddressed)             //check if slave is addressed to read 
00060                    {
00061                       while(loopvariable2<iterations)
00062                      {
00063                       if(loopvariable2%3==0)
00064                           {
00065                           screen.printf("\nvoltage%d\n",loopvariable2/3);
00066                           write_to_master(Sensor.Voltage[loopvariable2/3]);
00067                           }
00068                       else if(loopvariable2%3==1)
00069                           {   
00070                           screen.printf("\ncurrent%d\n",loopvariable2/3);
00071                           write_to_master(Sensor.Current[loopvariable2/3]);
00072                           }
00073                       else if(loopvariable2%3==2)
00074                           {   
00075                           screen.printf("\ntemp%d\n",loopvariable2/3);
00076                           write_to_master(Sensor.Temperature[loopvariable2/3]);
00077                           }         
00078                       loopvariable2++;
00079                        }
00080                        screen.printf("\nfault %c\n",Sensor.faultpoll);
00081                        write_to_master(Sensor.faultpoll);
00082                        screen.printf("\nfault %c\n",Sensor.faultir);
00083                        write_to_master(Sensor.faultir);
00084                        screen.printf("\npower mode %c\n",Sensor.power_mode);
00085                        write_to_master(Sensor.power_mode);
00086                        printf("\nExited i2c while loop\n");
00087                       slave.stop();    
00088                       loopvariable3=0;  
00089                     }//if(read addressed)
00090                     
00091                     }//while(loopvariable3)
00092                   
00093                   break;
00094          case 2 : screen.printf(" telecommand 2\n");
00095                   break;         
00096                  
00097         }//switch case ends
00098    }   
00099 }
00100    screen.printf("\nexited slave function\n");
00101 }
00102 */
00103 
00104 //******************The following is a new version********************************************************************************/
00105 #include "HK.h"
00106 #include "slave.h"
00107 
00108 
00109 
00110 I2CSlave slave(D14,D15);                       //configuring pins p27, p28 as I2Cslave
00111 Serial pc_slave (USBTX,USBRX);
00112 //InterruptIn interrupt(D9);                    //This should be in the main
00113 //DigitalOut data_ready(D10);                     //Again in the main function
00114 //int i2c_status=0;                                 //read/write mode for i2c 0 : write2slave, 1 : write2master (Again in tha main)
00115 
00116 typedef struct
00117 {
00118     char data;          // To avoid dynamic memory allocation
00119     int length;
00120 }i2c_data;
00121 
00122 //Mail<i2c_data,16> i2c_data_receive;           To be done in the main
00123 //Mail<i2c_data,16> i2c_data_send;              To be done in the main
00124 
00125 void FUNC_I2C_WRITE2CDMS(char *data, int length=1)
00126 {
00127        
00128     int slave_status = 1;
00129     while(slave_status)
00130     {                 
00131             slave.address(0x20);
00132             if(slave.receive()==1)
00133             {
00134                 slave_status=slave.write(data,length);
00135                // printf("\n In the while loop\n");
00136                 
00137                 /*if(!slave_status)
00138                 {
00139                         printf("slave wrote %c to master\n\r",*data);
00140               
00141                 }*/
00142                 
00143             }
00144             else
00145                 if(slave.receive()==3 || slave.receive()==2)
00146                 {
00147                      //i2c_data *i2c_data_r = i2c_data_receive.alloc();
00148                      slave_status=slave.read(data,length);
00149                      /*if(!slave_status)
00150                      {
00151                          printf("1 read %c from master\n\r",*data);
00152                      }*/
00153                 }
00154             //slave.stop();
00155     }
00156             printf("2 done");
00157 
00158 }
00159 
00160 /*void T_I2C_BAE(void const * args)
00161 {
00162     char data_send,data_receive;
00163     //data_send = 'a';
00164     while(1)
00165     {
00166         Thread::signal_wait(0x1);
00167         printf("\ndetected interrupt\n");
00168         if(i2c_status == 0)
00169         {
00170             
00171             FUNC_I2C_WRITE2CDMS(&data_receive);
00172             //printf("\n Data received from CDMS is %c\n",data_receive);
00173             i2c_data * i2c_data_r = i2c_data_receive.alloc();
00174             i2c_data_r->data = data_receive;
00175             i2c_data_r->length = 1;
00176             i2c_data_receive.put(i2c_data_r);
00177         }
00178         else if(i2c_status ==1 )
00179         {
00180             osEvent evt = i2c_data_send.get();
00181             if (evt.status == osEventMail) 
00182             {
00183                 i2c_data *i2c_data_s = (i2c_data*)evt.value.p;
00184                 //printf("\nData read from CDMS is %c\n",i2c_data_r->data);
00185                 data_send = i2c_data_s -> data;
00186                 FUNC_I2C_WRITE2CDMS(&data_send);
00187                 printf("\nData sent to CDMS is %c\n",data_send);
00188                 i2c_data_send.free(i2c_data_s);
00189                 i2c_status = 0;
00190                 //delete i2c_data_r;
00191             }
00192         }   
00193     }
00194 }
00195         
00196 void FUNC_INT()
00197 {
00198   // char * data = new char;
00199    //*data = 'a';
00200    //printf("\nInterrupt from master detected\n");
00201    ptr_t_i2c->signal_set(0x1);
00202   // 
00203    //delete data;
00204 }
00205    
00206 
00207 
00208 void main()
00209 {
00210     printf("\nStarted slave... waiting for master\n");
00211     ptr_t_i2c = new Thread(T_I2C_BAE);
00212     char data='a';
00213     interrupt.rise(&FUNC_INT);
00214     
00215    /* i2c_data * i2c_data_s = i2c_data_send.alloc();
00216     i2c_data_s->data = data;
00217     i2c_data_s->length = 1;
00218     i2c_data_send.put(i2c_data_s);
00219     //data_ready=1;
00220     i2c_status=1;*/
00221    // while(1)
00222     //{
00223         //*(data_send)=pc.getc();
00224         
00225         //FUNC_I2C_WRITE2CDMS(&data,1);
00226         //printf("\n The data send or received by slave is %c\n",data);
00227         //(data)++;
00228         //wait(1);
00229         //Remove the comments for receiving data
00230         /* osEvent evt = i2c_data_receive.get();
00231          if (evt.status == osEventMail) 
00232          {
00233             i2c_data *i2c_data_r = (i2c_data*)evt.value.p;
00234             printf("\nData read from CDMS is %c\n",i2c_data_r->data);
00235             
00236             i2c_data_receive.free(i2c_data_r);
00237             //delete i2c_data_r;
00238         }*/
00239 /*        //put in comments for receiving data
00240         data_ready=0;
00241         data = pc.getc();
00242         i2c_data * i2c_data_s = i2c_data_send.alloc();
00243         i2c_data_s->data = data;
00244         i2c_data_s->length = 1;
00245         i2c_data_send.put(i2c_data_s);
00246         data_ready=1;
00247         i2c_status=1;
00248                 
00249     }
00250 }
00251 */
00252 
00253 //To be done in the main