test.c

rt 7520采集卡 linux驱动源代码

   SetupCgtRow7520(&cscRow,0,GAIN1,AIN_BIP5,NRSE_AGND,_GND_SE,0,1,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);
   SetupCgtRow7520(&cscRow,0,GAIN1,AIN_BIP5,NRSE_AGND,_GND_SE,0,1,1,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);
   }


   ReadSampleCounter7520(board_idx,TC_ADC_SCNT,&cnt1);

   cnt2 = ReadUcnt7520(board_idx,TC_DAC1_UCNT);

   cnt3 = ReadUcnt7520(board_idx,TC_DAC2_UCNT);

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

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

   return cntError;
} // atest_da_update_cgt_2

/****************************************************************************
@func
 This function tests D/A (D/A FIFOs and D/A Update sources).
@rdesc
 Returns number of failed tests.
****************************************************************************/
int atest_da ()
{
   printf("======================================================================\n");
   printf("D/A Test\n");
   printf("======================================================================\n");

   atest_da_fifo(0); // DAC1
   atest_da_fifo(1); // DAC2
   atest_da_update_software(0); // DAC1
   atest_da_update_software(1); // DAC2
   atest_da_update_cgt_1(0); // DAC1
   atest_da_update_cgt_1(1); // DAC2
   atest_da_update_cgt_2();  // DAC1 & DAC2

   return cntError;
} // atest_da

//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
//------------------------  A D ---------------------------------------------------------------
//
//---------------------------------------------------------------------------------------------

/****************************************************************************
@func
 Check if A/D FIFO is empty.
@rdesc
 Returns non-zero if FIFO is not-empty, half-full or full.
****************************************************************************/
int check_adc_fifo_empty (void)
{
   uint8_t	fifo_empty;
   uint8_t	fifo_half_full;
   uint8_t	fifo_full;

   IsADFifoEmpty7520(board_idx, &fifo_empty);
   IsADFifoHalfFull7520(board_idx, &fifo_half_full);
   IsADFifoFull7520(board_idx, &fifo_full);
   if ( !fifo_empty )
   {
      printf("***FAILED (FIFO not empty)\n");
      return 1;
   } else
   if ( fifo_half_full )
   {
      printf("***FAILED (FIFO half full)\n");
      return 2;
   } else
   if ( fifo_full )
   {
      printf("***FAILED (FIFO full)\n");
      return 3;
   } else {
      printf("   Passed\n");
   }
   return 0;
} // check_adc_fifo_empty

/****************************************************************************
@func
 Check if A/D FIFO is not empty.
@rdesc
 Returns non-zero if FIFO is empty, half-full or full.
****************************************************************************/
int check_adc_fifo_not_empty (void)
{
   uint8_t	fifo_empty;
   uint8_t	fifo_half_full;
   uint8_t	fifo_full;

   IsADFifoEmpty7520(board_idx, &fifo_empty);
   IsADFifoHalfFull7520(board_idx, &fifo_half_full);
   IsADFifoFull7520(board_idx, &fifo_full);
   if ( fifo_empty )
   {
      printf("***FAILED (FIFO empty)\n");
      return 1;
   } else
   if ( fifo_half_full )
   {
      printf("***FAILED (FIFO half full)\n");
      return 2;
   } else
   if ( fifo_full )
   {
      printf("***FAILED (FIFO full)\n");
      return 3;
   } else {
      printf("   Passed\n");
   }
   return 0;
} // check_adc_fifo_not_empty

/****************************************************************************
@func
 Check if A/D FIFO is half-full.
@rdesc
 Returns non-zero if FIFO is empty, not half-full or full.
****************************************************************************/
int check_adc_fifo_half_full (void)
{
   uint8_t	fifo_empty;
   uint8_t	fifo_half_full;
   uint8_t	fifo_full;

   IsADFifoEmpty7520(board_idx, &fifo_empty);
   IsADFifoHalfFull7520(board_idx, &fifo_half_full);
   IsADFifoFull7520(board_idx, &fifo_full);
   if ( fifo_empty )
   {
      printf("***FAILED (FIFO empty)\n");
      return 1;
   } else
   if ( !fifo_half_full )
   {
      printf("***FAILED (FIFO not half full)\n");
      return 2;
   } else
   if ( fifo_full )
   {
      printf("***FAILED (FIFO full)\n");
      return 3;
   } else {
      printf("   Passed\n");
   }
   return 0;
} // check_adc_fifo_half_full

