这样的uart框架怎么样？

lindabell

以前是使用类似linux的，open/read/write/control等函数
但是发现每次设置参数时不够直观，往往要去查看代码
早上大概写写串口的API，发上来让大家指点一下。

1. #ifndef _RTS_UART_H
   
2. #define _RTS_UART_H
   
3. #include "stdint.h"
   
4. 
   
5. struct
   
6. {
   
7.     uint8_t poll_send:1;
   
8.     uint8_t poll_read:1;
   
9. 
   
10. }capability_t;
    
11. 
    
12. typedef struct
    
13. {
    
14.     uint8_t tt;
    
15. }rts_uart_t;
    
16. 
    
17. 
    
18. 
    
19. void rts_uart_init(rts_uart_t *dev);
    
20. void rts_uart_uninit(rts_uart_t *dev);
    
21. void rts_uart_control(uint32_t control,uint32_t arg);
    
22. 
    
23. void rts_uart_poll_send(rts_uart_t *dev,uint8_t *buffer,uint16_t len);
    
24. void rts_uart_poll_read(rts_uart_t *dev,uint8_t *buffer,uint16_t len);
    
25. 
    
26. void rts_uart_intterput_send(rts_uart_t *dev,uint8_t *buffer,uint16_t len);
    
27. void rts_uart_set_intterput_read_callback(rts_uart_t *dev,void (*callback)(uint8_t data));
    
28. 
    
29. 
    
30. void rts_uart_dma_send(rts_uart_t *dev,uint8_t *buffer,uint16_t len);
    
31. void rts_uart_set_dma_read_callback(rts_uart_t *dev,uint8_t *dmabuffer,uint16_t size,void (*callback)(uint8_t *buf,uint16_t len));
    
32. 
    
33. 
    
34. void rts_uart_queue_send(rts_uart_t *dev,uint8_t *buffer,uint16_t len);
    
35. void rts_uart_queue_read(rts_uart_t *dev,uint8_t *buffer,uint16_t len);
    
36. 
    
37. #endif

复制代码

whatcanitbe

把实现也开放会更赞

BongBong

很好的轮子。

redworlf007

这能看出来啥？

lindabell

whatcanitbe 发表于 2020-10-24 12:08
把实现也开放会更赞

实现还没有写

lindabell

BongBong 发表于 2020-10-24 12:09
很好的轮子。

总觉得自己的轮子好用些
像CMSISI driver/ AMetal /rt-thread 总是用不习惯

lindabell

又改了一下，使用函数指针来做

1. #ifndef _RTS_UART_H
   
2. #define _RTS_UART_H
   
3. #include "stdint.h"
   
4. 
   
5. #define RTS_UART_VERSION    "0.0.1"
   
6. 
   
7. typedef struct
   
8. {
   
9.     char *   name;
   
10.     uint32_t type;
    
11.     uint32_t api_ver;
    
12.     void *   api;
    
13. }rts_device_t;
    
14. 
    
15. 
    
16. typedef struct
    
17. {
    
18.     struct
    
19.     {
    
20.         uint32_t poll_send:1;
    
21.         uint32_t poll_read:1;
    
22.     };
    
23. 
    
24.     void (*init)(rts_uart_t *dev);
    
25.     void (*uninit)(rts_uart_t *dev);
    
26.     void (*control)(uint32_t control,uint32_t arg);
    
27. 
    
28.     void (*poll_send)(rts_uart_t *dev,uint8_t *buffer,uint16_t len);
    
29.     void (*poll_read)(rts_uart_t *dev,uint8_t *buffer,uint16_t len);
    
30. 
    
31.     void (*intterput_send)(rts_uart_t *dev,uint8_t *buffer,uint16_t len);
    
32.     void (*intterput_read_set_callback)(rts_uart_t *dev,void (*callback)(uint8_t data));
    
33. 
    
34.     void (*dma_send)(rts_uart_t *dev,uint8_t *buffer,uint16_t len);
    
35.     void (*dma_read_set_callback)(rts_uart_t *dev,uint8_t *dmabuffer,uint16_t size,void (*callback)(uint8_t *buf,uint16_t len));
    
36. 
    
37.     void (*queue_send)(rts_uart_t *dev,uint8_t *buffer,uint16_t len);
    
38.     void (*queue_read)(rts_uart_t *dev,uint8_t *buffer,uint16_t len);
    
39. 
    
40. }rts_uart_api_t;
    
