Mbed Client sample for GR-LYCHEE where ZXing is incorporated.
Dependencies: DisplayApp AsciiFont
Fork of GR-PEACH_mbed-os-client-ZXingSample by
Overview
This sample program shows how to use mbed Client together with ZXing which is an open-source, multi-format 1D/2D barcode image processing library. For more info on ZXing, please refer to https://github.com/zxing/zxing.
Required hardware
- GR-LYCHEE ( https://developer.mbed.org/platforms/Renesas-GR-LYCHEE/ )
Application setup
- Select the connection type. For details, please refer to the following wiki:
https://os.mbed.com/users/1050186/code/GR-LYCHEE_mbed-os-client-ZXingSample/wiki/Connection-type. - Set the client credentials. For details, please refer to the following wiki:
https://os.mbed.com/users/1050186/code/GR-LYCHEE_mbed-os-client-ZXingSample/wiki/Client-credentials. - Change Wifi settings. For details, please refer to the following wiki:
https://os.mbed.com/users/1050186/code/GR-LYCHEE_mbed-os-client-ZXingSample/wiki/Wifi-settings.
Building the example
To build this example:
- Import this example onto mbed Compiler.
- Configure the example in accordance with Application setup.
- Compile the example on mbed Compiler and download the resultant binary file.
- Plug the micro-USB cable into the OpenSDA port which lies on the next to the RESET button.
- Copy the binary previously downloaded to your PC to GR-LYCHEE to flash this example. When the copy is successfully completed, the board is ready to work.
- Press the RESET button on the board to run the example.
- For verification, please refer to the following wiki:
https://os.mbed.com/users/1050186/code/GR-LYCHEE_mbed-os-client-ZXingSample/wiki/Monitoring-the-application.
Application resources
This example exposes four resources listed below:
- 3202/0/5700. Decode result of barcode data input from camera (GET).
- 3201/0/5850. Blink function, blinks LED when executed (POST).
- 3201/0/5853. Blink pattern, used by the blink function to determine how to blink. In the format of 1000:500:1000:500:1000:500 (PUT).
- 3201/0/5855. Blink color, used by the blink function. Any of green, yellow, orange and red is acceptable (PUT).
Diff: simpleclient.h
- Revision:
- 0:eb73febb2bba
- Child:
- 2:6ec5c1c1d41c
diff -r 000000000000 -r eb73febb2bba simpleclient.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/simpleclient.h Thu Oct 06 18:00:30 2016 +0900 @@ -0,0 +1,329 @@ +/* + * 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. + */ + +#ifndef __SIMPLECLIENT_H__ +#define __SIMPLECLIENT_H__ + +#include "mbed-client/m2minterfacefactory.h" +#include "mbed-client/m2mdevice.h" +#include "mbed-client/m2minterfaceobserver.h" +#include "mbed-client/m2minterface.h" +#include "mbed-client/m2mobject.h" +#include "mbed-client/m2mobjectinstance.h" +#include "mbed-client/m2mresource.h" +#include "mbed-client/m2mconfig.h" +#include "security.h" +#include "mbed.h" + +//Select binding mode: UDP or TCP +M2MInterface::BindingMode SOCKET_MODE = M2MInterface::UDP; + +// MBED_DOMAIN and MBED_ENDPOINT_NAME come +// from the security.h file copied from connector.mbed.com + +struct MbedClientDevice { + const char* Manufacturer; + const char* Type; + const char* ModelNumber; + const char* SerialNumber; +}; + +/* +* Wrapper for mbed client stack that handles all callbacks, error handling, and +* other shenanigans to make the mbed client stack easier to use. +* +* The end user should only have to care about configuring the parameters at the +* top of this file and making sure they add the security.h file correctly. +* To add resources you can copy the _TODO__ function and add as many instances as +* you want. +* +*/ +class MbedClient: public M2MInterfaceObserver { +public: + + // constructor for MbedClient object, initialize private variables + MbedClient(struct MbedClientDevice device) { + _interface = NULL; + _bootstrapped = false; + _error = false; + _registered = false; + _unregistered = false; + _register_security = NULL; + _value = 0; + _object = NULL; + _device = device; + } + + // de-constructor for MbedClient object, you can ignore this + ~MbedClient() { + if(_interface) { + delete _interface; + } + if(_register_security){ + delete _register_security; + } + } + + // debug printf function + void trace_printer(const char* str) { + printf("\r\n%s\r\n", str); + } + + /* + * Creates M2MInterface using which endpoint can + * setup its name, resource type, life time, connection mode, + * Currently only LwIPv4 is supported. + */ + void create_interface(const char *server_address, + void *handler=NULL) { + // Randomizing listening port for Certificate mode connectivity + _server_address = server_address; + srand(time(NULL)); + uint16_t port = rand() % 65535 + 12345; + + // create mDS interface object, this is the base object everything else attaches to + _interface = M2MInterfaceFactory::create_interface(*this, + MBED_ENDPOINT_NAME, // endpoint name string + "test", // endpoint type string + 100, // lifetime + port, // listen port + MBED_DOMAIN, // domain string + SOCKET_MODE, // binding mode + M2MInterface::LwIP_IPv4, // network stack + ""); // context address string + const char *binding_mode = (SOCKET_MODE == M2MInterface::UDP) ? "UDP" : "TCP"; + printf("\r\nSOCKET_MODE : %s\r\n", binding_mode); + printf("Connecting to %s\r\n", server_address); + + if(_interface) { + _interface->set_platform_network_handler(handler); + } + + } + + /* + * check private variable to see if the registration was sucessful or not + */ + bool register_successful() { + return _registered; + } + + /* + * check private variable to see if un-registration was sucessful or not + */ + bool unregister_successful() { + return _unregistered; + } + + /* + * Creates register server object with mbed device server address and other parameters + * required for client to connect to mbed device server. + */ + M2MSecurity* create_register_object() { + // create security object using the interface factory. + // this will generate a security ObjectID and ObjectInstance + M2MSecurity *security = M2MInterfaceFactory::create_security(M2MSecurity::M2MServer); + + // make sure security ObjectID/ObjectInstance was created successfully + if(security) { + // Add ResourceID's and values to the security ObjectID/ObjectInstance + security->set_resource_value(M2MSecurity::M2MServerUri, _server_address); + security->set_resource_value(M2MSecurity::SecurityMode, M2MSecurity::Certificate); + security->set_resource_value(M2MSecurity::ServerPublicKey, SERVER_CERT, sizeof(SERVER_CERT)); + security->set_resource_value(M2MSecurity::PublicKey, CERT, sizeof(CERT)); + security->set_resource_value(M2MSecurity::Secretkey, KEY, sizeof(KEY)); + } + return security; + } + + /* + * Creates device object which contains mandatory resources linked with + * device endpoint. + */ + M2MDevice* create_device_object() { + // create device objectID/ObjectInstance + M2MDevice *device = M2MInterfaceFactory::create_device(); + // make sure device object was created successfully + if(device) { + // add resourceID's to device objectID/ObjectInstance + device->create_resource(M2MDevice::Manufacturer, _device.Manufacturer); + device->create_resource(M2MDevice::DeviceType, _device.Type); + device->create_resource(M2MDevice::ModelNumber, _device.ModelNumber); + device->create_resource(M2MDevice::SerialNumber, _device.SerialNumber); + } + return device; + } + + /* + * register an object + */ + void test_register(M2MSecurity *register_object, M2MObjectList object_list){ + if(_interface) { + // Register function + _interface->register_object(register_object, object_list); + } + } + + /* + * unregister all objects + */ + void test_unregister() { + if(_interface) { + // Unregister function + _interface->unregister_object(NULL); // NULL will unregister all objects + } + } + + //Callback from mbed client stack when the bootstrap + // is successful, it returns the mbed Device Server object + // which will be used for registering the resources to + // mbed Device server. + void bootstrap_done(M2MSecurity *server_object){ + if(server_object) { + _bootstrapped = true; + _error = false; + trace_printer("Bootstrapped"); + } + } + + //Callback from mbed client stack when the registration + // is successful, it returns the mbed Device Server object + // to which the resources are registered and registered objects. + void object_registered(M2MSecurity */*security_object*/, const M2MServer &/*server_object*/){ + _registered = true; + _unregistered = false; + trace_printer("Registered object successfully!"); + } + + //Callback from mbed client stack when the unregistration + // is successful, it returns the mbed Device Server object + // to which the resources were unregistered. + void object_unregistered(M2MSecurity */*server_object*/){ + trace_printer("Unregistered Object Successfully"); + _unregistered = true; + _registered = false; + } + + /* + * Callback from mbed client stack when registration is updated + */ + void registration_updated(M2MSecurity */*security_object*/, const M2MServer & /*server_object*/){ + /* The registration is updated automatically and frequently by the + * mbed client stack. This print statement is turned off because it + * tends to happen alot. + */ + //trace_printer("\r\nRegistration Updated\r\n"); + } + + // Callback from mbed client stack if any error is encountered + // during any of the LWM2M operations. Error type is passed in + // the callback. + void error(M2MInterface::Error error){ + _error = true; + switch(error){ + case M2MInterface::AlreadyExists: + trace_printer("[ERROR:] M2MInterface::AlreadyExist"); + break; + case M2MInterface::BootstrapFailed: + trace_printer("[ERROR:] M2MInterface::BootstrapFailed"); + break; + case M2MInterface::InvalidParameters: + trace_printer("[ERROR:] M2MInterface::InvalidParameters"); + break; + case M2MInterface::NotRegistered: + trace_printer("[ERROR:] M2MInterface::NotRegistered"); + break; + case M2MInterface::Timeout: + trace_printer("[ERROR:] M2MInterface::Timeout"); + break; + case M2MInterface::NetworkError: + trace_printer("[ERROR:] M2MInterface::NetworkError"); + break; + case M2MInterface::ResponseParseFailed: + trace_printer("[ERROR:] M2MInterface::ResponseParseFailed"); + break; + case M2MInterface::UnknownError: + trace_printer("[ERROR:] M2MInterface::UnknownError"); + break; + case M2MInterface::MemoryFail: + trace_printer("[ERROR:] M2MInterface::MemoryFail"); + break; + case M2MInterface::NotAllowed: + trace_printer("[ERROR:] M2MInterface::NotAllowed"); + break; + case M2MInterface::SecureConnectionFailed: + trace_printer("[ERROR:] M2MInterface::SecureConnectionFailed"); + break; + case M2MInterface::DnsResolvingFailed: + trace_printer("[ERROR:] M2MInterface::DnsResolvingFailed"); + break; + + default: + break; + } + } + + /* Callback from mbed client stack if any value has changed + * during PUT operation. Object and its type is passed in + * the callback. + * BaseType enum from m2mbase.h + * Object = 0x0, Resource = 0x1, ObjectInstance = 0x2, ResourceInstance = 0x3 + */ + void value_updated(M2MBase *base, M2MBase::BaseType type) { + printf("\r\nPUT Request Received!"); + printf("\r\nName :'%s', \r\nType : '%d' (0 for Object, 1 for Resource), \r\nType : '%s'\r\n", + base->name().c_str(), + type, + base->resource_type().c_str() + ); + } + + /* + * update the registration period + */ + void test_update_register() { + if (_registered) { + _interface->update_registration(_register_security, 100); + } + } + + /* + * manually configure the security object private variable + */ + void set_register_object(M2MSecurity *register_object) { + if (_register_security == NULL) { + _register_security = register_object; + } + } + +private: + + /* + * Private variables used in class + */ + M2MInterface *_interface; + M2MSecurity *_register_security; + M2MObject *_object; + volatile bool _bootstrapped; + volatile bool _error; + volatile bool _registered; + volatile bool _unregistered; + int _value; + struct MbedClientDevice _device; + String _server_address; +}; + +#endif // __SIMPLECLIENT_H__