HG_REPOSITORIES/LPP/INSTRUMENTATION/SOLO_LFR/DEV_PLE Commit - r272:ae46bf907e3b

1

/** Functions and tasks related to waveform packet generation.

1

/** Functions and tasks related to waveform packet generation.

2

*

2

*

3

* @file

3

* @file

4

* @author P. LEROY

4

* @author P. LEROY

5

*

5

*

6

* A group of functions to handle waveforms, in snapshot or continuous format.\n

6

* A group of functions to handle waveforms, in snapshot or continuous format.\n

7

*

7

*

8

*/

8

*/

9

10

#include "wf_handler.h"

10

#include "wf_handler.h"

11

12

//***************

12

//***************

13

// waveform rings

13

// waveform rings

14

// F0

14

// F0

15

ring_node waveform_ring_f0[NB_RING_NODES_F0];

15

ring_node waveform_ring_f0[NB_RING_NODES_F0];

16

ring_node *current_ring_node_f0;

16

ring_node *current_ring_node_f0;

17

ring_node *ring_node_to_send_swf_f0;

17

ring_node *ring_node_to_send_swf_f0;

18

// F1

18

// F1

19

ring_node waveform_ring_f1[NB_RING_NODES_F1];

19

ring_node waveform_ring_f1[NB_RING_NODES_F1];

20

ring_node *current_ring_node_f1;

20

ring_node *current_ring_node_f1;

21

ring_node *ring_node_to_send_swf_f1;

21

ring_node *ring_node_to_send_swf_f1;

22

ring_node *ring_node_to_send_cwf_f1;

22

ring_node *ring_node_to_send_cwf_f1;

23

// F2

23

// F2

24

ring_node waveform_ring_f2[NB_RING_NODES_F2];

24

ring_node waveform_ring_f2[NB_RING_NODES_F2];

25

ring_node *current_ring_node_f2;

25

ring_node *current_ring_node_f2;

26

ring_node *ring_node_to_send_swf_f2;

26

ring_node *ring_node_to_send_swf_f2;

27

ring_node *ring_node_to_send_cwf_f2;

27

ring_node *ring_node_to_send_cwf_f2;

28

// F3

28

// F3

29

ring_node waveform_ring_f3[NB_RING_NODES_F3];

29

ring_node waveform_ring_f3[NB_RING_NODES_F3];

30

ring_node *current_ring_node_f3;

30

ring_node *current_ring_node_f3;

31

ring_node *ring_node_to_send_cwf_f3;

31

ring_node *ring_node_to_send_cwf_f3;

32

char wf_cont_f3_light[ (NB_SAMPLES_PER_SNAPSHOT) * NB_BYTES_CWF3_LIGHT_BLK ];

32

char wf_cont_f3_light[ (NB_SAMPLES_PER_SNAPSHOT) * NB_BYTES_CWF3_LIGHT_BLK ];

33

34

bool extractSWF1 = false;

34

bool extractSWF1 = false;

35

bool extractSWF2 = false;

35

bool extractSWF2 = false;

36

bool swf0_ready_flag_f1 = false;

36

bool swf0_ready_flag_f1 = false;

37

bool swf0_ready_flag_f2 = false;

37

bool swf0_ready_flag_f2 = false;

38

bool swf1_ready = false;

38

bool swf1_ready = false;

39

bool swf2_ready = false;

39

bool swf2_ready = false;

40

41

int swf1_extracted[ (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK) ];

41

int swf1_extracted[ (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK) ];

42

int swf2_extracted[ (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK) ];

42

int swf2_extracted[ (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK) ];

43

ring_node ring_node_swf1_extracted;

43

ring_node ring_node_swf1_extracted;

44

ring_node ring_node_swf2_extracted;

44

ring_node ring_node_swf2_extracted;

45

46

typedef enum resynchro_state_t

46

typedef enum resynchro_state_t

47

{

47

{

48

MEASURE,

48

MEASURE,

49

CORRECTION

49

CORRECTION

50

} resynchro_state;

50

} resynchro_state;

51

52

//*********************

52

//*********************

53

// Interrupt SubRoutine

53

// Interrupt SubRoutine

54

55

ring_node * getRingNodeToSendCWF( unsigned char frequencyChannel)

55

ring_node * getRingNodeToSendCWF( unsigned char frequencyChannel)

56

{

56

{

57

ring_node *node;

57

ring_node *node;

58

59

node = NULL;

59

node = NULL;

60

switch ( frequencyChannel ) {

60

switch ( frequencyChannel ) {

61

case 1:

61

case 1:

62

node = ring_node_to_send_cwf_f1;

62

node = ring_node_to_send_cwf_f1;

63

break;

63

break;

64

case 2:

64

case 2:

65

node = ring_node_to_send_cwf_f2;

65

node = ring_node_to_send_cwf_f2;

66

break;

66

break;

67

case 3:

67

case 3:

68

node = ring_node_to_send_cwf_f3;

68

node = ring_node_to_send_cwf_f3;

69

break;

69

break;

70

default:

70

default:

71

break;

71

break;

72

}

72

}

73

74

return node;

74

return node;

75

}

75

}

76

77

ring_node * getRingNodeToSendSWF( unsigned char frequencyChannel)

77

ring_node * getRingNodeToSendSWF( unsigned char frequencyChannel)

78

{

78

{

79

ring_node *node;

79

ring_node *node;

80

81

node = NULL;

81

node = NULL;

82

switch ( frequencyChannel ) {

82

switch ( frequencyChannel ) {

83

case 0:

83

case 0:

84

node = ring_node_to_send_swf_f0;

84

node = ring_node_to_send_swf_f0;

85

break;

85

break;

86

case 1:

86

case 1:

87

node = ring_node_to_send_swf_f1;

87

node = ring_node_to_send_swf_f1;

88

break;

88

break;

89

case 2:

89

case 2:

90

node = ring_node_to_send_swf_f2;

90

node = ring_node_to_send_swf_f2;

91

break;

91

break;

92

default:

92

default:

93

break;

93

break;

94

}

94

}

95

96

return node;

96

return node;

97

}

97

}

98

99

void reset_extractSWF( void )

99

void reset_extractSWF( void )

100

{

100

{

101

extractSWF1 = false;

101

extractSWF1 = false;

102

extractSWF2 = false;

102

extractSWF2 = false;

103

swf0_ready_flag_f1 = false;

103

swf0_ready_flag_f1 = false;

104

swf0_ready_flag_f2 = false;

104

swf0_ready_flag_f2 = false;

105

swf1_ready = false;

105

swf1_ready = false;

106

swf2_ready = false;

106

swf2_ready = false;

107

}

107

}

108

109

inline void waveforms_isr_f3( void )

109

inline void waveforms_isr_f3( void )

110

{

110

{

111

rtems_status_code spare_status;

111

rtems_status_code spare_status;

112

113

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

113

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

114

|| (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )

114

|| (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )

115

{ // in modes other than STANDBY and BURST, send the CWF_F3 data

115

{ // in modes other than STANDBY and BURST, send the CWF_F3 data

116

//***

116

//***

117

// F3

117

// F3

118

if ( (waveform_picker_regs->status & 0xc0) != 0x00 ) { // [1100 0000] check the f3 full bits

118

if ( (waveform_picker_regs->status & 0xc0) != 0x00 ) { // [1100 0000] check the f3 full bits

119

ring_node_to_send_cwf_f3 = current_ring_node_f3->previous;

119

ring_node_to_send_cwf_f3 = current_ring_node_f3->previous;

120

current_ring_node_f3 = current_ring_node_f3->next;

120

current_ring_node_f3 = current_ring_node_f3->next;

121

if ((waveform_picker_regs->status & 0x40) == 0x40){ // [0100 0000] f3 buffer 0 is full

121

if ((waveform_picker_regs->status & 0x40) == 0x40){ // [0100 0000] f3 buffer 0 is full

122

ring_node_to_send_cwf_f3->coarseTime = waveform_picker_regs->f3_0_coarse_time;

122

ring_node_to_send_cwf_f3->coarseTime = waveform_picker_regs->f3_0_coarse_time;

123

ring_node_to_send_cwf_f3->fineTime = waveform_picker_regs->f3_0_fine_time;

123

ring_node_to_send_cwf_f3->fineTime = waveform_picker_regs->f3_0_fine_time;

124

waveform_picker_regs->addr_data_f3_0 = current_ring_node_f3->buffer_address;

124

waveform_picker_regs->addr_data_f3_0 = current_ring_node_f3->buffer_address;

125

waveform_picker_regs->status = waveform_picker_regs->status & 0x00008840; // [1000 1000 0100 0000]

125

waveform_picker_regs->status = waveform_picker_regs->status & 0x00008840; // [1000 1000 0100 0000]

126

}

126

}

127

else if ((waveform_picker_regs->status & 0x80) == 0x80){ // [1000 0000] f3 buffer 1 is full

127

else if ((waveform_picker_regs->status & 0x80) == 0x80){ // [1000 0000] f3 buffer 1 is full

128

ring_node_to_send_cwf_f3->coarseTime = waveform_picker_regs->f3_1_coarse_time;

128

ring_node_to_send_cwf_f3->coarseTime = waveform_picker_regs->f3_1_coarse_time;

129

ring_node_to_send_cwf_f3->fineTime = waveform_picker_regs->f3_1_fine_time;

129

ring_node_to_send_cwf_f3->fineTime = waveform_picker_regs->f3_1_fine_time;

130

waveform_picker_regs->addr_data_f3_1 = current_ring_node_f3->buffer_address;

130

waveform_picker_regs->addr_data_f3_1 = current_ring_node_f3->buffer_address;

131

waveform_picker_regs->status = waveform_picker_regs->status & 0x00008880; // [1000 1000 1000 0000]

131

waveform_picker_regs->status = waveform_picker_regs->status & 0x00008880; // [1000 1000 1000 0000]

132

}

132

}

133

if (rtems_event_send( Task_id[TASKID_CWF3], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {

133

if (rtems_event_send( Task_id[TASKID_CWF3], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {

134

spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );

134

spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );

135

}

135

}

136

}

136

}

137

}

137

}

138

}

138

}

139

140

inline void waveforms_isr_burst( void )

140

inline void waveforms_isr_burst( void )

141

{

141

{

142

unsigned char status;

142

unsigned char status;

143

rtems_status_code spare_status;

143

rtems_status_code spare_status;

144

145

status = (waveform_picker_regs->status & 0x30) >> 4; // [0011 0000] get the status bits for f2

145

status = (waveform_picker_regs->status & 0x30) >> 4; // [0011 0000] get the status bits for f2

146

147

148

switch(status)

148

switch(status)

149

{

149

{

150

case 1:

150

case 1:

151

ring_node_to_send_cwf_f2 = current_ring_node_f2->previous;

151

ring_node_to_send_cwf_f2 = current_ring_node_f2->previous;

152

ring_node_to_send_cwf_f2->sid = SID_BURST_CWF_F2;

152

ring_node_to_send_cwf_f2->sid = SID_BURST_CWF_F2;

153

ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time;

153

ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time;

154

ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_0_fine_time;

154

ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_0_fine_time;

155

current_ring_node_f2 = current_ring_node_f2->next;

155

current_ring_node_f2 = current_ring_node_f2->next;

156

waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address;

156

waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address;

157

if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {

157

if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {

158

spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );

158

spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );

159

}

159

}

160

waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]

160

waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]

161

break;

161

break;

162

case 2:

162

case 2:

163

ring_node_to_send_cwf_f2 = current_ring_node_f2->previous;

163

ring_node_to_send_cwf_f2 = current_ring_node_f2->previous;

164

ring_node_to_send_cwf_f2->sid = SID_BURST_CWF_F2;

164

ring_node_to_send_cwf_f2->sid = SID_BURST_CWF_F2;

165

ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time;

165

ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time;

166

ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_1_fine_time;

166

ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_1_fine_time;

167

current_ring_node_f2 = current_ring_node_f2->next;

167

current_ring_node_f2 = current_ring_node_f2->next;

168

waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;

168

waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;

169

if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {

169

if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {

170

spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );

170

spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );

171

}

171

}

172

waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]

172

waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]

173

break;

173

break;

174

default:

174

default:

175

break;

175

break;

176

}

176

}

177

}

177

}

178

179

inline void waveform_isr_normal_sbm1_sbm2( void )

179

inline void waveform_isr_normal_sbm1_sbm2( void )

180

{

180

{

181

rtems_status_code status;

181

rtems_status_code status;

182

183

//***

183

//***

184

// F0

184

// F0

185

if ( (waveform_picker_regs->status & 0x03) != 0x00 ) // [0000 0011] check the f0 full bits

185

if ( (waveform_picker_regs->status & 0x03) != 0x00 ) // [0000 0011] check the f0 full bits

186

{

186

{

187

swf0_ready_flag_f1 = true;

187

swf0_ready_flag_f1 = true;

188

swf0_ready_flag_f2 = true;

188

swf0_ready_flag_f2 = true;

189

ring_node_to_send_swf_f0 = current_ring_node_f0->previous;

189

ring_node_to_send_swf_f0 = current_ring_node_f0->previous;

190

current_ring_node_f0 = current_ring_node_f0->next;

190

current_ring_node_f0 = current_ring_node_f0->next;

191

if ( (waveform_picker_regs->status & 0x01) == 0x01)

191

if ( (waveform_picker_regs->status & 0x01) == 0x01)

192

{

192

{

193

194

ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_0_coarse_time;

194

ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_0_coarse_time;

195

ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_0_fine_time;

195

ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_0_fine_time;

196

waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->buffer_address;

196

waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->buffer_address;

197

waveform_picker_regs->status = waveform_picker_regs->status & 0x00001101; // [0001 0001 0000 0001]

197

waveform_picker_regs->status = waveform_picker_regs->status & 0x00001101; // [0001 0001 0000 0001]

198

}

198

}

199

else if ( (waveform_picker_regs->status & 0x02) == 0x02)

199

else if ( (waveform_picker_regs->status & 0x02) == 0x02)

200

{

200

{

201

ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_1_coarse_time;

201

ring_node_to_send_swf_f0->coarseTime = waveform_picker_regs->f0_1_coarse_time;

202

ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_1_fine_time;

202

ring_node_to_send_swf_f0->fineTime = waveform_picker_regs->f0_1_fine_time;

203

waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address;

203

waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address;

204

waveform_picker_regs->status = waveform_picker_regs->status & 0x00001102; // [0001 0001 0000 0010]

204

waveform_picker_regs->status = waveform_picker_regs->status & 0x00001102; // [0001 0001 0000 0010]

205

}

205

}

206

// send an event to the WFRM task for resynchro activities

206

// send an event to the WFRM task for resynchro activities

207

status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_SWF_RESYNCH );

207

status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_SWF_RESYNCH );

208

}

208

}

209

210

//***

210

//***

211

// F1

211

// F1

212

if ( (waveform_picker_regs->status & 0x0c) != 0x00 ) { // [0000 1100] check the f1 full bits

212

if ( (waveform_picker_regs->status & 0x0c) != 0x00 ) { // [0000 1100] check the f1 full bits

213

// (1) change the receiving buffer for the waveform picker

213

// (1) change the receiving buffer for the waveform picker

214

ring_node_to_send_cwf_f1 = current_ring_node_f1->previous;

214

ring_node_to_send_cwf_f1 = current_ring_node_f1->previous;

215

current_ring_node_f1 = current_ring_node_f1->next;

215

current_ring_node_f1 = current_ring_node_f1->next;

216

if ( (waveform_picker_regs->status & 0x04) == 0x04)

216

if ( (waveform_picker_regs->status & 0x04) == 0x04)

217

{

217

{

218

ring_node_to_send_cwf_f1->coarseTime = waveform_picker_regs->f1_0_coarse_time;

218

ring_node_to_send_cwf_f1->coarseTime = waveform_picker_regs->f1_0_coarse_time;

219

ring_node_to_send_cwf_f1->fineTime = waveform_picker_regs->f1_0_fine_time;

219

ring_node_to_send_cwf_f1->fineTime = waveform_picker_regs->f1_0_fine_time;

220

waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->buffer_address;

220

waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->buffer_address;

221

waveform_picker_regs->status = waveform_picker_regs->status & 0x00002204; // [0010 0010 0000 0100] f1 bits = 0

221

waveform_picker_regs->status = waveform_picker_regs->status & 0x00002204; // [0010 0010 0000 0100] f1 bits = 0

222

}

222

}

223

else if ( (waveform_picker_regs->status & 0x08) == 0x08)

223

else if ( (waveform_picker_regs->status & 0x08) == 0x08)

224

{

224

{

225

ring_node_to_send_cwf_f1->coarseTime = waveform_picker_regs->f1_1_coarse_time;

225

ring_node_to_send_cwf_f1->coarseTime = waveform_picker_regs->f1_1_coarse_time;

226

ring_node_to_send_cwf_f1->fineTime = waveform_picker_regs->f1_1_fine_time;

226

ring_node_to_send_cwf_f1->fineTime = waveform_picker_regs->f1_1_fine_time;

227

waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address;

227

waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address;

228

waveform_picker_regs->status = waveform_picker_regs->status & 0x00002208; // [0010 0010 0000 1000] f1 bits = 0

228

waveform_picker_regs->status = waveform_picker_regs->status & 0x00002208; // [0010 0010 0000 1000] f1 bits = 0

229

}

229

}

230

// (2) send an event for the the CWF1 task for transmission (and snapshot extraction if needed)

230

// (2) send an event for the the CWF1 task for transmission (and snapshot extraction if needed)

231

status = rtems_event_send( Task_id[TASKID_CWF1], RTEMS_EVENT_MODE_NORM_S1_S2 );

231

status = rtems_event_send( Task_id[TASKID_CWF1], RTEMS_EVENT_MODE_NORM_S1_S2 );

232

}

232

}

233

234

//***

234

//***

235

// F2

235

// F2

236

if ( (waveform_picker_regs->status & 0x30) != 0x00 ) { // [0011 0000] check the f2 full bit

236

if ( (waveform_picker_regs->status & 0x30) != 0x00 ) { // [0011 0000] check the f2 full bit

237

// (1) change the receiving buffer for the waveform picker

237

// (1) change the receiving buffer for the waveform picker

238

ring_node_to_send_cwf_f2 = current_ring_node_f2->previous;

238

ring_node_to_send_cwf_f2 = current_ring_node_f2->previous;

239

ring_node_to_send_cwf_f2->sid = SID_SBM2_CWF_F2;

239

ring_node_to_send_cwf_f2->sid = SID_SBM2_CWF_F2;

240

current_ring_node_f2 = current_ring_node_f2->next;

240

current_ring_node_f2 = current_ring_node_f2->next;

241

if ( (waveform_picker_regs->status & 0x10) == 0x10)

241

if ( (waveform_picker_regs->status & 0x10) == 0x10)

242

{

242

{

243

ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time;

243

ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_0_coarse_time;

244

ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_0_fine_time;

244

ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_0_fine_time;

245

waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address;

245

waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->buffer_address;

246

waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]

246

waveform_picker_regs->status = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]

247

}

247

}

248

else if ( (waveform_picker_regs->status & 0x20) == 0x20)

248

else if ( (waveform_picker_regs->status & 0x20) == 0x20)

249

{

249

{

250

ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time;

250

ring_node_to_send_cwf_f2->coarseTime = waveform_picker_regs->f2_1_coarse_time;

251

ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_1_fine_time;

251

ring_node_to_send_cwf_f2->fineTime = waveform_picker_regs->f2_1_fine_time;

252

waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;

252

waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;

253

waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]

253

waveform_picker_regs->status = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]

254

}

254

}

255

// (2) send an event for the waveforms transmission

255

// (2) send an event for the waveforms transmission

256

status = rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_NORM_S1_S2 );

256

status = rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_NORM_S1_S2 );

257

}

257

}

258

}

258

}

259

260

rtems_isr waveforms_isr( rtems_vector_number vector )

260

rtems_isr waveforms_isr( rtems_vector_number vector )

261

