HG_REPOSITORIES/LPP/INSTRUMENTATION/SOLO_LFR/DEV_PLE Commit - r308:0724e26d58fe

Merge

paul -

r308:0724e26d58fe R3_plus

parent child

Context file:

r308:0724e26d58fe

Expand all files

.buildconfig created 644 +8 0

			@@ -0,0 +1,8
		1	[default]
		2	name=Défaut
		3	device=local
		4	runtime=host
		5	config-opts=
		6	prefix=/home/jeandet/.cache/gnome-builder/install/DEV_PLE/host
		7	app-id=
		8	default=true

CMakeLists.txt created 644 +14 0

			@@ -0,0 +1,14
		1	cmake_minimum_required (VERSION 2.6)
		2	project (LFR_FSW)
		3
		4	if(NOT CMAKE_BUILD_TYPE)
		5	set(CMAKE_BUILD_TYPE "Release" CACHE STRING
		6	"Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE)
		7	endif(NOT CMAKE_BUILD_TYPE)
		8
		9	set(LFR_BP_SRC ${CMAKE_CURRENT_SOURCE_DIR}/LFR_basic-parameters/basic_parameters.c)
		10
		11	SET(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/sparc/")
		12
		13	add_subdirectory(src)
		14	add_subdirectory(timegen)

python_scripts/LFRControlPlugin_reload_fsw 3-0-0-10.py created 755 +13 0

			@@ -0,0 +1,13
		1	# LOAD FSW USING LINK 1
		2	SpwPlugin0.StarDundeeSelectLinkNumber( 1 )
		3
		4	dsu3plugin0.openFile("/opt/LFR/LFR-FSW/3.0.0.10/fsw")
		5	dsu3plugin0.loadFile()
		6
		7	dsu3plugin0.run()
		8
		9	# START SENDING TIMECODES AT 1 Hz
		10	SpwPlugin0.StarDundeeStartTimecodes( 1 )
		11
		12	# it is possible to change the time code frequency
		13	#RMAPPlugin0.changeTimecodeFrequency(2)

sparc/sparc-rtems.cmake created 644 +8 0

			@@ -0,0 +1,8
		1	set(CMAKE_SYSTEM_NAME rtems)
		2
		3	set(CMAKE_C_COMPILER /opt/rtems-4.10/bin/sparc-rtems-gcc)
		4	set(CMAKE_CXX_COMPILER /opt/rtems-4.10/bin/sparc-rtems-g++)
		5	set(CMAKE_LINKER /opt/rtems-4.10/bin/sparc-rtems-g++)
		6	SET(CMAKE_EXE_LINKER_FLAGS "-static")
		7	set(CMAKE_C_LINK_EXECUTABLE "<CMAKE_LINKER> <FLAGS> <CMAKE_CXX_LINK_FLAGS> <LINK_FLAGS> <OBJECTS> -o <TARGET> <LINK_LIBRARIES>")
		8	include_directories("/opt/rtems-4.10/sparc-rtems/leon3/lib/include")

src/CMakeLists.txt created 644 +105 0

			@@ -0,0 +1,105
		1	cmake_minimum_required (VERSION 2.6)
		2	project (FSW)
		3
		4	include(sparc-rtems)
		5
		6	include_directories("../header"
		7	"../header/lfr_common_headers"
		8	"../header/processing"
		9	"../LFR_basic-parameters"
		10	"../src")
		11
		12	set(SOURCES wf_handler.c
		13	tc_handler.c
		14	fsw_misc.c
		15	fsw_init.c
		16	fsw_globals.c
		17	fsw_spacewire.c
		18	tc_load_dump_parameters.c
		19	tm_lfr_tc_exe.c
		20	tc_acceptance.c
		21	processing/fsw_processing.c
		22	processing/avf0_prc0.c
		23	processing/avf1_prc1.c
		24	processing/avf2_prc2.c
		25	lfr_cpu_usage_report.c
		26	${LFR_BP_SRC}
		27	../header/wf_handler.h
		28	../header/tc_handler.h
		29	../header/grlib_regs.h
		30	../header/fsw_misc.h
		31	../header/fsw_init.h
		32	../header/fsw_spacewire.h
		33	../header/tc_load_dump_parameters.h
		34	../header/tm_lfr_tc_exe.h
		35	../header/tc_acceptance.h
		36	../header/processing/fsw_processing.h
		37	../header/processing/avf0_prc0.h
		38	../header/processing/avf1_prc1.h
		39	../header/processing/avf2_prc2.h
		40	../header/fsw_params_wf_handler.h
		41	../header/lfr_cpu_usage_report.h
		42	../header/lfr_common_headers/ccsds_types.h
		43	../header/lfr_common_headers/fsw_params.h
		44	../header/lfr_common_headers/fsw_params_nb_bytes.h
		45	../header/lfr_common_headers/fsw_params_processing.h
		46	../header/lfr_common_headers/tm_byte_positions.h
		47	../LFR_basic-parameters/basic_parameters.h
		48	../LFR_basic-parameters/basic_parameters_params.h
		49	../header/GscMemoryLPP.hpp
		50	)
		51
		52
		53	option(FSW_verbose "Enable verbose LFR" ON)
		54	option(FSW_boot_messages "Enable LFR boot messages" ON)
		55	option(FSW_debug_messages "Enable LFR debug messages" ON)
		56	option(FSW_cpu_usage_report "Enable LFR cpu usage report" OFF)
		57	option(FSW_stack_report "Enable LFR stack report" OFF)
		58	option(FSW_vhdl_dev "?" OFF)
		59	option(FSW_lpp_dpu_destid "Set to debug at LPP" ON)
		60	option(FSW_debug_watchdog "Enable debug watchdog" OFF)
		61	option(FSW_debug_tch "?" OFF)
		62
		63	set(SW_VERSION_N1 "3" CACHE STRING "Choose N1 FSW Version." FORCE)
		64	set(SW_VERSION_N2 "1" CACHE STRING "Choose N2 FSW Version." FORCE)
		65	set(SW_VERSION_N3 "0" CACHE STRING "Choose N3 FSW Version." FORCE)
		66	set(SW_VERSION_N4 "4" CACHE STRING "Choose N4 FSW Version." FORCE)
		67
		68
		69	if(FSW_verbose)
		70	add_definitions(-DPRINT_MESSAGES_ON_CONSOLE)
		71	endif()
		72	if(FSW_boot_messages)
		73	add_definitions(-DBOOT_MESSAGES)
		74	endif()
		75	if(FSW_debug_messages)
		76	add_definitions(-DDEBUG_MESSAGES)
		77	endif()
		78	if(FSW_cpu_usage_report)
		79	add_definitions(-DPRINT_TASK_STATISTICS)
		80	endif()
		81	if(FSW_stack_report)
		82	add_definitions(-DPRINT_STACK_REPORT)
		83	endif()
		84	if(FSW_vhdl_dev)
		85	add_definitions(-DVHDL_DEV)
		86	endif()
		87	if(FSW_lpp_dpu_destid)
		88	add_definitions(-DLPP_DPU_DESTID)
		89	endif()
		90	if(FSW_debug_watchdog)
		91	add_definitions(-DDEBUG_WATCHDOG)
		92	endif()
		93	if(FSW_debug_tch)
		94	add_definitions(-DDEBUG_TCH)
		95	endif()
		96
		97	add_definitions(-DMSB_FIRST_TCH)
		98
		99	add_definitions(-DSWVERSION=-1-0)
		100	add_definitions(-DSW_VERSION_N1=${SW_VERSION_N1})
		101	add_definitions(-DSW_VERSION_N2=${SW_VERSION_N2})
		102	add_definitions(-DSW_VERSION_N3=${SW_VERSION_N3})
		103	add_definitions(-DSW_VERSION_N4=${SW_VERSION_N4})
		104
		105	add_executable(FSW ${SOURCES})

timegen/CMakeLists.txt created 644 +88 0

			@@ -0,0 +1,88
		1	cmake_minimum_required (VERSION 2.6)
		2	project (timegen)
		3
		4	include(sparc-rtems)
		5
		6	include_directories("./src"
		7	"./header"
		8	"./header/processing"
		9	"./src/LFR_basic-parameters")
		10
		11	set(SOURCES src/tc_handler.c
		12	src/fsw_misc.c
		13	src/fsw_init.c
		14	src/fsw_globals.c
		15	src/fsw_spacewire.c
		16	src/tc_acceptance.c
		17	../LFR_basic-parameters/basic_parameters.c
		18	header/tc_handler.h
		19	header/grlib_regs.h
		20	header/fsw_params.h
		21	header/fsw_misc.h
		22	header/fsw_init.h
		23	header/ccsds_types.h
		24	header/fsw_spacewire.h
		25	header/tc_acceptance.h
		26	header/fsw_params_nb_bytes.h
		27	header/fsw_params_processing.h
		28	header/fsw_params_wf_handler.h
		29	header/lfr_cpu_usage_report.h
		30	../LFR_basic-parameters/basic_parameters.h
		31	../LFR_basic-parameters/basic_parameters_params.h
		32	header/TC_types.h
		33	)
		34
		35
		36	option(timegen_verbose "Enable verbose Timegen" ON)
		37	option(timegen_boot_messages "Enable Timegen boot messages" ON)
		38	option(timegen_debug_messages "Enable Timegen debug messages" ON)
		39	option(timegen_cpu_usage_report "Enable Timegen cpu usage report" OFF)
		40	option(timegen_stack_report "Enable Timegen stack report" OFF)
		41	option(timegen_vhdl_dev "?" OFF)
		42	option(timegen_lpp_dpu_destid "Set to debug at LPP" ON)
		43	option(timegen_debug_watchdog "Enable debug watchdog" OFF)
		44	option(timegen_debug_tch "?" OFF)
		45
		46	set(TIMEGEN_SW_VERSION_N1 "3" CACHE STRING "Choose N1 FSW Version." FORCE)
		47	set(TIMEGEN_SW_VERSION_N2 "1" CACHE STRING "Choose N2 FSW Version." FORCE)
		48	set(TIMEGEN_SW_VERSION_N3 "0" CACHE STRING "Choose N3 FSW Version." FORCE)
		49	set(TIMEGEN_SW_VERSION_N4 "4" CACHE STRING "Choose N4 FSW Version." FORCE)
		50
		51
		52	if (timegen_verbose)
		53	add_definitions(-DPRINT_MESSAGES_ON_CONSOLE)
		54	endif()
		55	if (timegen_boot_messages)
		56	add_definitions(-DBOOT_MESSAGES)
		57	endif()
		58	if (timegen_debug_messages)
		59	add_definitions(-DDEBUG_MESSAGES)
		60	endif()
		61	if (timegen_cpu_usage_report)
		62	add_definitions(-DPRINT_TASK_STATISTICS)
		63	endif()
		64	if (timegen_stack_report)
		65	add_definitions(-DPRINT_STACK_REPORT)
		66	endif()
		67	if (timegen_vhdl_dev)
		68	add_definitions(-DVHDL_DEV)
		69	endif()
		70	if (timegen_lpp_dpu_destid)
		71	add_definitions(-DLPP_DPU_DESTID)
		72	endif()
		73	if (timegen_debug_watchdog)
		74	add_definitions(-DDEBUG_WATCHDOG)
		75	endif()
		76	if (timegen_debug_tch)
		77	add_definitions(-DDEBUG_TCH)
		78	endif()
		79
		80	add_definitions(-DMSB_FIRST_TCH)
		81
		82	add_definitions(-DSWVERSION=-1-0)
		83	add_definitions(-DSW_VERSION_N1=${TIMEGEN_SW_VERSION_N1})
		84	add_definitions(-DSW_VERSION_N2=${TIMEGEN_SW_VERSION_N2})
		85	add_definitions(-DSW_VERSION_N3=${TIMEGEN_SW_VERSION_N3})
		86	add_definitions(-DSW_VERSION_N4=${TIMEGEN_SW_VERSION_N4})
		87
		88	add_executable(timegen ${SOURCES})

timegen/block diagram.odg created 644 binary 0 0

NO CONTENT: new file 100644, binary diff hidden

timegen/header/TC_types.h created 644 +219 0

			@@ -0,0 +1,219
		1	#ifndef TC_TYPES_H
		2	#define TC_TYPES_H
		3
		4	#include <ccsds_types.h>
		5
		6	#define PROTOCOLE_IDENTIFIER 0x02
		7
		8	// PACKET ID
		9	#define TC_LFR_PACKET_ID 0x1ccc // PID 76 CAT 12
		10
		11	#define PACKET_LENGTH_TC_LFR_RESET (12 - CCSDS_TC_TM_PACKET_OFFSET)
		12	#define PACKET_LENGTH_TC_LFR_LOAD_COMMON_PAR (14 - CCSDS_TC_TM_PACKET_OFFSET)
		13	#define PACKET_LENGTH_TC_LFR_LOAD_NORMAL_PAR (22 - CCSDS_TC_TM_PACKET_OFFSET)
		14	#define PACKET_LENGTH_TC_LFR_LOAD_BURST_PAR (14 - CCSDS_TC_TM_PACKET_OFFSET)
		15	#define PACKET_LENGTH_TC_LFR_LOAD_SBM1_PAR (14 - CCSDS_TC_TM_PACKET_OFFSET)
		16	#define PACKET_LENGTH_TC_LFR_LOAD_SBM2_PAR (14 - CCSDS_TC_TM_PACKET_OFFSET)
		17	#define PACKET_LENGTH_TC_LFR_DUMP_PAR (12 - CCSDS_TC_TM_PACKET_OFFSET)
		18	#define PACKET_LENGTH_TC_LFR_ENTER_MODE (20 - CCSDS_TC_TM_PACKET_OFFSET)
		19	#define PACKET_LENGTH_TC_LFR_UPDATE_INFO (46 - CCSDS_TC_TM_PACKET_OFFSET)
		20	#define PACKET_LENGTH_TC_LFR_ENABLE_CALIBRATION (12 - CCSDS_TC_TM_PACKET_OFFSET)
		21	#define PACKET_LENGTH_TC_LFR_DISABLE_CALIBRATION (12 - CCSDS_TC_TM_PACKET_OFFSET)
		22	#define PACKET_LENGTH_TC_LFR_UPDATE_TIME (18 - CCSDS_TC_TM_PACKET_OFFSET)
		23
		24	// TC TYPES
		25	#define TC_TYPE_DEFAULT 181
		26	#define TC_TYPE_LFR_UPDATE_TIME 9
		27
		28	// TC SUBTYPES
		29	#define TC_SUBTYPE_RESET 1
		30	#define TC_SUBTYPE_LOAD_COMMON_PAR 11
		31	#define TC_SUBTYPE_LOAD_NORMAL_PAR 13
		32	#define TC_SUBTYPE_LOAD_BURST_PAR 19
		33	#define TC_SUBTYPE_LOAD_SBM1_PAR 25
		34	#define TC_SUBTYPE_LOAD_SBM2_PAR 27
		35	#define TC_SUBTYPE_DUMP_PAR 31
		36	#define TC_SUBTYPE_ENTER_MODE 41
		37	#define TC_SUBTYPE_UPDATE_INFO 51
		38	#define TC_SUBTYPE_ENABLE_CALIBRATION 61
		39	#define TC_SUBTYPE_DISABLE_CALIBRATION 63
		40	#define TC_SUBTYPE_UPDATE_TIME 129
		41
		42	// OTHER CONSTANTS
		43	#define TC_LFR_PACKET_SEQUENCE_CONTROL 0xc000 // PID 76 CAT 12
		44	#define TC_LFR_DATA_FIELD_HEADER0 0x19
		45	#define TC_LFR_LOAD_COMMON_PAR_SPARE 0x00
		46
		47	struct Packet_TC_LFR_RESET_str
		48	{ // the CCSDS header is added by LPPMON
		49	unsigned char packetID[2];
		50	unsigned char packetSequenceControl[2];
		51	unsigned char packetLength[2];
		52	// DATA FIELD HEADER
		53	unsigned char ccsdsSecHeaderFlag_pusVersion_ack;
		54	unsigned char serviceType;
		55	unsigned char serviceSubType;
		56	unsigned char sourceID;
		57	unsigned char crc[2];
		58	};
		59	typedef struct Packet_TC_LFR_RESET_str Packet_TC_LFR_RESET_t;
		60
		61	struct Packet_TC_LFR_ENTER_MODE_str
		62	{ // the CCSDS header is added by LPPMON
		63	unsigned char packetID[2];
		64	unsigned char packetSequenceControl[2];
		65	unsigned char packetLength[2];
		66	// DATA FIELD HEADER
		67	unsigned char ccsdsSecHeaderFlag_pusVersion_ack;
		68	unsigned char serviceType;
		69	unsigned char serviceSubType;
		70	unsigned char sourceID;
		71	unsigned char spare;
		72	unsigned char mode;
		73	unsigned char enterModeTime[6];
		74	unsigned char crc[2];
		75	};
		76	typedef struct Packet_TC_LFR_ENTER_MODE_str Packet_TC_LFR_ENTER_MODE_t;
		77
		78	struct Packet_TC_LFR_UPDATE_INFO_str
		79	{ // the CCSDS header is added by LPPMON
		80	unsigned char packetID[2];
		81	unsigned char packetSequenceControl[2];
		82	unsigned char packetLength[2];
		83	// DATA FIELD HEADER
		84	unsigned char ccsdsSecHeaderFlag_pusVersion_ack;
		85	unsigned char serviceType;
		86	unsigned char serviceSubType;
		87	unsigned char sourceID;
		88	unsigned char set1;
		89	unsigned char set2;
		90	unsigned char set3_bias_setting_set1[6];
		91	unsigned char set3_bias_setting_set2[6];
		92	unsigned char set3_bias_voltage[4];
		93	unsigned char set4[8];
		94	unsigned char set5;
		95	unsigned char set6;
		96	unsigned char set7[8];
		97	unsigned char crc[2];
		98	};
		99	typedef struct Packet_TC_LFR_UPDATE_INFO_str Packet_TC_LFR_UPDATE_INFO_t;
		100
		101	struct Packet_TC_LFR_DUMP_PAR_str
		102	{ // the CCSDS header is added by LPPMON
		103	unsigned char packetID[2];
		104	unsigned char packetSequenceControl[2];
		105	unsigned char packetLength[2];
		106	// DATA FIELD HEADER
		107	unsigned char ccsdsSecHeaderFlag_pusVersion_ack;
		108	unsigned char serviceType;
		109	unsigned char serviceSubType;
		110	unsigned char sourceID;
		111	unsigned char crc[2];
		112
		113	};
		114	typedef struct Packet_TC_LFR_DUMP_PAR_str Packet_TC_LFR_DUMP_PAR_t;
		115
		116	struct Packet_TC_LFR_LOAD_COMMON_PAR_str
		117	{ // the CCSDS header is added by LPPMON
		118	unsigned char packetID[2];
		119	unsigned char packetSequenceControl[2];
		120	unsigned char packetLength[2];
		121	// DATA FIELD HEADER
		122	unsigned char ccsdsSecHeaderFlag_pusVersion_ack;
		123	unsigned char serviceType;
		124	unsigned char serviceSubType;
		125	unsigned char sourceID;
		126	unsigned char spare;
		127	unsigned char bw_sp0_sp1_r0_r1;
		128	unsigned char crc[2];
		129
		130	};
		131	typedef struct Packet_TC_LFR_LOAD_COMMON_PAR_str Packet_TC_LFR_LOAD_COMMON_PAR_t;
		132
		133	struct Packet_TC_LFR_LOAD_NORMAL_PAR_str
		134	{ // the CCSDS header is added by LPPMON
		135	unsigned char packetID[2];
		136	unsigned char packetSequenceControl[2];
		137	unsigned char packetLength[2];
		138	// DATA FIELD HEADER
		139	unsigned char ccsdsSecHeaderFlag_pusVersion_ack;
		140	unsigned char serviceType;
		141	unsigned char serviceSubType;
		142	unsigned char sourceID;
		143	unsigned char sy_lfr_n_swf_l[2];
		144	unsigned char sy_lfr_n_swf_p[2];
		145	unsigned char sy_lfr_n_asm_p[2];
		146	unsigned char sy_lfr_n_bp_p0;
		147	unsigned char sy_lfr_n_bp_p1;
		148	unsigned char sy_lfr_n_cwf_long_f3;
		149	unsigned char lfr_normal_parameters_spare;
		150	unsigned char crc[2];
		151	};
		152	typedef struct Packet_TC_LFR_LOAD_NORMAL_PAR_str Packet_TC_LFR_LOAD_NORMAL_PAR_t;
		153
		154	struct Packet_TC_LFR_LOAD_BURST_SBM1_SBM2_PAR_str
		155	{ // the CCSDS header is added by LPPMON
		156	unsigned char packetID[2];
		157	unsigned char packetSequenceControl[2];
		158	unsigned char packetLength[2];
		159	// DATA FIELD HEADER
		160	unsigned char ccsdsSecHeaderFlag_pusVersion_ack;
		161	unsigned char serviceType;
		162	unsigned char serviceSubType;
		163	unsigned char sourceID;
		164	unsigned char sy_lfr_bp_p0;
		165	unsigned char sy_lfr_bp_p1;
		166	unsigned char crc[2];
		167	};
		168	typedef struct Packet_TC_LFR_LOAD_BURST_SBM1_SBM2_PAR_str Packet_TC_LFR_LOAD_BURST_SBM1_SBM2_PAR_t;
		169
		170	struct Packet_TC_LFR_ENABLE_DISABLE_CALIBRATION_str
		171	{ // the CCSDS header is added by LPPMON
		172	unsigned char packetID[2];
		173	unsigned char packetSequenceControl[2];
		174	unsigned char packetLength[2];
		175	// DATA FIELD HEADER
		176	unsigned char ccsdsSecHeaderFlag_pusVersion_ack;
		177	unsigned char serviceType;
		178	unsigned char serviceSubType;
		179	unsigned char sourceID;
		180	unsigned char crc[2];
		181	};
		182	typedef struct Packet_TC_LFR_ENABLE_DISABLE_CALIBRATION_str Packet_TC_LFR_ENABLE_DISABLE_CALIBRATION_t;
		183
		184	struct Packet_TC_LFR_UPDATE_TIME_str
		185	{ // the CCSDS header is added by LPPMON
		186	unsigned char packetID[2];
		187	unsigned char packetSequenceControl[2];
		188	unsigned char packetLength[2];
		189	// DATA FIELD HEADER
		190	unsigned char ccsdsSecHeaderFlag_pusVersion_ack;
		191	unsigned char serviceType;
		192	unsigned char serviceSubType;
		193	unsigned char sourceID;
		194	unsigned char cp_rpw_time[6];
		195	unsigned char crc[2];
		196	};
		197	typedef struct Packet_TC_LFR_UPDATE_TIME_str Packet_TC_LFR_UPDATE_TIME_t;
		198
		199	struct Packet_TC_LFR_UPDATE_TIME_WITH_HEADER_str
		200	{
		201	unsigned char targetLogicalAddress;
		202	unsigned char protocolIdentifier;
		203	unsigned char reserved;
		204	unsigned char userApplication;
		205	//
		206	unsigned char packetID[2];
		207	unsigned char packetSequenceControl[2];
		208	unsigned char packetLength[2];
		209	// DATA FIELD HEADER
		210	unsigned char ccsdsSecHeaderFlag_pusVersion_ack;
		211	unsigned char serviceType;
		212	unsigned char serviceSubType;
		213	unsigned char sourceID;
		214	unsigned char cp_rpw_time[6];
		215	unsigned char crc[2];
		216	};
		217	typedef struct Packet_TC_LFR_UPDATE_TIME_WITH_HEADER_str Packet_TC_LFR_UPDATE_TIME_WITH_HEADER_t;
		218
		219	#endif // TC_TYPES_H

timegen/header/ccsds_types.h created 644 +665 0

This diff has been collapsed as it changes many lines, (665 lines changed) Show them Hide them
		@@ -0,0 +1,665
	1	#ifndef CCSDS_TYPES_H_INCLUDED
	2	#define CCSDS_TYPES_H_INCLUDED
	3
	4	#include "fsw_params_processing.h"
	5
	6	#define CCSDS_PROTOCOLE_EXTRA_BYTES 4
	7	#define CCSDS_TC_TM_PACKET_OFFSET 7
	8	#define CCSDS_TELEMETRY_HEADER_LENGTH 16+4
	9	#define CCSDS_TM_PKT_MAX_SIZE 4412
	10	#define CCSDS_TELECOMMAND_HEADER_LENGTH 10+4
	11	#define CCSDS_TC_PKT_MAX_SIZE 256
	12	#define CCSDS_TC_PKT_MIN_SIZE 16
	13	#define CCSDS_PROCESS_ID 76
	14	#define CCSDS_PACKET_CATEGORY 12
	15	#define CCSDS_NODE_ADDRESS 0xfe
	16	#define CCSDS_USER_APP 0x00
	17
	18	#define DEFAULT_SPARE1_PUSVERSION_SPARE2 0x10
	19	#define DEFAULT_RESERVED 0x00
	20	#define DEFAULT_HKBIA 0x1e // 0001 1110
	21
	22	// PACKET ID
	23	#define APID_TM_TC_EXE 0x0cc1 // PID 76 CAT 1
	24	#define APID_TM_HK 0x0cc4 // PID 76 CAT 4
	25	#define APID_TM_PARAMETER_DUMP 0x0cc9 // PID 76 CAT 9
	26	#define APID_TM_SCIENCE_NORMAL_BURST 0x0ccc // PID 76 CAT 12
	27	#define APID_TM_SCIENCE_SBM1_SBM2 0x0cfc // PID 79 CAT 12
	28	#define TM_PACKET_PID_DEFAULT 76
	29	#define TM_PACKET_PID_BURST_SBM1_SBM2 79
	30	#define TM_PACKET_CAT_TC_EXE 1
	31	#define TM_PACKET_CAT_HK 4
	32	#define TM_PACKET_CAT_PARAMETER_DUMP 9
	33	#define TM_PACKET_CAT_SCIENCE 12
	34	#define TC_PACKET_CAT 12
	35
	36	// PACKET SEQUENCE CONTROL
	37	#define TM_PACKET_SEQ_CTRL_CONTINUATION 0x00 // [0000 0000]
	38	#define TM_PACKET_SEQ_CTRL_FIRST 0x40 // [0100 0000]
	39	#define TM_PACKET_SEQ_CTRL_LAST 0x80 // [1000 0000]
	40	#define TM_PACKET_SEQ_CTRL_STANDALONE 0xc0 // [1100 0000]
	41	#define TM_PACKET_SEQ_CNT_DEFAULT 0x00 // [0000 0000]
	42
	43	// DESTINATION ID
	44	#define TM_DESTINATION_ID_GROUND 0
	45	#define TM_DESTINATION_ID_MISSION_TIMELINE 110
	46	#define TM_DESTINATION_ID_TC_SEQUENCES 111
	47	#define TM_DESTINATION_ID_RECOVERY_ACTION_COMMAND 112
	48	#define TM_DESTINATION_ID_BACKUP_MISSION_TIMELINE 113
	49	#define TM_DESTINATION_ID_DIRECT_CMD 120
	50	#define TM_DESTINATION_ID_SPARE_GRD_SRC1 121
	51	#define TM_DESTINATION_ID_SPARE_GRD_SRC2 122
	52	#define TM_DESTINATION_ID_OBCP 15
	53	#define TM_DESTINATION_ID_SYSTEM_CONTROL 14
	54	#define TM_DESTINATION_ID_AOCS 11
	55
	56	#define CCSDS_DESTINATION_ID 0x01
	57	#define CCSDS_PROTOCOLE_ID 0x02
	58	#define CCSDS_RESERVED 0x00
	59	#define CCSDS_USER_APP 0x00
	60
	61	#define SIZE_TM_LFR_TC_EXE_NOT_IMPLEMENTED 24
	62	#define SIZE_TM_LFR_TC_EXE_CORRUPTED 32
	63	#define SIZE_HK_PARAMETERS 112
	64
	65	// TC TYPES
	66	#define TC_TYPE_GEN 181
	67	#define TC_TYPE_TIME 9
	68
	69	// TC SUBTYPES
	70	#define TC_SUBTYPE_RESET 1
	71	#define TC_SUBTYPE_LOAD_COMM 11
	72	#define TC_SUBTYPE_LOAD_NORM 13
	73	#define TC_SUBTYPE_LOAD_BURST 19
	74	#define TC_SUBTYPE_LOAD_SBM1 25
	75	#define TC_SUBTYPE_LOAD_SBM2 27
	76	#define TC_SUBTYPE_DUMP 31
	77	#define TC_SUBTYPE_ENTER 41
	78	#define TC_SUBTYPE_UPDT_INFO 51
	79	#define TC_SUBTYPE_EN_CAL 61
	80	#define TC_SUBTYPE_DIS_CAL 63
	81	#define TC_SUBTYPE_UPDT_TIME 129
	82
	83	// TC LEN
	84	#define TC_LEN_RESET 12
	85	#define TC_LEN_LOAD_COMM 14
	86	#define TC_LEN_LOAD_NORM 22
	87	#define TC_LEN_LOAD_BURST 14
	88	#define TC_LEN_LOAD_SBM1 14
	89	#define TC_LEN_LOAD_SBM2 14
	90	#define TC_LEN_DUMP 12
	91	#define TC_LEN_ENTER 20
	92	#define TC_LEN_UPDT_INFO 46
	93	#define TC_LEN_EN_CAL 12
	94	#define TC_LEN_DIS_CAL 12
	95	#define TC_LEN_UPDT_TIME 18
	96
	97	// TM TYPES
	98	#define TM_TYPE_TC_EXE 1
	99	#define TM_TYPE_HK 3
	100	#define TM_TYPE_PARAMETER_DUMP 3
	101	#define TM_TYPE_LFR_SCIENCE 21
	102
	103	// TM SUBTYPES
	104	#define TM_SUBTYPE_EXE_OK 7
	105	#define TM_SUBTYPE_EXE_NOK 8
	106	#define TM_SUBTYPE_HK 25
	107	#define TM_SUBTYPE_PARAMETER_DUMP 25
	108	#define TM_SUBTYPE_SCIENCE 3
	109	#define TM_SUBTYPE_LFR_SCIENCE 3
	110
	111	// FAILURE CODES
	112	#define ILLEGAL_APID 0
	113	#define WRONG_LEN_PKT 1
	114	#define INCOR_CHECKSUM 2
	115	#define ILL_TYPE 3
	116	#define ILL_SUBTYPE 4
	117	#define WRONG_APP_DATA 5 // 0x00 0x05
	118	#define TC_NOT_EXE 42000 // 0xa4 0x10
	119	#define WRONG_SRC_ID 42001 // 0xa4 0x11
	120	#define FUNCT_NOT_IMPL 42002 // 0xa4 0x12
	121	#define FAIL_DETECTED 42003 // 0xa4 0x13
	122	#define NOT_ALLOWED 42004 // 0xa4 0x14
	123	#define CORRUPTED 42005 // 0xa4 0x15
	124	#define CCSDS_TM_VALID 7
	125
	126	// TC SID
	127	#define SID_TC_GROUND 0
	128	#define SID_TC_MISSION_TIMELINE 110
	129	#define SID_TC_TC_SEQUENCES 111
	130	#define SID_TC_RECOVERY_ACTION_CMD 112
	131	#define SID_TC_BACKUP_MISSION_TIMELINE 113
	132	#define SID_TC_DIRECT_CMD 120
	133	#define SID_TC_SPARE_GRD_SRC1 121
	134	#define SID_TC_SPARE_GRD_SRC2 122
	135	#define SID_TC_OBCP 15
	136	#define SID_TC_SYSTEM_CONTROL 14
	137	#define SID_TC_AOCS 11
	138	#define SID_TC_RPW_INTERNAL 254
	139
	140	enum apid_destid{
	141	GROUND,
	142	MISSION_TIMELINE,
	143	TC_SEQUENCES,
	144	RECOVERY_ACTION_CMD,
	145	BACKUP_MISSION_TIMELINE,
	146	DIRECT_CMD,
	147	SPARE_GRD_SRC1,
	148	SPARE_GRD_SRC2,
	149	OBCP,
	150	SYSTEM_CONTROL,
	151	AOCS,
	152	RPW_INTERNAL
	153	};
	154	// SEQUENCE COUNTERS
	155	#define SEQ_CNT_MAX 16383
	156	#define SEQ_CNT_NB_DEST_ID 12
	157
	158	// TM SID
	159	#define SID_HK 1
	160	#define SID_PARAMETER_DUMP 10
	161
	162	#define SID_NORM_SWF_F0 3
	163	#define SID_NORM_SWF_F1 4
	164	#define SID_NORM_SWF_F2 5
	165	#define SID_NORM_CWF_F3 1
	166	#define SID_BURST_CWF_F2 2
	167	#define SID_SBM1_CWF_F1 24
	168	#define SID_SBM2_CWF_F2 25
	169	#define SID_NORM_ASM_F0 11
	170	#define SID_NORM_ASM_F1 12
	171	#define SID_NORM_ASM_F2 13
	172	#define SID_NORM_BP1_F0 14
	173	#define SID_NORM_BP1_F1 15
	174	#define SID_NORM_BP1_F2 16
	175	#define SID_NORM_BP2_F0 19
	176	#define SID_NORM_BP2_F1 20
	177	#define SID_NORM_BP2_F2 21
	178	#define SID_BURST_BP1_F0 17
	179	#define SID_BURST_BP2_F0 22
	180	#define SID_BURST_BP1_F1 18
	181	#define SID_BURST_BP2_F1 23
	182	#define SID_SBM1_BP1_F0 28
	183	#define SID_SBM1_BP2_F0 31
	184	#define SID_SBM2_BP1_F0 29
	185	#define SID_SBM2_BP2_F0 32
	186	#define SID_SBM2_BP1_F1 30
	187	#define SID_SBM2_BP2_F1 33
	188	#define SID_NORM_CWF_LONG_F3 34
	189
	190	// LENGTH (BYTES)
	191	#define LENGTH_TM_LFR_TC_EXE_MAX 32
	192	#define LENGTH_TM_LFR_HK 126
	193
	194	// HEADER_LENGTH
	195	#define TM_HEADER_LEN 16
	196	#define HEADER_LENGTH_TM_LFR_SCIENCE_ASM 28
	197	// PACKET_LENGTH
	198	#define PACKET_LENGTH_TC_EXE_SUCCESS (20 - CCSDS_TC_TM_PACKET_OFFSET)
	199	#define PACKET_LENGTH_TC_EXE_INCONSISTENT (26 - CCSDS_TC_TM_PACKET_OFFSET)
	200	#define PACKET_LENGTH_TC_EXE_NOT_EXECUTABLE (26 - CCSDS_TC_TM_PACKET_OFFSET)
	201	#define PACKET_LENGTH_TC_EXE_NOT_IMPLEMENTED (24 - CCSDS_TC_TM_PACKET_OFFSET)
	202	#define PACKET_LENGTH_TC_EXE_ERROR (24 - CCSDS_TC_TM_PACKET_OFFSET)
	203	#define PACKET_LENGTH_TC_EXE_CORRUPTED (32 - CCSDS_TC_TM_PACKET_OFFSET)
	204	#define PACKET_LENGTH_HK (124 - CCSDS_TC_TM_PACKET_OFFSET)
	205	#define PACKET_LENGTH_PARAMETER_DUMP (36 - CCSDS_TC_TM_PACKET_OFFSET)
	206	#define PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F0 (2228 - CCSDS_TC_TM_PACKET_OFFSET) // 44 * 25 * 2 + 28
	207	#define PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F1 (2628 - CCSDS_TC_TM_PACKET_OFFSET) // 52 * 25 * 2 + 28
	208	#define PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F2 (2428 - CCSDS_TC_TM_PACKET_OFFSET) // 48 * 25 * 2 + 28
	209	#define PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0 (126 - CCSDS_TC_TM_PACKET_OFFSET) // 11 * 9 + 27 (1 spare bit in the header)
	210	#define PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0 (356 - CCSDS_TC_TM_PACKET_OFFSET) // 11 * 30 + 26
	211	#define PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F1 (144 - CCSDS_TC_TM_PACKET_OFFSET) // 13 * 9 + 27 (1 spare bit in the header)
	212	#define PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F1 (416 - CCSDS_TC_TM_PACKET_OFFSET) // 13 * 30 + 26
	213	#define PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F2 (134 - CCSDS_TC_TM_PACKET_OFFSET) // 12 * 9 + 26
	214	#define PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F2 (386 - CCSDS_TC_TM_PACKET_OFFSET) // 12 * 30 + 26
	215	#define PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0 (224 - CCSDS_TC_TM_PACKET_OFFSET) // 22 * 9 + 26
	216	#define PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0 (686 - CCSDS_TC_TM_PACKET_OFFSET) // 22 * 30 + 26
	217	#define PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F1 (260 - CCSDS_TC_TM_PACKET_OFFSET) // 26 * 9 + 26
	218	#define PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F1 (806 - CCSDS_TC_TM_PACKET_OFFSET) // 26 * 30 + 26
	219
	220	#define PACKET_LENGTH_DELTA 11 // 7 + 4
	221
	222	#define SPARE1_PUSVERSION_SPARE2 0x10
	223
	224	// R1
	225	#define TM_LEN_SCI_SWF_340 4101 // 340 * 12 + 10 + 12 - 1
	226	#define TM_LEN_SCI_SWF_8 117 // 8 * 12 + 10 + 12 - 1
	227	#define TM_LEN_SCI_CWF_340 4099 // 340 * 12 + 10 + 10 - 1
	228	#define TM_LEN_SCI_CWF_8 115 // 8 * 12 + 10 + 10 - 1
	229	#define TM_LEN_SCI_CWF3_LIGHT_340 2059 // 340 * 6 + 10 + 10 - 1
	230	#define TM_LEN_SCI_CWF3_LIGHT_8 67 // 8 * 6 + 10 + 10 - 1
	231	// R2
	232	#define TM_LEN_SCI_SWF_304 3669 // 304 * 12 + 10 + 12 - 1
	233	#define TM_LEN_SCI_SWF_224 2709 // 224 * 12 + 10 + 12 - 1
	234	#define TM_LEN_SCI_CWF_336 4051 // 336 * 12 + 10 + 10 - 1
	235	#define TM_LEN_SCI_CWF_672 4051 // 672 * 6 + 10 + 10 - 1
	236	//
	237	#define DEFAULT_PKTCNT 0x07
	238	#define BLK_NR_304 0x0130
	239	#define BLK_NR_224 0x00e0
	240	#define BLK_NR_CWF 0x0150 // 336
	241	#define BLK_NR_CWF_SHORT_F3 0x02a0 // 672
	242
	243	enum TM_TYPE{
	244	TM_LFR_TC_EXE_OK,
	245	TM_LFR_TC_EXE_ERR,
	246	TM_LFR_HK,
	247	TM_LFR_SCI,
	248	TM_LFR_SCI_SBM,
	249	TM_LFR_PAR_DUMP
	250	};
	251
	252	typedef struct {
	253	unsigned char targetLogicalAddress;
	254	unsigned char protocolIdentifier;
	255	unsigned char reserved;
	256	unsigned char userApplication;
	257	// PACKET HEADER
	258	unsigned char packetID[2];
	259	unsigned char packetSequenceControl[2];
	260	unsigned char packetLength[2];
	261	// DATA FIELD HEADER
	262	unsigned char spare1_pusVersion_spare2;
	263	unsigned char serviceType;
	264	unsigned char serviceSubType;
	265	unsigned char destinationID;
	266	unsigned char time[6];
	267	//
	268	unsigned char telecommand_pkt_id[2];
	269	unsigned char pkt_seq_control[2];
	270	} Packet_TM_LFR_TC_EXE_SUCCESS_t;
	271
	272	typedef struct {
	273	unsigned char targetLogicalAddress;
	274	unsigned char protocolIdentifier;
	275	unsigned char reserved;
	276	unsigned char userApplication;
	277	// PACKET HEADER
	278	unsigned char packetID[2];
	279	unsigned char packetSequenceControl[2];
	280	unsigned char packetLength[2];
	281	// DATA FIELD HEADER
	282	unsigned char spare1_pusVersion_spare2;
	283	unsigned char serviceType;
	284	unsigned char serviceSubType;
	285	unsigned char destinationID;
	286	unsigned char time[6];
	287	//
	288	unsigned char tc_failure_code[2];
	289	unsigned char telecommand_pkt_id[2];
	290	unsigned char pkt_seq_control[2];
	291	unsigned char tc_service;
	292	unsigned char tc_subtype;
	293	unsigned char byte_position;
	294	unsigned char rcv_value;
	295	} Packet_TM_LFR_TC_EXE_INCONSISTENT_t;
	296
	297	typedef struct {
	298	unsigned char targetLogicalAddress;
	299	unsigned char protocolIdentifier;
	300	unsigned char reserved;
	301	unsigned char userApplication;
	302	// PACKET HEADER
	303	unsigned char packetID[2];
	304	unsigned char packetSequenceControl[2];
	305	unsigned char packetLength[2];
	306	// DATA FIELD HEADER
	307	unsigned char spare1_pusVersion_spare2;
	308	unsigned char serviceType;
	309	unsigned char serviceSubType;
	310	unsigned char destinationID;
	311	unsigned char time[6];
	312	//
	313	unsigned char tc_failure_code[2];
	314	unsigned char telecommand_pkt_id[2];
	315	unsigned char pkt_seq_control[2];
	316	unsigned char tc_service;
	317	unsigned char tc_subtype;
	318	unsigned char lfr_status_word[2];
	319	} Packet_TM_LFR_TC_EXE_NOT_EXECUTABLE_t;
	320
	321	typedef struct {
	322	unsigned char targetLogicalAddress;
	323	unsigned char protocolIdentifier;
	324	unsigned char reserved;
	325	unsigned char userApplication;
	326	// PACKET HEADER
	327	unsigned char packetID[2];
	328	unsigned char packetSequenceControl[2];
	329	unsigned char packetLength[2];
	330	// DATA FIELD HEADER
	331	unsigned char spare1_pusVersion_spare2;
	332	unsigned char serviceType;
	333	unsigned char serviceSubType;
	334	unsigned char destinationID;
	335	unsigned char time[6];
	336	//
	337	unsigned char tc_failure_code[2];
	338	unsigned char telecommand_pkt_id[2];
	339	unsigned char pkt_seq_control[2];
	340	unsigned char tc_service;
	341	unsigned char tc_subtype;
	342	} Packet_TM_LFR_TC_EXE_NOT_IMPLEMENTED_t;
	343
	344	typedef struct {
	345	unsigned char targetLogicalAddress;
	346	unsigned char protocolIdentifier;
	347	unsigned char reserved;
	348	unsigned char userApplication;
	349	// PACKET HEADER
	350	unsigned char packetID[2];
	351	unsigned char packetSequenceControl[2];
	352	unsigned char packetLength[2];
	353	// DATA FIELD HEADER
	354	unsigned char spare1_pusVersion_spare2;
	355	unsigned char serviceType;
	356	unsigned char serviceSubType;
	357	unsigned char destinationID;
	358	unsigned char time[6];
	359	//
	360	unsigned char tc_failure_code[2];
	361	unsigned char telecommand_pkt_id[2];
	362	unsigned char pkt_seq_control[2];
	363	unsigned char tc_service;
	364	unsigned char tc_subtype;
	365	} Packet_TM_LFR_TC_EXE_ERROR_t;
	366
	367	typedef struct {
	368	unsigned char targetLogicalAddress;
	369	unsigned char protocolIdentifier;
	370	unsigned char reserved;
	371	unsigned char userApplication;
	372	// PACKET HEADER
	373	unsigned char packetID[2];
	374	unsigned char packetSequenceControl[2];
	375	unsigned char packetLength[2];
	376	// DATA FIELD HEADER
	377	unsigned char spare1_pusVersion_spare2;
	378	unsigned char serviceType;
	379	unsigned char serviceSubType;
	380	unsigned char destinationID;
	381	unsigned char time[6];
	382	//
	383	unsigned char tc_failure_code[2];
	384	unsigned char telecommand_pkt_id[2];
	385	unsigned char pkt_seq_control[2];
	386	unsigned char tc_service;
	387	unsigned char tc_subtype;
	388	unsigned char pkt_len_rcv_value[2];
	389	unsigned char pkt_datafieldsize_cnt[2];
	390	unsigned char rcv_crc[2];
	391	unsigned char computed_crc[2];
	392	} Packet_TM_LFR_TC_EXE_CORRUPTED_t;
	393
	394	typedef struct {
	395	unsigned char targetLogicalAddress;
	396	unsigned char protocolIdentifier;
	397	unsigned char reserved;
	398	unsigned char userApplication;
	399	unsigned char packetID[2];
	400	unsigned char packetSequenceControl[2];
	401	unsigned char packetLength[2];
	402	// DATA FIELD HEADER
	403	unsigned char spare1_pusVersion_spare2;
	404	unsigned char serviceType;
	405	unsigned char serviceSubType;
	406	unsigned char destinationID;
	407	unsigned char time[6];
	408	// AUXILIARY HEADER
	409	unsigned char sid;
	410	unsigned char hkBIA;
	411	unsigned char pktCnt;
	412	unsigned char pktNr;
	413	unsigned char acquisitionTime[6];
	414	unsigned char blkNr[2];
	415	} Header_TM_LFR_SCIENCE_SWF_t;
	416
	417	typedef struct {
	418	unsigned char targetLogicalAddress;
	419	unsigned char protocolIdentifier;
	420	unsigned char reserved;
	421	unsigned char userApplication;
	422	unsigned char packetID[2];
	423	unsigned char packetSequenceControl[2];
	424	unsigned char packetLength[2];
	425	// DATA FIELD HEADER
	426	unsigned char spare1_pusVersion_spare2;
	427	unsigned char serviceType;
	428	unsigned char serviceSubType;
	429	unsigned char destinationID;
	430	unsigned char time[6];
	431	// AUXILIARY DATA HEADER
	432	unsigned char sid;
	433	unsigned char hkBIA;
	434	unsigned char acquisitionTime[6];
	435	unsigned char blkNr[2];
	436	} Header_TM_LFR_SCIENCE_CWF_t;
	437
	438	typedef struct {
	439	unsigned char targetLogicalAddress;
	440	unsigned char protocolIdentifier;
	441	unsigned char reserved;
	442	unsigned char userApplication;
	443	unsigned char packetID[2];
	444	unsigned char packetSequenceControl[2];
	445	unsigned char packetLength[2];
	446	// DATA FIELD HEADER
	447	unsigned char spare1_pusVersion_spare2;
	448	unsigned char serviceType;
	449	unsigned char serviceSubType;
	450	unsigned char destinationID;
	451	unsigned char time[6];
	452	// AUXILIARY HEADER
	453	unsigned char sid;
	454	unsigned char biaStatusInfo;
	455	unsigned char pa_lfr_pkt_cnt_asm;
	456	unsigned char pa_lfr_pkt_nr_asm;
	457	unsigned char acquisitionTime[6];
	458	unsigned char pa_lfr_asm_blk_nr[2];
	459	} Header_TM_LFR_SCIENCE_ASM_t;
	460
	461	typedef struct {
	462	unsigned char targetLogicalAddress;
	463	unsigned char protocolIdentifier;
	464	unsigned char reserved;
	465	unsigned char userApplication;
	466	unsigned char packetID[2];
	467	unsigned char packetSequenceControl[2];
	468	unsigned char packetLength[2];
	469	// DATA FIELD HEADER
	470	unsigned char spare1_pusVersion_spare2;
	471	unsigned char serviceType;
	472	unsigned char serviceSubType;
	473	unsigned char destinationID;
	474	unsigned char time[6];
	475	// AUXILIARY HEADER
	476	unsigned char sid;
	477	unsigned char biaStatusInfo;
	478	unsigned char acquisitionTime[6];
	479	unsigned char source_data_spare;
	480	unsigned char pa_lfr_bp_blk_nr[2];
	481	} Header_TM_LFR_SCIENCE_BP_with_spare_t;
	482
	483	typedef struct {
	484	unsigned char targetLogicalAddress;
	485	unsigned char protocolIdentifier;
	486	unsigned char reserved;
	487	unsigned char userApplication;
	488	unsigned char packetID[2];
	489	unsigned char packetSequenceControl[2];
	490	unsigned char packetLength[2];
	491	// DATA FIELD HEADER
	492	unsigned char spare1_pusVersion_spare2;
	493	unsigned char serviceType;
	494	unsigned char serviceSubType;
	495	unsigned char destinationID;
	496	unsigned char time[6];
	497	// AUXILIARY HEADER
	498	unsigned char sid;
	499	unsigned char biaStatusInfo;
	500	unsigned char acquisitionTime[6];
	501	unsigned char pa_lfr_bp_blk_nr[2];
	502	} Header_TM_LFR_SCIENCE_BP_t;
	503
	504	typedef struct {
	505	//targetLogicalAddress is removed by the grspw module
	506	unsigned char protocolIdentifier;
	507	unsigned char reserved;
	508	unsigned char userApplication;
	509	unsigned char packetID[2];
	510	unsigned char packetSequenceControl[2];
	511	unsigned char packetLength[2];
	512	// DATA FIELD HEADER
	513	unsigned char headerFlag_pusVersion_Ack;
	514	unsigned char serviceType;
	515	unsigned char serviceSubType;
	516	unsigned char sourceID;
	517	unsigned char dataAndCRC[CCSDS_TC_PKT_MAX_SIZE-10];
	518	} ccsdsTelecommandPacket_t;
	519
	520	typedef struct {
	521	unsigned char targetLogicalAddress;
	522	unsigned char protocolIdentifier;
	523	unsigned char reserved;
	524	unsigned char userApplication;
	525	unsigned char packetID[2];
	526	unsigned char packetSequenceControl[2];
	527	unsigned char packetLength[2];
	528	unsigned char spare1_pusVersion_spare2;
	529	unsigned char serviceType;
	530	unsigned char serviceSubType;
	531	unsigned char destinationID;
	532	unsigned char time[6];
	533	unsigned char sid;
	534
	535	//**************
	536	// HK PARAMETERS
	537	unsigned char lfr_status_word[2];
	538	unsigned char lfr_sw_version[4];
	539	unsigned char lfr_fpga_version[3];
	540	// ressource statistics
	541	unsigned char hk_lfr_cpu_load;
	542	unsigned char hk_lfr_cpu_load_max;
	543	unsigned char hk_lfr_cpu_load_aver;
	544	// tc statistics
	545	unsigned char hk_lfr_update_info_tc_cnt[2];
	546	unsigned char hk_lfr_update_time_tc_cnt[2];
	547	unsigned char hk_lfr_exe_tc_cnt[2];
	548	unsigned char hk_lfr_rej_tc_cnt[2];
	549	unsigned char hk_lfr_last_exe_tc_id[2];
	550	unsigned char hk_lfr_last_exe_tc_type[2];
	551	unsigned char hk_lfr_last_exe_tc_subtype[2];
	552	unsigned char hk_lfr_last_exe_tc_time[6];
	553	unsigned char hk_lfr_last_rej_tc_id[2];
	554	unsigned char hk_lfr_last_rej_tc_type[2];
	555	unsigned char hk_lfr_last_rej_tc_subtype[2];
	556	unsigned char hk_lfr_last_rej_tc_time[6];
	557	// anomaly statistics
	558	unsigned char hk_lfr_le_cnt[2];
	559	unsigned char hk_lfr_me_cnt[2];
	560	unsigned char hk_lfr_he_cnt[2];
	561	unsigned char hk_lfr_last_er_rid[2];
	562	unsigned char hk_lfr_last_er_code;
	563	unsigned char hk_lfr_last_er_time[6];
	564	// vhdl_blk_status
	565	unsigned char hk_lfr_vhdl_aa_sm;
	566	unsigned char hk_lfr_vhdl_fft_sr;
	567	unsigned char hk_lfr_vhdl_cic_hk;
	568	unsigned char hk_lfr_vhdl_iir_cal;
	569	// spacewire_if_statistics
	570	unsigned char hk_lfr_dpu_spw_pkt_rcv_cnt[2];
	571	unsigned char hk_lfr_dpu_spw_pkt_sent_cnt[2];
	572	unsigned char hk_lfr_dpu_spw_tick_out_cnt;
	573	unsigned char hk_lfr_dpu_spw_last_timc;
	574	// ahb error statistics
	575	unsigned char hk_lfr_last_fail_addr[4];
	576	// temperatures
	577	unsigned char hk_lfr_temp_scm[2];
	578	unsigned char hk_lfr_temp_pcb[2];
	579	unsigned char hk_lfr_temp_fpga[2];
	580	// spacecraft potential
	581	unsigned char hk_lfr_sc_v_f3[2];
	582	unsigned char hk_lfr_sc_e1_f3[2];
	583	unsigned char hk_lfr_sc_e2_f3[2];
	584	// error counters
	585	unsigned char hk_lfr_dpu_spw_parity;
	586	unsigned char hk_lfr_dpu_spw_disconnect;
	587	unsigned char hk_lfr_dpu_spw_escape;
	588	unsigned char hk_lfr_dpu_spw_credit;
	589	unsigned char hk_lfr_dpu_spw_write_sync;
	590	unsigned char hk_lfr_dpu_spw_rx_ahb;
	591	unsigned char hk_lfr_dpu_spw_tx_ahb;
	592	unsigned char hk_lfr_dpu_spw_early_eop;
	593	unsigned char hk_lfr_dpu_spw_invalid_addr;
	594	unsigned char hk_lfr_dpu_spw_eep;
	595	unsigned char hk_lfr_dpu_spw_rx_too_big;
	596	// timecode
	597	unsigned char hk_lfr_timecode_erroneous;
	598	unsigned char hk_lfr_timecode_missing;
	599	unsigned char hk_lfr_timecode_invalid;
	600	// time
	601	unsigned char hk_lfr_time_timecode_it;
	602	unsigned char hk_lfr_time_not_synchro;
	603	unsigned char hk_lfr_time_timecode_ctr;
	604	// hk_lfr_buffer_dpu_
	605	unsigned char hk_lfr_buffer_dpu_tc_fifo;
	606	unsigned char hk_lfr_buffer_dpu_tm_fifo;
	607	// hk_lfr_ahb_
	608	unsigned char hk_lfr_ahb_correctable;
	609	unsigned char hk_lfr_ahb_uncorrectable;
	610	// spare
	611	unsigned char parameters_spare;
	612	} Packet_TM_LFR_HK_t;
	613
	614	typedef struct {
	615	unsigned char targetLogicalAddress;
	616	unsigned char protocolIdentifier;
	617	unsigned char reserved;
	618	unsigned char userApplication;
	619	unsigned char packetID[2];
	620	unsigned char packetSequenceControl[2];
	621	unsigned char packetLength[2];
	622	// DATA FIELD HEADER
	623	unsigned char spare1_pusVersion_spare2;
	624	unsigned char serviceType;
	625	unsigned char serviceSubType;
	626	unsigned char destinationID;
	627	unsigned char time[6];
	628	unsigned char sid;
	629
	630	//******************
	631	// COMMON PARAMETERS
	632	unsigned char unused0;
	633	unsigned char bw_sp0_sp1_r0_r1;
	634
	635	//******************
	636	// NORMAL PARAMETERS
	637	unsigned char sy_lfr_n_swf_l[2];
	638	unsigned char sy_lfr_n_swf_p[2];
	639	unsigned char sy_lfr_n_asm_p[2];
	640	unsigned char sy_lfr_n_bp_p0;
	641	unsigned char sy_lfr_n_bp_p1;
	642	unsigned char sy_lfr_n_cwf_long_f3;
	643	unsigned char lfr_normal_parameters_spare;
	644
	645	//*****************
	646	// BURST PARAMETERS
	647	unsigned char sy_lfr_b_bp_p0;
	648	unsigned char sy_lfr_b_bp_p1;
	649
	650	//****************
	651	// SBM1 PARAMETERS
	652	unsigned char sy_lfr_s1_bp_p0;
	653	unsigned char sy_lfr_s1_bp_p1;
	654
	655	//****************
	656	// SBM2 PARAMETERS
	657	unsigned char sy_lfr_s2_bp_p0;
	658	unsigned char sy_lfr_s2_bp_p1;
	659
	660	// SPARE
	661	unsigned char source_data_spare;
	662	} Packet_TM_LFR_PARAMETER_DUMP_t;
	663
	664
	665	#endif // CCSDS_TYPES_H_INCLUDED

timegen/header/fsw_init.h created 644 +39 0

			@@ -0,0 +1,39
		1	#ifndef FSW_INIT_H_INCLUDED
		2	#define FSW_INIT_H_INCLUDED
		3
		4	#include <rtems.h>
		5	#include <leon.h>
		6
		7	#include "fsw_params.h"
		8	#include "fsw_misc.h"
		9
		10	#include "tc_handler.h"
		11	#include "fsw_spacewire.h"
		12
		13	extern rtems_name Task_name[20]; /* array of task names */
		14	extern rtems_id Task_id[20]; /* array of task ids */
		15
		16	// RTEMS TASKS
		17	rtems_task Init( rtems_task_argument argument);
		18
		19	// OTHER functions
		20	void create_names( void );
		21	int create_all_tasks( void );
		22	int start_all_tasks( void );
		23	//
		24	rtems_status_code create_message_queues( void );
		25	rtems_status_code get_message_queue_id_send( rtems_id *queue_id );
		26	rtems_status_code get_message_queue_id_recv( rtems_id *queue_id );
		27	//
		28	int start_recv_send_tasks( void );
		29	//
		30	void init_local_mode_parameters( void );
		31	void reset_local_time( void );
		32
		33	extern void rtems_cpu_usage_report( void );
		34	extern void rtems_cpu_usage_reset( void );
		35	extern void rtems_stack_checker_report_usage( void );
		36
		37	extern int sched_yield( void );
		38
		39	#endif // FSW_INIT_H_INCLUDED

timegen/header/fsw_misc.h created 644 +45 0

			@@ -0,0 +1,45
		1	#ifndef FSW_MISC_H_INCLUDED
		2	#define FSW_MISC_H_INCLUDED
		3
		4	#include <rtems.h>
		5	#include <stdio.h>
		6	#include <grspw.h>
		7
		8	#include "fsw_params.h"
		9	#include "fsw_spacewire.h"
		10	#include "lfr_cpu_usage_report.h"
		11
		12	rtems_name name_hk_rate_monotonic; // name of the HK rate monotonic
		13	rtems_id HK_id; // id of the HK rate monotonic period
		14
		15	void configure_timer(gptimer_regs_t *gptimer_regs, unsigned char timer, unsigned int clock_divider,
		16	unsigned char interrupt_level, rtems_isr (*timer_isr)() );
		17	void timer_start( gptimer_regs_t *gptimer_regs, unsigned char timer );
		18	void timer_stop( gptimer_regs_t *gptimer_regs, unsigned char timer );
		19	void timer_set_clock_divider(gptimer_regs_t *gptimer_regs, unsigned char timer, unsigned int clock_divider);
		20
		21	// SERIAL LINK
		22	int send_console_outputs_on_apbuart_port( void );
		23	int enable_apbuart_transmitter( void );
		24	void set_apbuart_scaler_reload_register(unsigned int regs, unsigned int value);
		25
		26	// RTEMS TASKS
		27	rtems_task stat_task( rtems_task_argument argument );
		28	rtems_task hous_task( rtems_task_argument argument );
		29	rtems_task dumb_task( rtems_task_argument unused );
		30
		31	void init_housekeeping_parameters( void );
		32	void increment_seq_counter(unsigned short *packetSequenceControl);
		33	void getTime( unsigned char *time);
		34	unsigned long long int getTimeAsUnsignedLongLongInt( );
		35	void send_dumb_hk( void );
		36	void get_v_e1_e2_f3 (unsigned char *spacecraft_potential);
		37	void get_cpu_load( unsigned char *resource_statistics );
		38
		39	extern int sched_yield( void );
		40	extern void rtems_cpu_usage_reset();
		41	extern ring_node *current_ring_node_f3;
		42	extern ring_node *ring_node_to_send_cwf_f3;
		43	extern unsigned short sequenceCounterHK;
		44
		45	#endif // FSW_MISC_H_INCLUDED

timegen/header/fsw_params.h created 644 +255 0

			@@ -0,0 +1,255
		1	#ifndef FSW_PARAMS_H_INCLUDED
		2	#define FSW_PARAMS_H_INCLUDED
		3
		4	#include "grlib_regs.h"
		5	#include "fsw_params_processing.h"
		6	#include "fsw_params_nb_bytes.h"
		7	#include "tm_byte_positions.h"
		8	#include "ccsds_types.h"
		9
		10	#define GRSPW_DEVICE_NAME "/dev/grspw0"
		11	#define UART_DEVICE_NAME "/dev/console"
		12
		13	typedef struct ring_node
		14	{
		15	struct ring_node *previous;
		16	int buffer_address;
		17	struct ring_node *next;
		18	unsigned int status;
		19	} ring_node;
		20
		21	//************************
		22	// flight software version
		23	// this parameters is handled by the Qt project options
		24
		25	#define NB_PACKETS_PER_GROUP_OF_CWF 8 // 8 packets containing 336 blk
		26	#define NB_PACKETS_PER_GROUP_OF_CWF_LIGHT 4 // 4 packets containing 672 blk
		27	#define NB_SAMPLES_PER_SNAPSHOT 2688 // 336 * 8 = 672 * 4 = 2688
		28	#define TIME_OFFSET 2
		29	#define TIME_OFFSET_IN_BYTES 8
		30	#define WAVEFORM_EXTENDED_HEADER_OFFSET 22
		31	#define NB_BYTES_SWF_BLK (2 * 6)
		32	#define NB_WORDS_SWF_BLK 3
		33	#define NB_BYTES_CWF3_LIGHT_BLK 6
		34	#define WFRM_INDEX_OF_LAST_PACKET 6 // waveforms are transmitted in groups of 2048 blocks, 6 packets of 340 and 1 of 8
		35	#define NB_RING_NODES_F0 3 // AT LEAST 3
		36	#define NB_RING_NODES_F1 5 // AT LEAST 3
		37	#define NB_RING_NODES_F2 5 // AT LEAST 3
		38	#define NB_RING_NODES_F3 3 // AT LEAST 3
		39
		40	//**********
		41	// LFR MODES
		42	#define LFR_MODE_STANDBY 0
		43	#define LFR_MODE_NORMAL 1
		44	#define LFR_MODE_BURST 2
		45	#define LFR_MODE_SBM1 3
		46	#define LFR_MODE_SBM2 4
		47
		48	#define TDS_MODE_LFM 5
		49	#define TDS_MODE_STANDBY 0
		50	#define TDS_MODE_NORMAL 1
		51	#define TDS_MODE_BURST 2
		52	#define TDS_MODE_SBM1 3
		53	#define TDS_MODE_SBM2 4
		54
		55	#define THR_MODE_STANDBY 0
		56	#define THR_MODE_NORMAL 1
		57	#define THR_MODE_BURST 2
		58
		59	#define RTEMS_EVENT_MODE_STANDBY RTEMS_EVENT_0
		60	#define RTEMS_EVENT_MODE_NORMAL RTEMS_EVENT_1
		61	#define RTEMS_EVENT_MODE_BURST RTEMS_EVENT_2
		62	#define RTEMS_EVENT_MODE_SBM1 RTEMS_EVENT_3
		63	#define RTEMS_EVENT_MODE_SBM2 RTEMS_EVENT_4
		64	#define RTEMS_EVENT_MODE_SBM2_WFRM RTEMS_EVENT_5
		65	#define RTEMS_EVENT_NORM_BP1_F0 RTEMS_EVENT_6
		66	#define RTEMS_EVENT_NORM_BP2_F0 RTEMS_EVENT_7
		67	#define RTEMS_EVENT_NORM_ASM_F0 RTEMS_EVENT_8 // ASM only in NORM mode
		68	#define RTEMS_EVENT_NORM_BP1_F1 RTEMS_EVENT_9
		69	#define RTEMS_EVENT_NORM_BP2_F1 RTEMS_EVENT_10
		70	#define RTEMS_EVENT_NORM_ASM_F1 RTEMS_EVENT_11 // ASM only in NORM mode
		71	#define RTEMS_EVENT_NORM_BP1_F2 RTEMS_EVENT_12
		72	#define RTEMS_EVENT_NORM_BP2_F2 RTEMS_EVENT_13
		73	#define RTEMS_EVENT_NORM_ASM_F2 RTEMS_EVENT_14 // ASM only in NORM mode
		74	#define RTEMS_EVENT_SBM_BP1_F0 RTEMS_EVENT_15
		75	#define RTEMS_EVENT_SBM_BP2_F0 RTEMS_EVENT_16
		76	#define RTEMS_EVENT_SBM_BP1_F1 RTEMS_EVENT_17
		77	#define RTEMS_EVENT_SBM_BP2_F1 RTEMS_EVENT_18
		78	#define RTEMS_EVENT_BURST_BP1_F0 RTEMS_EVENT_19
		79	#define RTEMS_EVENT_BURST_BP2_F0 RTEMS_EVENT_20
		80	#define RTEMS_EVENT_BURST_BP1_F1 RTEMS_EVENT_21
		81	#define RTEMS_EVENT_BURST_BP2_F1 RTEMS_EVENT_22
		82
		83	//****************************
		84	// LFR DEFAULT MODE PARAMETERS
		85	// COMMON
		86	#define DEFAULT_SY_LFR_COMMON0 0x00
		87	#define DEFAULT_SY_LFR_COMMON1 0x10 // default value 0 0 0 1 0 0 0 0
		88	// NORM
		89	#define DFLT_SY_LFR_N_SWF_L 2048 // nb sample
		90	#define DFLT_SY_LFR_N_SWF_P 300 // sec
		91	#define DFLT_SY_LFR_N_ASM_P 3600 // sec
		92	#define DFLT_SY_LFR_N_BP_P0 4 // sec
		93	#define DFLT_SY_LFR_N_BP_P1 20 // sec
		94	#define DFLT_SY_LFR_N_CWF_LONG_F3 0 // 0 => production of light continuous waveforms at f3
		95	#define MIN_DELTA_SNAPSHOT 16 // sec
		96	// BURST
		97	#define DEFAULT_SY_LFR_B_BP_P0 1 // sec
		98	#define DEFAULT_SY_LFR_B_BP_P1 5 // sec
		99	// SBM1
		100	#define DEFAULT_SY_LFR_S1_BP_P0 1 // sec
		101	#define DEFAULT_SY_LFR_S1_BP_P1 1 // sec
		102	// SBM2
		103	#define DEFAULT_SY_LFR_S2_BP_P0 1 // sec
		104	#define DEFAULT_SY_LFR_S2_BP_P1 5 // sec
		105	// ADDITIONAL PARAMETERS
		106	#define TIME_BETWEEN_TWO_SWF_PACKETS 30 // nb x 10 ms => 300 ms
		107	#define TIME_BETWEEN_TWO_CWF3_PACKETS 1000 // nb x 10 ms => 10 s
		108	// STATUS WORD
		109	#define DEFAULT_STATUS_WORD_BYTE0 0x0d // [0000] [1] [101] mode 4 bits / SPW enabled 1 bit / state is run 3 bits
		110	#define DEFAULT_STATUS_WORD_BYTE1 0x00
		111	//
		112	#define SY_LFR_DPU_CONNECT_TIMEOUT 100 // 100 * 10 ms = 1 s
		113	#define SY_LFR_DPU_CONNECT_ATTEMPT 3
		114	//****************************
		115
		116	//*****************************
		117	// APB REGISTERS BASE ADDRESSES
		118	#define REGS_ADDR_APBUART 0x80000100
		119	#define REGS_ADDR_GPTIMER 0x80000300
		120	#define REGS_ADDR_GRSPW 0x80000500
		121	#define REGS_ADDR_TIME_MANAGEMENT 0x80000600
		122	#define REGS_ADDR_GRGPIO 0x80000b00
		123
		124	#define REGS_ADDR_SPECTRAL_MATRIX 0x80000f00
		125	#define REGS_ADDR_WAVEFORM_PICKER 0x80000f50
		126	#define REGS_ADDR_VHDL_VERSION 0x80000ff0
		127
		128	#define APBUART_CTRL_REG_MASK_DB 0xfffff7ff
		129	#define APBUART_CTRL_REG_MASK_TE 0x00000002
		130	#define APBUART_SCALER_RELOAD_VALUE 0x00000050 // 25 MHz => about 38400 (0x50)
		131
		132	//**********
		133	// IRQ LINES
		134	#define IRQ_SM_SIMULATOR 9
		135	#define IRQ_SPARC_SM_SIMULATOR 0x19 // see sparcv8.pdf p.76 for interrupt levels
		136	#define IRQ_WAVEFORM_PICKER 14
		137	#define IRQ_SPARC_WAVEFORM_PICKER 0x1e // see sparcv8.pdf p.76 for interrupt levels
		138	#define IRQ_SPECTRAL_MATRIX 6
		139	#define IRQ_SPARC_SPECTRAL_MATRIX 0x16 // see sparcv8.pdf p.76 for interrupt levels
		140
		141	//*****
		142	// TIME
		143	#define CLKDIV_SM_SIMULATOR (10416 - 1) // 10 ms => nominal is 1/96 = 0.010416667, 10417 - 1 = 10416
		144	#define TIMER_SM_SIMULATOR 1
		145	#define HK_PERIOD 100 // 100 * 10ms => 1s
		146	#define SY_LFR_TIME_SYN_TIMEOUT_in_ms 2000
		147	#define SY_LFR_TIME_SYN_TIMEOUT_in_ticks 200 // 200 * 10 ms = 2 s
		148
		149	//**********
		150	// LPP CODES
		151	#define LFR_SUCCESSFUL 0
		152	#define LFR_DEFAULT 1
		153	#define LFR_EXE_ERROR 2
		154
		155	//******
		156	// RTEMS
		157	#define TASKID_RECV 1
		158	#define TASKID_ACTN 2
		159	#define TASKID_SPIQ 3
		160	#define TASKID_STAT 4
		161	#define TASKID_AVF0 5
		162	#define TASKID_SWBD 6
		163	#define TASKID_WFRM 7
		164	#define TASKID_DUMB 8
		165	#define TASKID_HOUS 9
		166	#define TASKID_PRC0 10
		167	#define TASKID_CWF3 11
		168	#define TASKID_CWF2 12
		169	#define TASKID_CWF1 13
		170	#define TASKID_SEND 14
		171	#define TASKID_WTDG 15
		172	#define TASKID_AVF1 16
		173	#define TASKID_PRC1 17
		174	#define TASKID_AVF2 18
		175	#define TASKID_PRC2 19
		176
		177	#define TASK_PRIORITY_SPIQ 5
		178	#define TASK_PRIORITY_WTDG 20
		179	#define TASK_PRIORITY_HOUS 30
		180	#define TASK_PRIORITY_CWF1 35 // CWF1 and CWF2 are never running together
		181	#define TASK_PRIORITY_CWF2 35 //
		182	#define TASK_PRIORITY_SWBD 37 // SWBD has a lower priority than WFRM, this is to extract the snapshot before sending it
		183	#define TASK_PRIORITY_WFRM 40
		184	#define TASK_PRIORITY_CWF3 40 // there is a printf in this function, be careful with its priority wrt CWF1
		185	#define TASK_PRIORITY_SEND 45
		186	#define TASK_PRIORITY_RECV 50
		187	#define TASK_PRIORITY_ACTN 50
		188	#define TASK_PRIORITY_AVF0 60
		189	#define TASK_PRIORITY_AVF1 70
		190	#define TASK_PRIORITY_PRC0 100
		191	#define TASK_PRIORITY_PRC1 100
		192	#define TASK_PRIORITY_AVF2 110
		193	#define TASK_PRIORITY_PRC2 110
		194	#define TASK_PRIORITY_STAT 200
		195	#define TASK_PRIORITY_DUMB 200
		196
		197	#define MSG_QUEUE_COUNT_RECV 10
		198	#define MSG_QUEUE_COUNT_SEND 50
		199	#define MSG_QUEUE_COUNT_PRC0 10
		200	#define MSG_QUEUE_COUNT_PRC1 10
		201	#define MSG_QUEUE_COUNT_PRC2 5
		202	#define MSG_QUEUE_SIZE_SEND 810 // 806 + 4 => TM_LFR_SCIENCE_BURST_BP2_F1
		203	#define ACTION_MSG_SPW_IOCTL_SEND_SIZE 24 // hlen hdr dlen data sent options
		204	#define MSG_QUEUE_SIZE_PRC0 20 // two pointers and one rtems_event + 2 integers
		205	#define MSG_QUEUE_SIZE_PRC1 20 // two pointers and one rtems_event + 2 integers
		206	#define MSG_QUEUE_SIZE_PRC2 20 // two pointers and one rtems_event + 2 integers
		207
		208	#define QUEUE_RECV 0
		209	#define QUEUE_SEND 1
		210	#define QUEUE_PRC0 2
		211	#define QUEUE_PRC1 3
		212	#define QUEUE_PRC2 4
		213
		214	//*******
		215	// MACROS
		216	#ifdef PRINT_MESSAGES_ON_CONSOLE
		217	#define PRINTF(x) printf(x);
		218	#define PRINTF1(x,y) printf(x,y);
		219	#define PRINTF2(x,y,z) printf(x,y,z);
		220	#else
		221	#define PRINTF(x) ;
		222	#define PRINTF1(x,y) ;
		223	#define PRINTF2(x,y,z) ;
		224	#endif
		225
		226	#ifdef BOOT_MESSAGES
		227	#define BOOT_PRINTF(x) printf(x);
		228	#define BOOT_PRINTF1(x,y) printf(x,y);
		229	#define BOOT_PRINTF2(x,y,z) printf(x,y,z);
		230	#else
		231	#define BOOT_PRINTF(x) ;
		232	#define BOOT_PRINTF1(x,y) ;
		233	#define BOOT_PRINTF2(x,y,z) ;
		234	#endif
		235
		236	#ifdef DEBUG_MESSAGES
		237	#define DEBUG_PRINTF(x) printf(x);
		238	#define DEBUG_PRINTF1(x,y) printf(x,y);
		239	#define DEBUG_PRINTF2(x,y,z) printf(x,y,z);
		240	#else
		241	#define DEBUG_PRINTF(x) ;
		242	#define DEBUG_PRINTF1(x,y) ;
		243	#define DEBUG_PRINTF2(x,y,z) ;
		244	#endif
		245
		246	#define CPU_USAGE_REPORT_PERIOD 6 // * 10 s = period
		247
		248	struct param_local_str{
		249	unsigned int local_sbm1_nb_cwf_sent;
		250	unsigned int local_sbm1_nb_cwf_max;
		251	unsigned int local_sbm2_nb_cwf_sent;
		252	unsigned int local_sbm2_nb_cwf_max;
		253	};
		254
		255	#endif // FSW_PARAMS_H_INCLUDED

timegen/header/fsw_params_nb_bytes.h created 644 +37 0

			@@ -0,0 +1,37
		1	#ifndef TM_BYTE_POSITIONS_H
		2	#define TM_BYTE_POSITIONS_H
		3
		4	// SEQUENCE_CNT
		5	#define PACKET_POS_SEQUENCE_CNT 6 // 4 + 2
		6
		7	// TC_LFR_LOAD_COMMON_PAR
		8
		9	// TC_LFR_LOAD_NORMAL_PAR
		10	#define DATAFIELD_POS_SY_LFR_N_SWF_L 0
		11	#define DATAFIELD_POS_SY_LFR_N_SWF_P 2
		12	#define DATAFIELD_POS_SY_LFR_N_ASM_P 4
		13	#define DATAFIELD_POS_SY_LFR_N_BP_P0 6
		14	#define DATAFIELD_POS_SY_LFR_N_BP_P1 7
		15	#define DATAFIELD_POS_SY_LFR_N_CWF_LONG_F3 8
		16
		17	// TC_LFR_LOAD_BURST_PAR
		18	#define DATAFIELD_POS_SY_LFR_B_BP_P0 0
		19	#define DATAFIELD_POS_SY_LFR_B_BP_P1 1
		20
		21	// TC_LFR_LOAD_SBM1_PAR
		22	#define DATAFIELD_POS_SY_LFR_S1_BP_P0 0
		23	#define DATAFIELD_POS_SY_LFR_S1_BP_P1 1
		24
		25	// TC_LFR_LOAD_SBM2_PAR
		26	#define DATAFIELD_POS_SY_LFR_S2_BP_P0 0
		27	#define DATAFIELD_POS_SY_LFR_S2_BP_P1 1
		28
		29	// TC_LFR_UPDATE_INFO
		30	#define BYTE_POS_UPDATE_INFO_PARAMETERS_SET5 34
		31	#define BYTE_POS_UPDATE_INFO_PARAMETERS_SET6 35
		32
		33	// TC_LFR_ENTER_MODE
		34	#define BYTE_POS_CP_MODE_LFR_SET 11
		35	#define BYTE_POS_CP_LFR_ENTER_MODE_TIME 12
		36
		37	#endif // TM_BYTE_POSITIONS_H

timegen/header/fsw_params_processing.h created 644 +70 0

			@@ -0,0 +1,70
		1	#ifndef FSW_PARAMS_PROCESSING_H
		2	#define FSW_PARAMS_PROCESSING_H
		3
		4	#define NB_BINS_PER_SM 128
		5	#define NB_VALUES_PER_SM 25
		6	#define TOTAL_SIZE_SM 3200 // 25 * 128 = 0xC80
		7	#define TOTAL_SIZE_NORM_BP1_F0 99 // 11 * 9 = 99
		8	#define TOTAL_SIZE_NORM_BP1_F1 117 // 13 * 9 = 117
		9	#define TOTAL_SIZE_NORM_BP1_F2 108 // 12 * 9 = 108
		10	#define TOTAL_SIZE_SBM1_BP1_F0 198 // 22 * 9 = 198
		11	//
		12	#define NB_RING_NODES_SM_F0 12 // AT LEAST 3
		13	#define NB_RING_NODES_ASM_BURST_SBM_F0 10 // AT LEAST 3
		14	#define NB_RING_NODES_ASM_NORM_F0 10 // AT LEAST 3
		15	#define NB_RING_NODES_SM_F1 3 // AT LEAST 3
		16	#define NB_RING_NODES_ASM_BURST_SBM_F1 5 // AT LEAST 3
		17	#define NB_RING_NODES_ASM_NORM_F1 5 // AT LEAST 3
		18	#define NB_RING_NODES_SM_F2 3 // AT LEAST 3
		19	#define NB_RING_NODES_ASM_BURST_SBM_F2 3 // AT LEAST 3
		20	#define NB_RING_NODES_ASM_NORM_F2 3 // AT LEAST 3
		21	//
		22	#define NB_BINS_PER_ASM_F0 88
		23	#define NB_BINS_PER_PKT_ASM_F0 44
		24	#define TOTAL_SIZE_ASM_F0_IN_BYTES 4400 // 25 * 88 * 2
		25	#define ASM_F0_INDICE_START 17 // 88 bins
		26	#define ASM_F0_INDICE_STOP 104 // 2 packets of 44 bins
		27	//
		28	#define NB_BINS_PER_ASM_F1 104
		29	#define NB_BINS_PER_PKT_ASM_F1 52
		30	#define TOTAL_SIZE_ASM_F1_IN_BYTES 5200 // 25 * 104 * 2
		31	#define ASM_F1_INDICE_START 6 // 104 bins
		32	#define ASM_F1_INDICE_STOP 109 // 2 packets of 52 bins
		33	//
		34	#define NB_BINS_PER_ASM_F2 96
		35	#define NB_BINS_PER_PKT_ASM_F2 48
		36	#define TOTAL_SIZE_ASM_F2_IN_BYTES 4800 // 25 * 96 * 2
		37	#define ASM_F2_INDICE_START 7 // 96 bins
		38	#define ASM_F2_INDICE_STOP 102 // 2 packets of 48 bins
		39	//
		40	#define NB_BINS_COMPRESSED_SM_F0 11
		41	#define NB_BINS_COMPRESSED_SM_F1 13
		42	#define NB_BINS_COMPRESSED_SM_F2 12
		43	#define NB_BINS_COMPRESSED_SM_SBM_F0 22
		44	#define NB_BINS_COMPRESSED_SM_SBM_F1 26
		45	#define NB_BINS_COMPRESSED_SM_SBM_F2 24
		46	//
		47	#define NB_BYTES_PER_BP1 9
		48	//
		49	#define NB_BINS_TO_AVERAGE_ASM_F0 8
		50	#define NB_BINS_TO_AVERAGE_ASM_F1 8
		51	#define NB_BINS_TO_AVERAGE_ASM_F2 8
		52	#define NB_BINS_TO_AVERAGE_ASM_SBM_F0 4
		53	#define NB_BINS_TO_AVERAGE_ASM_SBM_F1 4
		54	#define NB_BINS_TO_AVERAGE_ASM_SBM_F2 4
		55	//
		56	#define TOTAL_SIZE_COMPRESSED_ASM_NORM_F0 275 // 11 * 25 WORDS
		57	#define TOTAL_SIZE_COMPRESSED_ASM_NORM_F1 325 // 13 * 25 WORDS
		58	#define TOTAL_SIZE_COMPRESSED_ASM_NORM_F2 300 // 12 * 25 WORDS
		59	#define TOTAL_SIZE_COMPRESSED_ASM_SBM_F0 550 // 22 * 25 WORDS
		60	#define TOTAL_SIZE_COMPRESSED_ASM_SBM_F1 650 // 26 * 25 WORDS
		61	#define TOTAL_SIZE_COMPRESSED_ASM_SBM_F2 600 // 24 * 25 WORDS
		62	#define TOTAL_SIZE_BP1_NORM_F0 99 // 9 * 11 UNSIGNED CHAR
		63	#define TOTAL_SIZE_BP1_SBM_F0 198 // 9 * 22 UNSIGNED CHAR
		64	// GENERAL
		65	#define NB_SM_BEFORE_AVF0 8 // must be 8 due to the SM_average() function
		66	#define NB_SM_BEFORE_AVF1 8 // must be 8 due to the SM_average() function
		67	#define NB_SM_BEFORE_AVF2 1 // must be 1 due to the SM_average_f2() function
		68
		69	#endif // FSW_PARAMS_PROCESSING_H
		70

timegen/header/fsw_params_wf_handler.h created 644 +8 0

			@@ -0,0 +1,8
		1	#ifndef FSW_PARAMS_WF_HANDLER_H
		2	#define FSW_PARAMS_WF_HANDLER_H
		3
		4	#define WFRM_BUFFER 8128 // (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK) + TIME_OFFSET + 62
		5	// (2688 * 3 ) + 2 + 62 = 8128 = 0X1FC0
		6	// 8128 * 4 = 32512 = 0x7F00
		7
		8	#endif // FSW_PARAMS_WF_HANDLER_H

timegen/header/fsw_spacewire.h created 644 +53 0

			@@ -0,0 +1,53
		1	#ifndef FSW_SPACEWIRE_H_INCLUDED
		2	#define FSW_SPACEWIRE_H_INCLUDED
		3
		4	#include <rtems.h>
		5	#include <grspw.h>
		6
		7	#include <fcntl.h> // for O_RDWR
		8	#include <unistd.h> // for the read call
		9	#include <sys/ioctl.h> // for the ioctl call
		10	#include <errno.h>
		11
		12	#include "fsw_params.h"
		13	#include "tc_handler.h"
		14	#include "TC_types.h"
		15
		16	extern spw_stats spacewire_stats;
		17	extern spw_stats spacewire_stats_backup;
		18	extern rtems_id rtems_task_id_updt;
		19
		20	void resetLocalCoarseTime();
		21	void setLocalCoarseTime( unsigned int value );
		22	unsigned int getLocalCoarseTime();
		23	void incrementLocalCoarseTime();
		24
		25	// TC_LFR_UPDATE_TIME
		26	void initLookUpTableForCRC( void );
		27	void GetCRCAsTwoBytes(unsigned char* data, unsigned char* crcAsTwoBytes, unsigned int sizeOfData);
		28	unsigned int Crc_opt( unsigned char D, unsigned int Chk);
		29	void updateTimePacket(unsigned int time, Packet_TC_LFR_UPDATE_TIME_WITH_HEADER_t *packet);
		30
		31	// RTEMS TASK
		32	rtems_task spiq_task( rtems_task_argument argument );
		33	rtems_task recv_task( rtems_task_argument unused );
		34	rtems_task send_task( rtems_task_argument argument );
		35	rtems_task wtdg_task( rtems_task_argument argument );
		36	rtems_task updt_task( rtems_task_argument unused );
		37
		38	int spacewire_open_link( void );
		39	int spacewire_start_link( int fd );
		40	int spacewire_stop_and_start_link( int fd );
		41	int spacewire_configure_link(int fd );
		42	int spacewire_reset_link( void );
		43	void spacewire_set_NP( unsigned char val, unsigned int regAddr ); // No Port force
		44	void spacewire_set_RE( unsigned char val, unsigned int regAddr ); // RMAP Enable
		45	void spacewire_compute_stats_offsets( void );
		46	void spacewire_update_statistics( void );
		47
		48	void timecode_irq_handler( void pDev, void regs, int minor, unsigned int tc );
		49	rtems_timer_service_routine user_routine( rtems_id timer_id, void *user_data );
		50
		51	void (grspw_timecode_callback) ( void pDev, void *regs, int minor, unsigned int tc );
		52
		53	#endif // FSW_SPACEWIRE_H_INCLUDED

timegen/header/grlib_regs.h created 644 +109 0

			@@ -0,0 +1,109
		1	#ifndef GRLIB_REGS_H_INCLUDED
		2	#define GRLIB_REGS_H_INCLUDED
		3
		4	#define NB_GPTIMER 3
		5
		6	struct apbuart_regs_str{
		7	volatile unsigned int data;
		8	volatile unsigned int status;
		9	volatile unsigned int ctrl;
		10	volatile unsigned int scaler;
		11	volatile unsigned int fifoDebug;
		12	};
		13
		14	struct grgpio_regs_str{
		15	volatile int io_port_data_register;
		16	int io_port_output_register;
		17	int io_port_direction_register;
		18	int interrupt_mak_register;
		19	int interrupt_polarity_register;
		20	int interrupt_edge_register;
		21	int bypass_register;
		22	int reserved;
		23	// 0x20-0x3c interrupt map register(s)
		24	};
		25
		26	typedef struct {
		27	volatile unsigned int counter;
		28	volatile unsigned int reload;
		29	volatile unsigned int ctrl;
		30	volatile unsigned int unused;
		31	} timer_regs_t;
		32
		33	typedef struct {
		34	volatile unsigned int scaler_value;
		35	volatile unsigned int scaler_reload;
		36	volatile unsigned int conf;
		37	volatile unsigned int unused0;
		38	timer_regs_t timer[NB_GPTIMER];
		39	} gptimer_regs_t;
		40
		41	typedef struct {
		42	volatile int ctrl; // bit 0 forces the load of the coarse_time_load value and resets the fine_time
		43	volatile int coarse_time_load;
		44	volatile int coarse_time;
		45	volatile int fine_time;
		46	} time_management_regs_t;
		47
		48	typedef struct {
		49	volatile int data_shaping; // 0x00 00 *** R1 R0 SP1 SP0 BW
		50	volatile int burst_enable; // 0x04 01 *** burst f2, f1, f0 enable f3, f2, f1, f0
		51	volatile int addr_data_f0; // 0x08 10 ***
		52	volatile int addr_data_f1; // 0x0c 11 ***
		53	volatile int addr_data_f2; // 0x10 100 ***
		54	volatile int addr_data_f3; // 0x14 101 ***
		55	volatile int status; // 0x18 110 ***
		56	volatile int delta_snapshot; // 0x1c 111 ***
		57	volatile int delta_f2_f1; // 0x20 0000 ***
		58	volatile int delta_f2_f0; // 0x24 0001 ***
		59	volatile int nb_burst_available;// 0x28 0010 ***
		60	volatile int nb_snapshot_param; // 0x2c 0011 ***
		61	} waveform_picker_regs_t;
		62
		63	typedef struct{
		64	int data_shaping; // 0x00 00 *** R1 R0 SP1 SP0 BW
		65	int run_burst_enable; // 0x04 01 * [run * burst f2, f1, f0 *** enable f3, f2, f1, f0 ]
		66	int addr_data_f0; // 0x08
		67	int addr_data_f1; // 0x0c
		68	int addr_data_f2; // 0x10
		69	int addr_data_f3; // 0x14
		70	volatile int status; // 0x18
		71	int delta_snapshot; // 0x1c
		72	int delta_f0; // 0x20
		73	int delta_f0_2; // 0x24
		74	int delta_f1; // 0x28
		75	int delta_f2; // 0x2c
		76	int nb_data_by_buffer; // 0x30
		77	int snapshot_param; // 0x34
		78	int start_date; // 0x38
		79	int nb_word_in_buffer; // 0x3c
		80	} waveform_picker_regs_new_t;
		81
		82	typedef struct {
		83	volatile int config; // 0x00
		84	volatile int status; // 0x04
		85	volatile int f0_0_address; // 0x08
		86	volatile int f0_1_address; // 0x0C
		87	//
		88	volatile int f1_0_address; // 0x10
		89	volatile int f1_1_address; // 0x14
		90	volatile int f2_0_address; // 0x18
		91	volatile int f2_1_address; // 0x1C
		92	//
		93	volatile unsigned int f0_0_coarse_time; // 0x20
		94	volatile unsigned int f0_0_fine_time; // 0x24
		95	volatile unsigned int f0_1_coarse_time; // 0x28
		96	volatile unsigned int f0_1_fine_time; // 0x2C
		97	//
		98	volatile unsigned int f1_0_coarse_time; // 0x30
		99	volatile unsigned int f1_0_fine_time; // 0x34
		100	volatile unsigned int f1_1_coarse_time; // 0x38
		101	volatile unsigned int f1_1_time_time; // 0x3C
		102	//
		103	volatile unsigned int f2_0_coarse_time; // 0x40
		104	volatile unsigned int f2_0_fine_time; // 0x44
		105	volatile unsigned int f2_1_coarse_time; // 0x48
		106	volatile unsigned int f2_1_fine_time; // 0x4C
		107	} spectral_matrix_regs_t;
		108
		109	#endif // GRLIB_REGS_H_INCLUDED

timegen/header/lfr_cpu_usage_report.h created 644 +32 0

			@@ -0,0 +1,32
		1	#ifndef LFR_CPU_USAGE_REPORT_H
		2	#define LFR_CPU_USAGE_REPORT_H
		3
		4	#ifdef HAVE_CONFIG_H
		5	#include "config.h"
		6	#endif
		7
		8	#include <rtems.h>
		9
		10	#include <assert.h>
		11	#include <string.h>
		12	#include <stdlib.h>
		13	#include <stdio.h>
		14	#include <ctype.h>
		15	#include <inttypes.h>
		16
		17	#include <rtems/cpuuse.h>
		18	#include <rtems/bspIo.h>
		19
		20	#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
		21	#include <rtems/score/timestamp.h>
		22	#endif
		23
		24	#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
		25	extern Timestamp_Control CPU_usage_Uptime_at_last_reset;
		26	#else
		27	extern uint32_t CPU_usage_Ticks_at_last_reset;
		28	#endif
		29
		30	unsigned char lfr_rtems_cpu_usage_report( void );
		31
		32	#endif // LFR_CPU_USAGE_REPORT_H

timegen/header/processing/avf0_prc0.h created 644 +36 0

			@@ -0,0 +1,36
		1	#ifndef AVF0_PRC0_H_INCLUDED
		2	#define AVF0_PRC0_H_INCLUDED
		3
		4	#include "fsw_processing.h"
		5	#include "basic_parameters.h"
		6
		7	typedef struct {
		8	unsigned int norm_bp1;
		9	unsigned int norm_bp2;
		10	unsigned int norm_asm;
		11	unsigned int burst_sbm_bp1;
		12	unsigned int burst_sbm_bp2;
		13	unsigned int burst_bp1;
		14	unsigned int burst_bp2;
		15	unsigned int sbm1_bp1;
		16	unsigned int sbm1_bp2;
		17	unsigned int sbm2_bp1;
		18	unsigned int sbm2_bp2;
		19	} nb_sm_before_bp_asm_f0;
		20
		21	//************
		22	// RTEMS TASKS
		23	rtems_task avf0_task( rtems_task_argument lfrRequestedMode );
		24	rtems_task prc0_task( rtems_task_argument lfrRequestedMode );
		25
		26	//**********
		27	// FUNCTIONS
		28
		29	void reset_nb_sm_f0( unsigned char lfrMode );
		30
		31	//*******
		32	// EXTERN
		33	extern ring_node_sm *ring_node_for_averaging_sm_f0;
		34	extern rtems_status_code get_message_queue_id_prc0( rtems_id *queue_id );
		35
		36	#endif // AVF0_PRC0_H_INCLUDED

timegen/header/processing/avf1_prc1.h created 644 +33 0

			@@ -0,0 +1,33
		1	#ifndef AVF1_PRC1_H
		2	#define AVF1_PRC1_H
		3
		4	#include "fsw_processing.h"
		5
		6	typedef struct {
		7	unsigned int norm_bp1;
		8	unsigned int norm_bp2;
		9	unsigned int norm_asm;
		10	unsigned int burst_sbm_bp1;
		11	unsigned int burst_sbm_bp2;
		12	unsigned int burst_bp1;
		13	unsigned int burst_bp2;
		14	unsigned int sbm2_bp1;
		15	unsigned int sbm2_bp2;
		16	} nb_sm_before_bp_asm_f1;
		17
		18	//************
		19	// RTEMS TASKS
		20	rtems_task avf1_task( rtems_task_argument lfrRequestedMode );
		21	rtems_task prc1_task( rtems_task_argument lfrRequestedMode );
		22
		23	//**********
		24	// FUNCTIONS
		25
		26	void reset_nb_sm_f1( unsigned char lfrMode );
		27
		28	//*******
		29	// EXTERN
		30	extern struct ring_node_sm *ring_node_for_averaging_sm_f1;
		31	extern rtems_status_code get_message_queue_id_prc1( rtems_id *queue_id );
		32
		33	#endif // AVF1_PRC1_H

timegen/header/processing/avf2_prc2.h created 644 +28 0

			@@ -0,0 +1,28
		1	#ifndef AVF2_PRC2_H
		2	#define AVF2_PRC2_H
		3
		4	#include "fsw_processing.h"
		5
		6	typedef struct {
		7	unsigned int norm_bp1;
		8	unsigned int norm_bp2;
		9	unsigned int norm_asm;
		10	} nb_sm_before_bp_asm_f2;
		11
		12	//************
		13	// RTEMS TASKS
		14	rtems_task avf2_task( rtems_task_argument lfrRequestedMode );
		15	rtems_task prc2_task( rtems_task_argument lfrRequestedMode );
		16
		17	//**********
		18	// FUNCTIONS
		19
		20	void reset_nb_sm_f2( void );
		21	void SM_average_f2( float averaged_spec_mat_f2, ring_node_sm ring_node, unsigned int nbAverageNormF2 );
		22
		23	//*******
		24	// EXTERN
		25	extern struct ring_node_sm *ring_node_for_averaging_sm_f2;
		26	extern rtems_status_code get_message_queue_id_prc2( rtems_id *queue_id );
		27
		28	#endif // AVF2_PRC2_H

timegen/header/processing/fsw_processing.h created 644 +243 0

			@@ -0,0 +1,243
		1	#ifndef FSW_PROCESSING_H_INCLUDED
		2	#define FSW_PROCESSING_H_INCLUDED
		3
		4	#include <rtems.h>
		5	#include <grspw.h>
		6	#include <math.h>
		7	#include <stdlib.h> // abs() is in the stdlib
		8	#include <stdio.h> // printf()
		9	#include <math.h>
		10
		11	#include "fsw_params.h"
		12	#include "fsw_spacewire.h"
		13
		14	typedef struct ring_node_sm
		15	{
		16	struct ring_node_sm *previous;
		17	struct ring_node_sm *next;
		18	int buffer_address;
		19	unsigned int status;
		20	unsigned int coarseTime;
		21	unsigned int fineTime;
		22	} ring_node_sm;
		23
		24	typedef struct ring_node_asm
		25	{
		26	struct ring_node_asm *next;
		27	float matrix[ TOTAL_SIZE_SM ];
		28	unsigned int status;
		29	} ring_node_asm;
		30
		31	typedef struct
		32	{
		33	Header_TM_LFR_SCIENCE_BP_t header;
		34	unsigned char data[ 30 * 22 ]; // MAX size is 22 * 30 [TM_LFR_SCIENCE_BURST_BP2_F1]
		35	} bp_packet;
		36
		37	typedef struct
		38	{
		39	Header_TM_LFR_SCIENCE_BP_with_spare_t header;
		40	unsigned char data[ 9 * 13 ]; // only for TM_LFR_SCIENCE_NORMAL_BP1_F0 and F1
		41	} bp_packet_with_spare;
		42
		43	typedef struct
		44	{
		45	ring_node_asm *norm;
		46	ring_node_asm *burst_sbm;
		47	rtems_event_set event;
		48	unsigned int coarseTime;
		49	unsigned int fineTime;
		50	} asm_msg;
		51
		52	extern volatile int sm_f0[ ];
		53	extern volatile int sm_f1[ ];
		54	extern volatile int sm_f2[ ];
		55
		56	// parameters
		57	extern struct param_local_str param_local;
		58
		59	// registers
		60	extern time_management_regs_t *time_management_regs;
		61	extern spectral_matrix_regs_t *spectral_matrix_regs;
		62
		63	extern rtems_name misc_name[5];
		64	extern rtems_id Task_id[20]; /* array of task ids */
		65
		66	// ISR
		67	rtems_isr spectral_matrices_isr( rtems_vector_number vector );
		68	rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector );
		69
		70	//******************
		71	// Spectral Matrices
		72	void reset_nb_sm( void );
		73	// SM
		74	void SM_init_rings( void );
		75	void SM_reset_current_ring_nodes( void );
		76	void SM_generic_init_ring(ring_node_sm *ring, unsigned char nbNodes, volatile int sm_f[] );
		77	// ASM
		78	void ASM_generic_init_ring(ring_node_asm *ring, unsigned char nbNodes );
		79	void ASM_init_header( Header_TM_LFR_SCIENCE_ASM_t *header);
		80	void ASM_send(Header_TM_LFR_SCIENCE_ASM_t header, char spectral_matrix,
		81	unsigned int sid, spw_ioctl_pkt_send *spw_ioctl_send, rtems_id queue_id);
		82
		83	//*****************
		84	// Basic Parameters
		85
		86	void BP_reset_current_ring_nodes( void );
		87	void BP_init_header( Header_TM_LFR_SCIENCE_BP_t *header,
		88	unsigned int apid, unsigned char sid,
		89	unsigned int packetLength , unsigned char blkNr);
		90	void BP_init_header_with_spare( Header_TM_LFR_SCIENCE_BP_with_spare_t *header,
		91	unsigned int apid, unsigned char sid,
		92	unsigned int packetLength, unsigned char blkNr );
		93	void BP_send( char *data,
		94	rtems_id queue_id ,
		95	unsigned int nbBytesToSend , unsigned int sid );
		96
		97	//******************
		98	// general functions
		99	void reset_spectral_matrix_regs( void );
		100	void set_time(unsigned char time, unsigned char timeInBuffer );
		101	unsigned long long int get_acquisition_time( unsigned char *timePtr );
		102	void close_matrix_actions(unsigned int *nb_sm, unsigned int nb_sm_before_avf, rtems_id avf_task_id,
		103	ring_node_sm node_for_averaging, ring_node_sm ringNode, unsigned long long int time);
		104	unsigned char getSID( rtems_event_set event );
		105
		106	extern rtems_status_code get_message_queue_id_prc1( rtems_id *queue_id );
		107	extern rtems_status_code get_message_queue_id_prc2( rtems_id *queue_id );
		108
		109	//***************************************
		110	// DEFINITIONS OF STATIC INLINE FUNCTIONS
		111	static inline void SM_average( float averaged_spec_mat_NORM, float averaged_spec_mat_SBM,
		112	ring_node_sm *ring_node_tab[],
		113	unsigned int nbAverageNORM, unsigned int nbAverageSBM );
		114	static inline void ASM_reorganize_and_divide(float averaged_spec_mat, float averaged_spec_mat_reorganized,
		115	float divider );
		116	static inline void ASM_compress_reorganize_and_divide(float averaged_spec_mat, float compressed_spec_mat,
		117	float divider,
		118	unsigned char nbBinsCompressedMatrix, unsigned char nbBinsToAverage , unsigned char ASMIndexStart);
		119	static inline void ASM_convert(volatile float input_matrix, char output_matrix);
		120
		121	void SM_average( float averaged_spec_mat_NORM, float averaged_spec_mat_SBM,
		122	ring_node_sm *ring_node_tab[],
		123	unsigned int nbAverageNORM, unsigned int nbAverageSBM )
		124	{
		125	float sum;
		126	unsigned int i;
		127
		128	for(i=0; i<TOTAL_SIZE_SM; i++)
		129	{
		130	sum = ( (int *) (ring_node_tab[0]->buffer_address) ) [ i ]
		131	+ ( (int *) (ring_node_tab[1]->buffer_address) ) [ i ]
		132	+ ( (int *) (ring_node_tab[2]->buffer_address) ) [ i ]
		133	+ ( (int *) (ring_node_tab[3]->buffer_address) ) [ i ]
		134	+ ( (int *) (ring_node_tab[4]->buffer_address) ) [ i ]
		135	+ ( (int *) (ring_node_tab[5]->buffer_address) ) [ i ]
		136	+ ( (int *) (ring_node_tab[6]->buffer_address) ) [ i ]
		137	+ ( (int *) (ring_node_tab[7]->buffer_address) ) [ i ];
		138
		139	if ( (nbAverageNORM == 0) && (nbAverageSBM == 0) )
		140	{
		141	averaged_spec_mat_NORM[ i ] = sum;
		142	averaged_spec_mat_SBM[ i ] = sum;
		143	}
		144	else if ( (nbAverageNORM != 0) && (nbAverageSBM != 0) )
		145	{
		146	averaged_spec_mat_NORM[ i ] = ( averaged_spec_mat_NORM[ i ] + sum );
		147	averaged_spec_mat_SBM[ i ] = ( averaged_spec_mat_SBM[ i ] + sum );
		148	}
		149	else if ( (nbAverageNORM != 0) && (nbAverageSBM == 0) )
		150	{
		151	averaged_spec_mat_NORM[ i ] = ( averaged_spec_mat_NORM[ i ] + sum );
		152	averaged_spec_mat_SBM[ i ] = sum;
		153	}
		154	else
		155	{
		156	PRINTF2("ERR * in SM_average * unexpected parameters %d %d\n", nbAverageNORM, nbAverageSBM)
		157	}
		158	}
		159	}
		160
		161	void ASM_reorganize_and_divide( float averaged_spec_mat, float averaged_spec_mat_reorganized, float divider )
		162	{
		163	int frequencyBin;
		164	int asmComponent;
		165	unsigned int offsetAveragedSpecMatReorganized;
		166	unsigned int offsetAveragedSpecMat;
		167
		168	for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++)
		169	{
		170	for( frequencyBin = 0; frequencyBin < NB_BINS_PER_SM; frequencyBin++ )
		171	{
		172	offsetAveragedSpecMatReorganized =
		173	frequencyBin * NB_VALUES_PER_SM
		174	+ asmComponent;
		175	offsetAveragedSpecMat =
		176	asmComponent * NB_BINS_PER_SM
		177	+ frequencyBin;
		178	averaged_spec_mat_reorganized[offsetAveragedSpecMatReorganized ] =
		179	averaged_spec_mat[ offsetAveragedSpecMat ] / divider;
		180	}
		181	}
		182	}
		183
		184	void ASM_compress_reorganize_and_divide(float averaged_spec_mat, float compressed_spec_mat , float divider,
		185	unsigned char nbBinsCompressedMatrix, unsigned char nbBinsToAverage, unsigned char ASMIndexStart )
		186	{
		187	int frequencyBin;
		188	int asmComponent;
		189	int offsetASM;
		190	int offsetCompressed;
		191	int k;
		192
		193	// build data
		194	for (asmComponent = 0; asmComponent < NB_VALUES_PER_SM; asmComponent++)
		195	{
		196	for( frequencyBin = 0; frequencyBin < nbBinsCompressedMatrix; frequencyBin++ )
		197	{
		198	offsetCompressed = // NO TIME OFFSET
		199	frequencyBin * NB_VALUES_PER_SM
		200	+ asmComponent;
		201	offsetASM = // NO TIME OFFSET
		202	asmComponent * NB_BINS_PER_SM
		203	+ ASMIndexStart
		204	+ frequencyBin * nbBinsToAverage;
		205	compressed_spec_mat[ offsetCompressed ] = 0;
		206	for ( k = 0; k < nbBinsToAverage; k++ )
		207	{
		208	compressed_spec_mat[offsetCompressed ] =
		209	( compressed_spec_mat[ offsetCompressed ]
		210	+ averaged_spec_mat[ offsetASM + k ] ) / (divider * nbBinsToAverage);
		211	}
		212	}
		213	}
		214	}
		215
		216	void ASM_convert( volatile float input_matrix, char output_matrix)
		217	{
		218	unsigned int frequencyBin;
		219	unsigned int asmComponent;
		220	char * pt_char_input;
		221	char * pt_char_output;
		222	unsigned int offsetInput;
		223	unsigned int offsetOutput;
		224
		225	pt_char_input = (char*) &input_matrix;
		226	pt_char_output = (char*) &output_matrix;
		227
		228	// convert all other data
		229	for( frequencyBin=0; frequencyBin<NB_BINS_PER_SM; frequencyBin++)
		230	{
		231	for ( asmComponent=0; asmComponent<NB_VALUES_PER_SM; asmComponent++)
		232	{
		233	offsetInput = (frequencyBin*NB_VALUES_PER_SM) + asmComponent ;
		234	offsetOutput = 2 * ( (frequencyBin*NB_VALUES_PER_SM) + asmComponent ) ;
		235	pt_char_input = (char*) &input_matrix [ offsetInput ];
		236	pt_char_output = (char*) &output_matrix[ offsetOutput ];
		237	pt_char_output[0] = pt_char_input[0]; // bits 31 downto 24 of the float
		238	pt_char_output[1] = pt_char_input[1]; // bits 23 downto 16 of the float
		239	}
		240	}
		241	}
		242
		243	#endif // FSW_PROCESSING_H_INCLUDED

timegen/header/tc_acceptance.h created 644 +25 0

			@@ -0,0 +1,25
		1	#ifndef TC_ACCEPTANCE_H_INCLUDED
		2	#define TC_ACCEPTANCE_H_INCLUDED
		3
		4	//#include "tm_lfr_tc_exe.h"
		5	#include "fsw_params.h"
		6
		7	//**********************
		8	// GENERAL USE FUNCTIONS
		9	unsigned int Crc_opt( unsigned char D, unsigned int Chk);
		10	void initLookUpTableForCRC( void );
		11	void GetCRCAsTwoBytes(unsigned char* data, unsigned char* crcAsTwoBytes, unsigned int sizeOfData);
		12
		13	//*********************
		14	// ACCEPTANCE FUNCTIONS
		15	int tc_parser( ccsdsTelecommandPacket_t * TCPacket, unsigned int estimatedPacketLength, unsigned char *computed_CRC );
		16	int tc_check_type( unsigned char packetType );
		17	int tc_check_type_subtype( unsigned char packetType, unsigned char packetSubType );
		18	int tc_check_sid( unsigned char sid );
		19	int tc_check_length( unsigned char packetType, unsigned int length );
		20	int tc_check_crc(ccsdsTelecommandPacket_t * TCPacket, unsigned int length , unsigned char *computed_CRC);
		21
		22	#endif // TC_ACCEPTANCE_H_INCLUDED
		23
		24
		25

timegen/header/tc_handler.h created 644 +66 0

			@@ -0,0 +1,66
		1	#ifndef TC_HANDLER_H_INCLUDED
		2	#define TC_HANDLER_H_INCLUDED
		3
		4	#include <rtems.h>
		5	#include <leon.h>
		6
		7	#include "tc_load_dump_parameters.h"
		8	#include "tc_acceptance.h"
		9	#include "tm_lfr_tc_exe.h"
		10	#include "wf_handler.h"
		11	#include "fsw_processing.h"
		12
		13	#include "lfr_cpu_usage_report.h"
		14
		15	// MODE PARAMETERS
		16	extern unsigned int maxCount;
		17
		18	//****
		19	// ISR
		20	rtems_isr commutation_isr1( rtems_vector_number vector );
		21	rtems_isr commutation_isr2( rtems_vector_number vector );
		22
		23	void reset_transitionCoarseTime( void );
		24	void set_transitionCoarseTime( unsigned int value );
		25	unsigned int get_transitionCoarseTime( void );
		26
		27	//***********
		28	// RTEMS TASK
		29	rtems_task actn_task( rtems_task_argument unused );
		30
		31	//***********
		32	// TC ACTIONS
		33	int action_reset( ccsdsTelecommandPacket_t TC, rtems_id queue_id, unsigned char time );
		34	int action_enter_mode(ccsdsTelecommandPacket_t *TC, rtems_id queue_id);
		35	int action_update_info( ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
		36	int action_enable_calibration( ccsdsTelecommandPacket_t TC, rtems_id queue_id, unsigned char time );
		37	int action_disable_calibration( ccsdsTelecommandPacket_t TC, rtems_id queue_id, unsigned char time );
		38	int action_update_time( ccsdsTelecommandPacket_t *TC);
		39
		40	// mode transition
		41	int check_mode_value( unsigned char requestedMode );
		42	int check_mode_transition( unsigned char requestedMode );
		43	int check_transition_date( unsigned int transitionCoarseTime );
		44	int stop_current_mode( void );
		45	int enter_mode( unsigned char mode , unsigned int transitionCoarseTime );
		46	int restart_science_tasks(unsigned char lfrRequestedMode );
		47	int suspend_science_tasks();
		48	void launch_waveform_picker(unsigned char mode , unsigned int transitionCoarseTime);
		49	void launch_spectral_matrix( void );
		50	void launch_spectral_matrix_simu( void );
		51	void set_irq_on_new_ready_matrix(unsigned char value );
		52	void set_run_matrix_spectral( unsigned char value );
		53
		54	// other functions
		55	void updateLFRCurrentMode();
		56	void update_last_TC_exe( ccsdsTelecommandPacket_t TC , unsigned char time );
		57	void update_last_TC_rej(ccsdsTelecommandPacket_t TC , unsigned char time );
		58	void close_action( ccsdsTelecommandPacket_t *TC, int result, rtems_id queue_id );
		59
		60	extern rtems_status_code get_message_queue_id_send( rtems_id *queue_id );
		61	extern rtems_status_code get_message_queue_id_recv( rtems_id *queue_id );
		62
		63	#endif // TC_HANDLER_H_INCLUDED
		64
		65
		66

timegen/header/tc_load_dump_parameters.h created 644 +51 0

			@@ -0,0 +1,51
		1	#ifndef TC_LOAD_DUMP_PARAMETERS_H
		2	#define TC_LOAD_DUMP_PARAMETERS_H
		3
		4	#include <rtems.h>
		5	#include <stdio.h>
		6
		7	#include "fsw_params.h"
		8	#include "wf_handler.h"
		9	#include "tm_lfr_tc_exe.h"
		10	#include "fsw_misc.h"
		11
		12	#define FLOAT_EQUAL_ZERO 0.001
		13
		14	extern unsigned short sequenceCounterParameterDump;
		15
		16	int action_load_common_par( ccsdsTelecommandPacket_t *TC );
		17	int action_load_normal_par(ccsdsTelecommandPacket_t TC, rtems_id queue_id , unsigned char time);
		18	int action_load_burst_par(ccsdsTelecommandPacket_t TC, rtems_id queue_id , unsigned char time);
		19	int action_load_sbm1_par(ccsdsTelecommandPacket_t TC, rtems_id queue_id , unsigned char time);
		20	int action_load_sbm2_par(ccsdsTelecommandPacket_t TC, rtems_id queue_id , unsigned char time);
		21	int action_dump_par(rtems_id queue_id );
		22
		23	// NORMAL
		24	int check_common_par_consistency( ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
		25	int set_sy_lfr_n_swf_l( ccsdsTelecommandPacket_t *TC );
		26	int set_sy_lfr_n_swf_p( ccsdsTelecommandPacket_t *TC );
		27	int set_sy_lfr_n_asm_p( ccsdsTelecommandPacket_t *TC );
		28	int set_sy_lfr_n_bp_p0( ccsdsTelecommandPacket_t *TC );
		29	int set_sy_lfr_n_bp_p1( ccsdsTelecommandPacket_t *TC );
		30	int set_sy_lfr_n_cwf_long_f3( ccsdsTelecommandPacket_t *TC );
		31
		32	// BURST
		33	int set_sy_lfr_b_bp_p0( ccsdsTelecommandPacket_t *TC );
		34	int set_sy_lfr_b_bp_p1( ccsdsTelecommandPacket_t *TC );
		35
		36	// SBM1
		37	int set_sy_lfr_s1_bp_p0( ccsdsTelecommandPacket_t *TC );
		38	int set_sy_lfr_s1_bp_p1( ccsdsTelecommandPacket_t *TC );
		39
		40	// SBM2
		41	int set_sy_lfr_s2_bp_p0( ccsdsTelecommandPacket_t *TC );
		42	int set_sy_lfr_s2_bp_p1( ccsdsTelecommandPacket_t *TC );
		43
		44	// TC_LFR_UPDATE_INFO
		45	unsigned int check_update_info_hk_lfr_mode( unsigned char mode );
		46	unsigned int check_update_info_hk_tds_mode( unsigned char mode );
		47	unsigned int check_update_info_hk_thr_mode( unsigned char mode );
		48
		49	void init_parameter_dump( void );
		50
		51	#endif // TC_LOAD_DUMP_PARAMETERS_H

timegen/header/tm_byte_positions.h created 644 +23 0

			@@ -0,0 +1,23
		1	#ifndef TM_BYTE_POSITIONS_H
		2	#define TM_BYTE_POSITIONS_H
		3
		4	#define BYTE_POS_CP_LFR_MODE 11
		5
		6	// TC_LFR_LOAD_COMMON_PAR
		7
		8	// TC_LFR_LOAD_NORMAL_PAR
		9	#define BYTE_POS_SY_LFR_N_SWF_L 0
		10	#define BYTE_POS_SY_LFR_N_SWF_P 2
		11	#define BYTE_POS_SY_LFR_N_ASM_P 4
		12	#define BYTE_POS_SY_LFR_N_BP_P0 6
		13	#define BYTE_POS_SY_LFR_N_BP_P1 7
		14	#define BYTE_POS_SY_LFR_N_CWF_LONG_F3 8
		15
		16	// TC_LFR_LOAD_BURST_PAR
		17
		18	// TC_LFR_LOAD_SBM1_PAR
		19
		20	// TC_LFR_LOAD_SBM2_PAR
		21
		22
		23	#endif // TM_BYTE_POSITIONS_H

timegen/header/tm_lfr_tc_exe.h created 644 +26 0

			@@ -0,0 +1,26
		1	#ifndef TM_LFR_TC_EXE_H_INCLUDED
		2	#define TM_LFR_TC_EXE_H_INCLUDED
		3
		4	#include <rtems.h>
		5	#include <stdio.h>
		6
		7	#include "fsw_params.h"
		8	#include "fsw_spacewire.h"
		9
		10	extern unsigned short sequenceCounters_TC_EXE[];
		11
		12	int send_tm_lfr_tc_exe_success( ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
		13	int send_tm_lfr_tc_exe_inconsistent( ccsdsTelecommandPacket_t *TC, rtems_id queue_id,
		14	unsigned char byte_position, unsigned char rcv_value );
		15	int send_tm_lfr_tc_exe_not_executable( ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
		16	int send_tm_lfr_tc_exe_not_implemented( ccsdsTelecommandPacket_t TC, rtems_id queue_id, unsigned char time );
		17	int send_tm_lfr_tc_exe_error(ccsdsTelecommandPacket_t *TC, rtems_id queue_id );
		18	int send_tm_lfr_tc_exe_corrupted( ccsdsTelecommandPacket_t *TC, rtems_id queue_id,
		19	unsigned char computed_CRC, unsigned char currentTC_LEN_RCV, unsigned char destinationID );
		20
		21	void increment_seq_counter_destination_id( unsigned char *packet_sequence_control, unsigned char destination_id );
		22
		23	#endif // TM_LFR_TC_EXE_H_INCLUDED
		24
		25
		26

timegen/header/wf_handler.h created 644 +92 0

			@@ -0,0 +1,92
		1	#ifndef WF_HANDLER_H_INCLUDED
		2	#define WF_HANDLER_H_INCLUDED
		3
		4	#include <rtems.h>
		5	#include <grspw.h>
		6	#include <stdio.h>
		7	#include <math.h>
		8
		9	#include "fsw_params.h"
		10	#include "fsw_spacewire.h"
		11	#include "fsw_misc.h"
		12	#include "fsw_params_wf_handler.h"
		13
		14	#define pi 3.1415
		15
		16	extern int fdSPW;
		17
		18	//*****************
		19	// waveform buffers
		20	extern volatile int wf_snap_f0[ ];
		21	extern volatile int wf_snap_f1[ ];
		22	extern volatile int wf_snap_f2[ ];
		23	extern volatile int wf_cont_f3[ ];
		24	extern char wf_cont_f3_light[ ];
		25
		26	extern waveform_picker_regs_new_t *waveform_picker_regs;
		27	extern time_management_regs_t *time_management_regs;
		28	extern Packet_TM_LFR_HK_t housekeeping_packet;
		29	extern Packet_TM_LFR_PARAMETER_DUMP_t parameter_dump_packet;
		30	extern struct param_local_str param_local;
		31
		32	extern unsigned short sequenceCounters_SCIENCE_NORMAL_BURST;
		33	extern unsigned short sequenceCounters_SCIENCE_SBM1_SBM2;
		34
		35	extern rtems_id Task_id[20]; /* array of task ids */
		36
		37	extern unsigned char lfrCurrentMode;
		38
		39	//**********
		40	// RTEMS_ISR
		41	void reset_extractSWF( void );
		42	rtems_isr waveforms_isr( rtems_vector_number vector );
		43
		44	//***********
		45	// RTEMS_TASK
		46	rtems_task wfrm_task( rtems_task_argument argument );
		47	rtems_task cwf3_task( rtems_task_argument argument );
		48	rtems_task cwf2_task( rtems_task_argument argument );
		49	rtems_task cwf1_task( rtems_task_argument argument );
		50	rtems_task swbd_task( rtems_task_argument argument );
		51
		52	//******************
		53	// general functions
		54	void WFP_init_rings( void );
		55	void init_waveform_ring( ring_node waveform_ring[], unsigned char nbNodes, volatile int wfrm[] );
		56	void WFP_reset_current_ring_nodes( void );
		57	//
		58	int init_header_snapshot_wf_table( unsigned int sid, Header_TM_LFR_SCIENCE_SWF_t *headerSWF );
		59	int init_header_continuous_wf_table( unsigned int sid, Header_TM_LFR_SCIENCE_CWF_t *headerCWF );
		60	int init_header_continuous_cwf3_light_table( Header_TM_LFR_SCIENCE_CWF_t *headerCWF );
		61	//
		62	int send_waveform_SWF( volatile int waveform, unsigned int sid, Header_TM_LFR_SCIENCE_SWF_t headerSWF, rtems_id queue_id );
		63	int send_waveform_CWF( volatile int waveform, unsigned int sid, Header_TM_LFR_SCIENCE_CWF_t headerCWF, rtems_id queue_id );
		64	int send_waveform_CWF3( volatile int waveform, unsigned int sid, Header_TM_LFR_SCIENCE_CWF_t headerCWF, rtems_id queue_id );
		65	int send_waveform_CWF3_light( volatile int waveform, Header_TM_LFR_SCIENCE_CWF_t headerCWF, rtems_id queue_id );
		66	//
		67	void compute_acquisition_time(unsigned int coarseTime, unsigned int fineTime,
		68	unsigned int sid, unsigned char pa_lfr_pkt_nr, unsigned char *acquisitionTime );
		69	void build_snapshot_from_ring(ring_node *ring_node_to_send , unsigned char frequencyChannel );
		70	void build_acquisition_time( unsigned long long int * acquisitionTimeAslong, ring_node *current_ring_node );
		71	//
		72	rtems_id get_pkts_queue_id( void );
		73
		74	//**************
		75	// wfp registers
		76	// RESET
		77	void reset_wfp_burst_enable( void );
		78	void reset_wfp_status(void);
		79	void reset_waveform_picker_regs( void );
		80	// SET
		81	void set_wfp_data_shaping(void);
		82	void set_wfp_burst_enable_register( unsigned char mode );
		83	void set_wfp_delta_snapshot( void );
		84	void set_wfp_delta_f0_f0_2( void );
		85	void set_wfp_delta_f1( void );
		86	void set_wfp_delta_f2( void );
		87
		88	//*****************
		89	// local parameters
		90	void increment_seq_counter_source_id( unsigned char *packet_sequence_control, unsigned int sid );
		91
		92	#endif // WF_HANDLER_H_INCLUDED

timegen/src/fsw_config.c created 644 +25 0

			@@ -0,0 +1,25
		1	#include <drvmgr/ambapp_bus.h>
		2
		3	// GRSPW0 resources
		4	struct drvmgr_key grlib_grspw_0n1_res[] = {
		5	{"txBdCnt", KEY_TYPE_INT, {(unsigned int)50}}, // 7 SWF_F0, 7 SWF_F1, 7 SWF_F2, 7 CWF_F3, 7 CWF_F1 ou 7 CWF_F2
		6	{"rxBdCnt", KEY_TYPE_INT, {(unsigned int)10}},
		7	{"txDataSize", KEY_TYPE_INT, {(unsigned int)4096}},
		8	{"txHdrSize", KEY_TYPE_INT, {(unsigned int)20+12}}, // 12 is for the auxiliary header, when needed
		9	{"rxPktSize", KEY_TYPE_INT, {(unsigned int)248+4}},
		10	KEY_EMPTY
		11	};
		12
		13	// If RTEMS_DRVMGR_STARTUP is defined we override the "weak defaults" that is defined by the LEON3 BSP.
		14
		15	struct drvmgr_bus_res grlib_drv_resources = {
		16	.next = NULL,
		17	.resource = {
		18	{DRIVER_AMBAPP_GAISLER_GRSPW_ID, 0, &grlib_grspw_0n1_res[0]},
		19	// {DRIVER_AMBAPP_GAISLER_APBUART_ID, 0, &grlib_drv_res_apbuart0[0]},
		20	// {DRIVER_AMBAPP_GAISLER_APBUART_ID, 1, &grlib_drv_res_apbuart1[0]},
		21	RES_EMPTY /* Mark end of device resource array */
		22	}
		23	};
		24
		25

timegen/src/fsw_globals.c created 644 +75 0

			@@ -0,0 +1,75
		1	/** Global variables of the LFR flight software.
		2	*
		3	* @file
		4	* @author P. LEROY
		5	*
		6	* Among global variables, there are:
		7	* - RTEMS names and id.
		8	* - APB configuration registers.
		9	* - waveforms global buffers, used by the waveform picker hardware module to store data.
		10	* - spectral matrices buffesr, used by the hardware module to store data.
		11	* - variable related to LFR modes parameters.
		12	* - the global HK packet buffer.
		13	* - the global dump parameter buffer.
		14	*
		15	*/
		16
		17	#include <rtems.h>
		18	#include <grspw.h>
		19
		20	#include "ccsds_types.h"
		21	#include "grlib_regs.h"
		22	#include "fsw_params.h"
		23	#include "fsw_params_wf_handler.h"
		24
		25	// RTEMS GLOBAL VARIABLES
		26	rtems_name misc_name[5];
		27	rtems_id misc_id[5];
		28	rtems_name Task_name[20]; /* array of task names */
		29	rtems_id Task_id[20]; /* array of task ids */
		30	unsigned int maxCount;
		31	int fdSPW = 0;
		32	int fdUART = 0;
		33	unsigned char lfrCurrentMode;
		34
		35	// WAVEFORMS GLOBAL VARIABLES // 2048 * 3 * 4 + 2 * 4 = 24576 + 8 bytes = 24584
		36	// 97 * 256 = 24832 => delta = 248 bytes = 62 words
		37	// WAVEFORMS GLOBAL VARIABLES // 2688 * 3 * 4 + 2 * 4 = 32256 + 8 bytes = 32264
		38	// 127 * 256 = 32512 => delta = 248 bytes = 62 words
		39	// F0 F1 F2 F3
		40	volatile int wf_snap_f0[ NB_RING_NODES_F0 * WFRM_BUFFER ] __attribute__((aligned(0x100)));
		41	volatile int wf_snap_f1[ NB_RING_NODES_F1 * WFRM_BUFFER ] __attribute__((aligned(0x100)));
		42	volatile int wf_snap_f2[ NB_RING_NODES_F2 * WFRM_BUFFER ] __attribute__((aligned(0x100)));
		43	volatile int wf_cont_f3[ NB_RING_NODES_F3 * WFRM_BUFFER ] __attribute__((aligned(0x100)));
		44	char wf_cont_f3_light[ (NB_SAMPLES_PER_SNAPSHOT) * NB_BYTES_CWF3_LIGHT_BLK + TIME_OFFSET_IN_BYTES ] __attribute__((aligned(0x100)));
		45
		46	//***********************************
		47	// SPECTRAL MATRICES GLOBAL VARIABLES
		48
		49	// alignment constraints for the spectral matrices buffers => the first data after the time (8 bytes) shall be aligned on 0x00
		50	volatile int sm_f0[ NB_RING_NODES_SM_F0 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100)));
		51	volatile int sm_f1[ NB_RING_NODES_SM_F1 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100)));
		52	volatile int sm_f2[ NB_RING_NODES_SM_F2 * TOTAL_SIZE_SM ] __attribute__((aligned(0x100)));
		53
		54	// APB CONFIGURATION REGISTERS
		55	time_management_regs_t time_management_regs = (time_management_regs_t) REGS_ADDR_TIME_MANAGEMENT;
		56	gptimer_regs_t gptimer_regs = (gptimer_regs_t ) REGS_ADDR_GPTIMER;
		57	waveform_picker_regs_new_t waveform_picker_regs = (waveform_picker_regs_new_t) REGS_ADDR_WAVEFORM_PICKER;
		58	spectral_matrix_regs_t spectral_matrix_regs = (spectral_matrix_regs_t) REGS_ADDR_SPECTRAL_MATRIX;
		59
		60	// MODE PARAMETERS
		61	Packet_TM_LFR_PARAMETER_DUMP_t parameter_dump_packet;
		62	struct param_local_str param_local;
		63
		64	// HK PACKETS
		65	Packet_TM_LFR_HK_t housekeeping_packet;
		66	// sequence counters are incremented by APID (PID + CAT) and destination ID
		67	unsigned short sequenceCounters_SCIENCE_NORMAL_BURST;
		68	unsigned short sequenceCounters_SCIENCE_SBM1_SBM2;
		69	unsigned short sequenceCounters_TC_EXE[SEQ_CNT_NB_DEST_ID];
		70	unsigned short sequenceCounterHK;
		71	unsigned short sequenceCounterParameterDump;
		72	spw_stats spacewire_stats;
		73	spw_stats spacewire_stats_backup;
		74
		75

timegen/src/fsw_init.c created 644 +489 0

			@@ -0,0 +1,489
		1	/** This is the RTEMS initialization module.
		2	*
		3	* @file
		4	* @author P. LEROY
		5	*
		6	* This module contains two very different information:
		7	* - specific instructions to configure the compilation of the RTEMS executive
		8	* - functions related to the fligth softwre initialization, especially the INIT RTEMS task
		9	*
		10	*/
		11
		12	//*************************
		13	// GPL reminder to be added
		14	//*************************
		15
		16	#include <rtems.h>
		17
		18	/* configuration information */
		19
		20	#define CONFIGURE_INIT
		21
		22	#include <bsp.h> /* for device driver prototypes */
		23
		24	/* configuration information */
		25
		26	#define CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
		27	#define CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
		28
		29	#define CONFIGURE_MAXIMUM_TASKS 20
		30	#define CONFIGURE_RTEMS_INIT_TASKS_TABLE
		31	#define CONFIGURE_EXTRA_TASK_STACKS (3 * RTEMS_MINIMUM_STACK_SIZE)
		32	#define CONFIGURE_LIBIO_MAXIMUM_FILE_DESCRIPTORS 32
		33	#define CONFIGURE_INIT_TASK_PRIORITY 1 // instead of 100
		34	#define CONFIGURE_INIT_TASK_MODE (RTEMS_DEFAULT_MODES \| RTEMS_NO_PREEMPT)
		35	#define CONFIGURE_INIT_TASK_ATTRIBUTES (RTEMS_DEFAULT_ATTRIBUTES \| RTEMS_FLOATING_POINT)
		36	#define CONFIGURE_MAXIMUM_DRIVERS 16
		37	#define CONFIGURE_MAXIMUM_PERIODS 5
		38	#define CONFIGURE_MAXIMUM_TIMERS 5 // STAT (1s), send SWF (0.3s), send CWF3 (1s)
		39	#define CONFIGURE_MAXIMUM_MESSAGE_QUEUES 5
		40	#ifdef PRINT_STACK_REPORT
		41	#define CONFIGURE_STACK_CHECKER_ENABLED
		42	#endif
		43
		44	#include <rtems/confdefs.h>
		45
		46	/* If --drvmgr was enabled during the configuration of the RTEMS kernel */
		47	#ifdef RTEMS_DRVMGR_STARTUP
		48	#ifdef LEON3
		49	/* Add Timer and UART Driver */
		50	#ifdef CONFIGURE_APPLICATION_NEEDS_CLOCK_DRIVER
		51	#define CONFIGURE_DRIVER_AMBAPP_GAISLER_GPTIMER
		52	#endif
		53	#ifdef CONFIGURE_APPLICATION_NEEDS_CONSOLE_DRIVER
		54	#define CONFIGURE_DRIVER_AMBAPP_GAISLER_APBUART
		55	#endif
		56	#endif
		57	#define CONFIGURE_DRIVER_AMBAPP_GAISLER_GRSPW /* GRSPW Driver */
		58	#include <drvmgr/drvmgr_confdefs.h>
		59	#endif
		60
		61	#include "fsw_init.h"
		62	#include "fsw_config.c"
		63
		64	rtems_id rtems_task_id_updt;
		65	rtems_name rtems_task_name_updt;
		66
		67	rtems_task Init( rtems_task_argument ignored )
		68	{
		69	/** This is the RTEMS INIT taks, it the first task launched by the system.
		70	*
		71	* @param unused is the starting argument of the RTEMS task
		72	*
		73	* The INIT task create and run all other RTEMS tasks.
		74	*
		75	*/
		76
		77	unsigned char *vhdlVersion;
		78
		79	reset_local_time();
		80
		81	rtems_cpu_usage_reset();
		82
		83	rtems_status_code status;
		84	rtems_status_code status_spw;
		85
		86	struct grgpio_regs_str grgpio_regs = (struct grgpio_regs_str ) REGS_ADDR_GRGPIO;
		87
		88	// UART settings
		89	send_console_outputs_on_apbuart_port();
		90	set_apbuart_scaler_reload_register(REGS_ADDR_APBUART, APBUART_SCALER_RELOAD_VALUE);
		91	enable_apbuart_transmitter();
		92	DEBUG_PRINTF("\n\n\n\n\nIn INIT *** Now the console is on port COM1\n")
		93
		94	PRINTF("\n\n\n\n\n")
		95	PRINTF("*************************\n")
		96	PRINTF(" timegen for LFR \n")
		97	PRINTF1("** %d.", SW_VERSION_N1)
		98	PRINTF1("%d." , SW_VERSION_N2)
		99	PRINTF1("%d." , SW_VERSION_N3)
		100	PRINTF1("%d **\n", SW_VERSION_N4)
		101
		102	vhdlVersion = (unsigned char *) (REGS_ADDR_VHDL_VERSION);
		103	PRINTF(" VHDL \n")
		104	PRINTF1("** %d.", vhdlVersion[1])
		105	PRINTF1("%d." , vhdlVersion[2])
		106	PRINTF1("%d **\n", vhdlVersion[3])
		107	PRINTF("*************************\n")
		108	PRINTF("\n\n")
		109
		110	create_names(); // create all names
		111
		112	status = create_message_queues(); // create message queues
		113	if (status != RTEMS_SUCCESSFUL)
		114	{
		115	PRINTF1("in INIT *** ERR in create_message_queues, code %d", status)
		116	}
		117
		118	status = create_all_tasks(); // create all tasks
		119	if (status != RTEMS_SUCCESSFUL)
		120	{
		121	PRINTF1("in INIT *** ERR in create_all_tasks, code %d\n", status)
		122	}
		123
		124	// **************************
		125	// <SPACEWIRE INITIALIZATION>
		126	grspw_timecode_callback = &timecode_irq_handler;
		127
		128	status_spw = spacewire_open_link(); // (1) open the link
		129	if ( status_spw != RTEMS_SUCCESSFUL )
		130	{
		131	PRINTF1("in INIT *** ERR spacewire_open_link code %d\n", status_spw )
		132	}
		133
		134	if ( status_spw == RTEMS_SUCCESSFUL ) // (2) configure the link
		135	{
		136	status_spw = spacewire_configure_link( fdSPW );
		137	if ( status_spw != RTEMS_SUCCESSFUL )
		138	{
		139	PRINTF1("in INIT *** ERR spacewire_configure_link code %d\n", status_spw )
		140	}
		141	}
		142
		143	if ( status_spw == RTEMS_SUCCESSFUL) // (3) start the link
		144	{
		145	status_spw = spacewire_start_link( fdSPW );
		146	if ( status_spw != RTEMS_SUCCESSFUL )
		147	{
		148	PRINTF1("in INIT *** ERR spacewire_start_link code %d\n", status_spw )
		149	}
		150	}
		151	// </SPACEWIRE INITIALIZATION>
		152	// ***************************
		153
		154	status = start_all_tasks(); // start all tasks
		155	if (status != RTEMS_SUCCESSFUL)
		156	{
		157	PRINTF1("in INIT *** ERR in start_all_tasks, code %d", status)
		158	}
		159
		160	// start RECV and SEND AFTER SpaceWire Initialization, due to the timeout of the start call during the initialization
		161	status = start_recv_send_tasks();
		162	if ( status != RTEMS_SUCCESSFUL )
		163	{
		164	PRINTF1("in INIT *** ERR start_recv_send_tasks code %d\n", status )
		165	}
		166
		167	// suspend science tasks, they will be restarted later depending on the mode
		168	status = suspend_science_tasks(); // suspend science tasks (not done in stop_current_mode if current mode = STANDBY)
		169	if (status != RTEMS_SUCCESSFUL)
		170	{
		171	PRINTF1("in INIT * in suspend_science_tasks * ERR code: %d\n", status)
		172	}
		173
		174	// if the spacewire link is not up then send an event to the SPIQ task for link recovery
		175	if ( status_spw != RTEMS_SUCCESSFUL )
		176	{
		177	status = rtems_event_send( Task_id[TASKID_SPIQ], SPW_LINKERR_EVENT );
		178	if ( status != RTEMS_SUCCESSFUL ) {
		179	PRINTF1("in INIT *** ERR rtems_event_send to SPIQ code %d\n", status )
		180	}
		181	}
		182
		183	//*********************************
		184	// init GPIO for trigger generation
		185	grgpio_regs->io_port_direction_register =
		186	grgpio_regs->io_port_direction_register \| 0x04; // [0000 0100], 0 = output disabled, 1 = output enabled
		187	grgpio_regs->io_port_direction_register =
		188	grgpio_regs->io_port_direction_register \| 0x08; // [0000 1000], 0 = output disabled, 1 = output enabled
		189
		190	BOOT_PRINTF("delete INIT\n")
		191
		192	status = rtems_task_delete(RTEMS_SELF);
		193
		194	}
		195
		196	void init_local_mode_parameters( void )
		197	{
		198	/** This function initialize the param_local global variable with default values.
		199	*
		200	*/
		201
		202	unsigned int i;
		203
		204	// LOCAL PARAMETERS
		205
		206	BOOT_PRINTF1("local_sbm1_nb_cwf_max %d \n", param_local.local_sbm1_nb_cwf_max)
		207	BOOT_PRINTF1("local_sbm2_nb_cwf_max %d \n", param_local.local_sbm2_nb_cwf_max)
		208	// BOOT_PRINTF1("nb_interrupt_f0_MAX = %d\n", param_local.local_nb_interrupt_f0_MAX)
		209
		210	// init sequence counters
		211
		212	for(i = 0; i<SEQ_CNT_NB_DEST_ID; i++)
		213	{
		214	sequenceCounters_TC_EXE[i] = 0x00;
		215	}
		216	sequenceCounters_SCIENCE_NORMAL_BURST = 0x00;
		217	sequenceCounters_SCIENCE_SBM1_SBM2 = 0x00;
		218	sequenceCounterHK = TM_PACKET_SEQ_CTRL_STANDALONE << 8;
		219	sequenceCounterParameterDump = TM_PACKET_SEQ_CTRL_STANDALONE << 8;
		220	}
		221
		222	void reset_local_time( void )
		223	{
		224	time_management_regs->ctrl = 0x02; // software reset, coarse time = 0x80000000
		225	}
		226
		227	void create_names( void ) // create all names for tasks and queues
		228	{
		229	/** This function creates all RTEMS names used in the software for tasks and queues.
		230	*
		231	* @return RTEMS directive status codes:
		232	* - RTEMS_SUCCESSFUL - successful completion
		233	*
		234	*/
		235
		236	// task names
		237	Task_name[TASKID_RECV] = rtems_build_name( 'R', 'E', 'C', 'V' );
		238	Task_name[TASKID_ACTN] = rtems_build_name( 'A', 'C', 'T', 'N' );
		239	Task_name[TASKID_SPIQ] = rtems_build_name( 'S', 'P', 'I', 'Q' );
		240	Task_name[TASKID_STAT] = rtems_build_name( 'S', 'T', 'A', 'T' );
		241	Task_name[TASKID_DUMB] = rtems_build_name( 'D', 'U', 'M', 'B' );
		242	Task_name[TASKID_SEND] = rtems_build_name( 'S', 'E', 'N', 'D' );
		243	Task_name[TASKID_WTDG] = rtems_build_name( 'W', 'T', 'D', 'G' );
		244
		245	rtems_task_name_updt = rtems_build_name( 'U', 'P', 'D', 'T' );
		246
		247	misc_name[QUEUE_RECV] = rtems_build_name( 'Q', '_', 'R', 'V' );
		248	misc_name[QUEUE_SEND] = rtems_build_name( 'Q', '_', 'S', 'D' );
		249
		250	}
		251
		252	int create_all_tasks( void ) // create all tasks which run in the software
		253	{
		254	/** This function creates all RTEMS tasks used in the software.
		255	*
		256	* @return RTEMS directive status codes:
		257	* - RTEMS_SUCCESSFUL - task created successfully
		258	* - RTEMS_INVALID_ADDRESS - id is NULL
		259	* - RTEMS_INVALID_NAME - invalid task name
		260	* - RTEMS_INVALID_PRIORITY - invalid task priority
		261	* - RTEMS_MP_NOT_CONFIGURED - multiprocessing not configured
		262	* - RTEMS_TOO_MANY - too many tasks created
		263	* - RTEMS_UNSATISFIED - not enough memory for stack/FP context
		264	* - RTEMS_TOO_MANY - too many global objects
		265	*
		266	*/
		267
		268	rtems_status_code status;
		269
		270	//**********
		271	// SPACEWIRE
		272	// RECV
		273	status = rtems_task_create(
		274	Task_name[TASKID_RECV], TASK_PRIORITY_RECV, RTEMS_MINIMUM_STACK_SIZE,
		275	RTEMS_DEFAULT_MODES,
		276	RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_RECV]
		277	);
		278	if (status == RTEMS_SUCCESSFUL) // SEND
		279	{
		280	status = rtems_task_create(
		281	Task_name[TASKID_SEND], TASK_PRIORITY_SEND, RTEMS_MINIMUM_STACK_SIZE,
		282	RTEMS_DEFAULT_MODES \| RTEMS_NO_PREEMPT,
		283	RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_SEND]
		284	);
		285	}
		286	if (status == RTEMS_SUCCESSFUL) // WTDG
		287	{
		288	status = rtems_task_create(
		289	Task_name[TASKID_WTDG], TASK_PRIORITY_WTDG, RTEMS_MINIMUM_STACK_SIZE,
		290	RTEMS_DEFAULT_MODES,
		291	RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_WTDG]
		292	);
		293	}
		294	if (status == RTEMS_SUCCESSFUL) // ACTN
		295	{
		296	status = rtems_task_create(
		297	Task_name[TASKID_ACTN], TASK_PRIORITY_ACTN, RTEMS_MINIMUM_STACK_SIZE,
		298	RTEMS_DEFAULT_MODES \| RTEMS_NO_PREEMPT,
		299	RTEMS_DEFAULT_ATTRIBUTES \| RTEMS_FLOATING_POINT, &Task_id[TASKID_ACTN]
		300	);
		301	}
		302	if (status == RTEMS_SUCCESSFUL) // SPIQ
		303	{
		304	status = rtems_task_create(
		305	Task_name[TASKID_SPIQ], TASK_PRIORITY_SPIQ, RTEMS_MINIMUM_STACK_SIZE,
		306	RTEMS_DEFAULT_MODES \| RTEMS_NO_PREEMPT,
		307	RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_SPIQ]
		308	);
		309	}
		310
		311	//*****
		312	// MISC
		313	if (status == RTEMS_SUCCESSFUL) // STAT
		314	{
		315	status = rtems_task_create(
		316	Task_name[TASKID_STAT], TASK_PRIORITY_STAT, RTEMS_MINIMUM_STACK_SIZE,
		317	RTEMS_DEFAULT_MODES,
		318	RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_STAT]
		319	);
		320	}
		321	if (status == RTEMS_SUCCESSFUL) // DUMB
		322	{
		323	status = rtems_task_create(
		324	Task_name[TASKID_DUMB], TASK_PRIORITY_DUMB, RTEMS_MINIMUM_STACK_SIZE,
		325	RTEMS_DEFAULT_MODES,
		326	RTEMS_DEFAULT_ATTRIBUTES, &Task_id[TASKID_DUMB]
		327	);
		328	}
		329	if (status == RTEMS_SUCCESSFUL) // UPDT
		330	{
		331	status = rtems_task_create(
		332	rtems_task_name_updt, TASK_PRIORITY_HOUS, RTEMS_MINIMUM_STACK_SIZE,
		333	RTEMS_DEFAULT_MODES,
		334	RTEMS_DEFAULT_ATTRIBUTES, &rtems_task_id_updt
		335	);
		336	}
		337
		338	return status;
		339	}
		340
		341	int start_recv_send_tasks( void )
		342	{
		343	rtems_status_code status;
		344
		345	status = rtems_task_start( Task_id[TASKID_RECV], recv_task, 1 );
		346	if (status!=RTEMS_SUCCESSFUL) {
		347	BOOT_PRINTF("in INIT *** Error starting TASK_RECV\n")
		348	}
		349
		350	if (status == RTEMS_SUCCESSFUL) // SEND
		351	{
		352	status = rtems_task_start( Task_id[TASKID_SEND], send_task, 1 );
		353	if (status!=RTEMS_SUCCESSFUL) {
		354	BOOT_PRINTF("in INIT *** Error starting TASK_SEND\n")
		355	}
		356	}
		357
		358	return status;
		359	}
		360
		361	int start_all_tasks( void ) // start all tasks except SEND RECV and HOUS
		362	{
		363	/** This function starts all RTEMS tasks used in the software.
		364	*
		365	* @return RTEMS directive status codes:
		366	* - RTEMS_SUCCESSFUL - ask started successfully
		367	* - RTEMS_INVALID_ADDRESS - invalid task entry point
		368	* - RTEMS_INVALID_ID - invalid task id
		369	* - RTEMS_INCORRECT_STATE - task not in the dormant state
		370	* - RTEMS_ILLEGAL_ON_REMOTE_OBJECT - cannot start remote task
		371	*
		372	*/
		373	// starts all the tasks fot eh flight software
		374
		375	rtems_status_code status;
		376
		377	//**********
		378	// SPACEWIRE
		379	status = rtems_task_start( Task_id[TASKID_SPIQ], spiq_task, 1 );
		380	if (status!=RTEMS_SUCCESSFUL) {
		381	BOOT_PRINTF("in INIT *** Error starting TASK_SPIQ\n")
		382	}
		383
		384	if (status == RTEMS_SUCCESSFUL) // WTDG
		385	{
		386	status = rtems_task_start( Task_id[TASKID_WTDG], wtdg_task, 1 );
		387	if (status!=RTEMS_SUCCESSFUL) {
		388	BOOT_PRINTF("in INIT *** Error starting TASK_WTDG\n")
		389	}
		390	}
		391
		392	if (status == RTEMS_SUCCESSFUL) // ACTN
		393	{
		394	status = rtems_task_start( Task_id[TASKID_ACTN], actn_task, 1 );
		395	if (status!=RTEMS_SUCCESSFUL) {
		396	BOOT_PRINTF("in INIT *** Error starting TASK_ACTN\n")
		397	}
		398	}
		399
		400	//*****
		401	// MISC
		402	if (status == RTEMS_SUCCESSFUL) // DUMB
		403	{
		404	status = rtems_task_start( Task_id[TASKID_DUMB], dumb_task, 1 );
		405	if (status!=RTEMS_SUCCESSFUL) {
		406	BOOT_PRINTF("in INIT *** Error starting TASK_DUMB\n")
		407	}
		408	}
		409	if (status == RTEMS_SUCCESSFUL) // STAT
		410	{
		411	status = rtems_task_start( Task_id[TASKID_STAT], stat_task, 1 );
		412	if (status!=RTEMS_SUCCESSFUL) {
		413	BOOT_PRINTF("in INIT *** Error starting TASK_STAT\n")
		414	}
		415	}
		416	if (status == RTEMS_SUCCESSFUL) // UPDT
		417	{
		418	status = rtems_task_start( rtems_task_id_updt, updt_task, 1 );
		419	if (status!=RTEMS_SUCCESSFUL) {
		420	BOOT_PRINTF("in INIT *** Error starting TASK_UPDT\n")
		421	}
		422	}
		423
		424	return status;
		425	}
		426
		427	rtems_status_code create_message_queues( void ) // create the two message queues used in the software
		428	{
		429	rtems_status_code status_recv;
		430	rtems_status_code status_send;
		431
		432	rtems_status_code ret;
		433	rtems_id queue_id;
		434
		435	ret = LFR_SUCCESSFUL;
		436
		437	//****************************************
		438	// create the queue for handling valid TCs
		439	status_recv = rtems_message_queue_create( misc_name[QUEUE_RECV],
		440	MSG_QUEUE_COUNT_RECV, CCSDS_TC_PKT_MAX_SIZE,
		441	RTEMS_FIFO \| RTEMS_LOCAL, &queue_id );
		442	if ( status_recv != RTEMS_SUCCESSFUL ) {
		443	PRINTF1("in create_message_queues *** ERR creating QUEU queue, %d\n", status_recv)
		444	}
		445
		446	//************************************************
		447	// create the queue for handling TM packet sending
		448	status_send = rtems_message_queue_create( misc_name[QUEUE_SEND],
		449	MSG_QUEUE_COUNT_SEND, MSG_QUEUE_SIZE_SEND,
		450	RTEMS_FIFO \| RTEMS_LOCAL, &queue_id );
		451	if ( status_send != RTEMS_SUCCESSFUL ) {
		452	PRINTF1("in create_message_queues *** ERR creating PKTS queue, %d\n", status_send)
		453	}
		454
		455	if ( status_recv != RTEMS_SUCCESSFUL )
		456	{
		457	ret = status_recv;
		458	}
		459	else if( status_send != RTEMS_SUCCESSFUL )
		460	{
		461	ret = status_send;
		462	}
		463
		464	return ret;
		465	}
		466
		467	rtems_status_code get_message_queue_id_send( rtems_id *queue_id )
		468	{
		469	rtems_status_code status;
		470	rtems_name queue_name;
		471
		472	queue_name = rtems_build_name( 'Q', '_', 'S', 'D' );
		473
		474	status = rtems_message_queue_ident( queue_name, 0, queue_id );
		475
		476	return status;
		477	}
		478
		479	rtems_status_code get_message_queue_id_recv( rtems_id *queue_id )
		480	{
		481	rtems_status_code status;
		482	rtems_name queue_name;
		483
		484	queue_name = rtems_build_name( 'Q', '_', 'R', 'V' );
		485
		486	status = rtems_message_queue_ident( queue_name, 0, queue_id );
		487
		488	return status;
		489	}

timegen/src/fsw_misc.c created 644 +252 0

			@@ -0,0 +1,252
		1	/** General usage functions and RTEMS tasks.
		2	*
		3	* @file
		4	* @author P. LEROY
		5	*
		6	*/
		7
		8	#include "fsw_misc.h"
		9
		10	void configure_timer(gptimer_regs_t *gptimer_regs, unsigned char timer, unsigned int clock_divider,
		11	unsigned char interrupt_level, rtems_isr (*timer_isr)() )
		12	{
		13	/** This function configures a GPTIMER timer instantiated in the VHDL design.
		14	*
		15	* @param gptimer_regs points to the APB registers of the GPTIMER IP core.
		16	* @param timer is the number of the timer in the IP core (several timers can be instantiated).
		17	* @param clock_divider is the divider of the 1 MHz clock that will be configured.
		18	* @param interrupt_level is the interrupt level that the timer drives.
		19	* @param timer_isr is the interrupt subroutine that will be attached to the IRQ driven by the timer.
		20	*
		21	* Interrupt levels are described in the SPARC documentation sparcv8.pdf p.76
		22	*
		23	*/
		24
		25	rtems_status_code status;
		26	rtems_isr_entry old_isr_handler;
		27
		28	gptimer_regs->timer[timer].ctrl = 0x00; // reset the control register
		29
		30	status = rtems_interrupt_catch( timer_isr, interrupt_level, &old_isr_handler) ; // see sparcv8.pdf p.76 for interrupt levels
		31	if (status!=RTEMS_SUCCESSFUL)
		32	{
		33	PRINTF("in configure_timer *** ERR rtems_interrupt_catch\n")
		34	}
		35
		36	timer_set_clock_divider( gptimer_regs, timer, clock_divider);
		37	}
		38
		39	void timer_start(gptimer_regs_t *gptimer_regs, unsigned char timer)
		40	{
		41	/** This function starts a GPTIMER timer.
		42	*
		43	* @param gptimer_regs points to the APB registers of the GPTIMER IP core.
		44	* @param timer is the number of the timer in the IP core (several timers can be instantiated).
		45	*
		46	*/
		47
		48	gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl \| 0x00000010; // clear pending IRQ if any
		49	gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl \| 0x00000004; // LD load value from the reload register
		50	gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl \| 0x00000001; // EN enable the timer
		51	gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl \| 0x00000002; // RS restart
		52	gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl \| 0x00000008; // IE interrupt enable
		53	}
		54
		55	void timer_stop(gptimer_regs_t *gptimer_regs, unsigned char timer)
		56	{
		57	/** This function stops a GPTIMER timer.
		58	*
		59	* @param gptimer_regs points to the APB registers of the GPTIMER IP core.
		60	* @param timer is the number of the timer in the IP core (several timers can be instantiated).
		61	*
		62	*/
		63
		64	gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl & 0xfffffffe; // EN enable the timer
		65	gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl & 0xffffffef; // IE interrupt enable
		66	gptimer_regs->timer[timer].ctrl = gptimer_regs->timer[timer].ctrl \| 0x00000010; // clear pending IRQ if any
		67	}
		68
		69	void timer_set_clock_divider(gptimer_regs_t *gptimer_regs, unsigned char timer, unsigned int clock_divider)
		70	{
		71	/** This function sets the clock divider of a GPTIMER timer.
		72	*
		73	* @param gptimer_regs points to the APB registers of the GPTIMER IP core.
		74	* @param timer is the number of the timer in the IP core (several timers can be instantiated).
		75	* @param clock_divider is the divider of the 1 MHz clock that will be configured.
		76	*
		77	*/
		78
		79	gptimer_regs->timer[timer].reload = clock_divider; // base clock frequency is 1 MHz
		80	}
		81
		82	int send_console_outputs_on_apbuart_port( void ) // Send the console outputs on the apbuart port
		83	{
		84	struct apbuart_regs_str apbuart_regs = (struct apbuart_regs_str ) REGS_ADDR_APBUART;
		85
		86	apbuart_regs->ctrl = APBUART_CTRL_REG_MASK_TE;
		87
		88	return 0;
		89	}
		90
		91	int enable_apbuart_transmitter( void ) // set the bit 1, TE Transmitter Enable to 1 in the APBUART control register
		92	{
		93	struct apbuart_regs_str apbuart_regs = (struct apbuart_regs_str ) REGS_ADDR_APBUART;
		94
		95	apbuart_regs->ctrl = apbuart_regs->ctrl \| APBUART_CTRL_REG_MASK_TE;
		96
		97	return 0;
		98	}
		99
		100	void set_apbuart_scaler_reload_register(unsigned int regs, unsigned int value)
		101	{
		102	/** This function sets the scaler reload register of the apbuart module
		103	*
		104	* @param regs is the address of the apbuart registers in memory
		105	* @param value is the value that will be stored in the scaler register
		106	*
		107	* The value shall be set by the software to get data on the serial interface.
		108	*
		109	*/
		110
		111	struct apbuart_regs_str apbuart_regs = (struct apbuart_regs_str ) regs;
		112
		113	apbuart_regs->scaler = value;
		114	BOOT_PRINTF1("OK *** apbuart port scaler reload register set to 0x%x\n", value)
		115	}
		116
		117	//************
		118	// RTEMS TASKS
		119
		120	rtems_task stat_task(rtems_task_argument argument)
		121	{
		122	int i;
		123	int j;
		124	i = 0;
		125	j = 0;
		126	BOOT_PRINTF("in STAT *** \n")
		127	while(1){
		128	rtems_task_wake_after(1000);
		129	PRINTF1("%d\n", j)
		130	if (i == CPU_USAGE_REPORT_PERIOD) {
		131	// #ifdef PRINT_TASK_STATISTICS
		132	// rtems_cpu_usage_report();
		133	// rtems_cpu_usage_reset();
		134	// #endif
		135	i = 0;
		136	}
		137	else i++;
		138	j++;
		139	}
		140	}
		141
		142	rtems_task dumb_task( rtems_task_argument unused )
		143	{
		144	/** This RTEMS taks is used to print messages without affecting the general behaviour of the software.
		145	*
		146	* @param unused is the starting argument of the RTEMS task
		147	*
		148	* The DUMB taks waits for RTEMS events and print messages depending on the incoming events.
		149	*
		150	*/
		151
		152	unsigned int i;
		153	unsigned int intEventOut;
		154	unsigned int coarse_time = 0;
		155	unsigned int fine_time = 0;
		156	rtems_event_set event_out;
		157
		158	char DumbMessages[12] = {"in DUMB ** default", // RTEMS_EVENT_0
		159	"in DUMB *** timecode_irq_handler", // RTEMS_EVENT_1
		160	"in DUMB *** f3 buffer changed", // RTEMS_EVENT_2
		161	"in DUMB * in SMIQ * Error sending event to AVF0", // RTEMS_EVENT_3
		162	"in DUMB * spectral_matrices_isr * Error sending event to SMIQ", // RTEMS_EVENT_4
		163	"in DUMB *** waveforms_simulator_isr", // RTEMS_EVENT_5
		164	"ERR HK", // RTEMS_EVENT_6
		165	"ready for dump", // RTEMS_EVENT_7
		166	"VHDL ERR *** spectral matrix", // RTEMS_EVENT_8
		167	"tick", // RTEMS_EVENT_9
		168	"VHDL ERR *** waveform picker", // RTEMS_EVENT_10
		169	"VHDL ERR *** unexpected ready matrix values" // RTEMS_EVENT_11
		170	};
		171
		172	BOOT_PRINTF("in DUMB *** \n")
		173
		174	while(1){
		175	rtems_event_receive(RTEMS_EVENT_0 \| RTEMS_EVENT_1 \| RTEMS_EVENT_2 \| RTEMS_EVENT_3
		176	\| RTEMS_EVENT_4 \| RTEMS_EVENT_5 \| RTEMS_EVENT_6 \| RTEMS_EVENT_7
		177	\| RTEMS_EVENT_8 \| RTEMS_EVENT_9,
		178	RTEMS_WAIT \| RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT
		179	intEventOut = (unsigned int) event_out;
		180	for ( i=0; i<32; i++)
		181	{
		182	if ( ((intEventOut >> i) & 0x0001) != 0)
		183	{
		184	coarse_time = time_management_regs->coarse_time;
		185	fine_time = time_management_regs->fine_time;
		186	printf("in DUMB *** coarse: %x, fine: %x, %s\n", coarse_time, fine_time, DumbMessages[i]);
		187	if (i==8)
		188	{
		189	}
		190	if (i==10)
		191	{
		192	}
		193	}
		194	}
		195	}
		196	}
		197
		198	//*****************************
		199	// init housekeeping parameters
		200
		201	void increment_seq_counter( unsigned short *packetSequenceControl )
		202	{
		203	/** This function increment the sequence counter psased in argument.
		204	*
		205	* The increment does not affect the grouping flag. In case of an overflow, the counter is reset to 0.
		206	*
		207	*/
		208
		209	unsigned short segmentation_grouping_flag;
		210	unsigned short sequence_cnt;
		211
		212	segmentation_grouping_flag = TM_PACKET_SEQ_CTRL_STANDALONE << 8; // keep bits 7 downto 6
		213	sequence_cnt = (*packetSequenceControl) & 0x3fff; // [0011 1111 1111 1111]
		214
		215	if ( sequence_cnt < SEQ_CNT_MAX)
		216	{
		217	sequence_cnt = sequence_cnt + 1;
		218	}
		219	else
		220	{
		221	sequence_cnt = 0;
		222	}
		223
		224	*packetSequenceControl = segmentation_grouping_flag \| sequence_cnt ;
		225	}
		226
		227	void getTime( unsigned char *time)
		228	{
		229	/** This function write the current local time in the time buffer passed in argument.
		230	*
		231	*/
		232
		233	time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
		234	time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
		235	time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
		236	time[3] = (unsigned char) (time_management_regs->coarse_time);
		237	time[4] = (unsigned char) (time_management_regs->fine_time>>8);
		238	time[5] = (unsigned char) (time_management_regs->fine_time);
		239	}
		240
		241	unsigned long long int getTimeAsUnsignedLongLongInt( )
		242	{
		243	/** This function write the current local time in the time buffer passed in argument.
		244	*
		245	*/
		246	unsigned long long int time;
		247
		248	time = ( (unsigned long long int) (time_management_regs->coarse_time & 0x7fffffff) << 16 )
		249	+ time_management_regs->fine_time;
		250
		251	return time;
		252	}

timegen/src/fsw_processing_globals.c created 644 +46 0

			@@ -0,0 +1,46
		1	/** Global variables used by the processing functions.
		2	*
		3	* @file
		4	* @author P. LEROY
		5	*
		6	*/
		7
		8	// TOTAL = 32 coefficients * 4 = 128 octets * 3 * 12 = 4608 octets
		9	// SX 12 coefficients
		10	float K14_sx_re = 1;
		11	float K14_sx_im = 1;
		12	float K15_sx_re = 1;
		13	float K15_sx_im = 1;
		14	float K24_sx_re = 1;
		15	float K24_sx_im = 1;
		16	float K25_sx_re = 1;
		17	float K25_sx_im = 1;
		18	float K34_sx_re = 1;
		19	float K34_sx_im = 1;
		20	float K35_sx_re = 1;
		21	float K35_sx_im = 1;
		22	// NY 8 coefficients
		23	float K24_ny_re = 1;
		24	float K24_ny_im = 1;
		25	float K25_ny_re = 1;
		26	float K25_ny_im = 1;
		27	float K34_ny_re = 1;
		28	float K34_ny_im = 1;
		29	float K35_ny_re = 1;
		30	float K35_ny_im = 1;
		31	// NZ 8 coefficients
		32	float K24_nz_re = 1;
		33	float K24_nz_im = 1;
		34	float K25_nz_re = 1;
		35	float K25_nz_im = 1;
		36	float K34_nz_re = 1;
		37	float K34_nz_im = 1;
		38	float K35_nz_re = 1;
		39	float K35_nz_im = 1;
		40	// PE 4 coefficients
		41	float K44_pe = 1;
		42	float K55_pe = 1;
		43	float K45_pe_re = 1;
		44	float K45_pe_im = 1;
		45
		46	float Alpha_M = M_PI/4;

timegen/src/fsw_spacewire.c created 644 +728 0

This diff has been collapsed as it changes many lines, (728 lines changed) Show them Hide them
		@@ -0,0 +1,728
	1	/** Functions related to the SpaceWire interface.
	2	*
	3	* @file
	4	* @author P. LEROY
	5	*
	6	* A group of functions to handle SpaceWire transmissions:
	7	* - configuration of the SpaceWire link
	8	* - SpaceWire related interruption requests processing
	9	* - transmission of TeleMetry packets by a dedicated RTEMS task
	10	* - reception of TeleCommands by a dedicated RTEMS task
	11	*
	12	*/
	13
	14	#include "fsw_spacewire.h"
	15
	16	rtems_name semq_name;
	17	rtems_id semq_id;
	18
	19	unsigned int localCoarseTime;
	20
	21	void resetLocalCoarseTime()
	22	{
	23	localCoarseTime = 0;
	24	}
	25
	26	void setLocalCoarseTime( unsigned int value )
	27	{
	28	localCoarseTime = value;
	29	}
	30
	31	unsigned int getLocalCoarseTime()
	32	{
	33	return localCoarseTime;
	34	}
	35
	36	void incrementLocalCoarseTime()
	37	{
	38	localCoarseTime = localCoarseTime + 1;
	39	}
	40
	41	//***********
	42	// RTEMS TASK
	43	rtems_task spiq_task(rtems_task_argument unused)
	44	{
	45	/** This RTEMS task is awaken by an rtems_event sent by the interruption subroutine of the SpaceWire driver.
	46	*
	47	* @param unused is the starting argument of the RTEMS task
	48	*
	49	*/
	50
	51	rtems_event_set event_out;
	52	rtems_status_code status;
	53	int linkStatus;
	54
	55	BOOT_PRINTF("in SPIQ *** \n")
	56
	57	while(true){
	58	rtems_event_receive(SPW_LINKERR_EVENT, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an SPW_LINKERR_EVENT
	59	PRINTF("in SPIQ *** got SPW_LINKERR_EVENT\n")
	60
	61	// [0] SUSPEND RECV AND SEND TASKS
	62	status = rtems_task_suspend( Task_id[ TASKID_RECV ] );
	63	if ( status != RTEMS_SUCCESSFUL ) {
	64	PRINTF("in SPIQ *** ERR suspending RECV Task\n")
	65	}
	66	status = rtems_task_suspend( Task_id[ TASKID_SEND ] );
	67	if ( status != RTEMS_SUCCESSFUL ) {
	68	PRINTF("in SPIQ *** ERR suspending SEND Task\n")
	69	}
	70
	71	// [1] CHECK THE LINK
	72	status = ioctl(fdSPW, SPACEWIRE_IOCTRL_GET_LINK_STATUS, &linkStatus); // get the link status (1)
	73	if ( linkStatus != 5) {
	74	PRINTF1("in SPIQ *** linkStatus %d, wait...\n", linkStatus)
	75	status = rtems_task_wake_after( SY_LFR_DPU_CONNECT_TIMEOUT ); // wait SY_LFR_DPU_CONNECT_TIMEOUT 1000 ms
	76	}
	77
	78	// [2] RECHECK THE LINK AFTER SY_LFR_DPU_CONNECT_TIMEOUT
	79	status = ioctl(fdSPW, SPACEWIRE_IOCTRL_GET_LINK_STATUS, &linkStatus); // get the link status (2)
	80	if ( linkStatus != 5 ) // [2.a] not in run state, reset the link
	81	{
	82	spacewire_compute_stats_offsets();
	83	status = spacewire_reset_link( );
	84	}
	85	else // [2.b] in run state, start the link
	86	{
	87	status = spacewire_stop_and_start_link( fdSPW ); // start the link
	88	if ( status != RTEMS_SUCCESSFUL)
	89	{
	90	PRINTF1("in SPIQ *** ERR spacewire_start_link %d\n", status)
	91	}
	92	}
	93
	94	// [3] COMPLETE RECOVERY ACTION AFTER SY_LFR_DPU_CONNECT_ATTEMPTS
	95	if ( status == RTEMS_SUCCESSFUL ) // [3.a] the link is in run state and has been started successfully
	96	{
	97	status = rtems_task_restart( Task_id[ TASKID_SEND ], 1 );
	98	if ( status != RTEMS_SUCCESSFUL ) {
	99	PRINTF("in SPIQ *** ERR resuming SEND Task\n")
	100	}
	101	status = rtems_task_restart( Task_id[ TASKID_RECV ], 1 );
	102	if ( status != RTEMS_SUCCESSFUL ) {
	103	PRINTF("in SPIQ *** ERR resuming RECV Task\n")
	104	}
	105	}
	106	else // [3.b] the link is not in run state, go in STANDBY mode
	107	{
	108	status = stop_current_mode();
	109	if ( status != RTEMS_SUCCESSFUL ) {
	110	PRINTF1("in SPIQ * ERR stop_current_mode * code %d\n", status)
	111	}
	112	status = enter_mode( LFR_MODE_STANDBY, 0 );
	113	if ( status != RTEMS_SUCCESSFUL ) {
	114	PRINTF1("in SPIQ * ERR enter_standby_mode * code %d\n", status)
	115	}
	116	// wake the WTDG task up to wait for the link recovery
	117	status = rtems_event_send ( Task_id[TASKID_WTDG], RTEMS_EVENT_0 );
	118	status = rtems_task_suspend( RTEMS_SELF );
	119	}
	120	}
	121	}
	122
	123	rtems_task recv_task( rtems_task_argument unused )
	124	{
	125	/** This RTEMS task is dedicated to the reception of incoming TeleCommands.
	126	*
	127	* @param unused is the starting argument of the RTEMS task
	128	*
	129	* The RECV task blocks on a call to the read system call, waiting for incoming SpaceWire data. When unblocked:
	130	* 1. It reads the incoming data.
	131	* 2. Launches the acceptance procedure.
	132	* 3. If the Telecommand is valid, sends it to a dedicated RTEMS message queue.
	133	*
	134	*/
	135
	136	int len;
	137	ccsdsTelecommandPacket_t currentTC;
	138	unsigned char computed_CRC[ 2 ];
	139	unsigned char currentTC_LEN_RCV[ 2 ];
	140	unsigned char destinationID;
	141	unsigned int estimatedPacketLength;
	142	unsigned int parserCode;
	143	rtems_status_code status;
	144	rtems_id queue_recv_id;
	145	rtems_id queue_send_id;
	146
	147	initLookUpTableForCRC(); // the table is used to compute Cyclic Redundancy Codes
	148
	149	status = get_message_queue_id_recv( &queue_recv_id );
	150	if (status != RTEMS_SUCCESSFUL)
	151	{
	152	PRINTF1("in RECV *** ERR get_message_queue_id_recv %d\n", status)
	153	}
	154
	155	status = get_message_queue_id_send( &queue_send_id );
	156	if (status != RTEMS_SUCCESSFUL)
	157	{
	158	PRINTF1("in RECV *** ERR get_message_queue_id_send %d\n", status)
	159	}
	160
	161	BOOT_PRINTF("in RECV *** \n")
	162
	163	while(1)
	164	{
	165	len = read( fdSPW, (char*) &currentTC, CCSDS_TC_PKT_MAX_SIZE ); // the call to read is blocking
	166	if (len == -1){ // error during the read call
	167	PRINTF1("in RECV *** last read call returned -1, ERRNO %d\n", errno)
	168	}
	169	else {
	170	if ( (len+1) < CCSDS_TC_PKT_MIN_SIZE ) {
	171	PRINTF("in RECV *** packet lenght too short\n")
	172	}
	173	else {
	174	estimatedPacketLength = (unsigned int) (len - CCSDS_TC_TM_PACKET_OFFSET - 3); // => -3 is for Prot ID, Reserved and User App bytes
	175	currentTC_LEN_RCV[ 0 ] = (unsigned char) (estimatedPacketLength >> 8);
	176	currentTC_LEN_RCV[ 1 ] = (unsigned char) (estimatedPacketLength );
	177	// CHECK THE TC
	178	parserCode = tc_parser( &currentTC, estimatedPacketLength, computed_CRC ) ;
	179	if ( (parserCode == ILLEGAL_APID) \|\| (parserCode == WRONG_LEN_PKT)
	180	\|\| (parserCode == INCOR_CHECKSUM) \|\| (parserCode == ILL_TYPE)
	181	\|\| (parserCode == ILL_SUBTYPE) \|\| (parserCode == WRONG_APP_DATA)
	182	\|\| (parserCode == WRONG_SRC_ID) )
	183	{ // send TM_LFR_TC_EXE_CORRUPTED
	184	PRINTF1("TC corrupted received, with code: %d\n", parserCode)
	185	if ( !( (currentTC.serviceType==TC_TYPE_TIME) && (currentTC.serviceSubType==TC_SUBTYPE_UPDT_TIME) )
	186	&&
	187	!( (currentTC.serviceType==TC_TYPE_GEN) && (currentTC.serviceSubType==TC_SUBTYPE_UPDT_INFO))
	188	)
	189	{
	190	if ( parserCode == WRONG_SRC_ID )
	191	{
	192	destinationID = SID_TC_GROUND;
	193	}
	194	else
	195	{
	196	destinationID = currentTC.sourceID;
	197	}
	198	}
	199	}
	200	else
	201	{ // send valid TC to the action launcher
	202	status = rtems_message_queue_send( queue_recv_id, &currentTC,
	203	estimatedPacketLength + CCSDS_TC_TM_PACKET_OFFSET + 3);
	204	}
	205	}
	206	}
	207	}
	208	}
	209
	210	rtems_task send_task( rtems_task_argument argument)
	211	{
	212	/** This RTEMS task is dedicated to the transmission of TeleMetry packets.
	213	*
	214	* @param unused is the starting argument of the RTEMS task
	215	*
	216	* The SEND task waits for a message to become available in the dedicated RTEMS queue. When a message arrives:
	217	* - if the first byte is equal to CCSDS_DESTINATION_ID, the message is sent as is using the write system call.
	218	* - if the first byte is not equal to CCSDS_DESTINATION_ID, the message is handled as a spw_ioctl_pkt_send. After
	219	* analyzis, the packet is sent either using the write system call or using the ioctl call SPACEWIRE_IOCTRL_SEND, depending on the
	220	* data it contains.
	221	*
	222	*/
	223
	224	rtems_status_code status; // RTEMS status code
	225	char incomingData[MSG_QUEUE_SIZE_SEND]; // incoming data buffer
	226	spw_ioctl_pkt_send *spw_ioctl_send;
	227	size_t size; // size of the incoming TC packet
	228	u_int32_t count;
	229	rtems_id queue_id;
	230
	231	status = get_message_queue_id_send( &queue_id );
	232	if (status != RTEMS_SUCCESSFUL)
	233	{
	234	PRINTF1("in HOUS *** ERR get_message_queue_id_send %d\n", status)
	235	}
	236
	237	BOOT_PRINTF("in SEND *** \n")
	238
	239	while(1)
	240	{
	241	status = rtems_message_queue_receive( queue_id, incomingData, &size,
	242	RTEMS_WAIT, RTEMS_NO_TIMEOUT );
	243
	244	if (status!=RTEMS_SUCCESSFUL)
	245	{
	246	PRINTF1("in SEND *** (1) ERR = %d\n", status)
	247	}
	248	else
	249	{
	250	if ((incomingData[0] == CCSDS_DESTINATION_ID) \|\| (incomingData[0] == (char) 0xfe)) // the incoming message is a ccsds packet
	251	{
	252	status = write( fdSPW, incomingData, size );
	253	if (status == -1){
	254	PRINTF2("in SEND *** (2.a) ERRNO = %d, size = %d\n", errno, size)
	255	}
	256	}
	257	else // the incoming message is a spw_ioctl_pkt_send structure
	258	{
	259	spw_ioctl_send = (spw_ioctl_pkt_send*) incomingData;
	260	status = ioctl( fdSPW, SPACEWIRE_IOCTRL_SEND, spw_ioctl_send );
	261	if (status == -1){
	262	PRINTF2("in SEND *** (2.b) ERRNO = %d, RTEMS = %d\n", errno, status)
	263	}
	264	}
	265	}
	266
	267	status = rtems_message_queue_get_number_pending( queue_id, &count );
	268	if (status != RTEMS_SUCCESSFUL)
	269	{
	270	PRINTF1("in SEND *** (3) ERR = %d\n", status)
	271	}
	272	else
	273	{
	274	if (count > maxCount)
	275	{
	276	maxCount = count;
	277	}
	278	}
	279	}
	280	}
	281
	282	rtems_task wtdg_task( rtems_task_argument argument )
	283	{
	284	rtems_event_set event_out;
	285	rtems_status_code status;
	286	int linkStatus;
	287
	288	BOOT_PRINTF("in WTDG ***\n")
	289
	290	while(1)
	291	{
	292	// wait for an RTEMS_EVENT
	293	rtems_event_receive( RTEMS_EVENT_0,
	294	RTEMS_WAIT \| RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
	295	PRINTF("in WTDG *** wait for the link\n")
	296	status = ioctl(fdSPW, SPACEWIRE_IOCTRL_GET_LINK_STATUS, &linkStatus); // get the link status
	297	while( linkStatus != 5) // wait for the link
	298	{
	299	rtems_task_wake_after( 10 );
	300	status = ioctl(fdSPW, SPACEWIRE_IOCTRL_GET_LINK_STATUS, &linkStatus); // get the link status
	301	}
	302
	303	status = spacewire_stop_and_start_link( fdSPW );
	304
	305	if (status != RTEMS_SUCCESSFUL)
	306	{
	307	PRINTF1("in WTDG *** ERR link not started %d\n", status)
	308	}
	309	else
	310	{
	311	PRINTF("in WTDG *** OK link started\n")
	312	}
	313
	314	// restart the SPIQ task
	315	status = rtems_task_restart( Task_id[TASKID_SPIQ], 1 );
	316	if ( status != RTEMS_SUCCESSFUL ) {
	317	PRINTF("in SPIQ *** ERR restarting SPIQ Task\n")
	318	}
	319
	320	// restart RECV and SEND
	321	status = rtems_task_restart( Task_id[ TASKID_SEND ], 1 );
	322	if ( status != RTEMS_SUCCESSFUL ) {
	323	PRINTF("in SPIQ *** ERR restarting SEND Task\n")
	324	}
	325	status = rtems_task_restart( Task_id[ TASKID_RECV ], 1 );
	326	if ( status != RTEMS_SUCCESSFUL ) {
	327	PRINTF("in SPIQ *** ERR restarting RECV Task\n")
	328	}
	329	}
	330	}
	331
	332	//****************
	333	// OTHER FUNCTIONS
	334	int spacewire_open_link( void ) // by default, the driver resets the core: [SPW_CTRL_WRITE(pDev, SPW_CTRL_RESET);]
	335	{
	336	/** This function opens the SpaceWire link.
	337	*
	338	* @return a valid file descriptor in case of success, -1 in case of a failure
	339	*
	340	*/
	341	rtems_status_code status;
	342
	343	fdSPW = open(GRSPW_DEVICE_NAME, O_RDWR); // open the device. the open call resets the hardware
	344	if ( fdSPW < 0 ) {
	345	PRINTF1("ERR * in configure_spw_link * error opening "GRSPW_DEVICE_NAME" with ERR %d\n", errno)
	346	}
	347	else
	348	{
	349	status = RTEMS_SUCCESSFUL;
	350	}
	351
	352	return status;
	353	}
	354
	355	int spacewire_start_link( int fd )
	356	{
	357	rtems_status_code status;
	358
	359	status = ioctl( fd, SPACEWIRE_IOCTRL_START, -1); // returns successfuly if the link is started
	360	// -1 default hardcoded driver timeout
	361
	362	return status;
	363	}
	364
	365	int spacewire_stop_and_start_link( int fd )
	366	{
	367	rtems_status_code status;
	368
	369	status = ioctl( fd, SPACEWIRE_IOCTRL_STOP); // start fails if link pDev->running != 0
	370	status = ioctl( fd, SPACEWIRE_IOCTRL_START, -1); // returns successfuly if the link is started
	371	// -1 default hardcoded driver timeout
	372
	373	return status;
	374	}
	375
	376	int spacewire_configure_link( int fd )
	377	{
	378	/** This function configures the SpaceWire link.
	379	*
	380	* @return GR-RTEMS-DRIVER directive status codes:
	381	* - 22 EINVAL - Null pointer or an out of range value was given as the argument.
	382	* - 16 EBUSY - Only used for SEND. Returned when no descriptors are avialble in non-blocking mode.
	383	* - 88 ENOSYS - Returned for SET_DESTKEY if RMAP command handler is not available or if a non-implemented call is used.
	384	* - 116 ETIMEDOUT - REturned for SET_PACKET_SIZE and START if the link could not be brought up.
	385	* - 12 ENOMEM - Returned for SET_PACKETSIZE if it was unable to allocate the new buffers.
	386	* - 5 EIO - Error when writing to grswp hardware registers.
	387	* - 2 ENOENT - No such file or directory
	388	*/
	389
	390	rtems_status_code status;
	391
	392	spacewire_set_NP(1, REGS_ADDR_GRSPW); // [N]o [P]ort force
	393	spacewire_set_RE(1, REGS_ADDR_GRSPW); // [R]MAP [E]nable, the dedicated call seems to break the no port force configuration
	394
	395	status = ioctl(fd, SPACEWIRE_IOCTRL_SET_RXBLOCK, 1); // sets the blocking mode for reception
	396	if (status!=RTEMS_SUCCESSFUL) {
	397	PRINTF("in SPIQ *** Error SPACEWIRE_IOCTRL_SET_RXBLOCK\n")
	398	}
	399	//
	400	status = ioctl(fd, SPACEWIRE_IOCTRL_SET_EVENT_ID, Task_id[TASKID_SPIQ]); // sets the task ID to which an event is sent when a
	401	if (status!=RTEMS_SUCCESSFUL) {
	402	PRINTF("in SPIQ *** Error SPACEWIRE_IOCTRL_SET_EVENT_ID\n") // link-error interrupt occurs
	403	}
	404	//
	405	status = ioctl(fd, SPACEWIRE_IOCTRL_SET_DISABLE_ERR, 0); // automatic link-disabling due to link-error interrupts
	406	if (status!=RTEMS_SUCCESSFUL) {
	407	PRINTF("in SPIQ *** Error SPACEWIRE_IOCTRL_SET_DISABLE_ERR\n")
	408	}
	409	//
	410	status = ioctl(fd, SPACEWIRE_IOCTRL_SET_LINK_ERR_IRQ, 1); // sets the link-error interrupt bit
	411	if (status!=RTEMS_SUCCESSFUL) {
	412	PRINTF("in SPIQ *** Error SPACEWIRE_IOCTRL_SET_LINK_ERR_IRQ\n")
	413	}
	414	//
	415	status = ioctl(fd, SPACEWIRE_IOCTRL_SET_TXBLOCK, 0); // transmission blocks
	416	if (status!=RTEMS_SUCCESSFUL) {
	417	PRINTF("in SPIQ *** Error SPACEWIRE_IOCTRL_SET_TXBLOCK\n")
	418	}
	419	//
	420	status = ioctl(fd, SPACEWIRE_IOCTRL_SET_TXBLOCK_ON_FULL, 1); // transmission blocks when no transmission descriptor is available
	421	if (status!=RTEMS_SUCCESSFUL) {
	422	PRINTF("in SPIQ *** Error SPACEWIRE_IOCTRL_SET_TXBLOCK_ON_FULL\n")
	423	}
	424	//
	425	status = ioctl(fd, SPACEWIRE_IOCTRL_SET_TCODE_CTRL, 0x0909); // [Time Rx : Time Tx : Link error : Tick-out IRQ]
	426	if (status!=RTEMS_SUCCESSFUL) {
	427	PRINTF("in SPIQ *** Error SPACEWIRE_IOCTRL_SET_TCODE_CTRL,\n")
	428	}
	429
	430	return status;
	431	}
	432
	433	int spacewire_reset_link( void )
	434	{
	435	/** This function is executed by the SPIQ rtems_task wehn it has been awaken by an interruption raised by the SpaceWire driver.
	436	*
	437	* @return RTEMS directive status code:
	438	* - RTEMS_UNSATISFIED is returned is the link is not in the running state after 10 s.
	439	* - RTEMS_SUCCESSFUL is returned if the link is up before the timeout.
	440	*
	441	*/
	442
	443	rtems_status_code status_spw;
	444	int i;
	445
	446	for ( i=0; i<SY_LFR_DPU_CONNECT_ATTEMPT; i++ )
	447	{
	448	PRINTF1("in spacewire_reset_link *** link recovery, try %d\n", i);
	449
	450	// CLOSING THE DRIVER AT THIS POINT WILL MAKE THE SEND TASK BLOCK THE SYSTEM
	451
	452	status_spw = spacewire_stop_and_start_link( fdSPW );
	453	if ( status_spw != RTEMS_SUCCESSFUL )
	454	{
	455	PRINTF1("in spacewire_reset_link *** ERR spacewire_start_link code %d\n", status_spw)
	456	}
	457
	458	if ( status_spw == RTEMS_SUCCESSFUL)
	459	{
	460	break;
	461	}
	462	}
	463
	464	return status_spw;
	465	}
	466
	467	void spacewire_set_NP( unsigned char val, unsigned int regAddr ) // [N]o [P]ort force
	468	{
	469	/** This function sets the [N]o [P]ort force bit of the GRSPW control register.
	470	*
	471	* @param val is the value, 0 or 1, used to set the value of the NP bit.
	472	* @param regAddr is the address of the GRSPW control register.
	473	*
	474	* NP is the bit 20 of the GRSPW control register.
	475	*
	476	*/
	477
	478	unsigned int spwptr = (unsigned int) regAddr;
	479
	480	if (val == 1) {
	481	spwptr = spwptr \| 0x00100000; // [NP] set the No port force bit
	482	}
	483	if (val== 0) {
	484	spwptr = spwptr & 0xffdfffff;
	485	}
	486	}
	487
	488	void spacewire_set_RE( unsigned char val, unsigned int regAddr ) // [R]MAP [E]nable
	489	{
	490	/** This function sets the [R]MAP [E]nable bit of the GRSPW control register.
	491	*
	492	* @param val is the value, 0 or 1, used to set the value of the RE bit.
	493	* @param regAddr is the address of the GRSPW control register.
	494	*
	495	* RE is the bit 16 of the GRSPW control register.
	496	*
	497	*/
	498
	499	unsigned int spwptr = (unsigned int) regAddr;
	500
	501	if (val == 1)
	502	{
	503	spwptr = spwptr \| 0x00010000; // [RE] set the RMAP Enable bit
	504	}
	505	if (val== 0)
	506	{
	507	spwptr = spwptr & 0xfffdffff;
	508	}
	509	}
	510
	511	void spacewire_compute_stats_offsets( void )
	512	{
	513	/** This function computes the SpaceWire statistics offsets in case of a SpaceWire related interruption raising.
	514	*
	515	* The offsets keep a record of the statistics in case of a reset of the statistics. They are added to the current statistics
	516	* to keep the counters consistent even after a reset of the SpaceWire driver (the counter are set to zero by the driver when it
	517	* during the open systel call).
	518	*
	519	*/
	520
	521	spw_stats spacewire_stats_grspw;
	522	rtems_status_code status;
	523
	524	status = ioctl( fdSPW, SPACEWIRE_IOCTRL_GET_STATISTICS, &spacewire_stats_grspw );
	525
	526	spacewire_stats_backup.packets_received = spacewire_stats_grspw.packets_received
	527	+ spacewire_stats.packets_received;
	528	spacewire_stats_backup.packets_sent = spacewire_stats_grspw.packets_sent
	529	+ spacewire_stats.packets_sent;
	530	spacewire_stats_backup.parity_err = spacewire_stats_grspw.parity_err
	531	+ spacewire_stats.parity_err;
	532	spacewire_stats_backup.disconnect_err = spacewire_stats_grspw.disconnect_err
	533	+ spacewire_stats.disconnect_err;
	534	spacewire_stats_backup.escape_err = spacewire_stats_grspw.escape_err
	535	+ spacewire_stats.escape_err;
	536	spacewire_stats_backup.credit_err = spacewire_stats_grspw.credit_err
	537	+ spacewire_stats.credit_err;
	538	spacewire_stats_backup.write_sync_err = spacewire_stats_grspw.write_sync_err
	539	+ spacewire_stats.write_sync_err;
	540	spacewire_stats_backup.rx_rmap_header_crc_err = spacewire_stats_grspw.rx_rmap_header_crc_err
	541	+ spacewire_stats.rx_rmap_header_crc_err;
	542	spacewire_stats_backup.rx_rmap_data_crc_err = spacewire_stats_grspw.rx_rmap_data_crc_err
	543	+ spacewire_stats.rx_rmap_data_crc_err;
	544	spacewire_stats_backup.early_ep = spacewire_stats_grspw.early_ep
	545	+ spacewire_stats.early_ep;
	546	spacewire_stats_backup.invalid_address = spacewire_stats_grspw.invalid_address
	547	+ spacewire_stats.invalid_address;
	548	spacewire_stats_backup.rx_eep_err = spacewire_stats_grspw.rx_eep_err
	549	+ spacewire_stats.rx_eep_err;
	550	spacewire_stats_backup.rx_truncated = spacewire_stats_grspw.rx_truncated
	551	+ spacewire_stats.rx_truncated;
	552	}
	553
	554	void spacewire_update_statistics( void )
	555	{
	556	rtems_status_code status;
	557	spw_stats spacewire_stats_grspw;
	558
	559	status = ioctl( fdSPW, SPACEWIRE_IOCTRL_GET_STATISTICS, &spacewire_stats_grspw );
	560
	561	spacewire_stats.packets_received = spacewire_stats_backup.packets_received
	562	+ spacewire_stats_grspw.packets_received;
	563	spacewire_stats.packets_sent = spacewire_stats_backup.packets_sent
	564	+ spacewire_stats_grspw.packets_sent;
	565	spacewire_stats.parity_err = spacewire_stats_backup.parity_err
	566	+ spacewire_stats_grspw.parity_err;
	567	spacewire_stats.disconnect_err = spacewire_stats_backup.disconnect_err
	568	+ spacewire_stats_grspw.disconnect_err;
	569	spacewire_stats.escape_err = spacewire_stats_backup.escape_err
	570	+ spacewire_stats_grspw.escape_err;
	571	spacewire_stats.credit_err = spacewire_stats_backup.credit_err
	572	+ spacewire_stats_grspw.credit_err;
	573	spacewire_stats.write_sync_err = spacewire_stats_backup.write_sync_err
	574	+ spacewire_stats_grspw.write_sync_err;
	575	spacewire_stats.rx_rmap_header_crc_err = spacewire_stats_backup.rx_rmap_header_crc_err
	576	+ spacewire_stats_grspw.rx_rmap_header_crc_err;
	577	spacewire_stats.rx_rmap_data_crc_err = spacewire_stats_backup.rx_rmap_data_crc_err
	578	+ spacewire_stats_grspw.rx_rmap_data_crc_err;
	579	spacewire_stats.early_ep = spacewire_stats_backup.early_ep
	580	+ spacewire_stats_grspw.early_ep;
	581	spacewire_stats.invalid_address = spacewire_stats_backup.invalid_address
	582	+ spacewire_stats_grspw.invalid_address;
	583	spacewire_stats.rx_eep_err = spacewire_stats_backup.rx_eep_err
	584	+ spacewire_stats_grspw.rx_eep_err;
	585	spacewire_stats.rx_truncated = spacewire_stats_backup.rx_truncated
	586	+ spacewire_stats_grspw.rx_truncated;
	587	//spacewire_stats.tx_link_err;
	588
	589	//****************************
	590	// DPU_SPACEWIRE_IF_STATISTICS
	591	housekeeping_packet.hk_lfr_dpu_spw_pkt_rcv_cnt[0] = (unsigned char) (spacewire_stats.packets_received >> 8);
	592	housekeeping_packet.hk_lfr_dpu_spw_pkt_rcv_cnt[1] = (unsigned char) (spacewire_stats.packets_received);
	593	housekeeping_packet.hk_lfr_dpu_spw_pkt_sent_cnt[0] = (unsigned char) (spacewire_stats.packets_sent >> 8);
	594	housekeeping_packet.hk_lfr_dpu_spw_pkt_sent_cnt[1] = (unsigned char) (spacewire_stats.packets_sent);
	595	//housekeeping_packet.hk_lfr_dpu_spw_tick_out_cnt;
	596	//housekeeping_packet.hk_lfr_dpu_spw_last_timc;
	597
	598	//******************************************
	599	// ERROR COUNTERS / SPACEWIRE / LOW SEVERITY
	600	housekeeping_packet.hk_lfr_dpu_spw_parity = (unsigned char) spacewire_stats.parity_err;
	601	housekeeping_packet.hk_lfr_dpu_spw_disconnect = (unsigned char) spacewire_stats.disconnect_err;
	602	housekeeping_packet.hk_lfr_dpu_spw_escape = (unsigned char) spacewire_stats.escape_err;
	603	housekeeping_packet.hk_lfr_dpu_spw_credit = (unsigned char) spacewire_stats.credit_err;
	604	housekeeping_packet.hk_lfr_dpu_spw_write_sync = (unsigned char) spacewire_stats.write_sync_err;
	605
	606	//*********************************************
	607	// ERROR COUNTERS / SPACEWIRE / MEDIUM SEVERITY
	608	housekeeping_packet.hk_lfr_dpu_spw_early_eop = (unsigned char) spacewire_stats.early_ep;
	609	housekeeping_packet.hk_lfr_dpu_spw_invalid_addr = (unsigned char) spacewire_stats.invalid_address;
	610	housekeeping_packet.hk_lfr_dpu_spw_eep = (unsigned char) spacewire_stats.rx_eep_err;
	611	housekeeping_packet.hk_lfr_dpu_spw_rx_too_big = (unsigned char) spacewire_stats.rx_truncated;
	612	}
	613
	614	void timecode_irq_handler( void pDev, void regs, int minor, unsigned int tc )
	615	{
	616	struct grgpio_regs_str grgpio_regs = (struct grgpio_regs_str ) REGS_ADDR_GRGPIO;
	617
	618	incrementLocalCoarseTime();
	619
	620	//*******
	621	// GPIO 2
	622	if ( get_transitionCoarseTime() == getLocalCoarseTime() )
	623	{
	624	grgpio_regs->io_port_output_register = grgpio_regs->io_port_output_register \| 0x04; // [0000 0100]
	625	}
	626	else
	627	{
	628	grgpio_regs->io_port_output_register = grgpio_regs->io_port_output_register & 0xfb; // [1111 1011]
	629	}
	630
	631	//*******
	632	// GPIO 3
	633	if ( (grgpio_regs->io_port_output_register & 0x08) == 0x08 )
	634	{
	635	grgpio_regs->io_port_output_register = grgpio_regs->io_port_output_register & 0xf7; // [1111 0111]
	636	}
	637	else
	638	{
	639	grgpio_regs->io_port_output_register = grgpio_regs->io_port_output_register \| 0x08; // [0000 1000]
	640	}
	641
	642	rtems_event_send( rtems_task_id_updt, RTEMS_EVENT_0);
	643	}
	644
	645	rtems_timer_service_routine user_routine( rtems_id timer_id, void *user_data )
	646	{
	647	int linkStatus;
	648	rtems_status_code status;
	649
	650	status = ioctl(fdSPW, SPACEWIRE_IOCTRL_GET_LINK_STATUS, &linkStatus); // get the link status
	651
	652	if ( linkStatus == 5) {
	653	PRINTF("in spacewire_reset_link *** link is running\n")
	654	status = RTEMS_SUCCESSFUL;
	655	}
	656	}
	657
	658	rtems_task updt_task(rtems_task_argument unused)
	659	{
	660
	661	rtems_event_set event_out;
	662	rtems_status_code status;
	663	rtems_id queue_id;
	664	unsigned int coarseTimeToSend;
	665
	666	Packet_TC_LFR_UPDATE_TIME_WITH_HEADER_t update_time_packet;
	667
	668	resetLocalCoarseTime();
	669	reset_transitionCoarseTime();
	670
	671	status = get_message_queue_id_send( &queue_id );
	672	if (status != RTEMS_SUCCESSFUL)
	673	{
	674	PRINTF1("in HOUS *** ERR get_message_queue_id_send %d\n", status)
	675	}
	676
	677	update_time_packet.targetLogicalAddress = 0xfe;
	678	update_time_packet.protocolIdentifier = CCSDS_PROTOCOLE_ID;
	679	update_time_packet.reserved = DEFAULT_RESERVED;
	680	update_time_packet.userApplication = CCSDS_USER_APP;
	681	update_time_packet.packetID[0] = (unsigned char) (TC_LFR_PACKET_ID >> 8);
	682	update_time_packet.packetID[1] = (unsigned char) (TC_LFR_PACKET_ID );
	683	update_time_packet.packetSequenceControl[0] = (unsigned char) (TC_LFR_PACKET_SEQUENCE_CONTROL >> 8);
	684	update_time_packet.packetSequenceControl[1] = (unsigned char) (TC_LFR_PACKET_SEQUENCE_CONTROL );
	685	update_time_packet.packetLength[0] = (unsigned char) (PACKET_LENGTH_TC_LFR_UPDATE_TIME >> 8);
	686	update_time_packet.packetLength[1] = (unsigned char) (PACKET_LENGTH_TC_LFR_UPDATE_TIME );
	687
	688	update_time_packet.ccsdsSecHeaderFlag_pusVersion_ack = 0x19;
	689	update_time_packet.serviceType = TC_TYPE_LFR_UPDATE_TIME;
	690	update_time_packet.serviceSubType = TC_SUBTYPE_UPDATE_TIME;
	691	update_time_packet.sourceID = SID_TC_RPW_INTERNAL;
	692
	693	BOOT_PRINTF("in UPDT *** \n")
	694
	695	while(true){
	696	rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT \| RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out); // wait for an SPW_LINKERR_EVENT
	697
	698	coarseTimeToSend = getLocalCoarseTime() + 1;
	699	updateTimePacket( coarseTimeToSend, &update_time_packet);
	700	printf("UPDT will send %x as coarse time in 700 ms\n", coarseTimeToSend);
	701
	702	rtems_task_wake_after( 70 ); // 70 => 700 ms
	703
	704	status = rtems_message_queue_urgent( queue_id, &update_time_packet,
	705	PACKET_LENGTH_TC_LFR_UPDATE_TIME + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES
	706	+ 0); // 1 is for the star dundee extra byte
	707	if (status != RTEMS_SUCCESSFUL) {
	708	PRINTF1("in HOUS *** ERR send: %d\n", status)
	709	}
	710	}
	711	}
	712
	713	void updateTimePacket(unsigned int time, Packet_TC_LFR_UPDATE_TIME_WITH_HEADER_t *packet)
	714	{
	715	unsigned char crcAsTwoBytes[2];
	716
	717	packet->cp_rpw_time[0] = (unsigned char) (time >> 24);
	718	packet->cp_rpw_time[1] = (unsigned char) (time >> 16);
	719	packet->cp_rpw_time[2] = (unsigned char) (time >> 8);
	720	packet->cp_rpw_time[3] = (unsigned char) (time);
	721	packet->cp_rpw_time[4] = 0; // fine time MSB
	722	packet->cp_rpw_time[5] = 0; // fine time LSB
	723
	724	GetCRCAsTwoBytes((unsigned char*) &packet->packetID, crcAsTwoBytes,
	725	PACKET_LENGTH_TC_LFR_UPDATE_TIME + CCSDS_TC_TM_PACKET_OFFSET - 2);
	726	packet->crc[0] = crcAsTwoBytes[0];
	727	packet->crc[1] = crcAsTwoBytes[1];
	728	}

timegen/src/lfr_cpu_usage_report.c created 644 +115 0

			@@ -0,0 +1,115
		1	/*
		2	* CPU Usage Reporter
		3	*
		4	* COPYRIGHT (c) 1989-2009
		5	* On-Line Applications Research Corporation (OAR).
		6	*
		7	* The license and distribution terms for this file may be
		8	* found in the file LICENSE in this distribution or at
		9	* http://www.rtems.com/license/LICENSE.
		10	*
		11	* $Id$
		12	*/
		13
		14	#include "lfr_cpu_usage_report.h"
		15
		16	unsigned char lfr_rtems_cpu_usage_report( void )
		17	{
		18	uint32_t api_index;
		19	Thread_Control *the_thread;
		20	Objects_Information *information;
		21	uint32_t ival, fval;
		22	#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
		23	Timestamp_Control uptime;
		24	Timestamp_Control total;
		25	Timestamp_Control ran;
		26	#else
		27	uint32_t total_units = 0;
		28	#endif
		29
		30	unsigned char cpu_load;
		31	cpu_load = 0;
		32
		33	/*
		34	* When not using nanosecond CPU usage resolution, we have to count
		35	* the number of "ticks" we gave credit for to give the user a rough
		36	* guideline as to what each number means proportionally.
		37	*/
		38	#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
		39	_TOD_Get_uptime( &uptime );
		40	_Timestamp_Subtract( &CPU_usage_Uptime_at_last_reset, &uptime, &total );
		41	#else
		42	for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ ) {
		43	if ( !_Objects_Information_table[ api_index ] ) { }
		44	else
		45	{
		46	information = _Objects_Information_table[ api_index ][ 1 ];
		47	if ( information != NULL )
		48	{
		49	for ( i=1 ; i <= information->maximum ; i++ ) {
		50	the_thread = (Thread_Control *)information->local_table[ i ];
		51
		52	if ( the_thread != NULL )
		53	total_units += the_thread->cpu_time_used;
		54	}
		55	}
		56	}
		57	}
		58	#endif
		59
		60	for ( api_index = 1 ; api_index <= OBJECTS_APIS_LAST ; api_index++ )
		61	{
		62	if ( !_Objects_Information_table[ api_index ] ) { }
		63	else
		64	{
		65	information = _Objects_Information_table[ api_index ][ 1 ];
		66	if ( information != NULL )
		67	{
		68	the_thread = (Thread_Control *)information->local_table[ 1 ];
		69
		70	if ( the_thread == NULL ) { }
		71	else
		72	{
		73	#ifndef __RTEMS_USE_TICKS_FOR_STATISTICS__
		74	/*
		75	* If this is the currently executing thread, account for time
		76	* since the last context switch.
		77	*/
		78	ran = the_thread->cpu_time_used;
		79	if ( _Thread_Executing->Object.id == the_thread->Object.id )
		80	{
		81	Timestamp_Control used;
		82	_Timestamp_Subtract(
		83	&_Thread_Time_of_last_context_switch, &uptime, &used
		84	);
		85	_Timestamp_Add_to( &ran, &used );
		86	}
		87	_Timestamp_Divide( &ran, &total, &ival, &fval );
		88
		89	#else
		90	if (total_units != 0)
		91	{
		92	uint64_t ival_64;
		93
		94	ival_64 = the_thread->cpu_time_used;
		95	ival_64 *= 100000;
		96	ival = ival_64 / total_units;
		97	}
		98	else
		99	{
		100	ival = 0;
		101	}
		102
		103	fval = ival % 1000;
		104	ival /= 1000;
		105	#endif
		106	}
		107	}
		108	}
		109	}
		110	cpu_load = (unsigned char) (100 - ival);
		111
		112	return cpu_load;
		113	}
		114
		115

timegen/src/processing/avf0_prc0.c created 644 +380 0

			@@ -0,0 +1,380
		1	/** Functions related to data processing.
		2	*
		3	* @file
		4	* @author P. LEROY
		5	*
		6	* These function are related to data processing, i.e. spectral matrices averaging and basic parameters computation.
		7	*
		8	*/
		9
		10	#include "avf0_prc0.h"
		11	#include "fsw_processing.h"
		12
		13	nb_sm_before_bp_asm_f0 nb_sm_before_f0;
		14
		15	//***
		16	// F0
		17	ring_node_asm asm_ring_norm_f0 [ NB_RING_NODES_ASM_NORM_F0 ];
		18	ring_node_asm asm_ring_burst_sbm_f0[ NB_RING_NODES_ASM_BURST_SBM_F0 ];
		19
		20	float asm_f0_reorganized [ TOTAL_SIZE_SM ];
		21	char asm_f0_char [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ];
		22	float compressed_sm_norm_f0[ TOTAL_SIZE_COMPRESSED_ASM_NORM_F0];
		23	float compressed_sm_sbm_f0 [ TOTAL_SIZE_COMPRESSED_ASM_SBM_F0 ];
		24	//unsigned char bp1_norm_f0 [ TOTAL_SIZE_BP1_NORM_F0 ];
		25	//unsigned char bp1_sbm_f0 [ TOTAL_SIZE_BP1_SBM_F0 ];
		26
		27	//************
		28	// RTEMS TASKS
		29
		30	rtems_task avf0_task( rtems_task_argument lfrRequestedMode )
		31	{
		32	int i;
		33
		34	rtems_event_set event_out;
		35	rtems_status_code status;
		36	rtems_id queue_id_prc0;
		37	asm_msg msgForMATR;
		38	ring_node_sm *ring_node_tab[8];
		39	ring_node_asm *current_ring_node_asm_burst_sbm_f0;
		40	ring_node_asm *current_ring_node_asm_norm_f0;
		41
		42	unsigned int nb_norm_bp1;
		43	unsigned int nb_norm_bp2;
		44	unsigned int nb_norm_asm;
		45	unsigned int nb_sbm_bp1;
		46	unsigned int nb_sbm_bp2;
		47
		48	nb_norm_bp1 = 0;
		49	nb_norm_bp2 = 0;
		50	nb_norm_asm = 0;
		51	nb_sbm_bp1 = 0;
		52	nb_sbm_bp2 = 0;
		53
		54	reset_nb_sm_f0( lfrRequestedMode ); // reset the sm counters that drive the BP and ASM computations / transmissions
		55	ASM_generic_init_ring( asm_ring_norm_f0, NB_RING_NODES_ASM_NORM_F0 );
		56	ASM_generic_init_ring( asm_ring_burst_sbm_f0, NB_RING_NODES_ASM_BURST_SBM_F0 );
		57	current_ring_node_asm_norm_f0 = asm_ring_norm_f0;
		58	current_ring_node_asm_burst_sbm_f0 = asm_ring_burst_sbm_f0;
		59
		60	BOOT_PRINTF1("in AVFO *** lfrRequestedMode = %d\n", (int) lfrRequestedMode)
		61
		62	status = get_message_queue_id_prc0( &queue_id_prc0 );
		63	if (status != RTEMS_SUCCESSFUL)
		64	{
		65	PRINTF1("in MATR *** ERR get_message_queue_id_prc0 %d\n", status)
		66	}
		67
		68	while(1){
		69	rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0
		70
		71	//****************************************
		72	// initialize the mesage for the MATR task
		73	msgForMATR.norm = current_ring_node_asm_norm_f0;
		74	msgForMATR.burst_sbm = current_ring_node_asm_burst_sbm_f0;
		75	msgForMATR.event = 0x00; // this composite event will be sent to the MATR task
		76	msgForMATR.coarseTime = ring_node_for_averaging_sm_f0->coarseTime;
		77	msgForMATR.fineTime = ring_node_for_averaging_sm_f0->fineTime;
		78	//
		79	//****************************************
		80
		81	ring_node_tab[NB_SM_BEFORE_AVF0-1] = ring_node_for_averaging_sm_f0;
		82	for ( i = 2; i < (NB_SM_BEFORE_AVF0+1); i++ )
		83	{
		84	ring_node_for_averaging_sm_f0 = ring_node_for_averaging_sm_f0->previous;
		85	ring_node_tab[NB_SM_BEFORE_AVF0-i] = ring_node_for_averaging_sm_f0;
		86	}
		87
		88	// compute the average and store it in the averaged_sm_f1 buffer
		89	SM_average( current_ring_node_asm_norm_f0->matrix,
		90	current_ring_node_asm_burst_sbm_f0->matrix,
		91	ring_node_tab,
		92	nb_norm_bp1, nb_sbm_bp1 );
		93
		94	// update nb_average
		95	nb_norm_bp1 = nb_norm_bp1 + NB_SM_BEFORE_AVF0;
		96	nb_norm_bp2 = nb_norm_bp2 + NB_SM_BEFORE_AVF0;
		97	nb_norm_asm = nb_norm_asm + NB_SM_BEFORE_AVF0;
		98	nb_sbm_bp1 = nb_sbm_bp1 + NB_SM_BEFORE_AVF0;
		99	nb_sbm_bp2 = nb_sbm_bp2 + NB_SM_BEFORE_AVF0;
		100
		101	if (nb_sbm_bp1 == nb_sm_before_f0.burst_sbm_bp1)
		102	{
		103	nb_sbm_bp1 = 0;
		104	// set another ring for the ASM storage
		105	current_ring_node_asm_burst_sbm_f0 = current_ring_node_asm_burst_sbm_f0->next;
		106	if ( lfrCurrentMode == LFR_MODE_BURST )
		107	{
		108	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_BURST_BP1_F0;
		109	}
		110	else if ( (lfrCurrentMode == LFR_MODE_SBM1) \|\| (lfrCurrentMode == LFR_MODE_SBM2) )
		111	{
		112	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_SBM_BP1_F0;
		113	}
		114	}
		115
		116	if (nb_sbm_bp2 == nb_sm_before_f0.burst_sbm_bp2)
		117	{
		118	nb_sbm_bp2 = 0;
		119	if ( lfrCurrentMode == LFR_MODE_BURST )
		120	{
		121	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_BURST_BP2_F0;
		122	}
		123	else if ( (lfrCurrentMode == LFR_MODE_SBM1) \|\| (lfrCurrentMode == LFR_MODE_SBM2) )
		124	{
		125	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_SBM_BP2_F0;
		126	}
		127	}
		128
		129	if (nb_norm_bp1 == nb_sm_before_f0.norm_bp1)
		130	{
		131	nb_norm_bp1 = 0;
		132	// set another ring for the ASM storage
		133	current_ring_node_asm_norm_f0 = current_ring_node_asm_norm_f0->next;
		134	if ( (lfrCurrentMode == LFR_MODE_NORMAL)
		135	\|\| (lfrCurrentMode == LFR_MODE_SBM1) \|\| (lfrCurrentMode == LFR_MODE_SBM2) )
		136	{
		137	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_NORM_BP1_F0;
		138	}
		139	}
		140
		141	if (nb_norm_bp2 == nb_sm_before_f0.norm_bp2)
		142	{
		143	nb_norm_bp2 = 0;
		144	if ( (lfrCurrentMode == LFR_MODE_NORMAL)
		145	\|\| (lfrCurrentMode == LFR_MODE_SBM1) \|\| (lfrCurrentMode == LFR_MODE_SBM2) )
		146	{
		147	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_NORM_BP2_F0;
		148	}
		149	}
		150
		151	if (nb_norm_asm == nb_sm_before_f0.norm_asm)
		152	{
		153	nb_norm_asm = 0;
		154	if ( (lfrCurrentMode == LFR_MODE_NORMAL)
		155	\|\| (lfrCurrentMode == LFR_MODE_SBM1) \|\| (lfrCurrentMode == LFR_MODE_SBM2) )
		156	{
		157	// PRINTF1("%lld\n", localTime)
		158	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_NORM_ASM_F0;
		159	}
		160	}
		161
		162	//*************************
		163	// send the message to MATR
		164	if (msgForMATR.event != 0x00)
		165	{
		166	status = rtems_message_queue_send( queue_id_prc0, (char *) &msgForMATR, MSG_QUEUE_SIZE_PRC0);
		167	}
		168
		169	if (status != RTEMS_SUCCESSFUL) {
		170	printf("in AVF0 *** Error sending message to MATR, code %d\n", status);
		171	}
		172	}
		173	}
		174
		175	rtems_task prc0_task( rtems_task_argument lfrRequestedMode )
		176	{
		177	char incomingData[MSG_QUEUE_SIZE_SEND]; // incoming data buffer
		178	size_t size; // size of the incoming TC packet
		179	asm_msg *incomingMsg;
		180	//
		181	unsigned char sid;
		182	spw_ioctl_pkt_send spw_ioctl_send_ASM;
		183	rtems_status_code status;
		184	rtems_id queue_id;
		185	rtems_id queue_id_q_p0;
		186	Header_TM_LFR_SCIENCE_ASM_t headerASM;
		187	bp_packet_with_spare packet_norm_bp1_f0;
		188	bp_packet packet_norm_bp2_f0;
		189	bp_packet packet_sbm_bp1_f0;
		190	bp_packet packet_sbm_bp2_f0;
		191
		192	unsigned long long int localTime;
		193
		194	ASM_init_header( &headerASM );
		195
		196	//*************
		197	// NORM headers
		198	BP_init_header_with_spare( &packet_norm_bp1_f0.header,
		199	APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP1_F0,
		200	PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0, NB_BINS_COMPRESSED_SM_F0 );
		201	BP_init_header( &packet_norm_bp2_f0.header,
		202	APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F0,
		203	PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0, NB_BINS_COMPRESSED_SM_F0);
		204
		205	//****************************
		206	// BURST SBM1 and SBM2 headers
		207	if ( lfrRequestedMode == LFR_MODE_BURST )
		208	{
		209	BP_init_header( &packet_sbm_bp1_f0.header,
		210	APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP1_F0,
		211	PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
		212	BP_init_header( &packet_sbm_bp2_f0.header,
		213	APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP2_F0,
		214	PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
		215	}
		216	else if ( lfrRequestedMode == LFR_MODE_SBM1 )
		217	{
		218	BP_init_header( &packet_sbm_bp1_f0.header,
		219	APID_TM_SCIENCE_SBM1_SBM2, SID_SBM1_BP1_F0,
		220	PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
		221	BP_init_header( &packet_sbm_bp2_f0.header,
		222	APID_TM_SCIENCE_SBM1_SBM2, SID_SBM1_BP2_F0,
		223	PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
		224	}
		225	else if ( lfrRequestedMode == LFR_MODE_SBM2 )
		226	{
		227	BP_init_header( &packet_sbm_bp1_f0.header,
		228	APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP1_F0,
		229	PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
		230	BP_init_header( &packet_sbm_bp2_f0.header,
		231	APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP2_F0,
		232	PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0, NB_BINS_COMPRESSED_SM_SBM_F0);
		233	}
		234	else
		235	{
		236	PRINTF1("in PRC0 *** lfrRequestedMode is %d, several headers not initialized\n", (unsigned int) lfrRequestedMode)
		237	}
		238
		239	status = get_message_queue_id_send( &queue_id );
		240	if (status != RTEMS_SUCCESSFUL)
		241	{
		242	PRINTF1("in PRC0 *** ERR get_message_queue_id_send %d\n", status)
		243	}
		244	status = get_message_queue_id_prc0( &queue_id_q_p0);
		245	if (status != RTEMS_SUCCESSFUL)
		246	{
		247	PRINTF1("in PRC0 *** ERR get_message_queue_id_prc0 %d\n", status)
		248	}
		249
		250	BOOT_PRINTF1("in PRC0 *** lfrRequestedMode = %d\n", (int) lfrRequestedMode)
		251
		252	while(1){
		253	status = rtems_message_queue_receive( queue_id_q_p0, incomingData, &size, //************************************
		254	RTEMS_WAIT, RTEMS_NO_TIMEOUT ); // wait for a message coming from AVF0
		255
		256	incomingMsg = (asm_msg*) incomingData;
		257
		258	localTime = getTimeAsUnsignedLongLongInt( );
		259
		260	//****************
		261	//****************
		262	// BURST SBM1 SBM2
		263	//****************
		264	//****************
		265	if ( (incomingMsg->event & RTEMS_EVENT_BURST_BP1_F0 ) \|\| (incomingMsg->event & RTEMS_EVENT_SBM_BP1_F0 ) )
		266	{
		267	sid = getSID( incomingMsg->event );
		268	// 1) compress the matrix for Basic Parameters calculation
		269	ASM_compress_reorganize_and_divide( incomingMsg->burst_sbm->matrix, compressed_sm_sbm_f0,
		270	nb_sm_before_f0.burst_sbm_bp1,
		271	NB_BINS_COMPRESSED_SM_SBM_F0, NB_BINS_TO_AVERAGE_ASM_SBM_F0,
		272	ASM_F0_INDICE_START);
		273	// 2) compute the BP1 set
		274	// BP1_set( compressed_sm_norm_f0, NB_BINS_COMPRESSED_SM_SBM_F0, bp1_sbm_f0 );
		275	// 3) send the BP1 set
		276	set_time( packet_sbm_bp1_f0.header.time, (unsigned char *) &incomingMsg->coarseTime );
		277	set_time( packet_sbm_bp1_f0.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
		278	BP_send( (char *) &packet_sbm_bp1_f0, queue_id,
		279	PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F0 + PACKET_LENGTH_DELTA,
		280	sid);
		281	// 4) compute the BP2 set if needed
		282	if ( (incomingMsg->event & RTEMS_EVENT_BURST_BP2_F0) \|\| (incomingMsg->event & RTEMS_EVENT_SBM_BP2_F0) )
		283	{
		284	// 1) compute the BP2 set
		285
		286	// 2) send the BP2 set
		287	set_time( packet_sbm_bp2_f0.header.time, (unsigned char *) &incomingMsg->coarseTime );
		288	set_time( packet_sbm_bp2_f0.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
		289	BP_send( (char *) &packet_sbm_bp2_f0, queue_id,
		290	PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F0 + PACKET_LENGTH_DELTA,
		291	sid);
		292	}
		293	}
		294
		295	//*****
		296	//*****
		297	// NORM
		298	//*****
		299	//*****
		300	if (incomingMsg->event & RTEMS_EVENT_NORM_BP1_F0)
		301	{
		302	// 1) compress the matrix for Basic Parameters calculation
		303	ASM_compress_reorganize_and_divide( incomingMsg->norm->matrix, compressed_sm_norm_f0,
		304	nb_sm_before_f0.norm_bp1,
		305	NB_BINS_COMPRESSED_SM_F0, NB_BINS_TO_AVERAGE_ASM_F0,
		306	ASM_F0_INDICE_START );
		307	// 2) compute the BP1 set
		308	// BP1_set( compressed_sm_norm_f0, NB_BINS_COMPRESSED_SM_F0, bp1_norm_f0 );
		309	// 3) send the BP1 set
		310	set_time( packet_norm_bp1_f0.header.time, (unsigned char *) &incomingMsg->coarseTime );
		311	set_time( packet_norm_bp1_f0.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
		312	BP_send( (char *) &packet_norm_bp1_f0, queue_id,
		313	PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F0 + PACKET_LENGTH_DELTA,
		314	SID_NORM_BP1_F0 );
		315	if (incomingMsg->event & RTEMS_EVENT_NORM_BP2_F0)
		316	{
		317	// 1) compute the BP2 set using the same ASM as the one used for BP1
		318
		319	// 2) send the BP2 set
		320	set_time( packet_norm_bp2_f0.header.time, (unsigned char *) &incomingMsg->coarseTime );
		321	set_time( packet_norm_bp2_f0.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
		322	BP_send( (char *) &packet_norm_bp2_f0, queue_id,
		323	PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F0 + PACKET_LENGTH_DELTA,
		324	SID_NORM_BP2_F0);
		325	}
		326	}
		327
		328	if (incomingMsg->event & RTEMS_EVENT_NORM_ASM_F0)
		329	{
		330	// 1) reorganize the ASM and divide
		331	ASM_reorganize_and_divide( incomingMsg->norm->matrix,
		332	asm_f0_reorganized,
		333	nb_sm_before_f0.norm_bp1 );
		334	// 2) convert the float array in a char array
		335	ASM_convert( asm_f0_reorganized, asm_f0_char);
		336	// 3) send the spectral matrix packets
		337	set_time( headerASM.time , (unsigned char *) &incomingMsg->coarseTime );
		338	set_time( headerASM.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
		339	ASM_send( &headerASM, asm_f0_char, SID_NORM_ASM_F0, &spw_ioctl_send_ASM, queue_id);
		340	}
		341
		342	}
		343	}
		344
		345	//**********
		346	// FUNCTIONS
		347
		348	void reset_nb_sm_f0( unsigned char lfrMode )
		349	{
		350	nb_sm_before_f0.norm_bp1 = parameter_dump_packet.sy_lfr_n_bp_p0 * 96;
		351	nb_sm_before_f0.norm_bp2 = parameter_dump_packet.sy_lfr_n_bp_p1 * 96;
		352	nb_sm_before_f0.norm_asm = (parameter_dump_packet.sy_lfr_n_asm_p[0] * 256 + parameter_dump_packet.sy_lfr_n_asm_p[1]) * 96;
		353	nb_sm_before_f0.sbm1_bp1 = parameter_dump_packet.sy_lfr_s1_bp_p0 * 24; // 0.25 s per digit
		354	nb_sm_before_f0.sbm1_bp2 = parameter_dump_packet.sy_lfr_s1_bp_p1 * 96;
		355	nb_sm_before_f0.sbm2_bp1 = parameter_dump_packet.sy_lfr_s2_bp_p0 * 96;
		356	nb_sm_before_f0.sbm2_bp2 = parameter_dump_packet.sy_lfr_s2_bp_p1 * 96;
		357	nb_sm_before_f0.burst_bp1 = parameter_dump_packet.sy_lfr_b_bp_p0 * 96;
		358	nb_sm_before_f0.burst_bp2 = parameter_dump_packet.sy_lfr_b_bp_p1 * 96;
		359
		360	if (lfrMode == LFR_MODE_SBM1)
		361	{
		362	nb_sm_before_f0.burst_sbm_bp1 = nb_sm_before_f0.sbm1_bp1;
		363	nb_sm_before_f0.burst_sbm_bp2 = nb_sm_before_f0.sbm1_bp2;
		364	}
		365	else if (lfrMode == LFR_MODE_SBM2)
		366	{
		367	nb_sm_before_f0.burst_sbm_bp1 = nb_sm_before_f0.sbm2_bp1;
		368	nb_sm_before_f0.burst_sbm_bp2 = nb_sm_before_f0.sbm2_bp2;
		369	}
		370	else if (lfrMode == LFR_MODE_BURST)
		371	{
		372	nb_sm_before_f0.burst_sbm_bp1 = nb_sm_before_f0.burst_bp1;
		373	nb_sm_before_f0.burst_sbm_bp2 = nb_sm_before_f0.burst_bp2;
		374	}
		375	else
		376	{
		377	nb_sm_before_f0.burst_sbm_bp1 = nb_sm_before_f0.burst_bp1;
		378	nb_sm_before_f0.burst_sbm_bp2 = nb_sm_before_f0.burst_bp2;
		379	}
		380	}

timegen/src/processing/avf1_prc1.c created 644 +360 0

			@@ -0,0 +1,360
		1	/** Functions related to data processing.
		2	*
		3	* @file
		4	* @author P. LEROY
		5	*
		6	* These function are related to data processing, i.e. spectral matrices averaging and basic parameters computation.
		7	*
		8	*/
		9
		10	#include "avf1_prc1.h"
		11
		12	nb_sm_before_bp_asm_f1 nb_sm_before_f1;
		13
		14	//***
		15	// F1
		16	ring_node_asm asm_ring_norm_f1 [ NB_RING_NODES_ASM_NORM_F1 ];
		17	ring_node_asm asm_ring_burst_sbm_f1[ NB_RING_NODES_ASM_BURST_SBM_F1 ];
		18
		19	float asm_f1_reorganized [ TOTAL_SIZE_SM ];
		20	char asm_f1_char [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ];
		21	float compressed_sm_norm_f1[ TOTAL_SIZE_COMPRESSED_ASM_NORM_F1];
		22	float compressed_sm_sbm_f1 [ TOTAL_SIZE_COMPRESSED_ASM_SBM_F1 ];
		23
		24	//************
		25	// RTEMS TASKS
		26
		27	rtems_task avf1_task( rtems_task_argument lfrRequestedMode )
		28	{
		29	int i;
		30
		31	rtems_event_set event_out;
		32	rtems_status_code status;
		33	rtems_id queue_id_prc1;
		34	asm_msg msgForMATR;
		35	ring_node_sm *ring_node_tab[8];
		36	ring_node_asm *current_ring_node_asm_burst_sbm_f1;
		37	ring_node_asm *current_ring_node_asm_norm_f1;
		38
		39	unsigned int nb_norm_bp1;
		40	unsigned int nb_norm_bp2;
		41	unsigned int nb_norm_asm;
		42	unsigned int nb_sbm_bp1;
		43	unsigned int nb_sbm_bp2;
		44
		45	nb_norm_bp1 = 0;
		46	nb_norm_bp2 = 0;
		47	nb_norm_asm = 0;
		48	nb_sbm_bp1 = 0;
		49	nb_sbm_bp2 = 0;
		50
		51	reset_nb_sm_f1( lfrRequestedMode ); // reset the sm counters that drive the BP and ASM computations / transmissions
		52	ASM_generic_init_ring( asm_ring_norm_f1, NB_RING_NODES_ASM_NORM_F1 );
		53	ASM_generic_init_ring( asm_ring_burst_sbm_f1, NB_RING_NODES_ASM_BURST_SBM_F1 );
		54	current_ring_node_asm_norm_f1 = asm_ring_norm_f1;
		55	current_ring_node_asm_burst_sbm_f1 = asm_ring_burst_sbm_f1;
		56
		57	BOOT_PRINTF1("in AVF1 *** lfrRequestedMode = %d\n", (int) lfrRequestedMode)
		58
		59	status = get_message_queue_id_prc1( &queue_id_prc1 );
		60	if (status != RTEMS_SUCCESSFUL)
		61	{
		62	PRINTF1("in AVF1 *** ERR get_message_queue_id_prc1 %d\n", status)
		63	}
		64
		65	while(1){
		66	rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0
		67
		68	//****************************************
		69	// initialize the mesage for the MATR task
		70	msgForMATR.event = 0x00; // this composite event will be sent to the PRC1 task
		71	msgForMATR.burst_sbm = current_ring_node_asm_burst_sbm_f1;
		72	msgForMATR.norm = current_ring_node_asm_norm_f1;
		73	msgForMATR.coarseTime = ring_node_for_averaging_sm_f1->coarseTime;
		74	msgForMATR.fineTime = ring_node_for_averaging_sm_f1->fineTime;
		75	//
		76	//****************************************
		77
		78	ring_node_tab[NB_SM_BEFORE_AVF1-1] = ring_node_for_averaging_sm_f1;
		79	for ( i = 2; i < (NB_SM_BEFORE_AVF1+1); i++ )
		80	{
		81	ring_node_for_averaging_sm_f1 = ring_node_for_averaging_sm_f1->previous;
		82	ring_node_tab[NB_SM_BEFORE_AVF1-i] = ring_node_for_averaging_sm_f1;
		83	}
		84
		85	// compute the average and store it in the averaged_sm_f1 buffer
		86	SM_average( current_ring_node_asm_norm_f1->matrix,
		87	current_ring_node_asm_burst_sbm_f1->matrix,
		88	ring_node_tab,
		89	nb_norm_bp1, nb_sbm_bp1 );
		90
		91	// update nb_average
		92	nb_norm_bp1 = nb_norm_bp1 + NB_SM_BEFORE_AVF1;
		93	nb_norm_bp2 = nb_norm_bp2 + NB_SM_BEFORE_AVF1;
		94	nb_norm_asm = nb_norm_asm + NB_SM_BEFORE_AVF1;
		95	nb_sbm_bp1 = nb_sbm_bp1 + NB_SM_BEFORE_AVF1;
		96	nb_sbm_bp2 = nb_sbm_bp2 + NB_SM_BEFORE_AVF1;
		97
		98	if (nb_sbm_bp1 == nb_sm_before_f1.burst_sbm_bp1)
		99	{
		100	nb_sbm_bp1 = 0;
		101	// set another ring for the ASM storage
		102	current_ring_node_asm_burst_sbm_f1 = current_ring_node_asm_burst_sbm_f1->next;
		103	if ( lfrCurrentMode == LFR_MODE_BURST )
		104	{
		105	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_BURST_BP1_F1;
		106	}
		107	else if ( lfrCurrentMode == LFR_MODE_SBM2 )
		108	{
		109	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_SBM_BP1_F1;
		110	}
		111	}
		112
		113	if (nb_sbm_bp2 == nb_sm_before_f1.burst_sbm_bp2)
		114	{
		115	nb_sbm_bp2 = 0;
		116	if ( lfrCurrentMode == LFR_MODE_BURST )
		117	{
		118	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_BURST_BP2_F1;
		119	}
		120	else if ( lfrCurrentMode == LFR_MODE_SBM2 )
		121	{
		122	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_SBM_BP2_F1;
		123	}
		124	}
		125
		126	if (nb_norm_bp1 == nb_sm_before_f1.norm_bp1)
		127	{
		128	nb_norm_bp1 = 0;
		129	// set another ring for the ASM storage
		130	current_ring_node_asm_norm_f1 = current_ring_node_asm_norm_f1->next;
		131	if ( (lfrCurrentMode == LFR_MODE_NORMAL)
		132	\|\| (lfrCurrentMode == LFR_MODE_SBM1) \|\| (lfrCurrentMode == LFR_MODE_SBM2) )
		133	{
		134	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_NORM_BP1_F1;
		135	}
		136	}
		137
		138	if (nb_norm_bp2 == nb_sm_before_f1.norm_bp2)
		139	{
		140	nb_norm_bp2 = 0;
		141	if ( (lfrCurrentMode == LFR_MODE_NORMAL)
		142	\|\| (lfrCurrentMode == LFR_MODE_SBM1) \|\| (lfrCurrentMode == LFR_MODE_SBM2) )
		143	{
		144	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_NORM_BP2_F1;
		145	}
		146	}
		147
		148	if (nb_norm_asm == nb_sm_before_f1.norm_asm)
		149	{
		150	nb_norm_asm = 0;
		151	if ( (lfrCurrentMode == LFR_MODE_NORMAL)
		152	\|\| (lfrCurrentMode == LFR_MODE_SBM1) \|\| (lfrCurrentMode == LFR_MODE_SBM2) )
		153	{
		154	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_NORM_ASM_F1;
		155	}
		156	}
		157
		158	//*************************
		159	// send the message to MATR
		160	if (msgForMATR.event != 0x00)
		161	{
		162	status = rtems_message_queue_send( queue_id_prc1, (char *) &msgForMATR, MSG_QUEUE_SIZE_PRC1);
		163	}
		164
		165	if (status != RTEMS_SUCCESSFUL) {
		166	printf("in AVF1 *** Error sending message to PRC1, code %d\n", status);
		167	}
		168	}
		169	}
		170
		171	rtems_task prc1_task( rtems_task_argument lfrRequestedMode )
		172	{
		173	char incomingData[MSG_QUEUE_SIZE_SEND]; // incoming data buffer
		174	size_t size; // size of the incoming TC packet
		175	asm_msg *incomingMsg;
		176	//
		177	unsigned char sid;
		178	spw_ioctl_pkt_send spw_ioctl_send_ASM;
		179	rtems_status_code status;
		180	rtems_id queue_id_send;
		181	rtems_id queue_id_q_p1;
		182	Header_TM_LFR_SCIENCE_ASM_t headerASM;
		183	bp_packet_with_spare packet_norm_bp1;
		184	bp_packet packet_norm_bp2;
		185	bp_packet packet_sbm_bp1;
		186	bp_packet packet_sbm_bp2;
		187
		188	unsigned long long int localTime;
		189
		190	ASM_init_header( &headerASM );
		191
		192	//*************
		193	// NORM headers
		194	BP_init_header_with_spare( &packet_norm_bp1.header,
		195	APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP1_F1,
		196	PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F1, NB_BINS_COMPRESSED_SM_F1 );
		197	BP_init_header( &packet_norm_bp2.header,
		198	APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F1,
		199	PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F1, NB_BINS_COMPRESSED_SM_F1);
		200
		201	//***********************
		202	// BURST and SBM2 headers
		203	if ( lfrRequestedMode == LFR_MODE_BURST )
		204	{
		205	BP_init_header( &packet_sbm_bp1.header,
		206	APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP1_F1,
		207	PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F1, NB_BINS_COMPRESSED_SM_SBM_F1);
		208	BP_init_header( &packet_sbm_bp2.header,
		209	APID_TM_SCIENCE_NORMAL_BURST, SID_BURST_BP2_F1,
		210	PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F1, NB_BINS_COMPRESSED_SM_SBM_F1);
		211	}
		212	else if ( lfrRequestedMode == LFR_MODE_SBM2 )
		213	{
		214	BP_init_header( &packet_sbm_bp1.header,
		215	APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP1_F1,
		216	PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F1, NB_BINS_COMPRESSED_SM_SBM_F1);
		217	BP_init_header( &packet_sbm_bp2.header,
		218	APID_TM_SCIENCE_SBM1_SBM2, SID_SBM2_BP2_F1,
		219	PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F1, NB_BINS_COMPRESSED_SM_SBM_F1);
		220	}
		221	else
		222	{
		223	PRINTF1("in PRC1 *** lfrRequestedMode is %d, several headers not initialized\n", (unsigned int) lfrRequestedMode)
		224	}
		225
		226	status = get_message_queue_id_send( &queue_id_send );
		227	if (status != RTEMS_SUCCESSFUL)
		228	{
		229	PRINTF1("in PRC1 *** ERR get_message_queue_id_send %d\n", status)
		230	}
		231	status = get_message_queue_id_prc1( &queue_id_q_p1);
		232	if (status != RTEMS_SUCCESSFUL)
		233	{
		234	PRINTF1("in PRC1 *** ERR get_message_queue_id_prc1 %d\n", status)
		235	}
		236
		237	BOOT_PRINTF1("in PRC1 *** lfrRequestedMode = %d\n", (int) lfrRequestedMode)
		238
		239	while(1){
		240	status = rtems_message_queue_receive( queue_id_q_p1, incomingData, &size, //************************************
		241	RTEMS_WAIT, RTEMS_NO_TIMEOUT ); // wait for a message coming from AVF0
		242
		243	incomingMsg = (asm_msg*) incomingData;
		244
		245	localTime = getTimeAsUnsignedLongLongInt( );
		246	//***********
		247	//***********
		248	// BURST SBM2
		249	//***********
		250	//***********
		251	if ( (incomingMsg->event & RTEMS_EVENT_BURST_BP1_F1) \|\| (incomingMsg->event & RTEMS_EVENT_SBM_BP1_F1) )
		252	{
		253	sid = getSID( incomingMsg->event );
		254	// 1) compress the matrix for Basic Parameters calculation
		255	ASM_compress_reorganize_and_divide( incomingMsg->burst_sbm->matrix, compressed_sm_sbm_f1,
		256	nb_sm_before_f1.burst_sbm_bp1,
		257	NB_BINS_COMPRESSED_SM_SBM_F1, NB_BINS_TO_AVERAGE_ASM_SBM_F1,
		258	ASM_F1_INDICE_START);
		259	// 2) compute the BP1 set
		260
		261	// 3) send the BP1 set
		262	set_time( packet_sbm_bp1.header.time, (unsigned char *) &incomingMsg->coarseTime );
		263	set_time( packet_sbm_bp1.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
		264	BP_send( (char *) &packet_sbm_bp1, queue_id_send,
		265	PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP1_F1 + PACKET_LENGTH_DELTA,
		266	sid );
		267	// 4) compute the BP2 set if needed
		268	if ( (incomingMsg->event & RTEMS_EVENT_BURST_BP2_F1) \|\| (incomingMsg->event & RTEMS_EVENT_SBM_BP2_F1) )
		269	{
		270	// 1) compute the BP2 set
		271
		272	// 2) send the BP2 set
		273	set_time( packet_sbm_bp2.header.time, (unsigned char *) &incomingMsg->coarseTime );
		274	set_time( packet_sbm_bp2.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
		275	BP_send( (char *) &packet_sbm_bp2, queue_id_send,
		276	PACKET_LENGTH_TM_LFR_SCIENCE_SBM_BP2_F1 + PACKET_LENGTH_DELTA,
		277	sid );
		278	}
		279	}
		280
		281	//*****
		282	//*****
		283	// NORM
		284	//*****
		285	//*****
		286	if (incomingMsg->event & RTEMS_EVENT_NORM_BP1_F1)
		287	{
		288	// 1) compress the matrix for Basic Parameters calculation
		289	ASM_compress_reorganize_and_divide( incomingMsg->norm->matrix, compressed_sm_norm_f1,
		290	nb_sm_before_f1.norm_bp1,
		291	NB_BINS_COMPRESSED_SM_F0, NB_BINS_TO_AVERAGE_ASM_F0,
		292	ASM_F0_INDICE_START );
		293	// 2) compute the BP1 set
		294
		295	// 3) send the BP1 set
		296	set_time( packet_norm_bp1.header.time, (unsigned char *) &incomingMsg->coarseTime );
		297	set_time( packet_norm_bp1.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
		298	BP_send( (char *) &packet_norm_bp1, queue_id_send,
		299	PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F1 + PACKET_LENGTH_DELTA,
		300	SID_NORM_BP1_F1 );
		301	if (incomingMsg->event & RTEMS_EVENT_NORM_BP2_F1)
		302	{
		303	// 1) compute the BP2 set
		304
		305	// 2) send the BP2 set
		306	set_time( packet_norm_bp2.header.time, (unsigned char *) &incomingMsg->coarseTime );
		307	set_time( packet_norm_bp2.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
		308	BP_send( (char *) &packet_norm_bp2, queue_id_send,
		309	PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F1 + PACKET_LENGTH_DELTA,
		310	SID_NORM_BP2_F1 );
		311	}
		312	}
		313
		314	if (incomingMsg->event & RTEMS_EVENT_NORM_ASM_F1)
		315	{
		316	// 1) reorganize the ASM and divide
		317	ASM_reorganize_and_divide( incomingMsg->norm->matrix,
		318	asm_f1_reorganized,
		319	nb_sm_before_f1.norm_bp1 );
		320	// 2) convert the float array in a char array
		321	ASM_convert( asm_f1_reorganized, asm_f1_char);
		322	// 3) send the spectral matrix packets
		323	set_time( headerASM.time , (unsigned char *) &incomingMsg->coarseTime );
		324	set_time( headerASM.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
		325	ASM_send( &headerASM, asm_f1_char, SID_NORM_ASM_F1, &spw_ioctl_send_ASM, queue_id_send);
		326	}
		327
		328	}
		329	}
		330
		331	//**********
		332	// FUNCTIONS
		333
		334	void reset_nb_sm_f1( unsigned char lfrMode )
		335	{
		336	nb_sm_before_f1.norm_bp1 = parameter_dump_packet.sy_lfr_n_bp_p0 * 16;
		337	nb_sm_before_f1.norm_bp2 = parameter_dump_packet.sy_lfr_n_bp_p1 * 16;
		338	nb_sm_before_f1.norm_asm = (parameter_dump_packet.sy_lfr_n_asm_p[0] * 256 + parameter_dump_packet.sy_lfr_n_asm_p[1]) * 16;
		339	nb_sm_before_f1.sbm2_bp1 = parameter_dump_packet.sy_lfr_s2_bp_p0 * 16;
		340	nb_sm_before_f1.sbm2_bp2 = parameter_dump_packet.sy_lfr_s2_bp_p1 * 16;
		341	nb_sm_before_f1.burst_bp1 = parameter_dump_packet.sy_lfr_b_bp_p0 * 16;
		342	nb_sm_before_f1.burst_bp2 = parameter_dump_packet.sy_lfr_b_bp_p1 * 16;
		343
		344	if (lfrMode == LFR_MODE_SBM2)
		345	{
		346	nb_sm_before_f1.burst_sbm_bp1 = nb_sm_before_f1.sbm2_bp1;
		347	nb_sm_before_f1.burst_sbm_bp2 = nb_sm_before_f1.sbm2_bp2;
		348	}
		349	else if (lfrMode == LFR_MODE_BURST)
		350	{
		351	nb_sm_before_f1.burst_sbm_bp1 = nb_sm_before_f1.burst_bp1;
		352	nb_sm_before_f1.burst_sbm_bp2 = nb_sm_before_f1.burst_bp2;
		353	}
		354	else
		355	{
		356	nb_sm_before_f1.burst_sbm_bp1 = nb_sm_before_f1.burst_bp1;
		357	nb_sm_before_f1.burst_sbm_bp2 = nb_sm_before_f1.burst_bp2;
		358	}
		359	}
		360

timegen/src/processing/avf2_prc2.c created 644 +255 0

			@@ -0,0 +1,255
		1	/** Functions related to data processing.
		2	*
		3	* @file
		4	* @author P. LEROY
		5	*
		6	* These function are related to data processing, i.e. spectral matrices averaging and basic parameters computation.
		7	*
		8	*/
		9
		10	#include "avf2_prc2.h"
		11
		12	nb_sm_before_bp_asm_f2 nb_sm_before_f2;
		13
		14	//***
		15	// F2
		16	ring_node_asm asm_ring_norm_f2 [ NB_RING_NODES_ASM_NORM_F2 ];
		17	ring_node_asm asm_ring_burst_sbm_f2[ NB_RING_NODES_ASM_BURST_SBM_F2 ];
		18
		19	float asm_f2_reorganized [ TOTAL_SIZE_SM ];
		20	char asm_f2_char [ TIME_OFFSET_IN_BYTES + (TOTAL_SIZE_SM * 2) ];
		21	float compressed_sm_norm_f2[ TOTAL_SIZE_COMPRESSED_ASM_NORM_F2];
		22	float compressed_sm_sbm_f2 [ TOTAL_SIZE_COMPRESSED_ASM_SBM_F2 ];
		23
		24	//************
		25	// RTEMS TASKS
		26
		27	//***
		28	// F2
		29	rtems_task avf2_task( rtems_task_argument argument )
		30	{
		31	rtems_event_set event_out;
		32	rtems_status_code status;
		33	rtems_id queue_id_prc2;
		34	asm_msg msgForMATR;
		35	ring_node_asm *current_ring_node_asm_norm_f2;
		36
		37	unsigned int nb_norm_bp1;
		38	unsigned int nb_norm_bp2;
		39	unsigned int nb_norm_asm;
		40
		41	nb_norm_bp1 = 0;
		42	nb_norm_bp2 = 0;
		43	nb_norm_asm = 0;
		44
		45	reset_nb_sm_f2( ); // reset the sm counters that drive the BP and ASM computations / transmissions
		46	ASM_generic_init_ring( asm_ring_norm_f2, NB_RING_NODES_ASM_NORM_F2 );
		47	current_ring_node_asm_norm_f2 = asm_ring_norm_f2;
		48
		49	BOOT_PRINTF("in AVF2 ***\n")
		50
		51	status = get_message_queue_id_prc2( &queue_id_prc2 );
		52	if (status != RTEMS_SUCCESSFUL)
		53	{
		54	PRINTF1("in AVF2 *** ERR get_message_queue_id_prc2 %d\n", status)
		55	}
		56
		57	while(1){
		58	rtems_event_receive(RTEMS_EVENT_0, RTEMS_WAIT, RTEMS_NO_TIMEOUT, &event_out); // wait for an RTEMS_EVENT0
		59
		60	//****************************************
		61	// initialize the mesage for the MATR task
		62	msgForMATR.event = 0x00; // this composite event will be sent to the MATR task
		63	msgForMATR.burst_sbm = NULL;
		64	msgForMATR.norm = current_ring_node_asm_norm_f2;
		65	msgForMATR.coarseTime = ring_node_for_averaging_sm_f2->coarseTime;
		66	msgForMATR.fineTime = ring_node_for_averaging_sm_f2->fineTime;
		67	//
		68	//****************************************
		69
		70	// compute the average and store it in the averaged_sm_f2 buffer
		71	SM_average_f2( current_ring_node_asm_norm_f2->matrix,
		72	ring_node_for_averaging_sm_f2,
		73	nb_norm_bp1 );
		74
		75	// update nb_average
		76	nb_norm_bp1 = nb_norm_bp1 + NB_SM_BEFORE_AVF2;
		77	nb_norm_bp2 = nb_norm_bp2 + NB_SM_BEFORE_AVF2;
		78	nb_norm_asm = nb_norm_asm + NB_SM_BEFORE_AVF2;
		79
		80	if (nb_norm_bp1 == nb_sm_before_f2.norm_bp1)
		81	{
		82	nb_norm_bp1 = 0;
		83	// set another ring for the ASM storage
		84	current_ring_node_asm_norm_f2 = current_ring_node_asm_norm_f2->next;
		85	if ( (lfrCurrentMode == LFR_MODE_NORMAL) \|\| (lfrCurrentMode == LFR_MODE_SBM1)
		86	\|\| (lfrCurrentMode == LFR_MODE_SBM2) )
		87	{
		88	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_NORM_BP1_F2;
		89	}
		90	}
		91
		92	if (nb_norm_bp2 == nb_sm_before_f2.norm_bp2)
		93	{
		94	nb_norm_bp2 = 0;
		95	if ( (lfrCurrentMode == LFR_MODE_NORMAL) \|\| (lfrCurrentMode == LFR_MODE_SBM1)
		96	\|\| (lfrCurrentMode == LFR_MODE_SBM2) )
		97	{
		98	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_NORM_BP2_F2;
		99	}
		100	}
		101
		102	if (nb_norm_asm == nb_sm_before_f2.norm_asm)
		103	{
		104	nb_norm_asm = 0;
		105	if ( (lfrCurrentMode == LFR_MODE_NORMAL) \|\| (lfrCurrentMode == LFR_MODE_SBM1)
		106	\|\| (lfrCurrentMode == LFR_MODE_SBM2) )
		107	{
		108	// PRINTF1("%lld\n", localTime)
		109	msgForMATR.event = msgForMATR.event \| RTEMS_EVENT_NORM_ASM_F2;
		110	}
		111	}
		112
		113	//*************************
		114	// send the message to MATR
		115	if (msgForMATR.event != 0x00)
		116	{
		117	status = rtems_message_queue_send( queue_id_prc2, (char *) &msgForMATR, MSG_QUEUE_SIZE_PRC0);
		118	}
		119
		120	if (status != RTEMS_SUCCESSFUL) {
		121	printf("in AVF2 *** Error sending message to MATR, code %d\n", status);
		122	}
		123	}
		124	}
		125
		126	rtems_task prc2_task( rtems_task_argument argument )
		127	{
		128	char incomingData[MSG_QUEUE_SIZE_SEND]; // incoming data buffer
		129	size_t size; // size of the incoming TC packet
		130	asm_msg *incomingMsg;
		131	//
		132	spw_ioctl_pkt_send spw_ioctl_send_ASM;
		133	rtems_status_code status;
		134	rtems_id queue_id;
		135	rtems_id queue_id_q_p2;
		136	Header_TM_LFR_SCIENCE_ASM_t headerASM;
		137	bp_packet packet_norm_bp1_f2;
		138	bp_packet packet_norm_bp2_f2;
		139
		140	unsigned long long int localTime;
		141
		142	incomingMsg = NULL;
		143
		144	ASM_init_header( &headerASM );
		145
		146	//*************
		147	// NORM headers
		148	BP_init_header( &packet_norm_bp1_f2.header,
		149	APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP1_F2,
		150	PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F2, NB_BINS_COMPRESSED_SM_F2 );
		151	BP_init_header( &packet_norm_bp2_f2.header,
		152	APID_TM_SCIENCE_NORMAL_BURST, SID_NORM_BP2_F2,
		153	PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F2, NB_BINS_COMPRESSED_SM_F2 );
		154
		155	status = get_message_queue_id_send( &queue_id );
		156	if (status != RTEMS_SUCCESSFUL)
		157	{
		158	PRINTF1("in PRC2 *** ERR get_message_queue_id_send %d\n", status)
		159	}
		160	status = get_message_queue_id_prc2( &queue_id_q_p2);
		161	if (status != RTEMS_SUCCESSFUL)
		162	{
		163	PRINTF1("in PRC2 *** ERR get_message_queue_id_prc2 %d\n", status)
		164	}
		165
		166	BOOT_PRINTF("in PRC2 ***\n")
		167
		168	while(1){
		169	status = rtems_message_queue_receive( queue_id_q_p2, incomingData, &size, //************************************
		170	RTEMS_WAIT, RTEMS_NO_TIMEOUT ); // wait for a message coming from AVF0
		171
		172	incomingMsg = (asm_msg*) incomingData;
		173
		174	localTime = getTimeAsUnsignedLongLongInt( );
		175
		176	//*****
		177	//*****
		178	// NORM
		179	//*****
		180	//*****
		181	if (incomingMsg->event & RTEMS_EVENT_NORM_BP1_F2)
		182	{
		183	// 1) compress the matrix for Basic Parameters calculation
		184	ASM_compress_reorganize_and_divide( incomingMsg->norm->matrix, compressed_sm_norm_f2,
		185	nb_sm_before_f2.norm_bp1,
		186	NB_BINS_COMPRESSED_SM_F2, NB_BINS_TO_AVERAGE_ASM_F2,
		187	ASM_F2_INDICE_START );
		188	// 2) compute the BP1 set
		189
		190	// 3) send the BP1 set
		191	set_time( packet_norm_bp1_f2.header.time, (unsigned char *) &incomingMsg->coarseTime );
		192	set_time( packet_norm_bp1_f2.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
		193	BP_send( (char *) &packet_norm_bp1_f2, queue_id,
		194	PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP1_F2 + PACKET_LENGTH_DELTA,
		195	SID_NORM_BP1_F2 );
		196	if (incomingMsg->event & RTEMS_EVENT_NORM_BP2_F2)
		197	{
		198	// 1) compute the BP2 set using the same ASM as the one used for BP1
		199
		200	// 2) send the BP2 set
		201	set_time( packet_norm_bp2_f2.header.time, (unsigned char *) &incomingMsg->coarseTime );
		202	set_time( packet_norm_bp2_f2.header.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
		203	BP_send( (char *) &packet_norm_bp2_f2, queue_id,
		204	PACKET_LENGTH_TM_LFR_SCIENCE_NORM_BP2_F2 + PACKET_LENGTH_DELTA,
		205	SID_NORM_BP2_F2 );
		206	}
		207	}
		208
		209	if (incomingMsg->event & RTEMS_EVENT_NORM_ASM_F2)
		210	{
		211	// 1) reorganize the ASM and divide
		212	ASM_reorganize_and_divide( incomingMsg->norm->matrix,
		213	asm_f2_reorganized,
		214	nb_sm_before_f2.norm_bp1 );
		215	// 2) convert the float array in a char array
		216	ASM_convert( asm_f2_reorganized, asm_f2_char);
		217	// 3) send the spectral matrix packets
		218	set_time( headerASM.time , (unsigned char *) &incomingMsg->coarseTime );
		219	set_time( headerASM.acquisitionTime, (unsigned char *) &incomingMsg->coarseTime );
		220	ASM_send( &headerASM, asm_f2_char, SID_NORM_ASM_F2, &spw_ioctl_send_ASM, queue_id);
		221	}
		222
		223	}
		224	}
		225
		226	//**********
		227	// FUNCTIONS
		228
		229	void reset_nb_sm_f2( void )
		230	{
		231	nb_sm_before_f2.norm_bp1 = parameter_dump_packet.sy_lfr_n_bp_p0;
		232	nb_sm_before_f2.norm_bp2 = parameter_dump_packet.sy_lfr_n_bp_p1;
		233	nb_sm_before_f2.norm_asm = parameter_dump_packet.sy_lfr_n_asm_p[0] * 256 + parameter_dump_packet.sy_lfr_n_asm_p[1];
		234	}
		235
		236	void SM_average_f2( float *averaged_spec_mat_f2,
		237	ring_node_sm *ring_node,
		238	unsigned int nbAverageNormF2 )
		239	{
		240	float sum;
		241	unsigned int i;
		242
		243	for(i=0; i<TOTAL_SIZE_SM; i++)
		244	{
		245	sum = ( (int *) (ring_node->buffer_address) ) [ i ];
		246	if ( (nbAverageNormF2 == 0) )
		247	{
		248	averaged_spec_mat_f2[ i ] = sum;
		249	}
		250	else
		251	{
		252	averaged_spec_mat_f2[ i ] = ( averaged_spec_mat_f2[ i ] + sum );
		253	}
		254	}
		255	}

timegen/src/processing/fsw_processing.c created 644 +696 0

This diff has been collapsed as it changes many lines, (696 lines changed) Show them Hide them
		@@ -0,0 +1,696
	1	/** Functions related to data processing.
	2	*
	3	* @file
	4	* @author P. LEROY
	5	*
	6	* These function are related to data processing, i.e. spectral matrices averaging and basic parameters computation.
	7	*
	8	*/
	9
	10	#include "fsw_processing.h"
	11	#include "fsw_processing_globals.c"
	12
	13	unsigned int nb_sm_f0;
	14	unsigned int nb_sm_f0_aux_f1;
	15	unsigned int nb_sm_f1;
	16	unsigned int nb_sm_f0_aux_f2;
	17
	18	//************************
	19	// spectral matrices rings
	20	ring_node_sm sm_ring_f0[ NB_RING_NODES_SM_F0 ];
	21	ring_node_sm sm_ring_f1[ NB_RING_NODES_SM_F1 ];
	22	ring_node_sm sm_ring_f2[ NB_RING_NODES_SM_F2 ];
	23	ring_node_sm *current_ring_node_sm_f0;
	24	ring_node_sm *current_ring_node_sm_f1;
	25	ring_node_sm *current_ring_node_sm_f2;
	26	ring_node_sm *ring_node_for_averaging_sm_f0;
	27	ring_node_sm *ring_node_for_averaging_sm_f1;
	28	ring_node_sm *ring_node_for_averaging_sm_f2;
	29
	30	//***********************************************************
	31	// Interrupt Service Routine for spectral matrices processing
	32
	33	void spectral_matrices_isr_f0( void )
	34	{
	35	unsigned char status;
	36	unsigned long long int time_0;
	37	unsigned long long int time_1;
	38	unsigned long long int syncBit0;
	39	unsigned long long int syncBit1;
	40
	41	status = spectral_matrix_regs->status & 0x03; // [0011] get the status_ready_matrix_f0_x bits
	42
	43	time_0 = get_acquisition_time( (unsigned char *) &spectral_matrix_regs->f0_0_coarse_time );
	44	time_1 = get_acquisition_time( (unsigned char *) &spectral_matrix_regs->f0_1_coarse_time );
	45	syncBit0 = ( (unsigned long long int) (spectral_matrix_regs->f0_0_coarse_time & 0x80000000) ) << 16;
	46	syncBit1 = ( (unsigned long long int) (spectral_matrix_regs->f0_1_coarse_time & 0x80000000) ) << 16;
	47
	48	switch(status)
	49	{
	50	case 0:
	51	break;
	52	case 3:
	53	if ( time_0 < time_1 )
	54	{
	55	close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0],
	56	ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_0 \| syncBit0);
	57	current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
	58	spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->buffer_address;
	59	close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0],
	60	ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_1 \| syncBit1);
	61	current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
	62	spectral_matrix_regs->f0_1_address = current_ring_node_sm_f0->buffer_address;
	63	}
	64	else
	65	{
	66	close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0],
	67	ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_1 \| syncBit1);
	68	current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
	69	spectral_matrix_regs->f0_1_address = current_ring_node_sm_f0->buffer_address;
	70	close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0],
	71	ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_0 \| syncBit0);
	72	current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
	73	spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->buffer_address;
	74	}
	75	spectral_matrix_regs->status = 0x03; // [0011]
	76	break;
	77	case 1:
	78	close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0],
	79	ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_0 \| syncBit0);
	80	current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
	81	spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->buffer_address;
	82	spectral_matrix_regs->status = 0x01; // [0001]
	83	break;
	84	case 2:
	85	close_matrix_actions( &nb_sm_f0, NB_SM_BEFORE_AVF0, Task_id[TASKID_AVF0],
	86	ring_node_for_averaging_sm_f0, current_ring_node_sm_f0, time_1 \| syncBit1);
	87	current_ring_node_sm_f0 = current_ring_node_sm_f0->next;
	88	spectral_matrix_regs->f0_1_address = current_ring_node_sm_f0->buffer_address;
	89	spectral_matrix_regs->status = 0x02; // [0010]
	90	break;
	91	}
	92	}
	93
	94	void spectral_matrices_isr_f1( void )
	95	{
	96	unsigned char status;
	97	unsigned long long int time;
	98	unsigned long long int syncBit;
	99	rtems_status_code status_code;
	100
	101	status = (spectral_matrix_regs->status & 0x0c) >> 2; // [1100] get the status_ready_matrix_f0_x bits
	102
	103	switch(status)
	104	{
	105	case 0:
	106	break;
	107	case 3:
	108	// UNEXPECTED VALUE
	109	spectral_matrix_regs->status = 0xc0; // [1100]
	110	status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_11 );
	111	break;
	112	case 1:
	113	time = get_acquisition_time( (unsigned char *) &spectral_matrix_regs->f1_0_coarse_time );
	114	syncBit = ( (unsigned long long int) (spectral_matrix_regs->f1_0_coarse_time & 0x80000000) ) << 16;
	115	close_matrix_actions( &nb_sm_f1, NB_SM_BEFORE_AVF1, Task_id[TASKID_AVF1],
	116	ring_node_for_averaging_sm_f1, current_ring_node_sm_f1, time \| syncBit);
	117	current_ring_node_sm_f1 = current_ring_node_sm_f1->next;
	118	spectral_matrix_regs->f1_0_address = current_ring_node_sm_f1->buffer_address;
	119	spectral_matrix_regs->status = 0x04; // [0100]
	120	break;
	121	case 2:
	122	time = get_acquisition_time( (unsigned char *) &spectral_matrix_regs->f1_1_coarse_time );
	123	syncBit = ( (unsigned long long int) (spectral_matrix_regs->f1_1_coarse_time & 0x80000000) ) << 16;
	124	close_matrix_actions( &nb_sm_f1, NB_SM_BEFORE_AVF1, Task_id[TASKID_AVF1],
	125	ring_node_for_averaging_sm_f1, current_ring_node_sm_f1, time \| syncBit);
	126	current_ring_node_sm_f1 = current_ring_node_sm_f1->next;
	127	spectral_matrix_regs->f1_1_address = current_ring_node_sm_f1->buffer_address;
	128	spectral_matrix_regs->status = 0x08; // [1000]
	129	break;
	130	}
	131	}
	132
	133	void spectral_matrices_isr_f2( void )
	134	{
	135	unsigned char status;
	136	rtems_status_code status_code;
	137
	138	status = (spectral_matrix_regs->status & 0x30) >> 4; // [0011 0000] get the status_ready_matrix_f0_x bits
	139
	140	ring_node_for_averaging_sm_f2 = current_ring_node_sm_f2;
	141
	142	current_ring_node_sm_f2 = current_ring_node_sm_f2->next;
	143
	144	switch(status)
	145	{
	146	case 0:
	147	break;
	148	case 3:
	149	// UNEXPECTED VALUE
	150	spectral_matrix_regs->status = 0x30; // [0011 0000]
	151	status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_11 );
	152	break;
	153	case 1:
	154	ring_node_for_averaging_sm_f2->coarseTime = spectral_matrix_regs->f2_0_coarse_time;
	155	ring_node_for_averaging_sm_f2->fineTime = spectral_matrix_regs->f2_0_fine_time;
	156	spectral_matrix_regs->f2_0_address = current_ring_node_sm_f2->buffer_address;
	157	spectral_matrix_regs->status = 0x10; // [0001 0000]
	158	if (rtems_event_send( Task_id[TASKID_AVF2], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
	159	{
	160	status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
	161	}
	162	break;
	163	case 2:
	164	ring_node_for_averaging_sm_f2->coarseTime = spectral_matrix_regs->f2_1_coarse_time;
	165	ring_node_for_averaging_sm_f2->fineTime = spectral_matrix_regs->f2_1_fine_time;
	166	spectral_matrix_regs->f2_1_address = current_ring_node_sm_f2->buffer_address;
	167	spectral_matrix_regs->status = 0x20; // [0010 0000]
	168	if (rtems_event_send( Task_id[TASKID_AVF2], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
	169	{
	170	status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
	171	}
	172	break;
	173	}
	174	}
	175
	176	void spectral_matrix_isr_error_handler( void )
	177	{
	178	rtems_status_code status_code;
	179
	180	if (spectral_matrix_regs->status & 0x7c0) // [0111 1100 0000]
	181	{
	182	status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_8 );
	183	}
	184	}
	185
	186	rtems_isr spectral_matrices_isr( rtems_vector_number vector )
	187	{
	188	// STATUS REGISTER
	189	// input_fifo_write(2) * input_fifo_write(1) * input_fifo_write(0)
	190	// 10 9 8
	191	// buffer_full bad_component_err f2_1 f2_0 f1_1 f1_0 f0_1 ** f0_0
	192	// 7 6 5 4 3 2 1 0
	193
	194	spectral_matrices_isr_f0();
	195
	196	spectral_matrices_isr_f1();
	197
	198	spectral_matrices_isr_f2();
	199
	200	// spectral_matrix_isr_error_handler();
	201	}
	202
	203	rtems_isr spectral_matrices_isr_simu( rtems_vector_number vector )
	204	{
	205	rtems_status_code status_code;
	206
	207	//***
	208	// F0
	209	nb_sm_f0 = nb_sm_f0 + 1;
	210	if (nb_sm_f0 == NB_SM_BEFORE_AVF0 )
	211	{
	212	ring_node_for_averaging_sm_f0 = current_ring_node_sm_f0;
	213	if (rtems_event_send( Task_id[TASKID_AVF0], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
	214	{
	215	status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
	216	}
	217	nb_sm_f0 = 0;
	218	}
	219
	220	//***
	221	// F1
	222	nb_sm_f0_aux_f1 = nb_sm_f0_aux_f1 + 1;
	223	if (nb_sm_f0_aux_f1 == 6)
	224	{
	225	nb_sm_f0_aux_f1 = 0;
	226	nb_sm_f1 = nb_sm_f1 + 1;
	227	}
	228	if (nb_sm_f1 == NB_SM_BEFORE_AVF1 )
	229	{
	230	ring_node_for_averaging_sm_f1 = current_ring_node_sm_f1;
	231	if (rtems_event_send( Task_id[TASKID_AVF1], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
	232	{
	233	status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
	234	}
	235	nb_sm_f1 = 0;
	236	}
	237
	238	//***
	239	// F2
	240	nb_sm_f0_aux_f2 = nb_sm_f0_aux_f2 + 1;
	241	if (nb_sm_f0_aux_f2 == 96)
	242	{
	243	nb_sm_f0_aux_f2 = 0;
	244	ring_node_for_averaging_sm_f2 = current_ring_node_sm_f2;
	245	if (rtems_event_send( Task_id[TASKID_AVF2], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
	246	{
	247	status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
	248	}
	249	}
	250	}
	251
	252	//******************
	253	// Spectral Matrices
	254
	255	void reset_nb_sm( void )
	256	{
	257	nb_sm_f0 = 0;
	258	nb_sm_f0_aux_f1 = 0;
	259	nb_sm_f0_aux_f2 = 0;
	260
	261	nb_sm_f1 = 0;
	262	}
	263
	264	void SM_init_rings( void )
	265	{
	266	unsigned char i;
	267
	268	// F0 RING
	269	sm_ring_f0[0].next = (ring_node_sm*) &sm_ring_f0[1];
	270	sm_ring_f0[0].previous = (ring_node_sm*) &sm_ring_f0[NB_RING_NODES_SM_F0-1];
	271	sm_ring_f0[0].buffer_address =
	272	(int) &sm_f0[ 0 ];
	273
	274	sm_ring_f0[NB_RING_NODES_SM_F0-1].next = (ring_node_sm*) &sm_ring_f0[0];
	275	sm_ring_f0[NB_RING_NODES_SM_F0-1].previous = (ring_node_sm*) &sm_ring_f0[NB_RING_NODES_SM_F0-2];
	276	sm_ring_f0[NB_RING_NODES_SM_F0-1].buffer_address =
	277	(int) &sm_f0[ (NB_RING_NODES_SM_F0-1) * TOTAL_SIZE_SM ];
	278
	279	for(i=1; i<NB_RING_NODES_SM_F0-1; i++)
	280	{
	281	sm_ring_f0[i].next = (ring_node_sm*) &sm_ring_f0[i+1];
	282	sm_ring_f0[i].previous = (ring_node_sm*) &sm_ring_f0[i-1];
	283	sm_ring_f0[i].buffer_address =
	284	(int) &sm_f0[ i * TOTAL_SIZE_SM ];
	285	}
	286
	287	// F1 RING
	288	sm_ring_f1[0].next = (ring_node_sm*) &sm_ring_f1[1];
	289	sm_ring_f1[0].previous = (ring_node_sm*) &sm_ring_f1[NB_RING_NODES_SM_F1-1];
	290	sm_ring_f1[0].buffer_address =
	291	(int) &sm_f1[ 0 ];
	292
	293	sm_ring_f1[NB_RING_NODES_SM_F1-1].next = (ring_node_sm*) &sm_ring_f1[0];
	294	sm_ring_f1[NB_RING_NODES_SM_F1-1].previous = (ring_node_sm*) &sm_ring_f1[NB_RING_NODES_SM_F1-2];
	295	sm_ring_f1[NB_RING_NODES_SM_F1-1].buffer_address =
	296	(int) &sm_f1[ (NB_RING_NODES_SM_F1-1) * TOTAL_SIZE_SM ];
	297
	298	for(i=1; i<NB_RING_NODES_SM_F1-1; i++)
	299	{
	300	sm_ring_f1[i].next = (ring_node_sm*) &sm_ring_f1[i+1];
	301	sm_ring_f1[i].previous = (ring_node_sm*) &sm_ring_f1[i-1];
	302	sm_ring_f1[i].buffer_address =
	303	(int) &sm_f1[ i * TOTAL_SIZE_SM ];
	304	}
	305
	306	// F2 RING
	307	sm_ring_f2[0].next = (ring_node_sm*) &sm_ring_f2[1];
	308	sm_ring_f2[0].previous = (ring_node_sm*) &sm_ring_f2[NB_RING_NODES_SM_F2-1];
	309	sm_ring_f2[0].buffer_address =
	310	(int) &sm_f2[ 0 ];
	311
	312	sm_ring_f2[NB_RING_NODES_SM_F2-1].next = (ring_node_sm*) &sm_ring_f2[0];
	313	sm_ring_f2[NB_RING_NODES_SM_F2-1].previous = (ring_node_sm*) &sm_ring_f2[NB_RING_NODES_SM_F2-2];
	314	sm_ring_f2[NB_RING_NODES_SM_F2-1].buffer_address =
	315	(int) &sm_f2[ (NB_RING_NODES_SM_F2-1) * TOTAL_SIZE_SM ];
	316
	317	for(i=1; i<NB_RING_NODES_SM_F2-1; i++)
	318	{
	319	sm_ring_f2[i].next = (ring_node_sm*) &sm_ring_f2[i+1];
	320	sm_ring_f2[i].previous = (ring_node_sm*) &sm_ring_f2[i-1];
	321	sm_ring_f2[i].buffer_address =
	322	(int) &sm_f2[ i * TOTAL_SIZE_SM ];
	323	}
	324
	325	DEBUG_PRINTF1("asm_ring_f0 @%x\n", (unsigned int) sm_ring_f0)
	326	DEBUG_PRINTF1("asm_ring_f1 @%x\n", (unsigned int) sm_ring_f1)
	327	DEBUG_PRINTF1("asm_ring_f2 @%x\n", (unsigned int) sm_ring_f2)
	328
	329	spectral_matrix_regs->f0_0_address = sm_ring_f0[0].buffer_address;
	330	DEBUG_PRINTF1("spectral_matrix_regs->matrixF0_Address0 @%x\n", spectral_matrix_regs->f0_0_address)
	331	}
	332
	333	void SM_generic_init_ring( ring_node_sm *ring, unsigned char nbNodes, volatile int sm_f[] )
	334	{
	335	unsigned char i;
	336
	337	//***************
	338	// BUFFER ADDRESS
	339	for(i=0; i<nbNodes; i++)
	340	{
	341	ring[ i ].buffer_address = (int) &sm_f[ i * TOTAL_SIZE_SM ];
	342	}
	343
	344	//*****
	345	// NEXT
	346	ring[ nbNodes - 1 ].next = (ring_node_sm*) &ring[ 0 ];
	347	for(i=0; i<nbNodes-1; i++)
	348	{
	349	ring[ i ].next = (ring_node_sm*) &ring[ i + 1 ];
	350	}
	351
	352	//*********
	353	// PREVIOUS
	354	ring[ 0 ].previous = (ring_node_sm*) &ring[ nbNodes -1 ];
	355	for(i=1; i<nbNodes; i++)
	356	{
	357	ring[ i ].previous = (ring_node_sm*) &ring[ i - 1 ];
	358	}
	359	}
	360
	361	void ASM_generic_init_ring( ring_node_asm *ring, unsigned char nbNodes )
	362	{
	363	unsigned char i;
	364
	365	ring[ nbNodes - 1 ].next
	366	= (ring_node_asm*) &ring[ 0 ];
	367
	368	for(i=0; i<nbNodes-1; i++)
	369	{
	370	ring[ i ].next = (ring_node_asm*) &ring[ i + 1 ];
	371	}
	372	}
	373
	374	void SM_reset_current_ring_nodes( void )
	375	{
	376	current_ring_node_sm_f0 = sm_ring_f0[0].next;
	377	current_ring_node_sm_f1 = sm_ring_f1[0].next;
	378	current_ring_node_sm_f2 = sm_ring_f2[0].next;
	379
	380	ring_node_for_averaging_sm_f0 = sm_ring_f0;
	381	ring_node_for_averaging_sm_f1 = sm_ring_f1;
	382	ring_node_for_averaging_sm_f2 = sm_ring_f2;
	383	}
	384
	385	void ASM_init_header( Header_TM_LFR_SCIENCE_ASM_t *header)
	386	{
	387	header->targetLogicalAddress = CCSDS_DESTINATION_ID;
	388	header->protocolIdentifier = CCSDS_PROTOCOLE_ID;
	389	header->reserved = 0x00;
	390	header->userApplication = CCSDS_USER_APP;
	391	header->packetID[0] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST >> 8);
	392	header->packetID[1] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST);
	393	header->packetSequenceControl[0] = 0xc0;
	394	header->packetSequenceControl[1] = 0x00;
	395	header->packetLength[0] = 0x00;
	396	header->packetLength[1] = 0x00;
	397	// DATA FIELD HEADER
	398	header->spare1_pusVersion_spare2 = 0x10;
	399	header->serviceType = TM_TYPE_LFR_SCIENCE; // service type
	400	header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype
	401	header->destinationID = TM_DESTINATION_ID_GROUND;
	402	// AUXILIARY DATA HEADER
	403	header->sid = 0x00;
	404	header->biaStatusInfo = 0x00;
	405	header->pa_lfr_pkt_cnt_asm = 0x00;
	406	header->pa_lfr_pkt_nr_asm = 0x00;
	407	header->time[0] = 0x00;
	408	header->time[0] = 0x00;
	409	header->time[0] = 0x00;
	410	header->time[0] = 0x00;
	411	header->time[0] = 0x00;
	412	header->time[0] = 0x00;
	413	header->pa_lfr_asm_blk_nr[0] = 0x00; // BLK_NR MSB
	414	header->pa_lfr_asm_blk_nr[1] = 0x00; // BLK_NR LSB
	415	}
	416
	417	void ASM_send(Header_TM_LFR_SCIENCE_ASM_t header, char spectral_matrix,
	418	unsigned int sid, spw_ioctl_pkt_send *spw_ioctl_send, rtems_id queue_id)
	419	{
	420	unsigned int i;
	421	unsigned int length = 0;
	422	rtems_status_code status;
	423
	424	for (i=0; i<2; i++)
	425	{
	426	// (1) BUILD THE DATA
	427	switch(sid)
	428	{
	429	case SID_NORM_ASM_F0:
	430	spw_ioctl_send->dlen = TOTAL_SIZE_ASM_F0_IN_BYTES / 2; // 2 packets will be sent
	431	spw_ioctl_send->data = &spectral_matrix[
	432	( (ASM_F0_INDICE_START + (iNB_BINS_PER_PKT_ASM_F0) ) NB_VALUES_PER_SM ) * 2
	433	];
	434	length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F0;
	435	header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F0) >> 8 ); // BLK_NR MSB
	436	header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F0); // BLK_NR LSB
	437	break;
	438	case SID_NORM_ASM_F1:
	439	spw_ioctl_send->dlen = TOTAL_SIZE_ASM_F1_IN_BYTES / 2; // 2 packets will be sent
	440	spw_ioctl_send->data = &spectral_matrix[
	441	( (ASM_F1_INDICE_START + (iNB_BINS_PER_PKT_ASM_F1) ) NB_VALUES_PER_SM ) * 2
	442	];
	443	length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F1;
	444	header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F1) >> 8 ); // BLK_NR MSB
	445	header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F1); // BLK_NR LSB
	446	break;
	447	case SID_NORM_ASM_F2:
	448	spw_ioctl_send->dlen = TOTAL_SIZE_ASM_F2_IN_BYTES / 2; // 2 packets will be sent
	449	spw_ioctl_send->data = &spectral_matrix[
	450	( (ASM_F2_INDICE_START + (iNB_BINS_PER_PKT_ASM_F2) ) NB_VALUES_PER_SM ) * 2
	451	];
	452	length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F2;
	453	header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F2) >> 8 ); // BLK_NR MSB
	454	header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F2); // BLK_NR LSB
	455	break;
	456	default:
	457	PRINTF1("ERR * in ASM_send * unexpected sid %d\n", sid)
	458	break;
	459	}
	460	spw_ioctl_send->hlen = HEADER_LENGTH_TM_LFR_SCIENCE_ASM + CCSDS_PROTOCOLE_EXTRA_BYTES;
	461	spw_ioctl_send->hdr = (char *) header;
	462	spw_ioctl_send->options = 0;
	463
	464	// (2) BUILD THE HEADER
	465	increment_seq_counter_source_id( header->packetSequenceControl, sid );
	466	header->packetLength[0] = (unsigned char) (length>>8);
	467	header->packetLength[1] = (unsigned char) (length);
	468	header->sid = (unsigned char) sid; // SID
	469	header->pa_lfr_pkt_cnt_asm = 2;
	470	header->pa_lfr_pkt_nr_asm = (unsigned char) (i+1);
	471
	472	// (3) SET PACKET TIME
	473	header->time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
	474	header->time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
	475	header->time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
	476	header->time[3] = (unsigned char) (time_management_regs->coarse_time);
	477	header->time[4] = (unsigned char) (time_management_regs->fine_time>>8);
	478	header->time[5] = (unsigned char) (time_management_regs->fine_time);
	479	//
	480	header->acquisitionTime[0] = header->time[0];
	481	header->acquisitionTime[1] = header->time[1];
	482	header->acquisitionTime[2] = header->time[2];
	483	header->acquisitionTime[3] = header->time[3];
	484	header->acquisitionTime[4] = header->time[4];
	485	header->acquisitionTime[5] = header->time[5];
	486
	487	// (4) SEND PACKET
	488	status = rtems_message_queue_send( queue_id, spw_ioctl_send, ACTION_MSG_SPW_IOCTL_SEND_SIZE);
	489	if (status != RTEMS_SUCCESSFUL) {
	490	printf("in ASM_send *** ERR %d\n", (int) status);
	491	}
	492	}
	493	}
	494
	495	//*****************
	496	// Basic Parameters
	497
	498	void BP_init_header( Header_TM_LFR_SCIENCE_BP_t *header,
	499	unsigned int apid, unsigned char sid,
	500	unsigned int packetLength, unsigned char blkNr )
	501	{
	502	header->targetLogicalAddress = CCSDS_DESTINATION_ID;
	503	header->protocolIdentifier = CCSDS_PROTOCOLE_ID;
	504	header->reserved = 0x00;
	505	header->userApplication = CCSDS_USER_APP;
	506	header->packetID[0] = (unsigned char) (apid >> 8);
	507	header->packetID[1] = (unsigned char) (apid);
	508	header->packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
	509	header->packetSequenceControl[1] = 0x00;
	510	header->packetLength[0] = (unsigned char) (packetLength >> 8);
	511	header->packetLength[1] = (unsigned char) (packetLength);
	512	// DATA FIELD HEADER
	513	header->spare1_pusVersion_spare2 = 0x10;
	514	header->serviceType = TM_TYPE_LFR_SCIENCE; // service type
	515	header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype
	516	header->destinationID = TM_DESTINATION_ID_GROUND;
	517	// AUXILIARY DATA HEADER
	518	header->sid = sid;
	519	header->biaStatusInfo = 0x00;
	520	header->time[0] = 0x00;
	521	header->time[0] = 0x00;
	522	header->time[0] = 0x00;
	523	header->time[0] = 0x00;
	524	header->time[0] = 0x00;
	525	header->time[0] = 0x00;
	526	header->pa_lfr_bp_blk_nr[0] = 0x00; // BLK_NR MSB
	527	header->pa_lfr_bp_blk_nr[1] = blkNr; // BLK_NR LSB
	528	}
	529
	530	void BP_init_header_with_spare(Header_TM_LFR_SCIENCE_BP_with_spare_t *header,
	531	unsigned int apid, unsigned char sid,
	532	unsigned int packetLength , unsigned char blkNr)
	533	{
	534	header->targetLogicalAddress = CCSDS_DESTINATION_ID;
	535	header->protocolIdentifier = CCSDS_PROTOCOLE_ID;
	536	header->reserved = 0x00;
	537	header->userApplication = CCSDS_USER_APP;
	538	header->packetID[0] = (unsigned char) (apid >> 8);
	539	header->packetID[1] = (unsigned char) (apid);
	540	header->packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
	541	header->packetSequenceControl[1] = 0x00;
	542	header->packetLength[0] = (unsigned char) (packetLength >> 8);
	543	header->packetLength[1] = (unsigned char) (packetLength);
	544	// DATA FIELD HEADER
	545	header->spare1_pusVersion_spare2 = 0x10;
	546	header->serviceType = TM_TYPE_LFR_SCIENCE; // service type
	547	header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype
	548	header->destinationID = TM_DESTINATION_ID_GROUND;
	549	// AUXILIARY DATA HEADER
	550	header->sid = sid;
	551	header->biaStatusInfo = 0x00;
	552	header->time[0] = 0x00;
	553	header->time[0] = 0x00;
	554	header->time[0] = 0x00;
	555	header->time[0] = 0x00;
	556	header->time[0] = 0x00;
	557	header->time[0] = 0x00;
	558	header->source_data_spare = 0x00;
	559	header->pa_lfr_bp_blk_nr[0] = 0x00; // BLK_NR MSB
	560	header->pa_lfr_bp_blk_nr[1] = blkNr; // BLK_NR LSB
	561	}
	562
	563	void BP_send(char *data, rtems_id queue_id, unsigned int nbBytesToSend, unsigned int sid )
	564	{
	565	rtems_status_code status;
	566
	567	// SET THE SEQUENCE_CNT PARAMETER
	568	increment_seq_counter_source_id( (unsigned char*) &data[ PACKET_POS_SEQUENCE_CNT ], sid );
	569	// SEND PACKET
	570	status = rtems_message_queue_send( queue_id, data, nbBytesToSend);
	571	if (status != RTEMS_SUCCESSFUL)
	572	{
	573	printf("ERR * in BP_send * ERR %d\n", (int) status);
	574	}
	575	}
	576
	577	//******************
	578	// general functions
	579
	580	void reset_spectral_matrix_regs( void )
	581	{
	582	/** This function resets the spectral matrices module registers.
	583	*
	584	* The registers affected by this function are located at the following offset addresses:
	585	*
	586	* - 0x00 config
	587	* - 0x04 status
	588	* - 0x08 matrixF0_Address0
	589	* - 0x10 matrixFO_Address1
	590	* - 0x14 matrixF1_Address
	591	* - 0x18 matrixF2_Address
	592	*
	593	*/
	594
	595	spectral_matrix_regs->config = 0x00;
	596	spectral_matrix_regs->status = 0x00;
	597
	598	spectral_matrix_regs->f0_0_address = current_ring_node_sm_f0->previous->buffer_address;
	599	spectral_matrix_regs->f0_1_address = current_ring_node_sm_f0->buffer_address;
	600	spectral_matrix_regs->f1_0_address = current_ring_node_sm_f1->previous->buffer_address;
	601	spectral_matrix_regs->f1_1_address = current_ring_node_sm_f1->buffer_address;
	602	spectral_matrix_regs->f2_0_address = current_ring_node_sm_f2->previous->buffer_address;
	603	spectral_matrix_regs->f2_1_address = current_ring_node_sm_f2->buffer_address;
	604	}
	605
	606	void set_time( unsigned char time, unsigned char timeInBuffer )
	607	{
	608	time[0] = timeInBuffer[0];
	609	time[1] = timeInBuffer[1];
	610	time[2] = timeInBuffer[2];
	611	time[3] = timeInBuffer[3];
	612	time[4] = timeInBuffer[6];
	613	time[5] = timeInBuffer[7];
	614	}
	615
	616	unsigned long long int get_acquisition_time( unsigned char *timePtr )
	617	{
	618	unsigned long long int acquisitionTimeAslong;
	619	acquisitionTimeAslong = 0x00;
	620	acquisitionTimeAslong = ( (unsigned long long int) (timePtr[0] & 0x7f) << 40 ) // [0111 1111] mask the synchronization bit
	621	+ ( (unsigned long long int) timePtr[1] << 32 )
	622	+ ( (unsigned long long int) timePtr[2] << 24 )
	623	+ ( (unsigned long long int) timePtr[3] << 16 )
	624	+ ( (unsigned long long int) timePtr[6] << 8 )
	625	+ ( (unsigned long long int) timePtr[7] );
	626	return acquisitionTimeAslong;
	627	}
	628
	629	void close_matrix_actions(unsigned int *nb_sm, unsigned int nb_sm_before_avf, rtems_id avf_task_id,
	630	ring_node_sm node_for_averaging, ring_node_sm ringNode,
	631	unsigned long long int time )
	632	{
	633	unsigned char *timePtr;
	634	unsigned char *coarseTimePtr;
	635	unsigned char *fineTimePtr;
	636	rtems_status_code status_code;
	637
	638	timePtr = (unsigned char *) &time;
	639	coarseTimePtr = (unsigned char *) &node_for_averaging->coarseTime;
	640	fineTimePtr = (unsigned char *) &node_for_averaging->fineTime;
	641
	642	nb_sm = nb_sm + 1;
	643	if (*nb_sm == nb_sm_before_avf)
	644	{
	645	node_for_averaging = ringNode;
	646	coarseTimePtr[0] = timePtr[2];
	647	coarseTimePtr[1] = timePtr[3];
	648	coarseTimePtr[2] = timePtr[4];
	649	coarseTimePtr[3] = timePtr[5];
	650	fineTimePtr[2] = timePtr[6];
	651	fineTimePtr[3] = timePtr[7];
	652	if (rtems_event_send( avf_task_id, RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL)
	653	{
	654	status_code = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_3 );
	655	}
	656	*nb_sm = 0;
	657	}
	658	}
	659
	660	unsigned char getSID( rtems_event_set event )
	661	{
	662	unsigned char sid;
	663
	664	rtems_event_set eventSetBURST;
	665	rtems_event_set eventSetSBM;
	666
	667	//******
	668	// BURST
	669	eventSetBURST = RTEMS_EVENT_BURST_BP1_F0
	670	\| RTEMS_EVENT_BURST_BP1_F1
	671	\| RTEMS_EVENT_BURST_BP2_F0
	672	\| RTEMS_EVENT_BURST_BP2_F1;
	673
	674	//****
	675	// SBM
	676	eventSetSBM = RTEMS_EVENT_SBM_BP1_F0
	677	\| RTEMS_EVENT_SBM_BP1_F1
	678	\| RTEMS_EVENT_SBM_BP2_F0
	679	\| RTEMS_EVENT_SBM_BP2_F1;
	680
	681	if (event & eventSetBURST)
	682	{
	683	sid = SID_BURST_BP1_F0;
	684	}
	685	else if (event & eventSetSBM)
	686	{
	687	sid = SID_SBM1_BP1_F0;
	688	}
	689	else
	690	{
	691	sid = 0;
	692	}
	693
	694	return sid;
	695	}
	696

timegen/src/tc_acceptance.c created 644 +437 0

			@@ -0,0 +1,437
		1	/** Functions related to TeleCommand acceptance.
		2	*
		3	* @file
		4	* @author P. LEROY
		5	*
		6	* A group of functions to handle TeleCommands parsing.\n
		7	*
		8	*/
		9
		10	#include "tc_acceptance.h"
		11
		12	unsigned int lookUpTableForCRC[256];
		13
		14	//**********************
		15	// GENERAL USE FUNCTIONS
		16	unsigned int Crc_opt( unsigned char D, unsigned int Chk)
		17	{
		18	/** This function generate the CRC for one byte and returns the value of the new syndrome.
		19	*
		20	* @param D is the current byte of data.
		21	* @param Chk is the current syndrom value.
		22	*
		23	* @return the value of the new syndrome on two bytes.
		24	*
		25	*/
		26
		27	return(((Chk << 8) & 0xff00)^lookUpTableForCRC [(((Chk >> 8)^D) & 0x00ff)]);
		28	}
		29
		30	void initLookUpTableForCRC( void )
		31	{
		32	/** This function is used to initiates the look-up table for fast CRC computation.
		33	*
		34	* The global table lookUpTableForCRC[256] is initiated.
		35	*
		36	*/
		37
		38	unsigned int i;
		39	unsigned int tmp;
		40
		41	for (i=0; i<256; i++)
		42	{
		43	tmp = 0;
		44	if((i & 1) != 0) {
		45	tmp = tmp ^ 0x1021;
		46	}
		47	if((i & 2) != 0) {
		48	tmp = tmp ^ 0x2042;
		49	}
		50	if((i & 4) != 0) {
		51	tmp = tmp ^ 0x4084;
		52	}
		53	if((i & 8) != 0) {
		54	tmp = tmp ^ 0x8108;
		55	}
		56	if((i & 16) != 0) {
		57	tmp = tmp ^ 0x1231;
		58	}
		59	if((i & 32) != 0) {
		60	tmp = tmp ^ 0x2462;
		61	}
		62	if((i & 64) != 0) {
		63	tmp = tmp ^ 0x48c4;
		64	}
		65	if((i & 128) != 0) {
		66	tmp = tmp ^ 0x9188;
		67	}
		68	lookUpTableForCRC[i] = tmp;
		69	}
		70	}
		71
		72	void GetCRCAsTwoBytes(unsigned char* data, unsigned char* crcAsTwoBytes, unsigned int sizeOfData)
		73	{
		74	/** This function calculates a two bytes Cyclic Redundancy Code.
		75	*
		76	* @param data points to a buffer containing the data on which to compute the CRC.
		77	* @param crcAsTwoBytes points points to a two bytes buffer in which the CRC is stored.
		78	* @param sizeOfData is the number of bytes of data used to compute the CRC.
		79	*
		80	* The specification of the Cyclic Redundancy Code is described in the following document: ECSS-E-70-41-A.
		81	*
		82	*/
		83
		84	unsigned int Chk;
		85	int j;
		86	Chk = 0xffff; // reset the syndrom to all ones
		87	for (j=0; j<sizeOfData; j++) {
		88	Chk = Crc_opt(data[j], Chk);
		89	}
		90	crcAsTwoBytes[0] = (unsigned char) (Chk >> 8);
		91	crcAsTwoBytes[1] = (unsigned char) (Chk & 0x00ff);
		92	}
		93
		94	//*********************
		95	// ACCEPTANCE FUNCTIONS
		96	int tc_parser(ccsdsTelecommandPacket_t * TCPacket, unsigned int estimatedPacketLength, unsigned char *computed_CRC)
		97	{
		98	/** This function parses TeleCommands.
		99	*
		100	* @param TC points to the TeleCommand that will be parsed.
		101	* @param estimatedPacketLength is the PACKET_LENGTH field calculated from the effective length of the received packet.
		102	*
		103	* @return Status code of the parsing.
		104	*
		105	* The parsing checks:
		106	* - process id
		107	* - category
		108	* - length: a global check is performed and a per subtype check also
		109	* - type
		110	* - subtype
		111	* - crc
		112	*
		113	*/
		114
		115	int status;
		116	int status_crc;
		117	unsigned char pid;
		118	unsigned char category;
		119	unsigned int packetLength;
		120	unsigned char packetType;
		121	unsigned char packetSubtype;
		122	unsigned char sid;
		123
		124	status = CCSDS_TM_VALID;
		125
		126	// APID check *** APID on 2 bytes
		127	pid = ((TCPacket->packetID[0] & 0x07)<<4) + ( (TCPacket->packetID[1]>>4) & 0x0f ); // PID = 11 *** 7 bits xxxxx210 7654xxxx
		128	category = (TCPacket->packetID[1] & 0x0f); // PACKET_CATEGORY = 12 *** 4 bits xxxxxxxx xxxx3210
		129	packetLength = (TCPacket->packetLength[0] * 256) + TCPacket->packetLength[1];
		130	packetType = TCPacket->serviceType;
		131	packetSubtype = TCPacket->serviceSubType;
		132	sid = TCPacket->sourceID;
		133
		134	if ( pid != CCSDS_PROCESS_ID ) // CHECK THE PROCESS ID
		135	{
		136	status = ILLEGAL_APID;
		137	}
		138	if (status == CCSDS_TM_VALID) // CHECK THE CATEGORY
		139	{
		140	if ( category != CCSDS_PACKET_CATEGORY )
		141	{
		142	status = ILLEGAL_APID;
		143	}
		144	}
		145	if (status == CCSDS_TM_VALID) // CHECK THE PACKET_LENGTH FIELD AND THE ESTIMATED PACKET_LENGTH COMPLIANCE
		146	{
		147	if (packetLength != estimatedPacketLength ) {
		148	status = WRONG_LEN_PKT;
		149	}
		150	}
		151	if (status == CCSDS_TM_VALID) // CHECK THAT THE PACKET DOES NOT EXCEED THE MAX SIZE
		152	{
		153	if ( packetLength >= CCSDS_TC_PKT_MAX_SIZE ) {
		154	status = WRONG_LEN_PKT;
		155	}
		156	}
		157	if (status == CCSDS_TM_VALID) // CHECK THE TYPE
		158	{
		159	status = tc_check_type( packetType );
		160	}
		161	if (status == CCSDS_TM_VALID) // CHECK THE SUBTYPE
		162	{
		163	status = tc_check_type_subtype( packetType, packetSubtype );
		164	}
		165	if (status == CCSDS_TM_VALID) // CHECK THE SID
		166	{
		167	status = tc_check_sid( sid );
		168	}
		169	if (status == CCSDS_TM_VALID) // CHECK THE SUBTYPE AND LENGTH COMPLIANCE
		170	{
		171	status = tc_check_length( packetSubtype, packetLength );
		172	}
		173	status_crc = tc_check_crc( TCPacket, estimatedPacketLength, computed_CRC );
		174	if (status == CCSDS_TM_VALID ) // CHECK CRC
		175	{
		176	status = status_crc;
		177	}
		178
		179	return status;
		180	}
		181
		182	int tc_check_type( unsigned char packetType )
		183	{
		184	/** This function checks that the type of a TeleCommand is valid.
		185	*
		186	* @param packetType is the type to check.
		187	*
		188	* @return Status code CCSDS_TM_VALID or ILL_TYPE.
		189	*
		190	*/
		191
		192	int status;
		193
		194	if ( (packetType == TC_TYPE_GEN) \|\| (packetType == TC_TYPE_TIME))
		195	{
		196	status = CCSDS_TM_VALID;
		197	}
		198	else
		199	{
		200	status = ILL_TYPE;
		201	}
		202
		203	return status;
		204	}
		205
		206	int tc_check_type_subtype( unsigned char packetType, unsigned char packetSubType )
		207	{
		208	/** This function checks that the subtype of a TeleCommand is valid and coherent with the type.
		209	*
		210	* @param packetType is the type of the TC.
		211	* @param packetSubType is the subtype to check.
		212	*
		213	* @return Status code CCSDS_TM_VALID or ILL_SUBTYPE.
		214	*
		215	*/
		216
		217	int status;
		218
		219	switch(packetType)
		220	{
		221	case TC_TYPE_GEN:
		222	if ( (packetSubType == TC_SUBTYPE_RESET)
		223	\|\| (packetSubType == TC_SUBTYPE_LOAD_COMM)
		224	\|\| (packetSubType == TC_SUBTYPE_LOAD_NORM) \|\| (packetSubType == TC_SUBTYPE_LOAD_BURST)
		225	\|\| (packetSubType == TC_SUBTYPE_LOAD_SBM1) \|\| (packetSubType == TC_SUBTYPE_LOAD_SBM2)
		226	\|\| (packetSubType == TC_SUBTYPE_DUMP)
		227	\|\| (packetSubType == TC_SUBTYPE_ENTER)
		228	\|\| (packetSubType == TC_SUBTYPE_UPDT_INFO)
		229	\|\| (packetSubType == TC_SUBTYPE_EN_CAL) \|\| (packetSubType == TC_SUBTYPE_DIS_CAL) )
		230	{
		231	status = CCSDS_TM_VALID;
		232	}
		233	else
		234	{
		235	status = ILL_SUBTYPE;
		236	}
		237	break;
		238
		239	case TC_TYPE_TIME:
		240	if (packetSubType == TC_SUBTYPE_UPDT_TIME)
		241	{
		242	status = CCSDS_TM_VALID;
		243	}
		244	else
		245	{
		246	status = ILL_SUBTYPE;
		247	}
		248	break;
		249
		250	default:
		251	status = ILL_SUBTYPE;
		252	break;
		253	}
		254
		255	return status;
		256	}
		257
		258	int tc_check_sid( unsigned char sid )
		259	{
		260	/** This function checks that the sid of a TeleCommand is valid.
		261	*
		262	* @param sid is the sid to check.
		263	*
		264	* @return Status code CCSDS_TM_VALID or CORRUPTED.
		265	*
		266	*/
		267
		268	int status;
		269
		270	if ( (sid == SID_TC_MISSION_TIMELINE) \|\| (sid == SID_TC_TC_SEQUENCES) \|\| (sid == SID_TC_RECOVERY_ACTION_CMD)
		271	\|\| (sid == SID_TC_BACKUP_MISSION_TIMELINE)
		272	\|\| (sid == SID_TC_DIRECT_CMD) \|\| (sid == SID_TC_SPARE_GRD_SRC1) \|\| (sid == SID_TC_SPARE_GRD_SRC2)
		273	\|\| (sid == SID_TC_OBCP) \|\| (sid == SID_TC_SYSTEM_CONTROL) \|\| (sid == SID_TC_AOCS)
		274	\|\| (sid == SID_TC_RPW_INTERNAL))
		275	{
		276	status = CCSDS_TM_VALID;
		277	}
		278	else
		279	{
		280	status = WRONG_SRC_ID;
		281	}
		282
		283	return status;
		284	}
		285
		286	int tc_check_length( unsigned char packetSubType, unsigned int length )
		287	{
		288	/** This function checks that the subtype and the length are compliant.
		289	*
		290	* @param packetSubType is the subtype to check.
		291	* @param length is the length to check.
		292	*
		293	* @return Status code CCSDS_TM_VALID or ILL_TYPE.
		294	*
		295	*/
		296
		297	int status;
		298
		299	status = LFR_SUCCESSFUL;
		300
		301	switch(packetSubType)
		302	{
		303	case TC_SUBTYPE_RESET:
		304	if (length!=(TC_LEN_RESET-CCSDS_TC_TM_PACKET_OFFSET)) {
		305	status = WRONG_LEN_PKT;
		306	}
		307	else {
		308	status = CCSDS_TM_VALID;
		309	}
		310	break;
		311	case TC_SUBTYPE_LOAD_COMM:
		312	if (length!=(TC_LEN_LOAD_COMM-CCSDS_TC_TM_PACKET_OFFSET)) {
		313	status = WRONG_LEN_PKT;
		314	}
		315	else {
		316	status = CCSDS_TM_VALID;
		317	}
		318	break;
		319	case TC_SUBTYPE_LOAD_NORM:
		320	if (length!=(TC_LEN_LOAD_NORM-CCSDS_TC_TM_PACKET_OFFSET)) {
		321	status = WRONG_LEN_PKT;
		322	}
		323	else {
		324	status = CCSDS_TM_VALID;
		325	}
		326	break;
		327	case TC_SUBTYPE_LOAD_BURST:
		328	if (length!=(TC_LEN_LOAD_BURST-CCSDS_TC_TM_PACKET_OFFSET)) {
		329	status = WRONG_LEN_PKT;
		330	}
		331	else {
		332	status = CCSDS_TM_VALID;
		333	}
		334	break;
		335	case TC_SUBTYPE_LOAD_SBM1:
		336	if (length!=(TC_LEN_LOAD_SBM1-CCSDS_TC_TM_PACKET_OFFSET)) {
		337	status = WRONG_LEN_PKT;
		338	}
		339	else {
		340	status = CCSDS_TM_VALID;
		341	}
		342	break;
		343	case TC_SUBTYPE_LOAD_SBM2:
		344	if (length!=(TC_LEN_LOAD_SBM2-CCSDS_TC_TM_PACKET_OFFSET)) {
		345	status = WRONG_LEN_PKT;
		346	}
		347	else {
		348	status = CCSDS_TM_VALID;
		349	}
		350	break;
		351	case TC_SUBTYPE_DUMP:
		352	if (length!=(TC_LEN_DUMP-CCSDS_TC_TM_PACKET_OFFSET)) {
		353	status = WRONG_LEN_PKT;
		354	}
		355	else {
		356	status = CCSDS_TM_VALID;
		357	}
		358	break;
		359	case TC_SUBTYPE_ENTER:
		360	if (length!=(TC_LEN_ENTER-CCSDS_TC_TM_PACKET_OFFSET)) {
		361	status = WRONG_LEN_PKT;
		362	}
		363	else {
		364	status = CCSDS_TM_VALID;
		365	}
		366	break;
		367	case TC_SUBTYPE_UPDT_INFO:
		368	if (length!=(TC_LEN_UPDT_INFO-CCSDS_TC_TM_PACKET_OFFSET)) {
		369	status = WRONG_LEN_PKT;
		370	}
		371	else {
		372	status = CCSDS_TM_VALID;
		373	}
		374	break;
		375	case TC_SUBTYPE_EN_CAL:
		376	if (length!=(TC_LEN_EN_CAL-CCSDS_TC_TM_PACKET_OFFSET)) {
		377	status = WRONG_LEN_PKT;
		378	}
		379	else {
		380	status = CCSDS_TM_VALID;
		381	}
		382	break;
		383	case TC_SUBTYPE_DIS_CAL:
		384	if (length!=(TC_LEN_DIS_CAL-CCSDS_TC_TM_PACKET_OFFSET)) {
		385	status = WRONG_LEN_PKT;
		386	}
		387	else {
		388	status = CCSDS_TM_VALID;
		389	}
		390	break;
		391	case TC_SUBTYPE_UPDT_TIME:
		392	if (length!=(TC_LEN_UPDT_TIME-CCSDS_TC_TM_PACKET_OFFSET)) {
		393	status = WRONG_LEN_PKT;
		394	}
		395	else {
		396	status = CCSDS_TM_VALID;
		397	}
		398	break;
		399	default: // if the subtype is not a legal value, return ILL_SUBTYPE
		400	status = ILL_SUBTYPE;
		401	break ;
		402	}
		403
		404	return status;
		405	}
		406
		407	int tc_check_crc( ccsdsTelecommandPacket_t * TCPacket, unsigned int length, unsigned char *computed_CRC )
		408	{
		409	/** This function checks the CRC validity of the corresponding TeleCommand packet.
		410	*
		411	* @param TCPacket points to the TeleCommand packet to check.
		412	* @param length is the length of the TC packet.
		413	*
		414	* @return Status code CCSDS_TM_VALID or INCOR_CHECKSUM.
		415	*
		416	*/
		417
		418	int status;
		419	unsigned char * CCSDSContent;
		420
		421	CCSDSContent = (unsigned char*) TCPacket->packetID;
		422	GetCRCAsTwoBytes(CCSDSContent, computed_CRC, length + CCSDS_TC_TM_PACKET_OFFSET - 2); // 2 CRC bytes removed from the calculation of the CRC
		423	if (computed_CRC[0] != CCSDSContent[length + CCSDS_TC_TM_PACKET_OFFSET -2]) {
		424	status = INCOR_CHECKSUM;
		425	}
		426	else if (computed_CRC[1] != CCSDSContent[length + CCSDS_TC_TM_PACKET_OFFSET -1]) {
		427	status = INCOR_CHECKSUM;
		428	}
		429	else {
		430	status = CCSDS_TM_VALID;
		431	}
		432
		433	return status;
		434	}
		435
		436
		437

timegen/src/tc_handler.c created 644 +250 0

			@@ -0,0 +1,250
		1	/** Functions and tasks related to TeleCommand handling.
		2	*
		3	* @file
		4	* @author P. LEROY
		5	*
		6	* A group of functions to handle TeleCommands:\n
		7	* action launching\n
		8	* TC parsing\n
		9	* ...
		10	*
		11	*/
		12
		13	#include "tc_handler.h"
		14
		15	//***********
		16	// RTEMS TASK
		17
		18	unsigned int incomingTransitionCoarseTime;
		19
		20	void reset_transitionCoarseTime( void )
		21	{
		22	incomingTransitionCoarseTime = 0xffffffff;
		23	}
		24
		25	void set_transitionCoarseTime( unsigned int value )
		26	{
		27	incomingTransitionCoarseTime = value;
		28	}
		29
		30	unsigned int get_transitionCoarseTime( void )
		31	{
		32	return incomingTransitionCoarseTime;
		33	}
		34
		35	rtems_task actn_task( rtems_task_argument unused )
		36	{
		37	/** This RTEMS task is responsible for launching actions upton the reception of valid TeleCommands.
		38	*
		39	* @param unused is the starting argument of the RTEMS task
		40	*
		41	* The ACTN task waits for data coming from an RTEMS msesage queue. When data arrives, it launches specific actions depending
		42	* on the incoming TeleCommand.
		43	*
		44	*/
		45
		46	int result;
		47	rtems_status_code status; // RTEMS status code
		48	ccsdsTelecommandPacket_t TC; // TC sent to the ACTN task
		49	size_t size; // size of the incoming TC packet
		50	unsigned char subtype; // subtype of the current TC packet
		51	unsigned char time[6];
		52	rtems_id queue_rcv_id;
		53	rtems_id queue_snd_id;
		54
		55	status = get_message_queue_id_recv( &queue_rcv_id );
		56	if (status != RTEMS_SUCCESSFUL)
		57	{
		58	PRINTF1("in ACTN *** ERR get_message_queue_id_recv %d\n", status)
		59	}
		60
		61	status = get_message_queue_id_send( &queue_snd_id );
		62	if (status != RTEMS_SUCCESSFUL)
		63	{
		64	PRINTF1("in ACTN *** ERR get_message_queue_id_send %d\n", status)
		65	}
		66
		67	result = LFR_SUCCESSFUL;
		68	subtype = 0; // subtype of the current TC packet
		69
		70	BOOT_PRINTF("in ACTN *** \n")
		71
		72	while(1)
		73	{
		74	status = rtems_message_queue_receive( queue_rcv_id, (char*) &TC, &size,
		75	RTEMS_WAIT, RTEMS_NO_TIMEOUT);
		76	getTime( time ); // set time to the current time
		77	if (status!=RTEMS_SUCCESSFUL)
		78	{
		79	PRINTF1("ERR * in task ACTN * error receiving a message, code %d \n", status)
		80	}
		81	else
		82	{
		83	subtype = TC.serviceSubType;
		84	switch(subtype)
		85	{
		86	case TC_SUBTYPE_ENTER:
		87	result = action_enter_mode( &TC, queue_snd_id );
		88	break;
		89	case TC_SUBTYPE_UPDATE_TIME:
		90	result = action_update_time( &TC );
		91	break;
		92	default:
		93	break;
		94	}
		95	}
		96	}
		97	}
		98
		99	//***********
		100	// TC ACTIONS
		101
		102	int action_reset(ccsdsTelecommandPacket_t TC, rtems_id queue_id, unsigned char time)
		103	{
		104	return LFR_SUCCESSFUL;
		105	}
		106
		107	int action_enter_mode(ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
		108	{
		109	unsigned int *transitionCoarseTime_ptr;
		110	unsigned int transitionCoarseTime;
		111	unsigned char * bytePosPtr;
		112
		113	bytePosPtr = (unsigned char *) &TC->packetID;
		114
		115	transitionCoarseTime_ptr = (unsigned int *) ( &bytePosPtr[ BYTE_POS_CP_LFR_ENTER_MODE_TIME ] );
		116	transitionCoarseTime = transitionCoarseTime_ptr[0] & 0x7fffffff;
		117	printf("local coarse time (without sync bit) = %x, requested transitionCoarseTime = %x\n",
		118	getLocalCoarseTime(),
		119	transitionCoarseTime);
		120
		121	set_transitionCoarseTime( transitionCoarseTime );
		122
		123	return LFR_SUCCESSFUL;
		124	}
		125
		126	int action_update_info(ccsdsTelecommandPacket_t *TC, rtems_id queue_id)
		127	{
		128	return LFR_SUCCESSFUL;
		129	}
		130
		131	int action_enable_calibration(ccsdsTelecommandPacket_t TC, rtems_id queue_id, unsigned char time)
		132	{
		133	return LFR_SUCCESSFUL;
		134	}
		135
		136	int action_disable_calibration(ccsdsTelecommandPacket_t TC, rtems_id queue_id, unsigned char time)
		137	{
		138	return LFR_SUCCESSFUL;
		139	}
		140
		141	int action_update_time(ccsdsTelecommandPacket_t *TC)
		142	{
		143	unsigned int incomingCoarseTime;
		144	unsigned int currentLocalCoarseTime;
		145
		146	incomingCoarseTime = (TC->dataAndCRC[0] << 24)
		147	+ (TC->dataAndCRC[1] << 16)
		148	+ (TC->dataAndCRC[2] << 8)
		149	+ TC->dataAndCRC[3];
		150
		151	currentLocalCoarseTime = getLocalCoarseTime();
		152	setLocalCoarseTime( incomingCoarseTime );
		153	printf( "currentLocalCoarseTime = %x, localCoarseTime set to: %x\n", currentLocalCoarseTime, getLocalCoarseTime() );
		154
		155	return LFR_SUCCESSFUL;
		156	}
		157
		158	//*******************
		159	// ENTERING THE MODES
		160	int check_mode_value( unsigned char requestedMode )
		161	{
		162	return LFR_SUCCESSFUL;
		163	}
		164
		165	int check_mode_transition( unsigned char requestedMode )
		166	{
		167	return LFR_SUCCESSFUL;
		168	}
		169
		170	int check_transition_date( unsigned int transitionCoarseTime )
		171	{
		172	return LFR_SUCCESSFUL;
		173	}
		174
		175	int stop_current_mode( void )
		176	{
		177	return LFR_SUCCESSFUL;
		178	}
		179
		180	int enter_mode( unsigned char mode, unsigned int transitionCoarseTime )
		181	{
		182	return LFR_SUCCESSFUL;
		183	}
		184
		185	int restart_science_tasks(unsigned char lfrRequestedMode )
		186	{
		187	return LFR_SUCCESSFUL;
		188	}
		189
		190	int suspend_science_tasks()
		191	{
		192	return LFR_SUCCESSFUL;
		193	}
		194
		195	void launch_waveform_picker( unsigned char mode, unsigned int transitionCoarseTime )
		196	{
		197	}
		198
		199	void launch_spectral_matrix( void )
		200	{
		201	}
		202
		203	void launch_spectral_matrix_simu( void )
		204	{
		205	}
		206
		207	void set_irq_on_new_ready_matrix( unsigned char value )
		208	{
		209	}
		210
		211	void set_run_matrix_spectral( unsigned char value )
		212	{
		213	}
		214
		215	//****************
		216	// CLOSING ACTIONS
		217	void update_last_TC_exe( ccsdsTelecommandPacket_t TC, unsigned char time )
		218	{
		219	}
		220
		221	void update_last_TC_rej(ccsdsTelecommandPacket_t TC, unsigned char time )
		222	{
		223	}
		224
		225	void close_action(ccsdsTelecommandPacket_t *TC, int result, rtems_id queue_id )
		226	{
		227	}
		228
		229	//***************************
		230	// Interrupt Service Routines
		231	rtems_isr commutation_isr1( rtems_vector_number vector )
		232	{
		233	if (rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
		234	printf("In commutation_isr1 *** Error sending event to DUMB\n");
		235	}
		236	}
		237
		238	rtems_isr commutation_isr2( rtems_vector_number vector )
		239	{
		240	if (rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
		241	printf("In commutation_isr2 *** Error sending event to DUMB\n");
		242	}
		243	}
		244
		245	//****************
		246	// OTHER FUNCTIONS
		247	void updateLFRCurrentMode()
		248	{
		249	}
		250

timegen/src/tc_load_dump_parameters.c created 644 +772 0

This diff has been collapsed as it changes many lines, (772 lines changed) Show them Hide them
		@@ -0,0 +1,772
	1	/** Functions to load and dump parameters in the LFR registers.
	2	*
	3	* @file
	4	* @author P. LEROY
	5	*
	6	* A group of functions to handle TC related to parameter loading and dumping.\n
	7	* TC_LFR_LOAD_COMMON_PAR\n
	8	* TC_LFR_LOAD_NORMAL_PAR\n
	9	* TC_LFR_LOAD_BURST_PAR\n
	10	* TC_LFR_LOAD_SBM1_PAR\n
	11	* TC_LFR_LOAD_SBM2_PAR\n
	12	*
	13	*/
	14
	15	#include "tc_load_dump_parameters.h"
	16
	17	int action_load_common_par(ccsdsTelecommandPacket_t *TC)
	18	{
	19	/** This function updates the LFR registers with the incoming common parameters.
	20	*
	21	* @param TC points to the TeleCommand packet that is being processed
	22	*
	23	*
	24	*/
	25
	26	parameter_dump_packet.unused0 = TC->dataAndCRC[0];
	27	parameter_dump_packet.bw_sp0_sp1_r0_r1 = TC->dataAndCRC[1];
	28	set_wfp_data_shaping( );
	29	return LFR_SUCCESSFUL;
	30	}
	31
	32	int action_load_normal_par(ccsdsTelecommandPacket_t TC, rtems_id queue_id, unsigned char time)
	33	{
	34	/** This function updates the LFR registers with the incoming normal parameters.
	35	*
	36	* @param TC points to the TeleCommand packet that is being processed
	37	* @param queue_id is the id of the queue which handles TM related to this execution step
	38	*
	39	*/
	40
	41	int result;
	42	int flag;
	43	rtems_status_code status;
	44
	45	flag = LFR_SUCCESSFUL;
	46
	47	if ( (lfrCurrentMode == LFR_MODE_NORMAL) \|\|
	48	(lfrCurrentMode == LFR_MODE_SBM1) \|\| (lfrCurrentMode == LFR_MODE_SBM2) ) {
	49	status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
	50	flag = LFR_DEFAULT;
	51	}
	52
	53	// CHECK THE PARAMETERS SET CONSISTENCY
	54	if (flag == LFR_SUCCESSFUL)
	55	{
	56	flag = check_common_par_consistency( TC, queue_id );
	57	}
	58
	59	// SET THE PARAMETERS IF THEY ARE CONSISTENT
	60	if (flag == LFR_SUCCESSFUL)
	61	{
	62	result = set_sy_lfr_n_swf_l( TC );
	63	result = set_sy_lfr_n_swf_p( TC );
	64	result = set_sy_lfr_n_bp_p0( TC );
	65	result = set_sy_lfr_n_bp_p1( TC );
	66	result = set_sy_lfr_n_asm_p( TC );
	67	result = set_sy_lfr_n_cwf_long_f3( TC );
	68	}
	69
	70	return flag;
	71	}
	72
	73	int action_load_burst_par(ccsdsTelecommandPacket_t TC, rtems_id queue_id, unsigned char time)
	74	{
	75	/** This function updates the LFR registers with the incoming burst parameters.
	76	*
	77	* @param TC points to the TeleCommand packet that is being processed
	78	* @param queue_id is the id of the queue which handles TM related to this execution step
	79	*
	80	*/
	81
	82	int flag;
	83	rtems_status_code status;
	84	unsigned char sy_lfr_b_bp_p0;
	85	unsigned char sy_lfr_b_bp_p1;
	86	float aux;
	87
	88	flag = LFR_SUCCESSFUL;
	89
	90	if ( lfrCurrentMode == LFR_MODE_BURST ) {
	91	status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
	92	flag = LFR_DEFAULT;
	93	}
	94
	95	sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ];
	96	sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ];
	97
	98	// sy_lfr_b_bp_p0
	99	if (flag == LFR_SUCCESSFUL)
	100	{
	101	if (sy_lfr_b_bp_p0 < DEFAULT_SY_LFR_B_BP_P0 )
	102	{
	103	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P0+10, sy_lfr_b_bp_p0 );
	104	flag = WRONG_APP_DATA;
	105	}
	106	}
	107	// sy_lfr_b_bp_p1
	108	if (flag == LFR_SUCCESSFUL)
	109	{
	110	if (sy_lfr_b_bp_p1 < DEFAULT_SY_LFR_B_BP_P1 )
	111	{
	112	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P1+10, sy_lfr_b_bp_p1 );
	113	flag = WRONG_APP_DATA;
	114	}
	115	}
	116	//****************************************************************
	117	// check the consistency between sy_lfr_b_bp_p0 and sy_lfr_b_bp_p1
	118	if (flag == LFR_SUCCESSFUL)
	119	{
	120	sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ];
	121	sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ];
	122	aux = ( (float ) sy_lfr_b_bp_p1 / sy_lfr_b_bp_p0 ) - floor(sy_lfr_b_bp_p1 / sy_lfr_b_bp_p0);
	123	if (aux > FLOAT_EQUAL_ZERO)
	124	{
	125	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_B_BP_P0+10, sy_lfr_b_bp_p0 );
	126	flag = LFR_DEFAULT;
	127	}
	128	}
	129
	130	// SET HTE PARAMETERS
	131	if (flag == LFR_SUCCESSFUL)
	132	{
	133	flag = set_sy_lfr_b_bp_p0( TC );
	134	flag = set_sy_lfr_b_bp_p1( TC );
	135	}
	136
	137	return flag;
	138	}
	139
	140	int action_load_sbm1_par(ccsdsTelecommandPacket_t TC, rtems_id queue_id, unsigned char time)
	141	{
	142	/** This function updates the LFR registers with the incoming sbm1 parameters.
	143	*
	144	* @param TC points to the TeleCommand packet that is being processed
	145	* @param queue_id is the id of the queue which handles TM related to this execution step
	146	*
	147	*/
	148
	149	int flag;
	150	rtems_status_code status;
	151	unsigned char sy_lfr_s1_bp_p0;
	152	unsigned char sy_lfr_s1_bp_p1;
	153	float aux;
	154
	155	flag = LFR_SUCCESSFUL;
	156
	157	if ( lfrCurrentMode == LFR_MODE_SBM1 ) {
	158	status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
	159	flag = LFR_DEFAULT;
	160	}
	161
	162	sy_lfr_s1_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P0 ];
	163	sy_lfr_s1_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P1 ];
	164
	165	// sy_lfr_s1_bp_p0
	166	if (flag == LFR_SUCCESSFUL)
	167	{
	168	if (sy_lfr_s1_bp_p0 < DEFAULT_SY_LFR_S1_BP_P0 )
	169	{
	170	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P0+10, sy_lfr_s1_bp_p0 );
	171	flag = WRONG_APP_DATA;
	172	}
	173	}
	174	// sy_lfr_s1_bp_p1
	175	if (flag == LFR_SUCCESSFUL)
	176	{
	177	if (sy_lfr_s1_bp_p1 < DEFAULT_SY_LFR_S1_BP_P1 )
	178	{
	179	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P1+10, sy_lfr_s1_bp_p1 );
	180	flag = WRONG_APP_DATA;
	181	}
	182	}
	183	//******************************************************************
	184	// check the consistency between sy_lfr_s1_bp_p0 and sy_lfr_s1_bp_p1
	185	if (flag == LFR_SUCCESSFUL)
	186	{
	187	aux = ( (float ) sy_lfr_s1_bp_p1 / (sy_lfr_s1_bp_p00.25) ) - floor(sy_lfr_s1_bp_p1 / (sy_lfr_s1_bp_p00.25));
	188	if (aux > FLOAT_EQUAL_ZERO)
	189	{
	190	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S1_BP_P0+10, sy_lfr_s1_bp_p0 );
	191	flag = LFR_DEFAULT;
	192	}
	193	}
	194
	195	// SET THE PARAMETERS
	196	if (flag == LFR_SUCCESSFUL)
	197	{
	198	flag = set_sy_lfr_s1_bp_p0( TC );
	199	flag = set_sy_lfr_s1_bp_p1( TC );
	200	}
	201
	202	return flag;
	203	}
	204
	205	int action_load_sbm2_par(ccsdsTelecommandPacket_t TC, rtems_id queue_id, unsigned char time)
	206	{
	207	/** This function updates the LFR registers with the incoming sbm2 parameters.
	208	*
	209	* @param TC points to the TeleCommand packet that is being processed
	210	* @param queue_id is the id of the queue which handles TM related to this execution step
	211	*
	212	*/
	213
	214	int flag;
	215	rtems_status_code status;
	216	unsigned char sy_lfr_s2_bp_p0;
	217	unsigned char sy_lfr_s2_bp_p1;
	218	float aux;
	219
	220	flag = LFR_SUCCESSFUL;
	221
	222	if ( lfrCurrentMode == LFR_MODE_SBM2 ) {
	223	status = send_tm_lfr_tc_exe_not_executable( TC, queue_id );
	224	flag = LFR_DEFAULT;
	225	}
	226
	227	sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ];
	228	sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ];
	229
	230	// sy_lfr_s2_bp_p0
	231	if (flag == LFR_SUCCESSFUL)
	232	{
	233	if (sy_lfr_s2_bp_p0 < DEFAULT_SY_LFR_S2_BP_P0 )
	234	{
	235	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P0+10, sy_lfr_s2_bp_p0 );
	236	flag = WRONG_APP_DATA;
	237	}
	238	}
	239	// sy_lfr_s2_bp_p1
	240	if (flag == LFR_SUCCESSFUL)
	241	{
	242	if (sy_lfr_s2_bp_p1 < DEFAULT_SY_LFR_S2_BP_P1 )
	243	{
	244	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P1+10, sy_lfr_s2_bp_p1 );
	245	flag = WRONG_APP_DATA;
	246	}
	247	}
	248	//******************************************************************
	249	// check the consistency between sy_lfr_s2_bp_p0 and sy_lfr_s2_bp_p1
	250	if (flag == LFR_SUCCESSFUL)
	251	{
	252	sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ];
	253	sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ];
	254	aux = ( (float ) sy_lfr_s2_bp_p1 / sy_lfr_s2_bp_p0 ) - floor(sy_lfr_s2_bp_p1 / sy_lfr_s2_bp_p0);
	255	if (aux > FLOAT_EQUAL_ZERO)
	256	{
	257	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_S2_BP_P0+10, sy_lfr_s2_bp_p0 );
	258	flag = LFR_DEFAULT;
	259	}
	260	}
	261
	262	// SET THE PARAMETERS
	263	if (flag == LFR_SUCCESSFUL)
	264	{
	265	flag = set_sy_lfr_s2_bp_p0( TC );
	266	flag = set_sy_lfr_s2_bp_p1( TC );
	267	}
	268
	269	return flag;
	270	}
	271
	272	int action_dump_par( rtems_id queue_id )
	273	{
	274	/** This function dumps the LFR parameters by sending the appropriate TM packet to the dedicated RTEMS message queue.
	275	*
	276	* @param queue_id is the id of the queue which handles TM related to this execution step.
	277	*
	278	* @return RTEMS directive status codes:
	279	* - RTEMS_SUCCESSFUL - message sent successfully
	280	* - RTEMS_INVALID_ID - invalid queue id
	281	* - RTEMS_INVALID_SIZE - invalid message size
	282	* - RTEMS_INVALID_ADDRESS - buffer is NULL
	283	* - RTEMS_UNSATISFIED - out of message buffers
	284	* - RTEMS_TOO_MANY - queue s limit has been reached
	285	*
	286	*/
	287
	288	int status;
	289
	290	// UPDATE TIME
	291	parameter_dump_packet.packetSequenceControl[0] = (unsigned char) (sequenceCounterParameterDump >> 8);
	292	parameter_dump_packet.packetSequenceControl[1] = (unsigned char) (sequenceCounterParameterDump );
	293	increment_seq_counter( &sequenceCounterParameterDump );
	294
	295	parameter_dump_packet.time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
	296	parameter_dump_packet.time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
	297	parameter_dump_packet.time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
	298	parameter_dump_packet.time[3] = (unsigned char) (time_management_regs->coarse_time);
	299	parameter_dump_packet.time[4] = (unsigned char) (time_management_regs->fine_time>>8);
	300	parameter_dump_packet.time[5] = (unsigned char) (time_management_regs->fine_time);
	301	// SEND DATA
	302	status = rtems_message_queue_send( queue_id, &parameter_dump_packet,
	303	PACKET_LENGTH_PARAMETER_DUMP + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES);
	304	if (status != RTEMS_SUCCESSFUL) {
	305	PRINTF1("in action_dump *** ERR sending packet, code %d", status)
	306	}
	307
	308	return status;
	309	}
	310
	311	//***********************
	312	// NORMAL MODE PARAMETERS
	313
	314	int check_common_par_consistency( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
	315	{
	316	unsigned char msb;
	317	unsigned char lsb;
	318	int flag;
	319	float aux;
	320	rtems_status_code status;
	321
	322	unsigned int sy_lfr_n_swf_l;
	323	unsigned int sy_lfr_n_swf_p;
	324	unsigned int sy_lfr_n_asm_p;
	325	unsigned char sy_lfr_n_bp_p0;
	326	unsigned char sy_lfr_n_bp_p1;
	327	unsigned char sy_lfr_n_cwf_long_f3;
	328
	329	flag = LFR_SUCCESSFUL;
	330
	331	//***************
	332	// get parameters
	333	msb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L ];
	334	lsb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L+1 ];
	335	sy_lfr_n_swf_l = msb * 256 + lsb;
	336
	337	msb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P ];
	338	lsb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P+1 ];
	339	sy_lfr_n_swf_p = msb * 256 + lsb;
	340
	341	msb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P ];
	342	lsb = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P+1 ];
	343	sy_lfr_n_asm_p = msb * 256 + lsb;
	344
	345	sy_lfr_n_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P0 ];
	346
	347	sy_lfr_n_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P1 ];
	348
	349	sy_lfr_n_cwf_long_f3 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_CWF_LONG_F3 ];
	350
	351	//******************
	352	// check consistency
	353	// sy_lfr_n_swf_l
	354	if (sy_lfr_n_swf_l != 2048)
	355	{
	356	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_SWF_L+10, sy_lfr_n_swf_l );
	357	flag = WRONG_APP_DATA;
	358	}
	359	// sy_lfr_n_swf_p
	360	if (flag == LFR_SUCCESSFUL)
	361	{
	362	if ( sy_lfr_n_swf_p < 16 )
	363	{
	364	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_SWF_P+10, sy_lfr_n_swf_p );
	365	flag = WRONG_APP_DATA;
	366	}
	367	}
	368	// sy_lfr_n_bp_p0
	369	if (flag == LFR_SUCCESSFUL)
	370	{
	371	if (sy_lfr_n_bp_p0 < DFLT_SY_LFR_N_BP_P0)
	372	{
	373	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P0+10, sy_lfr_n_bp_p0 );
	374	flag = WRONG_APP_DATA;
	375	}
	376	}
	377	// sy_lfr_n_asm_p
	378	if (flag == LFR_SUCCESSFUL)
	379	{
	380	if (sy_lfr_n_asm_p == 0)
	381	{
	382	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_ASM_P+10, sy_lfr_n_asm_p );
	383	flag = WRONG_APP_DATA;
	384	}
	385	}
	386	// sy_lfr_n_asm_p shall be a whole multiple of sy_lfr_n_bp_p0
	387	if (flag == LFR_SUCCESSFUL)
	388	{
	389	aux = ( (float ) sy_lfr_n_asm_p / sy_lfr_n_bp_p0 ) - floor(sy_lfr_n_asm_p / sy_lfr_n_bp_p0);
	390	if (aux > FLOAT_EQUAL_ZERO)
	391	{
	392	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_ASM_P+10, sy_lfr_n_asm_p );
	393	flag = WRONG_APP_DATA;
	394	}
	395	}
	396	// sy_lfr_n_bp_p1
	397	if (flag == LFR_SUCCESSFUL)
	398	{
	399	if (sy_lfr_n_bp_p1 < DFLT_SY_LFR_N_BP_P1)
	400	{
	401	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P1+10, sy_lfr_n_bp_p1 );
	402	flag = WRONG_APP_DATA;
	403	}
	404	}
	405	// sy_lfr_n_bp_p1 shall be a whole multiple of sy_lfr_n_bp_p0
	406	if (flag == LFR_SUCCESSFUL)
	407	{
	408	aux = ( (float ) sy_lfr_n_bp_p1 / sy_lfr_n_bp_p0 ) - floor(sy_lfr_n_bp_p1 / sy_lfr_n_bp_p0);
	409	if (aux > FLOAT_EQUAL_ZERO)
	410	{
	411	status = send_tm_lfr_tc_exe_inconsistent( TC, queue_id, DATAFIELD_POS_SY_LFR_N_BP_P1+10, sy_lfr_n_bp_p1 );
	412	flag = LFR_DEFAULT;
	413	}
	414	}
	415	// sy_lfr_n_cwf_long_f3
	416
	417	return flag;
	418	}
	419
	420	int set_sy_lfr_n_swf_l( ccsdsTelecommandPacket_t *TC )
	421	{
	422	/** This function sets the number of points of a snapshot (sy_lfr_n_swf_l).
	423	*
	424	* @param TC points to the TeleCommand packet that is being processed
	425	* @param queue_id is the id of the queue which handles TM related to this execution step
	426	*
	427	*/
	428
	429	int result;
	430
	431	result = LFR_SUCCESSFUL;
	432
	433	parameter_dump_packet.sy_lfr_n_swf_l[0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L ];
	434	parameter_dump_packet.sy_lfr_n_swf_l[1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_L+1 ];
	435
	436	return result;
	437	}
	438
	439	int set_sy_lfr_n_swf_p(ccsdsTelecommandPacket_t *TC )
	440	{
	441	/** This function sets the time between two snapshots, in s (sy_lfr_n_swf_p).
	442	*
	443	* @param TC points to the TeleCommand packet that is being processed
	444	* @param queue_id is the id of the queue which handles TM related to this execution step
	445	*
	446	*/
	447
	448	int result;
	449
	450	result = LFR_SUCCESSFUL;
	451
	452	parameter_dump_packet.sy_lfr_n_swf_p[0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P ];
	453	parameter_dump_packet.sy_lfr_n_swf_p[1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_SWF_P+1 ];
	454
	455	return result;
	456	}
	457
	458	int set_sy_lfr_n_asm_p( ccsdsTelecommandPacket_t *TC )
	459	{
	460	/** This function sets the time between two full spectral matrices transmission, in s (SY_LFR_N_ASM_P).
	461	*
	462	* @param TC points to the TeleCommand packet that is being processed
	463	* @param queue_id is the id of the queue which handles TM related to this execution step
	464	*
	465	*/
	466
	467	int result;
	468
	469	result = LFR_SUCCESSFUL;
	470
	471	parameter_dump_packet.sy_lfr_n_asm_p[0] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P ];
	472	parameter_dump_packet.sy_lfr_n_asm_p[1] = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_ASM_P+1 ];
	473
	474	return result;
	475	}
	476
	477	int set_sy_lfr_n_bp_p0( ccsdsTelecommandPacket_t *TC )
	478	{
	479	/** This function sets the time between two basic parameter sets, in s (DFLT_SY_LFR_N_BP_P0).
	480	*
	481	* @param TC points to the TeleCommand packet that is being processed
	482	* @param queue_id is the id of the queue which handles TM related to this execution step
	483	*
	484	*/
	485
	486	int status;
	487
	488	status = LFR_SUCCESSFUL;
	489
	490	parameter_dump_packet.sy_lfr_n_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P0 ];
	491
	492	return status;
	493	}
	494
	495	int set_sy_lfr_n_bp_p1(ccsdsTelecommandPacket_t *TC )
	496	{
	497	/** This function sets the time between two basic parameter sets (autocorrelation + crosscorrelation), in s (sy_lfr_n_bp_p1).
	498	*
	499	* @param TC points to the TeleCommand packet that is being processed
	500	* @param queue_id is the id of the queue which handles TM related to this execution step
	501	*
	502	*/
	503
	504	int status;
	505
	506	status = LFR_SUCCESSFUL;
	507
	508	parameter_dump_packet.sy_lfr_n_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_BP_P1 ];
	509
	510	return status;
	511	}
	512
	513	int set_sy_lfr_n_cwf_long_f3(ccsdsTelecommandPacket_t *TC )
	514	{
	515	/** This function allows to switch from CWF_F3 packets to CWF_LONG_F3 packets.
	516	*
	517	* @param TC points to the TeleCommand packet that is being processed
	518	* @param queue_id is the id of the queue which handles TM related to this execution step
	519	*
	520	*/
	521
	522	int status;
	523
	524	status = LFR_SUCCESSFUL;
	525
	526	parameter_dump_packet.sy_lfr_n_cwf_long_f3 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_N_CWF_LONG_F3 ];
	527
	528	return status;
	529	}
	530
	531	//**********************
	532	// BURST MODE PARAMETERS
	533	int set_sy_lfr_b_bp_p0(ccsdsTelecommandPacket_t *TC)
	534	{
	535	/** This function sets the time between two basic parameter sets, in s (SY_LFR_B_BP_P0).
	536	*
	537	* @param TC points to the TeleCommand packet that is being processed
	538	* @param queue_id is the id of the queue which handles TM related to this execution step
	539	*
	540	*/
	541
	542	int status;
	543
	544	status = LFR_SUCCESSFUL;
	545
	546	parameter_dump_packet.sy_lfr_b_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P0 ];
	547
	548	return status;
	549	}
	550
	551	int set_sy_lfr_b_bp_p1( ccsdsTelecommandPacket_t *TC )
	552	{
	553	/** This function sets the time between two basic parameter sets, in s (SY_LFR_B_BP_P1).
	554	*
	555	* @param TC points to the TeleCommand packet that is being processed
	556	* @param queue_id is the id of the queue which handles TM related to this execution step
	557	*
	558	*/
	559
	560	int status;
	561
	562	status = LFR_SUCCESSFUL;
	563
	564	parameter_dump_packet.sy_lfr_b_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_B_BP_P1 ];
	565
	566	return status;
	567	}
	568
	569	//*********************
	570	// SBM1 MODE PARAMETERS
	571	int set_sy_lfr_s1_bp_p0( ccsdsTelecommandPacket_t *TC )
	572	{
	573	/** This function sets the time between two basic parameter sets, in s (SY_LFR_S1_BP_P0).
	574	*
	575	* @param TC points to the TeleCommand packet that is being processed
	576	* @param queue_id is the id of the queue which handles TM related to this execution step
	577	*
	578	*/
	579
	580	int status;
	581
	582	status = LFR_SUCCESSFUL;
	583
	584	parameter_dump_packet.sy_lfr_s1_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P0 ];
	585
	586	return status;
	587	}
	588
	589	int set_sy_lfr_s1_bp_p1( ccsdsTelecommandPacket_t *TC )
	590	{
	591	/** This function sets the time between two basic parameter sets, in s (SY_LFR_S1_BP_P1).
	592	*
	593	* @param TC points to the TeleCommand packet that is being processed
	594	* @param queue_id is the id of the queue which handles TM related to this execution step
	595	*
	596	*/
	597
	598	int status;
	599
	600	status = LFR_SUCCESSFUL;
	601
	602	parameter_dump_packet.sy_lfr_s1_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S1_BP_P1 ];
	603
	604	return status;
	605	}
	606
	607	//*********************
	608	// SBM2 MODE PARAMETERS
	609	int set_sy_lfr_s2_bp_p0(ccsdsTelecommandPacket_t *TC)
	610	{
	611	/** This function sets the time between two basic parameter sets, in s (SY_LFR_S2_BP_P0).
	612	*
	613	* @param TC points to the TeleCommand packet that is being processed
	614	* @param queue_id is the id of the queue which handles TM related to this execution step
	615	*
	616	*/
	617
	618	int status;
	619
	620	status = LFR_SUCCESSFUL;
	621
	622	parameter_dump_packet.sy_lfr_s2_bp_p0 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P0 ];
	623
	624	return status;
	625	}
	626
	627	int set_sy_lfr_s2_bp_p1( ccsdsTelecommandPacket_t *TC )
	628	{
	629	/** This function sets the time between two basic parameter sets, in s (SY_LFR_S2_BP_P1).
	630	*
	631	* @param TC points to the TeleCommand packet that is being processed
	632	* @param queue_id is the id of the queue which handles TM related to this execution step
	633	*
	634	*/
	635
	636	int status;
	637
	638	status = LFR_SUCCESSFUL;
	639
	640	parameter_dump_packet.sy_lfr_s2_bp_p1 = TC->dataAndCRC[ DATAFIELD_POS_SY_LFR_S2_BP_P1 ];
	641
	642	return status;
	643	}
	644
	645
	646	//*******************
	647	// TC_LFR_UPDATE_INFO
	648	unsigned int check_update_info_hk_lfr_mode( unsigned char mode )
	649	{
	650	unsigned int status;
	651
	652	if ( (mode == LFR_MODE_STANDBY) \|\| (mode == LFR_MODE_NORMAL)
	653	\|\| (mode == LFR_MODE_BURST)
	654	\|\| (mode == LFR_MODE_SBM1) \|\| (mode == LFR_MODE_SBM2))
	655	{
	656	status = LFR_SUCCESSFUL;
	657	}
	658	else
	659	{
	660	status = LFR_DEFAULT;
	661	}
	662
	663	return status;
	664	}
	665
	666	unsigned int check_update_info_hk_tds_mode( unsigned char mode )
	667	{
	668	unsigned int status;
	669
	670	if ( (mode == TDS_MODE_STANDBY) \|\| (mode == TDS_MODE_NORMAL)
	671	\|\| (mode == TDS_MODE_BURST)
	672	\|\| (mode == TDS_MODE_SBM1) \|\| (mode == TDS_MODE_SBM2)
	673	\|\| (mode == TDS_MODE_LFM))
	674	{
	675	status = LFR_SUCCESSFUL;
	676	}
	677	else
	678	{
	679	status = LFR_DEFAULT;
	680	}
	681
	682	return status;
	683	}
	684
	685	unsigned int check_update_info_hk_thr_mode( unsigned char mode )
	686	{
	687	unsigned int status;
	688
	689	if ( (mode == THR_MODE_STANDBY) \|\| (mode == THR_MODE_NORMAL)
	690	\|\| (mode == THR_MODE_BURST))
	691	{
	692	status = LFR_SUCCESSFUL;
	693	}
	694	else
	695	{
	696	status = LFR_DEFAULT;
	697	}
	698
	699	return status;
	700	}
	701
	702	//**********
	703	// init dump
	704
	705	void init_parameter_dump( void )
	706	{
	707	/** This function initialize the parameter_dump_packet global variable with default values.
	708	*
	709	*/
	710
	711	parameter_dump_packet.targetLogicalAddress = CCSDS_DESTINATION_ID;
	712	parameter_dump_packet.protocolIdentifier = CCSDS_PROTOCOLE_ID;
	713	parameter_dump_packet.reserved = CCSDS_RESERVED;
	714	parameter_dump_packet.userApplication = CCSDS_USER_APP;
	715	parameter_dump_packet.packetID[0] = (unsigned char) (APID_TM_PARAMETER_DUMP >> 8);
	716	parameter_dump_packet.packetID[1] = (unsigned char) APID_TM_PARAMETER_DUMP;
	717	parameter_dump_packet.packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
	718	parameter_dump_packet.packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
	719	parameter_dump_packet.packetLength[0] = (unsigned char) (PACKET_LENGTH_PARAMETER_DUMP >> 8);
	720	parameter_dump_packet.packetLength[1] = (unsigned char) PACKET_LENGTH_PARAMETER_DUMP;
	721	// DATA FIELD HEADER
	722	parameter_dump_packet.spare1_pusVersion_spare2 = SPARE1_PUSVERSION_SPARE2;
	723	parameter_dump_packet.serviceType = TM_TYPE_PARAMETER_DUMP;
	724	parameter_dump_packet.serviceSubType = TM_SUBTYPE_PARAMETER_DUMP;
	725	parameter_dump_packet.destinationID = TM_DESTINATION_ID_GROUND;
	726	parameter_dump_packet.time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
	727	parameter_dump_packet.time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
	728	parameter_dump_packet.time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
	729	parameter_dump_packet.time[3] = (unsigned char) (time_management_regs->coarse_time);
	730	parameter_dump_packet.time[4] = (unsigned char) (time_management_regs->fine_time>>8);
	731	parameter_dump_packet.time[5] = (unsigned char) (time_management_regs->fine_time);
	732	parameter_dump_packet.sid = SID_PARAMETER_DUMP;
	733
	734	//******************
	735	// COMMON PARAMETERS
	736	parameter_dump_packet.unused0 = DEFAULT_SY_LFR_COMMON0;
	737	parameter_dump_packet.bw_sp0_sp1_r0_r1 = DEFAULT_SY_LFR_COMMON1;
	738
	739	//******************
	740	// NORMAL PARAMETERS
	741	parameter_dump_packet.sy_lfr_n_swf_l[0] = (unsigned char) (DFLT_SY_LFR_N_SWF_L >> 8);
	742	parameter_dump_packet.sy_lfr_n_swf_l[1] = (unsigned char) (DFLT_SY_LFR_N_SWF_L );
	743	parameter_dump_packet.sy_lfr_n_swf_p[0] = (unsigned char) (DFLT_SY_LFR_N_SWF_P >> 8);
	744	parameter_dump_packet.sy_lfr_n_swf_p[1] = (unsigned char) (DFLT_SY_LFR_N_SWF_P );
	745	parameter_dump_packet.sy_lfr_n_asm_p[0] = (unsigned char) (DFLT_SY_LFR_N_ASM_P >> 8);
	746	parameter_dump_packet.sy_lfr_n_asm_p[1] = (unsigned char) (DFLT_SY_LFR_N_ASM_P );
	747	parameter_dump_packet.sy_lfr_n_bp_p0 = (unsigned char) DFLT_SY_LFR_N_BP_P0;
	748	parameter_dump_packet.sy_lfr_n_bp_p1 = (unsigned char) DFLT_SY_LFR_N_BP_P1;
	749	parameter_dump_packet.sy_lfr_n_cwf_long_f3 = (unsigned char) DFLT_SY_LFR_N_CWF_LONG_F3;
	750
	751	//*****************
	752	// BURST PARAMETERS
	753	parameter_dump_packet.sy_lfr_b_bp_p0 = (unsigned char) DEFAULT_SY_LFR_B_BP_P0;
	754	parameter_dump_packet.sy_lfr_b_bp_p1 = (unsigned char) DEFAULT_SY_LFR_B_BP_P1;
	755
	756	//****************
	757	// SBM1 PARAMETERS
	758	parameter_dump_packet.sy_lfr_s1_bp_p0 = (unsigned char) DEFAULT_SY_LFR_S1_BP_P0; // min value is 0.25 s for the period
	759	parameter_dump_packet.sy_lfr_s1_bp_p1 = (unsigned char) DEFAULT_SY_LFR_S1_BP_P1;
	760
	761	//****************
	762	// SBM2 PARAMETERS
	763	parameter_dump_packet.sy_lfr_s2_bp_p0 = (unsigned char) DEFAULT_SY_LFR_S2_BP_P0;
	764	parameter_dump_packet.sy_lfr_s2_bp_p1 = (unsigned char) DEFAULT_SY_LFR_S2_BP_P1;
	765	}
	766
	767
	768
	769
	770
	771
	772

timegen/src/tm_lfr_tc_exe.c created 644 +510 0

This diff has been collapsed as it changes many lines, (510 lines changed) Show them Hide them
		@@ -0,0 +1,510
	1	/** Functions to send TM packets related to TC parsing and execution.
	2	*
	3	* @file
	4	* @author P. LEROY
	5	*
	6	* A group of functions to send appropriate TM packets after parsing and execution:
	7	* - TM_LFR_TC_EXE_SUCCESS
	8	* - TM_LFR_TC_EXE_INCONSISTENT
	9	* - TM_LFR_TC_EXE_NOT_EXECUTABLE
	10	* - TM_LFR_TC_EXE_NOT_IMPLEMENTED
	11	* - TM_LFR_TC_EXE_ERROR
	12	* - TM_LFR_TC_EXE_CORRUPTED
	13	*
	14	*/
	15
	16	#include "tm_lfr_tc_exe.h"
	17
	18	int send_tm_lfr_tc_exe_success( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
	19	{
	20	/** This function sends a TM_LFR_TC_EXE_SUCCESS packet in the dedicated RTEMS message queue.
	21	*
	22	* @param TC points to the TeleCommand packet that is being processed
	23	* @param queue_id is the id of the queue which handles TM
	24	*
	25	* @return RTEMS directive status code:
	26	* - RTEMS_SUCCESSFUL - message sent successfully
	27	* - RTEMS_INVALID_ID - invalid queue id
	28	* - RTEMS_INVALID_SIZE - invalid message size
	29	* - RTEMS_INVALID_ADDRESS - buffer is NULL
	30	* - RTEMS_UNSATISFIED - out of message buffers
	31	* - RTEMS_TOO_MANY - queue s limit has been reached
	32	*
	33	*/
	34
	35	rtems_status_code status;
	36	Packet_TM_LFR_TC_EXE_SUCCESS_t TM;
	37	unsigned char messageSize;
	38
	39	TM.targetLogicalAddress = CCSDS_DESTINATION_ID;
	40	TM.protocolIdentifier = CCSDS_PROTOCOLE_ID;
	41	TM.reserved = DEFAULT_RESERVED;
	42	TM.userApplication = CCSDS_USER_APP;
	43	// PACKET HEADER
	44	TM.packetID[0] = (unsigned char) (APID_TM_TC_EXE >> 8);
	45	TM.packetID[1] = (unsigned char) (APID_TM_TC_EXE );
	46	increment_seq_counter_destination_id( TM.packetSequenceControl, TC->sourceID );
	47	TM.packetLength[0] = (unsigned char) (PACKET_LENGTH_TC_EXE_SUCCESS >> 8);
	48	TM.packetLength[1] = (unsigned char) (PACKET_LENGTH_TC_EXE_SUCCESS );
	49	// DATA FIELD HEADER
	50	TM.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
	51	TM.serviceType = TM_TYPE_TC_EXE;
	52	TM.serviceSubType = TM_SUBTYPE_EXE_OK;
	53	TM.destinationID = TC->sourceID;
	54	TM.time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
	55	TM.time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
	56	TM.time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
	57	TM.time[3] = (unsigned char) (time_management_regs->coarse_time);
	58	TM.time[4] = (unsigned char) (time_management_regs->fine_time>>8);
	59	TM.time[5] = (unsigned char) (time_management_regs->fine_time);
	60	//
	61	TM.telecommand_pkt_id[0] = TC->packetID[0];
	62	TM.telecommand_pkt_id[1] = TC->packetID[1];
	63	TM.pkt_seq_control[0] = TC->packetSequenceControl[0];
	64	TM.pkt_seq_control[1] = TC->packetSequenceControl[1];
	65
	66	messageSize = PACKET_LENGTH_TC_EXE_SUCCESS + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES;
	67
	68	// SEND DATA
	69	status = rtems_message_queue_send( queue_id, &TM, messageSize);
	70	if (status != RTEMS_SUCCESSFUL) {
	71	PRINTF("in send_tm_lfr_tc_exe_success *** ERR\n")
	72	}
	73
	74	// UPDATE HK FIELDS
	75	update_last_TC_exe( TC, TM.time );
	76
	77	return status;
	78	}
	79
	80	int send_tm_lfr_tc_exe_inconsistent( ccsdsTelecommandPacket_t *TC, rtems_id queue_id,
	81	unsigned char byte_position, unsigned char rcv_value )
	82	{
	83	/** This function sends a TM_LFR_TC_EXE_INCONSISTENT packet in the dedicated RTEMS message queue.
	84	*
	85	* @param TC points to the TeleCommand packet that is being processed
	86	* @param queue_id is the id of the queue which handles TM
	87	* @param byte_position is the byte position of the MSB of the parameter that has been seen as inconsistent
	88	* @param rcv_value is the value of the LSB of the parameter that has been deteced as inconsistent
	89	*
	90	* @return RTEMS directive status code:
	91	* - RTEMS_SUCCESSFUL - message sent successfully
	92	* - RTEMS_INVALID_ID - invalid queue id
	93	* - RTEMS_INVALID_SIZE - invalid message size
	94	* - RTEMS_INVALID_ADDRESS - buffer is NULL
	95	* - RTEMS_UNSATISFIED - out of message buffers
	96	* - RTEMS_TOO_MANY - queue s limit has been reached
	97	*
	98	*/
	99
	100	rtems_status_code status;
	101	Packet_TM_LFR_TC_EXE_INCONSISTENT_t TM;
	102	unsigned char messageSize;
	103
	104	TM.targetLogicalAddress = CCSDS_DESTINATION_ID;
	105	TM.protocolIdentifier = CCSDS_PROTOCOLE_ID;
	106	TM.reserved = DEFAULT_RESERVED;
	107	TM.userApplication = CCSDS_USER_APP;
	108	// PACKET HEADER
	109	TM.packetID[0] = (unsigned char) (APID_TM_TC_EXE >> 8);
	110	TM.packetID[1] = (unsigned char) (APID_TM_TC_EXE );
	111	increment_seq_counter_destination_id( TM.packetSequenceControl, TC->sourceID );
	112	TM.packetLength[0] = (unsigned char) (PACKET_LENGTH_TC_EXE_INCONSISTENT >> 8);
	113	TM.packetLength[1] = (unsigned char) (PACKET_LENGTH_TC_EXE_INCONSISTENT );
	114	// DATA FIELD HEADER
	115	TM.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
	116	TM.serviceType = TM_TYPE_TC_EXE;
	117	TM.serviceSubType = TM_SUBTYPE_EXE_NOK;
	118	TM.destinationID = TC->sourceID;
	119	TM.time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
	120	TM.time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
	121	TM.time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
	122	TM.time[3] = (unsigned char) (time_management_regs->coarse_time);
	123	TM.time[4] = (unsigned char) (time_management_regs->fine_time>>8);
	124	TM.time[5] = (unsigned char) (time_management_regs->fine_time);
	125	//
	126	TM.tc_failure_code[0] = (char) (WRONG_APP_DATA >> 8);
	127	TM.tc_failure_code[1] = (char) (WRONG_APP_DATA );
	128	TM.telecommand_pkt_id[0] = TC->packetID[0];
	129	TM.telecommand_pkt_id[1] = TC->packetID[1];
	130	TM.pkt_seq_control[0] = TC->packetSequenceControl[0];
	131	TM.pkt_seq_control[1] = TC->packetSequenceControl[1];
	132	TM.tc_service = TC->serviceType; // type of the rejected TC
	133	TM.tc_subtype = TC->serviceSubType; // subtype of the rejected TC
	134	TM.byte_position = byte_position;
	135	TM.rcv_value = (unsigned char) rcv_value;
	136
	137	messageSize = PACKET_LENGTH_TC_EXE_INCONSISTENT + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES;
	138
	139	// SEND DATA
	140	status = rtems_message_queue_send( queue_id, &TM, messageSize);
	141	if (status != RTEMS_SUCCESSFUL) {
	142	PRINTF("in send_tm_lfr_tc_exe_inconsistent *** ERR\n")
	143	}
	144
	145	// UPDATE HK FIELDS
	146	update_last_TC_rej( TC, TM.time );
	147
	148	return status;
	149	}
	150
	151	int send_tm_lfr_tc_exe_not_executable( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
	152	{
	153	/** This function sends a TM_LFR_TC_EXE_NOT_EXECUTABLE packet in the dedicated RTEMS message queue.
	154	*
	155	* @param TC points to the TeleCommand packet that is being processed
	156	* @param queue_id is the id of the queue which handles TM
	157	*
	158	* @return RTEMS directive status code:
	159	* - RTEMS_SUCCESSFUL - message sent successfully
	160	* - RTEMS_INVALID_ID - invalid queue id
	161	* - RTEMS_INVALID_SIZE - invalid message size
	162	* - RTEMS_INVALID_ADDRESS - buffer is NULL
	163	* - RTEMS_UNSATISFIED - out of message buffers
	164	* - RTEMS_TOO_MANY - queue s limit has been reached
	165	*
	166	*/
	167
	168	rtems_status_code status;
	169	Packet_TM_LFR_TC_EXE_NOT_EXECUTABLE_t TM;
	170	unsigned char messageSize;
	171
	172	TM.targetLogicalAddress = CCSDS_DESTINATION_ID;
	173	TM.protocolIdentifier = CCSDS_PROTOCOLE_ID;
	174	TM.reserved = DEFAULT_RESERVED;
	175	TM.userApplication = CCSDS_USER_APP;
	176	// PACKET HEADER
	177	TM.packetID[0] = (unsigned char) (APID_TM_TC_EXE >> 8);
	178	TM.packetID[1] = (unsigned char) (APID_TM_TC_EXE );
	179	increment_seq_counter_destination_id( TM.packetSequenceControl, TC->sourceID );
	180	TM.packetLength[0] = (unsigned char) (PACKET_LENGTH_TC_EXE_NOT_EXECUTABLE >> 8);
	181	TM.packetLength[1] = (unsigned char) (PACKET_LENGTH_TC_EXE_NOT_EXECUTABLE );
	182	// DATA FIELD HEADER
	183	TM.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
	184	TM.serviceType = TM_TYPE_TC_EXE;
	185	TM.serviceSubType = TM_SUBTYPE_EXE_NOK;
	186	TM.destinationID = TC->sourceID; // default destination id
	187	TM.time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
	188	TM.time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
	189	TM.time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
	190	TM.time[3] = (unsigned char) (time_management_regs->coarse_time);
	191	TM.time[4] = (unsigned char) (time_management_regs->fine_time>>8);
	192	TM.time[5] = (unsigned char) (time_management_regs->fine_time);
	193	//
	194	TM.tc_failure_code[0] = (char) (TC_NOT_EXE >> 8);
	195	TM.tc_failure_code[1] = (char) (TC_NOT_EXE );
	196	TM.telecommand_pkt_id[0] = TC->packetID[0];
	197	TM.telecommand_pkt_id[1] = TC->packetID[1];
	198	TM.pkt_seq_control[0] = TC->packetSequenceControl[0];
	199	TM.pkt_seq_control[1] = TC->packetSequenceControl[1];
	200	TM.tc_service = TC->serviceType; // type of the rejected TC
	201	TM.tc_subtype = TC->serviceSubType; // subtype of the rejected TC
	202	TM.lfr_status_word[0] = housekeeping_packet.lfr_status_word[0];
	203	TM.lfr_status_word[1] = housekeeping_packet.lfr_status_word[1];
	204
	205	messageSize = PACKET_LENGTH_TC_EXE_NOT_EXECUTABLE + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES;
	206
	207	// SEND DATA
	208	status = rtems_message_queue_send( queue_id, &TM, messageSize);
	209	if (status != RTEMS_SUCCESSFUL) {
	210	PRINTF("in send_tm_lfr_tc_exe_not_executable *** ERR\n")
	211	}
	212
	213	// UPDATE HK FIELDS
	214	update_last_TC_rej( TC, TM.time );
	215
	216	return status;
	217	}
	218
	219	int send_tm_lfr_tc_exe_not_implemented( ccsdsTelecommandPacket_t TC, rtems_id queue_id, unsigned char time )
	220	{
	221	/** This function sends a TM_LFR_TC_EXE_NOT_IMPLEMENTED packet in the dedicated RTEMS message queue.
	222	*
	223	* @param TC points to the TeleCommand packet that is being processed
	224	* @param queue_id is the id of the queue which handles TM
	225	*
	226	* @return RTEMS directive status code:
	227	* - RTEMS_SUCCESSFUL - message sent successfully
	228	* - RTEMS_INVALID_ID - invalid queue id
	229	* - RTEMS_INVALID_SIZE - invalid message size
	230	* - RTEMS_INVALID_ADDRESS - buffer is NULL
	231	* - RTEMS_UNSATISFIED - out of message buffers
	232	* - RTEMS_TOO_MANY - queue s limit has been reached
	233	*
	234	*/
	235
	236	rtems_status_code status;
	237	Packet_TM_LFR_TC_EXE_NOT_IMPLEMENTED_t TM;
	238	unsigned char messageSize;
	239
	240	TM.targetLogicalAddress = CCSDS_DESTINATION_ID;
	241	TM.protocolIdentifier = CCSDS_PROTOCOLE_ID;
	242	TM.reserved = DEFAULT_RESERVED;
	243	TM.userApplication = CCSDS_USER_APP;
	244	// PACKET HEADER
	245	TM.packetID[0] = (unsigned char) (APID_TM_TC_EXE >> 8);
	246	TM.packetID[1] = (unsigned char) (APID_TM_TC_EXE );
	247	increment_seq_counter_destination_id( TM.packetSequenceControl, TC->sourceID );
	248	TM.packetLength[0] = (unsigned char) (PACKET_LENGTH_TC_EXE_NOT_IMPLEMENTED >> 8);
	249	TM.packetLength[1] = (unsigned char) (PACKET_LENGTH_TC_EXE_NOT_IMPLEMENTED );
	250	// DATA FIELD HEADER
	251	TM.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
	252	TM.serviceType = TM_TYPE_TC_EXE;
	253	TM.serviceSubType = TM_SUBTYPE_EXE_NOK;
	254	TM.destinationID = TC->sourceID; // default destination id
	255	TM.time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
	256	TM.time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
	257	TM.time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
	258	TM.time[3] = (unsigned char) (time_management_regs->coarse_time);
	259	TM.time[4] = (unsigned char) (time_management_regs->fine_time>>8);
	260	TM.time[5] = (unsigned char) (time_management_regs->fine_time);
	261	//
	262	TM.tc_failure_code[0] = (char) (FUNCT_NOT_IMPL >> 8);
	263	TM.tc_failure_code[1] = (char) (FUNCT_NOT_IMPL );
	264	TM.telecommand_pkt_id[0] = TC->packetID[0];
	265	TM.telecommand_pkt_id[1] = TC->packetID[1];
	266	TM.pkt_seq_control[0] = TC->packetSequenceControl[0];
	267	TM.pkt_seq_control[1] = TC->packetSequenceControl[1];
	268	TM.tc_service = TC->serviceType; // type of the rejected TC
	269	TM.tc_subtype = TC->serviceSubType; // subtype of the rejected TC
	270
	271	messageSize = PACKET_LENGTH_TC_EXE_NOT_IMPLEMENTED + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES;
	272
	273	// SEND DATA
	274	status = rtems_message_queue_send( queue_id, &TM, messageSize);
	275	if (status != RTEMS_SUCCESSFUL) {
	276	PRINTF("in send_tm_lfr_tc_exe_not_implemented *** ERR\n")
	277	}
	278
	279	// UPDATE HK FIELDS
	280	update_last_TC_rej( TC, TM.time );
	281
	282	return status;
	283	}
	284
	285	int send_tm_lfr_tc_exe_error( ccsdsTelecommandPacket_t *TC, rtems_id queue_id )
	286	{
	287	/** This function sends a TM_LFR_TC_EXE_ERROR packet in the dedicated RTEMS message queue.
	288	*
	289	* @param TC points to the TeleCommand packet that is being processed
	290	* @param queue_id is the id of the queue which handles TM
	291	*
	292	* @return RTEMS directive status code:
	293	* - RTEMS_SUCCESSFUL - message sent successfully
	294	* - RTEMS_INVALID_ID - invalid queue id
	295	* - RTEMS_INVALID_SIZE - invalid message size
	296	* - RTEMS_INVALID_ADDRESS - buffer is NULL
	297	* - RTEMS_UNSATISFIED - out of message buffers
	298	* - RTEMS_TOO_MANY - queue s limit has been reached
	299	*
	300	*/
	301
	302	rtems_status_code status;
	303	Packet_TM_LFR_TC_EXE_ERROR_t TM;
	304	unsigned char messageSize;
	305
	306	TM.targetLogicalAddress = CCSDS_DESTINATION_ID;
	307	TM.protocolIdentifier = CCSDS_PROTOCOLE_ID;
	308	TM.reserved = DEFAULT_RESERVED;
	309	TM.userApplication = CCSDS_USER_APP;
	310	// PACKET HEADER
	311	TM.packetID[0] = (unsigned char) (APID_TM_TC_EXE >> 8);
	312	TM.packetID[1] = (unsigned char) (APID_TM_TC_EXE );
	313	increment_seq_counter_destination_id( TM.packetSequenceControl, TC->sourceID );
	314	TM.packetLength[0] = (unsigned char) (PACKET_LENGTH_TC_EXE_ERROR >> 8);
	315	TM.packetLength[1] = (unsigned char) (PACKET_LENGTH_TC_EXE_ERROR );
	316	// DATA FIELD HEADER
	317	TM.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
	318	TM.serviceType = TM_TYPE_TC_EXE;
	319	TM.serviceSubType = TM_SUBTYPE_EXE_NOK;
	320	TM.destinationID = TC->sourceID; // default destination id
	321	TM.time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
	322	TM.time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
	323	TM.time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
	324	TM.time[3] = (unsigned char) (time_management_regs->coarse_time);
	325	TM.time[4] = (unsigned char) (time_management_regs->fine_time>>8);
	326	TM.time[5] = (unsigned char) (time_management_regs->fine_time);
	327	//
	328	TM.tc_failure_code[0] = (char) (FAIL_DETECTED >> 8);
	329	TM.tc_failure_code[1] = (char) (FAIL_DETECTED );
	330	TM.telecommand_pkt_id[0] = TC->packetID[0];
	331	TM.telecommand_pkt_id[1] = TC->packetID[1];
	332	TM.pkt_seq_control[0] = TC->packetSequenceControl[0];
	333	TM.pkt_seq_control[1] = TC->packetSequenceControl[1];
	334	TM.tc_service = TC->serviceType; // type of the rejected TC
	335	TM.tc_subtype = TC->serviceSubType; // subtype of the rejected TC
	336
	337	messageSize = PACKET_LENGTH_TC_EXE_ERROR + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES;
	338
	339	// SEND DATA
	340	status = rtems_message_queue_send( queue_id, &TM, messageSize);
	341	if (status != RTEMS_SUCCESSFUL) {
	342	PRINTF("in send_tm_lfr_tc_exe_error *** ERR\n")
	343	}
	344
	345	// UPDATE HK FIELDS
	346	update_last_TC_rej( TC, TM.time );
	347
	348	return status;
	349	}
	350
	351	int send_tm_lfr_tc_exe_corrupted(ccsdsTelecommandPacket_t *TC, rtems_id queue_id,
	352	unsigned char computed_CRC, unsigned char currentTC_LEN_RCV,
	353	unsigned char destinationID )
	354	{
	355	/** This function sends a TM_LFR_TC_EXE_CORRUPTED packet in the dedicated RTEMS message queue.
	356	*
	357	* @param TC points to the TeleCommand packet that is being processed
	358	* @param queue_id is the id of the queue which handles TM
	359	* @param computed_CRC points to a buffer of two bytes containing the CRC computed during the parsing of the TeleCommand
	360	* @param currentTC_LEN_RCV points to a buffer of two bytes containing a packet size field computed on the received data
	361	*
	362	* @return RTEMS directive status code:
	363	* - RTEMS_SUCCESSFUL - message sent successfully
	364	* - RTEMS_INVALID_ID - invalid queue id
	365	* - RTEMS_INVALID_SIZE - invalid message size
	366	* - RTEMS_INVALID_ADDRESS - buffer is NULL
	367	* - RTEMS_UNSATISFIED - out of message buffers
	368	* - RTEMS_TOO_MANY - queue s limit has been reached
	369	*
	370	*/
	371
	372	rtems_status_code status;
	373	Packet_TM_LFR_TC_EXE_CORRUPTED_t TM;
	374	unsigned char messageSize;
	375	unsigned int packetLength;
	376	unsigned char *packetDataField;
	377
	378	packetLength = (TC->packetLength[0] * 256) + TC->packetLength[1]; // compute the packet length parameter
	379	packetDataField = (unsigned char *) &TC->headerFlag_pusVersion_Ack; // get the beginning of the data field
	380
	381	TM.targetLogicalAddress = CCSDS_DESTINATION_ID;
	382	TM.protocolIdentifier = CCSDS_PROTOCOLE_ID;
	383	TM.reserved = DEFAULT_RESERVED;
	384	TM.userApplication = CCSDS_USER_APP;
	385	// PACKET HEADER
	386	TM.packetID[0] = (unsigned char) (APID_TM_TC_EXE >> 8);
	387	TM.packetID[1] = (unsigned char) (APID_TM_TC_EXE );
	388	increment_seq_counter_destination_id( TM.packetSequenceControl, TC->sourceID );
	389	TM.packetLength[0] = (unsigned char) (PACKET_LENGTH_TC_EXE_CORRUPTED >> 8);
	390	TM.packetLength[1] = (unsigned char) (PACKET_LENGTH_TC_EXE_CORRUPTED );
	391	// DATA FIELD HEADER
	392	TM.spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
	393	TM.serviceType = TM_TYPE_TC_EXE;
	394	TM.serviceSubType = TM_SUBTYPE_EXE_NOK;
	395	TM.destinationID = destinationID;
	396	TM.time[0] = (unsigned char) (time_management_regs->coarse_time>>24);
	397	TM.time[1] = (unsigned char) (time_management_regs->coarse_time>>16);
	398	TM.time[2] = (unsigned char) (time_management_regs->coarse_time>>8);
	399	TM.time[3] = (unsigned char) (time_management_regs->coarse_time);
	400	TM.time[4] = (unsigned char) (time_management_regs->fine_time>>8);
	401	TM.time[5] = (unsigned char) (time_management_regs->fine_time);
	402	//
	403	TM.tc_failure_code[0] = (unsigned char) (CORRUPTED >> 8);
	404	TM.tc_failure_code[1] = (unsigned char) (CORRUPTED );
	405	TM.telecommand_pkt_id[0] = TC->packetID[0];
	406	TM.telecommand_pkt_id[1] = TC->packetID[1];
	407	TM.pkt_seq_control[0] = TC->packetSequenceControl[0];
	408	TM.pkt_seq_control[1] = TC->packetSequenceControl[1];
	409	TM.tc_service = TC->serviceType; // type of the rejected TC
	410	TM.tc_subtype = TC->serviceSubType; // subtype of the rejected TC
	411	TM.pkt_len_rcv_value[0] = TC->packetLength[0];
	412	TM.pkt_len_rcv_value[1] = TC->packetLength[1];
	413	TM.pkt_datafieldsize_cnt[0] = currentTC_LEN_RCV[0];
	414	TM.pkt_datafieldsize_cnt[1] = currentTC_LEN_RCV[1];
	415	TM.rcv_crc[0] = packetDataField[ packetLength - 1 ];
	416	TM.rcv_crc[1] = packetDataField[ packetLength ];
	417	TM.computed_crc[0] = computed_CRC[0];
	418	TM.computed_crc[1] = computed_CRC[1];
	419
	420	messageSize = PACKET_LENGTH_TC_EXE_CORRUPTED + CCSDS_TC_TM_PACKET_OFFSET + CCSDS_PROTOCOLE_EXTRA_BYTES;
	421
	422	// SEND DATA
	423	status = rtems_message_queue_send( queue_id, &TM, messageSize);
	424	if (status != RTEMS_SUCCESSFUL) {
	425	PRINTF("in send_tm_lfr_tc_exe_error *** ERR\n")
	426	}
	427
	428	// UPDATE HK FIELDS
	429	update_last_TC_rej( TC, TM.time );
	430
	431	return status;
	432	}
	433
	434	void increment_seq_counter_destination_id( unsigned char *packet_sequence_control, unsigned char destination_id )
	435	{
	436	/** This function increment the packet sequence control parameter of a TC, depending on its destination ID.
	437	*
	438	* @param packet_sequence_control points to the packet sequence control which will be incremented
	439	* @param destination_id is the destination ID of the TM, there is one counter by destination ID
	440	*
	441	* If the destination ID is not known, a dedicated counter is incremented.
	442	*
	443	*/
	444
	445	unsigned short sequence_cnt;
	446	unsigned short segmentation_grouping_flag;
	447	unsigned short new_packet_sequence_control;
	448	unsigned char i;
	449
	450	switch (destination_id)
	451	{
	452	case SID_TC_GROUND:
	453	i = GROUND;
	454	break;
	455	case SID_TC_MISSION_TIMELINE:
	456	i = MISSION_TIMELINE;
	457	break;
	458	case SID_TC_TC_SEQUENCES:
	459	i = TC_SEQUENCES;
	460	break;
	461	case SID_TC_RECOVERY_ACTION_CMD:
	462	i = RECOVERY_ACTION_CMD;
	463	break;
	464	case SID_TC_BACKUP_MISSION_TIMELINE:
	465	i = BACKUP_MISSION_TIMELINE;
	466	break;
	467	case SID_TC_DIRECT_CMD:
	468	i = DIRECT_CMD;
	469	break;
	470	case SID_TC_SPARE_GRD_SRC1:
	471	i = SPARE_GRD_SRC1;
	472	break;
	473	case SID_TC_SPARE_GRD_SRC2:
	474	i = SPARE_GRD_SRC2;
	475	break;
	476	case SID_TC_OBCP:
	477	i = OBCP;
	478	break;
	479	case SID_TC_SYSTEM_CONTROL:
	480	i = SYSTEM_CONTROL;
	481	break;
	482	case SID_TC_AOCS:
	483	i = AOCS;
	484	break;
	485	case SID_TC_RPW_INTERNAL:
	486	i = RPW_INTERNAL;
	487	break;
	488	default:
	489	i = GROUND;
	490	break;
	491	}
	492
	493	segmentation_grouping_flag = TM_PACKET_SEQ_CTRL_STANDALONE << 8;
	494	sequence_cnt = sequenceCounters_TC_EXE[ i ] & 0x3fff;
	495
	496	new_packet_sequence_control = segmentation_grouping_flag \| sequence_cnt ;
	497
	498	packet_sequence_control[0] = (unsigned char) (new_packet_sequence_control >> 8);
	499	packet_sequence_control[1] = (unsigned char) (new_packet_sequence_control );
	500
	501	// increment the sequence counter
	502	if ( sequenceCounters_TC_EXE[ i ] < SEQ_CNT_MAX )
	503	{
	504	sequenceCounters_TC_EXE[ i ] = sequenceCounters_TC_EXE[ i ] + 1;
	505	}
	506	else
	507	{
	508	sequenceCounters_TC_EXE[ i ] = 0;
	509	}
	510	}

timegen/src/wf_handler.c created 644 +1323 0

This diff has been collapsed as it changes many lines, (1323 lines changed) Show them Hide them
		@@ -0,0 +1,1323
	1	/** Functions and tasks related to waveform packet generation.
	2	*
	3	* @file
	4	* @author P. LEROY
	5	*
	6	* A group of functions to handle waveforms, in snapshot or continuous format.\n
	7	*
	8	*/
	9
	10	#include "wf_handler.h"
	11
	12	//*****************
	13	// waveform headers
	14	// SWF
	15	Header_TM_LFR_SCIENCE_SWF_t headerSWF_F0[7];
	16	Header_TM_LFR_SCIENCE_SWF_t headerSWF_F1[7];
	17	Header_TM_LFR_SCIENCE_SWF_t headerSWF_F2[7];
	18	// CWF
	19	Header_TM_LFR_SCIENCE_CWF_t headerCWF_F1[ NB_PACKETS_PER_GROUP_OF_CWF ];
	20	Header_TM_LFR_SCIENCE_CWF_t headerCWF_F2_BURST[ NB_PACKETS_PER_GROUP_OF_CWF ];
	21	Header_TM_LFR_SCIENCE_CWF_t headerCWF_F2_SBM2[ NB_PACKETS_PER_GROUP_OF_CWF ];
	22	Header_TM_LFR_SCIENCE_CWF_t headerCWF_F3[ NB_PACKETS_PER_GROUP_OF_CWF ];
	23	Header_TM_LFR_SCIENCE_CWF_t headerCWF_F3_light[ NB_PACKETS_PER_GROUP_OF_CWF_LIGHT ];
	24
	25	//**************
	26	// waveform ring
	27	ring_node waveform_ring_f0[NB_RING_NODES_F0];
	28	ring_node waveform_ring_f1[NB_RING_NODES_F1];
	29	ring_node waveform_ring_f2[NB_RING_NODES_F2];
	30	ring_node waveform_ring_f3[NB_RING_NODES_F3];
	31	ring_node *current_ring_node_f0;
	32	ring_node *ring_node_to_send_swf_f0;
	33	ring_node *current_ring_node_f1;
	34	ring_node *ring_node_to_send_swf_f1;
	35	ring_node *ring_node_to_send_cwf_f1;
	36	ring_node *current_ring_node_f2;
	37	ring_node *ring_node_to_send_swf_f2;
	38	ring_node *ring_node_to_send_cwf_f2;
	39	ring_node *current_ring_node_f3;
	40	ring_node *ring_node_to_send_cwf_f3;
	41
	42	bool extractSWF = false;
	43	bool swf_f0_ready = false;
	44	bool swf_f1_ready = false;
	45	bool swf_f2_ready = false;
	46
	47	int wf_snap_extracted[ (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK) + TIME_OFFSET ];
	48
	49	//*********************
	50	// Interrupt SubRoutine
	51
	52	void reset_extractSWF( void )
	53	{
	54	extractSWF = false;
	55	swf_f0_ready = false;
	56	swf_f1_ready = false;
	57	swf_f2_ready = false;
	58	}
	59
	60	rtems_isr waveforms_isr( rtems_vector_number vector )
	61	{
	62	/** This is the interrupt sub routine called by the waveform picker core.
	63	*
	64	* This ISR launch different actions depending mainly on two pieces of information:
	65	* 1. the values read in the registers of the waveform picker.
	66	* 2. the current LFR mode.
	67	*
	68	*/
	69
	70	rtems_status_code status;
	71	rtems_status_code spare_status;
	72
	73	if ( (lfrCurrentMode == LFR_MODE_NORMAL) \|\| (lfrCurrentMode == LFR_MODE_BURST) // in BURST the data are used to place v, e1 and e2 in the HK packet
	74	\|\| (lfrCurrentMode == LFR_MODE_SBM1) \|\| (lfrCurrentMode == LFR_MODE_SBM2) )
	75	{ // in modes other than STANDBY and BURST, send the CWF_F3 data
	76	if ((waveform_picker_regs->status & 0x08) == 0x08){ // [1000] f3 is full
	77	// (1) change the receiving buffer for the waveform picker
	78	ring_node_to_send_cwf_f3 = current_ring_node_f3;
	79	current_ring_node_f3 = current_ring_node_f3->next;
	80	waveform_picker_regs->addr_data_f3 = current_ring_node_f3->buffer_address;
	81	// (2) send an event for the waveforms transmission
	82	if (rtems_event_send( Task_id[TASKID_CWF3], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
	83	spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2 );
	84	}
	85	rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2);
	86	waveform_picker_regs->status = waveform_picker_regs->status & 0xfffff777; // reset f3 bits to 0, [1111 0111 0111 0111]
	87	}
	88	}
	89
	90	switch(lfrCurrentMode)
	91	{
	92	//********
	93	// STANDBY
	94	case(LFR_MODE_STANDBY):
	95	break;
	96
	97	//******
	98	// NORMAL
	99	case(LFR_MODE_NORMAL):
	100	if ( (waveform_picker_regs->status & 0xff8) != 0x00) // [1000] check the error bits
	101	{
	102	spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2 );
	103	}
	104	if ( (waveform_picker_regs->status & 0x07) == 0x07) // [0111] check the f2, f1, f0 full bits
	105	{
	106	// change F0 ring node
	107	ring_node_to_send_swf_f0 = current_ring_node_f0;
	108	current_ring_node_f0 = current_ring_node_f0->next;
	109	waveform_picker_regs->addr_data_f0 = current_ring_node_f0->buffer_address;
	110	// change F1 ring node
	111	ring_node_to_send_swf_f1 = current_ring_node_f1;
	112	current_ring_node_f1 = current_ring_node_f1->next;
	113	waveform_picker_regs->addr_data_f1 = current_ring_node_f1->buffer_address;
	114	// change F2 ring node
	115	ring_node_to_send_swf_f2 = current_ring_node_f2;
	116	current_ring_node_f2 = current_ring_node_f2->next;
	117	waveform_picker_regs->addr_data_f2 = current_ring_node_f2->buffer_address;
	118	//
	119	if (rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_NORMAL ) != RTEMS_SUCCESSFUL)
	120	{
	121	spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2 );
	122	}
	123	waveform_picker_regs->status = waveform_picker_regs->status & 0xfffff888; // [1000 1000 1000]
	124	}
	125	break;
	126
	127	//******
	128	// BURST
	129	case(LFR_MODE_BURST):
	130	if ( (waveform_picker_regs->status & 0x04) == 0x04 ){ // [0100] check the f2 full bit
	131	// (1) change the receiving buffer for the waveform picker
	132	ring_node_to_send_cwf_f2 = current_ring_node_f2;
	133	current_ring_node_f2 = current_ring_node_f2->next;
	134	waveform_picker_regs->addr_data_f2 = current_ring_node_f2->buffer_address;
	135	// (2) send an event for the waveforms transmission
	136	if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {
	137	spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2 );
	138	}
	139	waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffbbb; // [1111 1011 1011 1011] f2 bit = 0
	140	}
	141	break;
	142
	143	//*****
	144	// SBM1
	145	case(LFR_MODE_SBM1):
	146	if ( (waveform_picker_regs->status & 0x02) == 0x02 ) { // [0010] check the f1 full bit
	147	// (1) change the receiving buffer for the waveform picker
	148	ring_node_to_send_cwf_f1 = current_ring_node_f1;
	149	current_ring_node_f1 = current_ring_node_f1->next;
	150	waveform_picker_regs->addr_data_f1 = current_ring_node_f1->buffer_address;
	151	// (2) send an event for the the CWF1 task for transmission (and snapshot extraction if needed)
	152	status = rtems_event_send( Task_id[TASKID_CWF1], RTEMS_EVENT_MODE_SBM1 );
	153	waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffddd; // [1111 1101 1101 1101] f1 bits = 0
	154	}
	155	if ( (waveform_picker_regs->status & 0x01) == 0x01 ) { // [0001] check the f0 full bit
	156	swf_f0_ready = true;
	157	waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffeee; // [1111 1110 1110 1110] f0 bits = 0
	158	}
	159	if ( (waveform_picker_regs->status & 0x04) == 0x04 ) { // [0100] check the f2 full bit
	160	swf_f2_ready = true;
	161	waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffbbb; // [1111 1011 1011 1011] f2 bits = 0
	162	}
	163	break;
	164
	165	//*****
	166	// SBM2
	167	case(LFR_MODE_SBM2):
	168	if ( (waveform_picker_regs->status & 0x04) == 0x04 ){ // [0100] check the f2 full bit
	169	// (1) change the receiving buffer for the waveform picker
	170	ring_node_to_send_cwf_f2 = current_ring_node_f2;
	171	current_ring_node_f2 = current_ring_node_f2->next;
	172	waveform_picker_regs->addr_data_f2 = current_ring_node_f2->buffer_address;
	173	// (2) send an event for the waveforms transmission
	174	status = rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_SBM2 );
	175	waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffbbb; // [1111 1011 1011 1011] f2 bit = 0
	176	}
	177	if ( (waveform_picker_regs->status & 0x01) == 0x01 ) { // [0001] check the f0 full bit
	178	swf_f0_ready = true;
	179	waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffeee; // [1111 1110 1110 1110] f0 bits = 0
	180	}
	181	if ( (waveform_picker_regs->status & 0x02) == 0x02 ) { // [0010] check the f1 full bit
	182	swf_f1_ready = true;
	183	waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffddd; // [1111 1101 1101 1101] f1, f0 bits = 0
	184	}
	185	break;
	186
	187	//********
	188	// DEFAULT
	189	default:
	190	break;
	191	}
	192	}
	193
	194	//************
	195	// RTEMS TASKS
	196
	197	rtems_task wfrm_task(rtems_task_argument argument) //used with the waveform picker VHDL IP
	198	{
	199	/** This RTEMS task is dedicated to the transmission of snapshots of the NORMAL mode.
	200	*
	201	* @param unused is the starting argument of the RTEMS task
	202	*
	203	* The following data packets are sent by this task:
	204	* - TM_LFR_SCIENCE_NORMAL_SWF_F0
	205	* - TM_LFR_SCIENCE_NORMAL_SWF_F1
	206	* - TM_LFR_SCIENCE_NORMAL_SWF_F2
	207	*
	208	*/
	209
	210	rtems_event_set event_out;
	211	rtems_id queue_id;
	212	rtems_status_code status;
	213
	214	init_header_snapshot_wf_table( SID_NORM_SWF_F0, headerSWF_F0 );
	215	init_header_snapshot_wf_table( SID_NORM_SWF_F1, headerSWF_F1 );
	216	init_header_snapshot_wf_table( SID_NORM_SWF_F2, headerSWF_F2 );
	217
	218	status = get_message_queue_id_send( &queue_id );
	219	if (status != RTEMS_SUCCESSFUL)
	220	{
	221	PRINTF1("in WFRM *** ERR get_message_queue_id_send %d\n", status)
	222	}
	223
	224	BOOT_PRINTF("in WFRM ***\n")
	225
	226	while(1){
	227	// wait for an RTEMS_EVENT
	228	rtems_event_receive(RTEMS_EVENT_MODE_NORMAL \| RTEMS_EVENT_MODE_SBM1
	229	\| RTEMS_EVENT_MODE_SBM2 \| RTEMS_EVENT_MODE_SBM2_WFRM,
	230	RTEMS_WAIT \| RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
	231	if (event_out == RTEMS_EVENT_MODE_NORMAL)
	232	{
	233	DEBUG_PRINTF("WFRM received RTEMS_EVENT_MODE_NORMAL\n")
	234	send_waveform_SWF((volatile int*) ring_node_to_send_swf_f0->buffer_address, SID_NORM_SWF_F0, headerSWF_F0, queue_id);
	235	send_waveform_SWF((volatile int*) ring_node_to_send_swf_f1->buffer_address, SID_NORM_SWF_F1, headerSWF_F1, queue_id);
	236	send_waveform_SWF((volatile int*) ring_node_to_send_swf_f2->buffer_address, SID_NORM_SWF_F2, headerSWF_F2, queue_id);
	237	}
	238	if (event_out == RTEMS_EVENT_MODE_SBM1)
	239	{
	240	DEBUG_PRINTF("WFRM received RTEMS_EVENT_MODE_SBM1\n")
	241	send_waveform_SWF((volatile int*) ring_node_to_send_swf_f0->buffer_address, SID_NORM_SWF_F0, headerSWF_F0, queue_id);
	242	send_waveform_SWF((volatile int*) wf_snap_extracted , SID_NORM_SWF_F1, headerSWF_F1, queue_id);
	243	send_waveform_SWF((volatile int*) ring_node_to_send_swf_f2->buffer_address, SID_NORM_SWF_F2, headerSWF_F2, queue_id);
	244	}
	245	if (event_out == RTEMS_EVENT_MODE_SBM2)
	246	{
	247	DEBUG_PRINTF("WFRM received RTEMS_EVENT_MODE_SBM2\n")
	248	send_waveform_SWF((volatile int*) ring_node_to_send_swf_f0->buffer_address, SID_NORM_SWF_F0, headerSWF_F0, queue_id);
	249	send_waveform_SWF((volatile int*) ring_node_to_send_swf_f1->buffer_address, SID_NORM_SWF_F1, headerSWF_F1, queue_id);
	250	send_waveform_SWF((volatile int*) wf_snap_extracted , SID_NORM_SWF_F2, headerSWF_F2, queue_id);
	251	}
	252	}
	253	}
	254
	255	rtems_task cwf3_task(rtems_task_argument argument) //used with the waveform picker VHDL IP
	256	{
	257	/** This RTEMS task is dedicated to the transmission of continuous waveforms at f3.
	258	*
	259	* @param unused is the starting argument of the RTEMS task
	260	*
	261	* The following data packet is sent by this task:
	262	* - TM_LFR_SCIENCE_NORMAL_CWF_F3
	263	*
	264	*/
	265
	266	rtems_event_set event_out;
	267	rtems_id queue_id;
	268	rtems_status_code status;
	269
	270	init_header_continuous_wf_table( SID_NORM_CWF_LONG_F3, headerCWF_F3 );
	271	init_header_continuous_cwf3_light_table( headerCWF_F3_light );
	272
	273	status = get_message_queue_id_send( &queue_id );
	274	if (status != RTEMS_SUCCESSFUL)
	275	{
	276	PRINTF1("in CWF3 *** ERR get_message_queue_id_send %d\n", status)
	277	}
	278
	279	BOOT_PRINTF("in CWF3 ***\n")
	280
	281	while(1){
	282	// wait for an RTEMS_EVENT
	283	rtems_event_receive( RTEMS_EVENT_0,
	284	RTEMS_WAIT \| RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
	285	if ( (lfrCurrentMode == LFR_MODE_NORMAL)
	286	\|\| (lfrCurrentMode == LFR_MODE_SBM1) \|\| (lfrCurrentMode==LFR_MODE_SBM2) )
	287	{
	288	if ( (parameter_dump_packet.sy_lfr_n_cwf_long_f3 & 0x01) == 0x01)
	289	{
	290	PRINTF("send CWF_LONG_F3\n")
	291	send_waveform_CWF(
	292	(volatile int*) ring_node_to_send_cwf_f3->buffer_address,
	293	SID_NORM_CWF_LONG_F3, headerCWF_F3, queue_id );
	294	}
	295	else
	296	{
	297	PRINTF("send CWF_F3 (light)\n")
	298	send_waveform_CWF3_light(
	299	(volatile int*) ring_node_to_send_cwf_f3->buffer_address,
	300	headerCWF_F3_light, queue_id );
	301	}
	302
	303	}
	304	else
	305	{
	306	PRINTF1("in CWF3 *** lfrCurrentMode is %d, no data will be sent\n", lfrCurrentMode)
	307	}
	308	}
	309	}
	310
	311	rtems_task cwf2_task(rtems_task_argument argument) // ONLY USED IN BURST AND SBM2
	312	{
	313	/** This RTEMS task is dedicated to the transmission of continuous waveforms at f2.
	314	*
	315	* @param unused is the starting argument of the RTEMS task
	316	*
	317	* The following data packet is sent by this function:
	318	* - TM_LFR_SCIENCE_BURST_CWF_F2
	319	* - TM_LFR_SCIENCE_SBM2_CWF_F2
	320	*
	321	*/
	322
	323	rtems_event_set event_out;
	324	rtems_id queue_id;
	325	rtems_status_code status;
	326
	327	init_header_continuous_wf_table( SID_BURST_CWF_F2, headerCWF_F2_BURST );
	328	init_header_continuous_wf_table( SID_SBM2_CWF_F2, headerCWF_F2_SBM2 );
	329
	330	status = get_message_queue_id_send( &queue_id );
	331	if (status != RTEMS_SUCCESSFUL)
	332	{
	333	PRINTF1("in CWF2 *** ERR get_message_queue_id_send %d\n", status)
	334	}
	335
	336	BOOT_PRINTF("in CWF2 ***\n")
	337
	338	while(1){
	339	// wait for an RTEMS_EVENT
	340	rtems_event_receive( RTEMS_EVENT_MODE_BURST \| RTEMS_EVENT_MODE_SBM2,
	341	RTEMS_WAIT \| RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
	342	if (event_out == RTEMS_EVENT_MODE_BURST)
	343	{
	344	send_waveform_CWF( (volatile int *) ring_node_to_send_cwf_f2->buffer_address, SID_BURST_CWF_F2, headerCWF_F2_BURST, queue_id );
	345	}
	346	if (event_out == RTEMS_EVENT_MODE_SBM2)
	347	{
	348	send_waveform_CWF( (volatile int *) ring_node_to_send_cwf_f2->buffer_address, SID_SBM2_CWF_F2, headerCWF_F2_SBM2, queue_id );
	349	// launch snapshot extraction if needed
	350	if (extractSWF == true)
	351	{
	352	ring_node_to_send_swf_f2 = ring_node_to_send_cwf_f2;
	353	// extract the snapshot
	354	build_snapshot_from_ring( ring_node_to_send_swf_f2, 2 );
	355	// send the snapshot when built
	356	status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM2 );
	357	extractSWF = false;
	358	}
	359	if (swf_f0_ready && swf_f1_ready)
	360	{
	361	extractSWF = true;
	362	swf_f0_ready = false;
	363	swf_f1_ready = false;
	364	}
	365	}
	366	}
	367	}
	368
	369	rtems_task cwf1_task(rtems_task_argument argument) // ONLY USED IN SBM1
	370	{
	371	/** This RTEMS task is dedicated to the transmission of continuous waveforms at f1.
	372	*
	373	* @param unused is the starting argument of the RTEMS task
	374	*
	375	* The following data packet is sent by this function:
	376	* - TM_LFR_SCIENCE_SBM1_CWF_F1
	377	*
	378	*/
	379
	380	rtems_event_set event_out;
	381	rtems_id queue_id;
	382	rtems_status_code status;
	383
	384	init_header_continuous_wf_table( SID_SBM1_CWF_F1, headerCWF_F1 );
	385
	386	status = get_message_queue_id_send( &queue_id );
	387	if (status != RTEMS_SUCCESSFUL)
	388	{
	389	PRINTF1("in CWF1 *** ERR get_message_queue_id_send %d\n", status)
	390	}
	391
	392	BOOT_PRINTF("in CWF1 ***\n")
	393
	394	while(1){
	395	// wait for an RTEMS_EVENT
	396	rtems_event_receive( RTEMS_EVENT_MODE_SBM1,
	397	RTEMS_WAIT \| RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
	398	send_waveform_CWF( (volatile int*) ring_node_to_send_cwf_f1->buffer_address, SID_SBM1_CWF_F1, headerCWF_F1, queue_id );
	399	// launch snapshot extraction if needed
	400	if (extractSWF == true)
	401	{
	402	ring_node_to_send_swf_f1 = ring_node_to_send_cwf_f1;
	403	// launch the snapshot extraction
	404	status = rtems_event_send( Task_id[TASKID_SWBD], RTEMS_EVENT_MODE_SBM1 );
	405	extractSWF = false;
	406	}
	407	if (swf_f0_ready == true)
	408	{
	409	extractSWF = true;
	410	swf_f0_ready = false; // this step shall be executed only one time
	411	}
	412	if ((swf_f1_ready == true) && (swf_f2_ready == true)) // swf_f1 is ready after the extraction
	413	{
	414	status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM1 );
	415	swf_f1_ready = false;
	416	swf_f2_ready = false;
	417	}
	418	}
	419	}
	420
	421	rtems_task swbd_task(rtems_task_argument argument)
	422	{
	423	/** This RTEMS task is dedicated to the building of snapshots from different continuous waveforms buffers.
	424	*
	425	* @param unused is the starting argument of the RTEMS task
	426	*
	427	*/
	428
	429	rtems_event_set event_out;
	430
	431	BOOT_PRINTF("in SWBD ***\n")
	432
	433	while(1){
	434	// wait for an RTEMS_EVENT
	435	rtems_event_receive( RTEMS_EVENT_MODE_SBM1 \| RTEMS_EVENT_MODE_SBM2,
	436	RTEMS_WAIT \| RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
	437	if (event_out == RTEMS_EVENT_MODE_SBM1)
	438	{
	439	build_snapshot_from_ring( ring_node_to_send_swf_f1, 1 );
	440	swf_f1_ready = true; // the snapshot has been extracted and is ready to be sent
	441	}
	442	else
	443	{
	444	PRINTF1("in SWBD *** unexpected rtems event received %x\n", (int) event_out)
	445	}
	446	}
	447	}
	448
	449	//******************
	450	// general functions
	451
	452	void WFP_init_rings( void )
	453	{
	454	// F0 RING
	455	init_waveform_ring( waveform_ring_f0, NB_RING_NODES_F0, wf_snap_f0 );
	456	// F1 RING
	457	init_waveform_ring( waveform_ring_f1, NB_RING_NODES_F1, wf_snap_f1 );
	458	// F2 RING
	459	init_waveform_ring( waveform_ring_f2, NB_RING_NODES_F2, wf_snap_f2 );
	460	// F3 RING
	461	init_waveform_ring( waveform_ring_f3, NB_RING_NODES_F3, wf_cont_f3 );
	462
	463	DEBUG_PRINTF1("waveform_ring_f0 @%x\n", (unsigned int) waveform_ring_f0)
	464	DEBUG_PRINTF1("waveform_ring_f1 @%x\n", (unsigned int) waveform_ring_f1)
	465	DEBUG_PRINTF1("waveform_ring_f2 @%x\n", (unsigned int) waveform_ring_f2)
	466	DEBUG_PRINTF1("waveform_ring_f3 @%x\n", (unsigned int) waveform_ring_f3)
	467	}
	468
	469	void init_waveform_ring(ring_node waveform_ring[], unsigned char nbNodes, volatile int wfrm[] )
	470	{
	471	unsigned char i;
	472
	473	waveform_ring[0].next = (ring_node*) &waveform_ring[ 1 ];
	474	waveform_ring[0].previous = (ring_node*) &waveform_ring[ nbNodes - 1 ];
	475	waveform_ring[0].buffer_address = (int) &wfrm[0];
	476
	477	waveform_ring[nbNodes-1].next = (ring_node*) &waveform_ring[ 0 ];
	478	waveform_ring[nbNodes-1].previous = (ring_node*) &waveform_ring[ nbNodes - 2 ];
	479	waveform_ring[nbNodes-1].buffer_address = (int) &wfrm[ (nbNodes-1) * WFRM_BUFFER ];
	480
	481	for(i=1; i<nbNodes-1; i++)
	482	{
	483	waveform_ring[i].next = (ring_node*) &waveform_ring[ i + 1 ];
	484	waveform_ring[i].previous = (ring_node*) &waveform_ring[ i - 1 ];
	485	waveform_ring[i].buffer_address = (int) &wfrm[ i * WFRM_BUFFER ];
	486	}
	487	}
	488
	489	void WFP_reset_current_ring_nodes( void )
	490	{
	491	current_ring_node_f0 = waveform_ring_f0;
	492	ring_node_to_send_swf_f0 = waveform_ring_f0;
	493
	494	current_ring_node_f1 = waveform_ring_f1;
	495	ring_node_to_send_cwf_f1 = waveform_ring_f1;
	496	ring_node_to_send_swf_f1 = waveform_ring_f1;
	497
	498	current_ring_node_f2 = waveform_ring_f2;
	499	ring_node_to_send_cwf_f2 = waveform_ring_f2;
	500	ring_node_to_send_swf_f2 = waveform_ring_f2;
	501
	502	current_ring_node_f3 = waveform_ring_f3;
	503	ring_node_to_send_cwf_f3 = waveform_ring_f3;
	504	}
	505
	506	int init_header_snapshot_wf_table( unsigned int sid, Header_TM_LFR_SCIENCE_SWF_t *headerSWF)
	507	{
	508	unsigned char i;
	509	int return_value;
	510
	511	return_value = LFR_SUCCESSFUL;
	512
	513	for (i=0; i<7; i++)
	514	{
	515	headerSWF[ i ].targetLogicalAddress = CCSDS_DESTINATION_ID;
	516	headerSWF[ i ].protocolIdentifier = CCSDS_PROTOCOLE_ID;
	517	headerSWF[ i ].reserved = DEFAULT_RESERVED;
	518	headerSWF[ i ].userApplication = CCSDS_USER_APP;
	519	headerSWF[ i ].packetID[0] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST >> 8);
	520	headerSWF[ i ].packetID[1] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST);
	521	headerSWF[ i ].packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
	522	if (i == 6)
	523	{
	524	headerSWF[ i ].packetLength[0] = (unsigned char) (TM_LEN_SCI_SWF_224 >> 8);
	525	headerSWF[ i ].packetLength[1] = (unsigned char) (TM_LEN_SCI_SWF_224 );
	526	headerSWF[ i ].blkNr[0] = (unsigned char) (BLK_NR_224 >> 8);
	527	headerSWF[ i ].blkNr[1] = (unsigned char) (BLK_NR_224 );
	528	}
	529	else
	530	{
	531	headerSWF[ i ].packetLength[0] = (unsigned char) (TM_LEN_SCI_SWF_304 >> 8);
	532	headerSWF[ i ].packetLength[1] = (unsigned char) (TM_LEN_SCI_SWF_304 );
	533	headerSWF[ i ].blkNr[0] = (unsigned char) (BLK_NR_304 >> 8);
	534	headerSWF[ i ].blkNr[1] = (unsigned char) (BLK_NR_304 );
	535	}
	536	headerSWF[ i ].packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
	537	headerSWF[ i ].pktCnt = DEFAULT_PKTCNT; // PKT_CNT
	538	headerSWF[ i ].pktNr = i+1; // PKT_NR
	539	// DATA FIELD HEADER
	540	headerSWF[ i ].spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
	541	headerSWF[ i ].serviceType = TM_TYPE_LFR_SCIENCE; // service type
	542	headerSWF[ i ].serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype
	543	headerSWF[ i ].destinationID = TM_DESTINATION_ID_GROUND;
	544	// AUXILIARY DATA HEADER
	545	headerSWF[ i ].time[0] = 0x00;
	546	headerSWF[ i ].time[0] = 0x00;
	547	headerSWF[ i ].time[0] = 0x00;
	548	headerSWF[ i ].time[0] = 0x00;
	549	headerSWF[ i ].time[0] = 0x00;
	550	headerSWF[ i ].time[0] = 0x00;
	551	headerSWF[ i ].sid = sid;
	552	headerSWF[ i ].hkBIA = DEFAULT_HKBIA;
	553	}
	554
	555	return return_value;
	556	}
	557
	558	int init_header_continuous_wf_table( unsigned int sid, Header_TM_LFR_SCIENCE_CWF_t *headerCWF )
	559	{
	560	unsigned int i;
	561	int return_value;
	562
	563	return_value = LFR_SUCCESSFUL;
	564
	565	for (i=0; i<NB_PACKETS_PER_GROUP_OF_CWF; i++)
	566	{
	567	headerCWF[ i ].targetLogicalAddress = CCSDS_DESTINATION_ID;
	568	headerCWF[ i ].protocolIdentifier = CCSDS_PROTOCOLE_ID;
	569	headerCWF[ i ].reserved = DEFAULT_RESERVED;
	570	headerCWF[ i ].userApplication = CCSDS_USER_APP;
	571	if ( (sid == SID_SBM1_CWF_F1) \|\| (sid == SID_SBM2_CWF_F2) )
	572	{
	573	headerCWF[ i ].packetID[0] = (unsigned char) (APID_TM_SCIENCE_SBM1_SBM2 >> 8);
	574	headerCWF[ i ].packetID[1] = (unsigned char) (APID_TM_SCIENCE_SBM1_SBM2);
	575	}
	576	else
	577	{
	578	headerCWF[ i ].packetID[0] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST >> 8);
	579	headerCWF[ i ].packetID[1] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST);
	580	}
	581	headerCWF[ i ].packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
	582	headerCWF[ i ].packetLength[0] = (unsigned char) (TM_LEN_SCI_CWF_336 >> 8);
	583	headerCWF[ i ].packetLength[1] = (unsigned char) (TM_LEN_SCI_CWF_336 );
	584	headerCWF[ i ].blkNr[0] = (unsigned char) (BLK_NR_CWF >> 8);
	585	headerCWF[ i ].blkNr[1] = (unsigned char) (BLK_NR_CWF );
	586	headerCWF[ i ].packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
	587	// DATA FIELD HEADER
	588	headerCWF[ i ].spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
	589	headerCWF[ i ].serviceType = TM_TYPE_LFR_SCIENCE; // service type
	590	headerCWF[ i ].serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype
	591	headerCWF[ i ].destinationID = TM_DESTINATION_ID_GROUND;
	592	// AUXILIARY DATA HEADER
	593	headerCWF[ i ].sid = sid;
	594	headerCWF[ i ].hkBIA = DEFAULT_HKBIA;
	595	headerCWF[ i ].time[0] = 0x00;
	596	headerCWF[ i ].time[0] = 0x00;
	597	headerCWF[ i ].time[0] = 0x00;
	598	headerCWF[ i ].time[0] = 0x00;
	599	headerCWF[ i ].time[0] = 0x00;
	600	headerCWF[ i ].time[0] = 0x00;
	601	}
	602
	603	return return_value;
	604	}
	605
	606	int init_header_continuous_cwf3_light_table( Header_TM_LFR_SCIENCE_CWF_t *headerCWF )
	607	{
	608	unsigned int i;
	609	int return_value;
	610
	611	return_value = LFR_SUCCESSFUL;
	612
	613	for (i=0; i<NB_PACKETS_PER_GROUP_OF_CWF_LIGHT; i++)
	614	{
	615	headerCWF[ i ].targetLogicalAddress = CCSDS_DESTINATION_ID;
	616	headerCWF[ i ].protocolIdentifier = CCSDS_PROTOCOLE_ID;
	617	headerCWF[ i ].reserved = DEFAULT_RESERVED;
	618	headerCWF[ i ].userApplication = CCSDS_USER_APP;
	619
	620	headerCWF[ i ].packetID[0] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST >> 8);
	621	headerCWF[ i ].packetID[1] = (unsigned char) (APID_TM_SCIENCE_NORMAL_BURST);
	622
	623	headerCWF[ i ].packetSequenceControl[0] = TM_PACKET_SEQ_CTRL_STANDALONE;
	624	headerCWF[ i ].packetLength[0] = (unsigned char) (TM_LEN_SCI_CWF_672 >> 8);
	625	headerCWF[ i ].packetLength[1] = (unsigned char) (TM_LEN_SCI_CWF_672 );
	626	headerCWF[ i ].blkNr[0] = (unsigned char) (BLK_NR_CWF_SHORT_F3 >> 8);
	627	headerCWF[ i ].blkNr[1] = (unsigned char) (BLK_NR_CWF_SHORT_F3 );
	628
	629	headerCWF[ i ].packetSequenceControl[1] = TM_PACKET_SEQ_CNT_DEFAULT;
	630	// DATA FIELD HEADER
	631	headerCWF[ i ].spare1_pusVersion_spare2 = DEFAULT_SPARE1_PUSVERSION_SPARE2;
	632	headerCWF[ i ].serviceType = TM_TYPE_LFR_SCIENCE; // service type
	633	headerCWF[ i ].serviceSubType = TM_SUBTYPE_LFR_SCIENCE; // service subtype
	634	headerCWF[ i ].destinationID = TM_DESTINATION_ID_GROUND;
	635	// AUXILIARY DATA HEADER
	636	headerCWF[ i ].sid = SID_NORM_CWF_F3;
	637	headerCWF[ i ].hkBIA = DEFAULT_HKBIA;
	638	headerCWF[ i ].time[0] = 0x00;
	639	headerCWF[ i ].time[0] = 0x00;
	640	headerCWF[ i ].time[0] = 0x00;
	641	headerCWF[ i ].time[0] = 0x00;
	642	headerCWF[ i ].time[0] = 0x00;
	643	headerCWF[ i ].time[0] = 0x00;
	644	}
	645
	646	return return_value;
	647	}
	648
	649	int send_waveform_SWF( volatile int *waveform, unsigned int sid,
	650	Header_TM_LFR_SCIENCE_SWF_t *headerSWF, rtems_id queue_id )
	651	{
	652	/** This function sends SWF CCSDS packets (F2, F1 or F0).
	653	*
	654	* @param waveform points to the buffer containing the data that will be send.
	655	* @param sid is the source identifier of the data that will be sent.
	656	* @param headerSWF points to a table of headers that have been prepared for the data transmission.
	657	* @param queue_id is the id of the rtems queue to which spw_ioctl_pkt_send structures will be send. The structures
	658	* contain information to setup the transmission of the data packets.
	659	*
	660	* One group of 2048 samples is sent as 7 consecutive packets, 6 packets containing 340 blocks and 8 packets containing 8 blocks.
	661	*
	662	*/
	663
	664	unsigned int i;
	665	int ret;
	666	unsigned int coarseTime;
	667	unsigned int fineTime;
	668	rtems_status_code status;
	669	spw_ioctl_pkt_send spw_ioctl_send_SWF;
	670
	671	spw_ioctl_send_SWF.hlen = TM_HEADER_LEN + 4 + 12; // + 4 is for the protocole extra header, + 12 is for the auxiliary header
	672	spw_ioctl_send_SWF.options = 0;
	673
	674	ret = LFR_DEFAULT;
	675
	676	coarseTime = waveform[0];
	677	fineTime = waveform[1];
	678
	679	for (i=0; i<7; i++) // send waveform
	680	{
	681	spw_ioctl_send_SWF.data = (char) &waveform[ (i BLK_NR_304 * NB_WORDS_SWF_BLK) + TIME_OFFSET];
	682	spw_ioctl_send_SWF.hdr = (char*) &headerSWF[ i ];
	683	// BUILD THE DATA
	684	if (i==6) {
	685	spw_ioctl_send_SWF.dlen = BLK_NR_224 * NB_BYTES_SWF_BLK;
	686	}
	687	else {
	688	spw_ioctl_send_SWF.dlen = BLK_NR_304 * NB_BYTES_SWF_BLK;
	689	}
	690	// SET PACKET SEQUENCE COUNTER
	691	increment_seq_counter_source_id( headerSWF[ i ].packetSequenceControl, sid );
	692	// SET PACKET TIME
	693	compute_acquisition_time( coarseTime, fineTime, sid, i, headerSWF[ i ].acquisitionTime );
	694	//
	695	headerSWF[ i ].time[0] = headerSWF[ i ].acquisitionTime[0];
	696	headerSWF[ i ].time[1] = headerSWF[ i ].acquisitionTime[1];
	697	headerSWF[ i ].time[2] = headerSWF[ i ].acquisitionTime[2];
	698	headerSWF[ i ].time[3] = headerSWF[ i ].acquisitionTime[3];
	699	headerSWF[ i ].time[4] = headerSWF[ i ].acquisitionTime[4];
	700	headerSWF[ i ].time[5] = headerSWF[ i ].acquisitionTime[5];
	701	// SEND PACKET
	702	status = rtems_message_queue_send( queue_id, &spw_ioctl_send_SWF, ACTION_MSG_SPW_IOCTL_SEND_SIZE);
	703	if (status != RTEMS_SUCCESSFUL) {
	704	printf("%d-%d, ERR %d\n", sid, i, (int) status);
	705	ret = LFR_DEFAULT;
	706	}
	707	rtems_task_wake_after(TIME_BETWEEN_TWO_SWF_PACKETS); // 300 ms between each packet => 7 * 3 = 21 packets => 6.3 seconds
	708	}
	709
	710	return ret;
	711	}
	712
	713	int send_waveform_CWF(volatile int *waveform, unsigned int sid,
	714	Header_TM_LFR_SCIENCE_CWF_t *headerCWF, rtems_id queue_id)
	715	{
	716	/** This function sends CWF CCSDS packets (F2, F1 or F0).
	717	*
	718	* @param waveform points to the buffer containing the data that will be send.
	719	* @param sid is the source identifier of the data that will be sent.
	720	* @param headerCWF points to a table of headers that have been prepared for the data transmission.
	721	* @param queue_id is the id of the rtems queue to which spw_ioctl_pkt_send structures will be send. The structures
	722	* contain information to setup the transmission of the data packets.
	723	*
	724	* One group of 2048 samples is sent as 7 consecutive packets, 6 packets containing 340 blocks and 8 packets containing 8 blocks.
	725	*
	726	*/
	727
	728	unsigned int i;
	729	int ret;
	730	unsigned int coarseTime;
	731	unsigned int fineTime;
	732	rtems_status_code status;
	733	spw_ioctl_pkt_send spw_ioctl_send_CWF;
	734
	735	spw_ioctl_send_CWF.hlen = TM_HEADER_LEN + 4 + 10; // + 4 is for the protocole extra header, + 10 is for the auxiliary header
	736	spw_ioctl_send_CWF.options = 0;
	737
	738	ret = LFR_DEFAULT;
	739
	740	coarseTime = waveform[0];
	741	fineTime = waveform[1];
	742
	743	for (i=0; i<NB_PACKETS_PER_GROUP_OF_CWF; i++) // send waveform
	744	{
	745	spw_ioctl_send_CWF.data = (char) &waveform[ (i BLK_NR_CWF * NB_WORDS_SWF_BLK) + TIME_OFFSET];
	746	spw_ioctl_send_CWF.hdr = (char*) &headerCWF[ i ];
	747	// BUILD THE DATA
	748	spw_ioctl_send_CWF.dlen = BLK_NR_CWF * NB_BYTES_SWF_BLK;
	749	// SET PACKET SEQUENCE COUNTER
	750	increment_seq_counter_source_id( headerCWF[ i ].packetSequenceControl, sid );
	751	// SET PACKET TIME
	752	compute_acquisition_time( coarseTime, fineTime, sid, i, headerCWF[ i ].acquisitionTime);
	753	//
	754	headerCWF[ i ].time[0] = headerCWF[ i ].acquisitionTime[0];
	755	headerCWF[ i ].time[1] = headerCWF[ i ].acquisitionTime[1];
	756	headerCWF[ i ].time[2] = headerCWF[ i ].acquisitionTime[2];
	757	headerCWF[ i ].time[3] = headerCWF[ i ].acquisitionTime[3];
	758	headerCWF[ i ].time[4] = headerCWF[ i ].acquisitionTime[4];
	759	headerCWF[ i ].time[5] = headerCWF[ i ].acquisitionTime[5];
	760	// SEND PACKET
	761	if (sid == SID_NORM_CWF_LONG_F3)
	762	{
	763	status = rtems_message_queue_send( queue_id, &spw_ioctl_send_CWF, sizeof(spw_ioctl_send_CWF));
	764	if (status != RTEMS_SUCCESSFUL) {
	765	printf("%d-%d, ERR %d\n", sid, i, (int) status);
	766	ret = LFR_DEFAULT;
	767	}
	768	rtems_task_wake_after(TIME_BETWEEN_TWO_CWF3_PACKETS);
	769	}
	770	else
	771	{
	772	status = rtems_message_queue_send( queue_id, &spw_ioctl_send_CWF, sizeof(spw_ioctl_send_CWF));
	773	if (status != RTEMS_SUCCESSFUL) {
	774	printf("%d-%d, ERR %d\n", sid, i, (int) status);
	775	ret = LFR_DEFAULT;
	776	}
	777	}
	778	}
	779
	780	return ret;
	781	}
	782
	783	int send_waveform_CWF3_light(volatile int waveform, Header_TM_LFR_SCIENCE_CWF_t headerCWF, rtems_id queue_id)
	784	{
	785	/** This function sends CWF_F3 CCSDS packets without the b1, b2 and b3 data.
	786	*
	787	* @param waveform points to the buffer containing the data that will be send.
	788	* @param headerCWF points to a table of headers that have been prepared for the data transmission.
	789	* @param queue_id is the id of the rtems queue to which spw_ioctl_pkt_send structures will be send. The structures
	790	* contain information to setup the transmission of the data packets.
	791	*
	792	* By default, CWF_F3 packet are send without the b1, b2 and b3 data. This function rebuilds a data buffer
	793	* from the incoming data and sends it in 7 packets, 6 containing 340 blocks and 1 one containing 8 blocks.
	794	*
	795	*/
	796
	797	unsigned int i;
	798	int ret;
	799	unsigned int coarseTime;
	800	unsigned int fineTime;
	801	rtems_status_code status;
	802	spw_ioctl_pkt_send spw_ioctl_send_CWF;
	803	char *sample;
	804
	805	spw_ioctl_send_CWF.hlen = TM_HEADER_LEN + 4 + 10; // + 4 is for the protocole extra header, + 10 is for the auxiliary header
	806	spw_ioctl_send_CWF.options = 0;
	807
	808	ret = LFR_DEFAULT;
	809
	810	//**********************
	811	// BUILD CWF3_light DATA
	812	for ( i=0; i< NB_SAMPLES_PER_SNAPSHOT; i++)
	813	{
	814	sample = (char) &waveform[ (i NB_WORDS_SWF_BLK) + TIME_OFFSET ];
	815	wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + TIME_OFFSET_IN_BYTES ] = sample[ 0 ];
	816	wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 1 + TIME_OFFSET_IN_BYTES ] = sample[ 1 ];
	817	wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 2 + TIME_OFFSET_IN_BYTES ] = sample[ 2 ];
	818	wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 3 + TIME_OFFSET_IN_BYTES ] = sample[ 3 ];
	819	wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 4 + TIME_OFFSET_IN_BYTES ] = sample[ 4 ];
	820	wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 5 + TIME_OFFSET_IN_BYTES ] = sample[ 5 ];
	821	}
	822
	823	coarseTime = waveform[0];
	824	fineTime = waveform[1];
	825
	826	//*********************
	827	// SEND CWF3_light DATA
	828	for (i=0; i<NB_PACKETS_PER_GROUP_OF_CWF_LIGHT; i++) // send waveform
	829	{
	830	spw_ioctl_send_CWF.data = (char) &wf_cont_f3_light[ (i BLK_NR_CWF_SHORT_F3 * NB_BYTES_CWF3_LIGHT_BLK) + TIME_OFFSET_IN_BYTES];
	831	spw_ioctl_send_CWF.hdr = (char*) &headerCWF[ i ];
	832	// BUILD THE DATA
	833	spw_ioctl_send_CWF.dlen = BLK_NR_CWF_SHORT_F3 * NB_BYTES_CWF3_LIGHT_BLK;
	834	// SET PACKET SEQUENCE COUNTER
	835	increment_seq_counter_source_id( headerCWF[ i ].packetSequenceControl, SID_NORM_CWF_F3 );
	836	// SET PACKET TIME
	837	compute_acquisition_time( coarseTime, fineTime, SID_NORM_CWF_F3, i, headerCWF[ i ].acquisitionTime );
	838	//
	839	headerCWF[ i ].time[0] = headerCWF[ i ].acquisitionTime[0];
	840	headerCWF[ i ].time[1] = headerCWF[ i ].acquisitionTime[1];
	841	headerCWF[ i ].time[2] = headerCWF[ i ].acquisitionTime[2];
	842	headerCWF[ i ].time[3] = headerCWF[ i ].acquisitionTime[3];
	843	headerCWF[ i ].time[4] = headerCWF[ i ].acquisitionTime[4];
	844	headerCWF[ i ].time[5] = headerCWF[ i ].acquisitionTime[5];
	845	// SEND PACKET
	846	status = rtems_message_queue_send( queue_id, &spw_ioctl_send_CWF, sizeof(spw_ioctl_send_CWF));
	847	if (status != RTEMS_SUCCESSFUL) {
	848	printf("%d-%d, ERR %d\n", SID_NORM_CWF_F3, i, (int) status);
	849	ret = LFR_DEFAULT;
	850	}
	851	rtems_task_wake_after(TIME_BETWEEN_TWO_CWF3_PACKETS);
	852	}
	853
	854	return ret;
	855	}
	856
	857	void compute_acquisition_time( unsigned int coarseTime, unsigned int fineTime,
	858	unsigned int sid, unsigned char pa_lfr_pkt_nr, unsigned char * acquisitionTime )
	859	{
	860	unsigned long long int acquisitionTimeAsLong;
	861	unsigned char localAcquisitionTime[6];
	862	double deltaT;
	863
	864	deltaT = 0.;
	865
	866	localAcquisitionTime[0] = (unsigned char) ( coarseTime >> 24 );
	867	localAcquisitionTime[1] = (unsigned char) ( coarseTime >> 16 );
	868	localAcquisitionTime[2] = (unsigned char) ( coarseTime >> 8 );
	869	localAcquisitionTime[3] = (unsigned char) ( coarseTime );
	870	localAcquisitionTime[4] = (unsigned char) ( fineTime >> 8 );
	871	localAcquisitionTime[5] = (unsigned char) ( fineTime );
	872
	873	acquisitionTimeAsLong = ( (unsigned long long int) localAcquisitionTime[0] << 40 )
	874	+ ( (unsigned long long int) localAcquisitionTime[1] << 32 )
	875	+ ( (unsigned long long int) localAcquisitionTime[2] << 24 )
	876	+ ( (unsigned long long int) localAcquisitionTime[3] << 16 )
	877	+ ( (unsigned long long int) localAcquisitionTime[4] << 8 )
	878	+ ( (unsigned long long int) localAcquisitionTime[5] );
	879
	880	switch( sid )
	881	{
	882	case SID_NORM_SWF_F0:
	883	deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 24576. ;
	884	break;
	885
	886	case SID_NORM_SWF_F1:
	887	deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 4096. ;
	888	break;
	889
	890	case SID_NORM_SWF_F2:
	891	deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 256. ;
	892	break;
	893
	894	case SID_SBM1_CWF_F1:
	895	deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 4096. ;
	896	break;
	897
	898	case SID_SBM2_CWF_F2:
	899	deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 256. ;
	900	break;
	901
	902	case SID_BURST_CWF_F2:
	903	deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 256. ;
	904	break;
	905
	906	case SID_NORM_CWF_F3:
	907	deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF_SHORT_F3 * 65536. / 16. ;
	908	break;
	909
	910	case SID_NORM_CWF_LONG_F3:
	911	deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 16. ;
	912	break;
	913
	914	default:
	915	PRINTF1("in compute_acquisition_time *** ERR unexpected sid %d", sid)
	916	deltaT = 0.;
	917	break;
	918	}
	919
	920	acquisitionTimeAsLong = acquisitionTimeAsLong + (unsigned long long int) deltaT;
	921	//
	922	acquisitionTime[0] = (unsigned char) (acquisitionTimeAsLong >> 40);
	923	acquisitionTime[1] = (unsigned char) (acquisitionTimeAsLong >> 32);
	924	acquisitionTime[2] = (unsigned char) (acquisitionTimeAsLong >> 24);
	925	acquisitionTime[3] = (unsigned char) (acquisitionTimeAsLong >> 16);
	926	acquisitionTime[4] = (unsigned char) (acquisitionTimeAsLong >> 8 );
	927	acquisitionTime[5] = (unsigned char) (acquisitionTimeAsLong );
	928
	929	}
	930
	931	void build_snapshot_from_ring( ring_node *ring_node_to_send, unsigned char frequencyChannel )
	932	{
	933	unsigned int i;
	934	unsigned long long int centerTime_asLong;
	935	unsigned long long int acquisitionTimeF0_asLong;
	936	unsigned long long int acquisitionTime_asLong;
	937	unsigned long long int bufferAcquisitionTime_asLong;
	938	unsigned char *ptr1;
	939	unsigned char *ptr2;
	940	unsigned char *timeCharPtr;
	941	unsigned char nb_ring_nodes;
	942	unsigned long long int frequency_asLong;
	943	unsigned long long int nbTicksPerSample_asLong;
	944	unsigned long long int nbSamplesPart1_asLong;
	945	unsigned long long int sampleOffset_asLong;
	946
	947	unsigned int deltaT_F0;
	948	unsigned int deltaT_F1;
	949	unsigned long long int deltaT_F2;
	950
	951	deltaT_F0 = 2731; // (2048. / 24576. / 2.) * 65536. = 2730.667;
	952	deltaT_F1 = 16384; // (2048. / 4096. / 2.) * 65536. = 16384;
	953	deltaT_F2 = 262144; // (2048. / 256. / 2.) * 65536. = 262144;
	954	sampleOffset_asLong = 0x00;
	955
	956	// (1) get the f0 acquisition time
	957	build_acquisition_time( &acquisitionTimeF0_asLong, current_ring_node_f0 );
	958
	959	// (2) compute the central reference time
	960	centerTime_asLong = acquisitionTimeF0_asLong + deltaT_F0;
	961
	962	// (3) compute the acquisition time of the current snapshot
	963	switch(frequencyChannel)
	964	{
	965	case 1: // 1 is for F1 = 4096 Hz
	966	acquisitionTime_asLong = centerTime_asLong - deltaT_F1;
	967	nb_ring_nodes = NB_RING_NODES_F1;
	968	frequency_asLong = 4096;
	969	nbTicksPerSample_asLong = 16; // 65536 / 4096;
	970	break;
	971	case 2: // 2 is for F2 = 256 Hz
	972	acquisitionTime_asLong = centerTime_asLong - deltaT_F2;
	973	nb_ring_nodes = NB_RING_NODES_F2;
	974	frequency_asLong = 256;
	975	nbTicksPerSample_asLong = 256; // 65536 / 256;
	976	break;
	977	default:
	978	acquisitionTime_asLong = centerTime_asLong;
	979	frequency_asLong = 256;
	980	nbTicksPerSample_asLong = 256;
	981	break;
	982	}
	983
	984	//****************************************************************************
	985	// (4) search the ring_node with the acquisition time <= acquisitionTime_asLong
	986	for (i=0; i<nb_ring_nodes; i++)
	987	{
	988	PRINTF1("%d ... ", i)
	989	build_acquisition_time( &bufferAcquisitionTime_asLong, ring_node_to_send );
	990	if (bufferAcquisitionTime_asLong <= acquisitionTime_asLong)
	991	{
	992	PRINTF1("buffer found with acquisition time = %llx\n", bufferAcquisitionTime_asLong)
	993	break;
	994	}
	995	ring_node_to_send = ring_node_to_send->previous;
	996	}
	997
	998	// (5) compute the number of samples to take in the current buffer
	999	sampleOffset_asLong = ((acquisitionTime_asLong - bufferAcquisitionTime_asLong) * frequency_asLong ) >> 16;
	1000	nbSamplesPart1_asLong = NB_SAMPLES_PER_SNAPSHOT - sampleOffset_asLong;
	1001	PRINTF2("sampleOffset_asLong = %llx, nbSamplesPart1_asLong = %llx\n", sampleOffset_asLong, nbSamplesPart1_asLong)
	1002
	1003	// (6) compute the final acquisition time
	1004	acquisitionTime_asLong = bufferAcquisitionTime_asLong +
	1005	sampleOffset_asLong * nbTicksPerSample_asLong;
	1006
	1007	// (7) copy the acquisition time at the beginning of the extrated snapshot
	1008	ptr1 = (unsigned char*) &acquisitionTime_asLong;
	1009	ptr2 = (unsigned char*) wf_snap_extracted;
	1010	ptr2[0] = ptr1[ 0 + 2 ];
	1011	ptr2[1] = ptr1[ 1 + 2 ];
	1012	ptr2[2] = ptr1[ 2 + 2 ];
	1013	ptr2[3] = ptr1[ 3 + 2 ];
	1014	ptr2[6] = ptr1[ 4 + 2 ];
	1015	ptr2[7] = ptr1[ 5 + 2 ];
	1016
	1017	// re set the synchronization bit
	1018	timeCharPtr = (unsigned char*) ring_node_to_send->buffer_address;
	1019	ptr2[0] = ptr2[0] \| (timeCharPtr[0] & 0x80); // [1000 0000]
	1020
	1021	if ( (nbSamplesPart1_asLong >= NB_SAMPLES_PER_SNAPSHOT) \| (nbSamplesPart1_asLong < 0) )
	1022	{
	1023	nbSamplesPart1_asLong = 0;
	1024	}
	1025	// copy the part 1 of the snapshot in the extracted buffer
	1026	for ( i = 0; i < (nbSamplesPart1_asLong * NB_WORDS_SWF_BLK); i++ )
	1027	{
	1028	wf_snap_extracted[i + TIME_OFFSET] =
	1029	((int) ring_node_to_send->buffer_address)[i + (sampleOffset_asLong NB_WORDS_SWF_BLK) + TIME_OFFSET];
	1030	}
	1031	// copy the part 2 of the snapshot in the extracted buffer
	1032	ring_node_to_send = ring_node_to_send->next;
	1033	for ( i = (nbSamplesPart1_asLong * NB_WORDS_SWF_BLK); i < (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK); i++ )
	1034	{
	1035	wf_snap_extracted[i + TIME_OFFSET] =
	1036	((int) ring_node_to_send->buffer_address)[(i-(nbSamplesPart1_asLong NB_WORDS_SWF_BLK)) + TIME_OFFSET];
	1037	}
	1038	}
	1039
	1040	void build_acquisition_time( unsigned long long int acquisitionTimeAslong, ring_node current_ring_node )
	1041	{
	1042	unsigned char *acquisitionTimeCharPtr;
	1043
	1044	acquisitionTimeCharPtr = (unsigned char*) current_ring_node->buffer_address;
	1045
	1046	*acquisitionTimeAslong = 0x00;
	1047	*acquisitionTimeAslong = ( (unsigned long long int) (acquisitionTimeCharPtr[0] & 0x7f) << 40 ) // [0111 1111] mask the synchronization bit
	1048	+ ( (unsigned long long int) acquisitionTimeCharPtr[1] << 32 )
	1049	+ ( (unsigned long long int) acquisitionTimeCharPtr[2] << 24 )
	1050	+ ( (unsigned long long int) acquisitionTimeCharPtr[3] << 16 )
	1051	+ ( (unsigned long long int) acquisitionTimeCharPtr[6] << 8 )
	1052	+ ( (unsigned long long int) acquisitionTimeCharPtr[7] );
	1053	}
	1054
	1055	//**************
	1056	// wfp registers
	1057	void reset_wfp_burst_enable(void)
	1058	{
	1059	/** This function resets the waveform picker burst_enable register.
	1060	*
	1061	* The burst bits [f2 f1 f0] and the enable bits [f3 f2 f1 f0] are set to 0.
	1062	*
	1063	*/
	1064
	1065	waveform_picker_regs->run_burst_enable = 0x00; // burst f2, f1, f0 enable f3, f2, f1, f0
	1066	}
	1067
	1068	void reset_wfp_status( void )
	1069	{
	1070	/** This function resets the waveform picker status register.
	1071	*
	1072	* All status bits are set to 0 [new_err full_err full].
	1073	*
	1074	*/
	1075
	1076	waveform_picker_regs->status = 0x00; // burst f2, f1, f0 enable f3, f2, f1, f0
	1077	}
	1078
	1079	void reset_waveform_picker_regs(void)
	1080	{
	1081	/** This function resets the waveform picker module registers.
	1082	*
	1083	* The registers affected by this function are located at the following offset addresses:
	1084	* - 0x00 data_shaping
	1085	* - 0x04 run_burst_enable
	1086	* - 0x08 addr_data_f0
	1087	* - 0x0C addr_data_f1
	1088	* - 0x10 addr_data_f2
	1089	* - 0x14 addr_data_f3
	1090	* - 0x18 status
	1091	* - 0x1C delta_snapshot
	1092	* - 0x20 delta_f0
	1093	* - 0x24 delta_f0_2
	1094	* - 0x28 delta_f1
	1095	* - 0x2c delta_f2
	1096	* - 0x30 nb_data_by_buffer
	1097	* - 0x34 nb_snapshot_param
	1098	* - 0x38 start_date
	1099	* - 0x3c nb_word_in_buffer
	1100	*
	1101	*/
	1102
	1103	set_wfp_data_shaping(); // 0x00 *** R1 R0 SP1 SP0 BW
	1104	reset_wfp_burst_enable(); // 0x04 * [run * burst f2, f1, f0 *** enable f3, f2, f1, f0 ]
	1105	waveform_picker_regs->addr_data_f0 = current_ring_node_f0->buffer_address; // 0x08
	1106	waveform_picker_regs->addr_data_f1 = current_ring_node_f1->buffer_address; // 0x0c
	1107	waveform_picker_regs->addr_data_f2 = current_ring_node_f2->buffer_address; // 0x10
	1108	waveform_picker_regs->addr_data_f3 = current_ring_node_f3->buffer_address; // 0x14
	1109	reset_wfp_status(); // 0x18
	1110	//
	1111	set_wfp_delta_snapshot(); // 0x1c
	1112	set_wfp_delta_f0_f0_2(); // 0x20, 0x24
	1113	set_wfp_delta_f1(); // 0x28
	1114	set_wfp_delta_f2(); // 0x2c
	1115	DEBUG_PRINTF1("delta_snapshot %x\n", waveform_picker_regs->delta_snapshot)
	1116	DEBUG_PRINTF1("delta_f0 %x\n", waveform_picker_regs->delta_f0)
	1117	DEBUG_PRINTF1("delta_f0_2 %x\n", waveform_picker_regs->delta_f0_2)
	1118	DEBUG_PRINTF1("delta_f1 %x\n", waveform_picker_regs->delta_f1)
	1119	DEBUG_PRINTF1("delta_f2 %x\n", waveform_picker_regs->delta_f2)
	1120	// 2688 = 8 * 336
	1121	waveform_picker_regs->nb_data_by_buffer = 0xa7f; // 0x30 *** 2688 - 1 => nb samples -1
	1122	waveform_picker_regs->snapshot_param = 0xa80; // 0x34 *** 2688 => nb samples
	1123	waveform_picker_regs->start_date = 0x00; // 0x38
	1124	waveform_picker_regs->nb_word_in_buffer = 0x1f82; // 0x3c *** 2688 * 3 + 2 = 8066
	1125	}
	1126
	1127	void set_wfp_data_shaping( void )
	1128	{
	1129	/** This function sets the data_shaping register of the waveform picker module.
	1130	*
	1131	* The value is read from one field of the parameter_dump_packet structure:\n
	1132	* bw_sp0_sp1_r0_r1
	1133	*
	1134	*/
	1135
	1136	unsigned char data_shaping;
	1137
	1138	// get the parameters for the data shaping [BW SP0 SP1 R0 R1] in sy_lfr_common1 and configure the register
	1139	// waveform picker : [R1 R0 SP1 SP0 BW]
	1140
	1141	data_shaping = parameter_dump_packet.bw_sp0_sp1_r0_r1;
	1142
	1143	waveform_picker_regs->data_shaping =
	1144	( (data_shaping & 0x10) >> 4 ) // BW
	1145	+ ( (data_shaping & 0x08) >> 2 ) // SP0
	1146	+ ( (data_shaping & 0x04) ) // SP1
	1147	+ ( (data_shaping & 0x02) << 2 ) // R0
	1148	+ ( (data_shaping & 0x01) << 4 ); // R1
	1149	}
	1150
	1151	void set_wfp_burst_enable_register( unsigned char mode )
	1152	{
	1153	/** This function sets the waveform picker burst_enable register depending on the mode.
	1154	*
	1155	* @param mode is the LFR mode to launch.
	1156	*
	1157	* The burst bits shall be before the enable bits.
	1158	*
	1159	*/
	1160
	1161	// [0000 0000] burst f2, f1, f0 enable f3 f2 f1 f0
	1162	// the burst bits shall be set first, before the enable bits
	1163	switch(mode) {
	1164	case(LFR_MODE_NORMAL):
	1165	waveform_picker_regs->run_burst_enable = 0x00; // [0000 0000] no burst enable
	1166	waveform_picker_regs->run_burst_enable = 0x0f; // [0000 1111] enable f3 f2 f1 f0
	1167	break;
	1168	case(LFR_MODE_BURST):
	1169	waveform_picker_regs->run_burst_enable = 0x40; // [0100 0000] f2 burst enabled
	1170	// waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable \| 0x04; // [0100] enable f2
	1171	waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable \| 0x0c; // [1100] enable f3 AND f2
	1172	break;
	1173	case(LFR_MODE_SBM1):
	1174	waveform_picker_regs->run_burst_enable = 0x20; // [0010 0000] f1 burst enabled
	1175	waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable \| 0x0f; // [1111] enable f3 f2 f1 f0
	1176	break;
	1177	case(LFR_MODE_SBM2):
	1178	waveform_picker_regs->run_burst_enable = 0x40; // [0100 0000] f2 burst enabled
	1179	waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable \| 0x0f; // [1111] enable f3 f2 f1 f0
	1180	break;
	1181	default:
	1182	waveform_picker_regs->run_burst_enable = 0x00; // [0000 0000] no burst enabled, no waveform enabled
	1183	break;
	1184	}
	1185	}
	1186
	1187	void set_wfp_delta_snapshot( void )
	1188	{
	1189	/** This function sets the delta_snapshot register of the waveform picker module.
	1190	*
	1191	* The value is read from two (unsigned char) of the parameter_dump_packet structure:
	1192	* - sy_lfr_n_swf_p[0]
	1193	* - sy_lfr_n_swf_p[1]
	1194	*
	1195	*/
	1196
	1197	unsigned int delta_snapshot;
	1198	unsigned int delta_snapshot_in_T2;
	1199
	1200	delta_snapshot = parameter_dump_packet.sy_lfr_n_swf_p[0]*256
	1201	+ parameter_dump_packet.sy_lfr_n_swf_p[1];
	1202
	1203	delta_snapshot_in_T2 = delta_snapshot * 256;
	1204	waveform_picker_regs->delta_snapshot = delta_snapshot_in_T2 - 1; // max 4 bytes
	1205	}
	1206
	1207	void set_wfp_delta_f0_f0_2( void )
	1208	{
	1209	unsigned int delta_snapshot;
	1210	unsigned int nb_samples_per_snapshot;
	1211	float delta_f0_in_float;
	1212
	1213	delta_snapshot = waveform_picker_regs->delta_snapshot;
	1214	nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];
	1215	delta_f0_in_float =nb_samples_per_snapshot / 2. * ( 1. / 256. - 1. / 24576.) * 256.;
	1216
	1217	waveform_picker_regs->delta_f0 = delta_snapshot - floor( delta_f0_in_float );
	1218	waveform_picker_regs->delta_f0_2 = 0x7; // max 7 bits
	1219	}
	1220
	1221	void set_wfp_delta_f1( void )
	1222	{
	1223	unsigned int delta_snapshot;
	1224	unsigned int nb_samples_per_snapshot;
	1225	float delta_f1_in_float;
	1226
	1227	delta_snapshot = waveform_picker_regs->delta_snapshot;
	1228	nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];
	1229	delta_f1_in_float = nb_samples_per_snapshot / 2. * ( 1. / 256. - 1. / 4096.) * 256.;
	1230
	1231	waveform_picker_regs->delta_f1 = delta_snapshot - floor( delta_f1_in_float );
	1232	}
	1233
	1234	void set_wfp_delta_f2()
	1235	{
	1236	unsigned int delta_snapshot;
	1237	unsigned int nb_samples_per_snapshot;
	1238
	1239	delta_snapshot = waveform_picker_regs->delta_snapshot;
	1240	nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];
	1241
	1242	waveform_picker_regs->delta_f2 = delta_snapshot - nb_samples_per_snapshot / 2;
	1243	}
	1244
	1245	//*****************
	1246	// local parameters
	1247
	1248	void increment_seq_counter_source_id( unsigned char *packet_sequence_control, unsigned int sid )
	1249	{
	1250	/** This function increments the parameter "sequence_cnt" depending on the sid passed in argument.
	1251	*
	1252	* @param packet_sequence_control is a pointer toward the parameter sequence_cnt to update.
	1253	* @param sid is the source identifier of the packet being updated.
	1254	*
	1255	* REQ-LFR-SRS-5240 / SSS-CP-FS-590
	1256	* The sequence counters shall wrap around from 2^14 to zero.
	1257	* The sequence counter shall start at zero at startup.
	1258	*
	1259	* REQ-LFR-SRS-5239 / SSS-CP-FS-580
	1260	* All TM_LFR_SCIENCE_ packets are sent to ground, i.e. destination id = 0
	1261	*
	1262	*/
	1263
	1264	unsigned short *sequence_cnt;
	1265	unsigned short segmentation_grouping_flag;
	1266	unsigned short new_packet_sequence_control;
	1267	rtems_mode initial_mode_set;
	1268	rtems_mode current_mode_set;
	1269	rtems_status_code status;
	1270
	1271	//******************************************
	1272	// CHANGE THE MODE OF THE CALLING RTEMS TASK
	1273	status = rtems_task_mode( RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &initial_mode_set );
	1274
	1275	if ( (sid == SID_NORM_SWF_F0) \|\| (sid == SID_NORM_SWF_F1) \|\| (sid == SID_NORM_SWF_F2)
	1276	\|\| (sid == SID_NORM_CWF_F3) \|\| (sid == SID_NORM_CWF_LONG_F3)
	1277	\|\| (sid == SID_BURST_CWF_F2)
	1278	\|\| (sid == SID_NORM_ASM_F0) \|\| (sid == SID_NORM_ASM_F1) \|\| (sid == SID_NORM_ASM_F2)
	1279	\|\| (sid == SID_NORM_BP1_F0) \|\| (sid == SID_NORM_BP1_F1) \|\| (sid == SID_NORM_BP1_F2)
	1280	\|\| (sid == SID_NORM_BP2_F0) \|\| (sid == SID_NORM_BP2_F1) \|\| (sid == SID_NORM_BP2_F2)
	1281	\|\| (sid == SID_BURST_BP1_F0) \|\| (sid == SID_BURST_BP2_F0)
	1282	\|\| (sid == SID_BURST_BP1_F1) \|\| (sid == SID_BURST_BP2_F1) )
	1283	{
	1284	sequence_cnt = (unsigned short *) &sequenceCounters_SCIENCE_NORMAL_BURST;
	1285	}
	1286	else if ( (sid ==SID_SBM1_CWF_F1) \|\| (sid ==SID_SBM2_CWF_F2)
	1287	\|\| (sid == SID_SBM1_BP1_F0) \|\| (sid == SID_SBM1_BP2_F0)
	1288	\|\| (sid == SID_SBM2_BP1_F0) \|\| (sid == SID_SBM2_BP2_F0)
	1289	\|\| (sid == SID_SBM2_BP1_F1) \|\| (sid == SID_SBM2_BP2_F1) )
	1290	{
	1291	sequence_cnt = (unsigned short *) &sequenceCounters_SCIENCE_SBM1_SBM2;
	1292	}
	1293	else
	1294	{
	1295	sequence_cnt = (unsigned short *) NULL;
	1296	PRINTF1("in increment_seq_counter_source_id *** ERR apid_destid %d not known\n", sid)
	1297	}
	1298
	1299	if (sequence_cnt != NULL)
	1300	{
	1301	segmentation_grouping_flag = TM_PACKET_SEQ_CTRL_STANDALONE << 8;
	1302	sequence_cnt = (sequence_cnt) & 0x3fff;
	1303
	1304	new_packet_sequence_control = segmentation_grouping_flag \| (*sequence_cnt) ;
	1305
	1306	packet_sequence_control[0] = (unsigned char) (new_packet_sequence_control >> 8);
	1307	packet_sequence_control[1] = (unsigned char) (new_packet_sequence_control );
	1308
	1309	// increment the sequence counter
	1310	if ( *sequence_cnt < SEQ_CNT_MAX)
	1311	{
	1312	sequence_cnt = sequence_cnt + 1;
	1313	}
	1314	else
	1315	{
	1316	*sequence_cnt = 0;
	1317	}
	1318	}
	1319
	1320	//***********************************
	1321	// RESET THE MODE OF THE CALLING TASK
	1322	status = rtems_task_mode( initial_mode_set, RTEMS_PREEMPT_MASK, &current_mode_set );
	1323	}

.hgignore +1 0

              run2/trace
              run3/src
              run3/trace
+             *CMakeLists.txt.user

.hgsubstate +1 -1

		@@ -1,2 +1,2
1	1	3081d1f9bb20b2b64a192585337a292a9804e0c5 LFR_basic-parameters
2		1ffa3d630b9ced4a87a362dafb10d9838e9cc0d9 header/lfr_common_headers
	2	94f0f2fccbcb8030d9437ffbb69ee0eefaaea188 header/lfr_common_headers

header/fsw_init.h +2 -2

              #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  Task_name[];       /* array of task names */
+             extern rtems_id    Task_id[];         /* array of task ids */
              extern rtems_name timecode_timer_name;
              extern rtems_id timecode_timer_id;
              extern unsigned char pa_bia_status_info;

header/fsw_misc.h +3 0

              rtems_name name_hk_rate_monotonic;  // name of the HK rate monotonic
              rtems_id HK_id;                     // id of the HK rate monotonic period
+             rtems_name name_avgv_rate_monotonic;  // name of the AVGV rate monotonic
+             rtems_id AVGV_id;                     // id of the AVGV rate monotonic period
              void timer_configure( unsigned char timer, unsigned int clock_divider,
                                  unsigned char interrupt_level, rtems_isr (*timer_isr)() );
              // RTEMS TASKS
              rtems_task load_task( rtems_task_argument argument );
              rtems_task hous_task( rtems_task_argument argument );
+             rtems_task avgv_task( rtems_task_argument argument );
              rtems_task dumb_task( rtems_task_argument unused );
              void init_housekeeping_parameters( void );

src/fsw_misc.c +85 0

		@@ -335,6 +335,91 rtems_task hous_task(rtems_task_argument
335	335	return;
336	336	}
337	337
	338	rtems_task avgv_task(rtems_task_argument argument)
	339	{
	340	#define MOVING_AVERAGE 16
	341	rtems_status_code status;
	342	unsigned int v[MOVING_AVERAGE];
	343	unsigned int e1[MOVING_AVERAGE];
	344	unsigned int e2[MOVING_AVERAGE];
	345	float average_v;
	346	float average_e1;
	347	float average_e2;
	348	unsigned char k;
	349	unsigned char indexOfOldValue;
	350
	351	BOOT_PRINTF("in AVGV ***\n");
	352
	353	if (rtems_rate_monotonic_ident( name_avgv_rate_monotonic, &HK_id) != RTEMS_SUCCESSFUL) {
	354	status = rtems_rate_monotonic_create( name_avgv_rate_monotonic, &AVGV_id );
	355	if( status != RTEMS_SUCCESSFUL ) {
	356	PRINTF1( "rtems_rate_monotonic_create failed with status of %d\n", status );
	357	}
	358	}
	359
	360	status = rtems_rate_monotonic_cancel(AVGV_id);
	361	if( status != RTEMS_SUCCESSFUL ) {
	362	PRINTF1( "ERR * in AVGV * rtems_rate_monotonic_cancel(AVGV_id) ***code: %d\n", status );
	363	}
	364	else {
	365	DEBUG_PRINTF("OK * in AVGV * rtems_rate_monotonic_cancel(AVGV_id)\n");
	366	}
	367
	368	// initialize values
	369	k = 0;
	370	indexOfOldValue = MOVING_AVERAGE - 1;
	371	for (k = 0; k < MOVING_AVERAGE; k++)
	372	{
	373	v[k] = 0;
	374	e1[k] = 0;
	375	e2[k] = 0;
	376	average_v = 0.;
	377	average_e1 = 0.;
	378	average_e2 = 0.;
	379	}
	380
	381	k = 0;
	382
	383	while(1){ // launch the rate monotonic task
	384	status = rtems_rate_monotonic_period( AVGV_id, AVGV_PERIOD );
	385	if ( status != RTEMS_SUCCESSFUL ) {
	386	PRINTF1( "in AVGV *** ERR period: %d\n", status);
	387	}
	388	else {
	389	// store new value in buffer
	390	v[k] = waveform_picker_regs->v;
	391	e1[k] = waveform_picker_regs->e1;
	392	e2[k] = waveform_picker_regs->e2;
	393	if (k == (MOVING_AVERAGE - 1))
	394	{
	395	indexOfOldValue = 0;
	396	}
	397	else
	398	{
	399	indexOfOldValue = k + 1;
	400	}
	401	average_v = average_v + v[k] - v[indexOfOldValue];
	402	average_e1 = average_e1 + e1[k] - e1[indexOfOldValue];
	403	average_e2 = average_e2 + e2[k] - e2[indexOfOldValue];
	404	}
	405	if (k == (MOVING_AVERAGE-1))
	406	{
	407	k = 0;
	408	printf("tick\n");
	409	}
	410	else
	411	{
	412	k++;
	413	}
	414	}
	415
	416	PRINTF("in AVGV *** deleting task\n")
	417
	418	status = rtems_task_delete( RTEMS_SELF ); // should not return
	419
	420	return;
	421	}
	422
338	423	rtems_task dumb_task( rtems_task_argument unused )
339	424	{
340	425	/** This RTEMS taks is used to print messages without affecting the general behaviour of the software.

FSW-qt/fsw-qt.pro removed 0 -132

NO CONTENT: file was removed

FSW-qt/fsw-qt.pro.user.cdbf9cd removed 0 -201

NO CONTENT: file was removed

FSW-qt/sparc.pri removed 0 -68

NO CONTENT: file was removed

timegen-qt/block diagram.odg removed binary 0 0

NO CONTENT: file was removed, binary diff hidden

timegen-qt/header/TC_types.h removed 0 -219

NO CONTENT: file was removed

timegen-qt/header/ccsds_types.h removed 0 -665

	1		NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (665 lines changed) Show them Hide them

timegen-qt/header/fsw_init.h removed 0 -39

NO CONTENT: file was removed

timegen-qt/header/fsw_misc.h removed 0 -45

NO CONTENT: file was removed

timegen-qt/header/fsw_params.h removed 0 -255

NO CONTENT: file was removed

timegen-qt/header/fsw_params_nb_bytes.h removed 0 -37

NO CONTENT: file was removed

timegen-qt/header/fsw_params_processing.h removed 0 -70

NO CONTENT: file was removed

timegen-qt/header/fsw_params_wf_handler.h removed 0 -8

NO CONTENT: file was removed

timegen-qt/header/fsw_spacewire.h removed 0 -53

NO CONTENT: file was removed

timegen-qt/header/grlib_regs.h removed 0 -109

NO CONTENT: file was removed

timegen-qt/header/lfr_cpu_usage_report.h removed 0 -32

NO CONTENT: file was removed

timegen-qt/header/processing/avf0_prc0.h removed 0 -36

NO CONTENT: file was removed

timegen-qt/header/processing/avf1_prc1.h removed 0 -33

NO CONTENT: file was removed

timegen-qt/header/processing/avf2_prc2.h removed 0 -28

NO CONTENT: file was removed

timegen-qt/header/processing/fsw_processing.h removed 0 -243

NO CONTENT: file was removed

timegen-qt/header/tc_acceptance.h removed 0 -25

NO CONTENT: file was removed

timegen-qt/header/tc_handler.h removed 0 -66

NO CONTENT: file was removed

timegen-qt/header/tc_load_dump_parameters.h removed 0 -51

NO CONTENT: file was removed

timegen-qt/header/tm_byte_positions.h removed 0 -23

NO CONTENT: file was removed

timegen-qt/header/tm_lfr_tc_exe.h removed 0 -26

NO CONTENT: file was removed

timegen-qt/header/wf_handler.h removed 0 -92

NO CONTENT: file was removed

timegen-qt/sparc.pri removed 0 -92

NO CONTENT: file was removed

timegen-qt/src/fsw_config.c removed 0 -25

NO CONTENT: file was removed

timegen-qt/src/fsw_globals.c removed 0 -75

NO CONTENT: file was removed

timegen-qt/src/fsw_init.c removed 0 -489

NO CONTENT: file was removed

timegen-qt/src/fsw_misc.c removed 0 -252

NO CONTENT: file was removed

timegen-qt/src/fsw_processing_globals.c removed 0 -46

NO CONTENT: file was removed

timegen-qt/src/fsw_spacewire.c removed 0 -728

	1		NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (728 lines changed) Show them Hide them

timegen-qt/src/lfr_cpu_usage_report.c removed 0 -115

NO CONTENT: file was removed

timegen-qt/src/processing/avf0_prc0.c removed 0 -380

NO CONTENT: file was removed

timegen-qt/src/processing/avf1_prc1.c removed 0 -360

NO CONTENT: file was removed

timegen-qt/src/processing/avf2_prc2.c removed 0 -255

NO CONTENT: file was removed

timegen-qt/src/processing/fsw_processing.c removed 0 -696

	1		NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (696 lines changed) Show them Hide them

timegen-qt/src/tc_acceptance.c removed 0 -437

NO CONTENT: file was removed

timegen-qt/src/tc_handler.c removed 0 -250

NO CONTENT: file was removed

timegen-qt/src/tc_load_dump_parameters.c removed 0 -772

	1		NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (772 lines changed) Show them Hide them

timegen-qt/src/tm_lfr_tc_exe.c removed 0 -510

	1		NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (510 lines changed) Show them Hide them

timegen-qt/src/wf_handler.c removed 0 -1323

	1		NO CONTENT: file was removed
This diff has been collapsed as it changes many lines, (1323 lines changed) Show them Hide them

timegen-qt/timegen-qt.pro removed 0 -81

NO CONTENT: file was removed

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages