1. This proposed experiment shall verify the function and performance of Inductors with different values in the RF Transmitter and Receiver Circuit since inductor is key component in this design. deAnother circuit where inductors are key components is about DC or AC power supply circuits. Inductance resonance can  generate high frequency carrier waveform for RF transmitter in modulation.

The impedance of inductor shall be,

  ,

That makes the inductor useful in some ripple suppression or waveform correction, used in demodulation in RF demodulation.

With different value of inductor in circuit, the performance varies a lot. The full set of Kemet inductor kits are perfect for this purpose.

The deadline draws near,  Until now, the experiment is still not get expected results. I still can not collect  delivery order with neccessary electronic components. My fault not place the orders earlier, even I have received the Kemet Inductor Kits by UPS last month. There is one large PAUSE here and I am home-office with one small suface Pro and several stock electronic parts. I shall show what I want to do and how far I can go with these parts.

 

2. The inductor kit and LCR meter

2.1 There are 31 types of inductor samples and one TENMA -8155 LCR meter,

The element14  and KEMET are kindly offering brand-new product, since I have tried to buy more before the sample kit arrives. Searching simply return empty page with no stock available.

It is obvious that the inductor are of high quality, I have some other at hand as comparation. But I have difficult get precise value by TENMA LCR meter. Within 2mH range, the bias value shall be got before measuring value, but it perplax me with short circuit value normally about 1mH. This is still one unsolved issue for me.

 

2.2 Use of LPC55S69xpresso with Freemaster

Not mentioned in my application, the LPC55S69 proves its versatile in boost-performance, dual-core function and high-precise ADC up to 16 bit SAR, only sample rate of 1M fps is not enough in HF waveband.

With Freemaster embedded with NXP-LPC series, the coding machenism and ADC Measuring can be integrated together. It provides idea debugg tool for programmers. Ther freemaster is something like J-link RTT viewer, but with more data throughput and diversity ports. Refere https://www.nxp.com/design/software/development-software/freemaster-run-time-debugging-tool:FREEMASTER?&tid=vanFREEMASTE…  for more information.

 

3. Experiment with RF Transmitter

3.1 Configurate with Freemaster library in NXP-LPC55S69xpresso

Import the Freemaster lib into the project

Key code in main.c

