summaryrefslogtreecommitdiff
path: root/digital/zigbit/bitcloud/stack/Components/NWK/include/private/nwkStateMachine.h
blob: 19a928710b57d27ca97e394e97d32c01b1e1cf3f (plain)
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
/**************************************************************************//**
  \file nwkStateMachine.h

  \brief State machine header file.

  \author
    Atmel Corporation: http://www.atmel.com \n
    Support email: avr@atmel.com

  Copyright (c) 2008-2011, Atmel Corporation. All rights reserved.
  Licensed under Atmel's Limited License Agreement (BitCloudTM).

  \internal
   History:
    2007-06-14 V. Panov - Created.
    2009-02-21 M. Gekk  - Refactoring.
   Last change:
    $Id: nwkStateMachine.h 17448 2011-06-09 13:53:59Z ataradov $
 ******************************************************************************/
#if !defined _NWK_STATE_MACHINE_H
#define _NWK_STATE_MACHINE_H

/******************************************************************************
                                Includes section
 ******************************************************************************/
#include <nwkConfig.h>
#include <nwkCommon.h>
#include <nwkMem.h>

/******************************************************************************
                                Define(s) section
 ******************************************************************************/
/* Identifiers of modules, packed to groups. A combination of modules, which
   activity is accepted, forms global NWK layer state. All modules in group
   change their status simultaneously by some event, so if the activity
   permission politics changes, perform corrsponding changes. */

#define NWK_MODULE_ID_DATA_REQ        (1U << 0)
#define NWK_MODULE_ID_SYNC            (1U << 0)
#define NWK_MODULE_ID_LINK_STATUS     (1U << 0)
#define NWK_MODULE_ID_NETWORK_COMMAND (1U << 0)
#define NWK_MODULE_ID_LEAVE           (1U << 0)
#define NWK_MODULE_ID_PANID_CONFLICT  (1U << 0)
#define NWK_MODULE_ID_DATA_IND        (1U << 0)
#define NWK_MODULE_ID_EDSCAN          (1U << 0)
#define NWK_MODULE_ID_ADDR_CONFLICT   (1U << 0)
#define NWK_MODULE_ID_ROUTE_DISCOVERY (1U << 0)
#define NWK_MODULE_ID_PERMIT_JOINING  (1U << 0)

#define NWK_MODULE_ID_FORMATION       (1U << 1)
#define NWK_MODULE_ID_START_ROUTER    (1U << 2)
#define NWK_MODULE_ID_JOIN_IND        (1U << 3)

#define NWK_MODULE_ID_JOIN_REQ        (1U << 4)
#define NWK_MODULE_ID_COMMAND_REQ     (1U << 4)

#define NWK_MODULE_ID_COMMAND_IND     (1U << 5)
#define NWK_MODULE_ID_DISCOVERY       (1U << 5)

/** Reserved bit is set until NWK reset process completed. */
#define NWK_MODULE_ID_RESERVED        (1U << 7)

/* Module permissions */
#define NWK_MODULE_NONE               0U

#define NWK_EVENT_RESET_REQ \
  (NWK_MODULE_ID_DISCOVERY | NWK_MODULE_ID_FORMATION \
  | NWK_MODULE_ID_JOIN_REQ | NWK_MODULE_ID_COMMAND_REQ \
  | NWK_MODULE_ID_COMMAND_IND | NWK_MODULE_ID_START_ROUTER)

#define NWK_EVENT_FORMATION_SUCCESS \
  ((NwkStateMachineEvent_t)(~NWK_MODULE_ID_FORMATION))

#define NWK_EVENT_LEAVE_ALL_CHILDREN \
  ((NwkStateMachineEvent_t)(~NWK_MODULE_ID_JOIN_IND\
                          & ~NWK_MODULE_ID_FORMATION \
                          & ~NWK_MODULE_ID_START_ROUTER))

#define NWK_EVENT_LEAVE_SUCCESS \
  (NWK_MODULE_ID_JOIN_REQ | NWK_MODULE_ID_COMMAND_REQ \
  | NWK_MODULE_ID_FORMATION)

#define NWK_EVENT_REJOIN_REQ \
  (NWK_MODULE_ID_JOIN_REQ | NWK_MODULE_ID_COMMAND_REQ \
  | NWK_MODULE_ID_COMMAND_IND | NWK_MODULE_ID_DISCOVERY)

#define NWK_EVENT_AWAYTING_RESET      (NWK_MODULE_ID_RESERVED)
#define NWK_EVENT_REJOIN_SUCCESS      (NWK_EVENT_FORMATION_SUCCESS)
#define NWK_EVENT_POWER_FAILURE_RESET (NWK_EVENT_FORMATION_SUCCESS)
#define NWK_EVENT_JOIN_SUCCESS        (NWK_EVENT_FORMATION_SUCCESS)
#define NWK_EVENT_LEAVE_FAIL          (NWK_EVENT_FORMATION_SUCCESS)

#define NWK_EVENT_EDSCAN NWK_MODULE_NONE /* Disable all NWK modules */

/******************************************************************************
                                 Types section
 ******************************************************************************/
/** Type of identifier of module. */
typedef uint8_t NwkStateMachineModuleID_t;

/** Type of NWK event. */
typedef NwkState_t NwkStateMachineEvent_t;

/******************************************************************************
                            Inline functions section
 *****************************************************************************/
/**************************************************************************//**
  \brief this function return true, if module with moduleID is allowed to work.
 ******************************************************************************/
INLINE uint8_t nwkCheckStateMachine(NwkStateMachineModuleID_t moduleID)
{
  return (nwkMem.state & moduleID);
}

/**************************************************************************//**
  \brief Modules that can switch state machine shall send events.

  \param[in] event - id of event.
  \return None.
 ******************************************************************************/
INLINE void nwkSwitchStateMachine(NwkStateMachineEvent_t event)
{
  nwkMem.state = event;
}

/**************************************************************************//**
  \brief This function return the current state of network layer.

  \return Current global state of NWK-layer.
 ******************************************************************************/
INLINE NwkState_t nwkGetStateMachine(void)
{
  return nwkMem.state;
}

/**************************************************************************//**
 \brief Set new the network layer state.

 \param[in] state - new state.
 \return current state
 ******************************************************************************/
INLINE void nwkRestoreStateMachine(NwkState_t state)
{
  nwkMem.state = state;
}

/**************************************************************************//**
 \brief State machine reset routine.
 ******************************************************************************/
NWK_PRIVATE void nwkResetStateMachine(void);

#endif /* _NWK_STATE_MACHINE_H */
/** eof nwkStateMachine.h */