HG_REPOSITORIES/LPP/INSTRUMENTATION/USERS/JEANDET/LFR_FSW Commit - r52:e2d761f8e287

waveform picker registers updated to be compliant with the new VHDL design

paul -

r52:e2d761f8e287 nov2013

parent child

Context file:

r52:e2d761f8e287

Collapse all files

FSW-qt/bin/fsw binary modified 0 0

NO CONTENT: modified file, binary diff hidden

header/wf_handler.h +2 -3

             extern volatile int wf_cont_f3[ ];
             extern volatile int wf_cont_f3_bis[ ];
             extern char wf_cont_f3_light[ ];
-            extern waveform_picker_regs_t *waveform_picker_regs;
+            extern new_waveform_picker_regs_t *new_waveform_picker_regs;
-            extern waveform_picker_regs_t_alt *waveform_picker_regs_alt;
             extern time_management_regs_t *time_management_regs;
             extern Packet_TM_LFR_HK_t housekeeping_packet;
             extern Packet_TM_LFR_PARAMETER_DUMP_t parameter_dump_packet;
             void set_wfp_burst_enable_register( unsigned char mode);
             void reset_wfp_burst_enable();
             void reset_wfp_status();
-            void reset_waveform_picker_regs();
+            void reset_new_waveform_picker_regs();
             //*****************
             // local parameters

src/fsw_globals.c +1 -2

             gptimer_regs_t         *gptimer_regs         = (gptimer_regs_t *)        REGS_ADDR_GPTIMER;
             #ifdef GSA
             #else
-                waveform_picker_regs_t *waveform_picker_regs = (waveform_picker_regs_t*) REGS_ADDR_WAVEFORM_PICKER;
+                new_waveform_picker_regs_t *new_waveform_picker_regs = (new_waveform_picker_regs_t*) REGS_ADDR_WAVEFORM_PICKER;
-                waveform_picker_regs_t_alt *waveform_picker_regs_alt = (waveform_picker_regs_t_alt*) REGS_ADDR_WAVEFORM_PICKER;
             #endif
             spectral_matrix_regs_t *spectral_matrix_regs = (spectral_matrix_regs_t*) REGS_ADDR_SPECTRAL_MATRIX;

