HG_REPOSITORIES/LPP/INSTRUMENTATION/SOLO_LFR/DEV_PLE Commit - r282:a83f8aeb97a8

TC_LFR_LOAD_PAS_FILTER_PAR added to the authorized telecommands...

paul -

r282:a83f8aeb97a8 R3_plus

parent child

Context file:

r282:a83f8aeb97a8

Collapse all files

.hgsubstate +1 -1

@@ -1,2 +1,2
1	3081d1f9bb20b2b64a192585337a292a9804e0c5 LFR_basic-parameters	1	3081d1f9bb20b2b64a192585337a292a9804e0c5 LFR_basic-parameters
2	1f3d7ce688e982a378d739596c8e3f8972f40b9d header/lfr_common_headers	2	c3197ff831df5057bdd145a4efd94ded0618661f header/lfr_common_headers

FSW-qt/fsw-qt.pro +2 -2

             TEMPLATE = app
             # CONFIG += console v8 sim
             # CONFIG options =
             #           verbose
             #           boot_messages
             #           debug_messages
             #           cpu_usage_report
             #           stack_report
             #           vhdl_dev
             #           debug_tch
             #           lpp_dpu_destid      /!\ REMOVE BEFORE DELIVERY TO LESIA /!\
             #           debug_watchdog
             CONFIG += console verbose lpp_dpu_destid
             CONFIG -= qt
             include(./sparc.pri)
             # flight software version
             SWVERSION=-1-0
             DEFINES += SW_VERSION_N1=3 # major
-            DEFINES += SW_VERSION_N2=0 # minor
+            DEFINES += SW_VERSION_N2=1 # minor
             DEFINES += SW_VERSION_N3=0 # patch
-            DEFINES += SW_VERSION_N4=22 # internal
+            DEFINES += SW_VERSION_N4=0 # internal
             # <GCOV>
             #QMAKE_CFLAGS_RELEASE += -fprofile-arcs -ftest-coverage
             #LIBS += -lgcov /opt/GCOV/01A/lib/overload.o -lc
             # </GCOV>
             # <CHANGE BEFORE FLIGHT>
             contains( CONFIG, lpp_dpu_destid ) {
                 DEFINES += LPP_DPU_DESTID
             }
             # </CHANGE BEFORE FLIGHT>
             contains( CONFIG, debug_tch ) {
                 DEFINES += DEBUG_TCH
             }
             DEFINES += MSB_FIRST_TCH
             contains( CONFIG, vhdl_dev ) {
                 DEFINES += VHDL_DEV
             }
             contains( CONFIG, verbose ) {
                 DEFINES += PRINT_MESSAGES_ON_CONSOLE
             }
             contains( CONFIG, debug_messages ) {
                 DEFINES += DEBUG_MESSAGES
             }
             contains( CONFIG, cpu_usage_report ) {
                 DEFINES += PRINT_TASK_STATISTICS
             }
             contains( CONFIG, stack_report ) {
                 DEFINES += PRINT_STACK_REPORT
             }
             contains( CONFIG, boot_messages ) {
                 DEFINES += BOOT_MESSAGES
             }
             contains( CONFIG, debug_watchdog ) {
                 DEFINES += DEBUG_WATCHDOG
             }
             #doxygen.target = doxygen
             #doxygen.commands = doxygen ../doc/Doxyfile
             #QMAKE_EXTRA_TARGETS += doxygen
             TARGET = fsw
             INCLUDEPATH += \
                 $${PWD}/../src \
                 $${PWD}/../header \
                 $${PWD}/../header/lfr_common_headers \
                 $${PWD}/../header/processing \
                 $${PWD}/../LFR_basic-parameters
             SOURCES += \
                 ../src/wf_handler.c \
                 ../src/tc_handler.c \
                 ../src/fsw_misc.c \
                 ../src/fsw_init.c \
                 ../src/fsw_globals.c \
                 ../src/fsw_spacewire.c \
                 ../src/tc_load_dump_parameters.c \
                 ../src/tm_lfr_tc_exe.c \
                 ../src/tc_acceptance.c \
                 ../src/processing/fsw_processing.c \
                 ../src/processing/avf0_prc0.c \
                 ../src/processing/avf1_prc1.c \
                 ../src/processing/avf2_prc2.c \
                 ../src/lfr_cpu_usage_report.c \
                 ../LFR_basic-parameters/basic_parameters.c
             HEADERS += \
                 ../header/wf_handler.h \
                 ../header/tc_handler.h \
                 ../header/grlib_regs.h \
                 ../header/fsw_misc.h \
                 ../header/fsw_init.h \
                 ../header/fsw_spacewire.h \
                 ../header/tc_load_dump_parameters.h \
                 ../header/tm_lfr_tc_exe.h \
                 ../header/tc_acceptance.h \
                 ../header/processing/fsw_processing.h \
                 ../header/processing/avf0_prc0.h \
                 ../header/processing/avf1_prc1.h \
                 ../header/processing/avf2_prc2.h \
                 ../header/fsw_params_wf_handler.h \
                 ../header/lfr_cpu_usage_report.h \
                 ../header/lfr_common_headers/ccsds_types.h \
                 ../header/lfr_common_headers/fsw_params.h \
                 ../header/lfr_common_headers/fsw_params_nb_bytes.h \
                 ../header/lfr_common_headers/fsw_params_processing.h \
                 ../header/lfr_common_headers/TC_types.h \
                 ../header/lfr_common_headers/tm_byte_positions.h \
                 ../LFR_basic-parameters/basic_parameters.h \
                 ../LFR_basic-parameters/basic_parameters_params.h \
                 ../header/GscMemoryLPP.hpp

