Important changes to repositories hosted on mbed.com
Mbed hosted mercurial repositories are deprecated and are due to be permanently deleted in July 2026.
To keep a copy of this software download the repository Zip archive or clone locally using Mercurial.
It is also possible to export all your personal repositories from the account settings page.
Dependencies: MAX44000 PWM_Tone_Library nexpaq_mdk
Fork of LED_Demo by
m2mfirmware.cpp
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 #include <cstdio> 00017 #include "mbed-client/m2mfirmware.h" 00018 #include "mbed-client/m2mconstants.h" 00019 #include "mbed-client/m2mobject.h" 00020 #include "mbed-client/m2mobjectinstance.h" 00021 #include "mbed-client/m2mresource.h" 00022 00023 #define BUFFER_SIZE 21 00024 #define TRACE_GROUP "mClt" 00025 00026 M2MFirmware* M2MFirmware::_instance = NULL; 00027 00028 M2MFirmware* M2MFirmware::get_instance() 00029 { 00030 if(_instance == NULL) { 00031 _instance = new M2MFirmware(); 00032 } 00033 return _instance; 00034 } 00035 00036 void M2MFirmware::delete_instance() 00037 { 00038 delete _instance; 00039 _instance = NULL; 00040 } 00041 00042 M2MFirmware::M2MFirmware() 00043 : M2MObject(M2M_FIRMWARE_ID) 00044 { 00045 M2MBase::set_register_uri(false); 00046 M2MBase::set_operation(M2MBase::GET_PUT_ALLOWED); 00047 _firmware_instance = M2MObject::create_object_instance(); 00048 if(_firmware_instance) { 00049 _firmware_instance->set_operation(M2MBase::GET_PUT_ALLOWED); 00050 create_mandatory_resources(); 00051 } 00052 } 00053 00054 M2MFirmware::~M2MFirmware() 00055 { 00056 } 00057 00058 void M2MFirmware::create_mandatory_resources() 00059 { 00060 _firmware_instance->set_coap_content_type(COAP_CONTENT_OMA_TLV_TYPE); 00061 M2MResource* res = _firmware_instance->create_dynamic_resource(FIRMWARE_PACKAGE, 00062 OMA_RESOURCE_TYPE, 00063 M2MResourceInstance::OPAQUE, 00064 false); 00065 if(res) { 00066 res->set_operation(M2MBase::PUT_ALLOWED); 00067 res->set_register_uri(false); 00068 } 00069 00070 res = _firmware_instance->create_dynamic_resource(FIRMWARE_PACKAGE_URI, 00071 OMA_RESOURCE_TYPE, 00072 M2MResourceInstance::STRING, 00073 false); 00074 if(res) { 00075 res->set_operation(M2MBase::PUT_ALLOWED); 00076 res->set_register_uri(false); 00077 } 00078 00079 res = _firmware_instance->create_dynamic_resource(FIRMWARE_UPDATE, 00080 OMA_RESOURCE_TYPE, 00081 M2MResourceInstance::OPAQUE, 00082 false); 00083 if(res) { 00084 res->set_operation(M2MBase::NOT_ALLOWED); 00085 res->set_register_uri(false); 00086 } 00087 00088 res = _firmware_instance->create_dynamic_resource(FIRMWARE_STATE, 00089 OMA_RESOURCE_TYPE, 00090 M2MResourceInstance::INTEGER, 00091 true); 00092 set_zero_value(res); 00093 if(res) { 00094 res->set_operation(M2MBase::GET_ALLOWED); 00095 res->set_register_uri(false); 00096 } 00097 res = _firmware_instance->create_dynamic_resource(FIRMWARE_UPDATE_RESULT, 00098 OMA_RESOURCE_TYPE, 00099 M2MResourceInstance::INTEGER, 00100 true); 00101 set_zero_value(res); 00102 if(res) { 00103 res->set_operation(M2MBase::GET_ALLOWED); 00104 res->set_register_uri(false); 00105 } 00106 } 00107 00108 M2MResource* M2MFirmware::create_resource(FirmwareResource resource, const String &value) 00109 { 00110 M2MResource* res = NULL; 00111 const char* firmware_id_ptr = ""; 00112 M2MBase::Operation operation = M2MBase::GET_ALLOWED; 00113 if(!is_resource_present(resource)) { 00114 switch(resource) { 00115 case PackageName: 00116 firmware_id_ptr = FIRMWARE_PACKAGE_NAME; 00117 break; 00118 case PackageVersion: 00119 firmware_id_ptr = FIRMWARE_PACKAGE_VERSION; 00120 break; 00121 default: 00122 break; 00123 } 00124 } 00125 String firmware_id(firmware_id_ptr); 00126 00127 if(!firmware_id.empty() && value.size() < 256) { 00128 if(_firmware_instance) { 00129 res = _firmware_instance->create_dynamic_resource(firmware_id, 00130 OMA_RESOURCE_TYPE, 00131 M2MResourceInstance::STRING, 00132 false); 00133 00134 if(res) { 00135 res->set_register_uri(false); 00136 res->set_operation(operation); 00137 if(value.empty()) { 00138 res->clear_value(); 00139 } else { 00140 res->set_value((const uint8_t*)value.c_str(), 00141 (uint32_t)value.length()); 00142 } 00143 } 00144 } 00145 } 00146 return res; 00147 } 00148 00149 M2MResource* M2MFirmware::create_resource(FirmwareResource resource, int64_t value) 00150 { 00151 M2MResource* res = NULL; 00152 const char* firmware_id_ptr = ""; 00153 M2MBase::Operation operation = M2MBase::GET_ALLOWED; 00154 if(!is_resource_present(resource)) { 00155 switch(resource) { 00156 case UpdateSupportedObjects: 00157 if(check_value_range(resource, value)) { 00158 firmware_id_ptr = FIRMWARE_UPDATE_SUPPORTED_OBJECTS; 00159 operation = M2MBase::GET_PUT_ALLOWED; 00160 } 00161 break; 00162 default: 00163 break; 00164 } 00165 } 00166 00167 const String firmware_id(firmware_id_ptr); 00168 00169 if(!firmware_id.empty()) { 00170 if(_firmware_instance) { 00171 res = _firmware_instance->create_dynamic_resource(firmware_id, 00172 OMA_RESOURCE_TYPE, 00173 M2MResourceInstance::INTEGER, 00174 false); 00175 00176 if(res) { 00177 res->set_register_uri(false); 00178 00179 res->set_operation(operation); 00180 res->set_value(value); 00181 } 00182 } 00183 } 00184 return res; 00185 } 00186 00187 bool M2MFirmware::set_resource_value(FirmwareResource resource, 00188 const String &value) 00189 { 00190 bool success = false; 00191 M2MResource* res = get_resource(resource); 00192 if(res) { 00193 if(M2MFirmware::PackageUri == resource || 00194 M2MFirmware::PackageName == resource || 00195 M2MFirmware::PackageVersion == resource) { 00196 if (value.size() < 256) { 00197 if(value.empty()) { 00198 res->clear_value(); 00199 success = true; 00200 } else { 00201 success = res->set_value((const uint8_t*)value.c_str(),(uint32_t)value.length()); 00202 } 00203 } 00204 } 00205 } 00206 return success; 00207 } 00208 00209 bool M2MFirmware::set_resource_value(FirmwareResource resource, 00210 int64_t value) 00211 { 00212 bool success = false; 00213 M2MResource* res = get_resource(resource); 00214 if(res) { 00215 if(M2MFirmware::State == resource || 00216 M2MFirmware::UpdateSupportedObjects == resource || 00217 M2MFirmware::UpdateResult == resource) { 00218 // If it is any of the above resource 00219 // set the value of the resource. 00220 if (check_value_range(resource, value)) { 00221 00222 success = res->set_value(value); 00223 } 00224 } 00225 } 00226 return success; 00227 } 00228 00229 bool M2MFirmware::set_resource_value(FirmwareResource resource, 00230 const uint8_t *value, 00231 const uint32_t length) 00232 { 00233 bool success = false; 00234 M2MResource* res = get_resource(resource); 00235 if(res) { 00236 if(M2MFirmware::Package == resource) { 00237 success = res->set_value(value,length); 00238 } 00239 } 00240 return success; 00241 } 00242 00243 bool M2MFirmware::is_resource_present(FirmwareResource resource) const 00244 { 00245 bool success = false; 00246 M2MResource* res = get_resource(resource); 00247 if(res) { 00248 success = true; 00249 } 00250 return success; 00251 } 00252 00253 const String M2MFirmware::resource_name(FirmwareResource resource) 00254 { 00255 const char* res_name = ""; 00256 switch(resource) { 00257 case Package: 00258 res_name = FIRMWARE_PACKAGE; 00259 break; 00260 case PackageUri: 00261 res_name = FIRMWARE_PACKAGE_URI; 00262 break; 00263 case Update: 00264 res_name = FIRMWARE_UPDATE; 00265 break; 00266 case State: 00267 res_name = FIRMWARE_STATE; 00268 break; 00269 case UpdateSupportedObjects: 00270 res_name = FIRMWARE_UPDATE_SUPPORTED_OBJECTS; 00271 break; 00272 case UpdateResult: 00273 res_name = FIRMWARE_UPDATE_RESULT; 00274 break; 00275 case PackageName: 00276 res_name = FIRMWARE_PACKAGE_NAME; 00277 break; 00278 case PackageVersion: 00279 res_name = FIRMWARE_PACKAGE_VERSION; 00280 break; 00281 } 00282 return String(res_name); 00283 } 00284 00285 uint16_t M2MFirmware::per_resource_count(FirmwareResource res) const 00286 { 00287 uint16_t count = 0; 00288 if(_firmware_instance) { 00289 count = _firmware_instance->resource_count(resource_name(res)); 00290 } 00291 return count; 00292 } 00293 00294 uint16_t M2MFirmware::total_resource_count() const 00295 { 00296 uint16_t count = 0; 00297 if(_firmware_instance) { 00298 count = _firmware_instance->resources().size(); 00299 } 00300 return count; 00301 } 00302 00303 uint32_t M2MFirmware::resource_value_buffer(FirmwareResource resource, 00304 uint8_t *&data) const 00305 { 00306 uint32_t size = 0; 00307 M2MResource* res = get_resource(resource); 00308 if(res) { 00309 if(M2MFirmware::Package == resource) { 00310 res->get_value(data,size); 00311 } 00312 } 00313 return size; 00314 } 00315 00316 M2MResource* M2MFirmware::get_resource(FirmwareResource res) const 00317 { 00318 M2MResource* res_object = NULL; 00319 if(_firmware_instance) { 00320 const char* res_name_ptr = ""; 00321 switch(res) { 00322 case Package: 00323 res_name_ptr = FIRMWARE_PACKAGE; 00324 break; 00325 case PackageUri: 00326 res_name_ptr = FIRMWARE_PACKAGE_URI; 00327 break; 00328 case Update: 00329 res_name_ptr = FIRMWARE_UPDATE; 00330 break; 00331 case State: 00332 res_name_ptr = FIRMWARE_STATE; 00333 break; 00334 case UpdateSupportedObjects: 00335 res_name_ptr = FIRMWARE_UPDATE_SUPPORTED_OBJECTS; 00336 break; 00337 case UpdateResult: 00338 res_name_ptr = FIRMWARE_UPDATE_RESULT; 00339 break; 00340 case PackageName: 00341 res_name_ptr = FIRMWARE_PACKAGE_NAME; 00342 break; 00343 case PackageVersion: 00344 res_name_ptr = FIRMWARE_PACKAGE_VERSION; 00345 break; 00346 } 00347 const String res_name(res_name_ptr); 00348 00349 res_object = _firmware_instance->resource(res_name); 00350 } 00351 return res_object; 00352 } 00353 00354 bool M2MFirmware::delete_resource(FirmwareResource resource) 00355 { 00356 bool success = false; 00357 if(M2MFirmware::UpdateSupportedObjects == resource || 00358 M2MFirmware::PackageName == resource || 00359 M2MFirmware::PackageVersion == resource) { 00360 if(_firmware_instance) { 00361 success = _firmware_instance->remove_resource(resource_name(resource)); 00362 } 00363 } 00364 return success; 00365 } 00366 00367 int64_t M2MFirmware::resource_value_int(FirmwareResource resource) const 00368 { 00369 int64_t value = -1; 00370 M2MResource* res = get_resource(resource); 00371 if(res) { 00372 if(M2MFirmware::State == resource || 00373 M2MFirmware::UpdateSupportedObjects == resource || 00374 M2MFirmware::UpdateResult == resource) { 00375 00376 value = res->get_value_int(); 00377 } 00378 } 00379 return value; 00380 } 00381 00382 String M2MFirmware::resource_value_string(FirmwareResource resource) const 00383 { 00384 String value = ""; 00385 M2MResource* res = get_resource(resource); 00386 if(res) { 00387 if(M2MFirmware::PackageUri == resource || 00388 M2MFirmware::PackageName == resource || 00389 M2MFirmware::PackageVersion == resource) { 00390 00391 value = res->get_value_string(); 00392 } 00393 } 00394 return value; 00395 } 00396 00397 bool M2MFirmware::check_value_range(FirmwareResource resource, int64_t value) const 00398 { 00399 bool success = false; 00400 switch (resource) { 00401 case UpdateSupportedObjects: 00402 if(value == 0 || value == 1) { 00403 success = true; 00404 } 00405 break; 00406 case State: 00407 if (value >= 0 && value <= 3) { 00408 success = true; 00409 M2MResource* updateRes = get_resource(M2MFirmware::Update); 00410 if (updateRes){ 00411 if (value == M2MFirmware::Downloaded) { 00412 updateRes->set_operation(M2MBase::POST_ALLOWED); 00413 } 00414 else { 00415 updateRes->set_operation(M2MBase::NOT_ALLOWED); 00416 } 00417 } 00418 } 00419 break; 00420 case UpdateResult: 00421 if (value >= 0 && value <= 7) { 00422 success = true; 00423 } 00424 break; 00425 default: 00426 break; 00427 } 00428 return success; 00429 } 00430 00431 void M2MFirmware::set_zero_value(M2MResource *resource) 00432 { 00433 resource->set_value((const uint8_t*)"0", 1); 00434 }
Generated on Tue Jul 12 2022 12:28:37 by
