Functions
Sensor

mmwave radar RF/Sensor Configuration Module More...

Functions

MMWL_EXPORT rlReturnVal_t rlSetChannelConfig (rlUInt8_t deviceMap, rlChanCfg_t *data)
 Sets the Rx and Tx Channel Configuration. More...
 
MMWL_EXPORT rlReturnVal_t rlSetAdcOutConfig (rlUInt8_t deviceMap, rlAdcOutCfg_t *data)
 Sets ADC Output Configuration. More...
 
MMWL_EXPORT rlReturnVal_t rlSetLowPowerModeConfig (rlUInt8_t deviceMap, rlLowPowerModeCfg_t *data)
 Sets Low Power Mode Configuration. More...
 
MMWL_EXPORT rlReturnVal_t rlRfInit (rlUInt8_t deviceMap)
 Initializes the RF/Analog Subsystem. More...
 
MMWL_EXPORT rlReturnVal_t rlGetProfileConfig (rlUInt8_t deviceMap, rlUInt16_t profileId, rlProfileCfg_t *data)
 Gets Chirp profile Configuration. More...
 
MMWL_EXPORT rlReturnVal_t rlSetProfileConfig (rlUInt8_t deviceMap, rlUInt16_t cnt, rlProfileCfg_t *data)
 Sets Chirp profile Configuration. More...
 
MMWL_EXPORT rlReturnVal_t rlGetChirpConfig (rlUInt8_t deviceMap, rlUInt16_t chirpStartIdx, rlUInt16_t chirpEndIdx, rlChirpCfg_t *data)
 Gets Chirp Configuration. More...
 
MMWL_EXPORT rlReturnVal_t rlSetChirpConfig (rlUInt8_t deviceMap, rlUInt16_t cnt, rlChirpCfg_t *data)
 Sets Chirp Configuration. More...
 
MMWL_EXPORT rlReturnVal_t rlSetMultiChirpCfg (rlUInt8_t deviceMap, rlUInt16_t cnt, rlChirpCfg_t **data)
 Injects chirp configuration to be programmed dynamically. More...
 
MMWL_EXPORT rlReturnVal_t rlGetFrameConfig (rlUInt8_t deviceMap, rlFrameCfg_t *data)
 Gets Frame Configuration. More...
 
MMWL_EXPORT rlReturnVal_t rlSetFrameConfig (rlUInt8_t deviceMap, rlFrameCfg_t *data)
 Sets Frame Configuration. More...
 
MMWL_EXPORT rlReturnVal_t rlSensorStart (rlUInt8_t deviceMap)
 Triggers Transmission of Frames. More...
 
MMWL_EXPORT rlReturnVal_t rlSensorStop (rlUInt8_t deviceMap)
 Stops Transmission of Frames. More...
 
MMWL_EXPORT rlReturnVal_t rlFrameStartStop (rlUInt8_t deviceMap, rlFrameTrigger_t *data)
 Triggers/Stops Transmission of Frames. More...
 
MMWL_EXPORT rlReturnVal_t rlGetAdvFrameConfig (rlUInt8_t deviceMap, rlAdvFrameCfg_t *data)
 Gets Advance Frame Configuration. More...
 
MMWL_EXPORT rlReturnVal_t rlSetAdvFrameConfig (rlUInt8_t deviceMap, rlAdvFrameCfg_t *data)
 Sets Advance Frame Configuration. More...
 
MMWL_EXPORT rlReturnVal_t rlSetContModeConfig (rlUInt8_t deviceMap, rlContModeCfg_t *data)
 Sets Continous mode Configuration. More...
 
MMWL_EXPORT rlReturnVal_t rlEnableContMode (rlUInt8_t deviceMap, rlContModeEn_t *data)
 Enable/Disable Continous mode. More...
 
MMWL_EXPORT rlReturnVal_t rlSetBpmCommonConfig (rlUInt8_t deviceMap, rlBpmCommonCfg_t *data)
 Sets Binary Phase Modulation Common Configuration. More...
 
MMWL_EXPORT rlReturnVal_t rlSetBpmChirpConfig (rlUInt8_t deviceMap, rlBpmChirpCfg_t *data)
 Sets Binary Phase Modulation Chirp Configuration. More...
 
MMWL_EXPORT rlReturnVal_t rlSetMultiBpmChirpConfig (rlUInt8_t deviceMap, rlUInt16_t cnt, rlBpmChirpCfg_t **data)
 Sets Binary Phase Modulation configuration for multiple Chirp. More...
 
MMWL_EXPORT rlReturnVal_t rlSetTestSourceConfig (rlUInt8_t deviceMap, rlTestSource_t *data)
 Configures the Test Source. More...
 
MMWL_EXPORT rlReturnVal_t rlTestSourceEnable (rlUInt8_t deviceMap, rlTestSourceEnable_t *data)
 Enables the Test Source. More...
 
MMWL_EXPORT rlReturnVal_t rlRfGetTemperatureReport (rlUInt8_t deviceMap, rlRfTempData_t *data)
 Gets Time and Temperature information report. More...
 
MMWL_EXPORT rlReturnVal_t rlRfDfeRxStatisticsReport (rlUInt8_t deviceMap, rlDfeStatReport_t *data)
 Gets Digital Front end statistics such as Residual DC, RMS power in I and Q chains for different Receive channels for different selected profiles. It also includes Cross correlation between I and Q chains. More...
 
MMWL_EXPORT rlReturnVal_t rlRfDynamicPowerSave (rlUInt8_t deviceMap, rlDynPwrSave_t *data)
 : Configure dynamic power saving feature. More...
 
MMWL_EXPORT rlReturnVal_t rlRfSetDeviceCfg (rlUInt8_t deviceMap, rlRfDevCfg_t *data)
 : Set different RadarSS device configurations More...
 
MMWL_EXPORT rlReturnVal_t rlSetGpAdcConfig (rlUInt8_t deviceMap, rlGpAdcCfg_t *data)
 : Configure GP ADC data parameters More...
 
MMWL_EXPORT rlReturnVal_t rlRfSetPhaseShiftConfig (rlUInt8_t deviceMap, rlUInt16_t cnt, rlRfPhaseShiftCfg_t *data)
 Enable/Disable phase shift configurations per chirp in each of the TXs. More...
 
MMWL_EXPORT rlReturnVal_t rlRfSetPALoopbackConfig (rlUInt8_t deviceMap, rlRfPALoopbackCfg_t *data)
 Enable/Disable PA loopback for all enabled profiles. More...
 
MMWL_EXPORT rlReturnVal_t rlRfSetPSLoopbackConfig (rlUInt8_t deviceMap, rlRfPSLoopbackCfg_t *data)
 Enable/Disable Phase shift loopback for all enabled profiles. More...
 
MMWL_EXPORT rlReturnVal_t rlRfSetIFLoopbackConfig (rlUInt8_t deviceMap, rlRfIFLoopbackCfg_t *data)
 Enable/Disable RF IF loopback for all enabled profiles. This is used for debug to check if both TX and RX chains are working correctly. More...
 
MMWL_EXPORT rlReturnVal_t rlRfSetProgFiltCoeffRam (rlUInt8_t deviceMap, rlRfProgFiltCoeff_t *data)
 Set Programmable Filter coefficient RAM. More...
 
MMWL_EXPORT rlReturnVal_t rlRfSetProgFiltConfig (rlUInt8_t deviceMap, rlRfProgFiltConf_t *data)
 Set Programmable Filter configuration. More...
 
MMWL_EXPORT rlReturnVal_t rlRfSetMiscConfig (rlUInt8_t deviceMap, rlRfMiscConf_t *data)
 Sets misc feature such as per chirp phase shifter. More...
 
MMWL_EXPORT rlReturnVal_t rlRfSetCalMonTimeUnitConfig (rlUInt8_t deviceMap, rlRfCalMonTimeUntConf_t *data)
 Set Calibration monitoring time unit. More...
 
MMWL_EXPORT rlReturnVal_t rlRfSetCalMonFreqLimitConfig (rlUInt8_t deviceMap, rlRfCalMonFreqLimitConf_t *data)
 Set Calibration monitoring Frequency Limit. More...
 
MMWL_EXPORT rlReturnVal_t rlRfInitCalibConfig (rlUInt8_t deviceMap, rlRfInitCalConf_t *data)
 Set RF Init Calibration Mask bits and report type. More...
 
MMWL_EXPORT rlReturnVal_t rlRfRunTimeCalibConfig (rlUInt8_t deviceMap, rlRunTimeCalibConf_t *data)
 Set RF one time & periodic calibration of various RF/analog aspects and trigger. More...
 
MMWL_EXPORT rlReturnVal_t rlRxGainTempLutSet (rlUInt8_t deviceMap, rlRxGainTempLutData_t *data)
 Overwrite RX gain temperature Lookup Table(LUT) in Radar SS. More...
 
MMWL_EXPORT rlReturnVal_t rlTxGainTempLutSet (rlUInt8_t deviceMap, rlTxGainTempLutData_t *data)
 Overwrites TX gain temperature based Lookup table (LUT) More...
 
MMWL_EXPORT rlReturnVal_t rlRfTxFreqPwrLimitConfig (rlUInt8_t deviceMap, rlRfTxFreqPwrLimitMonConf_t *data)
 Sets the limits for RF frequency transmission for each TX and also TX power limits. More...
 
MMWL_EXPORT rlReturnVal_t rlSetLoopBckBurstCfg (rlUInt8_t deviceMap, rlLoopbackBurst_t *data)
 This API is used to introduce loopback chirps within the functional frames. More...
 
MMWL_EXPORT rlReturnVal_t rlSetDynChirpCfg (rlUInt8_t deviceMap, rlUInt16_t segCnt, rlDynChirpCfg_t **data)
 Injects chirp configuration to be programmed dynamically. More...
 
MMWL_EXPORT rlReturnVal_t rlSetDynChirpEn (rlUInt8_t deviceMap, rlDynChirpEnCfg_t *data)
 Triggers copy of chirp config from SW to HW RAM. More...
 
MMWL_EXPORT rlReturnVal_t rlSetDynPerChirpPhShifterCfg (rlUInt8_t deviceMap, rlUInt16_t segCnt, rlDynPerChirpPhShftCfg_t **data)
 Injects per-chirp phase shifter configuration to be applied dynamically. More...
 
MMWL_EXPORT rlReturnVal_t rlRfCalibDataStore (rlUInt8_t deviceMap, rlCalibrationData_t *data)
 Read calibration data from the device. More...
 
MMWL_EXPORT rlReturnVal_t rlRfCalibDataRestore (rlUInt8_t deviceMap, rlCalibrationData_t *data)
 Injects calibration data to the device. More...
 
MMWL_EXPORT rlReturnVal_t rlRfInterRxGainPhaseConfig (rlUInt8_t deviceMap, rlInterRxGainPhConf_t *data)
 Sets different Rx gain/phase offset. More...
 
MMWL_EXPORT rlReturnVal_t rlGetRfBootupStatus (rlUInt8_t deviceMap, rlRfBootStatusCfg_t *data)
 Get radarSS bootup status. More...
 
MMWL_EXPORT rlReturnVal_t rlSetInterChirpBlkCtrl (rlUInt8_t deviceMap, rlInterChirpBlkCtrlCfg_t *data)
 Sets Inter-chip turn on and turn off times or various RF blocks. More...
 
MMWL_EXPORT rlReturnVal_t rlSetSubFrameStart (rlUInt8_t deviceMap, rlSubFrameStartCfg_t *data)
 Triggers the next sub-frame in software triggered sub-frame mode. More...
 
MMWL_EXPORT rlReturnVal_t rlRfPhShiftCalibDataStore (rlUInt8_t deviceMap, rlPhShiftCalibrationData_t *data)
 Read calibration data from the device. More...
 
MMWL_EXPORT rlReturnVal_t rlRfPhShiftCalibDataRestore (rlUInt8_t deviceMap, rlPhShiftCalibrationData_t *data)
 Injects phase shifter calibration data to the device. More...
 
MMWL_EXPORT rlReturnVal_t rlGetRfDieId (rlUInt8_t deviceMap, rlRfDieIdCfg_t *data)
 Get device die ID status. More...
 
MMWL_EXPORT rlReturnVal_t rlRfGetEsmFault (rlUInt8_t deviceMap, rlBssEsmFault_t *data)
 Get RadarSS ESM fault status. More...
 
MMWL_EXPORT rlReturnVal_t rlRfGetCpuFault (rlUInt8_t deviceMap, rlCpuFault_t *data)
 Get RadarSS CPU fault status. More...
 
MMWL_EXPORT rlReturnVal_t rlSetAdvChirpConfig (rlUInt8_t deviceMap, rlAdvChirpCfg_t *data)
 Set the Advanced chirp configuration to the device. More...
 
