#include "slave485DataParse.h"
#include "slaveQueueUart.h"

#include "mcu_common.h"

/**
  * @brief  接收J1口传来的数据
  * @param 
  * @retval
  */
void J1_SensorDataAnalysis(void)
{
    static uint32_t tick;

    if (J1_485RxBufferIndex == 0) {
        tick = xTaskGetTickCount();
    }

    /* 单次进入最多6ms（3个时钟周期），串口中有数据 */
    uint32_t nowTick = xTaskGetTickCount();
    while ((getTickDiff(nowTick) < 3)
            && (uart_dev_char_present(g_J1_handle) == 1)
            && (maxdataLen > J1_485RxBufferIndex)) {
        J1_485RxBuffer[J1_485RxBufferIndex++] = uart_dev_in_char(g_J1_handle);
    }

    /* 当时间到达或者数据量到达，就打包发送给智能模块 */
    if ((J1_485RxBufferIndex >= maxdataLen) || (getTickDiff(tick) > delayTick)) {
        uint32_t tempLen = 6 + J1_485RxBufferIndex + slaveQueueUartSendInfoSize;
        if (xPortGetFreeHeapSize() < tempLen + 1024) {
            J1_485RxBufferIndex = 0;
            return;
        }

        uint8_t *Buff = (uint8_t *)pvPortMalloc(tempLen);
        slaveQueueUartSendInfo *sendBuff = (slaveQueueUartSendInfo *)Buff;
        sendBuff->length = 6 + J1_485RxBufferIndex;        
        sendBuff->data = Buff + sizeof(slaveQueueUartSendInfo);
        uint8_t *send = sendBuff->data;

        /* 起始标志 */
        *send = 'S';
        *(send + 1) = 'L';

        /* 端口号 */
        send += 2;
        *send = J1;

        /* 数据包长度 */
        send += 1;
        *send = (uint8_t)(J1_485RxBufferIndex >> 8);
        *(send + 1) = (uint8_t)(J1_485RxBufferIndex);

        /* 数据包 */
        send += 2;
        memcpy((char *)send, (char *)J1_485RxBuffer, J1_485RxBufferIndex);

        /* 结束标志 */
        send += J1_485RxBufferIndex;
        *send = 0x17;

        /* 队列中有空间，则将发送数据 */
        if (uxQueueSpacesAvailable(mcu_uart_Queue)) {
            xQueueSend(mcu_uart_Queue, &Buff, 10);
        }
        /* 队列无空间，将数据丢弃 */
        else {
            vPortFree(Buff);
        }

        /* 发送完成或遇到问题，将buff中的数据清零 */
        J1_485RxBufferIndex = 0;
    }
}

/**
  * @brief  接收J3口传来的数据
  * @param 
  * @retval
  */
void J3_SensorDataAnalysis(void)
{
    static uint32_t tick;

    if (J3_485RxBufferIndex == 0) {
        tick = xTaskGetTickCount();
    }

    /* 单次进入最多6ms（3个时钟周期），串口中有数据 */
    uint32_t nowTick = xTaskGetTickCount();
    while ((getTickDiff(nowTick) < 3)
            && (uart_dev_char_present(g_J3_handle) == 1)
            && (maxdataLen > J3_485RxBufferIndex)) {
        J3_485RxBuffer[J3_485RxBufferIndex++] = uart_dev_in_char(g_J3_handle);
    }

    /* 当时间到达或者数据量到达，就打包发送给智能模块 */
    if ((J3_485RxBufferIndex >= maxdataLen) || (getTickDiff(tick) > delayTick)) {
        uint32_t tempLen = 6 + J3_485RxBufferIndex + slaveQueueUartSendInfoSize;
        if (xPortGetFreeHeapSize() < tempLen + 1024) {
            J3_485RxBufferIndex = 0;
            return;
        }

        uint8_t *Buff = (uint8_t *)pvPortMalloc(tempLen);
        slaveQueueUartSendInfo *sendBuff = (slaveQueueUartSendInfo *)Buff;
        sendBuff->length = 6 + J3_485RxBufferIndex;        
        sendBuff->data = Buff + sizeof(slaveQueueUartSendInfo);
        uint8_t *send = sendBuff->data;

        /* 起始标志 */
        *send = 'S';
        *(send + 1) = 'L';

        /* 端口号 */
        send += 2;
        *send = J3;

        /* 数据包长度 */
        send += 1;
        *send = (uint8_t)(J3_485RxBufferIndex >> 8);
        *(send + 1) = (uint8_t)(J3_485RxBufferIndex);

        /* 数据包 */
        send += 2;
        memcpy((char *)send, (char *)J3_485RxBuffer, J3_485RxBufferIndex);

        /* 结束标志 */
        send += J3_485RxBufferIndex;
        *send = 0x17;

        /* 队列中有空间，则将发送数据 */
        if (uxQueueSpacesAvailable(mcu_uart_Queue)) {
            xQueueSend(mcu_uart_Queue, &Buff, 10);
        }
        /* 队列无空间，将数据丢弃 */
        else {
            vPortFree(Buff);
        }

        /* 发送完成或遇到问题，将buff中的数据清零 */
        J3_485RxBufferIndex = 0;
    }
}

