/* ############################################################################### # # Temboo CoAP Edge Device library # # Copyright (C) 2017, Temboo Inc. # # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at # # http://www.apache.org/licenses/LICENSE-2.0 # # Unless required by applicable law or agreed to in writing, # software distributed under the License is distributed on an # "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, # either express or implied. See the License for the specific # language governing permissions and limitations under the License. # ############################################################################### */ #ifndef TEMBOOCOAP_H_ #define TEMBOOCOAP_H_ #ifndef TEMBOO_LIBRARY_VERSION #define TEMBOO_LIBRARY_VERSION 2 #endif /////////////////////////////////////////////////////// // BEGIN ARDUINO NON-YUN SUPPORT /////////////////////////////////////////////////////// #include "Arduino.h" #include "utility/TembooTimer.h" #include "utility/TembooTags.h" #include "utility/TembooCoAPIPStack.h" #include "utility/ChoreoInputSet.h" #include "utility/ChoreoInputExpressionSet.h" #include "utility/ChoreoSensorInputSet.h" #include "utility/ChoreoOutputSet.h" #include "utility/ChoreoPreset.h" #include "utility/ChoreoDevice.h" #include "utility/CoapMsg.h" #include "utility/CoapMessageLayer.h" #include "utility/CoapRRLayer.h" #define IS_EMPTY(s) (NULL == s || '\0' == *s) #define DEFAULT_CHOREO_TIMEOUT 900 class TembooCoAPChoreo; class TembooCoAPClient { public: TembooCoAPClient(TembooCoAPIPStack& ipStack, IPAddress gatewayAddress, uint16_t gatewayPort = DEFAULT_COAP_PORT); virtual ~TembooCoAPClient(); void begin(long seed); enum Result { NO_ERROR = 0, ERROR_REQUEST_FAILED, ERROR_BAD_RESPONSE, ERROR_MSG_TOKEN, ERROR_MSG_OPTION, ERROR_MSG_PAYLOAD, ERROR_SENDING_MSG, ERROR_RECEIVING_MSG, ERROR_BUFFER_FULL, ERROR_INVALID_MSG, ERROR_RECEIVING_RESPONSE }; enum State { STATE_IDLE, STATE_TRANSMIT, STATE_WAITING_FOR_RESPONSE, STATE_RESPONSE_STARTED, STATE_RESPONSE_READY, STATE_NO_RESPONSE, STATE_SEND_REQUEST, STATE_ERROR }; Result write(uint8_t value); Result write(uint8_t* value, uint16_t len); void clearData() {m_dataLen = 0;} Result loop(); Result sendChoreoRequest(); uint8_t* getPacketBuffer() {return m_respBuffer;} int32_t getPacketBufferSize() {return m_respLen;} int32_t getPacketLength() {return 1000;} int16_t getRespHttpCode() {return m_respHttpCode;} State getState() {return m_state;} Result sendBlockRequest(uint16_t msgID, uint32_t blockNum); void resetChoreo(); int getMessageState() {return m_lastResult;} Result requestTime(uint16_t msgID); protected: static const char URI_PATH[]; Result m_lastResult; bool moreBlocksToSend(); // MAX_BLOCK_SIZE *MUST* be one of the standard CoAP block sizes // This size should be set with consideration to any network or // hardware limitations on UDP packet size. // (16, 32, 64, 128, 256, 512, or 1024). static const int MAX_BLOCK_SIZE = 64; // MAX_PACKET_SIZE should be at least big enough to hold: // for outgoing requests: // 4 header bytes // 6 token bytes (in our case, Spec says tokens can be up to 8 bytes). // 1 byte for the URI PATH option (I *think*) // 4 strlen(URI_PATH) bytes for the URI PATH option value. // 3 bytes for a block1 option // 3 bytes for a block1 option value // 1 bytes for a block2 option (early response size negotiation) // 1 bytes for a block2 option value // ? 5 bytes for a size1 or size2 option // ? 4 bytes for a sizeX option value // 1 byte for the FF payload marker // MAX_BLOCK_SIZE for the payload // // or 24 + MAX_BLOCK_SIZE // // HOWEVER... we need to consider the possibility that the server may // use more options and thus send more bytes. So we should add as much // extra space as we can reasonably afford so as to avoid buffer overflows. static const size_t MAX_PACKET_SIZE = 90; static const size_t MAX_DATA_SIZE = 1000; static const uint16_t DEFAULT_COAP_PORT = 5683; CoapMessageLayer m_messageLayer; CoapRRLayer m_rrLayer; IPAddress m_gatewayAddress; uint16_t m_gatewayPort; uint16_t m_messageID; State m_state; uint16_t m_blockSize; Result m_lastError; uint16_t m_dataLen; uint8_t m_dataBuffer[MAX_DATA_SIZE]; uint8_t m_respBuffer[MAX_DATA_SIZE]; char m_token[9]; uint8_t m_txBuffer[MAX_PACKET_SIZE]; uint8_t m_rxBuffer[MAX_PACKET_SIZE]; uint32_t m_rxBlockNum; int32_t m_txIndex; int32_t m_txByteCount; int32_t m_respLen; uint32_t m_txBlockNum; int16_t m_respHttpCode; Result generateToken(); uint16_t getNextMessageID(); Result sendBlock(uint16_t msgID, uint8_t* payload, size_t len, uint32_t blockNum, bool moreBlocks); void adjustRequestBlockSize(CoapMsg& msg); void cancelWait(); int send(CoapMsg* msg); int sendResetMsg(CoapMsg& msg); int sendEmptyAckMsg(CoapMsg& msg); int sendBlock2AckMsg(CoapMsg& msg); bool isMsgResponse(CoapMsg& msg); void handleBlockAck(CoapMsg& msg); void handleBlock1InResponse(CoapMsg& msg); Result saveResponse(uint8_t* values, uint16_t len); friend class TembooCoAPChoreo; }; class TembooCoAPChoreo : public Stream { public: // Constructor. // client - an instance of a TembooCoAPClient. // Used to communicate with a Temboo CoAP Gateway. TembooCoAPChoreo(TembooCoAPClient& client); ~TembooCoAPChoreo(); // Does nothing. Just for source compatibility with Yun code. void begin() {;}; // Sets the account name to use when communicating with Temboo. // (required) void setAccountName(const String& accountName); void setAccountName(const char* accountName); // Sets the application key name to use with choreo execution requests. // (required) void setAppKeyName(const String& appKeyName); void setAppKeyName(const char* appKeyName); // Sets the application key value to use with choreo execution requests // (required) void setAppKey(const String& appKey); void setAppKey(const char* appKey); // sets the name of the choreo to be executed. // (required) void setChoreo(const String& choreoPath); void setChoreo(const char* choreoPath); // sets the name of the saved inputs to use when executing the choreo // (optional) void setSavedInputs(const String& savedInputsName); void setSavedInputs(const char* savedInputsName); void setCredential(const String& credentialName); void setCredential(const char* credentialName); void setProfile(const String& profileName); void setProfile(const char* profileName); // sets an input to be used when executing a choreo. // (optional or required, depending on the choreo being executed.) void addInput(const String& inputName, const String& inputValue); void addInput(const char* inputName, const char* inputValue); void addInput(const char* inputName, const String& inputValue); void addInput(const String& inputName, const char* inputValue); // sets an output filter to be used to process the choreo output // (optional) void addOutputFilter(const char* filterName, const char* filterPath, const char* variableName); void addOutputFilter(const String& filterName, const char* filterPath, const char* variableName); void addOutputFilter(const char* filterName, const String& filterPath, const char* variableName); void addOutputFilter(const String& filterName, const String& filterPath, const char* variableName); void addOutputFilter(const char* filterName, const char* filterPath, const String& variableName); void addOutputFilter(const String& filterName, const char* filterPath, const String& variableName); void addOutputFilter(const char* filterName, const String& filterPath, const String& variableName); void addOutputFilter(const String& filterName, const String& filterPath, const String& variableName); // run the choreo using the current input info int run(uint16_t timeoutSecs = DEFAULT_CHOREO_TIMEOUT); char* getResponseData() {return m_respData;} char* getHTTPResponseCode() {return m_httpCodeStr;} // Stream interface void close() {}; int available(); int read(); int peek(); void flush(); //Print interface size_t write(uint8_t data); enum Error { SUCCESS = 0, FAILURE, TEMBOO_ERROR_ACCOUNT_MISSING = 201, TEMBOO_ERROR_CHOREO_MISSING = 203, TEMBOO_ERROR_APPKEY_NAME_MISSING = 205, TEMBOO_ERROR_APPKEY_MISSING = 207, TEMBOO_ERROR_HTTP_ERROR = 223, TEMBOO_ERROR_TIMEOUT = 225, TEMBOO_ERROR_MEMORY = 900, TEMBOO_ERROR_TCPIP_CONNECT_FAIL = 901, TEMBOO_ERROR_NO_RESPONSE = 0xFFFF }; protected: static const size_t MAX_RESPONSE_SIZE = 900; TembooCoAPClient& m_client; const char* m_accountName; const char* m_appKeyName; const char* m_appKeyValue; const char* m_path; ChoreoInputSet m_inputs; ChoreoInputExpressionSet m_expressions; ChoreoSensorInputSet m_sensors; ChoreoOutputSet m_outputs; ChoreoPreset m_preset; ChoreoDevice m_deviceType; ChoreoDevice m_deviceName; char m_httpCodeStr[4]; char* m_respData; uint16_t m_requestId; static uint16_t s_nextRequestId; // variables for the stream interface size_t m_availableChars; const char* m_nextChar; enum State {START, HTTP_CODE_PRE, HTTP_CODE_VALUE, HTTP_CODE_SUF, RESP_DATA, END}; State m_nextState; protected: int waitForResponse(TembooTimer& timer); uint16_t getRequestId() {return m_requestId;} }; #endif //TEMBOO_H_