MMWL_EXPORT rlReturnVal_t rlMonTypeTrigConfig (rlUInt8_t deviceMap, rlMonTypeTrigCfg_t *data)
 Maintains monitoring timing synchronization in cascaded devices to avoid mutual interference of monitors running in different devices in the cascade sensor. More...
 
MMWL_EXPORT rlReturnVal_t rlRfApllSynthBwCtlConfig (rlUInt8_t deviceMap, rlRfApllSynthBwControl_t *data)
 Control bandwidth of the APLL and Synthesizer. More...
 
MMWL_EXPORT rlReturnVal_t rlSetAdvChirpLUTConfig (rlUInt8_t deviceMap, rlAdvChirpLUTCfg_t *data)
 Set the Advanced chirp LUT configuration to the device. More...
 
MMWL_EXPORT rlReturnVal_t rlSetMultiAdvChirpLUTConfig (rlUInt8_t deviceMap, rlAdvChirpLUTCfg_t *AdvChirpLUTCfgArgs, rlInt8_t *AdvChirpLUTData)
 Multi Advanced chirp LUT configuration API. More...
 
MMWL_EXPORT rlReturnVal_t rlSetAdvChirpDynLUTAddrOffConfig (rlUInt8_t deviceMap, rlAdvChirpDynLUTAddrOffCfg_t *data)
 Configure LUT address offset dynamically for each chirp parameters defined in rlSetAdvChirpConfig API. More...
 

Detailed Description

mmwave radar RF/Sensor Configuration Module

mmwave_frontend.png

The RF/Sensor Configuration module controls the different HW blocks inside mmWave Front end. mmWave Front End has below key blocks

  1. Chirp sequencer (Radar Timing Engine) - This block is responsible for constructing the sequence of FMCW chirps or frames and programming the timing engine
  2. Rx/Tx Channel - This defines how many Rx and Tx channel needs to be enabled. Also it defines how to configure the mmWave front end in cascade mode for Imaging Radar
  3. Rx Analog Chain - This defines how the received signal is mixed and how different filters in the chain can be configured
  4. ADC and Digital Front End Configuration - This defines how the IF data is digitized and how it is sampled for further processing in the DSP or Hardware Accelerator. Same ADC data can be sent over LVDS/CSI2 interface to an extenal processor

The Sensor Control APIs needs to be called by application in below sequence

Initial/Static Configuration

Application should first configure the mmWave Front end or Radar SS with below Static configurations

Initialization and Calibration

After initial static configurations, application should initialize RF and shall wait for calibration complete Asynchornous event RL_RF_AE_INITCALIBSTATUS_SB

FMCW chirp Configuration

After RF initilization, Application can configure chirps and frame using below APIs

Frame Trigger

After All the configuration, Application can use Sensor Start API to start Frame and shall wait for Frame Ready Asynchronous event RL_RF_AE_FRAME_TRIGGER_RDY_SB

Below is the list of advance features in mmWave Front end

Advance Frame

Legacy frame config API rlSetFrameConfig supports looping of the same FMCW frame. In order to configure multiple FMCW frames with different chirp profiles, user needs to use rlSetAdvFrameConfig API. Advance Frame consists of one or upto 4 Sub-Frames Each Sub-Frame consists of multiple bursts. Each burst consists of multiple chirps as shown in diagram below.
To enable Advance Frame, Application needs to follow below sequence

adv_frame_seq.png

Dynamic Chirp Configuration

Using Legacy chirp configuration API rlSetChirpConfig, chirps can't be re-configure without stopping the ongoing FMCW frame using rlSensorStop API.
If user needs to re-configure chirp during the frame, it needs to use Dynamic chirp config APIs. Once the API is received by mmWave Front end, it would re-configure the chirps for next FMCW frame. Dynamic Chirps can be defined using below APIs

Diagram below shows the Dynamic Chirp behaviour. Note that since dynamic chirps are configured at run time, there is not error checks done on the input data. If input data is out of range or invalid, device might misbehave.

dyn_chip_seq.png

Calibration

TI mmWave Front end includes built-in processor that is programmed by TI to handle RF calibrations and functional safety monitoring. The RF calibrations ensure that the performance of the device is maintained across temperature and process corners

  1. Some of the calibrations are just temperature and process based look-up-tables, which are used to update the RF/Analog components
  2. Built-in temperature sensors enable the device to monitor the temperature every few seconds and update the relevant components accordingly

API Programming Sequence

Single Device mode

  1. Power up the device
  2. Wait for AWR_AE_MSSPOWERUPDONE_SB
  3. Wait for AWR_AE_MSS_BOOTERRORSTATUS_SB if flash is not connected (Boot over SPI)
  4. AWR_DEV_CONFIGURATION_SET_SB
  5. AWR_DEV_RFPOWERUP_SB
  6. Wait for AWR_AE_RFPOWERUPDONE_SB
  7. AWR_RF_STATIC_CONF_SET_MSG
    • AWR_RF_DEVICE_CFG_SB
    • AWR_CHAN_CONF_SET_SB
    • AWR_ADCOUT_CONF_SET_SB
    • AWR_RF_LDO_BYPASS_SB with RFLDOBYPASS_EN set to 1 if RF supply is 1.0 V
    • AWR_LOWPOWERMODE_CONF_SET_SB
    • AWR_DYNAMICPOWERSAVE_CONF_SET_SB
    • AWR_CAL_MON_FREQUENCY_TX_POWER_LIMITS_SB
    • AWR_RF_RADAR_MISC_CTL_SB if per chirp phase shifter and Advance chirp configuration needs to be enabled.
    • AWR_APLL_SYNTH_BW_CONTROL_SB
  8. Data path configurations
    • AWR_DEV_RX_DATA_FORMAT_CONF_SET_SB
    • AWR_DEV_RX_DATA_PATH_CONF_SET_SB
    • AWR_DEV_RX_DATA_PATH_LANE_EN_SB
    • AWR_DEV_RX_DATA_PATH_CLK_SET_SB
    • AWR_HIGHSPEEDINTFCLK_CONF_SET_SB
    • AWR_DEV_LVDS_CFG_SET_SB / AWR_DEV_CSI2_CFG_SET_SB
  9. AWR_RF_INIT_MSG
    • AWR_PHASE_SHIFTER_CAL_DATA_RESTORE_SB (To restore factory calibration data for TX0), keep CAL_APPLY = 0
    • AWR_PHASE_SHIFTER_CAL_DATA_RESTORE_SB (To restore factory calibration data for TX1), keep CAL_APPLY = 0
    • AWR_PHASE_SHIFTER_CAL_DATA_RESTORE_SB (To restore factory calibration data for TX2), keep CAL_APPLY = 1
    • AWR_CAL_DATA_RESTORE_SB (To restore factory calibration data to avoid on field RF interference during calibration)
    • Wait for AWR_AE_RF_INITCALIBSTATUS_SB
    • AWR_RF_INIT_CALIBRATION_CONF_SB (Enable only required calibration to run)
    • AWR_RFINIT_SB: This triggers very basic calibrations and RF initializations
    • Wait for AWR_AE_RF_INITCALIBSTATUS_SB
  10. AWR_RF_DYNAMIC_CONF_SET_MSG
    • AWR_PROG_FILT_COEFF_RAM_SET_SB
    • AWR_PROG_FILT_CONF_SET_SB
    • AWR_PROFILE_CONF_SET_SB
    • Chirp configuration API
    • AWR_CHIRP_CONF_SET_SB or
    • AWR_ADVANCE_CHIRP_CONF_SB and
    • AWR_ADVANCE_CHIRP_GENERIC_LUT_LOAD_SB
    • AWR_LOOPBACK_BURST_CONF_SET_SB (if using loopback burst in advance frame config API)
    • AWR_FRAME_CONF_SET_SB or AWR_ADVANCED_FRAME_CONF_SB with SW or HW triggered mode and AWR_DEV_FRAME_CONFIG_APPLY_MSG.
    • AWR_CALIB_MON_TIME_UNIT_CONF_SB with CALIB_MON_TIME_UNIT value set to a value such that the total frame idle time across multiple CALIB_MON_TIME_UNITs is sufficient for all calibrations and monitoring. See Section 12 for details on calibration and monitoring durations. If any error AWR_CAL_MON_TIMING_FAIL_REPORT_AE_SB AE will be generated when frame is triggered. The calibrations and monitors will not run properly if this error is generated.
    • Set NUM_OF_CASCADED_DEV to 1, DEVICE_ID to 0 and Set MONITORING_MODE = 0 (MONITORING_MODE 1 is recommended only in cascade mode) in AWR_CALIB_MON_TIME_UNIT_CONF_SB API
    • AWR_RUN_TIME_CALIBRATION_CONF_AND_TRIGGER_SB (set all ONE_TIME_CALIB_ENABLE_MASK and set ENABLE_CAL_REPORT = 1)
    • Wait for AWR_RUN_TIME_CALIBRATION_SUMMARY_REPORT_AE_SB
    • AWR_RUN_TIME_CALIBRATION_CONF_AND_TRIGGER_SB (set all RUN_TIME_CALIB_ENABLE_MASK and set ENABLE_CAL_REPORT = 0 to avoid receiving periodic async events)
    • AWR_DEV_FRAME_CONFIG_APPLY_SB or AWR_DEV_ADV_FRAME_CONFIG_APPLY_SB
  11. MONITOR CONFIGURATIONS
    • AWR_MONITOR_RF_DIG_LATENTFAULT_CONF_SB : Wait for & AWR_MONITOR_RF_DIG_LATENTFAULT_REPORT_AE_SB AE. This API should not be issue when frames are running.
    • AWR_MSS_LATENTFAULT_TEST_CONF_SB :Wait for AWR_AE_MSS_LATENTFAULT_TESTREPORT_SB AE.
    • AWR_MSS_PERIODICTESTS_CONF_SB : Enable periodic digital monitors, the monitor starts immediately after enabling this API.
    • AWR_MONITOR_RF_DIG_PERIODIC_CONF_SB : Enable periodic digital monitors
    • AWR_MONITOR_ANALOG_ENABLES_CONF_SB : Enable periodic analog monitors, The corresponding monitoring configuration APIs should be issued after issuing this API. Refer latest release note for all supported monitors.
  12. AWR_RF_FRAME_TRIG_MSG for frame start
    • AWR_FRAMESTARTSTOP_CONF_SB in Start mode (1): after this, frames get transmitted, wait for AWR_AE_RF_FRAME_TRIGGER_RDY_SB AE.
  13. AWR_RF_FRAME_TRIG_MSG for frame stop
    • AWR_FRAMESTARTSTOP_CONF_SB in Stop mode (0): after this, frames are stopped. Wait for AWR_FRAME_END_AE_SB AE. The AWR_RF_FRAME_TRIG_MSG may be issued multiple times for multiple sets of frames. Refer AWR_FRAMESTARTSTOP_CONF_SB for more frame stop options.

Cascade Device mode

Chirping mode (cascaded)
S NoMaster Device SequenceSlave Device Sequence
1Power up master device
2Wait for AWR_AE_DEV_MSSPOWERUPDONE_SB
3AWR_DEV_RFPOWERUP_SB
4Wait for AWR_AE_DEV_RFPOWERUPDONE_SB
5AWR_CHAN_CONF_SET_SB with CASCADING_CFG = 0x0001. The reference clock for slave device is enabled by default
6Power on slave device
7Wait for AWR_AE_DEV_MSSPOWERUPDONE_SB
8AWR_DEV_RFPOWERUP_SB
9Wait for AWR_AE_DEV_RFPOWERUPDONE_SB
10AWR_CHAN_CONF_SET_SB with CASCADING_CFG = 0x0002 and disable OSC CLOCK OUT.
11Follow all AWR_RF_STATIC_CONF_SET_MSG APIs sequence as instructed in single chip mode, please refer application Care Abouts above if any deviation from single chipFollow all AWR_RF_STATIC_CONF_SET_MSG APIs sequence as instructed in single chip mode, please refer application Care Abouts above if any deviation from single chip
12Follow all Data path configurations APIs sequence as instructed in single chip modeFollow all Data path configurations APIs sequence as instructed in single chip mode
13Follow all AWR_RF_INIT_MSG APIs sequence as instructed in single chip modeFollow all AWR_RF_INIT_MSG APIs sequence as instructed in single chip mode
14Follow all AWR_RF_DYNAMIC_CONF_SET_MSG APIs sequence as instructed in single chip mode, please refer application Care Abouts above if any deviation from single chipFollow all AWR_RF_DYNAMIC_CONF_SET_MSG APIs sequence as instructed in single chip mode, please refer application Care Abouts above if any deviation from single chip
15Follow all MONITOR CONFIGURATIONS APIs sequence as instructed in single chip mode, please refer application Care Abouts above if any deviation from single chipFollow all MONITOR CONFIGURATIONS APIs sequence as instructed in single chip mode, please refer application Care Abouts above if any deviation from single chip
16AWR_FRAMESTARTSOP_CONF_SB with STARTSTOP_CMD = 0x0001
17Wait for AWR_AE_RF_FRAME_TRIGGER_RDY_SB
18AWR_FRAMESTARTSOP_CONF_SB with STARTSTOP_CMD = 0x0001
19Wait for AWR_AE_RF_FRAME_TRIGGER_RDY_SB
20Trigger AWR_MONITOR_TYPE_TRIG_CONF_SB API for type 0, 1 and 2 monitors and follow instructions mentioned in this API sectionTrigger AWR_MONITOR_TYPE_TRIG_CONF_SB API for type 0, 1 and 2 monitors and follow instructions mentioned in this API section
21AWR_FRAMESTARTSOP_CONF_SB with STARTSTOP_CMD = 0x0000
22Wait for AWR_FRAME_END_AE_SB AE
23AWR_FRAMESTARTSOP_CONF_SB with STARTSTOP_CMD = 0x0000
24Wait for AWR_FRAME_END_AE_SB AE

