test.c

rt 7520采集卡 linux驱动源代码

      printf("   Passed\n");
   }
   return 0;
} // check_dac_fifo_full

/****************************************************************************
@func
 This function tests a D/A FIFO.
@rdesc
 Returns number of failed tests.
****************************************************************************/
int atest_da_fifo ( int dac)
{
   int i;
   int channel = (0==dac)?DM7520_WRITE_DA1:DM7520_WRITE_DA2;

   printf("  --------------------------------------------------------------------\n");
   printf("  DAC%d FIFO Test\n",dac+1);
   printf("  --------------------------------------------------------------------\n");

   //
   // DAC FIFO Test
   //
   SetupDAC7520(board_idx,channel,AOUT_BIP5,DAC_CYCLE_SINGLE,DAC_START_SOFTWARE);

   printf("    %-40s","FIFO Clear");
   r7520_clear_dac_fifo(dac);
   if ( check_dac_fifo_empty(dac) )
   {
      cntError++;
      anykey();
   }

   printf("    %-40s","FIFO Write 1 sample");
   r7520_write_dac_fifo(dac,0);
   if ( check_dac_fifo_not_empty(dac) )
   {
      cntError++;
      anykey();
   }

   sprintf(buf,"FIFO Write %3d samples",fifohalf-1);
   printf("    %-40s", buf);
   for (i=0;i<fifohalf-1;i++) r7520_write_dac_fifo(dac,0);
   if ( check_dac_fifo_not_empty(dac) )
   {
      cntError++;
      anykey();
   }

   printf("    %-40s","FIFO Write 1 sample");
   r7520_write_dac_fifo(dac,0);
   if ( check_dac_fifo_half_full(dac) )
   {
      cntError++;
      anykey();
   }


   sprintf(buf,"FIFO Write %3d samples",fifohalf-2);
   printf("    %-40s",buf);
   for (i=0;i<fifohalf-2;i++) r7520_write_dac_fifo(dac,0);
   if ( check_dac_fifo_half_full(dac) )
   {
      cntError++;
      anykey();
   }

   printf("    %-40s","FIFO Write 1 sample");
   r7520_write_dac_fifo(dac,0);
   if ( check_dac_fifo_full(dac) )
   {
      cntError++;
      anykey();
   }

   printf("    %-40s","Update 1 time");
   r7520_update_dac(dac);
   if ( check_dac_fifo_half_full(dac) )
   {
      cntError++;
      anykey();
   }

   sprintf(buf,"Update %3d times",fifohalf-2);
   printf("    %-40s",buf);
   for (i=0;i<fifohalf-2;i++) r7520_update_dac(dac);
   if ( check_dac_fifo_half_full(dac) )
   {
      cntError++;
      anykey();
   }

   printf("    %-40s","Update 1 time");
   r7520_update_dac(dac);
   if ( check_dac_fifo_not_empty(dac) )
   {
      cntError++;
      anykey();
   }

   sprintf(buf,"Update %3d times",fifohalf-1);
   printf("    %-40s",buf);
   for (i=0;i<fifohalf-1;i++) r7520_update_dac(dac);
   if ( check_dac_fifo_not_empty(dac) )
   {
      cntError++;
      anykey();
   }

   printf("    %-40s","Update 1 time");
   r7520_update_dac(dac);
   if ( check_dac_fifo_empty(dac) )
   {
      cntError++;
      anykey();
   }

   //
   // Restore defaults
   //
   InitBoard7520(board_idx);

   return cntError;
} // atest_da_fifo