/**
  * @brief  接收J5口传来的数据
  * @param 
  * @retval
  */
void J5_SensorDataAnalysis(void)
{
    static uint32_t tick;

    if (J5_485RxBufferIndex == 0) {
        tick = xTaskGetTickCount();
    }

    /* 单次进入最多6ms（3个时钟周期），串口中有数据 */
    uint32_t nowTick = xTaskGetTickCount();
    while ((getTickDiff(nowTick) < 3)
            && (uart_dev_char_present(g_J5_handle) == 1)
            && (maxdataLen > J5_485RxBufferIndex)) {
        J5_485RxBuffer[J5_485RxBufferIndex++] = uart_dev_in_char(g_J5_handle);
    }

    /* 当时间到达或者数据量到达，就打包发送给智能模块 */
    if ((J5_485RxBufferIndex >= maxdataLen) || (getTickDiff(tick) > delayTick)) {
        uint32_t tempLen = 6 + J5_485RxBufferIndex + slaveQueueUartSendInfoSize;
        if (xPortGetFreeHeapSize() < tempLen + 1024) {
            J5_485RxBufferIndex = 0;
            return;
        }

        uint8_t *Buff = (uint8_t *)pvPortMalloc(tempLen);
        slaveQueueUartSendInfo *sendBuff = (slaveQueueUartSendInfo *)Buff;
        sendBuff->length = 6 + J5_485RxBufferIndex;        
        sendBuff->data = Buff + sizeof(slaveQueueUartSendInfo);
        uint8_t *send = sendBuff->data;

        /* 起始标志 */
        *send = 'S';
        *(send + 1) = 'L';

        /* 端口号 */
        send += 2;
        *send = J5;

        /* 数据包长度 */
        send += 1;
        *send = (uint8_t)(J5_485RxBufferIndex >> 8);
        *(send + 1) = (uint8_t)(J5_485RxBufferIndex);

        /* 数据包 */
        send += 2;
        memcpy((char *)send, (char *)J5_485RxBuffer, J5_485RxBufferIndex);

        /* 结束标志 */
        send += J5_485RxBufferIndex;
        *send = 0x17;

        /* 队列中有空间，则将发送数据 */
        if (uxQueueSpacesAvailable(mcu_uart_Queue)) {
            xQueueSend(mcu_uart_Queue, &Buff, 10);
        }
        /* 队列无空间，将数据丢弃 */
        else {
            vPortFree(Buff);
        }

        /* 发送完成或遇到问题，将buff中的数据清零 */
        J5_485RxBufferIndex = 0;
    }
}

/**
  * @brief  接收J7口传来的数据
  * @param 
  * @retval
  */
void J7_SensorDataAnalysis(void)
{
    static uint32_t tick;

    if (J7_485RxBufferIndex == 0) {
        tick = xTaskGetTickCount();
    }

    /* 单次进入最多6ms（3个时钟周期），串口中有数据 */
    uint32_t nowTick = xTaskGetTickCount();
    while ((getTickDiff(nowTick) < 3)
            && (uart_dev_char_present(g_J7_handle) == 1)
            && (maxdataLen > J7_485RxBufferIndex)) {
        J7_485RxBuffer[J7_485RxBufferIndex++] = uart_dev_in_char(g_J7_handle);
    }

    /* 当时间到达或者数据量到达，就打包发送给智能模块 */
    if ((J7_485RxBufferIndex >= maxdataLen) || (getTickDiff(tick) > delayTick)) {
        uint32_t tempLen = 6 + J7_485RxBufferIndex + slaveQueueUartSendInfoSize;
        if (xPortGetFreeHeapSize() < tempLen + 1024) {
            J7_485RxBufferIndex = 0;
            return;
        }

        uint8_t *Buff = (uint8_t *)pvPortMalloc(tempLen);
        slaveQueueUartSendInfo *sendBuff = (slaveQueueUartSendInfo *)Buff;
        sendBuff->length = 6 + J7_485RxBufferIndex;
        sendBuff->data = Buff + sizeof(slaveQueueUartSendInfo);
        uint8_t *send = sendBuff->data;

        /* 起始标志 */
        *send = 'S';
        *(send + 1) = 'L';

        /* 端口号 */
        send += 2;
        *send = J7;

        /* 数据包长度 */
        send += 1;
        *send = (uint8_t)(J7_485RxBufferIndex >> 8);
        *(send + 1) = (uint8_t)(J7_485RxBufferIndex);

        /* 数据包 */
        send += 2;
        memcpy((char *)send, (char *)J7_485RxBuffer, J7_485RxBufferIndex);

        /* 结束标志 */
        send += J7_485RxBufferIndex;
        *send = 0x17;

        /* 队列中有空间，则将发送数据 */
        if (uxQueueSpacesAvailable(mcu_uart_Queue)) {
            xQueueSend(mcu_uart_Queue, &Buff, 10);
        }
        /* 队列无空间，将数据丢弃 */
        else {
            vPortFree(Buff);
        }

        /* 发送完成或遇到问题，将buff中的数据清零 */
        J7_485RxBufferIndex = 0;
    }
}

