aesa/src/Corner_Turn_OL.c

   1 #include "Corner_Turn_OL.h"
   2
   3 /************************************************************************************/
   4
   5 void Corner_Turn_OL_init(DOLProcess * p)
   6 {
   7         int i,j;
   8
   9         p->local->excount = 0;
  10
  11
  12         for (i=0; i<NUMBER_OF_RANGE_BINS; i=i+1)
  13         {
  14                 for (j=0; j<NFFT; j=j+1)
  15                 {
  16                         p->local->Main_A[i][j].real = 0.0;      // Buffer for N_Range_Bins * NFFT complex samples
  17                         p->local->Main_A[i][j].imag = 0.0;
  18                         p->local->Main_B[i][j].real = 0.0;
  19                         p->local->Main_B[i][j].imag = 0.0;
  20                         p->local->Delayed_C[i][j].real = 0.0;   // Buffer for N_Range_Bins * NFFT complex samples
  21                         p->local->Delayed_C[i][j].imag = 0.0;
  22                         p->local->Delayed_D[i][j].real = 0.0;
  23                         p->local->Delayed_D[i][j].imag = 0.0;
  24                 }
  25
  26           // for (j=0; j<(NFFT/2); j=j+1)
  27           // {
  28                  //  p->local->Delayed_Output[i][j].real = 0.0;  // Buffer to create out delay of NFFT/2
  29           //    p->local->Delayed_Output[i][j].imag = 0.0;
  30           // }
  31         }
  32
  33         p->local->Zero.real = 0.0;
  34     p->local->Zero.imag = 0.0;
  35
  36         // p->local->buffer_mode = 0;
  37         p->local->state = 0;
  38         p->local->input_pointer = 0;
  39         p->local->output_pointer = 0;
  40         p->local->hold_input=0;
  41         p->local->hold_output=0;
  42
  43         p->local->pulse_counter_in = 0;
  44         p->local->pulse_counter_out = 0;
  45         p->local->bin_counter_in = 0;
  46         p->local->bin_counter_out = 0;
  47         // p->local->output_index = 0;
  48     p->local->n_batches = 0;
  49         p->local->n_iterations = 0;
  50
  51
  52 }
  53
  54 /************************************************************************************/
  55
  56 int Corner_Turn_OL_fire(DOLProcess * p)
  57 {
  58         ComplexNumber samples_in[NUMBER_OF_RANGE_BINS];
  59         p->local->excount++;
  60
  61         // This block will input in RANGE dimension and output in NFFT dimension.
  62         if(!p->local->hold_input){
  63         DOL_read((void*)PORT_DATA_IN, &samples_in, NUMBER_OF_RANGE_BINS*sizeof(ComplexNumber), p);  // Read a vector of input samples.
  64         }
  65         // if (p->local->buffer_mode == 0) // if buffer_mode = 0: input buffer is A, output buffer is B
  66         // {
  67         //      p->local->Beams_A[p->local->bin_counter_in][p->local->pulse_counter_in] = next_sample;
  68         //      next_sample = p->local->Beams_B[p->local->bin_counter_out][p->local->pulse_counter_out];
  69         //      DOL_write((void*)PORT_DATA_OUT, &next_sample, sizeof(ComplexNumber), p);
  70         //      DOL_write((void*)PORT_DATA_OUT_OL, &(p->local->Delayed_Output[p->local->bin_counter_out][p->local->output_index]), sizeof(ComplexNumber), p);
  71  //        p->local->Delayed_Output[p->local->bin_counter_out][p->local->output_index] = next_sample;     // Fill delay buffer with input
  72         // }
  73         // else  // if buffer_mode = 1: input buffer is B, output buffer is A
  74         // {
  75         //      p->local->Beams_B[p->local->bin_counter_in][p->local->pulse_counter_in] = next_sample;
  76         //      next_sample = p->local->Beams_A[p->local->bin_counter_out][p->local->pulse_counter_out];
  77         //      DOL_write((void*)PORT_DATA_OUT, &next_sample, sizeof(ComplexNumber), p);
  78         //      DOL_write((void*)PORT_DATA_OUT_OL, &(p->local->Delayed_Output[p->local->bin_counter_out][p->local->output_index]), sizeof(ComplexNumber), p);
  79  //        p->local->Delayed_Output[p->local->bin_counter_out][p->local->output_index] = next_sample;     // Fill delay buffer with input
  80  //    }
  81         int i;
  82         switch (p->local->state)
  83         {
  84
  85                 case 0:
  86                         // put the input vector in buffers (check documentation for details)
  87                         if(!p->local->hold_input){
  88                                 for (i=0; i<NUMBER_OF_RANGE_BINS; i++){
  89                                 p->local->Main_B[i][p->local->input_pointer]=samples_in[i];                                     //input B1
  90                                 p->local->Delayed_C[i][p->local->input_pointer + (NFFT/2)]=samples_in[i];       //input C2
  91                                 }
  92                     }
  93
  94                     if(!p->local->hold_output){
  95                     DOL_write((void*)PORT_DATA_OUT, &(p->local->Main_A[p->local->output_pointer][0]),NFFT*sizeof(ComplexNumber), p);                    //output A
  96                     DOL_write((void*)PORT_DATA_OUT_OL, &(p->local->Delayed_D[p->local->output_pointer][0]), NFFT*sizeof(ComplexNumber), p);     //output D
  97                         }
  98                 break;
  99
 100
 101                 case 1:
 102                         // put the input vector in buffers (check documentation for details)
 103                         if(!p->local->hold_input){
 104                                 for (i=0; i<NUMBER_OF_RANGE_BINS; i++){
 105                                 p->local->Main_B[i][p->local->input_pointer + (NFFT/2)]=samples_in[i];          //input B2
 106                                 p->local->Delayed_D[i][p->local->input_pointer ]=samples_in[i];                         //input D1
 107                             }
 108                     }
 109                     if(!p->local->hold_output){
 110                     DOL_write((void*)PORT_DATA_OUT, &(p->local->Main_A[p->local->output_pointer][0]),NFFT*sizeof(ComplexNumber), p);                    //output A
 111                     DOL_write((void*)PORT_DATA_OUT_OL, &(p->local->Delayed_C[p->local->output_pointer][0]), NFFT*sizeof(ComplexNumber), p);     //output D
 112                         }
 113                 break;
 114
 115
 116                 case 2:
 117                         // put the input vector in buffers (check documentation for details)
 118                         if(!p->local->hold_input){
 119                                 for (i=0; i<NUMBER_OF_RANGE_BINS; i++){
 120                                 p->local->Main_A[i][p->local->input_pointer]=samples_in[i];                                     //input A1
 121                                 p->local->Delayed_D[i][p->local->input_pointer + (NFFT/2)]=samples_in[i];       //input D2
 122                             }
 123                         }
 124                     if(!p->local->hold_output){
 125                     DOL_write((void*)PORT_DATA_OUT, &(p->local->Main_B[p->local->output_pointer][0]),NFFT*sizeof(ComplexNumber), p);                    //output A
 126                     DOL_write((void*)PORT_DATA_OUT_OL, &(p->local->Delayed_C[p->local->output_pointer][0]), NFFT*sizeof(ComplexNumber), p);     //output D
 127                         }
 128                 break;
 129
 130
 131                 case 3:
 132                         // put the input vector in buffers (check documentation for details)
 133                         if(!p->local->hold_input){
 134                                 for (i=0; i<NUMBER_OF_RANGE_BINS; i++){
 135                                 p->local->Main_A[i][p->local->input_pointer + (NFFT/2)]=samples_in[i];          //input A2
 136                                 p->local->Delayed_C[i][p->local->input_pointer ]=samples_in[i];                         //input C1
 137                             }
 138                         }
 139                     if(!p->local->hold_output){
 140                     DOL_write((void*)PORT_DATA_OUT, &(p->local->Main_B[p->local->output_pointer][0]),NFFT*sizeof(ComplexNumber), p);                    //output A
 141                     DOL_write((void*)PORT_DATA_OUT_OL, &(p->local->Delayed_D[p->local->output_pointer][0]), NFFT*sizeof(ComplexNumber), p);     //output D
 142                         }
 143                 break;
 144         }
 145
 146
 147         // state switching every NFFT/2
 148
 149         // !!!!!!!!!!!!!1111
 150         //something is wrong with the logic! proceed to debug for now!
 151         #if NUMBER_OF_RANGE_BINS > NFFT // This case, hold input till all output is sent (applies to all state switches)
 152
 153                 if (!p->local->hold_input)
 154                 {
 155                 p->local->input_pointer = p->local->input_pointer + 1;
 156                 }
 157
 158                 p->local->output_pointer = p->local->output_pointer + 1;
 159
 160                 if (p->local->input_pointer == NFFT/2 - 1)
 161                 {
 162                         if(p->local->output_pointer < NUMBER_OF_RANGE_BINS)
 163                         {
 164                                 p->local->hold_input = 1;
 165                         }
 166                         else  // output_pointer == NUMBER OF RANGE BINS
 167                         {
 168                                 p->local->input_pointer = 0;
 169                                 p->local->output_pointer = 0;
 170                                 p->local->hold_input = 0;
 171                                 p->local->n_batches = p->local->n_batches + 1;
 172                                 p->local->state = p->local->state + 1;
 173                                 if (p->local->state > 3)
 174                                 {
 175                                         p->local->state = 1;
 176                                 }
 177                         }
 178                 }
 179
 180
 181         #elif NUMBER_OF_RANGE_BINS < NFFT //This is the case that we have to hold the output until we receive
 182
 183                 p->local->input_pointer = p->local->input_pointer + 1;
 184
 185                 if(!p->local->hold_output)
 186                 {
 187                 p->local->output_pointer = p->local->output_pointer + 1;
 188                 }
 189
 190                 if (p->local->output_pointer >= NUMBER_OF_RANGE_BINS)
 191                 {
 192                         if   (p->local->input_pointer < (NFFT/2 ) )   // ???  -1   ??
 193                         {
 194                         p->local->hold_output = 1 ;
 195                         }
 196                         else
 197                         {
 198                                 p->local->input_pointer = 0;
 199                                 p->local->output_pointer = 0;
 200                                 p->local->hold_output = 0;
 201
 202                                 p->local->state = p->local->state + 1;
 203                                 p->local->n_batches = p->local->n_batches + 1;
 204                                 if (p->local->state > 3)
 205                                 {
 206                                         p->local->state = 1;
 207                                 }
 208                         }
 209                 }
 210
 211
 212
 213         #else // This is the case that we have equal number of input and output iterations
 214                 p->local->input_pointer = p->local->input_pointer + 1;
 215                 p->local->output_pointer = p->local->output_pointer + 1;
 216
 217                 if (p->local->input_pointer == NFFT/2 - 1)
 218                 {
 219                         p->local->input_pointer = 0;
 220                         p->local->n_batches = p->local->n_batches + 1;
 221                         p->local->state = p->local->state + 1;
 222                         if (p->local->state > 3)
 223                         {
 224                                 p->local->state = 1;
 225                         }
 226                 }
 227
 228                 if (p->local->output_pointer == NUMBER_OF_RANGE_BINS)
 229                 {
 230                         p->local->output_pointer = 0;
 231                 }
 232
 233
 234
 235         #endif
 236
 237
 238
 239            // !!!!!!!!!!!!!!!!1  check numbers! number of batches! I'm not sure!
 240     if (p->local->n_batches == 2 * (NUMBER_OF_PULSES/NFFT))          // Check if all batches completed
 241     {
 242       p->local->n_batches = 0;
 243           p->local->n_iterations = p->local->n_iterations + 1;
 244     }
 245
 246
 247
 248         if (p->local->n_iterations == NUMBER_OF_ITERATIONS)
 249         {
 250                 printf("\n\n:: Corner Turn with overlap process finished ::\n\n");
 251     // printf("\ttotal number of executions:  %d",p->local->excount);
 252
 253                 DOL_detach(p);
 254         }
 255
 256         return 0;
 257 }
 258
 259
 260
 261
 262
 263
 264
 265         /////
 266         // p->local->pulse_counter_in = p->local->pulse_counter_in + 1;
 267
 268
 269
 270         // if (p->local->pulse_counter_in == NFFT)
 271         // {
 272
 273
 274         //      p->local->pulse_counter_in = 0;
 275         //      p->local->bin_counter_in = p->local->bin_counter_in + 1;
 276
 277         //      if (p->local->bin_counter_in == NUMBER_OF_RANGE_BINS)
 278         //      {
 279         //              p->local->bin_counter_in = 0;  // One batch (N Range bins * NFFT pulses) ready
 280         //      }
 281         // }
 282
 283         // p->local->bin_counter_out = p->local->bin_counter_out + 1;
 284         // if (p->local->bin_counter_out == NUMBER_OF_RANGE_BINS)
 285         // {
 286         //      p->local->bin_counter_out = 0;
 287         //      p->local->pulse_counter_out = p->local->pulse_counter_out + 1;
 288         //      if (p->local->pulse_counter_out == NFFT)
 289         //      {
 290         //              p->local->pulse_counter_out = 0;
 291         //              p->local->buffer_mode = p->local->buffer_mode ^ 0x01;         // Switch buffer mode
 292
 293         //          p->local->n_batches = p->local->n_batches + 1;
 294         //          if (p->local->n_batches == (NUMBER_OF_PULSES/NFFT))          // Check if all batches completed
 295         //          {
 296         //            p->local->n_batches = 0;
 297         //                p->local->n_iterations = p->local->n_iterations + 1;
 298         //          }
 299         //      }
 300         // }
 301
 302         // p->local->output_index = p->local->output_index + 1;
 303         // if (p->local->output_index == NFFT/2)
 304         // {
 305         //      p->local->output_index = 0;
 306         // }
 307