[参考译文] SIMPLELINK-WIFI-CC3120-SDK-plugin：MSP432P401R 程序问题

你好，格雷格，

为了澄清问题，上述代码包含了 SDK 的哪个部分？  它是在基本代码 SDK 还是 Wifi 插件中？  

你好，贾斯，

只要调用 SL_SendTo (WiFi 插件 SDK 的 socket.h 内)，就会输入上述代码，我不太确定这意味着什么。 我只知道当我暂停调试器时，我处于该循环中。

代码本身位于 C:\ti\ccs1020\CC\CC_base_emulation \GEL\images\msp432p401r\revC\driverlib.c.

这方面的小补充。

在 SL_SendTo 内部，当执行命令 RetVal =_SlDrvDataWriteOp ((_Slsd_t) SD，&CmdCtrl，&Msg，&CmdExt)时，代码在第360行中特别失败。

不确定这是否有帮助。 同样，如果事先使用了收发器模式或未使用 ADC 缓冲器，则此功能也会正常工作。

格雷戈里，

感谢您提供更多信息。 我将邀请一位对 Wifi 插件了解更多的专家在这里提供帮助。  很抱歉耽误你的时间。  

贾斯，

没问题！ 感谢您的更新。

你好，贾斯

您是否可以提供应用程序到目前为止所做的工作的应用程序日志？ 我想确保您已连接到网络，并已连接到您的服务器，然后再呼叫发送方。 您使用的是无阻塞插座还是阻塞？  

你看到的功能看起来像一个空闲循环。 我不认为应用程序“失败”，但也许您被某些任务或功能阻止。  

你好，格雷戈里，

感谢您的解释。 请尝试以下几项：  

1.您是否可以验证在进行过交易模式通信时是否也在后台执行 ADC 采样，并且没有显示任何问题？

2.能否将 SL_Task 优先级设置为系统中的最高？

3.更改 ADC 采样率是否对问题有任何影响？ 这是通过 DMA 还是中断轮询来实现的？

您好，Vincent，

感谢您的建议。

在根据您的建议进行任何更改之前，该程序的参数如下：
-主线程：线程栈大小4096。 这是 STA 板上唯一运行的线程。
- ADCBuf：采样率1200，优先级7，3通道，未启用 DMA。
- SL_Task：任务优先级9，任务堆栈大小4096。

以下是这些建议的结果：
1.首先使用收发器模式，我可以看到 ADC 采样正在与 SL_SendTo 一起进行。 我通过在 ADCBuf 回调函数中设置断点，检查值并看到其继续按预期工作来确认这一点。 不使用收发器模式，我看到 ADCBuf 在 SL_SendTo 不工作后仍继续工作。
2.我尝试将任务优先级设置为0和1，但我没有看到任何更改。 我找不到有关 SL_Task 优先级的任何文档，所以请告诉我是否应该将其设置为不同的值。
3.1.我想将 DMA 与 ADCBuf 一起使用，但通过 SYSCFG 中的复选框启用 DMA 时，似乎会破坏程序的 ADCBuf 部分。 似乎回叫只在启用 DMA 的情况下执行一次，然后再也不会被调用。 对于使用收发器模式而不是使用收发器模式的用户来说，这是正确的。 除了选中该框以正确允许 DMA 外，我不确定是否需要进行更多更改。
3.2.如果未启用 DMA (因为它似乎不起作用)并首先使用收发器模式，则当采样率降低并增加倍数0f 4x 时，程序似乎运行良好。 跳过收发器模式(未启用 DMA)时，更改采样速率似乎没有发生任何变化。 ADCBuf 按预期运行，但 SL_SendTo 不工作。

我刚才尝试的另一件事是将 THREADSTACKSIZE 从4096增加到6144，任务堆栈大小从2048增加到4096。  未看到这方面的变化。

如果您认为这些参数更改的任何特定组合可能会有所不同，请告诉我。

谢谢格雷戈里。 您能否共享 ADC 线程和 SL_SendTo 线程的代码片段？

是的，我很高兴。

我使用一个函数启动 ADC 缓冲器，然后开始 SL_SendTo 循环。

我们过去(直到一年前)在单独的线程中启动 ADC 采样，该线程将被信号器挂起，直到需要启动为止。 我们发现，在同一线程中同时使用 ADCBuf 和 SL_SendTo 的当前方法同样有效。 我刚刚尝试复制这种方法，ADCBuf 在一个单独的线程中运行 ，以查看它是否可以修复它。 运气差。