Application care abouts in Cascade mode

When using cascaded devices, the reference clock is provided by master to slave. So unless master is powered-up and clock is available from master to slave, the slave device cannot be powered up.

Following instructions and sequence needs to be followed in cascade mode (Master and Slave mode configured in CASCADING_CFG field in rlSetChannelConfig API):

  1. Disable OSC clock out (OSCCLKOUT_DIS = 1) for slaves in rlSetChannelConfig API
  2. Write INTER_BURST_POWER_SAVE_DIS = 0 (Enable inter-burst power save) in rlRfSetDeviceCfg (default setting)
  3. Write WDT_ENABLE = 0 (Disable WDT) in rlRfSetDeviceCfg (default setting)
  4. Set MONITORING_MODE = 1 (API based monitor trigger. The automated monitoring trigger is also supported in cascade mode, not used in this sequence)
  5. Set NUM_OF_CASCADED_DEV to 1 and DEVICE_ID to 0 in rlRfSetCalMonTimeUnitConfig (Not recommended to set other values for proper functionality in MONITORING_MODE = 1)
  6. Clear PERIODIC_CALIB_ENABLE_MASK and set CALIBRATION_PERIODICITY to 0 to avoid run time calibration (Automated run time calibration is not recommended in cascade mode)
  7. When stopping the frames in master it is recommended to stop Slaves first and wait of frame stop AE then stop the master.
  8. Follow API based monitor trigger notes in rlMonTypeTrigConfig API section
  9. Set TRIGGER_SELECT = 1 in master device and TRIGGER_SELECT = 2 in slave device in rlSetFrameConfig or rlSetAdvFrameConfig API.

Continuous streaming mode (in single device case)

  1. Power up the device
  2. Wait for AWR_AE_MSSPOWERUPDONE_SB
  3. Wait for AWR_AE_MSS_BOOTERRORSTATUS_SB if flash is not connected (Boot over SPI)
  4. AWR_DEV_CONFIGURATION_SET_SB
  5. AWR_DEV_RFPOWERUP_SB
  6. Wait for AWR_AE_RFPOWERUPDONE_SB
  7. AWR_RF_STATIC_CONF_SET_MSG
    • AWR_RF_DEVICE_CFG_SB
    • AWR_CHAN_CONF_SET_SB
    • AWR_ADCOUT_CONF_SET_SB
    • AWR_RF_LDO_BYPASS_SB with RFLDOBYPASS_EN set to 1 if RF supply is 1.0 V
    • AWR_LOWPOWERMODE_CONF_SET_SB
    • AWR_DYNAMICPOWERSAVE_CONF_SET_SB
    • AWR_CAL_MON_FREQUENCY_TX_POWER_LIMITS_SB
    • AWR_RF_RADAR_MISC_CTL_SB if per chirp phase shifter and Advance chirp configuration needs to be enabled.
    • AWR_APLL_SYNTH_BW_CONTROL_SB
  8. Data path configurations
    • AWR_DEV_RX_DATA_FORMAT_CONF_SET_SB
    • AWR_DEV_RX_DATA_PATH_CONF_SET_SB
    • AWR_DEV_RX_DATA_PATH_LANE_EN_SB
    • AWR_DEV_RX_DATA_PATH_CLK_SET_SB
    • AWR_HIGHSPEEDINTFCLK_CONF_SET_SB
    • AWR_DEV_LVDS_CFG_SET_SB / AWR_DEV_CSI2_CFG_SET_SB
  9. AWR_RF_INIT_MSG
    • AWR_PHASE_SHIFTER_CAL_DATA_RESTORE_SB (To restore factory calibration data for TX0), keep CAL_APPLY = 0
    • AWR_PHASE_SHIFTER_CAL_DATA_RESTORE_SB (To restore factory calibration data for TX1), keep CAL_APPLY = 0
    • AWR_PHASE_SHIFTER_CAL_DATA_RESTORE_SB (To restore factory calibration data for TX2), keep CAL_APPLY = 1
    • AWR_CAL_DATA_RESTORE_SB (To restore factory calibration data to avoid on field RF interference during calibration)
    • Wait for AWR_AE_RF_INITCALIBSTATUS_SB
    • AWR_RF_INIT_CALIBRATION_CONF_SB (Enable only required calibration to run)
    • AWR_RFINIT_SB: This triggers very basic calibrations and RF initializations
    • Wait for AWR_AE_RF_INITCALIBSTATUS_SB
  10. AWR_RF_DYNAMIC_CONF_SET_MSG
    • AWR_PROG_FILT_COEFF_RAM_SET_SB
    • AWR_PROG_FILT_CONF_SET_SB
  11. AWR_CONT_STREAMING_MODE_EN_SB to start the trigger
    • AWR_CONT_STREAMING_MODE_CONF_SET_SB
    • AWR_DEV_RX_CONTSTREAMING_MODE_CONF_SET_SB
    • AWR_CONT_STREAMING_MODE_EN_SB with CONT_STREAMING_EN = 0x0001 to start continuous streaming
  12. AWR_CONT_STREAMING_MODE_EN_SB to stop the trigger
    • AWR_CONT_STREAMING_MODE_EN_SB with CONT_STREAMING_EN = 0x0000 to stop continuous streaming

Continuous streaming (CW) mode (in cascaded device case)

Continuous streaming (CW) mode (cascaded)
S NoMaster Device SequenceSlave Device Sequence
1Power up master device
2Wait for AWR_AE_DEV_MSSPOWERUPDONE_SB
3AWR_DEV_RFPOWERUP_SB
4Wait for AWR_AE_DEV_RFPOWERUPDONE_SB
5AWR_CHAN_CONF_SET_SB with CASCADING_CFG = 0x0001. The reference clock for slave device is enabled by default
6Power on slave device
7Wait for AWR_AE_DEV_MSSPOWERUPDONE_SB
8AWR_DEV_RFPOWERUP_SB
9Wait for AWR_AE_DEV_RFPOWERUPDONE_SB
10AWR_CHAN_CONF_SET_SB with CASCADING_CFG = 0x0002 and disable OSC CLOCK OUT.
11Follow all AWR_RF_STATIC_CONF_SET_MSG APIs sequence as instructed in single chip mode, please refer application Care Abouts above if any deviation from single chipFollow all AWR_RF_STATIC_CONF_SET_MSG APIs sequence as instructed in single chip mode, please refer application Care Abouts above if any deviation from single chip
12Follow all Data path configurations APIs sequence as instructed in single chip modeFollow all Data path configurations APIs sequence as instructed in single chip mode
13Follow all AWR_RF_INIT_MSG APIs sequence as instructed in single chip modeFollow all AWR_RF_INIT_MSG APIs sequence as instructed in single chip mode
14Follow all AWR_RF_DYNAMIC_CONF_SET_MSG APIs sequence as instructed in single chip mode, please refer application Care Abouts above if any deviation from single chipFollow all AWR_RF_DYNAMIC_CONF_SET_MSG APIs sequence as instructed in single chip mode, please refer application Care Abouts above if any deviation from single chip
15AWR_CONT_STREAMING_MODE_CONF_SET_SB
16AWR_CONT_STREAMING_MODE_EN_SB with CONT_STREAMING_EN = 0x0001 to start continuous streaming
17AWR_CONT_STREAMING_MODE_CONF_SET_SB with the same RF frequency configuration as in master device
18AWR_CONT_STREAMING_MODE_EN_SB with CONT_STREAMING_EN = 0x0001 to start continuous streaming
19AWR_CONT_STREAMING_MODE_EN_SB with CONT_STREAMING_EN = 0x0000 to stop continuous streaming
20AWR_CONT_STREAMING_MODE_EN_SB with CONT_STREAMING_EN = 0x0000 to stop continuous streaming
21Repeat steps 6-20 for a different CW mode configuration

Below is the list of calibrations and corresponding duration in microseconds
Boot Time Calibration

Calibration Duration
Calibration Duration(us)
APLL500
Synth VCO2500
LO DIST1500
ADC DC 600
HPF cutoff 3500
LPF cut off 200
Peak detector7000
TX power (for each TX)2000
RX gain 1500
TX phase (for each TX)12000
RX IQMM42000

Run Time Calibration The Calibration Total duration is consist of two components,

  1. Critical calibration chirp time, this is fixed to 145 us. Each calibration can have multiple critical chirps to complete the task, the total critical time captured in below table. The critical tasks are done in chunks of 145 us, refer interBurstTime for more info.
  2. Non critical setup and processing time, this is a variable component specific to each calibration, the total calibration duration captured in below table = total critical time + non critical time. Note that the User has to ensure the total idle time in one CAL_MON_TIME_UNIT is sufficient to fit the enabled calibrations.
    Calibration Duration
    Calibration Total Duration(us)Total Critical Time(us)
    APLL150145
    Synth VCO300290
    LO DIST300
    Peak detector600580
    TX power CLPC (for each TX and for 1 profile)800580
    TX power OLPC (In case CLPC is disabled)300
    RX gain 300
    Application of calibration to hardware (This needs to be included always) 5050

Chirp, Burst and Frame timings

AWR2243 device minimum chirp cycle time, inter-burst time, inter sub-frame/frame time requirements are documented in this section.

Chirp Cycle Time

Minimum chirp cycle time
Use case Min Chirp cycle time(us)Description
Typical chirps13The normal chirps used in a burst or a frame using legacy chirp configuration API
Advance chirps25The advance chirps used in a burst or a frame using advanced chirp configuration API
Chirps in Continuous framing mode20A single advance chirp used in a burst using either normal legacy chirp or advanced chirp configuration API. Continuous framing mode is a mode in which a single chirp is programmed in a burst using advanced frame configuration API. In this mode it is recommended to set idle time of chirp minimum 10us to save Inter chirp power save override time (Refer below table)

Minimum Inter Burst Time

Minimum Inter Burst Time
Min inter burst time Time(us)Description
Typical inter burst time55The minimum inter burst idle time required in normal bursts with legacy chirps configured in a advanced frame configuration API with inter burst power save disabled.
Inter burst power save time55Add inter burst power save time to minimum inter burst time if it is enabled. By default inter-burst power save is enabled, it can be disabled (Only in single chip mode) using rlRfSetDeviceCfg API
Inter chirp power save override time (power save disable)15Add inter chirp power save override time to minimum inter burst time if chirp idle time < 10us in a burst or can be controlled using rlRfDynamicPowerSave API
Advance chirp configuration time45Add advance chirp configuration time to minimum inter burst time if advance chirp configuration is enabled in rlRfSetMiscConfig API. Not applicable for Continuous framing mode (Refer below).
Advance chirp configuration time (Continuous framing mode)30Add Continuous framing mode advance chirp configuration time to minimum inter burst time if advance chirp configuration is enabled in rlRfSetMiscConfig API. Continuous framing mode is a mode in which a single chirp is programmed in a burst using advanced frame configuration API.
Normal chirps (Continuous framing mode)10Add Continuous framing mode normal chirp configuration time to minimum inter burst time. Continuous framing mode is a mode in which a single chirp is programmed in a burst using advanced frame configuration API.
Calibration or Monitoring chirp time145Add calibration or Monitoring chirp time to minimum inter burst time if calibration or monitors intended to be run in inter burst idle time. The calibration and monitoring chirps can run only in inter sub-frame or inter-frame interval if this time is not allocated in inter-burst time. Add calibration or Monitoring duration to minimum inter burst or sub-frame/frame time.

Minimum Inter Sub-frame or Frame Time