41. 
    
42. 
    
43. 
    
44. #endif
    

复制代码

jaywen

lindabell 发表于 2020-10-24 12:40
又改了一下，使用函数指针来做

用第二种吧   封装太狠 都不好用    第二种移植性也比较好 我写的和你有点区别的是  read  ， write， flush，RX_dispatch    .这几个函数都是固定的 非阻塞 。通过传入串口端口指针 来进行不同的收发。你的这种的话其实和我的差不多。唯一的不同的就是 每一路串口你都需要写一个 read  write等 给函数指针

bangbangji

不错，我也用不习惯各种系统自带的。
有段时间也自己搞了一套，不过都是基于中断的，主要考虑基本上有串口的mcu肯定可以中断，而不一定都可以用dma。

lindabell

又改了一下，比较完整一点

1. #ifndef _RTS_DRIVER_H
   
2. #define _RTS_DRIVER_H
   
3. #include "stdint.h"
   
4. 
   
5. /*
   
6. 
   
7.   |=======================================|
   
8.   | app                     |             |
   
9.   |-------------------------|             |
   
10.   | rts_driver | middleware |functionware |
    
11.   |---------------------------------------|
    
12.   | hardware                              |
    
13.   |=======================================|
    
14. */
    
15. 
    
16. 
    
17. typedef enum
    
18. {
    
19.     RTS_DRIVER_TYPE_UNKNOW=0,
    
20.     RTS_DRIVER_TYPE_UART,
    
21.     RTS_DRIVER_TYPE_SPI,
    
22.     RTS_DRIVER_TYPE_I2C,
    
23.     RTS_DRIVER_TYPE_I2S,
    
24.     RTS_DRIVER_TYPE_SDIO,
    
25.     RTS_DRIVER_TYPE_USB,
    
26.     RTS_DRIVER_TYPE_FLASH,
    
27.     RTS_DRIVER_TYPE_RTC,
    
28.     RTS_DRIVER_TYPE_WATCHDOG,
    
29.     RTS_DRIVER_TYPE_ADC,
    
30.     RTS_DRIVER_TYPE_PIN,
    
31.     RTS_DRIVER_TYPE_EEPROM,
    
32.     RTS_DRIVER_TYPE_PWM,
    
33.     RTS_DRIVER_TYPE_TIMER,
    
34.     RTS_DRIVER_TYPE_DAC,
    
35.     RTS_DRIVER_TYPE_CRC,
    
36.     RTS_DRIVER_TYPE_DMA,
    
37. 
    
38. }rts_driver_type_t;
    
39. 
    
40. typedef struct
    
41. {
    
42.     const char *              name;
    
43.     const rts_driver_type_t   type;
    
44.     const uint32_t            api_ver;
    
45.     const void *              api;
    
46. }rts_driver_t;
    
47. 
    
48. 
    
49. #define RTS_DRIVER_API_VER(x,y,z)   (((0x##x)<<24)|((0x##y)<<8)|(0x##z))
    
50. 
    
51. const char *rts_driver_get_type_str(const rts_driver_t *dev);
    
52. 
    
53. 
    
54. #if defined(__CC_ARM) || (defined(__ARMCC_VERSION) && __ARMCC_VERSION >= 6000000)
    
55. #define RTS_DRIVER_SECTION(x)                  __attribute__((section(x)))
    
56. #elif defined(__ICCARM__)
    
57. #define RTS_DRIVER_SECTION(x)                  @ x
    
58. #elif defined(__GNUC__)
    
59. #define RTS_DRIVER_SECTION(x)                  __attribute__((section(x)))
    
60. #else
    
61. #define RTS_DRIVER_SECTION(x)
    
62. #endif
    
63. 
    
64. #define     RTS_DRIVER_REGISTER(_name,_type,_api_ver,_api)                                          \
    
