@@ -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 | 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 |
|
|
|
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 |
|
|
|
66 | unsigned int cacheControlRegister; | |
|
67 | 67 | |
|
68 |
|
|
|
69 |
|
|
|
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 |
|
|
|
76 |
|
|
|
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 ( |
|
|
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 |
|
|
|
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 = ( |
|
|
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< |
|
|
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.d |
|
|
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_ |
|
|
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 = |
|
|
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 |
|
|
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 |
|
|
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 |
|
|
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