TI 毫米波雷达开发 —— 设置雷达上电自启动

已于 2024-11-17 22:03:43 修改
阅读量1k 收藏 18
点赞数 8
分类专栏： 毫米波雷达 文章标签： 单片机 嵌入式硬件
于 2024-02-14 18:58:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41861711/article/details/136075105
版权
本文详细介绍了TI毫米波雷达的免配置启动流程，包括上电后直接运行的策略，以及如何通过CLI接收和处理来自PC的配置命令，以实现无需额外配置文件的自启动过程。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

TI 毫米波雷达开发 —— 免配置程序上电自启动

mmWave 常规启动流程

TI 官方的例程上电启动流程为：
上电 – 等待配置 – 串口配置 – 配置完成后运行
现介绍一种上电之后不需要使用配置文件配置的方法，直接在ARM核上写固定程序。

mmWave 免配置启动流程

上电 – 配置完成后直接运行

主要思路

对于TI所有的需要配置参数的Demo而言，背后的处理流程都是一样的。

  1. PC通过UART发送命令。
  2. ARM内核接收，通过串口中断服务函数接收配置命令和配置数据。实现这一步需要初始化串口和CLI函数。
// 串口初始化函数
    /* Setup the default UART Parameters */
    UART_Params_init(&uartParams);
    uartParams.writeDataMode  = UART_DATA_BINARY;
    uartParams.readDataMode   = UART_DATA_BINARY;
    uartParams.clockFrequency = gMmwMssMCB.cfg.sysClockFrequency;
    uartParams.baudRate       = gMmwMssMCB.cfg.loggingBaudRate;
    uartParams.isPinMuxDone   = 1U;

    /* Open the Logging UART Instance: */
    gMmwMssMCB.loggingUartHandle = UART_open(1, &uartParams);
    if (gMmwMssMCB.loggingUartHandle == NULL)
    {
        System_printf("Error: MMWDemoMSS Unable to open the Logging UART Instance\n");
        return;
    }

   /*忽略中间代码*/
   
    MmwDemo_CLIInit(); //CLI 初始化函数用于注册当前Demo中所需的命令解析回调函数。

