example_full.c

用于DRX3973或DRX39系列的芯片的控制

         
      /* Set UIO pin to read/write mode */
      if( DRX_Ctrl( &demod, DRX_CTRL_UIO_CFG, &uioCfg ) != DRX_STS_OK )
      {
         XERROR("failure: error configuring UIO pin\n");
      }
      XPRINTF("success: configured UIO pin\n" );

      /* Set UIO pin to desired level (FALSE = LOW, TRUE = HIGH) */
      uioData.value = TRUE; 
      if( DRX_Ctrl( &demod, DRX_CTRL_UIO_WRITE, &uioData ) != DRX_STS_OK )
      {
         XERROR("failure: error setting UIO output value\n");
      }
      XPRINTF("success: UIO pin set to %d\n", uioData.value );

      /* Get value at the UIO pin (FALSE = LOW, TRUE = HIGH) */
      if( DRX_Ctrl( &demod, DRX_CTRL_UIO_READ, &uioData ) != DRX_STS_OK )
      {
         XERROR("failure: error retrieving UIO input value\n");
      }
      XPRINTF("success: value at UIO pin is %d\n", uioData.value );
   }
#endif

#if 0
   /* If required, change MPEG output configuration */
   {
      DRXCfgMPEGOutput_t  outputConfig;
      DRXCfg_t            config = { DRX_CFG_MPEG_OUTPUT, &outputConfig };

      /* re-configure MPEG output */       
      config.cfgData                = &outputConfig;
      outputConfig.enableMPEGOutput = TRUE;
      outputConfig.insertRSByte     = TRUE;
      outputConfig.enableParallel   = TRUE;
      outputConfig.invertDATA       = FALSE;
      outputConfig.invertERR        = FALSE;
      outputConfig.invertSTR        = FALSE;
      outputConfig.invertVAL        = FALSE;
      outputConfig.invertCLK        = FALSE;

      if ( DRX_Ctrl( &demod, DRX_CTRL_SET_CFG, &config ) != DRX_STS_OK )
      {
         XERROR("failure: error re-configuring MPEG output\n");
      }
      XPRINTF("success: re-configured MPEG output\n" );
   }
#endif

#if 0
   /* Optionally, the Impulse Noise Cruncher (INC) can be enabled/disabled */
   /* - The INC will lead to better performance in environments where a    */
   /*   lot of impulse noise is to be expected, e.g. near highways, etc.   */
   /* - Depending on the hardware, enabling it might affect adjacent- or   */
   /*   co-channel performance slightly.                                   */
   /* - For DRX397xD type A2 the INC is disabled by default, for DRX397xD  */
   /*   type B1 it is enabled by default.                                  */
   {
      Bool_t   incVal = TRUE;  /* TRUE to enable INC, FALSE to disable INC */
      DRXCfg_t config = { DRX3973D_CFG_IMP_NOISE, NULL };

      config.cfgData = &incVal;
      if ( DRX_Ctrl( &demod, DRX_CTRL_SET_CFG, &config ) != DRX_STS_OK )
      {
         XERROR("failure: error enabling/disabling Impulse Noise Cruncher\n");
      }
      XPRINTF("success: enabled/disabled Impulse Noise Cruncher\n" );
   }
