mirror of https://github.com/ARMmbed/mbed-os.git
Adding mbed prefixes to all macros and functions to avoid namespace conflicts
Senthil Ramakrishnan
parent
147d9cac4e
commit
d4fe75731d
|
|
@ -36,7 +36,7 @@ void test_error_count_and_reset()
|
|||
TEST_ASSERT_EQUAL_INT(count, get_error_count());
|
||||
|
||||
//clear the errors and error count to 0
|
||||
clear_all_errors();
|
||||
mbed_clear_all_errors();
|
||||
|
||||
//Now the error count should be 0
|
||||
TEST_ASSERT_EQUAL_INT(0, get_error_count());
|
||||
|
|
@ -56,15 +56,15 @@ void test_error_capturing()
|
|||
MBED_WARNING(MBED_ERROR_OUT_OF_RESOURCES, "System type error", 0x1100 );
|
||||
mbed_error_status_t lastError = get_last_error();
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TYPE_SYSTEM, MBED_GET_ERROR_TYPE(lastError));
|
||||
TEST_ASSERT_EQUAL_UINT(MODULE_UNKNOWN, MBED_GET_ERROR_MODULE(lastError));
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_MODULE_UNKNOWN, MBED_GET_ERROR_MODULE(lastError));
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_CODE_OUT_OF_RESOURCES, MBED_GET_ERROR_CODE(lastError));
|
||||
|
||||
mbed_error_status_t error = MAKE_ERROR(MODULE_DRIVER_SERIAL, MBED_ERROR_CODE_OUT_OF_RESOURCES);
|
||||
mbed_error_status_t error = MBED_MAKE_ERROR(MBED_MODULE_DRIVER_SERIAL, MBED_ERROR_CODE_OUT_OF_RESOURCES);
|
||||
MBED_WARNING(error, "Error Serial", 0xAA );
|
||||
lastError = get_last_error();
|
||||
TEST_ASSERT_EQUAL_UINT(error, lastError);
|
||||
|
||||
error = MAKE_CUSTOM_ERROR(MODULE_APPLICATION, MBED_ERROR_CODE_UNKNOWN);
|
||||
error = MBED_MAKE_CUSTOM_ERROR(MBED_MODULE_APPLICATION, MBED_ERROR_CODE_UNKNOWN);
|
||||
MBED_WARNING(error, "Custom Error Unknown", 0x1234 );
|
||||
lastError = get_last_error();
|
||||
TEST_ASSERT_EQUAL_UINT(error, lastError);
|
||||
|
|
@ -73,13 +73,13 @@ void test_error_capturing()
|
|||
lastError = get_last_error();
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_EPERM, lastError);
|
||||
|
||||
error = MAKE_CUSTOM_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_CREATE_FAILED);
|
||||
error = MBED_MAKE_CUSTOM_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_CREATE_FAILED);
|
||||
MBED_WARNING(error, "Custom Error Type", error_value);
|
||||
lastError = get_last_error();
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TYPE_CUSTOM, MBED_GET_ERROR_TYPE(lastError));
|
||||
TEST_ASSERT_EQUAL_UINT(MODULE_PLATFORM, MBED_GET_ERROR_MODULE(lastError));
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_MODULE_PLATFORM, MBED_GET_ERROR_MODULE(lastError));
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_CODE_CREATE_FAILED, MBED_GET_ERROR_CODE(lastError));
|
||||
mbed_error_status_t status = get_last_error_log_info( &error_ctx );
|
||||
mbed_error_status_t status = mbed_get_last_error_log_info( &error_ctx );
|
||||
TEST_ASSERT(status == MBED_SUCCESS);
|
||||
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value);
|
||||
|
||||
|
|
@ -87,20 +87,20 @@ void test_error_capturing()
|
|||
MBED_WARNING(MBED_ERROR_EACCES, "Posix Error", error_value );
|
||||
lastError = get_last_error();
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TYPE_POSIX, MBED_GET_ERROR_TYPE(lastError));
|
||||
TEST_ASSERT_EQUAL_UINT(MODULE_UNKNOWN, MBED_GET_ERROR_MODULE(lastError));
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_MODULE_UNKNOWN, MBED_GET_ERROR_MODULE(lastError));
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_CODE_EACCES, MBED_GET_ERROR_CODE(lastError));
|
||||
status = get_last_error_log_info( &error_ctx );
|
||||
status = mbed_get_last_error_log_info( &error_ctx );
|
||||
TEST_ASSERT(status == MBED_SUCCESS);
|
||||
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value);
|
||||
|
||||
error_value = 0;
|
||||
error = MAKE_ERROR(MODULE_HAL, MBED_ERROR_CODE_UNKNOWN);
|
||||
error = MBED_MAKE_ERROR(MBED_MODULE_HAL, MBED_ERROR_CODE_UNKNOWN);
|
||||
MBED_WARNING(error, "HAL Entity error", error_value );
|
||||
lastError = get_last_error();
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TYPE_SYSTEM, MBED_GET_ERROR_TYPE(lastError));
|
||||
TEST_ASSERT_EQUAL_UINT(MODULE_HAL, MBED_GET_ERROR_MODULE(lastError));
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_MODULE_HAL, MBED_GET_ERROR_MODULE(lastError));
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_CODE_UNKNOWN, MBED_GET_ERROR_CODE(lastError));
|
||||
status = get_last_error_log_info( &error_ctx );
|
||||
status = mbed_get_last_error_log_info( &error_ctx );
|
||||
TEST_ASSERT(status == MBED_SUCCESS);
|
||||
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value);
|
||||
|
||||
|
|
@ -121,7 +121,7 @@ void test_error_context_capture()
|
|||
mbed_error_ctx error_ctx = {0};
|
||||
|
||||
MBED_WARNING(MBED_ERROR_INVALID_ARGUMENT, "System type error", error_value );
|
||||
mbed_error_status_t status = get_last_error_log_info( &error_ctx );
|
||||
mbed_error_status_t status = mbed_get_last_error_log_info( &error_ctx );
|
||||
TEST_ASSERT(status == MBED_SUCCESS);
|
||||
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value);
|
||||
TEST_ASSERT_EQUAL_UINT(osThreadGetId(), error_ctx.thread_id);
|
||||
|
|
@ -144,22 +144,22 @@ void test_error_logging()
|
|||
mbed_error_ctx error_ctx = {0};
|
||||
|
||||
//clear the current errors first
|
||||
clear_all_errors();
|
||||
mbed_clear_all_errors();
|
||||
|
||||
//log 3 errors and retrieve them to ensure they are correct
|
||||
MBED_WARNING(MBED_ERROR_INVALID_ARGUMENT, "Invalid argument", 1 );
|
||||
MBED_WARNING(MBED_ERROR_INVALID_SIZE, "Invalid size", 2 );
|
||||
MBED_WARNING(MBED_ERROR_INVALID_FORMAT, "Invalid format", 3 );
|
||||
|
||||
mbed_error_status_t status = get_error_log_info( 0, &error_ctx );
|
||||
mbed_error_status_t status = mbed_get_error_log_info( 0, &error_ctx );
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_INVALID_ARGUMENT, error_ctx.error_status);
|
||||
TEST_ASSERT_EQUAL_UINT(1, error_ctx.error_value);
|
||||
|
||||
status = get_error_log_info( 1, &error_ctx );
|
||||
status = mbed_get_error_log_info( 1, &error_ctx );
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_INVALID_SIZE, error_ctx.error_status);
|
||||
TEST_ASSERT_EQUAL_UINT(2, error_ctx.error_value);
|
||||
|
||||
status = get_error_log_info( 2, &error_ctx );
|
||||
status = mbed_get_error_log_info( 2, &error_ctx );
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_INVALID_FORMAT, error_ctx.error_status);
|
||||
TEST_ASSERT_EQUAL_UINT(3, error_ctx.error_value);
|
||||
|
||||
|
|
@ -175,24 +175,24 @@ void test_error_logging()
|
|||
MBED_WARNING(MBED_ERROR_UNSUPPORTED, "Not supported", 12 );
|
||||
MBED_WARNING(MBED_ERROR_ACCESS_DENIED, "Access denied", 13 );
|
||||
|
||||
status = get_error_log_info( 0, &error_ctx );
|
||||
status = mbed_get_error_log_info( 0, &error_ctx );
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TIME_OUT, error_ctx.error_status);
|
||||
TEST_ASSERT_EQUAL_UINT(10, error_ctx.error_value);
|
||||
|
||||
status = get_error_log_info( 1, &error_ctx );
|
||||
status = mbed_get_error_log_info( 1, &error_ctx );
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_ALREADY_IN_USE, error_ctx.error_status);
|
||||
TEST_ASSERT_EQUAL_UINT(11, error_ctx.error_value);
|
||||
|
||||
status = get_error_log_info( 2, &error_ctx );
|
||||
status = mbed_get_error_log_info( 2, &error_ctx );
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_UNSUPPORTED, error_ctx.error_status);
|
||||
TEST_ASSERT_EQUAL_UINT(12, error_ctx.error_value);
|
||||
|
||||
status = get_error_log_info( 3, &error_ctx );
|
||||
status = mbed_get_error_log_info( 3, &error_ctx );
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_ACCESS_DENIED, error_ctx.error_status);
|
||||
TEST_ASSERT_EQUAL_UINT(13, error_ctx.error_value);
|
||||
|
||||
//Try an index which is invalid, we should get ERROR_INVALID_ARGUMENT back
|
||||
status = get_error_log_info( 99, &error_ctx );
|
||||
status = mbed_get_error_log_info( 99, &error_ctx );
|
||||
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_INVALID_ARGUMENT, status);
|
||||
|
||||
}
|
||||
|
|
@ -228,10 +228,10 @@ void test_error_logging_multithread()
|
|||
errThread[i]->join();
|
||||
}
|
||||
|
||||
i = get_error_log_count()-1;
|
||||
i = mbed_get_error_log_count()-1;
|
||||
//printf("\nError log count = %d\n", i+1);
|
||||
for(;i>=0;--i) {
|
||||
mbed_error_status_t status = get_error_log_info( i, &error_ctx );
|
||||
mbed_error_status_t status = mbed_get_error_log_info( i, &error_ctx );
|
||||
if(status != MBED_SUCCESS) {
|
||||
TEST_FAIL();
|
||||
}
|
||||
|
|
@ -252,7 +252,7 @@ void MyErrorHook(const mbed_error_ctx *error_ctx)
|
|||
*/
|
||||
void test_error_hook()
|
||||
{
|
||||
if( MBED_SUCCESS != set_error_hook(MyErrorHook)) {
|
||||
if( MBED_SUCCESS != mbed_set_error_hook(MyErrorHook)) {
|
||||
TEST_FAIL();
|
||||
}
|
||||
|
||||
|
|
@ -317,7 +317,7 @@ void test_save_error_log()
|
|||
TEST_FAIL();
|
||||
}
|
||||
|
||||
if(MBED_SUCCESS != save_error_log("/fs/errors.log")) {
|
||||
if(MBED_SUCCESS != mbed_save_error_log("/fs/errors.log")) {
|
||||
printf("Failed saving error log");
|
||||
TEST_FAIL();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -123,7 +123,7 @@ u32_t sys_now(void) {
|
|||
*---------------------------------------------------------------------------*/
|
||||
err_t sys_mbox_new(sys_mbox_t *mbox, int queue_sz) {
|
||||
if (queue_sz > MB_SIZE)
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_INVALID_SIZE), "sys_mbox_new size error\n", queue_sz);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_INVALID_SIZE), "sys_mbox_new size error\n", queue_sz);
|
||||
|
||||
memset(mbox, 0, sizeof(*mbox));
|
||||
|
||||
|
|
@ -131,7 +131,7 @@ err_t sys_mbox_new(sys_mbox_t *mbox, int queue_sz) {
|
|||
mbox->attr.cb_size = sizeof(mbox->data);
|
||||
mbox->id = osEventFlagsNew(&mbox->attr);
|
||||
if (mbox->id == NULL)
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_CREATE_FAILED), "sys_mbox_new create error\n", mbox->id);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_CREATE_FAILED), "sys_mbox_new create error\n", mbox->id);
|
||||
|
||||
osEventFlagsSet(mbox->id, SYS_MBOX_POST_EVENT);
|
||||
|
||||
|
|
@ -150,7 +150,7 @@ err_t sys_mbox_new(sys_mbox_t *mbox, int queue_sz) {
|
|||
*---------------------------------------------------------------------------*/
|
||||
void sys_mbox_free(sys_mbox_t *mbox) {
|
||||
if (mbox->post_idx != mbox->fetch_idx)
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_FREE_FAILED), "sys_mbox_free error\n", mbox->post_idx);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_FREE_FAILED), "sys_mbox_free error\n", mbox->post_idx);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------------------*
|
||||
|
|
@ -309,7 +309,7 @@ err_t sys_sem_new(sys_sem_t *sem, u8_t count) {
|
|||
sem->attr.cb_size = sizeof(sem->data);
|
||||
sem->id = osSemaphoreNew(UINT16_MAX, count, &sem->attr);
|
||||
if (sem->id == NULL)
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_CREATE_FAILED), "sys_sem_new create error\n", sem->id);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_CREATE_FAILED), "sys_sem_new create error\n", sem->id);
|
||||
|
||||
return ERR_OK;
|
||||
}
|
||||
|
|
@ -388,14 +388,14 @@ err_t sys_mutex_new(sys_mutex_t *mutex) {
|
|||
* @param mutex the mutex to lock */
|
||||
void sys_mutex_lock(sys_mutex_t *mutex) {
|
||||
if (osMutexAcquire(mutex->id, osWaitForever) != osOK)
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_mutex_lock error\n", mutex->id);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_mutex_lock error\n", mutex->id);
|
||||
}
|
||||
|
||||
/** Unlock a mutex
|
||||
* @param mutex the mutex to unlock */
|
||||
void sys_mutex_unlock(sys_mutex_t *mutex) {
|
||||
if (osMutexRelease(mutex->id) != osOK)
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_UNLOCK_FAILED), "sys_mutex_unlock error\n", mutex->id);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_UNLOCK_FAILED), "sys_mutex_unlock error\n", mutex->id);
|
||||
}
|
||||
|
||||
/** Delete a mutex
|
||||
|
|
@ -418,7 +418,7 @@ void sys_init(void) {
|
|||
lwip_sys_mutex_attr.cb_size = sizeof(lwip_sys_mutex_data);
|
||||
lwip_sys_mutex = osMutexNew(&lwip_sys_mutex_attr);
|
||||
if (lwip_sys_mutex == NULL)
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_INITIALIZATION_FAILED), "sys_init error\n", lwip_sys_mutex);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_INITIALIZATION_FAILED), "sys_init error\n", lwip_sys_mutex);
|
||||
}
|
||||
|
||||
/*---------------------------------------------------------------------------*
|
||||
|
|
@ -452,7 +452,7 @@ u32_t sys_jiffies(void) {
|
|||
*---------------------------------------------------------------------------*/
|
||||
sys_prot_t sys_arch_protect(void) {
|
||||
if (osMutexAcquire(lwip_sys_mutex, osWaitForever) != osOK)
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_arch_protect error\n", lwip_sys_mutex);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_arch_protect error\n", lwip_sys_mutex);
|
||||
return (sys_prot_t) 1;
|
||||
}
|
||||
|
||||
|
|
@ -469,7 +469,7 @@ sys_prot_t sys_arch_protect(void) {
|
|||
*---------------------------------------------------------------------------*/
|
||||
void sys_arch_unprotect(sys_prot_t p) {
|
||||
if (osMutexRelease(lwip_sys_mutex) != osOK)
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_arch_unprotect error\n", lwip_sys_mutex);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_MUTEX_LOCK_FAILED), "sys_arch_unprotect error\n", lwip_sys_mutex);
|
||||
}
|
||||
|
||||
u32_t sys_now(void) {
|
||||
|
|
@ -508,7 +508,7 @@ sys_thread_t sys_thread_new(const char *pcName,
|
|||
LWIP_DEBUGF(SYS_DEBUG, ("New Thread: %s\n", pcName));
|
||||
|
||||
if (thread_pool_index >= SYS_THREAD_POOL_N)
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_THREAD_CREATE_FAILED), "sys_thread_new number error\n", thread_pool_index);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_THREAD_CREATE_FAILED), "sys_thread_new number error\n", thread_pool_index);
|
||||
sys_thread_t t = (sys_thread_t)&thread_pool[thread_pool_index];
|
||||
thread_pool_index++;
|
||||
|
||||
|
|
@ -520,11 +520,11 @@ sys_thread_t sys_thread_new(const char *pcName,
|
|||
t->attr.stack_size = stacksize;
|
||||
t->attr.stack_mem = malloc(stacksize);
|
||||
if (t->attr.stack_mem == NULL) {
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_OUT_OF_MEMORY), "Error allocating the stack memory", t);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_OUT_OF_MEMORY), "Error allocating the stack memory", t);
|
||||
}
|
||||
t->id = osThreadNew((osThreadFunc_t)thread, arg, &t->attr);
|
||||
if (t->id == NULL)
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_NETWORK_STACK, MBED_ERROR_CODE_THREAD_CREATE_FAILED), "sys_thread_new create error\n", t->id);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_NETWORK_STACK, MBED_ERROR_CODE_THREAD_CREATE_FAILED), "sys_thread_new create error\n", t->id);
|
||||
|
||||
return t;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -57,13 +57,13 @@ int ReadOnlyBlockDevice::read(void *buffer, bd_addr_t addr, bd_size_t size)
|
|||
|
||||
int ReadOnlyBlockDevice::program(const void *buffer, bd_addr_t addr, bd_size_t size)
|
||||
{
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_BLOCK_DEVICE, MBED_ERROR_CODE_WRITE_PROTECTED), "ReadOnlyBlockDevice::program() not allowed", addr);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_BLOCK_DEVICE, MBED_ERROR_CODE_WRITE_PROTECTED), "ReadOnlyBlockDevice::program() not allowed", addr);
|
||||
return MBED_ERROR_WRITE_PROTECTED;
|
||||
}
|
||||
|
||||
int ReadOnlyBlockDevice::erase(bd_addr_t addr, bd_size_t size)
|
||||
{
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_BLOCK_DEVICE, MBED_ERROR_CODE_WRITE_PROTECTED), "ReadOnlyBlockDevice::erase() not allowed", addr);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_BLOCK_DEVICE, MBED_ERROR_CODE_WRITE_PROTECTED), "ReadOnlyBlockDevice::erase() not allowed", addr);
|
||||
return MBED_ERROR_WRITE_PROTECTED;
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ void pinmap_pinout(PinName pin, const PinMap *map) {
|
|||
}
|
||||
map++;
|
||||
}
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "could not pinout", pin);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "could not pinout", pin);
|
||||
}
|
||||
|
||||
uint32_t pinmap_merge(uint32_t a, uint32_t b) {
|
||||
|
|
@ -44,7 +44,7 @@ uint32_t pinmap_merge(uint32_t a, uint32_t b) {
|
|||
return a;
|
||||
|
||||
// mis-match error case
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "pinmap mis-match", a);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "pinmap mis-match", a);
|
||||
return (uint32_t)NC;
|
||||
}
|
||||
|
||||
|
|
@ -64,7 +64,7 @@ uint32_t pinmap_peripheral(PinName pin, const PinMap* map) {
|
|||
return (uint32_t)NC;
|
||||
peripheral = pinmap_find_peripheral(pin, map);
|
||||
if ((uint32_t)NC == peripheral) // no mapping available
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "pinmap not found for peripheral", peripheral);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "pinmap not found for peripheral", peripheral);
|
||||
return peripheral;
|
||||
}
|
||||
|
||||
|
|
@ -84,6 +84,6 @@ uint32_t pinmap_function(PinName pin, const PinMap* map) {
|
|||
return (uint32_t)NC;
|
||||
function = pinmap_find_function(pin, map);
|
||||
if ((uint32_t)NC == function) // no mapping available
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "pinmap not found for function", function);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_PINMAP_INVALID), "pinmap not found for function", function);
|
||||
return function;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -161,7 +161,7 @@ void sleep_manager_lock_deep_sleep_internal(void)
|
|||
core_util_critical_section_enter();
|
||||
if (deep_sleep_lock == USHRT_MAX) {
|
||||
core_util_critical_section_exit();
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_HAL, MBED_ERROR_CODE_OVERFLOW), "DeepSleepLock overflow (> USHRT_MAX)", deep_sleep_lock);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_HAL, MBED_ERROR_CODE_OVERFLOW), "DeepSleepLock overflow (> USHRT_MAX)", deep_sleep_lock);
|
||||
}
|
||||
core_util_atomic_incr_u16(&deep_sleep_lock, 1);
|
||||
core_util_critical_section_exit();
|
||||
|
|
@ -172,7 +172,7 @@ void sleep_manager_unlock_deep_sleep_internal(void)
|
|||
core_util_critical_section_enter();
|
||||
if (deep_sleep_lock == 0) {
|
||||
core_util_critical_section_exit();
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_HAL, MBED_ERROR_CODE_UNDERFLOW), "DeepSleepLock underflow (< 0)", deep_sleep_lock);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_HAL, MBED_ERROR_CODE_UNDERFLOW), "DeepSleepLock underflow (< 0)", deep_sleep_lock);
|
||||
}
|
||||
core_util_atomic_decr_u16(&deep_sleep_lock, 1);
|
||||
core_util_critical_section_exit();
|
||||
|
|
|
|||
|
|
@ -69,7 +69,7 @@ public:
|
|||
sleep_manager_lock_deep_sleep();
|
||||
}
|
||||
if (0 == count) {
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_OVERFLOW), "DeepSleepLock overflow (> USHRT_MAX)", count);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OVERFLOW), "DeepSleepLock overflow (> USHRT_MAX)", count);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -83,7 +83,7 @@ public:
|
|||
}
|
||||
if (count == USHRT_MAX) {
|
||||
core_util_critical_section_exit();
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_UNDERFLOW), "DeepSleepLock underflow (< 0)", count);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_UNDERFLOW), "DeepSleepLock underflow (< 0)", count);
|
||||
}
|
||||
}
|
||||
};
|
||||
|
|
|
|||
|
|
@ -29,7 +29,7 @@ Stream::Stream(const char *name) : FileLike(name), _file(NULL) {
|
|||
if (_file) {
|
||||
mbed_set_unbuffered_stream(_file);
|
||||
} else {
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_OPEN_FAILED), "Stream obj failure", _file);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OPEN_FAILED), "Stream obj failure", _file);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -175,7 +175,7 @@ WEAK mbed_error_status_t mbed_error(mbed_error_status_t error_status, const char
|
|||
}
|
||||
|
||||
//Register an application defined callback with error handling
|
||||
mbed_error_status_t set_error_hook(mbed_error_hook_t error_hook_in)
|
||||
mbed_error_status_t mbed_set_error_hook(mbed_error_hook_t error_hook_in)
|
||||
{
|
||||
//register the new hook/callback
|
||||
if( error_hook_in != NULL ) {
|
||||
|
|
@ -187,21 +187,21 @@ mbed_error_status_t set_error_hook(mbed_error_hook_t error_hook_in)
|
|||
}
|
||||
|
||||
//Retrieve the first error context from error log
|
||||
mbed_error_status_t get_first_error_log_info (mbed_error_ctx *error_info)
|
||||
mbed_error_status_t mbed_get_first_error_log_info (mbed_error_ctx *error_info)
|
||||
{
|
||||
memcpy(error_info, &first_error_ctx, sizeof(first_error_ctx));
|
||||
return MBED_SUCCESS;
|
||||
}
|
||||
|
||||
//Retrieve the last error context from error log
|
||||
mbed_error_status_t get_last_error_log_info (mbed_error_ctx *error_info)
|
||||
mbed_error_status_t mbed_get_last_error_log_info (mbed_error_ctx *error_info)
|
||||
{
|
||||
memcpy(error_info, &last_error_ctx, sizeof(mbed_error_ctx));
|
||||
return MBED_SUCCESS;
|
||||
}
|
||||
|
||||
//Makes an mbed_error_status_t value
|
||||
mbed_error_status_t make_mbed_error(mbed_error_type_t error_type, mbed_module_type_t entity, mbed_error_code_t error_code)
|
||||
mbed_error_status_t mbed_make_error(mbed_error_type_t error_type, mbed_module_type_t entity, mbed_error_code_t error_code)
|
||||
{
|
||||
switch(error_type)
|
||||
{
|
||||
|
|
@ -225,7 +225,7 @@ mbed_error_status_t make_mbed_error(mbed_error_type_t error_type, mbed_module_ty
|
|||
}
|
||||
|
||||
//If we are passed incorrect values return a generic system error
|
||||
return MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, MODULE_UNKNOWN, MBED_ERROR_CODE_UNKNOWN);
|
||||
return MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, MBED_MODULE_UNKNOWN, MBED_ERROR_CODE_UNKNOWN);
|
||||
}
|
||||
|
||||
/**
|
||||
|
|
@ -233,7 +233,7 @@ mbed_error_status_t make_mbed_error(mbed_error_type_t error_type, mbed_module_ty
|
|||
* @return 0 or MBED_SUCCESS on success.
|
||||
*
|
||||
*/
|
||||
mbed_error_status_t clear_all_errors(void)
|
||||
mbed_error_status_t mbed_clear_all_errors(void)
|
||||
{
|
||||
mbed_error_status_t status = MBED_SUCCESS;
|
||||
|
||||
|
|
@ -253,18 +253,18 @@ mbed_error_status_t clear_all_errors(void)
|
|||
|
||||
#ifndef MBED_CONF_ERROR_LOG_DISABLED
|
||||
//Retrieve the error context from error log at the specified index
|
||||
mbed_error_status_t get_error_log_info (int index, mbed_error_ctx *error_info)
|
||||
mbed_error_status_t mbed_get_error_log_info (int index, mbed_error_ctx *error_info)
|
||||
{
|
||||
return mbed_log_get_error(index, error_info);
|
||||
}
|
||||
|
||||
//Retrieve the error log count
|
||||
int get_error_log_count(void)
|
||||
int mbed_get_error_log_count(void)
|
||||
{
|
||||
return mbed_log_get_error_log_count();
|
||||
}
|
||||
|
||||
mbed_error_status_t save_error_log(const char *path)
|
||||
mbed_error_status_t mbed_save_error_log(const char *path)
|
||||
{
|
||||
mbed_error_status_t ret = MBED_SUCCESS;
|
||||
mbed_error_ctx ctx = {0};
|
||||
|
|
@ -273,13 +273,13 @@ mbed_error_status_t save_error_log(const char *path)
|
|||
|
||||
//Ensure path is valid
|
||||
if(path==NULL) {
|
||||
ret = MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_INVALID_ARGUMENT);
|
||||
ret = MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_INVALID_ARGUMENT);
|
||||
goto exit;
|
||||
}
|
||||
|
||||
//Open the file for saving the error log info
|
||||
if((error_log_file = fopen( path, "w" ) ) == NULL){
|
||||
ret = MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_OPEN_FAILED);
|
||||
ret = MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OPEN_FAILED);
|
||||
goto exit;
|
||||
}
|
||||
|
||||
|
|
@ -289,7 +289,7 @@ mbed_error_status_t save_error_log(const char *path)
|
|||
(unsigned int)first_error_ctx.thread_id,
|
||||
(unsigned int)first_error_ctx.error_address,
|
||||
(unsigned int)first_error_ctx.error_value) <= 0) {
|
||||
ret = MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_WRITE_FAILED);
|
||||
ret = MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_WRITE_FAILED);
|
||||
goto exit;
|
||||
}
|
||||
|
||||
|
|
@ -298,7 +298,7 @@ mbed_error_status_t save_error_log(const char *path)
|
|||
(unsigned int)last_error_ctx.thread_id,
|
||||
(unsigned int)last_error_ctx.error_address,
|
||||
(unsigned int)last_error_ctx.error_value) <= 0) {
|
||||
ret = MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_WRITE_FAILED);
|
||||
ret = MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_WRITE_FAILED);
|
||||
goto exit;
|
||||
}
|
||||
|
||||
|
|
@ -312,7 +312,7 @@ mbed_error_status_t save_error_log(const char *path)
|
|||
(unsigned int)ctx.thread_id,
|
||||
(unsigned int)ctx.error_address,
|
||||
(unsigned int)ctx.error_value) <= 0) {
|
||||
ret = MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_WRITE_FAILED);
|
||||
ret = MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_WRITE_FAILED);
|
||||
goto exit;
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -89,7 +89,7 @@ extern "C" {
|
|||
* Custom Error Codes - 4096 to 65535.\n
|
||||
*
|
||||
* @note Posix error codes are always encoded as negative of their actual value. For example, EPERM is encoded as -EPERM.
|
||||
* And, the MODULE TYPE for Posix error codes are always encoded as MODULE_UNKNOWN.\n
|
||||
* And, the MODULE TYPE for Posix error codes are always encoded as MBED_MODULE_UNKNOWN.\n
|
||||
* This is to enable easy injection of Posix error codes into MbedOS error handling system without altering the actual Posix error values.\n
|
||||
* Accordingly, Posix error codes are represented as -1 to -255 under MbedOS error status representation.
|
||||
*/
|
||||
|
|
@ -113,7 +113,7 @@ typedef int mbed_error_status_t;
|
|||
*/
|
||||
#define MBED_DEFINE_SYSTEM_ERROR( error_name, error_code ) \
|
||||
MBED_ERROR_CODE_##error_name = MBED_SYSTEM_ERROR_BASE + error_code, \
|
||||
MBED_ERROR_##error_name = MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, MODULE_UNKNOWN, MBED_ERROR_CODE_##error_name)
|
||||
MBED_ERROR_##error_name = MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, MBED_MODULE_UNKNOWN, MBED_ERROR_CODE_##error_name)
|
||||
|
||||
/**
|
||||
* Macro for defining a Custom error status. This macro is used to define custom error values in mbed_error_code_t enumeration.
|
||||
|
|
@ -123,7 +123,7 @@ typedef int mbed_error_status_t;
|
|||
*/
|
||||
#define MBED_DEFINE_CUSTOM_ERROR( error_name, error_code ) \
|
||||
MBED_ERROR_CODE_##error_name = MBED_CUSTOM_ERROR_BASE + error_code, \
|
||||
MBED_ERROR_##error_name = MAKE_MBED_ERROR(MBED_ERROR_TYPE_CUSTOM, MODULE_UNKNOWN, MBED_ERROR_CODE_##error_name)
|
||||
MBED_ERROR_##error_name = MAKE_MBED_ERROR(MBED_ERROR_TYPE_CUSTOM, MBED_MODULE_UNKNOWN, MBED_ERROR_CODE_##error_name)
|
||||
|
||||
|
||||
/**
|
||||
|
|
@ -195,30 +195,30 @@ typedef enum _mbed_error_type_t
|
|||
* @note
|
||||
* This enumeration defines the module types. The value of these enum values will be encoded into mbed_error_status_t MODULE field.\n\n
|
||||
* See mbed_error_status_t description for more info.\n
|
||||
* 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
|
||||
* 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
|
||||
* Other module values can be used to provide more info on who/where the error originated from.\n\n
|
||||
* For example, if I2C driver is the component originating the error you can use MODULE_DRIVER_I2C to provide more info.\n
|
||||
* Its used in call to MAKE_ERROR/MAKE_SYSTEM_ERROR/MAKE_CUSTOM_ERROR macros.\n
|
||||
* For example, if I2C driver is the component originating the error you can use MBED_MODULE_DRIVER_I2C to provide more info.\n
|
||||
* Its used in call to MBED_MAKE_ERROR/MBED_MAKE_SYSTEM_ERROR/MBED_MAKE_CUSTOM_ERROR macros.\n
|
||||
*
|
||||
* @code
|
||||
* Example: mbed_error_status_t i2c_driver_error = MAKE_ERROR( MODULE_DRIVER_I2C, MBED_ERROR_CONFIG_UNSUPPORTED );
|
||||
* Example: mbed_error_status_t i2c_driver_error = MBED_MAKE_ERROR( MBED_MODULE_DRIVER_I2C, MBED_ERROR_CONFIG_UNSUPPORTED );
|
||||
* @endcode
|
||||
*
|
||||
* @note
|
||||
* \n Below are the module code mappings:\n
|
||||
\verbatim
|
||||
MODULE_APPLICATION 0 Application
|
||||
MODULE_PLATFORM 1 Platform
|
||||
MBED_MODULE_APPLICATION 0 Application
|
||||
MBED_MODULE_PLATFORM 1 Platform
|
||||
MODULE_KERNEL 2 RTX Kernel
|
||||
MODULE_NETWORK_STACK 3 Network stack
|
||||
MODULE_HAL 4 HAL - Hardware Abstraction Layer
|
||||
MODULE_MEMORY_SUBSYSTEM 5 Memory Subsystem
|
||||
MODULE_FILESYSTEM 6 Filesystem
|
||||
MODULE_BLOCK_DEVICE 7 Block device
|
||||
MODULE_DRIVER 8 Driver
|
||||
MODULE_DRIVER_SERIAL 9 Serial Driver
|
||||
MODULE_DRIVER_RTC 10 RTC Driver
|
||||
MODULE_DRIVER_I2C 11 I2C Driver
|
||||
MBED_MODULE_NETWORK_STACK 3 Network stack
|
||||
MBED_MODULE_HAL 4 HAL - Hardware Abstraction Layer
|
||||
MBED_MODULE_NETWORK_STACKMODULE_MEMORY_SUBSYSTEM 5 Memory Subsystem
|
||||
MBED_MODULE_FILESYSTEM 6 Filesystem
|
||||
MBED_MODULE_BLOCK_DEVICE 7 Block device
|
||||
MBED_MODULE_DRIVER 8 Driver
|
||||
MBED_MODULE_DRIVER_SERIAL 9 Serial Driver
|
||||
MBED_MODULE_DRIVER_RTC 10 RTC Driver
|
||||
MBED_MODULE_DRIVER_I2C 11 I2C Driver
|
||||
MODULE_DRIVER_SPI 12 SPI Driver
|
||||
MODULE_DRIVER_GPIO 13 GPIO Driver
|
||||
MODULE_DRIVER_ANALOG 14 Analog Driver
|
||||
|
|
@ -231,39 +231,39 @@ typedef enum _mbed_error_type_t
|
|||
MODULE_DRIVER_USB 21 USB Driver
|
||||
MODULE_TARGET_SDK 22 SDK
|
||||
|
||||
MODULE_UNKNOWN 255 Unknown module
|
||||
MBED_MODULE_UNKNOWN 255 Unknown module
|
||||
\endverbatim
|
||||
*
|
||||
*/
|
||||
typedef enum _mbed_module_type
|
||||
{
|
||||
MODULE_APPLICATION = 0,
|
||||
MODULE_PLATFORM,
|
||||
MODULE_KERNEL,
|
||||
MODULE_NETWORK_STACK,
|
||||
MODULE_HAL,
|
||||
MODULE_MEMORY_SUBSYSTEM,
|
||||
MODULE_FILESYSTEM,
|
||||
MODULE_BLOCK_DEVICE,
|
||||
MODULE_DRIVER,
|
||||
MODULE_DRIVER_SERIAL,
|
||||
MODULE_DRIVER_RTC,
|
||||
MODULE_DRIVER_I2C,
|
||||
MODULE_DRIVER_SPI,
|
||||
MODULE_DRIVER_GPIO,
|
||||
MODULE_DRIVER_ANALOG,
|
||||
MODULE_DRIVER_DIGITAL,
|
||||
MODULE_DRIVER_CAN,
|
||||
MODULE_DRIVER_ETHERNET,
|
||||
MODULE_DRIVER_CRC,
|
||||
MODULE_DRIVER_PWM,
|
||||
MODULE_DRIVER_QSPI,
|
||||
MODULE_DRIVER_USB,
|
||||
MODULE_TARGET_SDK,
|
||||
MBED_MODULE_APPLICATION = 0,
|
||||
MBED_MODULE_PLATFORM,
|
||||
MBED_MODULE_KERNEL,
|
||||
MBED_MODULE_NETWORK_STACK,
|
||||
MBED_MODULE_HAL,
|
||||
MBED_MODULE_NETWORK_STACKMODULE_MEMORY_SUBSYSTEM,
|
||||
MBED_MODULE_FILESYSTEM,
|
||||
MBED_MODULE_BLOCK_DEVICE,
|
||||
MBED_MODULE_DRIVER,
|
||||
MBED_MODULE_DRIVER_SERIAL,
|
||||
MBED_MODULE_DRIVER_RTC,
|
||||
MBED_MODULE_DRIVER_I2C,
|
||||
MBED_MODULE_DRIVER_SPI,
|
||||
MBED_MODULE_DRIVER_GPIO,
|
||||
MBED_MODULE_DRIVER_ANALOG,
|
||||
MBED_MODULE_DRIVER_DIGITAL,
|
||||
MBED_MODULE_DRIVER_CAN,
|
||||
MBED_MODULE_DRIVER_ETHERNET,
|
||||
MBED_MODULE_DRIVER_CRC,
|
||||
MBED_MODULE_DRIVER_PWM,
|
||||
MBED_MODULE_DRIVER_QSPI,
|
||||
MBED_MODULE_DRIVER_USB,
|
||||
MBED_MODULE_TARGET_SDK,
|
||||
/* Add More entities here as required */
|
||||
|
||||
MODULE_UNKNOWN = 255,
|
||||
MODULE_MAX = MODULE_UNKNOWN
|
||||
MBED_MODULE_UNKNOWN = 255,
|
||||
MBED_MODULE_MAX = MBED_MODULE_UNKNOWN
|
||||
} mbed_module_type_t;
|
||||
|
||||
//Use MBED_SUCCESS(=0) or any postive number for successful returns
|
||||
|
|
@ -276,7 +276,7 @@ typedef enum _mbed_module_type
|
|||
//Error Code definitions
|
||||
/** mbed_error_code_t definition
|
||||
*
|
||||
* mbed_error_code_t enumeration defines the Error codes and Error status values for MODULE_UNKNOWN.\n
|
||||
* mbed_error_code_t enumeration defines the Error codes and Error status values for MBED_MODULE_UNKNOWN.\n
|
||||
* It defines all of Posix Error Codes/Statuses and Mbed System Error Codes/Statuses.\n\n
|
||||
*
|
||||
* @note
|
||||
|
|
@ -432,10 +432,10 @@ typedef enum _mbed_module_type
|
|||
* MbedOS System Error codes are defined using the macro MBED_DEFINE_SYSTEM_ERROR\n
|
||||
* For example MBED_DEFINE_SYSTEM_ERROR( INVALID_ARGUMENT ,1 ) macro defines the following values:\n
|
||||
* ERROR_CODE_INVALID_ARGUMENT = MBED_SYSTEM_ERROR_BASE+1\n
|
||||
* ERROR_INVALID_ARGUMENT = MAKE_MBED_ERROR(ERROR_TYPE_SYSTEM, MODULE_UNKNOWN, ERROR_CODE_INVALID_ARGUMENT)\n
|
||||
* ERROR_INVALID_ARGUMENT = MAKE_MBED_ERROR(ERROR_TYPE_SYSTEM, MBED_MODULE_UNKNOWN, ERROR_CODE_INVALID_ARGUMENT)\n
|
||||
* Its effectively equivalent to:\n
|
||||
* ERROR_CODE_INVALID_ARGUMENT = 1\n
|
||||
* ERROR_INVALID_ARGUMENT = 0x80FF0001\n (Note that MODULE field is set to MODULE_UNKNOWN)
|
||||
* ERROR_INVALID_ARGUMENT = 0x80FF0001\n (Note that MODULE field is set to MBED_MODULE_UNKNOWN)
|
||||
* New System Error codes should be defined using MBED_DEFINE_SYSTEM_ERROR macro and must have an unique error code value\n
|
||||
* passed as the second argument in the MBED_DEFINE_SYSTEM_ERROR macro.\n\n
|
||||
* Below are the Mbed System error codes and the description:
|
||||
|
|
@ -512,10 +512,10 @@ typedef enum _mbed_module_type
|
|||
* This is mainly meant to capture non-generic error codes specific to a device.
|
||||
* For example DEFINE_CUSTOM_ERROR( MY_CUSTOM_ERROR ,1 ) macro defines the following values:\n
|
||||
* ERROR_CODE_MY_CUSTOM_ERROR = MBED_CUSTOM_ERROR_BASE+1\n
|
||||
* ERROR_MY_CUSTOM_ERROR = MAKE_MBED_ERROR(ERROR_TYPE_CUSTOM, MODULE_UNKNOWN, ERROR_CODE_MY_CUSTOM_ERROR)\n
|
||||
* ERROR_MY_CUSTOM_ERROR = MAKE_MBED_ERROR(ERROR_TYPE_CUSTOM, MBED_MODULE_UNKNOWN, ERROR_CODE_MY_CUSTOM_ERROR)\n
|
||||
* Its effectively equivalent to:\n
|
||||
* ERROR_CODE_MY_CUSTOM_ERROR = 4097\n
|
||||
* ERROR_MY_CUSTOM_ERROR = 0xA0FF1001\n (Note that MODULE field is set to MODULE_UNKNOWN) \n\n
|
||||
* ERROR_MY_CUSTOM_ERROR = 0xA0FF1001\n (Note that MODULE field is set to MBED_MODULE_UNKNOWN) \n\n
|
||||
*
|
||||
* @note
|
||||
* **Using error codes:** \n
|
||||
|
|
@ -852,51 +852,51 @@ void error(const char* format, ...);
|
|||
|
||||
/**
|
||||
* Call this Macro to generate a mbed_error_status_t value for a System error
|
||||
* @param module Module generating the error code. If its unknown, pass MODULE_UNKNOWN. See mbed_module_type_t for module types.
|
||||
* @param module Module generating the error code. If its unknown, pass MBED_MODULE_UNKNOWN. See mbed_module_type_t for module types.
|
||||
* @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.
|
||||
*
|
||||
* @code
|
||||
*
|
||||
* mbed_error_status_t driver_error = MAKE_SYSTEM_ERROR( MODULE_DRIVER_USB, MBED_ERROR_CODE_INITIALIZATION_FAILED )
|
||||
* mbed_error_status_t driver_error = MBED_MAKE_SYSTEM_ERROR( MODULE_DRIVER_USB, MBED_ERROR_CODE_INITIALIZATION_FAILED )
|
||||
*
|
||||
* @endcode
|
||||
* @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_SYSTEM
|
||||
*
|
||||
*/
|
||||
#define MAKE_SYSTEM_ERROR(module, error_code) MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, module, error_code)
|
||||
#define MBED_MAKE_SYSTEM_ERROR(module, error_code) MAKE_MBED_ERROR(MBED_ERROR_TYPE_SYSTEM, module, error_code)
|
||||
|
||||
/**
|
||||
* Call this Macro to generate a mbed_error_status_t value for a Custom error
|
||||
* @param module Module generating the error code. If its unknown, pass MODULE_UNKNOWN. See mbed_module_type_t for module types.
|
||||
* @param module Module generating the error code. If its unknown, pass MBED_MODULE_UNKNOWN. See mbed_module_type_t for module types.
|
||||
* @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.
|
||||
*
|
||||
* @code
|
||||
*
|
||||
* mbed_error_status_t custom_error = MAKE_CUSTOM_ERROR( MODULE_APPLICATION, 0xDEAD//16-bit custom error code )
|
||||
* mbed_error_status_t custom_error = MBED_MAKE_CUSTOM_ERROR( MBED_MODULE_APPLICATION, 0xDEAD//16-bit custom error code )
|
||||
*
|
||||
* @endcode
|
||||
* @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_CUSTOM
|
||||
*
|
||||
*/
|
||||
#define MAKE_CUSTOM_ERROR(module, error_code) MAKE_MBED_ERROR(MBED_ERROR_TYPE_CUSTOM, module, error_code)
|
||||
#define MBED_MAKE_CUSTOM_ERROR(module, error_code) MAKE_MBED_ERROR(MBED_ERROR_TYPE_CUSTOM, module, error_code)
|
||||
|
||||
/**
|
||||
* Call this Macro to generate a mbed_error_status_t value for a System error
|
||||
* @param module Module generating the error code. If its unknown, pass MODULE_UNKNOWN. See mbed_module_type_t for module types.
|
||||
* @param module Module generating the error code. If its unknown, pass MBED_MODULE_UNKNOWN. See mbed_module_type_t for module types.
|
||||
* @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.
|
||||
*
|
||||
* @code
|
||||
*
|
||||
* mbed_error_status_t new_error = MAKE_ERROR( MODULE_DRIVER_USB, MBED_ERROR_INITIALIZATION_FAILED )
|
||||
* mbed_error_status_t new_error = MBED_MAKE_ERROR( MODULE_DRIVER_USB, MBED_ERROR_INITIALIZATION_FAILED )
|
||||
*
|
||||
* @endcode
|
||||
* @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_SYSTEM
|
||||
*
|
||||
*/
|
||||
#define MAKE_ERROR(module, error_code) MAKE_SYSTEM_ERROR(module, error_code)
|
||||
#define MBED_MAKE_ERROR(module, error_code) MBED_MAKE_SYSTEM_ERROR(module, error_code)
|
||||
|
||||
/**
|
||||
* Callback/Error hook function prototype. Applications needing a callback when an error is reported can use set_error_hook function
|
||||
* Callback/Error hook function prototype. Applications needing a callback when an error is reported can use mbed_set_error_hook function
|
||||
* to register a callback/error hook function using the following prototype. When an error happens in the system error handling
|
||||
* implementation will invoke this callback with the mbed_error_status_t reported and the error context at the time of error.
|
||||
* @param error_status mbed_error_status_t status being reported.
|
||||
|
|
@ -983,13 +983,13 @@ mbed_error_status_t mbed_error(mbed_error_status_t error_status, const char *err
|
|||
* //Do something with the error_status or error_ctx
|
||||
* }
|
||||
*
|
||||
* set_error_hook( my_custom_error_hook )
|
||||
* mbed_set_error_hook( my_custom_error_hook )
|
||||
*
|
||||
* @endcode
|
||||
* @note The erro hook function implementation should be re-entrant.
|
||||
*
|
||||
*/
|
||||
mbed_error_status_t set_error_hook(mbed_error_hook_t custom_error_hook);
|
||||
mbed_error_status_t mbed_set_error_hook(mbed_error_hook_t custom_error_hook);
|
||||
|
||||
/**
|
||||
* Reads the first error context information logged.
|
||||
|
|
@ -998,7 +998,7 @@ mbed_error_status_t set_error_hook(mbed_error_hook_t custom_error_hook);
|
|||
* MBED_ERROR_INVALID_ARGUMENT in case of invalid index
|
||||
*
|
||||
*/
|
||||
mbed_error_status_t get_first_error_log_info(mbed_error_ctx *error_info);
|
||||
mbed_error_status_t mbed_get_first_error_log_info(mbed_error_ctx *error_info);
|
||||
|
||||
/**
|
||||
* Reads the last error context information logged.
|
||||
|
|
@ -1007,14 +1007,14 @@ mbed_error_status_t get_first_error_log_info(mbed_error_ctx *error_info);
|
|||
* MBED_ERROR_INVALID_ARGUMENT in case of invalid index
|
||||
*
|
||||
*/
|
||||
mbed_error_status_t get_last_error_log_info(mbed_error_ctx *error_info);
|
||||
mbed_error_status_t mbed_get_last_error_log_info(mbed_error_ctx *error_info);
|
||||
|
||||
/**
|
||||
* Clears all the last error, error count and all entries in the error log.
|
||||
* @return 0 or MBED_SUCCESS on success.
|
||||
*
|
||||
*/
|
||||
mbed_error_status_t clear_all_errors(void);
|
||||
mbed_error_status_t mbed_clear_all_errors(void);
|
||||
|
||||
/**
|
||||
* Generates a mbed_error_status_t value based on passed in values for type, module and error code.
|
||||
|
|
@ -1024,14 +1024,14 @@ mbed_error_status_t clear_all_errors(void);
|
|||
* @return 0 or MBED_ERROR_SUCCESS on success.
|
||||
*
|
||||
*/
|
||||
mbed_error_status_t make_mbed_error(mbed_error_type_t error_type, mbed_module_type_t module, mbed_error_code_t error_code);
|
||||
mbed_error_status_t mbed_make_error(mbed_error_type_t error_type, mbed_module_type_t module, mbed_error_code_t error_code);
|
||||
|
||||
/**
|
||||
* Returns the current number of entries in the error log, if there has been more than max number of errors logged the number returned will be max depth of error log.
|
||||
* @return Current number of entries in the error log.
|
||||
*
|
||||
*/
|
||||
int get_error_log_count(void);
|
||||
int mbed_get_error_log_count(void);
|
||||
|
||||
/**
|
||||
* Reads the error context information for a specific error log specified by the index.
|
||||
|
|
@ -1044,7 +1044,7 @@ int get_error_log_count(void);
|
|||
* MBED_ERROR_INVALID_ARGUMENT in case of invalid index
|
||||
*
|
||||
*/
|
||||
mbed_error_status_t get_error_log_info(int index, mbed_error_ctx *error_info);
|
||||
mbed_error_status_t mbed_get_error_log_info(int index, mbed_error_ctx *error_info);
|
||||
|
||||
/**
|
||||
* Saves the error log information to a file
|
||||
|
|
@ -1057,7 +1057,7 @@ mbed_error_status_t get_error_log_info(int index, mbed_error_ctx *error_info);
|
|||
* @note Filesystem support is required in order for this function to work.
|
||||
*
|
||||
*/
|
||||
mbed_error_status_t save_error_log(const char *path);
|
||||
mbed_error_status_t mbed_save_error_log(const char *path);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
|
|
|
|||
|
|
@ -538,7 +538,7 @@ extern "C" int PREFIX(_write)(FILEHANDLE fh, const unsigned char *buffer, unsign
|
|||
|
||||
#if defined(MBED_TRAP_ERRORS_ENABLED) && MBED_TRAP_ERRORS_ENABLED && defined(MBED_CONF_RTOS_PRESENT)
|
||||
if (core_util_is_isr_active() || !core_util_are_interrupts_enabled()) {
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_PROHIBITED_IN_ISR_CONTEXT), "Error - writing to a file in an ISR or critical section\r\n", fh);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_PROHIBITED_IN_ISR_CONTEXT), "Error - writing to a file in an ISR or critical section\r\n", fh);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -646,7 +646,7 @@ extern "C" int PREFIX(_read)(FILEHANDLE fh, unsigned char *buffer, unsigned int
|
|||
|
||||
#if defined(MBED_TRAP_ERRORS_ENABLED) && MBED_TRAP_ERRORS_ENABLED && defined(MBED_CONF_RTOS_PRESENT)
|
||||
if (core_util_is_isr_active() || !core_util_are_interrupts_enabled()) {
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_PROHIBITED_IN_ISR_CONTEXT), "Error - reading from a file in an ISR or critical section\r\n", fh);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_PROHIBITED_IN_ISR_CONTEXT), "Error - reading from a file in an ISR or critical section\r\n", fh);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
|
@ -1088,7 +1088,7 @@ extern "C" int statvfs(const char *path, struct statvfs *buf) {
|
|||
#include "mbed_error.h"
|
||||
namespace __gnu_cxx {
|
||||
void __verbose_terminate_handler() {
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_CLIB_EXCEPTION),"Exception", 0);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_CLIB_EXCEPTION),"Exception", 0);
|
||||
}
|
||||
}
|
||||
extern "C" WEAK void __cxa_pure_virtual(void);
|
||||
|
|
@ -1387,7 +1387,7 @@ void *operator new(std::size_t count)
|
|||
{
|
||||
void *buffer = malloc_wrapper(count, MBED_CALLER_ADDR());
|
||||
if (NULL == buffer) {
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count);
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
|
|
@ -1431,7 +1431,7 @@ void *operator new(std::size_t count)
|
|||
{
|
||||
void *buffer = malloc_wrapper(_REENT, count, MBED_CALLER_ADDR());
|
||||
if (NULL == buffer) {
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count);
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
|
|
@ -1440,7 +1440,7 @@ void *operator new[](std::size_t count)
|
|||
{
|
||||
void *buffer = malloc_wrapper(_REENT, count, MBED_CALLER_ADDR());
|
||||
if (NULL == buffer) {
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count);
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
|
|
@ -1471,7 +1471,7 @@ void *operator new(std::size_t count)
|
|||
{
|
||||
void *buffer = malloc(count);
|
||||
if (NULL == buffer) {
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new out of memory\r\n", count);
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
|
|
@ -1480,7 +1480,7 @@ void *operator new[](std::size_t count)
|
|||
{
|
||||
void *buffer = malloc(count);
|
||||
if (NULL == buffer) {
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new[] out of memory\r\n", count);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Operator new[] out of memory\r\n", count);
|
||||
}
|
||||
return buffer;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -82,7 +82,7 @@ __NO_RETURN void mbed_fault_handler (uint32_t fault_type, void *mbed_fault_conte
|
|||
mbed_error_print("\n\n-- MbedOS Fault Handler --\n\n",NULL);
|
||||
|
||||
//Now call mbed_error, to log the error and halt the system
|
||||
mbed_error( MAKE_ERROR( MODULE_UNKNOWN, faultStatus ), "System encountered an unrecoverable fault excaption, halting system.", mbed_fault_context.PC_reg, NULL, 0 );
|
||||
mbed_error( MBED_MAKE_ERROR( MBED_MODULE_UNKNOWN, faultStatus ), "System encountered an unrecoverable fault excaption, halting system.", mbed_fault_context.PC_reg, NULL, 0 );
|
||||
|
||||
/* In case we return, just spin here, we have already crashed */
|
||||
for (;;) {
|
||||
|
|
|
|||
|
|
@ -323,7 +323,7 @@ void mbed_start_main(void)
|
|||
_main_thread_attr.name = "main_thread";
|
||||
osThreadId_t result = osThreadNew((osThreadFunc_t)pre_main, NULL, &_main_thread_attr);
|
||||
if ((void *)result == NULL) {
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_INITIALIZATION_FAILED), "Pre main thread not created", &_main_thread_attr);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_INITIALIZATION_FAILED), "Pre main thread not created", &_main_thread_attr);
|
||||
}
|
||||
|
||||
osKernelStart();
|
||||
|
|
|
|||
|
|
@ -47,27 +47,27 @@ __NO_RETURN uint32_t osRtxErrorNotify (uint32_t code, void *object_id)
|
|||
case osRtxErrorStackUnderflow:
|
||||
// Stack underflow detected for thread (thread_id=object_id)
|
||||
// Note: "overflow" is printed instead of "underflow" due to end user familiarity with overflow errors
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_KERNEL, MBED_ERROR_CODE_STACK_OVERFLOW), "CMSIS-RTOS error: Stack overflow", code);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_KERNEL, MBED_ERROR_CODE_STACK_OVERFLOW), "CMSIS-RTOS error: Stack overflow", code);
|
||||
break;
|
||||
case osRtxErrorISRQueueOverflow:
|
||||
// ISR Queue overflow detected when inserting object (object_id)
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_KERNEL, MBED_ERROR_CODE_ISR_QUEUE_OVERFLOW), "CMSIS-RTOS error: ISR Queue overflow", code);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_KERNEL, MBED_ERROR_CODE_ISR_QUEUE_OVERFLOW), "CMSIS-RTOS error: ISR Queue overflow", code);
|
||||
break;
|
||||
case osRtxErrorTimerQueueOverflow:
|
||||
// User Timer Callback Queue overflow detected for timer (timer_id=object_id)
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_KERNEL, MBED_ERROR_CODE_TIMER_QUEUE_OVERFLOW), "CMSIS-RTOS error: User Timer Callback Queue overflow", code);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_KERNEL, MBED_ERROR_CODE_TIMER_QUEUE_OVERFLOW), "CMSIS-RTOS error: User Timer Callback Queue overflow", code);
|
||||
break;
|
||||
case osRtxErrorClibSpace:
|
||||
// Standard C/C++ library libspace not available: increase OS_THREAD_LIBSPACE_NUM
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_KERNEL, MBED_ERROR_CODE_CLIB_SPACE_UNAVAILABLE), "CMSIS-RTOS error: STD C/C++ library libspace not available", code);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_KERNEL, MBED_ERROR_CODE_CLIB_SPACE_UNAVAILABLE), "CMSIS-RTOS error: STD C/C++ library libspace not available", code);
|
||||
break;
|
||||
case osRtxErrorClibMutex:
|
||||
// Standard C/C++ library mutex initialization failed
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_KERNEL, MBED_ERROR_CODE_CLIB_MUTEX_INIT_FAILURE), "CMSIS-RTOS error: STD C/C++ library mutex initialization failed", code);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_KERNEL, MBED_ERROR_CODE_CLIB_MUTEX_INIT_FAILURE), "CMSIS-RTOS error: STD C/C++ library mutex initialization failed", code);
|
||||
break;
|
||||
default:
|
||||
//Unknown error flagged from kernel
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_KERNEL, MBED_ERROR_CODE_UNKNOWN), "CMSIS-RTOS error: Unknown", code);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_KERNEL, MBED_ERROR_CODE_UNKNOWN), "CMSIS-RTOS error: Unknown", code);
|
||||
break;
|
||||
}
|
||||
|
||||
|
|
@ -99,27 +99,27 @@ static const char* error_msg(int32_t status)
|
|||
|
||||
void EvrRtxKernelError (int32_t status)
|
||||
{
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_EVENT), error_msg(status), status);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_EVENT), error_msg(status), status);
|
||||
}
|
||||
|
||||
void EvrRtxThreadError (osThreadId_t thread_id, int32_t status)
|
||||
{
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_THREAD_EVENT), error_msg(status), thread_id);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_THREAD_EVENT), error_msg(status), thread_id);
|
||||
}
|
||||
|
||||
void EvrRtxTimerError (osTimerId_t timer_id, int32_t status)
|
||||
{
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_TIMER_EVENT), error_msg(status), timer_id);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_TIMER_EVENT), error_msg(status), timer_id);
|
||||
}
|
||||
|
||||
void EvrRtxEventFlagsError (osEventFlagsId_t ef_id, int32_t status)
|
||||
{
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_EVENT_FLAGS_EVENT), error_msg(status), ef_id);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_EVENT_FLAGS_EVENT), error_msg(status), ef_id);
|
||||
}
|
||||
|
||||
void EvrRtxMutexError (osMutexId_t mutex_id, int32_t status)
|
||||
{
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_MUTEX_EVENT), error_msg(status), mutex_id);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_MUTEX_EVENT), error_msg(status), mutex_id);
|
||||
}
|
||||
|
||||
void EvrRtxSemaphoreError (osSemaphoreId_t semaphore_id, int32_t status)
|
||||
|
|
@ -129,17 +129,17 @@ void EvrRtxSemaphoreError (osSemaphoreId_t semaphore_id, int32_t status)
|
|||
return;
|
||||
}
|
||||
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_SEMAPHORE_EVENT), error_msg(status), semaphore_id);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_SEMAPHORE_EVENT), error_msg(status), semaphore_id);
|
||||
}
|
||||
|
||||
void EvrRtxMemoryPoolError (osMemoryPoolId_t mp_id, int32_t status)
|
||||
{
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_MEMORY_POOL_EVENT), error_msg(status), mp_id);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_MEMORY_POOL_EVENT), error_msg(status), mp_id);
|
||||
}
|
||||
|
||||
void EvrRtxMessageQueueError (osMessageQueueId_t mq_id, int32_t status)
|
||||
{
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_MESSAGE_QUEUE_EVENT), error_msg(status), mq_id);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_RTOS_MESSAGE_QUEUE_EVENT), error_msg(status), mq_id);
|
||||
}
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -78,13 +78,13 @@ void Thread::constructor(Callback<void()> task,
|
|||
|
||||
switch (start(task)) {
|
||||
case osErrorResource:
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_RESOURCES), "OS ran out of threads!\n", task);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_RESOURCES), "OS ran out of threads!\n", task);
|
||||
break;
|
||||
case osErrorParameter:
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_ALREADY_IN_USE), "Thread already running!\n", task);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_ALREADY_IN_USE), "Thread already running!\n", task);
|
||||
break;
|
||||
case osErrorNoMemory:
|
||||
MBED_ERROR(MAKE_ERROR(MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Error allocating the stack memory\n", task);
|
||||
MBED_ERROR(MBED_MAKE_ERROR(MBED_MODULE_PLATFORM, MBED_ERROR_CODE_OUT_OF_MEMORY), "Error allocating the stack memory\n", task);
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
|
|
|||
Loading…
Reference in New Issue