// 接下俩看看MmwDemo_CLIInit()的函数体
void MmwDemo_CLIInit(void)
{
    CLI_Cfg cliCfg;
    char    demoBanner[256];
    /* CLI 初始化命令 */
    sprintf(&demoBanner[0],
            "******************************************\n"
            "xWR68xx High Acc Demo. SDK: %02d.%02d.%02d.%02d\n"
            "******************************************\n",
            MMWAVE_SDK_VERSION_MAJOR,
            MMWAVE_SDK_VERSION_MINOR,
            MMWAVE_SDK_VERSION_BUGFIX,
            MMWAVE_SDK_VERSION_BUILD);

    /* 初始化CLI 配置 */
    memset((void *)&cliCfg, 0, sizeof(CLI_Cfg));
    cliCfg.cliPrompt                   = "mmwDemo:/>";
    cliCfg.cliBanner                   = demoBanner;
    cliCfg.cliUartHandle               = gMmwMssMCB.commandUartHandle;
    cliCfg.taskPriority                = 3;
    cliCfg.socHandle                   = gMmwMssMCB.socHandle;
    cliCfg.mmWaveHandle                = gMmwMssMCB.ctrlHandle;
    cliCfg.enableMMWaveExtension       = 1U;
    cliCfg.usePolledMode               = true;
    
    cliCfg.tableEntry[0].cmd           = "sensorStart";
    cliCfg.tableEntry[0].helpString    = "No arguments";
    cliCfg.tableEntry[0].cmdHandlerFxn = MmwDemo_CLISensorStart;
    
    cliCfg.tableEntry[1].cmd           = "sensorStop";
    cliCfg.tableEntry[1].helpString    = "No arguments";
    cliCfg.tableEntry[1].cmdHandlerFxn = MmwDemo_CLISensorStop;
    
    cliCfg.tableEntry[2].cmd           = "frameStart";
    cliCfg.tableEntry[2].helpString    = "No arguments";
    cliCfg.tableEntry[2].cmdHandlerFxn = MmwDemo_CLIFrameStart;
    
    cliCfg.tableEntry[3].cmd           = "guiMonitor";
    cliCfg.tableEntry[3].helpString    = "<detectedObjects> <logMagRange> <rangeAzimuthHeatMap> <rangeDopplerHeatMap>";
    cliCfg.tableEntry[3].cmdHandlerFxn = MmwDemo_CLIGuiMonSel;
    
    cliCfg.tableEntry[4].cmd           = "highAccCfg";
    cliCfg.tableEntry[4].helpString    = "<numRangeBinZoomIn> <skipLeft> <skipRight> <enablePhaseEst> <enableLinearFit> <enableFilter>";
    cliCfg.tableEntry[4].cmdHandlerFxn = MmwDemo_CLIHighAccuCfg;
    
    cliCfg.tableEntry[5].cmd           = "dataLogger";
    cliCfg.tableEntry[5].helpString    = "<mssLogger | dssLogger>";
    cliCfg.tableEntry[5].cmdHandlerFxn = MmwDemo_CLISetDataLogger;
    
    cliCfg.tableEntry[6].cmd           = "adcbufCfg";
    cliCfg.tableEntry[6].helpString    = "<adcOutputFmt> <SampleSwap> <ChanInterleave> <ChirpThreshold>";
    cliCfg.tableEntry[6].cmdHandlerFxn = MmwDemo_CLIADCBufCfg;
    
    cliCfg.tableEntry[7].cmd           = "RangeLimitCfg";
    cliCfg.tableEntry[7].helpString    = "<numRangeBinZoomIn> <enabled> <min_range> <max_range> "; //"<numRangeBinZoomIn> <enabled> <min_range> <max_range> ";
    cliCfg.tableEntry[7].cmdHandlerFxn = MmwDemo_CLIRangeLimitCfg;

    if (CLI_open(&cliCfg) < 0) // 记住CLI_open 函数会创建一个task , 用于接收并解析命令，后面会提到。
    {
        System_printf("Error: Unable to open the CLI\n");
        return;
    }
    System_printf("Debug: CLI is operational\n");
    return;
}
  1. 接收到的数据提交到命令解析回调函数。
// CLI_open 会进行相关内容的初始化并且创建新的CLI task
int32_t CLI_open (CLI_Cfg* ptrCLICfg)
{
    Task_Params     taskParams;
    uint32_t        index;

    /*  空指针检查 */
    if (ptrCLICfg == NULL)
        return -1;

    /* 初始化 CLI 管理控制块 */
    memset ((void*)&gCLI, 0, sizeof(CLI_MCB));

    /* 数据复制，用于安全控制*/
    memcpy ((void *)&gCLI.cfg, (void *)ptrCLICfg, sizeof(CLI_Cfg));

    /* 循环查看支持的命令 */
    for (index = 0; index < CLI_MAX_CMD; index++)
    {
        /* Do we have a valid entry? */
        if (gCLI.cfg.tableEntry[index].cmd == NULL)
        {
            /* NO: This is the last entry */
            break;
        }
        else
        {
            /* YES: Increment the number of CLI commands */
            gCLI.numCLICommands = gCLI.numCLICommands + 1;
        }
    }

    /* Is the mmWave Extension enabled? */
    if (gCLI.cfg.enableMMWaveExtension == 1U)
    {
        /* YES: Initialize the CLI Extension: */
        if (CLI_MMWaveExtensionInit (ptrCLICfg) < 0)
            return -1;
    }

    /* Do we have a CLI Prompt specified?  */
    if (gCLI.cfg.cliPrompt == NULL)
        gCLI.cfg.cliPrompt = "CLI:/>";

    gCLI.cfg.tableEntry[gCLI.numCLICommands].cmd           = "help";
    gCLI.cfg.tableEntry[gCLI.numCLICommands].helpString    = NULL;
    gCLI.cfg.tableEntry[gCLI.numCLICommands].cmdHandlerFxn = CLI_help;

    /* Increment the number of CLI commands: */
    gCLI.numCLICommands++;

    /* Initialize the task parameters and launch the CLI Task: */
    Task_Params_init(&taskParams);
    taskParams.priority  = gCLI.cfg.taskPriority;
    taskParams.stackSize = 4*1024;
// 创建CLI任务
    gCLI.cliTaskHandle = Task_create(CLI_task, &taskParams, NULL);
    return 0;
}

