rf_afc.~cpp

关于ＭＴＫ 的ＭＡＴＡ开发工具的ＲＦ源码

//#include "meta2.h"
#include <IniFiles.hpp>

#include "form_RFTool.h"
#include "rf_afc.h"
#include "man_timer.h"
#include "man_active.h"
#include "man_fdm.h"

//===========================================================================
extern TfrmRFTool *frmRFTool;
static CRFAFC*  rf_afc_ptr;

//===========================================================================

static void  REQ_SelectBand( void )
{  rf_afc_ptr->REQ_SelectBand( );
}

static void __stdcall CNF_SelectBand( const unsigned char cnf, const short token, void *usrData )
{
 rf_afc_ptr->CNF_SelectBand( cnf, token, usrData );
}
static void  REQ_MeasureAFC( void )
{  rf_afc_ptr->REQ_MeasureAFC( );
}

static void __stdcall CNF_MeasureAFC(const RfAfc_Cnf *cnf, const short token, void *usrData)
{
  rf_afc_ptr->CNF_MeasureAFC( cnf, token, usrData);
}

static  void  CNF_ReadFromNVRAM( void )
{
  rf_afc_ptr->CNF_ReadFromNVRAM();
}

static void  CNF_WriteToNVRAM( void )
{
  rf_afc_ptr->CNF_WriteToNVRAM( );
}
static void  REQ_TimeOut( void )
{  rf_afc_ptr->REQ_TimeOut();
}
static void  REQ_Finish( void )
{   rf_afc_ptr->REQ_Finish();
}

//===========================================================================

CRFAFC::CRFAFC( void )
{
   IsRunning = false;
   ConfirmCallback = 0;

   AfcBufSize = 0;
   AfcBuf = 0;

   EvalAfcDac[0]  = 4100;
   EvalAfcDac[1]  = 4100;
   EvalFreqErr[0] = 0;
   EvalFreqErr[1] = 0;
}
//---------------------------------------------------------------------------

CRFAFC::~CRFAFC( )
{
   IsRunning = false;
   ConfirmCallback = 0;
   if(RFReq_AFC)
   {
      delete RFReq_AFC;
      RFReq_AFC = NULL;
   }
   if(AfcBuf)
   {
      delete [] AfcBuf;
      AfcBuf = NULL;
   }
}
//---------------------------------------------------------------------------

void  CRFAFC::REQ_Finish( void )
{
   if(!IsRunning)  return;

   TimerMan->CounterStop();
   Confirm( STATE_AFC_OK );
   IsRunning = false;
}
//---------------------------------------------------------------------------

void  CRFAFC::REQ_Stop( void )
{
   if(!IsRunning)  return;

   TimerMan->CounterStop();
   META_Cancel( RFID_AFC );
   Confirm( STATE_AFC_STOP );
   IsRunning = false;
}
//---------------------------------------------------------------------------

void  CRFAFC::REQ_TimeOut( void )
{
   if(!IsRunning)  return;

   TimerMan->CounterStop();
   META_Cancel( RFID_AFC );
   Confirm( STATE_AFC_TIMEOUT );
   IsRunning = false;
}
//---------------------------------------------------------------------------

void  CRFAFC::Confirm( int confirm_state )
{
   if(!IsRunning)  return;

   if(ConfirmCallback==0)  return;
   ConfirmState = confirm_state;
   ActiveMan->SetActiveFunction( ConfirmCallback );
}
//===========================================================================

void  CRFAFC::REQ_Start( int band, int arfcn, int gain, int afc_dac, int test_count )
{
    rf_afc_ptr = this;
    IsRunning  = true;

        Band = band;
       Arfcn = arfcn;
        Gain = gain;
      AfcDac = afc_dac;
   TestCount = test_count;

   TimerMan->CounterStart( test_count*90, ::REQ_TimeOut );
   ActiveMan->SetActiveFunction( ::REQ_SelectBand );
}

//--------------------------------------------------------------------------------------------------
void  CRFAFC::REQ_Start( int band, int arfcn, int gain, int minafc_dac, int test_count, int maxafc_dac, int stepafc_dac )
{
    rf_afc_ptr = this;
    IsRunning  = true;

    Band = band;
    Arfcn = arfcn;
    Gain = gain;
    AfcDac = minafc_dac;
    TestCount = test_count;
    CurAFC = minafc_dac;
    AFCMin = minafc_dac;
    AFCMax = maxafc_dac;
    AFCStep = stepafc_dac;
    TimerMan->CounterStart( 12000, ::REQ_TimeOut );
    ActiveMan->SetActiveFunction( ::REQ_SelectBand );
}

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

