[参考译文] MSP430FR6047：传输的 UART 数据中出错

我认为我们需要了解您是如何发送数据的？ 不等待 TXBuf 清除的实现会对其造成阻碍。 您是否使用示波器对其进行了检查、以验证波特率是否正确？

你好、Joshua、

假如您试图通过 UART 获取采集信息、例如在 Water_Demo 中、您是否简单指 dToF、atof、VFR... 等等？ 这在模板示例中进行了演示、其中已经包含通过 UART 将此信息发送出去的功能。 要查看这些数据、您只需要将示例项目编程到器件中、并探测 EVM 上的 UART 引脚。 是否有理由避免使用模板示例中包含的 UART 功能？

尊敬的 Keith：

感谢您的快速响应。 我按照 Water_Demo 中的相同步骤发送 USS ADC 捕获(UPS 和 DNS 捕获)。 我将使用演示代码中的以下函数。

extern void CommandHandler_Transportations (Packet_t *packet)；

extern void CommandHandler_TransourceCapturePackages (Packet_t *packet、
uint8_t id、
uint8_t numOfPcks、
int8_t finalPckLenight、
uint8_t* PCAP)；

extern void CommandHandler_TransourcePacket (Packet_t *packet)；

extern void Comm_writePacket (const Packet_t *packet)；

extern void Com_writeBuffer (const uint8_t * sourceBuffer、uint16_t sourceLength)；

我已经创建了一个如下所示的 uart.c、当 MSP 接收到 UART 代码"a""/n"时、开始传输。  CommandHandler_Transportations 函数来完成这些操作。

/*
 * uart.c
 *
 *  Created on: 23 Jan 2024
 *      Author: AntonyJoshua
 */

#include "protocol/uart.h"
#include <intrinsics.h>
#include <stdint.h>
#include "msp430.h"
#include "main.h"
#include "protocol/packet.h"
#include "protocol/uart.h"


extern void CommandHandler_transmitCaptures(Packet_t *packet);
extern void CommandHandler_transmitCapturePackages(Packet_t *packet,
                                                   uint8_t id,
                                                   uint8_t numOfPcks,
                                                   int8_t finalPckLenght,
                                                   uint8_t* pCap);

extern void CommandHandler_transmitPacket(Packet_t *packet);
extern void Comm_writePacket(const Packet_t *packet);
extern void Comm_writeBuffer(const uint8_t *sourceBuffer, uint16_t sourceLength);

//extern uint16_t g_ui16UARTTransmitBytesLeft;



#define BUFFER_SIZE 27

#define COMMAND_HANDLER_UPS_DNS_CAP_MAX_CAP_SIZE            27

/*  USS GUI Design Center Plotting variable length packet
*******************************************************************************/
#define COMMAND_HANDLER_CAPTURE_PACKET_SIZE                 60
#define COMMAND_HANDLER_UPS_ADC_CAPTURE_ID                  0xC0
#define COMMAND_HANDLER_DNS_ADC_CAPTURE_ID                  0xC1

/*******************************************************************************
*  USS GUI Design Center Plotting packet
*******************************************************************************/
#define COMMAND_HANDLER_PLOT_PACKET_SIZE                    11
#define COMMAND_HANDLER_PLOT_DTOF_ID                        0xB0
#define COMMAND_HANDLER_PLOT_ABS_UPS_ID                     0xB1
#define COMMAND_HANDLER_PLOT_ABS_DNS_ID                     0xB2
#define COMMAND_HANDLER_PLOT_VOL_ID                         0xB3
#define COMMAND_HANDLER_PLOT_ADC_UPS_STRT_STP_PACKS_ID      0xB4
#define COMMAND_HANDLER_PLOT_ADC_DNS_STRT_STP_PACKS_ID      0xB5
#define COMMAND_HANDLER_PLOT_GENERIC_PLOT_ID                0xB6
#define COMMAND_HANDLER_PLOT_ADVANCED_GENERIC_PLOT_ID       0xB7
#define COMMAND_HANDLER_PLOT_ADC_START_TX                   true
#define COMMAND_HANDLER_PLOT_ADC_STOP_TX                    false
// Command 0xB6-0xBF  are reserved for future plotting commands

/*******************************************************************************
* Define used to identify packet as USS GUI Desing Center packet
*******************************************************************************/
#define COMMAND_HANDLER_USS_GUI_ID_BYTE                     0x04
#define COMMAND_HANDLER_WRITE_CMD                           true
#define COMM_TX_BUFF_SZ  (800)
#define EUSCI_A_UART_TRANSMIT_INTERRUPT                     UCTXIE

