##// END OF EJS Templates
HG_REPOSITORIES » LPP » INSTRUMENTATION » SOLO_LFR » DEV_PLE
RSS

Clone from http://pc-instru.lpp.polytechnique.fr:5000/DEV_PLE

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