为了澄清问题，下面的所有代码都来自单线程版本，该版本可用于收发器启动，但不能直接用于 AP/STA 连接。

int32_t sensorNetDataSend(uint8_t ttl)
{
    /* Checks and Counters */
    int32_t ret = 0;
    uint8_t break_check = 0;
    uint32_t i = 0;
    uint32_t poll_interval = 20;
    //uint16_t nb_counter = 0;

    /* Param Parses */
    SendCmd_t SendCmdParams;
    ConnectCmd_t ConnectParams;

    /* Socket Inits */
    int32_t sock;
    int32_t nonBlocking;
    SlSockAddr_t        *sa;
    int32_t addrSize;
    sockAddr_t sAddr;
    struct SlTimeval_t TimeVal;

    /* ADC Buffer Inits */
    ADCBuf_Handle adcBuf;
    ADCBuf_Params adcBufParams;

    /* Timestamp Inits */
    uint64_t ttl_us = 15*ttl*60*1000000;
    uint64_t prev_packet_ts = 0;
    uint64_t last_packet_ts = 0;
    float microsecond_divider = 0.187500;

    /* Packet Inits */
    int16_t buflen = PAYLOADOFFSET + PAYLOADSIZE;
    SlWlanGetRxStatResponse_t rxStatResp;
    uint32_t ipv4;
    uint8_t trans_id = 0;
    uint8_t retrans_attempts = 0;
    uint8_t length = PAYLOADSIZE / 6;   // Needs to be decoded when receiving

    /* Call the Packet Send parser */
    memset(&SendCmdParams, 0x0, sizeof(SendCmd_t));
    ret = ParseSendCmd(&SendCmdParams);
    if(ret < 0)
    {
        UART_PRINT("\r\nFailed to Parse Sending Data");
        FreeSendCmd(&SendCmdParams);
        return(-1);
    }

    /* Send Data as a Client by UDP */
    if (dbg) UART_PRINT("\r\nSending Packets as a UDP Client...");

    /* clear the global data buffer */
    memset(&app_CB.gDataBuffer.nwData, 0x0, sizeof(app_CB.gDataBuffer));

    if(SendCmdParams.ipv6) // Can clear this since only ipV6
    {
        sAddr.in6.sin6_family = SL_AF_INET6;
        sAddr.in6.sin6_port = sl_Htons(SendCmdParams.portNumber);
        sAddr.in6.sin6_flowinfo = 0;

        sAddr.in6.sin6_addr._S6_un._S6_u32[0] =
            ((unsigned long *)SendCmdParams.ipAddr.ipv6)[0];
        sAddr.in6.sin6_addr._S6_un._S6_u32[1] =
            ((unsigned long *)SendCmdParams.ipAddr.ipv6)[1];
        sAddr.in6.sin6_addr._S6_un._S6_u32[2] =
            ((unsigned long *)SendCmdParams.ipAddr.ipv6)[2];
        sAddr.in6.sin6_addr._S6_un._S6_u32[3] =
            ((unsigned long *)SendCmdParams.ipAddr.ipv6)[3];

        sa = (SlSockAddr_t*)&sAddr.in6;
        addrSize = sizeof(SlSockAddrIn6_t);
    }
    else
    {
        /* Set socket family according to L3 Protocol:
                        Ipv4 or Ipv6 - this is IPv4 case */
        sAddr.in4.sin_family = SL_AF_INET;
        /* Change the port number and IP
                   address byte ordering from Host order (little endian)
         * to network order (Big endian) */
        sAddr.in4.sin_port = sl_Htons((unsigned short)SendCmdParams.portNumber);
        sAddr.in4.sin_addr.s_addr = sl_Htonl((unsigned int)SendCmdParams.ipAddr.ipv4);

        /* Since this is the client's side,
         * we must know beforehand the IP address
         * and the port of the server wer'e trying to send/receive UDP data to.
         */
        sa = (SlSockAddr_t*)&sAddr.in4;
        addrSize = sizeof(SlSockAddrIn_t);
    }

    /* Get UDP sock descriptor - This call opens the socket. */
    sock = sl_Socket(sa->sa_family,SL_SOCK_DGRAM, 0);
    ASSERT_ON_ERROR(sock, SL_SOCKET_ERROR);

    /* Set socket as non-blocking socket (if needed):
     * Non-blocking sockets allows user to handle other tasks rather than block
     * on socket API calls.
     * If an API call using the Non-blocking socket descriptor
     * returns 'SL_ERROR_BSD_EAGAIN' -
     * this indicate that the user should try the API again later.
     */
    if(TRUE == SendCmdParams.nb)
    {
        nonBlocking = TRUE;
        ret =
            sl_SetSockOpt(sock, SL_SOL_SOCKET, SL_SO_NONBLOCKING, &nonBlocking,
                          sizeof(nonBlocking));
        if(ret < 0)
        {
            UART_PRINT("[line:%d, error:%d] %s\n\r", __LINE__, ret,
                       SL_SOCKET_ERROR);
            sl_Close(sock);
            return(-1);
        }
    }
    else
    {
        /* In case of blocking, a timeout for sl_RecvFrom will be set to TimeVal
        * When timeout is expired sl_RecvFrom will return SL_ERROR_BSD_EAGAIN */
        TimeVal.tv_sec = RECEIVE_TIMEOUT;
        TimeVal.tv_usec = 0;
        ret =
            sl_SetSockOpt(sock,SL_SOL_SOCKET,SL_SO_RCVTIMEO,
                          (uint8_t *)&TimeVal,
                          sizeof(TimeVal));
        if(ret < 0)
        {
            UART_PRINT("[line:%d, error:%d] %s\n\r", __LINE__, ret,
                       SL_SOCKET_ERROR);
            sl_Close(sock);
            return(-1);
        }
    }

    /* Initialize Packet semaphore to release payload */
    ret = sem_init(&packetSem, 0, 0);
    if (ret != 0)
    {
        UART_PRINT("Error creating adcPacketSem\n");
        while(1);
    }

    /* Set RSSI from the Incoming Rsponse Packets */
    ret = sl_WlanRxStatGet(&rxStatResp, 0);
    if(ret < 0)
    {
        return(RADIO_TOOL_ERROR_GETTING_RX_STATS);
    }
    memcpy(&app_CB.gDataBuffer.nwData[0],
           &rxStatResp.AvarageDataCtrlRssi, 1);

    /* Pull Connect params to store source IP in packet */
    memset(&ConnectParams, 0x0, sizeof(ConnectCmd_t));
    ret = ParseConnectCmd(&ConnectParams);
    if(ret < 0)
    {
        FreeConnectCmd(&ConnectParams);
        return(-1);
    }
    ret = ipv4AddressParse(ConnectParams.ip, &ipv4);
    writeUInt32ToBufferBigEndian(ipv4, &app_CB.gDataBuffer.nwData[1]);
    FreeConnectCmd(&ConnectParams);

    /* Copy Packet Length */
    memcpy(&app_CB.gDataBuffer.nwData[7], &length, 1);

    /* Assign Application ID */
    memcpy(&app_CB.gDataBuffer.nwData[8], &appId, 1);

    /* Start timing samples */
    startSnetTimer();

    /********************************************************/
    // This is the process for the vibration sensor.
    // We need to only execute this process if appID is 5.
    /* Setup and Start ADCBuf */
    adcCount = 0;
    startADCBuf(&adcBuf, &adcBufParams, continuousConversion);
    /********************************************************/

    /* Transmission Loop: Send Packets to the AP */
    while(1)
    {
        /* Send packets in groups of poll_interval before polling for TTL */
        for (i = 0; i < poll_interval; i++)
        {
            /* Increment Transaction ID */
            trans_id++;
            memcpy(&app_CB.gDataBuffer.nwData[5], &trans_id, sizeof(trans_id));

            /* Load Previous Packet Timestamp */
            writeUInt64ToBufferBigEndian(prev_packet_ts, &app_CB.gDataBuffer.nwData[17]);

            /* Wait for ADC to fill the payload then pause ADC collection*/
            sem_wait(&packetSem);

            /* Send packets to server, data sent is the data buffer */
            ret =
                sl_SendTo(sock, &app_CB.gDataBuffer.nwData, buflen, 0, sa,
                          (SlSocklen_t)addrSize);

            /* Timestamp the Packet just Sent */
            prev_packet_ts = (uint64_t)((4294967296 - Timer32_getValue(TIMER32_0_BASE) )/ microsecond_divider);

            /* Sending Error Check */
            if((ret == SL_ERROR_BSD_EAGAIN) && (TRUE == SendCmdParams.nb))
            {
                /* Attempt to track retransmission count *************************************/
                // DIDN'T WORK
                retrans_attempts++;
                memcpy(&app_CB.gDataBuffer.nwData[6], &retrans_attempts, sizeof(retrans_attempts));
                /*****************************************************************************/

                sleep(1);
                continue;
            }
            else if(ret < 0)
            {
                UART_PRINT("[line:%d, error:%d] %s\n\r", __LINE__, ret,
                           SL_SOCKET_ERROR);
                sl_Close(sock);
                return(-1);
            }
            i++;

            /* Clear Data buffer before each transmission */
            retrans_attempts = 0;
            memcpy(&app_CB.gDataBuffer.nwData[PAYLOADOFFSET], 0x0, sizeof(PAYLOADSIZE));

            /* Checks if TTL has expired */
            if (prev_packet_ts >=  ttl_us)
            {
                /* Stop and Reset SensorNet Timer + ADC Buffer */
                stopADCBuf(&adcBuf);
                stopSnetTimer();

                /* Load and Send the Final Packet */
                last_packet_ts = (uint64_t)((4294967296 - Timer32_getValue(TIMER32_0_BASE) )/ microsecond_divider);
                writeUInt64ToBufferBigEndian(last_packet_ts, &app_CB.gDataBuffer.nwData[9]);
                writeUInt64ToBufferBigEndian(prev_packet_ts, &app_CB.gDataBuffer.nwData[17]);
                trans_id++;
                memcpy(&app_CB.gDataBuffer.nwData[5], &trans_id, sizeof(trans_id));
                memcpy(&app_CB.gDataBuffer.nwData[PAYLOADOFFSET], 0x0, sizeof(PAYLOADSIZE));
                ret = sl_SendTo(sock, &app_CB.gDataBuffer.nwData, buflen, 0, sa,
                                   (SlSocklen_t)addrSize);
                break_check = 1;
                break;
            }

        }
        if (break_check == 1)
        {
            break;
        }

    }

    /* Calling 'close' with the socket descriptor,
     * once operation is finished.
     */
    ret = sl_Close(sock);
    ASSERT_ON_ERROR(ret, SL_SOCKET_ERROR);

    if (dbg) UART_PRINT("Sent packets successfully!!!\n\r");
    FreeSendCmd(&SendCmdParams);
    return(ret);
}