Minimum Inter Sub-frame or Frame Time
Min inter subframe/frame timeTime(us)Description
Typical inter subframe/frame time300The minimum inter sub-frame/frame idle time required in normal sub-frames with legacy chirps configured in a advanced frame configuration API or in a legacy frame config API. This time includes time required for minimum inter-burst idle time, inter burst power save, inter chirp power save override and single calibration/monitoring chirp time.
Advance chirp configuration time45Add advance chirp configuration time to minimum inter sub-frame/frame time if advance chirp configuration is enabled in rlRfSetMiscConfig API
Calibration or Monitoring durationTable 12.4 and Table 12.8Add calibration or Monitoring duration to minimum inter sub-frame/frame time based on Table 12.4 and Table 12.8
Loop-back burst configuration time300Add Loop-back burst configuration time to minimum inter sub-frame time for loop back sub-frames if it is enabled in advance frame config API
Dynamic legacy chirp configuration time (for 16 chirps)20 for 16 chirps + 500Add dynamic legacy chirp configuration time to minimum inter frame time if dynamic chirp/phase-shifter APIs are issued in runtime.
Dynamic advance chirp configuration time (without LUT)500Add dynamic advance chirp configuration time to minimum inter frame time if dynamic advance chirp API is issued in runtime. The dynamic update of advance chirp generic LUT is done immediately when the API is received at BSS and there is no impact to inter frame time, however user has to take care of timing of the LUT update as it should not corrupt the ongoing chirp configuration.
Dynamic profile configuration time (for 1 profile)1200Add dynamic profile configuration time to minimum inter frame time if dynamic profile API is issued in runtime.
Test source config time170Add test source configuration time to minimum inter sub-frame time if test source API is issued.

Typical APLL and Synth BW settings

Typical APLL and Synth BW settings
SYNTH_ICP_TRIMSYNTH_RZ_TRIMAPLL_ICP_TRIMAPLL_RZ_TRIMVCO1_BWVCO2_BW APLL_BWDescriptionMax VCO Slope (MHz/us)
180x260x9750K1.5M150KDefault settings (+/-0.2% Ferror at 2us ADC start)266
380x260x9375K750K150KOptimum for 76-77GHz VCO1 (1M, 10M PN) 100
080x260x91.3M2.6M150KSynth High BW (+/-0.2% Ferror at 1us ADC start)266
380x3F0x9375K1.5M300KOptimum 100K PN100

Programmable filter DFE sampling rate and number of taps

Programmable filter DFE sampling rate and number of taps
DFE sampling rate Fs (Msps)No of taps in Real ModeNo of taps in Complex Mode
>=2542NA
>=12.5, <254221
>=6.25, <12.56345
Else6363
 Related Files
- rl_sensor.c

Function Documentation

◆ rlEnableContMode()

rlReturnVal_t rlEnableContMode ( rlUInt8_t  deviceMap,
rlContModeEn_t data 
)

Enable/Disable Continous mode.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Continous Mode enable/disable
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function enables/disables the FMCW radar continous mode

Definition at line 1351 of file rl_sensor.c.

◆ rlFrameStartStop()

rlReturnVal_t rlFrameStartStop ( rlUInt8_t  deviceMap,
rlFrameTrigger_t data 
)

Triggers/Stops Transmission of Frames.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Container for Frame trigger Configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function triggers/stops the transmission of the frames as per the frame and chirp configuration. If trigger mode is selected as SW API based trigger, mmWaveFront end would start chirp immediately after receiving this API. If trigger mode is HW SYNC IN pulse, it would wait for SYNC pulse

Note
1: Once the chirping starts, mmWave Front end would send asynchronous event RL_RF_AE_FRAME_TRIGGER_RDY_SB indicating the start of frame
2: Once the chirping stops, mmWave Front end would send asynchronous event RL_RF_AE_FRAME_END_SB indicating the stop of frame
3: When Frame Stop command with 'option-0' is sent to RadarSS, the frame will be stopped after completing all the chirps of a Frame/Advance frame (sub-frames).
4: In non periodic Hw triggered mode or in sub-frame triggered mode, if frame needs to be stopped immediately then frame stop command with 'option-4' can be used. The 'option-4' can not be used when active frames are running.
5: Recommended to re-issue frame configuration API if frame is not stopped at sub-frame boundary, this is to re-config CSI2 or LVDS data path configuration in MSS.

Definition at line 1555 of file rl_sensor.c.

◆ rlGetAdvFrameConfig()

rlReturnVal_t rlGetAdvFrameConfig ( rlUInt8_t  deviceMap,
rlAdvFrameCfg_t data 
)

Gets Advance Frame Configuration.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[out]data- Container for Advance Frame Configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function reads the advance frame properties of the device. This API calls internally two APIs, one to RadraSS for sensor configuraion and another to MasterSS for datapath configuraion.

Definition at line 1238 of file rl_sensor.c.

◆ rlGetChirpConfig()

rlReturnVal_t rlGetChirpConfig ( rlUInt8_t  deviceMap,
rlUInt16_t  chirpStartIdx,
rlUInt16_t  chirpEndIdx,
rlChirpCfg_t data 
)

Gets Chirp Configuration.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]chirpStartIdx- Chirp Start Index
[in]chirpEndIdx- Chirp End Index
[out]data- Container for Chirp Configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function gets the chirp configuration from the device.

Definition at line 722 of file rl_sensor.c.

◆ rlGetFrameConfig()

rlReturnVal_t rlGetFrameConfig ( rlUInt8_t  deviceMap,
rlFrameCfg_t data 
)

Gets Frame Configuration.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[out]data- Container for Frame Configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function reads the frame properties of the device. This API calls internally two APIs, one to RadraSS for sensor configuraion and another to MasterSS for datapath configuraion.

Definition at line 1078 of file rl_sensor.c.

◆ rlGetProfileConfig()

rlReturnVal_t rlGetProfileConfig ( rlUInt8_t  deviceMap,
rlUInt16_t  profileId,
rlProfileCfg_t data 
)

Gets Chirp profile Configuration.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]profileId- Profile Id
[out]data- Container for Profile Configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function gets the FMCW radar chirp properties like FMCW slope, chirp duration, TX power etc. from the device.

Definition at line 522 of file rl_sensor.c.

◆ rlGetRfBootupStatus()

rlReturnVal_t rlGetRfBootupStatus ( rlUInt8_t  deviceMap,
rlRfBootStatusCfg_t data 
)

Get radarSS bootup status.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- bootup status configuration
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API gets the radarSS bootup status

Definition at line 3416 of file rl_sensor.c.

◆ rlGetRfDieId()

rlReturnVal_t rlGetRfDieId ( rlUInt8_t  deviceMap,
rlRfDieIdCfg_t data 
)

Get device die ID status.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[out]data- Die ID status
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API gets the device Die ID status

Definition at line 3714 of file rl_sensor.c.

◆ rlMonTypeTrigConfig()

rlReturnVal_t rlMonTypeTrigConfig ( rlUInt8_t  deviceMap,
rlMonTypeTrigCfg_t data 
)

Maintains monitoring timing synchronization in cascaded devices to avoid mutual interference of monitors running in different devices in the cascade sensor.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- structure contains monitor trigger type configs
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API helps to maintain monitoring timing synchronization in cascaded devices to avoid mutual interference of monitors running in different devices in the cascade sensor.
The host must trigger the monitor of types below to avoid interference if MONITORING MODE is set to ’1’ in AWR_CALIB_MON_TIME_UNIT_CONF_SB.
The AWR_AE_RF_MONITOR_TYPE_TRIGGER_DONE_SB_AE will be sent once monitor type is executed
The monitors can be categorized into 3 types :
Monitor Types Description Type 0 Non-transmitting monitor, The execution of non-transmitting monitors does not cause RF interference to monitors executing on other devices. Therefore, they can be executed in parallel across all devices in the cascade. These include monitors which receive a test signal through RX LNA and digital monitors.
Type 1 Transmitting but not receiving (test signal), The monitors that transmit but don’t receive any test signal through RX LNA are not susceptible to interference. Therefore, they can be executed in parallel across all devices in the cascade, but not when monitors that receive test signals through RX LNA are executing.
Type 2 Transmitting and receiving (test signal), The monitors that transmit and also receive test signal through RX LNA are susceptible to interference. They can be executed sequentially so as to create time separation between monitoring chirps of different devices

Note
1: This is a new feature addition in AWR2243.
2: The Host can trigger all 3 types of monitor at same time or can trigger each type one after other based on system requirement, in case host is triggering monitor types one after other, then it is recommended to follow order type 0, type 1 and type 2 respectively.
3: The Host must wait for AWR_AE_RF_MONITOR_TYPE_TRIGGER_DONE_SB_AE before issuing trigger for next monitor type.
4: The Host must ensure all types of monitors are executed within defined device FTTI interval, otherwise device can not finish all the monitors within FTTI and will report failure AE_AWR_CAL_MON_TIMING_FAIL_REPORT_AE_SB

Definition at line 3964 of file rl_sensor.c.

◆ rlRfApllSynthBwCtlConfig()

rlReturnVal_t rlRfApllSynthBwCtlConfig ( rlUInt8_t  deviceMap,
rlRfApllSynthBwControl_t data 
)

Control bandwidth of the APLL and Synthesizer.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- APLL and Synthesizer B/W control data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API is used to control bandwidth of the APLL and Synthesizer

Note
1 : This API is supported only in AWR2243.
2 : Recommended to issue this API before rlRfInit API. The RF_INIT synthesizer boot calibration shall run after changing the APLL BW.

Definition at line 4009 of file rl_sensor.c.

◆ rlRfCalibDataRestore()

rlReturnVal_t rlRfCalibDataRestore ( rlUInt8_t  deviceMap,
rlCalibrationData_t data 
)

Injects calibration data to the device.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Calibration data of 3 chunks stored at application space
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API restores the calibration data which was stored previously using the rlCalibDataStore command. Application needs to feed in 3 chunks of calibration data. recommended API sequence for calibration data restore is:

  1. rlRfCalibDataRestore (To restore factory calibration data to avoid on field RF interference during calibration)
  2. Wait for RL_RF_AE_INITCALIBSTATUS_SB event.
  3. rlRfInitCalibConfig (Enable only required calibration to run)
  4. rlRfInit: This triggers very basic calibrations and RF initializations.
  5. Wait for RL_RF_AE_INITCALIBSTATUS_SB event.
    Note
    1: Once the calibration data is restored properly in radarSS SW RAM and validated, mmWave Front end would send asynchronous event RL_RF_AE_INITCALIBSTATUS_SB indicating the result of the calibrations based on Calib data sent by the application, this indicates success of the calibration data restore.
    2: All 3 chunks of 224 bytes each shall be sent to radar device to complete the restore process and to generate RL_RF_AE_INITCALIBSTATUS_SB.

Definition at line 3218 of file rl_sensor.c.

◆ rlRfCalibDataStore()

rlReturnVal_t rlRfCalibDataStore ( rlUInt8_t  deviceMap,
rlCalibrationData_t data 
)

Read calibration data from the device.

Parameters
[in]deviceMap- Bitmap of devices to send the message.
[in]data- Calibration data of 3 chunks which will filled by device.
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API reads the calibration data from the device which can be injected later using the rlCalibDataRestore command. RadarSS will return 3 chunks of calibration data.

Note
1: The total size of the calibration data is 672 bytes, this has been split into 3 chunks (numOfChunk)of 224 bytes each due to SPI limitation. The Host should receive all these 3 chunks from radar device, later host can store only relevant data in non volatile memory.
2: Before storing the calibration data in non volatile memory, the host shall make sure validity status of all enabled calibrations are SET to value 1 including APLL, VCO1, VCO2 and LODIST calibration validity in rlRfInit of radar device.
3: Host can store only relevant calibration data in non volatile memory and corresponding validity bits shall be set to 1 in rlRfCalibDataRestore and rest of the validity bits should be clear to 0 before restoring the data to radar device.
4: Host shall ignore APLL, VCO1, VCO2 and LODIST calibration validity bits while restoring, these calibrations will be done in each device power-up.

Definition at line 3300 of file rl_sensor.c.

◆ rlRfDfeRxStatisticsReport()

rlReturnVal_t rlRfDfeRxStatisticsReport ( rlUInt8_t  deviceMap,
rlDfeStatReport_t data 
)

Gets Digital Front end statistics such as Residual DC, RMS power in I and Q chains for different Receive channels for different selected profiles. It also includes Cross correlation between I and Q chains.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Container of dfe receiver status report
Returns
rlReturnVal_t Success - 0, Failure - Error Code

Gets Digital Front end statistics such as Residual DC, RMS power in I and Q chains for different Receive channels for different selected profiles. It also includes Cross correlation between I and Q chains

Definition at line 1780 of file rl_sensor.c.

◆ rlRfDynamicPowerSave()

rlReturnVal_t rlRfDynamicPowerSave ( rlUInt8_t  deviceMap,
rlDynPwrSave_t data 
)

: Configure dynamic power saving feature.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Container of dynamic power save information
Returns
rlReturnVal_t Success - 0, Failure - Error Code

Configure dynamic power saving feature during Inter chirp Idle time by turning off various circuits such as Transmitter, Receiver and LO distribution blocks

