##// END OF EJS Templates
TM_LFR_SCIENCE_NORMA_ASM_ packets modified, 32 bits values instead of 16 bits...
paul -
r196:48fc5efcfe9b R3
parent child
Show More
@@ -1,2 +1,2
1 1 a586fe639ac179e95bdc150ebdbab0312f31dc30 LFR_basic-parameters
2 a806a190dcd72f71d336545073400d3cdaaa3119 header/lfr_common_headers
2 72c4d5eb0bb95a1546beb2b22c8b88c31322ae31 header/lfr_common_headers
@@ -2,7 +2,7 TEMPLATE = app
2 2 # CONFIG += console v8 sim
3 3 # CONFIG options = verbose *** boot_messages *** debug_messages *** cpu_usage_report *** stack_report *** vhdl_dev *** debug_tch
4 4 # lpp_dpu_destid
5 CONFIG += console verbose lpp_dpu_destid
5 CONFIG += console verbose lpp_dpu_destid cpu_usage_report
6 6 CONFIG -= qt
7 7
8 8 include(./sparc.pri)
@@ -30,6 +30,13 static inline void flushCache() {
30 30 asm("flush");
31 31 }
32 32
33 static void resetCacheControlRegister() {
34 #ifdef LEON3
35 unsigned int cacheControlRegister;
36 cacheControlRegister = 0x00;
37 setCacheControlRegister(cacheControlRegister);
38 #endif
39 }
33 40
34 41 static void enableInstructionCache() {
35 42 #ifdef LEON3
@@ -37,7 +37,9 void init_header_asm( Header_TM_LFR_SCIE
37 37 int spw_send_waveform_CWF( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_CWF_t *header );
38 38 int spw_send_waveform_SWF( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_SWF_t *header );
39 39 int spw_send_waveform_CWF3_light( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_CWF_t *header );
40 void spw_send_asm( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_ASM_t *header );
40 void spw_send_asm_f0( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_ASM_t *header );
41 void spw_send_asm_f1( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_ASM_t *header );
42 void spw_send_asm_f2( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_ASM_t *header );
41 43 void spw_send_k_dump( ring_node *ring_node_to_send );
42 44
43 45 void timecode_irq_handler( void *pDev, void *regs, int minor, unsigned int tc );
@@ -1,5 +1,5
1 1 # LOAD FSW USING LINK 1
2 SpwPlugin0.StarDundeeSelectLinkNumber( 2 )
2 SpwPlugin0.StarDundeeSelectLinkNumber( 1 )
3 3
4 4 dsu3plugin0.openFile("/opt/DEV_PLE/FSW-qt/bin/fsw")
5 5 #dsu3plugin0.openFile("/opt/LFR/LFR-FSW/2.0.2.3/fsw")
@@ -5,7 +5,7 struct drvmgr_key grlib_grspw_0n1_res[]
5 5 {"txBdCnt", KEY_TYPE_INT, {(unsigned int)50}}, // 7 SWF_F0, 7 SWF_F1, 7 SWF_F2, 7 CWF_F3, 7 CWF_F1 ou 7 CWF_F2
6 6 {"rxBdCnt", KEY_TYPE_INT, {(unsigned int)10}},
7 7 {"txDataSize", KEY_TYPE_INT, {(unsigned int)4096}},
8 {"txHdrSize", KEY_TYPE_INT, {(unsigned int)20+12}}, // 12 is for the auxiliary header, when needed
8 {"txHdrSize", KEY_TYPE_INT, {(unsigned int)34}},
9 9 {"rxPktSize", KEY_TYPE_INT, {(unsigned int)248+4}},
10 10 KEY_EMPTY
11 11 };
@@ -63,22 +63,24
63 63
64 64 void initCache()
65 65 {
66 // unsigned int cacheControlRegister;
66 unsigned int cacheControlRegister;
67 67
68 // cacheControlRegister = getCacheControlRegister();
69 // printf("(0) cacheControlRegister = %x\n", cacheControlRegister);
68 cacheControlRegister = getCacheControlRegister();
69 printf("(0) cacheControlRegister = %x\n", cacheControlRegister);
70
71 resetCacheControlRegister();
70 72
71 73 enableInstructionCache();
72 74 enableDataCache();
73 75 enableInstructionBurstFetch();
74 76
75 // cacheControlRegister = getCacheControlRegister();
76 // printf("(1) cacheControlRegister = %x\n", cacheControlRegister);
77 cacheControlRegister = getCacheControlRegister();
78 printf("(1) cacheControlRegister = %x\n", cacheControlRegister);
77 79 }
78 80
79 81 rtems_task Init( rtems_task_argument ignored )
80 82 {
81 /** This is the RTEMS INIT taks, it the first task launched by the system.
83 /** This is the RTEMS INIT taks, it is the first task launched by the system.
82 84 *
83 85 * @param unused is the starting argument of the RTEMS task
84 86 *
@@ -270,9 +270,17 rtems_task send_task( rtems_task_argumen
270 270 {
271 271 spw_send_waveform_CWF3_light( incomingRingNodePtr, &headerCWF );
272 272 }
273 else if ( (sid==SID_NORM_ASM_F0) || (sid==SID_NORM_ASM_F1) || (sid==SID_NORM_ASM_F2) )
273 else if (sid==SID_NORM_ASM_F0)
274 {
275 spw_send_asm_f0( incomingRingNodePtr, &headerASM );
276 }
277 else if (sid==SID_NORM_ASM_F1)
274 278 {
275 spw_send_asm( incomingRingNodePtr, &headerASM );
279 spw_send_asm_f1( incomingRingNodePtr, &headerASM );
280 }
281 else if (sid==SID_NORM_ASM_F2)
282 {
283 spw_send_asm_f2( incomingRingNodePtr, &headerASM );
276 284 }
277 285 else if ( sid==TM_CODE_K_DUMP )
278 286 {
@@ -806,7 +814,7 int spw_send_waveform_CWF( ring_node *ri
806 814 int *dataPtr;
807 815 unsigned char sid;
808 816
809 spw_ioctl_send_CWF.hlen = TM_HEADER_LEN + 4 + 10; // + 4 is for the protocole extra header, + 10 is for the auxiliary header
817 spw_ioctl_send_CWF.hlen = HEADER_LENGTH_TM_LFR_SCIENCE_CWF;
810 818 spw_ioctl_send_CWF.options = 0;
811 819
812 820 ret = LFR_DEFAULT;
@@ -891,7 +899,7 int spw_send_waveform_SWF( ring_node *ri
891 899 int *dataPtr;
892 900 unsigned char sid;
893 901
894 spw_ioctl_send_SWF.hlen = TM_HEADER_LEN + 4 + 12; // + 4 is for the protocole extra header, + 12 is for the auxiliary header
902 spw_ioctl_send_SWF.hlen = HEADER_LENGTH_TM_LFR_SCIENCE_SWF;
895 903 spw_ioctl_send_SWF.options = 0;
896 904
897 905 ret = LFR_DEFAULT;
@@ -980,7 +988,7 int spw_send_waveform_CWF3_light( ring_n
980 988 char *dataPtr;
981 989 unsigned char sid;
982 990
983 spw_ioctl_send_CWF.hlen = TM_HEADER_LEN + 4 + 10; // + 4 is for the protocole extra header, + 10 is for the auxiliary header
991 spw_ioctl_send_CWF.hlen = HEADER_LENGTH_TM_LFR_SCIENCE_CWF;
984 992 spw_ioctl_send_CWF.options = 0;
985 993
986 994 ret = LFR_DEFAULT;
@@ -1036,65 +1044,51 int spw_send_waveform_CWF3_light( ring_n
1036 1044 return ret;
1037 1045 }
1038 1046
1039 void spw_send_asm( ring_node *ring_node_to_send,
1047 void spw_send_asm_f0( ring_node *ring_node_to_send,
1040 1048 Header_TM_LFR_SCIENCE_ASM_t *header )
1041 1049 {
1042 1050 unsigned int i;
1043 1051 unsigned int length = 0;
1044 1052 rtems_status_code status;
1045 1053 unsigned int sid;
1046 char *spectral_matrix;
1054 float *spectral_matrix;
1047 1055 int coarseTime;
1048 1056 int fineTime;
1049 1057 spw_ioctl_pkt_send spw_ioctl_send_ASM;
1050 1058
1051 1059 sid = ring_node_to_send->sid;
1052 spectral_matrix = (char*) ring_node_to_send->buffer_address;
1060 spectral_matrix = (float*) ring_node_to_send->buffer_address;
1053 1061 coarseTime = ring_node_to_send->coarseTime;
1054 1062 fineTime = ring_node_to_send->fineTime;
1055 1063
1056 1064 header->sy_lfr_common_parameters = parameter_dump_packet.sy_lfr_common_parameters;
1057 1065
1058 for (i=0; i<2; i++)
1066 for (i=0; i<3; i++)
1059 1067 {
1060 // (1) BUILD THE DATA
1061 switch(sid)
1068 if ((i==0) || (i==1))
1062 1069 {
1063 case SID_NORM_ASM_F0:
1064 spw_ioctl_send_ASM.dlen = TOTAL_SIZE_ASM_F0_IN_BYTES / 2; // 2 packets will be sent
1065 spw_ioctl_send_ASM.data = &spectral_matrix[
1066 ( (ASM_F0_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F0) ) * NB_VALUES_PER_SM ) * 2
1067 ];
1068 length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F0;
1069 header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE_6;
1070 header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F0) >> 8 ); // BLK_NR MSB
1071 header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F0); // BLK_NR LSB
1072 break;
1073 case SID_NORM_ASM_F1:
1074 spw_ioctl_send_ASM.dlen = TOTAL_SIZE_ASM_F1_IN_BYTES / 2; // 2 packets will be sent
1075 spw_ioctl_send_ASM.data = &spectral_matrix[
1076 ( (ASM_F1_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F1) ) * NB_VALUES_PER_SM ) * 2
1070 spw_ioctl_send_ASM.dlen = DLEN_ASM_F0_PKT_1;
1071 spw_ioctl_send_ASM.data = (char *) &spectral_matrix[
1072 ( (ASM_F0_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F0_1) ) * NB_VALUES_PER_SM )
1077 1073 ];
1078 length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F1;
1074 length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F0_1;
1079 1075 header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE_6;
1080 header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F1) >> 8 ); // BLK_NR MSB
1081 header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F1); // BLK_NR LSB
1082 break;
1083 case SID_NORM_ASM_F2:
1084 spw_ioctl_send_ASM.dlen = TOTAL_SIZE_ASM_F2_IN_BYTES / 2; // 2 packets will be sent
1085 spw_ioctl_send_ASM.data = &spectral_matrix[
1086 ( (ASM_F2_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F2) ) * NB_VALUES_PER_SM ) * 2
1076 header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F0_1) >> 8 ); // BLK_NR MSB
1077 header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F0_1); // BLK_NR LSB
1078 }
1079 else
1080 {
1081 spw_ioctl_send_ASM.dlen = DLEN_ASM_F0_PKT_2;
1082 spw_ioctl_send_ASM.data = (char*) &spectral_matrix[
1083 ( (ASM_F0_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F0_1) ) * NB_VALUES_PER_SM )
1087 1084 ];
1088 length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F2;
1089 header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE_3;
1090 header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F2) >> 8 ); // BLK_NR MSB
1091 header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F2); // BLK_NR LSB
1092 break;
1093 default:
1094 PRINTF1("ERR *** in spw_send_asm *** unexpected sid %d\n", sid)
1095 break;
1085 length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F0_2;
1086 header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE_6;
1087 header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F0_2) >> 8 ); // BLK_NR MSB
1088 header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F0_2); // BLK_NR LSB
1096 1089 }
1097 spw_ioctl_send_ASM.hlen = HEADER_LENGTH_TM_LFR_SCIENCE_ASM + CCSDS_PROTOCOLE_EXTRA_BYTES;
1090
1091 spw_ioctl_send_ASM.hlen = HEADER_LENGTH_TM_LFR_SCIENCE_ASM;
1098 1092 spw_ioctl_send_ASM.hdr = (char *) header;
1099 1093 spw_ioctl_send_ASM.options = 0;
1100 1094
@@ -1103,7 +1097,152 void spw_send_asm( ring_node *ring_node_
1103 1097 header->packetLength[0] = (unsigned char) (length>>8);
1104 1098 header->packetLength[1] = (unsigned char) (length);
1105 1099 header->sid = (unsigned char) sid; // SID
1106 header->pa_lfr_pkt_cnt_asm = 2;
1100 header->pa_lfr_pkt_cnt_asm = 3;
1101 header->pa_lfr_pkt_nr_asm = (unsigned char) (i+1);
1102
1103 // (3) SET PACKET TIME
1104 header->time[0] = (unsigned char) (coarseTime>>24);
1105 header->time[1] = (unsigned char) (coarseTime>>16);
1106 header->time[2] = (unsigned char) (coarseTime>>8);
1107 header->time[3] = (unsigned char) (coarseTime);
1108 header->time[4] = (unsigned char) (fineTime>>8);
1109 header->time[5] = (unsigned char) (fineTime);
1110 //
1111 header->acquisitionTime[0] = header->time[0];
1112 header->acquisitionTime[1] = header->time[1];
1113 header->acquisitionTime[2] = header->time[2];
1114 header->acquisitionTime[3] = header->time[3];
1115 header->acquisitionTime[4] = header->time[4];
1116 header->acquisitionTime[5] = header->time[5];
1117
1118 // (4) SEND PACKET
1119 status = ioctl( fdSPW, SPACEWIRE_IOCTRL_SEND, &spw_ioctl_send_ASM );
1120 if (status != RTEMS_SUCCESSFUL) {
1121 printf("in ASM_send *** ERR %d\n", (int) status);
1122 }
1123 }
1124 }
1125
1126 void spw_send_asm_f1( ring_node *ring_node_to_send,
1127 Header_TM_LFR_SCIENCE_ASM_t *header )
1128 {
1129 unsigned int i;
1130 unsigned int length = 0;
1131 rtems_status_code status;
1132 unsigned int sid;
1133 float *spectral_matrix;
1134 int coarseTime;
1135 int fineTime;
1136 spw_ioctl_pkt_send spw_ioctl_send_ASM;
1137
1138 sid = ring_node_to_send->sid;
1139 spectral_matrix = (float*) ring_node_to_send->buffer_address;
1140 coarseTime = ring_node_to_send->coarseTime;
1141 fineTime = ring_node_to_send->fineTime;
1142
1143 header->sy_lfr_common_parameters = parameter_dump_packet.sy_lfr_common_parameters;
1144
1145 for (i=0; i<3; i++)
1146 {
1147 if ((i==0) || (i==1))
1148 {
1149 spw_ioctl_send_ASM.dlen = DLEN_ASM_F1_PKT_1;
1150 spw_ioctl_send_ASM.data = (char *) &spectral_matrix[
1151 ( (ASM_F1_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F1_1) ) * NB_VALUES_PER_SM )
1152 ];
1153 length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F1_1;
1154 header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE_6;
1155 header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F1_1) >> 8 ); // BLK_NR MSB
1156 header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F1_1); // BLK_NR LSB
1157 }
1158 else
1159 {
1160 spw_ioctl_send_ASM.dlen = DLEN_ASM_F1_PKT_2;
1161 spw_ioctl_send_ASM.data = (char*) &spectral_matrix[
1162 ( (ASM_F1_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F1_1) ) * NB_VALUES_PER_SM )
1163 ];
1164 length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F1_2;
1165 header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE_6;
1166 header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F1_2) >> 8 ); // BLK_NR MSB
1167 header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F1_2); // BLK_NR LSB
1168 }
1169
1170 spw_ioctl_send_ASM.hlen = HEADER_LENGTH_TM_LFR_SCIENCE_ASM;
1171 spw_ioctl_send_ASM.hdr = (char *) header;
1172 spw_ioctl_send_ASM.options = 0;
1173
1174 // (2) BUILD THE HEADER
1175 increment_seq_counter_source_id( header->packetSequenceControl, sid );
1176 header->packetLength[0] = (unsigned char) (length>>8);
1177 header->packetLength[1] = (unsigned char) (length);
1178 header->sid = (unsigned char) sid; // SID
1179 header->pa_lfr_pkt_cnt_asm = 3;
1180 header->pa_lfr_pkt_nr_asm = (unsigned char) (i+1);
1181
1182 // (3) SET PACKET TIME
1183 header->time[0] = (unsigned char) (coarseTime>>24);
1184 header->time[1] = (unsigned char) (coarseTime>>16);
1185 header->time[2] = (unsigned char) (coarseTime>>8);
1186 header->time[3] = (unsigned char) (coarseTime);
1187 header->time[4] = (unsigned char) (fineTime>>8);
1188 header->time[5] = (unsigned char) (fineTime);
1189 //
1190 header->acquisitionTime[0] = header->time[0];
1191 header->acquisitionTime[1] = header->time[1];
1192 header->acquisitionTime[2] = header->time[2];
1193 header->acquisitionTime[3] = header->time[3];
1194 header->acquisitionTime[4] = header->time[4];
1195 header->acquisitionTime[5] = header->time[5];
1196
1197 // (4) SEND PACKET
1198 status = ioctl( fdSPW, SPACEWIRE_IOCTRL_SEND, &spw_ioctl_send_ASM );
1199 if (status != RTEMS_SUCCESSFUL) {
1200 printf("in ASM_send *** ERR %d\n", (int) status);
1201 }
1202 }
1203 }
1204
1205 void spw_send_asm_f2( ring_node *ring_node_to_send,
1206 Header_TM_LFR_SCIENCE_ASM_t *header )
1207 {
1208 unsigned int i;
1209 unsigned int length = 0;
1210 rtems_status_code status;
1211 unsigned int sid;
1212 float *spectral_matrix;
1213 int coarseTime;
1214 int fineTime;
1215 spw_ioctl_pkt_send spw_ioctl_send_ASM;
1216
1217 sid = ring_node_to_send->sid;
1218 spectral_matrix = (float*) ring_node_to_send->buffer_address;
1219 coarseTime = ring_node_to_send->coarseTime;
1220 fineTime = ring_node_to_send->fineTime;
1221
1222 header->sy_lfr_common_parameters = parameter_dump_packet.sy_lfr_common_parameters;
1223
1224 for (i=0; i<3; i++)
1225 {
1226
1227 spw_ioctl_send_ASM.dlen = DLEN_ASM_F2_PKT;
1228 spw_ioctl_send_ASM.data = (char *) &spectral_matrix[
1229 ( (ASM_F2_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F2) ) * NB_VALUES_PER_SM )
1230 ];
1231 length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F2;
1232 header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE_3;
1233 header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F2) >> 8 ); // BLK_NR MSB
1234 header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F2); // BLK_NR LSB
1235
1236 spw_ioctl_send_ASM.hlen = HEADER_LENGTH_TM_LFR_SCIENCE_ASM;
1237 spw_ioctl_send_ASM.hdr = (char *) header;
1238 spw_ioctl_send_ASM.options = 0;
1239
1240 // (2) BUILD THE HEADER
1241 increment_seq_counter_source_id( header->packetSequenceControl, sid );
1242 header->packetLength[0] = (unsigned char) (length>>8);
1243 header->packetLength[1] = (unsigned char) (length);
1244 header->sid = (unsigned char) sid; // SID
1245 header->pa_lfr_pkt_cnt_asm = 3;
1107 1246 header->pa_lfr_pkt_nr_asm = (unsigned char) (i+1);
1108 1247
1109 1248 // (3) SET PACKET TIME
@@ -341,10 +341,8 rtems_task prc0_task( rtems_task_argumen
341 341 {
342 342 // 1) reorganize the ASM and divide
343 343 ASM_reorganize_and_divide( asm_f0_patched_norm,
344 asm_f0_reorganized,
344 (float*) current_ring_node_to_send_asm_f0->buffer_address,
345 345 nb_sm_before_f0.norm_bp1 );
346 // 2) convert the float array in a char array
347 ASM_convert( asm_f0_reorganized, (char*) current_ring_node_to_send_asm_f0->buffer_address );
348 346 current_ring_node_to_send_asm_f0->coarseTime = incomingMsg->coarseTimeNORM;
349 347 current_ring_node_to_send_asm_f0->fineTime = incomingMsg->fineTimeNORM;
350 348 current_ring_node_to_send_asm_f0->sid = SID_NORM_ASM_F0;
@@ -336,10 +336,8 rtems_task prc1_task( rtems_task_argumen
336 336 {
337 337 // 1) reorganize the ASM and divide
338 338 ASM_reorganize_and_divide( asm_f1_patched_norm,
339 asm_f1_reorganized,
339 (float*) current_ring_node_to_send_asm_f1->buffer_address,
340 340 nb_sm_before_f1.norm_bp1 );
341 // 2) convert the float array in a char array
342 ASM_convert( asm_f1_reorganized, (char*) current_ring_node_to_send_asm_f1->buffer_address );
343 341 current_ring_node_to_send_asm_f1->coarseTime = incomingMsg->coarseTimeNORM;
344 342 current_ring_node_to_send_asm_f1->fineTime = incomingMsg->fineTimeNORM;
345 343 current_ring_node_to_send_asm_f1->sid = SID_NORM_ASM_F1;
@@ -235,10 +235,8 rtems_task prc2_task( rtems_task_argumen
235 235 {
236 236 // 1) reorganize the ASM and divide
237 237 ASM_reorganize_and_divide( asm_f2_patched_norm,
238 asm_f2_reorganized,
238 (float*) current_ring_node_to_send_asm_f2->buffer_address,
239 239 nb_sm_before_f2.norm_bp1 );
240 // 2) convert the float array in a char array
241 ASM_convert( asm_f2_reorganized, (char*) current_ring_node_to_send_asm_f2->buffer_address );
242 240 current_ring_node_to_send_asm_f2->coarseTime = incomingMsg->coarseTimeNORM;
243 241 current_ring_node_to_send_asm_f2->fineTime = incomingMsg->fineTimeNORM;
244 242 current_ring_node_to_send_asm_f2->sid = SID_NORM_ASM_F2;
General Comments 0
You need to be logged in to leave comments. Login now