HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/LFR_FSW Commit - r248:c648c60c0eef

timecode handling modified:...

paul -

r248:c648c60c0eef R3a

parent child

Context file:

r248:c648c60c0eef

Collapse all files

.hgsubstate +1 -1

@@ -1,2 +1,2
1	3081d1f9bb20b2b64a192585337a292a9804e0c5 LFR_basic-parameters	1	3081d1f9bb20b2b64a192585337a292a9804e0c5 LFR_basic-parameters
2	ce0c2f17257170a8529605f68687c18f23973087 header/lfr_common_headers	2	084fd0db5e4139a1096789935e32ef498192f395 header/lfr_common_headers

header/fsw_init.h +3 0

             #ifndef FSW_INIT_H_INCLUDED
             #define FSW_INIT_H_INCLUDED
             #include <rtems.h>
             #include <leon.h>
             #include "fsw_params.h"
             #include "fsw_misc.h"
             #include "fsw_processing.h"
             #include "tc_handler.h"
             #include "wf_handler.h"
             #include "fsw_spacewire.h"
             #include "avf0_prc0.h"
             #include "avf1_prc1.h"
             #include "avf2_prc2.h"
             extern rtems_name  Task_name[20];       /* array of task names */
             extern rtems_id    Task_id[20];         /* array of task ids */
+            extern rtems_name timecode_timer_name;
+            extern rtems_id timecode_timer_id;
             extern unsigned char pa_bia_status_info;
             // RTEMS TASKS
             rtems_task Init( rtems_task_argument argument);
             // OTHER functions
             void create_names( void );
             int create_all_tasks( void );
             int start_all_tasks( void );
             //
             rtems_status_code create_message_queues( void );
+            rtems_status_code create_timecode_timer( void );
             rtems_status_code get_message_queue_id_send( rtems_id *queue_id );
             rtems_status_code get_message_queue_id_recv( rtems_id *queue_id );
             rtems_status_code get_message_queue_id_prc0( rtems_id *queue_id );
             rtems_status_code get_message_queue_id_prc1( rtems_id *queue_id );
             rtems_status_code get_message_queue_id_prc2( rtems_id *queue_id );
             void update_queue_max_count( rtems_id queue_id, unsigned char*fifo_size_max );
             void init_ring(ring_node ring[], unsigned char nbNodes, volatile int buffer[], unsigned int bufferSize );
             //
             int start_recv_send_tasks( void );
             //
             void init_local_mode_parameters( void );
             void reset_local_time( void );
             extern void rtems_cpu_usage_report( void );
             extern void rtems_cpu_usage_reset( void );
             extern void rtems_stack_checker_report_usage( void );
             extern int sched_yield( void );
             #endif // FSW_INIT_H_INCLUDED

header/fsw_spacewire.h +6 0

             #ifndef FSW_SPACEWIRE_H_INCLUDED
             #define FSW_SPACEWIRE_H_INCLUDED
             #include <rtems.h>
             #include <grspw.h>
             #include <fcntl.h>      // for  O_RDWR
             #include <unistd.h>     // for the read call
             #include <sys/ioctl.h>  // for the ioctl call
             #include <errno.h>
             #include "fsw_params.h"
             #include "tc_handler.h"
             #include "fsw_init.h"
             extern spw_stats spacewire_stats;
             extern spw_stats spacewire_stats_backup;
+            extern rtems_name timecode_timer_name;
+            extern rtems_id timecode_timer_id;
             // RTEMS TASK
             rtems_task spiq_task( rtems_task_argument argument );
             rtems_task recv_task( rtems_task_argument unused );
             rtems_task send_task( rtems_task_argument argument );
             rtems_task wtdg_task( rtems_task_argument argument );
             int spacewire_open_link( void );
             int spacewire_start_link( int fd );
             int spacewire_stop_and_start_link( int fd );
             int spacewire_configure_link(int fd );
             int spacewire_reset_link( void );
             void spacewire_set_NP( unsigned char val, unsigned int regAddr ); // No Port force
             void spacewire_set_RE( unsigned char val, unsigned int regAddr ); // RMAP Enable
             void spacewire_compute_stats_offsets( void );
             void spacewire_update_statistics( void );
