• 状态
  • 已锁定 已锁定
  • 回复 9 回复
  • 订户 0 订户
  • 视图 346 视图
  • 用户 0 会员在此处
选项
选项
相关

This thread has been locked.

If you have a related question, please click the "Ask a related question" button in the top right corner. The newly created question will be automatically linked to this question.

[参考译文] 编译器/TDA2SX：RTOS/tda2x：如何在中断中配置 MCSPI2从模式

admin
Guru**** 2539500 points
Other Parts Discussed in Thread: SYSBIOS, SYSCONFIG

请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

https://e2e.ti.com/support/processors-group/processors/f/processors-forum/905615/compiler-tda2sx-rtos-tda2x-how-to-config-mcspi2-slave-mode-in-interupt

器件型号：TDA2Sx
Thread 中讨论的其他器件：SysBIOS、 SysConfig

工具/软件：TI C/C++编译器

我使用 utils_mcspi.c 来使 SPI2在主模式下正常工作、并且可以从 MCU。读取数据、但在从模式下、它不起作用。 我检查  

utils_mcspiRead()函数和 find  
Gio_Recy()函数无法返回。我通过轮询模式进行测试，并且可以从 MCU。读取数据，因此我认为中断不起作用。
IRQXBARConnect (SOC_IRQ_DMARQ_crossbar_register_base、
CPU_IPU1、XBAR_INST_IPU1_IRQ_58、MCSPI2_IRQ)；
我已如上所述添加 interupt 配置。但不使用。您能给我一些建议吗？ 谢谢
  • 0
    TI__Guru**** 2539500 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。
    if ((MCSPI_COMMMODE_SLAVE =
    instHandle->spiHWconfig.masterOrSlave)
    &&
    (instHandle->opMode =
    MCSPI_OPMODE_INTERRUPT))
    ｛
    mcspiRegisterIntraHandler (
    instHandle->instNum、
    instHandle->deviceInfo。
    cpuEventNumber、
    mcspiSlaveIntraHandler、
    instHandle)；
    ｝
    其他
    ｛
    mcspiRegisterIntraHandler (
    instHandle->instNum、
    instHandle->deviceInfo。
    cpuEventNumber、
    mcspiIntraHandler、
    instHandle)；
    ｝
    在 bsp_mcspi.c 文件中，我只在 salve 和 Interrupt 模式下找到它，它使用不同的功能。但我不知道它为什么不能正常工作。所以，给我一些方向。谢谢
  • 0
    TI__Guru**** 2539500 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

    您好！

    如果 McSPI 驱动器配置为从模式和中断模式、
    在开始传输之前、驾驶员需要至少为2个缓冲区灌注。

    此致、
    Prasad

  • 0
    TI__Guru**** 2539500 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

    没错。 我发现读取字节的数量必须 是32的倍数。 但还有其他问题，只有一个任务是从机和中断模式 读取数据 正常，一旦其他任务正在运行，将显示 RX 溢出。 我认为 M4忙，所以需要使用 DMA 模式。 但显示 EDMA 传输启用失败。您能否提供一些指导。 谢谢。

  • 0
    TI__Guru**** 2539500 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。
    /*使用 McSPI1作为主设备*/
    EDMA3_DRV_RESULT edmaResult = 0；
    gEdmaHandle_send = edma3init (0、&edmaResult)；
    utils_mcspiInit (test_MCSPI_INST0)；
    mcspiHandle_send = Utils_mcspiOpen (0、0、0、gEdmaHandle_send)；
    SPI_WRITE_STY = Utils_mcspiWrite (mcspiHandle_send、SPI_Send_Buffer、SPI_SEND_BUF_SIZE)；
    mcspiCfgPrms[mcSPINum].opMode = MCSPI_OPMODE_DMAINTERRUPT；
     
    如上所述进行设置。ERROR：
    SPI 测试：EDMA 传输启用失败
    SPI 测试：RX**** -1647318392**** 35*2****
    SPI 测试：EDMA 传输启用失败
    我希望您能快速回复。非常感谢您。或者我们可以通过电子邮件进行沟通 我的电子邮件：295481527@qq.com。
  • 0
    TI__Guru**** 2539500 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

    您好：

    今天 我测试并注意 到、使用1MHz，通过从器件\中断模式从 MCU 读取数据、并且其他任务正在运行、还可以。我很高兴、但我的目标是5MHz，您能提供一些指导。 谢谢。

  • 0
    TI__Guru**** 2539500 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

    您好：

       添加最后一个回复。在 使用1MHz 时、我也会对 fifoRxTrigLevel 进行认证。 读取任务从32到16、写入任务从32到64、这样就可以了。谢谢！

  • 0
    TI__Guru**** 2539500 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

    您好！

    您是否能够解决问题？

    如果不是、您可以更新您当前面临的问题。

    此致、
    Prasad

  • 0
    TI__Guru**** 2539500 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

    文件：utils_mcspi_msg.c

    /*********
     * 包含文件
     秘书长的报告
     *
    #include
    #include
    #include
    #include
    #include
    #include
    /*==================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================== *
    /*                宏定义                *
    /*==================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================================== *
    #define SPI_RCV_Task_PRI   (13U)
    #define SPI_RCV_STACK_SIZE  (16*1024)
    #define SPI_RCV_BUF_SIZE   (1024U)
    #define SPI_SEND_TASK_PRI   (13U)
    #define SPI_SEND_STACK_SIZE  (16*1024)
    #define SPI_SEND_BUF_SIZE   (1024U)
    #define TEST_MCSPI_INST0          (0U)
    #define TEST_MCSPI_INST1          (1U)
    #define TEST_MCSPI_INST2          (2U)
    #define TEST_MCSPI_INST3          (3U)
    #define DEBUG_SPI_READ
    #define DEBUG_SPI_WRITE
    uint8 SPI_rcv_taskStack[SPI_RCV_STACK_SIZE]；
    uint8 SPI_SEND_taskStack[SPI_SEND_STACK_SIZE]；
    如果已定义 DEBUG_SPI_READ
    #pragma DATA_ALIGN (SPI_Rcv_Buffer、128)；
    静态 UINT8    SPI_Rcv_Buffer[SPI_SEND_BUF_SIZE]=｛0｝；
    #endif
    #if def定义 DEBUG_SPI_WRITE
    #pragma DATA_ALIGN (SPI_Send_Buffer、128)；
    静态 UINT8    SPI_Send_Buffer[SPI_SEND_BUF_SIZE]=｛0｝；
    #endif
    /*处理 EDMA 驱动程序实例                      *
    EDMA3_DRV_Handle edma3init (uint32 edma3Id、EDMA3_DRV_Result *)；
    EDMA3_DRV_Handle gEdmaHandle_rcv；
    EDMA3_DRV_Handle gEdmaHandle_SEND；
    void * mcspiHandle_rcv；
    void * mcspiHandle_send；
    静态 uint8_t ERROR_COUNT = 0；
    静态 uint16_t CalcCheckSum16 (uint8_t *消息地址、uint32_t byte_count)
    ｛
      uint16_t calc_checksum = 0；
      uint16_t* byte_address；
      uint16_t* end_address；
      uint16_t* short_memory_address；
      short_memory_address =(uint16_t*)(message_address)；
      end_address = short_memory_address +(byte_count>>1)；
      for (byte_address = short_memory_address；
         byte_address < end_address；
         byte_address ++)
      ｛
        CALC_CHECKSUM +=*字节_地址；
      ｝
      return (calc_checksum)；
    ｝
    如果已定义 DEBUG_SPI_READ
    静态空 MCU_SPI_READ_work (UARg arg1、UARg arg2)
    ｛
      /*使用 McSPI2作为从属设备*/
      VPS_printf ("********) MCU SPI 读取测试******* \n");
      int SPI_READ_STACH = 1；
      EDMA3_DRV_RESULT edmaResult = 0；
      gEdmaHandle_rcv = edma3init (0、&edmaResult)；
      if (edmaResult！= EDMA3_DRV_SOK)
      ｛
        /*报告 EDMA 错误*/
        VPS_printf ("********) DMA 驱动程序初始化失败********* \n");
      ｝
      其他
      ｛
        VPS_printf ("********) EDMA 驱动程序初始化通过********* \n");
      ｝
      utils_mcspiInit (test_MCSPI_INST1)；
      mcspiHandle_rcv = Utils_mcspiOpen (1、1、0、gEdmaHandle_rcv)；
      //vps_printf ("********) SPI2硬件初始化********* \n");
    //vps_printf ("********) SPI2硬件初始化结束********* \n");
      //int j；
      静态 uint16 rcv_CHECKSUM = 0；
      静态 uint32_t rcv_count = 0；
      while (1)
      ｛
        //vps_printf ("***** SPI ******* RCV_buf--begre--6.10 ---- \n");
        spi_read_state = Utils_mcspiRead (mcspiHandle_rcv、SPI_Rcv_Buffer、SPI_RCV_BUF_SIZE)；//SPI_RCV_BUF_SIZE
        RCV_COUNT++；
        vps_printf ("***** SPI2结束读取***SPI_READ_STACD：%d**ERROR_COUNT：%d**rcv_count：%d***%0x-%0x-%0x-%0x-**\n"，
            spi_read_state、error_count、rcv_count、spi_Rcv_Buffer[0]、spi_Rcv_Buffer[1]、spi_Rcv_Buffer[2]、spi_Rcv_Buffer[3])；
        RCV_CHECKSUM =(~(CalcCheckSum16 (SPI_Rcv_Buffer、(SPI_RCV_BUF_SIZE)))+ 1；
        if (((uint8_t)(rcv_checksum &(0x00ff))！= SPI_Rcv_Buffer[SPI_RCV_BUF_SIZE-2])||(((uint8_t)(((rcv_checksum &(0x00)))>> 8)！= SPI_Rcv_Buffer_size-1[SPI_RCV])
        ｛
          ERROR_COUNT++；
          System_printf ("------ ！！！！！！！！！！！！！！！！！！！ -recv 校验和--：%0x-%0x-**** ERROR_COUNT：%d ******** ","、SPI_Rcv_Buffer[SPI_RCV_BUF_SIZE-1]、SPI_Rcv_Buffer[SPI_RCV_BUF_SIZE-2]、ERROR_COUNT)；
        ｝
        /*表示(j = 0；j < SPI_RCV_BUF_SIZE；j++)
        ｛
          System_printf ("%0x"、SPI_Rcv_Buffer[j])；
          System_printf (")；
          如果(j > 0 & j%60 = 0)
            System_printf ("\n")；
        ｝*/
      ｝
    ｝
    #endif
    #if def定义 DEBUG_SPI_WRITE
    静态空 MCU_SPI_WRITE_work (UARg arg1、UARg arg2)
    ｛
      /*使用 McSPI1作为主设备*/
      VPS_printf ("********) MCU SPI 写入测试******* \n");
      int SPI_WRITE_STACH = 1；
      EDMA3_DRV_RESULT edmaResult = 0；
      gEdmaHandle_send = edma3init (0、&edmaResult)；
      if (edmaResult！= EDMA3_DRV_SOK)
      ｛
        /*报告 EDMA 错误*/
        VPS_printf ("********) DMA 驱动程序初始化失败********* \n");
      ｝
      其他
      ｛
        VPS_printf ("********) EDMA 驱动程序初始化通过********* \n");
      ｝
      utils_mcspiInit (test_MCSPI_INST0)；
      mcspiHandle_send = Utils_mcspiOpen (0、0、0、gEdmaHandle_send)；
      //vps_printf ("********) SPI1硬件初始化***** \n");
    //vps_printf ("********) SPI1硬件初始化结束********* \n");
      int i；
      静态 UINT16 SEND_CHECKSUM = 0；
      静态 uint32_t SEND_COUNT = 0；
      while (1)
      ｛
        SPI_Send_Buffer[0]= 0x12、
        SPI_Send_Buffer[1]= 0x34、
        SPI_Send_Buffer[2]= 0x56、
        SPI_Send_Buffer[3]= 0x78、
        SPI_Send_Buffer[4]=(uint8_t) error_count；
        SPI_Send_Buffer[5]=(uint8_t)(SEND_COUNT % 256)；
        对于(i=6；I < SPI_SEND_BUF_SIZE -2；i++)
        ｛
          SPI_Send_Buffer[i]= i % 256；
          /* System_printf ("%0x"、SPI_Send_Buffer[i])；
          System_printf (")；
          如果(I > 0 & I%60 = 0)
            System_printf ("\n")；*
        ｝
        SEND_CHECKSUM =(~(CalcCheckSum16 (SPI_Send_Buffer、(SPI_SEND_BUF_SIZE–2))))+ 1；
        SPI_Send_Buffer[SPI_SEND_BUF_SIZE-2]=(uint8_t)(SEND_CHECKSUM &(0x00ff))；
        SPI_Send_Buffer[SPI_SEND_BUF_SIZE-1]=(uint8_t)((SEND_CHECKSUM &(0xC0000))>>8)；
        SPI_WRITE_STY = Utils_mcspiWrite (mcspiHandle_send、SPI_Send_Buffer、SPI_SEND_BUF_SIZE)；//SPI_SEND_BUF_SIZE
        SEND_COUNT++；
        vps_printf ("***** SPI2结束写入***** SPI_WRITE_STACD:%d***发送校验和:%0X***发送计数:%d***** ",SPI_WRITE_STATUS,SEND_CHECKSUM,SEND_COUNT)；
         
        /*表示(i=0；i < SPI_SEND_BUF_SIZE；i++)
        ｛
          System_printf ("%0x"、SPI_Send_Buffer[i])；
          //System_printf (")；
          如果(I > 0 & I%60 = 0)
            System_printf ("\n")；
        ｝*/
        BspOSAL_SLEEP (2U)；
      ｝
    ｝
    #endif
    void Create_Mcspi_task()
    ｛
    如果已定义 DEBUG_SPI_READ
      BspOSAL_TaskHandle MCU_SPI_READ_TSK；
      MCU_SPI_READ_TSK =BspOsal_taskCreate (
                (BspOSAL_TaskFuncPtr) MCU_SPI_READ_work、
                "McuSpiReadWork"、
                SPI_RCV_TASK_PRI、
                &SPI_rcv_taskStack、
                SPI_RCV_STACK_SIZE、
                null、
                utils_TSK_Affinity_CORE0)；
      utils_assert (mcu_spi_read_tsk！= NULL)；
    #endif
    #if def定义 DEBUG_SPI_WRITE
      BspOSAL_TaskHandle MCU_SPI_WRITE_TSK；
      MCU_SPI_WRITE_TSK =BspOSAL_taskCreate (
                (BspOSAL_TaskFuncPtr) MCU_SPI_WRITE_work、
                "McuSpiWriteWork"、
                SPI_SEND_TASK_PRI、
                &SPI_SEND_taskStack、
                SPI_SEND_STACK_SIZE、
                null、
                utils_TSK_Affinity_CORE0)；
      utils_assert (MCU_SPI_WRITE_tsk！= NULL)；
    #endif
    ｝
    /*
    版权所有(c)[2012 - 2017] Texas Instruments Incorporated
    保留所有权利、此处未授予。
    有限许可。
     德州仪器公司授予全球范围内免专利费的非独占性
     根据其现在或以后拥有或控制的版权和专利授予的许可
     制作、 制作、使用、进口、要约出售和出售("利用")此软件
     受此处条款的约束。  对于上述专利许可、
     此类许可仅在 需要任何此类专利的情况下授予
     仅使用软件。  专利许可不适用于任何
     除与器件的组合之外、还包括此软件的组合
     由 TI 制造或为 TI 制造(以下简称"TI 器件")。  未授权硬件专利
     以下内容。
     重新分发必须保留现有的版权声明并复制此声明
     许可(包括上述版权声明和免责声明以及
     (如果适用)文档中的源代码许可限制)
     和/或随分发提供的其他材料
     允许以二进制形式重新分发和使用、无需修改
     前提是满足以下条件：
     *此软件不进行反向工程、反编译或反汇编
      以二进制形式提供的任何软件。
     * TI 仅许可对 TI 器件进行任何重新分发和使用。
     * TI 没有义务向您提供软件的源代码
      已获得许可并以目标代码提供给您。
     如果向您提供了软件源代码、请对进行修改和重新分发
     只要满足以下条件、就允许使用源代码：
     *源代码的任何重新分发和使用、包括任何结果
      衍生作品、TI 许可仅用于 TI 器件。
     *对从源代码编译的任何目标代码的任何重新分发和使用
      以及由此产生的任何衍生作品、TI 仅许可与 TI 一起使用
      器件。
     德州仪器公司的名称及其名称均不相同
     供应商可用于认可或推广从本软件衍生的产品
     未经特定的事先书面许可。
     免责声明。
     此软件由 TI 和 TI 的许可证颁发者"按原样"以及任何明示或
     默示保证、包括但不限于的默示保证
     不承认适销性和特定用途的适用性。
     在任何情况下、TI 和 TI 的许可人都不对任何直接、间接、
     附带、特殊、惩戒性或后果性损害(包括但不包括)
     仅限于采购替代产品或服务；丢失使用、数据或
     利润；或业务中断)
     责任、无论是合同责任、严格责任还是侵权行为(包括疏忽)
     或其他)以任何方式因使用本软件而产生、即使是
     被告知可能会发生此类损坏。
    *
    /**
     秘书长的报告
     *\file utils_mcspi.c
     *
     *\brief 此文件具有用于 UART 的实现
     *
     *\version 0.0 (2016年8月)：[PG]第一版
     *\version 0.1 (2017年10月)：针对4 McSPI 更新了[PG]
     *
     秘书长的报告
    *
    /*********
     * 包含文件
     秘书长的报告
     *
    #include
    #include
    #include
    #include
    #include
    #include
    #include
    #include
    #include
    #include
    #include
    #include
    #include
    //#include
    #include
    //#include
    #include
    #include
    #include
    #include
    #include
    #include
    #include
    #include
    #define UTILS_MCSPI_NUM_MCSPI_INST (4U)
    #define UTILS_MCSPI_NUM_DEVICES  (8U)
    /**要发布和回收的数字 bufs */
    #define UTILS_MCSPI_NUM_BUFS    (3U)
    静态 int read_FLAG = 0；
    /**\brief McSPI 配置参数*/
    静态 Mcspi_Params mcspiCfgPrms[utils_MCSPI_NUM_MCSPI_INST]；
    /**\McSPI 驱动程序名称的短字符串标识符*/
    静态 XDC_String gMcspiDriverNames [utils_MCSPI_NUM_MCSPI_INST]=
    ｛
      "/mcspi0"、
      "/mcspi1"、
      "/mcspi2"、
      "/mcspi3"
    }；
    /**
     * \brief 包含所需内容的 McSPI 通信句柄对象
     *      用于与 McSPI 器件通信的信息。
     *
    typedef 结构
    ｛
      uint32.       deviceIdx；
      /**<相应设备实例的设备索引*/
      gio_handle    mcspiHandle；
      /**< McSPI 的 GIO 句柄*/
      Gio_Params    mcspiIoPrms；
      /**<创建驱动程序时使用的 McSPI GIO 参数*/
      Mcspi_ChanParams mcspiChanParams；
      /**< McSPI 通道参数*/
    } Utils_mcspiDeviceCommObj；
    /**
     * \brief 指向雷达 McSPI 通信对象的指针。
     *
    typedef Utils_mcspiDeviceCommObj * Utils_mcspiCommHandle；
    /* MISRA.VAR.MIN.VIS
     * MISRAC_2004_Rule_8.7
     * MISRAC_PER弃权 声明：所有全局变量都在文件顶部定义
     *以提高代码的可读性和维护性。
     *
    静态 Utils_mcspiDeviceCommObj gUtils_mcspiDeviceCommObj[utils_MCSPI_NUM_DEVICS]；
    /*********
     * 函数声明
     秘书长的报告
     *
    /* MISRA.FUNC.NOPROT.CALL 规则8.2 FIX */
    静态内联空 ti_sysbios_io_gio_params_init (ti_sysbios_io_gio_params * PRMS)；
    /**
     秘书长的报告
     * \brief 用户定义的将初始化 McSPI 的函数。 此函数
     *      在创建 McSPI 驱动程序时调用。
     *
     *\返回 无
     *
     秘书长的报告
     *
    静态空 Utils_mcspiUserCommonInit (uint32_t mcSPINum)；
    静态空 Utils_mcspi0UserInit (void)；
    静态空 Utils_mcspi1UserInit(void);
    静态空 Utils_mcspi2UserInit (void)；
    静态空 Utils_mcspi3UserInit(void);
    int32 retval；
    /**
     秘书长的报告
     *
     *\brief 初始化 McSPI 并添加 GIO_Device
     *
     *\返回 无
     *
     秘书长的报告
     *
    空 Utils_mcspiInit (uint32 mcSpiInstNum)
    ｛
      if (mcSpiInstNum < utils_MCSPI_NUM_MCSPI_INST)
      ｛
        /*设置 mcspi 参数*/
        switch (mcSpiInstNum)
        ｛
          判例0U：PlatformMCSPI1SetPinMux()；
              RetVal = PMHALModuleModeSet (PMHAL_PRCM_MOD_MCSPI1、
            PMHAL_PRCM_MODULE_MODE_ENABLED、
            PM_TIMEOUT_INALEVINLETON_)
              Gio_addDevice (gMcspiDriverNames [mcSpiInstNum]、
              (XDC_PTR)和 Mcspi_IOMFXNS、
              Utils_mcspi0UserInit (&U)、
              (XDC_Int) mcSpiInstNum、(XDC_PTR)和(mcspiCfgPrms[mcSpiInstNum])；
              中断；
          案例1U：PlatformMCSPI2SetPinMux()；
              RetVal = PMHALModuleModeSet (PMHAL_PRCM_MOD_MCSPI2、
            PMHAL_PRCM_MODULE_MODE_ENABLED、
            PM_TIMEOUT_INALEVINLETON_)
              //vps_printf ("系统：mcspi 创建 (=%d)！！！ \n"、retval)；
              Gio_addDevice (gMcspiDriverNames [mcSpiInstNum]、
              (XDC_PTR)和 Mcspi_IOMFXNS、
              Utils_mcspi1UserInit (&U)、
              (XDC_Int) mcSpiInstNum、(XDC_PTR)和(mcspiCfgPrms[mcSpiInstNum])；
              //vps_printf ("********) Mcspi Init \n");
              //BSP_boardSelectDevice (BSP_DRV_ID_MCSPI、BSP_DEVICE_MCSPI_INST_ID_1)；
              中断；
          案例2U：/*设置非默认交叉开关*/
              IRQXBARConnect (SOC_IRQ_DMARQ_crossbar_register_base、
          #ifdef IPU_PRIMARY_CORE_IPU2
                    CPU_IPU2、XBAR_INST_IPU1_IRQ_59、MCSPI3_IRQ)；
          其他
                    CPU_IPU1、XBAR_INST_IPU1_IRQ_59、MCSPI3_IRQ)；
          #endif
              Gio_addDevice (gMcspiDriverNames [mcSpiInstNum]、
              (XDC_PTR)和 Mcspi_IOMFXNS、
              Utils_mcspi2UserInit (&U)、
              (XDC_Int) mcSpiInstNum、(XDC_PTR)和(mcspiCfgPrms[mcSpiInstNum])；
              bsp_boardSelectDevice (bsp_DRV_ID_MCSPI、bsp_device_mspi_INST_ID_2)；
              中断；
          案例3U：
              /*设置非默认交叉开关*/
              IRQXBARConnect (SOC_IRQ_DMARQ_crossbar_register_base、
          #ifdef IPU_PRIMARY_CORE_IPU2
                    CPU_IPU2、XBAR_INST_IPU1_IRQ_60、MCSPI4_IRQ)；
          其他
                    CPU_IPU1、XBAR_INST_IPU1_IRQ_60、MCSPI4_IRQ)；
          #endif
              Gio_addDevice (gMcspiDriverNames [mcSpiInstNum]、
              (XDC_PTR)和 Mcspi_IOMFXNS、
              Utils_mcspi3UserInit (&U)、
              (XDC_Int) mcSpiInstNum、(XDC_PTR)和(mcspiCfgPrms[mcSpiInstNum])；
              bsp_boardSelectDevice (bsp_DRV_ID_MCSPI、bsp_device_mspi_INST_ID_3)；
              中断；
          默认值：
              /*不应该来这里*/
              中断；
        ｝
      ｝
    ｝
    /**
     秘书长的报告
     *
     *\brief 会取消初始化 McSPI 并删除 GIO_Device
     *
     *\param mcSpiInstNum McSPI 实例编号
     *\返回 无
     *
     秘书长的报告
     *
    空 Utils_mcspiDeinit (uint32 mcSpiInstNum)
    ｛
      gio_removeDevice (gMcspiDriverNames [mcSpiInstNum])；
    ｝
    /**
     秘书长的报告
     *
     *\brief 获取 McSPI 设备名称
     *
     *\param mcSpiInstNum McSPI 实例编号
        API 返回的*\param DevName 设备名称。
     *\返回 无
     *
     秘书长的报告
     *
    空 Utils_mcspiGetDevName (uint32 mcSpiInstNum、XDC_String DevName)
    ｛
      if (mcSpiInstNum < utils_MCSPI_NUM_MCSPI_INST)
      ｛
        strcpy (DevName、gMcspiDriverNames [mcSpiInstNum])；
      ｝
    ｝
    /**
     秘书长的报告
     *
     *\brief 打开 McSPI 设备句柄
     *
     *\param deviceId      与之通信的器件的索引
     *\param mcSpiDevInstNum  McSPI 实例编号
     McSPI  实例的*\param mcSpiChannelNum 通道编号。
     *\param edmaHandle     用于 McSPI 传输的 EDMA 句柄。
     *
     *\return 指针到 mcspi 通信句柄的句柄。
     *
     秘书长的报告
     *
    void * Utils_mcspiOpen (uint8       DeviceID、
                uint8       mcSpiDevInstNum、
                uint8       mcSpiChannelNum、
                EDMA3_DRV_Handle edmaHandle)
    ｛
      utils_mcspiCommHandle commHnlfle =&gUtils_mcspiDeviceCommObj[deviceId]；
      静态 uint32 FIFO 启用[utils_MCSPI_NUM_MCSPI_INST]=｛0U、0U、0U、0U｝；
      void * returnHandle  = NULL；
      if (mcSpiDevInstNum < utils_MCSPI_NUM_MCSPI_INST)
      ｛
        ERROR_Block EB；
        ERROR_INIT (&EB)；
        /*
         *初始化通道属性。
         *
        gio_Params_init (&commHnle->mcspiIoPrms)；
        /*更新 McSPI 通道参数*/
        commhnlg->mcspiChanParams.hEdma = edmaHandle；
        commhnel->mcspiChanParams.chipSelTimeControl = MCSPI_CLK_CYCLE0；
        /*只能为一个通道启用 FIFO */
        if (fifoEnabled[mcSpiDevInstNum]= 0U)
        ｛
          commhnlg-> mcspiChanParams.fifoEnable      =(bool) true；
          FifoEnabled[mcSpiDevInstNum]= 1U；
        ｝
        其他
        ｛
          commhnlg-> mcspiChanParams.fifoEnable      =(bool) false；
        ｝
        commhnlng->mcspiChanParams.spiChipselectHold =(bool) true；// by zy false
        commhnlning->mcspiChanParams.chanNum = mcSpiChannelNum；
        /*如果正在使用交叉开关事件，则使 isCrossBarIntEn = true
         *和
         *选择要映射的相应中断编号(将其分配给
         * intNumToBeMapped)
         *
        /*横线设备已禁用*/
        commhnlg->mcspiChanParams.crossBarEvtParam.isCrossBarIntEn =
          (bool) false；
        /*编程无效值*/
        commhfLs->mcspiChanParams.crossBarEvtParam.intNumToBeMapped = 0xFF；
        commhnlng->mcspiIoPrms.chanParams =(PTR)& commhnlg->mcspiChanParams；
        commhlng->mcspiIoPrms.model   = GIO_Model_ISSUERECLAIM；
        commhlng->mcspiIoPrms.numPacfets = utils_MCSPI_NUM_BUFS + 1U；
        commhlning->deviceIdx =(UINT32) deviceId；
        commhlng->mcspiHandle =(GIO_Handle) GIO_CREATE (
          (XDC_String) gMcspiDriverNames [mcSpiDevInstNum]、(UINT32) GIO_INOUT、
          &commHnge->mcspiIoPrms，&EB)；
        if (commhnlng->mcspiHandle ==空)
        ｛
          vps_printf (" utils_MCSPI：McSPI GIO 创建失败！！！\r\n")；
        ｝
        返回手柄=(void *)服服；
      ｝
      其他
      ｛
        返回手柄=空；
      ｝
      返回手柄；
    ｝
    /**
     秘书长的报告
     *
     *\brief 关闭 McSPI 设备句柄
     *
     *\param fd  指向 McSPI 通信句柄的指针。
     *
     *\return system_link_status_sok
     *
     秘书长的报告
     *
    int32 Utils_mcspiClose (void * FD)
    ｛
      utils_mcspiCommHandle commHnlfg=(Utils_mcspiCommHandle) fd；
      gio_delete (((gio_handle *)&commHnale->mcspiHandle)；
      返回 SYSTEM_LINK_STATUS_SOK；
    ｝
    /**
     秘书长的报告
     *
     *\brief 函数、用于从 McSPI 器件读取数据
     *
     *\param fd  指向 McSPI 通信句柄的指针。
     *\param pBuff 指针指向要向其写入数据的缓冲区。
     *\param len 要  读取的字节数。
     *
     *\return system_link_status_sok、如果操作成功、
     *      否则为 SYSTEM_LINK_STATUS_EFAIL。
     *
     秘书长的报告
     *
    int32 Utils_mcspiRead (void * fd、uint8 * pBuff、uint16 len)
    ｛
      uint32.           尺寸        = 0U；
      内部             状态       = IOM_Completed；
      Mcspi_DataParam       issueDataparam  =｛0｝；
      Mcspi_DataParam       RelaimDataparam =｛0｝；
      PTR             pReclaimDataParam；
      Int32.            RetVal  = SYSTEM_LINK_STATUS_SOK；
      utils_mcspiCommHandle commHnlfg=(Utils_mcspiCommHandle) fd；
      //Mcspi_FifoTrigLevel      五流五流五流五流
      issueDataparam.inBuffer =(UINT8 *) pBuff；
      issueDataparam.bufLen  =(uint32) len；
      如果((uint32) len > 0x1000U)
      ｛
        /*如果满足此条件，则会出现问题*/
        vps_printf (" utils_mcspi：请求的读取太大！！ 长度=%x\r\n"、
             (uint32)len);
        RetVal = SYSTEM_LINK_STATUS_EFAIL；
      ｝
      if (RetVal = system_link_status_Sok)
      ｛
        /*如果(len <(uint16) 32)
        ｛
           fifoLevel.rxTriggerLevel = len；
           fifoLevel.txTriggerLevel = len；
        ｝
        其他
        ｛
           fifoLevel.rxTriggerLevel = 32；
           fifoLevel.txTriggerLevel=32;
        ｝*/
        //vps_printf ("********) SPI 立即阅读 ********* \n");
        issueDataparam.outBuffer =空；
        大小=(uint32) len；
        /* status = GIO_CONTROL (commHnlle->mcspiHandle、IOCTL_MCSPI_SET_TRIGGER_LVL、
                   五音级别(&F)；*/
        //vps_printf ("********) SPI 立即阅读 2******* \n");
        if (IOM _已完成==状态)
        ｛
          如果(READ_FLAG = 0)
          ｛
            状态= GIO_Issue (commHnge->mcspiHandle、&issueDataparam、Size、
                    null)；
            READ_FLAG = 1；
          ｝
          /*向输入流发出第一个和第二个空缓冲区*/
          状态= GIO_Issue (commHnge->mcspiHandle、&issueDataparam、Size、
                    null)；
        ｝
        //vps_printf ("********) SPI 立即阅读 3******* \n");
        if ((status！= IOM_PENDING)&&(status！= IOM_Completed))
        ｛
          vps_printf (" utils_mcspi：无法发出空缓冲区进行流式传输！！！\r\n")；
        ｝
        /*回收在每个问题后完成，缓冲区未被灌注。 如果
         *缓冲区被作为前一个传输的开始，下一个传输将立即初始化
         *第一个已完成。 我们无法确保传输
         *在主器件上初始化第二个缓冲区之前的从器件
         *
        pReclaimDataParam =(ptr)& reimDataparam；
        状态=
          gio_rema回收(((gio_Object *) commHnlle->mcspiHandle、
                (ptr *) pReclaimDataParam (&P)、
                null、
                null)；
        //vps_printf ("********) SPI 立即阅读 4***** \n");
        if (IOM _已完成！=状态)
        ｛
          vps_printf (" utils_mcspi：SPI 读取失败\r\n)；
          RetVal = SYSTEM_LINK_STATUS_EFAIL；
        ｝
        其他
        ｛
          RetVal =(Int32) len；
        ｝
        //vps_printf ("********) SPI 立即阅读 5 ***** \n");
      ｝
      //vps_printf ("********) SPI 立即阅读 ********* \n");
      返回 RetVal；
       
    ｝
    /**
     秘书长的报告
     *
     *\brief 函数、用于写入 McSPI 器件
     *
     *\param fd  指向 McSPI 通信句柄的指针。
     *\param pBuff 指针指向要向其写入数据的缓冲区。
     *\param len 要  读取的字节数。
     *
     *\return system_link_status_sok、如果操作成功、
     *      否则为 SYSTEM_LINK_STATUS_EFAIL。
     *
     秘书长的报告
     *
    int32 Utils_mcspiWrite (void * FD、uint8 * pBuff、uint16 len)
    ｛
      uint32.           尺寸        = 0；
      内部             状态       = IOM_Completed；
      Mcspi_DataParam       issueDataparam  =｛0｝；
      Mcspi_DataParam       RelaimDataparam =｛0｝；
      PTR             pReclaimDataparam；
      Int32.            RetVal  = SYSTEM_LINK_STATUS_SOK；
      utils_mcspiCommHandle commHnlfg=(Utils_mcspiCommHandle) fd；
      //Mcspi_FifoTrigLevel      五流五流五流五流
      issueDataparam.outBuffer =(uint8 *) pBuff；
      issueDataparam.bufLen  =(uint32) len；
      issueDataparam.inBuffer =空；
      大小=(uint32) len；
      /*如果(len <(uint16) 32)
      ｛
         fifoLevel.rxTriggerLevel = len；
         fifoLevel.txTriggerLevel = len；
      ｝
      其他
      ｛
         fifoLevel.rxTriggerLevel = 32；
         fifoLevel.txTriggerLevel=32;
      ｝*/
      //vps_printf ("********) SPI 立即写入 1***** \n");
      /* status = GIO_CONTROL (commHnlle->mcspiHandle、IOCTL_MCSPI_SET_TRIGGER_LVL、
                 五音级别(&F)；*/
       
      //vps_printf ("********) SPI 立即写入 2***** %d ******** ",status);
      if (IOM _已完成==状态)
      ｛
        /*向输入流发出第一个和第二个空缓冲区*/
        状态= GIO_Issue (commHnge->mcspiHandle、&issueDataparam、Size、
                null)；
        //vps_printf ("********) Gio_Issue 成功********* \n");
      ｝
      if ((status！= IOM_PENDING)&&(status！= IOM_Completed))
      ｛
        vps_printf (" utils_mcspi：无法发出空缓冲区进行流式传输！！！\r\n")；
      ｝
      /*回收在每个问题后完成，缓冲区未被灌注。 如果
       *缓冲区被作为前一个传输的开始，下一个传输将立即初始化
       *第一个已完成。 我们无法确保传输
       *在主器件上初始化第二个缓冲区之前的从器件
       *
      pReclaimDataparam =(PTR)& reimDataparam；
      //vps_printf ("********) SPI 立即写入 3********* \n");
      状态=
        Gio_rema回收(commHnlng->mcspiHandle、
              (ptr *) pReclaimDataparam (&P)、
              null、
              null)；
      //vps_printf ("********) SPI 立即写入 4***** \n");
      if (IOM _已完成！=状态)
      ｛
        vps_printf (" utils_mcspi：SPI 写入失败\r\n)；
        RetVal = SYSTEM_LINK_STATUS_EFAIL；
      ｝
      其他
      ｛
        RetVal =(Int32) len；
      ｝
      返回 RetVal；
    ｝
    静态空 Utils_mcspi0UserInit (空)
    ｛
      utils_mcspiUserCommonInit (0U)；
    ｝
    静态空 Utils_mcspi1UserInit (空)
    ｛
      utils_mcspiUserCommonInit (1U)；
    ｝
    静态空 Utils_mcspi2UserInit (空)
    ｛
      utils_mcspiUserCommonInit (2U)；
    ｝
    静态空 Utils_mcspi3UserInit (空)
    ｛
      utils_mcspiUserCommonInit (3U)；
    ｝
    静态空 Utils_mcspiUserCommonInit (uint32_t mcSPINum)
    ｛
      uint32    i = 0U；
      静态 uint32_t done = 0U；
      如果(DONE ==0U)
      ｛
        Mcspi_init()；
        完成= 1U；
      ｝
      memcpy ((void *)&mcspiCfgPrms[mcSPINum]、(const void *)&Mcspi_Params、sizeof (Mcspi_Params))；
      /*设置 McSPI 参数*/
      mcspiCfgPrms[mcSPINum].instNum = mcSPINum；
      mcspiCfgPrms[mcSPINum].opMode      = MCSPI_OPMODE_DMAINTERRUPT；//by zy MCSPI_OPMODE_DMAINTERRUPT
      mcspiCfgPrms[mcSPINum].hwiNumber    = 7；
      mcspiCfgPrms[mcSPINum].enableCache   =(uint32) true；
      mcspiCfgPrms[mcSPINum].edma3EventQueue = 0；
      mcspiCfgPrms[mcSPINum].enableErrIntr  =(uint32) false；
    #ifdef A15_target_os_Linux
      mcspiCfgPrms[mcSPINum].prcmPwrmEnable = false；
    其他
      mcspiCfgPrms[mcSPINum].prcmPwrmEnable = true；
    #endif
      如果(mcSPINum == 0U)
      ｛
        mcspiCfgPrms[mcSPINum].spiHWCfgData.masterOrSlave      = MCSPI_COMMMODE_MASTER；//y
      ｝
      else /*重新设置SPI2的Slave模式*/
      ｛
        VPS_printf ("********) 设置 SPI2从模式***** \n");
        mcspiCfgPrms[mcSPINum].spiHWCfgData.masterOrSlave      = MCSPI_COMMMODE_SLAVE；//y
      ｝  
      mcspiCfgPrms[mcSPINum].spiHWCfgData.singleOrMultiChEnable = MCSPI_SINGLE_CHANNEL；//y
      mcspiCfgPrms[mcSPINum].spiHWCfgData.pinOpModes  = MCSPI_PINOPMODE_4引脚；
      如果(mcSPINum == 0U)
      ｛
        mcspiCfgPrms[mcSPINum].spiHWCfgData.fifoRxTrigLevel = 64；
        mcspiCfgPrms[mcSPINum].spiHWCfgData.fifoTxTrigLevel = 64；
      ｝
      else /*重新设置SPI2的触发*/
      ｛
        mcspiCfgPrms[mcSPINum].spiHWCfgData.fifoRxTrigLevel = 16；
        mcspiCfgPrms[mcSPINum].spiHWCfgData.fifoTxTrigLevel = 16；
      ｝
      对于(I = 0U；I < CSL_MCSPI_0_NumOfPhyChannels；I++)
      ｛
        mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].charLength = MCSPI_LEN_8bit；//zy
        mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].multiWordAccessEnable =
          (uint32) false；
        mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].spiChipSelectEnablePol =
          (uint32) false；
        mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].clockMode =
          MCSPI_MODE0；//时钟的极性和相位设置，y
        mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].clockRatioExtension = 0；
        mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].spiWordInitDelay  =
          MCSPI_NO_DELAY；
        mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].trasmitReceiveMode =
          MCSPI_BLE_RxTx；
        mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].granularityEnable =
          (uint32) true；
    #IF 定义(TDA3XX_AR12_ALPS)
        /* 8MHz 总线频率*/
        mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].busFreq       = 80000；
    其他
        /* 24MHz 总线频率*/
        mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].busFreq       = 1000000；//1MHz、采用 y
    #endif
        mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].spienHighPolarity =
          (uint32) false；//POL=0、y
        mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].slaveModeChipSelect =
          MCSPI_SPIE_0；
        如果(mcSPINum == 0U)
        ｛
          mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].spiDat0Dir = MCSPI_OUT；//y
          mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].spiDat1Dir = MCSPI_IN；//y
        ｝
        else /*重新设置SPI2的IN OUT引脚*/
        ｛
          //vps_printf ("********) 将 SPI2置为 Out ******* \n");
          mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].spiDat0Dir = MCSPI_IN；//y
          mcspiCfgPrms[mcSPINum].spiHWCfgData.configChfmt[i].spiDat1Dir = MCSPI_OUT；//y
        ｝
      ｝
      if (MCSPI_OPMODE_INTERRUPT = mcspiCfgPrms[mcSPINum].opMode)
      ｛
        vps_printf (" utils_mcspi：McSPI 配置为中断模式！！！\r\n")；
      ｝
    ｝

    寄存器

    McSPI1物理层

    地址

    值

    McSPI2物理层

    地址

    值

    MCSPI_HL_REV

    0x48098000

    0x4030120B

    0x4809A000

    0x4030120B

    MCSPI_HL_hwinfo

    0x48098004

    0x00000011.

    0x4809A004

    0x00000011.

    MCSPI_HL_SysConfig

    0x48098010

    0x00000004

    0x4809A010

    0x00000004

    MCSPI_REVISION

    0x48098100

    0x0000002B

    0x4809A100

    0x0000002B

    MCSPI_SysConfig

    0x48098110

    0x00000308

    0x4809A110

    0x00000308

    MCSPI_SYSSTATUS

    0x48098114

    0x00000001

    0x4809A114

    0x00000001

    MCSPI_IRQSTATUS

    0x48098118

    0x00000000

    0x4809A118

    0x0001000B

    MCSPI_IRQENABLE

    0x4809811C

    0x00020000

    0x4809A11C

    0x0000000C

    MCSPI_WAKEUPENABLE

    0x48098120

    0x00000000

    0x4809A120

    0x00000000

    MCSPI_SYST

    0x48098124

    0x00000000

    0x4809A124

    0x00000000

    MCSPI_MODULCTRL

    0x48098128

    0x00000101

    0x4809A128

    0x00000104

    MCSPI_CHxCONF (1)

    0x4809812C

    0x380603FC

    0x4809A12C

    0x180103C0

    MCSPI_CHxSTAT (1)

    0x48098130

    0x0000002E

    0x4809A130

    0x00000003

    MCSPI_CHxCTRL (1)

    0x48098134

    0x00000200

    0x4809A134

    0x00000000

    MCSPI_TXx (1)

    0x48098138

    0x0000003A

    0x4809A138

    0x00000000

    MCSPI_Rxx (1)

    0x4809813C

    0x000000FF

    0x4809A13C

    0x0000000B

    MCSPI_XFERLEVEL

    0x4809817C

    0x00003F3F

    0x4809A17C

    0x00000F0F

    MCSPI_DAFTX

    0x48098180

    0x0000003A

    0x4809A180

    0x00000000

    MCSPI_DAFRX

    0x480981A0

    0x000000FF

    0x4809A1A0

    0x0000000D

     

    在这种情况下：“*错误*行：276，文件：src/bsp_mcspi.c - Rx 溢出中断”，获取寄存器值。

     

    使用 McSPI1作为主器件、使用通道0、仅一个任务、 它运行良好。

     

    使用 McSPI2作为从机，使用通道0，中断模式；只有一个任务，它运行良好。但许多任务正在运行，显示了这一点

    ：“*错误*行：276，文件：src/bsp_mcspi.c - Rx 溢出中断”，

     

    如何解决？  谢谢。

     

     

  • 0
    TI__Guru**** 2539500 points
    请注意，本文内容源自机器翻译，可能存在语法或其它翻译错误，仅供参考。如需获取准确内容，请参阅链接中的英语原文或自行翻译。

    您好！

    您附加了哪些文件？
    他们是 TI 的交付产品吗？

    此致、
    Prasad