65.             static const rts_driver_t rts_driver_##_name RTS_DRIVER_SECTION("RTS_DRIVER_LIST")=     \
    
66.             {                                                                                       \
    
67.                 .name=#_name,                                                                       \
    
68.                 .type=_type,                                                                        \
    
69.                 .api_ver=_api_ver,                                                                  \
    
70.                 .api=_api                                                                           \
    
71.             }
    
72. 
    
73. 
    
74. #endif
    

复制代码

1. #ifndef _RTS_UART_H
   
2. #define _RTS_UART_H
   
3. #include "stdint.h"
   
4. #include "rts_driver.h"
   
5. 
   
6. #define RTS_UART_API_VERSION    RTS_DRIVER_API_VER(0,0,1)
   
7. 
   
8. //error codes
   
9. typedef enum
   
10. {
    
11.     RTS_UART_SUCCESS=0,
    
12.     RTS_UART_ERROR,
    
13.     RTS_UART_BUSY,
    
14.     RTS_UART_UNSUPPORT_BAUDRATE,
    
15.     RTS_UART_UNSUPPORT_DATA_BITS,
    
16.     RTS_UART_UNSUPPORT_PARITY,
    
17.     RTS_UART_UNSUPPORT_STOP_BITS,
    
18.     RTS_UART_UNSUPPORT_APIS
    
19. }rts_uart_err_t;
    
20. 
    
21. 
    
22. //control cmd lists
    
23. #define RTS_UART_BAUDRATE           (1<<0)      //arg: baud rate(dafault:9600)
    
24. 
    
25. #define RTS_UART_DATA_BITS_5        (1<<1)
    
26. #define RTS_UART_DATA_BITS_6        (1<<2)
    
27. #define RTS_UART_DATA_BITS_7        (1<<3)
    
28. #define RTS_UART_DATA_BITS_8        (1<<4)      //default
    
29. #define RTS_UART_DATA_BITS_9        (1<<5)
    
30. 
    
31. #define RTS_UART_PARITY_EVEN        (1<<6)
    
32. #define RTS_UART_PARITY_NONE        (1<<7)      //default
    
33. #define RTS_UART_PARITY_ODD         (1<<8)
    
34. 
    
35. #define RTS_UART_STOP_BITS_1        (1<<9)      //default
    
36. #define RTS_UART_STOP_BITS_2        (1<<10)
    
37. #define RTS_UART_STOP_BITS_1_5      (1<<11)
    
38. #define RTS_UART_STOP_BITS_0_5      (1<<12)
    
39. 
    
40. #define RTS_UART_POLL_SEND          (1<<13)     //default
    
41. #define RTS_UART_POLL_READ          (1<<14)
    
42. #define RTS_UART_INTTERPUT_SEND     (1<<15)
    
43. #define RTS_UART_INTTERPUT_READ     (1<<16)     //defalut
    
44. #define RTS_UART_DMA_SEND           (1<<17)
    
45. #define RTS_UART_DMA_READ           (1<<18)
    
46. #define RTS_UART_QUEUE_SEND         (1<<19)
    
47. #define RTS_UART_QUEUE_READ         (1<<20)
    
48. 
    
49. 
    
50. #pragma anon_unions
    
51. struct rts_uart
    