Note
1: whether to enable dynamic power saving during inter-chirp IDLE times by turning off various circuits e.g. TX, RX, LO Distribution blocks. If Idle time + Tx start time < 10us or Idle time < 3.5us then inter-chirp dynamic power save option will be disabled, in that case, 15us of inter-burst idle time will be utilized to configure sequencer LO, TX and RX signal timings by firmware.
2: All the 3 configuration bits (TX, RX and LO) should have same value, i.e. user should program value 0x7 to enable power save or 0x0 to disable the power save in blkCfg.

Definition at line 1829 of file rl_sensor.c.

◆ rlRfGetCpuFault()

rlReturnVal_t rlRfGetCpuFault ( rlUInt8_t  deviceMap,
rlCpuFault_t data 
)

Get RadarSS CPU fault status.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Container for RadarSS CPU fault status
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API gets the RadarSS CPU fault status.

Definition at line 3747 of file rl_sensor.c.

◆ rlRfGetEsmFault()

rlReturnVal_t rlRfGetEsmFault ( rlUInt8_t  deviceMap,
rlBssEsmFault_t data 
)

Get RadarSS ESM fault status.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Container for RadarSS ESM fault status
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API gets the RadarSS ESM fault status.

Definition at line 3786 of file rl_sensor.c.

◆ rlRfGetTemperatureReport()

rlReturnVal_t rlRfGetTemperatureReport ( rlUInt8_t  deviceMap,
rlRfTempData_t data 
)

Gets Time and Temperature information report.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[out]data- Structure to store temperature report from all the temp sensors
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function reads Temperature information from all temperature sensors in the device

Definition at line 1738 of file rl_sensor.c.

◆ rlRfInit()

rlReturnVal_t rlRfInit ( rlUInt8_t  deviceMap)

Initializes the RF/Analog Subsystem.

Parameters
[in]deviceMap- Bitmap of devices to send the message
Returns
rlReturnVal_t Success - 0, Failure - Error Code

Initializes the RF/Analog Subsystem. This triggers one time calibrations for APLL and synthesizer. Calibration can be enabled/disabled using Calibraton configuration APIs. Device will turn on Tx/Rx and components for the calibration which will cause higher curent consumption momenterily.

Note
1: Once the calibration is complete, mmWave Front end would send asynchronous event RL_RF_AE_INITCALIBSTATUS_SB indicating the result of the initialization/calibrations. Application needs to wait for this Async event message before calling next APIs.
2: The following boot-time calibrations are susceptible to corruption by interference. The calibrations may result in false configuration of the RF analog sections due to corruption by interference during the calibration measurements.
a. RX gain calibration (susceptible to interference)
b. RX IQMM calibration (susceptible to interference)
c. TX Phase calibration (susceptible to interference)
It is recommended to perform factory calibration and store the calibration data in non volatile memory using rlRfCalibDataStore. This data can be restored to radar device using rlRfCalibDataRestore API.
3: It is not recommended to issue this API in runtime multiple times. This API shall be issued only once after power cycle with or without calibration data restore operation.

Definition at line 1611 of file rl_sensor.c.

◆ rlRfInitCalibConfig()

rlReturnVal_t rlRfInitCalibConfig ( rlUInt8_t  deviceMap,
rlRfInitCalConf_t data 
)

Set RF Init Calibration Mask bits and report type.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- RF Init calib config
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function configures RF Init calibration mask bits and report type. Normally, upon receiving rlRfInit API, the Radar SS performs all relevant initial calibrations. This step can be disabled by setting the corresponding bit in rlRfInitCalConf_t field to 0x0.If disabled, the host needs to send the calibration data using rlRfCalibDataRestore so that the RadarSS can operate using the injected calibration data

Note
1 : Each of these calibrations can be selectively disabled by issuing this message before rlRfInit API.
2 : The APLL, SYNTH1 and SYNTH2 calibrations are always triggred by default on RF init command.

Definition at line 2523 of file rl_sensor.c.

◆ rlRfInterRxGainPhaseConfig()

rlReturnVal_t rlRfInterRxGainPhaseConfig ( rlUInt8_t  deviceMap,
rlInterRxGainPhConf_t data 
)

Sets different Rx gain/phase offset.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Inter RX gain, phase offset config
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API can be used to compensate various RX and gain/phase offsets and same API can be used to estimation the same using TX frequency shift.

Note
1: This API is supported only on AWR2243 device. Please refer latest DFP release note for more info.
2: Issue this API first in the sequence before rlSetProfileConfig API.
3: The Digital TX frequency shift enable mode in below API is for debug purpose only, the functional phase shifter will not be operational when this mode is used. It is recommended to re-issue profile config API after disabling this mode before running functional frames.
4: An application for the digital delay compensation field may be to digitally compensate for linear IF frequency dependent phase mismatch (e.g. mismatch across devices in cascaded operation, caused by DIG_SYNC_IN path mismatches). The residual phase error can be up to +/-0.5 degree.

Definition at line 3382 of file rl_sensor.c.

◆ rlRfPhShiftCalibDataRestore()

rlReturnVal_t rlRfPhShiftCalibDataRestore ( rlUInt8_t  deviceMap,
rlPhShiftCalibrationData_t data 
)

Injects phase shifter calibration data to the device.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Calibration data of number of TX channels enabled chunks stored at application space
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API restores the phase shifter calibration data which was stored previously using the rlRfPhShiftCalibDataStore command. Application needs to feed number of TX channels enabled chunks of phase shifter calibration data. This is device specific feature, please refer data sheet.

Note
1: The resulting buffer should hold data for all 3 TX channels even if only 2 or 1 TX channels are enabled. The buffer should have the data in the order of TX0, TX1 and TX2.

Definition at line 3553 of file rl_sensor.c.

◆ rlRfPhShiftCalibDataStore()

rlReturnVal_t rlRfPhShiftCalibDataStore ( rlUInt8_t  deviceMap,
rlPhShiftCalibrationData_t data 
)

Read calibration data from the device.

Parameters
[in]deviceMap- Bitmap of devices to send the message.
[in]data- Phase shift calibration data of number of TX channels enbled chunks which will filled by device.
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API reads the phase shifter calibration data from the device which can be injected later using the rlRfPhShifterCalibDataRestore command. RadarSS will return number of TX chunks of phase shifter calibration data.This is device specific feature, please refer data sheet.

Note
1: The application is expected to memset the rlPhShiftCalibrationData_t structure to zero and hand over that buffer to mmwavelink.
2: The resulting buffer will contain data for all 3 TX channels even if only 2 or 1 TX channels are enabled. The buffer contains the data in the order of TX0, TX1 and TX2.

Definition at line 3639 of file rl_sensor.c.

◆ rlRfRunTimeCalibConfig()

rlReturnVal_t rlRfRunTimeCalibConfig ( rlUInt8_t  deviceMap,
rlRunTimeCalibConf_t data 
)

Set RF one time & periodic calibration of various RF/analog aspects and trigger.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Runtime calibration config
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function configures RF one time & periodic calibration of various RF/analog aspects and trigger. The response is in the form of an asynchronous event. The calibration would be performed by Radar SS during while framing during inter-burst idle time slot of 250uS.

Note
1: This API must be called after rlSetProfileConfig
2: This API should be issued when the device is not framing.
3: This API can be issued when the device is framing, the calibration periodicity update or one time calibrations can be done while frames are running.
4: In case of single frame configured in frame config API then set CALIB_MON_TIME_UNIT to one to run all monitors. It is recommended to use ONE_TIME_CALIB_ENABLE_MASK in AWR_RUN_TIME_CALIBRATION_CONF_AND_TRIGGER_SB API to run one shot calibrations before frame trigger in single frame case.
5: The CAL_TEMP_INDEX_OVERRIDE_ENABLE is supported only for one time calibrations enabled using ONE_TIME_CALIB_ENABLE_MASK, the periodic run time calibrations are recommended to be disabled using PERIODIC_CALIB_ENABLE_MASK.

Definition at line 2575 of file rl_sensor.c.

◆ rlRfSetCalMonFreqLimitConfig()

rlReturnVal_t rlRfSetCalMonFreqLimitConfig ( rlUInt8_t  deviceMap,
rlRfCalMonFreqLimitConf_t data 
)

Set Calibration monitoring Frequency Limit.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- RF Calib Frequency Limit config
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function configures limits on RF frequency transmission during calibration and monitoring

Note
1 : The minimum RF bandwidth shall be set to 200MHz, this is to perform internal calibration and monitoring
2 : The limit set in this API is not applicable for functional chirps and loop-back chirps used in advanced frame config API.
3 : The TX0 frequency limit is used by default in calibrations and monitors where TX is not relevant or enabled.
4 : The RF band used in functional chirp profiles shall be within the limit set in this API.

Definition at line 2475 of file rl_sensor.c.

◆ rlRfSetCalMonTimeUnitConfig()

rlReturnVal_t rlRfSetCalMonTimeUnitConfig ( rlUInt8_t  deviceMap,
rlRfCalMonTimeUntConf_t data 
)

Set Calibration monitoring time unit.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- RF Calib Monitoring Time unit config
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function configures calibration monitoring time unit

Note
1: The Minimum total blank time in a calibMonTimeUnit shall be 1ms to run internal APLL and SYNTH calibrations + ~12.5% of calibMonTimeUnit for WDT clearing time if WDT is enabled.
2: Refer to AnalogMonitoringDuration, DigitalMonitoringDuration for the duration of run time monitors and SoftwareOverheads for software overheads.
3: The CALIB_MON_TIME_UNIT is applicable for one frame trigger API. Once frame is stopped then FTTI will reset, CALIB_MON_TIME_UNIT is not applicable across multiple SW frame trigger API.
4: In case of single frame configured in frame config API then set CALIB_MON_TIME_UNIT to one to run all monitors. It is recommended to use ONE_TIME_CALIB_ENABLE_MASK in AWR_RUN_TIME_CALIBRATION_CONF_AND_TRIGGER_SB API to run one shot calibrations before frame trigger in single frame case.

Definition at line 2424 of file rl_sensor.c.

◆ rlRfSetDeviceCfg()

rlReturnVal_t rlRfSetDeviceCfg ( rlUInt8_t  deviceMap,
rlRfDevCfg_t data 
)

: Set different RadarSS device configurations

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Configuration parameter for AE.
Returns
rlReturnVal_t Success - 0, Failure - Error Code

Set different RadarSS device configurations. Enable and Configure asynchronous event direction for device. By default all asynchronous event are enabled and sent to the platform which issued the API. Below events can be configured to be received on different platform by using this API:
[1.] CPU_FAULT [2.] ESM_FAULT [3.] ANALOG_FAULT Similarly all monitoring events can be configured to be received on specific platform using this API Below events can be disabled using this API:
[1.] FRAME_START_ASYNC_EVENT [2.] FRAME_STOP_ASYNC_EVENT
Enable[1]/Disable[0] RadarSS Watchdog, where by default it is disable. Configure CRC type for asynchronous event from RadarSS [0] 16Bit, [1] 32Bit, [2] 64Bit.

Definition at line 1879 of file rl_sensor.c.

◆ rlRfSetIFLoopbackConfig()

rlReturnVal_t rlRfSetIFLoopbackConfig ( rlUInt8_t  deviceMap,
rlRfIFLoopbackCfg_t data 
)

Enable/Disable RF IF loopback for all enabled profiles. This is used for debug to check if both TX and RX chains are working correctly.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- IF loopback configuration
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function Enables/Disables RF IF loopback for all enabled profiles. This is used to debug the RX IF chain.

Note
1: The IF loop-back configuration API is supported only for debug purpose. Please refer latest DFP release note for more info.

Definition at line 2238 of file rl_sensor.c.

◆ rlRfSetMiscConfig()

rlReturnVal_t rlRfSetMiscConfig ( rlUInt8_t  deviceMap,
rlRfMiscConf_t data 
)

Sets misc feature such as per chirp phase shifter.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Misc configuration such as per chirp phase shifter
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function enables misc feature such as per chirp phase shifter.This API is valid for devices for which phase shifter is enabled(AWR1243P, AWR2243, AWR1843).

Note
: Issue this API first in the sequence if rlRfSetPhaseShiftConfig, rlSetDynPerChirpPhShifterCfg and rlSetAdvChirpConfig are issued down in the sequence.

Definition at line 2372 of file rl_sensor.c.

◆ rlRfSetPALoopbackConfig()

rlReturnVal_t rlRfSetPALoopbackConfig ( rlUInt8_t  deviceMap,
rlRfPALoopbackCfg_t data 
)

Enable/Disable PA loopback for all enabled profiles.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- PA loopback configuration
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function Enables/Disables PA loopback for all enabled profiles. This is used for debug purpose that both the TX and RX paths are working properly

Note
1: The PA loop-back configuration API is supported only for debug purpose. Please refer latest DFP release note for more info.

Definition at line 2145 of file rl_sensor.c.

◆ rlRfSetPhaseShiftConfig()

rlReturnVal_t rlRfSetPhaseShiftConfig ( rlUInt8_t  deviceMap,
rlUInt16_t  cnt,
rlRfPhaseShiftCfg_t data 
)

