linux_door/jni/uart/UartContext.cpp

/*
 * UartContext.cpp
 *
 */
#include <stdio.h>
#include <unistd.h>
#include <fcntl.h>
#include <memory.h>
#include <termio.h>
#include <string>
#include <sys/ioctl.h>

#include "uart/UartContext.h"
#include "utils/Log.h"
#include "utils/ByteUtil.h"
#include "base/strings.hpp"
#include "storage/StoragePreferences.h"
#include "service/BusinessConfig.h"
#include "net/tcp_client5084.h"

#define UART_DATA_BUF_LEN			16384	// 16KB

extern int parseProtocol(const BYTE *pData, UINT len);
extern void buildProtocolData(std::string info);

static const char* getBaudRate(UINT baudRate) {
	struct {
		UINT baud;
		const char *pBaudStr;
	} baudInfoTab[] = {
		{ B1200, "B1200" },
		{ B2400, "B2400" },
		{ B4800, "B4800" },
		{ B9600, "B9600" },
		{ B19200, "B19200" },
		{ B38400, "B38400" },
		{ B57600, "B57600" },
		{ B115200, "B115200" },
		{ B230400, "B230400" },
		{ B460800, "B460800" },
		{ B921600, "B921600" }
	};

	int len = sizeof(baudInfoTab) / sizeof(baudInfoTab[0]);
	for (int i = 0; i < len; ++i) {
		if (baudInfoTab[i].baud == baudRate) {
			return baudInfoTab[i].pBaudStr;
		}
	}

	return NULL;
}

UartContext::UartContext(int uartNum) :
	mIsOpen(false),
	mUartID(0),
	mDataBufPtr(NULL),
	mDataBufLen(0),
	mUartNumber(uartNum){

}

UartContext::~UartContext() {
	delete[] mDataBufPtr;
	closeUart();
}

static bool mUart1IsOpen = false;
static bool mUart2IsOpen = false;
static bool mUart3IsOpen = false;

// 打开串口，pFileName为串口号，baudRate为波特率
bool UartContext::openUart(const char *pFileName, UINT baudRate) {
//	LOGD("打开串口  串口号 = %s, 波特率 = %s\n", pFileName, getBaudRate(baudRate));
	mUartID = open(pFileName, O_RDWR|O_NOCTTY);		// mUartID等于打开的串口

	if (mUartID <= 0) {
		mIsOpen = false;
		if (mUartNumber == 1) {
			mUart1IsOpen = false;
		}
		if (mUartNumber == 2) {
			mUart2IsOpen = false;
		}
		if (mUartNumber == 3) {
			mUart3IsOpen = false;
		}
		LOGD("uart%d open error", mUartNumber);
	} else {
		struct termios oldtio = { 0 };
		struct termios newtio = { 0 };
		tcgetattr(mUartID, &oldtio);

		newtio.c_cflag = baudRate|CS8|CLOCAL|CREAD;
		newtio.c_iflag = 0;	// IGNPAR | ICRNL
		newtio.c_oflag = 0;
		newtio.c_lflag = 0;	// ICANON
		newtio.c_cc[VTIME] = 0; /* inter-character timer unused */
		newtio.c_cc[VMIN] = 1; /* blocking read until 1 character arrives */
		tcflush(mUartID, TCIOFLUSH);
		tcsetattr(mUartID, TCSANOW, &newtio);

		// 设置为非阻塞 Set to non-blocking
		fcntl(mUartID, F_SETFL, O_NONBLOCK);

		mIsOpen = run("uart");
		if (!mIsOpen) {
			close(mUartID);
			mUartID = 0;
		}

		if (mUartNumber == 1) {
			mUart1IsOpen = true;
		}
		if (mUartNumber == 2) {
			mUart2IsOpen = true;
		}
		if (mUartNumber == 3) {
			mUart3IsOpen = true;
		}

		LOGD("openUart mIsOpen = %d\n", mIsOpen);
	}

	return mIsOpen;
}

void UartContext::closeUart() {
	LOGD("closeUart mIsOpen: %d...\n", mIsOpen);
	if (mIsOpen) {
		requestExit();

		close(mUartID);
		mUartID = 0;
		mIsOpen = false;
	}
}

