#include <stdio.h>
#include <string.h>
#include <pthread.h>
#include <stdlib.h>

#include <fcntl.h>
#include <unistd.h>
#include <termios.h>
#include <sys/time.h>
#include "JZsdk_uart/Uart_Config.h"
#include "JZsdk_Uart_Recv/JZsdk_Uart_RecvDeal.h"
#include "JZsdkLib.h"
#include "JZsdk_uart/JZsdk_Uart_Input.h"
#include "JZsdk_TaskManagement/TaskManagement.h"
#include "JZsdk_Uart_UartDeal.h"


#if APP_VERSION == APP_PSDK
	#include "data_transmission/test_data_transmission.h"
#endif

// 串口参数结构体
typedef struct
{
	int UartFd;			   // 串口识别符
	int UartDevName;    //串口名
	char Message[1024];	   // 传递的字符串
	int MessageLength;	   // 字符串的长度
	int ResLen;			//剩余长度
	pthread_mutex_t WriteMutex; // 互斥锁
	pthread_mutex_t ReadMutex; // 互斥锁
	pthread_cond_t cond;   // 条件变量
} s_SerialArgs;

// 再注册串口
typedef struct
{
	int UartFd;			   // 串口识别符
	int UartDevName;    //串口名
	int BitRate;	//波特率
} s_SerialInitArg;

//不同串口的描述符
static int Uart_4G_fd;
static int Uart_DEV1_fd;
static int Uart_DEV2_fd;

//用于判断关闭的是哪个串口
static int Uart_4G_Switch = JZ_FLAGCODE_OFF;
static int Uart_DEV1_Switch = JZ_FLAGCODE_OFF;
static int Uart_DEV2_Switch = JZ_FLAGCODE_OFF;

static int Recv_Thread = JZ_FLAGCODE_OFF;	//用于判断接收线程是否成功退出
static int Deal_Thread = JZ_FLAGCODE_OFF;	//用于判断处理线程是否成功退出

static void *UartDeal_rece(void *arg);
static void *UartDeal_deal(void *arg);

/*********************
 *
 *  串口接收线程
 *
 * *****************/
/******************************************************************

	初始化串口接收和处理

******************************************************************/
int JZsdk_Uart_UartDeal_Receive(int Uart_fd, int Uart_Dev_name)
{
	int ret = 0;
	pthread_t Uart_rece_task;

	pthread_attr_t task_attribute;										   // 线程属性
	pthread_attr_init(&task_attribute);									   // 初始化线程属性
	pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); // 设置线程属性

	if (Uart_Dev_name == UART_DEV_1)
	{
		Uart_DEV1_fd = Uart_fd;
	}
	else if (Uart_Dev_name == UART_DEV_2)
	{
		Uart_DEV2_fd = Uart_fd;
	}
	else if (Uart_Dev_name == UART_4G)
	{
		Uart_4G_fd = Uart_fd;
	}

	s_SerialArgs *parameter = (s_SerialArgs *)malloc(sizeof(s_SerialArgs));
	parameter->UartFd = Uart_fd;
	parameter->UartDevName = Uart_Dev_name;
	parameter->MessageLength = 0;
	memset(parameter->Message, 0, sizeof(parameter->Message));
	pthread_mutex_init(&parameter->WriteMutex, NULL);
	pthread_mutex_init(&parameter->ReadMutex, NULL);

	pthread_cond_init(&parameter->cond, NULL);

	// 创建串口数据接收线程
	pthread_t receiveThread;
	pthread_t SerialDealThread;
	pthread_attr_t task_attribute1;											// 线程属性
	pthread_attr_t task_attribute2;											// 线程属性
	pthread_attr_setdetachstate(&task_attribute1, PTHREAD_CREATE_DETACHED); // 设置线程分离属性
	pthread_attr_setdetachstate(&task_attribute2, PTHREAD_CREATE_DETACHED); // 设置线程分离属性

	pthread_attr_init(&task_attribute1);
	pthread_attr_init(&task_attribute2);

	if (pthread_create(&receiveThread, &task_attribute1, UartDeal_rece, parameter) != 0)
	{
		JZSDK_LOG_ERROR("Failed to create receive thread");
		return 1;
	}

	// 创建串口数据处理线程
	if (pthread_create(&SerialDealThread, &task_attribute2, UartDeal_deal, parameter) != 0)
	{
		JZSDK_LOG_ERROR("Failed to create receive thread");
		return 1;
	}
}
/***
 *
 * 	串口接收线程
 *
 * ***/