header/tc_load_dump_parameters.h +4 0

             #ifndef TC_LOAD_DUMP_PARAMETERS_H
             #define TC_LOAD_DUMP_PARAMETERS_H
             #include <rtems.h>
             #include <stdio.h>
             #include "fsw_params.h"
             #include "wf_handler.h"
             #include "tm_lfr_tc_exe.h"
             #include "fsw_misc.h"
             #include "basic_parameters_params.h"
             #include "avf0_prc0.h"
             #define FLOAT_EQUAL_ZERO 0.001
             extern unsigned short sequenceCounterParameterDump;
             extern unsigned short sequenceCounters_TM_DUMP[];
             extern float k_coeff_intercalib_f0_norm[ ];
             extern float k_coeff_intercalib_f0_sbm[ ];
             extern float k_coeff_intercalib_f1_norm[ ];
             extern float k_coeff_intercalib_f1_sbm[ ];
             extern float k_coeff_intercalib_f2[ ];
             int action_load_common_par( ccsdsTelecommandPacket_t *TC );
             int action_load_normal_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time);
             int action_load_burst_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time);
             int action_load_sbm1_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time);
             int action_load_sbm2_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id , unsigned char *time);
             int action_load_kcoefficients(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time);
             int action_load_fbins_mask(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time);