void  CRFAFC::REQ_SelectBand( void )
{
   if(!IsRunning)  return;


   unsigned char select_PCS1900;
   if(Band==BANDSEL_PCS1900)
      select_PCS1900 = 1;
   else
      select_PCS1900 = 0;
   MetaResult = META_Rf_SelectFrequencyBand1900( select_PCS1900, ::CNF_SelectBand, &RFID_AFC, NULL );

   if(MetaResult!=META_SUCCESS)
   {  Confirm( STATE_AFC_FAIL );  return;  }
}
//-------------------------------------
void __stdcall CRFAFC::CNF_SelectBand( const unsigned char cnf, const short token, void *usrData )
{
   if(!IsRunning)  return;

   if(cnf==false)
   {  Confirm( STATE_AFC_FAIL );  return;  }

   ActiveMan->SetActiveFunction( ::REQ_MeasureAFC );
}
//---------------------------------------------------------------------------

void  CRFAFC::REQ_MeasureAFC( void )
{
   if(!IsRunning)  return;
   if( RFReq_AFC == NULL)
   {
      RFReq_AFC = new RfAfc_Req;
   }
   if(frmRFTool->pctlToolSel->ActivePageIndex ==  PAGEIDX_AFC)
   {

    RFReq_AFC->arfcn      = Arfcn;
    RFReq_AFC->gain       = Gain;
    RFReq_AFC->dacValue   = AfcDac;
    RFReq_AFC->testNumber = TestCount;


    MetaResult = META_Rf_AFC( RFReq_AFC, ::CNF_MeasureAFC, &RFID_AFC, NULL );

    if(MetaResult!=META_SUCCESS)
      {  Confirm( STATE_AFC_FAIL );  return;  }
    }
  else if(frmRFTool->pctlToolSel->ActivePageIndex ==  PAGEIDX_AFCSWEEP)
    {

       if( HasMeasured )
       {
        DisplayAFC = CurAFC - AFCStep;
        Confirm( STATE_AFC_SECTION_OK );
       }
       RFReq_AFC->arfcn      = Arfcn;
       RFReq_AFC->gain       = Gain;
       RFReq_AFC->dacValue   = CurAFC;
       RFReq_AFC->testNumber = TestCount;
       HasMeasured = false;

       MetaResult = META_Rf_AFC( RFReq_AFC, ::CNF_MeasureAFC, &RFID_AFC, NULL );

       if(MetaResult!=META_SUCCESS)
       {  Confirm( STATE_AFC_FAIL );  return;  }
       }

       CurAFC += AFCStep;
       if( CurAFC> (AFCMax + AFCStep) )
       {  REQ_Finish();
          return;
       }

  
}
//-------------------------------------
void __stdcall CRFAFC::CNF_MeasureAFC(const RfAfc_Cnf *cnf, const short token, void *usrData)
{
   if(!IsRunning)  return;

   if(frmRFTool->pctlToolSel->ActivePageIndex ==  PAGEIDX_AFC)
   {
     RFCnf_AFC = *cnf;
     if(cnf->fcb_ok_number)
     {
        EvalAfcDac[0]  = EvalAfcDac[1];
        EvalFreqErr[0] = EvalFreqErr[1];
        EvalAfcDac[1]  = AfcDac;
        EvalFreqErr[1] = cnf->freqOffset;
     }

     ActiveMan->SetActiveFunction( ::REQ_Finish );
   }
   else if(frmRFTool->pctlToolSel->ActivePageIndex ==  PAGEIDX_AFCSWEEP)
   {
      HasMeasured = true;
      RFCnf_AFC = *cnf;
      ActiveMan->SetActiveFunction( ::REQ_MeasureAFC );
   }
}
//===========================================================================
void  CRFAFC::REQ_Read_From_NVRAM( void )
{
   rf_afc_ptr = this;
   IsRunning = true;

   if(AfcBuf==0)
   {
      MetaResult = META_NVRAM_GetRecLen( "NVRAM_EF_L1_AFCDATA_LID",
                                                        &AfcBufSize );
      if(MetaResult!=META_SUCCESS)
      {  Confirm( STATE_AFC_FAIL );  return;  }
      AfcBuf = new  char[AfcBufSize];
   }

   NVRAMMan->ConfirmCallback = ::CNF_ReadFromNVRAM;

   NVRAMMan->REQ_ReadNVRAM_Start( "NVRAM_EF_L1_AFCDATA_LID",
	                          1, // set to 1 temp
                              AfcBufSize,
                              AfcBuf );

}
//-------------------------------------
void  CRFAFC::CNF_ReadFromNVRAM( void )
{
   if(!IsRunning)  return;


  int  state = NVRAMMan->ConfirmState;

  if(state==STATE_NVRAM_OK)
   { MetaResult;



      MetaResult = META_NVRAM_GetRecFieldValue( "NVRAM_EF_L1_AFCDATA_LID",
                                               "dacValue",
                                               AfcBuf,
                                               AfcBufSize,
                                               &InitAfcDac,
                                               sizeof(InitAfcDac) );

      if(MetaResult!=META_SUCCESS)
      {  Confirm( STATE_AFC_FAIL );  return;  }


      MetaResult = META_NVRAM_GetRecFieldValue( "NVRAM_EF_L1_AFCDATA_LID",
                                               "slopeInv",
                                               AfcBuf,
                                               AfcBufSize,
                                               &AfcSlope,
                                               sizeof(AfcSlope) );
      if(MetaResult!=META_SUCCESS)
      {  Confirm( STATE_AFC_FAIL );  return;  }

      ActiveMan->SetActiveFunction( ::REQ_Finish );
   }

   else if(state==STATE_NVRAM_TIMEOUT)
   {   Confirm( STATE_AFC_TIMEOUT );
   }
   else if(state==STATE_NVRAM_STOP)
   {   Confirm( STATE_AFC_STOP );
   }
   else
   {   Confirm( STATE_AFC_FAIL );
   }
}
//===========================================================================
void  CRFAFC::REQ_Write_To_NVRAM( void )
{  MetaResult;

   rf_afc_ptr = this;
   IsRunning = true;

   if(AfcBuf==0)
   {

      MetaResult = META_NVRAM_GetRecLen( "NVRAM_EF_L1_AFCDATA_LID",
                                                       &AfcBufSize );
      if(MetaResult!=META_SUCCESS)
      {  Confirm( STATE_AFC_FAIL );  return;  }
      AfcBuf = new  char[AfcBufSize];
   }

   unsigned short  sdata = (unsigned short)InitAfcDac;


   MetaResult = META_NVRAM_SetRecFieldValue( "NVRAM_EF_L1_AFCDATA_LID",
                                            "dacValue",
                                            AfcBuf,
                                            AfcBufSize,
                                            &sdata,
                                            sizeof(sdata) );

   if(MetaResult!=META_SUCCESS)
   {  Confirm( STATE_AFC_FAIL );  return;  }

   MetaResult = META_NVRAM_SetRecFieldValue( "NVRAM_EF_L1_AFCDATA_LID",
                                            "slopeInv",
                                            AfcBuf,
                                            AfcBufSize,
                                            &AfcSlope,
                                            sizeof(AfcSlope) );
   if(MetaResult!=META_SUCCESS)
   {  Confirm( STATE_AFC_FAIL );  return;  }


  NVRAMMan->ConfirmCallback = ::CNF_WriteToNVRAM;

  NVRAMMan->REQ_WriteNVRAM_Start( "NVRAM_EF_L1_AFCDATA_LID",
                               1, // only 1 record
                               AfcBufSize,
                               AfcBuf );
}
//-------------------------------------
void  CRFAFC::CNF_WriteToNVRAM( void )
{
   if(!IsRunning)  return;


   int  state = NVRAMMan->ConfirmState;

   if(state==STATE_NVRAM_OK)
   {
      ActiveMan->SetActiveFunction( ::REQ_Finish );
   }
   else if(state==STATE_NVRAM_TIMEOUT)
   {  Confirm( STATE_AFC_TIMEOUT );
   }
   else if(state==STATE_NVRAM_STOP)
   {  Confirm( STATE_AFC_STOP );
   }
   else
   {  Confirm( STATE_AFC_FAIL );
   }
}
//===========================================================================

