Post Go back to editing

QEC tracking settling time

Thread Summary

The user is investigating the QEC tracking convergence time on the ADRV9029 evaluation board after a change in LO frequency. The final answer suggests checking the QEC tracking Cal status and using timestamps to measure the update time, noting that QEC tracking Cal updates every 30 seconds. The user faces issues with limited capture depth and command latency/jitter, but the solution provides a method to measure the settling time more accurately.
AI Generated Content
Category: Hardware
Product Number: ADRV9029

Hello,

I am currently investigating the performance and timing of the QEC tracking on the ADRV9029 evaluation board. My goal is to measure the settling time (convergence time) of the QEC tracking algorithm specifically after a change in the LO frequency.

My current approach: I attempted to capture data from the Rx3 channel while simultaneously enabling QEC tracking. The plan was to analyze the raw data using Python/MATLAB to observe the image rejection improvement over time.

The issues I am facing:

  1. Capture Depth: The evaluation board (TES) limits the capture to approximately 50ms of data, which is a very narrow window.
  2. Command Latency/Jitter: Due to the communication overhead and jitter between the PC (TES/IronPython) and the FPGA, it is extremely difficult to synchronize the start of the QEC tracking/frequency change with the 50ms capture window.

My questions:

  • Is there a recommended method to measure the QEC settling time more accurately on the evaluation board?
  • Is there a way to trigger the capture based on an API command or a hardware signal to bypass the software jitter?
  • Did I miss any specific section in the User Guide (UG-1727 or similar) that provides characterization data for QEC convergence speed under different bandwidths or sample rates?

Thank you for your help.

Best regards,



Parents
  • You can try to check the QEC tracking Cal status. You can have a time stamp and see how much it is taking time for each update. QEC tracking Cal updates every 30seconds.

  • I used the TrackingCalAllStateGet API to monitor the RX3 QEC tracking status bit.
    From the log, I see that:

    • the RX QEC tracking wakes up approximately every 0.1 s, and
    • each time the RUNNING bit is set, it remains high for about 60 ms to 800 ms, after which the new QEC coefficients are applied.

    My understanding is that a single QEC tracking update takes 60–800 ms to complete, and these updates are triggered roughly every 0.1 s.
    Could you confirm if this is the expected behavior, and how this should be translated into an effective settling time after an LO frequency change (i.e. is it roughly “one wake‑up period + one RUNNING duration” in the worst case)?

  • Please use the below script and keep checking for the iteration count and the update count. You may reduce the sleep time to check QEC the update time.

    #################################################################################
    #GUI Version: 4.2.0.63
    #DLL Version: 4.2.0.53
    #Cmd Server Version: 4.2.0.53
    #FPGA Version: 0xC9000015
    #ARM Version: 4.2.0.21(ADI_ADRV9010_ARMBUILD_TESTOBJ)
    #StreamVersion: 6.2.0.5
    #Author: Sripad Jadhav
    #Precondition: EVB is programmed and init, Tracking cals are run , make sure to config the correct Tx-ORX mapping for Tx LOL status
    #Description: This script read the tracking cal status   
    #################################################################################
    
    #Import Reference to the DLL
    import System
    import clr
    import time
    import os
    from System import Array
    
    try:
        clr.AddReferenceToFileAndPath(os.getcwd() + "\\adrv9010_dll.dll")
    except System.IO.IOException as e:
        clr.AddReferenceToFileAndPath(os.getcwd() + "\\adrvtrx_dll.dll")
    	
    from adrv9010_dll import AdiEvaluationSystem
    from adrv9010_dll import Types
    from adrv9010_dll import Ad9528Types
    
    def spiRead(address):
        data = adrv9010.Hal.SpiByteRead(address, 0)
        print "SPI Read Address " + hex(address) + ": " + hex(data[1])
    
    def spiWrite(address, data):
        adrv9010.Hal.SpiByteWrite(address, data)
        print "SPI Write Address " + hex(address) + ": " + hex(data)
    
    #Create an Instance of the Class
    link = AdiEvaluationSystem.Instance	
    connect = False
    
    if (link.IsConnected() == False):
        connect = True
        link.platform.board.Client.Connect("192.168.1.10", 55556) 
        print "Connecting"
    
    if (link.IsConnected()):
        adrv9010 = link.Adrv9010Get(1)
        print "Connected"
        ##### YOUR CODE GOES HERE #####
    
    else:
        print "Not Connected"
    
    link.platform.board.Adrv9010Device.RadioCtrl.RxTxEnableSet(0x00,0x3)
    
    # "Set the required channel status to be read"
    ch = Types.adi_adrv9010_TxChannels_e()
    Tx_ch = [ch.ADI_ADRV9010_TX1,ch.ADI_ADRV9010_TX2,ch.ADI_ADRV9010_TX3,ch.ADI_ADRV9010_TX4]
    ORx_ch = Types.adi_adrv9010_RxChannels_e.ADI_ADRV9010_ORX1
    Rx_ch = Types.adi_adrv9010_RxChannels_e.ADI_ADRV9010_RX1
    
    loop = 30
    for j in range(0,loop):
        print "Iteration %d" %(j)
        time.sleep(30)
        for i in range(0,2):
            print "TX QEC Status of "  + str(Tx_ch[i])
            TX_status = Types.adi_adrv9010_TxQecStatus_t()
            link.platform.board.Adrv9010Device.Cals.TrackingCalTxQecStatusGet(Tx_ch[i],TX_status)
            print "errorCode = ", hex(TX_status.errorCode)
            print "percentComplete = ", hex(TX_status.percentComplete)
            print "selfcheckIrrDb = ", hex(TX_status.correctionMetric)
            print "iterCount = ", hex(TX_status.iterCount)
            print "updateCount = ", hex(TX_status.updateCount)
            print " "
        
    
    '''
    print "TX LOL"
    LOL_status = Types.adi_adrv9010_TxLolStatus_t()
    link.platform.board.Adrv9010Device.Cals.TrackingCalTxLolStatusGet(Tx_ch,LOL_status)
    print "errorCode = ", hex(LOL_status.errorCode)
    print "percentComplete = ", hex(LOL_status.percentComplete)
    print "selfcheckIrrDb = ", hex(LOL_status.varianceMetric)
    print "iterCount = ", hex(LOL_status.iterCount)
    print "updateCount = ", hex(LOL_status.updateCount)
    print " "
    '''
    if (connect):
        link.platform.board.Client.Disconnect()
        print "Disconnected"

    We run the QEC cal every 30seconds.

    Could you confirm if this is the expected behavior, and how this should be translated into an effective settling time after an LO frequency change (i.e. is it roughly “one wake‑up period + one RUNNING duration” in the worst case)?

    Yes, you can consider this.

    What is your application? What is that are looking for exactly?

  • We will use the chip for frequency hopping.

    My goal is to know how long it takes for the QEC tracking to become efficient once the frequency has changed.

    I need to measure the time needed by the QEC tracking calibration to calculate the coefficients and apply them to the Rx channel.

    Does the UG talk about the settling time of the QEC tracking?

  • This chip does not support frequency hopping. No, For Every 30seconds, the QEC cal tries to run and it can take maximum of 30 seconds depending on the QEC cal convergence.

  • For this chip, is there a way to store the QEC init coefficients in a JSON file or something else?
    Is it possible to get these coefficients and recall them later?
    Do we have access with the API to QEC calibration coefficients?

  • No, user does not have access to the QEC cal coefficients.

Reply Children
No Data