static void CLI_task(UArg arg0, UArg arg1)
{
    uint8_t                 cmdString[256];
    char*                   tokenizedArgs[CLI_MAX_ARGS];
    char*                   ptrCLICommand;
    char                    delimitter[] = " \r\n";
    uint32_t                argIndex;
    CLI_CmdTableEntry*      ptrCLICommandEntry;
    int32_t                 cliStatus;
    uint32_t                index;

    /* Do we have a banner to be displayed? */
    if (gCLI.cfg.cliBanner != NULL)
    {
        /* YES: Display the banner */
        CLI_write (gCLI.cfg.cliBanner);
    }

    /* Loop around forever: */
    while (1)
    {
        /* Demo Prompt: */
        CLI_write (gCLI.cfg.cliPrompt);

        /* Reset the command string: */
        memset ((void *)&cmdString[0], 0, sizeof(cmdString));

        /* Read the command message from the UART: */
        UART_read (gCLI.cfg.cliUartHandle, &cmdString[0], (sizeof(cmdString) - 1));

        /* Reset all the tokenized arguments: */
        memset ((void *)&tokenizedArgs, 0, sizeof(tokenizedArgs));
        argIndex      = 0;
        ptrCLICommand = (char*)&cmdString[0];

        /* comment lines found - ignore the whole line*/
        if (cmdString[0]=='%') {
            CLI_write ("Skipped\n");
            continue;
        }

        /* Set the CLI status: */
        cliStatus = -1;

        /* The command has been entered we now tokenize the command message */
        while (1)
        {
            /* Tokenize the arguments: */
            tokenizedArgs[argIndex] = strtok(ptrCLICommand, delimitter);
            if (tokenizedArgs[argIndex] == NULL)
                break;

            /* Increment the argument index: */
            argIndex++;
            if (argIndex >= CLI_MAX_ARGS)
                break;

            /* Reset the command string */
            ptrCLICommand = NULL;
        }

        /* Were we able to tokenize the CLI command? */
        if (argIndex == 0)
            continue;

        /* Cycle through all the registered CLI commands: */
        for (index = 0; index < gCLI.numCLICommands; index++)
        {
            ptrCLICommandEntry = &gCLI.cfg.tableEntry[index];

            /* Do we have a match? */
            if (strcmp(ptrCLICommandEntry->cmd, tokenizedArgs[0]) == 0)
            {
                /* YES: Pass this to the CLI registered function */
                cliStatus = ptrCLICommandEntry->cmdHandlerFxn (argIndex, tokenizedArgs);
                if (cliStatus == 0)
                {
                    CLI_write ("Done\n");
                }
                else
                {
                    CLI_write ("Error %d\n", cliStatus);
                }
                break;
            }
        }

        /* Did we get a matching CLI command? */
        if (index == gCLI.numCLICommands)
        {
            /* NO matching command found. Is the mmWave extension enabled? */
            if (gCLI.cfg.enableMMWaveExtension == 1U)
            {
                /* Yes: Pass this to the mmWave extension handler */
                cliStatus = CLI_MMWaveExtensionHandler (argIndex, tokenizedArgs);
            }

            /* Was the CLI command found? */
            if (cliStatus == -1)
            {
                /* No: The command was still not found */
                CLI_write ("'%s' is not recognized as a CLI command\n", tokenizedArgs[0]);
            }
        }
    }
}
  1. 命令解析函数对各配置命令进行处理。
