test.c

rt 7520采集卡 linux驱动源代码

   //
   // Clear High-Speed Digital Input FIFO
   //
   printf("    %-40s","Clear FIFO           [    0 sample ]");
   ClearDinFifo7520(board_idx);
   if ( check_din_fifo_empty(board_idx) )
   {
      cntError++;
      anykey();
   }
   

   // Convert 1 sample
   printf("    %-40s","Convert    1 sample  [    1 sample ]");
   StartHdin7520(board_idx);
   if ( check_din_fifo_not_empty(board_idx) )
   {
      cntError++;

      anykey();
   }

   // Convert fifohalf -1 (511) samples

   sprintf(buf, "Convert %4d samples [ %4d samples]",fifohalf-1,fifohalf);
   printf("    %-40s", buf);
   for (i=0;i<fifohalf-1;i++) {
      StartHdin7520(board_idx);
   }
   if ( check_din_fifo_not_empty(board_idx) )
   {
      cntError++;

      anykey();
   }

   // Convert 1 sample

   sprintf(buf,"Convert    1 sample  [ %4d samples]",fifohalf+1);
   printf("    %-40s", buf);
   
   StartHdin7520(board_idx);
   if ( check_din_fifo_half_full(board_idx) )
   {
      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++) {
      StartHdin7520(board_idx);
   }
   if ( check_din_fifo_half_full(board_idx) )
   {
      cntError++;

      anykey();
   }

   // Convert 1 sample

   sprintf(buf,"Convert    1 sample  [ %4d samples]",fifosize);
   printf("    %-40s",buf);
   
   StartHdin7520(board_idx);
   if ( check_din_fifo_full(board_idx) )
   {
      cntError++;

      anykey();
   }

   // Read 1 sample

   sprintf(buf,"Read       1 sample  [ %4d samples]",fifosize-1);
   printf("    %-40s", buf);
   

   ReadDinFifo7520(board_idx, &bData);
   if ( check_din_fifo_half_full(board_idx) )
   {
      cntError++;

      anykey();
   }

   // Read 510 samples

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

      anykey();
   }

   // Read 1 sample

   sprintf(buf, "Read    %4d sample  [ %4d samples]",1,fifohalf);
   printf("    %-40s", buf);
   
   ReadDinFifo7520(board_idx,&bData);
   if ( check_din_fifo_not_empty(board_idx) )
   {
      cntError++;

      anykey();
   }

   // Read 511 samples

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

      anykey();
   }

   // Read 1 sample
   sprintf(buf,"Read       1 sample  [    0 sample ]");
   printf("    %-40s", buf);
   ReadDinFifo7520(board_idx,&bData);
   if ( check_din_fifo_empty(board_idx) )
   {
      cntError++;

      anykey();
   }

   //
   // High Speed Digital Input Read Test
   //
   printf("  --------------------------------------------------------------------\n");
   printf("  High Speed Digital Read Test\n");
   printf("  --------------------------------------------------------------------\n");

   printf("    %-40s","Readback test");
   ClearAllIO7520(board_idx);

   //
   // Set up for Software controled High-Speed Digital Input
   //
   ClearDinFifo7520(board_idx);
   SetHdinStart7520(board_idx,HDIN_SOFTWARE);

   //
   // Program Port 0 for output
   //
   ClearDIO7520(board_idx);
   ClearDIO0IrqStatus7520(board_idx);
   SetupPort07520(board_idx,0xFF,0x00,0,0x00,0,FALSE);

   //
   // Write value to Port 0, take a HDIN sample:
   // they must be the same.
   //
   for ( i=0; i<=0xFF; i++ )
   {
      WriteDIO07520(board_idx,i);
      StartHdin7520(board_idx);
      ReadDinFifo7520(board_idx,&bData);
      if ( i != (uint8_t) bData )
      {
         cntError++;
         printf("***FAILED (write: %X, read: %X)\n",i,bData);
	 anykey();
         break;
      }
   } // for i
   if ( i > 0xFF )
   {
      printf("   Passed\n");
   }

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

   return cntError;
} // atest_hdin_fifo