{

261

{

262

/** This is the interrupt sub routine called by the waveform picker core.

262

/** This is the interrupt sub routine called by the waveform picker core.

263

*

263

*

264

* This ISR launch different actions depending mainly on two pieces of information:

264

* This ISR launch different actions depending mainly on two pieces of information:

265

* 1. the values read in the registers of the waveform picker.

265

* 1. the values read in the registers of the waveform picker.

266

* 2. the current LFR mode.

266

* 2. the current LFR mode.

267

*

267

*

268

*/

268

*/

269

270

// STATUS

270

// STATUS

271

// new error error buffer full

271

// new error error buffer full

272

// 15 14 13 12 11 10 9 8

272

// 15 14 13 12 11 10 9 8

273

// f3 f2 f1 f0 f3 f2 f1 f0

273

// f3 f2 f1 f0 f3 f2 f1 f0

274

//

274

//

275

// ready buffer

275

// ready buffer

276

// 7 6 5 4 3 2 1 0

276

// 7 6 5 4 3 2 1 0

277

// f3_1 f3_0 f2_1 f2_0 f1_1 f1_0 f0_1 f0_0

277

// f3_1 f3_0 f2_1 f2_0 f1_1 f1_0 f0_1 f0_0

278

279

rtems_status_code spare_status;

279

rtems_status_code spare_status;

280

281

waveforms_isr_f3();

281

waveforms_isr_f3();

282

283

//*************************************************

283

//*************************************************

284

// copy the status bits in the housekeeping packets

284

// copy the status bits in the housekeeping packets

285

housekeeping_packet.hk_lfr_vhdl_iir_cal =

285

housekeeping_packet.hk_lfr_vhdl_iir_cal =

286

(unsigned char) ((waveform_picker_regs->status & 0xff00) >> 8);

286

(unsigned char) ((waveform_picker_regs->status & 0xff00) >> 8);

287

288

if ( (waveform_picker_regs->status & 0xff00) != 0x00) // [1111 1111 0000 0000] check the error bits

288

if ( (waveform_picker_regs->status & 0xff00) != 0x00) // [1111 1111 0000 0000] check the error bits

289

{

289

{

290

spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_10 );

290

spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_10 );

291

}

291

}

292

293

switch(lfrCurrentMode)

293

switch(lfrCurrentMode)

294

{

294

{

295

//********

295

//********

296

// STANDBY

296

// STANDBY

297

case LFR_MODE_STANDBY:

297

case LFR_MODE_STANDBY:

298

break;

298

break;

299

//**************************

299

//**************************

300

// LFR NORMAL, SBM1 and SBM2

300

// LFR NORMAL, SBM1 and SBM2

301

case LFR_MODE_NORMAL:

301

case LFR_MODE_NORMAL:

302

case LFR_MODE_SBM1:

302

case LFR_MODE_SBM1:

303

case LFR_MODE_SBM2:

303

case LFR_MODE_SBM2:

304

waveform_isr_normal_sbm1_sbm2();

304

waveform_isr_normal_sbm1_sbm2();

305

break;

305

break;

306

//******

306

//******

307

// BURST

307

// BURST

308

case LFR_MODE_BURST:

308

case LFR_MODE_BURST:

309

waveforms_isr_burst();

309

waveforms_isr_burst();

310

break;

310

break;

311

//********

311

//********

312

// DEFAULT

312

// DEFAULT

313

default:

313

default:

314

break;

314

break;

315

}

315

}

316

}

316

}

317

318

//************

318

//************

319

// RTEMS TASKS

319

// RTEMS TASKS

320

321

rtems_task wfrm_task(rtems_task_argument argument) //used with the waveform picker VHDL IP

321

rtems_task wfrm_task(rtems_task_argument argument) //used with the waveform picker VHDL IP

322

{

322

{

323

/** This RTEMS task is dedicated to the transmission of snapshots of the NORMAL mode.

323

/** This RTEMS task is dedicated to the transmission of snapshots of the NORMAL mode.

324

*

324

*

325

* @param unused is the starting argument of the RTEMS task

325

* @param unused is the starting argument of the RTEMS task

326

*

326

*

327

* The following data packets are sent by this task:

327

* The following data packets are sent by this task:

328

* - TM_LFR_SCIENCE_NORMAL_SWF_F0

328

* - TM_LFR_SCIENCE_NORMAL_SWF_F0

329

* - TM_LFR_SCIENCE_NORMAL_SWF_F1

329

* - TM_LFR_SCIENCE_NORMAL_SWF_F1

330

* - TM_LFR_SCIENCE_NORMAL_SWF_F2

330

* - TM_LFR_SCIENCE_NORMAL_SWF_F2

331

*

331

*

332

*/

332

*/

333

334

rtems_event_set event_out;

334

rtems_event_set event_out;

335

rtems_id queue_id;

335

rtems_id queue_id;

336

rtems_status_code status;

336

rtems_status_code status;

337

ring_node *ring_node_swf1_extracted_ptr;

337

ring_node *ring_node_swf1_extracted_ptr;

338

ring_node *ring_node_swf2_extracted_ptr;

338

ring_node *ring_node_swf2_extracted_ptr;

339

340

ring_node_swf1_extracted_ptr = (ring_node *) &ring_node_swf1_extracted;

340

ring_node_swf1_extracted_ptr = (ring_node *) &ring_node_swf1_extracted;

341

ring_node_swf2_extracted_ptr = (ring_node *) &ring_node_swf2_extracted;

341

ring_node_swf2_extracted_ptr = (ring_node *) &ring_node_swf2_extracted;

342

343

status = get_message_queue_id_send( &queue_id );

343

status = get_message_queue_id_send( &queue_id );

344

if (status != RTEMS_SUCCESSFUL)

344

if (status != RTEMS_SUCCESSFUL)

345

{

345

{

346

PRINTF1("in WFRM *** ERR get_message_queue_id_send %d\n", status);

346

PRINTF1("in WFRM *** ERR get_message_queue_id_send %d\n", status);

347

}

347

}

348

349

BOOT_PRINTF("in WFRM ***\n");

349

BOOT_PRINTF("in WFRM ***\n");

350

351

while(1){

351

while(1){

352

// wait for an RTEMS_EVENT

352

// wait for an RTEMS_EVENT

353

rtems_event_receive(RTEMS_EVENT_MODE_NORMAL | RTEMS_EVENT_SWF_RESYNCH,

353

rtems_event_receive(RTEMS_EVENT_MODE_NORMAL | RTEMS_EVENT_SWF_RESYNCH,

354

RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);

354

RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);

355

356

if (event_out == RTEMS_EVENT_MODE_NORMAL)

356

if (event_out == RTEMS_EVENT_MODE_NORMAL)

357

{

357

{

358

DEBUG_PRINTF("WFRM received RTEMS_EVENT_MODE_SBM2\n");

358

DEBUG_PRINTF("WFRM received RTEMS_EVENT_MODE_SBM2\n");

359

ring_node_to_send_swf_f0->sid = SID_NORM_SWF_F0;

359

ring_node_to_send_swf_f0->sid = SID_NORM_SWF_F0;

360

ring_node_swf1_extracted_ptr->sid = SID_NORM_SWF_F1;

360

ring_node_swf1_extracted_ptr->sid = SID_NORM_SWF_F1;

361

ring_node_swf2_extracted_ptr->sid = SID_NORM_SWF_F2;

361

ring_node_swf2_extracted_ptr->sid = SID_NORM_SWF_F2;

362

status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f0, sizeof( ring_node* ) );

362

status = rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f0, sizeof( ring_node* ) );

363

status = rtems_message_queue_send( queue_id, &ring_node_swf1_extracted_ptr, sizeof( ring_node* ) );

363

status = rtems_message_queue_send( queue_id, &ring_node_swf1_extracted_ptr, sizeof( ring_node* ) );

364

status = rtems_message_queue_send( queue_id, &ring_node_swf2_extracted_ptr, sizeof( ring_node* ) );

364

status = rtems_message_queue_send( queue_id, &ring_node_swf2_extracted_ptr, sizeof( ring_node* ) );

365

}

365

}

366

if (event_out == RTEMS_EVENT_SWF_RESYNCH)

366

if (event_out == RTEMS_EVENT_SWF_RESYNCH)

367

{

367

{

368

snapshot_resynchronization( (unsigned char *) &ring_node_to_send_swf_f0->coarseTime );

368

snapshot_resynchronization( (unsigned char *) &ring_node_to_send_swf_f0->coarseTime );

369

}

369

}

370

}

370

}

371

}

371

}

372

373

rtems_task cwf3_task(rtems_task_argument argument) //used with the waveform picker VHDL IP

373

rtems_task cwf3_task(rtems_task_argument argument) //used with the waveform picker VHDL IP

374

{

374

{

375

/** This RTEMS task is dedicated to the transmission of continuous waveforms at f3.

375

/** This RTEMS task is dedicated to the transmission of continuous waveforms at f3.

376

*

376

*

377

* @param unused is the starting argument of the RTEMS task

377

* @param unused is the starting argument of the RTEMS task

378

*

378

*

379

* The following data packet is sent by this task:

379

* The following data packet is sent by this task:

380

* - TM_LFR_SCIENCE_NORMAL_CWF_F3

380

* - TM_LFR_SCIENCE_NORMAL_CWF_F3

381

*

381

*

382

*/

382

*/

383

384

rtems_event_set event_out;

384

rtems_event_set event_out;

385

rtems_id queue_id;

385

rtems_id queue_id;

386

rtems_status_code status;

386

rtems_status_code status;

387

ring_node ring_node_cwf3_light;

387

ring_node ring_node_cwf3_light;

388

ring_node *ring_node_to_send_cwf;

388

ring_node *ring_node_to_send_cwf;

389

390

status = get_message_queue_id_send( &queue_id );

390

status = get_message_queue_id_send( &queue_id );

391

if (status != RTEMS_SUCCESSFUL)

391

if (status != RTEMS_SUCCESSFUL)

392

{

392

{

393

PRINTF1("in CWF3 *** ERR get_message_queue_id_send %d\n", status)

393

PRINTF1("in CWF3 *** ERR get_message_queue_id_send %d\n", status)

394

}

394

}

395

396

ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_LONG_F3;

396

ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_LONG_F3;

397

398

// init the ring_node_cwf3_light structure

398

// init the ring_node_cwf3_light structure

399

ring_node_cwf3_light.buffer_address = (int) wf_cont_f3_light;

399

ring_node_cwf3_light.buffer_address = (int) wf_cont_f3_light;

400

ring_node_cwf3_light.coarseTime = 0x00;

400

ring_node_cwf3_light.coarseTime = 0x00;

401

ring_node_cwf3_light.fineTime = 0x00;

401

ring_node_cwf3_light.fineTime = 0x00;

402

ring_node_cwf3_light.next = NULL;

402

ring_node_cwf3_light.next = NULL;

403

ring_node_cwf3_light.previous = NULL;

403

ring_node_cwf3_light.previous = NULL;

404

ring_node_cwf3_light.sid = SID_NORM_CWF_F3;

404

ring_node_cwf3_light.sid = SID_NORM_CWF_F3;

405

ring_node_cwf3_light.status = 0x00;

405

ring_node_cwf3_light.status = 0x00;

406

407

BOOT_PRINTF("in CWF3 ***\n")

407

BOOT_PRINTF("in CWF3 ***\n")

408

409

while(1){

409

while(1){

410

// wait for an RTEMS_EVENT

410

// wait for an RTEMS_EVENT

411

rtems_event_receive( RTEMS_EVENT_0,

411

rtems_event_receive( RTEMS_EVENT_0,

412

RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);

412

RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);

413

if ( (lfrCurrentMode == LFR_MODE_NORMAL)

413

if ( (lfrCurrentMode == LFR_MODE_NORMAL)

414

|| (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode==LFR_MODE_SBM2) )

414

|| (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode==LFR_MODE_SBM2) )

415

{

415

{

416

ring_node_to_send_cwf = getRingNodeToSendCWF( 3 );

416

ring_node_to_send_cwf = getRingNodeToSendCWF( 3 );

417

if ( (parameter_dump_packet.sy_lfr_n_cwf_long_f3 & 0x01) == 0x01)

417

if ( (parameter_dump_packet.sy_lfr_n_cwf_long_f3 & 0x01) == 0x01)

418

{

418

{

419

PRINTF("send CWF_LONG_F3\n")

419

PRINTF("send CWF_LONG_F3\n")

420

ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_LONG_F3;

420

ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_LONG_F3;

421

status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf, sizeof( ring_node* ) );

421

status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf, sizeof( ring_node* ) );

422

}

422

}

423

else

423

else

424

{

424

{

425

PRINTF("send CWF_F3 (light)\n")

425

PRINTF("send CWF_F3 (light)\n")

426

send_waveform_CWF3_light( ring_node_to_send_cwf, &ring_node_cwf3_light, queue_id );

426

send_waveform_CWF3_light( ring_node_to_send_cwf, &ring_node_cwf3_light, queue_id );

427

}

427

}

428

429

}

429

}

430

else

430

else

431

{

431

{

432

PRINTF1("in CWF3 *** lfrCurrentMode is %d, no data will be sent\n", lfrCurrentMode)

432

PRINTF1("in CWF3 *** lfrCurrentMode is %d, no data will be sent\n", lfrCurrentMode)

433

}

433

}

434

}

434

}

435

}

435

}

436

437

rtems_task cwf2_task(rtems_task_argument argument) // ONLY USED IN BURST AND SBM2

437

rtems_task cwf2_task(rtems_task_argument argument) // ONLY USED IN BURST AND SBM2

438

{

438

{

439

/** This RTEMS task is dedicated to the transmission of continuous waveforms at f2.

439

/** This RTEMS task is dedicated to the transmission of continuous waveforms at f2.

440

*

440

*

441

* @param unused is the starting argument of the RTEMS task

441

* @param unused is the starting argument of the RTEMS task

442

*

442

*

443

* The following data packet is sent by this function:

443

* The following data packet is sent by this function:

444

* - TM_LFR_SCIENCE_BURST_CWF_F2

444

* - TM_LFR_SCIENCE_BURST_CWF_F2

445

* - TM_LFR_SCIENCE_SBM2_CWF_F2

445

* - TM_LFR_SCIENCE_SBM2_CWF_F2

446

*

446

*

447

*/

447

*/

448

449

rtems_event_set event_out;

449

rtems_event_set event_out;

450

rtems_id queue_id;

450

rtems_id queue_id;

451

rtems_status_code status;

451

rtems_status_code status;

452

ring_node *ring_node_to_send;

452

ring_node *ring_node_to_send;

453

unsigned long long int acquisitionTimeF0_asLong;

453

unsigned long long int acquisitionTimeF0_asLong;

454

455

acquisitionTimeF0_asLong = 0x00;

455

acquisitionTimeF0_asLong = 0x00;

456

457

status = get_message_queue_id_send( &queue_id );

457

status = get_message_queue_id_send( &queue_id );

458

if (status != RTEMS_SUCCESSFUL)

458

if (status != RTEMS_SUCCESSFUL)

459

{

459

{

460

PRINTF1("in CWF2 *** ERR get_message_queue_id_send %d\n", status)

460

PRINTF1("in CWF2 *** ERR get_message_queue_id_send %d\n", status)

461

}

461

}

462

463

BOOT_PRINTF("in CWF2 ***\n")

463

BOOT_PRINTF("in CWF2 ***\n")

464

465

while(1){

465

while(1){

466

// wait for an RTEMS_EVENT// send the snapshot when built

466

// wait for an RTEMS_EVENT// send the snapshot when built

467

status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM2 );

467

status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM2 );

468

rtems_event_receive( RTEMS_EVENT_MODE_NORM_S1_S2 | RTEMS_EVENT_MODE_BURST,

468

rtems_event_receive( RTEMS_EVENT_MODE_NORM_S1_S2 | RTEMS_EVENT_MODE_BURST,

469

RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);

469

RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);

470

ring_node_to_send = getRingNodeToSendCWF( 2 );

470

ring_node_to_send = getRingNodeToSendCWF( 2 );

471

if (event_out == RTEMS_EVENT_MODE_BURST)

471

if (event_out == RTEMS_EVENT_MODE_BURST)

472

{

472

{

473

status = rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) );

473

status = rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) );

474

}

474

}

475

else if (event_out == RTEMS_EVENT_MODE_NORM_S1_S2)

475

else if (event_out == RTEMS_EVENT_MODE_NORM_S1_S2)

476

{

476

{

477

if ( lfrCurrentMode == LFR_MODE_SBM2 )

477

if ( lfrCurrentMode == LFR_MODE_SBM2 )

478

{

478

{

479

status = rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) );

479

status = rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) );

480

}

480

}

481

// launch snapshot extraction if needed

481

// launch snapshot extraction if needed

482

if (extractSWF2 == true)

482

if (extractSWF2 == true)

483

{

483

{

484

ring_node_to_send_swf_f2 = ring_node_to_send_cwf_f2;

484

ring_node_to_send_swf_f2 = ring_node_to_send_cwf_f2;

485

// extract the snapshot

485

// extract the snapshot

486

build_snapshot_from_ring( ring_node_to_send_swf_f2, 2, acquisitionTimeF0_asLong,

486

build_snapshot_from_ring( ring_node_to_send_swf_f2, 2, acquisitionTimeF0_asLong,

487

&ring_node_swf2_extracted, swf2_extracted );

487

&ring_node_swf2_extracted, swf2_extracted );

488

extractSWF2 = false;

488

extractSWF2 = false;

489

swf2_ready = true; // once the snapshot at f2 is ready the CWF1 task will send an event to WFRM

489

swf2_ready = true; // once the snapshot at f2 is ready the CWF1 task will send an event to WFRM

490

}

490

}

491

if (swf0_ready_flag_f2 == true)

491

if (swf0_ready_flag_f2 == true)

492

{

492

{

493

extractSWF2 = true;

493

extractSWF2 = true;

494

// record the acquition time of the f0 snapshot to use to build the snapshot at f2

494

// record the acquition time of the f0 snapshot to use to build the snapshot at f2

495

acquisitionTimeF0_asLong = get_acquisition_time( (unsigned char *) &ring_node_to_send_swf_f0->coarseTime );

495

acquisitionTimeF0_asLong = get_acquisition_time( (unsigned char *) &ring_node_to_send_swf_f0->coarseTime );

496

swf0_ready_flag_f2 = false;

496

swf0_ready_flag_f2 = false;

497

}

497

}

498

}

498

}

499

}

499

}

500

}

500

}

501

502

rtems_task cwf1_task(rtems_task_argument argument) // ONLY USED IN SBM1

502

rtems_task cwf1_task(rtems_task_argument argument) // ONLY USED IN SBM1

503

{

503

{

504

/** This RTEMS task is dedicated to the transmission of continuous waveforms at f1.

504

/** This RTEMS task is dedicated to the transmission of continuous waveforms at f1.

505

*

505

*

506

* @param unused is the starting argument of the RTEMS task

506

* @param unused is the starting argument of the RTEMS task

507

*

507

*

508

* The following data packet is sent by this function:

508

* The following data packet is sent by this function:

509

* - TM_LFR_SCIENCE_SBM1_CWF_F1

509

* - TM_LFR_SCIENCE_SBM1_CWF_F1

510

*

510

*

511

*/

511

*/

512

513

rtems_event_set event_out;

513

rtems_event_set event_out;

514

rtems_id queue_id;

514

rtems_id queue_id;

515

rtems_status_code status;

515

rtems_status_code status;

516

517

ring_node *ring_node_to_send_cwf;

517

ring_node *ring_node_to_send_cwf;

518

519

status = get_message_queue_id_send( &queue_id );

519

status = get_message_queue_id_send( &queue_id );

520

if (status != RTEMS_SUCCESSFUL)

520

if (status != RTEMS_SUCCESSFUL)

521

{

521

{

522

PRINTF1("in CWF1 *** ERR get_message_queue_id_send %d\n", status)

522

PRINTF1("in CWF1 *** ERR get_message_queue_id_send %d\n", status)

523

}

523

}

524

525

BOOT_PRINTF("in CWF1 ***\n");

525

BOOT_PRINTF("in CWF1 ***\n");

526

527

while(1){

527

while(1){

528

// wait for an RTEMS_EVENT

528

// wait for an RTEMS_EVENT

529

rtems_event_receive( RTEMS_EVENT_MODE_NORM_S1_S2,

529

rtems_event_receive( RTEMS_EVENT_MODE_NORM_S1_S2,

530

RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);

530

RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);

531

ring_node_to_send_cwf = getRingNodeToSendCWF( 1 );

531

ring_node_to_send_cwf = getRingNodeToSendCWF( 1 );

532

ring_node_to_send_cwf_f1->sid = SID_SBM1_CWF_F1;

532

ring_node_to_send_cwf_f1->sid = SID_SBM1_CWF_F1;

533

if (lfrCurrentMode == LFR_MODE_SBM1)

533

if (lfrCurrentMode == LFR_MODE_SBM1)

534

{

534

{

535

status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf, sizeof( ring_node* ) );

535

status = rtems_message_queue_send( queue_id, &ring_node_to_send_cwf, sizeof( ring_node* ) );

536

if (status != 0)

536

if (status != 0)

537

{

537

{

538

PRINTF("cwf sending failed\n")

538

PRINTF("cwf sending failed\n")

539

}

539

}

540

}

540

}

541

// launch snapshot extraction if needed

541

// launch snapshot extraction if needed

542

if (extractSWF1 == true)

542

if (extractSWF1 == true)

543

{

543

{

544

ring_node_to_send_swf_f1 = ring_node_to_send_cwf;

544

ring_node_to_send_swf_f1 = ring_node_to_send_cwf;

545

// launch the snapshot extraction

545

// launch the snapshot extraction

546

status = rtems_event_send( Task_id[TASKID_SWBD], RTEMS_EVENT_MODE_NORM_S1_S2 );

546

status = rtems_event_send( Task_id[TASKID_SWBD], RTEMS_EVENT_MODE_NORM_S1_S2 );

547

extractSWF1 = false;

547

extractSWF1 = false;

548

}

548

}

549

if (swf0_ready_flag_f1 == true)

549

if (swf0_ready_flag_f1 == true)

550

{

550

{

551

extractSWF1 = true;

551

extractSWF1 = true;

552

swf0_ready_flag_f1 = false; // this step shall be executed only one time

552

swf0_ready_flag_f1 = false; // this step shall be executed only one time

553

}

553

}

554

if ((swf1_ready == true) && (swf2_ready == true)) // swf_f1 is ready after the extraction

554

if ((swf1_ready == true) && (swf2_ready == true)) // swf_f1 is ready after the extraction

555

{

555

{

556

status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_NORMAL );

556

status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_NORMAL );

557

swf1_ready = false;

557

swf1_ready = false;

558

swf2_ready = false;

558

swf2_ready = false;

559

}

559

}

560

}