#endif

   XPRINTF("\n");

   /*-----------------------------------------------------------------------*/
   /* (4) Program channel and wait for lock                                 */
   /*-----------------------------------------------------------------------*/

   /* set channel parameters */
   channelParams.frequency      = DESIRED_FREQUENCY;    /* [kHz] */
   channelParams.bandwidth      = DESIRED_BANDWIDTH;
   channelParams.mirror         = DRX_MIRROR_AUTO;
   channelParams.constellation  = DRX_CONSTELLATION_AUTO;
   channelParams.hierarchy      = DRX_HIERARCHY_AUTO;
   channelParams.priority       = DRX_PRIORITY_HIGH;
   channelParams.coderate       = DRX_CODERATE_AUTO;
   channelParams.guard          = DRX_GUARD_AUTO;
   channelParams.fftmode        = DRX_FFTMODE_AUTO;
   channelParams.classification = DRX_CLASSIFICATION_AUTO;

   /* program channel using desired frequency and bandwidth */
   if ( DRX_Ctrl( &demod, DRX_CTRL_SET_CHANNEL, &channelParams ) != DRX_STS_OK )
   {
      XERROR("failure: error programming desired channel\n");
   }
   XPRINTF("channel programmed... waiting for lock\n");

   /* wait for the system to achieve MPEG lock */
   start      = DRXBSP_HST_Clock();
   everLocked = FALSE;
   do
   {
      if ( DRX_Ctrl( &demod, DRX_CTRL_LOCK_STATUS, &lockStatus ) != DRX_STS_OK )
      {
         XERROR("error retrieving lock status\n");
      }
      
      /* check for any type of lock */
      if ( lockStatus != DRX_NOT_LOCKED )
      {
         everLocked = TRUE;
      }
      
      /* update time passed */
      delta =  DRXBSP_HST_Clock() - start;
      
      /* check for timeouts */
      if ( delta > LOCK_TIMEOUT_MPEG )
      {
         break; /* total timeout */
      }
      if ( (delta > LOCK_TIMEOUT_ANY) && (everLocked == FALSE) )
      {
         break; /* no lock to be expected */
      }
   } while( lockStatus != DRX_LOCKED );

   if ( lockStatus != DRX_LOCKED )
   {
      XERROR("cannot lock to signal\n");
   }
   XPRINTF("lock achieved\n");

   XPRINTF("\n");

   /*-----------------------------------------------------------------------*/
   /* (5) Retrieve channel parameters                                       */
   /*-----------------------------------------------------------------------*/

   /* let system stabilize */
   XWAITMSECS( 1000 );

   XPRINTF("retrieving channel parameters...");
   /* channel parameters found by the system are stored in channelParams */
   if ( DRX_Ctrl( &demod, DRX_CTRL_GET_CHANNEL, &channelParams) != DRX_STS_OK )
   {
      XERROR("error retrieving channel parameters\n");
   }
   
   /* print channel parameters */
   XPRINTF( "\nDetected channel parameters:\n" );
   XPRINTF( "Frequency      : %d kHz\n" , channelParams.frequency );
   XPRINTF( "Bandwidth      : %s\n" , DRX_STR_BANDWIDTH(     channelParams.bandwidth     ) );
   XPRINTF( "FFT mode       : %s\n" , DRX_STR_FFTMODE(       channelParams.fftmode       ) );
   XPRINTF( "Guard interval : %s\n" , DRX_STR_GUARD(         channelParams.guard         ) );
   XPRINTF( "Constellation  : %s\n" , DRX_STR_CONSTELLATION( channelParams.constellation ) );
   XPRINTF( "Code rate      : %s\n" , DRX_STR_CODERATE(      channelParams.coderate      ) );
   XPRINTF( "Hierarchy      : %s\n" , DRX_STR_HIERARCHY(     channelParams.hierarchy     ) );
   XPRINTF( "Priority       : %s\n" , DRX_STR_PRIORITY(      channelParams.priority      ) ); 
   XPRINTF( "Mirroring      : %s\n" , DRX_STR_MIRROR(        channelParams.mirror        ) );  
   XPRINTF( "\n" );   

   /* channel parameters according to the TPS info are stored in TPSInfo */
   if ( DRX_Ctrl( &demod, DRX_CTRL_TPS_INFO, &TPSInfo) != DRX_STS_OK )
   {
      XERROR("error retrieving TPS info\n");
   }

   XPRINTF("\n");

   /*-----------------------------------------------------------------------*/
   /* (6) Show signal quality and strength                                  */
   /*-----------------------------------------------------------------------*/

   /* Let system stabilize */
   XWAITMSECS( 200 );

   XPRINTF( "Measuring signal quality...\n" );
   if ( DRX_Ctrl( &demod, DRX_CTRL_SIG_QUALITY, &sigQuality ) != DRX_STS_OK )
   {
      XERROR("error retrieving signal quality (possibly demod out of lock)\n");
   }
   if ( DRX_Ctrl( &demod, DRX_CTRL_SIG_STRENGTH, &sigStrength ) != DRX_STS_OK )
   {
      XERROR("error retrieving signal strength\n");
   }

