test_qam_gen_packed.c

aduc845 N30部分 手册

/*******************************************************************************
Copyright(c) 2000 - 2002 Analog Devices. All Rights Reserved.
Developed by Joint Development Software Application Team, IPDC, Bangalore, India
for Blackfin DSPs  ( Micro Signal Architecture 1.0 specification).

By using this module you agree to the terms of the Analog Devices License
Agreement for DSP Software. 
********************************************************************************
File Name       : Test_qam_gen_packed.c
Description     : This function tests qam_gen_packed with 7 test cases and finds
                  cycle count for symbol size = 2,3,4,5,6,7 and 8 and number of 
                  symbols = 4,8,16,32,64,128 and 256 repectively.
                    1. Test1 - All combinations of QAM Size(Baud) = 2
                    2. Test2 - All combinations of QAM Size(Baud) = 3
                    3. Test3 - All combinations of QAM Size(Baud) = 4
                    4. Test4 - All combinations of QAM Size(Baud) = 5
                    5. Test5 - All combinations of QAM Size(Baud) = 6
                    6. Test6 - All combinations of QAM Size(Baud) = 7
                    7. Test7 - All combinations of QAM Size(Baud) = 8
*******************************************************************************/
#include "qamdata.h"

void qam_gen_packed (int *iptr, short *optr, int n, short k);

int error_flag = 0;
void (*f1)();
int cycle_count[10];

void main()
 {
    int n,i;
    short k;
    short optr[512];
 
    f1 = (void(*)()) qam_gen_packed;                            

// Test1 - Test all combinations of QAM Size(Baud) = 2
                            
    k = 2;
    n = 4;

    cycle_count[0] = Compute_Cycle_Count(&iptr2, optr, n, k);
                            //This function inturn calls qam_gen_packed()
    for(i=0; i<2*n; i+=2)
        if( (optr[i] != optr2[i]) || (optr[i+1] != optr2[i+1]) ) 
        {
            error_flag = error_flag | 1;
        }
                            
// Test2 - Test all combinations of QAM Size(Baud) = 3
                            
    k = 3;
    n = 8;

    cycle_count[1] = Compute_Cycle_Count(&iptr3, optr, n, k);

    for(i=0; i<2*n; i+=2)
        if( (optr[i] != optr3[i]) || (optr[i+1] != optr3[i+1]) ) 
        {
            error_flag = error_flag | 2;
        }

                            
// Test3 - Test all combinations of QAM Size(Baud) = 4
                            
    k = 4;
    n = 16;

    cycle_count[2] = Compute_Cycle_Count(iptr4, optr, n, k);
                            //This function inturn calls qam_gen_packed()
    for(i = 0; i<2*n; i+=2)
        if( (optr[i] != optr4[i]) || (optr[i+1] != optr4[i+1]) ) 
        {
            error_flag = error_flag | 4;
        }

                            
// Test4 - Test all combinations of QAM Size(Baud) = 5
                            
    k = 5;
    n = 32;

    cycle_count[3] = Compute_Cycle_Count(&iptr5, optr, n, k);
                            //This function inturn calls qam_gen_packed()
    for(i = 0; i<2*n; i+=2)
        if( (optr[i] != optr5[i]) || (optr[i+1] != optr5[i+1]) ) 
        {
            error_flag = error_flag | 8;
        }

                            
// Test5 - Test all combinations of QAM Size(Baud) = 6
                            
    k = 6;
    n = 64;

    cycle_count[4] = Compute_Cycle_Count(&iptr6, optr, n, k);
                            //This function inturn calls qam_gen_packed()
    for(i=0; i<2*n; i+=2)
        if( (optr[i] != optr6[i]) || (optr[i+1] != optr6[i+1]) ) 
        {
            error_flag = error_flag | 16;
        }

                            
// Test6 - Test all combinations of QAM Size(Baud) = 7
                            
    k = 7;
    n = 128;

    cycle_count[5] = Compute_Cycle_Count(&iptr7, optr, n, k);
                            //This function inturn calls qam_gen_packed()
    for(i = 0; i<2*n; i+=2)
    if( (optr[i] != optr7[i]) || (optr[i+1] != optr7[i+1]) ) 
        {
            error_flag = error_flag | 32;
        }

                            
// Test7 - Test all combinations of QAM Size(Baud) = 8
                            
    k = 8;
    n = 256;

    cycle_count[6] = Compute_Cycle_Count(&iptr8, optr, n, k);
                            //This function inturn calls qam_gen_packed()
    for(i = 0; i<2*n; i+=2)
        if( (optr[i] != optr8[i]) || (optr[i+1] != optr8[i+1]) ) 
        {
            error_flag = error_flag | 64;
        }

    #ifdef PRINTF_SUPPORT
        if(error_flag & 1)
            printf("Test Case 1 failed\n");
        else
            printf("Test Case 1 passed\n");
        if(error_flag & 2)
            printf("Test Case 2 failed\n");
        else
            printf("Test Case 2 passed\n");
        if(error_flag & 4)
            printf("Test Case 3 failed\n");
        else
            printf("Test Case 3 passed\n");
        if(error_flag & 8)
            printf("Test Case 4 failed\n");
        else
            printf("Test Case 4 passed\n");
        if(error_flag & 16)
            printf("Test Case 5 failed\n");
        else
            printf("Test Case 5 passed\n");
        if(error_flag & 32)
            printf("Test Case 6 failed\n");
        else
            printf("Test Case 6 passed\n");
        if(error_flag & 64)
            printf("Test Case 7 failed\n");
        else
            printf("Test Case 7 passed\n");
    #endif
    
    printf("cycle_count[0]=%d,cycle_count[1]=%d,cycle_count[2]=%dcycle_count[3]=%d,cycle_count[4]=%d,cycle_count[5]=%dcycle_count[6]=%d\n",cycle_count[0],cycle_count[1],cycle_count[2],cycle_count[3],cycle_count[4],cycle_count[5],cycle_count[6]);

}