#include "slaveQueueUart.h"
#include "uart_dev.h"
#include "slaveBusIdleDetection.h"

#include "FM_GPIO.h"

#include "semphr.h"

/* 队列中每个消息的大小 */
#define QUEUE_SIZE 4

/* 485队列的长度 */
#define rs485QueueLength 5
#define mcuUartQueueLength 10

/* 各个通讯口的队列 */
QueueHandle_t J1_485_Queue = NULL;
QueueHandle_t J3_485_Queue = NULL;
QueueHandle_t J5_485_Queue = NULL;
QueueHandle_t J7_485_Queue = NULL;
QueueHandle_t J8_485_Queue = NULL;
QueueHandle_t J9_485_Queue = NULL;
QueueHandle_t mcu_uart_Queue = NULL;

/* 创建二值信号量 */
static SemaphoreHandle_t J1_FreeMemorySemaphore = NULL;
static SemaphoreHandle_t J3_FreeMemorySemaphore = NULL;
static SemaphoreHandle_t J5_FreeMemorySemaphore = NULL;
static SemaphoreHandle_t J7_FreeMemorySemaphore = NULL;
static SemaphoreHandle_t J8_FreeMemorySemaphore = NULL;
static SemaphoreHandle_t J9_FreeMemorySemaphore = NULL;
static SemaphoreHandle_t slaveMcu_uart_FreeMemorySemaphore = NULL;
// 创建队列集
static QueueSetHandle_t slaveBinarySemaphoreSet = NULL;
/* 创建二值信号量 */
static SemaphoreHandle_t J1_sendOverSemaphore = NULL;
static SemaphoreHandle_t J3_sendOverSemaphore = NULL;
static SemaphoreHandle_t J5_sendOverSemaphore = NULL;
static SemaphoreHandle_t J7_sendOverSemaphore = NULL;
static SemaphoreHandle_t J8_sendOverSemaphore = NULL;
static SemaphoreHandle_t J9_sendOverSemaphore = NULL;
static SemaphoreHandle_t slaveMcu_uart_sendOverSemaphore = NULL;


/* 通过该结构体接收对应的数据用来发送，结束后通过该结构体，释放数据的内存 */
typedef struct _slaveQueueSendDataInfo {
    slaveQueueUartSendInfo *J1_485_data;
    slaveQueueUartSendInfo *J3_485_data;
    slaveQueueUartSendInfo *J5_485_data;
    slaveQueueUartSendInfo *J7_485_data;
    slaveQueueUartSendInfo *J8_485_data;
    slaveQueueUartSendInfo *J9_485_data;
    slaveQueueUartSendInfo *mcu_uart_data;
} slaveQueueSendDataInfo;
static slaveQueueSendDataInfo slaveQueueSendData;


/**
  * @brief  初始化串口发送使用到的队列和释放内存所使用的信号量
  * @param  
  * @retval 
  */