src/wf_handler.c +72 -111

                 if ( (lfrCurrentMode == LFR_MODE_NORMAL)
                      || (lfrCurrentMode == LFR_MODE_SBM1) || (lfrCurrentMode == LFR_MODE_SBM2) )
                 { // in modes other than STANDBY and BURST, send the CWF_F3 data
-                    if ((waveform_picker_regs->status & 0x08) == 0x08){     // [1000] f3 is full
+                    if ((new_waveform_picker_regs->status & 0x08) == 0x08){     // [1000] f3 is full
                         // (1) change the receiving buffer for the waveform picker
-                        if (waveform_picker_regs->addr_data_f3 == (int) wf_cont_f3) {
+                        if (new_waveform_picker_regs->addr_data_f3 == (int) wf_cont_f3) {
-                            waveform_picker_regs->addr_data_f3 = (int) (wf_cont_f3_bis);
+                            new_waveform_picker_regs->addr_data_f3 = (int) (wf_cont_f3_bis);
                         }
                         else {
-                            waveform_picker_regs->addr_data_f3 = (int) (wf_cont_f3);
+                            new_waveform_picker_regs->addr_data_f3 = (int) (wf_cont_f3);
                         }
                         // (2) send an event for the waveforms transmission
                         if (rtems_event_send( Task_id[TASKID_CWF3], RTEMS_EVENT_0 ) != RTEMS_SUCCESSFUL) {
                             rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2 );
                         }
-                        waveform_picker_regs->status = waveform_picker_regs->status & 0xfffff777; // reset f3 bits to 0, [1111 0111 0111 0111]
+                        new_waveform_picker_regs->status = new_waveform_picker_regs->status & 0xfffff777; // reset f3 bits to 0, [1111 0111 0111 0111]
                     }
                 }
             #endif
             #ifdef GSA
                     PRINTF("in waveform_isr *** unexpected waveform picker interruption\n")
             #else
-                    if ( (waveform_picker_regs->burst_enable & 0x7) == 0x0 ){ // if no channel is enable
+                    if ( (new_waveform_picker_regs->run_burst_enable & 0x7) == 0x0 ){ // if no channel is enable
                         rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2 );
                     }
                     else {
-                        if ( (waveform_picker_regs->status & 0x7) == 0x7 ){ // f2 f1 and f0 are full
+                        if ( (new_waveform_picker_regs->status & 0x7) == 0x7 ){ // f2 f1 and f0 are full
-                            waveform_picker_regs->burst_enable = waveform_picker_regs->burst_enable & 0x08;
+                            new_waveform_picker_regs->run_burst_enable = new_waveform_picker_regs->run_burst_enable & 0x08;
                             if (rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_NORMAL ) != RTEMS_SUCCESSFUL) {
                                 rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2 );
                             }
-            //                waveform_picker_regs->status = waveform_picker_regs->status & 0x00;
+            //                new_waveform_picker_regs->status = new_waveform_picker_regs->status & 0x00;
-                            waveform_picker_regs->status = waveform_picker_regs->status & 0xfffff888;
+                            new_waveform_picker_regs->status = new_waveform_picker_regs->status & 0xfffff888;
-                            waveform_picker_regs->burst_enable = waveform_picker_regs->burst_enable | 0x07; // [0111] enable f2 f1 f0
+                            new_waveform_picker_regs->run_burst_enable = new_waveform_picker_regs->run_burst_enable | 0x07; // [0111] enable f2 f1 f0
                         }
                    }
             #endif
             #ifdef GSA
                     PRINTF("in waveform_isr *** unexpected waveform picker interruption\n")
             #else
-                    if ((waveform_picker_regs->status & 0x04) == 0x04){ // [0100] check the f2 full bit
+                    if ((new_waveform_picker_regs->status & 0x04) == 0x04){ // [0100] check the f2 full bit
                         // (1) change the receiving buffer for the waveform picker
-                        if (waveform_picker_regs->addr_data_f2 == (int) wf_snap_f2) {
+                        if (new_waveform_picker_regs->addr_data_f2 == (int) wf_snap_f2) {
-                            waveform_picker_regs->addr_data_f2 = (int) (wf_snap_f2_bis);
+                            new_waveform_picker_regs->addr_data_f2 = (int) (wf_snap_f2_bis);
                         }
                         else {
-                            waveform_picker_regs->addr_data_f2 = (int) (wf_snap_f2);
+                            new_waveform_picker_regs->addr_data_f2 = (int) (wf_snap_f2);
                         }
                         // (2) send an event for the waveforms transmission
                         if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_BURST ) != RTEMS_SUCCESSFUL) {
                             rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2 );
                         }
-                        waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffbbb; // [1111 1011 1011 1011] f2 bits = 0
+                        new_waveform_picker_regs->status = new_waveform_picker_regs->status & 0xfffffbbb; // [1111 1011 1011 1011] f2 bits = 0
                     }
             #endif
                     break;
             #ifdef GSA
                     PRINTF("in waveform_isr *** unexpected waveform picker interruption\n")
             #else
