[参考译文] LP-MSPM0G3507：将数据从 Rx 缓冲区传输到帧(由我们创建)

您好、 Abhaya

确保 M0G 已以正确的帧结构发送正确的读取命令。

按照7.3.2中所示的说明操作：

具有功能安全的 BQ79600-Q1汽车类 SPI/UART 通信接口数据表(修订版 A)

此致、

赫利克

大家好、我只使用了相同的示例代码命令、它完美地将信号发送到唤醒器件等、但问题发生在 Rx 侧。

执行｛channel = 0；currentBoard = 0；delayus (192+5* TOTALBOARDS)；ReadReg (0、VCELL16_HI+(16-ACTIVECHANNELS)* 2、 Response_FRAME、ACTIVECHANNELS*2、0、FRMWRT_STK_R)；ReadReg (0、 GPIO1_HI+(8-ACTIVECHANNELS)*2、RESPON_FRAME_T、ACTIVECHANNELS*2、0、FRMWRT_STK_R)； ＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊＊ *注意:有些计算机在通过 printf 语句接收大量数据时会出现问题。 *以下响应数据打印输出*不保证在所有系统上都能正常工作。 ＊＊ */ printf ("\n")；//开始换行以在每个循环之间增加一些额外的间距//如果没有桥接设备(currentBoard=0；currentBoard<(BRIDGEDEVICE=1？)，则只读取/打印基本设备的数据 TOTALBOARDS-1：TOTALBOARDS)；currentBoard++)｛printf (Board %d：\t"、TOTALBOARDS-CURRENTBOARDS-CURRENTBOAR-1)；//打印每个活动通道(每个通道2字节)的数据(CHANNE=0；CHANNE<(ACTIVECHANLS*2)

您好、 Abhaya

您好、您是否使用 printf 进行调试？ 确保它运行良好。

或者 逻辑分析仪或在调试模式下观察 rx_buf 将会有所帮助。

您可以使用"插入"-  下面的代码以插入代码块。

此致、

赫利克

例如、我使用 printf 打印响应帧中应该出现的电压值、但 仅打印0。

我也使用逻辑分析仪进行了检查、BQ7900表现出完美的效果、Rx 缓冲区也在不断更新。  

 do
    {
        channel = 0;
        currentBoard = 0;
        delayus(192+5*TOTALBOARDS);
        ReadReg(0, VCELL16_HI+(16-ACTIVECHANNELS)*2, response_frame, ACTIVECHANNELS*2, 0, FRMWRT_STK_R);
        ReadReg(0, GPIO1_HI+(8-ACTIVECHANNELS)*2, response_frame_T, ACTIVECHANNELS*2, 0, FRMWRT_STK_R);
        /*
         * ***********************************************
         * NOTE: SOME COMPUTERS HAVE ISSUES RECEIVING
         * A LARGE AMOUNT OF DATA VIA printf STATEMENTS.         * THE FOLLOWING PRINTOUT OF THE RESPONSE DATA
         * IS NOT GUARANTEED TO WORK ON ALL SYSTEMS.
         * ***********************************************
        */

        printf("\n"); //start with a newline to add some extra spacing between each loop
        //only read/print the base device's data if there is no bridge device
        for(currentBoard=0; currentBoard<( BRIDGEDEVICE==1 ? TOTALBOARDS-1 : TOTALBOARDS); currentBoard++)
        {
            printf("BOARD %d:\t",TOTALBOARDS-currentBoard-1);
            //print the data from each active channel (2 bytes each channel)
            for(channel=0; channel<(ACTIVECHANNELS*2); channel+=2)
            {
                int boardByteStart = (ACTIVECHANNELS*2+6)*currentBoard;
                uint16 rawData = (response_frame[boardByteStart+channel+4] << 8) | response_frame[boardByteStart+channel+5];
                float cellVoltage = rawData*0.00019073; //rawData*VLSB_ADC
                printf("%f\t", cellVoltage);
            }


            printf("\n"); //newline per board
        }

    }while(1);