// 以MmwDemo_CLIHighAccuCfg为例
static int32_t MmwDemo_CLIHighAccuCfg(int32_t argc, char *argv[])
{
    radarModuleHighAccuConfig highAccuConfig;
    MmwDemo_message           message;

    /* Sanity Check: Minimum argument check */
    if (argc != 7)
    {
        CLI_write("Error: Invalid usage of the CLI command\n");
        return -1;
    }

    /* Initialize the ADC Output configuration: */
    memset((void *)&highAccuConfig, 0, sizeof(radarModuleHighAccuConfig));


    // System_printf("highAccuConfig config\n");

    // cliCfg.tableEntry[4].helpString     = "<numRangeBinZoomIn> <skipLeft> <skipRight> <enablePhaseEst> <enableLinearFit> <enableFilter>";
    /* Populate configuration: */
    highAccuConfig.numRangeBinZoomIn = (uint16_t)atoi(argv[1]);
    highAccuConfig.skipLeft          = (uint16_t)atoi(argv[2]);
    highAccuConfig.skipRight         = (uint16_t)atoi(argv[3]);
    highAccuConfig.enablePhaseEst    = (uint16_t)atoi(argv[4]);
    highAccuConfig.enableLinearFit   = (uint16_t)atoi(argv[5]);
    highAccuConfig.enableFilter      = (uint16_t)atoi(argv[6]);

    /* Save Configuration to use later */
    memcpy((void *)&gMmwMssMCB.cfg.highAccuRangeCfg, (void *)&highAccuConfig, sizeof(radarModuleHighAccuConfig));

    /* Send configuration to DSS */
    memset((void *)&message, 0, sizeof(MmwDemo_message));

    message.type = MMWDEMO_MSS2DSS_HIGHACCURANGE_CFG;
    memcpy((void *)&message.body.highAccuRangeCfg, (void *)&highAccuConfig, sizeof(radarModuleHighAccuConfig));

    if (MmwDemo_mboxWrite(&message) == 0)
        return 0;
    else
        return -1;
}

所以如果期望实现免配置自启动，只需要给第3步提供合适的入口参数。

实现方式

cli.c中定义配置命令

#define USE_HARD_CODED_CONFIG

#ifdef USE_HARD_CODED_CONFIG

int32_t hardCodedConfigIndex;


char *hardCodedConfigCommands[] = {
    "sensorStop",
    "flushCfg",
    "dfeDataOutputMode 1",
    "channelCfg 15 7 0",
    "adcCfg 2 1",
    "adcbufCfg -1 0 1 1 1",
    "lowPower 0 0",
    "profileCfg 0 60 7 3 24 0 0 166 1 256 12500 0 0 158",
    "chirpCfg 0 0 0 0 0 0 0 1",
    "chirpCfg 1 1 0 0 0 0 0 4",
    "chirpCfg 2 2 0 0 0 0 0 2",
    "frameCfg 0 2 32 0 100 1 0",
    "guiMonitor -1 1 1 1 0 0 1",
    "cfarCfg -1 0 2 8 4 3 0 15.0 0",
    "cfarCfg -1 1 0 4 2 3 1 15.0 0",
    "multiObjBeamForming -1 1 0.5",
    "calibDcRangeSig -1 0 -5 8 256",
    "clutterRemoval -1 0",

    "compRangeBiasAndRxChanPhase 0.0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0 1 0",
    "measureRangeBiasAndRxChanPhase 0 1. 0.2",

    "aoaFovCfg -1 -90 90 -90 90",
    "cfarFovCfg -1 0 0.25 9.0",
    "cfarFovCfg -1 1 -20.16 20.16",
    "extendedMaxVelocity -1 0",

    "CQRxSatMonitor 0 3 4 63 0",
    "CQSigImgMonitor 0 127 4",
    "analogMonitor 0 0",
    "lvdsStreamCfg -1 0 0 0",
    "bpmCfg -1 0 0 0",
    "calibData 0 0 0",
    "sensorStart",
    "!!!END_OF_HARD_CODED_COMMANDS"
};

#endif

CLI_task 函数增加处理代码