+            void increase_an_unsigned_char_counter( unsigned char *counter );
             void init_header_cwf( Header_TM_LFR_SCIENCE_CWF_t *header );
             void init_header_swf( Header_TM_LFR_SCIENCE_SWF_t *header );
             void init_header_asm( Header_TM_LFR_SCIENCE_ASM_t *header );
             int spw_send_waveform_CWF( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_CWF_t *header );
             int spw_send_waveform_SWF( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_SWF_t *header );
             int spw_send_waveform_CWF3_light( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_CWF_t *header );
             void spw_send_asm_f0( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_ASM_t *header );
             void spw_send_asm_f1( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_ASM_t *header );
             void spw_send_asm_f2( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_ASM_t *header );
             void spw_send_k_dump( ring_node *ring_node_to_send );
+            rtems_timer_service_routine timecode_timer_routine( rtems_id timer_id, void *user_data );
+            unsigned int check_timecode_and_previous_timecode_coherency(unsigned char currentTimecodeCtr);
+            unsigned int check_timecode_and_internal_time_coherency(unsigned char timecode, unsigned char internalTime);
             void timecode_irq_handler( void *pDev, void *regs, int minor, unsigned int tc );
             void (*grspw_timecode_callback) ( void *pDev, void *regs, int minor, unsigned int tc );
             #endif // FSW_SPACEWIRE_H_INCLUDED

src/fsw_globals.c +2 0

             /** Global variables of the LFR flight software.
              *
              * @file
              * @author P. LEROY
              *
              * Among global variables, there are:
              * - RTEMS names and id.
              * - APB configuration registers.
              * - waveforms global buffers, used by the waveform picker hardware module to store data.
              * - spectral  matrices buffesr, used by the hardware module to store data.
              * - variable related to LFR modes parameters.
              * - the global HK packet buffer.
              * - the global dump parameter buffer.
              *
              */
             #include <rtems.h>
             #include <grspw.h>
             #include "ccsds_types.h"
             #include "grlib_regs.h"
             #include "fsw_params.h"
             #include "fsw_params_wf_handler.h"
             // RTEMS GLOBAL VARIABLES
             rtems_name  misc_name[5];
             rtems_name  Task_name[20];       /* array of task names */
             rtems_id    Task_id[20];         /* array of task ids */