static void *UartDeal_rece(void *arg)
{

	s_SerialArgs *args = (s_SerialArgs *)arg;
	struct timeval timeout; // 超时时间
	fd_set fs_read;

	int Uart_fd = args->UartFd;

	FD_ZERO(&fs_read);
	FD_SET(Uart_fd, &fs_read);

	memset(args->Message, 0, sizeof(args->Message)); // 清空接收数组
	args->ResLen = 0;
	args->MessageLength = 0;

	int *TheadSwtch = NULL;
	if (args->UartDevName == UART_4G)
	{
		TheadSwtch = &Uart_4G_Switch;
		Uart_4G_Switch = JZ_FLAGCODE_ON;
	}
	else if (args->UartDevName == UART_DEV_1)
	{
		TheadSwtch = &Uart_DEV1_Switch;		
		Uart_DEV1_Switch = JZ_FLAGCODE_ON;
	}
	else if (args->UartDevName == UART_DEV_2)
	{
		TheadSwtch = &Uart_DEV2_Switch;
		Uart_DEV2_Switch = JZ_FLAGCODE_ON;
	}
	
	while (*TheadSwtch)
	{        
		FD_ZERO(&fs_read);
		FD_SET(Uart_fd, &fs_read);

		timeout.tv_sec = 0;
		timeout.tv_usec = 100000; // 设置为可变的超时时间（100毫秒）

		// 检查fs_read套接字是否有数据
		int ret = select(Uart_fd + 1, &fs_read, NULL, NULL, &timeout);
		if (ret < 0) {
			// 发生错误
			JZSDK_LOG_ERROR("串口select出错");
			args->MessageLength = 0;
			args->ResLen = 0;
			memset(&(args->Message[0]), 0, sizeof(args->Message));
			delayMs(3);
			continue;
		} else if (ret == 0) 
		{
			// 超时
			continue;
		}

		// 如果有数据就加锁
		pthread_mutex_lock(&args->WriteMutex);

		// 读取串口内容
		int bytesRead = read(Uart_fd, &(args->Message[args->ResLen]), (sizeof(args->Message) - args->ResLen));
		if (bytesRead > 0) 
		{
			args->MessageLength = args->ResLen + bytesRead;

			// data_len+=bytesRead;
			// data_len2+=args->MessageLength;
			// printf("当前接收长度%d  bytesRead%d bmessage%d reslen%d\n",data_len,bytesRead,data_len2,args->ResLen);

			// JZSDK_LOG_INFO("从串口读取到,长度%d",(args->MessageLength-args->ResLen));

			// for (int i = 0; i < (args->MessageLength-args->ResLen); i++)
			// {
			// 	JZSDK_LOG_OUTPUTHEX("%s",&args->Message[i+args->ResLen]);
			// }

			args->ResLen = 0;
		} 
		else if (bytesRead == 0) 
		{
			// 串口关闭或者无数据可读
			JZSDK_LOG_ERROR("串口读取数据为空");
			args->MessageLength = 0;
			args->ResLen = 0;
			memset(&(args->Message[0]), 0, sizeof(args->Message));
		} 
		else 
		{
			// 读取错误发生
			JZSDK_LOG_ERROR("Error reading from serial port");
			args->MessageLength = 0;
			args->ResLen = 0;
			memset(&(args->Message[0]), 0, sizeof(args->Message));
		}

		// 通知线程
		//pthread_cond_signal(&args->cond);
		pthread_mutex_unlock(&args->ReadMutex); // 解锁

		// 添加适当延时，确保接收缓冲区完全填满
		delayMs(3); // 加多了可能导致实时播放难恢复,以及声音间隔  3ms32字节 会向上约1个3ms opus一帧80字节
	}

	//注销相关
	Recv_Thread = JZ_FLAGCODE_OFF;
	// 通知线程
	//pthread_cond_signal(&args->cond);
	pthread_mutex_unlock(&args->WriteMutex); // 解锁

	JZSDK_LOG_WARN("串口接收线程被关闭");
}