/****************************************************************************
@func
 This function tests Digital Output.
@rdesc
 Returns number of failed tests.
****************************************************************************/
int atest_dout (int board_idx)
{
   unsigned char bData;
   int i;
   cg_entry_t cscRow;

   printf("  --------------------------------------------------------------------\n");
   printf("  Digital Table Test\n");
   printf("  --------------------------------------------------------------------\n");

   //
   // Fill Digitale Table but do not enable
   //
   printf("    %-40s","Table Disabled test");

   ClearAllIO7520(board_idx);

   ClearADFifo7520(board_idx);
   SetConversionSelect7520(board_idx,ADC_START_SOFTWARE);

   ClearCGT7520(board_idx);
   for ( i=0; i<=0xFF; i++ )
   {
      SetupCgtRow7520(&cscRow,0,GAIN1,AIN_BIP5,NRSE_AGND,_GND_SE,0,0,0,0);
      WriteCGTAnalog7520(board_idx,*(uint16_t *)&cscRow);
      WriteCGTDigital7520(board_idx,i);
   } // for i
   EnableCGT7520(board_idx,CSC_CGT);
   EnableCGTDigital7520(board_idx,0);

   ClearDIO7520(board_idx);
   ClearDIO0IrqStatus7520(board_idx);

   //
   // Write a pattern to Port1 ==> A/D conversions must not change it.
   //
   SetDIO1Direction7520(board_idx,1);
   WriteDIO17520(board_idx,0x55);
   //SetDIO1Direction7520(board_idx,0); // BUG: why does it set DO to 0xFF ?

   for ( i=0; i<=0xFF; i++ )
   {
      StartConversion7520(board_idx);
      ReadDIO17520(board_idx,&bData);
      if ( 0x55 != bData )
      {
         cntError++;
         printf("***FAILED (write: %X, read: %X)\n",i,bData);
		 anykey();
         break;
      }
   } // for i
   if ( i >= 0xFF )
   {
      printf("   Passed\n");
   }

   //
   // Fill Digitale Table and enable
   //
   printf("    %-40s","Table Enabled test");

   ClearAllIO7520(board_idx);

   ClearADFifo7520(board_idx);
   SetConversionSelect7520(board_idx,ADC_START_SOFTWARE);

   ClearCGT7520(board_idx);
   for ( i=0; i<=0xFF; i++ )
   {
      SetupCgtRow7520(&cscRow,0,GAIN1,AIN_BIP5,NRSE_AGND,_GND_SE,0,0,0,0);
      WriteCGTAnalog7520(board_idx,*(uint16_t *)&cscRow);
      WriteCGTDigital7520(board_idx,i);
   } // for i
   EnableCGT7520(board_idx,CSC_CGT);
   EnableCGTDigital7520(board_idx,1);

   ClearDIO7520(board_idx);
   ClearDIO0IrqStatus7520(board_idx);

   SetDIO1Direction7520(board_idx,1);
   WriteDIO17520(board_idx,0x00);


   for ( i=0; i<=0xFF; i++ )
   {
      StartConversion7520(board_idx);
      ReadDIO17520(board_idx,&bData);
      if ( (unsigned char)(i+1) != bData )
      {
         cntError++;
         printf("***FAILED (write: %X, read: %X)\n",i,bData);
		 anykey();
         break;
      }
   } // for i
   if ( i >= 0xFF )
   {
      printf("   Passed\n");
   }

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

   return cntError;
} // atest_dout



/****************************************************************************
@func
 This function tests if the Digital I/O Chip registers are accessible.
@rdesc
 Returns number of failed tests.
****************************************************************************/
int atest_dio (int board)
{
   printf("======================================================================\n");
   printf("Digital I/O Test\n");
   printf("======================================================================\n");

   atest_dio_registers(board); //
   atest_din(board);
   atest_hdin_fifo(board);
   atest_dout(board);

   return cntError;
} // atest_dio

//=========================================================================
//			DA
//------------------------------------------------------------------------


//----------------------------------------------------------------

/****************************************************************************
 Indexed Functions
****************************************************************************/
void r7520_update_dac(int dac)
     { ( 0 == dac ? UpdateDAC17520(board_idx)
                  : UpdateDAC27520(board_idx) ); }
void r7520_write_dac_fifo(int dac, uint16_t data)
     { ( 0 == dac ? WriteDac1Fifo7520(board_idx,data)
                  : WriteDac2Fifo7520(board_idx,data) ); }
void r7520_clear_dac_fifo(int dac)
     { ( 0 == dac ? ClearDAC1Fifo7520(board_idx)
                  : ClearDAC2Fifo7520(board_idx) ); }
