SmartOS之(C++)------串口类SerialPort

 

 

SmartOS(C++)的串口驱动，兼容STM32F0/F1/F4/GD32F10x/GD32F1x0

头文件

  1 #ifndef __SerialPort_H__

  2 #define __SerialPort_H__

  3 

  4 #include "Sys.h"

  5 #include "Port.h"

  6 #include "Net\ITransport.h"

  7 

  8 // 串口类

  9 class SerialPort : public ITransport

 10 {

 11 private:

 12     byte _index;

 13     byte _parity;

 14     byte _dataBits;

 15     byte _stopBits;

 16     int _baudRate;

 17 

 18     USART_TypeDef* _port;

 19     AlternatePort _tx;

 20 #if defined(STM32F0) || defined(STM32F4)

 21     AlternatePort _rx;

 22 #else

 23     InputPort _rx;

 24 #endif

 25 

 26     void Init();

 27 

 28 public:

 29     char         Name[5];// 名称。COMx，后面1字节\0表示结束

 30     bool        IsRemap;// 是否重映射

 31     OutputPort* RS485;    // RS485使能引脚

 32     int         Error;    // 错误计数

 33 

 34     SerialPort();

 35     SerialPort(COM_Def index,

 36         int baudRate = 115200,

 37         byte parity = USART_Parity_No,       //无奇偶校验

 38         byte dataBits = USART_WordLength_8b, //8位数据长度

 39         byte stopBits = USART_StopBits_1)    //1位停止位

 40     {

 41         Init();

 42         Init(index, baudRate, parity, dataBits, stopBits);

 43     }

 44 

 45     SerialPort(USART_TypeDef* com,

 46         int baudRate = 115200,

 47         byte parity = USART_Parity_No,       //无奇偶校验

 48         byte dataBits = USART_WordLength_8b, //8位数据长度

 49         byte stopBits = USART_StopBits_1);    //1位停止位

 50     // 析构时自动关闭

 51     virtual ~SerialPort();

 52 

 53     void Init(byte index,

 54         int baudRate = 115200,

 55         byte parity = USART_Parity_No,       //无奇偶校验

 56         byte dataBits = USART_WordLength_8b, //8位数据长度

 57         byte stopBits = USART_StopBits_1);    //1位停止位

 58 

 59     void SendData(byte data, uint times = 3000);

 60 

 61     bool Flush(uint times = 3000);

 62 

 63     void GetPins(Pin* txPin, Pin* rxPin);

 64 

 65     virtual void Register(TransportHandler handler, void* param = NULL);

 66 

 67     virtual string ToString() { return Name; }

 68 

 69     static SerialPort* GetMessagePort();

 70 protected:

 71     virtual bool OnOpen();

 72     virtual void OnClose();

 73 

 74     virtual bool OnWrite(const byte* buf, uint size);

 75     virtual uint OnRead(byte* buf, uint size);

 76 

 77 private:

 78     static void OnUsartReceive(ushort num, void* param);

 79 };

 80 

 81 #endif

 82 源码实现

 83 

 84 #include "Sys.h"

 85 #include <stdio.h>

 86 

 87 #include "Port.h"

 88 #include "SerialPort.h"

 89 

 90 #define COM_DEBUG 0

 91 

 92 SerialPort::SerialPort() { Init(); }

 93 

 94 SerialPort::SerialPort(USART_TypeDef* com, int baudRate, byte parity, byte dataBits, byte stopBits)

 95 {

 96     assert_param(com);

 97 

 98     const USART_TypeDef* const g_Uart_Ports[] = UARTS;

 99     byte _index = 0xFF;

100     for(int i=0; i<ArrayLength(g_Uart_Ports); i++)

101     {

102         if(g_Uart_Ports[i] == com)

103         {

104             _index = i;

105             break;

106         }

107     }

108 

109     Init();

110     Init(_index, baudRate, parity, dataBits, stopBits);

111 }

112 

113 // 析构时自动关闭

114 SerialPort::~SerialPort()

115 {

116     if(RS485) delete RS485;

117     RS485 = NULL;

118 }