#if ( SHOW_SIGNAL_QUALITY_AS_FLOATS )
   XPRINTF( "\nMeasured values (floats) : \n" ); 
   XPRINTF( "BER(PreViterbi)  = %f\n" , 
                   ( (float) sigQuality.preViterbiBER  / (float) sigQuality.scaleFactorBER ) );
   XPRINTF( "BER(PostViterbi) = %f\n" , 
                   ( (float) sigQuality.postViterbiBER  / (float) sigQuality.scaleFactorBER ) );
   XPRINTF( "Packet Errors    = %d\n" , 
                   ( sigQuality.packetError ) );
   XPRINTF( "MER              = %f dB\n" , 
                   ( (float) sigQuality.MER / 10.0 ) );
   XPRINTF( "Signal Strength  = %f %%\n" ,
                   ( (float) sigStrength * 100.0 / 1023.0 ) );
#endif

#if ( SHOW_SIGNAL_QUALITY_AS_INTEGERS )
   XPRINTF( "\nMeasured values (integers) : \n" );
   XPRINTF( "BER(PreViterbi)  = %d.%6.6d\n" , 
                   (sigQuality.preViterbiBER/sigQuality.scaleFactorBER) ,
                   (sigQuality.preViterbiBER%sigQuality.scaleFactorBER) );
   XPRINTF( "BER(PostViterbi) = %d.%6.6d\n" ,
                   (sigQuality.postViterbiBER/sigQuality.scaleFactorBER) ,
                   (sigQuality.postViterbiBER%sigQuality.scaleFactorBER) );
   XPRINTF( "Packet Errors    = %d\n"           , sigQuality.packetError ); 
   XPRINTF( "MER              = %3d.%1.1d dB\n" , 
                   (sigQuality.MER/10) ,
                   (sigQuality.MER%10) );
   XPRINTF( "Signal Strength  = %4d (range 0 to 1023)\n" , 
                   sigStrength );
#endif

#if ( SHOW_SIGNAL_QUALITY_AS_INDICATORS )
   {
      u16_t indicatorQuality, indicatorStrength;
      
      /* map signal quality to a useful range from 0 to 100           */
      /* In this case, MER range from 8- to 28+ dB range is mapped    */
      indicatorQuality = 0;
      if ( sigQuality.MER > 80 )
      {
         indicatorQuality  = (sigQuality.MER - 80) / 2;
         if ( indicatorQuality > 100 )
         {
            indicatorQuality = 100;
         }
      }
      
      /* map signal strength to a useful range from 0 to 100          */
      /* Depending on the hardware, this might need some midification */
      indicatorStrength = 100;
      if ( sigStrength < 1000 )
      {
         indicatorStrength = sigStrength/10;
      }

      XPRINTF("\nMeasured values (indicator mapping) : \n");
      XPRINTF( ("Signal Quality   = %3d %%\n") , indicatorQuality  );
      XPRINTF( ("Signal Strength  = %3d %%\n") , indicatorStrength );
   }
#endif

   XWAITKEYPRESSED( "\nPress enter to terminate system.\n" );

   /*-----------------------------------------------------------------------*/
   /* (7) Terminate system                                                  */
   /*-----------------------------------------------------------------------*/

   /* close demodulator */
   if ( DRX_Close( &demod ) != DRX_STS_OK )
   {
      XERROR("failure: error closing demodulator instance\n");
   }
   XPRINTF("DRX demodulator instance closed\n");

   /* terminate driver */
   if ( DRX_Term() != DRX_STS_OK )
   {
      XERROR("failure: error terminating DRX driver\n");
   }
   XPRINTF("DRX driver terminated\n");

   if ( DRXBSP_HST_Term() != DRX_STS_OK )
   {
      XERROR("failure: error terminating host bsp\n");
   }
   XPRINTF("Host bsp terminated\n");

   if ( DRXBSP_I2C_Term() != DRX_STS_OK )
   {
      XERROR("failure: error terminating i2c\n");
   }
   XPRINTF("I2C terminated\n");

   XWAITKEYPRESSED( "\nPress enter to quit.\n" );
   return 0;
}


/*============================================================================*/
/* END OF FILE */