// 发送串口消息
bool UartContext::send(const BYTE *pData, UINT len) {
	// 这里是串口没有打开
	if (!mIsOpen) {
		LOGD("uart%d not opend", mUartNumber);
		return false;
	}


	int ret = write(mUartID, pData, len); // 这是发送串口消息
	if (ret != (int) len) {	// 这里是发送失败
		LOGD("发送串口消息失败\n");
		return false;
	}

	std::string logInfo = " >>> ";
	for (int i = 0; i < len; ++i) {
		logInfo += base::format("%02x",pData[i]);
	}
	LOGD("%s",logInfo.c_str());

	// success
	LOGD("send Success\n");

	return true;
}

//UartContext* UartContext::getInstance() {
//	static UartContext sUC;
//	return &sUC;
//}

bool UartContext::readyToRun() {
	if (mDataBufPtr == NULL) {
		mDataBufPtr = new BYTE[UART_DATA_BUF_LEN];
	}

	if (mDataBufPtr == NULL) {
		closeUart();
	}

	return (mDataBufPtr != NULL);
}


static std::string sleepRevStr = "";
static int sleepRevStrSize = 0;
static unsigned char s433Buffer[5] = {0};
static int s433BufferSize = 0;
void dataProcessing(int ret, unsigned char* buffer, std::string serialType) {

	if (serialType == SerialType::ENABLE) {
		return;
	}
	else if (serialType == SerialType::PANEL_BUTTON) {
		if (buffer[0]==CMD_HEAD && buffer[ret-2] == CMD_END1 && buffer[ret-1] == CMD_END2){
			std::string revStr = "";
			//std::string logInfo = " <<< ";
			//依次将读取到的数据输出到日志
			for (int i = 0; i < ret; ++i) {
				if (i==0 || i==ret-1 || i==ret-2){
					continue;
				}
				revStr += buffer[i];
			}
			buildProtocolData(revStr);
		}
	}
	else if (serialType == SerialType::S433_BUTTON) {
        std::string revStr = "";
        if (ret < 5) {
        	for (int i = 0; i < ret; ++i) {
        		s433Buffer[s433BufferSize + i] = buffer[i];
        	}
        	s433BufferSize += ret;

        	if (s433BufferSize < 5) {
            	return;
        	}
        	else {
        		s433BufferSize = 0;
        	}
        }
        else {
        	ByteUtil::copyUnsignedCharArray(buffer, s433Buffer, ret);
        }

        for (int i = 0; i < 5; ++i) {
			if (i == 0 || i == 4){
				continue;
			}
            char buf[1024];
            sprintf(buf, "%02x", s433Buffer[i]);
            revStr += buf;
        }
//        LOGD("revStr == %s", revStr.c_str());
        TcpClient::instance()->dataParse(revStr);
		return;
	}
	else if (serialType == SerialType::MULTIFUNCTIONAL_BUTTON) {
		return;
	}
	else if (serialType == SerialType::SLEEP_MATTRESS) {
		// cd0f0076000004643320504168100064e401a601e301a501df01a501e601a601e101a501e101a401e401a601e301a401e401a301e401a401e101a601e201a501e301a301e401a401e101a401df01a401e301a501e301a501e201a401e401a401e101a401e101a501e201a301e201a501e201a3015631303032dc
		char buf[1024] = {0};
		// 根据进入的数据来判断，如果进入的数据是cd开头
		if (buffer[0] == 0xcd && sleepRevStr == "") {
			// 循环拼接解析
			sleepRevStr = ByteUtil::convertToString(buffer, ret);
//			LOGD("sleepRevStr1 =======================> %s", sleepRevStr.c_str());

			// 如果进入的数据字节数大于4，就可以判断完整数据长度
			if (ret >= 4) {
				sprintf(buf, "%02x", buffer[3]);
				char *stop;
				sleepRevStrSize = strtol(buf, &stop, 16);
			}
		}
		else {
			if (sleepRevStr.substr(0, 2) == "cd") {
				for (int i = 0; i < ret; ++i) {
					sprintf(buf, "%02x", buffer[i]);
					sleepRevStr += buf;

					if (sleepRevStr.size() == 8) {
						char *stop;
						sleepRevStrSize = strtol(buf, &stop, 16);
					}
				}
//				LOGD("sleepRevStr2 =======================> %s", sleepRevStr.c_str());
			}
		}

		if (sleepRevStr.size() >= (sleepRevStrSize + 4) * 2) {
			TcpClient5084::instance()->dataParse(sleepRevStr);

			// 然后对数据进行处理
			sleepRevStr = "";
			sleepRevStrSize = 0;
		}
	}
	else if (serialType == SerialType::NFC) {
        if (buffer[0] == 0xfe && buffer[2] == 0x03) {
            if (buffer[1] == 0x08) {
                std::string revStr = "";
                for (int i = 0; i < ret; ++i) {
                    if (i==0 || i==1 || i==2 || i==3 || i==4 || i==ret-1){
                        continue;
                    }
                    char buf[1024];
                    sprintf(buf, "%02x", buffer[i]);
                    revStr += buf;
                }
                LOGD("revStr == %s", revStr.c_str());
            }
        }
		return;
	}
}