int main(void)
{
    lpadc_config_t mLpadcConfigStruct;
    lpadc_conv_trigger_config_t mLpadcTriggerConfigStruct;
    lpadc_conv_command_config_t mLpadcCommandConfigStruct;
    lpadc_conv_result_t mLpadcResultConfigStruct;


    /* attach main clock divide to FLEXCOMM0 (debug console) */
    CLOCK_AttachClk(BOARD_DEBUG_UART_CLK_ATTACH);


    /* Board initialization */
    BOARD_InitPins();
    BOARD_BootClockFROHF96M();
    //BOARD_BootClockPLL150M();


    /**************************LPADC**************************/
    CLOCK_SetClkDiv(kCLOCK_DivAdcAsyncClk, 16U, true);
    CLOCK_AttachClk(kMAIN_CLK_to_ADC_CLK);




    /* Disable LDOGPADC power down */
    POWER_DisablePD(kPDRUNCFG_PD_LDOGPADC);


    //PRINTF("LPADC Polling Example\r\n");


    LPADC_GetDefaultConfig(&mLpadcConfigStruct);
    mLpadcConfigStruct.enableAnalogPreliminary = true;
#if defined(DEMO_LPADC_VREF_SOURCE)
    mLpadcConfigStruct.referenceVoltageSource = DEMO_LPADC_VREF_SOURCE;
#endif /* DEMO_LPADC_VREF_SOURCE */
#if defined(FSL_FEATURE_LPADC_HAS_CTRL_CAL_AVGS) && FSL_FEATURE_LPADC_HAS_CTRL_CAL_AVGS
    mLpadcConfigStruct.conversionAverageMode = kLPADC_ConversionAverage128;
#endif /* FSL_FEATURE_LPADC_HAS_CTRL_CAL_AVGS */
    LPADC_Init(DEMO_LPADC_BASE, &mLpadcConfigStruct);


#if defined(FSL_FEATURE_LPADC_HAS_CTRL_CALOFS) && FSL_FEATURE_LPADC_HAS_CTRL_CALOFS
#if defined(FSL_FEATURE_LPADC_HAS_OFSTRIM) && FSL_FEATURE_LPADC_HAS_OFSTRIM
    /* Request offset calibration. */
    if (true == DEMO_LPADC_DO_OFFSET_CALIBRATION)
    {
        LPADC_DoOffsetCalibration(DEMO_LPADC_BASE);
    }
    else
    {
        LPADC_SetOffsetValue(DEMO_LPADC_BASE, DEMO_LPADC_OFFSET_VALUE_A, DEMO_LPADC_OFFSET_VALUE_B);
    }
#endif /* FSL_FEATURE_LPADC_HAS_OFSTRIM */
    /* Request gain calibration. */
    LPADC_DoAutoCalibration(DEMO_LPADC_BASE);
#endif /* FSL_FEATURE_LPADC_HAS_CTRL_CALOFS */


#if (defined(FSL_FEATURE_LPADC_HAS_CFG_CALOFS) && FSL_FEATURE_LPADC_HAS_CFG_CALOFS)
    /* Do auto calibration. */
    LPADC_DoAutoCalibration(DEMO_LPADC_BASE);
#endif /* FSL_FEATURE_LPADC_HAS_CFG_CALOFS */


    /* Set conversion CMD configuration. */
    LPADC_GetDefaultConvCommandConfig(&mLpadcCommandConfigStruct);
    mLpadcCommandConfigStruct.channelNumber = DEMO_LPADC_USER_CHANNEL;
    LPADC_SetConvCommandConfig(DEMO_LPADC_BASE, DEMO_LPADC_USER_CMDID, &mLpadcCommandConfigStruct);


    /* Set trigger configuration. */
    LPADC_GetDefaultConvTriggerConfig(&mLpadcTriggerConfigStruct);
    mLpadcTriggerConfigStruct.targetCommandId       = DEMO_LPADC_USER_CMDID;
    mLpadcTriggerConfigStruct.enableHardwareTrigger = false;
    LPADC_SetConvTriggerConfig(DEMO_LPADC_BASE, 0U, &mLpadcTriggerConfigStruct); /* Configurate the trigger0. */


    //PRINTF("ADC Full Range: %d\r\n", g_Lpadc_12bitFullRange);
#if defined(FSL_FEATURE_LPADC_HAS_CMDL_CSCALE) && FSL_FEATURE_LPADC_HAS_CMDL_CSCALE
    if (kLPADC_SampleFullScale == mLpadcCommandConfigStruct.sampleScaleMode)
    {
        //PRINTF("Full channel scale (Factor of 1).\r\n");
    }
    else if (kLPADC_SamplePartScale == mLpadcCommandConfigStruct.sampleScaleMode)
    {
        //PRINTF("Divided input voltage signal. (Factor of 30/64).\r\n");
    }
#endif


    //PRINTF("Please press any key to get user channel's ADC value.\r\n");


    /*********************END of LPADC**************************/




    /* FreeMASTER communication layer initialization */
    init_freemaster_usart();


    /* This example uses shared code from FreeMASTER generic example application */
    FMSTR_Example_Init();


    while(1)
    {
        //GETCHAR();
        LPADC_DoSoftwareTrigger(DEMO_LPADC_BASE, 1U); /* 1U is trigger0 mask. */
#if (defined(FSL_FEATURE_LPADC_FIFO_COUNT) && (FSL_FEATURE_LPADC_FIFO_COUNT == 2U))
        while (!LPADC_GetConvResult(DEMO_LPADC_BASE, &mLpadcResultConfigStruct, 0U))
#else
        while (!LPADC_GetConvResult(DEMO_LPADC_BASE, &mLpadcResultConfigStruct))
#endif /* FSL_FEATURE_LPADC_FIFO_COUNT */
        {
        }
        //PRINTF("ADC value: %d\r\n", ((mLpadcResultConfigStruct.convValue) >> 3U));


        /* FreeMASTER example increments several variables periodically,
           use the FreeMASTER PC Host tool to visualize the variables */
        FMSTR_Example_Poll(mLpadcResultConfigStruct.convValue);
    }
}

 

 