52. {
    
53.     struct
    
54.     {
    
55.         uint32_t support_poll_send:1;
    
56.         uint32_t support_poll_read:1;
    
57.         uint32_t support_intterput_send:1;
    
58.         uint32_t support_intterput_read:1;
    
59.         uint32_t support_dma_send:1;
    
60.         uint32_t support_dma_read:1;
    
61.         uint32_t support_queue_send:1;
    
62.         uint32_t support_queue_read:1;
    
63.     };
    
64. 
    
65.     rts_uart_err_t (*init)(struct rts_uart *dev);
    
66.     void (*uninit)(struct rts_uart *dev);
    
67.     rts_uart_err_t (*control)(struct rts_uart *dev,uint32_t control,uint32_t arg);
    
68. 
    
69.     uint32_t (*poll_send)(struct rts_uart *dev,uint8_t *buffer,uint32_t len);
    
70.     uint32_t (*poll_read)(struct rts_uart *dev,uint8_t *buffer,uint32_t size);
    
71. 
    
72.     uint32_t (*intterput_send)(struct rts_uart *dev,uint8_t *buffer,uint32_t len);
    
73.     void (*intterput_read_set_callback)(struct rts_uart *dev,void (*callback)(uint8_t data));
    
74. 
    
75.     uint32_t (*dma_send)(struct rts_uart *dev,uint8_t *buffer,uint32_t len);
    
76.     void (*dma_read_set_callback)(struct rts_uart *dev,uint8_t *dmabuffer,uint32_t size,void (*callback)(uint8_t *buf,uint32_t len));
    
77. 
    
78.     uint32_t (*queue_send)(struct rts_uart *dev,uint8_t *buffer,uint32_t len);
    
79.     uint32_t (*queue_read)(struct rts_uart *dev,uint8_t *buffer,uint32_t len);
    
80. 
    
81. };
    
82. 
    
83. //rts uart api
    
84. inline rts_uart_err_t rts_uart_init(struct rts_uart *dev);
    
85. inline void rts_uart_uninit(struct rts_uart *dev);
    
86. inline rts_uart_err_t rts_uart_control(struct rts_uart *dev,uint32_t control,uint32_t arg);
    
87. 
    
88. inline uint32_t rts_uart_poll_send(struct rts_uart *dev,uint8_t *buffer,uint32_t len);
    
89. inline uint32_t rts_uart_poll_read(struct rts_uart *dev,uint8_t *buffer,uint32_t size);
    
90. 
    
91. inline uint32_t rts_uart_intterput_send(struct rts_uart *dev,uint8_t *buffer,uint32_t len);
    
92. inline void rts_uart_intterput_read_set_callback(struct rts_uart *dev,void (*callback)(uint8_t data));
    
93. 
    
94. inline uint32_t rts_uart_dma_send(struct rts_uart *dev,uint8_t *buffer,uint32_t len);
    
95. inline void rts_uart_dma_read_set_callback(struct rts_uart *dev,uint8_t *dmabuffer,uint32_t size,void (*callback)(uint8_t *buf,uint32_t len));
    
96. 
    
97. inline uint32_t rts_uart_queue_send(struct rts_uart *dev,uint8_t *buffer,uint32_t len);
    
98. inline uint32_t rts_uart_queue_read(struct rts_uart *dev,uint8_t *buffer,uint32_t len);
    
99. 
    
100. #endif
     

复制代码

1. #include "rts_uart.h"
   
2. #include "stdint.h"
   
3. 
   
4. inline rts_uart_err_t rts_uart_init(struct rts_uart *dev)
   
5. {
   
6.     return dev->init(dev);
   
7. }
   
8. inline void rts_uart_uninit(struct rts_uart *dev)
   
9. {
   
10.     dev->uninit(dev);
    
11. }
    
12. inline rts_uart_err_t rts_uart_control(struct rts_uart *dev,uint32_t control,uint32_t arg)
    
13. {
    
14.     return dev->control(dev,control,arg);
    
15. }
    
16. 
    
17. inline uint32_t rts_uart_poll_send(struct rts_uart *dev,uint8_t *buffer,uint32_t len)
    
18. {
    
19.     if(!dev->support_poll_send) return 0;
    
20. 
    
21.     return dev->poll_send(dev,buffer,len);
    
22. }
    
23. inline uint32_t rts_uart_poll_read(struct rts_uart *dev,uint8_t *buffer,uint32_t len)
    
24. {
    
25.     if(!dev->support_poll_read)return 0;
    
26. 
    
27.     return dev->poll_read(dev,buffer,len);
    
28. }
    
29. 
    
30. inline uint32_t rts_uart_intterput_send(struct rts_uart *dev,uint8_t *buffer,uint32_t len)
    
31. {
    
32.     if(!dev->support_intterput_send)return 0;
    
33. 
    
34.     return dev->intterput_send(dev,buffer,len);
    
35. }
    
36. inline void rts_uart_intterput_read_set_callback(struct rts_uart *dev,void (*callback)(uint8_t data))
    
