source: arduino-1-6-7/trunk/fuentes/arduino-ide-amd64/libraries/Temboo/src/TembooCoAPEdgeDevice.h @ 46

Last change on this file since 46 was 46, checked in by jrpelegrina, 4 years ago

First release to Xenial

File size: 10.9 KB
Line 
1/*
2 ###############################################################################
3 #
4 # Temboo CoAP Edge Device library
5 #
6 # Copyright (C) 2015, Temboo Inc.
7 #
8 # Licensed under the Apache License, Version 2.0 (the "License");
9 # you may not use this file except in compliance with the License.
10 # You may obtain a copy of the License at
11 #
12 # http://www.apache.org/licenses/LICENSE-2.0
13 #
14 # Unless required by applicable law or agreed to in writing,
15 # software distributed under the License is distributed on an
16 # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
17 # either express or implied. See the License for the specific
18 # language governing permissions and limitations under the License.
19 #
20 ###############################################################################
21 */
22
23#ifndef TEMBOOCOAP_H_
24#define TEMBOOCOAP_H_
25
26
27///////////////////////////////////////////////////////
28//  BEGIN ARDUINO NON-YUN SUPPORT
29///////////////////////////////////////////////////////
30
31#include "Arduino.h"
32#include "utility/TembooTimer.h"
33#include "utility/TembooTags.h"
34
35#include "utility/TembooCoAPIPStack.h"
36#include "utility/ChoreoInputSet.h"
37#include "utility/ChoreoOutputSet.h"
38#include "utility/ChoreoPreset.h"
39#include "utility/CoapMsg.h"
40#include "utility/CoapMessageLayer.h"
41#include "utility/CoapRRLayer.h"
42
43
44#define IS_EMPTY(s) (NULL == s || '\0' == *s)
45#define DEFAULT_CHOREO_TIMEOUT 900
46
47class TembooCoAPChoreo;
48
49class TembooCoAPClient {
50    public:
51        TembooCoAPClient(TembooCoAPIPStack& ipStack, IPAddress gatewayAddress, uint16_t gatewayPort = DEFAULT_COAP_PORT);
52        virtual ~TembooCoAPClient();
53        void begin(long seed);
54       
55        enum Result {
56            NO_ERROR = 0,
57            ERROR_REQUEST_FAILED,
58            ERROR_BAD_RESPONSE,
59            ERROR_MSG_TOKEN,
60            ERROR_MSG_OPTION,
61            ERROR_MSG_PAYLOAD,
62            ERROR_SENDING_MSG,
63            ERROR_RECEIVING_MSG,
64            ERROR_BUFFER_FULL,
65            ERROR_INVALID_MSG,
66            ERROR_RECEIVING_RESPONSE
67        };
68       
69        enum State {
70            STATE_IDLE,
71            STATE_TRANSMIT,
72            STATE_WAITING_FOR_RESPONSE,
73            STATE_RESPONSE_STARTED,
74            STATE_RESPONSE_READY,
75            STATE_NO_RESPONSE,
76            STATE_SEND_REQUEST,
77            STATE_ERROR
78        };
79       
80        Result write(uint8_t value);
81        Result write(uint8_t* value, uint16_t len);
82        void clearData() {m_dataLen = 0;}
83        Result loop();
84        Result sendChoreoRequest();
85        uint8_t* getPacketBuffer() {return m_respBuffer;}
86        int32_t getPacketBufferSize() {return m_respLen;}
87        int32_t getPacketLength() {return 1000;}
88        int16_t getRespHttpCode() {return m_respHttpCode;}
89        State getState() {return m_state;}
90        Result sendBlockRequest(uint16_t msgID, uint32_t blockNum);
91        void resetChoreo();
92        int getMessageState() {return m_lastResult;}
93        Result requestTime(uint16_t msgID);
94       
95    protected:
96        static const char URI_PATH[];
97        Result m_lastResult;
98        bool moreBlocksToSend();
99       
100        // MAX_BLOCK_SIZE *MUST* be one of the standard CoAP block sizes
101        // This size should be set with consideration to any network or
102        // hardware limitations on UDP packet size.
103        // (16, 32, 64, 128, 256, 512, or 1024).
104        static const int MAX_BLOCK_SIZE = 64;
105       
106        // MAX_PACKET_SIZE should be at least big enough to hold:
107        // for outgoing requests:
108        // 4 header bytes
109        // 6 token bytes (in our case,  Spec says tokens can be up to 8 bytes).
110        // 1 byte for the URI PATH option (I *think*)
111        // 4 strlen(URI_PATH) bytes for the URI PATH option value.
112        // 3 bytes for a block1 option
113        // 3 bytes for a block1 option value
114        // 1 bytes for a block2 option (early response size negotiation)
115        // 1 bytes for a block2 option value
116        // ? 5 bytes for a size1 or size2 option
117        // ? 4 bytes for a sizeX option value
118        // 1 byte for the FF payload marker
119        // MAX_BLOCK_SIZE for the payload
120        //
121        // or 24 + MAX_BLOCK_SIZE
122        //
123        // HOWEVER... we need to consider the possibility that the server may
124        // use more options and thus send more bytes.  So we should add as much
125        // extra space as we can reasonably afford so as to avoid buffer overflows.
126       
127        static const size_t MAX_PACKET_SIZE = 90;
128       
129       
130        static const size_t MAX_DATA_SIZE = 1000;
131       
132        static const uint16_t DEFAULT_COAP_PORT = 5683;
133       
134        CoapMessageLayer m_messageLayer;
135        CoapRRLayer m_rrLayer;
136        IPAddress m_gatewayAddress;
137        uint16_t m_gatewayPort;
138        uint16_t m_messageID;
139        State m_state;
140        uint16_t m_blockSize;
141        Result m_lastError;
142       
143        uint16_t m_dataLen;
144        uint8_t m_dataBuffer[MAX_DATA_SIZE];
145        uint8_t m_respBuffer[MAX_DATA_SIZE];
146       
147        char m_token[9];
148        uint8_t m_txBuffer[MAX_PACKET_SIZE];
149        uint8_t m_rxBuffer[MAX_PACKET_SIZE];
150        uint32_t m_rxBlockNum;
151        int32_t m_txIndex;
152        int32_t m_txByteCount;
153        int32_t m_respLen;
154        uint32_t m_txBlockNum;
155        int16_t m_respHttpCode;
156       
157        Result generateToken();
158        uint16_t getNextMessageID();
159       
160        Result sendBlock(uint16_t msgID, uint8_t* payload, size_t len, uint32_t blockNum, bool moreBlocks);
161        void adjustRequestBlockSize(CoapMsg& msg);
162        void cancelWait();
163       
164        int send(CoapMsg* msg);
165        int sendResetMsg(CoapMsg& msg);
166        int sendEmptyAckMsg(CoapMsg& msg);
167        int sendBlock2AckMsg(CoapMsg& msg);
168        bool isMsgResponse(CoapMsg& msg);
169        void handleBlockAck(CoapMsg& msg);
170        void handleBlock1InResponse(CoapMsg& msg);
171        Result saveResponse(uint8_t* values, uint16_t len);
172       
173        friend class TembooCoAPChoreo;
174};
175
176class TembooCoAPChoreo : public Stream {
177    public:
178       
179        // Constructor.
180        // client - an instance of a TembooCoAPClient.
181        //          Used to communicate with a Temboo CoAP Gateway.
182        TembooCoAPChoreo(TembooCoAPClient& client);
183        ~TembooCoAPChoreo();
184       
185        // Does nothing. Just for source compatibility with Yun code.
186        void begin() {;};
187       
188        // Sets the account name to use when communicating with Temboo.
189        // (required)
190        void setAccountName(const String& accountName);
191        void setAccountName(const char* accountName);
192       
193        // Sets the application key name to use with choreo execution requests.
194        // (required)
195        void setAppKeyName(const String& appKeyName);
196        void setAppKeyName(const char* appKeyName);
197       
198        // Sets the application key value to use with choreo execution requests
199        // (required)
200        void setAppKey(const String& appKey);
201        void setAppKey(const char* appKey);
202       
203        // sets the name of the choreo to be executed.
204        // (required)
205        void setChoreo(const String& choreoPath);
206        void setChoreo(const char* choreoPath);
207       
208       
209        // sets the name of the saved inputs to use when executing the choreo
210        // (optional)
211        void setSavedInputs(const String& savedInputsName);
212        void setSavedInputs(const char* savedInputsName);
213       
214        void setCredential(const String& credentialName);
215        void setCredential(const char* credentialName);
216       
217        void setProfile(const String& profileName);
218        void setProfile(const char* profileName);
219       
220        // sets an input to be used when executing a choreo.
221        // (optional or required, depending on the choreo being executed.)
222        void addInput(const String& inputName, const String& inputValue);
223        void addInput(const char* inputName, const char* inputValue);
224        void addInput(const char* inputName, const String& inputValue);
225        void addInput(const String& inputName, const char* inputValue);
226       
227        // sets an output filter to be used to process the choreo output
228        // (optional)
229        void addOutputFilter(const char* filterName, const char* filterPath, const char* variableName);
230        void addOutputFilter(const String& filterName, const char* filterPath, const char* variableName);
231        void addOutputFilter(const char* filterName, const String& filterPath, const char* variableName);
232        void addOutputFilter(const String& filterName, const String& filterPath, const char* variableName);
233        void addOutputFilter(const char* filterName, const char* filterPath, const String& variableName);
234        void addOutputFilter(const String& filterName, const char* filterPath, const String& variableName);
235        void addOutputFilter(const char* filterName, const String& filterPath, const String& variableName);
236        void addOutputFilter(const String& filterName, const String& filterPath, const String& variableName);
237       
238        // run the choreo using the current input info
239        int run(uint16_t timeoutSecs = DEFAULT_CHOREO_TIMEOUT);
240       
241        char* getResponseData() {return m_respData;}
242        char* getHTTPResponseCode() {return m_httpCodeStr;}
243       
244       
245        // Stream interface
246        void close() {};
247        int available();
248        int read();
249        int peek();
250        void flush();
251       
252        //Print interface
253        size_t write(uint8_t data);
254       
255        enum Error {
256            SUCCESS = 0,
257            FAILURE,
258            TEMBOO_ERROR_ACCOUNT_MISSING       = 201,
259            TEMBOO_ERROR_CHOREO_MISSING        = 203,
260            TEMBOO_ERROR_APPKEY_NAME_MISSING   = 205,
261            TEMBOO_ERROR_APPKEY_MISSING        = 207,
262            TEMBOO_ERROR_HTTP_ERROR            = 223,
263            TEMBOO_ERROR_TIMEOUT               = 225,
264            TEMBOO_ERROR_MEMORY                = 900,
265            TEMBOO_ERROR_TCPIP_CONNECT_FAIL    = 901,
266            TEMBOO_ERROR_NO_RESPONSE           = 0xFFFF
267        };
268       
269       
270       
271    protected:
272        static const size_t MAX_RESPONSE_SIZE = 900;
273       
274        TembooCoAPClient& m_client;
275        const char* m_accountName;
276        const char* m_appKeyName;
277        const char* m_appKeyValue;
278        const char* m_path;
279       
280        ChoreoInputSet m_inputs;
281        ChoreoOutputSet m_outputs;
282        ChoreoPreset m_preset;
283       
284        char m_httpCodeStr[4];
285        char* m_respData;
286       
287        uint16_t m_requestId;
288        static uint16_t s_nextRequestId;
289       
290        // variables for the stream interface
291        size_t m_availableChars;
292        const char* m_nextChar;
293        enum State {START,
294            HTTP_CODE_PRE,
295            HTTP_CODE_VALUE,
296            HTTP_CODE_SUF,
297            RESP_DATA,
298            END};
299        State m_nextState;
300       
301    protected:
302        int waitForResponse(TembooTimer& timer);
303        uint16_t getRequestId() {return m_requestId;}
304};
305
306
307#endif //TEMBOO_H_
Note: See TracBrowser for help on using the repository browser.