Enable/Disable phase shift configurations per chirp in each of the TXs.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]cnt- Number of configurations
[in]data- phase shift enable/disable configuration
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function configures the static phase shift configurations per chirp in each of the TXs. This API is applicable only in certain devices (please refer data sheet). This API will be honored after enabling per chirp phase shifter in rlRfSetMiscConfig.

Note
1: Phase shifter(PS) settings are applied in advance at max -5us or at -(idleTimeConst-1.28us-DfeLagTime) from the knee of the ramp. If idle time > 6.28us, then PS is applied always at -5us and if idle time < 6.28us, then PS is applied at -(idleTimeConst-1.28us-DfeLagTime) from knee of the ramp. Where DfeLagTime is internal DFE lag time (Please refer rampgen calculator).
2: It is recommended to configure TX start time > -5us or -(idleTimeConst-1.28us-DfeLagTime) based on PS apply time.

Definition at line 2021 of file rl_sensor.c.

◆ rlRfSetProgFiltCoeffRam()

rlReturnVal_t rlRfSetProgFiltCoeffRam ( rlUInt8_t  deviceMap,
rlRfProgFiltCoeff_t data 
)

Set Programmable Filter coefficient RAM.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- array of coefficients for the programmable filter
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function is used to program the coefficients for the external programmable filter. This is a new feature added in AWR2243.

Note
1: The programmable filter allow for a trade-off between digital filter chain settling time and close-in anti-alias attenuation. The Maximum DFE outout sampling rate in real mode is 25Msps and in complex mode is 22.5Msps.
A real-coefficient FIR with up to 63 taps (16-bit coefficients) is supported in both Complex and real output mode.
2: Please refer Table ProgFiltSettings for details on Programmable filter DFE sampling rate and number of taps.
3: This API should be issued before rlSetProfileConfig.
4: This API should not be issued when frames are ongoing.

Definition at line 2287 of file rl_sensor.c.

◆ rlRfSetProgFiltConfig()

rlReturnVal_t rlRfSetProgFiltConfig ( rlUInt8_t  deviceMap,
rlRfProgFiltConf_t data 
)

Set Programmable Filter configuration.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- programmable filter configuration
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function selects programmable filter cofficient RAM and map it to configured profile ID.

Note
1: This API should not be issued when frames are ongoing.

Definition at line 2329 of file rl_sensor.c.

◆ rlRfSetPSLoopbackConfig()

rlReturnVal_t rlRfSetPSLoopbackConfig ( rlUInt8_t  deviceMap,
rlRfPSLoopbackCfg_t data 
)

Enable/Disable Phase shift loopback for all enabled profiles.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Phase shift loopback configuration
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function Enables/Disables Phase shift loopback for all enabled profiles.This is used to debug the TX (before the PA) and RX chains.

Note
1: The PS loop-back configuration API is supported only for debug purpose. Please refer latest DFP release note for more info.
2: The expected signal strength change with change in index value is only approximately indicated for PS<n>_PGA_GAIN_INDEX. Typically, the loopback path is the dominant path only in top ~10 indices (highest PGA gain values). For lower indices (lower PGA gain values), parasitic paths in the RF system can start dominating the loop-back measurements, and under such conditions, inter channel imbalances measured using such LB path, and LB signal SNR etc. can show degraded performance, with the degradation attributed to the loop-back path and not the functional path/circuits/system.

Definition at line 2195 of file rl_sensor.c.

◆ rlRfTxFreqPwrLimitConfig()

rlReturnVal_t rlRfTxFreqPwrLimitConfig ( rlUInt8_t  deviceMap,
rlRfTxFreqPwrLimitMonConf_t data 
)

Sets the limits for RF frequency transmission for each TX and also TX power limits.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Tx Rf freq and power limit config data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API sets the limits for RF frequency transmission for each TX and also TX power limits.

Note
1 : The minimum RF bandwidth shall be set to 200MHz, this is to perform internal calibration and monitoring
2 : The limit set in this API is not applicable for functional chirps and loop-back chirps used in advanced frame config API.
3 : The TX0 frequency limit is used by default in calibrations and monitors where TX is not relevant or enabled.
4 : The RF band used in functional chirp profiles shall be within the limit set in this API.

Definition at line 2821 of file rl_sensor.c.

◆ rlRxGainTempLutSet()

rlReturnVal_t rlRxGainTempLutSet ( rlUInt8_t  deviceMap,
rlRxGainTempLutData_t data 
)

Overwrite RX gain temperature Lookup Table(LUT) in Radar SS.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- RX gain Temperature LUT config
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API can be used to overwrite the RX gain Lookup Table(LUT) for different temperature used in RadarSS.

Note
1 : This API should be issued after profile configuration API.

Definition at line 2616 of file rl_sensor.c.

◆ rlSensorStart()

rlReturnVal_t rlSensorStart ( rlUInt8_t  deviceMap)

Triggers Transmission of Frames.

Parameters
[in]deviceMap- Bitmap of devices to send the message
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function triggers the transmission of the frames as per the frame and chirp configuration If trigger mode is selected as SW API based trigger, mmWaveFront end would start chirp immediately after receiving this API. If trigger mode is HW SYNC IN pulse, it would wait for SYNC pulse

Note
1: Once the chirping starts, mmWave Front end would send asynchronous event RL_RF_AE_FRAME_TRIGGER_RDY_SB indicating the start of frame
2: This API might get deprecated in future releases. Refer to rlFrameStartStop API

Definition at line 1441 of file rl_sensor.c.

◆ rlSensorStop()

rlReturnVal_t rlSensorStop ( rlUInt8_t  deviceMap)

Stops Transmission of Frames.

Parameters
[in]deviceMap- Bitmap of devices to send the message
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function stops the transmission of the frames.

Note
1: Once the chirping stops, mmWave Front end would send asynchronous event RL_RF_AE_FRAME_END_SB indicating the stop of frame
2: When Frame Stop command is sent to RadarSS, the frame will be stopped after completing all the chirps of a Frame/Advance frame. In non periodic HW triggered mode if frame stop command is issued when HW pulses are paused (i.e after completing previous frame) then a HW pulse is required to trigger next frame/bursts and frame will be stopped at the end of this triggered frame. In HW triggered mode, the forced frame stop is not supported, the frame end command is honored only if frames are actively running.
3: This API might get deprecated in future releases. Refer to rlFrameStartStop API

Definition at line 1495 of file rl_sensor.c.

◆ rlSetAdcOutConfig()

rlReturnVal_t rlSetAdcOutConfig ( rlUInt8_t  deviceMap,
rlAdcOutCfg_t data 
)

Sets ADC Output Configuration.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Container for ADC Configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function sets the static device configuration for the data format of the ADC and digital front end output. This is RAW ADC samples of IF signal and needs to be processed by HW accelerator or DSP. The ADC data can be sent to external Processor over High Speed Interface such as LVDS or CSI2. The ADC data size supported are 12, 14 and 16 bits and supported formats are Real, Complex 1x and Complex 2x. In Complex 1x, Image band is filtered out and only signal band is sampled in ADC. Where as in Complex 2x, Both Image and Signal band is sampled.
Complex baseband architecture results in better noise figure and is recommended.

Note
At the same sampling frequency(Fs), Complex 1x would support IF bandwidth of Fs, where as real and complex 2x would provide IF bandwidth of upto Fs/2.

Definition at line 153 of file rl_sensor.c.

◆ rlSetAdvChirpConfig()

rlReturnVal_t rlSetAdvChirpConfig ( rlUInt8_t  deviceMap,
rlAdvChirpCfg_t data 
)

Set the Advanced chirp configuration to the device.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- structure contains adv-chirp configs
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API defines the programming of advanced chirp configurations for each chirp parameters to generate a waveform pattern in a frame/burst. It provides ability to program fixed delta increment (Delta dither) for certain chirp parameters (eg. chirp start frequency, idle time, phase shifter), on top of unique dithers selected from configurable look-up-table (LUT Dither). The configurable look-up-table is an array of values loaded into a pre-configured Generic SW Chirp Parameter LUT. The size of the generic LUT is 12kB and user has the flexibility to program any number of unique dithers for each chirp parameters. Thus the user can achieve fixed increment, or LUT based dither, or a combination of both.
When using the Advanced Chirp Config API, there are some implications to frame config and advanced frame config APIs. Specifically, the CHIRP_START_INDX and CHIRP_END_INDX fields are no longer applicable, and the NUM_LOOPS field has a different meaning in the sense that this field now denotes the total number of chirps in the frame/burst. Please refer AWR_FRAME_CONF_SET_SB and AWR_ADVANCED_FRAME_CONF_SB APIs with the updated field descriptions as below.
The total number of chirps L in a burst should be programmed as per below calculation in frame configuration API (using the NUM_LOOPS field).
L = X * Y, where X is 1 to 512 (supported HW CHIRP RAM) and Y is 1 to 128 (supported HW CHIRP LOOPS)
The value of L should be a multiple of 4 (assuming each chirp is min 25us duration) i.e 1, 4, 8, 12, 16, 20, 24 ¦ 32768 (max). The FW needs to prepare and update HW CHIRP RAM dynamically in advance chirp config API, this puts some restriction on minimum number of chirps in a burst/frame.
Using this API, four types of control can be achieved on each parameters of a chirp.

  1. Fixed value for all chirps: To generate sequence of chirps which never changes, then only one value can be programmed in LUT (LUT Dither), i.e NUM_OF_PATTERNS (P) = 1 and LUT_PARAM_UPDATE_PERIOD (K) = 0
  2. Unique chirps: Index every LUT_PARAM_UPDATE_PERIOD (K) chirps in LUT to generate unique sequence of chirps.
  3. Delta increment every DELTA_PARAM_UPDATE_PERIOD (N) chirps: On top of sequence of unique chirps from LUT, the fixed delta increment (Delta dither) can be done every N chirps.
  4. The set of chirp parameters across bursts and sub-frames can be different by setting offset to LUT in BURST_LUT_INDEX_OFFSET and SF_LUT_INDEX_OFFSET.
    Note
    1 : The Legacy rlSetChirpConfig, rlSetDynChirpCfg, rlRfSetPhaseShiftConfig , rlSetDynPerChirpPhShifterCfg and rlSetBpmChirpConfig APIs are not supported if device is configured with Advanced Chirp Config API enabled in AWR_RF_RADAR_MISC_CTL_SB or vice versa.
    2 : The per chirp phase shifter and BPM configurations are part of this API.
    3 : The parameters in this API are not applicable to loop-back sub-frames rlSetLoopBckBurstCfg. If loop-back sub-frames are needed, it is recommended to be configured in the last sub-frame (SF) of rlSetAdvFrameConfig API.
    4 : The dynamic update of this API is allowed at frame boundary along with the Generic SW Chirp Parameters, as long as the LUT addresses modified differ from the addresses used in the current ongoing frame. The dynamic chirp enable API AWR_DYN_CHIRP_ENABLE_SB shall be issued at least 500us before end of current active window of frame (500us before start of idle time of the frame) to apply the dynamic configurations in immediate next frame.
    5 : If fixed delta dither is used to generate the pattern then it is recommended to program same start frequency in profile config API for each chirps in a frame. Each chirp can have different profiles associated with it except start frequency.
    6 : The number of chirps programmed in a burst/frame shall be multiple of 4.
    Exception: a single chirp can be programmed in a burst.
    7 : The RF frequency used for measurement in monitors are derived only from profile settings (start frequency and slope) and not from the advance chirp configuration API, if fixed delta increment is used to change the start frequency every chirp, it is recommended to have a separate profile for monitors which covers full RF bandwidth of interest.
    8 : All the fields in this API are specific to selected CHIRP_PARAM_INDEX in this API, this API needs to be programmed ten times for each of the chirp parameters defined in CHIRP_PARAM_INDEX field in below API.
    9 : The Delta Dither is optional and can be disabled by setting DELTA_PARAM_UPDATE_PERIOD (N) = 0 and SFn_CHIRP_PARAM_DELTA = 0.
    10: The LUT Dither is mandatory and at least one dither parameter value (it can be value zero) shall be programmed for all chirp parameters in generic LUT, same dither value can be programmed to all chirps in a burst/frame by setting LUT_PARAM_UPDATE_PERIOD (K) = 0.

Definition at line 3893 of file rl_sensor.c.

◆ rlSetAdvChirpDynLUTAddrOffConfig()

rlReturnVal_t rlSetAdvChirpDynLUTAddrOffConfig ( rlUInt8_t  deviceMap,
rlAdvChirpDynLUTAddrOffCfg_t data 
)

Configure LUT address offset dynamically for each chirp parameters defined in rlSetAdvChirpConfig API.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- structure contains adv-chirp dynamic LUT address offset configs
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API helps to update only the LUT offset address for chirp parameters when LUT data is modified at frame boundary dynamically while frames are running.
The dynamic chirp enable API AWR_DYN_CHIRP_ENABLE_SB shall be issued after issuing this API at least 500us before end of current active window of frame (500us before start of idle time of the frame) to apply the dynamic configurations in immediate next frame.