uint8_t Comm_transmitBuffer[COMM_TX_BUFF_SZ];

uint8_t uss_param_uart[BUFFER_SIZE];
uint16_t UartRcvBufIndex = 0;

#if defined(__TI_COMPILER_VERSION__)
#pragma PERSISTENT(gstxPacket)
#define __persistent
#elif defined (__IAR_SYSTEMS_ICC__)
#else
#error Compiler not supported!
#endif

/*** GLOBAL VARIABLES ***/
__persistent Packet_t gstxPacket = {0};


//*****************************************************************************
//
//! var g_pUARTPort stores a pointer to the UART port configuration
//! structure that was passed to the UART_openPort function.  The UART
//! driver does not modify this structure.
//
//*****************************************************************************
const tUARTPort *g_pUARTPort;

//*****************************************************************************
//
//! var g_pUARTTransmitPtr stores a pointer to the current byte to transmit.
//
//*****************************************************************************
volatile const uint8_t *g_pUARTTransmitPtr;

//*****************************************************************************
//
//! var g_ui16UARTTransmitBytesLeft stores how many bytes remain to be sent
//! in the current transmission.
//
//*****************************************************************************
volatile uint16_t g_ui16UARTTransmitBytesLeft;

//*****************************************************************************
//
//! var g_UARTStatus stores the current status of the UART port driver.
//
//*****************************************************************************
volatile uint8_t g_UARTStatus;

//void UART_openPort(const tUARTPort *pPort)
//{
//    UART_closePort();
//    g_pUARTPort = pPort;
//
//    EUSCI_A_UART_init(
//            UART__EUSCI_A_PERIPHERAL,
//            (EUSCI_A_UART_initParam*)&(g_pUARTPort->peripheralParameters)
//        );
//    EUSCI_A_UART_enable(UART__EUSCI_A_PERIPHERAL);
//    EUSCI_A_UART_clearInterrupt(
//            UART__EUSCI_A_PERIPHERAL,
//            EUSCI_A_UART_RECEIVE_INTERRUPT_FLAG
//        );
//    EUSCI_A_UART_enableInterrupt(
//            UART__EUSCI_A_PERIPHERAL,
//            EUSCI_A_UART_RECEIVE_INTERRUPT
//        );
//
//    g_UARTStatus = eUARTIsIdle;
//}
//
//void UART_closePort(void)
//{
//    g_UARTStatus = eUARTIsClosed;
//    EUSCI_A_UART_disable(UART__EUSCI_A_PERIPHERAL);
//}

uint8_t UART_getPortStatus(void)
{
    return g_UARTStatus;
}

void UART_transmitBuffer(const uint8_t *pBuffer, uint16_t ui16Length)
{
    g_UARTStatus = eUARTIsIdle;

    if (g_UARTStatus == eUARTIsClosed)
    {
        return;
    }

    //
    // Before transmitting, safely wait for
    // current operations to finish
    //
#if (UART__LPMx_bits>0)
    while (1)
    {
        __bic_SR_register(GIE);
        if (g_UARTStatus != eUARTIsIdle)
        {
            __bis_SR_register(UART__LPMx_bits | GIE);
        }
        else
        {
            __bis_SR_register(GIE);
            break;
        }
    };
#else
    while(g_UARTStatus != eUARTIsIdle);
#endif

    g_pUARTTransmitPtr = pBuffer;
    g_ui16UARTTransmitBytesLeft = ui16Length;
    g_UARTStatus = eUARTIsTransmitting;
    EUSCI_A_UART_enableInterrupt(
            UART__EUSCI_A_PERIPHERAL,
            EUSCI_A_UART_TRANSMIT_INTERRUPT
        );
}

//extern void UART_transmitByteImmediately(uint8_t ui8Data)
//{
//    while(!(EUSCI_A_UART_getInterruptStatus(
//                    UART__EUSCI_A_PERIPHERAL,
//                    EUSCI_A_UART_TRANSMIT_INTERRUPT_FLAG
//                )
//            ));
//    EUSCI_A_UART_transmitData(UART__EUSCI_A_PERIPHERAL, ui8Data);
//};

//*****************************************************************************
//
//! UART Interrupt Service Routine
//
//*****************************************************************************