void slaveUartSendInit(void)
{
    /* 初始化队列 */
    J1_485_Queue = xQueueCreate(rs485QueueLength, QUEUE_SIZE);
    J3_485_Queue = xQueueCreate(rs485QueueLength, QUEUE_SIZE);
    J5_485_Queue = xQueueCreate(rs485QueueLength, QUEUE_SIZE);
    J7_485_Queue = xQueueCreate(rs485QueueLength, QUEUE_SIZE);
    J8_485_Queue = xQueueCreate(rs485QueueLength, QUEUE_SIZE);
    J9_485_Queue = xQueueCreate(rs485QueueLength, QUEUE_SIZE);
    mcu_uart_Queue = xQueueCreate(mcuUartQueueLength, QUEUE_SIZE);

    /* 初始化释放内存二值变量 */
    J1_FreeMemorySemaphore = xSemaphoreCreateBinary();
    J3_FreeMemorySemaphore = xSemaphoreCreateBinary();
    J5_FreeMemorySemaphore = xSemaphoreCreateBinary();
    J7_FreeMemorySemaphore = xSemaphoreCreateBinary();
    J8_FreeMemorySemaphore = xSemaphoreCreateBinary();
    J9_FreeMemorySemaphore = xSemaphoreCreateBinary();
    slaveMcu_uart_FreeMemorySemaphore = xSemaphoreCreateBinary();
    // 初始化队列集
    slaveBinarySemaphoreSet = xQueueCreateSet(7);
    // 将二值信号量添加到队列集中
    xQueueAddToSet(J1_FreeMemorySemaphore, slaveBinarySemaphoreSet);
    xQueueAddToSet(J3_FreeMemorySemaphore, slaveBinarySemaphoreSet);
    xQueueAddToSet(J5_FreeMemorySemaphore, slaveBinarySemaphoreSet);
    xQueueAddToSet(J7_FreeMemorySemaphore, slaveBinarySemaphoreSet);
    xQueueAddToSet(J8_FreeMemorySemaphore, slaveBinarySemaphoreSet);
    xQueueAddToSet(J9_FreeMemorySemaphore, slaveBinarySemaphoreSet);
    xQueueAddToSet(slaveMcu_uart_FreeMemorySemaphore, slaveBinarySemaphoreSet);

    /* 发送完成信号量 */
    J1_sendOverSemaphore = xSemaphoreCreateBinary();
    xSemaphoreGive(J1_sendOverSemaphore);
    J3_sendOverSemaphore = xSemaphoreCreateBinary();
    xSemaphoreGive(J3_sendOverSemaphore);
    J5_sendOverSemaphore = xSemaphoreCreateBinary();
    xSemaphoreGive(J5_sendOverSemaphore);
    J7_sendOverSemaphore = xSemaphoreCreateBinary();
    xSemaphoreGive(J7_sendOverSemaphore);
    J8_sendOverSemaphore = xSemaphoreCreateBinary();
    xSemaphoreGive(J8_sendOverSemaphore);
    J9_sendOverSemaphore = xSemaphoreCreateBinary();
    xSemaphoreGive(J9_sendOverSemaphore);
    slaveMcu_uart_sendOverSemaphore = xSemaphoreCreateBinary();
    xSemaphoreGive(slaveMcu_uart_sendOverSemaphore);
}

/**
  * @brief  从J1队列中取出数据，并完成发送，无数据或不满足发送条件时，处于阻塞状态
  * @param  
  * @retval 
  */
