drone-micropython-stm32 0.1.1

MicroPython for Drone STM32.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69

use drone_core::drv::Resource;
use drone_micropython_core::exec::UncaughtException;
use drone_micropython_core::{Cmd, CmdRes, MpSessResCore};
use drone_plat::stack_adapter::{Context, Stack};
use futures::prelude::*;
use rt::init_stack;

/// MicroPython session platform driver.
#[derive(Driver, Resource)]
pub struct MpSessPlat<T: MpSessResPlat>(T);

/// MicroPython session platform resource.
pub trait MpSessResPlat: Resource<Source = Self> {
  /// Stack storage.
  type Stack: Stack<Cmd, CmdRes, Self::Req, Self::ReqRes>;

  /// Context handler.
  type Context: Context<Self::Req, Self::ReqRes>;

  /// Possible requests.
  type Req: Send + 'static;

  /// Possible request results.
  type ReqRes: Send + 'static;

  /// Possible errors.
  type Error: From<UncaughtException>;

  /// Stack size.
  const STACK_SIZE: usize;

  /// Heap size.
  const HEAP_SIZE: usize;

  /// Returns a mutable reference to the stack object.
  fn stack(&mut self) -> &mut Self::Stack;

  /// Runs a request `req` asynchronously.
  fn run_req<'sess>(
    &'sess mut self,
    req: Self::Req,
  ) -> Box<Future<Item = Self::ReqRes, Error = Self::Error> + 'sess>;
}

impl<T: MpSessResPlat> MpSessResCore for MpSessPlat<T> {
  type Stack = T::Stack;
  type Context = T::Context;
  type Req = T::Req;
  type ReqRes = T::ReqRes;
  type Error = T::Error;

  const STACK_SIZE: usize = T::STACK_SIZE;
  const HEAP_SIZE: usize = T::HEAP_SIZE;

  fn init() {
    init_stack();
  }

  fn stack(&mut self) -> &mut Self::Stack {
    self.0.stack()
  }

  fn run_req<'sess>(
    &'sess mut self,
    req: Self::Req,
  ) -> Box<Future<Item = Self::ReqRes, Error = Self::Error> + 'sess> {
    self.0.run_req(req)
  }
}