/**
  * @brief  接收J8口传来的数据
  * @param 
  * @retval
  */
void J8_SensorDataAnalysis(void)
{
    static uint32_t tick;

    if (J8_485RxBufferIndex == 0) {
        tick = xTaskGetTickCount();
    }

    /* 单次进入最多6ms（3个时钟周期），串口中有数据 */
    uint32_t nowTick = xTaskGetTickCount();
    while ((getTickDiff(nowTick) < 3)
            && (uart_dev_char_present(g_J8_handle) == 1)
            && (maxdataLen > J8_485RxBufferIndex)) {
        J8_485RxBuffer[J8_485RxBufferIndex++] = uart_dev_in_char(g_J8_handle);
    }

    /* 当时间到达或者数据量到达，就打包发送给智能模块 */
    if ((J8_485RxBufferIndex >= maxdataLen) || (getTickDiff(tick) > delayTick)) {
        uint32_t tempLen = 6 + J8_485RxBufferIndex + slaveQueueUartSendInfoSize;
        if (xPortGetFreeHeapSize() < tempLen + 1024) {
            J8_485RxBufferIndex = 0;
            return;
        }

        uint8_t *Buff = (uint8_t *)pvPortMalloc(tempLen);
        slaveQueueUartSendInfo *sendBuff = (slaveQueueUartSendInfo *)Buff;
        sendBuff->length = 6 + J8_485RxBufferIndex;        
        sendBuff->data = Buff + sizeof(slaveQueueUartSendInfo);
        uint8_t *send = sendBuff->data;

        /* 起始标志 */
        *send = 'S';
        *(send + 1) = 'L';

        /* 端口号 */
        send += 2;
        *send = J8;

        /* 数据包长度 */
        send += 1;
        *send = (uint8_t)(J8_485RxBufferIndex >> 8);
        *(send + 1) = (uint8_t)(J8_485RxBufferIndex);

        /* 数据包 */
        send += 2;
        memcpy((char *)send, (char *)J8_485RxBuffer, J8_485RxBufferIndex);

        /* 结束标志 */
        send += J8_485RxBufferIndex;
        *send = 0x17;

        /* 队列中有空间，则将发送数据 */
        if (uxQueueSpacesAvailable(mcu_uart_Queue)) {
            xQueueSend(mcu_uart_Queue, &Buff, 10);
        }
        /* 队列无空间，将数据丢弃 */
        else {
            vPortFree(Buff);
        }

        /* 发送完成或遇到问题，将buff中的数据清零 */
        J8_485RxBufferIndex = 0;
    }
}

/**
  * @brief  接收J9口传来的数据
  * @param 
  * @retval
  */
void J9_SensorDataAnalysis(void)
{
    static uint32_t tick;

    if (J9_485RxBufferIndex == 0) {
        tick = xTaskGetTickCount();
    }

    /* 单次进入最多6ms（3个时钟周期），串口中有数据 */
    uint32_t nowTick = xTaskGetTickCount();
    while ((getTickDiff(nowTick) < 3)
            && (uart_dev_char_present(g_J9_handle) == 1)
            && (maxdataLen > J9_485RxBufferIndex)) {
        J9_485RxBuffer[J9_485RxBufferIndex++] = uart_dev_in_char(g_J9_handle);
    }

    /* 当时间到达或者数据量到达，就打包发送给智能模块 */
    if ((J9_485RxBufferIndex >= maxdataLen) || (getTickDiff(tick) > delayTick)) {
        uint32_t tempLen = 6 + J9_485RxBufferIndex + slaveQueueUartSendInfoSize;
        if (xPortGetFreeHeapSize() < tempLen + 1024) {
            J9_485RxBufferIndex = 0;
            return;
        }

        uint8_t *Buff = (uint8_t *)pvPortMalloc(tempLen);
        slaveQueueUartSendInfo *sendBuff = (slaveQueueUartSendInfo *)Buff;
        sendBuff->length = 6 + J9_485RxBufferIndex;        
        sendBuff->data = Buff + sizeof(slaveQueueUartSendInfo);
        uint8_t *send = sendBuff->data;

        /* 起始标志 */
        *send = 'S';
        *(send + 1) = 'L';

        /* 端口号 */
        send += 2;
        *send = J9;

        /* 数据包长度 */
        send += 1;
        *send = (uint8_t)(J9_485RxBufferIndex >> 8);
        *(send + 1) = (uint8_t)(J9_485RxBufferIndex);

        /* 数据包 */
        send += 2;
        memcpy((char *)send, (char *)J9_485RxBuffer, J9_485RxBufferIndex);

        /* 结束标志 */
        send += J9_485RxBufferIndex;
        *send = 0x17;

        /* 队列中有空间，则将发送数据 */
        if (uxQueueSpacesAvailable(mcu_uart_Queue)) {
            xQueueSend(mcu_uart_Queue, &Buff, 10);
        }
        /* 队列无空间，将数据丢弃 */
        else {
            vPortFree(Buff);
        }

        /* 发送完成或遇到问题，将buff中的数据清零 */
        J9_485RxBufferIndex = 0;
    }
}