static void CLI_task(UArg arg0, UArg arg1)
{
    uint8_t            cmdString[256];
    char              *tokenizedArgs[CLI_MAX_ARGS];
    char              *ptrCLICommand;
    char               delimitter[] = " \r\n";
    uint32_t           argIndex;
    CLI_CmdTableEntry *ptrCLICommandEntry;
    int32_t            cliStatus;
    uint32_t           index;

    /* Do we have a banner to be displayed? */
    if (gCLI.cfg.cliBanner != NULL)
    {
        /* YES: Display the banner */
        CLI_write(gCLI.cfg.cliBanner);
    }
#ifdef USE_HARD_CODED_CONFIG

    hardCodedConfigIndex = 0;

    CLI_write("Wait some time for system to initialize...\n");

    Task_sleep(100);

    CLI_write("Performing hard-coded config\n");

#endif
    /* Loop around forever: */
    while (1)
    {
        /* Demo Prompt: */
        CLI_write(gCLI.cfg.cliPrompt);

        /* Reset the command string: */
        memset((void *)&cmdString[0], 0, sizeof(cmdString));

#ifdef USE_HARD_CODED_CONFIG
        //新增上电自启动处理代码
        if (hardCodedConfigCommands[hardCodedConfigIndex][0] != '!')
        {   // CLI_write (hardCodedConfigCommands[hardCodedConfigIndex]);
            CLI_write("Command\n");
            memcpy((void *)&cmdString[0], (void *)hardCodedConfigCommands[hardCodedConfigIndex],
                   strlen(hardCodedConfigCommands[hardCodedConfigIndex]));
            hardCodedConfigIndex++;
        }
        else
        {
            UART_read(gCLI.cfg.cliUartHandle, &cmdString[0], (sizeof(cmdString) - 1));
        }
#else    //保留原来的串口处理方式
        /* Read the command message from the UART: */
        UART_read(gCLI.cfg.cliUartHandle, &cmdString[0], (sizeof(cmdString) - 1));
#endif
        /* Reset all the tokenized arguments: */
        memset((void *)&tokenizedArgs, 0, sizeof(tokenizedArgs));
        argIndex      = 0;
        ptrCLICommand = (char *)&cmdString[0];

        /* comment lines found - ignore the whole line*/
        if (cmdString[0] == '%')
        {
            CLI_write("Skipped\n");
            continue;
        }

        /* Set the CLI status: */
        cliStatus = -1;

        /* The command has been entered we now tokenize the command message */
        while (1)
        {
            /* Tokenize the arguments: */
            tokenizedArgs[argIndex] = strtok(ptrCLICommand, delimitter);
            if (tokenizedArgs[argIndex] == NULL)
                break;

            /* Increment the argument index: */
            argIndex++;
            if (argIndex >= CLI_MAX_ARGS)
                break;

            /* Reset the command string */
            ptrCLICommand = NULL;
        }

        /* Were we able to tokenize the CLI command? */
        if (argIndex == 0)
            continue;

        /* Cycle through all the registered CLI commands: */
        for (index = 0; index < gCLI.numCLICommands; index++)
        {
            ptrCLICommandEntry = &gCLI.cfg.tableEntry[index];

            /* Do we have a match? */
            if (strcmp(ptrCLICommandEntry->cmd, tokenizedArgs[0]) == 0)
            {
                /* YES: Pass this to the CLI registered function */
                cliStatus = ptrCLICommandEntry->cmdHandlerFxn(argIndex, tokenizedArgs);
                if (cliStatus == 0)
                {
                    CLI_write("Done\n");
                }
                else
                {
                    CLI_write("Error %d\n", cliStatus);
                }
                break;
            }
        }

        /* Did we get a matching CLI command? */
        if (index == gCLI.numCLICommands)
        {
            /* NO matching command found. Is the mmWave extension enabled? */
            if (gCLI.cfg.enableMMWaveExtension == 1U)
            {
                /* Yes: Pass this to the mmWave extension handler */
                cliStatus = CLI_MMWaveExtensionHandler(argIndex, tokenizedArgs);
            }

            /* Was the CLI command found? */
            if (cliStatus == -1)
            {
                /* No: The command was still not found */
                CLI_write("'%s' is not recognized as a CLI command\n", tokenizedArgs[0]);
            }
        }
    }
}