37. {
    
38.     if(!dev->support_intterput_read)return;
    
39. 
    
40.     dev->intterput_read_set_callback(dev,callback);
    
41. }
    
42. 
    
43. inline uint32_t rts_uart_dma_send(struct rts_uart *dev,uint8_t *buffer,uint32_t len)
    
44. {
    
45.     if(!dev->support_dma_send)return 0;
    
46. 
    
47.     return dev->dma_send(dev,buffer,len);
    
48. }
    
49. inline void rts_uart_dma_read_set_callback(struct rts_uart *dev,uint8_t *dmabuffer,uint32_t size,void (*callback)(uint8_t *buf,uint32_t len))
    
50. {
    
51.     if(!dev->support_dma_read)return;
    
52. 
    
53.     dev->dma_read_set_callback(dev,dmabuffer,size,callback);
    
54. }
    
55. 
    
56. inline uint32_t rts_uart_queue_send(struct rts_uart *dev,uint8_t *buffer,uint32_t len)
    
57. {
    
58.     if(!dev->support_queue_send)return 0;
    
59. 
    
60.     return dev->queue_send(dev,buffer,len);
    
61. }
    
62. inline uint32_t rts_uart_queue_read(struct rts_uart *dev,uint8_t *buffer,uint32_t len)
    
63. {
    
64.     if(!dev->support_queue_read)return 0;
    
65. 
    
66.     return dev->queue_read(dev,buffer,len);
    
67. }
    

复制代码

xiaoergao

用C++吧，你会发现你想要的有更完美的实现。

lindabell

xiaoergao 发表于 2020-10-25 12:58
用C++吧，你会发现你想要的有更完美的实现。

给点思路呗

way2888

使用类，应该是很容易的吧

lindabell

way2888 发表于 2020-10-25 16:22
使用类，应该是很容易的吧

类一些函数不用的话，不能优化掉吧？

way2888

你测一下就知道了，应该会优化调吧

xiaoergao

lindabell 发表于 2020-10-25 15:24
给点思路呗

定义成类，不同的对象只是成员变量占内存，所有的对象共用方法。我贴个我写的usart的头文件抛砖引玉一下。

class USART: public StringIO{
        public:
                USART(USART_TypeDef *USARTx, Gpio *pTx, Gpio * tRx);
                void init(u32 baud);
                void init(u32 baud, u8 dataBit, u8 parity, float stopBit);
                void send(u8* pBuf, u16 size);
                void sendString(char* pStr);
                void sendInt(int num);
                void putChar(char c);
                int isTxBusy();
                virtual                void printf(const char *fmt, ...);
       
                void rxReset();
                virtual                char* getRxBufferAddr();
                virtual                int getRxLength();
                virtual                char* getRxString();
                char* getTxBufferAddr();

                static u32 pSelfObjectArr[6];
                static void _IRQCallBack(u32 pCallerObject);
       
                void attach(void (*hook)(void));
               
                template<typename T>
                void attach(T *pObject, void (T::*member)(void));
        private:
                char                                recieveBuf[256];
                USART_TypeDef *         USARTx;
                Gpio*                                 pTx;
                Gpio*                                pRx;
                Dma*                                pTxDma;
                Dma*                                pRxDma;
                char                                sendBuf[256];
                CallBack*                        pCB;
};

使用的时候

void handle(){
        uart1.rxReset();
        memcpy(&buf,uart1.getRxBufferAddr(),uart1.getRxLength());
        LED.toggle();
}

void serialInit(){
        uart1.init(115200);
        uart1.printf("uart1 init,baud is %d",115200)
        uart1.attach(handle);
}

xiaoergao

1、第一行类的声明使用了继承，可以先忽略。
2、attach()方法那里，我为了回调对象的方法使用了C++模板的语法，如果只是调用函数的话也可以忽略。

whatcanitbe

xiaoergao 发表于 2020-10-25 21:40
1、第一行类的声明使用了继承，可以先忽略。
2、attach()方法那里，我为了回调对象的方法使用了C++模板的语 ...

干脆共享下你造的这个轮子呗