Key code in FMSTR_Init() and FMSTR_poll() , update data every loop,

void FMSTR_Example_Init(void)
{


    static FMSTR_U8 recBuffer[512]; /* Recorder #1 sampling buffer */
    FMSTR_REC_BUFF recBuffCfg;
    FMSTR_HPIPE hpipe;
    int i;


    var8     = 0;
    var8rw   = 0;
    var8inc  = 1;
    var16    = 0;
    var16rw  = 0;
    var16inc = 1;
    var32    = 0;
    var32rw  = 0;
    var32inc = 100;


    frac8   = 0;
    frac16  = 0;
    frac32  = 0;
    ufrac8  = 0;
    ufrac16 = 0;
    ufrac32 = 0;




#if FMSTR_DEMO_SUPPORT_FLT
    varFLT    = 0;
    varFLTrw  = 0;
    varFLTinc = 1.0;
#endif


#if FMSTR_DEMO_SUPPORT_DBL
    varDBL    = 0;
    varDBLrw  = 0;
    varDBLinc = 1.0;
#endif


    arr_size = ARR_SIZE;


    so1.a  = 1;
    so2.a  = 2;
    si1.aa = 1;
    si2.aa = 2;


    for (i = 0; i < ARR_SIZE; i++)
    {
        arr8[i]  = (unsigned char)i;
        arr16[i] = (unsigned short)i * 10;
        arr32[i] = (unsigned long)i * 100;
#if FMSTR_DEMO_SUPPORT_I64
        arr64[i] = (unsigned long long)i * 1000;
#endif
#if FMSTR_DEMO_SUPPORT_FLT
        arrFLT[i] = ((float)i) / 10;
#endif
#if FMSTR_DEMO_SUPPORT_DBL
        arrDBL[i] = ((double)i) / 10;
#endif
    }


    /* FreeMASTER driver initialization */
    FMSTR_Init();


    /* Registering the App.Command handler */
    FMSTR_RegisterAppCmdCall(10, my_appcmd_handler);


    /* Example of dynamic TSA table definition in runtime. Use this approach to add TSA entries
       in runtime for variables whose address is not known in compilation time. This may be used for
       dynamically allocated varaibles, provided that they remain allocated at the same place throughout
       the whole application runtime. In this case, we just demonstrate it using var16prv symbol. */
    FMSTR_SetUpTsaBuff((FMSTR_ADDR)tsa_dyn_table_storage, sizeof(tsa_dyn_table_storage));
    FMSTR_TsaAddVar("var16prv", FMSTR_TSA_UINT16, (void *)&var16prv, sizeof(var16prv), FMSTR_TSA_INFO_RW_VAR);


    /* Note that Recorder #0 is set up automatically when FMSTR_USE_RECORDER>0 and FMSTR_REC_BUFF_SIZE != 0
       this is to enable backward compatiblity with older driver versions. Extra recorder instances
       need to be set up during intitialization (see below). */


    /* Setup the buffer for Recorder #1 */
    recBuffCfg.addr          = recBuffer;
    recBuffCfg.size          = sizeof(recBuffer);
    recBuffCfg.basePeriod_ns = 0; /* Unknown period, use FMSTR_RecorderSetTimeBase to set in runtime later */
    recBuffCfg.name          = "Example of additional recorder";
    FMSTR_RecorderCreate(1, &recBuffCfg);


    /* Open pipes. The first pipe at port 1 */
    hpipe = FMSTR_PipeOpen(1, my_pipe_handler, (FMSTR_ADDR)pipe1_rxb, sizeof(pipe1_rxb), (FMSTR_ADDR)pipe1_txb,
                           sizeof(pipe1_txb), FMSTR_PIPE_TYPE_ANSI_TERMINAL, "Pipe 1");


    if (hpipe)
    {
        FMSTR_PipeWrite(hpipe, (FMSTR_ADDR)sz_pipe1_hello, FMSTR_StrLen(sz_pipe1_hello), 0);
        FMSTR_PipeWrite(hpipe, (FMSTR_ADDR)sz_pipe_other, FMSTR_StrLen(sz_pipe_other), 0);
    }


    /* Second pipe at port 2 */
    hpipe = FMSTR_PipeOpen(2, my_pipe_handler, (FMSTR_ADDR)pipe2_rxb, sizeof(pipe2_rxb), (FMSTR_ADDR)pipe2_txb,
                           sizeof(pipe2_txb), FMSTR_PIPE_TYPE_ANSI_TERMINAL, "Pipe 2");


    if (hpipe)
    {
        FMSTR_PipeWrite(hpipe, (FMSTR_ADDR)sz_pipe2_hello, FMSTR_StrLen(sz_pipe2_hello), 0);
        FMSTR_PipeWrite(hpipe, (FMSTR_ADDR)sz_pipe_other, FMSTR_StrLen(sz_pipe_other), 0);
    }


    /* Third pipe is a binary one at port 33 */
    FMSTR_PipeOpen(33, my_pipe_math, (FMSTR_ADDR)pipe3_rxb, sizeof(pipe3_rxb), (FMSTR_ADDR)pipe3_txb, sizeof(pipe3_txb),
                   FMSTR_PIPE_TYPE_UNICODE_TERMINAL, "Test pipe");
}


