ushell 0.4.0

Embedded shell over serial connection
Documentation 
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
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

#![no_std]
#![deny(unsafe_code)]

extern crate heapless;
extern crate nb;
extern crate uluru;

pub mod serial;
pub mod autocomplete;
pub mod control;
pub mod history;

mod shell;

use core::{fmt, marker::PhantomData, str::Utf8Error};
pub use shell::*;
pub use serial::*;


pub enum ShellError<S>
where
    S: Read<u8> + Write<u8>,
{
    ReadError(<S as Read<u8>>::Error),
    WriteError(<S as Write<u8>>::Error),
    FormatError(fmt::Error),
    BadInputError(Utf8Error),
    WouldBlock,
    HistoryError,
}

impl<S> From<fmt::Error> for ShellError<S>
where
    S: Read<u8> + Write<u8>,
{
    fn from(err: fmt::Error) -> Self {
        ShellError::FormatError(err)
    }
}

impl<S> From<Utf8Error> for ShellError<S>
where
    S: Read<u8> + Write<u8>,
{
    fn from(err: Utf8Error) -> Self {
        ShellError::BadInputError(err)
    }
}

pub enum SpinError<S, E>
where
    S: Read<u8> + Write<u8>,
{
    ShellError(ShellError<S>),
    EnvironmentError(E),
}

impl<S, E> From<ShellError<S>> for SpinError<S, E>
where
    S: Read<u8> + Write<u8>,
{
    fn from(err: ShellError<S>) -> Self {
        SpinError::ShellError(err)
    }
}

impl<S, E> From<fmt::Error> for SpinError<S, E>
where
    S: Read<u8> + Write<u8>,
{
    fn from(err: fmt::Error) -> Self {
        SpinError::ShellError(err.into())
    }
}

impl<S, E> From<Utf8Error> for SpinError<S, E>
where
    S: Read<u8> + Write<u8>,
{
    fn from(err: Utf8Error) -> Self {
        SpinError::ShellError(err.into())
    }
}

pub enum Input<'a> {
    Control(u8),
    Command((&'a str, &'a str)),
}

pub trait Environment<S, A, H, E, const CMD_LEN: usize>
where
    S: Read<u8> + Write<u8>,
    A: autocomplete::Autocomplete<CMD_LEN>,
    H: history::History<CMD_LEN>,
{
    fn command(
        &mut self,
        shell: &mut UShell<S, A, H, CMD_LEN>,
        cmd: &str,
        args: &str,
    ) -> SpinResult<S, E>;

    fn control(&mut self, shell: &mut UShell<S, A, H, CMD_LEN>, code: u8) -> SpinResult<S, E>;
}

pub struct Serial<W, TX: Write<W>, RX: Read<W>> {
    w: PhantomData<W>,
    tx: TX,
    rx: RX,
}

impl<W, TX: Write<W>, RX: Read<W>> Serial<W, TX, RX> {
    pub fn from_parts(tx: TX, rx: RX) -> Self {
        Self {
            tx,
            rx,
            w: PhantomData,
        }
    }

    pub fn tx(&mut self) -> &mut TX {
        &mut self.tx
    }

    pub fn rx(&mut self) -> &mut RX {
        &mut self.rx
    }

    pub fn split(self) -> (TX, RX) {
        (self.tx, self.rx)
    }
}

impl<W, TX: Write<W>, RX: Read<W>> Write<W> for Serial<W, TX, RX> {
    type Error = TX::Error;

    fn write(&mut self, word: W) -> nb::Result<(), Self::Error> {
        self.tx.write(word)
    }

    fn flush(&mut self) -> nb::Result<(), Self::Error> {
        self.tx.flush()
    }
}

impl<W, TX: Write<W>, RX: Read<W>> Read<W> for Serial<W, TX, RX> {
    type Error = RX::Error;

    fn read(&mut self) -> nb::Result<W, Self::Error> {
        self.rx.read()
    }
}