Definition at line 4243 of file rl_sensor.c.

◆ rlSetAdvChirpLUTConfig()

rlReturnVal_t rlSetAdvChirpLUTConfig ( rlUInt8_t  deviceMap,
rlAdvChirpLUTCfg_t data 
)

Set the Advanced chirp LUT configuration to the device.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- structure contains adv-chirp configs
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API sub-block loads the unique dither values for each chirp on Generic SW Chirp Parameter LUT at offset address defined in AWR_ADVANCE_CHIRP_CONF_SB API. This LUT can be used to pre-load dither patterns for each chirp parameters and provides the flexibility to program any number of unique dithers for each chirp parameters.

Note
1 : The Generic SW Chirp Parameter LUT can be modified by the host dynamically, as long as the LUT addresses modified differ from the addresses used in the current frame.
2 : The dynamic update of this API is effective immediately and does not depend on AWR_DYN_CHIRP_ENABLE_SB API. This might impact the ongoing chirps if timing of the update is not handled properly as if ongoing chirps use same fields/addresses in LUT. It is recommended to perform proper timing analysis before updating the LUT dynamically considering SPI communication delays.
3 : The total size of Generic SW Chirp Parameter LUT is 12kB.
4 : The start address offset of all chirp parameter in LUT shall be multiple of 4 bytes (word boundary), that means minimum 4 bytes in LUT shall be allocated to each chirp parameter.
5 : At least one dither parameter value shall be programmed for each chirp parameter type (10 types) in generic LUT, same value can be programmed to all chirps in a burst/frame using Advance chirp config API, LUT_PARAM_UPDATE_PERIOD (K) = 0 configuration

Definition at line 4063 of file rl_sensor.c.

◆ rlSetAdvFrameConfig()

rlReturnVal_t rlSetAdvFrameConfig ( rlUInt8_t  deviceMap,
rlAdvFrameCfg_t data 
)

Sets Advance Frame Configuration.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Container for Advance Frame Configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function allows configuration of advance frame in mmWave Front end. Advance Frame is a sequence of chirps and how this sequnece needs to be repeated over time. User first need to define a profile and set of chirps(associated with a profile).
This function then defines how to sequence these chirps. Multiple chirps can be looped to create a burst. Multiple bursts can be grouped to create a sub-frame. Multiple sub-frames(Upto 4) can be grouped to create advance frame.
This function defines the advance frame properties like the number of burst in subframe, number of chirps and loops in a burst, sequence of subframes to be transmitted, number of frames to be transmitted, periodicity of the frame and the trigger method. This API calls internally two APIs, one to RadraSS for sensor configuraion and another to MasterSS for datapath configuraion.

Note
1: If hardware trigger mode is used with subFrameTrigger = 0, then the trigger should be issued for each burst. If subFrameTrigger = 1, then the trigger needs to be issued for each sub-frame.
2: If hardware triggered mode is used, the SYNC_IN pulse width should be less than 1us. Also, the minimum pulse width of SYNC_IN should be 25 ns.
3: If frame trigger delay is used with hardware triggered mode, then external SYNC IN pulse periodicity should take care of the configured frame trigger delay and frame periodicity. The external pulse should be issued only after the sum total of frame trigger delay and frame periodicity.
4: In Hw triggered mode, the Hw pulse should be issued or periodicity of pulse is configured such that, the pulse is generated only 150us after the completion of previous frame/burst (The pulse should not be issued before end of previous frame/ burst). The time delta between end of previous frame/burst and raising edge of Hw pulse recommended to be < 300us.
5: The PF_NUM_ADC_SAMPLES parameter should be identical across chirps in a sub-frame, when multiple profiles are used in a sub-frame.
6: The PF_DIGITAL_OUTPUT_SAMPLING_RATE impacts the LVDS/CSI2 data rate in a sub-frame, so it is recommended to analyze timing impact if different sample rate is used across chirps in a sub-frame.
7: Please refer Table interBurstTime and interSubFrameTime for details on minimum inter-frame blank time requirements.
8: If advance chirp configuration is enabled then this API takes around 1.8ms to execute in RadarSS sub System for 128 chirps. The error checks for each parameters of advance chirp is done in frame configuration API. This option can be disabled by using ADVANCE_CHIRP_ERROR_CHK_DIS option in rlRfSetMiscConfig API. If this error check takes more than 50ms due to large number of chirps then it is recommended to disable RadarSS WDT while executing this API.

Definition at line 1190 of file rl_sensor.c.

◆ rlSetBpmChirpConfig()

rlReturnVal_t rlSetBpmChirpConfig ( rlUInt8_t  deviceMap,
rlBpmChirpCfg_t data 
)

Sets Binary Phase Modulation Chirp Configuration.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Container for BPM chirp configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API defines static configurations related to BPM (Binary Phase Modulation) feature in each of the TXs

Note
1: BPM values are configured using TX phase shifter and applied at TX start time.

Definition at line 241 of file rl_sensor.c.

◆ rlSetBpmCommonConfig()

rlReturnVal_t rlSetBpmCommonConfig ( rlUInt8_t  deviceMap,
rlBpmCommonCfg_t data 
)

Sets Binary Phase Modulation Common Configuration.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Container for BPM common Configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API defines static configurations related to BPM (Binary Phase Modulation) feature in each of the TXs. E.g. the source of the BPM pattern (one constant value for each chirp as defined, or intra-chirp pseudo random BPM pattern as found by a programmable LFSR or a programmable sequence inside each chirp), are defined here.

Note
1: Different source of BPM is currently not supported, hence this API is not required to be called by application.

Definition at line 199 of file rl_sensor.c.

◆ rlSetChannelConfig()

rlReturnVal_t rlSetChannelConfig ( rlUInt8_t  deviceMap,
rlChanCfg_t data 
)

Sets the Rx and Tx Channel Configuration.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Container for Channel Configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function allows configuration of mmWave Front end for how many Receiver and Transmit channels need to be enabled. It also defines whether to to enable single mmWave device or multiple mmWave devices to realize a larger antenna array (multiple is applicable only in AWR2243). This is applicable for given power cycle.

Note
This is global configuration for transmit channels. Later one can chose which transmit channel to be used for each chirp using Chirp configuaration API. For e.g - If Chirp 0, uses TX0 and TX1, and Chirp 1 uses TX1 and TX2, One need to enable TX0, TX1 and TX2 in this API. Based on the configuration, mmWave Front would do necessary calibration before the transmit channel is used to transmit chirps rlSetChirpConfig

Definition at line 107 of file rl_sensor.c.

◆ rlSetChirpConfig()

rlReturnVal_t rlSetChirpConfig ( rlUInt8_t  deviceMap,
rlUInt16_t  cnt,
rlChirpCfg_t data 
)

Sets Chirp Configuration.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]cnt- Number of configurations
[in]data- Array of Chirp Configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function sets the chirp to chirp variations on top of the chirp profile. The User should first define a profile using rlSetProfileConfig. This function then configures the chirp by associating it with a particular profile defined in rlSetProfileConfig API. In addition to that user can define fine dither to the profile parameters using this API. The dithers used in this configuration are only additive on top of programmed parameters in rlSetProfileConfig. This API allows configuration of 1 or upto 512 chirps. Also it allows configuraiton of which Transmit channels to be used for each chirp.

Note
1: One can set upto 512 unique chirps which can be stored in dedicated memory inside mmWave front end. Hence user doesn't need to program the chirps during run time. Also these chirps can be sequenced in a frame using rlSetFrameConfig to create a larger FMCW signal.

rlSetFrameConfig

Definition at line 597 of file rl_sensor.c.

◆ rlSetContModeConfig()

rlReturnVal_t rlSetContModeConfig ( rlUInt8_t  deviceMap,
rlContModeCfg_t data 
)

Sets Continous mode Configuration.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Continous mode Configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function sets the FMCW radar continous mode properties like Start Freq, TX power etc. In continuous mode, the signal is not frequency modulated but has the same frequency over time.

Note
: The continuous streaming mode configuration APIs are supported only for debug purpose. Please refer latest DFP release note for more info.

Definition at line 1311 of file rl_sensor.c.

◆ rlSetDynChirpCfg()

rlReturnVal_t rlSetDynChirpCfg ( rlUInt8_t  deviceMap,
rlUInt16_t  segCnt,
rlDynChirpCfg_t **  data 
)

Injects chirp configuration to be programmed dynamically.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]segCnt- number of segments for which application sends array of data.
[in]data- Dynamic chirp configuration
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API can be used to dynamically change the chirp configuration while frames are on-going. The configuration will be stored in software and at rlDynChirpEnCfg API invocation radarSS copies these chirp configurations from SW RAM to HW RAM at the end of current on-going frame.

Note
: The new feature of dynamic chirp configuaration to configuare 48 chirps in one API is not applicable in xWR6843.

Definition at line 2917 of file rl_sensor.c.

◆ rlSetDynChirpEn()

rlReturnVal_t rlSetDynChirpEn ( rlUInt8_t  deviceMap,
rlDynChirpEnCfg_t data 
)

Triggers copy of chirp config from SW to HW RAM.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Dynamic chirp enable configuration
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API can be used to trigger the copy of chirp configuration from software to hardware RAM. The copy will be performed at the end of the ongoing frame active window (start of the frame idle time).

Note
1: User needs to invoke this API within inter-frame idle time, not at boundary of frame end. Since dynamic chirps are configured at run time, there is not error checks done on the input data. If input data is out of range or invalid, device might misbehave.
2: HW reconfiguration time is around 500 us. User has to ensure that AWR_DYN_CHIRP_ENABLE_SB API is issued at least 500 us before the end of the ongoing frame active window (start of the frame idle time) to apply configurations for next frame onwards.

Definition at line 3041 of file rl_sensor.c.

◆ rlSetDynPerChirpPhShifterCfg()

rlReturnVal_t rlSetDynPerChirpPhShifterCfg ( rlUInt8_t  deviceMap,
rlUInt16_t  segCnt,
rlDynPerChirpPhShftCfg_t **  data 
)

Injects per-chirp phase shifter configuration to be applied dynamically.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]segCnt- number of segments for which application sends array of data.
[in]data- Dynamic chirp configuration
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API can be used to dynamically change the per-chirp phase shifter configuration while frames are on-going. The configuration will be stored in software and the new configuration will be applied at the end of the on-going frame. Note that the configuration should be received by the firmware 10 ms before the end of the current frame.

Note
1: This API is valid only for AWR1243P/2243 mmWave device when mmWaveLink instance is running on External Host Processor.
2: Phase shifter(PS) settings are applied in advance at max -5us or at -(idleTimeConst-1.28us-DfeLagTime) from the knee of the ramp. If idle time > 6.28us, then PS is applied always at -5us and if idle time < 6.28us, then PS is applied at -(idleTimeConst-1.28us-DfeLagTime) from knee of the ramp. Where DfeLagTime is internal DFE lag time (Please refer rampgen calculator).
3: It is recommended to configure TX start time > -5us or -(idleTimeConst-1.28us-DfeLagTime) based on PS apply time.

Definition at line 3090 of file rl_sensor.c.

◆ rlSetFrameConfig()

rlReturnVal_t rlSetFrameConfig ( rlUInt8_t  deviceMap,
rlFrameCfg_t data 
)

Sets Frame Configuration.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Container for Frame Configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function allows configuration of FMCW frame in mmWave Front end. A Frame is basically a sequence of chirps and how this sequnece needs to be repeated over time. User first need to define a profile and set of chirps(associated with a profile).
This function then defines how to sequence these chirps. The same chirp can be simply looped to create a large FMCW frame or multiple unique chirps cane be sequenced to create the frame. Chirp Start and end Index defines how to sequence them in a frame.
The API also allows configuration of number of frames to be transmitted, periodicity of the frame and the trigger method. The trigger method could be SW API based trigger or HW SYNC IN based trigger.
This API calls internally two APIs, one to RadraSS for sensor configuraion and another to MasterSS for datapath configuraion.