-                    if ((waveform_picker_regs->status & 0x02) == 0x02){ // [0010] check the f1 full bit
+                    if ((new_waveform_picker_regs->status & 0x02) == 0x02){ // [0010] check the f1 full bit
                         // (1) change the receiving buffer for the waveform picker
                         if ( param_local.local_sbm1_nb_cwf_sent == (param_local.local_sbm1_nb_cwf_max-1) )
                         {
-                            waveform_picker_regs->addr_data_f1 = (int) (wf_snap_f1_norm);
+                            new_waveform_picker_regs->addr_data_f1 = (int) (wf_snap_f1_norm);
                         }
-                        else if ( waveform_picker_regs->addr_data_f1 == (int) wf_snap_f1_norm )
+                        else if ( new_waveform_picker_regs->addr_data_f1 == (int) wf_snap_f1_norm )
                         {
                             doubleSendCWF1 = 1;
-                            waveform_picker_regs->addr_data_f1 = (int) (wf_snap_f1);
+                            new_waveform_picker_regs->addr_data_f1 = (int) (wf_snap_f1);
                         }
-                        else if ( waveform_picker_regs->addr_data_f1 == (int) wf_snap_f1 ) {
+                        else if ( new_waveform_picker_regs->addr_data_f1 == (int) wf_snap_f1 ) {
-                            waveform_picker_regs->addr_data_f1 = (int) (wf_snap_f1_bis);
+                            new_waveform_picker_regs->addr_data_f1 = (int) (wf_snap_f1_bis);
                         }
                         else {
-                            waveform_picker_regs->addr_data_f1 = (int) (wf_snap_f1);
+                            new_waveform_picker_regs->addr_data_f1 = (int) (wf_snap_f1);
                         }
                         // (2) send an event for the waveforms transmission
                         if (rtems_event_send( Task_id[TASKID_CWF1], RTEMS_EVENT_MODE_SBM1 ) != RTEMS_SUCCESSFUL) {
                             rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2 );
                         }
-                        waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffddd; // [1111 1101 1101 1101] f1 bit = 0
+                        new_waveform_picker_regs->status = new_waveform_picker_regs->status & 0xfffffddd; // [1111 1101 1101 1101] f1 bit = 0
                     }
-                    if ( ( (waveform_picker_regs->status & 0x05) == 0x05 ) ) { // [0101] check the f2 and f0 full bit
+                    if ( ( (new_waveform_picker_regs->status & 0x05) == 0x05 ) ) { // [0101] check the f2 and f0 full bit
                         if (rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_NORMAL ) != RTEMS_SUCCESSFUL) {
                             rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2 );
                         }
-                        waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffaaa; // [1111 1010 1010 1010] f2 and f0 bits = 0
+                        new_waveform_picker_regs->status = new_waveform_picker_regs->status & 0xfffffaaa; // [1111 1010 1010 1010] f2 and f0 bits = 0
                         reset_local_sbm1_nb_cwf_sent();
                     }
             #ifdef GSA
                     PRINTF("in waveform_isr *** unexpected waveform picker interruption\n")
             #else
-                    if ((waveform_picker_regs->status & 0x04) == 0x04){ // [0100] check the f2 full bit
+                    if ((new_waveform_picker_regs->status & 0x04) == 0x04){ // [0100] check the f2 full bit
                         // (1) change the receiving buffer for the waveform picker
                         if ( param_local.local_sbm2_nb_cwf_sent == (param_local.local_sbm2_nb_cwf_max-1) )
                         {
-                            waveform_picker_regs->addr_data_f2 = (int) (wf_snap_f2_norm);
+                            new_waveform_picker_regs->addr_data_f2 = (int) (wf_snap_f2_norm);
                         }
-                        else if ( waveform_picker_regs->addr_data_f2 == (int) wf_snap_f2_norm ) {
+                        else if ( new_waveform_picker_regs->addr_data_f2 == (int) wf_snap_f2_norm ) {
-                            waveform_picker_regs->addr_data_f2 = (int) (wf_snap_f2);
+                            new_waveform_picker_regs->addr_data_f2 = (int) (wf_snap_f2);
                             doubleSendCWF2 = 1;
                             if (rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM2_WFRM ) != RTEMS_SUCCESSFUL) {
                                 rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2 );
                             }
                             reset_local_sbm2_nb_cwf_sent();
                         }
-                        else if ( waveform_picker_regs->addr_data_f2 == (int) wf_snap_f2 ) {
+                        else if ( new_waveform_picker_regs->addr_data_f2 == (int) wf_snap_f2 ) {
-                            waveform_picker_regs->addr_data_f2 = (int) (wf_snap_f2_bis);
+                            new_waveform_picker_regs->addr_data_f2 = (int) (wf_snap_f2_bis);
                         }
                         else {
-                            waveform_picker_regs->addr_data_f2 = (int) (wf_snap_f2);
+                            new_waveform_picker_regs->addr_data_f2 = (int) (wf_snap_f2);
                         }
                         // (2) send an event for the waveforms transmission
                         if (rtems_event_send( Task_id[TASKID_CWF2], RTEMS_EVENT_MODE_SBM2 ) != RTEMS_SUCCESSFUL) {
                             rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2 );
                         }
-                        waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffbbb; // [1111 1011 1011 1011] f2 bit = 0
+                        new_waveform_picker_regs->status = new_waveform_picker_regs->status & 0xfffffbbb; // [1111 1011 1011 1011] f2 bit = 0
                     }