bool  CRFAFC::REQ_Read_From_File( char *filename )
{
   TIniFile   *ini_file;
   float  fdata;

   ini_file = new TIniFile( filename );
   if(ini_file != NULL) // added by Andy Ueng
   {
   InitAfcDac = ini_file->ReadInteger( "AFC control",
                                       "Initial value",
                                       4100 );

   fdata = ini_file->ReadFloat( "AFC control",
                                "Slope",
                                1.0 );
   if(fdata==0)  fdata=0.0000001;
   AfcSlope = (int)(AFC_SLOPE_SCALE/fdata);

   delete  ini_file;
   }
   return( true );
}
//===========================================================================

bool  CRFAFC::REQ_Write_To_File( char *filename )
{
   TIniFile   *ini_file;
   char  str[20];
   float  fdata;

   ini_file = new TIniFile( filename );
   if(ini_file != NULL) // added by Andy Ueng
   {
   ini_file->WriteInteger( "AFC control",
                           "Initial value",
                           InitAfcDac );

   if(AfcSlope==0)  AfcSlope=1;
   fdata = 1.0*AFC_SLOPE_SCALE/AfcSlope;
   sprintf( str, "%.4f", fdata );
   ini_file->WriteString( "AFC control",
                          "Slope",
                          str );
   delete  ini_file;
   }
   return( true );
}
//===========================================================================

void  CRFAFC::Evaluate( void )
{
   int  d0 = EvalAfcDac[0];
   int  d1 = EvalAfcDac[1];
   int  f0 = EvalFreqErr[0];
   int  f1 = EvalFreqErr[1];
   float fdata;

   if(f0-f1!=0)
   {  fdata =  d0 - 1.0*f0*(d0-d1)/(f0-f1);
      fdata += (fdata>=0) ? 0.5 : -0.5 ;
      EvalInitDac = (int)fdata;

      fdata =  -1.0*(d0-d1)/(f0-f1)*AFC_SLOPE_SCALE;
      fdata += (fdata>=0) ? 0.5 : -0.5 ;
      EvalSlope = (int)fdata;
      if(EvalSlope==0)  EvalSlope=1;
   }
}
//===========================================================================