int r7520_is_dac_fifo_empty(int dac) {
    uint8_t fifo_empty;

    if (dac == 0) 
	IsDAC1FifoEmpty7520(board_idx, &fifo_empty);
    else
	IsDAC2FifoEmpty7520(board_idx, &fifo_empty);

    return fifo_empty;
}
int r7520_is_dac_fifo_half_full(int dac) {
    uint8_t fifo_half_full;

    if (dac == 0)
	IsDAC1FifoHalfFull7520(board_idx, &fifo_half_full);
    else
	IsDAC2FifoHalfFull7520(board_idx, &fifo_half_full);

    return fifo_half_full;
}
int r7520_is_dac_fifo_full(int dac) {
    uint8_t fifo_full;

    if (dac == 0)
	IsDAC1FifoFull7520(board_idx, &fifo_full);
    else
	IsDAC2FifoFull7520(board_idx, &fifo_full);

    return fifo_full;
}
void r7520_set_dac_start(int dac,uint16_t src)
     { ( 0 == dac ? SetDAC1Start7520(board_idx,src)
                  : SetDAC2Start7520(board_idx,src) ); }

uint16_t ReadUcnt7520 ( int DeviceNumber, uint16_t ucnt )
{
   uint16_t	counter = 0;

   switch (ucnt) {
      case TC_DAC1_UCNT:
             GetUcnt1Count7520(DeviceNumber,&counter);
             break;
      case TC_DAC2_UCNT:
             GetUcnt2Count7520(DeviceNumber,&counter);
	     break;
      default:
             break;
     }
   return counter;
 }

void SetupUcnt7520 ( int DeviceNumber, uint16_t ucnt, uint16_t divisor )
{
   switch(ucnt)
     {
      case TC_DAC1_UCNT:        //Ucnt1
             LoadUcnt17520(DeviceNumber,divisor);
             break;
      case TC_DAC2_UCNT:        //Ucnt2
             LoadUcnt27520(DeviceNumber,divisor);
             break;
      default: break;
     }
}
/****************************************************************************
@func
 Check if a D/A FIFO is empty.
@rdesc
 Returns non-zero if FIFO is not empty, hal-full or full.
****************************************************************************/
int check_dac_fifo_empty ( int dac )
{
   if ( !r7520_is_dac_fifo_empty(dac) )
   {
      printf("***FAILED (FIFO not empty)\n");
      return 1;
   } else
   if ( r7520_is_dac_fifo_half_full(dac) )
   {
      printf("***FAILED (FIFO half full)\n");
      return 2;
   } else
   if ( r7520_is_dac_fifo_full(dac) )
   {
      printf("***FAILED (FIFO full)\n");
      return 3;
   } else {
      printf("   Passed\n");
   }
   return 0;
} // check_dac_fifo_empty

/****************************************************************************
@func
 Check if a D/A FIFO is not empty.
@rdesc
 Returns non-zero if FIFO is empty, half-full or full.
****************************************************************************/
int check_dac_fifo_not_empty ( int dac )
{
   if ( r7520_is_dac_fifo_empty(dac) )
   {
      printf("***FAILED (FIFO empty)\n");
      return 1;
   } else
   if ( r7520_is_dac_fifo_half_full(dac) )
   {
      printf("***FAILED (FIFO half full)\n");
      return 2;
   } else
   if ( r7520_is_dac_fifo_full(dac) )
   {
      printf("***FAILED (FIFO full)\n");
      return 3;
   } else {
      printf("   Passed\n");
   }
   return 0;
} // check_dac_fifo_not_empty

/****************************************************************************
@func
 Check if a D/A FIFO is half-full.
@rdesc
 Returns non-zero if FIFO is empty, not half-full or full.
****************************************************************************/
int check_dac_fifo_half_full ( int dac )
{
   if ( r7520_is_dac_fifo_empty(dac) )
   {
      printf("***FAILED (FIFO empty)\n");
      return 1;
   } else
   if ( !r7520_is_dac_fifo_half_full(dac) )
   {
      printf("***FAILED (FIFO not half full)\n");
      return 2;
   } else
   if ( r7520_is_dac_fifo_full(dac) )
   {
      printf("***FAILED (FIFO full)\n");
      return 3;
   } else {
      printf("   Passed\n");
   }
   return 0;
} // check_dac_fifo_half_full

/****************************************************************************
@func
 Check if a D/A FIFO is full.
@rdesc
 Returns non-zero if FIFO is empty, not half-full or not full.
****************************************************************************/
int check_dac_fifo_full ( int dac )
{
   if ( r7520_is_dac_fifo_empty(dac) )
   {
      printf("***FAILED (FIFO empty)\n");
      return 1;
   } else
   if ( !r7520_is_dac_fifo_half_full(dac) )
   {
      printf("***FAILED (FIFO not half full)\n");
      return 2;
   } else
   if ( !r7520_is_dac_fifo_full(dac) )
   {
      printf("***FAILED (FIFO not full)\n");
      return 3;
   } else {