119 

120 void SerialPort::Init()

121 {

122     _index = 0xFF;

123     RS485 = NULL;

124     Error = 0;

125 

126     IsRemap = false;

127 }

128 

129 void SerialPort::Init(byte index, int baudRate, byte parity, byte dataBits, byte stopBits)

130 {

131     USART_TypeDef* const g_Uart_Ports[] = UARTS;

132     _index = index;

133     assert_param(_index < ArrayLength(g_Uart_Ports));

134 

135     _port = g_Uart_Ports[_index];

136     _baudRate = baudRate;

137     _parity = parity;

138     _dataBits = dataBits;

139     _stopBits = stopBits;

140 

141     // 根据端口实际情况决定打开状态

142     if(_port->CR1 & USART_CR1_UE) Opened = true;

143     

144     // 设置名称

145     //Name = "COMx";

146     *(uint*)Name = *(uint*)"COMx";

147     Name[3] = '0' + _index + 1;

148     Name[4] = 0;

149 }

150 

151 // 打开串口

152 bool SerialPort::OnOpen()

153 {

154     Pin rx, tx;

155     GetPins(&tx, &rx);

156 

157     //debug_printf("Serial%d Open(%d, %d, %d, %d)\r\n", _index + 1, _baudRate, _parity, _dataBits, _stopBits);

158 #if COM_DEBUG

159     if(_index != Sys.MessagePort)

160     {

161 ShowLog:

162         debug_printf("Serial%d Open(%d", _index + 1, _baudRate);

163         switch(_parity)

164         {

165             case USART_Parity_No: debug_printf(", Parity_None"); break;

166             case USART_Parity_Even: debug_printf(", Parity_Even"); break;

167             case USART_Parity_Odd: debug_printf(", Parity_Odd"); break;

168         }

169         switch(_dataBits)

170         {

171             case USART_WordLength_8b: debug_printf(", WordLength_8b"); break;

172             case USART_WordLength_9b: debug_printf(", WordLength_9b"); break;

173         }

174         switch(_stopBits)

175         {

176 #ifdef STM32F10X

177             case USART_StopBits_0_5: debug_printf(", StopBits_0_5"); break;

178 #endif

179             case USART_StopBits_1: debug_printf(", StopBits_1"); break;

180             case USART_StopBits_1_5: debug_printf(", StopBits_1_5"); break;

181             case USART_StopBits_2: debug_printf(", StopBits_2"); break;

182         }

183         debug_printf(") TX=P%c%d RX=P%c%d\r\n", _PIN_NAME(tx), _PIN_NAME(rx));

184 

185         // 有可能是打开串口完成以后跳回来

186         if(Opened) return true;

187     }

188 #endif

189 

190     USART_InitTypeDef  p;

191 

192     //串口引脚初始化

193     _tx.Set(tx);

194 #if defined(STM32F0) || defined(STM32F4)

195     _rx.Set(rx);

196 #else

197     _rx.Set(rx);

198 #endif

199 

200     // 不要关调试口，否则杯具

201     if(_index != Sys.MessagePort) USART_DeInit(_port);

202     // USART_DeInit其实就是关闭时钟，这里有点多此一举。但为了安全起见，还是使用

203 

204     // 检查重映射

205 #ifdef STM32F1XX

206     if(IsRemap)

207     {

208         switch (_index) {

209         case 0: AFIO->MAPR |= AFIO_MAPR_USART1_REMAP; break;

210         case 1: AFIO->MAPR |= AFIO_MAPR_USART2_REMAP; break;

211         case 2: AFIO->MAPR |= AFIO_MAPR_USART3_REMAP_FULLREMAP; break;

212         }

213     }

214     RCC_APB2PeriphClockCmd(RCC_APB2Periph_AFIO, ENABLE );

215 #endif

216 

217     // 打开 UART 时钟。必须先打开串口时钟，才配置引脚

218 #ifdef STM32F0XX

219     switch(_index)

220     {

221         case COM1:    RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1, ENABLE);    break;//开启时钟

222         case COM2:    RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE);    break;

223         default:    break;