/****************************************************************************
@func
 This function tests a DAC with different update sources.
@rdesc
 Returns number of failed tests.
****************************************************************************/
int atest_da_update_software ( int dac )
{
   #define atest_SAMPLES 800
   #define ATEST_SCNT    8000
// #define atest_SAMPLES 80
// #define atest_SCNT    800
   unsigned int atest_SCNT;
//   int res;
   int i;
//   uint16_t sts;
   uint16_t cnt;
   uint16_t ucnt = ( 0 == dac ? TC_DAC1_UCNT : TC_DAC2_UCNT );
   uint16_t mask,pattern,r1,r2,cntsize;
   int channel = (0==dac)? DM7520_WRITE_DA1:DM7520_WRITE_DA2;

   printf("  --------------------------------------------------------------------\n");
   printf("  DAC%d Clock Update Test\n",dac+1);
   printf("  --------------------------------------------------------------------\n");


   //
   // DAC Clock Update Test
   //
   printf("    %-40s","Update by DAC Clock (no repeat)");
   ClearAllIO7520(board_idx);
   r7520_clear_dac_fifo(dac);
   SetupDAC7520(board_idx,channel,AOUT_BIP5,DAC_CYCLE_SINGLE,DAC_START_SOFTWARE);
   for (i=0;i<513;i++) r7520_write_dac_fifo(dac,0);
   SetDACRate7520(board_idx,8000);
   r7520_set_dac_start(dac,DAC_START_DAC_CLK);
   sleep(1);
   if ( check_dac_fifo_empty(dac) )
   {
      cntError++;
      anykey();
   }

   //
   // DAC Repeat Mode Test
   //
   printf("    %-40s","Update by DAC Clock (repeat)");
   SetupDAC7520(board_idx,channel,AOUT_BIP5,DAC_CYCLE_MULTI,DAC_START_SOFTWARE);
   r7520_clear_dac_fifo(dac);
   for (i=0;i<513;i++) r7520_write_dac_fifo(dac,0);
   r7520_set_dac_start(dac,DAC_START_DAC_CLK);
   SetDACDivisor7520(board_idx,8000);
   sleep(1);
   if ( check_dac_fifo_not_empty(dac) )
   {
      cntError++;
      anykey();
   }

   // write patterns into sample counter
   // mask contains the tested bit set to 1
   // pattern contains the tested bit set to 0, all others to 1
   // r1 must contain the tested bit in 0, r2 in 1. If not,
   // the tested bit is not writable
   cntsize=0;
   for (i=8;i<16;i++)
     {
      mask=1<<(i);
      pattern=0xffff^mask;
      SetupUcnt7520(board_idx,ucnt,pattern);
      r1 = ReadUcnt7520(board_idx,ucnt);
      SetupUcnt7520(board_idx,ucnt,mask);
      r2 = ReadUcnt7520(board_idx,ucnt);
      if ( (r1&mask)==0 && (r2&mask)!=0)
        {
         cntsize=i;
        }
     }

   sprintf(buf,"DAC%d Update counter writable bits   %4d", dac+1, cntsize+1);
   printf("    %-40s",buf);
   printf("\n");

   SetupDAC7520(board_idx,channel,AOUT_BIP5,DAC_CYCLE_SINGLE,DAC_START_SOFTWARE);
   r7520_clear_dac_fifo(dac);
   cntsize=0;
   for (i=8;i<16;i++)
     {
      mask=1<<(i);
      r7520_write_dac_fifo(dac,0);
      SetupUcnt7520(board_idx,ucnt,mask);
      r7520_update_dac(dac);

	  sleep(1);
      r2 = ReadUcnt7520(board_idx,ucnt);
      if (mask==(r2+1))
        cntsize=i;

     }

   sprintf(buf,"DAC%d Update counter meaningful bits: %4d", dac+1, cntsize+1);
   printf("    %-40s",buf);
   printf("\n");
   atest_SCNT=(1<<(cntsize+1))-1;



   //
   // DAC Update Counter Test (no repeat)
   //

   printf("    %-40s","Update Counter Test (no repeat) ");
   SetupDAC7520(board_idx,channel,AOUT_BIP5,DAC_CYCLE_SINGLE,DAC_START_SOFTWARE);
   r7520_clear_dac_fifo(dac);
   for (i=0;i<atest_SAMPLES;i++) r7520_write_dac_fifo(dac,0);

   SetupUcnt7520(board_idx,ucnt,atest_SCNT);

   // Timing precision makes this measurement unreliable
   // therefore we do software updates
   for (i=0;i<atest_SAMPLES;i++)
     {
      r7520_update_dac(dac);
//      /*-*/usleep(1);
     }

   cnt = ReadUcnt7520(board_idx,ucnt);
   if ( (atest_SCNT-cnt) != atest_SAMPLES )
   {
      cntError++;
      printf("***FAILED (%u)\n",atest_SCNT-cnt);
	  anykey();
   } else {
      printf("   Passed\n");
   }

   //
   // DAC Update Counter Test (repeat)
   //
   printf("    %-40s","Update Counter Test (repeat)");
   SetupDAC7520(board_idx,channel,AOUT_BIP5,DAC_CYCLE_MULTI,DAC_START_SOFTWARE);
   r7520_clear_dac_fifo(dac);
   for (i=0;i<atest_SAMPLES;i++) r7520_write_dac_fifo(dac,0);
   SetDACDivisor7520(board_idx,8000);
   SetupUcnt7520(board_idx,ucnt,atest_SCNT);

   // Timing precision makes this measurement unreliable
   // therefore we do software updates
   for (i=0;i<2*atest_SAMPLES;i++)
     {
      r7520_update_dac(dac);
     }

   cnt = ReadUcnt7520(board_idx,ucnt);

   if ( cnt!= ((atest_SCNT-(2*atest_SAMPLES))& atest_SCNT) )
   {
      cntError++;
      printf("***FAILED (%u)\n",cnt);
	  anykey();
   } else {
      printf("   Passed\n");
   }

   //
   // Restore defaults
   //
   InitBoard7520(board_idx);

   return cntError;
} // atest_da_update_software