-                    if ( ( (waveform_picker_regs->status & 0x03) == 0x03 ) ) { // [0011] f3 f2 f1 f0, f1 and f0 are full
+                    if ( ( (new_waveform_picker_regs->status & 0x03) == 0x03 ) ) { // [0011] f3 f2 f1 f0, f1 and f0 are full
                         if (rtems_event_send( Task_id[TASKID_WFRM], RTEMS_EVENT_MODE_SBM2 ) != RTEMS_SUCCESSFUL) {
                             rtems_event_send( Task_id[TASKID_DUMB], RTEMS_EVENT_2 );
                         }
-                        waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffccc; // [1111 1100 1100 1100] f1, f0 bits = 0
+                        new_waveform_picker_regs->status = new_waveform_picker_regs->status & 0xfffffccc; // [1111 1100 1100 1100] f1, f0 bits = 0
                     }
             #endif
                     break;
                         send_waveform_SWF(wf_snap_f1, SID_NORM_SWF_F1, headerSWF_F1, queue_id);
                         send_waveform_SWF(wf_snap_f2, SID_NORM_SWF_F2, headerSWF_F2, queue_id);
             #ifdef GSA
-                        waveform_picker_regs->status = waveform_picker_regs->status & 0xf888; // [1111 1000 1000 1000] f2, f1, f0 bits =0
+                        new_waveform_picker_regs->status = new_waveform_picker_regs->status & 0xf888; // [1111 1000 1000 1000] f2, f1, f0 bits =0
             #endif
                     }
                     else if (event_out == RTEMS_EVENT_MODE_SBM1)
                         send_waveform_SWF(wf_snap_f1_norm, SID_NORM_SWF_F1, headerSWF_F1, queue_id);
                         send_waveform_SWF(wf_snap_f2, SID_NORM_SWF_F2, headerSWF_F2, queue_id);
             #ifdef GSA
-                        waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffaaa; // [1111 1010 1010 1010] f2, f0 bits = 0
+                        new_waveform_picker_regs->status = new_waveform_picker_regs->status & 0xfffffaaa; // [1111 1010 1010 1010] f2, f0 bits = 0
             #endif
                     }
                     else if (event_out == RTEMS_EVENT_MODE_SBM2)
                         send_waveform_SWF(wf_snap_f0, SID_NORM_SWF_F0, headerSWF_F0, queue_id);
                         send_waveform_SWF(wf_snap_f1, SID_NORM_SWF_F1, headerSWF_F1, queue_id);
             #ifdef GSA
-                        waveform_picker_regs->status = waveform_picker_regs->status & 0xfffffccc; // [1111 1100 1100 1100] f1, f0 bits = 0
+                        new_waveform_picker_regs->status = new_waveform_picker_regs->status & 0xfffffccc; // [1111 1100 1100 1100] f1, f0 bits = 0
             #endif
                     }
                     else if (event_out == RTEMS_EVENT_MODE_SBM2_WFRM)
                     PRINTF("send CWF F3 \n")
             #ifdef GSA
             #else
