adc_internal_calib.c

/*****************************************************************************
//
##    File:
##       adc_internal_calib.c
//
//       Copyright (c) MAX Technologies Inc. 1988-2019, All Rights Reserved.
//             CONFIDENTIAL AND PROPRIETARY INFORMATION WHICH IS THE 
//                         PROPERTY OF MAX TECHNOLOGIES INC. 
//
//      This example demonstrates how to calibrate one channel of IPM-ADC module by using
//       internal calibration.
//
//       Hardware requirements:
//          - MAXT 500 series carrier with IPM-ADC (jumpers must be set for +/- 10V operation).
//
*****************************************************************************/

#include "example.h"

#define MAX_REC 1000

int main(void)
{
uint32      rc;
HMXF_SERVER server;
HMXF_CHANNEL chn=0;
HMXF_MODULE module=0;
uint64 count=0;
MXF_ANALOG_DATAREC aRecANALOG[MAX_REC];
MXF_ANALOG_DATAREC* p;
HMXF_BUFFER rxBuffer=0;
int         iCalib;
uint64      calib[2]={VMXF_ANALOG_MODULE_ADC_CALIBRATION_MODE_0,VMXF_ANALOG_MODULE_ADC_CALIBRATION_MODE_4900000};
uint64      status=0, byteCount, iRec;
double      fValue[2];

   // Connect to services and initialize environment
   rc = mxfServerConnect("0.0.0.0", "", "", FALSE, &server);
   if (rc != MAXT_SUCCESS)
   {
      printf("Failed to connect; rc=0x%08x", rc);
      printf("\nPress a key to terminate\n");
      getchar();
      return 0;
   }

   // Initialize the server
   printf("\nStarting\n");

   rc = mxfSystemInit(server);

   // Get a handle to first Analog IPM-ADC channel
   if(!rc)
      rc = mxfChannelAllGet(server, MXF_CLASS_ANALOG, MXF_SCLASS_RX_CHANNEL, MXF_MODULE_ALL, 1, &count, &chn);
   
   // If channel not found, return an error
   if (!rc && !count)
      rc = MAXT_ERROR_NOT_FOUND;

   if(!rc)
      rc = mxfChannelInfoGet(chn, NULL, &module);
   
   // Set the channel selection to only first channel
   if(!rc)
      rc = mxfAttributeUint64Set(module, KMXF_ANALOG_MODULE_ADC_CHN_SELECTION, 0x00000001);

   // Set the first channel to single ended
   if(!rc)
      rc = mxfAttributeUint64Set(module, KMXF_ANALOG_MODULE_ADC_CHN_DIFF_SELECTION, 0xFFFE);
   
   // Set the scan mode to uniform continuous
   if(!rc)
      rc = mxfAttributeUint64Set(module, KMXF_ANALOG_MODULE_ADC_SCAN_MODE, VMXF_ANALOG_MODULE_ADC_SCAN_MODE_UNIFORM_CONTINUOUS);

   // Set the conversion rate to 1 millisecond
   if(!rc)
      rc = mxfAttributeUint64Set(module, KMXF_ANALOG_MODULE_ADC_CONVERSION_PERIOD, 1*1000*1000);

   // Set the input range to +/-10v
   if(!rc)
      rc = mxfAttributeUint64Set(module, KMXF_ANALOG_MODULE_ADC_INPUT_RANGE, VMXF_ANALOG_MODULE_ADC_INPUT_RANGE_10v);

   // Set the data format to float
   if (!rc)
      rc = mxfAttributeUint64Set(module, KMXF_ANALOG_MODULE_ADC_DATA_FORMAT, VMXF_ANALOG_MODULE_ADC_DATA_FORMAT_FLOAT);

   // Allocate RX acquisition buffer
   if (!rc)
      rc = mxfRxAcqBufferAlloc(chn, (uint64)sizeof(aRecANALOG), &rxBuffer, NULL);

   if(!rc)
      rc = mxfRxAcqModeSet(rxBuffer, MXF_RXACQ_MODE_LINEAR);

   for(iCalib=0;!rc && iCalib<2;iCalib++)
   {
      // Set calibration mode
      rc = mxfAttributeUint64Set(module, KMXF_ANALOG_MODULE_ADC_CALIBRATION_MODE, calib[iCalib]);

      //Start acquisition
      if(!rc)      
         rc = mxfRxAcqStart(rxBuffer, MXF_RXACQ_FLAG_DEFAULT, 0, 0);

      // Wait acquisition stopped
      if(!rc)
      {
         do
         {
            mxfSleep(100);
            rc = mxfRxAcqBufferStatusGet(rxBuffer, NULL, &count, NULL, NULL);
         }
         while(!rc && (count < MAX_REC));
      }

      if(!rc)
         rc = mxfRxAcqStop(rxBuffer);

      // Compute average value
      if(!rc)
      {
         fValue[iCalib] = 0.0;
         rc = mxfAnalogRxAcqRead(rxBuffer, 0, sizeof(aRecANALOG), &status, &count, &byteCount, aRecANALOG);
         p = aRecANALOG;
         for(iRec=0;!rc && iRec<count;iRec++)
         {
            fValue[iCalib] += p->data.value;
            mxfAnalogNextDataRecordPtrGet(p, &p);
         }
         fValue[iCalib] /= count;
      }
   }

   // Set calibration offset (b of y=mx+b)
   if(!rc)
      rc = mxfAttributeDoubleSet(chn, KMXF_ANALOG_CHN_ADC_CALIBRATION_OFFSET, fValue[0]*-1);
   
   // Set calibration slope (m of y=mx+b)
   if(!rc)
      rc = mxfAttributeDoubleSet(chn, KMXF_ANALOG_CHN_ADC_CALIBRATION_SLOPE, (fValue[1]-fValue[0])/4.9f);

   if(!rc)
   {
      rc = mxfAttributeDoubleGet(chn, KMXF_ANALOG_CHN_ADC_CALIBRATION_OFFSET, &fValue[0]);
      if(!rc)
         printf("Offset = %f\n\r", fValue[0]);
   }

   if(!rc)
   {
      rc = mxfAttributeDoubleGet(chn, KMXF_ANALOG_CHN_ADC_CALIBRATION_SLOPE, &fValue[1]);
      if(!rc)
         printf("Slope = %f\n\r", fValue[1]);
   }

   if (rc)
   {
   char buffer[256];

      if (mxfSystemErrorStringGet(server, rc, sizeof(buffer), buffer))
         sprintf(buffer, "ERROR # 0x%08X", rc);

      printf("%s\n\r", buffer);
   }

   //Frees all buffers
   if (rxBuffer)
      mxfRxAcqBufferFree(rxBuffer);

   // Terminate
   mxfSystemTerminate(server);
   mxfServerDisconnect(server);

   printf("\nPress enter to terminate\n");
   getchar();

return rc;
}