/***
 *
 * 	串口处理线程
 *
 * ***/
// 串口数据处理线程函数
static void *UartDeal_deal(void *arg)
{
	s_SerialArgs *args = (s_SerialArgs *)arg;

	static int ResidualLength = 0; // 未处理数据长度

	int *TheadSwtch = NULL;
	if (args->UartDevName == UART_4G)
	{
		TheadSwtch = &Uart_4G_Switch;
		Uart_4G_Switch = JZ_FLAGCODE_ON;
	}
	else if (args->UartDevName == UART_DEV_1)
	{
		TheadSwtch = &Uart_DEV1_Switch;		
		Uart_DEV1_Switch = JZ_FLAGCODE_ON;
	}
	else if (args->UartDevName == UART_DEV_2)
	{
		TheadSwtch = &Uart_DEV2_Switch;
		Uart_DEV2_Switch = JZ_FLAGCODE_ON;
	}

	//int data_len = 0;

	while (*TheadSwtch)
	{

		// 加锁
		pthread_mutex_lock(&args->ReadMutex);

		// 等候接收线程的通知
		//pthread_cond_wait(&args->cond, &args->mutex);

		// data_len+=args->MessageLength;
		// printf("当前处理长度%d\n",data_len);

		if (args->MessageLength > 0)
		{

			//清除错误的多余半帧
			//前面有帧的长度
			if(args->ResLen != 0)
			{
				//存在第一帧，同时第二轮的数据开头是帧头，则清空前半段第一帧
				if (   (args->Message[args->ResLen ] == 0x5A) 
					&& (args->Message[args->ResLen + 1] == 0x5A) 
					&& (args->Message[args->ResLen + 2] == 0x77) )  
				{
					int temp_num;
					temp_num = args->MessageLength - args->ResLen;
					if (temp_num < 0)
					{
						temp_num = 0;
					}
		
					memcpy(args->Message, &(args->Message[args->ResLen]), temp_num);
					memset(&args->Message[temp_num], 0, (args->MessageLength - temp_num));
					args->MessageLength = temp_num;
					args->ResLen = 0;

					JZSDK_LOG_ERROR("串口上一帧为不完全帧，舍弃该帧操作");
				}
			}
			
			// 处理数据
			ResidualLength = UartDeal_Recv_interface(0, args->UartFd, args->Message, args->MessageLength);
			//如果还有剩余的长度
			if (ResidualLength != 0)
			{
				memcpy(args->Message, &(args->Message[args->MessageLength - ResidualLength]), ResidualLength);
				memset(&(args->Message[ResidualLength]), 0, (sizeof(args->Message) - ResidualLength));
				args->MessageLength = 0;
				args->ResLen = ResidualLength;
			}
			else
			{
				memset(args->Message, 0, sizeof(args->Message));
				args->MessageLength = 0;
				args->ResLen = 0;
			}

		}
		else
		{
			memset(args->Message, 0, sizeof(args->Message));
			args->MessageLength = 0;
			args->ResLen = 0;
		}

		pthread_mutex_unlock(&args->WriteMutex); // 解锁
	}
	
	Deal_Thread = JZ_FLAGCODE_OFF;
	free(args); //释放掉处理结构体
	JZSDK_LOG_WARN("串口处理线程被关闭");
}

/*

	数据排出函数

*/
static int UartDeal_Recv_Ouput(int tpye, int fd, unsigned char *getbuf, int ReadLen)
{
	//JZSDK_LOG_INFO("UartDeal_Recv_Ouput排出函数%d",ReadLen);
	if (tpye == 0)
	{
		if (fd == Uart_DEV1_fd)
		{
			JZsdk_Uart_RecvDeal_CharmDeal(UART_DEV_1, getbuf, ReadLen);

		}
		else if (fd == Uart_DEV2_fd)
		{
			JZsdk_Uart_RecvDeal_CharmDeal(UART_DEV_2, getbuf, ReadLen);
		}
		else if (fd == Uart_4G_fd)
		{
			JZsdk_Uart_RecvDeal_CharmDeal(UART_4G, getbuf, ReadLen);
		}
		else
		{
			JZSDK_LOG_ERROR("接收到的数据不是从正常串口来的");
			return 0;
		}
	}
	else if (tpye == 1)
	{
		if (fd == HAL_DATA_TRANSMISSION)
		{
			JZsdk_Uart_RecvDeal_CharmDeal(HAL_DATA_TRANSMISSION, getbuf, ReadLen);
		}
		else
		{
			JZSDK_LOG_ERROR("接收到的数据不是从hal_transmisson来的");
			return 0;
		}		
	}
}

