rf_tx.cpp

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

//#include "meta2.h"
//#include "temp.h" // added by Andy Ueng temp
//===========================================================================
#include <IniFiles.hpp>
#include "form_RFTool.h"

#include "rf_tx.h"
#include "man_timer.h"
#include "man_active.h"
#include "man_fdm.h"
static CRFTX*  rf_tx_ptr;

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

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

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

static void __stdcall CNF_BBTXCfg(const unsigned char cnf, const short token, void *usrData)
{
  rf_tx_ptr->CNF_BBTXCfg( cnf, token, usrData );
}
static void  REQ_NormalTX( void )
{  rf_tx_ptr->REQ_NormalTX( );
}

static void __stdcall CNF_NormalTX(const unsigned char cnf, const short token, void *usrData)
{
  rf_tx_ptr->CNF_NormalTX( cnf, token, usrData );
}
static void  REQ_TimeOut( void )
{  rf_tx_ptr->REQ_TimeOut();
}
static void  REQ_Finish( void )
{   rf_tx_ptr->REQ_Finish();
}

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

CRFTX::CRFTX( void )
{
   IsRunning = false;
   ConfirmCallback = 0;
   RFReq_TX = NULL;
   RFReq_BBTXCFG = NULL;
}
//---------------------------------------------------------------------------

CRFTX::~CRFTX( )
{
   IsRunning = false;
   ConfirmCallback = 0;
   if(RFReq_TX != NULL)
   {
      delete RFReq_TX;
      RFReq_TX = NULL;
   }

   if( RFReq_BBTXCFG != NULL)
   {
      delete RFReq_BBTXCFG;
      RFReq_BBTXCFG = NULL;
   }
}
//---------------------------------------------------------------------------

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

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

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

   TimerMan->CounterStop();
   META_Cancel( RFID_TX );
   Confirm( STATE_TX_STOP );
   IsRunning = false;
}
//---------------------------------------------------------------------------

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

   TimerMan->CounterStop();
   META_Cancel( RFID_TX );
   Confirm( STATE_TX_TIMEOUT );
   IsRunning = false;
}
//---------------------------------------------------------------------------

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

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

void  CRFTX::REQ_Start( int band, int arfcn, int bsic, int pcl, int frames, int afc_dac, int burst_type, int trim_i, int trim_q, int off_i, int off_q )
{
    rf_tx_ptr = this;
    IsRunning = true;

        Band = band;
	    Arfcn = arfcn;
	     Bsic = bsic;
	      PCL = pcl;
	   Frames = frames;
	   AFCDac = afc_dac;
	BurstType = burst_type;
      TrimI = trim_i;
      TrimQ = trim_q;
    OffsetI = off_i;
    OffsetQ = off_q;

   TimerMan->CounterStart( 1000, ::REQ_TimeOut );
   ActiveMan->SetActiveFunction( ::REQ_SelectBand );
}
//---------------------------------------------------------------------------

void  CRFTX::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_TX, NULL );

   
   if(MetaResult!=META_SUCCESS)
   {  Confirm( STATE_TX_FAIL );  return;  }
}
//-------------------------------------

void __stdcall CRFTX::CNF_SelectBand( const unsigned char cnf, const short token, void *usrData )
{
   if(!IsRunning)  return;

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

   if((TrimI==-99)&&(TrimQ==-99))
   {  ActiveMan->SetActiveFunction( ::REQ_NormalTX );
   }
   else
   {  ActiveMan->SetActiveFunction( ::REQ_BBTXCfg );
   }
}
//---------------------------------------------------------------------------

void  CRFTX::REQ_BBTXCfg( void )
{
   if(!IsRunning)  return;

   if( RFReq_BBTXCFG == NULL )
   {
      RFReq_BBTXCFG = new RfSetBBTXCfg_Req;
   } 
   RFReq_BBTXCFG->TxTrimI   = TrimI;
   RFReq_BBTXCFG->TxTrimQ   = TrimQ;
   RFReq_BBTXCFG->TxOffsetI = OffsetI;
   RFReq_BBTXCFG->TxOffsetQ = OffsetQ;


   MetaResult = META_Rf_SetBBTXCfg( RFReq_BBTXCFG, ::CNF_BBTXCfg, &RFID_TX, NULL );

   
   if(MetaResult!=META_SUCCESS)
   {  Confirm( STATE_TX_FAIL );  return;  }
}
//-------------------------------------


void __stdcall CRFTX::CNF_BBTXCfg(const unsigned char cnf, const short token, void *usrData)
{
   if(!IsRunning)  return;

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

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

void  CRFTX::REQ_NormalTX( void )
{
   if(!IsRunning)  return;
   if( RFReq_TX == NULL)
   {
      RFReq_TX = new RfNbtx_Req;
   }
   RFReq_TX->arfcn       = Arfcn;
   RFReq_TX->bsic        = Bsic;
   RFReq_TX->power       = PCL;
   RFReq_TX->frames      = Frames;
   RFReq_TX->dacValue    = AFCDac;
   if(BurstType==0)  RFReq_TX->burstTypeNB = AB_TX_RANDOM_WITH_SYNC_SEQ;
   if(BurstType==1)  RFReq_TX->burstTypeNB = NB_TX_RANDOM_WITH_TSC;
   if(BurstType==2)  RFReq_TX->burstTypeNB = NB_TX_ALL_ONES_WITHOUT_TSC;


 MetaResult = META_Rf_NB_TX( RFReq_TX, ::CNF_NormalTX, &RFID_TX, NULL );

 
   if(MetaResult!=META_SUCCESS)
   {  Confirm( STATE_TX_FAIL );  return;  }
}
//-------------------------------------


void __stdcall CRFTX::CNF_NormalTX(const unsigned char cnf, const short token, void *usrData)
{
   if(!IsRunning)  return;

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

   ActiveMan->SetActiveFunction( ::REQ_Finish );
}
//===========================================================================