/****************************************************************************
 *
 * Poll function of the FreeMASTER example, called periodically from the
 * main application
 *
 */


void FMSTR_Example_Poll(float adc_value)
{
    static unsigned short div;




    /* scope variables, increment once a while */
    if (++div > 20)
    {
        var8 += var8inc;
        var16 += var16inc;
        var32 += var32inc;




#if FMSTR_DEMO_SUPPORT_FLT
        varFLT = adc_value;
#endif




        div = 0;
    }


    /* This call should rather be placed in the timer interrupt or anywhere
       where the recorder sampling should occur. */
    FMSTR_Recorder(0);


    /* In this example we call both recorders here in the main loop. In real project
        each recorder will be called from different place. */
    FMSTR_Recorder(1);


    /* The FreeMASTER poll call must be called in the main application loop
       to handle the communication interface and protocol. */
    FMSTR_Poll();
}

 

3.2 Run freemaster in PC host

Design the Freemaster project, with watch-grid, oscilloscope , recorder Blocks. Watch-grid show the values in MCU, it can be revised in PC host if set as Read/Write. oscilloscope block runs like real oscilloscope in realtime, but limited by UART baudrate as of 115200. Recorder Block runs in burst mode, sends data onece MCU buff is full, shown in PC host block by block.

Then Start Connection Communication,

 

Once connected, the oscilloscope starts,

 

 

3.3 RF transimmter circuit in breadboard

Typical transmitter circuit shall be decided by L-C and NPN thyristor like,

The source wave shall be fed into base pole of thyristor 2N3904, then modulated by carrier wave decided by C2,C3 and L1, the frequency shall be

change the value of inductor can change the oscillator frequency, as in breadboard,

 

4. Experiment with RF receiver

Here is typical circuit or recever after demodulator, the inductor can normalize the signal after half-wave modulator by diode. Different value of inductor change the quanlity of signal.

Here is simplified bread board circuit wiring,

 

5. The result

Here is the full connection in bread board,

Even the RF part is skipped , there is no surprising with the results. There are conditions to be met for Oscillation, the value of capacitor and inductor shall be fine tuned for better output. In this case, there is no resonate in the circuit.

the demo video,

 

Clearly only the irregular noise is detected.

 

6 Next,

My draft plan is flexible and big one. With programmable LPC55S69, FFT with powerquant lib, high resolution SAR ADC similar with Instrument ADC, the experiment platform proved in breadboard can be migrated into duplex-RF-transceiver in dual-M33 core, direct sensor to PDM microphone or optical heartrate can enlarge the application. In every design, Kemet Inductor would be robust key component for better performance.

My delayed package shall arrived any way with matched components, I would finish this experiment anyway. Another task for me is to prepare one small home-lab, buy spare instruments for home-office hours.

I have digged around NXP-LPC55S69 for several months, Freemaster library would be one of ice on the cake, worth a try if you have spare time.