以下是 ADCBuf 的相关函数：

/* Variables for Local Buffer Functions */
#define ADCBUFFERSIZE       (2)
#define OUTPUTBUFFERSIZE    (3)
uint16_t sampleBufferOne[ADCBUFFERSIZE];
uint16_t sampleBufferTwo[ADCBUFFERSIZE];
uint16_t sampleBufferThree[ADCBUFFERSIZE];
uint16_t sampleBufferFour[ADCBUFFERSIZE];
uint16_t sampleBufferFive[ADCBUFFERSIZE];
uint16_t sampleBufferSix[ADCBUFFERSIZE];
uint32_t buffersCompletedCounter = 0;
uint16_t outputBuffer[OUTPUTBUFFERSIZE];
uint16_t payloadBuffer[1500];
float microsecond_divider = 0.187500;
float minute_divider = 11250000;

/* Buffer Markers */
uint16_t payload_marker = 0;
uint8_t ts_flag = 1;

/* Timestamp Buffer */
uint64_t first_vectorSample_ts = 0;

/*!
 *
 * Releases a Vector Sample into the Global Data Buffer
 *
 */
void sendVectorSample()
{
    /* Store ADC values in the Payload Buffer*/
    memcpy(&payloadBuffer[payload_marker], &outputBuffer, sizeof(outputBuffer));

    /* Shift the payload index marker */
    payload_marker += 3;

    /* Check if payload index marker has reached the end of the payload */
    if (payload_marker >= (PAYLOADSIZE/2))
    {
        /* Prep for next payload */
        payload_marker = 0;
        ts_flag = 1;

        /* Load the gDataBuffer */
        memcpy(&app_CB.gDataBuffer.nwData[PAYLOADOFFSET], &payloadBuffer, sizeof(payloadBuffer));

        /* Release the packet semaphore */
        sem_post(&packetSem);
    }
}