#pragma vector=EUSCI_A1_VECTOR
__interrupt void USCI_A1_ISR(void)
{
    switch(__even_in_range(UCA1IV, USCI_UART_UCTXCPTIFG))
    {
        case USCI_NONE: break;
        case USCI_UART_UCRXIFG:

            uss_param_uart[UartRcvBufIndex++] = UCA1RXBUF; //fetch byte and store


           if (UCA1RXBUF == '\n')
           {

               if(uss_param_uart[0]=='a')
               {
                   CommandHandler_transmitCaptures(&gstxPacket);
               }


               UartRcvBufIndex = 0; // Clearing the array index 
               flag=0;
           }

            __no_operation();
            break;

        case USCI_UART_UCTXIFG:
          EUSCI_A_UART_transmitData(
                    UART__EUSCI_A_PERIPHERAL,
                   *(g_pUARTTransmitPtr++)
              );

            g_ui16UARTTransmitBytesLeft--;

            if (g_ui16UARTTransmitBytesLeft == 0)
            {
                EUSCI_A_UART_disableInterrupt(
                        UART__EUSCI_A_PERIPHERAL,
                        EUSCI_A_UART_TRANSMIT_INTERRUPT
                    );
                g_UARTStatus = eUARTIsIdle;
                __bic_SR_register_on_exit(UART__LPMx_bits);
            }
            break;
        case USCI_UART_UCSTTIFG: break;
        case USCI_UART_UCTXCPTIFG: break;
        default: break;
    }
}


// Function to send ADC Capture

void CommandHandler_transmitCaptures(Packet_t *txPacket)
{
    // Calculate number of packets that will need to be sent
    // Each ADC capture packet can hold up to 27 captures
    uint16_t updnsCaptureSize = gUssSWConfig.captureConfig->sampleSize;
    uint8_t numOfPcks = (uint8_t)(updnsCaptureSize/ COMMAND_HANDLER_UPS_DNS_CAP_MAX_CAP_SIZE);
    int8_t finalPckLength = (uint8_t)(updnsCaptureSize % COMMAND_HANDLER_UPS_DNS_CAP_MAX_CAP_SIZE);
    // Calculate number of bytes in each capture
    uint8_t* pUPSCap = (uint8_t*)(USS_getUPSPtr(&gUssSWConfig));
    uint8_t* pDNSCap = (uint8_t*)(USS_getDNSPtr(&gUssSWConfig));

    if( finalPckLength > 0 )
    {
        numOfPcks++;
    }
    else
    {
        finalPckLength = COMMAND_HANDLER_UPS_DNS_CAP_MAX_CAP_SIZE;
    }


    CommandHandler_transmitCapturePackages(txPacket,
            COMMAND_HANDLER_UPS_ADC_CAPTURE_ID,
            numOfPcks,
            finalPckLength, pUPSCap);

    CommandHandler_transmitCapturePackages(txPacket,
            COMMAND_HANDLER_DNS_ADC_CAPTURE_ID,
            numOfPcks,
            finalPckLength, pDNSCap);

}