224     }

225 #else

226     if (_index) { // COM2-5 on APB1

227         RCC->APB1ENR |= RCC_APB1ENR_USART2EN >> 1 << _index;

228     } else { // COM1 on APB2

229         RCC->APB2ENR |= RCC_APB2ENR_USART1EN;

230     }

231 #endif

232 

233 #ifdef STM32F0

234     GPIO_PinAFConfig(_GROUP(tx), _PIN(tx), GPIO_AF_1);//将IO口映射为USART接口

235     GPIO_PinAFConfig(_GROUP(rx), _PIN(rx), GPIO_AF_1);

236 #elif defined(STM32F4)

237     const byte afs[] = { GPIO_AF_USART1, GPIO_AF_USART2, GPIO_AF_USART3, GPIO_AF_UART4, GPIO_AF_UART5, GPIO_AF_USART6, GPIO_AF_UART7, GPIO_AF_UART8 };

238     GPIO_PinAFConfig(_GROUP(tx), _PIN(tx), afs[_index]);

239     GPIO_PinAFConfig(_GROUP(rx), _PIN(rx), afs[_index]);

240 #endif

241 

242     USART_StructInit(&p);

243     p.USART_BaudRate = _baudRate;

244     p.USART_WordLength = _dataBits;

245     p.USART_StopBits = _stopBits;

246     p.USART_Parity = _parity;

247     USART_Init(_port, &p);

248 

249     USART_ITConfig(_port, USART_IT_RXNE, ENABLE); // 串口接收中断配置

250     // 初始化的时候会关闭所有中断，这里不需要单独关闭发送中断

251     //USART_ITConfig(_port, USART_IT_TXE, DISABLE); // 不需要发送中断

252 

253     USART_Cmd(_port, ENABLE);//使能串口

254 

255     if(RS485) *RS485 = false;

256 

257     //Opened = true;

258 

259 #if COM_DEBUG

260     if(_index == Sys.MessagePort)

261     {

262         // 提前设置为已打开端口，ShowLog里面需要判断

263         Opened = true;

264         goto ShowLog;

265     }

266 #endif

267 

268     return true;

269 }

270 

271 // 关闭端口

272 void SerialPort::OnClose()

273 {

274     debug_printf("~Serial%d Close\r\n", _index + 1);

275 

276     Pin tx, rx;

277     GetPins(&tx, &rx);

278 

279     USART_DeInit(_port);

280 

281     // 检查重映射

282 #ifdef STM32F1XX

283     if(IsRemap)

284     {

285         switch (_index) {

286         case 0: AFIO->MAPR &= ~AFIO_MAPR_USART1_REMAP; break;

287         case 1: AFIO->MAPR &= ~AFIO_MAPR_USART2_REMAP; break;

288         case 2: AFIO->MAPR &= ~AFIO_MAPR_USART3_REMAP_FULLREMAP; break;

289         }

290     }

291 #endif

292 }

293 

294 // 发送单一字节数据

295 void SerialPort::SendData(byte data, uint times)

296 {

297     while(USART_GetFlagStatus(_port, USART_FLAG_TXE) == RESET && --times > 0);//等待发送完毕

298     if(times > 0)

299         USART_SendData(_port, (ushort)data);

300     else

301         Error++;

302 }

303 

304 // 向某个端口写入数据。如果size为0，则把data当作字符串，一直发送直到遇到\0为止

305 bool SerialPort::OnWrite(const byte* buf, uint size)

306 {

307     if(RS485) *RS485 = true;

308 

309     if(size > 0)

310     {

311         for(int i=0; i<size; i++) SendData(*buf++);

312     }

313     else

314     {

315         while(*buf) SendData(*buf++);

316     }

317 

318     if(RS485) *RS485 = false;

319 

320     return true;

321 }

322 

323 // 从某个端口读取数据

324 uint SerialPort::OnRead(byte* buf, uint size)

