812 lines
22 KiB
C
812 lines
22 KiB
C
#include "uart_dev.h"
|
|
#include "FreeRTOS.h"
|
|
|
|
device_handle g_J0_handle;
|
|
device_handle g_J1_handle;
|
|
device_handle g_J2_handle;
|
|
device_handle g_J3_handle;
|
|
device_handle g_J4_handle;
|
|
device_handle g_J5_handle;
|
|
device_handle g_J6_handle;
|
|
device_handle g_J7_handle;
|
|
device_handle g_J8_handle;
|
|
device_handle g_J9_handle;
|
|
device_handle g_Mcu_handle;
|
|
device_handle g_Su806_handle;
|
|
device_handle g_Lora_handle;
|
|
|
|
static int32_t rs485BuffLen;
|
|
static int32_t loraBuffLen;
|
|
static int32_t mcuBuffLen;
|
|
static int32_t su806BuffLen;
|
|
|
|
static uint8_t *J0Buff;
|
|
static uint8_t *J1Buff;
|
|
static uint8_t *J2Buff;
|
|
static uint8_t *J3Buff;
|
|
static uint8_t *J4Buff;
|
|
static uint8_t *J5Buff;
|
|
static uint8_t *J6Buff;
|
|
static uint8_t *J7Buff;
|
|
static uint8_t *J8Buff;
|
|
static uint8_t *J9Buff;
|
|
static uint8_t *LoraBuff;
|
|
static uint8_t *McuBuff;
|
|
static uint8_t *Su806Buff;
|
|
|
|
|
|
/**
|
|
* @brief 串口信息初始化，串口号及波特率.
|
|
* @param uart_index 对应的硬件串口号
|
|
* @param uart_baudrate 波特率
|
|
*/
|
|
uart_device_info uart_devices[]={
|
|
[0] = {
|
|
.init = 0,
|
|
.uart_index = J01_485_INDEX,
|
|
.uart_baudrate = 9600,
|
|
},
|
|
[1] = {
|
|
.init = 0,
|
|
.uart_index = J23_485_INDEX,
|
|
.uart_baudrate = 9600,
|
|
},
|
|
[2] = {
|
|
.init = 0,
|
|
.uart_index = J45_485_INDEX,
|
|
.uart_baudrate = 9600,
|
|
},
|
|
[3] = {
|
|
.init = 0,
|
|
.uart_index = J67_485_INDEX,
|
|
.uart_baudrate = 9600,
|
|
},
|
|
[4] = {
|
|
.init = 0,
|
|
.uart_index = J8_485_INDEX,
|
|
.uart_baudrate = 9600,
|
|
},
|
|
[5] = {
|
|
.init = 0,
|
|
.uart_index = J9_485_INDEX,
|
|
.uart_baudrate = 9600,
|
|
},
|
|
[6] = {
|
|
.init = 0,
|
|
.uart_index = Lora_UART_INDEX,
|
|
.uart_baudrate = 9600,
|
|
},
|
|
[7] = {
|
|
.init = 0,
|
|
.uart_index = Su806_UART_INDEX,
|
|
.uart_baudrate = 115200,
|
|
},
|
|
[8] = {
|
|
.init = 0,
|
|
.uart_index = MCU_UART_INDEX,
|
|
.uart_baudrate = 115200,
|
|
},
|
|
};
|
|
|
|
static device_handle uart_dev_init(uartIndex_e uart_index, uint8_t *buff, int buff_size);
|
|
static void uart_init(uartIndex_e uart_index, uint32_t baud);
|
|
|
|
/**
|
|
* @brief 初始化串口设备.
|
|
* @param uart_index 初始化串口号
|
|
* @param buff 串口循环buff地址
|
|
* @param buff_size 串口循环buff对应大小
|
|
* @retval 串口句柄
|
|
*/
|
|
device_handle uart_dev_init(uartIndex_e uart_index, uint8_t *buff, int buff_size)
|
|
{
|
|
int i = 0;
|
|
for (; i < ELEMENT_OF(uart_devices); i++) {
|
|
if (uart_devices[i].uart_index == uart_index) {
|
|
if (!uart_devices[i].init) {
|
|
InitRingQueue(&uart_devices[i].uart_ring_queue, buff, buff_size);
|
|
uart_init(uart_index, uart_devices[i].uart_baudrate);
|
|
uart_devices[i].init = 1;
|
|
}
|
|
return (device_handle)(&uart_devices[i]);
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief 串口硬件初始化.
|
|
* @param uart_index 串口号
|
|
* @param baud 波特率
|
|
* @retval None
|
|
*/
|
|
void uart_init(uartIndex_e uart_index, uint32_t baud)
|
|
{
|
|
if (uart_index == J01_485_INDEX) {
|
|
uart3Init(baud);
|
|
}
|
|
else if (uart_index == J23_485_INDEX) {
|
|
uart4Init(baud);
|
|
}
|
|
else if (uart_index == J45_485_INDEX) {
|
|
uart5Init(baud);
|
|
}
|
|
else if (uart_index == J67_485_INDEX) {
|
|
uart6Init(baud);
|
|
}
|
|
else if (uart_index == J8_485_INDEX) {
|
|
uart8Init(baud);
|
|
}
|
|
else if (uart_index == J9_485_INDEX) {
|
|
uart7Init(baud);
|
|
}
|
|
else if (uart_index == Lora_UART_INDEX) {
|
|
uart7Init(baud);
|
|
}
|
|
else if (uart_index == Su806_UART_INDEX) {
|
|
uart8Init(baud);
|
|
}
|
|
else if (uart_index == MCU_UART_INDEX) {
|
|
uart2Init(baud);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief 从串口设备循环buff读取一个数据.
|
|
* @param device 串口句柄
|
|
* @retval 读取到的字符
|
|
*/
|
|
uint8_t uart_dev_in_char(device_handle device)
|
|
{
|
|
uart_device_info *device_info = (uart_device_info *)device;
|
|
char c = 0;
|
|
|
|
if (uart_dev_char_present(device))
|
|
OutRingQueue(&device_info->uart_ring_queue, (u_int8_t*)&c);
|
|
return c;
|
|
}
|
|
|
|
/**
|
|
* @brief 判断串口设备循环buff是否有数据.
|
|
* @param device 串口句柄
|
|
* @retval 0 空 1有数据
|
|
*/
|
|
int uart_dev_char_present(device_handle device)
|
|
{
|
|
uart_device_info *device_info = (uart_device_info *)device;
|
|
|
|
if((!device) || (!device_info->init))
|
|
return 0;
|
|
|
|
return !RingQueueEmpty(&device_info->uart_ring_queue);
|
|
}
|
|
|
|
/**
|
|
* @brief 主mcu初始化串口buff.
|
|
* @param rs485BufLen 485buff的长度
|
|
loraBufLen lora通信buff的长度
|
|
mcuBufLen mcu通信buff的长度
|
|
su806BufLen su806通信buff的长度
|
|
* @retval
|
|
*/
|
|
void HostMcu_uartBuf_Init(int32_t rs485BufLen, int32_t loraBufLen, int32_t mcuBufLen, int32_t su806BufLen)
|
|
{
|
|
rs485BuffLen = rs485BufLen;
|
|
loraBuffLen = loraBufLen;
|
|
mcuBuffLen = mcuBufLen;
|
|
su806BuffLen = su806BufLen;
|
|
|
|
J0Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
|
|
J2Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
|
|
J4Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
|
|
J6Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
|
|
|
|
McuBuff = (uint8_t *)pvPortMalloc(mcuBuffLen);
|
|
|
|
Su806Buff = (uint8_t *)pvPortMalloc(su806BuffLen);
|
|
|
|
LoraBuff = (uint8_t *)pvPortMalloc(loraBuffLen);
|
|
}
|
|
|
|
/**
|
|
* @brief 从mcu初始化串口buff.
|
|
* @param rs485BufLen 485buff的长度
|
|
mcuBufLen mcu通信buff的长度
|
|
* @retval
|
|
*/
|
|
void SlaveMcu_uartBuf_Init(int32_t rs485BufLen, int32_t mcuBufLen)
|
|
{
|
|
rs485BuffLen = rs485BufLen;
|
|
mcuBuffLen = mcuBufLen;
|
|
|
|
J1Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
|
|
J3Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
|
|
J4Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
|
|
J7Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
|
|
J8Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
|
|
J9Buff = (uint8_t *)pvPortMalloc(rs485BuffLen);
|
|
|
|
McuBuff = (uint8_t *)pvPortMalloc(mcuBuffLen);
|
|
}
|
|
|
|
void Init_J0_485(uint32_t baud)
|
|
{
|
|
uart_devices[0].uart_baudrate = baud;
|
|
g_J0_handle = uart_dev_init(J01_485_INDEX, J0Buff, rs485BuffLen);
|
|
}
|
|
|
|
void Init_J1_485(uint32_t baud)
|
|
{
|
|
uart_devices[0].uart_baudrate = baud;
|
|
g_J1_handle = uart_dev_init(J01_485_INDEX, J1Buff, rs485BuffLen);
|
|
}
|
|
|
|
void Init_J2_485(uint32_t baud)
|
|
{
|
|
uart_devices[1].uart_baudrate = baud;
|
|
g_J2_handle = uart_dev_init(J23_485_INDEX, J2Buff, rs485BuffLen);
|
|
}
|
|
|
|
void Init_J3_485(uint32_t baud)
|
|
{
|
|
uart_devices[1].uart_baudrate = baud;
|
|
g_J3_handle = uart_dev_init(J23_485_INDEX, J3Buff, rs485BuffLen);
|
|
}
|
|
|
|
void Init_J4_485(uint32_t baud)
|
|
{
|
|
uart_devices[2].uart_baudrate = baud;
|
|
g_J4_handle = uart_dev_init(J45_485_INDEX, J4Buff, rs485BuffLen);
|
|
}
|
|
|
|
void Init_J5_485(uint32_t baud)
|
|
{
|
|
uart_devices[2].uart_baudrate = baud;
|
|
g_J5_handle = uart_dev_init(J45_485_INDEX, J5Buff, rs485BuffLen);
|
|
}
|
|
|
|
void Init_J6_485(uint32_t baud)
|
|
{
|
|
uart_devices[3].uart_baudrate = baud;
|
|
g_J6_handle = uart_dev_init(J67_485_INDEX, J6Buff, rs485BuffLen);
|
|
}
|
|
|
|
void Init_J7_485(uint32_t baud)
|
|
{
|
|
uart_devices[3].uart_baudrate = baud;
|
|
g_J7_handle = uart_dev_init(J67_485_INDEX, J7Buff, rs485BuffLen);
|
|
}
|
|
|
|
void Init_J8_485(uint32_t baud)
|
|
{
|
|
uart_devices[4].uart_baudrate = baud;
|
|
g_J8_handle = uart_dev_init(J8_485_INDEX, J8Buff, rs485BuffLen);
|
|
}
|
|
|
|
void Init_J9_485(uint32_t baud)
|
|
{
|
|
uart_devices[5].uart_baudrate = baud;
|
|
g_J9_handle = uart_dev_init(J9_485_INDEX, J9Buff, rs485BuffLen);
|
|
}
|
|
|
|
void Init_Lora_Uart(uint32_t baud)
|
|
{
|
|
uart_devices[6].uart_baudrate = baud;
|
|
g_Lora_handle = uart_dev_init(Lora_UART_INDEX, LoraBuff, loraBuffLen);
|
|
}
|
|
|
|
void Init_Su806_Uart(uint32_t baud)
|
|
{
|
|
uart_devices[7].uart_baudrate = baud;
|
|
g_Su806_handle = uart_dev_init(Su806_UART_INDEX, Su806Buff, su806BuffLen);
|
|
}
|
|
|
|
void Init_Mcu_Uart(uint32_t baud)
|
|
{
|
|
uart_devices[8].uart_baudrate = baud;
|
|
g_Mcu_handle = uart_dev_init(MCU_UART_INDEX, McuBuff, mcuBuffLen);
|
|
}
|
|
|
|
/**
|
|
* @brief mcu初始化串口中断.
|
|
* @retval
|
|
*/
|
|
void uartIT_Init(void)
|
|
{
|
|
if (getMCU()) {
|
|
setIDLE(J0_USART, ENABLE);
|
|
setIDLE(J2_USART, ENABLE);
|
|
setIDLE(J4_USART, ENABLE);
|
|
setIDLE(J6_USART, ENABLE);
|
|
}
|
|
else {
|
|
setIDLE(J1_USART, ENABLE);
|
|
setIDLE(J3_USART, ENABLE);
|
|
setIDLE(J5_USART, ENABLE);
|
|
setIDLE(J7_USART, ENABLE);
|
|
setIDLE(J8_USART, ENABLE);
|
|
setIDLE(J9_USART, ENABLE);
|
|
}
|
|
}
|
|
|
|
/* 串口中断处理函数 */
|
|
void J0_Interrupt()
|
|
{
|
|
if (getMCU()) {
|
|
return;
|
|
}
|
|
|
|
/* 数据接收中断 */
|
|
static uint8_t flag = 0;
|
|
static uint8_t c;
|
|
if (USART_GetITStatus(J0_USART, USART_IT_RXNE) != RESET) {
|
|
if (flag == 0) {
|
|
flag = 1;
|
|
J0_485_IN_RXNE();
|
|
}
|
|
c = USART_ReceiveData(J0_USART); //接收数据
|
|
uart_device_info *dev = (uart_device_info *)g_J0_handle;
|
|
if(!RingQueueFull(&dev->uart_ring_queue))
|
|
InRingQueue(&dev->uart_ring_queue, c);
|
|
}
|
|
|
|
/* 数据发送中断 */
|
|
if (USART_GetITStatus(J0_USART, USART_IT_TXE) != RESET) {
|
|
uart_device_info *dev = (uart_device_info *)g_J0_handle;
|
|
if (dev->uart_send_data.count >= dev->uart_send_data.len) {
|
|
USART_ITConfig(J0_USART, USART_IT_TXE, DISABLE);
|
|
J0_485_IN_TXE();
|
|
return;
|
|
}
|
|
USART_SendData(J0_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
|
|
}
|
|
|
|
/* 空闲中断 */
|
|
if (USART_GetITStatus(J0_USART, USART_IT_IDLE) != RESET) {
|
|
J0_USART->STATR;
|
|
J0_USART->DATAR;
|
|
J0_485_IN_IDLE();
|
|
}
|
|
}
|
|
|
|
void J1_Interrupt()
|
|
{
|
|
if (!getMCU()) {
|
|
return;
|
|
}
|
|
|
|
/* 数据接收中断 */
|
|
static uint8_t flag = 0;
|
|
static uint8_t c;
|
|
if (USART_GetITStatus(J1_USART, USART_IT_RXNE) != RESET) {
|
|
if (flag == 0) {
|
|
flag = 1;
|
|
J1_485_IN_RXNE();
|
|
}
|
|
c = USART_ReceiveData(J1_USART); //接收数据
|
|
uart_device_info *dev = (uart_device_info *)g_J1_handle;
|
|
if(!RingQueueFull(&dev->uart_ring_queue))
|
|
InRingQueue(&dev->uart_ring_queue, c);
|
|
}
|
|
|
|
/* 数据发送中断 */
|
|
if (USART_GetITStatus(J1_USART, USART_IT_TXE) != RESET) {
|
|
uart_device_info *dev = (uart_device_info *)g_J1_handle;
|
|
if (dev->uart_send_data.count >= dev->uart_send_data.len) {
|
|
USART_ITConfig(J1_USART, USART_IT_TXE, DISABLE);
|
|
J1_485_IN_TXE();
|
|
return;
|
|
}
|
|
USART_SendData(J1_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
|
|
}
|
|
|
|
/* 空闲中断 */
|
|
if (USART_GetITStatus(J1_USART, USART_IT_IDLE) != RESET) {
|
|
J1_USART->STATR;
|
|
J1_USART->DATAR;
|
|
J1_485_IN_IDLE();
|
|
}
|
|
}
|
|
|
|
void J2_Interrupt()
|
|
{
|
|
if (getMCU()) {
|
|
return;
|
|
}
|
|
|
|
/* 数据接收中断 */
|
|
static uint8_t flag = 0;
|
|
static uint8_t c;
|
|
if (USART_GetITStatus(J2_USART, USART_IT_RXNE) != RESET) {
|
|
if (flag == 0) {
|
|
flag = 1;
|
|
J2_485_IN_RXNE();
|
|
}
|
|
c = USART_ReceiveData(J2_USART); //接收数据
|
|
uart_device_info *dev = (uart_device_info *)g_J2_handle;
|
|
if(!RingQueueFull(&dev->uart_ring_queue))
|
|
InRingQueue(&dev->uart_ring_queue, c);
|
|
}
|
|
|
|
/* 数据发送中断 */
|
|
if (USART_GetITStatus(J2_USART, USART_IT_TXE) != RESET) {
|
|
uart_device_info *dev = (uart_device_info *)g_J2_handle;
|
|
if (dev->uart_send_data.count >= dev->uart_send_data.len) {
|
|
USART_ITConfig(J2_USART, USART_IT_TXE, DISABLE);
|
|
J2_485_IN_TXE();
|
|
return;
|
|
}
|
|
USART_SendData(J2_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
|
|
}
|
|
|
|
/* 空闲中断 */
|
|
if (USART_GetITStatus(J2_USART, USART_IT_IDLE) != RESET) {
|
|
J2_USART->STATR;
|
|
J2_USART->DATAR;
|
|
J2_485_IN_IDLE();
|
|
}
|
|
}
|
|
|
|
void J3_Interrupt()
|
|
{
|
|
if (!getMCU()) {
|
|
return;
|
|
}
|
|
/* 数据接收中断 */
|
|
static uint8_t flag = 0;
|
|
static uint8_t c;
|
|
if (USART_GetITStatus(J3_USART, USART_IT_RXNE) != RESET) {
|
|
if (flag == 0) {
|
|
flag = 1;
|
|
J3_485_IN_RXNE();
|
|
}
|
|
c = USART_ReceiveData(J3_USART); //接收数据
|
|
uart_device_info *dev = (uart_device_info *)g_J3_handle;
|
|
if(!RingQueueFull(&dev->uart_ring_queue))
|
|
InRingQueue(&dev->uart_ring_queue, c);
|
|
}
|
|
|
|
/* 数据发送中断 */
|
|
if (USART_GetITStatus(J3_USART, USART_IT_TXE) != RESET) {
|
|
uart_device_info *dev = (uart_device_info *)g_J3_handle;
|
|
if (dev->uart_send_data.count >= dev->uart_send_data.len) {
|
|
USART_ITConfig(J3_USART, USART_IT_TXE, DISABLE);
|
|
J3_485_IN_TXE();
|
|
return;
|
|
}
|
|
USART_SendData(J3_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
|
|
}
|
|
|
|
/* 空闲中断 */
|
|
if (USART_GetITStatus(J3_USART, USART_IT_IDLE) != RESET) {
|
|
J3_USART->STATR;
|
|
J3_USART->DATAR;
|
|
J3_485_IN_IDLE();
|
|
}
|
|
}
|
|
|
|
void J4_Interrupt()
|
|
{
|
|
if (getMCU()) {
|
|
return;
|
|
}
|
|
/* 数据接收中断 */
|
|
static uint8_t flag = 0;
|
|
static uint8_t c;
|
|
if (USART_GetITStatus(J4_USART, USART_IT_RXNE) != RESET) {
|
|
if (flag == 0) {
|
|
flag = 1;
|
|
J4_485_IN_RXNE();
|
|
}
|
|
c = USART_ReceiveData(J4_USART); //接收数据
|
|
uart_device_info *dev = (uart_device_info *)g_J4_handle;
|
|
if(!RingQueueFull(&dev->uart_ring_queue))
|
|
InRingQueue(&dev->uart_ring_queue, c);
|
|
}
|
|
|
|
/* 数据发送中断 */
|
|
if (USART_GetITStatus(J4_USART, USART_IT_TXE) != RESET) {
|
|
uart_device_info *dev = (uart_device_info *)g_J4_handle;
|
|
if (dev->uart_send_data.count >= dev->uart_send_data.len) {
|
|
USART_ITConfig(J4_USART, USART_IT_TXE, DISABLE);
|
|
J4_485_IN_TXE();
|
|
return;
|
|
}
|
|
USART_SendData(J4_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
|
|
}
|
|
|
|
/* 空闲中断 */
|
|
if (USART_GetITStatus(J4_USART, USART_IT_IDLE) != RESET) {
|
|
J4_USART->STATR;
|
|
J4_USART->DATAR;
|
|
J4_485_IN_IDLE();
|
|
}
|
|
|
|
}
|
|
|
|
void J5_Interrupt()
|
|
{
|
|
if (!getMCU()) {
|
|
return;
|
|
}
|
|
|
|
/* 数据接收中断 */
|
|
static uint8_t flag = 0;
|
|
static uint8_t c;
|
|
if (USART_GetITStatus(J5_USART, USART_IT_RXNE) != RESET) {
|
|
if (flag == 0) {
|
|
flag = 1;
|
|
J5_485_IN_RXNE();
|
|
}
|
|
c = USART_ReceiveData(J5_USART); //接收数据
|
|
uart_device_info *dev = (uart_device_info *)g_J5_handle;
|
|
if(!RingQueueFull(&dev->uart_ring_queue))
|
|
InRingQueue(&dev->uart_ring_queue, c);
|
|
}
|
|
|
|
/* 数据发送中断 */
|
|
if (USART_GetITStatus(J5_USART, USART_IT_TXE) != RESET) {
|
|
uart_device_info *dev = (uart_device_info *)g_J5_handle;
|
|
if (dev->uart_send_data.count >= dev->uart_send_data.len) {
|
|
USART_ITConfig(J5_USART, USART_IT_TXE, DISABLE);
|
|
J5_485_IN_TXE();
|
|
return;
|
|
}
|
|
USART_SendData(J5_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
|
|
}
|
|
|
|
/* 空闲中断 */
|
|
if (USART_GetITStatus(J5_USART, USART_IT_IDLE) != RESET) {
|
|
J5_USART->STATR;
|
|
J5_USART->DATAR;
|
|
J5_485_IN_IDLE();
|
|
}
|
|
|
|
}
|
|
|
|
void J6_Interrupt()
|
|
{
|
|
if (getMCU()) {
|
|
return;
|
|
}
|
|
/* 数据接收中断 */
|
|
static uint8_t flag = 0;
|
|
static uint8_t c;
|
|
if (USART_GetITStatus(J1_USART, USART_IT_RXNE) != RESET) {
|
|
if (flag == 0) {
|
|
flag = 1;
|
|
J6_485_IN_RXNE();
|
|
}
|
|
c = USART_ReceiveData(J6_USART); //接收数据
|
|
uart_device_info *dev = (uart_device_info *)g_J6_handle;
|
|
if(!RingQueueFull(&dev->uart_ring_queue))
|
|
InRingQueue(&dev->uart_ring_queue, c);
|
|
}
|
|
|
|
/* 数据发送中断 */
|
|
if (USART_GetITStatus(J6_USART, USART_IT_TXE) != RESET) {
|
|
uart_device_info *dev = (uart_device_info *)g_J6_handle;
|
|
if (dev->uart_send_data.count >= dev->uart_send_data.len) {
|
|
USART_ITConfig(J6_USART, USART_IT_TXE, DISABLE);
|
|
J6_485_IN_TXE();
|
|
return;
|
|
}
|
|
USART_SendData(J6_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
|
|
}
|
|
|
|
/* 空闲中断 */
|
|
if (USART_GetITStatus(J6_USART, USART_IT_IDLE) != RESET) {
|
|
J6_USART->STATR;
|
|
J6_USART->DATAR;
|
|
J6_485_IN_IDLE();
|
|
}
|
|
}
|
|
|
|
void J7_Interrupt()
|
|
{
|
|
if (!getMCU()) {
|
|
return;
|
|
}
|
|
/* 数据接收中断 */
|
|
static uint8_t flag = 0;
|
|
static uint8_t c;
|
|
if (USART_GetITStatus(J7_USART, USART_IT_RXNE) != RESET) {
|
|
if (flag == 0) {
|
|
flag = 1;
|
|
J7_485_IN_RXNE();
|
|
}
|
|
c = USART_ReceiveData(J7_USART); //接收数据
|
|
uart_device_info *dev = (uart_device_info *)g_J7_handle;
|
|
if(!RingQueueFull(&dev->uart_ring_queue))
|
|
InRingQueue(&dev->uart_ring_queue, c);
|
|
}
|
|
|
|
/* 数据发送中断 */
|
|
if (USART_GetITStatus(J7_USART, USART_IT_TXE) != RESET) {
|
|
uart_device_info *dev = (uart_device_info *)g_J7_handle;
|
|
if (dev->uart_send_data.count >= dev->uart_send_data.len) {
|
|
USART_ITConfig(J7_USART, USART_IT_TXE, DISABLE);
|
|
J7_485_IN_TXE();
|
|
return;
|
|
}
|
|
USART_SendData(J7_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
|
|
}
|
|
|
|
/* 空闲中断 */
|
|
if (USART_GetITStatus(J7_USART, USART_IT_IDLE) != RESET) {
|
|
J7_USART->STATR;
|
|
J7_USART->DATAR;
|
|
J7_485_IN_IDLE();
|
|
}
|
|
|
|
}
|
|
|
|
void J8_Interrupt()
|
|
{
|
|
if (!getMCU()) {
|
|
return;
|
|
}
|
|
|
|
/* 数据接收中断 */
|
|
static uint8_t flag = 0;
|
|
static uint8_t c;
|
|
if (USART_GetITStatus(J8_USART, USART_IT_RXNE) != RESET) {
|
|
if (flag == 0) {
|
|
flag = 1;
|
|
J8_485_IN_RXNE();
|
|
}
|
|
c = USART_ReceiveData(J8_USART); //接收数据
|
|
uart_device_info *dev = (uart_device_info *)g_J8_handle;
|
|
if(!RingQueueFull(&dev->uart_ring_queue))
|
|
InRingQueue(&dev->uart_ring_queue, c);
|
|
}
|
|
|
|
/* 数据发送中断 */
|
|
if (USART_GetITStatus(J8_USART, USART_IT_TXE) != RESET) {
|
|
uart_device_info *dev = (uart_device_info *)g_J8_handle;
|
|
if (dev->uart_send_data.count >= dev->uart_send_data.len) {
|
|
USART_ITConfig(J8_USART, USART_IT_TXE, DISABLE);
|
|
J8_485_IN_TXE();
|
|
return;
|
|
}
|
|
USART_SendData(J8_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
|
|
}
|
|
|
|
/* 空闲中断 */
|
|
if (USART_GetITStatus(J8_USART, USART_IT_IDLE) != RESET) {
|
|
J8_USART->STATR;
|
|
J8_USART->DATAR;
|
|
J8_485_IN_IDLE();
|
|
}
|
|
}
|
|
|
|
void J9_Interrupt()
|
|
{
|
|
if (!getMCU()) {
|
|
return;
|
|
}
|
|
|
|
/* 数据接收中断 */
|
|
static uint8_t flag = 0;
|
|
static uint8_t c;
|
|
if (USART_GetITStatus(J9_USART, USART_IT_RXNE) != RESET) {
|
|
if (flag == 0) {
|
|
flag = 1;
|
|
J9_485_IN_RXNE();
|
|
}
|
|
c = USART_ReceiveData(J9_USART); //接收数据
|
|
uart_device_info *dev = (uart_device_info *)g_J9_handle;
|
|
if(!RingQueueFull(&dev->uart_ring_queue))
|
|
InRingQueue(&dev->uart_ring_queue, c);
|
|
}
|
|
|
|
/* 数据发送中断 */
|
|
if (USART_GetITStatus(J9_USART, USART_IT_TXE) != RESET) {
|
|
uart_device_info *dev = (uart_device_info *)g_J9_handle;
|
|
if (dev->uart_send_data.count >= dev->uart_send_data.len) {
|
|
USART_ITConfig(J9_USART, USART_IT_TXE, DISABLE);
|
|
J9_485_IN_TXE();
|
|
return;
|
|
}
|
|
USART_SendData(J9_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
|
|
}
|
|
|
|
/* 空闲中断 */
|
|
if (USART_GetITStatus(J9_USART, USART_IT_IDLE) != RESET) {
|
|
J9_USART->STATR;
|
|
J9_USART->DATAR;
|
|
J9_485_IN_IDLE();
|
|
}
|
|
}
|
|
|
|
void Mcu_Interrupt()
|
|
{
|
|
/* 数据接收中断 */
|
|
static uint8_t c;
|
|
if (USART_GetITStatus(Mcu_USART, USART_IT_RXNE) != RESET) {
|
|
c = USART_ReceiveData(Mcu_USART); //接收数据
|
|
uart_device_info *dev = (uart_device_info *)g_Mcu_handle;
|
|
if(!RingQueueFull(&dev->uart_ring_queue))
|
|
InRingQueue(&dev->uart_ring_queue, c);
|
|
}
|
|
|
|
/* 数据发送中断 */
|
|
if (USART_GetITStatus(Mcu_USART, USART_IT_TXE) != RESET) {
|
|
uart_device_info *dev = (uart_device_info *)g_Mcu_handle;
|
|
if (dev->uart_send_data.count >= dev->uart_send_data.len) {
|
|
USART_ITConfig(Mcu_USART, USART_IT_TXE, DISABLE);
|
|
if (getMCU()) {
|
|
slaveMcu_uart_IN_TXE();
|
|
}
|
|
else {
|
|
hostMcu_uart_IN_TXE();
|
|
}
|
|
return;
|
|
}
|
|
USART_SendData(Mcu_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
|
|
}
|
|
}
|
|
|
|
void Su806_Interrupt()
|
|
{
|
|
if (getMCU()) {
|
|
return;
|
|
}
|
|
|
|
/* 数据接收中断 */
|
|
static uint8_t c;
|
|
if (USART_GetITStatus(Su806_USART, USART_IT_RXNE) != RESET) {
|
|
c = USART_ReceiveData(Su806_USART); //接收数据
|
|
uart_device_info *dev = (uart_device_info *)g_Su806_handle;
|
|
if(!RingQueueFull(&dev->uart_ring_queue))
|
|
InRingQueue(&dev->uart_ring_queue, c);
|
|
}
|
|
|
|
/* 数据发送中断 */
|
|
if (USART_GetITStatus(Su806_USART, USART_IT_TXE) != RESET) {
|
|
uart_device_info *dev = (uart_device_info *)g_Su806_handle;
|
|
if (dev->uart_send_data.count >= dev->uart_send_data.len) {
|
|
USART_ITConfig(Su806_USART, USART_IT_TXE, DISABLE);
|
|
Su806_uart_IN_TXE();
|
|
return;
|
|
}
|
|
USART_SendData(Su806_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
|
|
}
|
|
}
|
|
|
|
void Lora_Interrupt()
|
|
{
|
|
if (getMCU()) {
|
|
return;
|
|
}
|
|
|
|
/* 数据接收中断 */
|
|
static uint8_t c;
|
|
if (USART_GetITStatus(Lora_USART, USART_IT_RXNE) != RESET) {
|
|
c = USART_ReceiveData(Lora_USART); //接收数据
|
|
uart_device_info *dev = (uart_device_info *)g_Lora_handle;
|
|
if(!RingQueueFull(&dev->uart_ring_queue))
|
|
InRingQueue(&dev->uart_ring_queue, c);
|
|
}
|
|
|
|
/* 数据发送中断 */
|
|
if (USART_GetITStatus(Lora_USART, USART_IT_TXE) != RESET) {
|
|
uart_device_info *dev = (uart_device_info *)g_Lora_handle;
|
|
if (dev->uart_send_data.count >= dev->uart_send_data.len) {
|
|
USART_ITConfig(Lora_USART, USART_IT_TXE, DISABLE);
|
|
Lora_uart_IN_TXE();
|
|
return;
|
|
}
|
|
USART_SendData(Lora_USART, dev->uart_send_data.data[dev->uart_send_data.count++]);
|
|
}
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|