/*
 * This function is called whenever a buffer is full.
 * The content of the buffer is then converted into human-readable format and
 * sent to the PC via UART.
 *
 */
void adcBufCallback(ADCBuf_Handle handle, ADCBuf_Conversion *conversion,
    void *completedADCBuffer, uint32_t completedChannel) {
    uint_fast16_t i;
    uint16_t *completedBuffer = (uint16_t *) completedADCBuffer;

    /* Load an axis sample into the output buffer */
    for (i = 0; i < OUTPUTBUFFERSIZE; i++)
    {
        outputBuffer[completedChannel] = completedBuffer[0];
    }

    /* Check if all axes have been sampled */
    if (completedChannel >= 2)
    {
        /* Load timestamp if needed */
        if (ts_flag)
        {
            first_vectorSample_ts = (uint64_t)((4294967296 - Timer32_getValue(TIMER32_0_BASE) )/ microsecond_divider);
            writeUInt64ToBufferBigEndian(first_vectorSample_ts, &app_CB.gDataBuffer.nwData[9]);
            ts_flag = 0;
        }

        /* Buffer the Vector Sample when ready */
        sendVectorSample();
    }
}

/*
 * This function sets up the ADC Buffer for operations in the background of where this is called.
 * sampFreq needs to be set elsewhere.
 *
 */