bool UartContext::threadLoop() {
	if (mIsOpen) {
#if 0
		// 可能上一次解析后有残留数据，需要拼接起来
		int readNum = read(mUartID, mDataBufPtr + mDataBufLen, UART_DATA_BUF_LEN - mDataBufLen);

		if (readNum > 0) {
			mDataBufLen += readNum;

			// 解析协议
			int len = parseProtocol(mDataBufPtr, mDataBufLen);
			if ((len > 0) && (len < mDataBufLen)) {
				// 将未解析的数据移到头部
				memcpy(mDataBufPtr, mDataBufPtr + len, mDataBufLen - len);
			}

			mDataBufLen -= len;
		} else {
			Thread::sleep(50);
		}
#else
		unsigned char buffer[1024] = {0};
		int ret = read(mUartID, buffer, sizeof(buffer));
		if (ret > 0) {
			if (mUartNumber == 2) {
				dataProcessing(ret, buffer, StoragePreferences::getString(STORE_LINUX_SERIAL2, "PANEL_BUTTON"));
			}
			else if (mUartNumber == 3) {
				dataProcessing(ret, buffer, StoragePreferences::getString(STORE_LINUX_SERIAL3, "ENABLE"));
			}
			else if (mUartNumber == 1) {
				dataProcessing(ret, buffer, StoragePreferences::getString(STORE_LINUX_SERIAL1, "ENABLE"));
			}
		} else {
		  //没收到数据时，休眠50ms，防止过度消耗cpu
		  usleep(1000 * 50);
		}
#endif

		return true;
	}

	return false;
}

static UartContext* uart0 = NULL;
static UartContext* uart1 = NULL;
static UartContext* uart2 = NULL;
static UartContext* uart3 = NULL;

void UartContext::init() {
//    uart0 = new UartContext(UART_TTYS0);
//    uart0->openUart("/dev/ttyS0", B115200);

	uart1 = new UartContext(UART_TTYS1);
	uart1->openUart("/dev/ttyS1", B115200);
	LOGD("打开串口1");

	uart2 = new UartContext(UART_TTYS2);
	uart2->openUart("/dev/ttyS2", B115200);
	LOGD("打开串口2");

	uart3 = new UartContext(UART_TTYS3);
	uart3->openUart("/dev/ttyS3", B115200);
	LOGD("打开串口3");
}

void UartContext::destroy() {
    if (uart0) {
        delete uart0;
        uart0 = NULL;
    }
    if (uart1) {
        delete uart1;
        uart1 = NULL;
    }
    if (uart2) {
        delete uart1;
        uart2 = NULL;
    }
    if (uart3) {
        delete uart1;
        uart3 = NULL;
    }
}

bool UartContext::sendTo(int uart, const BYTE* pData, UINT len) {
    switch (uart) {
    case UART_TTYS0:
        return uart0->send(pData, len);
    case UART_TTYS1:
        return uart1->send(pData, len);
    case UART_TTYS2:
        return uart2->send(pData, len);
    case UART_TTYS3:
        return uart3->send(pData, len);
    }
    LOGD("无效的串口号");
    return false;
}

bool UartContext::Uart1IsOpen() {return mUart1IsOpen;}
bool UartContext::Uart2IsOpen() {return mUart2IsOpen;}
bool UartContext::Uart3IsOpen() {return mUart3IsOpen;}