/*

	处理数据接口，返回没有处理的数据长度

*/
int UartDeal_Recv_interface(int type, int Uart_fd , unsigned char *getbuf, int getbufLen)
{
	//0即是串口内容
	if (type == 0)
	{
		if (Uart_fd == Uart_DEV1_fd)
		{
			JZSDK_LOG_INFO("串口-设备1号,接受到数据+未处理数据的长度len: %d", getbufLen);
		}
		else if (Uart_fd == Uart_DEV2_fd)
		{
			JZSDK_LOG_INFO("串口-设备2号,接受到数据+未处理数据的长度len: %d", getbufLen);
		}
		else if (Uart_fd == Uart_4G_fd)
		{
			JZSDK_LOG_INFO("串口-设备4G,接受到数据+未处理数据的长度len: %d", getbufLen);
		}
		else
		{
			JZSDK_LOG_ERROR("接收到的数据不是从正常串口来的");
			return 0;
		}
	}
	else if (type == 1)
	{
		if (Uart_fd == HAL_DATA_TRANSMISSION)
		{
			JZSDK_LOG_INFO("hal_data,接受到数据+未处理数据的长度len: %d", getbufLen);
		}		
		else
		{
			JZSDK_LOG_ERROR("接收到的数据不是从hal_transmisson来的");
			return 0;
		}
	}

	// 是否要打印内容
	// printf("getbuf: %s\n", getbuf);
	// for (int i = 0; i < getbufLen; i++)
	// {
	// 	printf("%x ", getbuf[i]);
	// }
	// printf("\n");

	int HaveReadLen = 0; // 已读长度
	int HaveDealLen = 0; // 已处理长度
	int FrameFlag = 0;	 // 帧标志
	int FrameLen = 0;

	// 检索出帧数据

	// 遍历数据找帧头，直到数据的倒数第4位，如果这里有帧，帧存在帧头3位+数据长度两位

	//printf("遍历开始\n");
	for (HaveReadLen = 0; HaveReadLen < (getbufLen - 4); )
	{
		// 1、如果找到 5A 5B 6A 6B 判断是否是帧
		switch (getbuf[HaveReadLen])
		{
		case 0x5A:
			if ( (getbuf[HaveReadLen + 1] == 0x5A) && (getbuf[HaveReadLen + 2] == 0x77))
			{
				//JZSDK_LOG_INFO("输入5A");
				FrameFlag = 0x5A;
				break;
			}
			else
			{
				FrameFlag = 0x00;
				break;
			}

		case 0x5B:
			if ((getbuf[HaveReadLen + 1] == 0x5B) && (getbuf[HaveReadLen + 2] == 0x77))
			{
				//JZSDK_LOG_INFO("输入5B");
				FrameFlag = 0x5B;
				break;
			}
			else
			{
				FrameFlag = 0x00;
				break;
			}

		case 0x6A:
			if ((getbuf[HaveReadLen + 1] == 0x6A) && (getbuf[HaveReadLen + 2] == 0x77))
			{
				//JZSDK_LOG_INFO("输入6A");
				FrameFlag = 0x6A;
				break;
			}
			else
			{
				FrameFlag = 0x00;
				break;
			}

		case 0x6B:
			if ((getbuf[HaveReadLen + 1] == 0x6B) && (getbuf[HaveReadLen + 2] == 0x77))
			{
				//JZSDK_LOG_INFO("输入6B");
				FrameFlag = 0x6B;
				break;
			}
			else
			{
				FrameFlag = 0x00;
				break;
			}

		default:
				FrameFlag = 0x00;
			break;
		}

		if (FrameFlag == 0)
		{
			if (HaveReadLen >= (getbufLen - 5))
			{
				//JZSDK_LOG_INFO("没有找到帧头");
			}	
			HaveReadLen++;
			continue;
		}
		
		// 3、如果有帧头,则先判断前面有没有多余的数据残留,并将其排出到处理线程
		if ((HaveReadLen - HaveDealLen) > 0)
		{
			//JZSDK_LOG_INFO("残余处理%d",(HaveReadLen - HaveDealLen));
			UartDeal_Recv_Ouput(type, Uart_fd, &getbuf[HaveDealLen], (HaveReadLen - HaveDealLen));
			HaveDealLen = HaveReadLen;
		}

		// 4、检查帧长度是否超过数组剩余内容
		FrameLen = (((int)getbuf[HaveReadLen+3]) << 8) + (int)getbuf[HaveReadLen+4];
		if (FrameLen > (getbufLen - HaveReadLen))
		{
			JZSDK_LOG_DEBUG("当前帧长度位长度%d 超出剩余帧长度%d ",FrameLen,(getbufLen - HaveReadLen));
			// 直接跳出for循环
			break;
		}

		//5、检查帧长度是否为0，避免卡死接收串口
		if (FrameLen == 0)
		{
			JZSDK_LOG_ERROR("严重错误，接收到的帧出现长度为空");
			//直接清空接收的数组
			return 0;
		}

		// 6、以上检查都没问题，则正常输出帧
		//JZSDK_LOG_INFO("正常输出帧%d",FrameLen);
		UartDeal_Recv_Ouput(type, Uart_fd, &getbuf[HaveReadLen], FrameLen);
		HaveReadLen = HaveReadLen + FrameLen;	
		HaveDealLen = HaveReadLen;

		JZSDK_LOG_INFO("framelen%d read%d [read]:%x get%d",FrameLen ,HaveReadLen, getbuf[HaveReadLen],  getbufLen);

		FrameLen = 0;
		FrameFlag = 0;
	}

	//JZSDK_LOG_INFO("UartDeal_Recv_Ouput%d  %d  %d",HaveDealLen,HaveReadLen , getbufLen);

	// 如果没有数据残留了
	if (HaveDealLen >= getbufLen) 
	{
		//printf("HaveReadLen:%d HaveDealLen%d getbufLen:%d\n",HaveReadLen,HaveDealLen,getbufLen);
		return 0;
	}

	// 如果是有帧头的情况跳出的，说明是帧被切了，需要返回帧长度给接收线程
	if (FrameFlag != 0)  //bu
	{
		// 1、判断帧的长度会不会不合理，帧的长度最大为文件名帧，其长度为9+2+400
		if (FrameLen > (9 + 2 + 400))
		{
			// 将其排出不返回
			UartDeal_Recv_Ouput(type, Uart_fd, &getbuf[HaveReadLen], (getbufLen - HaveReadLen));
			HaveDealLen = HaveReadLen;
			return 0;
		}

		printf("切帧返回%d\n",(getbufLen - HaveDealLen));

		// 2、如果合理，则返回剩余长度
		return (getbufLen - HaveDealLen);
	}

	// 如果是没有帧头的情况下跳出的
	// 1、先检查  未经检查最后 最后4 3位
	//如果还有4 或者 3 位未处理
	for (; HaveReadLen < getbufLen - 2; HaveReadLen++)
	{
		if ((getbuf[HaveReadLen] == 0x5A && getbuf[HaveReadLen + 1] == 0x5A && getbuf[HaveReadLen + 2] == 0x77) ||
			(getbuf[HaveReadLen] == 0x5B && getbuf[HaveReadLen + 1] == 0x5B && getbuf[HaveReadLen + 2] == 0x77) ||
			(getbuf[HaveReadLen] == 0x6A && getbuf[HaveReadLen + 1] == 0x6A && getbuf[HaveReadLen + 2] == 0x77) ||
			(getbuf[HaveReadLen] == 0x6B && getbuf[HaveReadLen + 1] == 0x6B && getbuf[HaveReadLen + 2] == 0x77))
		{
			if ((HaveReadLen - HaveDealLen) > 0)
			{
				UartDeal_Recv_Ouput(type, Uart_fd, &getbuf[HaveDealLen], (HaveReadLen - HaveDealLen));
				HaveDealLen = HaveReadLen;
			}

			printf("检查最后3 4位%d\n",(getbufLen - HaveDealLen));
			
			return (getbufLen - HaveDealLen);
		}
	}

	// 2、检查最后两位
	// 如果还有两位未处理
	for (; HaveReadLen < getbufLen - 1; HaveReadLen++)
	{
		if ((getbuf[HaveReadLen] == 0x5A && getbuf[HaveReadLen + 1] == 0x5A) ||
		(getbuf[HaveReadLen] == 0x5B && getbuf[HaveReadLen + 1] == 0x5B) ||
		(getbuf[HaveReadLen] == 0x6A && getbuf[HaveReadLen + 1] == 0x6A) ||
		(getbuf[HaveReadLen] == 0x6B && getbuf[HaveReadLen + 1] == 0x6B))
		{
			if ((HaveReadLen - HaveDealLen) > 0)
			{
				UartDeal_Recv_Ouput(type, Uart_fd, &getbuf[HaveDealLen], (HaveReadLen - HaveDealLen));
				HaveDealLen = HaveReadLen;
			}

					printf("检查最后两位%d\n",(getbufLen - HaveDealLen));

			return (getbufLen - HaveDealLen);
		}
	}

	// 2、检查最后一位
	// 如果还有一位未处理
	for (; HaveReadLen < getbufLen - 0; HaveReadLen++)
	{
		// 1、检查最后一位
		if (getbuf[HaveReadLen] == 0x5A ||
			getbuf[HaveReadLen] == 0x5B ||
			getbuf[HaveReadLen] == 0x6A ||
			getbuf[HaveReadLen] == 0x6B)
		{
			if ((HaveReadLen - HaveDealLen) > 0)
			{
				UartDeal_Recv_Ouput(type, Uart_fd, &getbuf[HaveDealLen], (HaveReadLen - HaveDealLen));
				HaveDealLen = HaveReadLen;
			}

				printf("检查最后一位%d\n",(getbufLen - HaveDealLen));

			return (getbufLen - HaveDealLen);
		}
	}

	// 都检查完了，还是没有帧头在里面, 将剩余的所有数据排出
	UartDeal_Recv_Ouput(type, Uart_fd, &getbuf[HaveDealLen], (HaveReadLen - HaveDealLen));
	printf("检查完毕,排出剩余数据HaveReadLen:%d HaveDealLen%d getbufLen:%d\n",HaveReadLen,HaveDealLen,getbufLen);

	return 0;
}