/****************************************************************************
@func
 This function tests a CGT D/A Update bit.
@rdesc
 Returns number of failed tests.
****************************************************************************/
int atest_da_update_cgt_1 ( int dac )
{
   #define atest_SAMPLES 800
//   int res;
   int i;
//   uint16_t sts;
   uint16_t cnt1, cnt2;
   cg_entry_t cscRow;
   uint16_t ucnt = ( 0 == dac ? TC_DAC1_UCNT : TC_DAC2_UCNT );
   int channel = (0==dac)? DM7520_WRITE_DA1:DM7520_WRITE_DA2;
   

   printf("  --------------------------------------------------------------------\n");
   printf("  DAC%d CGT Update Test\n",dac+1);
   printf("  --------------------------------------------------------------------\n");

   //
   // DAC CGT Update Test (no update)
   //
   printf("    %-40s","Update bit = 0          [no updates]");
   ClearAllIO7520(board_idx);
   ClearADFifo7520(board_idx);
   r7520_clear_dac_fifo(dac);

   ClearCGT7520(board_idx);
   SetupCgtRow7520(&cscRow,0,GAIN1,AIN_BIP5,NRSE_AGND,_GND_SE,0,0,0,0);
   WriteCGTAnalog7520(board_idx,*(uint16_t *)&cscRow);
   SetupCgtRow7520(&cscRow,0,GAIN1,AIN_BIP5,NRSE_AGND,_GND_SE,0,0,0,0);
   WriteCGTAnalog7520(board_idx,*(uint16_t *)&cscRow);

   SetConversionSelect7520(board_idx,ADC_START_SOFTWARE);
   EnableCGT7520(board_idx,CSC_CGT);
   EnableCGTDigital7520(board_idx,0);

   SetupDAC7520(board_idx,channel,AOUT_BIP5,DAC_CYCLE_SINGLE,DAC_START_SOFTWARE);
   for (i=0;i<513;i++) r7520_write_dac_fifo(dac,0);
   r7520_set_dac_start(dac,DAC_START_CGT);

   SetupSampleCounter7520( board_idx,TC_ADC_SCNT,ADC_SCNT_FIFO_WRITE,
                             100);
   SetupSampleCounter7520( board_idx,ucnt,0,
                             100);

   // Do 20 A/D conversions (=> CGT executed 10 times)
   for (i=0;i<20;i++)
   {
       StartConversion7520(board_idx);
//       /*-*/usleep(2);
   }


   cnt2 = ReadUcnt7520(board_idx,ucnt);

   if ( 100 != cnt2 )
   {
      cntError++;
      printf("***FAILED (%u updates)\n",100-cnt2);
	  anykey();
   } else {
      printf("   Passed\n");
   }

   //
   // DAC CGT Update Test (update)
   //
   printf("    %-40s","Update bit = 1   [20/2 = 10 updates]");
   ClearAllIO7520(board_idx);
   ClearADFifo7520(board_idx);
   r7520_clear_dac_fifo(dac);

   ClearCGT7520(board_idx);
   SetupCgtRow7520(&cscRow,0,GAIN1,AIN_BIP5,NRSE_AGND,_GND_SE,0,0,0,0);
   WriteCGTAnalog7520(board_idx,*(uint16_t *)&cscRow);
   if ( dac )
      SetupCgtRow7520(&cscRow,0,GAIN1,AIN_BIP5,NRSE_AGND,_GND_SE,0,0,1,0);
   else
      SetupCgtRow7520(&cscRow,0,GAIN1,AIN_BIP5,NRSE_AGND,_GND_SE,0,1,0,0);
   WriteCGTAnalog7520(board_idx,*(uint16_t *)&cscRow);


   SetConversionSelect7520(board_idx,ADC_START_SOFTWARE);
   EnableCGT7520(board_idx,CSC_CGT);
   EnableCGTDigital7520(board_idx,0);

   SetupDAC7520(board_idx,channel,AOUT_BIP5,DAC_CYCLE_SINGLE,DAC_START_SOFTWARE);
   for (i=0;i<513;i++) r7520_write_dac_fifo(dac,0);
   r7520_set_dac_start(dac,DAC_START_CGT);

   SetupSampleCounter7520( board_idx,TC_ADC_SCNT,ADC_SCNT_FIFO_WRITE,
                             100);
   SetupSampleCounter7520( board_idx,ucnt,0,
                             100);

   ReadSampleCounter7520(board_idx,TC_ADC_SCNT,&cnt1);

   cnt2 = ReadUcnt7520(board_idx,ucnt);


   // Do 20 A/D conversions (=> CGT executed 10 times)
   for (i=0;i<20;i++)
   {
       StartConversion7520(board_idx);
//       /*-*/usleep(2);
   }


   ReadSampleCounter7520(board_idx,TC_ADC_SCNT,&cnt1);

   cnt2 = ReadUcnt7520(board_idx,ucnt);

   if ( (100-cnt2) != (100-cnt1)/2 )
   {
      cntError++;
      printf("***FAILED (%u updates)\n",(100-cnt2));
	  anykey();
   } else {
      printf("   Passed\n");
   }

   //
   // Restore defaults
   //
   InitBoard7520(board_idx);

   return cntError;
} // atest_da_update_cgt_1