-                    if (waveform_picker_regs->addr_data_f3 == (int) wf_cont_f3) {
+                    if (new_waveform_picker_regs->addr_data_f3 == (int) wf_cont_f3) {
                         send_waveform_CWF3_light( wf_cont_f3_bis, headerCWF_F3_light, queue_id );
                     }
                     else {
                         // F2
             #ifdef GSA
             #else
-                        if (waveform_picker_regs->addr_data_f2 == (int) wf_snap_f2) {
+                        if (new_waveform_picker_regs->addr_data_f2 == (int) wf_snap_f2) {
                             send_waveform_CWF( wf_snap_f2_bis, SID_BURST_CWF_F2, headerCWF_F2_BURST, queue_id );
                         }
                         else {
                             doubleSendCWF2 = 0;
                             send_waveform_CWF( wf_snap_f2_norm, SID_SBM2_CWF_F2, headerCWF_F2_SBM2, queue_id );
                         }
-                        else if (waveform_picker_regs->addr_data_f2 == (int) wf_snap_f2) {
+                        else if (new_waveform_picker_regs->addr_data_f2 == (int) wf_snap_f2) {
                             send_waveform_CWF( wf_snap_f2_bis, SID_SBM2_CWF_F2, headerCWF_F2_SBM2, queue_id );
                         }
                         else {
                             doubleSendCWF1 = 0;
                             send_waveform_CWF( wf_snap_f1_norm, SID_SBM1_CWF_F1, headerCWF_F1, queue_id );
                         }
-                        else if (waveform_picker_regs->addr_data_f1 == (int) wf_snap_f1) {
+                        else if (new_waveform_picker_regs->addr_data_f1 == (int) wf_snap_f1) {
                            send_waveform_CWF( wf_snap_f1_bis, SID_SBM1_CWF_F1, headerCWF_F1, queue_id );
                         }
                         else {
             #ifdef GSA
             #else
-                waveform_picker_regs->data_shaping =
+                new_waveform_picker_regs->data_shaping =
                           ( (data_shaping & 0x10) >> 4 )     // BW
                         + ( (data_shaping & 0x08) >> 2 )     // SP0
                         + ( (data_shaping & 0x04)      )     // SP1
                     aux = delta_snapshot ;
                     ret = LFR_SUCCESSFUL;
                 }
-                waveform_picker_regs->delta_snapshot = aux - 1;             // max 2 bytes
+                new_waveform_picker_regs->delta_snapshot = aux - 1;             // max 2 bytes
             #endif
                 return ret;
                 // the burst bits shall be set first, before the enable bits
                 switch(mode) {
                 case(LFR_MODE_NORMAL):
-                    waveform_picker_regs->burst_enable = 0x00;  // [0000 0000] no burst enable
+                    new_waveform_picker_regs->run_burst_enable = 0x00;  // [0000 0000] no burst enable
-                    waveform_picker_regs->burst_enable = 0x0f; // [0000 1111] enable f3 f2 f1 f0
+                    new_waveform_picker_regs->run_burst_enable = 0x0f; // [0000 1111] enable f3 f2 f1 f0
                     break;
                 case(LFR_MODE_BURST):
-                    waveform_picker_regs->burst_enable = 0x40;  // [0100 0000] f2 burst enabled
+                    new_waveform_picker_regs->run_burst_enable = 0x40;  // [0100 0000] f2 burst enabled
-                    waveform_picker_regs->burst_enable =  waveform_picker_regs->burst_enable | 0x04; // [0100] enable f2
+                    new_waveform_picker_regs->run_burst_enable =  new_waveform_picker_regs->run_burst_enable | 0x04; // [0100] enable f2
                     break;
                 case(LFR_MODE_SBM1):
-                    waveform_picker_regs->burst_enable = 0x20;  // [0010 0000] f1 burst enabled
+                    new_waveform_picker_regs->run_burst_enable = 0x20;  // [0010 0000] f1 burst enabled
-                    waveform_picker_regs->burst_enable =  waveform_picker_regs->burst_enable | 0x0f; // [1111] enable f3 f2 f1 f0
+                    new_waveform_picker_regs->run_burst_enable =  new_waveform_picker_regs->run_burst_enable | 0x0f; // [1111] enable f3 f2 f1 f0
                     break;
                 case(LFR_MODE_SBM2):
-                    waveform_picker_regs->burst_enable = 0x40;  // [0100 0000] f2 burst enabled
+                    new_waveform_picker_regs->run_burst_enable = 0x40;  // [0100 0000] f2 burst enabled
-                    waveform_picker_regs->burst_enable =  waveform_picker_regs->burst_enable | 0x0f; // [1111] enable f3 f2 f1 f0
+                    new_waveform_picker_regs->run_burst_enable =  new_waveform_picker_regs->run_burst_enable | 0x0f; // [1111] enable f3 f2 f1 f0
                     break;
                 default:
-                    waveform_picker_regs->burst_enable = 0x00;  // [0000 0000] no burst enabled, no waveform enabled
+                    new_waveform_picker_regs->run_burst_enable = 0x00;  // [0000 0000] no burst enabled, no waveform enabled
                     break;
                 }
             #endif
             #ifdef GSA
             #else
-                waveform_picker_regs->burst_enable = 0x00;              // burst f2, f1, f0     enable f3, f2, f1, f0
+                new_waveform_picker_regs->run_burst_enable = 0x00;              // burst f2, f1, f0     enable f3, f2, f1, f0
             #endif
             }
             #ifdef GSA
             #else
-                waveform_picker_regs->status = 0x00;              // burst f2, f1, f0     enable f3, f2, f1, f0
+                new_waveform_picker_regs->status = 0x00;              // burst f2, f1, f0     enable f3, f2, f1, f0
             #endif
             }
-            void reset_waveform_picker_regs()
+            void reset_new_waveform_picker_regs()
             {
-                /** This function resets the waveform picker module registers.
+                new_waveform_picker_regs->data_shaping = 0x01;      // 0x00 00      *** R1 R0 SP1 SP0 BW
+                new_waveform_picker_regs->run_burst_enable = 0x00;  // 0x04 01      *** [run *** burst f2, f1, f0 *** enable f3, f2, f1, f0 ]
-                 * The registers affected by this function are located at the following offset addresses:
+                new_waveform_picker_regs->addr_data_f0 = (int) (wf_snap_f0);    // 0x08
-                 * - 0x00 data_shaping
+                new_waveform_picker_regs->addr_data_f1 = (int) (wf_snap_f1);    // 0x0c
-                 * - 0x04 burst_enable
+                new_waveform_picker_regs->addr_data_f2 = (int) (wf_snap_f2);    // 0x10
-                 * - 0x08 addr_data_f0
+                new_waveform_picker_regs->addr_data_f3 = (int) (wf_cont_f3);    // 0x14
-                 * - 0x0C addr_data_f1
+                new_waveform_picker_regs->status = 0x00;                        // 0x18
-                 * - 0x10 addr_data_f2
+                new_waveform_picker_regs->delta_snapshot = 0x12800;             // 0x1c
-                 * - 0x14 addr_data_f3
+                new_waveform_picker_regs->delta_f0 = 0x3f5;                     // 0x20 *** 1013
-                 * - 0x18 status
+                new_waveform_picker_regs->delta_f0_2 = 0x7;                     // 0x24 *** 7
-                 * - 0x1C delta_snapshot
+                new_waveform_picker_regs->delta_f1 = 0x3c0;                     // 0x28 *** 960
-                 * - 0x20 delta_f2_f1
+                new_waveform_picker_regs->delta_f2 = 0x12200;                   // 0x2c *** 74240
-                 * - 0x24 delta_f2_f0
+                new_waveform_picker_regs->nb_data_by_buffer = 0x1802;           // 0x30 *** 2048 * 3 + 2
-                 * - 0x28 nb_burst
+                new_waveform_picker_regs->snapshot_param = 0x7ff;               // 0x34 *** 2048 -1
-                 * - 0x2C nb_snapshot
+                new_waveform_picker_regs->start_date = 0x00;
-                 */
-            #ifdef GSA
-            #else
-                reset_wfp_burst_enable();
-                reset_wfp_status();
-                // set buffer addresses
-                waveform_picker_regs->addr_data_f0 = (int) (wf_snap_f0);    //
-                waveform_picker_regs->addr_data_f1 = (int) (wf_snap_f1);    //
-                waveform_picker_regs->addr_data_f2 = (int) (wf_snap_f2);    //
-                waveform_picker_regs->addr_data_f3 = (int) (wf_cont_f3);    //
-                // set other parameters
-                set_wfp_data_shaping();
-                set_wfp_delta_snapshot();                           // time in seconds between two snapshots
-                waveform_picker_regs->delta_f2_f1 = 0xffff;         // 0x16800 => 92160 (max 4 bytes)
-                waveform_picker_regs->delta_f2_f0 = 0x17c00;        // 97 280 (max 5 bytes)
-                waveform_picker_regs->nb_burst_available = 0x180;   // max 3 bytes, size of the buffer in burst (1 burst = 16 x 4 octets)
-                waveform_picker_regs->nb_snapshot_param = 0x7ff;    // max 3 octets, 2048 - 1
-            #endif
-            void reset_waveform_picker_regs_alt()
-                waveform_picker_regs_alt->data_shaping = 0x01;      // 0x00 00      *** R1 R0 SP1 SP0 BW
-                waveform_picker_regs_alt->run_burst_enable = 0x00;  // 0x04 01      *** [run *** burst f2, f1, f0 *** enable f3, f2, f1, f0 ]
-                waveform_picker_regs_alt->addr_data_f0 = (int) (wf_snap_f0);    // 0x08
-                waveform_picker_regs_alt->addr_data_f1 = (int) (wf_snap_f1);    // 0x0c
-                waveform_picker_regs_alt->addr_data_f2 = (int) (wf_snap_f2);    // 0x10
-                waveform_picker_regs_alt->addr_data_f3 = (int) (wf_cont_f3);    // 0x14
-                waveform_picker_regs_alt->status = 0x00;                        // 0x18
-                waveform_picker_regs_alt->delta_snapshot = 0x12800;             // 0x1c
-                waveform_picker_regs_alt->delta_f0 = 0x3f5;                     // 0x20 *** 1013
-                waveform_picker_regs_alt->delta_f0_2 = 0x7;                     // 0x24 *** 7
-                waveform_picker_regs_alt->delta_f1 = 0x3c0;                     // 0x28 *** 960
-                waveform_picker_regs_alt->delta_f2 = 0x12200;                   // 0x2c *** 74240
-                waveform_picker_regs_alt->nb_data_by_buffer = 0x1802;           // 0x30 *** 2048 * 3 + 2
-                waveform_picker_regs_alt->snapshot_param = 0x7ff;               // 0x34 *** 2048 -1
-                waveform_picker_regs_alt->start_date = 0x00;
             }
             //*****************

General Comments 0

Write
Preview

You need to be logged in to leave comments. Login now

No TODOs yet

	Site-wide shortcuts
/	Use quick search box
g h	Goto home page
g g	Goto my private gists page
g G	Goto my public gists page
g 0-9	Goto bookmarked items from 0-9
n r	New repository page
n g	New gist page

	Repositories
g s	Goto summary page
g c	Goto changelog page
g f	Goto files page
g F	Goto files page with file search activated
g p	Goto pull requests page
g o	Goto repository settings
g O	Goto repository access permissions settings
t s	Toggle sidebar on some pages