mbed official
mbed library sources. Supersedes mbed-src.
Dependents: Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more
Embed:
(wiki syntax)
Show/hide line numbers
mbed_error.h
00001 /** \addtogroup platform */ 00002 /** @{*/ 00003 /** 00004 * \defgroup platform_error Error functions 00005 * @{ 00006 */ 00007 /* mbed Microcontroller Library 00008 * Copyright (c) 2006-2013 ARM Limited 00009 * SPDX-License-Identifier: Apache-2.0 00010 * 00011 * Licensed under the Apache License, Version 2.0 (the "License"); 00012 * you may not use this file except in compliance with the License. 00013 * You may obtain a copy of the License at 00014 * 00015 * http://www.apache.org/licenses/LICENSE-2.0 00016 * 00017 * Unless required by applicable law or agreed to in writing, software 00018 * distributed under the License is distributed on an "AS IS" BASIS, 00019 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 00020 * See the License for the specific language governing permissions and 00021 * limitations under the License. 00022 */ 00023 #ifndef MBED_ERROR_H 00024 #define MBED_ERROR_H 00025 00026 #include "platform/mbed_retarget.h" 00027 #include "platform/mbed_toolchain.h" 00028 00029 #ifdef __cplusplus 00030 extern "C" { 00031 #endif 00032 00033 /** Define this macro to include filenames in error context. For release builds, do not include filename to save memory. 00034 * MBED_PLATFORM_CONF_ERROR_FILENAME_CAPTURE_ENABLED 00035 */ 00036 00037 /** Define this macro to enable error history 00038 * MBED_PLATFORM_CONF_ERROR_HIST_ENABLED 00039 */ 00040 00041 #ifndef MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN 00042 #define MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN 16 00043 #else //MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN 00044 #if MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN > 64 00045 //We have to limit this to 64 bytes since we use mbed_error_printf for error reporting 00046 //and mbed_error_vprintf uses 128bytes internal buffer which may not be sufficient for anything 00047 //longer that 64 bytes with the current implementation. 00048 #error "Unsupported error filename buffer length detected, max supported length is 64 chars. Please change MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN or max-error-filename-len in configuration." 00049 #endif 00050 #endif 00051 00052 #define MBED_ERROR_STATUS_CODE_MASK (0x0000FFFF) 00053 #define MBED_ERROR_STATUS_CODE_POS (0) 00054 #define MBED_ERROR_STATUS_CODE_FIELD_SIZE (16) 00055 00056 #define MBED_ERROR_STATUS_MODULE_MASK (0x00FF0000) 00057 #define MBED_ERROR_STATUS_MODULE_POS (16) 00058 #define MBED_ERROR_STATUS_MODULE_FIELD_SIZE (8) 00059 00060 #define MBED_ERROR_STATUS_TYPE_MASK (0x60000000) 00061 #define MBED_ERROR_STATUS_TYPE_POS (29) 00062 #define MBED_ERROR_STATUS_TYPE_FIELD_SIZE (2) 00063 00064 /* mbed_error_status_t Status Encoding */ 00065 //|31(1 bit) Always Negative|30-29(2 bits) |28-24 | 23-16(8 bits) | 15-0(16 bits) | 00066 //|-1 |TYPE |(unused/reserved) | MODULE TYPE | ERROR CODE | 00067 00068 #define MAKE_MBED_ERROR(type, module, error_code) (mbed_error_status_t) \ 00069 ((0x80000000) | \ 00070 (MBED_ERROR_STATUS_CODE_MASK & (error_code << MBED_ERROR_STATUS_CODE_POS)) | \ 00071 (MBED_ERROR_STATUS_MODULE_MASK & (module << MBED_ERROR_STATUS_MODULE_POS)) | \ 00072 (MBED_ERROR_STATUS_TYPE_MASK & (type << MBED_ERROR_STATUS_TYPE_POS))) 00073 00074 #define MBED_GET_ERROR_TYPE( error_status ) ((error_status & MBED_ERROR_STATUS_TYPE_MASK) >> MBED_ERROR_STATUS_TYPE_POS) 00075 #define MBED_GET_ERROR_MODULE( error_status ) ((error_status & MBED_ERROR_STATUS_MODULE_MASK) >> MBED_ERROR_STATUS_MODULE_POS) 00076 #define MBED_GET_ERROR_CODE( error_status ) (int)((MBED_GET_ERROR_TYPE( error_status ) == MBED_ERROR_TYPE_POSIX)?(-error_status):((error_status & MBED_ERROR_STATUS_CODE_MASK) >> MBED_ERROR_STATUS_CODE_POS)) 00077 00078 /** mbed_error_status_t description 00079 * 00080 * mbed_error_status_t type represents the error status values under MbedOS. mbed_error_status_t values are signed integers and always be negative.\n 00081 * Internally its encoded as below with bit-fields representing error type, module and error code:\n\n 00082 * mbed_error_status_t Status Encoding:\n 00083 * 00084 \verbatim 00085 | 31 Always Negative | 30-29(2 bits) | 28-24 | 23-16(8 bits) | 15-0(16 bits) | 00086 | -1 | TYPE | (unused/reserved) | MODULE TYPE | ERROR CODE | 00087 \endverbatim 00088 * 00089 * The error status value range for each error type is as follows:\n 00090 * POSIX Error Status-es - 0xFFFFFFFF to 0xFFFFFF01(-1 -255) - This corresponds to POSIX error codes represented as negative.\n 00091 * System Error Status-es - 0x80XX0100 to 0x80XX0FFF - This corresponds to System error codes range(all values are negative). Bits 23-16 will be module type(marked with XX)\n 00092 * Custom Error Status-es - 0xA0XX1000 to 0xA0XXFFFF - This corresponds to Custom error codes range(all values are negative). Bits 23-16 will be module type(marked with XX)\n\n 00093 * 00094 * The ERROR CODE(values encoded into ERROR CODE bit-field in mbed_error_status_t) value range for each error type is also separated as below:\n 00095 * POSIX Error Codes - 1 to 255.\n 00096 * System Error Codes - 256 to 4095.\n 00097 * Custom Error Codes - 4096 to 65535.\n 00098 * 00099 * @note POSIX error codes are always encoded as negative of their actual value. For example, EPERM is encoded as -EPERM. 00100 * And, the MODULE TYPE for POSIX error codes are always encoded as MBED_MODULE_UNKNOWN.\n 00101 * This is to enable easy injection of POSIX error codes into MbedOS error handling system without altering the actual POSIX error values.\n 00102 * Accordingly, POSIX error codes are represented as -1 to -255 under MbedOS error status representation. 00103 */ 00104 typedef int mbed_error_status_t; 00105 00106 /** 00107 * Macro for defining a POSIX error status. This macro is mainly used to define POSIX error values in mbed_error_code_t enumeration. 00108 * @param error_name Name of the error without the ERROR_ prefix 00109 * @param error_code Error code value to be used, must be between 1 and 255(inclusive). 00110 * 00111 */ 00112 #define MBED_DEFINE_POSIX_ERROR( error_name, error_code ) \ 00113 MBED_ERROR_CODE_##error_name = error_code, \ 00114 MBED_ERROR_##error_name = -(MBED_POSIX_ERROR_BASE + error_code) 00115 00116 /** 00117 * Macro for defining a System error status. This macro is used to define System error values in mbed_error_code_t enumeration. 00118 * @param error_name Name of the error without the ERROR_ prefix 00119 * @param error_code Error code value to be used, must be between 256 and 4096(inclusive). 00120 * 00121 */ 00122 #define MBED_DEFINE_SYSTEM_ERROR( error_name, error_code ) \ 00123 MBED_ERROR_CODE_##error_name = MBED_SYSTEM_ERROR_BASE + error_code, \ 00124 MBED_ERROR_##error_name = MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, MBED_MODULE_UNKNOWN, MBED_ERROR_CODE_##error_name) 00125 00126 /** 00127 * Macro for defining a Custom error status. This macro is used to define custom error values in mbed_error_code_t enumeration. 00128 * @param error_name Name of the error without the ERROR_ prefix 00129 * @param error_code Error code value to be used, must be between 4097 and 65535(inclusive). 00130 * 00131 */ 00132 #define MBED_DEFINE_CUSTOM_ERROR( error_name, error_code ) \ 00133 MBED_ERROR_CODE_##error_name = MBED_CUSTOM_ERROR_BASE + error_code, \ 00134 MBED_ERROR_##error_name = MAKE_MBED_ERROR(MBED_ERROR_TYPE_CUSTOM, MBED_MODULE_UNKNOWN, MBED_ERROR_CODE_##error_name) 00135 00136 00137 /** 00138 * Macros for setting a system warning. These macros will log the error, Its a wrapper for calling mbed_warning API. 00139 * There are 2 versions of this macro. MBED_WARNING takes status and message. MBED_WARNING1 takes an additional context specific argument 00140 * @param error_status mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values). 00141 * @param error_msg The error message to be printed out to STDIO/Serial. 00142 * @param error_value Value associated with the error status. This would depend on error code/error scenario. 00143 * 00144 * @code 00145 * 00146 * MBED_WARNING( ERROR_INVALID_SIZE, "MyDriver: Invalid size in read" ) 00147 * MBED_WARNING1( ERROR_INVALID_SIZE, "MyDriver: Invalid size in read", size_val ) 00148 * 00149 * @endcode 00150 * @note The macro calls mbed_warning API with filename and line number info without caller explicitly passing them. 00151 * Since this macro is a wrapper for mbed_warning API callers should process the return value from this macro which is the return value from calling mbed_error API. 00152 * 00153 */ 00154 #ifdef NDEBUG 00155 #define MBED_WARNING1( error_status, error_msg, error_value ) mbed_warning( error_status, (const char *)NULL, (uint32_t)error_value, NULL, 0 ) 00156 #define MBED_WARNING( error_status, error_msg ) mbed_warning( error_status, (const char *)NULL, (uint32_t)0, NULL, 0 ) 00157 #else //NDEBUG 00158 #if MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED 00159 #define MBED_WARNING1( error_status, error_msg, error_value ) mbed_warning( error_status, (const char *)error_msg, (uint32_t)error_value, (const char *)MBED_FILENAME, __LINE__ ) 00160 #define MBED_WARNING( error_status, error_msg ) mbed_warning( error_status, (const char *)error_msg, (uint32_t)0 , (const char *)MBED_FILENAME, __LINE__ ) 00161 #else //MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED 00162 #define MBED_WARNING1( error_status, error_msg, error_value ) mbed_warning( error_status, (const char *)error_msg, (uint32_t)error_value, NULL, 0 ) 00163 #define MBED_WARNING( error_status, error_msg ) mbed_warning( error_status, (const char *)error_msg, (uint32_t)0, NULL, 0 ) 00164 #endif 00165 #endif 00166 00167 /** 00168 * Macros for setting a fatal system error. These macros will log the error, prints the error report and halts the system. Its a wrapper for calling mbed_error API. 00169 * There are 2 versions of this macro. MBED_ERROR takes status and message. MBED_ERROR1 takes an additional context specific argument 00170 * @param error_status mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values). 00171 * @param error_msg The error message to be printed out to STDIO/Serial. 00172 * @param error_value Value associated with the error status. This would depend on error code/error scenario. Only available with MBED_ERROR1 00173 * @return Does not return 00174 * 00175 * @code 00176 * 00177 * MBED_ERROR( MBED_ERROR_MUTEX_LOCK_FAILED, "MyDriver: Can't lock driver Mutex" ) 00178 * MBED_ERROR1( MBED_ERROR_MUTEX_LOCK_FAILED, "MyDriver: Can't lock driver Mutex", &my_mutex ) 00179 * 00180 * @endcode 00181 * @note The macro calls mbed_error API with filename and line number info without caller explicitly passing them. 00182 * Since this macro is a wrapper for mbed_error API callers should process the return value from this macro which is the return value from calling mbed_error API. 00183 * 00184 */ 00185 #ifdef NDEBUG 00186 #define MBED_ERROR1( error_status, error_msg, error_value ) mbed_error( error_status, (const char *)NULL, (uint32_t)error_value, NULL, 0 ) 00187 #define MBED_ERROR( error_status, error_msg ) mbed_error( error_status, (const char *)NULL, (uint32_t)0 , NULL, 0 ) 00188 #else //NDEBUG 00189 #if MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED 00190 #define MBED_ERROR1( error_status, error_msg, error_value ) mbed_error( error_status, (const char *)error_msg, (uint32_t)error_value, (const char *)MBED_FILENAME, __LINE__ ) 00191 #define MBED_ERROR( error_status, error_msg ) mbed_error( error_status, (const char *)error_msg, (uint32_t)0 , (const char *)MBED_FILENAME, __LINE__ ) 00192 #else //MBED_CONF_PLATFORM_ERROR_FILENAME_CAPTURE_ENABLED 00193 #define MBED_ERROR1( error_status, error_msg, error_value ) mbed_error( error_status, (const char *)error_msg, (uint32_t)error_value, NULL, 0 ) 00194 #define MBED_ERROR( error_status, error_msg ) mbed_error( error_status, (const char *)error_msg, (uint32_t)0 , NULL, 0 ) 00195 #endif 00196 #endif 00197 00198 //Error Type definition 00199 /** mbed_error_type_t definition 00200 * @note 00201 * This enumeration defines the Error types supported. The value of these enum values will be encoded into mbed_error_status_t TYPE field.\n 00202 * See mbed_error_status_t description for more info.\n 00203 * MBED_ERROR_TYPE_SYSTEM - Used to indicate that the error status is of System defined Error type.\n 00204 * MBED_ERROR_TYPE_CUSTOM - Used to indicate that the error status is of Custom defined Error type.\n 00205 * MBED_ERROR_TYPE_POSIX - Used to indicate that the error status is of POSIX error type.\n 00206 * 00207 */ 00208 typedef enum _mbed_error_type_t { 00209 MBED_ERROR_TYPE_SYSTEM = 0, 00210 MBED_ERROR_TYPE_CUSTOM = 1, 00211 //2 is reserved 00212 //Use 3 for POSIX because we are mapping -1 to -255 to POSIX error codes 00213 //and thus we must use 3 to match the type bits in error status representation which are from 0xFFFFFFFF to 0xFFFFFF00 00214 MBED_ERROR_TYPE_POSIX = 3 00215 } mbed_error_type_t; 00216 00217 //Module type/id definitions 00218 /** mbed_module_type_t definition 00219 * @note 00220 * This enumeration defines the module types. The value of these enum values will be encoded into mbed_error_status_t MODULE field.\n\n 00221 * See mbed_error_status_t description for more info.\n 00222 * MBED_MODULE_UNKNOWN - This module type can be used if caller of the mbed_error/mbed_warning doesn't know who is the actual originator of the error.\n 00223 * Other module values can be used to provide more info on who/where the error originated from.\n\n 00224 * For example, if I2C driver is the component originating the error you can use MBED_MODULE_DRIVER_I2C to provide more info.\n 00225 * Its used in call to MBED_MAKE_ERROR/MBED_MAKE_SYSTEM_ERROR/MBED_MAKE_CUSTOM_ERROR macros.\n 00226 * 00227 * @code 00228 * Example: mbed_error_status_t i2c_driver_error = MBED_MAKE_ERROR( MBED_MODULE_DRIVER_I2C, MBED_ERROR_CONFIG_UNSUPPORTED ); 00229 * @endcode 00230 * 00231 * @note 00232 * \n Below are the module code mappings:\n 00233 \verbatim 00234 MBED_MODULE_APPLICATION 0 Application 00235 MBED_MODULE_PLATFORM 1 Platform 00236 MBED_MODULE_KERNEL 2 RTX Kernel 00237 MBED_MODULE_NETWORK_STACK 3 Network stack 00238 MBED_MODULE_HAL 4 HAL - Hardware Abstraction Layer 00239 MBED_MODULE_MEMORY_SUBSYSTEM 5 Memory Subsystem 00240 MBED_MODULE_FILESYSTEM 6 Filesystem 00241 MBED_MODULE_BLOCK_DEVICE 7 Block device 00242 MBED_MODULE_DRIVER 8 Driver 00243 MBED_MODULE_DRIVER_SERIAL 9 Serial Driver 00244 MBED_MODULE_DRIVER_RTC 10 RTC Driver 00245 MBED_MODULE_DRIVER_I2C 11 I2C Driver 00246 MBED_MODULE_DRIVER_SPI 12 SPI Driver 00247 MBED_MODULE_DRIVER_GPIO 13 GPIO Driver 00248 MBED_MODULE_DRIVER_ANALOG 14 Analog Driver 00249 MBED_MODULE_DRIVER_DIGITAL 15 DigitalIO Driver 00250 MBED_MODULE_DRIVER_CAN 16 CAN Driver 00251 MBED_MODULE_DRIVER_ETHERNET 17 Ethernet Driver 00252 MBED_MODULE_DRIVER_CRC 18 CRC Module 00253 MBED_MODULE_DRIVER_PWM 19 PWM Driver 00254 MBED_MODULE_DRIVER_QSPI 20 QSPI Driver 00255 MBED_MODULE_DRIVER_USB 21 USB Driver 00256 MBED_MODULE_TARGET_SDK 22 SDK 00257 MBED_MODULE_BLE 23 BLE 00258 MBED_MODULE_NETWORK_STATS 24 Network Statistics 00259 00260 MBED_MODULE_UNKNOWN 255 Unknown module 00261 \endverbatim 00262 * 00263 */ 00264 typedef enum _mbed_module_type { 00265 MBED_MODULE_APPLICATION = 0, 00266 MBED_MODULE_PLATFORM, 00267 MBED_MODULE_KERNEL, 00268 MBED_MODULE_NETWORK_STACK, 00269 MBED_MODULE_HAL, 00270 MBED_MODULE_MEMORY_SUBSYSTEM, 00271 MBED_MODULE_FILESYSTEM, 00272 MBED_MODULE_BLOCK_DEVICE, 00273 MBED_MODULE_DRIVER, 00274 MBED_MODULE_DRIVER_SERIAL, 00275 MBED_MODULE_DRIVER_RTC, 00276 MBED_MODULE_DRIVER_I2C, 00277 MBED_MODULE_DRIVER_SPI, 00278 MBED_MODULE_DRIVER_GPIO, 00279 MBED_MODULE_DRIVER_ANALOG, 00280 MBED_MODULE_DRIVER_DIGITAL, 00281 MBED_MODULE_DRIVER_CAN, 00282 MBED_MODULE_DRIVER_ETHERNET, 00283 MBED_MODULE_DRIVER_CRC, 00284 MBED_MODULE_DRIVER_PWM, 00285 MBED_MODULE_DRIVER_QSPI, 00286 MBED_MODULE_DRIVER_USB, 00287 MBED_MODULE_TARGET_SDK, 00288 MBED_MODULE_BLE, 00289 MBED_MODULE_NETWORK_STATS, 00290 /* Add More entities here as required */ 00291 00292 MBED_MODULE_UNKNOWN = 255, 00293 MBED_MODULE_MAX = MBED_MODULE_UNKNOWN 00294 } mbed_module_type_t; 00295 00296 //Use MBED_SUCCESS(=0) or any positive number for successful returns 00297 #define MBED_SUCCESS 0 00298 00299 #define MBED_POSIX_ERROR_BASE 0 00300 #define MBED_SYSTEM_ERROR_BASE 256 00301 #define MBED_CUSTOM_ERROR_BASE 4096 00302 00303 //Error Code definitions 00304 /** mbed_error_code_t definition 00305 * 00306 * mbed_error_code_t enumeration defines the Error codes and Error status values for MBED_MODULE_UNKNOWN.\n 00307 * It defines all of POSIX Error Codes/Statuses and Mbed System Error Codes/Statuses.\n\n 00308 * 00309 * @note 00310 * POSIX Error codes are defined using the macro MBED_DEFINE_POSIX_ERROR\n 00311 * For example MBED_DEFINE_POSIX_ERROR( EPERM, EPERM ). This effectively defines the following values:\n 00312 * ERROR_CODE_EPERM = EPERM\n 00313 * ERROR_EPERM = -EPERM\n 00314 * 00315 * POSIX Error codes are defined using the macro MBED_DEFINE_POSIX_ERROR\n 00316 * For example MBED_DEFINE_POSIX_ERROR( EPERM, EPERM ). This macro defines the following values:\n 00317 * ERROR_CODE_EPERM = MBED_POSIX_ERROR_BASE+EPERM\n 00318 * ERROR_EPERM = -(MBED_POSIX_ERROR_BASE+EPERM)\n 00319 * Its effectively equivalent to:\n 00320 * ERROR_CODE_EPERM = 1\n 00321 * ERROR_EPERM = -1\n 00322 * All POSIX error codes currently supported by MbedOS(defined in mbed_retarget.h) are defined using the MBED_DEFINE_POSIX_ERROR macro.\n\n 00323 * Below are the POSIX error codes and the description:\n 00324 * \verbatim 00325 EPERM 1 Operation not permitted 00326 ENOENT 2 No such file or directory 00327 ESRCH 3 No such process 00328 EINTR 4 Interrupted system call 00329 EIO 5 I/O error 00330 ENXIO 6 No such device or address 00331 E2BIG 7 Argument list too long 00332 ENOEXEC 8 Exec format error 00333 EBADF 9 Bad file number 00334 ECHILD 10 No child processes 00335 EAGAIN 11 Try again 00336 ENOMEM 12 Out of memory 00337 EACCES 13 Permission denied 00338 EFAULT 14 Bad address 00339 ENOTBLK 15 Block device required 00340 EBUSY 16 Device or resource busy 00341 EEXIST 17 File exists 00342 EXDEV 18 Cross-device link 00343 ENODEV 19 No such device 00344 ENOTDIR 20 Not a directory 00345 EISDIR 21 Is a directory 00346 EINVAL 22 Invalid argument 00347 ENFILE 23 File table overflow 00348 EMFILE 24 Too many open files 00349 ENOTTY 25 Not a typewriter 00350 ETXTBSY 26 Text file busy 00351 EFBIG 27 File too large 00352 ENOSPC 28 No space left on device 00353 ESPIPE 29 Illegal seek 00354 EROFS 30 Read-only file system 00355 EMLINK 31 Too many links 00356 EPIPE 32 Broken pipe 00357 EDOM 33 Math argument out of domain of func 00358 ERANGE 34 Math result not representable 00359 EDEADLK 35 Resource deadlock would occur 00360 ENAMETOOLONG 36 File name too long 00361 ENOLCK 37 No record locks available 00362 ENOSYS 38 Function not implemented 00363 ENOTEMPTY 39 Directory not empty 00364 ELOOP 40 Too many symbolic links encountered 00365 EWOULDBLOCK EAGAIN Operation would block 00366 ENOMSG 42 No message of desired type 00367 EIDRM 43 Identifier removed 00368 ECHRNG 44 Channel number out of range 00369 EL2NSYNC 45 Level 2 not synchronized 00370 EL3HLT 46 Level 3 halted 00371 EL3RST 47 Level 3 reset 00372 ELNRNG 48 Link number out of range 00373 EUNATCH 49 Protocol driver not attached 00374 ENOCSI 50 No CSI structure available 00375 EL2HLT 51 Level 2 halted 00376 EBADE 52 Invalid exchange 00377 EBADR 53 Invalid request descriptor 00378 EXFULL 54 Exchange full 00379 ENOANO 55 No anode 00380 EBADRQC 56 Invalid request code 00381 EBADSLT 57 Invalid slot 00382 EDEADLOCK EDEADLK Resource deadlock would occur 00383 EBFONT 59 Bad font file format 00384 ENOSTR 60 Device not a stream 00385 ENODATA 61 No data available 00386 ETIME 62 Timer expired 00387 ENOSR 63 Out of streams resources 00388 ENONET 64 Machine is not on the network 00389 ENOPKG 65 Package not installed 00390 EREMOTE 66 Object is remote 00391 ENOLINK 67 Link has been severed 00392 EADV 68 Advertise error 00393 ESRMNT 69 Srmount error 00394 ECOMM 70 Communication error on send 00395 EPROTO 71 Protocol error 00396 EMULTIHOP 72 Multihop attempted 00397 EDOTDOT 73 RFS specific error 00398 EBADMSG 74 Not a data message 00399 EOVERFLOW 75 Value too large for defined data type 00400 ENOTUNIQ 76 Name not unique on network 00401 EBADFD 77 File descriptor in bad state 00402 EREMCHG 78 Remote address changed 00403 ELIBACC 79 Can not access a needed shared library 00404 ELIBBAD 80 Accessing a corrupted shared library 00405 ELIBSCN 81 .lib section in a.out corrupted 00406 ELIBMAX 82 Attempting to link in too many shared libraries 00407 ELIBEXEC 83 Cannot exec a shared library directly 00408 EILSEQ 84 Illegal byte sequence 00409 ERESTART 85 Interrupted system call should be restarted 00410 ESTRPIPE 86 Streams pipe error 00411 EUSERS 87 Too many users 00412 ENOTSOCK 88 Socket operation on non-socket 00413 EDESTADDRREQ 89 Destination address required 00414 EMSGSIZE 90 Message too long 00415 EPROTOTYPE 91 Protocol wrong type for socket 00416 ENOPROTOOPT 92 Protocol not available 00417 EPROTONOSUPPORT 93 Protocol not supported 00418 ESOCKTNOSUPPORT 94 Socket type not supported 00419 EOPNOTSUPP 95 Operation not supported on transport endpoint 00420 EPFNOSUPPORT 96 Protocol family not supported 00421 EAFNOSUPPORT 97 Address family not supported by protocol 00422 EADDRINUSE 98 Address already in use 00423 EADDRNOTAVAIL 99 Cannot assign requested address 00424 ENETDOWN 100 Network is down 00425 ENETUNREACH 101 Network is unreachable 00426 ENETRESET 102 Network dropped connection because of reset 00427 ECONNABORTED 103 Software caused connection abort 00428 ECONNRESET 104 Connection reset by peer 00429 ENOBUFS 105 No buffer space available 00430 EISCONN 106 Transport endpoint is already connected 00431 ENOTCONN 107 Transport endpoint is not connected 00432 ESHUTDOWN 108 Cannot send after transport endpoint shutdown 00433 ETOOMANYREFS 109 Too many references: cannot splice 00434 ETIMEDOUT 110 Connection timed out 00435 ECONNREFUSED 111 Connection refused 00436 EHOSTDOWN 112 Host is down 00437 EHOSTUNREACH 113 No route to host 00438 EALREADY 114 Operation already in progress 00439 EINPROGRESS 115 Operation now in progress 00440 ESTALE 116 Stale NFS file handle 00441 EUCLEAN 117 Structure needs cleaning 00442 ENOTNAM 118 Not a XENIX named type file 00443 ENAVAIL 119 No XENIX semaphores available 00444 EISNAM 120 Is a named type file 00445 EREMOTEIO 121 Remote I/O error 00446 EDQUOT 122 Quota exceeded 00447 ENOMEDIUM 123 No medium found 00448 EMEDIUMTYPE 124 Wrong medium type 00449 ECANCELED 125 Operation Canceled 00450 ENOKEY 126 Required key not available 00451 EKEYEXPIRED 127 Key has expired 00452 EKEYREVOKED 128 Key has been revoked 00453 EKEYREJECTED 129 Key was rejected by service 00454 EOWNERDEAD 130 Owner died 00455 ENOTRECOVERABLE 131 State not recoverable 00456 \endverbatim 00457 * 00458 * @note 00459 * MbedOS System Error codes are defined using the macro MBED_DEFINE_SYSTEM_ERROR\n 00460 * For example MBED_DEFINE_SYSTEM_ERROR( INVALID_ARGUMENT ,1 ) macro defines the following values:\n 00461 * ERROR_CODE_INVALID_ARGUMENT = MBED_SYSTEM_ERROR_BASE+1\n 00462 * ERROR_INVALID_ARGUMENT = MAKE_MBED_ERROR(ERROR_TYPE_SYSTEM, MBED_MODULE_UNKNOWN, ERROR_CODE_INVALID_ARGUMENT)\n 00463 * Its effectively equivalent to:\n 00464 * ERROR_CODE_INVALID_ARGUMENT = 1\n 00465 * ERROR_INVALID_ARGUMENT = 0x80FF0001\n (Note that MODULE field is set to MBED_MODULE_UNKNOWN) 00466 * New System Error codes should be defined using MBED_DEFINE_SYSTEM_ERROR macro and must have an unique error code value\n 00467 * passed as the second argument in the MBED_DEFINE_SYSTEM_ERROR macro.\n\n 00468 * Below are the Mbed System error codes and the description: 00469 * \verbatim 00470 UNKNOWN 256 Unknown error 00471 INVALID_ARGUMENT 257 Invalid Argument 00472 INVALID_DATA 258 Invalid data 00473 INVALID_FORMAT 259 Invalid format 00474 INVALID_INDEX 260 Invalid Index 00475 INVALID_SIZE 261 Invalid Size 00476 INVALID_OPERATION 262 Invalid Operation 00477 NOT_FOUND 263 Not Found 00478 ACCESS_DENIED 264 Access Denied 00479 NOT_SUPPORTED 265 Not supported 00480 BUFFER_FULL 266 Buffer Full 00481 MEDIA_FULL 267 Media/Disk Full 00482 ALREADY_IN_USE 268 Already in use 00483 TIMEOUT 269 Timeout error 00484 NOT_READY 270 Not Ready 00485 FAILED_OPERATION 271 Requested Operation failed 00486 OPERATION_PROHIBITED 272 Operation prohibited 00487 OPERATION_ABORTED 273 Operation failed 00488 WRITE_PROTECTED 274 Attempt to write to write-protected resource 00489 NO_RESPONSE 275 No response 00490 SEMAPHORE_LOCK_FAILED 276 Semaphore lock failed 00491 MUTEX_LOCK_FAILED 277 Mutex lock failed 00492 SEMAPHORE_UNLOCK_FAILED 278 Semaphore unlock failed 00493 MUTEX_UNLOCK_FAILED 279 Mutex unlock failed 00494 CRC_ERROR 280 CRC error or mismatch 00495 OPEN_FAILED 281 Open failed 00496 CLOSE_FAILED 282 Close failed 00497 READ_FAILED 283 Read failed 00498 WRITE_FAILED 284 Write failed 00499 INITIALIZATION_FAILED 285 Initialization failed 00500 BOOT_FAILURE 286 Boot failure 00501 OUT_OF_MEMORY 287 Out of memory 00502 OUT_OF_RESOURCES 288 Out of resources 00503 ALLOC_FAILED 289 Alloc failed 00504 FREE_FAILED 290 Free failed 00505 OVERFLOW 291 Overflow error 00506 UNDERFLOW 292 Underflow error 00507 STACK_OVERFLOW 293 Stack overflow error 00508 ISR_QUEUE_OVERFLOW 294 ISR queue overflow 00509 TIMER_QUEUE_OVERFLOW 295 Timer Queue overflow 00510 CLIB_SPACE_UNAVAILABLE 296 Standard library error - Space unavailable 00511 CLIB_EXCEPTION 297 Standard library error - Exception 00512 CLIB_MUTEX_INIT_FAILURE 298 Standard library error - Mutex Init failure 00513 CREATE_FAILED 299 Create failed 00514 DELETE_FAILED 300 Delete failed 00515 THREAD_CREATE_FAILED 301 Thread Create failed 00516 THREAD_DELETE_FAILED 302 Thread Delete failed 00517 PROHIBITED_IN_ISR_CONTEXT 303 Operation Prohibited in ISR context 00518 PINMAP_INVALID 304 Pinmap Invalid 00519 RTOS_EVENT 305 Unknown Rtos Error 00520 RTOS_THREAD_EVENT 306 Rtos Thread Error 00521 RTOS_MUTEX_EVENT 307 Rtos Mutex Error 00522 RTOS_SEMAPHORE_EVENT 308 Rtos Semaphore Error 00523 RTOS_MEMORY_POOL_EVENT 309 Rtos Memory Pool Error 00524 RTOS_TIMER_EVENT 310 Rtos Timer Error 00525 RTOS_EVENT_FLAGS_EVENT 311 Rtos Event flags Error 00526 RTOS_MESSAGE_QUEUE_EVENT 312 Rtos Message queue Error 00527 DEVICE_BUSY 313 Device Busy 00528 CONFIG_UNSUPPORTED 314 Configuration not supported 00529 CONFIG_MISMATCH 315 Configuration mismatch 00530 ALREADY_INITIALIZED 316 Already initialized 00531 HARDFAULT_EXCEPTION 317 HardFault exception 00532 MEMMANAGE_EXCEPTION 318 MemManage exception 00533 BUSFAULT_EXCEPTION 319 BusFault exception 00534 USAGEFAULT_EXCEPTION 320 UsageFault exception 00535 BLE_NO_FRAME_INITIALIZED, 321 BLE No frame initialized 00536 BLE_BACKEND_CREATION_FAILED 322 BLE Backend creation failed 00537 BLE_BACKEND_NOT_INITIALIZED 323 BLE Backend not initialized 00538 ASSERTION_FAILED 324 Assertion Failed 00539 AUTHENTICATION_FAILED 325 Authentication Failed 00540 RBP_AUTHENTICATION_FAILED 326 Rollback Protect Authentication Failed 00541 \endverbatim 00542 * 00543 * @note 00544 * Custom Error codes can be defined using the macro DEFINE_CUSTOM_ERROR\n 00545 * This is mainly meant to capture non-generic error codes specific to a device. 00546 * For example DEFINE_CUSTOM_ERROR( MY_CUSTOM_ERROR ,1 ) macro defines the following values:\n 00547 * ERROR_CODE_MY_CUSTOM_ERROR = MBED_CUSTOM_ERROR_BASE+1\n 00548 * ERROR_MY_CUSTOM_ERROR = MAKE_MBED_ERROR(ERROR_TYPE_CUSTOM, MBED_MODULE_UNKNOWN, ERROR_CODE_MY_CUSTOM_ERROR)\n 00549 * Its effectively equivalent to:\n 00550 * ERROR_CODE_MY_CUSTOM_ERROR = 4097\n 00551 * ERROR_MY_CUSTOM_ERROR = 0xA0FF1001\n (Note that MODULE field is set to MBED_MODULE_UNKNOWN) \n\n 00552 * 00553 * @note 00554 * **Using error codes:** \n 00555 * POSIX error codes may be used in modules/functions currently using POSIX error codes and switching them to Mbed-OS error codes 00556 * may cause interoperability issues. For example, some of the filesystem, network stack implementations may need to use 00557 * POSIX error codes in order to keep them compatible with other modules interfacing with them, and may continue to use POSIX error codes. 00558 * 00559 * In all other cases, like for any native development of Mbed-OS modules Mbed-OS error codes should be used. 00560 * This makes it easy to use Mbed-OS error reporting/logging infrastructure and makes debugging error scenarios 00561 * much more efficient. 00562 * 00563 * @note 00564 * **Searching for error codes in mbed-os source tree:** \n 00565 * If you get an error report as below which you want to search for in mbed-os source tree, first take note of "Error Code" number. \n 00566 * For example, the below error report has an error code of \b 259. Find the error name associated with the error code and in this case its \b INVALID_FORMAT. \n 00567 * Use that error name(\b INVALID_FORMAT) to search the source tree for code locations setting that specific error code. \n 00568 * If the Error module reported is not 255(which indicates unknown module), you can also use that to narrow down to the specific component reporting the error. 00569 * See mbed_module_type_t enum above for module mapping. \n 00570 * 00571 * \verbatim 00572 ++ MbedOS Error Info ++ 00573 Error Status: 0x80FF013D Code: 317 Module: 255 00574 Error Message: Fault exception 00575 Location: 0x5CD1 00576 Error Value: 0x4A2A 00577 Current Thread: Id: 0x20001E80 Entry: 0x5EB1 StackSize: 0x1000 StackMem: 0x20000E80 SP: 0x2002FF90 00578 For more info, visit: https://mbed.com/s/error?error=0x80FF013D&mbedos=999999&core=0x410FC241&compile=1&ver=5060528 00579 -- MbedOS Error Info -- 00580 \endverbatim 00581 */ 00582 00583 typedef enum _mbed_error_code { 00584 //Below are POSIX ERROR CODE definitions, which starts at MBED_POSIX_ERROR_BASE(=0) 00585 //POSIX ERROR CODE definitions starts at offset 0(MBED_POSIX_ERROR_BASE) to align them with actual POSIX Error Code 00586 //defintions in mbed_retarget.h 00587 // Error Name Error Code 00588 MBED_DEFINE_POSIX_ERROR(EPERM, EPERM), /* 1 Operation not permitted */ 00589 MBED_DEFINE_POSIX_ERROR(ENOENT, ENOENT), /* 2 No such file or directory */ 00590 MBED_DEFINE_POSIX_ERROR(ESRCH, ESRCH), /* 3 No such process */ 00591 MBED_DEFINE_POSIX_ERROR(EINTR, EINTR), /* 4 Interrupted system call */ 00592 MBED_DEFINE_POSIX_ERROR(EIO, EIO), /* 5 I/O error */ 00593 MBED_DEFINE_POSIX_ERROR(ENXIO, ENXIO), /* 6 No such device or address */ 00594 MBED_DEFINE_POSIX_ERROR(E2BIG, E2BIG), /* 7 Argument list too long */ 00595 MBED_DEFINE_POSIX_ERROR(ENOEXEC, ENOEXEC), /* 8 Exec format error */ 00596 MBED_DEFINE_POSIX_ERROR(EBADF, EBADF), /* 9 Bad file number */ 00597 MBED_DEFINE_POSIX_ERROR(ECHILD, ECHILD), /* 10 No child processes */ 00598 MBED_DEFINE_POSIX_ERROR(EAGAIN, EAGAIN), /* 11 Try again */ 00599 MBED_DEFINE_POSIX_ERROR(ENOMEM, ENOMEM), /* 12 Out of memory */ 00600 MBED_DEFINE_POSIX_ERROR(EACCES, EACCES), /* 13 Permission denied */ 00601 MBED_DEFINE_POSIX_ERROR(EFAULT, EFAULT), /* 14 Bad address */ 00602 MBED_DEFINE_POSIX_ERROR(ENOTBLK, ENOTBLK), /* 15 Block device required */ 00603 MBED_DEFINE_POSIX_ERROR(EBUSY, EBUSY), /* 16 Device or resource busy */ 00604 MBED_DEFINE_POSIX_ERROR(EEXIST, EEXIST), /* 17 File exists */ 00605 MBED_DEFINE_POSIX_ERROR(EXDEV, EXDEV), /* 18 Cross-device link */ 00606 MBED_DEFINE_POSIX_ERROR(ENODEV, ENODEV), /* 19 No such device */ 00607 MBED_DEFINE_POSIX_ERROR(ENOTDIR, ENOTDIR), /* 20 Not a directory */ 00608 MBED_DEFINE_POSIX_ERROR(EISDIR, EISDIR), /* 21 Is a directory */ 00609 MBED_DEFINE_POSIX_ERROR(EINVAL, EINVAL), /* 22 Invalid argument */ 00610 MBED_DEFINE_POSIX_ERROR(ENFILE, ENFILE), /* 23 File table overflow */ 00611 MBED_DEFINE_POSIX_ERROR(EMFILE, EMFILE), /* 24 Too many open files */ 00612 MBED_DEFINE_POSIX_ERROR(ENOTTY, ENOTTY), /* 25 Not a typewriter */ 00613 MBED_DEFINE_POSIX_ERROR(ETXTBSY, ETXTBSY), /* 26 Text file busy */ 00614 MBED_DEFINE_POSIX_ERROR(EFBIG, EFBIG), /* 27 File too large */ 00615 MBED_DEFINE_POSIX_ERROR(ENOSPC, ENOSPC), /* 28 No space left on device */ 00616 MBED_DEFINE_POSIX_ERROR(ESPIPE, ESPIPE), /* 29 Illegal seek */ 00617 MBED_DEFINE_POSIX_ERROR(EROFS, EROFS), /* 30 Read-only file system */ 00618 MBED_DEFINE_POSIX_ERROR(EMLINK, EMLINK), /* 31 Too many links */ 00619 MBED_DEFINE_POSIX_ERROR(EPIPE, EPIPE), /* 32 Broken pipe */ 00620 MBED_DEFINE_POSIX_ERROR(EDOM, EDOM), /* 33 Math argument out of domain of func */ 00621 MBED_DEFINE_POSIX_ERROR(ERANGE, ERANGE), /* 34 Math result not representable */ 00622 MBED_DEFINE_POSIX_ERROR(EDEADLK, EDEADLK), /* 35 Resource deadlock would occur */ 00623 MBED_DEFINE_POSIX_ERROR(ENAMETOOLONG, ENAMETOOLONG), /* 36 File name too long */ 00624 MBED_DEFINE_POSIX_ERROR(ENOLCK, ENOLCK), /* 37 No record locks available */ 00625 MBED_DEFINE_POSIX_ERROR(ENOSYS, ENOSYS), /* 38 Function not implemented */ 00626 MBED_DEFINE_POSIX_ERROR(ENOTEMPTY, ENOTEMPTY), /* 39 Directory not empty */ 00627 MBED_DEFINE_POSIX_ERROR(ELOOP, ELOOP), /* 40 Too many symbolic links encountered */ 00628 MBED_DEFINE_POSIX_ERROR(EWOULDBLOCK, EAGAIN), /* EAGAIN Operation would block */ 00629 MBED_DEFINE_POSIX_ERROR(ENOMSG, ENOMSG), /* 42 No message of desired type */ 00630 MBED_DEFINE_POSIX_ERROR(EIDRM, EIDRM), /* 43 Identifier removed */ 00631 MBED_DEFINE_POSIX_ERROR(ECHRNG, ECHRNG), /* 44 Channel number out of range */ 00632 MBED_DEFINE_POSIX_ERROR(EL2NSYNC, EL2NSYNC), /* 45 Level 2 not synchronized */ 00633 MBED_DEFINE_POSIX_ERROR(EL3HLT, EL3HLT), /* 46 Level 3 halted */ 00634 MBED_DEFINE_POSIX_ERROR(EL3RST, EL3RST), /* 47 Level 3 reset */ 00635 MBED_DEFINE_POSIX_ERROR(ELNRNG, ELNRNG), /* 48 Link number out of range */ 00636 MBED_DEFINE_POSIX_ERROR(EUNATCH, EUNATCH), /* 49 Protocol driver not attached */ 00637 MBED_DEFINE_POSIX_ERROR(ENOCSI, ENOCSI), /* 50 No CSI structure available */ 00638 MBED_DEFINE_POSIX_ERROR(EL2HLT, EL2HLT), /* 51 Level 2 halted */ 00639 MBED_DEFINE_POSIX_ERROR(EBADE, EBADE), /* 52 Invalid exchange */ 00640 MBED_DEFINE_POSIX_ERROR(EBADR, EBADR), /* 53 Invalid request descriptor */ 00641 MBED_DEFINE_POSIX_ERROR(EXFULL, EXFULL), /* 54 Exchange full */ 00642 MBED_DEFINE_POSIX_ERROR(ENOANO, ENOANO), /* 55 No anode */ 00643 MBED_DEFINE_POSIX_ERROR(EBADRQC, EBADRQC), /* 56 Invalid request code */ 00644 MBED_DEFINE_POSIX_ERROR(EBADSLT, EBADSLT), /* 57 Invalid slot */ 00645 MBED_DEFINE_POSIX_ERROR(EDEADLOCK, EDEADLK), /* EDEADLK Resource deadlock would occur */ 00646 MBED_DEFINE_POSIX_ERROR(EBFONT, EBFONT), /* 59 Bad font file format */ 00647 MBED_DEFINE_POSIX_ERROR(ENOSTR, ENOSTR), /* 60 Device not a stream */ 00648 MBED_DEFINE_POSIX_ERROR(ENODATA, ENODATA), /* 61 No data available */ 00649 MBED_DEFINE_POSIX_ERROR(ETIME, ETIME), /* 62 Timer expired */ 00650 MBED_DEFINE_POSIX_ERROR(ENOSR, ENOSR), /* 63 Out of streams resources */ 00651 MBED_DEFINE_POSIX_ERROR(ENONET, ENONET), /* 64 Machine is not on the network */ 00652 MBED_DEFINE_POSIX_ERROR(ENOPKG, ENOPKG), /* 65 Package not installed */ 00653 MBED_DEFINE_POSIX_ERROR(EREMOTE, EREMOTE), /* 66 Object is remote */ 00654 MBED_DEFINE_POSIX_ERROR(ENOLINK, ENOLINK), /* 67 Link has been severed */ 00655 MBED_DEFINE_POSIX_ERROR(EADV, EADV), /* 68 Advertise error */ 00656 MBED_DEFINE_POSIX_ERROR(ESRMNT, ESRMNT), /* 69 Srmount error */ 00657 MBED_DEFINE_POSIX_ERROR(ECOMM, ECOMM), /* 70 Communication error on send */ 00658 MBED_DEFINE_POSIX_ERROR(EPROTO, EPROTO), /* 71 Protocol error */ 00659 MBED_DEFINE_POSIX_ERROR(EMULTIHOP, EMULTIHOP), /* 72 Multihop attempted */ 00660 MBED_DEFINE_POSIX_ERROR(EDOTDOT, EDOTDOT), /* 73 RFS specific error */ 00661 MBED_DEFINE_POSIX_ERROR(EBADMSG, EBADMSG), /* 74 Not a data message */ 00662 MBED_DEFINE_POSIX_ERROR(EOVERFLOW, EOVERFLOW), /* 75 Value too large for defined data type */ 00663 MBED_DEFINE_POSIX_ERROR(ENOTUNIQ, ENOTUNIQ), /* 76 Name not unique on network */ 00664 MBED_DEFINE_POSIX_ERROR(EBADFD, EBADFD), /* 77 File descriptor in bad state */ 00665 MBED_DEFINE_POSIX_ERROR(EREMCHG, EREMCHG), /* 78 Remote address changed */ 00666 MBED_DEFINE_POSIX_ERROR(ELIBACC, ELIBACC), /* 79 Can not access a needed shared library */ 00667 MBED_DEFINE_POSIX_ERROR(ELIBBAD, ELIBBAD), /* 80 Accessing a corrupted shared library */ 00668 MBED_DEFINE_POSIX_ERROR(ELIBSCN, ELIBSCN), /* 81 .lib section in a.out corrupted */ 00669 MBED_DEFINE_POSIX_ERROR(ELIBMAX, ELIBMAX), /* 82 Attempting to link in too many shared libraries */ 00670 MBED_DEFINE_POSIX_ERROR(ELIBEXEC, ELIBEXEC), /* 83 Cannot exec a shared library directly */ 00671 MBED_DEFINE_POSIX_ERROR(EILSEQ, EILSEQ), /* 84 Illegal byte sequence */ 00672 MBED_DEFINE_POSIX_ERROR(ERESTART, ERESTART), /* 85 Interrupted system call should be restarted */ 00673 MBED_DEFINE_POSIX_ERROR(ESTRPIPE, ESTRPIPE), /* 86 Streams pipe error */ 00674 MBED_DEFINE_POSIX_ERROR(EUSERS, EUSERS), /* 87 Too many users */ 00675 MBED_DEFINE_POSIX_ERROR(ENOTSOCK, ENOTSOCK), /* 88 Socket operation on non-socket */ 00676 MBED_DEFINE_POSIX_ERROR(EDESTADDRREQ, EDESTADDRREQ), /* 89 Destination address required */ 00677 MBED_DEFINE_POSIX_ERROR(EMSGSIZE, EMSGSIZE), /* 90 Message too long */ 00678 MBED_DEFINE_POSIX_ERROR(EPROTOTYPE, EPROTOTYPE), /* 91 Protocol wrong type for socket */ 00679 MBED_DEFINE_POSIX_ERROR(ENOPROTOOPT, ENOPROTOOPT), /* 92 Protocol not available */ 00680 MBED_DEFINE_POSIX_ERROR(EPROTONOSUPPORT, EPROTONOSUPPORT), /* 93 Protocol not supported */ 00681 MBED_DEFINE_POSIX_ERROR(ESOCKTNOSUPPORT, ESOCKTNOSUPPORT), /* 94 Socket type not supported */ 00682 MBED_DEFINE_POSIX_ERROR(EOPNOTSUPP, EOPNOTSUPP), /* 95 Operation not supported on transport endpoint */ 00683 MBED_DEFINE_POSIX_ERROR(EPFNOSUPPORT, EPFNOSUPPORT), /* 96 Protocol family not supported */ 00684 MBED_DEFINE_POSIX_ERROR(EAFNOSUPPORT, EAFNOSUPPORT), /* 97 Address family not supported by protocol */ 00685 MBED_DEFINE_POSIX_ERROR(EADDRINUSE, EADDRINUSE), /* 98 Address already in use */ 00686 MBED_DEFINE_POSIX_ERROR(EADDRNOTAVAIL, EADDRNOTAVAIL), /* 99 Cannot assign requested address */ 00687 MBED_DEFINE_POSIX_ERROR(ENETDOWN, ENETDOWN), /* 100 Network is down */ 00688 MBED_DEFINE_POSIX_ERROR(ENETUNREACH, ENETUNREACH), /* 101 Network is unreachable */ 00689 MBED_DEFINE_POSIX_ERROR(ENETRESET, ENETRESET), /* 102 Network dropped connection because of reset */ 00690 MBED_DEFINE_POSIX_ERROR(ECONNABORTED, ECONNABORTED), /* 103 Software caused connection abort */ 00691 MBED_DEFINE_POSIX_ERROR(ECONNRESET, ECONNRESET), /* 104 Connection reset by peer */ 00692 MBED_DEFINE_POSIX_ERROR(ENOBUFS, ENOBUFS), /* 105 No buffer space available */ 00693 MBED_DEFINE_POSIX_ERROR(EISCONN, EISCONN), /* 106 Transport endpoint is already connected */ 00694 MBED_DEFINE_POSIX_ERROR(ENOTCONN, ENOTCONN), /* 107 Transport endpoint is not connected */ 00695 MBED_DEFINE_POSIX_ERROR(ESHUTDOWN, ESHUTDOWN), /* 108 Cannot send after transport endpoint shutdown */ 00696 MBED_DEFINE_POSIX_ERROR(ETOOMANYREFS, ETOOMANYREFS), /* 109 Too many references: cannot splice */ 00697 MBED_DEFINE_POSIX_ERROR(ETIMEDOUT, ETIMEDOUT), /* 110 Connection timed out */ 00698 MBED_DEFINE_POSIX_ERROR(ECONNREFUSED, ECONNREFUSED), /* 111 Connection refused */ 00699 MBED_DEFINE_POSIX_ERROR(EHOSTDOWN, EHOSTDOWN), /* 112 Host is down */ 00700 MBED_DEFINE_POSIX_ERROR(EHOSTUNREACH, EHOSTUNREACH), /* 113 No route to host */ 00701 MBED_DEFINE_POSIX_ERROR(EALREADY, EALREADY), /* 114 Operation already in progress */ 00702 MBED_DEFINE_POSIX_ERROR(EINPROGRESS, EINPROGRESS), /* 115 Operation now in progress */ 00703 MBED_DEFINE_POSIX_ERROR(ESTALE, ESTALE), /* 116 Stale NFS file handle */ 00704 MBED_DEFINE_POSIX_ERROR(EUCLEAN, EUCLEAN), /* 117 Structure needs cleaning */ 00705 MBED_DEFINE_POSIX_ERROR(ENOTNAM, ENOTNAM), /* 118 Not a XENIX named type file */ 00706 MBED_DEFINE_POSIX_ERROR(ENAVAIL, ENAVAIL), /* 119 No XENIX semaphores available */ 00707 MBED_DEFINE_POSIX_ERROR(EISNAM, EISNAM), /* 120 Is a named type file */ 00708 MBED_DEFINE_POSIX_ERROR(EREMOTEIO, EREMOTEIO), /* 121 Remote I/O error */ 00709 MBED_DEFINE_POSIX_ERROR(EDQUOT, EDQUOT), /* 122 Quota exceeded */ 00710 MBED_DEFINE_POSIX_ERROR(ENOMEDIUM, ENOMEDIUM), /* 123 No medium found */ 00711 MBED_DEFINE_POSIX_ERROR(EMEDIUMTYPE, EMEDIUMTYPE), /* 124 Wrong medium type */ 00712 MBED_DEFINE_POSIX_ERROR(ECANCELED, ECANCELED), /* 125 Operation Canceled */ 00713 MBED_DEFINE_POSIX_ERROR(ENOKEY, ENOKEY), /* 126 Required key not available */ 00714 MBED_DEFINE_POSIX_ERROR(EKEYEXPIRED, EKEYEXPIRED), /* 127 Key has expired */ 00715 MBED_DEFINE_POSIX_ERROR(EKEYREVOKED, EKEYREVOKED), /* 128 Key has been revoked */ 00716 MBED_DEFINE_POSIX_ERROR(EKEYREJECTED, EKEYREJECTED), /* 129 Key was rejected by service */ 00717 MBED_DEFINE_POSIX_ERROR(EOWNERDEAD, EOWNERDEAD), /* 130 Owner died */ 00718 MBED_DEFINE_POSIX_ERROR(ENOTRECOVERABLE, ENOTRECOVERABLE), /* 131 State not recoverable */ 00719 00720 //Below are MBED SYSTEM ERROR CODE definitions 00721 //MBED SYSTEM ERROR CODE definitions starts at offset MBED_SYSTEM_ERROR_BASE, see above. 00722 // Error Name Error Offset Error Code 00723 MBED_DEFINE_SYSTEM_ERROR(UNKNOWN, 0), /* 256 Unknown error */ 00724 MBED_DEFINE_SYSTEM_ERROR(INVALID_ARGUMENT, 1), /* 257 Invalid Argument */ 00725 MBED_DEFINE_SYSTEM_ERROR(INVALID_DATA_DETECTED, 2), /* 258 Invalid data detected */ 00726 MBED_DEFINE_SYSTEM_ERROR(INVALID_FORMAT, 3), /* 259 Invalid format */ 00727 MBED_DEFINE_SYSTEM_ERROR(INVALID_INDEX, 4), /* 260 Invalid Index */ 00728 MBED_DEFINE_SYSTEM_ERROR(INVALID_SIZE, 5), /* 261 Invalid Size */ 00729 MBED_DEFINE_SYSTEM_ERROR(INVALID_OPERATION, 6), /* 262 Invalid Operation */ 00730 MBED_DEFINE_SYSTEM_ERROR(ITEM_NOT_FOUND, 7), /* 263 Item Not Found */ 00731 MBED_DEFINE_SYSTEM_ERROR(ACCESS_DENIED, 8), /* 264 Access Denied */ 00732 MBED_DEFINE_SYSTEM_ERROR(UNSUPPORTED, 9), /* 265 Unsupported */ 00733 MBED_DEFINE_SYSTEM_ERROR(BUFFER_FULL, 10), /* 266 Buffer Full */ 00734 MBED_DEFINE_SYSTEM_ERROR(MEDIA_FULL, 11), /* 267 Media/Disk Full */ 00735 MBED_DEFINE_SYSTEM_ERROR(ALREADY_IN_USE, 12), /* 268 Already in use */ 00736 MBED_DEFINE_SYSTEM_ERROR(TIME_OUT, 13), /* 269 Timeout error */ 00737 MBED_DEFINE_SYSTEM_ERROR(NOT_READY, 14), /* 270 Not Ready */ 00738 MBED_DEFINE_SYSTEM_ERROR(FAILED_OPERATION, 15), /* 271 Requested Operation failed */ 00739 MBED_DEFINE_SYSTEM_ERROR(OPERATION_PROHIBITED, 16), /* 272 Operation prohibited */ 00740 MBED_DEFINE_SYSTEM_ERROR(OPERATION_ABORTED, 17), /* 273 Operation failed */ 00741 MBED_DEFINE_SYSTEM_ERROR(WRITE_PROTECTED, 18), /* 274 Attempt to write to write-protected resource */ 00742 MBED_DEFINE_SYSTEM_ERROR(NO_RESPONSE, 19), /* 275 No response */ 00743 MBED_DEFINE_SYSTEM_ERROR(SEMAPHORE_LOCK_FAILED, 20), /* 276 Semaphore lock failed */ 00744 MBED_DEFINE_SYSTEM_ERROR(MUTEX_LOCK_FAILED, 21), /* 277 Mutex lock failed */ 00745 MBED_DEFINE_SYSTEM_ERROR(SEMAPHORE_UNLOCK_FAILED, 22), /* 278 Semaphore unlock failed */ 00746 MBED_DEFINE_SYSTEM_ERROR(MUTEX_UNLOCK_FAILED, 23), /* 279 Mutex unlock failed */ 00747 MBED_DEFINE_SYSTEM_ERROR(CRC_ERROR, 24), /* 280 CRC error or mismatch */ 00748 MBED_DEFINE_SYSTEM_ERROR(OPEN_FAILED, 25), /* 281 Open failed */ 00749 MBED_DEFINE_SYSTEM_ERROR(CLOSE_FAILED, 26), /* 282 Close failed */ 00750 MBED_DEFINE_SYSTEM_ERROR(READ_FAILED, 27), /* 283 Read failed */ 00751 MBED_DEFINE_SYSTEM_ERROR(WRITE_FAILED, 28), /* 284 Write failed */ 00752 MBED_DEFINE_SYSTEM_ERROR(INITIALIZATION_FAILED, 29), /* 285 Initialization failed */ 00753 MBED_DEFINE_SYSTEM_ERROR(BOOT_FAILURE, 30), /* 286 Boot failure */ 00754 MBED_DEFINE_SYSTEM_ERROR(OUT_OF_MEMORY, 31), /* 287 Out of memory */ 00755 MBED_DEFINE_SYSTEM_ERROR(OUT_OF_RESOURCES, 32), /* 288 Out of resources */ 00756 MBED_DEFINE_SYSTEM_ERROR(ALLOC_FAILED, 33), /* 289 Alloc failed */ 00757 MBED_DEFINE_SYSTEM_ERROR(FREE_FAILED, 34), /* 290 Free failed */ 00758 MBED_DEFINE_SYSTEM_ERROR(OVERFLOW, 35), /* 291 Overflow error */ 00759 MBED_DEFINE_SYSTEM_ERROR(UNDERFLOW, 36), /* 292 Underflow error */ 00760 MBED_DEFINE_SYSTEM_ERROR(STACK_OVERFLOW, 37), /* 293 Stack overflow error */ 00761 MBED_DEFINE_SYSTEM_ERROR(ISR_QUEUE_OVERFLOW, 38), /* 294 ISR queue overflow */ 00762 MBED_DEFINE_SYSTEM_ERROR(TIMER_QUEUE_OVERFLOW, 39), /* 295 Timer Queue overflow */ 00763 MBED_DEFINE_SYSTEM_ERROR(CLIB_SPACE_UNAVAILABLE, 40), /* 296 Standard library error - Space unavailable */ 00764 MBED_DEFINE_SYSTEM_ERROR(CLIB_EXCEPTION, 41), /* 297 Standard library error - Exception */ 00765 MBED_DEFINE_SYSTEM_ERROR(CLIB_MUTEX_INIT_FAILURE, 42), /* 298 Standard library error - Mutex Init failure */ 00766 MBED_DEFINE_SYSTEM_ERROR(CREATE_FAILED, 43), /* 299 Create failed */ 00767 MBED_DEFINE_SYSTEM_ERROR(DELETE_FAILED, 44), /* 300 Delete failed */ 00768 MBED_DEFINE_SYSTEM_ERROR(THREAD_CREATE_FAILED, 45), /* 301 Thread Create failed */ 00769 MBED_DEFINE_SYSTEM_ERROR(THREAD_DELETE_FAILED, 46), /* 302 Thread Delete failed */ 00770 MBED_DEFINE_SYSTEM_ERROR(PROHIBITED_IN_ISR_CONTEXT, 47), /* 303 Operation Prohibited in ISR context */ 00771 MBED_DEFINE_SYSTEM_ERROR(PINMAP_INVALID, 48), /* 304 Pinmap Invalid */ 00772 MBED_DEFINE_SYSTEM_ERROR(RTOS_EVENT, 49), /* 305 Unknown Rtos Error */ 00773 MBED_DEFINE_SYSTEM_ERROR(RTOS_THREAD_EVENT, 50), /* 306 Rtos Thread Error */ 00774 MBED_DEFINE_SYSTEM_ERROR(RTOS_MUTEX_EVENT, 51), /* 307 Rtos Mutex Error */ 00775 MBED_DEFINE_SYSTEM_ERROR(RTOS_SEMAPHORE_EVENT, 52), /* 308 Rtos Semaphore Error */ 00776 MBED_DEFINE_SYSTEM_ERROR(RTOS_MEMORY_POOL_EVENT, 53), /* 309 Rtos Memory Pool Error */ 00777 MBED_DEFINE_SYSTEM_ERROR(RTOS_TIMER_EVENT, 54), /* 310 Rtos Timer Error */ 00778 MBED_DEFINE_SYSTEM_ERROR(RTOS_EVENT_FLAGS_EVENT, 55), /* 311 Rtos Event flags Error */ 00779 MBED_DEFINE_SYSTEM_ERROR(RTOS_MESSAGE_QUEUE_EVENT, 56), /* 312 Rtos Message queue Error */ 00780 MBED_DEFINE_SYSTEM_ERROR(DEVICE_BUSY, 57), /* 313 Device Busy */ 00781 MBED_DEFINE_SYSTEM_ERROR(CONFIG_UNSUPPORTED, 58), /* 314 Configuration not supported */ 00782 MBED_DEFINE_SYSTEM_ERROR(CONFIG_MISMATCH, 59), /* 315 Configuration mismatch */ 00783 MBED_DEFINE_SYSTEM_ERROR(ALREADY_INITIALIZED, 60), /* 316 Already initialized */ 00784 MBED_DEFINE_SYSTEM_ERROR(HARDFAULT_EXCEPTION, 61), /* 317 HardFault exception */ 00785 MBED_DEFINE_SYSTEM_ERROR(MEMMANAGE_EXCEPTION, 62), /* 318 MemManage exception */ 00786 MBED_DEFINE_SYSTEM_ERROR(BUSFAULT_EXCEPTION, 63), /* 319 BusFault exception */ 00787 MBED_DEFINE_SYSTEM_ERROR(USAGEFAULT_EXCEPTION, 64), /* 320 UsageFault exception*/ 00788 MBED_DEFINE_SYSTEM_ERROR(BLE_NO_FRAME_INITIALIZED, 65), /* 321 BLE No frame initialized */ 00789 MBED_DEFINE_SYSTEM_ERROR(BLE_BACKEND_CREATION_FAILED, 66), /* 322 BLE Backend creation failed */ 00790 MBED_DEFINE_SYSTEM_ERROR(BLE_BACKEND_NOT_INITIALIZED, 67), /* 323 BLE Backend not initialized */ 00791 MBED_DEFINE_SYSTEM_ERROR(ASSERTION_FAILED, 68), /* 324 Assertion Failed */ 00792 MBED_DEFINE_SYSTEM_ERROR(AUTHENTICATION_FAILED, 69), /* 325 Authentication Failed */ 00793 MBED_DEFINE_SYSTEM_ERROR(RBP_AUTHENTICATION_FAILED, 70), /* 326 Rollback Protection Authentication Failed */ 00794 MBED_DEFINE_SYSTEM_ERROR(BLE_USE_INCOMPATIBLE_API, 71), /* 327 Concurrent use of incompatible versions of a BLE API */ 00795 MBED_DEFINE_SYSTEM_ERROR(BLE_ILLEGAL_STATE, 72), /* 328 BLE stack entered illegal state */ 00796 00797 //Everytime you add a new system error code, you must update 00798 //Error documentation under Handbook to capture the info on 00799 //the new error status/codes 00800 00801 //MBED CUSTOM ERROR CODE definitions starts at offset MBED_CUSTOM_ERROR_BASE, see above. 00802 /* Add More/Custom Error Codes here, See example below */ 00803 //DEFINE_CUSTOM_ERROR( MY_CUSTOM_ERROR , 1 ), 00804 00805 } mbed_error_code_t; 00806 00807 /** mbed_error_ctx struct 00808 * 00809 * This struct captures the context information at the time of error.\n 00810 * It primarily contains information about the thread where the error originated,\n 00811 * filename/line number of the source file where the error occurred, a context specific error value(error_value)\n 00812 * and the address where the error originated.\n 00813 * 00814 * @note 00815 * Below are the members of mbed_error_ctx struct\n 00816 * error_status mbed_error_status_t value for this error\n 00817 * error_function_address Address where the error occurred\n 00818 * thread_id ID of the thread which generated the error\n 00819 * thread_entry_address Entry function of the thread which generated the error\n 00820 * thread_stack_size Stack Size of the thread which generated the error\n 00821 * thread_stack_mem Stack Top of the thread which generated the error\n 00822 * thread_current_sp Current Stack Pointer of the thread which generated the error\n 00823 * error_value A context/error specific value associated with this error\n 00824 * error_filename Filename where the error originated\n 00825 * error_line_number Line number in error_filename where the error originated\n 00826 */ 00827 typedef struct _mbed_error_ctx { 00828 mbed_error_status_t error_status; 00829 uint32_t error_address; 00830 uint32_t error_value; 00831 uint32_t thread_id; 00832 uint32_t thread_entry_address; 00833 uint32_t thread_stack_size; 00834 uint32_t thread_stack_mem; 00835 uint32_t thread_current_sp; 00836 #ifdef MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN 00837 char error_filename[MBED_CONF_PLATFORM_MAX_ERROR_FILENAME_LEN]; 00838 uint32_t error_line_number; 00839 #endif 00840 #if MBED_CONF_PLATFORM_CRASH_CAPTURE_ENABLED 00841 int32_t error_reboot_count;//everytime we write this struct we increment this value by 1, irrespective of time between reboots. Note that the data itself might change, but everytime we reboot due to error we update this count by 1 00842 int32_t is_error_processed;//once this error is processed set this value to 1 00843 uint32_t crc_error_ctx;//crc_error_ctx should always be the last member in this struct 00844 #endif 00845 } mbed_error_ctx; 00846 00847 /** To generate a fatal compile-time error, you can use the pre-processor #error directive. 00848 * 00849 * @param format C string that contains data stream to be printed. 00850 * Code snippets below show valid format. 00851 * 00852 * @code 00853 * #error "That shouldn't have happened!" 00854 * @endcode 00855 * 00856 * If the compiler evaluates this line, it will report the error and stop the compile. 00857 * 00858 * For example, you could use this to check some user-defined compile-time variables: 00859 * 00860 * @code 00861 * #define NUM_PORTS 7 00862 * #if (NUM_PORTS > 4) 00863 * #error "NUM_PORTS must be less than 4" 00864 * #endif 00865 * @endcode 00866 * 00867 * Reporting Run-Time Errors: 00868 * To generate a fatal run-time error, you can use the mbed error() function. 00869 * 00870 * @code 00871 * error("That shouldn't have happened!"); 00872 * @endcode 00873 * 00874 * If the mbed running the program executes this function, it will print the 00875 * message via the USB serial port, and then die with the blue lights of death! 00876 * 00877 * The message can use printf-style formatting, so you can report variables in the 00878 * message too. For example, you could use this to check a run-time condition: 00879 * 00880 * @code 00881 * if(x >= 5) { 00882 * error("expected x to be less than 5, but got %d", x); 00883 * } 00884 * @endcode 00885 * 00886 * 00887 */ 00888 00889 MBED_NORETURN void error(const char *format, ...) MBED_PRINTF(1, 2); 00890 00891 /** 00892 * Call this Macro to generate a mbed_error_status_t value for a System error 00893 * @param module Module generating the error code. If its unknown, pass MBED_MODULE_UNKNOWN. See mbed_module_type_t for module types. 00894 * @param error_code The mbed_error_code_t code to be used in generating the mbed_error_status_t. See mbed_error_code_t for error codes. 00895 * 00896 * @code 00897 * 00898 * mbed_error_status_t driver_error = MBED_MAKE_SYSTEM_ERROR( MODULE_DRIVER_USB, MBED_ERROR_CODE_INITIALIZATION_FAILED ) 00899 * 00900 * @endcode 00901 * @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_SYSTEM 00902 * 00903 */ 00904 #define MBED_MAKE_SYSTEM_ERROR(module, error_code) MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, module, error_code) 00905 00906 /** 00907 * Call this Macro to generate a mbed_error_status_t value for a Custom error 00908 * @param module Module generating the error code. If its unknown, pass MBED_MODULE_UNKNOWN. See mbed_module_type_t for module types. 00909 * @param error_code The mbed_error_code_t code to be used in generating the mbed_error_status_t. See mbed_error_code_t for error codes. 00910 * 00911 * @code 00912 * 00913 * mbed_error_status_t custom_error = MBED_MAKE_CUSTOM_ERROR( MBED_MODULE_APPLICATION, 0xDEAD//16-bit custom error code ) 00914 * 00915 * @endcode 00916 * @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_CUSTOM 00917 * 00918 */ 00919 #define MBED_MAKE_CUSTOM_ERROR(module, error_code) MAKE_MBED_ERROR(MBED_ERROR_TYPE_CUSTOM, module, error_code) 00920 00921 /** 00922 * Call this Macro to generate a mbed_error_status_t value for a System error 00923 * @param module Module generating the error code. If its unknown, pass MBED_MODULE_UNKNOWN. See mbed_module_type_t for module types. 00924 * @param error_code The mbed_error_code_t code to be used in generating the mbed_error_status_t. See mbed_error_code_t for error codes. 00925 * 00926 * @code 00927 * 00928 * mbed_error_status_t new_error = MBED_MAKE_ERROR( MODULE_DRIVER_USB, MBED_ERROR_INITIALIZATION_FAILED ) 00929 * 00930 * @endcode 00931 * @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_SYSTEM 00932 * 00933 */ 00934 #define MBED_MAKE_ERROR(module, error_code) MBED_MAKE_SYSTEM_ERROR(module, error_code) 00935 00936 /** 00937 * Callback/Error hook function prototype. Applications needing a callback when an error is reported can use mbed_set_error_hook function 00938 * to register a callback/error hook function using the following prototype. When an error happens in the system error handling 00939 * implementation will invoke this callback with the mbed_error_status_t reported and the error context at the time of error. 00940 * @param error_ctx Error context structure associated with this error. 00941 * @return void 00942 * 00943 */ 00944 typedef void (*mbed_error_hook_t)(const mbed_error_ctx *error_ctx); 00945 00946 00947 /** 00948 * Callback function for reporting error context during boot up. When MbedOS error handling system detects a fatal error 00949 * it will auto-reboot the system(if MBED_CONF_PLATFORM_FATAL_ERROR_AUTO_REBOOT_ENABLED is enabled) after capturing the 00950 * error info in special crash data RAM region. Once rebooted, MbedOS initialization routines will call this function with a pointer to 00951 * the captured mbed_error_ctx structure. If application implementation needs to receive this callback, mbed_error_reboot_callback 00952 * function should be overridden with custom implementation. By default it's defined as a WEAK function in mbed_error.c. 00953 * Note that this callback will be invoked before the system starts executing main() function. So the implementation of 00954 * the callback should be aware any resource limitations/availability of resources which are yet to be initialized by application main(). 00955 * 00956 * @param error_ctx Error context structure associated with this error. 00957 * @return void 00958 * 00959 */ 00960 void mbed_error_reboot_callback(mbed_error_ctx *error_context); 00961 00962 /** 00963 * Initialize error handling system, this is called by the mbed-os boot sequence. This is not required to be called by Application unless the boot sequence is overridden by the system implementation. 00964 * NOTE: If MBED_CONF_PLATFORM_FATAL_ERROR_AUTO_REBOOT_ENABLED is enabled and if the current reboot count exceeds MBED_CONF_PLATFORM_ERROR_REBOOT_MAX the system will halt when this function is called, 00965 * and in such cases the caller will not get the control back. Also note that calling this function may trigger mbed_error_reboot_callback() if application side overides mbed_error_reboot_callback(). 00966 * @return MBED_SUCCESS on success. 00967 * 00968 */ 00969 00970 mbed_error_status_t mbed_error_initialize(void); 00971 00972 /** 00973 * Call this function to retrieve the error context after a fatal error which triggered a system reboot. The function retrieves the error context stored in crash-report ram area which is preserved over reboot. 00974 * @param error_info Pointer to mbed_error_ctx struct allocated by the caller. This is the mbed_error_ctx info captured as part of the fatal error which triggered the reboot. 00975 * @return 0 or MBED_SUCCESS on success. 00976 * MBED_ERROR_INVALID_ARGUMENT in case of invalid error_info pointer 00977 * MBED_ERROR_ITEM_NOT_FOUND if no reboot context is currently captured by the system 00978 * 00979 */ 00980 mbed_error_status_t mbed_get_reboot_error_info(mbed_error_ctx *error_info); 00981 00982 /** 00983 * Calling this function resets the current reboot context captured by the system(stored in special crash data RAM region). 00984 * @return MBED_SUCCESS on success. 00985 * MBED_ERROR_ITEM_NOT_FOUND if no reboot context is currently captured by the system 00986 */ 00987 mbed_error_status_t mbed_reset_reboot_error_info(void); 00988 00989 /** 00990 * Calling this function resets the current reboot count stored as part of error context captured in special crash data RAM region. 00991 * The function will also update the CRC value stored as part of error context accordingly. 00992 * @return MBED_SUCCESS on success. 00993 * MBED_ERROR_ITEM_NOT_FOUND if no reboot context is currently captured by the system 00994 */ 00995 mbed_error_status_t mbed_reset_reboot_count(void); 00996 00997 /** 00998 * Call this function to set a system error/warning. This function will log the error status with the context info and return to caller. 00999 * 01000 * @param error_status mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values). 01001 * @param error_msg The error message to be printed out to STDIO/Serial. 01002 * @param error_value Value associated with the error status. This would depend on error code/error scenario. 01003 * @param filename Name of the source file originating the error( Most callers can pass __FILE__ here ). 01004 * @param line_number The line number of the source file originating the error( Most callers can pass __LINE__ here ) . 01005 * @return 0 or MBED_SUCCESS. 01006 * MBED_ERROR_INVALID_ARGUMENT if called with invalid error status/codes 01007 * 01008 * @code 01009 * 01010 * mbed_error( ERROR_OUT_OF_MEMORY, "Out of memory error", 0, __FILE__, __LINE__ ) 01011 * 01012 * @endcode 01013 * 01014 * @note See MBED_WARNING/MBED_ERROR macros which provides a wrapper on this API 01015 */ 01016 mbed_error_status_t mbed_warning(mbed_error_status_t error_status, const char *error_msg, unsigned int error_value, const char *filename, int line_number); 01017 01018 /** 01019 * Returns the first system error reported. 01020 * @return mbed_error_status_t code logged for the first error or MBED_SUCCESS if no errors are logged. 01021 * 01022 */ 01023 mbed_error_status_t mbed_get_first_error(void); 01024 01025 /** 01026 * Returns the most recent system error reported. 01027 * @return mbed_error_status_t code logged for the last error or MBED_SUCCESS if no errors are logged. 01028 * 01029 */ 01030 mbed_error_status_t mbed_get_last_error(void); 01031 01032 /** 01033 * Returns the number of system errors reported after boot. 01034 * @return int Number of errors reported. 01035 * 01036 */ 01037 int mbed_get_error_count(void); 01038 01039 /** 01040 * Call this function to set a fatal system error and halt the system. This function will log the fatal error with the context info and prints the error report and halts the system. 01041 * 01042 * @param error_status mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values). 01043 * @param error_msg The error message to be printed out to STDIO/Serial. 01044 * @param error_value Value associated with the error status. This would depend on error code/error scenario. 01045 * @param filename Name of the source file originating the error( Most callers can pass __FILE__ here ). 01046 * @param line_number The line number of the source file originating the error( Most callers can pass __LINE__ here ) . 01047 * @return Does not return. 01048 * 01049 * @code 01050 * 01051 * mbed_error( MBED_ERROR_PROHIBITED_OPERATION, "Prohibited operation tried", 0, __FILE__, __LINE__ ) 01052 * 01053 * @endcode 01054 * 01055 * @note See MBED_WARNING/MBED_ERROR macros which provides a wrapper on this API 01056 */ 01057 MBED_NORETURN mbed_error_status_t mbed_error(mbed_error_status_t error_status, const char *error_msg, unsigned int error_value, const char *filename, int line_number); 01058 01059 /** 01060 * Registers an application defined error callback with the error handling system. 01061 * This function will be called with error context info whenever system handles a mbed_error/mbed_warning call 01062 * NOTE: This function should be implemented for re-entrancy as multiple threads may invoke mbed_error which may cause error hook to be called. 01063 * @param custom_error_hook mbed_error_status_t status to be set(See mbed_error_status_t enum above for available error status values). 01064 * @return 0 or MBED_SUCCESS on success. 01065 * MBED_ERROR_INVALID_ARGUMENT in case of NULL for custom_error_hook 01066 * 01067 * @code 01068 * 01069 * mbed_error_status_t my_custom_error_hook(mbed_error_status_t error_status, const mbed_error_ctx *error_ctx) { 01070 * //Do something with the error_status or error_ctx 01071 * } 01072 * 01073 * mbed_set_error_hook( my_custom_error_hook ) 01074 * 01075 * @endcode 01076 * @note The erro hook function implementation should be re-entrant. 01077 * 01078 */ 01079 mbed_error_status_t mbed_set_error_hook(mbed_error_hook_t custom_error_hook); 01080 01081 /** 01082 * Reads the first error context information captured. 01083 * @param error_info This is the mbed_error_context info captured as part of the first mbed_error call. The caller should pass a pointer to mbed_error_context struct allocated by the caller. 01084 * @return 0 or MBED_SUCCESS on success. 01085 * MBED_ERROR_INVALID_ARGUMENT in case of invalid index 01086 * 01087 */ 01088 mbed_error_status_t mbed_get_first_error_info(mbed_error_ctx *error_info); 01089 01090 /** 01091 * Reads the last error context information captured. 01092 * @param error_info This is the mbed_error_context info captured as part of the last mbed_error call. The caller should pass a pointer to mbed_error_context struct allocated by the caller. 01093 * @return 0 or MBED_ERROR_SUCCESS on success. 01094 * MBED_ERROR_INVALID_ARGUMENT in case of invalid index 01095 * 01096 */ 01097 mbed_error_status_t mbed_get_last_error_info(mbed_error_ctx *error_info); 01098 01099 /** 01100 * Clears the last error, first error, error count and all entries in the error history. 01101 * @return 0 or MBED_SUCCESS on success. 01102 * 01103 */ 01104 mbed_error_status_t mbed_clear_all_errors(void); 01105 01106 /** 01107 * Generates a mbed_error_status_t value based on passed in values for type, module and error code. 01108 * @param error_type Error type based on mbed_error_type_t enum. 01109 * @param module Module type based on mbed_module_type_t enum. 01110 * @param error_code Error codes defined by mbed_error_code_t enum 01111 * @return 0 or MBED_ERROR_SUCCESS on success. 01112 * 01113 */ 01114 mbed_error_status_t mbed_make_error(mbed_error_type_t error_type, mbed_module_type_t module, mbed_error_code_t error_code); 01115 01116 /** 01117 * Returns the current number of entries in the error history, if there has been more than max number of errors logged the number returned will be max depth of error history. 01118 * @return Current number of entries in the error history. 01119 * 01120 */ 01121 int mbed_get_error_hist_count(void); 01122 01123 /** 01124 * Reads the error context information for a specific error from error history, specified by the index. 01125 * 01126 * @param index index of the error context entry in the history to be retrieved.\n 01127 * The number of entries in the error history is configured during build and the max index depends on max depth of error history.\n 01128 * index = 0 points to the oldest entry in the history, and index = (max history depth - 1) points to the latest entry in the error history.\n 01129 * @param error_info This is the mbed_error_context info captured as part of the error history. The caller should pass a pointer to mbed_error_context struct allocated by the caller. 01130 * @return 0 or MBED_SUCCESS on success. 01131 * MBED_ERROR_INVALID_ARGUMENT in case of invalid index 01132 * 01133 */ 01134 mbed_error_status_t mbed_get_error_hist_info(int index, mbed_error_ctx *error_info); 01135 01136 /** 01137 * Saves the error history information to a file 01138 * 01139 * @param path path to the file in the filesystem 01140 * @return 0 or MBED_ERROR_SUCCESS on success. 01141 * MBED_ERROR_WRITE_FAILED if writing to file failed 01142 * MBED_ERROR_INVALID_ARGUMENT if path is not valid 01143 * 01144 * @note Filesystem support is required in order for this function to work. 01145 * 01146 */ 01147 mbed_error_status_t mbed_save_error_hist(const char *path); 01148 01149 #ifdef __cplusplus 01150 } 01151 #endif 01152 01153 #endif 01154 01155 /** @}*/ 01156 /** @}*/ 01157 01158
Generated on Tue Jul 12 2022 20:41:15 by
1.7.2