/**********
 * 
 *  无任务发送函数
 * 
 * ***********/
T_JZsdkReturnCode JZsdk_Uart_UartSend_NotTask(int Uart_Name, unsigned char *str, int str_lenth) 
{
	if (Uart_Name == UART_4G)
	{
		printf("向4G设备发送\n");
		write(Uart_4G_fd, str, str_lenth);
	}
	else if (Uart_Name == UART_DEV_1)
	{
		printf("向串口1号设备发送\n");
		write(Uart_DEV1_fd, str, str_lenth);
	}
	else if (Uart_Name = UART_DEV_2)
	{
		printf("向串口2号设备发送\n");
		write(Uart_DEV2_fd, str, str_lenth);
	}

	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}

typedef struct {
    char* str;
	int str_lenth;
	int Uart_name;
} UartSendData;

/**********
 * 
 *  发送任务函数
 * 
 * ***********/
static void JZsdk_Uart_UartSend_Task(void *data) 
{
	UartSendData* taskData = (UartSendData*)data;

	if (taskData->Uart_name == UART_4G)
	{
		printf("向4G设备发送\n");
		write(Uart_4G_fd, taskData->str, taskData->str_lenth);
	}
	else if (taskData->Uart_name == UART_DEV_1)
	{
		printf("向串口1号设备发送\n");
		write(Uart_DEV1_fd, taskData->str, taskData->str_lenth);
	}
	else if (taskData->Uart_name == UART_DEV_2)
	{
		printf("向串口2号设备发送\n");
		write(Uart_DEV2_fd, taskData->str, taskData->str_lenth);
	}
	else if (taskData->Uart_name == HAL_DATA_TRANSMISSION)
	{
#if APP_VERSION == APP_PSDK
		DJI_Low_Data_Trans(taskData->str, taskData->str_lenth);
#endif
	}

	free(taskData->str);
	taskData->str = NULL;

    free(taskData);
    taskData = NULL;
}