void J1QueueSend(void)
{
    /* 有数据需要发送 */
    if (xQueueReceive(J1_485_Queue, slaveQueueSendData.J1_485_data, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 上次数据发送完成 */
    if (xSemaphoreTake(J1_sendOverSemaphore, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 总线空闲 */
    if (xSemaphoreTake(J1_IDLESemaphore, portMAX_DELAY) == pdTRUE) {
        return;        
    }
    slaveUartInterruptSend(g_J1_handle, slaveQueueSendData.J1_485_data->data
            , slaveQueueSendData.J1_485_data->length);
}

/**
  * @brief  从J3队列中取出数据，并完成发送，无数据或不满足发送条件时，处于阻塞状态
  * @param  
  * @retval 
  */
void J3QueueSend(void)
{
    /* 有数据需要发送 */
    if (xQueueReceive(J3_485_Queue, slaveQueueSendData.J3_485_data, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 上次数据发送完成 */
    if (xSemaphoreTake(J3_sendOverSemaphore, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 总线空闲 */
    if (xSemaphoreTake(J3_IDLESemaphore, portMAX_DELAY) == pdTRUE) {
        return;        
    }
    slaveUartInterruptSend(g_J3_handle, slaveQueueSendData.J3_485_data->data
            , slaveQueueSendData.J3_485_data->length);
}

/**
  * @brief  从J5队列中取出数据，并完成发送，无数据或不满足发送条件时，处于阻塞状态
  * @param  
  * @retval 
  */
void J5QueueSend(void)
{
    /* 有数据需要发送 */
    if (xQueueReceive(J5_485_Queue, slaveQueueSendData.J5_485_data, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 上次数据发送完成 */
    if (xSemaphoreTake(J5_sendOverSemaphore, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 总线空闲 */
    if (xSemaphoreTake(J5_IDLESemaphore, portMAX_DELAY) == pdTRUE) {
        return;        
    }
    slaveUartInterruptSend(g_J5_handle, slaveQueueSendData.J5_485_data->data
            , slaveQueueSendData.J5_485_data->length);
}

/**
  * @brief  从J7队列中取出数据，并完成发送，无数据或不满足发送条件时，处于阻塞状态
  * @param  
  * @retval 
  */
void J7QueueSend(void)
{
    /* 有数据需要发送 */
    if (xQueueReceive(J7_485_Queue, slaveQueueSendData.J7_485_data, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 上次数据发送完成 */
    if (xSemaphoreTake(J7_sendOverSemaphore, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 总线空闲 */
    if (xSemaphoreTake(J7_IDLESemaphore, portMAX_DELAY) == pdTRUE) {
        return;        
    }
    slaveUartInterruptSend(g_J7_handle, slaveQueueSendData.J7_485_data->data
            , slaveQueueSendData.J7_485_data->length);
}

/**
  * @brief  从J8队列中取出数据，并完成发送，无数据或不满足发送条件时，处于阻塞状态
  * @param  
  * @retval 
  */
void J8QueueSend(void)
{
    /* 有数据需要发送 */
    if (xQueueReceive(J8_485_Queue, slaveQueueSendData.J8_485_data, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 上次数据发送完成 */
    if (xSemaphoreTake(J8_sendOverSemaphore, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 总线空闲 */
    if (xSemaphoreTake(J8_IDLESemaphore, portMAX_DELAY) == pdTRUE) {
        return;        
    }
    slaveUartInterruptSend(g_J8_handle, slaveQueueSendData.J8_485_data->data
            , slaveQueueSendData.J8_485_data->length);
}

/**
  * @brief  从J9队列中取出数据，并完成发送，无数据或不满足发送条件时，处于阻塞状态
  * @param  
  * @retval 
  */
void J9QueueSend(void)
{
    /* 有数据需要发送 */
    if (xQueueReceive(J9_485_Queue, slaveQueueSendData.J9_485_data, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 上次数据发送完成 */
    if (xSemaphoreTake(J9_sendOverSemaphore, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 总线空闲 */
    if (xSemaphoreTake(J9_IDLESemaphore, portMAX_DELAY) == pdTRUE) {
        return;        
    }
    slaveUartInterruptSend(g_J9_handle, slaveQueueSendData.J9_485_data->data
            , slaveQueueSendData.J9_485_data->length);
}

/**
  * @brief  从slaveMcu队列中取出数据，并完成发送，无数据或不满足发送条件时，处于阻塞状态
  * @param  
  * @retval 
  */
void slaveMcuQueueSend(void)
{
    /* 有数据需要发送 */
    if (xQueueReceive(mcu_uart_Queue, slaveQueueSendData.mcu_uart_data, portMAX_DELAY) != pdTRUE) {
        return;
    }
    /* 上次数据发送完成 */
    if (xSemaphoreTake(slaveMcu_uart_sendOverSemaphore, portMAX_DELAY) != pdTRUE) {
        return;
    }
    slaveUartInterruptSend(g_Mcu_handle, slaveQueueSendData.mcu_uart_data->data
            , slaveQueueSendData.mcu_uart_data->length);
}

/**
  * @brief  数据发送完成后用于清除内存
  * @param  
  * @retval 
  */
void J1_485_IN_TXE(void)
{
    xSemaphoreGiveFromISR(J1_FreeMemorySemaphore, 0);
}
void J3_485_IN_TXE(void)
{
    xSemaphoreGiveFromISR(J3_FreeMemorySemaphore, 0);
}
void J5_485_IN_TXE(void)
{
    xSemaphoreGiveFromISR(J5_FreeMemorySemaphore, 0);
}
void J7_485_IN_TXE(void)
{
    xSemaphoreGiveFromISR(J7_FreeMemorySemaphore, 0);
}
void J8_485_IN_TXE(void)
{
    xSemaphoreGiveFromISR(J8_FreeMemorySemaphore, 0);
}
void J9_485_IN_TXE(void)
{
    xSemaphoreGiveFromISR(J9_FreeMemorySemaphore, 0);
}
void slaveMcu_uart_IN_TXE(void)
{
    xSemaphoreGiveFromISR(slaveMcu_uart_FreeMemorySemaphore, 0);
}


/**
  * @brief  通过二值信号量释放中断发送数据的内存
  * @param  
  * @retval 
  */
void binarySemaphoreFreeMemory(void)
{
    // 等待队列集中的事件
    QueueSetMemberHandle_t xActivatedMember = xQueueSelectFromSet(slaveBinarySemaphoreSet, portMAX_DELAY);

    if (xActivatedMember == J1_FreeMemorySemaphore) {
        vPortFree(slaveQueueSendData.J1_485_data);
        vTaskDelay(1);
        readJ1_485;
        // 处理二值信号量事件
        xSemaphoreTake(J1_FreeMemorySemaphore, 0);
        xSemaphoreGive(J1_sendOverSemaphore);
    }

    else if (xActivatedMember == J3_FreeMemorySemaphore) {
        vPortFree(slaveQueueSendData.J3_485_data);
        vTaskDelay(1);
        readJ3_485;
        xSemaphoreTake(J3_FreeMemorySemaphore, 0);
        xSemaphoreGive(J3_sendOverSemaphore);
    }

    else if (xActivatedMember == J5_FreeMemorySemaphore) {
        vPortFree(slaveQueueSendData.J5_485_data);
        vTaskDelay(1);
        readJ5_485;
        xSemaphoreTake(J5_FreeMemorySemaphore, 0);
        xSemaphoreGive(J5_sendOverSemaphore);
    }

    else if (xActivatedMember == J7_FreeMemorySemaphore) {
        vPortFree(slaveQueueSendData.J7_485_data);
        vTaskDelay(1);
        readJ7_485;
        xSemaphoreTake(J7_FreeMemorySemaphore, 0);
        xSemaphoreGive(J7_sendOverSemaphore);
    }

    else if (xActivatedMember == J8_FreeMemorySemaphore) {
        vPortFree(slaveQueueSendData.J8_485_data);
        vTaskDelay(1);
        readJ8_485;
        xSemaphoreTake(J8_FreeMemorySemaphore, 0);
        xSemaphoreGive(J8_sendOverSemaphore);
    }

    else if (xActivatedMember == J9_FreeMemorySemaphore) {
        vPortFree(slaveQueueSendData.J9_485_data);
        vTaskDelay(1);
        readJ9_485;
        xSemaphoreTake(J9_FreeMemorySemaphore, 0);
        xSemaphoreGive(J9_sendOverSemaphore);
    }

    else if (xActivatedMember == slaveMcu_uart_FreeMemorySemaphore) {
        vPortFree(slaveQueueSendData.mcu_uart_data);
        xSemaphoreTake(slaveMcu_uart_FreeMemorySemaphore, 0);
        xSemaphoreGive(slaveMcu_uart_sendOverSemaphore);
    }
}

/**
  * @brief  通过中断发送
  * @param  device 设备
            data 指向数据的指针
            len 数据长度
  * @retval 0：成功 
            1：上次数据还未发送完成
            0xFF：错误
  */
uint8_t slaveUartInterruptSend(device_handle device,uint8_t *data, uint16_t len)
{
    /* 指向数据 */
    uart_device_info *dev = (uart_device_info *)device;
    dev->uart_send_data.data = data;
    dev->uart_send_data.count = 0;
    dev->uart_send_data.len = len;

    /* 开始发送 */
    if (device == g_J1_handle) {
        xSemaphoreTake(J1_sendOverSemaphore, 0);
        writeJ1_485;
        USART_ITConfig(J1_USART, USART_IT_TXE, ENABLE);
        USART_SendData(J1_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
    }
    else if (device == g_J3_handle) {
        xSemaphoreTake(J3_sendOverSemaphore, 0);
        writeJ3_485;
        USART_ITConfig(J3_USART, USART_IT_TXE, ENABLE);
        USART_SendData(J3_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);    
    }
    else if (device == g_J5_handle) {
        xSemaphoreTake(J5_sendOverSemaphore, 0);
        writeJ5_485;
        USART_ITConfig(J5_USART, USART_IT_TXE, ENABLE);
        USART_SendData(J5_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);    
    }
    else if (device == g_J7_handle) {
        xSemaphoreTake(J7_sendOverSemaphore, 0);
        writeJ7_485;
        USART_ITConfig(J7_USART, USART_IT_TXE, ENABLE);
        USART_SendData(J7_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);    
    }
    else if (device == g_J8_handle) {
        xSemaphoreTake(J8_sendOverSemaphore, 0);
        writeJ8_485;
        USART_ITConfig(J8_USART, USART_IT_TXE, ENABLE);
        USART_SendData(J8_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);    
    }
    else if (device == g_J9_handle) {
        xSemaphoreTake(J9_sendOverSemaphore, 0);
        writeJ9_485;
        USART_ITConfig(J9_USART, USART_IT_TXE, ENABLE);
        USART_SendData(J9_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);    
    }
    else if (device == g_Mcu_handle) {
        xSemaphoreTake(slaveMcu_uart_sendOverSemaphore, 0);
        USART_ITConfig(Mcu_USART, USART_IT_TXE, ENABLE);
        USART_SendData(Mcu_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);    
    }

    return 0;
}