325 {

326     // 在100ms内接收数据

327     uint msTimeout = 1;

328     ulong us = Time.Current() + msTimeout * 1000;

329     uint count = 0; // 收到的字节数

330     while(count < size && Time.Current() < us)

331     {

332         // 轮询接收寄存器，收到数据则放入缓冲区

333         if(USART_GetFlagStatus(_port, USART_FLAG_RXNE) != RESET)

334         {

335             *buf++ = (byte)USART_ReceiveData(_port);

336             count++;

337             us = Time.Current() + msTimeout * 1000;

338         }

339     }

340     return count;

341 }

342 

343 // 刷出某个端口中的数据

344 bool SerialPort::Flush(uint times)

345 {

346     //uint times = 3000;

347     while(USART_GetFlagStatus(_port, USART_FLAG_TXE) == RESET && --times > 0);//等待发送完毕

348     return times > 0;

349 }

350 

351 void SerialPort::Register(TransportHandler handler, void* param)

352 {

353     ITransport::Register(handler, param);

354 

355     const byte irqs[] = UART_IRQs;

356     byte irq = irqs[_index];

357     if(handler)

358     {

359         Interrupt.SetPriority(irq, 1);

360 

361         Interrupt.Activate(irq, OnUsartReceive, this);

362     }

363     else

364     {

365         Interrupt.Deactivate(irq);

366     }

367 }

368 

369 // 真正的串口中断函数

370 void SerialPort::OnUsartReceive(ushort num, void* param)

371 {

372     SerialPort* sp = (SerialPort*)param;

373     if(sp && sp->HasHandler())

374     {

375         if(USART_GetITStatus(sp->_port, USART_IT_RXNE) != RESET)

376         {

377             // 从栈分配，节省内存

378             byte buf[64];

379             uint len = sp->Read(buf, ArrayLength(buf));

380             if(len)

381             {

382                 len = sp->OnReceive(buf, len);

383                 assert_param(len <= ArrayLength(buf));

384                 // 如果有数据，则反馈回去

385                 if(len) sp->Write(buf, len);

386             }

387         }

388     }

389 }

390 

391 // 获取引脚

392 void SerialPort::GetPins(Pin* txPin, Pin* rxPin)

393 {

394     *rxPin = *txPin = P0;

395 

396     const Pin g_Uart_Pins[] = UART_PINS;

397     const Pin g_Uart_Pins_Map[] = UART_PINS_FULLREMAP;

398     const Pin* p = g_Uart_Pins;

399     if(IsRemap) p = g_Uart_Pins_Map;

400 

401     int n = _index << 2;

402     *txPin  = p[n];

403     *rxPin  = p[n + 1];

404 }

405 

406 extern "C"

407 {

408     SerialPort* _printf_sp;

409     bool isInFPutc;

410 

411     /* 重载fputc可以让用户程序使用printf函数 */

412     int fputc(int ch, FILE *f)

413     {

414         if(!Sys.Inited) return ch;

415 

416         int _index = Sys.MessagePort;

417         if(_index == COM_NONE) return ch;

418 

419         USART_TypeDef* g_Uart_Ports[] = UARTS;

420         USART_TypeDef* port = g_Uart_Ports[_index];

421 

422         if(isInFPutc) return ch;

423         isInFPutc = true;

424         // 检查并打开串口

425         if((port->CR1 & USART_CR1_UE) != USART_CR1_UE && _printf_sp == NULL)

426         {

427             _printf_sp = new SerialPort(port);

428             _printf_sp->Open();

429         }

430 

431         _printf_sp->SendData((byte)ch);

432 

433         isInFPutc = false;

434         return ch;

435     }

436 }

437 

438 SerialPort* SerialPort::GetMessagePort()

439 {

440     if(!_printf_sp)

441     {

442         int _index = Sys.MessagePort;

443         if(_index == COM_NONE) return NULL;

444 

445         USART_TypeDef* g_Uart_Ports[] = UARTS;

446         USART_TypeDef* port = g_Uart_Ports[_index];

447         _printf_sp = new SerialPort(port);

448         _printf_sp->Open();

449     }

450     return _printf_sp;

451 }

End!

欢迎大家一起交流 ，分享程序员励志故事。   幸福的程序员 QQ群： 智能硬件群