您好、 Abhaya

Unknown 说：

BQ7900正完美地发送了一些值

检查此返回值是否正确。 同时、通过逻辑分析仪检查 M0发送读取命令是否正确。
需要了解哪个零件工作异常。

此致、

赫利克

如果您使用的是 RX 中断、请在中断中放入一个断点。

好的、我也会尝试  

您好、该超运行寄存器设置为11、

OVRERR 1 -设置 UART 接收溢出错误。向该位写入无效。 向 UART EVENT ICLR 寄存器中的 OVRERR 位写入1即可清除该标志。 在发生接收 FIFO 上溢的情况下、FIFO 的内容将保持有效、因为当 FIFO 已满时不会再写入任何数据。 只有移位寄存器的内容会被覆盖。 此时、CPU 必须读取数据以便将 FIFO 清空。

您能告诉我解决办法吗？

您好！  

OVRERR=1表示 Rx FIFO 中有数据需要读出、并且 已经有数据因 FIFO 已满而被丢弃。

请参阅 SDK 中的以下代码示例：  

C：\ti\mspm0_sdk_1_20_01_06\examples\nortos\lp_MSPM0G3507\driverlib\uart_rw_multibyte_fifo_poll

或 Web 链接：

uart_rw_multibyte_fifo_poll

此致、

赫利克

您好、 Abhaya Raj Mishra

我 多次使用此示例。 没有发现任何问题。

Unknown 说：

但是此示例代码可能存在一些问题，但它没有实现。  [/报价]

您会遇到什么问题？

Unknown 说：

或者一个 逻辑分析仪或在调试模式下观察 rx_buf 将会有所帮助。

我仍然建议 尝试  使用调试模式或逻辑分析仪观察 UART Tx 和 Rx 数据。

此致、

赫利克

[/quote]

您好！  

请遵循自述文件和自述文件-代码示例的使用示例。

Update the jumpers to connect RX and TX between two UART devices.

uart_rw_multibyte_fifo_poll

本例 展示了如何通过 UART 与其他器件进行通信。

Unknown 说：

但我检查了数据来自 BQ79600的 Tx 引脚、该引脚连接到 LP-MSPM0G3507的 Rx 引脚、Rx 缓冲区也在获取数据、但没有传输到响应帧。

检查此 Rx 缓冲区是否正确、以及为什么不在调试模式下通过在传输函数处添加断点来发送响应。

此致、

赫利克

我用断点进行了检查  

它在循环这里  

