关于GPIO接口的建议

Pin类型默认是零大小的(C-ZST-PIN)

由HAL暴露的GPIO接口应该为所有接口或者端口上的每一个管脚提供一个专用的零大小类型，从而当所有的管脚分配静态已知时，提供一个零开销抽象。

每个GPIO接口或者端口应该实现一个split方法，它返回一个有所有管脚的结构体。

案例:

  1. #![allow(unused)]
  2. fn main() {
  3. pub struct PA0;
  4. pub struct PA1;
  5. // ...
  7. pub struct PortA;
  9. impl PortA {
  10.     pub fn split(self) -> PortAPins {
  11.         PortAPins {
  12.             pa0: PA0,
  13.             pa1: PA1,
  14.             // ...
  15.         }
  16.     }
  17. }
  19. pub struct PortAPins {
  20.     pub pa0: PA0,
  21.     pub pa1: PA1,
  22.     // ...
  23. }
  24. }

管脚类型提供方法去擦除管脚和端口(C-ERASED-PIN)

管脚应该提供类型擦除方法去将它们的属性从编译时移到运行时，允许在应用中有更多的灵活性。

案例:

  1. #![allow(unused)]
  2. fn main() {
  3. /// 端口 A, 管脚 0。
  4. pub struct PA0;
  6. impl PA0 {
  7.     pub fn erase_pin(self) -> PA {
  8.         PA { pin: 0 }
  9.     }
  10. }
  12. /// 端口A上的A管脚。
  13. pub struct PA {
  14.     /// 管脚号。
  15.     pin: u8,
  16. }
  18. impl PA {
  19.     pub fn erase_port(self) -> Pin {
  20.         Pin {
  21.             port: Port::A,
  22.             pin: self.pin,
  23.         }
  24.     }
  25. }
  27. pub struct Pin {
  28.     port: Port,
  29.     pin: u8,
  30.     // (这些字段)
  31.     // (这些字段可以打包以减少内存占用)
  32. }
  34. enum Port {
  35.     A,
  36.     B,
  37.     C,
  38.     D,
  39. }
  40. }

管脚状态应该被编码成类型参数 (C-PIN-STATE)

取决于芯片或者芯片系列，管脚可能被配置为具有不同特性的输出或者输入。这个状态应该在类型系统中被编码去避免在错误的状态中使用管脚。

另外，芯片特定的状态(eg. 驱动强度)可能也用这个办法被编码，使用额外的类型参数。

用来改变管脚状态的方法应该被实现成into_input和into_output方法。

另外，应该提供with_{input,output}_state方法，在一个不同的状态中临时配置一个管脚而不是移动它。

应该为每个的管脚类型提供下列的方法(也就是说，已擦除和未擦除的管脚类型应该提供一样的API):

  • pub fn into_input<N: InputState>(self, input: N) -> Pin<N>
  • pub fn into_output<N: OutputState>(self, output: N) -> Pin<N>

  • pub fn with_input_state<N: InputState, R>( &mut self, input: N, f: impl FnOnce(&mut PA1<N>) -> R, ) -> R

  • pub fn with_output_state<N: OutputState, R>( &mut self, output: N, f: impl FnOnce(&mut PA1<N>) -> R, ) -> R

管脚状态应该用sealed traits来绑定。HAL的用户应该不需要添加它们自己的状态。这个traits能提供HAL特定的方法，实现管脚状态API需要这些方法。

案例:

  1. #![allow(unused)]
  2. fn main() {
  3. use std::marker::PhantomData;
  4. mod sealed {
  5.     pub trait Sealed {}
  6. }
  8. pub trait PinState: sealed::Sealed {}
  9. pub trait OutputState: sealed::Sealed {}
  10. pub trait InputState: sealed::Sealed {
  11.     // ...
  12. }
  14. pub struct Output<S: OutputState> {
  15.     _p: PhantomData<S>,
  16. }
  18. impl<S: OutputState> PinState for Output<S> {}
  19. impl<S: OutputState> sealed::Sealed for Output<S> {}
  21. pub struct PushPull;
  22. pub struct OpenDrain;
  24. impl OutputState for PushPull {}
  25. impl OutputState for OpenDrain {}
  26. impl sealed::Sealed for PushPull {}
  27. impl sealed::Sealed for OpenDrain {}
  29. pub struct Input<S: InputState> {
  30.     _p: PhantomData<S>,
  31. }
  33. impl<S: InputState> PinState for Input<S> {}
  34. impl<S: InputState> sealed::Sealed for Input<S> {}
  36. pub struct Floating;
  37. pub struct PullUp;
  38. pub struct PullDown;
  40. impl InputState for Floating {}
  41. impl InputState for PullUp {}
  42. impl InputState for PullDown {}
  43. impl sealed::Sealed for Floating {}
  44. impl sealed::Sealed for PullUp {}
  45. impl sealed::Sealed for PullDown {}
  47. pub struct PA1<S: PinState> {
  48.     _p: PhantomData<S>,
  49. }
  51. impl<S: PinState> PA1<S> {
  52.     pub fn into_input<N: InputState>(self, input: N) -> PA1<Input<N>> {
  53.         todo!()
  54.     }
  56.     pub fn into_output<N: OutputState>(self, output: N) -> PA1<Output<N>> {
  57.         todo!()
  58.     }
  60.     pub fn with_input_state<N: InputState, R>(
  61.         &mut self,
  62.         input: N,
  63.         f: impl FnOnce(&mut PA1<N>) -> R,
  64.     ) -> R {
  65.         todo!()
  66.     }
  68.     pub fn with_output_state<N: OutputState, R>(
  69.         &mut self,
  70.         output: N,
  71.         f: impl FnOnce(&mut PA1<N>) -> R,
  72.     ) -> R {
  73.         todo!()
  74.     }
  75. }
  77. // 对于`PA`和`Pin`一样的，对于其它管脚类型来说也是。
  78. }