560

}

561

}

561

}

562

563

rtems_task swbd_task(rtems_task_argument argument)

563

rtems_task swbd_task(rtems_task_argument argument)

564

{

564

{

565

/** This RTEMS task is dedicated to the building of snapshots from different continuous waveforms buffers.

565

/** This RTEMS task is dedicated to the building of snapshots from different continuous waveforms buffers.

566

*

566

*

567

* @param unused is the starting argument of the RTEMS task

567

* @param unused is the starting argument of the RTEMS task

568

*

568

*

569

*/

569

*/

570

571

rtems_event_set event_out;

571

rtems_event_set event_out;

572

unsigned long long int acquisitionTimeF0_asLong;

572

unsigned long long int acquisitionTimeF0_asLong;

573

574

acquisitionTimeF0_asLong = 0x00;

574

acquisitionTimeF0_asLong = 0x00;

575

576

BOOT_PRINTF("in SWBD ***\n")

576

BOOT_PRINTF("in SWBD ***\n")

577

578

while(1){

578

while(1){

579

// wait for an RTEMS_EVENT

579

// wait for an RTEMS_EVENT

580

rtems_event_receive( RTEMS_EVENT_MODE_NORM_S1_S2,

580

rtems_event_receive( RTEMS_EVENT_MODE_NORM_S1_S2,

581

RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);

581

RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);

582

if (event_out == RTEMS_EVENT_MODE_NORM_S1_S2)

582

if (event_out == RTEMS_EVENT_MODE_NORM_S1_S2)

583

{

583

{

584

acquisitionTimeF0_asLong = get_acquisition_time( (unsigned char *) &ring_node_to_send_swf_f0->coarseTime );

584

acquisitionTimeF0_asLong = get_acquisition_time( (unsigned char *) &ring_node_to_send_swf_f0->coarseTime );

585

build_snapshot_from_ring( ring_node_to_send_swf_f1, 1, acquisitionTimeF0_asLong,

585

build_snapshot_from_ring( ring_node_to_send_swf_f1, 1, acquisitionTimeF0_asLong,

586

&ring_node_swf1_extracted, swf1_extracted );

586

&ring_node_swf1_extracted, swf1_extracted );

587

swf1_ready = true; // the snapshot has been extracted and is ready to be sent

587

swf1_ready = true; // the snapshot has been extracted and is ready to be sent

588

}

588

}

589

else

589

else

590

{

590

{

591

PRINTF1("in SWBD *** unexpected rtems event received %x\n", (int) event_out)

591

PRINTF1("in SWBD *** unexpected rtems event received %x\n", (int) event_out)

592

}

592

}

593

}

593

}

594

}

594

}

595

596

//******************

596

//******************

597

// general functions

597

// general functions

598

599

void WFP_init_rings( void )

599

void WFP_init_rings( void )

600

{

600

{

601

// F0 RING

601

// F0 RING

602

init_ring( waveform_ring_f0, NB_RING_NODES_F0, wf_buffer_f0, WFRM_BUFFER );

602

init_ring( waveform_ring_f0, NB_RING_NODES_F0, wf_buffer_f0, WFRM_BUFFER );

603

// F1 RING

603

// F1 RING

604

init_ring( waveform_ring_f1, NB_RING_NODES_F1, wf_buffer_f1, WFRM_BUFFER );

604

init_ring( waveform_ring_f1, NB_RING_NODES_F1, wf_buffer_f1, WFRM_BUFFER );

605

// F2 RING

605

// F2 RING

606

init_ring( waveform_ring_f2, NB_RING_NODES_F2, wf_buffer_f2, WFRM_BUFFER );

606

init_ring( waveform_ring_f2, NB_RING_NODES_F2, wf_buffer_f2, WFRM_BUFFER );

607

// F3 RING

607

// F3 RING

608

init_ring( waveform_ring_f3, NB_RING_NODES_F3, wf_buffer_f3, WFRM_BUFFER );

608

init_ring( waveform_ring_f3, NB_RING_NODES_F3, wf_buffer_f3, WFRM_BUFFER );

609

610

ring_node_swf1_extracted.buffer_address = (int) swf1_extracted;

610

ring_node_swf1_extracted.buffer_address = (int) swf1_extracted;

611

ring_node_swf2_extracted.buffer_address = (int) swf2_extracted;

611

ring_node_swf2_extracted.buffer_address = (int) swf2_extracted;

612

613

DEBUG_PRINTF1("waveform_ring_f0 @%x\n", (unsigned int) waveform_ring_f0)

613

DEBUG_PRINTF1("waveform_ring_f0 @%x\n", (unsigned int) waveform_ring_f0)

614

DEBUG_PRINTF1("waveform_ring_f1 @%x\n", (unsigned int) waveform_ring_f1)

614

DEBUG_PRINTF1("waveform_ring_f1 @%x\n", (unsigned int) waveform_ring_f1)

615

DEBUG_PRINTF1("waveform_ring_f2 @%x\n", (unsigned int) waveform_ring_f2)

615

DEBUG_PRINTF1("waveform_ring_f2 @%x\n", (unsigned int) waveform_ring_f2)

616

DEBUG_PRINTF1("waveform_ring_f3 @%x\n", (unsigned int) waveform_ring_f3)

616

DEBUG_PRINTF1("waveform_ring_f3 @%x\n", (unsigned int) waveform_ring_f3)

617

DEBUG_PRINTF1("wf_buffer_f0 @%x\n", (unsigned int) wf_buffer_f0)

617

DEBUG_PRINTF1("wf_buffer_f0 @%x\n", (unsigned int) wf_buffer_f0)

618

DEBUG_PRINTF1("wf_buffer_f1 @%x\n", (unsigned int) wf_buffer_f1)

618

DEBUG_PRINTF1("wf_buffer_f1 @%x\n", (unsigned int) wf_buffer_f1)

619

DEBUG_PRINTF1("wf_buffer_f2 @%x\n", (unsigned int) wf_buffer_f2)

619

DEBUG_PRINTF1("wf_buffer_f2 @%x\n", (unsigned int) wf_buffer_f2)

620

DEBUG_PRINTF1("wf_buffer_f3 @%x\n", (unsigned int) wf_buffer_f3)

620

DEBUG_PRINTF1("wf_buffer_f3 @%x\n", (unsigned int) wf_buffer_f3)

621

622

}

622

}

623

624

void WFP_reset_current_ring_nodes( void )

624

void WFP_reset_current_ring_nodes( void )

625

{

625

{

626

current_ring_node_f0 = waveform_ring_f0[0].next;

626

current_ring_node_f0 = waveform_ring_f0[0].next;

627

current_ring_node_f1 = waveform_ring_f1[0].next;

627

current_ring_node_f1 = waveform_ring_f1[0].next;

628

current_ring_node_f2 = waveform_ring_f2[0].next;

628

current_ring_node_f2 = waveform_ring_f2[0].next;

629

current_ring_node_f3 = waveform_ring_f3[0].next;

629

current_ring_node_f3 = waveform_ring_f3[0].next;

630

631

ring_node_to_send_swf_f0 = waveform_ring_f0;

631

ring_node_to_send_swf_f0 = waveform_ring_f0;

632

ring_node_to_send_swf_f1 = waveform_ring_f1;

632

ring_node_to_send_swf_f1 = waveform_ring_f1;

633

ring_node_to_send_swf_f2 = waveform_ring_f2;

633

ring_node_to_send_swf_f2 = waveform_ring_f2;

634

635

ring_node_to_send_cwf_f1 = waveform_ring_f1;

635

ring_node_to_send_cwf_f1 = waveform_ring_f1;

636

ring_node_to_send_cwf_f2 = waveform_ring_f2;

636

ring_node_to_send_cwf_f2 = waveform_ring_f2;

637

ring_node_to_send_cwf_f3 = waveform_ring_f3;

637

ring_node_to_send_cwf_f3 = waveform_ring_f3;

638

}

638

}

639

640

int send_waveform_CWF3_light( ring_node *ring_node_to_send, ring_node *ring_node_cwf3_light, rtems_id queue_id )

640

int send_waveform_CWF3_light( ring_node *ring_node_to_send, ring_node *ring_node_cwf3_light, rtems_id queue_id )

641

{

641

{

642

/** This function sends CWF_F3 CCSDS packets without the b1, b2 and b3 data.

642

/** This function sends CWF_F3 CCSDS packets without the b1, b2 and b3 data.

643

*

643

*

644

* @param waveform points to the buffer containing the data that will be send.

644

* @param waveform points to the buffer containing the data that will be send.

645

* @param headerCWF points to a table of headers that have been prepared for the data transmission.

645

* @param headerCWF points to a table of headers that have been prepared for the data transmission.

646

* @param queue_id is the id of the rtems queue to which spw_ioctl_pkt_send structures will be send. The structures

646

* @param queue_id is the id of the rtems queue to which spw_ioctl_pkt_send structures will be send. The structures

647

* contain information to setup the transmission of the data packets.

647

* contain information to setup the transmission of the data packets.

648

*

648

*

649

* By default, CWF_F3 packet are send without the b1, b2 and b3 data. This function rebuilds a data buffer

649

* By default, CWF_F3 packet are send without the b1, b2 and b3 data. This function rebuilds a data buffer

650

* from the incoming data and sends it in 7 packets, 6 containing 340 blocks and 1 one containing 8 blocks.

650

* from the incoming data and sends it in 7 packets, 6 containing 340 blocks and 1 one containing 8 blocks.

651

*

651

*

652

*/

652

*/

653

654

unsigned int i;

654

unsigned int i;

655

int ret;

655

int ret;

656

rtems_status_code status;

656

rtems_status_code status;

657

658

char *sample;

658

char *sample;

659

int *dataPtr;

659

int *dataPtr;

660

661

ret = LFR_DEFAULT;

661

ret = LFR_DEFAULT;

662

663

dataPtr = (int*) ring_node_to_send->buffer_address;

663

dataPtr = (int*) ring_node_to_send->buffer_address;

664

665

ring_node_cwf3_light->coarseTime = ring_node_to_send->coarseTime;

665

ring_node_cwf3_light->coarseTime = ring_node_to_send->coarseTime;

666

ring_node_cwf3_light->fineTime = ring_node_to_send->fineTime;

666

ring_node_cwf3_light->fineTime = ring_node_to_send->fineTime;

667

668

//**********************

668

//**********************

669

// BUILD CWF3_light DATA

669

// BUILD CWF3_light DATA

670

for ( i=0; i< NB_SAMPLES_PER_SNAPSHOT; i++)

670

for ( i=0; i< NB_SAMPLES_PER_SNAPSHOT; i++)

671

{

671

{

672

sample = (char*) &dataPtr[ (i * NB_WORDS_SWF_BLK) ];

672

sample = (char*) &dataPtr[ (i * NB_WORDS_SWF_BLK) ];

673

wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) ] = sample[ 0 ];

673

wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) ] = sample[ 0 ];

674

wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 1 ] = sample[ 1 ];

674

wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 1 ] = sample[ 1 ];

675

wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 2 ] = sample[ 2 ];

675

wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 2 ] = sample[ 2 ];

676

wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 3 ] = sample[ 3 ];

676

wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 3 ] = sample[ 3 ];

677

wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 4 ] = sample[ 4 ];

677

wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 4 ] = sample[ 4 ];

678

wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 5 ] = sample[ 5 ];

678

wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 5 ] = sample[ 5 ];

679

}

679

}

680

681

// SEND PACKET

681

// SEND PACKET

682

status = rtems_message_queue_send( queue_id, &ring_node_cwf3_light, sizeof( ring_node* ) );

682

status = rtems_message_queue_send( queue_id, &ring_node_cwf3_light, sizeof( ring_node* ) );

683

if (status != RTEMS_SUCCESSFUL) {

683

if (status != RTEMS_SUCCESSFUL) {

684

ret = LFR_DEFAULT;

684

ret = LFR_DEFAULT;

685

}

685

}

686

687

return ret;

687

return ret;

688

}

688

}

689

690

void compute_acquisition_time( unsigned int coarseTime, unsigned int fineTime,

690

void compute_acquisition_time( unsigned int coarseTime, unsigned int fineTime,

691

unsigned int sid, unsigned char pa_lfr_pkt_nr, unsigned char * acquisitionTime )

691

unsigned int sid, unsigned char pa_lfr_pkt_nr, unsigned char * acquisitionTime )

692

{

692

{

693

unsigned long long int acquisitionTimeAsLong;

693

unsigned long long int acquisitionTimeAsLong;

694

unsigned char localAcquisitionTime[6];

694

unsigned char localAcquisitionTime[6];

695

double deltaT;

695

double deltaT;

696

697

deltaT = 0.;

697

deltaT = 0.;

698

699

localAcquisitionTime[0] = (unsigned char) ( coarseTime >> 24 );

699

localAcquisitionTime[0] = (unsigned char) ( coarseTime >> 24 );

700

localAcquisitionTime[1] = (unsigned char) ( coarseTime >> 16 );

700

localAcquisitionTime[1] = (unsigned char) ( coarseTime >> 16 );

701

localAcquisitionTime[2] = (unsigned char) ( coarseTime >> 8 );

701

localAcquisitionTime[2] = (unsigned char) ( coarseTime >> 8 );

702

localAcquisitionTime[3] = (unsigned char) ( coarseTime );

702

localAcquisitionTime[3] = (unsigned char) ( coarseTime );

703

localAcquisitionTime[4] = (unsigned char) ( fineTime >> 8 );

703

localAcquisitionTime[4] = (unsigned char) ( fineTime >> 8 );

704

localAcquisitionTime[5] = (unsigned char) ( fineTime );

704

localAcquisitionTime[5] = (unsigned char) ( fineTime );

705

706

acquisitionTimeAsLong = ( (unsigned long long int) localAcquisitionTime[0] << 40 )

706

acquisitionTimeAsLong = ( (unsigned long long int) localAcquisitionTime[0] << 40 )

707

+ ( (unsigned long long int) localAcquisitionTime[1] << 32 )

707

+ ( (unsigned long long int) localAcquisitionTime[1] << 32 )

708

+ ( (unsigned long long int) localAcquisitionTime[2] << 24 )

708

+ ( (unsigned long long int) localAcquisitionTime[2] << 24 )

709

+ ( (unsigned long long int) localAcquisitionTime[3] << 16 )

709

+ ( (unsigned long long int) localAcquisitionTime[3] << 16 )

710

+ ( (unsigned long long int) localAcquisitionTime[4] << 8 )

710

+ ( (unsigned long long int) localAcquisitionTime[4] << 8 )

711

+ ( (unsigned long long int) localAcquisitionTime[5] );

711

+ ( (unsigned long long int) localAcquisitionTime[5] );

712

713

switch( sid )

713

switch( sid )

714

{

714

{

715

case SID_NORM_SWF_F0:

715

case SID_NORM_SWF_F0:

716

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 24576. ;

716

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 24576. ;

717

break;

717

break;

718

719

case SID_NORM_SWF_F1:

719

case SID_NORM_SWF_F1:

720

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 4096. ;

720

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 4096. ;

721

break;

721

break;

722

723

case SID_NORM_SWF_F2:

723

case SID_NORM_SWF_F2:

724

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 256. ;

724

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 256. ;

725

break;

725

break;

726

727

case SID_SBM1_CWF_F1:

727

case SID_SBM1_CWF_F1:

728

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 4096. ;

728

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 4096. ;

729

break;

729

break;

730

731

case SID_SBM2_CWF_F2:

731

case SID_SBM2_CWF_F2:

732

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 256. ;

732

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 256. ;

733

break;

733

break;

734

735

case SID_BURST_CWF_F2:

735

case SID_BURST_CWF_F2:

736

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 256. ;

736

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 256. ;

737

break;

737

break;

738

739

case SID_NORM_CWF_F3:

739

case SID_NORM_CWF_F3:

740

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF_SHORT_F3 * 65536. / 16. ;

740

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF_SHORT_F3 * 65536. / 16. ;

741

break;

741

break;

742

743

case SID_NORM_CWF_LONG_F3:

743

case SID_NORM_CWF_LONG_F3:

744

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 16. ;

744

deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 16. ;

745

break;

745

break;

746

747

default:

747

default:

748

PRINTF1("in compute_acquisition_time *** ERR unexpected sid %d\n", sid)

748

PRINTF1("in compute_acquisition_time *** ERR unexpected sid %d\n", sid)

749

deltaT = 0.;

749

deltaT = 0.;

750

break;

750

break;

751

}

751

}

752

753

acquisitionTimeAsLong = acquisitionTimeAsLong + (unsigned long long int) deltaT;

753

acquisitionTimeAsLong = acquisitionTimeAsLong + (unsigned long long int) deltaT;

754

//

754

//

755

acquisitionTime[0] = (unsigned char) (acquisitionTimeAsLong >> 40);

755

acquisitionTime[0] = (unsigned char) (acquisitionTimeAsLong >> 40);

756

acquisitionTime[1] = (unsigned char) (acquisitionTimeAsLong >> 32);

756

acquisitionTime[1] = (unsigned char) (acquisitionTimeAsLong >> 32);

757

acquisitionTime[2] = (unsigned char) (acquisitionTimeAsLong >> 24);

757

acquisitionTime[2] = (unsigned char) (acquisitionTimeAsLong >> 24);

758

acquisitionTime[3] = (unsigned char) (acquisitionTimeAsLong >> 16);

758

acquisitionTime[3] = (unsigned char) (acquisitionTimeAsLong >> 16);

759

acquisitionTime[4] = (unsigned char) (acquisitionTimeAsLong >> 8 );

759

acquisitionTime[4] = (unsigned char) (acquisitionTimeAsLong >> 8 );

760

acquisitionTime[5] = (unsigned char) (acquisitionTimeAsLong );

760

acquisitionTime[5] = (unsigned char) (acquisitionTimeAsLong );

761

762

}

762

}

763

764

void build_snapshot_from_ring( ring_node *ring_node_to_send,

764

void build_snapshot_from_ring( ring_node *ring_node_to_send,

765

unsigned char frequencyChannel,

765

unsigned char frequencyChannel,

766

unsigned long long int acquisitionTimeF0_asLong,

766

unsigned long long int acquisitionTimeF0_asLong,

767

ring_node *ring_node_swf_extracted,

767

ring_node *ring_node_swf_extracted,

768

int *swf_extracted)

768

int *swf_extracted)

769

