main.cpp

00001 // Librerie
00002 #include "mbed.h"
00003 #include <math.h>
00004 #include <string.h>
00005 #include <stdlib.h>
00006 #include <stdbool.h>
00007 
00008 // Macros
00009 #define config 2    // 0: spacecraft, 1: mima, 2: no diagnostic 
00010 #define PACKETDIM 15    // temperature
00011 #define word 1
00012 #define packet 2    // 2 bytes
00013 #define channel_size 10 // temeprature channel from sen30202
00014 #define CMD05_1 40
00015 #define CMD05_2 41
00016 #define TLMODE_HSK 0
00017 #define TLMODE_HSKSD 127
00018 #define CMD00 0
00019 #define CMD02 16
00020 #define TEMP_QUERY 32
00021 #define CMD15_R 121
00022 #define CMD15 120
00023 #define ALL_RELAY_OFF 42
00024 #define ALL_RELAY_ON 85
00025 #define ENABLE_12V 1
00026 #define DISABLE_12V 0
00027 #define ENABLE_5V 3
00028 #define DISABLE_5V 2
00029 #define ENABLE_15V 7
00030 #define DISABLE_15V 6
00031 #define ENABLE_24V 15
00032 #define DISABLE_24V 8
00033 #define CMD31 241
00034 #define RESET_GLOBAL_VARS 127
00035 
00036 // Definizione periferiche
00037 Serial spacecraft(PC_1, PC_0); 
00038 //Serial spacecraft(USBTX, USBRX); // se pc connesso direttamente all'stm32
00039 Serial mima(PC_4, PC_5);
00040 /* se si desidera utilizzare il pc come mima 
00041 Serial mima(PC_1, PC_0);   
00042 Serial spacecraft(PC_4, PC_5);
00043 */
00044 Serial max31865(PA_0, PA_1);
00045 // L16 Actuonix: 
00046 AnalogOut actuonix(PA_4);
00047 PwmOut actuonix_dig(PB_3);
00048 float offset;
00049 float offset_dig;
00050 // Relay
00051 DigitalOut Relay5V(PA_7);
00052 DigitalOut Relay12V(PB_4);
00053 DigitalOut Relay24V(PB_5);
00054 DigitalOut Relay15_15_5V(PB_10);
00055 
00056 // Buffer: telecommand
00057 volatile int rxTlcPtr;  
00058 int rxTlcDataCounter = 0;
00059 char rx_TLC[word+1];  
00060 char data_TLC[word+1];    
00061 
00062 // Buffer: standard telemetry (1 frame da 16 bit o 2 frame da 16 bit ciascuno)
00063 volatile int rxTlmPtr;
00064 int rxTlmDataCounter = 0;
00065 char rx_TLM[word+1]; 
00066 char data_TLM[word+1];  
00067 
00068 // Buffer: TLMODE telemetry option 1 (tutte le housekeeping telemetries)
00069 volatile int rxTlmOpt1Ptr;
00070 int rxTlmOpt1DataCounter = 0;
00071 char rx_TLMOpt1[word+1];
00072 char data_TLMOpt1[word+1];
00073 
00074 // Buffer: TLMODE telemetry option 2 (housekeeping + data dall'interferometro)
00075 volatile int rxTlmOpt2Ptr;
00076 int rxTlmOpt2DataCounter = 0;
00077 char rx_TLMOpt2[word+1];
00078 char data_TLMOpt2[word+1];
00079 
00080 // Timer: 3 contatori differenti a seconda del numero di bytes da ricevere
00081 Timer timer; 
00082 Timer rx;
00083 Timer rx_wide;
00084 float rxWindow = 6 /*seconds, TBA */, rxTimeStart, rxTimeStop, rxTimeRead; // standard teleemtry + hsk
00085 float rx_wideWindow = 300 /*seconds, TBA */, rx_wideTimeStart, rx_wideTimeStop, rx_wideTimeRead; // full hsk+scientific data
00086 float TIMEOUT = 3 /*seconds */, tTimeStart, tTimeStop, tTimeRead; // telecommand
00087 
00088 // TLMODE: definizione dei vari flag, assegnazioni di variabili 
00089 volatile int tlmode_option_1, tlmode_option_2, tlmode_tlm;
00090 volatile char payload;
00091 volatile bool TlcSend;
00092 volatile bool Spare;
00093 volatile char dataIn;
00094 
00095 // SC-MIMA communication: TX/RX
00096 void RxTelecommand(void);
00097 void TxTelecommand(void);
00098 void RxTelemetry(void);
00099 void TxTelemetry(void);
00100 // System utility
00101 void clearBuffer(char *arr, int arrLen);
00102 
00103 // Richiesta temperatura
00104 char tempCH1[channel_size];
00105 char tempCH2[channel_size];
00106 volatile int j; // first channel index
00107 volatile int t; // second channel index
00108 volatile char caRxPacket[PACKETDIM]; // temperature buffer
00109 volatile char nRxCharCount; // temperature char counter
00110 
00111 // Routines dedicate alla ricezione di dati della temperatura (Pt100)
00112 void SerialeRxInterrupt(void)
00113 {
00114     char cReadChar;
00115     while ((max31865.readable()))
00116     {
00117         cReadChar = max31865.getc();
00118         nRxCharCount++;
00119         caRxPacket[nRxCharCount] = cReadChar;
00120     }
00121 
00122     if (nRxCharCount == PACKETDIM)  
00123     {
00124         nRxCharCount = 0;
00125     }
00126 }
00127 
00128 // Main
00129 int main()
00130 {
00131     // config 0: il mio pc come spacecraft
00132     // config 1: il mio pc come mima
00133 
00134     // Baudrate
00135     spacecraft.baud(9600);
00136     mima.baud(9600);
00137     max31865.baud(115200);
00138 
00139     // Diagnostica
00140     if (config == 0)
00141     {
00142         spacecraft.printf(" Avvio Spacecraft... \n\r");
00143     }
00144     else if (config == 1)
00145     {
00146         mima.printf(" Avvio MIMA... \n\r");
00147     }
00148 
00149     // Setup per temperatura
00150     int nIndex;
00151     nRxCharCount = 0;
00152     for (nIndex = 0; nIndex < PACKETDIM; nIndex++)
00153     {
00154         caRxPacket[nIndex] = 0;
00155     }
00156 
00157     // Setup per Actuonix L16->PWM    
00158     actuonix_dig.period_us(1000);
00159     offset_dig = actuonix_dig.read();
00160     offset = actuonix.read();
00161 
00162     // Setup per Relay: 1 = OFF (1->OFF, 0->ON)
00163     Relay5V = 1;
00164     Relay12V = 1;
00165     Relay15_15_5V = 1;
00166     Relay24V = 1;
00167 
00168     // Bool flags 
00169     TlcSend = false;
00170 
00171     // Interrupts
00172     max31865.attach(&SerialeRxInterrupt, Serial::RxIrq);
00173     spacecraft.attach(&RxTelecommand, Serial::RxIrq);
00174     mima.attach(&RxTelemetry, Serial::RxIrq);
00175 
00176     // Diagnostica
00177     if (config == 0)
00178     {
00179         spacecraft.printf(" ... Ready to send... \n\r");
00180     }
00181     else if (config == 1)
00182     {
00183         mima.printf(" ... Ready to send... \n\r");
00184     }
00185     
00186     // Main loop
00187     while (true)
00188     {
00189         // Inizializza contatore caratteri in arrivo e flag di ricezione comando Spare
00190         rxTlcPtr = 0;
00191         Spare = false;
00192 
00193         // Setup per RX (uno dei flag verrà attivato solo via invio di un telecomando)
00194         // se tutti i flag sono su "1", dora non trasmetterà nulla verso spacecraft
00195         tlmode_option_1 = 1;
00196         tlmode_option_2 = 1;
00197         tlmode_tlm = 1;
00198 
00199         // Timer
00200         timer.start();
00201         tTimeStart = timer.read();
00202         tTimeRead = tTimeStart;
00203 
00204         // Finché non raggiungo la dimensione richiesta (16 bit, 2 byte),
00205         // resto in attesa di dati da spacecraft, all'interno della finestra di ricezione
00206         while ((rxTlcPtr < packet) && ((tTimeRead - tTimeStart) < TIMEOUT))
00207         {
00208             tTimeRead = timer.read();
00209         }
00210 
00211         timer.stop();
00212 
00213         // Se ho ricevuto 2 byte nella finestra di ricezione, preparo un array di data
00214         // per ricomporre il frame da 16 bit e inviarlo a mima tramite dora
00215         if ((rxTlcPtr == packet) && ((tTimeRead - tTimeStart) < TIMEOUT))
00216         {
00217             __disable_irq();
00218             memcpy(data_TLC, rx_TLC, rxTlcPtr);
00219             rxTlcDataCounter = rxTlcPtr;
00220 
00221             // Legge il contenuto del payload ignorando il LSB
00222             payload = data_TLC[1] >> 1;
00223 
00224             // Diagnostica
00225             if (config == 0)
00226             {
00227                 spacecraft.printf("\n\r .... Telecomando ricevuto su DORA! \n\r");
00228             }
00229             else if (config == 1)
00230             {
00231                 mima.printf("\n\r .... Telecomando ricevuto su DORA! \n\r");
00232             }
00233             
00234             // Visualizza i byte inviati
00235             for (int i = 0; i < sizeof(data_TLC) / sizeof(char); i++)
00236             {
00237                 if (config == 0)
00238                 {
00239                     spacecraft.printf("> Carattere: %i \n\r", (int) data_TLC[i]);
00240                 }
00241                 else if (config == 1)
00242                 {
00243                     mima.printf("> Carattere: %i \n\r", (int) data_TLC[i]);
00244                 }
00245             }
00246 
00247             // add a null just in case the received data didn't have one at the end
00248             data_TLC[rxTlcDataCounter] = 0;
00249 
00250             // hw control: set-point init
00251             offset = actuonix.read(); // legge il valore attuale dell'attuatore
00252             offset_dig = actuonix_dig.read();
00253 
00254             // RX settings
00255             // Si prepara alla ricezione di telemetrie standard in caso di invio di telecomandi
00256             // differenti dal CMD05 (TLMODE)
00257             if (((int) data_TLC[0] != CMD05_1) || ((int) data_TLC[0] != CMD05_2))
00258             {
00259                 tlmode_option_1 = 1;
00260                 tlmode_option_2 = 1;
00261                 tlmode_tlm = 0;
00262             }
00263 
00264             // Controllo dell'attuatore lineare L16 (comando Spare)
00265             if ((int) data_TLC[0] == CMD00)
00266             {
00267                 offset = (int) payload;
00268                 offset = offset / 100;
00269                 
00270                 offset_dig = (int) payload;
00271                 offset_dig = offset_dig / 100;
00272                 
00273                 actuonix_dig.write(offset_dig);
00274                 actuonix.write(offset);
00275 
00276                 Spare = true;
00277             }
00278 
00279             // Richiesta delle temperature. Data: SXXX.XX;YYY.YYP > START/CH1;CH2/END
00280             // Controllo del flusso di dati proveniente dalla Seriale
00281             else if (((int) data_TLC[0] == CMD02) && ((int) payload == TEMP_QUERY))
00282             {
00283                 // Cleaning buffers
00284                 clearBuffer(tempCH1, sizeof(tempCH1) / sizeof(char));
00285                 clearBuffer(tempCH2, sizeof(tempCH2) / sizeof(char));
00286 
00287                 // Index setup
00288                 nRxCharCount = 0;
00289                 int y = 0, u = 0;
00290                 t = 0; j = 0; // global
00291 
00292                 for (int i = 0; i < PACKETDIM; i++)
00293                 {
00294                     if (caRxPacket[i] == 'S')
00295                     {
00296                         // Indice sul quale cade la prima cifra del canale 1
00297                         j = i + 1;
00298 
00299                         while (j < PACKETDIM)
00300                         {
00301                             if (caRxPacket[j] == ';')
00302                             {
00303                                 break;
00304                             }
00305                             else
00306                             {
00307                                 tempCH1[y++] = caRxPacket[j];
00308                             }
00309 
00310                             j++;
00311                         }
00312 
00313                         // Indice sul quale cade la prima cifra del canale 2
00314                         t = j + 1;
00315 
00316                         while (t < PACKETDIM)
00317                         {
00318                             if (caRxPacket[t] == 'P')
00319                             {
00320                                 break;
00321                             }
00322                             else
00323                             {
00324                                 tempCH2[u++] = caRxPacket[t];
00325                             }
00326 
00327                             t++;
00328                         }
00329 
00330                         break;
00331                     }
00332                 }
00333 
00334                 // Invia i dati a Spacecraft
00335                 spacecraft.puts(tempCH1);
00336                 spacecraft.puts(";");   // split ch1-ch2 data
00337                 spacecraft.puts(tempCH2);
00338 
00339                 Spare = true;
00340             }
00341             else if (((int) data_TLC[0] == CMD15_R) && ((int) payload == ALL_RELAY_OFF))
00342             {
00343                 Relay5V = 1;
00344                 Relay12V = 1;
00345                 Relay15_15_5V = 1;
00346                 Relay24V = 1;
00347 
00348                 Spare = true;
00349             }
00350             else if (((int) data_TLC[0] == CMD15) && ((int) payload == ALL_RELAY_ON))
00351             {
00352                 Relay5V = 0;
00353                 Relay12V = 0;
00354                 Relay15_15_5V = 0;
00355                 Relay24V = 0;
00356 
00357                 Spare = true;
00358             }
00359             else if (((int) data_TLC[0] == CMD15))  
00360             {
00361                 if (((int) payload == DISABLE_12V))
00362                 {
00363                     Relay12V = 1;
00364                     Spare = true;
00365                 }
00366                 else if (((int) payload == ENABLE_12V))
00367                 {
00368                     Relay12V = 0;
00369                     // since the linear actuator is driven by 12V power
00370                     offset = actuonix.read();
00371                     offset_dig = actuonix_dig.read();
00372                     
00373                     actuonix.write(offset);
00374                     actuonix.write(offset_dig);
00375                     
00376                     Spare = true;
00377                 }
00378                 else if (((int) payload == DISABLE_5V))
00379                 {
00380                     Relay5V = 1;
00381                     Spare = true;
00382                 }
00383                 else if (((int) payload == ENABLE_5V))
00384                 {
00385                     Relay5V = 0;
00386                     Spare = true;
00387                 }
00388                 else if (((int) payload == DISABLE_15V))
00389                 {
00390                     Relay15_15_5V = 1;
00391                     Spare = true;
00392                 }
00393                 else if (((int) payload == ENABLE_15V))
00394                 {
00395                     Relay15_15_5V = 0;
00396                     Spare = true;
00397                 }
00398                 else if (((int) payload == DISABLE_24V))
00399                 {
00400                     Relay24V = 1;
00401                     Spare = true;
00402                 }
00403                 else if (((int) payload == ENABLE_24V))
00404                 {
00405                     Relay24V = 0;
00406                     Spare = true;
00407                 }
00408             }
00409             else if (((int) data_TLC[0] == CMD05_1) && ((int) payload == TLMODE_HSK))
00410             {
00411                 tlmode_option_1 = 0;
00412                 tlmode_option_2 = 1;
00413                 tlmode_tlm = 1;
00414                 rxTlmPtr = 0;
00415                 rxTlmOpt1Ptr = 0;
00416                 rxTlmOpt2Ptr = 0;
00417 
00418                 if (config == 0)
00419                 {
00420                     spacecraft.printf("\n\r ... Sono entrato in TLMODE 1 ... \n\r");
00421                 }
00422                 else if (config == 1)
00423                 {
00424                     mima.printf("\n\r ... Sono entrato in TLMODE 1 ... \n\r");
00425                 }
00426             }
00427             else if (((int) data_TLC[0] == CMD05_2) && ((int) payload == TLMODE_HSKSD))
00428             {
00429                 tlmode_option_2 = 0;
00430                 tlmode_option_1 = 1;
00431                 tlmode_tlm = 1;
00432                 rxTlmPtr = 0;
00433                 rxTlmOpt1Ptr = 0;
00434                 rxTlmOpt2Ptr = 0;
00435 
00436                 if (config == 0)
00437                 {
00438                     spacecraft.printf("\n\r ... Sono entrato in TLMODE 2 ... \n\r");
00439                 }
00440                 else if (config == 1)
00441                 {
00442                     mima.printf("\n\r ... Sono entrato in TLMODE 2 ... \n\r");
00443                 }
00444             }
00445 
00446             // Reset global vars 
00447             else if (((int) data_TLC[0] == CMD31) && ((int) payload == RESET_GLOBAL_VARS))
00448             {
00449                 nRxCharCount = 0;
00450                 rxTlcPtr = 0;
00451                 rxTlmOpt1Ptr = 0;
00452                 rxTlmOpt2Ptr = 0;
00453                 rxTlcDataCounter = 0;
00454                 rxTlmOpt1DataCounter = 0;
00455                 rxTlmOpt2DataCounter = 0;
00456                 tlmode_tlm = 1;
00457                 tlmode_option_1 = 1;
00458                 tlmode_option_2 = 1;
00459 
00460                 for (nIndex = 0; nIndex < PACKETDIM; nIndex++)
00461                 {
00462                     caRxPacket[nIndex] = 0;
00463                 }
00464 
00465                 clearBuffer(data_TLC, sizeof(data_TLC) / sizeof(char));
00466                 clearBuffer(data_TLM, sizeof(data_TLM) / sizeof(char));
00467                 clearBuffer(data_TLMOpt1, sizeof(data_TLMOpt1) / sizeof(char));
00468                 clearBuffer(data_TLMOpt2, sizeof(data_TLMOpt2) / sizeof(char));
00469                 
00470                 Spare = true;
00471 
00472                 if (config == 0)
00473                 {
00474                     spacecraft.printf("\n\r ... Reset variabili effettuato! ... \n\r");
00475                 }
00476                 else if (config == 1)
00477                 {
00478                     mima.printf("\n\r ... Reset variabili effettuato! ... \n\r");
00479                 }
00480             }
00481 
00482             // Invia il telecomando a MIMA se non è Spare
00483             if (!Spare)
00484             {
00485                 TxTelecommand();
00486             }
00487             // Telecommand sent, flags set
00488 
00489             if (config == 0)
00490             {
00491                 spacecraft.printf("\n\r ... Telecomando inviato a MIMA ... \n\r");
00492             }
00493             else if (config == 1)
00494             {
00495                 mima.printf("\n\r ... Telecomando inviato a MIMA ... \n\r");
00496             }
00497 
00498             // Ripulisci il buffer di ricezione telecomando
00499             clearBuffer(rx_TLC, sizeof(rx_TLC) / sizeof(char));
00500             clearBuffer(data_TLC, sizeof(data_TLC) / sizeof(char));
00501 
00502             if (config == 0)
00503             {
00504                 spacecraft.printf("\n\r ... Ho ripulito i buffer di ricezione TLC .... \n\r");
00505             }
00506             else
00507             {
00508                 mima.printf("\n\r ... Ho ripulito i buffer di ricezione TLC .... \n\r");
00509             }
00510 
00511             __enable_irq(); // now he's ready to receive new data
00512 
00513         }   // end-if:telecommand 
00514         else if ((tTimeRead - tTimeStart) >= TIMEOUT)
00515         {
00516             rxTlcPtr = 0;
00517             for (int i = 0; i < packet; i++)
00518             {
00519                 rx_TLC[i] = '\0';
00520                 data_TLC[i] = '\0';
00521             }
00522 
00523             if (config == 0)
00524             {
00525                 spacecraft.printf(" n\r ... Telecommand RX timeout ... \n\r");
00526             }
00527             else if (config == 1)
00528             {
00529                 mima.printf("\n\r ... Telecommand RX timeout ... \n\r");
00530             }
00531         }   // end-else-if:telecommand+timeout   
00532 
00533         // Telemetry 
00534         /* DORA si predispone a ricevere lato mima solo se un comando che non sia 
00535         Spare è stato inviato, onde evitare ritardi (sul prossimo telecomando) 
00536         dovuti a Timeout indesiderati. Sostanzialmente attende due byte 
00537         (ricompone il frame) e li invia a spacecraft all'interno della finestra
00538         di trasmissione. */
00539         if ((!Spare) && (TlcSend))
00540         {
00541             if ((tlmode_option_1 == 1) && (tlmode_option_2 == 1) && (tlmode_tlm == 0)) // standard telemetry
00542             {
00543                 clearBuffer(data_TLM, sizeof(data_TLM) / sizeof(char));
00544 
00545                 rx.start();
00546                 rxTimeStart = rx.read();
00547                 rxTimeRead = rxTimeStart;
00548 
00549                 while (((rxTimeRead - rxTimeStart) < rxWindow))
00550                 {
00551                     if (rxTlmPtr == packet)
00552                     {
00553                         __disable_irq();
00554                         memcpy(data_TLM, rx_TLM, rxTlmPtr);
00555                         rxTlmDataCounter = rxTlmPtr;
00556                         rxTlmPtr = 0;
00557                         
00558                         data_TLM[rxTlmDataCounter] = 0;
00559 
00560                         TxTelemetry();
00561                         __enable_irq();
00562 
00563                         // Diagnostic
00564                         if (config == 0)
00565                         {
00566                             spacecraft.printf("\n\r ... Ricevuto Telemetry Standard ... \n\r");
00567                         }
00568                         else if (config == 1)
00569                         {
00570                             mima.printf("\n\r ... Ricevuto Telemetry Standard ... \n\r");
00571                         }
00572                     }
00573                     // update
00574                     rxTimeRead = rx.read();
00575                 }
00576 
00577                 rx.stop();
00578 
00579                 if ((rxTimeRead - rxTimeStart) >= rxWindow)
00580                 {
00581                     if (config == 0)
00582                     {
00583                         spacecraft.printf("\n\r ... Scattato il timeout in Telemetry ... \n\r");
00584                     }
00585                     else if (config == 1)
00586                     {
00587                         mima.printf("\n\r ... Scattato il timeout in Telemetry ... \n\r");
00588                     }
00589 
00590                     rxTlmPtr = 0;
00591 
00592                     for (int i = 0; i < packet; i++)
00593                     {
00594                         rx_TLM[i] = '\0';
00595                         data_TLM[i] = '\0';
00596                     }
00597                 }   // end-else-if:telecommand-send+timeout   
00598 
00599                 TlcSend = false;
00600             }   // end-if-send-telecommand
00601             else if ((tlmode_option_1 == 0) && (tlmode_option_2 == 1) && (tlmode_tlm == 1)) // all housekeeping teemetries
00602             {
00603                 clearBuffer(data_TLMOpt1, sizeof(data_TLMOpt1)/sizeof(char));
00604 
00605                 rx.start();
00606                 rxTimeStart = rx.read();
00607                 rxTimeRead = rxTimeStart;
00608 
00609                 while (((rxTimeRead - rxTimeStart) < rxWindow))
00610                 {
00611                     if (rxTlmOpt1Ptr == packet)
00612                     {
00613                         __disable_irq(); 
00614                         memcpy(data_TLMOpt1, rx_TLMOpt1, rxTlmOpt1Ptr);  
00615                         rxTlmOpt1DataCounter = rxTlmOpt1Ptr;
00616                         rxTlmOpt1Ptr = 0;                                                 
00617       
00618                         data_TLMOpt1[rxTlmOpt1DataCounter] = 0;
00619                     
00620                         TxTelemetry();
00621                         __enable_irq();
00622 
00623                         // Diagnostic
00624                         if (config == 0)
00625                         {
00626                             spacecraft.printf("\n\r ... Ricevuto Telemetry Opt 1 ... \n\r");
00627                         }
00628                         else if (config == 1)
00629                         {
00630                             mima.printf("\n\r ... Ricevuto Telemetry Opt 1 ... \n\r");
00631                         }
00632                         
00633                     }
00634                     // update
00635                     rxTimeRead = rx.read();
00636                 }
00637 
00638                 rx.stop();
00639 
00640                 if ((rxTimeRead - rxTimeStart) >= rxWindow)
00641                 {
00642                     if (config == 0)
00643                     {
00644                         spacecraft.printf("\n\r ... Scattato il timeout in Telemetry Opt 1 ... \n\r");
00645                     }
00646                     else if (config == 1)
00647                     {
00648                         mima.printf("\n\r ... Scattato il timeout in Telemetry Opt 1 ... \n\r");
00649                     }
00650                     
00651                     rxTlmOpt1Ptr = 0;
00652                     for (int i = 0; i < packet; i++)
00653                     {
00654                         rx_TLMOpt1[i] = '\0';
00655                         data_TLMOpt1[i] = '\0';
00656                     }
00657                 }   // end-else-if:telecommand-send+timeout   
00658 
00659                 TlcSend = false;
00660             }   // end-else-if-send-telecommand
00661             else if ((tlmode_option_1 == 1) && (tlmode_option_2 == 0) && (tlmode_tlm == 1)) // all hsk + inteferogram data
00662             {
00663                 clearBuffer(data_TLMOpt2, sizeof(data_TLMOpt2)/sizeof(char));
00664 
00665                 rx_wide.start();
00666                 rx_wideTimeStart = rx_wide.read();
00667                 rx_wideTimeRead = rx_wideTimeStart;
00668 
00669                 while (((rx_wideTimeRead - rx_wideTimeStart) < rx_wideWindow))
00670                 {
00671                     if (rxTlmOpt2Ptr == packet)
00672                     {
00673                         __disable_irq(); 
00674                         memcpy(data_TLMOpt2, rx_TLMOpt2, rxTlmOpt2Ptr);  
00675                         rxTlmOpt2DataCounter = rxTlmOpt2Ptr;
00676                         rxTlmOpt2Ptr = 0;                                                 
00677       
00678                         data_TLMOpt2[rxTlmOpt2DataCounter] = 0;
00679                     
00680                         TxTelemetry();
00681                         __enable_irq();
00682 
00683                         // Diagnostic
00684                         if (config == 0)
00685                         {
00686                             spacecraft.printf("\n\r ... Ricevuto Telemetry Opt 2 ... \n\r");
00687                         }
00688                         else if (config == 1)
00689                         {
00690                             mima.printf("\n\r ... Ricevuto Telemetry Opt 2  ... \n\r");
00691                         }
00692                         
00693                     }
00694                     // update
00695                     rx_wideTimeRead = rx_wide.read();
00696                 }
00697 
00698                 rx.stop();
00699 
00700                 if ((rx_wideTimeRead - rx_wideTimeStart) >= rx_wideWindow)
00701                 {
00702                     if (config == 0)
00703                     {
00704                         spacecraft.printf("\n\r ... Scattato il timeout in Telemetry Opt 2 ... \n\r");
00705                     }
00706                     else if (config == 1)
00707                     {
00708                         mima.printf("\n\r ... Scattato il timeout in Telemetry Opt 2 ... \n\r");
00709                     }
00710                     
00711                     rxTlmOpt2Ptr = 0;
00712                     for (int i = 0; i < packet; i++)
00713                     {
00714                         rx_TLMOpt2[i] = '\0';
00715                         data_TLMOpt2[i] = '\0';
00716                     }
00717                 }   // end-else-if:telecommand-send+timeout   
00718 
00719                 TlcSend = false;
00720             }   // end-2nd-else-if-send-telecommand
00721         }
00722     }   // end-while:true
00723 
00724 }   // end-Main
00725 
00726 /* ************************************************************ */
00727 /* ******* SYSTEM INTERRPUTS MANAGEMENT AND FUNCTIONS ********* */
00728 /* ************************************************************ */
00729 
00730 // Interrupt: DORA receives a byte from Spacecraft
00731 void RxTelecommand(void)
00732 {
00733     char txChar;
00734     while (spacecraft.readable())
00735     {
00736         txChar = spacecraft.getc();
00737         
00738         if (rxTlcPtr < packet)
00739         {
00740             rx_TLC[rxTlcPtr++] = txChar;
00741         }
00742     }
00743 }
00744 
00745 // Interrupt: DORA receives a byte from MIMA
00746 void RxTelemetry(void)
00747 {
00748     char rxChar;
00749     while (mima.readable()) 
00750     { 
00751         rxChar = mima.getc();
00752         
00753         if (tlmode_tlm == 0) // Standard telemetry message
00754         {
00755             rx_TLM[rxTlmPtr++] = rxChar;
00756         }
00757         else if (tlmode_option_1 == 0) // TLMODE 1 (all housekeeping telemetries)
00758         {
00759             rx_TLMOpt1[rxTlmOpt1Ptr++] = rxChar;
00760         }
00761         else if (tlmode_option_2 == 0) // TLMODE 2 (hsk+scientific data)
00762         {
00763             rx_TLMOpt2[rxTlmOpt2Ptr++] = rxChar;
00764         }
00765     }
00766 }
00767 
00768 // Once received a full telecommand frame, send it to MIMA
00769 void TxTelecommand(void)
00770 {
00771     for (int i = 0; i < packet; i++)
00772     {
00773         mima.putc(data_TLC[i]);
00774     }
00775 
00776     TlcSend = true;
00777 }
00778 
00779 // Once received a full telemetry frame, send it to Spacecraft
00780 void TxTelemetry(void)
00781 {
00782     if (tlmode_tlm == 0)
00783     {
00784         for (int i = 0; i < packet; i++)
00785         {
00786             spacecraft.putc(data_TLM[i]);
00787         }
00788     }
00789     else if (tlmode_option_1 == 0)
00790     {
00791         for (int i = 0; i < packet; i++)
00792         {
00793             spacecraft.putc(data_TLMOpt1[i]);
00794         }
00795     }
00796     else if (tlmode_option_2 == 0)
00797     {
00798         for (int i = 0; i < packet; i++)
00799         {
00800             spacecraft.putc(data_TLMOpt2[i]);
00801         }
00802     }
00803 }
00804 
00805 // Reset
00806 void clearBuffer(char *arr, int arrLen)
00807 {
00808     int myIndex;
00809     for (myIndex = 0; myIndex < arrLen; myIndex++)
00810     {
00811         arr[myIndex] = '\0';    // terminatore
00812     }
00813 }