eBox（stm32） 之中断结构

        eBox的中断结构参考了mbed，和我们平时所用的中断结构有些差异，不容易理解，最近仔细看了底层代码，终于搞清楚了，总结一下

        一  首先要要搞清楚的几个概念：类的静态成员，实例成员

                1  静态成员（static）对类以及类的所有实例有意义。即在该类的范围内所有类共享该成员。即使未创建实例，静态成员也存在，可以访问

                2  类的实例成员仅对每个实例有意义，在创建实例之前，未分配内存，无法访问

        成员分为属性和方法，对于属性：

                1  静态属性，对应一块内存. 静态属性在使用前必须初始化

                2  实例属性，每个实例属性个对应一块内存

         对于方法：不管是静态方法还是实例方法，都是同一块内存，区别在于

                1  静态方法，可以通过类名或者实例对象名调用。 例如：class::call(),object.call() . 静态方法不能直接调用实例方法（实例方法此时还未分配内存空间），可以通过对象名间接访问

                2  实例方法，只可以通过实例对象名调用 object.call() ；实例方法可以调用静态方法

        二 接下来在来看ebox中的中断相关代码 

                先来看绑定中断的过程

                 1  在类声明里如下两个，绑定中断的过程就是通过模版变量pirq的attach方法保存回调函数指针

1. // 绑定静态回调函数
2. void attach(void(*fptr)(void)){
3. pirq.attach(fptr);
4. }
6. FunctionPointer pirq;

                2  声明了两个变量，一个函数指针，一个数组       

1. typedefvoid(*exti_irq_handler)(uint32_t id);
3. static exti_irq_handler irq_handler;
4. staticuint32_t exti_irq_ids[16];

               其中，  数组用来保存实例对象地址（id），函数指针指向类的静态方法（handel）

1. int exti_irq_init(uint8_t index,exti_irq_handler handler,uint32_t id)
2. {
3. exti_irq_ids[index]= id;
4. irq_handler = handler;
5. return0;
6. }

              3  在类中实现一个静态方法，id为实例对象指针。前面说过静态方法可以通过对象名间接调用实例方法

1. void IRQ::irq_handler(uint32_t id)
2. {
3. IRQ *handler =(IRQ*)id;// 指向回调函数地址
4. handler->pirq.call();// 调用回调函数
5. }

              4   在初始化的时候，将静态方法地址，和实例地址分别送入

1. exti_irq_init(13,(&IRQ::irq_handler),(uint32_t)this);

               绑定完毕之后，我们就可以在中断中调用了

1. void EXTI4_15_IRQHandler(void)
2. {
3. if(LL_EXTI_IsActiveFlag_0_31(LL_EXTI_LINE_13)!= RESET)
4. {
5. LL_EXTI_ClearFlag_0_31(LL_EXTI_LINE_13);
6. /* Manage code in main.c.*/
7. irq_handler(exti_irq_ids[13]);
8. }
9. }

             假设我们创建了类IRQ的实例  A, 那么中断的调用过程就是

           中断服务-->IRQ::irq_handler(&A)-->A->pirq.call() 。也就是最终访问的是实例对象A中的变量pirq.  然后通过调用perq的call（）方法执行回调函数。

            以上是对非类成员方法作为回调函数的绑定和调用过程。 如果类成员方法做为回调函数，过程一致，只是我们在类里声明函数指针的时候，因为不知到具体回调的是哪个类的实例，无法定义该变量。所以用到了模版。模版的用途就是定义了一个通用的函数指针，我们在对该指针初始化的时候传入的是什么类型，就是什么类型

1. /** A class for storing and calling a pointer to a static or member function 用来保存静态或成员函数的指针类
2. */
3. // R-返回值类型 A1-参数类型
4. template<typename R,typename A1>
5. classFunctionPointerArg1{
6. public:
7. /** Create a FunctionPointer, attaching a static function 创建函数指针
8. *
9. * @param function The static function to attach (default is none) 附加静态函数，默认为void
10. */
11. FunctionPointerArg1(R (*function)(A1)=0){
12. attach(function);
13. }
15. /** Create a FunctionPointer, attaching a member function
16. * 附加成员函数，object 成员函数的对象的指针。 成员函数
17. * @param object The object pointer to invoke the member function on (i.e. the this pointer)
18. * @param function The address of the member function to attach
19. */
20. template<typename T>
21. FunctionPointerArg1(T *object, R (T::*member)(A1)){
22. attach(object, member);
23. }
25. /** Attach a static function
26. * 附件静态函数
27. * @param function The static function to attach (default is none)
28. */
29. void attach(R (*function)(A1)){
30. _p.function = function;
31. _membercaller =0;
32. }
34. /** Attach a member function
35. * 附件成员函数
36. * @param object The object pointer to invoke the member function on (i.e. the this pointer)
37. * @param function The address of the member function to attach
38. */
39. template<typename T>
40. void attach(T *object, R (T::*member)(A1)){
41. _p.object =static_cast<void*>(object);// 将对象转换成void* 类型
42. *reinterpret_cast<R (T::**)(A1)>(_member)= member;
43. _membercaller =&FunctionPointerArg1::membercaller<T>;//注册成员函数地址
44. }
46. /** Call the attached static or member function
47. */
48. R call(A1 a){
49. if(_membercaller ==0&& _p.function){
50. return _p.function(a);
51. }elseif(_membercaller && _p.object){
52. return _membercaller(_p.object, _member, a);
53. }
54. return(R)0;
55. }
57. /** Get registered static function
58. */
59. R(*get_function(A1))(){
60. return _membercaller ?(R(*)(A1))0:(R(*)(A1))_p.function;
61. }
63. #ifdef MBED_OPERATORS
64. R operator()(A1 a){
65. return call(a);
66. }
67. operatorbool(void)const{
68. return(_membercaller != NULL ? _p.object :(void*)_p.function)!= NULL;
69. }
70. #endif
71. private:
72. template<typename T>//对象类型
73. // 调用成员 对象，成员函数
74. static R membercaller(void*object,uintptr_t*member, A1 a){
75. T* o =static_cast<T*>(object);//类型转换
76. R (T::**m)(A1)=reinterpret_cast<R (T::**)(A1)>(member);
77. return(o->**m)(a);
78. }
80. union{
81. R (*function)(A1);// static function pointer 静态函数指针
82. void*object;// object this pointer 对象指针
83. } _p;// 用联合体保存指针，静态函数或者对象，只能保存其中一种
84. uintptr_t _member[4];// aligned raw member function pointer storage - converted back by registered _membercaller
85. // 函数指针
86. R (*_membercaller)(void*,uintptr_t*, A1);// registered membercaller function to convert back and call _m.member on _object
87. };

           总结，中断回调的关键有两点

           1   如何在类未实例化之前访问类成员--静态成员函数

           2   如何在允许挂在中断回调函数的类里声明指针变量，以用来指向回调函数 -- 模版

           所以只要理解了静态成员和模版就能够理解ebox中中断结构以及实现方法

        

          

      

 

来自为知笔记(Wiz)