{

769

{

770

unsigned int i;

770

unsigned int i;

771

unsigned long long int centerTime_asLong;

771

unsigned long long int centerTime_asLong;

772

unsigned long long int acquisitionTime_asLong;

772

unsigned long long int acquisitionTime_asLong;

773

unsigned long long int bufferAcquisitionTime_asLong;

773

unsigned long long int bufferAcquisitionTime_asLong;

774

unsigned char *ptr1;

774

unsigned char *ptr1;

775

unsigned char *ptr2;

775

unsigned char *ptr2;

776

unsigned char *timeCharPtr;

776

unsigned char *timeCharPtr;

777

unsigned char nb_ring_nodes;

777

unsigned char nb_ring_nodes;

778

unsigned long long int frequency_asLong;

778

unsigned long long int frequency_asLong;

779

unsigned long long int nbTicksPerSample_asLong;

779

unsigned long long int nbTicksPerSample_asLong;

780

unsigned long long int nbSamplesPart1_asLong;

780

unsigned long long int nbSamplesPart1_asLong;

781

unsigned long long int sampleOffset_asLong;

781

unsigned long long int sampleOffset_asLong;

782

783

unsigned int deltaT_F0;

783

unsigned int deltaT_F0;

784

unsigned int deltaT_F1;

784

unsigned int deltaT_F1;

785

unsigned long long int deltaT_F2;

785

unsigned long long int deltaT_F2;

786

787

deltaT_F0 = 2731; // (2048. / 24576. / 2.) * 65536. = 2730.667;

787

deltaT_F0 = 2731; // (2048. / 24576. / 2.) * 65536. = 2730.667;

788

deltaT_F1 = 16384; // (2048. / 4096. / 2.) * 65536. = 16384;

788

deltaT_F1 = 16384; // (2048. / 4096. / 2.) * 65536. = 16384;

789

deltaT_F2 = 262144; // (2048. / 256. / 2.) * 65536. = 262144;

789

deltaT_F2 = 262144; // (2048. / 256. / 2.) * 65536. = 262144;

790

sampleOffset_asLong = 0x00;

790

sampleOffset_asLong = 0x00;

791

792

// (1) get the f0 acquisition time => the value is passed in argument

792

// (1) get the f0 acquisition time => the value is passed in argument

793

794

// (2) compute the central reference time

794

// (2) compute the central reference time

795

centerTime_asLong = acquisitionTimeF0_asLong + deltaT_F0;

795

centerTime_asLong = acquisitionTimeF0_asLong + deltaT_F0;

796

797

// (3) compute the acquisition time of the current snapshot

797

// (3) compute the acquisition time of the current snapshot

798

switch(frequencyChannel)

798

switch(frequencyChannel)

799

{

799

{

800

case 1: // 1 is for F1 = 4096 Hz

800

case 1: // 1 is for F1 = 4096 Hz

801

acquisitionTime_asLong = centerTime_asLong - deltaT_F1;

801

acquisitionTime_asLong = centerTime_asLong - deltaT_F1;

802

nb_ring_nodes = NB_RING_NODES_F1;

802

nb_ring_nodes = NB_RING_NODES_F1;

803

frequency_asLong = 4096;

803

frequency_asLong = 4096;

804

nbTicksPerSample_asLong = 16; // 65536 / 4096;

804

nbTicksPerSample_asLong = 16; // 65536 / 4096;

805

break;

805

break;

806

case 2: // 2 is for F2 = 256 Hz

806

case 2: // 2 is for F2 = 256 Hz

807

acquisitionTime_asLong = centerTime_asLong - deltaT_F2;

807

acquisitionTime_asLong = centerTime_asLong - deltaT_F2;

808

nb_ring_nodes = NB_RING_NODES_F2;

808

nb_ring_nodes = NB_RING_NODES_F2;

809

frequency_asLong = 256;

809

frequency_asLong = 256;

810

nbTicksPerSample_asLong = 256; // 65536 / 256;

810

nbTicksPerSample_asLong = 256; // 65536 / 256;

811

break;

811

break;

812

default:

812

default:

813

acquisitionTime_asLong = centerTime_asLong;

813

acquisitionTime_asLong = centerTime_asLong;

814

frequency_asLong = 256;

814

frequency_asLong = 256;

815

nbTicksPerSample_asLong = 256;

815

nbTicksPerSample_asLong = 256;

816

break;

816

break;

817

}

817

}

818

819

//****************************************************************************

819

//****************************************************************************

820

// (4) search the ring_node with the acquisition time <= acquisitionTime_asLong

820

// (4) search the ring_node with the acquisition time <= acquisitionTime_asLong

821

for (i=0; i<nb_ring_nodes; i++)

821

for (i=0; i<nb_ring_nodes; i++)

822

{

822

{

823

//PRINTF1("%d ... ", i);

823

//PRINTF1("%d ... ", i);

824

bufferAcquisitionTime_asLong = get_acquisition_time( (unsigned char *) &ring_node_to_send->coarseTime );

824

bufferAcquisitionTime_asLong = get_acquisition_time( (unsigned char *) &ring_node_to_send->coarseTime );

825

if (bufferAcquisitionTime_asLong <= acquisitionTime_asLong)

825

if (bufferAcquisitionTime_asLong <= acquisitionTime_asLong)

826

{

826

{

827

//PRINTF1("buffer found with acquisition time = %llx\n", bufferAcquisitionTime_asLong);

827

//PRINTF1("buffer found with acquisition time = %llx\n", bufferAcquisitionTime_asLong);

828

break;

828

break;

829

}

829

}

830

ring_node_to_send = ring_node_to_send->previous;

830

ring_node_to_send = ring_node_to_send->previous;

831

}

831

}

832

833

// (5) compute the number of samples to take in the current buffer

833

// (5) compute the number of samples to take in the current buffer

834

sampleOffset_asLong = ((acquisitionTime_asLong - bufferAcquisitionTime_asLong) * frequency_asLong ) >> 16;

834

sampleOffset_asLong = ((acquisitionTime_asLong - bufferAcquisitionTime_asLong) * frequency_asLong ) >> 16;

835

nbSamplesPart1_asLong = NB_SAMPLES_PER_SNAPSHOT - sampleOffset_asLong;

835

nbSamplesPart1_asLong = NB_SAMPLES_PER_SNAPSHOT - sampleOffset_asLong;

836

//PRINTF2("sampleOffset_asLong = %lld, nbSamplesPart1_asLong = %lld\n", sampleOffset_asLong, nbSamplesPart1_asLong);

836

//PRINTF2("sampleOffset_asLong = %lld, nbSamplesPart1_asLong = %lld\n", sampleOffset_asLong, nbSamplesPart1_asLong);

837

838

// (6) compute the final acquisition time

838

// (6) compute the final acquisition time

839

acquisitionTime_asLong = bufferAcquisitionTime_asLong +

839

acquisitionTime_asLong = bufferAcquisitionTime_asLong +

840

sampleOffset_asLong * nbTicksPerSample_asLong;

840

sampleOffset_asLong * nbTicksPerSample_asLong;

841

842

// (7) copy the acquisition time at the beginning of the extrated snapshot

842

// (7) copy the acquisition time at the beginning of the extrated snapshot

843

ptr1 = (unsigned char*) &acquisitionTime_asLong;

843

ptr1 = (unsigned char*) &acquisitionTime_asLong;

844

// fine time

844

// fine time

845

ptr2 = (unsigned char*) &ring_node_swf_extracted->fineTime;

845

ptr2 = (unsigned char*) &ring_node_swf_extracted->fineTime;

846

ptr2[2] = ptr1[ 4 + 2 ];

846

ptr2[2] = ptr1[ 4 + 2 ];

847

ptr2[3] = ptr1[ 5 + 2 ];

847

ptr2[3] = ptr1[ 5 + 2 ];

848

// coarse time

848

// coarse time

849

ptr2 = (unsigned char*) &ring_node_swf_extracted->coarseTime;

849

ptr2 = (unsigned char*) &ring_node_swf_extracted->coarseTime;

850

ptr2[0] = ptr1[ 0 + 2 ];

850

ptr2[0] = ptr1[ 0 + 2 ];

851

ptr2[1] = ptr1[ 1 + 2 ];

851

ptr2[1] = ptr1[ 1 + 2 ];

852

ptr2[2] = ptr1[ 2 + 2 ];

852

ptr2[2] = ptr1[ 2 + 2 ];

853

ptr2[3] = ptr1[ 3 + 2 ];

853

ptr2[3] = ptr1[ 3 + 2 ];

854

855

// re set the synchronization bit

855

// re set the synchronization bit

856

timeCharPtr = (unsigned char*) &ring_node_to_send->coarseTime;

856

timeCharPtr = (unsigned char*) &ring_node_to_send->coarseTime;

857

ptr2[0] = ptr2[0] | (timeCharPtr[0] & 0x80); // [1000 0000]

857

ptr2[0] = ptr2[0] | (timeCharPtr[0] & 0x80); // [1000 0000]

858

859

if ( (nbSamplesPart1_asLong >= NB_SAMPLES_PER_SNAPSHOT) | (nbSamplesPart1_asLong < 0) )

859

if ( (nbSamplesPart1_asLong >= NB_SAMPLES_PER_SNAPSHOT) | (nbSamplesPart1_asLong < 0) )

860

{

860

{

861

nbSamplesPart1_asLong = 0;

861

nbSamplesPart1_asLong = 0;

862

}

862

}

863

// copy the part 1 of the snapshot in the extracted buffer

863

// copy the part 1 of the snapshot in the extracted buffer

864

for ( i = 0; i < (nbSamplesPart1_asLong * NB_WORDS_SWF_BLK); i++ )

864

for ( i = 0; i < (nbSamplesPart1_asLong * NB_WORDS_SWF_BLK); i++ )

865

{

865

{

866

swf_extracted[i] =

866

swf_extracted[i] =

867

((int*) ring_node_to_send->buffer_address)[ i + (sampleOffset_asLong * NB_WORDS_SWF_BLK) ];

867

((int*) ring_node_to_send->buffer_address)[ i + (sampleOffset_asLong * NB_WORDS_SWF_BLK) ];

868

}

868

}

869

// copy the part 2 of the snapshot in the extracted buffer

869

// copy the part 2 of the snapshot in the extracted buffer

870

ring_node_to_send = ring_node_to_send->next;

870

ring_node_to_send = ring_node_to_send->next;

871

for ( i = (nbSamplesPart1_asLong * NB_WORDS_SWF_BLK); i < (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK); i++ )

871

for ( i = (nbSamplesPart1_asLong * NB_WORDS_SWF_BLK); i < (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK); i++ )

872

{

872

{

873

swf_extracted[i] =

873

swf_extracted[i] =

874

((int*) ring_node_to_send->buffer_address)[ (i-(nbSamplesPart1_asLong * NB_WORDS_SWF_BLK)) ];

874

((int*) ring_node_to_send->buffer_address)[ (i-(nbSamplesPart1_asLong * NB_WORDS_SWF_BLK)) ];

875

}

875

}

876

}

876

}

877

878

double computeCorrection( unsigned char *timePtr )

878

double computeCorrection( unsigned char *timePtr )

879

{

879

{

880

unsigned long long int acquisitionTime;

880

unsigned long long int acquisitionTime;

881

unsigned long long int centerTime;

881

unsigned long long int centerTime;

882

unsigned long long int previousTick;

882

unsigned long long int previousTick;

883

unsigned long long int nextTick;

883

unsigned long long int nextTick;

884

unsigned long long int deltaPreviousTick;

884

unsigned long long int deltaPreviousTick;

885

unsigned long long int deltaNextTick;

885

unsigned long long int deltaNextTick;

886

double deltaPrevious_ms;

886

double deltaPrevious_ms;

887

double deltaNext_ms;

887

double deltaNext_ms;

888

double correctionInF2;

888

double correctionInF2;

889

890

// get acquisition time in fine time ticks

890

// get acquisition time in fine time ticks

891

acquisitionTime = get_acquisition_time( timePtr );

891

acquisitionTime = get_acquisition_time( timePtr );

892

893

// compute center time

893

// compute center time

894

centerTime = acquisitionTime + 2731; // (2048. / 24576. / 2.) * 65536. = 2730.667;

894

centerTime = acquisitionTime + 2731; // (2048. / 24576. / 2.) * 65536. = 2730.667;

895

previousTick = centerTime - (centerTime & 0xffff);

895

previousTick = centerTime - (centerTime & 0xffff);

896

nextTick = previousTick + 65536;

896

nextTick = previousTick + 65536;

897

898

deltaPreviousTick = centerTime - previousTick;

898

deltaPreviousTick = centerTime - previousTick;

899

deltaNextTick = nextTick - centerTime;

899

deltaNextTick = nextTick - centerTime;

900

901

deltaPrevious_ms = ((double) deltaPreviousTick) / 65536. * 1000.;

901

deltaPrevious_ms = ((double) deltaPreviousTick) / 65536. * 1000.;

902

deltaNext_ms = ((double) deltaNextTick) / 65536. * 1000.;

902

deltaNext_ms = ((double) deltaNextTick) / 65536. * 1000.;

903

904

PRINTF2(" delta previous = %.3f ms, delta next = %.2f ms\n", deltaPrevious_ms, deltaNext_ms);

904

PRINTF2(" delta previous = %.3f ms, delta next = %.2f ms\n", deltaPrevious_ms, deltaNext_ms);

905

// PRINTF2(" delta previous = %llu fine time ticks, delta next = %llu fine time ticks\n",

906

// deltaPreviousTick, deltaNextTick);

907

905

908

// which tick is the closest?

906

// which tick is the closest?

909

if (deltaPreviousTick > deltaNextTick)

907

if (deltaPreviousTick > deltaNextTick)

910

{

908

{

911

// the snapshot center is just before the second => increase delta_snapshot

909

// the snapshot center is just before the second => increase delta_snapshot

912

correctionInF2 = + (deltaNext_ms * 256. / 1000. );

910

correctionInF2 = + (deltaNext_ms * 256. / 1000. );

913

}

911

}

914

else

912

else

915

{

913

{

916

// the snapshot center is just after the second => decrease delta_snapshot

914

// the snapshot center is just after the second => decrease delta_snapshot

917

correctionInF2 = - (deltaPrevious_ms * 256. / 1000. );

915

correctionInF2 = - (deltaPrevious_ms * 256. / 1000. );

918

}

916

}

919

917

920

PRINTF1(" correctionInF2 = %.2f\n", correctionInF2);

918

PRINTF1(" correctionInF2 = %.2f\n", correctionInF2);

921

919

922

return correctionInF2;

920

return correctionInF2;

923

}

921

}

924

922

925

void applyCorrection( double correction )

923

void applyCorrection( double correction )

926

{

924

{

927

int correctionInt;

925

int correctionInt;

928

926

929

if (correction>=0.)

927

if (correction >= 0.)

930

{

928

{

931

if ( correction > 0.5 )

929

if ( (1. > correction) && (correction > 0.5) )

932

{

930

{

933

correctionInt = 1;

931

correctionInt = 1;

934

}

932

}

935

else

933

else

936

{

934

{

937

correctionInt = floor(correction);

935

correctionInt = floor(correction);

938

}

936

}

939

}

937

}

940

else

938

else

941

{

939

{

942

if ( correction < -0.5)

940

if ( (correction < -1.) && (correction < -0.5) )

943

{

941

{

944

correctionInt = -1;

942

correctionInt = -1;

945

}

943

}

946

else

944

else

947

{

945

{

948

correctionInt = ceil(correction);

946

correctionInt = ceil(correction);

949

}

947

}

950

}

948

}

951

waveform_picker_regs->delta_snapshot = waveform_picker_regs->delta_snapshot + correctionInt;

949

waveform_picker_regs->delta_snapshot = waveform_picker_regs->delta_snapshot + correctionInt;

952

}

950

}

953

951

954

void snapshot_resynchronization( unsigned char *timePtr )

952

void snapshot_resynchronization( unsigned char *timePtr )

955

{

953

{

956

/** This function compute a correction to apply on delta_snapshot.

954

/** This function compute a correction to apply on delta_snapshot.

957

*

955

*

958

*

956

*

959

* @param timePtr is a pointer to the acquisition time of the snapshot being considered.

957

* @param timePtr is a pointer to the acquisition time of the snapshot being considered.

960

*

958

*

961

* @return void

959

* @return void

962

*

960

*

963

*/

961

*/

964

962

965

static double correction = 0.;

963

static double correction = 0.;

966

static resynchro_state state = MEASURE;

964

static resynchro_state state = MEASURE;

967

static unsigned int nbSnapshots = 0;

965

static unsigned int nbSnapshots = 0;

968

966

969

int correctionInt;

967

int correctionInt;

970

968

971

correctionInt = 0;

969

correctionInt = 0;

972

970

973

switch (state)

971

switch (state)

974

{

972

{

975

973

976

case MEASURE:

974

case MEASURE:

977

// ********

975

// ********

978

PRINTF1("MEASURE === %d\n", nbSnapshots);

976

PRINTF1("MEASURE === %d\n", nbSnapshots);

979

state = CORRECTION;

977

state = CORRECTION;

980

correction = computeCorrection( timePtr );

978

correction = computeCorrection( timePtr );

981

PRINTF1("MEASURE === correction = %.2f\n", correction );

979

PRINTF1("MEASURE === correction = %.2f\n", correction );

982

applyCorrection( correction );

980

applyCorrection( correction );

983

PRINTF1("MEASURE === delta_snapshot = %d\n", waveform_picker_regs->delta_snapshot);

981

PRINTF1("MEASURE === delta_snapshot = %d\n", waveform_picker_regs->delta_snapshot);

984

//****

982

//****

985

break;

983

break;

986

984

987

case CORRECTION:

985

case CORRECTION:

988

//************

986

//************

989

PRINTF1("CORRECTION === %d\n", nbSnapshots);

987

PRINTF1("CORRECTION === %d\n", nbSnapshots);

990

state = MEASURE;

988

state = MEASURE;

991

computeCorrection( timePtr );

989

computeCorrection( timePtr );

992

correction = -correction;

990

correction = -correction;

993

PRINTF1("CORRECTION === correction = %.2f\n", correction );

991

PRINTF1("CORRECTION === correction = %.2f\n", correction );

994

applyCorrection( correction );

992

applyCorrection( correction );

995

PRINTF1("CORRECTION === delta_snapshot = %d\n", waveform_picker_regs->delta_snapshot);

993

PRINTF1("CORRECTION === delta_snapshot = %d\n", waveform_picker_regs->delta_snapshot);

996

//****

994

//****

997

break;

995

break;

998

996

999

default:

997

default:

1000

break;

998

break;

1001

999

1002

}

1000

}

1003

1001

1004

nbSnapshots++;

1002

nbSnapshots++;

1005

}

1003

}

1006

1004

1007

//**************

1005

//**************

1008

// wfp registers

1006

// wfp registers

1009

void reset_wfp_burst_enable( void )

1007

void reset_wfp_burst_enable( void )

1010

{

1008

{

1011

/** This function resets the waveform picker burst_enable register.

1009

/** This function resets the waveform picker burst_enable register.

1012

*

1010

*

1013

* The burst bits [f2 f1 f0] and the enable bits [f3 f2 f1 f0] are set to 0.

1011

* The burst bits [f2 f1 f0] and the enable bits [f3 f2 f1 f0] are set to 0.

1014

*

1012

*

1015

*/

1013

*/

1016

1014

1017

// [1000 000] burst f2, f1, f0 enable f3, f2, f1, f0

1015

// [1000 000] burst f2, f1, f0 enable f3, f2, f1, f0

1018

waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable & 0x80;

1016

waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable & 0x80;

1019

}

1017

}

1020

1018

1021

void reset_wfp_status( void )

1019

void reset_wfp_status( void )

1022

{

1020

{

1023

/** This function resets the waveform picker status register.

1021

/** This function resets the waveform picker status register.

1024

*

1022

*

1025

* All status bits are set to 0 [new_err full_err full].

1023

* All status bits are set to 0 [new_err full_err full].

1026

*

1024

*

1027

*/

1025

*/

1028

1026

1029

waveform_picker_regs->status = 0xffff;

1027

waveform_picker_regs->status = 0xffff;

1030

}

1028

}

1031

1029

1032

void reset_wfp_buffer_addresses( void )

1030

void reset_wfp_buffer_addresses( void )

1033