Note
1: If hardware triggered mode is used, the SYNC_IN pulse width should be less than 1us. Also, the minimum pulse width of SYNC_IN should be 25 ns.
2: If frame trigger delay is used with hardware triggered mode, then external SYNC_IN pulse periodicity should take care of the configured frame trigger delay and frame periodicity. The external pulse should be issued only after the sum total of frame trigger delay and frame periodicity.
3: If dummy chirp is used then programmer should make sure the idle time of dummy chirp >= 4us + DFE spill over time of previous chirp (calculate from rampgen calculator). The first chirp of frame cannot be a dummy chirp.
4: In Hw triggered mode, the Hw pulse should be issued or periodicity of pulse is configured such that, the pulse is generated only 150us after the completion of previous frame/burst (The pulse should not be issued before end of previous frame/ burst). The time delta between end of previous frame/burst and raising edge of HW pulse recommended to be < 300us.
5: Frame could have multiple chirps associated with different profile, but number of samples need to be same in all the profiles.
6: The PF_NUM_ADC_SAMPLES parameter should be identical across chirps in a frame, when multiple profiles are used in a frame.
7: The PF_DIGITAL_OUTPUT_SAMPLING_RATE impacts the LVDS/CSI2 data rate in a frame, so it is recommended to analyze timing impact if different sample rate is used across chirps in a frame.
8: Please refer Table interSubFrameTime for details on minimum inter-frame blank time requirements.
9: If advance chirp configuration is enabled then this API takes around 1.8ms to execute in RadarSS sub System for 128 chirps. The error checks for each parameters of advance chirp is done in frame configuration API. This option can be disabled by using ADVANCE_CHIRP_ERROR_CHK_DIS option in rlRfSetMiscConfig API. If this error check takes more than 50ms due to large number of chirps then it is recommended to disable RadarSS WDT while executing this API.

Definition at line 1017 of file rl_sensor.c.

◆ rlSetGpAdcConfig()

rlReturnVal_t rlSetGpAdcConfig ( rlUInt8_t  deviceMap,
rlGpAdcCfg_t data 
)

: Configure GP ADC data parameters

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Configuration parameter for GP ADC
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API enables the GPADC reads for external inputs (available only in xWR1642/xWR6843/ xWR1843/AWR2243). xWR1642/xWR1843 sends GP-ADC measurement data in async event RL_RF_AE_GPADC_MEAS_DATA_SB

Note
: The actual measurement of these GPADC signal are done in inter-burst or frame idle time and the result AE sub block will be sent only after completing all the measurements.

Definition at line 1925 of file rl_sensor.c.

◆ rlSetInterChirpBlkCtrl()

rlReturnVal_t rlSetInterChirpBlkCtrl ( rlUInt8_t  deviceMap,
rlInterChirpBlkCtrlCfg_t data 
)

Sets Inter-chip turn on and turn off times or various RF blocks.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Inter chirp block control config
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API programs the Inter-chip turn on and turn off times or various RF blocks

Note
The minimum inter-chirp time should be greater than maximum of the following
  1. abs(rx02RfTurnOffTime) + max(abs(rx02RfPreEnTime), abs(rx02RfTurnOnTime))
  2. abs(rx13RfTurnOffTime) + max(abs(rx13RfPreEnTime), abs(rx13RfTurnOnTime))
  3. abs(rx02BbTurnOffTime) + max(abs(rx02BbPreEnTime), abs(rx02BbTurnOnTime))
  4. abs(rx13BbTurnOffTime) + max(abs(rx13BbPreEnTime), abs(rx13BbTurnOnTime))
  5. abs(rxLoChainTurnOffTime) + abs(rxLoChainTurnOnTime)
  6. abs(txLoChainTurnOffTime) + abs(txLoChainTurnOnTime)
: The inter-chirp timing control configuration API is supported in this release. Please refer latest DFP release note for more info.

Definition at line 3459 of file rl_sensor.c.

◆ rlSetLoopBckBurstCfg()

rlReturnVal_t rlSetLoopBckBurstCfg ( rlUInt8_t  deviceMap,
rlLoopbackBurst_t data 
)

This API is used to introduce loopback chirps within the functional frames.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Loopback chirp config
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API can be used to introduce loopback chirps within the functional frames. This loopback chirps will be introduced only if advanced frame configuration is used where user can define which sub-frame contains loopback chirps. The following loopback configuration will apply to one burst and user can program up to 16 different loopback configurations in 16 different bursts of a given sub-frame. User has to ensure that the corresponding sub-frame is defined in rlSetAdvFrameConfig and sufficient time is given to allow the loopback bursts to be transmitted.

Note
1: If user desires to enable loopback chirps within functional frames, then this API should be issued before rlSetProfileConfig
2: Only profile based phase shifter is supported in loopback configuration. Per-chirp phase shifter if enabled will not be reflected in loopback chirps.
3: For the sub-frame in which loopback is desired, user should set numOfChirps per burst as 1 and can use numLoops per burst for multiple chirps in the burst.
4: The expected signal strength change with change in index value is only approximately indicated for PS<n>_PGA_GAIN_INDEX. Typically, the loopback path is the dominant path only in top ~10 indices (highest PGA gain values). For lower indices (lower PGA gain values), parasitic paths in the RF system can start dominating the loop-back measurements, and under such conditions, inter channel imbalances measured using such LB path, and LB signal SNR etc. can show degraded performance, with the degradation attributed to the loop-back path and not the functional path/circuits/system.

Definition at line 2877 of file rl_sensor.c.

◆ rlSetLowPowerModeConfig()

rlReturnVal_t rlSetLowPowerModeConfig ( rlUInt8_t  deviceMap,
rlLowPowerModeCfg_t data 
)

Sets Low Power Mode Configuration.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Container for Low power mode Configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function sets the static device configurations of low power options. Sigma Delta ADC root sampling reduces to half the rate to save power in small IF bandwidth applications.

Note
: Low power ADC mode is mandatory on 5 MHz part variant(for e.g. xWR1642), Normally if IF band width <= 7.5MHz then low power mode setting is recommended.

Definition at line 1396 of file rl_sensor.c.

◆ rlSetMultiAdvChirpLUTConfig()

rlReturnVal_t rlSetMultiAdvChirpLUTConfig ( rlUInt8_t  deviceMap,
rlAdvChirpLUTCfg_t AdvChirpLUTCfgArgs,
rlInt8_t *  AdvChirpLUTData 
)

Multi Advanced chirp LUT configuration API.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]AdvChirpLUTCfgArgs- Parameters for Advanced chirp LUT configuaration
[in]AdvChirpLUTData- LUT buffer filled with the chirp parameter data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

Multi Advanced chirp LUT configuration API. This API is used to send the programmed LUT RAM data to the device populating the RadarSS LUT. This API takes Chirp LUT buffer from the application and internally chunks to multiple SPI packets (max 256 Bytes each).

Note
: This API is supported only in AWR2243.

Definition at line 4113 of file rl_sensor.c.

◆ rlSetMultiBpmChirpConfig()

rlReturnVal_t rlSetMultiBpmChirpConfig ( rlUInt8_t  deviceMap,
rlUInt16_t  cnt,
rlBpmChirpCfg_t **  data 
)

Sets Binary Phase Modulation configuration for multiple Chirp.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]cnt- number of BPM chirp config data
[in]data- pointer to linked list/array of BPM chirp configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

Using this API application can configure multiple BPM chirp configuration in a single call. This API defines static configurations related to BPM (Binary Phase Modulation) feature in each of the TXs.

Definition at line 285 of file rl_sensor.c.

◆ rlSetMultiChirpCfg()

rlReturnVal_t rlSetMultiChirpCfg ( rlUInt8_t  deviceMap,
rlUInt16_t  cnt,
rlChirpCfg_t **  data 
)

Injects chirp configuration to be programmed dynamically.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]cnt- number of chirps
[in]data- Pointer to Chirp configuration linked list/array
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function sets the chirp to chirp variations on top of the chirp profile. The User should first define a profile using rlSetProfileConfig.
This function then configures the chirp by associating it with a particular profile defined in rlSetProfileConfig API. In addition to that user can define fine dither to the profile parameters using this API
This API allows configuration of 1 or upto 512 chirps. Also it allows configuraiton of which Transmit channels to be used for each chirp.

Note
One can set upto 512 unique chirps which can be stored in dedicated memory inside mmWave front end. Hence user doesn't need to program the chirps during run time. Also these chirps can be sequenced in a frame using rlSetFrameConfig to create a larger FMCW signal
This API is similar to rlSetChirpConfig but gives the flexibility to pass the array of chirp configuration pointers, so chirp configuration memory need not be contiguous.

Definition at line 860 of file rl_sensor.c.

◆ rlSetProfileConfig()

rlReturnVal_t rlSetProfileConfig ( rlUInt8_t  deviceMap,
rlUInt16_t  cnt,
rlProfileCfg_t data 
)

Sets Chirp profile Configuration.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]cnt- Number of Profiles
[in]data- Array of Profile Configuration data
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This function sets the chirp profile in mmWave Front end. A profile is like a template which contains coarse information about FMCW signal such as start frequency, chirp slope, chirp duration, TX power etc. The API allows multiple profiles to be set together by passing the array of profile data along with count of profiles.

Note
1: One can set upto 4 profiles. Each profile contains coarse inforamtion. Fine dithering can be added using chirp configuration API
2: This API can be issued dynamically to change profile parameters. Few parameters which cannot be changed are
  1. numAdcSamples
  2. digOutSampleRate
  3. Programmable filter coefficients
3: Please refer Table chirpCycleTime for details on minimum chirp duration.
4: The max TX output power back-off only up to 20dB is supported.
5: The RF band used in functional chirp profiles shall be within the limit set in AWR_CAL_MON_FREQUENCY_TX_POWER_LIMITS_SB API.
6: This API takes around 700us to execute in RadarSS sub System
7: Phase shifter(PS) settings are applied in advance at max -5us or at -(idleTimeConst-1.28us-DfeLagTime) from the knee of the ramp. If idle time > 6.28us, then PS is applied always at -5us and if idle time < 6.28us, then PS is applied at -(idleTimeConst-1.28us-DfeLagTime) from knee of the ramp. Where DfeLagTime is internal DFE lag time (Please refer rampgen calculator).
8: It is recommended to configure TX start time > -5us or -(idleTimeConst-1.28us-DfeLagTime) based on PS apply time.

rlSetChirpConfig

Definition at line 435 of file rl_sensor.c.

◆ rlSetSubFrameStart()

rlReturnVal_t rlSetSubFrameStart ( rlUInt8_t  deviceMap,
rlSubFrameStartCfg_t data 
)

Triggers the next sub-frame in software triggered sub-frame mode.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Sub-frame start config
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API triggers the next sub-frame in software triggered sub-frame mode

Note
1: If the user wishes to trigger each sub-frame independently, then after advanced frame config, the rlSensorStart should be issued once using rlSensorStop. This does not start any sub-frames but it will prepare the hardware for sub-frame trigger. Next any subsequent sub-frame trigger will start the sub-frames.
2: If the user wishes to use sub-frame trigger, he has to ensure that sub-frame trigger command is issued k*N times where k is the number of sub-frames in each frame and N is the number of frames. If the user wishes to stop frames in between, then he has to issue the rlSensorStop only after k*M triggers of sub-frame trigger command (where M is an integer). i.e. rlSensorStop can be issued only at frame boundaries.
3: If software based sub-frame trigger mode is chosen by the user, watchdog feature will not be available. User has to ensure that the watchdog is disabled before enabling the software based sub-frame trigger mode.
4: If sub-frame trigger or hardware trigger mode is used to trigger the frames/sub- frames and if frames need to be stopped before the specified number of frames, then the the frame stop command using rlSensorStop API should be issued while the frame is on-going. If the frames are stopped while the device is idle, it can lead to errors

Definition at line 3511 of file rl_sensor.c.

◆ rlSetTestSourceConfig()

rlReturnVal_t rlSetTestSourceConfig ( rlUInt8_t  deviceMap,
rlTestSource_t data 
)

Configures the Test Source.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Container for Test source configuration
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API allows configuration of the Test Source in mmWave Front end. A Test source simulates 2 objects at certain position relative to the mmWave device and generates the RAW ADC data. It also simulates velocity of objects, relative position of TX and RX antennas.

Note
1: This helps in checking the integrity of control and data path during development phase. API is meant to be used in development phase only and doesn't relate to any real use case.
2: The test source configuration APIs are supported only for debug purpose. Please refer latest DFP release note for more info.
3: After test source usage, it is recommend to disable the test source and issue profile configuration API again for normal functionality of radar.

Definition at line 1658 of file rl_sensor.c.

◆ rlTestSourceEnable()

rlReturnVal_t rlTestSourceEnable ( rlUInt8_t  deviceMap,
rlTestSourceEnable_t data 
)

Enables the Test Source.

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- Container for Test source enable parameters
Returns
rlReturnVal_t Success - 0, Failure - Error Code

Enables the Test Source that is configured using rlSetTestSourceConfig API

Definition at line 1698 of file rl_sensor.c.

◆ rlTxGainTempLutSet()

rlReturnVal_t rlTxGainTempLutSet ( rlUInt8_t  deviceMap,
rlTxGainTempLutData_t data 
)

Overwrites TX gain temperature based Lookup table (LUT)

Parameters
[in]deviceMap- Bitmap of devices to send the message
[in]data- TX gain Temperature LUT config
Returns
rlReturnVal_t Success - 0, Failure - Error Code

This API can be used to overwrite the TX gain temperature LUT used in Radar SS. This API should be issued after profile configuration API.

Definition at line 2714 of file rl_sensor.c.


Copyright 2020, Texas Instruments Incorporated