@@ -1,2 +1,2 | |||||
1 | a586fe639ac179e95bdc150ebdbab0312f31dc30 LFR_basic-parameters |
|
1 | a586fe639ac179e95bdc150ebdbab0312f31dc30 LFR_basic-parameters | |
2 | a806a190dcd72f71d336545073400d3cdaaa3119 header/lfr_common_headers |
|
2 | 72c4d5eb0bb95a1546beb2b22c8b88c31322ae31 header/lfr_common_headers |
@@ -2,7 +2,7 TEMPLATE = app | |||||
2 | # CONFIG += console v8 sim |
|
2 | # CONFIG += console v8 sim | |
3 | # CONFIG options = verbose *** boot_messages *** debug_messages *** cpu_usage_report *** stack_report *** vhdl_dev *** debug_tch |
|
3 | # CONFIG options = verbose *** boot_messages *** debug_messages *** cpu_usage_report *** stack_report *** vhdl_dev *** debug_tch | |
4 | # lpp_dpu_destid |
|
4 | # lpp_dpu_destid | |
5 | CONFIG += console verbose lpp_dpu_destid |
|
5 | CONFIG += console verbose lpp_dpu_destid cpu_usage_report | |
6 | CONFIG -= qt |
|
6 | CONFIG -= qt | |
7 |
|
7 | |||
8 | include(./sparc.pri) |
|
8 | include(./sparc.pri) |
@@ -30,6 +30,13 static inline void flushCache() { | |||||
30 | asm("flush"); |
|
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 | static void enableInstructionCache() { |
|
41 | static void enableInstructionCache() { | |
35 | #ifdef LEON3 |
|
42 | #ifdef LEON3 |
@@ -37,7 +37,9 void init_header_asm( Header_TM_LFR_SCIE | |||||
37 | int spw_send_waveform_CWF( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_CWF_t *header ); |
|
37 | int spw_send_waveform_CWF( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_CWF_t *header ); | |
38 | int spw_send_waveform_SWF( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_SWF_t *header ); |
|
38 | int spw_send_waveform_SWF( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_SWF_t *header ); | |
39 | int spw_send_waveform_CWF3_light( ring_node *ring_node_to_send, Header_TM_LFR_SCIENCE_CWF_t *header ); |
|
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 | void spw_send_k_dump( ring_node *ring_node_to_send ); |
|
43 | void spw_send_k_dump( ring_node *ring_node_to_send ); | |
42 |
|
44 | |||
43 | void timecode_irq_handler( void *pDev, void *regs, int minor, unsigned int tc ); |
|
45 | void timecode_irq_handler( void *pDev, void *regs, int minor, unsigned int tc ); |
@@ -1,5 +1,5 | |||||
1 | # LOAD FSW USING LINK 1 |
|
1 | # LOAD FSW USING LINK 1 | |
2 |
SpwPlugin0.StarDundeeSelectLinkNumber( |
|
2 | SpwPlugin0.StarDundeeSelectLinkNumber( 1 ) | |
3 |
|
3 | |||
4 | dsu3plugin0.openFile("/opt/DEV_PLE/FSW-qt/bin/fsw") |
|
4 | dsu3plugin0.openFile("/opt/DEV_PLE/FSW-qt/bin/fsw") | |
5 | #dsu3plugin0.openFile("/opt/LFR/LFR-FSW/2.0.2.3/fsw") |
|
5 | #dsu3plugin0.openFile("/opt/LFR/LFR-FSW/2.0.2.3/fsw") |
@@ -5,7 +5,7 struct drvmgr_key grlib_grspw_0n1_res[] | |||||
5 | {"txBdCnt", KEY_TYPE_INT, {(unsigned int)50}}, // 7 SWF_F0, 7 SWF_F1, 7 SWF_F2, 7 CWF_F3, 7 CWF_F1 ou 7 CWF_F2 |
|
5 | {"txBdCnt", KEY_TYPE_INT, {(unsigned int)50}}, // 7 SWF_F0, 7 SWF_F1, 7 SWF_F2, 7 CWF_F3, 7 CWF_F1 ou 7 CWF_F2 | |
6 | {"rxBdCnt", KEY_TYPE_INT, {(unsigned int)10}}, |
|
6 | {"rxBdCnt", KEY_TYPE_INT, {(unsigned int)10}}, | |
7 | {"txDataSize", KEY_TYPE_INT, {(unsigned int)4096}}, |
|
7 | {"txDataSize", KEY_TYPE_INT, {(unsigned int)4096}}, | |
8 |
|
|
8 | {"txHdrSize", KEY_TYPE_INT, {(unsigned int)34}}, | |
9 | {"rxPktSize", KEY_TYPE_INT, {(unsigned int)248+4}}, |
|
9 | {"rxPktSize", KEY_TYPE_INT, {(unsigned int)248+4}}, | |
10 | KEY_EMPTY |
|
10 | KEY_EMPTY | |
11 | }; |
|
11 | }; |
@@ -63,22 +63,24 | |||||
63 |
|
63 | |||
64 | void initCache() |
|
64 | void initCache() | |
65 | { |
|
65 | { | |
66 |
|
|
66 | unsigned int cacheControlRegister; | |
67 |
|
67 | |||
68 |
|
|
68 | cacheControlRegister = getCacheControlRegister(); | |
69 |
|
|
69 | printf("(0) cacheControlRegister = %x\n", cacheControlRegister); | |
|
70 | ||||
|
71 | resetCacheControlRegister(); | |||
70 |
|
72 | |||
71 | enableInstructionCache(); |
|
73 | enableInstructionCache(); | |
72 | enableDataCache(); |
|
74 | enableDataCache(); | |
73 | enableInstructionBurstFetch(); |
|
75 | enableInstructionBurstFetch(); | |
74 |
|
76 | |||
75 |
|
|
77 | cacheControlRegister = getCacheControlRegister(); | |
76 |
|
|
78 | printf("(1) cacheControlRegister = %x\n", cacheControlRegister); | |
77 | } |
|
79 | } | |
78 |
|
80 | |||
79 | rtems_task Init( rtems_task_argument ignored ) |
|
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 | * @param unused is the starting argument of the RTEMS task |
|
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 | spw_send_waveform_CWF3_light( incomingRingNodePtr, &headerCWF ); |
|
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 | else if ( sid==TM_CODE_K_DUMP ) |
|
285 | else if ( sid==TM_CODE_K_DUMP ) | |
278 | { |
|
286 | { | |
@@ -806,7 +814,7 int spw_send_waveform_CWF( ring_node *ri | |||||
806 | int *dataPtr; |
|
814 | int *dataPtr; | |
807 | unsigned char sid; |
|
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 | spw_ioctl_send_CWF.options = 0; |
|
818 | spw_ioctl_send_CWF.options = 0; | |
811 |
|
819 | |||
812 | ret = LFR_DEFAULT; |
|
820 | ret = LFR_DEFAULT; | |
@@ -891,7 +899,7 int spw_send_waveform_SWF( ring_node *ri | |||||
891 | int *dataPtr; |
|
899 | int *dataPtr; | |
892 | unsigned char sid; |
|
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 | spw_ioctl_send_SWF.options = 0; |
|
903 | spw_ioctl_send_SWF.options = 0; | |
896 |
|
904 | |||
897 | ret = LFR_DEFAULT; |
|
905 | ret = LFR_DEFAULT; | |
@@ -980,7 +988,7 int spw_send_waveform_CWF3_light( ring_n | |||||
980 | char *dataPtr; |
|
988 | char *dataPtr; | |
981 | unsigned char sid; |
|
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 | spw_ioctl_send_CWF.options = 0; |
|
992 | spw_ioctl_send_CWF.options = 0; | |
985 |
|
993 | |||
986 | ret = LFR_DEFAULT; |
|
994 | ret = LFR_DEFAULT; | |
@@ -1036,65 +1044,51 int spw_send_waveform_CWF3_light( ring_n | |||||
1036 | return ret; |
|
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 | Header_TM_LFR_SCIENCE_ASM_t *header ) |
|
1048 | Header_TM_LFR_SCIENCE_ASM_t *header ) | |
1041 | { |
|
1049 | { | |
1042 | unsigned int i; |
|
1050 | unsigned int i; | |
1043 | unsigned int length = 0; |
|
1051 | unsigned int length = 0; | |
1044 | rtems_status_code status; |
|
1052 | rtems_status_code status; | |
1045 | unsigned int sid; |
|
1053 | unsigned int sid; | |
1046 |
|
|
1054 | float *spectral_matrix; | |
1047 | int coarseTime; |
|
1055 | int coarseTime; | |
1048 | int fineTime; |
|
1056 | int fineTime; | |
1049 | spw_ioctl_pkt_send spw_ioctl_send_ASM; |
|
1057 | spw_ioctl_pkt_send spw_ioctl_send_ASM; | |
1050 |
|
1058 | |||
1051 | sid = ring_node_to_send->sid; |
|
1059 | sid = ring_node_to_send->sid; | |
1052 |
spectral_matrix = ( |
|
1060 | spectral_matrix = (float*) ring_node_to_send->buffer_address; | |
1053 | coarseTime = ring_node_to_send->coarseTime; |
|
1061 | coarseTime = ring_node_to_send->coarseTime; | |
1054 | fineTime = ring_node_to_send->fineTime; |
|
1062 | fineTime = ring_node_to_send->fineTime; | |
1055 |
|
1063 | |||
1056 | header->sy_lfr_common_parameters = parameter_dump_packet.sy_lfr_common_parameters; |
|
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 |
|
1068 | if ((i==0) || (i==1)) | |
1061 | switch(sid) |
|
|||
1062 | { |
|
1069 | { | |
1063 | case SID_NORM_ASM_F0: |
|
1070 | spw_ioctl_send_ASM.dlen = DLEN_ASM_F0_PKT_1; | |
1064 | spw_ioctl_send_ASM.dlen = TOTAL_SIZE_ASM_F0_IN_BYTES / 2; // 2 packets will be sent |
|
1071 | spw_ioctl_send_ASM.data = (char *) &spectral_matrix[ | |
1065 | spw_ioctl_send_ASM.data = &spectral_matrix[ |
|
1072 | ( (ASM_F0_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F0_1) ) * NB_VALUES_PER_SM ) | |
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 |
|
|||
1077 | ]; |
|
1073 | ]; | |
1078 | length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F1; |
|
1074 | length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F0_1; | |
1079 | header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE_6; |
|
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 |
|
1076 | header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F0_1) >> 8 ); // BLK_NR MSB | |
1081 | header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F1); // BLK_NR LSB |
|
1077 | header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F0_1); // BLK_NR LSB | |
1082 | break; |
|
1078 | } | |
1083 | case SID_NORM_ASM_F2: |
|
1079 | else | |
1084 | spw_ioctl_send_ASM.dlen = TOTAL_SIZE_ASM_F2_IN_BYTES / 2; // 2 packets will be sent |
|
1080 | { | |
1085 |
spw_ioctl_send_ASM.d |
|
1081 | spw_ioctl_send_ASM.dlen = DLEN_ASM_F0_PKT_2; | |
1086 | ( (ASM_F2_INDICE_START + (i*NB_BINS_PER_PKT_ASM_F2) ) * NB_VALUES_PER_SM ) * 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; |
|
1085 | length = PACKET_LENGTH_TM_LFR_SCIENCE_ASM_F0_2; | |
1089 |
header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE_ |
|
1086 | header->serviceSubType = TM_SUBTYPE_LFR_SCIENCE_6; | |
1090 | header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F2) >> 8 ); // BLK_NR MSB |
|
1087 | header->pa_lfr_asm_blk_nr[0] = (unsigned char) ( (NB_BINS_PER_PKT_ASM_F0_2) >> 8 ); // BLK_NR MSB | |
1091 | header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F2); // BLK_NR LSB |
|
1088 | header->pa_lfr_asm_blk_nr[1] = (unsigned char) (NB_BINS_PER_PKT_ASM_F0_2); // BLK_NR LSB | |
1092 | break; |
|
|||
1093 | default: |
|
|||
1094 | PRINTF1("ERR *** in spw_send_asm *** unexpected sid %d\n", sid) |
|
|||
1095 | break; |
|
|||
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 | spw_ioctl_send_ASM.hdr = (char *) header; |
|
1092 | spw_ioctl_send_ASM.hdr = (char *) header; | |
1099 | spw_ioctl_send_ASM.options = 0; |
|
1093 | spw_ioctl_send_ASM.options = 0; | |
1100 |
|
1094 | |||
@@ -1103,7 +1097,152 void spw_send_asm( ring_node *ring_node_ | |||||
1103 | header->packetLength[0] = (unsigned char) (length>>8); |
|
1097 | header->packetLength[0] = (unsigned char) (length>>8); | |
1104 | header->packetLength[1] = (unsigned char) (length); |
|
1098 | header->packetLength[1] = (unsigned char) (length); | |
1105 | header->sid = (unsigned char) sid; // SID |
|
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 | header->pa_lfr_pkt_nr_asm = (unsigned char) (i+1); |
|
1246 | header->pa_lfr_pkt_nr_asm = (unsigned char) (i+1); | |
1108 |
|
1247 | |||
1109 | // (3) SET PACKET TIME |
|
1248 | // (3) SET PACKET TIME |
@@ -341,10 +341,8 rtems_task prc0_task( rtems_task_argumen | |||||
341 | { |
|
341 | { | |
342 | // 1) reorganize the ASM and divide |
|
342 | // 1) reorganize the ASM and divide | |
343 | ASM_reorganize_and_divide( asm_f0_patched_norm, |
|
343 | ASM_reorganize_and_divide( asm_f0_patched_norm, | |
344 |
asm_f0 |
|
344 | (float*) current_ring_node_to_send_asm_f0->buffer_address, | |
345 | nb_sm_before_f0.norm_bp1 ); |
|
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 | current_ring_node_to_send_asm_f0->coarseTime = incomingMsg->coarseTimeNORM; |
|
346 | current_ring_node_to_send_asm_f0->coarseTime = incomingMsg->coarseTimeNORM; | |
349 | current_ring_node_to_send_asm_f0->fineTime = incomingMsg->fineTimeNORM; |
|
347 | current_ring_node_to_send_asm_f0->fineTime = incomingMsg->fineTimeNORM; | |
350 | current_ring_node_to_send_asm_f0->sid = SID_NORM_ASM_F0; |
|
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 | // 1) reorganize the ASM and divide |
|
337 | // 1) reorganize the ASM and divide | |
338 | ASM_reorganize_and_divide( asm_f1_patched_norm, |
|
338 | ASM_reorganize_and_divide( asm_f1_patched_norm, | |
339 |
asm_f1 |
|
339 | (float*) current_ring_node_to_send_asm_f1->buffer_address, | |
340 | nb_sm_before_f1.norm_bp1 ); |
|
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 | current_ring_node_to_send_asm_f1->coarseTime = incomingMsg->coarseTimeNORM; |
|
341 | current_ring_node_to_send_asm_f1->coarseTime = incomingMsg->coarseTimeNORM; | |
344 | current_ring_node_to_send_asm_f1->fineTime = incomingMsg->fineTimeNORM; |
|
342 | current_ring_node_to_send_asm_f1->fineTime = incomingMsg->fineTimeNORM; | |
345 | current_ring_node_to_send_asm_f1->sid = SID_NORM_ASM_F1; |
|
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 | // 1) reorganize the ASM and divide |
|
236 | // 1) reorganize the ASM and divide | |
237 | ASM_reorganize_and_divide( asm_f2_patched_norm, |
|
237 | ASM_reorganize_and_divide( asm_f2_patched_norm, | |
238 |
asm_f2 |
|
238 | (float*) current_ring_node_to_send_asm_f2->buffer_address, | |
239 | nb_sm_before_f2.norm_bp1 ); |
|
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 | current_ring_node_to_send_asm_f2->coarseTime = incomingMsg->coarseTimeNORM; |
|
240 | current_ring_node_to_send_asm_f2->coarseTime = incomingMsg->coarseTimeNORM; | |
243 | current_ring_node_to_send_asm_f2->fineTime = incomingMsg->fineTimeNORM; |
|
241 | current_ring_node_to_send_asm_f2->fineTime = incomingMsg->fineTimeNORM; | |
244 | current_ring_node_to_send_asm_f2->sid = SID_NORM_ASM_F2; |
|
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