+            rtems_name timecode_timer_name;
+            rtems_id timecode_timer_id;
             int fdSPW = 0;
             int fdUART = 0;
             unsigned char lfrCurrentMode;
             unsigned char pa_bia_status_info;
             // WAVEFORMS GLOBAL VARIABLES   // 2048 * 3 * 4 + 2 * 4 = 24576 + 8 bytes = 24584
                                             //  97 * 256 = 24832 => delta = 248 bytes = 62 words
             // WAVEFORMS GLOBAL VARIABLES   // 2688 * 3 * 4 + 2 * 4 = 32256 + 8 bytes = 32264
                                             // 127 * 256 = 32512 => delta = 248 bytes = 62 words
             // F0 F1 F2 F3
             volatile int wf_buffer_f0[ NB_RING_NODES_F0 * WFRM_BUFFER ] __attribute__((aligned(0x100)));
             volatile int wf_buffer_f1[ NB_RING_NODES_F1 * WFRM_BUFFER ] __attribute__((aligned(0x100)));
             volatile int wf_buffer_f2[ NB_RING_NODES_F2 * WFRM_BUFFER ] __attribute__((aligned(0x100)));
             volatile int wf_buffer_f3[ NB_RING_NODES_F3 * WFRM_BUFFER ] __attribute__((aligned(0x100)));
             //***********************************
             // SPECTRAL MATRICES GLOBAL VARIABLES
             // alignment constraints for the spectral matrices buffers => the first data after the time (8 bytes) shall be aligned on 0x00
             volatile int sm_f0[ NB_RING_NODES_SM_F0 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100)));
             volatile int sm_f1[ NB_RING_NODES_SM_F1 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100)));
             volatile int sm_f2[ NB_RING_NODES_SM_F2 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100)));
             // APB CONFIGURATION REGISTERS
             time_management_regs_t          *time_management_regs   = (time_management_regs_t*)         REGS_ADDR_TIME_MANAGEMENT;
             gptimer_regs_t                  *gptimer_regs           = (gptimer_regs_t *)                REGS_ADDR_GPTIMER;
             waveform_picker_regs_0_1_18_t   *waveform_picker_regs   = (waveform_picker_regs_0_1_18_t*)  REGS_ADDR_WAVEFORM_PICKER;
             spectral_matrix_regs_t          *spectral_matrix_regs   = (spectral_matrix_regs_t*)         REGS_ADDR_SPECTRAL_MATRIX;
             // MODE PARAMETERS
             Packet_TM_LFR_PARAMETER_DUMP_t parameter_dump_packet;
             struct param_local_str param_local;
             unsigned int lastValidEnterModeTime;
             // HK PACKETS
             Packet_TM_LFR_HK_t housekeeping_packet;
             // message queues occupancy
             unsigned char hk_lfr_q_sd_fifo_size_max;
             unsigned char hk_lfr_q_rv_fifo_size_max;
             unsigned char hk_lfr_q_p0_fifo_size_max;
             unsigned char hk_lfr_q_p1_fifo_size_max;
             unsigned char hk_lfr_q_p2_fifo_size_max;
             // sequence counters are incremented by APID (PID + CAT) and destination ID
             unsigned short sequenceCounters_SCIENCE_NORMAL_BURST;
             unsigned short sequenceCounters_SCIENCE_SBM1_SBM2;
             unsigned short sequenceCounters_TC_EXE[SEQ_CNT_NB_DEST_ID];
             unsigned short sequenceCounters_TM_DUMP[SEQ_CNT_NB_DEST_ID];
             unsigned short sequenceCounterHK;
             spw_stats spacewire_stats;
             spw_stats spacewire_stats_backup;

src/fsw_init.c +27 -1

             /** This is the RTEMS initialization module.
              *
              * @file
              * @author P. LEROY
              *
              * This module contains two very different information:
              * - specific instructions to configure the compilation of the RTEMS executive
              * - functions related to the fligth softwre initialization, especially the INIT RTEMS task
              *
              */
             //*************************
             // GPL reminder to be added
             //*************************
             #include <rtems.h>
             /* configuration information */
             #define CONFIGURE_INIT
             #include <bsp.h> /* for device driver prototypes */
             /* configuration information */
             #define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
             #define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
             #define CONFIGURE_MAXIMUM_TASKS 20
             #define CONFIGURE_RTEMS_INIT_TASKS_TABLE
             #define CONFIGURE_EXTRA_TASK_STACKS (3 * RTEMS_MINIMUM_STACK_SIZE)
             #define CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS 32
             #define CONFIGURE_INIT_TASK_PRIORITY 1 // instead of 100
             #define CONFIGURE_INIT_TASK_MODE (RTEMS_DEFAULT_MODES | RTEMS_NO_PREEMPT)
             #define CONFIGURE_INIT_TASK_ATTRIBUTES (RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT)
             #define CONFIGURE_MAXIMUM_DRIVERS 16
             #define CONFIGURE_MAXIMUM_PERIODS 5
