simple_client.h

00001 /*
00002  * Copyright (c) 2015 ARM Limited. All rights reserved.
00003  * SPDX-License-Identifier: Apache-2.0
00004  * Licensed under the Apache License, Version 2.0 (the License); you may
00005  * not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  * http://www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an AS IS BASIS, WITHOUT
00012  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016  
00017  #ifndef __SIMPLE_CLIENT_H__
00018  #define __SIMPLE_CLIENT_H__
00019  
00020  #include "mbed.h"
00021  #include "security.h"
00022  #include "mbed-client/m2minterfacefactory.h"
00023 #include "mbed-client/m2mdevice.h"
00024 #include "mbed-client/m2minterfaceobserver.h"
00025 #include "mbed-client/m2minterface.h"
00026 #include "mbed-client/m2mobjectinstance.h"
00027 #include "mbed-client/m2mresource.h"
00028 //#include "mbed-client-classic/m2mnetwork.h"
00029 
00030 extern Serial output;
00031 DigitalOut _relay(D5);
00032 DigitalOut status_led(LED1);
00033  
00034 // This is address to mbed Device Connector
00035 const String &MBED_SERVER_ADDRESS = "coap://api.connector.mbed.com:5684";
00036 
00037 const uint8_t STATIC_VALUE[] = "Living Room Outlet"; 
00038 const String &MBED_USER_NAME_DOMAIN = MBED_DOMAIN;
00039 const String &ENDPOINT_NAME = MBED_ENDPOINT_NAME;
00040 const String &MANUFACTURER = "manufacturer";
00041 const String &TYPE = "connected-outlet";
00042 const String &MODEL_NUMBER = "2015";
00043 const String &SERIAL_NUMBER = "12345";
00044 
00045 //Select binding mode: UDP or TCP
00046 M2MInterface::BindingMode SOCKET_MODE = M2MInterface::UDP;
00047 
00048 class MbedClient: public M2MInterfaceObserver {
00049 public:
00050     MbedClient(){
00051         _interface = NULL;
00052         _bootstrapped = false;
00053         _error = false;
00054         _registered = false;
00055         _unregistered = false;
00056         _register_security = NULL;
00057         _value = 0;
00058         _object = NULL;
00059     }
00060 
00061     ~MbedClient() {
00062         if(_interface) {
00063             delete _interface;
00064         }
00065         if(_register_security){
00066             delete _register_security;
00067         }
00068     }
00069 
00070     void trace_printer(const char* str) {
00071         output.printf("\r\n%s\r\n", str);
00072     }
00073 
00074     void create_interface() {
00075         // Creates M2MInterface using which endpoint can
00076         // setup its name, resource type, life time, connection mode,
00077         // Currently only LwIPv4 is supported.
00078 
00079         // Randomizing listening port for Certificate mode connectivity
00080         srand(time(NULL));
00081         uint16_t port = rand() % 65535 + 12345;
00082 
00083         _interface = M2MInterfaceFactory::create_interface(*this,
00084                                                   ENDPOINT_NAME,
00085                                                   TYPE,
00086                                                   3600,
00087                                                   port,
00088                                                   MBED_USER_NAME_DOMAIN,
00089                                                   SOCKET_MODE,
00090                                                   M2MInterface::LwIP_IPv4,
00091                                                   "");
00092     }
00093 
00094     bool register_successful() {
00095         return _registered;
00096     }
00097 
00098     bool unregister_successful() {
00099         return _unregistered;
00100     }
00101 
00102     M2MSecurity* create_register_object() {
00103         // Creates register server object with mbed device server address and other parameters
00104         // required for client to connect to mbed device server.
00105         M2MSecurity *security = M2MInterfaceFactory::create_security(M2MSecurity::M2MServer);
00106         if(security) {
00107             security->set_resource_value(M2MSecurity::M2MServerUri, MBED_SERVER_ADDRESS);
00108             security->set_resource_value(M2MSecurity::SecurityMode, M2MSecurity::Certificate);
00109             security->set_resource_value(M2MSecurity::ServerPublicKey,SERVER_CERT,sizeof(SERVER_CERT));
00110             security->set_resource_value(M2MSecurity::PublicKey,CERT,sizeof(CERT));
00111             security->set_resource_value(M2MSecurity::Secretkey,KEY,sizeof(KEY));
00112         }
00113         return security;
00114     }
00115 
00116     M2MDevice* create_device_object() {
00117         // Creates device object which contains mandatory resources linked with
00118         // device endpoint.
00119         M2MDevice *device = M2MInterfaceFactory::create_device();
00120         if(device) {
00121             device->create_resource(M2MDevice::Manufacturer,MANUFACTURER);
00122             device->create_resource(M2MDevice::DeviceType,TYPE);
00123             device->create_resource(M2MDevice::ModelNumber,MODEL_NUMBER);
00124             device->create_resource(M2MDevice::SerialNumber,SERIAL_NUMBER);
00125         }
00126         return device;
00127     }
00128     
00129     // PUT callback FN
00130     void Ecallback(void *input){
00131         //output.printf("Put Triggered!\n");
00132         //output.printf("\tData: %d, 0x%x, %f, '%s'\n",*(int *)input, *(int *)input , *(float *)input, (char *)input);
00133         int x = *(char *)input;
00134         if(x == '1'){
00135             status_led = 0;
00136             _relay = 1;    
00137         } else{
00138             status_led = 1;
00139             _relay = 0;    
00140         }
00141         //status_led = x;
00142         //status_led = !status_led;   
00143         //_relay = !_relay;
00144         //_relay = (int *)input;
00145     }
00146     
00147     M2MObject* create_generic_object() {
00148         _object = M2MInterfaceFactory::create_object("Test");
00149         if(_object) {
00150             M2MObjectInstance* inst = _object->create_object_instance();
00151             if(inst) {
00152                     M2MResource* res = inst->create_dynamic_resource("E",
00153                                                                      "LightControl",
00154                                                                      M2MResourceInstance::INTEGER,
00155                                                                      true);
00156                     char buffer[20];
00157                     int size = sprintf(buffer,"%d",_value);
00158                     res->set_operation(M2MBase::GET_PUT_POST_ALLOWED);
00159                     res->set_value((const uint8_t*)buffer,
00160                                    (const uint32_t)size);
00161                     //res->set_execute_function(&Ecallback);
00162                     res->set_execute_function(execute_callback (this, &MbedClient::Ecallback));
00163                     _value++;
00164 
00165                     inst->create_static_resource("N",
00166                                                  "Name",
00167                                                  M2MResourceInstance::STRING,
00168                                                  STATIC_VALUE,
00169                                                  sizeof(STATIC_VALUE)-1);
00170                                                  
00171                     M2MResource* res2 = inst->create_dynamic_resource("C",
00172                                                                      "effective-current-ma",
00173                                                                      M2MResourceInstance::INTEGER,
00174                                                                      true);
00175                     char buffer2[20];
00176                     int size2 = sprintf(buffer2,"%d",_value2);
00177                     res2->set_operation(M2MBase::GET_ALLOWED);
00178                     res2->set_value((const uint8_t*)buffer2,
00179                                    (const uint32_t)size2);
00180             }
00181         }
00182         return _object;
00183     }
00184 
00185     void updateCurrent(float current_ma){
00186         if(_object) {
00187             M2MObjectInstance* inst = _object->object_instance();
00188             if(inst) {
00189                     M2MResource* res = inst->resource("C");
00190 
00191                     char buffer[20];
00192                     int x = current_ma;
00193                     int size = sprintf(buffer,"%f",current_ma);
00194                     res->set_value((const uint8_t*)buffer,
00195                                    (const uint32_t)size);
00196                     _value2 = current_ma;
00197                 }
00198         }
00199     }
00200 
00201     void update_resource() {
00202         if(_object) {
00203             M2MObjectInstance* inst = _object->object_instance();
00204             if(inst) {
00205                     M2MResource* res = inst->resource("D");
00206 
00207                     char buffer[20];
00208                     int size = sprintf(buffer,"%d",_value);
00209                     res->set_value((const uint8_t*)buffer,
00210                                    (const uint32_t)size);
00211                     _value++;
00212                 }
00213         }
00214     }
00215 
00216     void test_register(M2MSecurity *register_object, M2MObjectList object_list){
00217         if(_interface) {
00218             // Register function
00219             _interface->register_object(register_object, object_list);
00220         }
00221     }
00222 
00223     void test_unregister() {
00224         if(_interface) {
00225             // Unregister function
00226             _interface->unregister_object(NULL);
00227         }
00228     }
00229 
00230     //Callback from mbed client stack when the bootstrap
00231     // is successful, it returns the mbed Device Server object
00232     // which will be used for registering the resources to
00233     // mbed Device server.
00234     void bootstrap_done(M2MSecurity *server_object){
00235         if(server_object) {
00236             _bootstrapped = true;
00237             _error = false;
00238             trace_printer("\nBootstrapped\n");
00239         }
00240     }
00241 
00242     //Callback from mbed client stack when the registration
00243     // is successful, it returns the mbed Device Server object
00244     // to which the resources are registered and registered objects.
00245     void object_registered(M2MSecurity */*security_object*/, const M2MServer &/*server_object*/){
00246         _registered = true;
00247         _unregistered = false;
00248         trace_printer("\nRegistered\n");
00249     }
00250 
00251     //Callback from mbed client stack when the unregistration
00252     // is successful, it returns the mbed Device Server object
00253     // to which the resources were unregistered.
00254     void object_unregistered(M2MSecurity */*server_object*/){
00255         _unregistered = true;
00256         _registered = false;
00257         trace_printer("\nUnregistered\n");
00258     }
00259 
00260     void registration_updated(M2MSecurity */*security_object*/, const M2MServer & /*server_object*/){
00261     }
00262 
00263     //Callback from mbed client stack if any error is encountered
00264     // during any of the LWM2M operations. Error type is passed in
00265     // the callback.
00266     void error(M2MInterface::Error error){
00267         _error = true;
00268         switch(error){
00269             case M2MInterface::AlreadyExists:
00270                 trace_printer("[ERROR:] M2MInterface::AlreadyExists\n");
00271                 break;
00272             case M2MInterface::BootstrapFailed:
00273                 trace_printer("[ERROR:] M2MInterface::BootstrapFailed\n");
00274                 break;
00275             case M2MInterface::InvalidParameters:
00276                 trace_printer("[ERROR:] M2MInterface::InvalidParameters\n");
00277                 break;
00278             case M2MInterface::NotRegistered:
00279                 trace_printer("[ERROR:] M2MInterface::NotRegistered\n");
00280                 break;
00281             case M2MInterface::Timeout:
00282                 trace_printer("[ERROR:] M2MInterface::Timeout\n");
00283                 break;
00284             case M2MInterface::NetworkError:
00285                 trace_printer("[ERROR:] M2MInterface::NetworkError\n");
00286                 break;
00287             case M2MInterface::ResponseParseFailed:
00288                 trace_printer("[ERROR:] M2MInterface::ResponseParseFailed\n");
00289                 break;
00290             case M2MInterface::UnknownError:
00291                 trace_printer("[ERROR:] M2MInterface::UnknownError\n");
00292                 break;
00293             case M2MInterface::MemoryFail:
00294                 trace_printer("[ERROR:] M2MInterface::MemoryFail\n");
00295                 break;
00296             case M2MInterface::NotAllowed:
00297                 trace_printer("[ERROR:] M2MInterface::NotAllowed\n");
00298                 break;
00299             default:
00300                 break;
00301         }
00302     }
00303 
00304     //Callback from mbed client stack if any value has changed
00305     // during PUT operation. Object and its type is passed in
00306     // the callback.
00307     void value_updated(M2MBase *base, M2MBase::BaseType type) {
00308         output.printf("\nValue updated of Object name %s and Type %d\n",
00309                base->name().c_str(), type);
00310     }
00311 
00312     void test_update_register() {
00313         if (_registered) {
00314             _interface->update_registration(_register_security, 3600);
00315         }
00316     }
00317 
00318    void set_register_object(M2MSecurity *register_object) {
00319         if (_register_security == NULL) {
00320             _register_security = register_object;
00321         }
00322     }
00323     
00324 private:
00325 
00326     M2MInterface        *_interface;
00327     M2MSecurity         *_register_security;
00328     M2MObject           *_object;
00329     volatile bool       _bootstrapped;
00330     volatile bool       _error;
00331     volatile bool       _registered;
00332     volatile bool       _unregistered;
00333     int                 _value;
00334     int                 _value2;
00335 };
00336 
00337 #endif // __SIMPLE_CLIENT_H__