void app_start(int, char**) { // setup the EthernetInterface eth.init(); // DHCP eth.connect(); // initialize the ipv4 tcp/ip stack lwipv4_socket_init(); // setup the M2MInterface srand(time(NULL)); uint16_t port = rand() % 65535 + 12345; srv = M2MInterfaceFactory::create_interface(observer,endpoint,type, lifetime,port,domain,M2MInterface::UDP,M2MInterface::LwIP_IPv4,context_address); // setup the Security object sec = M2MInterfaceFactory::create_security(M2MSecurity::M2MServer); sec->set_resource_value(M2MSecurity::M2MServerUri,address); sec->set_resource_value(M2MSecurity::SecurityMode, M2MSecurity::NoSecurity); // setup the Device object dev = M2MInterfaceFactory::create_device(); dev->create_resource(M2MDevice::Manufacturer,"Freescale"); dev->create_resource(M2MDevice::DeviceType,"frdm-k64f"); dev->create_resource(M2MDevice::ModelNumber,"M64FN1MOVLL12"); dev->create_resource(M2MDevice::SerialNumber,"EB1524XXXX"); // setup the sensor objects obj = M2MInterfaceFactory::create_object("loc"); M2MObjectInstance* ins = obj->create_object_instance(); M2MResource* resx = ins->create_dynamic_resource("x","accel",M2MResourceInstance::INTEGER,true); resx->set_operation(M2MBase::GET_PUT_ALLOWED); resx->set_value((const uint8_t*)"0",1); M2MResource* resy = ins->create_dynamic_resource("y","accel",M2MResourceInstance::INTEGER,true); resy->set_operation(M2MBase::GET_PUT_ALLOWED); resy->set_value((const uint8_t*)"0",1); // Assemble the list of objects to register M2MObjectList list; list.push_back(dev); list.push_back(obj); // setup registration event Ticker timer; timer.attach(®,&Registrar::update,20); // enable accelerometer printf("Initializied accelerometer\r\n"); accel.enable(); Ticker sampler; sampler.attach(sample,5); // schedule FunctionPointer1<void, M2MObjectList> fp(®, &Registrar::setup); minar::Scheduler::postCallback(fp.bind(list)); minar::Scheduler::postCallback(sample).period(minar::milliseconds(10000)); minar::Scheduler::start(); }
bool M2MLWClient::create_object(const char *name, bool new_instance, uint8_t object_operation, uint8_t object_instance_operation, uint16_t object_instance_id, bool object_observable, bool object_instance_observable) { bool success = false; M2MObjectInstance *inst = NULL; if(!_object) { _object = M2MInterfaceFactory::create_object(name); if(_object) { _object->set_operation(int_to_operation(object_operation)); _object->set_observable(object_observable); inst = _object->create_object_instance(object_instance_id); if(inst) { success = true; inst->set_operation(int_to_operation(object_instance_operation)); inst->set_observable(object_instance_observable); } } } else { if(new_instance) { inst = _object->create_object_instance(object_instance_id); if(inst) { success = true; inst->set_operation(int_to_operation(object_instance_operation)); inst->set_observable(object_instance_observable); } } } return success; }
M2MObject* create_generic_object() { _object = M2MInterfaceFactory::create_object("Test"); if(_object) { M2MObjectInstance* inst = _object->create_object_instance(); if(inst) { M2MResource* res = inst->create_dynamic_resource("D", "ResourceTest", M2MResourceInstance::INTEGER, true); char buffer[20]; int size = sprintf(buffer,"%d",_value); res->set_operation(M2MBase::GET_PUT_ALLOWED); res->set_value((const uint8_t*)buffer, (const uint32_t)size); _value++; inst->create_static_resource("S", "ResourceTest", M2MResourceInstance::STRING, STATIC_VALUE, sizeof(STATIC_VALUE)-1); } } return _object; }
M2MObject* create_led_object() { _sdw_led_object = M2MInterfaceFactory::create_object("311"); if (_sdw_led_object) { M2MObjectInstance* inst = _sdw_led_object->create_object_instance(); if (inst) { M2MResource* res = inst->create_dynamic_resource("5850", "LED", M2MResourceInstance::STRING, false); if (res) { char buffer[10] = ""; memset(buffer,0,10); strcpy(buffer,"0"); if (__led == 1) strcpy(buffer,"1"); // set the value of the LED res->set_operation(M2MBase::GET_PUT_ALLOWED); // we allow GET and PUT of the LED res->set_value((const uint8_t*)buffer, (const uint32_t)strlen(buffer)); } } } return _sdw_led_object; }
bool M2MLWClient::create_dynamic_resource_instance_string(const char *name, bool observable, bool multiple_instance, uint16_t object_instance, uint16_t resource_instance, uint8_t resource_instance_operation) { bool success = false; String name_string; if(name) { name_string += name; } if(_object) { M2MObjectInstance *inst = _object->object_instance(object_instance); if(inst) { M2MResourceInstance *res = inst->create_dynamic_resource_instance(name,"resource", M2MResourceInstance::STRING, observable, resource_instance); if( res) { success = true; res->set_operation(int_to_operation(resource_instance_operation)); } } } return success; }
bool M2MObject::remove_object_instance(uint16_t inst_id) { tr_debug("M2MObject::remove_object_instance(inst_id %d)", inst_id); bool success = false; if(!_instance_list.empty()) { M2MObjectInstance* obj = NULL; M2MObjectInstanceList::const_iterator it; it = _instance_list.begin(); int pos = 0; for ( ; it != _instance_list.end(); it++, pos++ ) { if((*it)->instance_id() == inst_id) { // Instance found and deleted. obj = *it; String obj_name = name(); obj_name.push_back('/'); obj_name.append_int(obj->instance_id()); obj->remove_resource_from_coap(obj_name); _instance_list.erase(pos); delete obj; success = true; break; } } } return success; }
bool M2MLWClient::create_static_resource_instance_string(const char *name, const char *value, bool multiple_instance, uint16_t object_instance, uint16_t resource_instance) { bool success = false; String name_string; if(name) { name_string += name; } String value_string; if(value) { value_string += value; } if(_object) { M2MObjectInstance *inst = _object->object_instance(object_instance); if(inst) { if(inst->create_static_resource_instance(name,"resource", M2MResourceInstance::STRING, (const uint8_t*)value_string.c_str(), value_string.size(), resource_instance) != NULL) { success = true; } } } return success; }
bool create_generic_object() { bool success = false; _object = M2MInterfaceFactory::create_object("10"); if(_object) { _object->set_operation(M2MBase::GET_PUT_POST_ALLOWED); M2MObjectInstance* inst = _object->create_object_instance(); if(inst) { inst->set_operation(M2MBase::GET_PUT_POST_ALLOWED); inst->set_observable(false); char buffer[20]; int size = sprintf(buffer,"%d",_value); inst->create_static_resource("0", "ResourceTest", M2MResourceInstance::INTEGER, STATIC_VALUE, sizeof(STATIC_VALUE)-1); M2MResourceInstance* instance = inst->create_dynamic_resource_instance("1", "ResourceTest", M2MResourceInstance::INTEGER, true,0); if(instance) { instance->set_operation(M2MBase::GET_PUT_POST_ALLOWED); instance->set_value((const uint8_t*)buffer, (const uint32_t)size); instance->set_execute_function(execute_callback(this,&MbedClient::execute_function)); _value++; } } } return success; }
//Callback from mbed client stack if any value has changed // during PUT operation. Object and its type is passed in // the callback. void value_updated(M2MBase *base, M2MBase::BaseType type) { output.printf("\nUpdate Object name %s and Type %d\n", base->name().c_str(), type); // only the LED supports PUT so lets see if its this instance... M2MObjectInstance* inst = _sdw_led_object->object_instance(); if (inst) { // should be the /311/0/5850 resource... check for it... M2MResource* res = inst->resource("5850"); if (res != NULL && base == res) { // extract the LED value... char *new_led_value = (char *)(res->value()); // DEBUG printf("\nLight Switch Resource Changed! [%s]\n",new_led_value); // Update the LED if (strcmp(new_led_value,"1") == 0) { __led = 0; } else { __led = 1; } } } }
bool M2MLWClient::set_resource_instance_value(const char *name, const char *value, uint16_t object_instance, uint16_t resource_instance) { bool success = false; String name_string; String value_string; if(name) { name_string += name; } if(value) { value_string += value; } if(_object && name_string.length() > 0) { M2MObjectInstance *inst = _object->object_instance(object_instance); if(inst) { M2MResource *res = inst->resource(name_string); if (res) { M2MResourceInstance *res_inst = res->resource_instance(resource_instance); if(res_inst) { if (res_inst->set_value((const uint8_t*)value_string.c_str(), value_string.size())) { success = true; } } } } } return success; }
bool M2MLWClient::create_static_resource_instance_int(const char *name, int32_t value, bool multiple_instance, uint16_t object_instance, uint16_t resource_instance) { bool success = false; String name_string; String value_string; if(name) { name_string += name; } char value_buffer[20]; sprintf(value_buffer,"%ld",value); value_string += value_buffer; if(_object) { M2MObjectInstance *inst = _object->object_instance(object_instance); if(inst) { if(inst->create_static_resource_instance(name,"resource", M2MResourceInstance::INTEGER, (const uint8_t*)value_string.c_str(), value_string.size(), resource_instance) != NULL) { success = true; } } } return success; }
/* * When you press the button, we read the current value of the click counter * from mbed Device Connector, then up the value with one. */ void handle_state_change(DoorIndicator::WarnStatus warnStatus) { M2MObjectInstance* inst = btn_object->object_instance(); M2MResource* res = inst->resource("5501"); printf("handle_state_change, new value of state is %d\r\n", (int) warnStatus); // serialize the value of counter as a string, and tell connector stringstream ss; ss << (int) warnStatus; std::string stringified = ss.str(); res->set_value((uint8_t*)stringified.c_str(), stringified.length()); }
void M2MLWClient::set_fw_execute_function() { if(_firmware) { M2MObjectInstance *inst = _firmware->object_instance(0); if(inst) { M2MResource *res = inst->resource("2"); if (res) { res->set_execute_function(execute_callback( this, &M2MLWClient::fw_execute_function)); } } } }
void update_resource() { if(_object) { M2MObjectInstance* inst = _object->object_instance(); if(inst) { M2MResource* res = inst->resource("D"); char buffer[20]; int size = sprintf(buffer,"%d",_value); res->set_value((const uint8_t*)buffer, (const uint32_t)size); _value++; } } }
M2MObjectInstance* M2MObject::create_object_instance(uint16_t instance_id) { tr_debug("M2MObject::create_object_instance - id: %d", instance_id); M2MObjectInstance *instance = NULL; if(!object_instance(instance_id)) { instance = new M2MObjectInstance(this->name(),*this); if(instance) { instance->add_observation_level(observation_level()); instance->set_instance_id(instance_id); if(M2MBase::name_id() != -1) { instance->set_coap_content_type(COAP_CONTENT_OMA_TLV_TYPE); } _instance_list.push_back(instance); } } return instance; }
void blink(void *argument) { // read the value of 'Pattern' status_ticker.detach(); green_led = LED_OFF; M2MObjectInstance* inst = led_object->object_instance(); M2MResource* res = inst->resource("5853"); // Clear previous blink data blink_args->clear(); // values in mbed Client are all buffers, and we need a vector of int's uint8_t* buffIn = NULL; uint32_t sizeIn; res->get_value(buffIn, sizeIn); // turn the buffer into a string, and initialize a vector<int> on the heap std::string s((char*)buffIn, sizeIn); free(buffIn); printf("led_execute_callback pattern=%s\n", s.c_str()); // our pattern is something like 500:200:500, so parse that std::size_t found = s.find_first_of(":"); while (found!=std::string::npos) { blink_args->blink_pattern.push_back(atoi((const char*)s.substr(0,found).c_str())); s = s.substr(found+1); found=s.find_first_of(":"); if(found == std::string::npos) { blink_args->blink_pattern.push_back(atoi((const char*)s.c_str())); } } // check if POST contains payload if (argument) { M2MResource::M2MExecuteParameter* param = (M2MResource::M2MExecuteParameter*)argument; String object_name = param->get_argument_object_name(); uint16_t object_instance_id = param->get_argument_object_instance_id(); String resource_name = param->get_argument_resource_name(); int payload_length = param->get_argument_value_length(); uint8_t* payload = param->get_argument_value(); printf("Resource: %s/%d/%s executed\n", object_name.c_str(), object_instance_id, resource_name.c_str()); printf("Payload: %.*s\n", payload_length, payload); } // do_blink is called with the vector, and starting at -1 blinky_thread.start(callback(this, &LedResource::do_blink)); }
void do_blink() { for (;;) { // blink the LED red_led = !red_led; // up the position, if we reached the end of the vector if (blink_args->position >= blink_args->blink_pattern.size()) { // send delayed response after blink is done M2MObjectInstance* inst = led_object->object_instance(); M2MResource* led_res = inst->resource("5850"); led_res->send_delayed_post_response(); red_led = LED_OFF; status_ticker.attach_us(blinky, 250000); return; } // Wait requested time, then continue prosessing the blink pattern from next position. Thread::wait(blink_args->blink_pattern.at(blink_args->position)); blink_args->position++; } }
void update_resource() { if(_object) { M2MObjectInstance* inst = _object->object_instance(); if(inst) { M2MResource* res = inst->resource("1"); res = inst->resource("1"); if(res) { M2MResourceInstance *res_inst = res->resource_instance(0); if(res_inst) { char buffer1[20]; int size1 = sprintf(buffer1,"%d",_value); res_inst->set_value((const uint8_t*)buffer1, (const uint32_t)size1); _value++; } } } } }
/* * When you press the button, we read the current value of the click counter * from mbed Device Connector, then up the value with one. */ void handle_button_click() { if (mbed_client.register_successful()) { M2MObjectInstance* inst = btn_object->object_instance(); M2MResource* res = inst->resource("5501"); // up counter counter++; #ifdef TARGET_K64F printf("handle_button_click, new value of counter is %d\n", counter); #else printf("simulate button_click, new value of counter is %d\n", counter); #endif // serialize the value of counter as a string, and tell connector char buffer[20]; int size = sprintf(buffer,"%d",counter); res->set_value((uint8_t*)buffer, size); } else { printf("simulate button_click, device not registered\n"); } }
// sample the accelerometer every second static void sample(void) { char buffer[24]; accel.getAxis(acc_raw); int len = 0; M2MObjectInstance* ins = obj->object_instance(); // X len = snprintf(buffer,sizeof(buffer), "%d",acc_raw.x); printf("x: %s\r\n",buffer); if (! connected) return; M2MResource* resx = ins->resource("x"); resx->set_value((uint8_t*)buffer,len); // Y len = snprintf(buffer,sizeof(buffer), "%d",acc_raw.y); printf("y: %s\r\n",buffer); if (! connected) return; M2MResource* resy = ins->resource("y"); resy->set_value((uint8_t*)buffer,len); }
void Test_M2MInterfaceImpl::test_register_object() { M2MSecurity *sec = new M2MSecurity(M2MSecurity::M2MServer); m2msecurity_stub::int_value = 2; M2MObject *object = new M2MObject("test"); M2MObjectInstance *ins = object->create_object_instance(); ins->create_dynamic_resource("test","type",M2MResourceInstance::STRING,false,false); M2MObjectList list; list.push_back(object); String *val = new String("coaps://[2001:12:12:23::23:FF]:5685"); m2msecurity_stub::string_value = val; m2mnsdlinterface_stub::bool_value = true; m2mconnectionhandler_stub::bool_value = true; impl->register_object(sec,list); CHECK(impl->_current_state == M2MInterfaceImpl::STATE_REGISTER); impl->_register_ongoing = false; impl->_current_state = M2MInterfaceImpl::STATE_IDLE; impl->register_object(sec,list); CHECK(impl->_current_state == M2MInterfaceImpl::STATE_REGISTER); delete val; val = new String("coaps://[10.45.3.83:5685"); impl->_register_ongoing = false; impl->_current_state = M2MInterfaceImpl::STATE_IDLE; m2msecurity_stub::string_value = val; m2mnsdlinterface_stub::bool_value = true; m2mconnectionhandler_stub::bool_value = true; delete impl->_security; impl->_security = NULL; sec = new M2MSecurity(M2MSecurity::M2MServer); impl->register_object(sec,list); CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE); CHECK(observer->error_occured == true); observer->error_occured = false; delete val; val = new String("coaps://10.45.3.83]:5685"); impl->_register_ongoing = false; impl->_current_state = M2MInterfaceImpl::STATE_IDLE; m2msecurity_stub::string_value = val; m2mnsdlinterface_stub::bool_value = true; m2mconnectionhandler_stub::bool_value = true; delete impl->_security; impl->_security = NULL; sec = new M2MSecurity(M2MSecurity::M2MServer); impl->register_object(sec,list); CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE); CHECK(observer->error_occured == true); observer->error_occured = false; delete val; val = new String("coaps://10.45.3.83:5685"); delete impl->_security; impl->_security = NULL; sec = new M2MSecurity(M2MSecurity::M2MServer); impl->_register_ongoing = false; impl->_current_state = M2MInterfaceImpl::STATE_IDLE; m2msecurity_stub::string_value = val; m2mnsdlinterface_stub::bool_value = true; m2mconnectionhandler_stub::bool_value = true; impl->register_object(sec,list); CHECK(impl->_current_state == M2MInterfaceImpl::STATE_REGISTER); observer->error_occured = false; delete val; val = new String("coap://10.45.3.83:5685"); delete impl->_security; impl->_security = NULL; sec = new M2MSecurity(M2MSecurity::M2MServer); impl->_register_ongoing = false; impl->_current_state = M2MInterfaceImpl::STATE_IDLE; m2msecurity_stub::string_value = val; m2mnsdlinterface_stub::bool_value = true; m2mconnectionhandler_stub::bool_value = true; impl->register_object(sec,list); CHECK(impl->_current_state == M2MInterfaceImpl::STATE_REGISTER); delete val; val = new String("coap://10.45.3.83:5685"); impl->register_object(sec,list); CHECK(impl->_current_state == M2MInterfaceImpl::STATE_REGISTER); impl->_current_state = M2MInterfaceImpl::STATE_IDLE; m2mconnectionhandler_stub::bool_value = true; m2mnsdlinterface_stub::bool_value = false; delete impl->_security; impl->_security = NULL; sec = new M2MSecurity(M2MSecurity::M2MServer); impl->register_object(sec,list); CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE); CHECK(observer->error_occured == true); impl->_current_state = M2MInterfaceImpl::STATE_IDLE; m2mconnectionhandler_stub::bool_value = false; m2mnsdlinterface_stub::bool_value = true; impl->register_object(sec,list); CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE); CHECK(observer->error_occured == true); impl->_register_ongoing = false; impl->_current_state = M2MInterfaceImpl::STATE_BOOTSTRAP; m2mconnectionhandler_stub::bool_value = true; m2mnsdlinterface_stub::bool_value = true; impl->register_object(sec,list); CHECK(impl->_current_state == M2MInterfaceImpl::STATE_BOOTSTRAP); CHECK(observer->error_occured == true); impl->_current_state = M2MInterfaceImpl::STATE_IDLE; m2mconnectionhandler_stub::bool_value = true; m2mnsdlinterface_stub::bool_value = true; impl->register_object(sec,list); CHECK(impl->_current_state == M2MInterfaceImpl::STATE_IDLE); CHECK(observer->error_occured == true); impl->_current_state = M2MInterfaceImpl::STATE_BOOTSTRAP; m2mconnectionhandler_stub::bool_value = true; m2mnsdlinterface_stub::bool_value = true; impl->register_object(sec,list); CHECK(observer->error_occured == true); delete val; val = NULL; list.clear(); delete object; delete sec; }