ti154 0.3.2

Library for creating and parsing TI 15.4 UART packets.
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
153
154
155
156
157

pub mod areq;
pub mod sreq;
pub mod srsp;

use crate::error::Error;
use crate::subsystem::MTFramePayload;
use crate::types::CommandType;
use num_traits::FromPrimitive;

pub fn try_decode(cmd_type: &CommandType, id: u8, buffer: &[u8]) -> Result<MTFramePayload, Error> {
    use crate::types::MACCommandId::*;
    use MTFramePayload::*;

    let id = FromPrimitive::from_u8(id).ok_or(Error::InvalidCommandId(id))?;

    match cmd_type {
        CommandType::POLL => Err(Error::NotImplemented),
        CommandType::SREQ => match id {
            Init => sreq::Init::try_decode(buffer).map(|x| MAC_Init_SREQ(x)),
            DataReq => sreq::DataReq::try_decode(buffer).map(|x| MAC_DataReq_SREQ(x)),
            PurgeReq => sreq::PurgeReq::try_decode(buffer).map(|x| MAC_PurgeReq_SREQ(x)),
            AssociateReq => {
                sreq::AssociateReq::try_decode(buffer).map(|x| MAC_AssociateReq_SREQ(x))
            }
            AssociateRsp => {
                sreq::AssociateRsp::try_decode(buffer).map(|x| MAC_AssociateRsp_SREQ(x))
            }
            DisassociateReq => {
                sreq::DisassociateReq::try_decode(buffer).map(|x| MAC_DisassociateReq_SREQ(x))
            }
            GetReq => sreq::GetReq::try_decode(buffer).map(|x| MAC_GetReq_SREQ(x)),
            SetReq => sreq::SetReq::try_decode(buffer).map(|x| MAC_SetReq_SREQ(x)),
            SecurityGetReq => {
                sreq::SecurityGetReq::try_decode(buffer).map(|x| MAC_SecurityGetReq_SREQ(x))
            }
            SecuritySetReq => {
                sreq::SecuritySetReq::try_decode(buffer).map(|x| MAC_SecuritySetReq_SREQ(x))
            }
            UpdatePANIdReq => {
                sreq::UpdatePANIdReq::try_decode(buffer).map(|x| MAC_UpdatePANIdReq_SREQ(x))
            }
            AddDeviceReq => {
                sreq::AddDeviceReq::try_decode(buffer).map(|x| MAC_AddDeviceReq_SREQ(x))
            }
            DeleteDeviceReq => {
                sreq::DeleteDeviceReq::try_decode(buffer).map(|x| MAC_DeleteDeviceReq_SREQ(x))
            }
            DeleteAllDevicesReq => sreq::DeleteAllDevicesReq::try_decode(buffer)
                .map(|x| MAC_DeleteAllDevicesReq_SREQ(x)),
            DeleteKeyReq => {
                sreq::DeleteKeyReq::try_decode(buffer).map(|x| MAC_DeleteKeyReq_SREQ(x))
            }
            ReadKeyReq => sreq::ReadKeyReq::try_decode(buffer).map(|x| MAC_ReadKeyReq_SREQ(x)),
            WriteKeyReq => sreq::WriteKeyReq::try_decode(buffer).map(|x| MAC_WriteKeyReq_SREQ(x)),
            OrphanRsp => sreq::OrphanRsp::try_decode(buffer).map(|x| MAC_OrphanRsp_SREQ(x)),
            PollReq => sreq::PollReq::try_decode(buffer).map(|x| MAC_PollReq_SREQ(x)),
            ResetReq => sreq::ResetReq::try_decode(buffer).map(|x| MAC_ResetReq_SREQ(x)),
            ScanReq => sreq::ScanReq::try_decode(buffer).map(|x| MAC_ScanReq_SREQ(x)),
            StartReq => sreq::StartReq::try_decode(buffer).map(|x| MAC_StartReq_SREQ(x)),
            SyncReq => sreq::SyncReq::try_decode(buffer).map(|x| MAC_SyncReq_SREQ(x)),
            SetRxGainReq => {
                sreq::SetRxGainReq::try_decode(buffer).map(|x| MAC_SetRxGainReq_SREQ(x))
            }
            WSAsyncReq => sreq::WSAsyncReq::try_decode(buffer).map(|x| MAC_WSAsyncReq_SREQ(x)),
            FHEnableReq => sreq::FHEnableReq::try_decode(buffer).map(|x| MAC_FHEnableReq_SREQ(x)),
            FHStartReq => sreq::FHStartReq::try_decode(buffer).map(|x| MAC_FHStartReq_SREQ(x)),
            FHGetReq => sreq::FHGetReq::try_decode(buffer).map(|x| MAC_FHGetReq_SREQ(x)),
            FHSetReq => sreq::FHSetReq::try_decode(buffer).map(|x| MAC_FHSetReq_SREQ(x)),
            _ => Err(Error::NotImplemented),
        },
        CommandType::AREQ => match id {
            DataCnf => areq::DataCnf::try_decode(buffer).map(|x| MAC_DataCnf_AREQ(x)),
            DataInd => areq::DataInd::try_decode(buffer).map(|x| MAC_DataInd_AREQ(x)),
            PurgeCnf => areq::PurgeCnf::try_decode(buffer).map(|x| MAC_PurgeCnf_AREQ(x)),
            WSAsyncInd => areq::WSAsyncInd::try_decode(buffer).map(|x| MAC_WSAsyncInd_AREQ(x)),
            SyncLossInd => areq::SyncLossInd::try_decode(buffer).map(|x| MAC_SyncLossInd_AREQ(x)),
            AssociateInd => {
                areq::AssociateInd::try_decode(buffer).map(|x| MAC_AssociateInd_AREQ(x))
            }
            AssociateCnf => {
                areq::AssociateCnf::try_decode(buffer).map(|x| MAC_AssociateCnf_AREQ(x))
            }
            BeaconNotifyInd => {
                areq::BeaconNotifyInd::try_decode(buffer).map(|x| MAC_BeaconNotifyInd_AREQ(x))
            }
            DisassociateInd => {
                areq::DisassociateInd::try_decode(buffer).map(|x| MAC_DisassociateInd_AREQ(x))
            }
            DisassociateCnf => {
                areq::DisassociateCnf::try_decode(buffer).map(|x| MAC_DisassociateCnf_AREQ(x))
            }
            OrphanInd => areq::OrphanInd::try_decode(buffer).map(|x| MAC_OrphanInd_AREQ(x)),
            PollCnf => areq::PollCnf::try_decode(buffer).map(|x| MAC_PollCnf_AREQ(x)),
            PollInd => areq::PollInd::try_decode(buffer).map(|x| MAC_PollInd_AREQ(x)),
            ScanCnf => areq::ScanCnf::try_decode(buffer).map(|x| MAC_ScanCnf_AREQ(x)),
            CommStatusInd => {
                areq::CommStatusInd::try_decode(buffer).map(|x| MAC_CommStatusInd_AREQ(x))
            }
            StartCnf => areq::StartCnf::try_decode(buffer).map(|x| MAC_StartCnf_AREQ(x)),
            WSAsyncCnf => areq::WSAsyncCnf::try_decode(buffer).map(|x| MAC_WSAsyncCnf_AREQ(x)),
            _ => Err(Error::NotImplemented),
        },
        CommandType::SRSP => match id {
            Init => srsp::Init::try_decode(buffer).map(|x| MAC_Init_SRSP(x)),
            DataReq => srsp::DataReq::try_decode(buffer).map(|x| MAC_DataReq_SRSP(x)),
            PurgeReq => srsp::PurgeReq::try_decode(buffer).map(|x| MAC_PurgeReq_SRSP(x)),
            AssociateReq => {
                srsp::AssociateReq::try_decode(buffer).map(|x| MAC_AssociateReq_SRSP(x))
            }
            AssociateRsp => {
                srsp::AssociateRsp::try_decode(buffer).map(|x| MAC_AssociateRsp_SRSP(x))
            }
            DisassociateReq => {
                srsp::DisassociateReq::try_decode(buffer).map(|x| MAC_DisassociateReq_SRSP(x))
            }
            GetReq => srsp::GetReq::try_decode(buffer).map(|x| MAC_GetReq_SRSP(x)),
            SetReq => srsp::SetReq::try_decode(buffer).map(|x| MAC_SetReq_SRSP(x)),
            SecurityGetReq => {
                srsp::SecurityGetReq::try_decode(buffer).map(|x| MAC_SecurityGetReq_SRSP(x))
            }
            SecuritySetReq => {
                srsp::SecuritySetReq::try_decode(buffer).map(|x| MAC_SecuritySetReq_SRSP(x))
            }
            UpdatePANIdReq => {
                srsp::UpdatePANIdReq::try_decode(buffer).map(|x| MAC_UpdatePANIdReq_SRSP(x))
            }
            AddDeviceReq => {
                srsp::AddDeviceReq::try_decode(buffer).map(|x| MAC_AddDeviceReq_SRSP(x))
            }
            DeleteDeviceReq => {
                srsp::DeleteDeviceReq::try_decode(buffer).map(|x| MAC_DeleteDeviceReq_SRSP(x))
            }
            DeleteAllDevicesReq => srsp::DeleteAllDevicesReq::try_decode(buffer)
                .map(|x| MAC_DeleteAllDevicesReq_SRSP(x)),
            DeleteKeyReq => {
                srsp::DeleteKeyReq::try_decode(buffer).map(|x| MAC_DeleteKeyReq_SRSP(x))
            }
            ReadKeyReq => srsp::ReadKeyReq::try_decode(buffer).map(|x| MAC_ReadKeyReq_SRSP(x)),
            WriteKeyReq => srsp::WriteKeyReq::try_decode(buffer).map(|x| MAC_WriteKeyReq_SRSP(x)),
            OrphanRsp => srsp::OrphanRsp::try_decode(buffer).map(|x| MAC_OrphanRsp_SRSP(x)),
            PollReq => srsp::PollReq::try_decode(buffer).map(|x| MAC_PollReq_SRSP(x)),
            ResetReq => srsp::ResetReq::try_decode(buffer).map(|x| MAC_ResetReq_SRSP(x)),
            ScanReq => srsp::ScanReq::try_decode(buffer).map(|x| MAC_ScanReq_SRSP(x)),
            StartReq => srsp::StartReq::try_decode(buffer).map(|x| MAC_StartReq_SRSP(x)),
            SyncReq => srsp::SyncReq::try_decode(buffer).map(|x| MAC_SyncReq_SRSP(x)),
            SetRxGainReq => {
                srsp::SetRxGainReq::try_decode(buffer).map(|x| MAC_SetRxGainReq_SRSP(x))
            }
            WSAsyncReq => srsp::WSAsyncReq::try_decode(buffer).map(|x| MAC_WSAsyncReq_SRSP(x)),
            FHEnableReq => srsp::FHEnableReq::try_decode(buffer).map(|x| MAC_FHEnableReq_SRSP(x)),
            FHStartReq => srsp::FHStartReq::try_decode(buffer).map(|x| MAC_FHStartReq_SRSP(x)),
            FHGetReq => srsp::FHGetReq::try_decode(buffer).map(|x| MAC_FHGetReq_SRSP(x)),
            FHSetReq => srsp::FHSetReq::try_decode(buffer).map(|x| MAC_FHSetReq_SRSP(x)),
            _ => Err(Error::NotImplemented),
        },
    }
}