工程中添加宏定义使能

在 工程中添加宏定义配置 USE_HARD_CODED_CONFIG 后生效 。
在这里插入图片描述
在这里插入图片描述

手把手教你搭建TI毫米波雷达开发环境
qq_42235129的博客
09-25 2692
目录 Step1. 确定ES number Step 2. 下载对应版本的SDK Step 3 安装Uniflash Step 4 下载mmWave Demo Visualizer Step 5 安装mmWave Studio Step 6 下载工具箱 Step 7 下载CCS 本教程将带你安装TI毫米波雷达开发的必要环境和工具，如SDK，CCS，mmWave Studio，Uniflash，mmWave Demo Visualizer等。 本例程以安装AW...
TI单芯片毫米波雷达1642demo代码走读（一）
lightninghenry的博客
06-22 1万+
今天我们来实际看下代码。 首先使用CCS软件导入demo工程，工程有两个，一个是ARM的工程，工程名是mmw_mss_16xx；另一个是DSP的工程，工程名为mmw_dss_16xx。我们将这两个工程的主函数打开，分别位于mss_main.c和dss_main.c文件中。 先看mss的主函数，代码如下。我为每行代码都加了中文注释和自己的理解。 int main (void) { Task_Params taskPara...
TI毫米波雷达（六）——high accurary示例分析（一）
最新发布
slyywd的博客
11-20 907
毫米波雷达还有一个不可忽视的应用场景：高精度测距，通过实现Zoom-FFT可以达到毫米级测距精度。TI在Radar Toolbox中提供了一个high accuracy示例，我们就通过这个示例的分析学习如何实现高精度测距，然后将工程移植到新平台IWR1843中。最后，尝试将high accuracy与out of box进行结合，实现高精度区域扫描功能。至此，示例程序框架基本理清。
TI 77GHz毫米波雷达快速开发说明
05-02
通过阅读这篇文章，使开发人员面对TI的雷达传感方案，轻松上手，快速入门。
毫米波雷达IWR6843-配置自启动
dufudouhenmang的博客
03-18 4277
IWR6843是TI推出的单芯片毫米波雷达解决方案，其内部可通过DSP以及ARM对雷达信号进行处理分析，其采用基于eclipse的CCS开发环境可方便对雷达内部计算资源进行使用。官方demo大多为工程开发版本，需要在pyqt/matlab上位机上进行配置，将涉及雷达的关键参数通过命令串口发送到雷达板后，雷达板才开始工作。当然，这样做确实方便在开发阶段对关键参数进行调试。但当配置参数固定后，我们需要雷达上电后即可自动完成配置，并运行相关用户程序，这里就牵扯到这款6843的配置固化和程序自启动问题。 ..
毫米波雷达SLAM：利用TI IWR1443+ROS+NVIDIA JTX+TurtleBot2实现（上）
gua_MASS的博客
03-20 1万+
利用毫米波雷达IWR1443实现室内建图，篇幅较长故分为上中下三篇。本片介绍如何安装毫米波雷达驱动，以及驱动是如何工作的。
毫米波雷达（AWR1864）一、demo的使用
zrdsz的博客
10-06 6507
毫米波雷达（AWR1864）一、demo的使用AWR1864入门事先准备硬件的准备接口问题端口识别成功后，mmWave Demo Visualizer如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 AWR1864入门 你好！ 这是你第一次使用 Markdown编辑器 所展示的欢迎页。如果你想学习如何使用
TI 毫米波雷达开发项目子任务拆解分析
qq_41861711的博客
09-24 2215
分享雷达开发过程中可能涉及的大问题
TI毫米波雷达软硬件概述
qq_41861711的博客
07-10 6244
本期视频分析了TI毫米波雷达的分类、工业毫米波雷达传感器和汽车毫米波雷达传感器的应用场景分析、雷达芯片关键文档、TI基于雷达芯片的评估板以及级联板卡概述 软件分享了 TI 毫米波雷达常用软件 mmWave Studio 、 CCS 、Radar ToolBox 、Uniflash、Vrisualizer、mmWave SDK的功能使用方案。
TI 毫米波雷达开发系列之mmWave Studio 和 Visuiallizer 的异同点&雷达影响因素分析
qq_41861711的博客
11-25 3616
雷达前端在后面详细展开讨论，先关注MSS和DSS两个子系统。MSS和DSS其实并不神秘，MSS就是一颗MCU，俗称单片机。所以大可认为这里有一个STM32，只不过STM32的内核是ARM Cortex-M3/M4的，而AWR1642 MSS里面的MCU内核是ARM Cortex-R4F。
TI毫米波雷达开发-6843 High Accuracy Demo 串口数据接收及TLV协议解析 matlab 源码
02-07
6843 High Accuracy Demo 串口数据接收及TLV协议解析 matlab 源码
TI IWR 6843 ISK 毫米波雷达开箱测试
qq_57061492的博客
03-04 2487
TI IWR6843 ISK毫米波雷达上手体验，教程十分详细，对于新手很友好。
关于TI MMWAVE Demo 的一些经验
qq_41861711的博客
04-27 1526
AWR1642
使用ubuntu 18.04 配置iwr1443 ，启动毫米波雷达时出现bug
afucc111的博客
03-29 971
[ERROR] [1648553254.462476156]: mmWaveQuickConfig: Command failed (mmWave sensor did not respond with 'Done') [ERROR] [1648553254.462511683]: mmWaveQuickConfig: Response: 'calibData 0 0 0 'calibData' is not recognized as a CLI command 解决办法： 1、断电重开 2...
【TI毫米波雷达】CLI模块初始化，demo工程覆写CLI控制指令代码的操作方式（以IWR6843AOP为例）
Mike Zhou的博客
02-01 1981
【TI毫米波雷达】CLI模块初始化，demo工程覆写CLI控制指令代码的操作方式（以IWR6843AOP为例）
【TI毫米波雷达】毫米波雷达芯片框架解析：out_of_box开箱demo代码重构，绕过上位机CLI指令（IWR6843AOP）
Mike Zhou的博客
08-31 1841
【TI毫米波雷达】毫米波雷达芯片out_of_box开箱demo代码重构，绕过上位机CLI指令（IWR6843AOP）
TI毫米波雷达开发常见问题总结
热门推荐
nuaahz的博客
03-15 3万+
欢迎加入毫米波雷达技术交流群，qq群号码：732821012 2017年开始接触德州仪器TI发布的三款毫米波雷达AWR1243、AWR1443、AWR1642。主要使用探索汽车防撞雷达以及车内人员检测以及呼吸检测等等毫米波雷达应用（偏了解AWR1243和AWR1642）。现将该系列雷达开发过程中常见问题总结如下： 一、AWR1243 【Radar Studio】 1......
【TI-mmWave】一、IWR6843ISK-ODS毫米波雷达【固件烧写和上手使用】流程
z5z5z5z56的博客
06-22 9871
TI毫米波雷达上手~
[解疑][TI]TI毫米波雷达系列（四）：xWR1642雷达数据解析
指甲的博客
09-26 7239
根据采集文件的数据格式，计算一下文件大小。 数据形式如下图： 保存的文件大小为： 由上图可以看到，文件大小为16MB。 已知 数据包有32个帧 一帧(frame)有128个chrip 一个chrip采256个点 一个采样点16bit 一个接收天线分为I/Q两路采集（看上上图） iwr1642有4个接收天线 一个接收天线1帧的数据大小（字节）: E=128 * 256 * (16/8) * 2 4个接收天线32帧的数据大小（字节) : 32 * 4 * E=16,777,216 字节 ...
TI毫米波雷达demo工程开源代码分享
在开发毫米波雷达应用时，需要考虑的因素有雷达系统的频率选择、天线设计、信号处理算法、目标检测与跟踪等。这些方面往往需要硬件和软件工程师紧密合作，确保系统在不同的应用环境中都能正常工作。而这份demo工程...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

雷达爆破手

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值