/****************************************************************************
@func
 Check if A/D FIFO is full.
@rdesc
 Returns non-zero if FIFO is empty, not half-full or not full.
****************************************************************************/
int check_adc_fifo_full (void)
{
   uint8_t	fifo_empty;
   uint8_t	fifo_half_full;
   uint8_t	fifo_full;

   IsADFifoEmpty7520(board_idx, &fifo_empty);
   IsADFifoHalfFull7520(board_idx, &fifo_half_full);
   IsADFifoFull7520(board_idx, &fifo_full);
   if ( fifo_empty )
   {
      printf("***FAILED (FIFO empty)\n");
      return 1;
   } else
   if ( !fifo_half_full )
   {
      printf("***FAILED (FIFO not half full)\n");
      return 2;
   } else
   if ( !fifo_full )
   {
      printf("***FAILED (FIFO not full)\n");
      return 3;
   } else {
      printf("   Passed\n");
   }
   return 0;
} // check_adc_fifo_full

/****************************************************************************
@func
 This function tests A/D (A/D FIFO and A/D Conversion sources).
@rdesc
 Returns number of failed tests.
****************************************************************************/
int atest_ad_fifo (void)
{
   int i;
   cg_entry_t cscRow;

   uint16_t sts;
   uint16_t	timer_status;
   uint8_t	fifo_empty;
   int16_t	sample;
   uint16_t	fifo_status;
   uint16_t	counter;

   printf("  --------------------------------------------------------------------\n");
   printf("  ADC & FIFO Test\n");
   printf("  --------------------------------------------------------------------\n");

   GetTimerStatus7520(board_idx, &timer_status);
    printf("Pacer clock status register=%X\n", timer_status);

   //
   // A/D Converter Test
   //
   printf("    %-40s","A/D Converter");
   ClearAllIO7520(board_idx);
   ClearADFifo7520(board_idx);
   SetConversionSelect7520(board_idx,ADC_START_SOFTWARE);
   SetupCgtRow7520(&cscRow,0,GAIN1,AIN_BIP5,NRSE_AGND,_GND_SE,0,0,0,0);
   WriteCGTLatch7520(board_idx,*(uint16_t *)&cscRow);
   EnableCGT7520(board_idx,CSC_LATCH);

   StartConversion7520(board_idx);
   /*-*/usleep(1);
   IsADFifoEmpty7520(board_idx, &fifo_empty);
   if ( fifo_empty )
   {
      cntError++;
      printf("***FAILED (A/D conversion 1 msec timeout)\n");
	  anykey();
   } else {
      printf("   Passed\n");
   }

   //
   // A/D FIFO Test
   //
   printf("    %-40s\n","ADC FIFO (Latch, Software Convert)");
   ClearAllIO7520(board_idx);
   SetConversionSelect7520(board_idx,ADC_START_SOFTWARE);
   SetupCgtRow7520(&cscRow,0,GAIN1,AIN_BIP5,NRSE_AGND,_GND_SE,0,0,0,0);
   WriteCGTLatch7520(board_idx,*(uint16_t *)&cscRow);
   EnableCGT7520(board_idx,CSC_LATCH);

   printf("    %-40s","Clear FIFO             [    0 sample ]");
   ClearADFifo7520(board_idx);
   GetTimerStatus7520(board_idx,&sts);
   if ( sts & 0x10 )
   {
      cntError++;
      printf("***FAILED (Pacer Clock Run Flag=1)\n");
	  anykey();
   } else
   if ( check_adc_fifo_empty() )
   {
      cntError++;
      anykey();
   }

   // Convert 1 sample
   printf("    %-40s","Convert    1 sample    [    1 sample ]");
   StartConversion7520(board_idx);
   /*-*/usleep(1);
   if ( check_adc_fifo_not_empty() )
   {
      cntError++;
      anykey();
   }

   // Convert 511 samples

   sprintf(buf,"Convert %4d samples   [ %4d samples]",fifohalf-1,fifohalf);
   printf("    %-40s", buf);
   for (i=0;i<fifohalf-1;i++) {
      StartConversion7520(board_idx);
//      /*-*/usleep(1);
   }
   if ( check_adc_fifo_not_empty() )
   {
      cntError++;
      anykey();
   }

   // Convert 1 sample

   sprintf(buf,"Convert    1 sample    [ %4d samples]",fifohalf+1);
   printf("    %-40s", buf);
   StartConversion7520(board_idx);
   /*-*/usleep(1);
   if ( check_adc_fifo_half_full() )
   {
      cntError++;
      anykey();
   }

   // Convert 510 samples

   sprintf(buf,"Convert %4d samples   [ %4d samples]",fifohalf-2,fifosize-1);
   printf("    %-40s", buf);
   for (i=0;i<fifohalf-2;i++) {
      StartConversion7520(board_idx);
//      /*-*/usleep(1);
   }
   if ( check_adc_fifo_half_full() )
   {
      cntError++;
      anykey();
   }

   // Convert 1 sample

   sprintf(buf,"Convert    1 sample    [ %4d samples]",fifosize);
   printf("    %-40s", buf);
   StartConversion7520(board_idx);
   /*-*/usleep(1);
   if ( check_adc_fifo_full() )
   {
      cntError++;
      anykey();
   }

   // Read 1 sample

   sprintf(buf,"Read       1 sample    [ %4d samples]",fifosize-1);
   printf("    %-40s", buf);
   ReadADDataWithMarker7520(board_idx, &sample);
   if ( check_adc_fifo_half_full() )
   {
      cntError++;
      anykey();
   }

   // Read 510 samples

   sprintf(buf,"Read    %4d samples   [ %4d samples]",fifohalf-2,fifohalf+1);
   printf("    %-40s", buf);
   for (i=0;i<fifohalf-2;i++) ReadADDataWithMarker7520(board_idx, &sample);
   if ( check_adc_fifo_half_full() )
   {
      cntError++;
      anykey();
   }

   // Read 1 sample

   sprintf(buf,"Read       1 sample    [ %4d samples]",fifohalf);
   printf("    %-40s", buf);
   ReadADDataWithMarker7520(board_idx, &sample);
   if ( check_adc_fifo_not_empty() )
   {
      cntError++;
      anykey();
   }

   // Read 511 samples

   sprintf(buf,"Read    %4d samples   [    1 sample ]",fifohalf-1);
   printf("    %-40s", buf);
   for (i=0;i<fifohalf-1;i++) ReadADDataWithMarker7520(board_idx, &sample);
   if ( check_adc_fifo_not_empty() )
   {
      cntError++;
      anykey();
   }

   // Read 1 sample
   printf("    %-40s","Read       1 sample    [    0 sample ]");
   ReadADDataWithMarker7520(board_idx, &sample);
   if ( check_adc_fifo_empty() )
   {
      cntError++;
      anykey();
   }

   GetFifoStatus7520(board_idx, &fifo_status);
    printf("Fifo status=%X\n", fifo_status);   
    GetTimerStatus7520(board_idx, &timer_status);
    printf("Pacer clock status register=%X\n", timer_status);
    if(timer_status&0x20) {
	printf("A/D Halted because FIFO was full. Clearing\n");
	ClearADFifo7520(board_idx);
    }
   
   printf("    %-40s","AD CNT test [count=980]");
   
   
   SetAdcntSource7520(board_idx, ADC_SCNT_FIFO_WRITE);
   LoadAdcnt7520(board_idx, 1000);
   for (i=0;i<20;i++) {
      StartConversion7520(board_idx);
     /*-*/usleep(1000);
   } 
   
   if ( check_adc_fifo_not_empty() )
   {
      cntError++;
      anykey();
   }   
   
   GetAdcntCount7520(board_idx, &counter);
   if ( 980!=counter )
   {
      cntError++;
      printf("***FAILED = %d\n",i);
	  anykey();
   } else {
      printf("   Passed\n");
   }

   sprintf(buf,"Read    19 samples   [    1 sample ]");
   printf("    %-40s", buf);
   for (i=0;i<19;i++) ReadADDataWithMarker7520(board_idx, &sample);
   if ( check_adc_fifo_not_empty() )
   {
      cntError++;
      anykey();
   }

   // Read 1 sample
   printf("    %-40s","Read       1 sample    [    0 sample ]");
   ReadADDataWithMarker7520(board_idx, &sample);
   if ( check_adc_fifo_empty() )
   {
      cntError++;
      anykey();
   }
   
   //
   // Restore defaults
   //
   InitBoard7520(board_idx);

   return cntError;
} // atest_ad_fifo