//Transmitting capture packages
void CommandHandler_transmitCapturePackages(Packet_t *txPacket,
            uint8_t id, uint8_t numOfPcks, int8_t finalPckLength,
            uint8_t* pCap)
{
    uint8_t i,j;
    uint8_t tempID;

    if(id == COMMAND_HANDLER_UPS_ADC_CAPTURE_ID)
    {
        tempID = COMMAND_HANDLER_PLOT_ADC_UPS_STRT_STP_PACKS_ID;
    }else
    {
        tempID = COMMAND_HANDLER_PLOT_ADC_DNS_STRT_STP_PACKS_ID;
    }

    // Generate packet ADC capture packets in START mode
    txPacket->length = COMMAND_HANDLER_PLOT_PACKET_SIZE;
    txPacket->payload[0] = COMMAND_HANDLER_USS_GUI_ID_BYTE;
    txPacket->payload[1] = tempID;
    txPacket->payload[2] = COMMAND_HANDLER_WRITE_CMD;
    txPacket->payload[3] = (uint8_t)COMMAND_HANDLER_PLOT_ADC_START_TX;
    txPacket->payload[4] = numOfPcks;

    CommandHandler_transmitPacket(txPacket);

    txPacket->length = COMMAND_HANDLER_CAPTURE_PACKET_SIZE;
    txPacket->payload[0] = COMMAND_HANDLER_USS_GUI_ID_BYTE;
    txPacket->payload[1] = id;
    txPacket->payload[2] = COMMAND_HANDLER_WRITE_CMD;
    txPacket->payload[4] = COMMAND_HANDLER_UPS_DNS_CAP_MAX_CAP_SIZE;


    // Transmit ADC UPS capture packets
    for(i = 1; i < numOfPcks ; i++)
    {
        txPacket->payload[3] = i;

        for( j = 0; j < (sizeof(uint16_t)*COMMAND_HANDLER_UPS_DNS_CAP_MAX_CAP_SIZE); j+=2)
        {
            txPacket->payload[(j + 5)] = *(pCap++);
            txPacket->payload[(j + 6)] = *(pCap++);
        }

        CommandHandler_transmitPacket(txPacket);
    }

    // Transmit final packet with remaining capture samples
    if(finalPckLength > 0)
    {
        txPacket->payload[3] = numOfPcks;
        txPacket->payload[4] = finalPckLength;
        i=0;
        while(finalPckLength > 0)
        {
            txPacket->payload[(i + 5)] = *(pCap++);
            txPacket->payload[(i + 6)] = *(pCap++);
            i+=2;
            finalPckLength--;
        }

        CommandHandler_transmitPacket(txPacket);
    }

    // Generate packet ADC capture packets in START mode
    txPacket->length = COMMAND_HANDLER_PLOT_PACKET_SIZE;
    txPacket->payload[0] = COMMAND_HANDLER_USS_GUI_ID_BYTE;
    txPacket->payload[1] = tempID;
    txPacket->payload[2] = COMMAND_HANDLER_WRITE_CMD;
    txPacket->payload[3] = (uint8_t)COMMAND_HANDLER_PLOT_ADC_STOP_TX;
    txPacket->payload[4] = numOfPcks;

    CommandHandler_transmitPacket(txPacket);


}

void CommandHandler_transmitPacket(Packet_t *packet)
{
    Comm_writePacket(packet);

    while(g_ui16UARTTransmitBytesLeft!=0);

}

void Comm_writePacket(const Packet_t *packet)
{
    //
    // Simply call the write buffer function, passing the packet parameters.
    //
    Comm_writeBuffer(packet->payload, packet->length);
}

void Comm_writeBuffer(const uint8_t *sourceBuffer, uint16_t sourceLength)
{

    //
    // Because UART is being used, convert the source buffer into stream format.
    // This adds headers, byte stuffing, and the checksum.
    //
    sourceLength = Packet_convertToStream(
            &Comm_transmitBuffer[0],
            sourceBuffer,
            sourceLength
        );
    //
    // Transmit the packet via the UART interface.
    //
    UART_transmitBuffer(&Comm_transmitBuffer[0], sourceLength);

}

我做错了什么事吗？

提前感谢。

尊敬的 Dylan：  

感谢您的回复、我将发送 UPS 和 DNS CAPTURE 以及 DToF 值。 当 MSP 接收到 UART 命令时、它会进入如上所述的发送捕获数据模式。

谢谢

我明白了。 您不只是使用水演示示示例并切掉一些您不需要的其他 GUI 功能、是不是有原因的？ 我认为水演示和模板示例之间的主要区别是一个使用 GUI、而另一个使用简单的 UART 接口。 您能否将 UART 引脚连接到逻辑分析仪而不是调试器、并以这种方式查看信息？

它也可以帮助我了解您的最终目标是以这种方式获取这些数据。 感谢您目前的讲解。

大家好、Dylan、我没有逻辑分析仪、但我尝试使用示波器读取该信号、我得到了以下结果。

我尝试获取这些数据和 DNS 数据、以便像 USS GUI 一样绘制 ADC 图、并想在  FR6047_USSSWLib_TEMPLATE_example 中实现此功能。

它以大约1us 的位时间运行、或大约1MBaud 的速率运行。 这就是您设置的 PC 吗？

是的、我已经尝试过波特率1M、仍然是严重的。  

在传输此捕获详细信息时、如何将波特率更改为4800？

查看代码中的注释、它的数字为9600、这是它应该发送的值、但用户指南中告诉您如何操作的位置。

9600波特应该有104us 位时间、以便您的时序偏离某个位置。

尊敬的 Keith：

我能够以4800波特率获得 DToF 和其他结果、如果我以4800波特率向 MSP 发送数据、它正在读取、但在 UPS 和 DNS 捕获的情况下、我有问题。