/****************
 *
 *
 *		发送函数
 *
 * ****************/
T_JZsdkReturnCode JZsdk_Uart_UartSend(int UartPort, unsigned char *send, int num)
{
	UartSendData *senddata = (UartSendData*)malloc(sizeof(UartSendData));
    if (senddata == NULL) {
        // 处理内存分配失败的情况
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

	
	senddata->str = (unsigned char*)malloc(num + 1); // 分配足够的内存用于保存字符串
    if (senddata->str == NULL) {
        // 处理内存分配失败的情况
        free(senddata); // 释放之前分配的内存
		senddata = NULL;
        return JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE;
    }

	senddata->str_lenth = num;
	senddata->Uart_name = UartPort;
	memcpy(senddata->str, send, num);

	T_JZsdkReturnCode ret = TaskManagement_SubmitTask(JZsdk_Uart_UartSend_Task, (void *)senddata);
	if (ret == JZ_ERROR_SYSTEM_MODULE_CODE_FAILURE)
	{
		free(senddata->str);
		senddata->str = NULL;
		free(senddata);
		senddata = NULL;
		return ret;
	}
	
	return JZ_ERROR_SYSTEM_MODULE_CODE_SUCCESS;
}


/****************
 *
 *		串口识别符关闭
 *
 * ****************/
int JZsdk_Uart_CloseUartFd(int UartPort)
{
	if (UartPort == UART_4G)
	{
		JZSDK_LOG_INFO("关闭4g串口识别符\n");
		close(Uart_4G_fd);
		return 0;
	}
	else if (UartPort == UART_DEV_1)
	{
		JZSDK_LOG_INFO("关闭串口1识别符\n");
		close(Uart_DEV1_fd);
		return 0;
	}
	else if (UartPort == UART_DEV_2)
	{
		JZSDK_LOG_INFO("关闭串口2识别符\n");
		close(Uart_DEV1_fd);
		return 0;
	}
}




static void *CloseUart(void *arg)
{
	s_SerialInitArg *args = (s_SerialInitArg *)arg;
	int UartPort = args->UartDevName;
	int BitRate = args->BitRate;

	Recv_Thread = JZ_FLAGCODE_ON;
	Deal_Thread = JZ_FLAGCODE_ON;

	if (UartPort == UART_4G)
	{
		JZSDK_LOG_INFO("关闭4g线程\n");
		Uart_4G_Switch = JZ_FLAGCODE_OFF;
	}
	else if (UartPort == UART_DEV_1)
	{
		JZSDK_LOG_INFO("关闭串口1线程\n");
		Uart_DEV1_Switch = JZ_FLAGCODE_OFF;
	}
	else if (UartPort == UART_DEV_2)
	{
		JZSDK_LOG_INFO("关闭串口2线程\n");
		Uart_DEV2_Switch = JZ_FLAGCODE_OFF;
	}
	else
	{
		return 0;
	}

	while ( (Recv_Thread != JZ_FLAGCODE_OFF) && (Deal_Thread != JZ_FLAGCODE_OFF))
	{
		delayMs(1);
	}
	
	delayMs(100);

	//保证全部注销后
	JZSDK_LOG_INFO("串口注销完毕");

	//创建新的
	JZsdk_Uart_SecondInit(UartPort, BitRate);

	free(args);
}

/****************
 *
 *		线程关闭, 并创建一个新的串口
 *
 * ****************/
int JZsdk_Uart_CloseUartThead(int UartPort, int BitRate)
{

    //将串口描述符关闭
    JZsdk_Uart_CloseUartFd(UartPort);

	s_SerialInitArg *parameter = (s_SerialInitArg *)malloc(sizeof(s_SerialInitArg));
	parameter->UartDevName = UartPort;
	parameter->BitRate = BitRate;


	// 创建关闭串口的线程
	pthread_t CloseThread;
	pthread_attr_t task_attribute;											// 线程属性
	pthread_attr_setdetachstate(&task_attribute, PTHREAD_CREATE_DETACHED); // 设置线程分离属性

	pthread_attr_init(&task_attribute);


	// 创建串口数据处理线程
	if (pthread_create(&CloseThread, &task_attribute, CloseUart, parameter) != 0)
	{
		JZSDK_LOG_ERROR("Failed to create receive thread");
		return 1;
	}
}