+            int action_load_pas_filter_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time);
             int action_dump_kcoefficients(ccsdsTelecommandPacket_t *TC, rtems_id queue_id, unsigned char *time);
             int action_dump_par(ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
             // NORMAL
             int check_normal_par_consistency( ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
             int set_sy_lfr_n_swf_l( ccsdsTelecommandPacket_t *TC );
             int set_sy_lfr_n_swf_p( ccsdsTelecommandPacket_t *TC );
             int set_sy_lfr_n_asm_p( ccsdsTelecommandPacket_t *TC );
             int set_sy_lfr_n_bp_p0( ccsdsTelecommandPacket_t *TC );
             int set_sy_lfr_n_bp_p1( ccsdsTelecommandPacket_t *TC );
             int set_sy_lfr_n_cwf_long_f3( ccsdsTelecommandPacket_t *TC );
             // BURST
             int set_sy_lfr_b_bp_p0( ccsdsTelecommandPacket_t *TC );
             int set_sy_lfr_b_bp_p1( ccsdsTelecommandPacket_t *TC );
             // SBM1
             int set_sy_lfr_s1_bp_p0( ccsdsTelecommandPacket_t *TC );
             int set_sy_lfr_s1_bp_p1( ccsdsTelecommandPacket_t *TC );
             // SBM2
             int set_sy_lfr_s2_bp_p0( ccsdsTelecommandPacket_t *TC );
             int set_sy_lfr_s2_bp_p1( ccsdsTelecommandPacket_t *TC );
             // TC_LFR_UPDATE_INFO
             unsigned int check_update_info_hk_lfr_mode( unsigned char mode );
             unsigned int check_update_info_hk_tds_mode( unsigned char mode );
             unsigned int check_update_info_hk_thr_mode( unsigned char mode );
             // FBINS_MASK
             int set_sy_lfr_fbins( ccsdsTelecommandPacket_t *TC );
+            // TC_LFR_LOAD_PARS_FILTER_PAR
+            int check_sy_lfr_pas_filter_parameters( ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
             // KCOEFFICIENTS
             int set_sy_lfr_kcoeff(ccsdsTelecommandPacket_t *TC , rtems_id queue_id);
             void copyFloatByChar( unsigned char *destination, unsigned char *source );
             void init_parameter_dump( void );
             void init_kcoefficients_dump( void );
             void init_kcoefficients_dump_packet( Packet_TM_LFR_KCOEFFICIENTS_DUMP_t *kcoefficients_dump, unsigned char pkt_nr, unsigned char blk_nr );
             void increment_seq_counter_destination_id_dump( unsigned char *packet_sequence_control, unsigned char destination_id );
             #endif // TC_LOAD_DUMP_PARAMETERS_H

src/tc_acceptance.c +10 -1

             /** Functions related to TeleCommand acceptance.
              *
              * @file
              * @author P. LEROY
              *
              * A group of functions to handle TeleCommands parsing.\n
              *
              */
             #include "tc_acceptance.h"
             #include <stdio.h>
             unsigned int lookUpTableForCRC[256];
             //**********************
             // GENERAL USE FUNCTIONS
             unsigned int Crc_opt( unsigned char D, unsigned int Chk)
             {
                 /** This function generate the CRC for one byte and returns the value of the new syndrome.
                  *
                  * @param D is the current byte of data.
                  * @param Chk is the current syndrom value.
                  *
                  * @return the value of the new syndrome on two bytes.
                  *
                  */
                 return(((Chk << 8) & 0xff00)^lookUpTableForCRC [(((Chk >> 8)^D) & 0x00ff)]);
             }
             void initLookUpTableForCRC( void )
             {
                 /** This function is used to initiates the look-up table for fast CRC computation.
                  *
                  * The global table lookUpTableForCRC[256] is initiated.
                  *
                  */
                 unsigned int i;
                 unsigned int tmp;
                 for (i=0; i<256; i++)
                 {
                     tmp = 0;
                     if((i & 1) != 0) {
                         tmp = tmp ^ 0x1021;
                     }
                     if((i & 2) != 0) {
                         tmp = tmp ^ 0x2042;
                     }
                     if((i & 4) != 0) {
                         tmp = tmp ^ 0x4084;
                     }
                     if((i & 8) != 0) {
                         tmp = tmp ^ 0x8108;
                     }
                     if((i & 16) != 0) {
                         tmp = tmp ^ 0x1231;
                     }
                     if((i & 32) != 0) {
                         tmp = tmp ^ 0x2462;
                     }
                     if((i & 64) != 0) {
                         tmp = tmp ^ 0x48c4;
                     }
                     if((i & 128) != 0) {
                         tmp = tmp ^ 0x9188;
                     }
                     lookUpTableForCRC[i] = tmp;
                 }
             }
             void GetCRCAsTwoBytes(unsigned char* data, unsigned char* crcAsTwoBytes, unsigned int sizeOfData)
             {
                 /** This function calculates a two bytes Cyclic Redundancy Code.
                  *
                  * @param data points to a buffer containing the data on which to compute the CRC.
                  * @param crcAsTwoBytes points points to a two bytes buffer in which the CRC is stored.
                  * @param sizeOfData is the number of bytes of *data* used to compute the CRC.
                  *
                  * The specification of the Cyclic Redundancy Code is described in the following document: ECSS-E-70-41-A.
                  *
                  */
                 unsigned int Chk;
                 int j;
                 Chk = 0xffff; // reset the syndrom to all ones
                 for (j=0; j<sizeOfData; j++) {
                     Chk = Crc_opt(data[j], Chk);
                 }
                 crcAsTwoBytes[0] = (unsigned char) (Chk >> 8);
                 crcAsTwoBytes[1] = (unsigned char) (Chk & 0x00ff);
             }
             //*********************
             // ACCEPTANCE FUNCTIONS
             int tc_parser(ccsdsTelecommandPacket_t * TCPacket, unsigned int estimatedPacketLength, unsigned char *computed_CRC)
             {
                 /** This function parses TeleCommands.
                  *
                  * @param TC points to the TeleCommand that will be parsed.
                  * @param estimatedPacketLength is the PACKET_LENGTH field calculated from the effective length of the received packet.
                  *
                  * @return Status code of the parsing.
                  *
                  * The parsing checks:
                  * - process id
                  * - category
                  * - length: a global check is performed and a per subtype check also
                  * - type
                  * - subtype
                  * - crc
                  *
                  */
                 int status;
                 int status_crc;
                 unsigned char pid;
                 unsigned char category;
                 unsigned int packetLength;
                 unsigned char packetType;
                 unsigned char packetSubtype;
                 unsigned char sid;
                 status = CCSDS_TM_VALID;
                 // APID check *** APID on 2 bytes
                 pid             = ((TCPacket->packetID[0] & 0x07)<<4) + ( (TCPacket->packetID[1]>>4) & 0x0f );   // PID = 11 *** 7 bits xxxxx210 7654xxxx
                 category        = (TCPacket->packetID[1] & 0x0f);         // PACKET_CATEGORY = 12 *** 4 bits xxxxxxxx xxxx3210
                 packetLength    = (TCPacket->packetLength[0] * 256) + TCPacket->packetLength[1];
                 packetType      = TCPacket->serviceType;
                 packetSubtype   = TCPacket->serviceSubType;
                 sid             = TCPacket->sourceID;
                 if ( pid != CCSDS_PROCESS_ID )  // CHECK THE PROCESS ID
                 {
                     status = ILLEGAL_APID;
                 }
                 if (status == CCSDS_TM_VALID)   // CHECK THE CATEGORY
                 {
                     if ( category != CCSDS_PACKET_CATEGORY )
                     {
                         status = ILLEGAL_APID;
                     }
                 }
                 if (status == CCSDS_TM_VALID)   // CHECK THE PACKET_LENGTH FIELD AND THE ESTIMATED PACKET_LENGTH COMPLIANCE
                 {
                     if (packetLength != estimatedPacketLength ) {
                         status = WRONG_LEN_PKT;
                     }
                 }
                 if (status == CCSDS_TM_VALID)   // CHECK THAT THE PACKET DOES NOT EXCEED THE MAX SIZE
                 {
                     if ( packetLength >= CCSDS_TC_PKT_MAX_SIZE ) {
                         status = WRONG_LEN_PKT;
                     }
                 }
                 if (status == CCSDS_TM_VALID)   // CHECK THE TYPE
                 {
                     status = tc_check_type( packetType );
                 }
                 if (status == CCSDS_TM_VALID)   // CHECK THE SUBTYPE
                 {
                     status = tc_check_type_subtype( packetType, packetSubtype );
                 }
                 if (status == CCSDS_TM_VALID)   // CHECK THE SID
                 {
                     status = tc_check_sid( sid );
                 }
                 if (status == CCSDS_TM_VALID)   // CHECK THE SUBTYPE AND LENGTH COMPLIANCE
                 {
                     status = tc_check_length( packetSubtype, packetLength );
                 }
                 status_crc = tc_check_crc( TCPacket, estimatedPacketLength, computed_CRC );
                 if (status == CCSDS_TM_VALID )  // CHECK CRC
                 {
                     status = status_crc;
                 }
                 return status;
             }
             int tc_check_type( unsigned char packetType )
             {
                 /** This function checks that the type of a TeleCommand is valid.
                  *
                  * @param packetType is the type to check.
                  *
                  * @return Status code CCSDS_TM_VALID or ILL_TYPE.
                  *
                  */
                 int status;
                 if ( (packetType == TC_TYPE_GEN) || (packetType == TC_TYPE_TIME))
                 {
                     status = CCSDS_TM_VALID;
                 }
                 else
                 {
                     status = ILL_TYPE;
                 }
                 return status;
             }
             int tc_check_type_subtype( unsigned char packetType, unsigned char packetSubType )
             {
                 /** This function checks that the subtype of a TeleCommand is valid and coherent with the type.
                  *
                  * @param packetType is the type of the TC.
                  * @param packetSubType is the subtype to check.
                  *
                  * @return Status code CCSDS_TM_VALID or ILL_SUBTYPE.
                  *
                  */
                 int status;
                 switch(packetType)
                 {
                 case TC_TYPE_GEN:
                     if ( (packetSubType == TC_SUBTYPE_RESET)
                          || (packetSubType == TC_SUBTYPE_LOAD_COMM)
                          || (packetSubType == TC_SUBTYPE_LOAD_NORM) || (packetSubType == TC_SUBTYPE_LOAD_BURST)
                          || (packetSubType == TC_SUBTYPE_LOAD_SBM1) || (packetSubType == TC_SUBTYPE_LOAD_SBM2)
                          || (packetSubType == TC_SUBTYPE_DUMP)
                          || (packetSubType == TC_SUBTYPE_ENTER)
                          || (packetSubType == TC_SUBTYPE_UPDT_INFO)
                          || (packetSubType == TC_SUBTYPE_EN_CAL)    || (packetSubType == TC_SUBTYPE_DIS_CAL)
                          || (packetSubType == TC_SUBTYPE_LOAD_K)    || (packetSubType == TC_SUBTYPE_DUMP_K)
-                         || (packetSubType == TC_SUBTYPE_LOAD_FBINS) )
+                         || (packetSubType == TC_SUBTYPE_LOAD_FBINS)
+                         || (packetSubType == TC_SUBTYPE_LOAD_PAS_FILTER_PAR))
                     {
                         status = CCSDS_TM_VALID;
                     }
                     else
                     {
                         status = ILL_SUBTYPE;
                     }
                     break;
                 case TC_TYPE_TIME:
                     if (packetSubType == TC_SUBTYPE_UPDT_TIME)
                     {
                         status = CCSDS_TM_VALID;
                     }
                     else
                     {
                         status = ILL_SUBTYPE;
                     }
                     break;
                 default:
                     status = ILL_SUBTYPE;
                     break;
                 }
                 return status;
             }
             int tc_check_sid( unsigned char sid )
             {
                 /** This function checks that the sid of a TeleCommand is valid.
                  *
                  * @param sid is the sid to check.
                  *
                  * @return Status code CCSDS_TM_VALID or CORRUPTED.
                  *
                  */
                 int status;
                 if ( (sid == SID_TC_MISSION_TIMELINE) || (sid == SID_TC_TC_SEQUENCES)   || (sid == SID_TC_RECOVERY_ACTION_CMD)
                      || (sid == SID_TC_BACKUP_MISSION_TIMELINE)
                      || (sid == SID_TC_DIRECT_CMD)       || (sid == SID_TC_SPARE_GRD_SRC1) || (sid == SID_TC_SPARE_GRD_SRC2)
                      || (sid == SID_TC_OBCP)             || (sid == SID_TC_SYSTEM_CONTROL) || (sid == SID_TC_AOCS)
                      || (sid == SID_TC_RPW_INTERNAL))
                 {
                     status = CCSDS_TM_VALID;
                 }
                 else
                 {
                     status = WRONG_SRC_ID;
                 }
                 return status;
             }
             int tc_check_length( unsigned char packetSubType, unsigned int length )
             {
                 /** This function checks that the subtype and the length are compliant.
                  *
                  * @param packetSubType is the subtype to check.
                  * @param length is the length to check.
                  *
                  * @return Status code CCSDS_TM_VALID or ILL_TYPE.
                  *
                  */
                 int status;
                 status = LFR_SUCCESSFUL;
                 switch(packetSubType)
                 {
                 case TC_SUBTYPE_RESET:
                     if (length!=(TC_LEN_RESET-CCSDS_TC_TM_PACKET_OFFSET)) {
                         status = WRONG_LEN_PKT;
                     }
                     else {
                         status = CCSDS_TM_VALID;
                     }
                     break;
                 case TC_SUBTYPE_LOAD_COMM:
                     if (length!=(TC_LEN_LOAD_COMM-CCSDS_TC_TM_PACKET_OFFSET)) {
                         status = WRONG_LEN_PKT;
                     }
                     else {
                         status = CCSDS_TM_VALID;
                     }
                     break;
                 case TC_SUBTYPE_LOAD_NORM:
                     if (length!=(TC_LEN_LOAD_NORM-CCSDS_TC_TM_PACKET_OFFSET)) {
                         status = WRONG_LEN_PKT;
                     }
                     else {
                         status = CCSDS_TM_VALID;
                     }
                     break;
                 case TC_SUBTYPE_LOAD_BURST:
                     if (length!=(TC_LEN_LOAD_BURST-CCSDS_TC_TM_PACKET_OFFSET)) {
                         status = WRONG_LEN_PKT;
                     }
                     else {
                         status = CCSDS_TM_VALID;
                     }
                     break;
                 case TC_SUBTYPE_LOAD_SBM1:
                     if (length!=(TC_LEN_LOAD_SBM1-CCSDS_TC_TM_PACKET_OFFSET)) {
                         status = WRONG_LEN_PKT;
                     }
                     else {
                         status = CCSDS_TM_VALID;
                     }
                     break;
                 case TC_SUBTYPE_LOAD_SBM2:
                     if (length!=(TC_LEN_LOAD_SBM2-CCSDS_TC_TM_PACKET_OFFSET)) {
                         status = WRONG_LEN_PKT;
                     }
                     else {
                         status = CCSDS_TM_VALID;
                     }
                     break;
                 case TC_SUBTYPE_DUMP:
                     if (length!=(TC_LEN_DUMP-CCSDS_TC_TM_PACKET_OFFSET)) {
                         status = WRONG_LEN_PKT;
                     }
                     else {
                         status = CCSDS_TM_VALID;
                     }
                     break;
                 case TC_SUBTYPE_ENTER:
                     if (length!=(TC_LEN_ENTER-CCSDS_TC_TM_PACKET_OFFSET)) {
                         status = WRONG_LEN_PKT;
                     }
                     else {
                         status = CCSDS_TM_VALID;
                     }
                     break;
                 case TC_SUBTYPE_UPDT_INFO:
                     if (length!=(TC_LEN_UPDT_INFO-CCSDS_TC_TM_PACKET_OFFSET)) {
                         status = WRONG_LEN_PKT;
                     }
                     else {
                         status = CCSDS_TM_VALID;
                     }
                     break;
                 case TC_SUBTYPE_EN_CAL:
                     if (length!=(TC_LEN_EN_CAL-CCSDS_TC_TM_PACKET_OFFSET)) {
                         status = WRONG_LEN_PKT;
                     }
                     else {
                         status = CCSDS_TM_VALID;
                     }
                     break;
                 case TC_SUBTYPE_DIS_CAL:
                     if (length!=(TC_LEN_DIS_CAL-CCSDS_TC_TM_PACKET_OFFSET)) {
                         status = WRONG_LEN_PKT;
                     }
                     else {
                         status = CCSDS_TM_VALID;
                     }
                     break;