{

1031

{

1034

// F0

1032

// F0

1035

waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->previous->buffer_address; // 0x08

1033

waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->previous->buffer_address; // 0x08

1036

waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address; // 0x0c

1034

waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address; // 0x0c

1037

// F1

1035

// F1

1038

waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->previous->buffer_address; // 0x10

1036

waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->previous->buffer_address; // 0x10

1039

waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address; // 0x14

1037

waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address; // 0x14

1040

// F2

1038

// F2

1041

waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->previous->buffer_address; // 0x18

1039

waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->previous->buffer_address; // 0x18

1042

waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address; // 0x1c

1040

waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address; // 0x1c

1043

// F3

1041

// F3

1044

waveform_picker_regs->addr_data_f3_0 = current_ring_node_f3->previous->buffer_address; // 0x20

1042

waveform_picker_regs->addr_data_f3_0 = current_ring_node_f3->previous->buffer_address; // 0x20

1045

waveform_picker_regs->addr_data_f3_1 = current_ring_node_f3->buffer_address; // 0x24

1043

waveform_picker_regs->addr_data_f3_1 = current_ring_node_f3->buffer_address; // 0x24

1046

}

1044

}

1047

1045

1048

void reset_waveform_picker_regs( void )

1046

void reset_waveform_picker_regs( void )

1049

{

1047

{

1050

/** This function resets the waveform picker module registers.

1048

/** This function resets the waveform picker module registers.

1051

*

1049

*

1052

* The registers affected by this function are located at the following offset addresses:

1050

* The registers affected by this function are located at the following offset addresses:

1053

* - 0x00 data_shaping

1051

* - 0x00 data_shaping

1054

* - 0x04 run_burst_enable

1052

* - 0x04 run_burst_enable

1055

* - 0x08 addr_data_f0

1053

* - 0x08 addr_data_f0

1056

* - 0x0C addr_data_f1

1054

* - 0x0C addr_data_f1

1057

* - 0x10 addr_data_f2

1055

* - 0x10 addr_data_f2

1058

* - 0x14 addr_data_f3

1056

* - 0x14 addr_data_f3

1059

* - 0x18 status

1057

* - 0x18 status

1060

* - 0x1C delta_snapshot

1058

* - 0x1C delta_snapshot

1061

* - 0x20 delta_f0

1059

* - 0x20 delta_f0

1062

* - 0x24 delta_f0_2

1060

* - 0x24 delta_f0_2

1063

* - 0x28 delta_f1 (obsolet parameter)

1061

* - 0x28 delta_f1 (obsolet parameter)

1064

* - 0x2c delta_f2

1062

* - 0x2c delta_f2

1065

* - 0x30 nb_data_by_buffer

1063

* - 0x30 nb_data_by_buffer

1066

* - 0x34 nb_snapshot_param

1064

* - 0x34 nb_snapshot_param

1067

* - 0x38 start_date

1065

* - 0x38 start_date

1068

* - 0x3c nb_word_in_buffer

1066

* - 0x3c nb_word_in_buffer

1069

*

1067

*

1070

*/

1068

*/

1071

1069

1072

set_wfp_data_shaping(); // 0x00 *** R1 R0 SP1 SP0 BW

1070

set_wfp_data_shaping(); // 0x00 *** R1 R0 SP1 SP0 BW

1073

1071

1074

reset_wfp_burst_enable(); // 0x04 *** [run *** burst f2, f1, f0 *** enable f3, f2, f1, f0 ]

1072

reset_wfp_burst_enable(); // 0x04 *** [run *** burst f2, f1, f0 *** enable f3, f2, f1, f0 ]

1075

1073

1076

reset_wfp_buffer_addresses();

1074

reset_wfp_buffer_addresses();

1077

1075

1078

reset_wfp_status(); // 0x18

1076

reset_wfp_status(); // 0x18

1079

1077

1080

set_wfp_delta_snapshot(); // 0x1c *** 300 s => 0x12bff

1078

set_wfp_delta_snapshot(); // 0x1c *** 300 s => 0x12bff

1081

1079

1082

set_wfp_delta_f0_f0_2(); // 0x20, 0x24

1080

set_wfp_delta_f0_f0_2(); // 0x20, 0x24

1083

1081

1084

//the parameter delta_f1 [0x28] is not used anymore

1082

//the parameter delta_f1 [0x28] is not used anymore

1085

1083

1086

set_wfp_delta_f2(); // 0x2c

1084

set_wfp_delta_f2(); // 0x2c

1087

1085

1088

DEBUG_PRINTF1("delta_snapshot %x\n", waveform_picker_regs->delta_snapshot);

1086

DEBUG_PRINTF1("delta_snapshot %x\n", waveform_picker_regs->delta_snapshot);

1089

DEBUG_PRINTF1("delta_f0 %x\n", waveform_picker_regs->delta_f0);

1087

DEBUG_PRINTF1("delta_f0 %x\n", waveform_picker_regs->delta_f0);

1090

DEBUG_PRINTF1("delta_f0_2 %x\n", waveform_picker_regs->delta_f0_2);

1088

DEBUG_PRINTF1("delta_f0_2 %x\n", waveform_picker_regs->delta_f0_2);

1091

DEBUG_PRINTF1("delta_f1 %x\n", waveform_picker_regs->delta_f1);

1089

DEBUG_PRINTF1("delta_f1 %x\n", waveform_picker_regs->delta_f1);

1092

DEBUG_PRINTF1("delta_f2 %x\n", waveform_picker_regs->delta_f2);

1090

DEBUG_PRINTF1("delta_f2 %x\n", waveform_picker_regs->delta_f2);

1093

// 2688 = 8 * 336

1091

// 2688 = 8 * 336

1094

waveform_picker_regs->nb_data_by_buffer = 0xa7f; // 0x30 *** 2688 - 1 => nb samples -1

1092

waveform_picker_regs->nb_data_by_buffer = 0xa7f; // 0x30 *** 2688 - 1 => nb samples -1

1095

waveform_picker_regs->snapshot_param = 0xa80; // 0x34 *** 2688 => nb samples

1093

waveform_picker_regs->snapshot_param = 0xa80; // 0x34 *** 2688 => nb samples

1096

waveform_picker_regs->start_date = 0x7fffffff; // 0x38

1094

waveform_picker_regs->start_date = 0x7fffffff; // 0x38

1097

//

1095

//

1098

// coarse time and fine time registers are not initialized, they are volatile

1096

// coarse time and fine time registers are not initialized, they are volatile

1099

//

1097

//

1100

waveform_picker_regs->buffer_length = 0x1f8;// buffer length in burst = 3 * 2688 / 16 = 504 = 0x1f8

1098

waveform_picker_regs->buffer_length = 0x1f8;// buffer length in burst = 3 * 2688 / 16 = 504 = 0x1f8

1101

}

1099

}

1102

1100

1103

void set_wfp_data_shaping( void )

1101

void set_wfp_data_shaping( void )

1104

{

1102

{

1105

/** This function sets the data_shaping register of the waveform picker module.

1103

/** This function sets the data_shaping register of the waveform picker module.

1106

*

1104

*

1107

* The value is read from one field of the parameter_dump_packet structure:\n

1105

* The value is read from one field of the parameter_dump_packet structure:\n

1108

* bw_sp0_sp1_r0_r1

1106

* bw_sp0_sp1_r0_r1

1109

*

1107

*

1110

*/

1108

*/

1111

1109

1112

unsigned char data_shaping;

1110

unsigned char data_shaping;

1113

1111

1114

// get the parameters for the data shaping [BW SP0 SP1 R0 R1] in sy_lfr_common1 and configure the register

1112

// get the parameters for the data shaping [BW SP0 SP1 R0 R1] in sy_lfr_common1 and configure the register

1115

// waveform picker : [R1 R0 SP1 SP0 BW]

1113

// waveform picker : [R1 R0 SP1 SP0 BW]

1116

1114

1117

data_shaping = parameter_dump_packet.sy_lfr_common_parameters;

1115

data_shaping = parameter_dump_packet.sy_lfr_common_parameters;

1118

1116

1119

waveform_picker_regs->data_shaping =

1117

waveform_picker_regs->data_shaping =

1120

( (data_shaping & 0x20) >> 5 ) // BW

1118

( (data_shaping & 0x20) >> 5 ) // BW

1121

+ ( (data_shaping & 0x10) >> 3 ) // SP0

1119

+ ( (data_shaping & 0x10) >> 3 ) // SP0

1122

+ ( (data_shaping & 0x08) >> 1 ) // SP1

1120

+ ( (data_shaping & 0x08) >> 1 ) // SP1

1123

+ ( (data_shaping & 0x04) << 1 ) // R0

1121

+ ( (data_shaping & 0x04) << 1 ) // R0

1124

+ ( (data_shaping & 0x02) << 3 ) // R1

1122

+ ( (data_shaping & 0x02) << 3 ) // R1

1125

+ ( (data_shaping & 0x01) << 5 ); // R2

1123

+ ( (data_shaping & 0x01) << 5 ); // R2

1126

}

1124

}

1127

1125

1128

void set_wfp_burst_enable_register( unsigned char mode )

1126

void set_wfp_burst_enable_register( unsigned char mode )

1129

{

1127

{

1130

/** This function sets the waveform picker burst_enable register depending on the mode.

1128

/** This function sets the waveform picker burst_enable register depending on the mode.

1131

*

1129

*

1132

* @param mode is the LFR mode to launch.

1130

* @param mode is the LFR mode to launch.

1133

*

1131

*

1134

* The burst bits shall be before the enable bits.

1132

* The burst bits shall be before the enable bits.

1135

*

1133

*

1136

*/

1134

*/

1137

1135

1138

// [0000 0000] burst f2, f1, f0 enable f3 f2 f1 f0

1136

// [0000 0000] burst f2, f1, f0 enable f3 f2 f1 f0

1139

// the burst bits shall be set first, before the enable bits

1137

// the burst bits shall be set first, before the enable bits

1140

switch(mode) {

1138

switch(mode) {

1141

case LFR_MODE_NORMAL:

1139

case LFR_MODE_NORMAL:

1142

case LFR_MODE_SBM1:

1140

case LFR_MODE_SBM1:

1143

case LFR_MODE_SBM2:

1141

case LFR_MODE_SBM2:

1144

waveform_picker_regs->run_burst_enable = 0x60; // [0110 0000] enable f2 and f1 burst

1142

waveform_picker_regs->run_burst_enable = 0x60; // [0110 0000] enable f2 and f1 burst

1145

waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x0f; // [1111] enable f3 f2 f1 f0

1143

waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x0f; // [1111] enable f3 f2 f1 f0

1146

break;

1144

break;

1147

case LFR_MODE_BURST:

1145

case LFR_MODE_BURST:

1148

waveform_picker_regs->run_burst_enable = 0x40; // [0100 0000] f2 burst enabled

1146

waveform_picker_regs->run_burst_enable = 0x40; // [0100 0000] f2 burst enabled

1149

waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x0c; // [1100] enable f3 and f2

1147

waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x0c; // [1100] enable f3 and f2

1150

break;

1148

break;

1151

default:

1149

default:

1152

waveform_picker_regs->run_burst_enable = 0x00; // [0000 0000] no burst enabled, no waveform enabled

1150

waveform_picker_regs->run_burst_enable = 0x00; // [0000 0000] no burst enabled, no waveform enabled

1153

break;

1151

break;

1154

}

1152

}

1155

}

1153

}

1156

1154

1157

void set_wfp_delta_snapshot( void )

1155

void set_wfp_delta_snapshot( void )

1158

{

1156

{

1159

/** This function sets the delta_snapshot register of the waveform picker module.

1157

/** This function sets the delta_snapshot register of the waveform picker module.

1160

*

1158

*

1161

* The value is read from two (unsigned char) of the parameter_dump_packet structure:

1159

* The value is read from two (unsigned char) of the parameter_dump_packet structure:

1162

* - sy_lfr_n_swf_p[0]

1160

* - sy_lfr_n_swf_p[0]

1163

* - sy_lfr_n_swf_p[1]

1161

* - sy_lfr_n_swf_p[1]

1164

*

1162

*

1165

*/

1163

*/

1166

1164

1167

unsigned int delta_snapshot;

1165

unsigned int delta_snapshot;

1168

unsigned int delta_snapshot_in_T2;

1166

unsigned int delta_snapshot_in_T2;

1169

1167

1170

delta_snapshot = parameter_dump_packet.sy_lfr_n_swf_p[0]*256

1168

delta_snapshot = parameter_dump_packet.sy_lfr_n_swf_p[0]*256

1171

+ parameter_dump_packet.sy_lfr_n_swf_p[1];

1169

+ parameter_dump_packet.sy_lfr_n_swf_p[1];

1172

1170

1173

delta_snapshot_in_T2 = delta_snapshot * 256;

1171

delta_snapshot_in_T2 = delta_snapshot * 256;

1174

waveform_picker_regs->delta_snapshot = delta_snapshot_in_T2 - 1; // max 4 bytes

1172

waveform_picker_regs->delta_snapshot = delta_snapshot_in_T2 - 1; // max 4 bytes

1175

}

1173

}

1176

1174

1177

void set_wfp_delta_f0_f0_2( void )

1175

void set_wfp_delta_f0_f0_2( void )

1178

{

1176

{

1179

unsigned int delta_snapshot;

1177

unsigned int delta_snapshot;

1180

unsigned int nb_samples_per_snapshot;

1178

unsigned int nb_samples_per_snapshot;

1181

float delta_f0_in_float;

1179

float delta_f0_in_float;

1182

1180

1183

delta_snapshot = waveform_picker_regs->delta_snapshot;

1181

delta_snapshot = waveform_picker_regs->delta_snapshot;

1184

nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];

1182

nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];

1185

delta_f0_in_float = nb_samples_per_snapshot / 2. * ( 1. / 256. - 1. / 24576.) * 256.;

1183

delta_f0_in_float = nb_samples_per_snapshot / 2. * ( 1. / 256. - 1. / 24576.) * 256.;

1186

1184

1187

waveform_picker_regs->delta_f0 = delta_snapshot - floor( delta_f0_in_float );

1185

waveform_picker_regs->delta_f0 = delta_snapshot - floor( delta_f0_in_float );

1188

waveform_picker_regs->delta_f0_2 = 0x30; // 48 = 11 0000, max 7 bits

1186

waveform_picker_regs->delta_f0_2 = 0x30; // 48 = 11 0000, max 7 bits

1189

}

1187

}

1190

1188

1191

void set_wfp_delta_f1( void )

1189

void set_wfp_delta_f1( void )

1192

{

1190

{

1193

/** Sets the value of the delta_f1 parameter

1191

/** Sets the value of the delta_f1 parameter

1194

*

1192

*

1195

* @param void

1193

* @param void

1196

*

1194

*

1197

* @return void

1195

* @return void

1198

*

1196

*

1199

* delta_f1 is not used, the snapshots are extracted from CWF_F1 waveforms.

1197

* delta_f1 is not used, the snapshots are extracted from CWF_F1 waveforms.

1200

*

1198

*

1201

*/

1199

*/

1202

1200

1203

unsigned int delta_snapshot;

1201

unsigned int delta_snapshot;

1204

unsigned int nb_samples_per_snapshot;

1202

unsigned int nb_samples_per_snapshot;

1205

float delta_f1_in_float;

1203

float delta_f1_in_float;

1206

1204

1207

delta_snapshot = waveform_picker_regs->delta_snapshot;

1205

delta_snapshot = waveform_picker_regs->delta_snapshot;

1208

nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];

1206

nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];

1209

delta_f1_in_float = nb_samples_per_snapshot / 2. * ( 1. / 256. - 1. / 4096.) * 256.;

1207

delta_f1_in_float = nb_samples_per_snapshot / 2. * ( 1. / 256. - 1. / 4096.) * 256.;

1210

1208

1211

waveform_picker_regs->delta_f1 = delta_snapshot - floor( delta_f1_in_float );

1209

waveform_picker_regs->delta_f1 = delta_snapshot - floor( delta_f1_in_float );

1212

}

1210

}

1213

1211

1214

void set_wfp_delta_f2( void ) // parameter not used, only delta_f0 and delta_f0_2 are used

1212

void set_wfp_delta_f2( void ) // parameter not used, only delta_f0 and delta_f0_2 are used

1215

{

1213

{

1216

/** Sets the value of the delta_f2 parameter

1214

/** Sets the value of the delta_f2 parameter

1217

*

1215

*

1218

* @param void

1216

* @param void

1219

*

1217

*

1220

* @return void

1218

* @return void

1221

*

1219

*

1222

* delta_f2 is used only for the first snapshot generation, even when the snapshots are extracted from CWF_F2

1220

* delta_f2 is used only for the first snapshot generation, even when the snapshots are extracted from CWF_F2

1223

* waveforms (see lpp_waveform_snapshot_controler.vhd for details).

1221

* waveforms (see lpp_waveform_snapshot_controler.vhd for details).

1224

*

1222

*

1225

*/

1223

*/

1226

1224

1227

unsigned int delta_snapshot;

1225

unsigned int delta_snapshot;

1228

unsigned int nb_samples_per_snapshot;

1226

unsigned int nb_samples_per_snapshot;

1229

1227

1230

delta_snapshot = waveform_picker_regs->delta_snapshot;

1228

delta_snapshot = waveform_picker_regs->delta_snapshot;

1231

nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];

1229

nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];

1232

1230

1233

waveform_picker_regs->delta_f2 = delta_snapshot - nb_samples_per_snapshot / 2 - 1;

1231

waveform_picker_regs->delta_f2 = delta_snapshot - nb_samples_per_snapshot / 2 - 1;

1234

}

1232

}

1235

1233

1236

//*****************

1234

//*****************

1237

// local parameters

1235

// local parameters

1238

1236

1239

void increment_seq_counter_source_id( unsigned char *packet_sequence_control, unsigned int sid )

1237

void increment_seq_counter_source_id( unsigned char *packet_sequence_control, unsigned int sid )

1240