__static_inline bool DL_UART_isRXFIFOmpty (UART_Regs *UART)
{
返回((UART->STAT 和 UART_STAT_RXFE_MASK)== UART_STAT_RXFE_SET)；
｝

您好、 Abhaya

M0仍在等待来自 UART 的新数据。

卡在这里后、您需要检查原因、检查接收缓冲区。

在 CCS Debug 窗口中、 检查断点处的函数嵌套、如下图所示、该操作有助于找出调用 isRXFIFOEMpty 的函数。

请参阅数据表7.3.2以检查 M0和 BQ 之间的数据。

具有功能安全的 BQ79600-Q1汽车类 SPI/UART 通信接口数据表(修订版 A)

此致、

赫利克

好的、但同时 发生 OVRERR 1置位、也会发生这种情况。  

您好、 Abhaya

您是否使用逻辑分析仪在 M0的 Rx 端口上看到任何数据？

顺便说一下、

如果程序正在等待接收数据、则代码应为：

while(DL_UART_isRXFIFOEmpty(UART0));

UARTRxBuffer = UART0.RXDATA.

此致、

赫利克

好的、我也会尝试这个。

但是、您能告诉我在 UART 的内部环回模式下收到的错误吗？

您好、 Abhaya

声明为内联的函数可能会导致这种情况。

这些函数通常只有几行代码、并且经常被调用。

这不是错误。

您知道程序可以执行延迟函数、如果您有兴趣、可以查看反汇编。

此致、

赫利克

那么、需要对此做些什么呢？

没有必要做任何事情。

但此回送 Ex 代码不起作用。  

这会在我们开始调试并运行时自动弹出。

Unknown 说：

但是此回送 Ex 代码不起作用。  [/报价]

此内部环回示例代码将在成功时切换 LED。

在调试模式下点击"开始"按钮后、您会看到红色 LED 的切换速度非常快。

每次红色 LED 切换都意味着 UART 发送数据与 UART 接收数据相同、这意味着它是有效的。

Unknown 说：

直接在我们开始调试并运行时将会弹出此消息。

它停在这里？ 弹出时、请向我显示您的调试窗口。

——

如果要测试 UART 与另一个器件的通信、 请尝试使用外部环回示例。

此致、

赫利克

[/quote]

好的、并且 LED 也不在切换。  

与前面的查询相关、这里是逻辑分析仪数据以及 RX 缓冲区和中断抓图。

在逻辑分析仪图像中、通道0 是 TX 数据、通道1是 Rx 数据。 它与循环粘滞的数据是相同的。

逻辑分析仪：  

Rx 数据和缓冲器以及中断：  

我无法从您的逻辑分析仪屏幕截图中获得任何有用信息

有什么建议吗？

您好、 Abhaya

我建议您使用调试来查看发送和接收函数中的数据是否正确。

从您的屏幕截图中,它应该是 AutoAddress()。 检查以下函数以查找 Tx 和 Rx 缓冲器。

同时、使用逻辑分析仪来捕获 Tx 和 Rx 数据线路。

此致、

赫利克

AutoAddress()内部有一些 readreg()指令，  

此代码仅来自 BQ7900 UART 示例代码的示例代码。

在这种情况下、第一条 readreg 语句正在实现、但在第二条语句中、它被卡住。

您好、对于波特率1Mbps、对于 UART、时钟频率应该是多少？

您能告诉我吗。

您好、 Abhaya

您需要保留以下代码：

  波特率* 过采样<= 时钟源

如果缺省 过采样= 16倍且波特率= 1M。

时钟源应>= 16 MHz。 建议使用32MHz。

您还应将"Calculated Error (%)<= 1%。

此致、

赫利克

首先、我使用的是32MHz、对16进行过采样。

太棒了！

void AutoAddress()
{
    //DUMMY WRITE TO SNCHRONIZE ALL DAISY CHAIN DEVICES DLL (IF A DEVICE RESET OCCURED PRIOR TO THIS)
    WriteReg(0, OTP_ECC_DATAIN1, 0X00, 1, FRMWRT_STK_W);   // I'm changing it to all write from stk_w, tried did't worked
    WriteReg(0, OTP_ECC_DATAIN2, 0X00, 1, FRMWRT_STK_W);
    WriteReg(0, OTP_ECC_DATAIN3, 0X00, 1, FRMWRT_STK_W);
    WriteReg(0, OTP_ECC_DATAIN4, 0X00, 1, FRMWRT_STK_W);
    WriteReg(0, OTP_ECC_DATAIN5, 0X00, 1, FRMWRT_STK_W);
    WriteReg(0, OTP_ECC_DATAIN6, 0X00, 1, FRMWRT_STK_W);
    WriteReg(0, OTP_ECC_DATAIN7, 0X00, 1, FRMWRT_STK_W);
    WriteReg(0, OTP_ECC_DATAIN8, 0X00, 1, FRMWRT_STK_W);

    //ENABLE AUTO ADDRESSING MODE
    WriteReg(0, CONTROL1, 0X01, 1, FRMWRT_ALL_W);

    //SET ADDRESSES FOR EVERY BOARD
    for(currentBoard=0; currentBoard<TOTALBOARDS; currentBoard++)
    {
        WriteReg(0, DIR0_ADDR, currentBoard, 1, FRMWRT_ALL_W);
    }

    //BROADCAST WRITE TO SET ALL DEVICES AS STACK DEVICE
    WriteReg(0, COMM_CTRL, 0x02, 1, FRMWRT_ALL_W);

    //SET THE HIGHEST DEVICE IN THE STACK AS BOTH STACK AND TOP OF STACK
    //WriteReg(TOTALBOARDS-1, COMM_CTRL, 0x03, 1, FRMWRT_SGL_W);
    // insted of this Kartik code
    if(TOTALBOARDS==1) //if there's only 1 board, it's the base AND top of stack, so change it to those
     {
         WriteReg(0, COMM_CTRL, 0x01, 1, FRMWRT_SGL_W);
     }
     else //otherwise set the base and top of stack individually
     {
         WriteReg(0, COMM_CTRL, 0x00, 1, FRMWRT_SGL_W);
         WriteReg(TOTALBOARDS-1, COMM_CTRL, 0x03, 1, FRMWRT_SGL_W);
     }

    //SYNCRHONIZE THE DLL WITH A THROW-AWAY READ
    // I tried to change this for the single read configuration (didn't worked) - Abhaya raj mishra
    ReadReg(0, OTP_ECC_DATAIN1, autoaddr_response_frame, 1, 0, FRMWRT_STK_R);    // changing all to all read from stk_r, tried did't worked
    ReadReg(0, OTP_ECC_DATAIN2, autoaddr_response_frame, 1, 0, FRMWRT_STK_R);
    ReadReg(0, OTP_ECC_DATAIN3, autoaddr_response_frame, 1, 0, FRMWRT_STK_R);
    ReadReg(0, OTP_ECC_DATAIN4, autoaddr_response_frame, 1, 0, FRMWRT_STK_R);
    ReadReg(0, OTP_ECC_DATAIN5, autoaddr_response_frame, 1, 0, FRMWRT_STK_R);
    ReadReg(0, OTP_ECC_DATAIN6, autoaddr_response_frame, 1, 0, FRMWRT_STK_R);
    ReadReg(0, OTP_ECC_DATAIN7, autoaddr_response_frame, 1, 0, FRMWRT_STK_R);
    ReadReg(0, OTP_ECC_DATAIN8, autoaddr_response_frame, 1, 0, FRMWRT_STK_R);

    //OPTIONAL: read back all device addresses
//    for(currentBoard=0; currentBoard<TOTALBOARDS; currentBoard++)
//    {
//        ReadReg(currentBoard, DIR0_ADDR, autoaddr_response_frame, 1, 0, FRMWRT_SGL_R);
//    }
//
    //OPTIONAL: read register address 0x2001 and verify that the value is 0x14
//    ReadReg(0, 0x2001, autoaddr_response_frame, 1, 0, FRMWRT_SGL_R);
// ************
    //RESET ANY COMM FAULT CONDITIONS FROM STARTUP
     WriteReg(0, FAULT_RST2, 0x03, 1, FRMWRT_ALL_W);

    return;
}

//**************************
//END AUTO ADDRESS SEQUENCE
//**************************


//************************
//WRITE AND READ FUNCTIONS
//************************

//FORMAT WRITE DATA, SEND TO
//BE COMBINED WITH REST OF FRAME
int WriteReg(BYTE bID, uint16 wAddr, uint64 dwData, BYTE bLen, BYTE bWriteType) {
    // device address, register start address, data bytes, data length, write type (single, broadcast, stack)
    memset(bBuf,0,sizeof(bBuf));
    switch (bLen) {
    case 1:
        bBuf[0] = dwData & 0x00000000000000FF;
        bRes = WriteFrame(bID, wAddr, bBuf, 1, bWriteType);
        break;
    case 2:
        bBuf[0] = (dwData & 0x000000000000FF00) >> 8;
        bBuf[1] = dwData & 0x00000000000000FF;
        bRes = WriteFrame(bID, wAddr, bBuf, 2, bWriteType);
        break;
    case 3:
        bBuf[0] = (dwData & 0x0000000000FF0000) >> 16;
        bBuf[1] = (dwData & 0x000000000000FF00) >> 8;
        bBuf[2] = dwData & 0x00000000000000FF;
        bRes = WriteFrame(bID, wAddr, bBuf, 3, bWriteType);
        break;
    case 4:
        bBuf[0] = (dwData & 0x00000000FF000000) >> 24;
        bBuf[1] = (dwData & 0x0000000000FF0000) >> 16;
        bBuf[2] = (dwData & 0x000000000000FF00) >> 8;
        bBuf[3] = dwData & 0x00000000000000FF;
        bRes = WriteFrame(bID, wAddr, bBuf, 4, bWriteType);
        break;
    case 5:
        bBuf[0] = (dwData & 0x000000FF00000000) >> 32;
        bBuf[1] = (dwData & 0x00000000FF000000) >> 24;
        bBuf[2] = (dwData & 0x0000000000FF0000) >> 16;
        bBuf[3] = (dwData & 0x000000000000FF00) >> 8;
        bBuf[4] = dwData & 0x00000000000000FF;
        bRes = WriteFrame(bID, wAddr, bBuf, 5, bWriteType);
        break;
    case 6:
        bBuf[0] = (dwData & 0x0000FF0000000000) >> 40;
        bBuf[1] = (dwData & 0x000000FF00000000) >> 32;
        bBuf[2] = (dwData & 0x00000000FF000000) >> 24;
        bBuf[3] = (dwData & 0x0000000000FF0000) >> 16;
        bBuf[4] = (dwData & 0x000000000000FF00) >> 8;
        bBuf[5] = dwData & 0x00000000000000FF;
        bRes = WriteFrame(bID, wAddr, bBuf, 6, bWriteType);
        break;
    case 7:
        bBuf[0] = (dwData & 0x00FF000000000000) >> 48;
        bBuf[1] = (dwData & 0x0000FF0000000000) >> 40;
        bBuf[2] = (dwData & 0x000000FF00000000) >> 32;
        bBuf[3] = (dwData & 0x00000000FF000000) >> 24;
        bBuf[4] = (dwData & 0x0000000000FF0000) >> 16;
        bBuf[5] = (dwData & 0x000000000000FF00) >> 8;
        bBuf[6] = dwData & 0x00000000000000FF;
        bRes = WriteFrame(bID, wAddr, bBuf, 7, bWriteType);
        break;
    case 8:
        bBuf[0] = (dwData & 0xFF00000000000000) >> 56;
        bBuf[1] = (dwData & 0x00FF000000000000) >> 48;
        bBuf[2] = (dwData & 0x0000FF0000000000) >> 40;
        bBuf[3] = (dwData & 0x000000FF00000000) >> 32;
        bBuf[4] = (dwData & 0x00000000FF000000) >> 24;
        bBuf[5] = (dwData & 0x0000000000FF0000) >> 16;
        bBuf[6] = (dwData & 0x000000000000FF00) >> 8;
        bBuf[7] = dwData & 0x00000000000000FF;
        bRes = WriteFrame(bID, wAddr, bBuf, 8, bWriteType);
        break;
    default:
        break;
    }
    return bRes;
}


int WriteFrame(BYTE bID, uint16 wAddr, BYTE * pData, BYTE bLen, BYTE bWriteType) {
    int bPktLen = 0;
    uint8 * pBuf = pFrame;
    memset(pFrame, 0x7F, sizeof(pFrame));
    *pBuf++ = 0x80 | (bWriteType) | ((bWriteType & 0x10) ? bLen - 0x01 : 0x00); //Only include blen if it is a write; Writes are 0x90, 0xB0, 0xD0
    if (bWriteType == FRMWRT_SGL_R || bWriteType == FRMWRT_SGL_W)
    {
        *pBuf++ = (bID & 0x00FF);
    }
    *pBuf++ = (wAddr & 0xFF00) >> 8;
    *pBuf++ = wAddr & 0x00FF;

    while (bLen--)
        *pBuf++ = *pData++;

    bPktLen = pBuf - pFrame;

    wCRC2 = CRC16(pFrame, bPktLen);
    *pBuf++ = wCRC2 & 0x00FF;
    *pBuf++ = (wCRC2 & 0xFF00) >> 8;
    bPktLen += 2;
    //THIS SEEMS to occasionally drop bytes from the frame. Sometimes is not sending the last frame of the CRC.
    //(Seems to be caused by stack overflow, so take precautions to reduce stack usage in function calls)

    sendData(bPktLen, pFrame);

    return bPktLen;
}

void sendData(uint32 length,uint8 *data)
{
    uint8_t txPacket[10] = {};
        delayus(500);
        for(int i = 0; i< length; i++){
            while (!DL_UART_Main_isRXFIFOEmpty(UART_0_INST));
            DL_UART_Main_transmitDataBlocking(UART_0_INST, *data);
            data++;
        }
   /* Wait until all bytes have been transmitted and the TX FIFO is empty */
        while (DL_UART_Main_isBusy(UART_0_INST));

}


int ReadReg(BYTE bID, uint16 wAddr, BYTE * pData, BYTE bLen, uint32 dwTimeOut, BYTE bWriteType){
    //GENERATE READ COMMAND FRAME AND THEN WAIT FOR RESPONSE DATA (INTERRUPT MODE FOR SCIRX)
    // device address, register start address, byte frame pointer to store data, data length, read type (single, broadcast, stack)
    //DL_UART_disableInterrupt(UART_0_INST,DL_UART_INTERRUPT_RX);
    bRes = 0;
    count = 1000000; //timeout after this many attempts

    if (bWriteType == FRMWRT_SGL_R) {
        ReadFrameReq(bID, wAddr, bLen, bWriteType);
        memset(&pData, 0, sizeof(pData));
        DL_UART_enableInterrupt(UART_0_INST,DL_UART_INTERRUPT_RX);
        bRes = bLen + 6;

    } else if (bWriteType == FRMWRT_STK_R) {
        bRes = ReadFrameReq(bID, wAddr, bLen, bWriteType);
        memset(&pData, 0, sizeof(pData));
        DL_UART_enableInterrupt(UART_0_INST,DL_UART_INTERRUPT_RX);
        bRes = (bLen + 6) * (TOTALBOARDS - 1);

    } else if (bWriteType == FRMWRT_ALL_R) {
        bRes = ReadFrameReq(bID, wAddr, bLen, bWriteType);
        memset(&pData, 0, sizeof(pData));
        DL_UART_enableInterrupt(UART_0_INST,DL_UART_INTERRUPT_RX);
        bRes = (bLen + 6) * TOTALBOARDS;

    } else {
        bRes = 0;
    }

//    //CHECK IF CRC IS CORRECT
//    for(crc_i=0; crc_i<bRes; crc_i+=(bLen+6))
//    {
//        if(CRC16(&pData[crc_i], bLen+6)!=0)
//        {
//            printf("BAD CRC\n");
//        }
//    }

    return bRes;

}

int ReadFrameReq(BYTE bID, uint16 wAddr, BYTE bByteToReturn, BYTE bWriteType) {
    bReturn = bByteToReturn - 1;

    if (bReturn > 127)
        return 0;

    return WriteFrame(bID, wAddr, &bReturn, 1, bWriteType);
}

这是自动地址的代码、请检查一次、  

因为 Rx 溢出错误无法解决。

您好、 Abhaya

您需要自行深入研究这段代码、弄清为什么该代码示例会停止接收数据并生成溢出错误。

以下是我的建议：

  这是哪个通信命令导致的。

  在错误生成之前、哪些数据已发送到 BQ 并 从 BQ 中接收。

  根据这些数据、为什么它卡在这里？

此致、

赫利克