void startADCBuf(ADCBuf_Handle *adcBuf, ADCBuf_Params *adcBufParams, ADCBuf_Conversion *continuousConversion)
{
    /* Call driver init functions */
    ADCBuf_init();

    /* Set up an ADCBuf peripheral in ADCBuf_RECURRENCE_MODE_CONTINUOUS */
    ADCBuf_Params_init(adcBufParams);
    adcBufParams->callbackFxn = adcBufCallback;
    adcBufParams->recurrenceMode = ADCBuf_RECURRENCE_MODE_CONTINUOUS;
    adcBufParams->returnMode = ADCBuf_RETURN_MODE_CALLBACK;
    adcBufParams->samplingFrequency = sampFreq * 20 * 6;
    //adcBufParams->samplingFrequency = 1200;
    *adcBuf = ADCBuf_open(CONFIG_ADCBUF_0, adcBufParams);

    /* Configure the conversion struct for two channels on same sequencer */
    continuousConversion[0].arg = NULL;
    continuousConversion[0].adcChannel = CONFIG_ADCBUF_0CHANNEL_0;
    continuousConversion[0].sampleBuffer = sampleBufferOne;
    continuousConversion[0].sampleBufferTwo = sampleBufferTwo;
    continuousConversion[0].samplesRequestedCount = ADCBUFFERSIZE;

    continuousConversion[1].arg = NULL;
    continuousConversion[1].adcChannel = CONFIG_ADCBUF_0CHANNEL_1;
    continuousConversion[1].sampleBuffer = sampleBufferThree;
    continuousConversion[1].sampleBufferTwo = sampleBufferFour;
    continuousConversion[1].samplesRequestedCount = ADCBUFFERSIZE;

    continuousConversion[2].arg = NULL;
    continuousConversion[2].adcChannel = CONFIG_ADCBUF_0CHANNEL_2;
    continuousConversion[2].sampleBuffer = sampleBufferFive;
    continuousConversion[2].sampleBufferTwo = sampleBufferSix;
    continuousConversion[2].samplesRequestedCount = ADCBUFFERSIZE;

    /* ADCBuf Error Check */
    if (!*adcBuf){
        /* AdcBuf did not open correctly. */
        while(1);
    }

    /* Start converting sequencer 0. */
    if (ADCBuf_convert(*adcBuf, continuousConversion, 3) !=
        ADCBuf_STATUS_SUCCESS) {
        /* Did not start conversion process correctly. */
        while(1);
    }
}

/*!
 * Stops the Running ADC Buffer
 *
 */
void stopADCBuf(ADCBuf_Handle *adcBuf)
{
    int_fast16_t ret;

    ret = ADCBuf_convertCancel(*adcBuf);
    if (ret != ADCBuf_STATUS_SUCCESS)
    {
        UART_PRINT("\n\r [ERROR] Error stopping ADC Buffer");
    }
}

您好，

我想知道是否有任何关于问题可能原因的更新？