main.cpp

00001 
00002 // in data 13/07/2022 abbiamo testato spacecraft-mima avendo come spacecraft
00003 // la seriale che parla su STM, mentre mima l'usb del pc
00004 
00005 // Librerie
00006 #include "mbed.h"
00007 #include <math.h>
00008 #include <string.h>
00009 #include <stdlib.h>
00010 #include <stdbool.h>
00011 
00012 // Macros
00013 #define PACKETDIM 15 // temperature
00014 #define word 1 
00015 #define packet 2 // 2 bytes
00016 #define hsk_buf 113 
00017 #define hsk_rx 114 // 114 bytes - 57 telemetry words(housekeeping)
00018 #define hsk_sd_buf 11211
00019 #define hsk_sd 11212 // 11212 bytes - 5606 interferogram data words
00020 #define channel_size 10 // temeprature channel from sen30202
00021 
00022 // Serial e periferiche 
00023 Serial spacecraft(USBTX, USBRX); // switchare questo e le print con mima
00024 Serial mima(PC_4, PC_5);
00025 Serial max31865(PA_0, PA_1);
00026 // L16 Actuonix: 
00027 PwmOut actuonix (PB_3);
00028 float offset;
00029 // Relay: configurazione pull-up
00030 DigitalOut Relay5V (PA_7);
00031 DigitalOut Relay12V (PB_4);
00032 DigitalOut Relay24V (PB_5);
00033 DigitalOut Relay15_15_5V (PB_10);
00034 
00035 // Buffer: telecommand
00036 volatile int rxTlcPtr; // telecommand receiving buffer
00037 int rxTlcDataCounter = 0; 
00038 char rx_TLC[word+1]; // buffer
00039 char data_TLC[word+1]; // telecommand
00040 
00041 // Buffer: standard telemetry
00042 volatile int rxTlmPtr; 
00043 int rxTlmDataCounter = 0;
00044 char rx_TLM[word+1]; // buffer
00045 char data_TLM[word+1]; // standard telemetry
00046 
00047 // Buffer: TLMODE telemetry option 1
00048 volatile int rxTlmOpt1Ptr; 
00049 int rxTlmOpt1DataCounter = 0;
00050 char rx_TLMOpt1[hsk_buf+1]; 
00051 char data_TLMOpt1[hsk_buf+1];
00052 
00053 // Buffer: TLMODE telemetry option 1
00054 volatile int rxTlmOpt2Ptr; 
00055 int rxTlmOpt2DataCounter = 0;
00056 char rx_TLMOpt2[hsk_sd_buf+1]; 
00057 char data_TLMOpt2[hsk_sd_buf+1];
00058 
00059 // Timer
00060 Timer timer; // telecommand
00061 Timer rx; // rx window
00062 float rxWindow = 300 /* seconds */, rxTimeStart, rxTimeStop, rxTimeRead;
00063 float TIMEOUT = 10 /* seconds */, tTimeStart, tTimeStop, tTimeRead;
00064 
00065 // TLMODE
00066 volatile int tlmode_option_1, tlmode_option_2, tlmode_tlm;
00067 volatile bool TlcSend;
00068 
00069 // SC-MIMA communication: TX/RX
00070 void RxTelecommand();
00071 void TxTelecommand();
00072 void RxTelemetry();
00073 void TxTelemetry();
00074 // System utility
00075 void clearBuffer(char *arr, int arrLen);
00076 
00077 // Temperature settings
00078 char tempCH1[channel_size];
00079 char tempCH2[channel_size];
00080 volatile int j; // first channel index
00081 volatile int t; // second channel index
00082 volatile char caRxPacket[PACKETDIM]; // temperature buffer
00083 volatile char nRxCharCount; // temperature char counter
00084 
00085 // Routines dedicate alla ricezione di dati della temperatura (Pt100)
00086 void SerialeRxInterrupt(void)
00087 {
00088     char cReadChar; 
00089     while((max31865.readable()))
00090     {
00091         cReadChar = max31865.getc(); 
00092         nRxCharCount++; 
00093         caRxPacket[nRxCharCount] = cReadChar;
00094     }  
00095     
00096     if (nRxCharCount == PACKETDIM) // if it reaches max -> reset
00097     {
00098         nRxCharCount = 0;
00099     }
00100 }
00101 
00102 // Main
00103 int main()
00104 {
00105     // Baudrate
00106     spacecraft.baud(115200);
00107     //spacecraft.baud(9600);
00108     mima.baud(9600);
00109     //mima.baud(115200);
00110     max31865.baud(115200);
00111 
00112     // Diagnostica
00113     spacecraft.printf(" Avvio Spacecraft... \n\r");
00114     //mima.printf(" Avvio MIMA... \n\r");
00115     
00116     // Setup per temperatura
00117     int nIndex;
00118     nRxCharCount = 0;
00119     for(nIndex = 0; nIndex < PACKETDIM; nIndex++)
00120     {
00121         caRxPacket[nIndex] = 0;
00122     }   
00123     
00124     // Setup per Actuonix L16      
00125     actuonix.period_us(1000);
00126     offset = actuonix.read();
00127     
00128     // Setup per Relay: 1 = OFF (1->OFF, 0->ON)
00129     Relay5V         = 1;
00130     Relay12V        = 1;
00131     Relay15_15_5V   = 1;
00132     Relay24V        = 1;
00133     
00134     // Bool flags 
00135     TlcSend = false;
00136     
00137     // Interrupt routine 
00138     max31865.attach(&SerialeRxInterrupt, Serial::RxIrq);
00139     spacecraft.attach(&RxTelecommand, Serial::RxIrq);
00140     mima.attach(&RxTelemetry, Serial::RxIrq);
00141     
00142     // Main loop
00143     while (true)
00144     {    
00145         // Telecommand
00146         timer.start();
00147         tTimeStart = timer.read();  // in secondi 
00148         tTimeRead = tTimeStart;
00149         
00150         while ((rxTlcPtr < packet) && ((tTimeRead - tTimeStart) < TIMEOUT))
00151         {
00152             tTimeRead = timer.read();
00153         }
00154         
00155         timer.stop();
00156         
00157         if ((rxTlcPtr == packet) && ((tTimeRead - tTimeStart) < TIMEOUT))
00158         { 
00159             __disable_irq(); // disable interrupts so data doesn't arrive while we are doing this
00160             memcpy(data_TLC, rx_TLC, rxTlcPtr);  
00161             rxTlcDataCounter = rxTlcPtr;
00162             rxTlcPtr = 0;                                                 
00163             //__enable_irq(); // re-enable interrupts
00164             
00165             data_TLC[1] = data_TLC[1] >> 1; // read payload data ignoring the LSB
00166             
00167             spacecraft.printf("\n\r .... Telecomando ricevuto su DORA! \n\r");
00168                         
00169             for (int i = 0; i < sizeof(data_TLC)/sizeof(char); i++)
00170             {
00171                 spacecraft.printf("> Carattere: %f \n\r", (float)data_TLC[i]);
00172             }            
00173             
00174             data_TLC[rxTlcDataCounter] = 0; // add a null just in case the received data didn't have one at the end
00175           
00176             // hw control: set-point init
00177             offset = 0;
00178             
00179             // RX settings
00180             if (((float)data_TLC[0] != 40) || ((float)data_TLC[0] != 41))
00181             {
00182                 tlmode_option_1 = 1;
00183                 tlmode_option_2 = 1;
00184                 tlmode_tlm = 0;
00185             }
00186             
00187             // L16 setpoint
00188             if ((float)data_TLC[0] == 0)
00189             {
00190                 offset = (float)data_TLC[1];    
00191                 offset = offset/100;    
00192                 actuonix.write(offset);
00193             }
00194             // Temperature request
00195             else if (((float)data_TLC[0] == 16) && ((float)data_TLC[1] == 32))
00196             {
00197                 // Cleaning buffers
00198                 clearBuffer(tempCH1, sizeof(tempCH1)/sizeof(char));
00199                 clearBuffer(tempCH2, sizeof(tempCH2)/sizeof(char));
00200 
00201                 // Index setup
00202                 nRxCharCount = 0;
00203                 int y = 0, u = 0;
00204                 t = 0; j = 0;
00205 
00206                 for (int i = 0; i < PACKETDIM; i++)
00207                 {
00208                     if (caRxPacket[i] == 'S')
00209                     {
00210                         j = i + 1;
00211 
00212                         while (j < PACKETDIM)
00213                         {
00214                             if (caRxPacket[j] == ';')
00215                             {
00216                                 break;
00217                             }
00218                             else
00219                             {
00220                                 tempCH1[y++] = caRxPacket[j];
00221                             }
00222 
00223                             j++;
00224                         }
00225 
00226                         t = j + 1;
00227 
00228                         while (t < PACKETDIM)
00229                         {
00230                             if (caRxPacket[t] == 'P')
00231                             {
00232                                 break;
00233                             }
00234                             else
00235                             {
00236                                 tempCH2[u++] = caRxPacket[t];
00237                             }
00238                             t++;
00239                         }
00240                         break;
00241                     }
00242                 }
00243                 // Send
00244                 spacecraft.puts(tempCH1);
00245                 spacecraft.puts(";");
00246                 spacecraft.puts(tempCH2);
00247             }
00248             else if (((float)data_TLC[0] == 121) && ((float)data_TLC[1] == 42))
00249             {
00250                 Relay5V = 1;
00251                 Relay12V = 1;
00252                 Relay15_15_5V = 1;
00253                 Relay24V = 1;
00254             }
00255             else if (((float)data_TLC[0] == 120) && ((float)data_TLC[1] == 85))
00256             {
00257                 Relay5V = 0;
00258                 Relay12V = 0;
00259                 Relay15_15_5V = 0;
00260                 Relay24V = 0; 
00261             }
00262             else if (((float)data_TLC[0] == 120)) // Relay 
00263             {
00264                 if (((float)data_TLC[1] == 0))
00265                 {
00266                     Relay12V = 1;
00267                 }
00268                 else if (((float)data_TLC[1] == 1))
00269                 {
00270                     Relay12V = 0;
00271                     // since the linear actuator is driven by 12V power
00272                     offset = actuonix.read();
00273                     actuonix.write(offset);
00274                 }
00275                 else if (((float)data_TLC[1] == 2))
00276                 {
00277                     Relay5V = 1; 
00278                 }
00279                 else if (((float)data_TLC[1] == 3))
00280                 {
00281                     Relay5V = 0; 
00282                 }
00283                 else if (((float)data_TLC[1] == 6))
00284                 {
00285                     Relay15_15_5V = 1;
00286                 }
00287                 else if (((float)data_TLC[1] == 7))
00288                 {
00289                     Relay15_15_5V = 0;
00290                 }
00291                 else if (((float)data_TLC[1] == 8))
00292                 {
00293                     Relay24V = 1;
00294                 }
00295                 else if (((float)data_TLC[1] == 15))
00296                 {
00297                     Relay24V = 0;
00298                 }
00299             }
00300             else if (((float)data_TLC[0] == 40) && ((float)data_TLC[1] == 24))
00301             {
00302                 tlmode_option_1 = 0;
00303                 tlmode_option_2 = 1;
00304                 tlmode_tlm = 1;
00305                 rxTlmPtr = 0;
00306                 rxTlmOpt1Ptr = 0;
00307                 rxTlmOpt2Ptr = 0;
00308                 spacecraft.printf("> Sono entrato in TLMODE 1 \n\r");
00309             }
00310             else if (((float)data_TLC[0] == 41) && ((float)data_TLC[1] == 127))
00311             {
00312                 tlmode_option_2 = 0;
00313                 tlmode_option_1 = 1;
00314                 tlmode_tlm = 1;
00315                 rxTlmPtr = 0;
00316                 rxTlmOpt1Ptr = 0;
00317                 rxTlmOpt2Ptr = 0;
00318                 spacecraft.printf("> Sono entrato in TLMODE 2 \n\r");
00319             }
00320             // Reset global vars 
00321             else if (((float)data_TLC[0] == 241) && ((float)data_TLC[1] == 127))
00322             {
00323                 nRxCharCount = 0;
00324                 rxTlcPtr = 0;
00325                 rxTlmOpt1Ptr = 0;
00326                 rxTlmOpt2Ptr = 0;
00327                 rxTlcDataCounter = 0;
00328                 rxTlmOpt1DataCounter = 0;
00329                 rxTlmOpt2DataCounter = 0;
00330                 tlmode_tlm = 1;
00331                 tlmode_option_1 = 1;
00332                 tlmode_option_2 = 1;
00333                 
00334                 for(nIndex = 0; nIndex < PACKETDIM; nIndex++)
00335                 {
00336                     caRxPacket[nIndex] = 0;
00337                 }   
00338                 
00339                 clearBuffer(data_TLC, sizeof(data_TLC)/sizeof(char));
00340                 clearBuffer(data_TLM, sizeof(data_TLM)/sizeof(char));
00341                 clearBuffer(data_TLMOpt1, sizeof(data_TLMOpt1)/sizeof(char));
00342                 clearBuffer(data_TLMOpt2, sizeof(data_TLMOpt2)/sizeof(char));
00343                 
00344                 spacecraft.printf(".... Reset variabili effettuato! \n\r");
00345             }
00346         
00347             // Send after setting flags and clear
00348             TxTelecommand();
00349             spacecraft.printf(".... Telecomando inviato a MIMA ....");
00350             __enable_irq(); // *********************************************************************
00351             clearBuffer(rx_TLC, sizeof(rx_TLC)/sizeof(char));
00352             clearBuffer(data_TLC, sizeof(data_TLC)/sizeof(char));
00353             
00354             spacecraft.printf(".... Ho ripulito i buffer di ricezione TLC .... \n\r");
00355        
00356             /* *********************************************************** */
00357             
00358             //__disable_irq(); // da lavorare su queste chiamate perché se da un lato prevengono 
00359             // blocco del telecomando durante ricezione, dall'altro impediscono al comando di telemetria di ricevere
00360             
00361             if ((TlcSend) && (tlmode_option_1 == 1) && (tlmode_option_2 == 1) && (tlmode_tlm == 0))
00362             { 
00363                 clearBuffer(data_TLM, sizeof(data_TLM)/sizeof(char));
00364 
00365                 // Standard telemetry frame
00366                 rx.start();
00367                 rxTimeStart = rx.read(); 
00368                 rxTimeRead = rxTimeStart;
00369                 
00370                 while ((rxTlmPtr < packet) && ((rxTimeRead - rxTimeStart) < rxWindow))
00371                 {
00372                     rxTimeRead = rx.read();
00373                 }
00374                 
00375                 rx.stop();
00376                 
00377                 if ((rxTlmPtr == packet) && ((rxTimeRead - rxTimeStart) < rxWindow))
00378                 { 
00379                     __disable_irq(); 
00380                     memcpy(data_TLM, rx_TLM, rxTlmPtr);  
00381                     rxTlmDataCounter = rxTlmPtr;
00382                     rxTlmPtr = 0;                                                 
00383                     //__enable_irq();
00384       
00385                     data_TLM[rxTlmDataCounter] = 0;
00386                     
00387                     TxTelemetry();
00388                     __enable_irq(); // ***************************************************
00389                     spacecraft.printf("\n\r Ricevuto Telemetry Standard \n\r");
00390 
00391                 }
00392                 else if ((rxTimeRead - rxTimeStart) >= rxWindow)
00393                 {
00394                     spacecraft.printf("\n\r !!! Scattato il timeout in Telemetry !!! \n\r");
00395                     rxTlmPtr = 0;
00396                     for (int i = 0; i < packet; i++)
00397                     {
00398                         rx_TLM[i] = '\0';
00399                         data_TLM[i] = '\0';
00400                     }
00401                 } // end-else-if:telecommand-send+timeout   
00402                 
00403                 TlcSend = false;
00404             } // end-if-send-telecommand
00405             else if ((TlcSend) && (tlmode_option_1 == 0) && (tlmode_option_2 == 1) && (tlmode_tlm == 1))
00406             {   
00407                 spacecraft.printf("\n\r > Sono entrato in TLMODE 1 - TX Telemetry \n\r");
00408                 clearBuffer(data_TLMOpt1, sizeof(data_TLMOpt1)/sizeof(char));  
00409                           
00410                 rx.start();
00411                 rxTimeStart = rx.read(); 
00412                 rxTimeRead = rxTimeStart;
00413                                 
00414                 while ((rxTlmOpt1Ptr < hsk_rx) && ((rxTimeRead - rxTimeStart) < rxWindow))
00415                 {
00416                     rxTimeRead = rx.read();
00417                 }
00418                 
00419                 rx.stop();
00420                 
00421                 if ((rxTlmOpt1Ptr == hsk_rx) && ((rxTimeRead - rxTimeStart) < rxWindow))
00422                 { 
00423                     __disable_irq(); 
00424                     memcpy(data_TLMOpt1, rx_TLMOpt1, rxTlmOpt1Ptr);  
00425                     rxTlmOpt1DataCounter = rxTlmOpt1Ptr;
00426                     rxTlmOpt1Ptr = 0;                                                 
00427                     //__enable_irq();
00428       
00429                     data_TLMOpt1[rxTlmOpt1DataCounter] = 0;
00430                     
00431                     TxTelemetry();
00432                     __enable_irq(); // ***************************************************
00433                     spacecraft.printf("\n\r > Ricevuto Telemetry Opt 1 \n\r");
00434 
00435                 }
00436                 else if ((rxTimeRead - rxTimeStart) >= rxWindow)
00437                 {
00438                     mima.printf("\n\r !!! Scattato il timeout in Telemetry Opt 1 !!! \n\r");
00439                     rxTlmOpt1Ptr = 0;
00440                     for (int i = 0; i < packet; i++)
00441                     {
00442                         rx_TLMOpt1[i] = '\0';
00443                         data_TLMOpt1[i] = '\0';
00444                     }
00445                 } 
00446                 TlcSend = false;
00447             } // end-else-if-send-telecommand
00448             else if ((TlcSend) && (tlmode_option_1 == 1) && (tlmode_option_2 == 0) && (tlmode_tlm == 1))
00449             {   
00450                 spacecraft.printf("\n\r > Sono entrato in TLMODE 2 - TX Telemetry \n\r");
00451                 clearBuffer(data_TLMOpt2, sizeof(data_TLMOpt2)/sizeof(char)); 
00452                            
00453                 rx.start();
00454                 rxTimeStart = rx.read(); 
00455                 rxTimeRead = rxTimeStart;
00456                                   
00457                 while ((rxTlmOpt2Ptr < hsk_sd) && ((rxTimeRead - rxTimeStart) < rxWindow))
00458                 {
00459                     rxTimeRead = rx.read();
00460                 }
00461                 
00462                 rx.stop();
00463                 
00464                 if ((rxTlmOpt2Ptr == hsk_sd) && ((rxTimeRead - rxTimeStart) < rxWindow))
00465                 { 
00466                     __disable_irq(); 
00467                     memcpy(data_TLMOpt2, rx_TLMOpt2, rxTlmOpt2Ptr);  
00468                     rxTlmOpt2DataCounter = rxTlmOpt2Ptr;
00469                     rxTlmOpt2Ptr = 0;                                                 
00470                     //__enable_irq();
00471       
00472                     data_TLMOpt2[rxTlmOpt2DataCounter] = 0;
00473                     
00474                     TxTelemetry();
00475                     __enable_irq(); // ***************************************************
00476                     spacecraft.printf("\n\r Ricevuto Telemetry Opt 2 \n\r");
00477 
00478                 }
00479                 else if ((rxTimeRead - rxTimeStart) >= rxWindow)
00480                 {
00481                     spacecraft.printf("\n\r !!! Scattato il timeout in Telemetry Opt 2 !!! \n\r");
00482                     rxTlmOpt2Ptr = 0;
00483                     for (int i = 0; i < packet; i++)
00484                     {
00485                         rx_TLMOpt2[i] = '\0';
00486                         data_TLMOpt2[i] = '\0';
00487                     }
00488                 } 
00489                 TlcSend = false;
00490             } // end-2nd-else-if-send-telecommand
00491             
00492             spacecraft.printf("\n\r .... Ho inviato il telecomando entro la finestra di timeout .... \n\r");
00493             spacecraft.printf(" *************************************** \n\r");
00494             
00495             //__enable_irq();
00496             
00497         } // end-if:telecommand 
00498         else if ((tTimeRead - tTimeStart) >= TIMEOUT)
00499         {      
00500             rxTlcPtr = 0;
00501             for (int i = 0; i < packet; i++)
00502             {
00503                 rx_TLC[i] = '\0';
00504                 data_TLC[i] = '\0';
00505             }
00506             
00507             spacecraft.printf(" .... Telecomando non inviato: timeout, riprovare! \n\r");
00508         } // end-else-if:telecommand+timeout   
00509     } // end-while:true
00510 } // end-Main
00511 
00512 
00513 /* ************************************************************* */
00514 /* ******** SYSTEM INTERRPUTS MANAGEMENT AND FUNCTIONS ********* */
00515 /* ************************************************************* */
00516 
00517 // Interrupt: DORA receives a byte from Spacecraft
00518 void RxTelecommand()
00519 {
00520     char txChar;
00521     while (spacecraft.readable()) 
00522     { 
00523         txChar = spacecraft.getc();
00524         rx_TLC[rxTlcPtr++] = txChar;
00525     }
00526 }
00527 
00528 // Interrupt: DORA receives a byte from MIMA
00529 void RxTelemetry()
00530 {
00531     char rxChar;
00532     while (mima.readable()) 
00533     { 
00534         rxChar = mima.getc();
00535         
00536         if (tlmode_tlm == 0) // Standard telemetry message
00537         {
00538             rx_TLM[rxTlmPtr++] = rxChar;
00539         }
00540         else if (tlmode_option_1 == 0) // TLMODE 1 (all housekeeping telemetries)
00541         {
00542             rx_TLMOpt1[rxTlmOpt1Ptr++] = rxChar;
00543         }
00544         else if (tlmode_option_2 == 0) // TLMODE 2 (hsk+scientific data)
00545         {
00546             rx_TLMOpt2[rxTlmOpt2Ptr++] = rxChar;
00547         }
00548     }
00549 }
00550 
00551 // Once received a full telecommand frame, send it to MIMA
00552 void TxTelecommand()
00553 {
00554     mima.puts(data_TLC);
00555     TlcSend = true;
00556 }
00557 
00558 // Once received a full telemetry frame, send it to Spacecraft
00559 void TxTelemetry()
00560 {
00561     if (tlmode_tlm == 0)
00562     {
00563         spacecraft.puts(data_TLM);
00564     }
00565     else if (tlmode_option_1 == 0)
00566     {
00567         spacecraft.puts(data_TLMOpt1);
00568     }
00569     else if (tlmode_option_2 == 0)
00570     {
00571         spacecraft.puts(data_TLMOpt2);
00572     }
00573 }
00574 
00575 // Reset
00576 void clearBuffer(char *arr, int arrLen)
00577 {
00578     int myIndex;
00579     for (myIndex = 0; myIndex < arrLen; myIndex++)
00580     {
00581         arr[myIndex] = '\0'; // terminatore
00582     }
00583 }