/****************************************************************************
@func
 This function tests both CGT D/A Update bits simultaneously.
@rdesc
 Returns number of failed tests.
****************************************************************************/
int atest_da_update_cgt_2 (void)
{
   #define atest_SAMPLES 800
//   int res;
   int i;
//   uint16_t sts;
   uint16_t cnt1, cnt2, cnt3;
   cg_entry_t cscRow;

   printf("  --------------------------------------------------------------------\n");
   printf("  DAC1 & DAC2 CGT Update Test\n");
   printf("  --------------------------------------------------------------------\n");

   //
   // DAC1 & DAC2 CGT Update Test (no update)
   //
   printf("    %-40s","Update bit = 0          [no updates]");
   ClearAllIO7520(board_idx);
   ClearADFifo7520(board_idx);
   ClearDAC1Fifo7520(board_idx);
   ClearDAC2Fifo7520(board_idx);

   ClearCGT7520(board_idx);
   SetupCgtRow7520(&cscRow,0,GAIN1,AIN_BIP5,NRSE_AGND,_GND_SE,0,0,0,0);
   WriteCGTAnalog7520(board_idx,*(uint16_t *)&cscRow);
   SetupCgtRow7520(&cscRow,0,GAIN1,AIN_BIP5,NRSE_AGND,_GND_SE,0,0,0,0);
   WriteCGTAnalog7520(board_idx,*(uint16_t *)&cscRow);

   SetConversionSelect7520(board_idx,ADC_START_SOFTWARE);
   EnableCGT7520(board_idx,CSC_CGT);
   EnableCGTDigital7520(board_idx,0);

   SetupDAC7520(board_idx,DM7520_WRITE_DA1,AOUT_BIP5,DAC_CYCLE_SINGLE,DAC_START_SOFTWARE);
   for (i=0;i<513;i++) WriteDac1Fifo7520(board_idx,0);
   SetDAC1Start7520(board_idx,DAC_START_CGT);
   SetupDAC7520(board_idx,DM7520_WRITE_DA2,AOUT_BIP5,DAC_CYCLE_SINGLE,DAC_START_SOFTWARE);
   for (i=0;i<513;i++) WriteDac2Fifo7520(board_idx,0);
   SetDAC2Start7520(board_idx,DAC_START_CGT);

   SetupSampleCounter7520( board_idx,TC_ADC_SCNT,ADC_SCNT_FIFO_WRITE,
                             100);
   SetupSampleCounter7520( board_idx,TC_DAC1_UCNT,0,
                             100);
   SetupSampleCounter7520( board_idx,TC_DAC2_UCNT,0,
                             100);

   // Do 20 A/D conversions (=> CGT executed 10 times)
   for (i=0;i<20;i++)
   {
       StartConversion7520(board_idx);
//       /*-*/usleep(2);
   }


   cnt2 = ReadUcnt7520(board_idx,TC_DAC1_UCNT);

   cnt3 = ReadUcnt7520(board_idx,TC_DAC2_UCNT);

   if ( 100 != cnt2 )
   {
      cntError++;
      printf("***FAILED (DAC1: %u updates)\n",100-cnt2);
	  anykey();
   } else
   if ( 100 != cnt3 )
   {
      cntError++;
      printf("***FAILED (DAC2: %u updates)\n",100-cnt3);
	  anykey();
   } else {
      printf("   Passed\n");
   }

   //
   // DAC1 & DAC2 CGT Update Test (update)
   //
   printf("    %-40s","Update bit = 1    [10 and 5 updates]");
   ClearAllIO7520(board_idx);
   ClearADFifo7520(board_idx);
   ClearDAC1Fifo7520(board_idx);
   ClearDAC2Fifo7520(board_idx);

   ClearCGT7520(board_idx);
   SetupCgtRow7520(&cscRow,0,GAIN1,AIN_BIP5,NRSE_AGND,_GND_SE,0,0,0,0);
   WriteCGTAnalog7520(board_idx,*(uint16_t *)&cscRow);