This is a mbed Client sample where ZXing is incorporated, and works on GR-PEACH and GR-LYCHEE.
Dependencies: DisplayApp AsciiFont
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-PEACH ( https://developer.mbed.org/platforms/Renesas-GR-PEACH/ )
- Audio Camera Shield ( https://developer.mbed.org/teams/Renesas/wiki/Audio_Camera-shield )
- LCD Shield ( https://developer.mbed.org/teams/Renesas/wiki/LCD-shield )
- Ethernet cable and connection to the internet
- Wireless Camera shieled (This is GR-PEACH' Wifi(ESP32) optional.)
- 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/teams/Renesas/code/GR-PEACH_mbed-os-client-ZXingSample/wiki/Connection-type. - Set the client credentials. For details, please refer to the following wiki:
https://os.mbed.com/teams/Renesas/code/GR-PEACH_mbed-os-client-ZXingSample/wiki/Client-credentials. - Change Ethernet settings. For details, please refer to the following wiki:
https://developer.mbed.org/teams/Renesas/code/GR-PEACH_mbed-os-client-ZXingSample/wiki/Ethernet-settings. - Change Wifi settings. For details, please refer to the following wiki:
https://os.mbed.com/teams/Renesas/code/GR-PEACH_mbed-os-client-ZXingSample/wiki/Wifi-settings. - Set up an IP address. (This step is optional.) For details, please refer to the following wiki:
https://os.mbed.com/teams/Renesas/code/GR-PEACH_mbed-os-client-ZXingSample/wiki/IP-address-setup.
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 Ethernet cable into GR-PEACH or GR-LYCHEE if you are using Ethernet mode.
- 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-PEACH or 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://developer.mbed.org/teams/Renesas/code/GR-PEACH_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 red, green, blue, cyan, yellow and magenta is acceptable if you are using GR-PEACH board (PUT).
- 3201/0/5855. Blink color, used by the blink function. Any of green, yellow, orange and red is acceptable if you are using GR-LYCHEE board (PUT).
For more info on how to get notifications when resource 1 changes, or how to use resource 2, 3 and 4, please look at
Import programGR-PEACH_mbed-connector-ZXingSample-node
Node.js based Web Application for mbed Device Connector specific to GR-PEACH_mbed-os-client-ZXingSample
simpleclient.h
- Committer:
- 1050186
- Date:
- 2018-12-13
- Revision:
- 6:ea24d9271ff1
- Parent:
- 2:6ec5c1c1d41c
File content as of revision 6:ea24d9271ff1:
/* * 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 "mbed-client/m2mblockmessage.h" #include "security.h" #include "mbed.h" #define STRINGIFY(s) #s // EASY_CONNECT_MESH coming via easy-connect #if defined (EASY_CONNECT_MESH) || (MBED_CONF_LWIP_IPV6_ENABLED==true) // Mesh is always IPV6 - also WiFi and ETH can be IPV6 if IPV6 is enabled M2MInterface::NetworkStack NETWORK_STACK = M2MInterface::LwIP_IPv6; #else // Everything else - we assume it's IPv4 M2MInterface::NetworkStack NETWORK_STACK = M2MInterface::LwIP_IPv4; #endif //Select binding mode: UDP or TCP -- note - Mesh networking is IPv6 UDP ONLY #if defined (EASY_CONNECT_MESH) M2MInterface::BindingMode SOCKET_MODE = M2MInterface::UDP; #else // WiFi or Ethernet supports both - TCP by default to avoid // NAT problems, but UDP will also work - IF you configure // your network right. M2MInterface::BindingMode SOCKET_MODE = M2MInterface::TCP; #endif // 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; uint16_t port = 0; // Network interface will randomize with port 0 // 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 NETWORK_STACK, // 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) - 1); security->set_resource_value(M2MSecurity::PublicKey, CERT, sizeof(CERT) - 1); security->set_resource_value(M2MSecurity::Secretkey, KEY, sizeof(KEY) - 1); } 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\nPath : '%s', \r\nType : '%d' (0 for Object, 1 for Resource), \r\nType : '%s'\r\n", base->name(), base->uri_path(), type, base->resource_type() ); } /* * 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__