boting ren
This is an example of BLE GATT Client, which receives broadcast data from BLE_Server_BME280 ( a GATT server) , then transfers values up to mbed Device Connector (cloud).
Please refer details about BLEClient_mbedDevConn below. https://github.com/soramame21/BLEClient_mbedDevConn
The location of required BLE GATT server, BLE_Server_BME280, is at here. https://developer.mbed.org/users/edamame22/code/BLE_Server_BME280/
Diff: mbed-client/source/m2mresource.cpp
- Revision:
- 0:29983394c6b6
diff -r 000000000000 -r 29983394c6b6 mbed-client/source/m2mresource.cpp
--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/mbed-client/source/m2mresource.cpp Thu Apr 13 04:48:11 2017 +0000
@@ -0,0 +1,619 @@
+/*
+ * Copyright (c) 2015 ARM Limited. All rights reserved.
+ * SPDX-License-Identifier: Apache-2.0
+ * 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.
+ */
+#include "mbed-client/m2mconstants.h"
+#include "mbed-client/m2mresource.h"
+#include "mbed-client/m2mobservationhandler.h"
+#include "include/m2mreporthandler.h"
+#include "include/m2mtlvserializer.h"
+#include "include/m2mtlvdeserializer.h"
+#include "mbed-trace/mbed_trace.h"
+
+#include <stdlib.h>
+
+#define TRACE_GROUP "mClt"
+
+M2MResource::M2MResource(M2MObjectInstance &parent,
+ const String &resource_name,
+ const String &resource_type,
+ M2MResourceInstance::ResourceType type,
+ const uint8_t *value,
+ const uint8_t value_length,
+ char *path,
+ const uint16_t object_instance_id,
+ bool multiple_instance,
+ bool external_blockwise_store)
+: M2MResourceInstance(*this, resource_name, resource_type, type, value, value_length,
+ object_instance_id,
+ path, external_blockwise_store),
+ _parent(parent),
+ _delayed_token(NULL),
+ _delayed_token_len(0),
+ _has_multiple_instances(multiple_instance),
+ _delayed_response(false)
+{
+ M2MBase::set_base_type(M2MBase::Resource);
+ M2MBase::set_operation(M2MBase::GET_ALLOWED);
+ M2MBase::set_observable(false);
+
+}
+
+M2MResource::M2MResource(M2MObjectInstance &parent,
+ const lwm2m_parameters_s* s,
+ M2MResourceInstance::ResourceType type,
+ const uint16_t object_instance_id)
+: M2MResourceInstance(*this, s, type, object_instance_id),
+ _parent(parent),
+ _delayed_token(NULL),
+ _delayed_token_len(0),
+ _has_multiple_instances(false),
+ _delayed_response(false)
+{
+ // tbd: _has_multiple_instances could be in flash, but no real benefit, because of current alignment.
+}
+
+M2MResource::M2MResource(M2MObjectInstance &parent,
+ const String &resource_name,
+ const String &resource_type,
+ M2MResourceInstance::ResourceType type,
+ bool observable,
+ char *path,
+ const uint16_t object_instance_id,
+ bool multiple_instance,
+ bool external_blockwise_store)
+: M2MResourceInstance(*this, resource_name, resource_type, type,
+ object_instance_id,
+ path,
+ external_blockwise_store),
+ _parent(parent),
+ _delayed_token(NULL),
+ _delayed_token_len(0),
+ _has_multiple_instances(multiple_instance),
+ _delayed_response(false)
+{
+ M2MBase::set_base_type(M2MBase::Resource);
+ M2MBase::set_operation(M2MBase::GET_PUT_ALLOWED);
+ M2MBase::set_observable(observable);
+}
+
+
+M2MResource::~M2MResource()
+{
+ if(!_resource_instance_list.empty()) {
+ M2MResourceInstance* res = NULL;
+ M2MResourceInstanceList::const_iterator it;
+ it = _resource_instance_list.begin();
+ for (; it!=_resource_instance_list.end(); it++ ) {
+ //Free allocated memory for resources.
+ res = *it;
+ delete res;
+ }
+ _resource_instance_list.clear();
+ }
+ free(_delayed_token);
+}
+
+bool M2MResource::supports_multiple_instances() const
+{
+ return _has_multiple_instances;
+}
+
+void M2MResource::set_delayed_response(bool delayed_response)
+{
+ _delayed_response = delayed_response;
+}
+
+bool M2MResource::send_delayed_post_response()
+{
+ bool success = false;
+ if(_delayed_response) {
+ success = true;
+ observation_handler()->send_delayed_response(this);
+ }
+ return success;
+}
+
+void M2MResource::get_delayed_token(uint8_t *&token, uint8_t &token_length)
+{
+ token_length = 0;
+ if(token) {
+ free(token);
+ token = NULL;
+ }
+ if(_delayed_token && _delayed_token_len > 0) {
+ token = alloc_copy(_delayed_token, _delayed_token_len);
+ if(token) {
+ token_length = _delayed_token_len;
+ }
+ }
+}
+
+bool M2MResource::remove_resource_instance(uint16_t inst_id)
+{
+ tr_debug("M2MResource::remove_resource(inst_id %d)", inst_id);
+ bool success = false;
+ if(!_resource_instance_list.empty()) {
+ M2MResourceInstance* res = NULL;
+ M2MResourceInstanceList::const_iterator it;
+ it = _resource_instance_list.begin();
+ int pos = 0;
+ for ( ; it != _resource_instance_list.end(); it++, pos++ ) {
+ if(((*it)->instance_id() == inst_id)) {
+ // Resource found and deleted.
+ res = *it;
+ delete res;
+ _resource_instance_list.erase(pos);
+ success = true;
+ break;
+ }
+ }
+ }
+ return success;
+}
+
+M2MResourceInstance* M2MResource::resource_instance(uint16_t inst_id) const
+{
+ tr_debug("M2MResource::resource(resource_name inst_id %d)", inst_id);
+ M2MResourceInstance *res = NULL;
+ if(!_resource_instance_list.empty()) {
+ M2MResourceInstanceList::const_iterator it;
+ it = _resource_instance_list.begin();
+ for ( ; it != _resource_instance_list.end(); it++ ) {
+ if(((*it)->instance_id() == inst_id)) {
+ // Resource found.
+ res = *it;
+ break;
+ }
+ }
+ }
+ return res;
+}
+
+const M2MResourceInstanceList& M2MResource::resource_instances() const
+{
+ return _resource_instance_list;
+}
+
+uint16_t M2MResource::resource_instance_count() const
+{
+ return (uint16_t)_resource_instance_list.size();
+}
+
+bool M2MResource::delayed_response() const
+{
+ return _delayed_response;
+}
+
+bool M2MResource::handle_observation_attribute(const char *query)
+{
+ tr_debug("M2MResource::handle_observation_attribute - is_under_observation(%d)", is_under_observation());
+ bool success = false;
+ M2MReportHandler *handler = M2MBase::report_handler();
+ if (!handler) {
+ handler = M2MBase::create_report_handler();
+ }
+
+ if (handler) {
+ success = handler->parse_notification_attribute(query,
+ M2MBase::base_type(), _resource_type);
+ if (success) {
+ if (is_under_observation()) {
+ handler->set_under_observation(true);
+ }
+ }
+ else {
+ handler->set_default_values();
+ }
+
+ if (success) {
+ if(!_resource_instance_list.empty()) {
+ M2MResourceInstanceList::const_iterator it;
+ it = _resource_instance_list.begin();
+ for ( ; it != _resource_instance_list.end(); it++ ) {
+ M2MReportHandler *report_handler = (*it)->report_handler();
+ if(report_handler && is_under_observation()) {
+ report_handler->set_notification_trigger();
+ }
+ }
+ }
+ }
+ }
+ return success;
+}
+
+void M2MResource::add_observation_level(M2MBase::Observation observation_level)
+{
+ M2MBase::add_observation_level(observation_level);
+ if(!_resource_instance_list.empty()) {
+ M2MResourceInstanceList::const_iterator inst;
+ inst = _resource_instance_list.begin();
+ for ( ; inst != _resource_instance_list.end(); inst++ ) {
+ (*inst)->add_observation_level(observation_level);
+ }
+ }
+}
+
+void M2MResource::remove_observation_level(M2MBase::Observation observation_level)
+{
+ M2MBase::remove_observation_level(observation_level);
+ if(!_resource_instance_list.empty()) {
+ M2MResourceInstanceList::const_iterator inst;
+ inst = _resource_instance_list.begin();
+ for ( ; inst != _resource_instance_list.end(); inst++ ) {
+ (*inst)->remove_observation_level(observation_level);
+ }
+ }
+}
+
+void M2MResource::add_resource_instance(M2MResourceInstance *res)
+{
+ tr_debug("M2MResource::add_resource_instance()");
+ if(res) {
+ _resource_instance_list.push_back(res);
+ }
+}
+
+sn_coap_hdr_s* M2MResource::handle_get_request(nsdl_s *nsdl,
+ sn_coap_hdr_s *received_coap_header,
+ M2MObservationHandler *observation_handler)
+{
+ tr_debug("M2MResource::handle_get_request()");
+ sn_coap_msg_code_e msg_code = COAP_MSG_CODE_RESPONSE_CONTENT;
+ sn_coap_hdr_s * coap_response = NULL;
+ if(_has_multiple_instances) {
+ coap_response = sn_nsdl_build_response(nsdl,
+ received_coap_header,
+ msg_code);
+ if(received_coap_header) {
+ // process the GET if we have registered a callback for it
+ if ((operation() & SN_GRS_GET_ALLOWED) != 0) {
+ if(coap_response) {
+ uint16_t coap_content_type = 0;
+ bool content_type_present = false;
+ if(received_coap_header->content_format != COAP_CT_NONE){
+ content_type_present = true;
+ coap_content_type = received_coap_header->content_format;
+ }
+
+ if(!content_type_present &&
+ M2MBase::coap_content_type() == COAP_CONTENT_OMA_TLV_TYPE) {
+ coap_content_type = COAP_CONTENT_OMA_TLV_TYPE;
+ }
+
+ tr_debug("M2MResource::handle_get_request() - Request Content-Type %d", coap_content_type);
+ if (coap_response->content_format == COAP_CT_NONE) {
+ coap_response->content_format = sn_coap_content_format_e(coap_content_type);
+ if (coap_response->content_format != COAP_CT_NONE) {
+ set_coap_content_type(coap_content_type);
+ }
+ }
+ uint8_t *data = NULL;
+ uint32_t data_length = 0;
+ // fill in the CoAP response payload
+ if(COAP_CONTENT_OMA_TLV_TYPE == coap_content_type) {
+ M2MTLVSerializer serializer;
+ data = serializer.serialize(this, data_length);
+ } else {
+ msg_code = COAP_MSG_CODE_RESPONSE_UNSUPPORTED_CONTENT_FORMAT; // Content format not supported
+ }
+
+ coap_response->payload_len = data_length;
+ coap_response->payload_ptr = data;
+
+ coap_response->options_list_ptr = sn_nsdl_alloc_options_list(nsdl, coap_response);
+
+ coap_response->options_list_ptr->max_age = max_age();
+
+ if(received_coap_header->options_list_ptr) {
+ if(received_coap_header->options_list_ptr->observe != -1) {
+ if (is_observable()) {
+ uint32_t number = 0;
+ uint8_t observe_option = 0;
+ observe_option = received_coap_header->options_list_ptr->observe;
+ if(START_OBSERVATION == observe_option) {
+ tr_debug("M2MResource::handle_get_request - Starts Observation");
+ // If the observe length is 0 means register for observation.
+ if(received_coap_header->options_list_ptr->observe != -1) {
+ number = received_coap_header->options_list_ptr->observe;
+ }
+ if(received_coap_header->token_ptr) {
+ tr_debug("M2MResource::handle_get_request - Sets Observation Token to resource");
+ set_observation_token(received_coap_header->token_ptr,
+ received_coap_header->token_len);
+ }
+
+ // If the observe value is 0 means register for observation.
+ if(number == 0) {
+ tr_debug("M2MResource::handle_get_request - Put Resource under Observation");
+ M2MResourceInstanceList::const_iterator it;
+ it = _resource_instance_list.begin();
+ for (; it!=_resource_instance_list.end(); it++ ) {
+ tr_debug("M2MResource::handle_get_request - set_resource_observer");
+ (*it)->set_resource_observer(this);
+ (*it)->add_observation_level(M2MBase::R_Attribute);
+ }
+ set_under_observation(true,observation_handler);
+ M2MBase::add_observation_level(M2MBase::R_Attribute);
+ coap_response->options_list_ptr->observe = observation_number();
+ }
+ } else if (STOP_OBSERVATION == observe_option) {
+ tr_debug("M2MResource::handle_get_request - Stops Observation");
+ set_under_observation(false,NULL);
+ M2MBase::remove_observation_level(M2MBase::R_Attribute);
+ M2MResourceInstanceList::const_iterator it;
+ it = _resource_instance_list.begin();
+ for (; it!=_resource_instance_list.end(); it++ ) {
+ (*it)->set_resource_observer(NULL);
+ }
+ }
+ msg_code = COAP_MSG_CODE_RESPONSE_CONTENT;
+ }
+ else {
+ msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED;
+ }
+ }
+ }
+ }
+ } else {
+ tr_error("M2MResource::handle_get_request - Return COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED");
+ // Operation is not allowed.
+ msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED;
+ }
+ }
+ if(coap_response) {
+ coap_response->msg_code = msg_code;
+ }
+ } else {
+ coap_response = M2MResourceInstance::handle_get_request(nsdl,
+ received_coap_header,
+ observation_handler);
+ }
+ return coap_response;
+}
+
+sn_coap_hdr_s* M2MResource::handle_put_request(nsdl_s *nsdl,
+ sn_coap_hdr_s *received_coap_header,
+ M2MObservationHandler *observation_handler,
+ bool &execute_value_updated)
+{
+ tr_debug("M2MResource::handle_put_request()");
+ sn_coap_msg_code_e msg_code = COAP_MSG_CODE_RESPONSE_CHANGED; // 2.04
+ sn_coap_hdr_s * coap_response = NULL;
+ if(_has_multiple_instances) {
+ coap_response = sn_nsdl_build_response(nsdl,
+ received_coap_header,
+ msg_code);
+ // process the PUT if we have registered a callback for it
+ if(received_coap_header) {
+ uint16_t coap_content_type = 0;
+ bool content_type_present = false;
+ if(received_coap_header->content_format != COAP_CT_NONE && coap_response) {
+ content_type_present = true;
+ coap_content_type = received_coap_header->content_format;
+ }
+ if(received_coap_header->options_list_ptr &&
+ received_coap_header->options_list_ptr->uri_query_ptr) {
+ char *query = (char*)alloc_string_copy(received_coap_header->options_list_ptr->uri_query_ptr,
+ received_coap_header->options_list_ptr->uri_query_len);
+ if (query){
+ msg_code = COAP_MSG_CODE_RESPONSE_CHANGED;
+ tr_debug("M2MResource::handle_put_request() - Query %s", query);
+ // if anything was updated, re-initialize the stored notification attributes
+ if (!handle_observation_attribute(query)){
+ tr_debug("M2MResource::handle_put_request() - Invalid query");
+ msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST; // 4.00
+ }
+ free(query);
+ }
+ } else if ((operation() & SN_GRS_PUT_ALLOWED) != 0) {
+ if(!content_type_present &&
+ M2MBase::coap_content_type() == COAP_CONTENT_OMA_TLV_TYPE) {
+ coap_content_type = COAP_CONTENT_OMA_TLV_TYPE;
+ }
+
+ tr_debug("M2MResource::handle_put_request() - Request Content-Type %d", coap_content_type);
+
+ if(COAP_CONTENT_OMA_TLV_TYPE == coap_content_type) {
+ M2MTLVDeserializer deserializer;
+ M2MTLVDeserializer::Error error = M2MTLVDeserializer::None;
+ error = deserializer.deserialize_resource_instances(received_coap_header->payload_ptr,
+ received_coap_header->payload_len,
+ *this,
+ M2MTLVDeserializer::Put);
+ switch(error) {
+ case M2MTLVDeserializer::None:
+ if(observation_handler) {
+ String value = "";
+ if (received_coap_header->uri_path_ptr != NULL &&
+ received_coap_header->uri_path_len > 0) {
+
+ value.append_raw((char*)received_coap_header->uri_path_ptr,received_coap_header->uri_path_len);
+ }
+ execute_value_updated = true;
+ }
+ msg_code = COAP_MSG_CODE_RESPONSE_CHANGED;
+ break;
+ case M2MTLVDeserializer::NotFound:
+ msg_code = COAP_MSG_CODE_RESPONSE_NOT_FOUND;
+ break;
+ case M2MTLVDeserializer::NotAllowed:
+ msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED;
+ break;
+ case M2MTLVDeserializer::NotValid:
+ msg_code = COAP_MSG_CODE_RESPONSE_BAD_REQUEST;
+ break;
+ }
+ } else {
+ msg_code =COAP_MSG_CODE_RESPONSE_UNSUPPORTED_CONTENT_FORMAT;
+ } // if(COAP_CONTENT_OMA_TLV_TYPE == coap_content_type)
+ } else {
+ // Operation is not allowed.
+ tr_error("M2MResource::handle_put_request() - COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED");
+ msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED;
+ }
+ } else {
+ msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED;
+ }
+ if(coap_response) {
+ coap_response->msg_code = msg_code;
+ }
+ } else {
+ coap_response = M2MResourceInstance::handle_put_request(nsdl,
+ received_coap_header,
+ observation_handler,
+ execute_value_updated);
+ }
+ return coap_response;
+}
+
+sn_coap_hdr_s* M2MResource::handle_post_request(nsdl_s *nsdl,
+ sn_coap_hdr_s *received_coap_header,
+ M2MObservationHandler */*observation_handler*/,
+ bool &/*execute_value_updated*/,
+ sn_nsdl_addr_s *address)
+{
+ tr_debug("M2MResource::handle_post_request()");
+ sn_coap_msg_code_e msg_code = COAP_MSG_CODE_RESPONSE_CHANGED; // 2.04
+ sn_coap_hdr_s * coap_response = sn_nsdl_build_response(nsdl,
+ received_coap_header,
+ msg_code);
+ // process the POST if we have registered a callback for it
+ if(received_coap_header) {
+ if ((operation() & SN_GRS_POST_ALLOWED) != 0) {
+ M2MResource::M2MExecuteParameter *exec_params = new M2MResource::M2MExecuteParameter();
+ if (exec_params) {
+ exec_params->_object_name = object_name();
+ exec_params->_resource_name = name();
+ exec_params->_object_instance_id = object_instance_id();
+ }
+ uint16_t coap_content_type = 0;
+ if(received_coap_header->payload_ptr) {
+ if(received_coap_header->content_format != COAP_CT_NONE) {
+ coap_content_type = received_coap_header->content_format;
+ }
+ if(coap_content_type == 0) {
+ if (exec_params){
+ exec_params->_value = alloc_string_copy(received_coap_header->payload_ptr,
+ received_coap_header->payload_len);
+ if (exec_params->_value) {
+ exec_params->_value_length = received_coap_header->payload_len;
+ }
+ }
+ } else {
+ msg_code = COAP_MSG_CODE_RESPONSE_UNSUPPORTED_CONTENT_FORMAT;
+ }
+ }
+ if(COAP_MSG_CODE_RESPONSE_CHANGED == msg_code) {
+ tr_debug("M2MResource::handle_post_request - Execute resource function");
+ if(_delayed_response) {
+ msg_code = COAP_MSG_CODE_EMPTY;
+ coap_response->msg_type = COAP_MSG_TYPE_ACKNOWLEDGEMENT;
+ coap_response->msg_code = msg_code;
+ coap_response->msg_id = received_coap_header->msg_id;
+ if(received_coap_header->token_len) {
+ free(_delayed_token);
+ _delayed_token = NULL;
+ _delayed_token_len = 0;
+ _delayed_token = alloc_copy(received_coap_header->token_ptr, received_coap_header->token_len);
+ if(_delayed_token) {
+ _delayed_token_len = received_coap_header->token_len;
+ }
+ sn_nsdl_send_coap_message(nsdl, address, coap_response);
+ }
+ } else {
+ uint32_t length = 0;
+ get_value(coap_response->payload_ptr, length);
+ coap_response->payload_len = length;
+ }
+ execute(exec_params);
+ }
+ delete exec_params;
+ } else { // if ((object->operation() & SN_GRS_POST_ALLOWED) != 0)
+ tr_error("M2MResource::handle_post_request - COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED");
+ msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED; // 4.05
+ }
+ } else { //if(object && received_coap_header)
+ tr_error("M2MResource::handle_post_request - COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED");
+ msg_code = COAP_MSG_CODE_RESPONSE_METHOD_NOT_ALLOWED; // 4.01
+ }
+ if(coap_response) {
+ coap_response->msg_code = msg_code;
+ }
+ return coap_response;
+}
+
+void M2MResource::notification_update()
+{
+ tr_debug("M2MResource::notification_update()");
+ M2MReportHandler *report_handler = M2MBase::report_handler();
+ if(report_handler && is_observable()) {
+ report_handler->set_notification_trigger();
+ }
+}
+
+M2MObjectInstance& M2MResource::get_parent_object_instance() const
+{
+ return _parent;
+}
+
+const char* M2MResource::object_name() const
+{
+ const M2MObjectInstance& parent_object_instance = _parent;
+ const M2MObject& parent_object = parent_object_instance.get_parent_object();
+
+ return parent_object.name();
+}
+
+
+M2MResource::M2MExecuteParameter::M2MExecuteParameter()
+{
+ _value = NULL;
+ _value_length = 0;
+ _object_name = "";
+ _resource_name = "";
+ _object_instance_id = 0;
+}
+
+M2MResource::M2MExecuteParameter::~M2MExecuteParameter()
+{
+ free(_value);
+}
+
+uint8_t *M2MResource::M2MExecuteParameter::get_argument_value() const
+{
+ return _value;
+}
+
+uint16_t M2MResource::M2MExecuteParameter::get_argument_value_length() const
+{
+ return _value_length;
+}
+
+const String& M2MResource::M2MExecuteParameter::get_argument_object_name() const
+{
+ return _object_name;
+}
+
+const String& M2MResource::M2MExecuteParameter::get_argument_resource_name() const
+{
+ return _resource_name;
+}
+
+uint16_t M2MResource::M2MExecuteParameter::get_argument_object_instance_id() const
+{
+ return _object_instance_id;
+}
+
+