/****************************************************************************
@func
 This function tests CGT (and A/D Sample Counter count modes).
@rdesc
 Returns number of failed tests.
****************************************************************************/
int atest_cgt (void)
{
   int i;
   cg_entry_t cscRow;
   uint16_t cnt;
   uint16_t scnt_samples;
   int pacerCounter;
//   int sample;
   uint16_t mask,pattern,r1,r2,cntsize;
   float actual;
   int fifocount;
   uint8_t	fifo_empty;
   int16_t	sample;

   printf("  --------------------------------------------------------------------\n");
   printf("  CGT Test\n");
   printf("  --------------------------------------------------------------------\n");

   //
   // CGT FIFO Test
   //
   printf("    %-40s","CGT operation");
   ClearAllIO7520(board_idx);
   ClearADFifo7520(board_idx);
   ClearCGT7520(board_idx);
   for (i=0;i<16;i++)
     {
      SetupCgtRow7520(&cscRow,i,GAIN1,AIN_BIP5,NRSE_AGND,_GND_SE,0,0,0,0);
      WriteCGTAnalog7520(board_idx,*(uint16_t *)&cscRow);
     }
   EnableCGT7520(board_idx,CSC_CGT);
   EnableCGTDigital7520(board_idx,0);
   SetConversionSelect7520(board