431 lines
14 KiB
C
431 lines
14 KiB
C
|
||
#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;
|
||
}
|