{

1238

{

1241

/** This function increments the parameter "sequence_cnt" depending on the sid passed in argument.

1239

/** This function increments the parameter "sequence_cnt" depending on the sid passed in argument.

1242

*

1240

*

1243

* @param packet_sequence_control is a pointer toward the parameter sequence_cnt to update.

1241

* @param packet_sequence_control is a pointer toward the parameter sequence_cnt to update.

1244

* @param sid is the source identifier of the packet being updated.

1242

* @param sid is the source identifier of the packet being updated.

1245

*

1243

*

1246

* REQ-LFR-SRS-5240 / SSS-CP-FS-590

1244

* REQ-LFR-SRS-5240 / SSS-CP-FS-590

1247

* The sequence counters shall wrap around from 2^14 to zero.

1245

* The sequence counters shall wrap around from 2^14 to zero.

1248

* The sequence counter shall start at zero at startup.

1246

* The sequence counter shall start at zero at startup.

1249

*

1247

*

1250

* REQ-LFR-SRS-5239 / SSS-CP-FS-580

1248

* REQ-LFR-SRS-5239 / SSS-CP-FS-580

1251

* All TM_LFR_SCIENCE_ packets are sent to ground, i.e. destination id = 0

1249

* All TM_LFR_SCIENCE_ packets are sent to ground, i.e. destination id = 0

1252

*

1250

*

1253

*/

1251

*/

1254

1252

1255

unsigned short *sequence_cnt;

1253

unsigned short *sequence_cnt;

1256

unsigned short segmentation_grouping_flag;

1254

unsigned short segmentation_grouping_flag;

1257

unsigned short new_packet_sequence_control;

1255

unsigned short new_packet_sequence_control;

1258

rtems_mode initial_mode_set;

1256

rtems_mode initial_mode_set;

1259

rtems_mode current_mode_set;

1257

rtems_mode current_mode_set;

1260

rtems_status_code status;

1258

rtems_status_code status;

1261

1259

1262

//******************************************

1260

//******************************************

1263

// CHANGE THE MODE OF THE CALLING RTEMS TASK

1261

// CHANGE THE MODE OF THE CALLING RTEMS TASK

1264

status = rtems_task_mode( RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &initial_mode_set );

1262

status = rtems_task_mode( RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &initial_mode_set );

1265

1263

1266

if ( (sid == SID_NORM_SWF_F0) || (sid == SID_NORM_SWF_F1) || (sid == SID_NORM_SWF_F2)

1264

if ( (sid == SID_NORM_SWF_F0) || (sid == SID_NORM_SWF_F1) || (sid == SID_NORM_SWF_F2)

1267

|| (sid == SID_NORM_CWF_F3) || (sid == SID_NORM_CWF_LONG_F3)

1265

|| (sid == SID_NORM_CWF_F3) || (sid == SID_NORM_CWF_LONG_F3)

1268

|| (sid == SID_BURST_CWF_F2)

1266

|| (sid == SID_BURST_CWF_F2)

1269

|| (sid == SID_NORM_ASM_F0) || (sid == SID_NORM_ASM_F1) || (sid == SID_NORM_ASM_F2)

1267

|| (sid == SID_NORM_ASM_F0) || (sid == SID_NORM_ASM_F1) || (sid == SID_NORM_ASM_F2)

1270

|| (sid == SID_NORM_BP1_F0) || (sid == SID_NORM_BP1_F1) || (sid == SID_NORM_BP1_F2)

1268

|| (sid == SID_NORM_BP1_F0) || (sid == SID_NORM_BP1_F1) || (sid == SID_NORM_BP1_F2)

1271

|| (sid == SID_NORM_BP2_F0) || (sid == SID_NORM_BP2_F1) || (sid == SID_NORM_BP2_F2)

1269

|| (sid == SID_NORM_BP2_F0) || (sid == SID_NORM_BP2_F1) || (sid == SID_NORM_BP2_F2)

1272

|| (sid == SID_BURST_BP1_F0) || (sid == SID_BURST_BP2_F0)

1270

|| (sid == SID_BURST_BP1_F0) || (sid == SID_BURST_BP2_F0)

1273

|| (sid == SID_BURST_BP1_F1) || (sid == SID_BURST_BP2_F1) )

1271

|| (sid == SID_BURST_BP1_F1) || (sid == SID_BURST_BP2_F1) )

1274

{

1272

{

1275

sequence_cnt = (unsigned short *) &sequenceCounters_SCIENCE_NORMAL_BURST;

1273

sequence_cnt = (unsigned short *) &sequenceCounters_SCIENCE_NORMAL_BURST;

1276

}

1274

}

1277

else if ( (sid ==SID_SBM1_CWF_F1) || (sid ==SID_SBM2_CWF_F2)

1275

else if ( (sid ==SID_SBM1_CWF_F1) || (sid ==SID_SBM2_CWF_F2)

1278

|| (sid == SID_SBM1_BP1_F0) || (sid == SID_SBM1_BP2_F0)

1276

|| (sid == SID_SBM1_BP1_F0) || (sid == SID_SBM1_BP2_F0)

1279

|| (sid == SID_SBM2_BP1_F0) || (sid == SID_SBM2_BP2_F0)

1277

|| (sid == SID_SBM2_BP1_F0) || (sid == SID_SBM2_BP2_F0)

1280

|| (sid == SID_SBM2_BP1_F1) || (sid == SID_SBM2_BP2_F1) )

1278

|| (sid == SID_SBM2_BP1_F1) || (sid == SID_SBM2_BP2_F1) )

1281

{

1279

{

1282

sequence_cnt = (unsigned short *) &sequenceCounters_SCIENCE_SBM1_SBM2;

1280

sequence_cnt = (unsigned short *) &sequenceCounters_SCIENCE_SBM1_SBM2;

1283

}

1281

}

1284

else

1282

else

1285

{

1283

{

1286

sequence_cnt = (unsigned short *) NULL;

1284

sequence_cnt = (unsigned short *) NULL;

1287

PRINTF1("in increment_seq_counter_source_id *** ERR apid_destid %d not known\n", sid)

1285

PRINTF1("in increment_seq_counter_source_id *** ERR apid_destid %d not known\n", sid)

1288

}

1286

}

1289

1287

1290

if (sequence_cnt != NULL)

1288

if (sequence_cnt != NULL)

1291

{

1289

{

1292

segmentation_grouping_flag = TM_PACKET_SEQ_CTRL_STANDALONE << 8;

1290

segmentation_grouping_flag = TM_PACKET_SEQ_CTRL_STANDALONE << 8;

1293

*sequence_cnt = (*sequence_cnt) & 0x3fff;

1291

*sequence_cnt = (*sequence_cnt) & 0x3fff;

1294

1292

1295

new_packet_sequence_control = segmentation_grouping_flag | (*sequence_cnt) ;

1293

new_packet_sequence_control = segmentation_grouping_flag | (*sequence_cnt) ;

1296

1294

1297

packet_sequence_control[0] = (unsigned char) (new_packet_sequence_control >> 8);

1295

packet_sequence_control[0] = (unsigned char) (new_packet_sequence_control >> 8);

1298

packet_sequence_control[1] = (unsigned char) (new_packet_sequence_control );

1296

packet_sequence_control[1] = (unsigned char) (new_packet_sequence_control );

1299

1297

1300

// increment the sequence counter

1298

// increment the sequence counter

1301

if ( *sequence_cnt < SEQ_CNT_MAX)

1299

if ( *sequence_cnt < SEQ_CNT_MAX)

1302

{

1300

{

1303

*sequence_cnt = *sequence_cnt + 1;

1301

*sequence_cnt = *sequence_cnt + 1;

1304

}

1302

}

1305

else

1303

else

1306

{

1304

{

1307

*sequence_cnt = 0;

1305

*sequence_cnt = 0;

1308

}

1306

}

1309

}

1307

}

1310

1308

1311

//*************************************

1309

//*************************************

1312

// RESTORE THE MODE OF THE CALLING TASK

1310

// RESTORE THE MODE OF THE CALLING TASK

1313

status = rtems_task_mode( initial_mode_set, RTEMS_PREEMPT_MASK, &current_mode_set );

1311

status = rtems_task_mode( initial_mode_set, RTEMS_PREEMPT_MASK, &current_mode_set );

1314

}

1312

}

	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

             /** Functions and tasks related to waveform packet generation.
              *
              * @file
              * @author P. LEROY
              *
              * A group of functions to handle waveforms, in snapshot or continuous format.\n
              *
              */
             #include "wf_handler.h"
             //***************
             // waveform rings
             // F0
             ring_node waveform_ring_f0[NB_RING_NODES_F0];
             ring_node *current_ring_node_f0;
             ring_node *ring_node_to_send_swf_f0;
             // F1
             ring_node waveform_ring_f1[NB_RING_NODES_F1];
             ring_node *current_ring_node_f1;
             ring_node *ring_node_to_send_swf_f1;
             ring_node *ring_node_to_send_cwf_f1;
             // F2
             ring_node waveform_ring_f2[NB_RING_NODES_F2];
             ring_node *current_ring_node_f2;
             ring_node *ring_node_to_send_swf_f2;
             ring_node *ring_node_to_send_cwf_f2;
             // F3
             ring_node waveform_ring_f3[NB_RING_NODES_F3];
             ring_node *current_ring_node_f3;
             ring_node *ring_node_to_send_cwf_f3;
             char wf_cont_f3_light[ (NB_SAMPLES_PER_SNAPSHOT) * NB_BYTES_CWF3_LIGHT_BLK ];
             bool extractSWF1 = false;
             bool extractSWF2 = false;
             bool swf0_ready_flag_f1 = false;
             bool swf0_ready_flag_f2 = false;
             bool swf1_ready = false;
             bool swf2_ready = false;
             int swf1_extracted[ (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK) ];
             int swf2_extracted[ (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK) ];
             ring_node ring_node_swf1_extracted;
             ring_node ring_node_swf2_extracted;
             typedef enum resynchro_state_t
             {
                 MEASURE,
                 CORRECTION
             } resynchro_state;
             //*********************
             // Interrupt SubRoutine
             ring_node * getRingNodeToSendCWF( unsigned char frequencyChannel)
             {
                 ring_node *node;
                 node = NULL;
                 switch ( frequencyChannel ) {
                 case 1:
                     node = ring_node_to_send_cwf_f1;
                     break;
                 case 2:
                     node = ring_node_to_send_cwf_f2;
                     break;
                 case 3:
                     node = ring_node_to_send_cwf_f3;
                     break;
                 default:
                     break;
                 }
                 return node;
             }
             ring_node * getRingNodeToSendSWF( unsigned char frequencyChannel)
             {
                 ring_node *node;
                 node = NULL;
                 switch ( frequencyChannel ) {
                 case 0:
                     node = ring_node_to_send_swf_f0;
                     break;
                 case 1:
                     node = ring_node_to_send_swf_f1;
                     break;
                 case 2:
                     node = ring_node_to_send_swf_f2;
                     break;
                 default:
                     break;
                 }
                 return node;
             }
             void reset_extractSWF( void )
             {
                 extractSWF1 = false;
                 extractSWF2 = false;
                 swf0_ready_flag_f1 = false;
                 swf0_ready_flag_f2 = false;
                 swf1_ready = false;
                 swf2_ready = false;
             }
             inline void waveforms_isr_f3( void )
             {
                 rtems_status_code spare_status;
                 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
                      || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
                 { // in modes other than STANDBY and BURST, send the CWF_F3 data
                     //***
                     // F3
                     if ( (waveform_picker_regs->status & 0xc0) != 0x00 ) {  // [1100 0000] check the f3 full bits
                         ring_node_to_send_cwf_f3    = current_ring_node_f3->previous;
                         current_ring_node_f3        = current_ring_node_f3->next;
                         if ((waveform_picker_regs->status & 0x40) == 0x40){         // [0100 0000] f3 buffer 0 is full
                             ring_node_to_send_cwf_f3->coarseTime    = waveform_picker_regs->f3_0_coarse_time;
                             ring_node_to_send_cwf_f3->fineTime      = waveform_picker_regs->f3_0_fine_time;
                             waveform_picker_regs->addr_data_f3_0    = current_ring_node_f3->buffer_address;
                             waveform_picker_regs->status            = waveform_picker_regs->status & 0x00008840; // [1000 1000 0100 0000]
                         }
                         else if ((waveform_picker_regs->status & 0x80) == 0x80){     // [1000 0000] f3 buffer 1 is full
                             ring_node_to_send_cwf_f3->coarseTime    = waveform_picker_regs->f3_1_coarse_time;
                             ring_node_to_send_cwf_f3->fineTime      = waveform_picker_regs->f3_1_fine_time;
                             waveform_picker_regs->addr_data_f3_1    = current_ring_node_f3->buffer_address;
                             waveform_picker_regs->status            = waveform_picker_regs->status & 0x00008880; // [1000 1000 1000 0000]
                         }
                         if (rtems_event_send( Task_id[TASKID_CWF3], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
                             spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );
                         }
                     }
                 }
             }
             inline void waveforms_isr_burst( void )
             {
                 unsigned char status;
                 rtems_status_code spare_status;
                 status = (waveform_picker_regs->status & 0x30) >> 4;   // [0011 0000] get the status bits for f2
                 switch(status)
                 {
                 case 1:
                     ring_node_to_send_cwf_f2                = current_ring_node_f2->previous;
                     ring_node_to_send_cwf_f2->sid           = SID_BURST_CWF_F2;
                     ring_node_to_send_cwf_f2->coarseTime    = waveform_picker_regs->f2_0_coarse_time;
                     ring_node_to_send_cwf_f2->fineTime      = waveform_picker_regs->f2_0_fine_time;
                     current_ring_node_f2                    = current_ring_node_f2->next;
                     waveform_picker_regs->addr_data_f2_0    = current_ring_node_f2->buffer_address;
                     if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {
                         spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );
                     }
                     waveform_picker_regs->status            = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]
                     break;
                 case 2:
                     ring_node_to_send_cwf_f2                = current_ring_node_f2->previous;
                     ring_node_to_send_cwf_f2->sid           = SID_BURST_CWF_F2;
                     ring_node_to_send_cwf_f2->coarseTime    = waveform_picker_regs->f2_1_coarse_time;
                     ring_node_to_send_cwf_f2->fineTime      = waveform_picker_regs->f2_1_fine_time;
                     current_ring_node_f2                    = current_ring_node_f2->next;
                     waveform_picker_regs->addr_data_f2_1    = current_ring_node_f2->buffer_address;
                     if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {
                         spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_0 );
                     }
                     waveform_picker_regs->status            = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]
                     break;
                 default:
                     break;
                 }
             }
             inline void waveform_isr_normal_sbm1_sbm2( void )
             {
                 rtems_status_code status;
                 //***
                 // F0
                 if ( (waveform_picker_regs->status & 0x03) != 0x00 )  // [0000 0011] check the f0 full bits
                 {
                     swf0_ready_flag_f1 = true;
                     swf0_ready_flag_f2 = true;
                     ring_node_to_send_swf_f0    = current_ring_node_f0->previous;
                     current_ring_node_f0        = current_ring_node_f0->next;
                     if ( (waveform_picker_regs->status & 0x01) == 0x01)
                     {
                         ring_node_to_send_swf_f0->coarseTime    = waveform_picker_regs->f0_0_coarse_time;
                         ring_node_to_send_swf_f0->fineTime      = waveform_picker_regs->f0_0_fine_time;
                         waveform_picker_regs->addr_data_f0_0    = current_ring_node_f0->buffer_address;
                         waveform_picker_regs->status            = waveform_picker_regs->status & 0x00001101; // [0001 0001 0000 0001]
                     }
                     else if ( (waveform_picker_regs->status & 0x02) == 0x02)
                     {
                         ring_node_to_send_swf_f0->coarseTime    = waveform_picker_regs->f0_1_coarse_time;
                         ring_node_to_send_swf_f0->fineTime      = waveform_picker_regs->f0_1_fine_time;
                         waveform_picker_regs->addr_data_f0_1    = current_ring_node_f0->buffer_address;
                         waveform_picker_regs->status            = waveform_picker_regs->status & 0x00001102; // [0001 0001 0000 0010]
                     }
                     // send an event to the WFRM task for resynchro activities
                     status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_SWF_RESYNCH );
                 }
                 //***
                 // F1
                 if ( (waveform_picker_regs->status & 0x0c) != 0x00 ) {  // [0000 1100] check the f1 full bits
                     // (1) change the receiving buffer for the waveform picker
                     ring_node_to_send_cwf_f1    = current_ring_node_f1->previous;
                     current_ring_node_f1        = current_ring_node_f1->next;
                     if ( (waveform_picker_regs->status & 0x04) == 0x04)
                     {
                         ring_node_to_send_cwf_f1->coarseTime    = waveform_picker_regs->f1_0_coarse_time;
                         ring_node_to_send_cwf_f1->fineTime      = waveform_picker_regs->f1_0_fine_time;
                         waveform_picker_regs->addr_data_f1_0    = current_ring_node_f1->buffer_address;
                         waveform_picker_regs->status            = waveform_picker_regs->status & 0x00002204; // [0010 0010 0000 0100] f1 bits = 0
                     }
                     else if ( (waveform_picker_regs->status & 0x08) == 0x08)
                     {
                         ring_node_to_send_cwf_f1->coarseTime    = waveform_picker_regs->f1_1_coarse_time;
                         ring_node_to_send_cwf_f1->fineTime      = waveform_picker_regs->f1_1_fine_time;
                         waveform_picker_regs->addr_data_f1_1    = current_ring_node_f1->buffer_address;
                         waveform_picker_regs->status            = waveform_picker_regs->status & 0x00002208; // [0010 0010 0000 1000] f1 bits = 0
                     }
                     // (2) send an event for the the CWF1 task for transmission (and snapshot extraction if needed)
                     status = rtems_event_send( Task_id[TASKID_CWF1], RTEMS_EVENT_MODE_NORM_S1_S2 );
                 }
                 //***
                 // F2
                 if ( (waveform_picker_regs->status & 0x30) != 0x00 ) {  // [0011 0000] check the f2 full bit
                     // (1) change the receiving buffer for the waveform picker
                     ring_node_to_send_cwf_f2      = current_ring_node_f2->previous;
                     ring_node_to_send_cwf_f2->sid = SID_SBM2_CWF_F2;
                     current_ring_node_f2          = current_ring_node_f2->next;
                     if ( (waveform_picker_regs->status & 0x10) == 0x10)
                     {
                         ring_node_to_send_cwf_f2->coarseTime    = waveform_picker_regs->f2_0_coarse_time;
                         ring_node_to_send_cwf_f2->fineTime      = waveform_picker_regs->f2_0_fine_time;
                         waveform_picker_regs->addr_data_f2_0    = current_ring_node_f2->buffer_address;
                         waveform_picker_regs->status            = waveform_picker_regs->status & 0x00004410; // [0100 0100 0001 0000]
                     }
                     else if ( (waveform_picker_regs->status & 0x20) == 0x20)
                     {
                         ring_node_to_send_cwf_f2->coarseTime    = waveform_picker_regs->f2_1_coarse_time;
                         ring_node_to_send_cwf_f2->fineTime      = waveform_picker_regs->f2_1_fine_time;
                         waveform_picker_regs->addr_data_f2_1    = current_ring_node_f2->buffer_address;
                         waveform_picker_regs->status            = waveform_picker_regs->status & 0x00004420; // [0100 0100 0010 0000]
                     }
                     // (2) send an event for the waveforms transmission
                     status = rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_NORM_S1_S2 );
                 }
             }
             rtems_isr waveforms_isr( rtems_vector_number vector )
             {
                 /** This is the interrupt sub routine called by the waveform picker core.
                  *
                  * This ISR launch different actions depending mainly on two pieces of information:
                  * 1. the values read in the registers of the waveform picker.
                  * 2. the current LFR mode.
                  *
                  */
                 // STATUS
                 // new error        error buffer full
                 // 15 14 13 12      11 10 9  8
                 // f3 f2 f1 f0      f3 f2 f1 f0
                 //
                 // ready buffer
                 // 7    6    5    4    3    2    1    0
                 // f3_1 f3_0 f2_1 f2_0 f1_1 f1_0 f0_1 f0_0
                 rtems_status_code spare_status;
                 waveforms_isr_f3();
                 //*************************************************
                 // copy the status bits in the housekeeping packets
                 housekeeping_packet.hk_lfr_vhdl_iir_cal =
                         (unsigned char) ((waveform_picker_regs->status & 0xff00) >> 8);
                 if ( (waveform_picker_regs->status & 0xff00) != 0x00)    // [1111 1111 0000 0000] check the error bits
                 {
                     spare_status = rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_10 );
                 }
                 switch(lfrCurrentMode)
                 {
                 //********
                 // STANDBY
                 case LFR_MODE_STANDBY:
                     break;
                     //**************************
                     // LFR NORMAL, SBM1 and SBM2
                 case LFR_MODE_NORMAL:
                 case LFR_MODE_SBM1:
                 case LFR_MODE_SBM2:
                     waveform_isr_normal_sbm1_sbm2();
                     break;
                     //******
                     // BURST
                 case LFR_MODE_BURST:
                     waveforms_isr_burst();
                     break;
                     //********
                     // DEFAULT
                 default:
                     break;
                 }
             }
             //************
             // RTEMS TASKS
             rtems_task wfrm_task(rtems_task_argument argument) //used with the waveform picker VHDL IP
             {
                 /** This RTEMS task is dedicated to the transmission of snapshots of the NORMAL mode.
                  *
                  * @param unused is the starting argument of the RTEMS task
                  *
                  * The following data packets are sent by this task:
                  * - TM_LFR_SCIENCE_NORMAL_SWF_F0
                  * - TM_LFR_SCIENCE_NORMAL_SWF_F1
                  * - TM_LFR_SCIENCE_NORMAL_SWF_F2
                  *
                  */
                 rtems_event_set event_out;
                 rtems_id queue_id;
                 rtems_status_code status;
                 ring_node *ring_node_swf1_extracted_ptr;
                 ring_node *ring_node_swf2_extracted_ptr;
                 ring_node_swf1_extracted_ptr = (ring_node *) &ring_node_swf1_extracted;
                 ring_node_swf2_extracted_ptr = (ring_node *) &ring_node_swf2_extracted;
                 status =  get_message_queue_id_send( &queue_id );
                 if (status != RTEMS_SUCCESSFUL)
                 {
                     PRINTF1("in WFRM *** ERR get_message_queue_id_send %d\n", status);
                 }
                 BOOT_PRINTF("in WFRM ***\n");
                 while(1){
                     // wait for an RTEMS_EVENT
                     rtems_event_receive(RTEMS_EVENT_MODE_NORMAL | RTEMS_EVENT_SWF_RESYNCH,
                                         RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
                     if (event_out == RTEMS_EVENT_MODE_NORMAL)
                     {
                         DEBUG_PRINTF("WFRM received RTEMS_EVENT_MODE_SBM2\n");
                         ring_node_to_send_swf_f0->sid           = SID_NORM_SWF_F0;
                         ring_node_swf1_extracted_ptr->sid       = SID_NORM_SWF_F1;
                         ring_node_swf2_extracted_ptr->sid       = SID_NORM_SWF_F2;
                         status =  rtems_message_queue_send( queue_id, &ring_node_to_send_swf_f0,     sizeof( ring_node* ) );
                         status =  rtems_message_queue_send( queue_id, &ring_node_swf1_extracted_ptr, sizeof( ring_node* ) );
                         status =  rtems_message_queue_send( queue_id, &ring_node_swf2_extracted_ptr, sizeof( ring_node* ) );
                     }
                     if (event_out == RTEMS_EVENT_SWF_RESYNCH)
                     {
                         snapshot_resynchronization( (unsigned char *)  &ring_node_to_send_swf_f0->coarseTime );
                     }
                 }
             }
             rtems_task cwf3_task(rtems_task_argument argument) //used with the waveform picker VHDL IP
             {
                 /** This RTEMS task is dedicated to the transmission of continuous waveforms at f3.
                  *
                  * @param unused is the starting argument of the RTEMS task
                  *
                  * The following data packet is sent by this task:
                  * - TM_LFR_SCIENCE_NORMAL_CWF_F3
                  *
                  */
                 rtems_event_set event_out;
                 rtems_id queue_id;
                 rtems_status_code status;
                 ring_node ring_node_cwf3_light;
                 ring_node *ring_node_to_send_cwf;
                 status =  get_message_queue_id_send( &queue_id );
                 if (status != RTEMS_SUCCESSFUL)
                 {
                     PRINTF1("in CWF3 *** ERR get_message_queue_id_send %d\n", status)
                 }
                 ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_LONG_F3;
                 // init the ring_node_cwf3_light structure
                 ring_node_cwf3_light.buffer_address = (int) wf_cont_f3_light;
                 ring_node_cwf3_light.coarseTime = 0x00;
                 ring_node_cwf3_light.fineTime = 0x00;
                 ring_node_cwf3_light.next = NULL;
                 ring_node_cwf3_light.previous = NULL;
                 ring_node_cwf3_light.sid = SID_NORM_CWF_F3;
                 ring_node_cwf3_light.status = 0x00;
                 BOOT_PRINTF("in CWF3 ***\n")
                         while(1){
                     // wait for an RTEMS_EVENT
                     rtems_event_receive( RTEMS_EVENT_0,
                                          RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
                     if ( (lfrCurrentMode == LFR_MODE_NORMAL)
                          || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode==LFR_MODE_SBM2) )
                     {
                         ring_node_to_send_cwf = getRingNodeToSendCWF( 3 );
                         if ( (parameter_dump_packet.sy_lfr_n_cwf_long_f3 & 0x01) == 0x01)
                         {
                             PRINTF("send CWF_LONG_F3\n")
                                     ring_node_to_send_cwf_f3->sid = SID_NORM_CWF_LONG_F3;
                             status =  rtems_message_queue_send( queue_id, &ring_node_to_send_cwf, sizeof( ring_node* ) );
                         }
                         else
                         {
                             PRINTF("send CWF_F3 (light)\n")
                                     send_waveform_CWF3_light( ring_node_to_send_cwf, &ring_node_cwf3_light, queue_id );
                         }
                     }
                     else
                     {
                         PRINTF1("in CWF3 *** lfrCurrentMode is %d, no data will be sent\n", lfrCurrentMode)
                     }
                 }
             }
             rtems_task cwf2_task(rtems_task_argument argument)  // ONLY USED IN BURST AND SBM2
             {
                 /** This RTEMS task is dedicated to the transmission of continuous waveforms at f2.
                  *
                  * @param unused is the starting argument of the RTEMS task
                  *
                  * The following data packet is sent by this function:
                  * - TM_LFR_SCIENCE_BURST_CWF_F2
                  * - TM_LFR_SCIENCE_SBM2_CWF_F2
                  *
                  */
                 rtems_event_set event_out;
                 rtems_id queue_id;
                 rtems_status_code status;
                 ring_node *ring_node_to_send;
                 unsigned long long int acquisitionTimeF0_asLong;
                 acquisitionTimeF0_asLong = 0x00;
                 status =  get_message_queue_id_send( &queue_id );
                 if (status != RTEMS_SUCCESSFUL)
                 {
                     PRINTF1("in CWF2 *** ERR get_message_queue_id_send %d\n", status)
                 }
                 BOOT_PRINTF("in CWF2 ***\n")
                         while(1){
                     // wait for an RTEMS_EVENT// send the snapshot when built
                     status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM2 );
                     rtems_event_receive( RTEMS_EVENT_MODE_NORM_S1_S2 | RTEMS_EVENT_MODE_BURST,
                                          RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
                     ring_node_to_send = getRingNodeToSendCWF( 2 );
                     if (event_out == RTEMS_EVENT_MODE_BURST)
                     {
                         status =  rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) );
                     }
                     else if (event_out == RTEMS_EVENT_MODE_NORM_S1_S2)
                     {
                         if ( lfrCurrentMode == LFR_MODE_SBM2 )
                         {
                             status =  rtems_message_queue_send( queue_id, &ring_node_to_send, sizeof( ring_node* ) );
                         }
                         // launch snapshot extraction if needed
                         if (extractSWF2 == true)
                         {
                             ring_node_to_send_swf_f2 = ring_node_to_send_cwf_f2;
                             // extract the snapshot
                             build_snapshot_from_ring( ring_node_to_send_swf_f2, 2, acquisitionTimeF0_asLong,
                                                       &ring_node_swf2_extracted, swf2_extracted );
                             extractSWF2 = false;
                             swf2_ready = true;  // once the snapshot at f2 is ready the CWF1 task will send an event to WFRM
                         }
                         if (swf0_ready_flag_f2 == true)
                         {
                             extractSWF2 = true;
                             // record the acquition time of the f0 snapshot to use to build the snapshot at f2
                             acquisitionTimeF0_asLong = get_acquisition_time( (unsigned char *) &ring_node_to_send_swf_f0->coarseTime );
                             swf0_ready_flag_f2 = false;
                         }
                     }
                 }
             }
             rtems_task cwf1_task(rtems_task_argument argument)  // ONLY USED IN SBM1
             {
                 /** This RTEMS task is dedicated to the transmission of continuous waveforms at f1.
                  *
                  * @param unused is the starting argument of the RTEMS task
                  *
                  * The following data packet is sent by this function:
                  * - TM_LFR_SCIENCE_SBM1_CWF_F1
                  *
                  */
                 rtems_event_set event_out;
                 rtems_id queue_id;
                 rtems_status_code status;
                 ring_node *ring_node_to_send_cwf;
                 status =  get_message_queue_id_send( &queue_id );
                 if (status != RTEMS_SUCCESSFUL)
                 {
                     PRINTF1("in CWF1 *** ERR get_message_queue_id_send %d\n", status)
                 }
                 BOOT_PRINTF("in CWF1 ***\n");
                 while(1){
                     // wait for an RTEMS_EVENT
                     rtems_event_receive( RTEMS_EVENT_MODE_NORM_S1_S2,
                                          RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
                     ring_node_to_send_cwf = getRingNodeToSendCWF( 1 );
                     ring_node_to_send_cwf_f1->sid = SID_SBM1_CWF_F1;
                     if (lfrCurrentMode == LFR_MODE_SBM1)
                     {
                         status =  rtems_message_queue_send( queue_id, &ring_node_to_send_cwf, sizeof( ring_node* ) );
                         if (status != 0)
                         {
                             PRINTF("cwf sending failed\n")
                         }
                     }
                     // launch snapshot extraction if needed
                     if (extractSWF1 == true)
                     {
                         ring_node_to_send_swf_f1 = ring_node_to_send_cwf;
                         // launch the snapshot extraction
                         status = rtems_event_send( Task_id[TASKID_SWBD], RTEMS_EVENT_MODE_NORM_S1_S2 );
                         extractSWF1 = false;
                     }
                     if (swf0_ready_flag_f1 == true)
                     {
                         extractSWF1 = true;
                         swf0_ready_flag_f1 = false;   // this step shall be executed only one time
                     }
                     if ((swf1_ready == true) && (swf2_ready == true))   // swf_f1 is ready after the extraction
                     {
                         status = rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_NORMAL );
                         swf1_ready = false;
                         swf2_ready = false;
                     }
                 }
             }
             rtems_task swbd_task(rtems_task_argument argument)
             {
                 /** This RTEMS task is dedicated to the building of snapshots from different continuous waveforms buffers.
                  *
                  * @param unused is the starting argument of the RTEMS task
                  *
                  */
                 rtems_event_set event_out;
                 unsigned long long int acquisitionTimeF0_asLong;
                 acquisitionTimeF0_asLong = 0x00;
                 BOOT_PRINTF("in SWBD ***\n")
                         while(1){
                     // wait for an RTEMS_EVENT
                     rtems_event_receive( RTEMS_EVENT_MODE_NORM_S1_S2,
                                          RTEMS_WAIT | RTEMS_EVENT_ANY, RTEMS_NO_TIMEOUT, &event_out);
                     if (event_out == RTEMS_EVENT_MODE_NORM_S1_S2)
                     {
                         acquisitionTimeF0_asLong = get_acquisition_time( (unsigned char *) &ring_node_to_send_swf_f0->coarseTime );
                         build_snapshot_from_ring( ring_node_to_send_swf_f1, 1, acquisitionTimeF0_asLong,
                                                   &ring_node_swf1_extracted, swf1_extracted );
                         swf1_ready = true;    // the snapshot has been extracted and is ready to be sent
                     }
                     else
                     {
                         PRINTF1("in SWBD *** unexpected rtems event received %x\n", (int) event_out)
                     }
                 }
             }
             //******************
             // general functions
             void WFP_init_rings( void )
             {
                 // F0 RING
                 init_ring( waveform_ring_f0, NB_RING_NODES_F0, wf_buffer_f0, WFRM_BUFFER );
                 // F1 RING
                 init_ring( waveform_ring_f1, NB_RING_NODES_F1, wf_buffer_f1, WFRM_BUFFER );
                 // F2 RING
                 init_ring( waveform_ring_f2, NB_RING_NODES_F2, wf_buffer_f2, WFRM_BUFFER );
                 // F3 RING
                 init_ring( waveform_ring_f3, NB_RING_NODES_F3, wf_buffer_f3, WFRM_BUFFER );
                 ring_node_swf1_extracted.buffer_address = (int) swf1_extracted;
                 ring_node_swf2_extracted.buffer_address = (int) swf2_extracted;
                 DEBUG_PRINTF1("waveform_ring_f0 @%x\n", (unsigned int) waveform_ring_f0)
                         DEBUG_PRINTF1("waveform_ring_f1 @%x\n", (unsigned int) waveform_ring_f1)
                         DEBUG_PRINTF1("waveform_ring_f2 @%x\n", (unsigned int) waveform_ring_f2)
                         DEBUG_PRINTF1("waveform_ring_f3 @%x\n", (unsigned int) waveform_ring_f3)
                         DEBUG_PRINTF1("wf_buffer_f0 @%x\n", (unsigned int) wf_buffer_f0)
                         DEBUG_PRINTF1("wf_buffer_f1 @%x\n", (unsigned int) wf_buffer_f1)
                         DEBUG_PRINTF1("wf_buffer_f2 @%x\n", (unsigned int) wf_buffer_f2)
                         DEBUG_PRINTF1("wf_buffer_f3 @%x\n", (unsigned int) wf_buffer_f3)
             }
             void WFP_reset_current_ring_nodes( void )
             {
                 current_ring_node_f0      = waveform_ring_f0[0].next;
                 current_ring_node_f1      = waveform_ring_f1[0].next;
                 current_ring_node_f2      = waveform_ring_f2[0].next;
                 current_ring_node_f3      = waveform_ring_f3[0].next;
                 ring_node_to_send_swf_f0  = waveform_ring_f0;
                 ring_node_to_send_swf_f1  = waveform_ring_f1;
                 ring_node_to_send_swf_f2  = waveform_ring_f2;
                 ring_node_to_send_cwf_f1  = waveform_ring_f1;
                 ring_node_to_send_cwf_f2  = waveform_ring_f2;
                 ring_node_to_send_cwf_f3  = waveform_ring_f3;
             }
             int send_waveform_CWF3_light( ring_node *ring_node_to_send, ring_node *ring_node_cwf3_light, rtems_id queue_id )
             {
                 /** This function sends CWF_F3 CCSDS packets without the b1, b2 and b3 data.
                  *
                  * @param waveform points to the buffer containing the data that will be send.
                  * @param headerCWF points to a table of headers that have been prepared for the data transmission.
                  * @param queue_id is the id of the rtems queue to which spw_ioctl_pkt_send structures will be send. The structures
                  * contain information to setup the transmission of the data packets.
                  *
                  * By default, CWF_F3 packet are send without the b1, b2 and b3 data. This function rebuilds a data buffer
                  * from the incoming data and sends it in 7 packets, 6 containing 340 blocks and 1 one containing 8 blocks.
                  *
                  */
                 unsigned int i;
                 int ret;
                 rtems_status_code status;
                 char *sample;
                 int *dataPtr;
                 ret = LFR_DEFAULT;
                 dataPtr     = (int*) ring_node_to_send->buffer_address;
                 ring_node_cwf3_light->coarseTime = ring_node_to_send->coarseTime;
                 ring_node_cwf3_light->fineTime = ring_node_to_send->fineTime;
                 //**********************
                 // BUILD CWF3_light DATA
                 for ( i=0; i< NB_SAMPLES_PER_SNAPSHOT; i++)
                 {
                     sample = (char*) &dataPtr[ (i * NB_WORDS_SWF_BLK) ];
                     wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK)     ] = sample[ 0 ];
                     wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 1 ] = sample[ 1 ];
                     wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 2 ] = sample[ 2 ];
                     wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 3 ] = sample[ 3 ];
                     wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 4 ] = sample[ 4 ];
                     wf_cont_f3_light[ (i * NB_BYTES_CWF3_LIGHT_BLK) + 5 ] = sample[ 5 ];
                 }
                 // SEND PACKET
                 status =  rtems_message_queue_send( queue_id, &ring_node_cwf3_light, sizeof( ring_node* ) );
                 if (status != RTEMS_SUCCESSFUL) {
                     ret = LFR_DEFAULT;
                 }
                 return ret;
             }
             void compute_acquisition_time( unsigned int coarseTime, unsigned int fineTime,
                                            unsigned int sid, unsigned char pa_lfr_pkt_nr, unsigned char * acquisitionTime )
             {
                 unsigned long long int acquisitionTimeAsLong;
                 unsigned char localAcquisitionTime[6];
                 double deltaT;
                 deltaT = 0.;
                 localAcquisitionTime[0] = (unsigned char) ( coarseTime >> 24 );
                 localAcquisitionTime[1] = (unsigned char) ( coarseTime >> 16 );
                 localAcquisitionTime[2] = (unsigned char) ( coarseTime >> 8  );
                 localAcquisitionTime[3] = (unsigned char) ( coarseTime       );
                 localAcquisitionTime[4] = (unsigned char) ( fineTime   >> 8  );
                 localAcquisitionTime[5] = (unsigned char) ( fineTime         );
                 acquisitionTimeAsLong = ( (unsigned long long int) localAcquisitionTime[0] << 40 )
                         + ( (unsigned long long int) localAcquisitionTime[1] << 32 )
                         + ( (unsigned long long int) localAcquisitionTime[2] << 24 )
                         + ( (unsigned long long int) localAcquisitionTime[3] << 16 )
                         + ( (unsigned long long int) localAcquisitionTime[4] << 8  )
                         + ( (unsigned long long int) localAcquisitionTime[5]       );
                 switch( sid )
                 {
                 case SID_NORM_SWF_F0:
                     deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 24576. ;
                     break;
                 case SID_NORM_SWF_F1:
                     deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 4096. ;
                     break;
                 case SID_NORM_SWF_F2:
                     deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_304 * 65536. / 256. ;
                     break;
                 case SID_SBM1_CWF_F1:
                     deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 4096. ;
                     break;
                 case SID_SBM2_CWF_F2:
                     deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 256. ;
                     break;
                 case SID_BURST_CWF_F2:
                     deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 256. ;
                     break;
                 case SID_NORM_CWF_F3:
                     deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF_SHORT_F3 * 65536. / 16. ;
                     break;
                 case SID_NORM_CWF_LONG_F3:
                     deltaT = ( (double ) (pa_lfr_pkt_nr) ) * BLK_NR_CWF * 65536. / 16. ;
                     break;
                 default:
                     PRINTF1("in compute_acquisition_time *** ERR unexpected sid %d\n", sid)
                             deltaT = 0.;
                     break;
                 }
                 acquisitionTimeAsLong = acquisitionTimeAsLong + (unsigned long long int) deltaT;
                 //
                 acquisitionTime[0] = (unsigned char) (acquisitionTimeAsLong >> 40);
                 acquisitionTime[1] = (unsigned char) (acquisitionTimeAsLong >> 32);
                 acquisitionTime[2] = (unsigned char) (acquisitionTimeAsLong >> 24);
                 acquisitionTime[3] = (unsigned char) (acquisitionTimeAsLong >> 16);
                 acquisitionTime[4] = (unsigned char) (acquisitionTimeAsLong >> 8 );
                 acquisitionTime[5] = (unsigned char) (acquisitionTimeAsLong      );
             }
             void build_snapshot_from_ring( ring_node *ring_node_to_send,
                                            unsigned char frequencyChannel,
                                            unsigned long long int acquisitionTimeF0_asLong,
                                            ring_node *ring_node_swf_extracted,
                                            int *swf_extracted)
             {
                 unsigned int i;
                 unsigned long long int centerTime_asLong;
                 unsigned long long int acquisitionTime_asLong;
                 unsigned long long int bufferAcquisitionTime_asLong;
                 unsigned char *ptr1;
                 unsigned char *ptr2;
                 unsigned char *timeCharPtr;
                 unsigned char nb_ring_nodes;
                 unsigned long long int frequency_asLong;
                 unsigned long long int nbTicksPerSample_asLong;
                 unsigned long long int nbSamplesPart1_asLong;
                 unsigned long long int sampleOffset_asLong;
                 unsigned int deltaT_F0;
                 unsigned int deltaT_F1;
                 unsigned long long int deltaT_F2;
                 deltaT_F0 = 2731;      // (2048. / 24576. / 2.) * 65536. = 2730.667;
                 deltaT_F1 = 16384;  // (2048. / 4096.  / 2.) * 65536. = 16384;
                 deltaT_F2 = 262144; // (2048. / 256.   / 2.) * 65536. = 262144;
                 sampleOffset_asLong = 0x00;
                 // (1) get the f0 acquisition time => the value is passed in argument
                 // (2) compute the central reference time
                 centerTime_asLong = acquisitionTimeF0_asLong + deltaT_F0;
                 // (3) compute the acquisition time of the current snapshot
                 switch(frequencyChannel)
                 {
                 case 1: // 1 is for F1 = 4096 Hz
                     acquisitionTime_asLong = centerTime_asLong - deltaT_F1;
                     nb_ring_nodes = NB_RING_NODES_F1;
                     frequency_asLong = 4096;
                     nbTicksPerSample_asLong = 16;  // 65536 / 4096;
                     break;
                 case 2: // 2 is for F2 = 256 Hz
                     acquisitionTime_asLong = centerTime_asLong - deltaT_F2;
                     nb_ring_nodes = NB_RING_NODES_F2;
                     frequency_asLong = 256;
                     nbTicksPerSample_asLong = 256;  // 65536 / 256;
                     break;
                 default:
                     acquisitionTime_asLong = centerTime_asLong;
                     frequency_asLong = 256;
                     nbTicksPerSample_asLong = 256;
                     break;
                 }
                 //****************************************************************************
                 // (4) search the ring_node with the acquisition time <= acquisitionTime_asLong
                 for (i=0; i<nb_ring_nodes; i++)
                 {
                     //PRINTF1("%d ... ", i);
                             bufferAcquisitionTime_asLong = get_acquisition_time( (unsigned char *) &ring_node_to_send->coarseTime );
                     if (bufferAcquisitionTime_asLong <= acquisitionTime_asLong)
                     {
                         //PRINTF1("buffer found with acquisition time = %llx\n", bufferAcquisitionTime_asLong);
                                 break;
                     }
                     ring_node_to_send = ring_node_to_send->previous;
                 }
                 // (5) compute the number of samples to take in the current buffer
                 sampleOffset_asLong = ((acquisitionTime_asLong - bufferAcquisitionTime_asLong) * frequency_asLong ) >> 16;
                 nbSamplesPart1_asLong = NB_SAMPLES_PER_SNAPSHOT - sampleOffset_asLong;
                 //PRINTF2("sampleOffset_asLong = %lld, nbSamplesPart1_asLong = %lld\n", sampleOffset_asLong, nbSamplesPart1_asLong);
                         // (6) compute the final acquisition time
                         acquisitionTime_asLong = bufferAcquisitionTime_asLong +
                         sampleOffset_asLong * nbTicksPerSample_asLong;
                 // (7) copy the acquisition time at the beginning of the extrated snapshot
                 ptr1 = (unsigned char*) &acquisitionTime_asLong;
                 // fine time
                 ptr2 = (unsigned char*) &ring_node_swf_extracted->fineTime;
                 ptr2[2] = ptr1[ 4 + 2 ];
                 ptr2[3] = ptr1[ 5 + 2 ];
                 // coarse time
                 ptr2 = (unsigned char*) &ring_node_swf_extracted->coarseTime;
                 ptr2[0] = ptr1[ 0 + 2 ];
                 ptr2[1] = ptr1[ 1 + 2 ];
                 ptr2[2] = ptr1[ 2 + 2 ];
                 ptr2[3] = ptr1[ 3 + 2 ];
                 // re set the synchronization bit
                 timeCharPtr = (unsigned char*) &ring_node_to_send->coarseTime;
                 ptr2[0] = ptr2[0] | (timeCharPtr[0] & 0x80); // [1000 0000]
                 if ( (nbSamplesPart1_asLong >= NB_SAMPLES_PER_SNAPSHOT) | (nbSamplesPart1_asLong < 0) )
                 {
                     nbSamplesPart1_asLong = 0;
                 }
                 // copy the part 1 of the snapshot in the extracted buffer
                 for ( i = 0; i < (nbSamplesPart1_asLong * NB_WORDS_SWF_BLK); i++ )
                 {
                     swf_extracted[i] =
                             ((int*) ring_node_to_send->buffer_address)[ i + (sampleOffset_asLong * NB_WORDS_SWF_BLK) ];
                 }
                 // copy the part 2 of the snapshot in the extracted buffer
                 ring_node_to_send = ring_node_to_send->next;
                 for ( i = (nbSamplesPart1_asLong * NB_WORDS_SWF_BLK); i < (NB_SAMPLES_PER_SNAPSHOT * NB_WORDS_SWF_BLK); i++ )
                 {
                     swf_extracted[i] =
                             ((int*) ring_node_to_send->buffer_address)[ (i-(nbSamplesPart1_asLong * NB_WORDS_SWF_BLK)) ];
                 }
             }
             double computeCorrection( unsigned char *timePtr )
             {
                 unsigned long long int acquisitionTime;
                 unsigned long long int centerTime;
                 unsigned long long int previousTick;
                 unsigned long long int nextTick;
                 unsigned long long int deltaPreviousTick;
                 unsigned long long int deltaNextTick;
                 double deltaPrevious_ms;
                 double deltaNext_ms;
                 double correctionInF2;
                 // get acquisition time in fine time ticks
                 acquisitionTime = get_acquisition_time( timePtr );
                 // compute center time
                 centerTime = acquisitionTime + 2731;    // (2048. / 24576. / 2.) * 65536. = 2730.667;
                 previousTick = centerTime - (centerTime & 0xffff);
                 nextTick = previousTick + 65536;
                 deltaPreviousTick   = centerTime - previousTick;
                 deltaNextTick       = nextTick - centerTime;
                 deltaPrevious_ms    = ((double) deltaPreviousTick) / 65536. * 1000.;
                 deltaNext_ms        = ((double) deltaNextTick) / 65536. * 1000.;
                 PRINTF2("    delta previous = %.3f ms, delta next = %.2f ms\n", deltaPrevious_ms, deltaNext_ms);
-            //    PRINTF2("    delta previous = %llu fine time ticks, delta next = %llu fine time ticks\n",
-            //            deltaPreviousTick, deltaNextTick);
                 // which tick is the closest?
                 if (deltaPreviousTick > deltaNextTick)
                 {
                     // the snapshot center is just before the second => increase delta_snapshot
                     correctionInF2 = + (deltaNext_ms * 256. / 1000. );
                 }
                 else
                 {
                     // the snapshot center is just after the second => decrease delta_snapshot
                     correctionInF2 = - (deltaPrevious_ms * 256. / 1000. );
                 }
                 PRINTF1("    correctionInF2 = %.2f\n", correctionInF2);
                 return correctionInF2;
             }
             void applyCorrection( double correction )
             {
                 int correctionInt;
-                if (correction>=0.)
+                if (correction >= 0.)
                 {
-                    if ( correction > 0.5 )
+                    if ( (1. > correction) && (correction > 0.5) )
                     {
                         correctionInt = 1;
                     }
                     else
                     {
                         correctionInt = floor(correction);
                     }
                 }
                 else
                 {
-                    if ( correction < -0.5)
+                    if ( (correction < -1.) && (correction < -0.5) )
                     {
                         correctionInt = -1;
                     }
                     else
                     {
                         correctionInt =  ceil(correction);
                     }
                 }
                 waveform_picker_regs->delta_snapshot = waveform_picker_regs->delta_snapshot + correctionInt;
             }
             void snapshot_resynchronization( unsigned char *timePtr )
             {
                 /** This function compute a correction to apply on delta_snapshot.
                  *
                  *
                  * @param timePtr is a pointer to the acquisition time of the snapshot being considered.
                  *
                  * @return void
                  *
                  */
                 static double correction    = 0.;
                 static resynchro_state state = MEASURE;
                 static unsigned int nbSnapshots = 0;
                 int correctionInt;
                 correctionInt = 0;
                 switch (state)
                 {
                 case MEASURE:
                     // ********
                     PRINTF1("MEASURE === %d\n", nbSnapshots);
                     state = CORRECTION;
                     correction = computeCorrection( timePtr );
                     PRINTF1("MEASURE === correction = %.2f\n", correction );
                     applyCorrection( correction );
                     PRINTF1("MEASURE === delta_snapshot = %d\n", waveform_picker_regs->delta_snapshot);
                     //****
                     break;
                 case CORRECTION:
                     //************
                     PRINTF1("CORRECTION === %d\n", nbSnapshots);
                     state = MEASURE;
                     computeCorrection( timePtr );
                     correction = -correction;
                     PRINTF1("CORRECTION === correction = %.2f\n", correction );
                     applyCorrection( correction );
                     PRINTF1("CORRECTION === delta_snapshot = %d\n", waveform_picker_regs->delta_snapshot);
                     //****
                     break;
                 default:
                     break;
                 }
                 nbSnapshots++;
             }
             //**************
             // wfp registers
             void reset_wfp_burst_enable( void )
             {
                 /** This function resets the waveform picker burst_enable register.
                  *
                  * The burst bits [f2 f1 f0] and the enable bits [f3 f2 f1 f0] are set to 0.
                  *
                  */
                 // [1000 000] burst f2, f1, f0     enable f3, f2, f1, f0
                 waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable & 0x80;
             }
             void reset_wfp_status( void )
             {
                 /** This function resets the waveform picker status register.
                  *
                  * All status bits are set to 0 [new_err full_err full].
                  *
                  */
                 waveform_picker_regs->status = 0xffff;
             }
             void reset_wfp_buffer_addresses( void )
             {
                 // F0
                 waveform_picker_regs->addr_data_f0_0 = current_ring_node_f0->previous->buffer_address;  // 0x08
                 waveform_picker_regs->addr_data_f0_1 = current_ring_node_f0->buffer_address;            // 0x0c
                 // F1
                 waveform_picker_regs->addr_data_f1_0 = current_ring_node_f1->previous->buffer_address;  // 0x10
                 waveform_picker_regs->addr_data_f1_1 = current_ring_node_f1->buffer_address;            // 0x14
                 // F2
                 waveform_picker_regs->addr_data_f2_0 = current_ring_node_f2->previous->buffer_address;  // 0x18
                 waveform_picker_regs->addr_data_f2_1 = current_ring_node_f2->buffer_address;            // 0x1c
                 // F3
                 waveform_picker_regs->addr_data_f3_0 = current_ring_node_f3->previous->buffer_address;  // 0x20
                 waveform_picker_regs->addr_data_f3_1 = current_ring_node_f3->buffer_address;            // 0x24
             }
             void reset_waveform_picker_regs( void )
             {
                 /** This function resets the waveform picker module registers.
                 *
                 * The registers affected by this function are located at the following offset addresses:
                 * - 0x00 data_shaping
                 * - 0x04 run_burst_enable
                 * - 0x08 addr_data_f0
                 * - 0x0C addr_data_f1
                 * - 0x10 addr_data_f2
                 * - 0x14 addr_data_f3
                 * - 0x18 status
                 * - 0x1C delta_snapshot
                 * - 0x20 delta_f0
                 * - 0x24 delta_f0_2
                 * - 0x28 delta_f1 (obsolet parameter)
                 * - 0x2c delta_f2
                 * - 0x30 nb_data_by_buffer
                 * - 0x34 nb_snapshot_param
                 * - 0x38 start_date
                 * - 0x3c nb_word_in_buffer
                 *
                 */
                 set_wfp_data_shaping();                                     // 0x00 *** R1 R0 SP1 SP0 BW
                 reset_wfp_burst_enable();                                   // 0x04 *** [run *** burst f2, f1, f0 *** enable f3, f2, f1, f0 ]
                 reset_wfp_buffer_addresses();
                 reset_wfp_status();                                         // 0x18
                 set_wfp_delta_snapshot();   // 0x1c *** 300 s => 0x12bff
                 set_wfp_delta_f0_f0_2();    // 0x20, 0x24
                 //the parameter delta_f1 [0x28] is not used anymore
                 set_wfp_delta_f2();         // 0x2c
                 DEBUG_PRINTF1("delta_snapshot %x\n",    waveform_picker_regs->delta_snapshot);
                 DEBUG_PRINTF1("delta_f0 %x\n",          waveform_picker_regs->delta_f0);
                 DEBUG_PRINTF1("delta_f0_2 %x\n",        waveform_picker_regs->delta_f0_2);
                 DEBUG_PRINTF1("delta_f1 %x\n",          waveform_picker_regs->delta_f1);
                 DEBUG_PRINTF1("delta_f2 %x\n",          waveform_picker_regs->delta_f2);
                 // 2688 = 8 * 336
                 waveform_picker_regs->nb_data_by_buffer = 0xa7f; // 0x30 *** 2688 - 1 => nb samples -1
                 waveform_picker_regs->snapshot_param    = 0xa80; // 0x34 *** 2688 => nb samples
                 waveform_picker_regs->start_date        = 0x7fffffff;  // 0x38
                 //
                 // coarse time and fine time registers are not initialized, they are volatile
                 //
                 waveform_picker_regs->buffer_length     = 0x1f8;// buffer length in burst = 3 * 2688 / 16 = 504 = 0x1f8
             }
             void set_wfp_data_shaping( void )
             {
                 /** This function sets the data_shaping register of the waveform picker module.
                  *
                  * The value is read from one field of the parameter_dump_packet structure:\n
                  * bw_sp0_sp1_r0_r1
                  *
                  */
                 unsigned char data_shaping;
                 // get the parameters for the data shaping [BW SP0 SP1 R0 R1] in sy_lfr_common1 and configure the register
                 // waveform picker : [R1 R0 SP1 SP0 BW]
                 data_shaping = parameter_dump_packet.sy_lfr_common_parameters;
                 waveform_picker_regs->data_shaping =
                         ( (data_shaping & 0x20) >> 5 )     // BW
                         + ( (data_shaping & 0x10) >> 3 )     // SP0
                         + ( (data_shaping & 0x08) >> 1 )     // SP1
                         + ( (data_shaping & 0x04) << 1 )     // R0
                         + ( (data_shaping & 0x02) << 3 )     // R1
                         + ( (data_shaping & 0x01) << 5 );    // R2
             }
             void set_wfp_burst_enable_register( unsigned char mode )
             {
                 /** This function sets the waveform picker burst_enable register depending on the mode.
                  *
                  * @param mode is the LFR mode to launch.
                  *
                  * The burst bits shall be before the enable bits.
                  *
                  */
                 // [0000 0000] burst f2, f1, f0 enable f3 f2 f1 f0
                 // the burst bits shall be set first, before the enable bits
                 switch(mode) {
                 case LFR_MODE_NORMAL:
                 case LFR_MODE_SBM1:
                 case LFR_MODE_SBM2:
                     waveform_picker_regs->run_burst_enable = 0x60;  // [0110 0000] enable f2 and f1 burst
                     waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x0f; // [1111] enable f3 f2 f1 f0
                     break;
                 case LFR_MODE_BURST:
                     waveform_picker_regs->run_burst_enable = 0x40;  // [0100 0000] f2 burst enabled
                     waveform_picker_regs->run_burst_enable = waveform_picker_regs->run_burst_enable | 0x0c; // [1100] enable f3 and f2
                     break;
                 default:
                     waveform_picker_regs->run_burst_enable = 0x00;  // [0000 0000] no burst enabled, no waveform enabled
                     break;
                 }
             }
             void set_wfp_delta_snapshot( void )
             {
                 /** This function sets the delta_snapshot register of the waveform picker module.
                  *
                  * The value is read from two (unsigned char) of the parameter_dump_packet structure:
                  * - sy_lfr_n_swf_p[0]
                  * - sy_lfr_n_swf_p[1]
                  *
                  */
                 unsigned int delta_snapshot;
                 unsigned int delta_snapshot_in_T2;
                 delta_snapshot = parameter_dump_packet.sy_lfr_n_swf_p[0]*256
                         + parameter_dump_packet.sy_lfr_n_swf_p[1];
                 delta_snapshot_in_T2 = delta_snapshot * 256;
                 waveform_picker_regs->delta_snapshot = delta_snapshot_in_T2 - 1;    // max 4 bytes
             }
             void set_wfp_delta_f0_f0_2( void )
             {
                 unsigned int delta_snapshot;
                 unsigned int nb_samples_per_snapshot;
                 float delta_f0_in_float;
                 delta_snapshot = waveform_picker_regs->delta_snapshot;
                 nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];
                 delta_f0_in_float = nb_samples_per_snapshot / 2. * ( 1. / 256. - 1. / 24576.) * 256.;
                 waveform_picker_regs->delta_f0      = delta_snapshot - floor( delta_f0_in_float );
                 waveform_picker_regs->delta_f0_2    = 0x30;         // 48 = 11 0000, max 7 bits
             }
             void set_wfp_delta_f1( void )
             {
                 /** Sets the value of the delta_f1 parameter
                  *
                  * @param void
                  *
                  * @return void
                  *
                  * delta_f1 is not used, the snapshots are extracted from CWF_F1 waveforms.
                  *
                  */
                 unsigned int delta_snapshot;
                 unsigned int nb_samples_per_snapshot;
                 float delta_f1_in_float;
                 delta_snapshot = waveform_picker_regs->delta_snapshot;
                 nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];
                 delta_f1_in_float = nb_samples_per_snapshot / 2. * ( 1. / 256. - 1. / 4096.) * 256.;
                 waveform_picker_regs->delta_f1 = delta_snapshot - floor( delta_f1_in_float );
             }
             void set_wfp_delta_f2( void )   // parameter not used, only delta_f0 and delta_f0_2 are used
             {
                 /** Sets the value of the delta_f2 parameter
                  *
                  * @param void
                  *
                  * @return void
                  *
                  * delta_f2 is used only for the first snapshot generation, even when the snapshots are extracted from CWF_F2
                  * waveforms (see lpp_waveform_snapshot_controler.vhd for details).
                  *
                  */
                 unsigned int delta_snapshot;
                 unsigned int nb_samples_per_snapshot;
                 delta_snapshot = waveform_picker_regs->delta_snapshot;
                 nb_samples_per_snapshot = parameter_dump_packet.sy_lfr_n_swf_l[0] * 256 + parameter_dump_packet.sy_lfr_n_swf_l[1];
                 waveform_picker_regs->delta_f2 = delta_snapshot - nb_samples_per_snapshot / 2 - 1;
             }
             //*****************
             // local parameters
             void increment_seq_counter_source_id( unsigned char *packet_sequence_control, unsigned int sid )
             {
                 /** This function increments the parameter "sequence_cnt" depending on the sid passed in argument.
                  *
                  * @param packet_sequence_control is a pointer toward the parameter sequence_cnt to update.
                  * @param sid is the source identifier of the packet being updated.
                  *
                  * REQ-LFR-SRS-5240 / SSS-CP-FS-590
                  * The sequence counters shall wrap around from 2^14 to zero.
                  * The sequence counter shall start at zero at startup.
                  *
                  * REQ-LFR-SRS-5239 / SSS-CP-FS-580
                  * All TM_LFR_SCIENCE_ packets are sent to ground, i.e. destination id = 0
                  *
                  */
                 unsigned short *sequence_cnt;
                 unsigned short segmentation_grouping_flag;
                 unsigned short new_packet_sequence_control;
                 rtems_mode initial_mode_set;
                 rtems_mode current_mode_set;
                 rtems_status_code status;
                 //******************************************
                 // CHANGE THE MODE OF THE CALLING RTEMS TASK
                 status =  rtems_task_mode( RTEMS_NO_PREEMPT, RTEMS_PREEMPT_MASK, &initial_mode_set );
                 if ( (sid == SID_NORM_SWF_F0)    || (sid == SID_NORM_SWF_F1) || (sid == SID_NORM_SWF_F2)
                      || (sid == SID_NORM_CWF_F3) || (sid == SID_NORM_CWF_LONG_F3)
                      || (sid == SID_BURST_CWF_F2)
                      || (sid == SID_NORM_ASM_F0) || (sid == SID_NORM_ASM_F1) || (sid == SID_NORM_ASM_F2)
                      || (sid == SID_NORM_BP1_F0) || (sid == SID_NORM_BP1_F1) || (sid == SID_NORM_BP1_F2)
                      || (sid == SID_NORM_BP2_F0) || (sid == SID_NORM_BP2_F1) || (sid == SID_NORM_BP2_F2)
                      || (sid == SID_BURST_BP1_F0) || (sid == SID_BURST_BP2_F0)
                      || (sid == SID_BURST_BP1_F1) || (sid == SID_BURST_BP2_F1) )
                 {
                     sequence_cnt = (unsigned short *) &sequenceCounters_SCIENCE_NORMAL_BURST;
                 }
                 else if ( (sid ==SID_SBM1_CWF_F1) || (sid ==SID_SBM2_CWF_F2)
                           || (sid == SID_SBM1_BP1_F0) || (sid == SID_SBM1_BP2_F0)
                           || (sid == SID_SBM2_BP1_F0) || (sid == SID_SBM2_BP2_F0)
                           || (sid == SID_SBM2_BP1_F1) || (sid == SID_SBM2_BP2_F1) )
                 {
                     sequence_cnt = (unsigned short *) &sequenceCounters_SCIENCE_SBM1_SBM2;
                 }
                 else
                 {
                     sequence_cnt = (unsigned short *) NULL;
                     PRINTF1("in increment_seq_counter_source_id *** ERR apid_destid %d not known\n", sid)
                 }
                 if (sequence_cnt != NULL)
                 {
                     segmentation_grouping_flag  = TM_PACKET_SEQ_CTRL_STANDALONE << 8;
                     *sequence_cnt                = (*sequence_cnt) & 0x3fff;
                     new_packet_sequence_control = segmentation_grouping_flag | (*sequence_cnt) ;
                     packet_sequence_control[0] = (unsigned char) (new_packet_sequence_control >> 8);
                     packet_sequence_control[1] = (unsigned char) (new_packet_sequence_control     );
                     // increment the sequence counter
                     if ( *sequence_cnt < SEQ_CNT_MAX)
                     {
                         *sequence_cnt = *sequence_cnt + 1;
                     }
                     else
                     {
                         *sequence_cnt = 0;
                     }
                 }
                 //*************************************
                 // RESTORE THE MODE OF THE CALLING TASK
                 status =  rtems_task_mode( initial_mode_set, RTEMS_PREEMPT_MASK, &current_mode_set );
             }