rake_supp.c

WCDMA的仿真程序,分别用C和MATLAB两种语言仿真

                            break;
                        } /* if */
                    } /* for j */
                } /* if fingers[i].status */
            } /* for i */

        } /* if stable_taps */

    } else {
        /*
         * First activation, no earlier finger allocation.
         * If channel response is shorter than amount of fingers
         * to use, allocate only 'channel_len' fingers.
         */
        if (channel_len < nFingers) nFingers = channel_len;
        for (i=0; i < nFingers; i++) {
            fingers[i].status = 0;
            fingers[i].delay = channel_delays[ candidates[i] ];
            fingers[i].amplitude = channel_amplitudes[ candidates[i] ];
            fingers[i].weight = 1.0;
            fingers[i].fill_index = 0;
            fingers[i].combine_index = 0;
            fingers[i].nOutputs = 0;
        } /* for i */
        init_flag = FALSE;
    }

    /*
     * Search minimum and maximum of tap delays.
     */
    misc_data->min_delay = MAX_MULTIPATH_DELAY;
    misc_data->max_delay = 0;
    for (i=0; i < nFingers; i++) {
        if (fingers[i].delay > misc_data->max_delay)
            misc_data->max_delay = fingers[i].delay;
        if (fingers[i].delay < misc_data->min_delay)
            misc_data->min_delay = fingers[i].delay;
    } /* for */

    return;
} /* wcdma_rake_finger_alloc */


/* -------------------------------------------------------------------- */
/*
 * Function:	wcdma_rake_symbol_direct
 * Desc.:	Despreads all direct input samples for one finger.
 *
 * Note:	
 *              All the available symbols are despreaded for a finger.
 *              Due to the previous sentence, there may be different
 *              amount of output symbols for combining.
 */
int wcdma_rake_symbol_direct(
	int finger_id,          /* IN: id number of current finger */
        double input[],         /* IN: input received samples */
        int in_len,             /* IN: length of input vector */
        int code[],             /* IN: spreading code */
        int code_len,           /* IN: length of spreading code */
        finger_type *finger,   /* IN/OUT: vector of finger data structures */
        mem_chips_t *prev_samples)  /* IN: old saved samples */
{
    int offset = finger->delay;
    /*
     * nSamples lasketaan vaarin. Jos delay on suurempi kuin symboli,
     * niin pitaa ottaa viive huomioon.
     */
    int nSamples = in_len - (in_len % code_len);
    int add_index = finger->fill_index;
    int nSymbols = nSamples / code_len;
    int bufLength = FINGER_OUT_BUFFER;

    wcdma_soft_despread(input, nSamples, code, code_len,
                        code_len, &(finger->output[0]),
                        add_index, bufLength);

    /*
     * Advance fill index and output count for finger output ring buffer.
     */
    add_index = (add_index + nSymbols) % bufLength;
    finger->fill_index = add_index;
    finger->nOutputs += nSymbols;

    return(0);
} /* wcdma_rake_symbol_direct */


/* -------------------------------------------------------------------- */
/*
 * Function:	wcdma_rake_symbol_delayed
 * Desc.:	Despreads old samples in memory for one finger.
 *
 * Note:	
 */
int wcdma_rake_symbol_delayed(
	int finger_id,          /* IN: id number of current finger */
        double input[],         /* IN: input received samples */
        int in_len,             /* IN: length of input vector */
        int code[],             /* IN: spreading code */
        int code_len,           /* IN: length of spreading code */
        finger_type *finger,   /* IN/OUT: vector of finger data structures */
        mem_chips_t *prev_samples)  /* IN: old saved samples */
{
    int nOldChips, nNewChips;
    double old_data_block[MAX_SPREADING_FACTOR];
    int add_index = finger->fill_index;
    int nSymbols = 1;
    int bufLength = FINGER_OUT_BUFFER;

    /*
     * Calculate amount of old and new chips to despread.
     * Sum of old and new chips is one symbol.
     * If there are no old chips (code aligns with input data),
     * don't do anything.
     */
    nOldChips = finger->old_chips;
    nNewChips = code_len - nOldChips;
    if (nOldChips == 0) return(0);
    memcpy(old_data_block, &(prev_samples->chips[(code_len - nOldChips)]),
           nOldChips * sizeof(double) );
    memcpy(old_data_block+nOldChips, input, 
           nNewChips * sizeof(double) );
    wcdma_soft_despread(old_data_block, code_len, code, code_len, code_len,
                         &(finger->output[0]), add_index, bufLength);
    
    /*
     * Advance fill index and output count for finger output ring buffer.
     */
    add_index = (add_index + nSymbols) % bufLength;
    finger->fill_index = add_index;
    finger->nOutputs += nSymbols;

    return(0);
} /* wcdma_rake_symbol_delayed */


/* -------------------------------------------------------------------- */
/*
 * Function:	wcdma_rake_finger_memory_save
 * Desc.:	Saves input samples for all fingers to one memory.
 *
 * Note:	
 *		The amount of samples to save is exactly one symbol
 *              (length of spreading code);
 */
int wcdma_rake_finger_memory_save(
	double input[],		/* IN: input received samples */
        int in_len,             /* IN: input length */
        int code_len,           /* IN: spreading code length */
        mem_chips_t *prev_samples)  /* IN/OUT: old saved samples */
{ 
    memcpy(prev_samples->chips, &(input[in_len-code_len]), 
           code_len * sizeof(double) );

    return(0);
} /* wcdma_rake_finger_memory_save */


/* -------------------------------------------------------------------- */
/*
 * Function:	wcdma_rake_fingers_combine
 * Desc.:	Saves input samples for all fingers to one memory.
 *
 * Note:	
 */
int wcdma_rake_fingers_combine(
        finger_type *fingers,   /* IN: vector of finger data */
        int nFingers,		/* IN: number of fingers to combine */
        double output[],	/* OUT: output symbols */
        int *nOutputs)          /* OUT: length of output vector */
{ 
    int i, minSymbols, j, k, buf_length;
    double r_tmp;

    /*
     * Search number of symbols ready in all fingers.
     */
    minSymbols = FINGER_OUT_BUFFER;
    for (i=0; i < nFingers; i++) {
         if (fingers[i].nOutputs < minSymbols) minSymbols = fingers[i].nOutputs;
    } /* for nFingers */

    /*
     * Combine symbols.
     * Combine results only from the fingers on which tap amplitude
     * is above FINGER_ALLOC_THRESHOLD level.
     */
    buf_length = FINGER_OUT_BUFFER;
    for (i=0; i < minSymbols; i++) {
        r_tmp = 0;
        for (j=0; j < nFingers; j++) {
            k = fingers[j].combine_index;
            if (fingers[j].amplitude > FINGER_ALLOC_THRESHOLD) {
                r_tmp += fingers[j].weight * 	/* optinal weight */
                         fingers[j].amplitude * /* relative amplitude (0-1) */
                         fingers[j].output[k];  /* despreaded finger output */
            }
            fingers[j].combine_index =
                (fingers[j].combine_index + 1) % buf_length;
        } /* for nFingers */
        output[i] = r_tmp;
    } /* for minSymbols */

    /*
     * Correct amount of finger outputs in fingers.
     */
    for (j=0; j < nFingers; j++) {
        fingers[j].nOutputs -= minSymbols;
    } /* for nFingers */

    *nOutputs = minSymbols;

    return(0);
} /* wcdma_rake_fingers_combine */



/* -------------------------------------------------------------------- */