UartContext.cpp 7.4 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317
  1. /*
  2. * UartContext.cpp
  3. *
  4. */
  5. #include <stdio.h>
  6. #include <unistd.h>
  7. #include <fcntl.h>
  8. #include <memory.h>
  9. #include <termio.h>
  10. #include <string>
  11. #include <sys/ioctl.h>
  12. #include "uart/UartContext.h"
  13. #include "utils/Log.h"
  14. #include "base/strings.hpp"
  15. #include "service/BusinessConfig.h"
  16. #define UART_DATA_BUF_LEN 16384 // 16KB
  17. extern int parseProtocol(const BYTE *pData, UINT len);
  18. extern void buildProtocolData(std::string info);
  19. static const char* getBaudRate(UINT baudRate) {
  20. struct {
  21. UINT baud;
  22. const char *pBaudStr;
  23. } baudInfoTab[] = {
  24. { B1200, "B1200" },
  25. { B2400, "B2400" },
  26. { B4800, "B4800" },
  27. { B9600, "B9600" },
  28. { B19200, "B19200" },
  29. { B38400, "B38400" },
  30. { B57600, "B57600" },
  31. { B115200, "B115200" },
  32. { B230400, "B230400" },
  33. { B460800, "B460800" },
  34. { B921600, "B921600" }
  35. };
  36. int len = sizeof(baudInfoTab) / sizeof(baudInfoTab[0]);
  37. for (int i = 0; i < len; ++i) {
  38. if (baudInfoTab[i].baud == baudRate) {
  39. return baudInfoTab[i].pBaudStr;
  40. }
  41. }
  42. return NULL;
  43. }
  44. UartContext::UartContext(int uartNum) :
  45. mIsOpen(false),
  46. mUartID(0),
  47. mDataBufPtr(NULL),
  48. mDataBufLen(0),
  49. mUartNumber(uartNum){
  50. }
  51. UartContext::~UartContext() {
  52. delete[] mDataBufPtr;
  53. closeUart();
  54. }
  55. static bool mUart1IsOpen = false;
  56. static bool mUart2IsOpen = false;
  57. static bool mUart3IsOpen = false;
  58. // 打开串口,pFileName为串口号,baudRate为波特率
  59. bool UartContext::openUart(const char *pFileName, UINT baudRate) {
  60. // LOGD("打开串口 串口号 = %s, 波特率 = %s\n", pFileName, getBaudRate(baudRate));
  61. mUartID = open(pFileName, O_RDWR|O_NOCTTY); // mUartID等于打开的串口
  62. LOGD("mUartNumber == %d", mUartNumber);
  63. if (mUartID <= 0) {
  64. mIsOpen = false;
  65. if (mUartNumber == 1) {
  66. mUart1IsOpen = false;
  67. }
  68. if (mUartNumber == 2) {
  69. mUart2IsOpen = false;
  70. }
  71. if (mUartNumber == 3) {
  72. mUart3IsOpen = false;
  73. }
  74. LOGD("uart%d open error", mUartNumber);
  75. } else {
  76. struct termios oldtio = { 0 };
  77. struct termios newtio = { 0 };
  78. tcgetattr(mUartID, &oldtio);
  79. newtio.c_cflag = baudRate|CS8|CLOCAL|CREAD;
  80. newtio.c_iflag = 0; // IGNPAR | ICRNL
  81. newtio.c_oflag = 0;
  82. newtio.c_lflag = 0; // ICANON
  83. newtio.c_cc[VTIME] = 0; /* inter-character timer unused */
  84. newtio.c_cc[VMIN] = 1; /* blocking read until 1 character arrives */
  85. tcflush(mUartID, TCIOFLUSH);
  86. tcsetattr(mUartID, TCSANOW, &newtio);
  87. // 设置为非阻塞 Set to non-blocking
  88. fcntl(mUartID, F_SETFL, O_NONBLOCK);
  89. mIsOpen = run("uart");
  90. if (!mIsOpen) {
  91. close(mUartID);
  92. mUartID = 0;
  93. }
  94. if (mUartNumber == 1) {
  95. mUart1IsOpen = true;
  96. }
  97. if (mUartNumber == 2) {
  98. mUart2IsOpen = true;
  99. }
  100. if (mUartNumber == 3) {
  101. mUart3IsOpen = true;
  102. }
  103. LOGD("openUart mIsOpen = %d\n", mIsOpen);
  104. }
  105. return mIsOpen;
  106. }
  107. void UartContext::closeUart() {
  108. LOGD("closeUart mIsOpen: %d...\n", mIsOpen);
  109. if (mIsOpen) {
  110. requestExit();
  111. close(mUartID);
  112. mUartID = 0;
  113. mIsOpen = false;
  114. }
  115. }
  116. // 发送串口消息
  117. bool UartContext::send(const BYTE *pData, UINT len) {
  118. // 这里是串口没有打开
  119. if (!mIsOpen) {
  120. LOGD("uart%d not opend", mUartNumber);
  121. return false;
  122. }
  123. int ret = write(mUartID, pData, len); // 这是发送串口消息
  124. if (ret != (int) len) { // 这里是发送失败
  125. LOGD("发送串口消息失败\n");
  126. return false;
  127. }
  128. std::string logInfo = " >>> ";
  129. for (int i = 0; i < len; ++i) {
  130. logInfo += base::format("%02x",pData[i]);
  131. }
  132. LOGD("%s",logInfo.c_str());
  133. // success
  134. LOGD("send Success\n");
  135. return true;
  136. }
  137. //UartContext* UartContext::getInstance() {
  138. // static UartContext sUC;
  139. // return &sUC;
  140. //}
  141. bool UartContext::readyToRun() {
  142. if (mDataBufPtr == NULL) {
  143. mDataBufPtr = new BYTE[UART_DATA_BUF_LEN];
  144. }
  145. if (mDataBufPtr == NULL) {
  146. closeUart();
  147. }
  148. return (mDataBufPtr != NULL);
  149. }
  150. bool UartContext::threadLoop() {
  151. if (mIsOpen) {
  152. #if 0
  153. // 可能上一次解析后有残留数据,需要拼接起来
  154. int readNum = read(mUartID, mDataBufPtr + mDataBufLen, UART_DATA_BUF_LEN - mDataBufLen);
  155. if (readNum > 0) {
  156. mDataBufLen += readNum;
  157. // 解析协议
  158. int len = parseProtocol(mDataBufPtr, mDataBufLen);
  159. if ((len > 0) && (len < mDataBufLen)) {
  160. // 将未解析的数据移到头部
  161. memcpy(mDataBufPtr, mDataBufPtr + len, mDataBufLen - len);
  162. }
  163. mDataBufLen -= len;
  164. } else {
  165. Thread::sleep(50);
  166. }
  167. #else
  168. unsigned char buffer[1024] = {0};
  169. int ret = read(mUartID, buffer, sizeof(buffer));
  170. if (ret > 0) {
  171. if (mUartID == 32) {
  172. if (buffer[0]==CMD_HEAD && buffer[ret-2] == CMD_END1 && buffer[ret-1] == CMD_END2){
  173. std::string revStr = "";
  174. //std::string logInfo = " <<< ";
  175. //依次将读取到的数据输出到日志
  176. for (int i = 0; i < ret; ++i) {
  177. if (i==0 || i==ret-1 || i==ret-2){
  178. continue;
  179. }
  180. //LOGD(" <<< %02x", buffer[i]);
  181. revStr += buffer[i];
  182. //logInfo += base::format("%02x",buffer[i]);
  183. }
  184. //LOGD(" %s",logInfo.c_str());
  185. buildProtocolData(revStr);
  186. }
  187. }
  188. else if (mUartID == 33) {
  189. if (buffer[0] == 0xfe && buffer[2] == 0x03) {
  190. if (buffer[1] == 0x08) {
  191. std::string revStr = "";
  192. for (int i = 0; i < ret; ++i) {
  193. if (i==0 || i==1 || i==2 || i==3 || i==4 || i==ret-1){
  194. continue;
  195. }
  196. char buf[1024];
  197. sprintf(buf, "%02x", buffer[i]);
  198. revStr += buf;
  199. }
  200. LOGD("revStr == %s", revStr.c_str());
  201. nfcLogin(revStr);
  202. }
  203. }
  204. }
  205. else if (mUartID == 31) {
  206. std::string revStr = "";
  207. for (int i = 0; i < ret; ++i) {
  208. char buf[1024];
  209. sprintf(buf, "%02x", buffer[i]);
  210. revStr += buf;
  211. }
  212. LOGD("revStr == %s", revStr.c_str());
  213. }
  214. } else {
  215. //没收到数据时,休眠50ms,防止过度消耗cpu
  216. usleep(1000 * 50);
  217. }
  218. #endif
  219. return true;
  220. }
  221. return false;
  222. }
  223. static UartContext* uart0 = NULL;
  224. static UartContext* uart1 = NULL;
  225. static UartContext* uart2 = NULL;
  226. static UartContext* uart3 = NULL;
  227. void UartContext::init() {
  228. // uart0 = new UartContext(UART_TTYS0);
  229. // uart0->openUart("/dev/ttyS0", B115200);
  230. uart1 = new UartContext(UART_TTYS1);
  231. uart1->openUart("/dev/ttyS1", B115200);
  232. // 20221108的板子打开了串口2
  233. uart2 = new UartContext(UART_TTYS2);
  234. uart2->openUart("/dev/ttyS2", B115200);
  235. uart3 = new UartContext(UART_TTYS3);
  236. uart3->openUart("/dev/ttyS3", B115200);
  237. LOGD("打开串口");
  238. }
  239. void UartContext::destroy() {
  240. if (uart0) {
  241. delete uart0;
  242. uart0 = NULL;
  243. }
  244. if (uart1) {
  245. delete uart1;
  246. uart1 = NULL;
  247. }
  248. if (uart2) {
  249. delete uart1;
  250. uart2 = NULL;
  251. }
  252. if (uart3) {
  253. delete uart1;
  254. uart3 = NULL;
  255. }
  256. }
  257. bool UartContext::sendTo(int uart, const BYTE* pData, UINT len) {
  258. switch (uart) {
  259. case UART_TTYS0:
  260. return uart0->send(pData, len);
  261. case UART_TTYS1:
  262. return uart1->send(pData, len);
  263. case UART_TTYS2:
  264. return uart2->send(pData, len);
  265. case UART_TTYS3:
  266. return uart3->send(pData, len);
  267. }
  268. LOGD("无效的串口号");
  269. return false;
  270. }
  271. bool UartContext::Uart1IsOpen() {return mUart1IsOpen;}
  272. bool UartContext::Uart2IsOpen() {return mUart2IsOpen;}
  273. bool UartContext::Uart3IsOpen() {return mUart3IsOpen;}