-            #define CONFIGURE_MAXIMUM_TIMERS 5  // STAT (1s), send SWF (0.3s), send CWF3 (1s)
+            #define CONFIGURE_MAXIMUM_TIMERS 5 // [spiq] [wtdg] [spacewire_reset_link]
             #define CONFIGURE_MAXIMUM_MESSAGE_QUEUES 5
             #ifdef PRINT_STACK_REPORT
                 #define CONFIGURE_STACK_CHECKER_ENABLED
             #endif
             #include <rtems/confdefs.h>
             /* If --drvmgr was enabled during the configuration of the RTEMS kernel */
             #ifdef RTEMS_DRVMGR_STARTUP
                 #ifdef LEON3
                 /* Add Timer and UART Driver */
                     #ifdef CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
                         #define CONFIGURE_DRIVER_AMBAPP_GAISLER_GPTIMER
                     #endif
                     #ifdef CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
                         #define CONFIGURE_DRIVER_AMBAPP_GAISLER_APBUART
                     #endif
                 #endif
                 #define CONFIGURE_DRIVER_AMBAPP_GAISLER_GRSPW   /* GRSPW Driver */
                 #include <drvmgr/drvmgr_confdefs.h>
             #endif
             #include "fsw_init.h"
             #include "fsw_config.c"
             #include "GscMemoryLPP.hpp"
             void initCache()
             {
                 unsigned int cacheControlRegister;
                 cacheControlRegister = getCacheControlRegister();
                 PRINTF1("(0) cacheControlRegister = %x\n", cacheControlRegister)
                 resetCacheControlRegister();
                 enableInstructionCache();
                 enableDataCache();
                 enableInstructionBurstFetch();
                 cacheControlRegister = getCacheControlRegister();
                 PRINTF1("(1) cacheControlRegister = %x\n", cacheControlRegister)
             }
             rtems_task Init( rtems_task_argument ignored )
             {
                 /** This is the RTEMS INIT taks, it is the first task launched by the system.
                  *
                  * @param unused is the starting argument of the RTEMS task
                  *
                  * The INIT task create and run all other RTEMS tasks.
                  *
                  */
                 //***********
                 // INIT CACHE
                 unsigned char *vhdlVersion;
                 reset_lfr();
                 reset_local_time();
                 rtems_cpu_usage_reset();
                 rtems_status_code status;
                 rtems_status_code status_spw;
                 rtems_isr_entry  old_isr_handler;
                 // UART settings
                 send_console_outputs_on_apbuart_port();
                 set_apbuart_scaler_reload_register(REGS_ADDR_APBUART, APBUART_SCALER_RELOAD_VALUE);
                 enable_apbuart_transmitter();
                 DEBUG_PRINTF("\n\n\n\n\nIn INIT *** Now the console is on port COM1\n")
                 PRINTF("\n\n\n\n\n")
                 initCache();
                 PRINTF("*************************\n")
                 PRINTF("** LFR Flight Software **\n")
                 PRINTF1("** %d.", SW_VERSION_N1)
                 PRINTF1("%d."   , SW_VERSION_N2)
                 PRINTF1("%d."   , SW_VERSION_N3)
                 PRINTF1("%d            **\n", SW_VERSION_N4)
                 vhdlVersion = (unsigned char *) (REGS_ADDR_VHDL_VERSION);
                 PRINTF("** VHDL                **\n")
                 PRINTF1("** %d.", vhdlVersion[1])
                 PRINTF1("%d."   , vhdlVersion[2])
                 PRINTF1("%d              **\n", vhdlVersion[3])
                 PRINTF("*************************\n")
                 PRINTF("\n\n")
                 init_parameter_dump();
                 init_kcoefficients_dump();
                 init_local_mode_parameters();
                 init_housekeeping_parameters();
                 init_k_coefficients_prc0();
                 init_k_coefficients_prc1();
                 init_k_coefficients_prc2();
                 pa_bia_status_info = 0x00;
                 update_last_valid_transition_date( DEFAULT_LAST_VALID_TRANSITION_DATE  );
                 // waveform picker initialization
                 WFP_init_rings();  LEON_Clear_interrupt( IRQ_SPARC_GPTIMER_WATCHDOG );    // initialize the waveform rings
                 WFP_reset_current_ring_nodes();
                 reset_waveform_picker_regs();
                 // spectral matrices initialization
                 SM_init_rings();            // initialize spectral matrices rings
                 SM_reset_current_ring_nodes();
                 reset_spectral_matrix_regs();
                 // configure calibration
                 configureCalibration( false );   // true means interleaved mode, false is for normal mode
                 updateLFRCurrentMode();
                 BOOT_PRINTF1("in INIT *** lfrCurrentMode is %d\n", lfrCurrentMode)
                 create_names();                             // create all names
+                status = create_timecode_timer();           // create the timer used by timecode_irq_handler
+                if (status != RTEMS_SUCCESSFUL)
+                {
+                    PRINTF1("in INIT *** ERR in create_timer_timecode, code %d", status)
+                }
                 status = create_message_queues();           // create message queues
                 if (status != RTEMS_SUCCESSFUL)
                 {
                     PRINTF1("in INIT *** ERR in create_message_queues, code %d", status)
                 }
                 status = create_all_tasks();                // create all tasks
                 if (status != RTEMS_SUCCESSFUL)
                 {
                     PRINTF1("in INIT *** ERR in create_all_tasks, code %d\n", status)
                 }
                 // **************************
                 // <SPACEWIRE INITIALIZATION>
                 grspw_timecode_callback = &timecode_irq_handler;
                 status_spw = spacewire_open_link();     // (1) open the link
                 if ( status_spw != RTEMS_SUCCESSFUL )
                 {
                     PRINTF1("in INIT *** ERR spacewire_open_link code %d\n", status_spw )
                 }
                 if ( status_spw == RTEMS_SUCCESSFUL )   // (2) configure the link
                 {
                     status_spw = spacewire_configure_link( fdSPW );
                     if ( status_spw != RTEMS_SUCCESSFUL )
                     {
                         PRINTF1("in INIT *** ERR spacewire_configure_link code %d\n", status_spw )
                     }
                 }
                 if ( status_spw == RTEMS_SUCCESSFUL)    // (3) start the link
                 {
                     status_spw = spacewire_start_link( fdSPW );
                     if (  status_spw != RTEMS_SUCCESSFUL )
                     {
                         PRINTF1("in INIT *** ERR spacewire_start_link code %d\n",  status_spw )
                     }
                 }
                 // </SPACEWIRE INITIALIZATION>
                 // ***************************
                 status = start_all_tasks();     // start all tasks
                 if (status != RTEMS_SUCCESSFUL)
                 {
                     PRINTF1("in INIT *** ERR in start_all_tasks, code %d", status)
                 }
                 // start RECV and SEND *AFTER* SpaceWire Initialization, due to the timeout of the start call during the initialization
                 status = start_recv_send_tasks();
                 if ( status != RTEMS_SUCCESSFUL )
                 {
                     PRINTF1("in INIT *** ERR start_recv_send_tasks code %d\n",  status )
                 }
                 // suspend science tasks, they will be restarted later depending on the mode
                 status = suspend_science_tasks();   // suspend science tasks (not done in stop_current_mode if current mode = STANDBY)
                 if (status != RTEMS_SUCCESSFUL)
                 {
                     PRINTF1("in INIT *** in suspend_science_tasks *** ERR code: %d\n", status)
                 }
                 // configure IRQ handling for the waveform picker unit
                 status = rtems_interrupt_catch( waveforms_isr,
                                                IRQ_SPARC_WAVEFORM_PICKER,
                                                &old_isr_handler) ;
                 // configure IRQ handling for the spectral matrices unit
                 status = rtems_interrupt_catch( spectral_matrices_isr,
                                                IRQ_SPARC_SPECTRAL_MATRIX,
                                                &old_isr_handler) ;
                 // if the spacewire link is not up then send an event to the SPIQ task for link recovery
                 if ( status_spw != RTEMS_SUCCESSFUL )
                 {
                     status = rtems_event_send( Task_id[TASKID_SPIQ], SPW_LINKERR_EVENT );
                     if ( status != RTEMS_SUCCESSFUL ) {
                         PRINTF1("in INIT *** ERR rtems_event_send to SPIQ code %d\n",  status )
                     }
                 }
                 BOOT_PRINTF("delete INIT\n")
                 set_hk_lfr_sc_potential_flag( true );
                 status = rtems_task_delete(RTEMS_SELF);
             }
             void init_local_mode_parameters( void )
             {
                 /** This function initialize the param_local global variable with default values.
                  *
                  */
                 unsigned int i;
                 // LOCAL PARAMETERS
                 BOOT_PRINTF1("local_sbm1_nb_cwf_max %d \n", param_local.local_sbm1_nb_cwf_max)
                 BOOT_PRINTF1("local_sbm2_nb_cwf_max %d \n", param_local.local_sbm2_nb_cwf_max)
                 BOOT_PRINTF1("nb_interrupt_f0_MAX = %d\n", param_local.local_nb_interrupt_f0_MAX)
                 // init sequence counters
                 for(i = 0; i<SEQ_CNT_NB_DEST_ID; i++)
                 {
                     sequenceCounters_TC_EXE[i] = 0x00;
                     sequenceCounters_TM_DUMP[i] = 0x00;
                 }
                 sequenceCounters_SCIENCE_NORMAL_BURST = 0x00;
                 sequenceCounters_SCIENCE_SBM1_SBM2 =    0x00;
                 sequenceCounterHK =                     TM_PACKET_SEQ_CTRL_STANDALONE << 8;
             }
             void reset_local_time( void )
             {
                 time_management_regs->ctrl = time_management_regs->ctrl | 0x02;  // [0010] software reset, coarse time = 0x80000000
             }
             void create_names( void ) // create all names for tasks and queues
             {
                 /** This function creates all RTEMS names used in the software for tasks and queues.
                  *
                  * @return RTEMS directive status codes:
                  * - RTEMS_SUCCESSFUL - successful completion
                  *
                  */
                 // task names
                 Task_name[TASKID_RECV] = rtems_build_name( 'R', 'E', 'C', 'V' );
                 Task_name[TASKID_ACTN] = rtems_build_name( 'A', 'C', 'T', 'N' );
                 Task_name[TASKID_SPIQ] = rtems_build_name( 'S', 'P', 'I', 'Q' );
                 Task_name[TASKID_LOAD] = rtems_build_name( 'L', 'O', 'A', 'D' );
                 Task_name[TASKID_AVF0] = rtems_build_name( 'A', 'V', 'F', '0' );
                 Task_name[TASKID_SWBD] = rtems_build_name( 'S', 'W', 'B', 'D' );
                 Task_name[TASKID_WFRM] = rtems_build_name( 'W', 'F', 'R', 'M' );
                 Task_name[TASKID_DUMB] = rtems_build_name( 'D', 'U', 'M', 'B' );
                 Task_name[TASKID_HOUS] = rtems_build_name( 'H', 'O', 'U', 'S' );
                 Task_name[TASKID_PRC0] = rtems_build_name( 'P', 'R', 'C', '0' );
                 Task_name[TASKID_CWF3] = rtems_build_name( 'C', 'W', 'F', '3' );
                 Task_name[TASKID_CWF2] = rtems_build_name( 'C', 'W', 'F', '2' );
                 Task_name[TASKID_CWF1] = rtems_build_name( 'C', 'W', 'F', '1' );
                 Task_name[TASKID_SEND] = rtems_build_name( 'S', 'E', 'N', 'D' );
                 Task_name[TASKID_WTDG] = rtems_build_name( 'W', 'T', 'D', 'G' );
                 Task_name[TASKID_AVF1] = rtems_build_name( 'A', 'V', 'F', '1' );
                 Task_name[TASKID_PRC1] = rtems_build_name( 'P', 'R', 'C', '1' );
                 Task_name[TASKID_AVF2] = rtems_build_name( 'A', 'V', 'F', '2' );
                 Task_name[TASKID_PRC2] = rtems_build_name( 'P', 'R', 'C', '2' );
                 // rate monotonic period names
                 name_hk_rate_monotonic = rtems_build_name( 'H', 'O', 'U', 'S' );
                 misc_name[QUEUE_RECV] = rtems_build_name( 'Q', '_', 'R', 'V' );
                 misc_name[QUEUE_SEND] = rtems_build_name( 'Q', '_', 'S', 'D' );
                 misc_name[QUEUE_PRC0] = rtems_build_name( 'Q', '_', 'P', '0' );
                 misc_name[QUEUE_PRC1] = rtems_build_name( 'Q', '_', 'P', '1' );
                 misc_name[QUEUE_PRC2] = rtems_build_name( 'Q', '_', 'P', '2' );
+                timecode_timer_name = rtems_build_name( 'S', 'P', 'T', 'C' );
             }
             int create_all_tasks( void ) // create all tasks which run in the software
             {
                 /** This function creates all RTEMS tasks used in the software.
                  *
                  * @return RTEMS directive status codes:
                  * - RTEMS_SUCCESSFUL - task created successfully
                  * - RTEMS_INVALID_ADDRESS - id is NULL
                  * - RTEMS_INVALID_NAME - invalid task name
                  * - RTEMS_INVALID_PRIORITY - invalid task priority
                  * - RTEMS_MP_NOT_CONFIGURED - multiprocessing not configured
                  * - RTEMS_TOO_MANY - too many tasks created
                  * - RTEMS_UNSATISFIED - not enough memory for stack/FP context
                  * - RTEMS_TOO_MANY - too many global objects
                  *
                  */
                 rtems_status_code status;
                 //**********
                 // SPACEWIRE
                 // RECV
                 status = rtems_task_create(
                     Task_name[TASKID_RECV], TASK_PRIORITY_RECV, RTEMS_MINIMUM_STACK_SIZE,
                     RTEMS_DEFAULT_MODES,
                     RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_RECV]
                 );
                 if (status == RTEMS_SUCCESSFUL) // SEND
                 {
                     status = rtems_task_create(
                         Task_name[TASKID_SEND], TASK_PRIORITY_SEND, RTEMS_MINIMUM_STACK_SIZE * 2,
                         RTEMS_DEFAULT_MODES,
                         RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT, &Task_id[TASKID_SEND]
                     );
                 }
                 if (status == RTEMS_SUCCESSFUL) // WTDG
                 {
                     status = rtems_task_create(
                         Task_name[TASKID_WTDG], TASK_PRIORITY_WTDG, RTEMS_MINIMUM_STACK_SIZE,
                         RTEMS_DEFAULT_MODES,
                         RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_WTDG]
                     );
                 }
                 if (status == RTEMS_SUCCESSFUL) // ACTN
                 {
                     status = rtems_task_create(
                         Task_name[TASKID_ACTN], TASK_PRIORITY_ACTN, RTEMS_MINIMUM_STACK_SIZE,
                         RTEMS_DEFAULT_MODES | RTEMS_NO_PREEMPT,
                         RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT, &Task_id[TASKID_ACTN]
                     );
                 }
                 if (status == RTEMS_SUCCESSFUL) // SPIQ
                 {
                     status = rtems_task_create(
                         Task_name[TASKID_SPIQ], TASK_PRIORITY_SPIQ, RTEMS_MINIMUM_STACK_SIZE,
                         RTEMS_DEFAULT_MODES | RTEMS_NO_PREEMPT,
                         RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_SPIQ]
                     );
                 }
                 //******************
                 // SPECTRAL MATRICES
                 if (status == RTEMS_SUCCESSFUL) // AVF0
                 {
                     status = rtems_task_create(
                         Task_name[TASKID_AVF0], TASK_PRIORITY_AVF0, RTEMS_MINIMUM_STACK_SIZE,
                         RTEMS_DEFAULT_MODES,
                         RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT, &Task_id[TASKID_AVF0]
                     );
                 }
                 if (status == RTEMS_SUCCESSFUL) // PRC0
                 {
                     status = rtems_task_create(
                         Task_name[TASKID_PRC0], TASK_PRIORITY_PRC0, RTEMS_MINIMUM_STACK_SIZE * 2,
                         RTEMS_DEFAULT_MODES | RTEMS_NO_PREEMPT,
                         RTEMS_DEFAULT_ATTRIBUTES | RTEMS_FLOATING_POINT, &Task_id[TASKID_PRC0]
                     );