ARMmbed
/
mbed-os
mirror of https://github.com/ARMmbed/mbed-os.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

Adding mbed prefixes to all macros and functions to avoid namespace conflicts

pull/6983/head
Senthil Ramakrishnan 2018-05-22 12:28:57 -05:00
parent 147d9cac4e
commit d4fe75731d
14 changed files with 158 additions and 158 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
TESTS/mbed_platform/error_handling/main.cpp
View File

@ -36,7 +36,7 @@ void test_error_count_and_reset()
TEST_ASSERT_EQUAL_INT(count, get_error_count()); TEST_ASSERT_EQUAL_INT(count, get_error_count());
//clear the errors and error count to 0 //clear the errors and error count to 0
clear_all_errors(); mbed_clear_all_errors();
//Now the error count should be 0 //Now the error count should be 0
TEST_ASSERT_EQUAL_INT(0, get_error_count()); 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_WARNING(MBED_ERROR_OUT_OF_RESOURCES, "System type error", 0x1100 );
mbed_error_status_t lastError = get_last_error(); 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(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)); 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 ); MBED_WARNING(error, "Error Serial", 0xAA );
lastError = get_last_error(); lastError = get_last_error();
TEST_ASSERT_EQUAL_UINT(error, lastError); 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 ); MBED_WARNING(error, "Custom Error Unknown", 0x1234 );
lastError = get_last_error(); lastError = get_last_error();
TEST_ASSERT_EQUAL_UINT(error, lastError); TEST_ASSERT_EQUAL_UINT(error, lastError);
@ -73,13 +73,13 @@ void test_error_capturing()
lastError = get_last_error(); lastError = get_last_error();
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_EPERM, lastError); 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); MBED_WARNING(error, "Custom Error Type", error_value);
lastError = get_last_error(); lastError = get_last_error();
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TYPE_CUSTOM, MBED_GET_ERROR_TYPE(lastError)); 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)); 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(status == MBED_SUCCESS);
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value); 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 ); MBED_WARNING(MBED_ERROR_EACCES, "Posix Error", error_value );
lastError = get_last_error(); lastError = get_last_error();
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TYPE_POSIX, MBED_GET_ERROR_TYPE(lastError)); 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)); 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(status == MBED_SUCCESS);
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value); TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value);
error_value = 0; 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 ); MBED_WARNING(error, "HAL Entity error", error_value );
lastError = get_last_error(); lastError = get_last_error();
TEST_ASSERT_EQUAL_UINT(MBED_ERROR_TYPE_SYSTEM, MBED_GET_ERROR_TYPE(lastError)); 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)); 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(status == MBED_SUCCESS);
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value); 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_error_ctx error_ctx = {0};
MBED_WARNING(MBED_ERROR_INVALID_ARGUMENT, "System type error", error_value ); 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(status == MBED_SUCCESS);
TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value); TEST_ASSERT_EQUAL_UINT(error_value, error_ctx.error_value);
TEST_ASSERT_EQUAL_UINT(osThreadGetId(), error_ctx.thread_id); TEST_ASSERT_EQUAL_UINT(osThreadGetId(), error_ctx.thread_id);
@ -144,22 +144,22 @@ void test_error_logging()
mbed_error_ctx error_ctx = {0}; mbed_error_ctx error_ctx = {0};
//clear the current errors first //clear the current errors first
clear_all_errors(); mbed_clear_all_errors();
//log 3 errors and retrieve them to ensure they are correct //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_ARGUMENT, "Invalid argument", 1 );
MBED_WARNING(MBED_ERROR_INVALID_SIZE, "Invalid size", 2 ); MBED_WARNING(MBED_ERROR_INVALID_SIZE, "Invalid size", 2 );
MBED_WARNING(MBED_ERROR_INVALID_FORMAT, "Invalid format", 3 ); 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(MBED_ERROR_INVALID_ARGUMENT, error_ctx.error_status);
TEST_ASSERT_EQUAL_UINT(1, error_ctx.error_value); 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(MBED_ERROR_INVALID_SIZE, error_ctx.error_status);
TEST_ASSERT_EQUAL_UINT(2, error_ctx.error_value); 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(MBED_ERROR_INVALID_FORMAT, error_ctx.error_status);
TEST_ASSERT_EQUAL_UINT(3, error_ctx.error_value); 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_UNSUPPORTED, "Not supported", 12 );
MBED_WARNING(MBED_ERROR_ACCESS_DENIED, "Access denied", 13 ); 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(MBED_ERROR_TIME_OUT, error_ctx.error_status);
TEST_ASSERT_EQUAL_UINT(10, error_ctx.error_value); 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(MBED_ERROR_ALREADY_IN_USE, error_ctx.error_status);
TEST_ASSERT_EQUAL_UINT(11, error_ctx.error_value); 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(MBED_ERROR_UNSUPPORTED, error_ctx.error_status);
TEST_ASSERT_EQUAL_UINT(12, error_ctx.error_value); 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(MBED_ERROR_ACCESS_DENIED, error_ctx.error_status);
TEST_ASSERT_EQUAL_UINT(13, error_ctx.error_value); TEST_ASSERT_EQUAL_UINT(13, error_ctx.error_value);
//Try an index which is invalid, we should get ERROR_INVALID_ARGUMENT back //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); TEST_ASSERT_EQUAL_UINT(MBED_ERROR_INVALID_ARGUMENT, status);
} }
@ -228,10 +228,10 @@ void test_error_logging_multithread()
errThread[i]->join(); errThread[i]->join();
} }
i = get_error_log_count()-1; i = mbed_get_error_log_count()-1;
//printf("\nError log count = %d\n", i+1); //printf("\nError log count = %d\n", i+1);
for(;i>=0;--i) { 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) { if(status != MBED_SUCCESS) {
TEST_FAIL(); TEST_FAIL();
} }
@ -252,7 +252,7 @@ void MyErrorHook(const mbed_error_ctx *error_ctx)
*/ */
void test_error_hook() void test_error_hook()
{ {
if( MBED_SUCCESS != set_error_hook(MyErrorHook)) { if( MBED_SUCCESS != mbed_set_error_hook(MyErrorHook)) {
TEST_FAIL(); TEST_FAIL();
} }
@ -317,7 +317,7 @@ void test_save_error_log()
TEST_FAIL(); 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"); printf("Failed saving error log");
TEST_FAIL(); TEST_FAIL();
} }

24
features/FEATURE_LWIP/lwip-interface/lwip-sys/arch/lwip_sys_arch.c
View File

@ -123,7 +123,7 @@ u32_t sys_now(void) {
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
err_t sys_mbox_new(sys_mbox_t *mbox, int queue_sz) { err_t sys_mbox_new(sys_mbox_t *mbox, int queue_sz) {
if (queue_sz > MB_SIZE) 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)); 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->attr.cb_size = sizeof(mbox->data);
mbox->id = osEventFlagsNew(&mbox->attr); mbox->id = osEventFlagsNew(&mbox->attr);
if (mbox->id == NULL) 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); 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) { void sys_mbox_free(sys_mbox_t *mbox) {
if (mbox->post_idx != mbox->fetch_idx) 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->attr.cb_size = sizeof(sem->data);
sem->id = osSemaphoreNew(UINT16_MAX, count, &sem->attr); sem->id = osSemaphoreNew(UINT16_MAX, count, &sem->attr);
if (sem->id == NULL) 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; return ERR_OK;
} }
@ -388,14 +388,14 @@ err_t sys_mutex_new(sys_mutex_t *mutex) {
* @param mutex the mutex to lock */ * @param mutex the mutex to lock */
void sys_mutex_lock(sys_mutex_t *mutex) { void sys_mutex_lock(sys_mutex_t *mutex) {
if (osMutexAcquire(mutex->id, osWaitForever) != osOK) 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 /** Unlock a mutex
* @param mutex the mutex to unlock */ * @param mutex the mutex to unlock */
void sys_mutex_unlock(sys_mutex_t *mutex) { void sys_mutex_unlock(sys_mutex_t *mutex) {
if (osMutexRelease(mutex->id) != osOK) 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 /** 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_attr.cb_size = sizeof(lwip_sys_mutex_data);
lwip_sys_mutex = osMutexNew(&lwip_sys_mutex_attr); lwip_sys_mutex = osMutexNew(&lwip_sys_mutex_attr);
if (lwip_sys_mutex == NULL) 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) { sys_prot_t sys_arch_protect(void) {
if (osMutexAcquire(lwip_sys_mutex, osWaitForever) != osOK) 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; return (sys_prot_t) 1;
} }
@ -469,7 +469,7 @@ sys_prot_t sys_arch_protect(void) {
*---------------------------------------------------------------------------*/ *---------------------------------------------------------------------------*/
void sys_arch_unprotect(sys_prot_t p) { void sys_arch_unprotect(sys_prot_t p) {
if (osMutexRelease(lwip_sys_mutex) != osOK) 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) { 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)); LWIP_DEBUGF(SYS_DEBUG, ("New Thread: %s\n", pcName));
if (thread_pool_index >= SYS_THREAD_POOL_N) 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]; sys_thread_t t = (sys_thread_t)&thread_pool[thread_pool_index];
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_size = stacksize;
t->attr.stack_mem = malloc(stacksize); t->attr.stack_mem = malloc(stacksize);
if (t->attr.stack_mem == NULL) { 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); t->id = osThreadNew((osThreadFunc_t)thread, arg, &t->attr);
if (t->id == NULL) 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; return t;
} }

4
features/filesystem/bd/ReadOnlyBlockDevice.cpp
View File

@ -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) 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; return MBED_ERROR_WRITE_PROTECTED;
} }
int ReadOnlyBlockDevice::erase(bd_addr_t addr, bd_size_t size) 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; return MBED_ERROR_WRITE_PROTECTED;
} }

8
hal/mbed_pinmap_common.c
View File

@ -29,7 +29,7 @@ void pinmap_pinout(PinName pin, const PinMap *map) {
} }
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) { 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; return a;
// mis-match error case // 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; return (uint32_t)NC;
} }
@ -64,7 +64,7 @@ uint32_t pinmap_peripheral(PinName pin, const PinMap* map) {
return (uint32_t)NC; return (uint32_t)NC;
peripheral = pinmap_find_peripheral(pin, map); peripheral = pinmap_find_peripheral(pin, map);
if ((uint32_t)NC == peripheral) // no mapping available 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; return peripheral;
} }
@ -84,6 +84,6 @@ uint32_t pinmap_function(PinName pin, const PinMap* map) {
return (uint32_t)NC; return (uint32_t)NC;
function = pinmap_find_function(pin, map); function = pinmap_find_function(pin, map);
if ((uint32_t)NC == function) // no mapping available 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; return function;
} }

4
hal/mbed_sleep_manager.c
View File

@ -161,7 +161,7 @@ void sleep_manager_lock_deep_sleep_internal(void)
core_util_critical_section_enter(); core_util_critical_section_enter();
if (deep_sleep_lock == USHRT_MAX) { if (deep_sleep_lock == USHRT_MAX) {
core_util_critical_section_exit(); 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_atomic_incr_u16(&deep_sleep_lock, 1);
core_util_critical_section_exit(); core_util_critical_section_exit();
@ -172,7 +172,7 @@ void sleep_manager_unlock_deep_sleep_internal(void)
core_util_critical_section_enter(); core_util_critical_section_enter();
if (deep_sleep_lock == 0) { if (deep_sleep_lock == 0) {
core_util_critical_section_exit(); 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_atomic_decr_u16(&deep_sleep_lock, 1);
core_util_critical_section_exit(); core_util_critical_section_exit();

4
platform/DeepSleepLock.h
View File

@ -69,7 +69,7 @@ public:
sleep_manager_lock_deep_sleep(); sleep_manager_lock_deep_sleep();
} }
if (0 == count) { 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) { if (count == USHRT_MAX) {
core_util_critical_section_exit(); 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);
} }
} }
}; };

2
platform/Stream.cpp
View File

@ -29,7 +29,7 @@ Stream::Stream(const char *name) : FileLike(name), _file(NULL) {
if (_file) { if (_file) {
mbed_set_unbuffered_stream(_file); mbed_set_unbuffered_stream(_file);
} else { } 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);
} }
} }

28
platform/mbed_error.c
View 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 //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 //register the new hook/callback
if( error_hook_in != NULL ) { 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 //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)); memcpy(error_info, &first_error_ctx, sizeof(first_error_ctx));
return MBED_SUCCESS; return MBED_SUCCESS;
} }
//Retrieve the last error context from error log //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)); memcpy(error_info, &last_error_ctx, sizeof(mbed_error_ctx));
return MBED_SUCCESS; return MBED_SUCCESS;
} }
//Makes an mbed_error_status_t value //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) 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 //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. * @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; 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 #ifndef MBED_CONF_ERROR_LOG_DISABLED
//Retrieve the error context from error log at the specified index //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); return mbed_log_get_error(index, error_info);
} }
//Retrieve the error log count //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(); 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_status_t ret = MBED_SUCCESS;
mbed_error_ctx ctx = {0}; mbed_error_ctx ctx = {0};
@ -273,13 +273,13 @@ mbed_error_status_t save_error_log(const char *path)
//Ensure path is valid //Ensure path is valid
if(path==NULL) { 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; goto exit;
} }
//Open the file for saving the error log info //Open the file for saving the error log info
if((error_log_file = fopen( path, "w" ) ) == NULL){ 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; 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.thread_id,
(unsigned int)first_error_ctx.error_address, (unsigned int)first_error_ctx.error_address,
(unsigned int)first_error_ctx.error_value) <= 0) { (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; 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.thread_id,
(unsigned int)last_error_ctx.error_address, (unsigned int)last_error_ctx.error_address,
(unsigned int)last_error_ctx.error_value) <= 0) { (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; goto exit;
} }
@ -312,7 +312,7 @@ mbed_error_status_t save_error_log(const char *path)
(unsigned int)ctx.thread_id, (unsigned int)ctx.thread_id,
(unsigned int)ctx.error_address, (unsigned int)ctx.error_address,
(unsigned int)ctx.error_value) <= 0) { (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; goto exit;
} }
} }

136
platform/mbed_error.h
View File

@ -89,7 +89,7 @@ extern "C" {
* Custom Error Codes - 4096 to 65535.\n * 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. * @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 * 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. * 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 ) \ #define MBED_DEFINE_SYSTEM_ERROR( error_name, error_code ) \
MBED_ERROR_CODE_##error_name = MBED_SYSTEM_ERROR_BASE + 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. * 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 ) \ #define MBED_DEFINE_CUSTOM_ERROR( error_name, error_code ) \
MBED_ERROR_CODE_##error_name = MBED_CUSTOM_ERROR_BASE + 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 * @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 * 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 * 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 * 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 * 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 MAKE_ERROR/MAKE_SYSTEM_ERROR/MAKE_CUSTOM_ERROR macros.\n * Its used in call to MBED_MAKE_ERROR/MBED_MAKE_SYSTEM_ERROR/MBED_MAKE_CUSTOM_ERROR macros.\n
* *
* @code * @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 * @endcode
* *
* @note * @note
* \n Below are the module code mappings:\n * \n Below are the module code mappings:\n
\verbatim \verbatim
MODULE_APPLICATION 0 Application MBED_MODULE_APPLICATION 0 Application
MODULE_PLATFORM 1 Platform MBED_MODULE_PLATFORM 1 Platform
MODULE_KERNEL 2 RTX Kernel MODULE_KERNEL 2 RTX Kernel
MODULE_NETWORK_STACK 3 Network stack MBED_MODULE_NETWORK_STACK 3 Network stack
MODULE_HAL 4 HAL - Hardware Abstraction Layer MBED_MODULE_HAL 4 HAL - Hardware Abstraction Layer
MODULE_MEMORY_SUBSYSTEM 5 Memory Subsystem MBED_MODULE_NETWORK_STACKMODULE_MEMORY_SUBSYSTEM 5 Memory Subsystem
MODULE_FILESYSTEM 6 Filesystem MBED_MODULE_FILESYSTEM 6 Filesystem
MODULE_BLOCK_DEVICE 7 Block device MBED_MODULE_BLOCK_DEVICE 7 Block device
MODULE_DRIVER 8 Driver MBED_MODULE_DRIVER 8 Driver
MODULE_DRIVER_SERIAL 9 Serial Driver MBED_MODULE_DRIVER_SERIAL 9 Serial Driver
MODULE_DRIVER_RTC 10 RTC Driver MBED_MODULE_DRIVER_RTC 10 RTC Driver
MODULE_DRIVER_I2C 11 I2C Driver MBED_MODULE_DRIVER_I2C 11 I2C Driver
MODULE_DRIVER_SPI 12 SPI Driver MODULE_DRIVER_SPI 12 SPI Driver
MODULE_DRIVER_GPIO 13 GPIO Driver MODULE_DRIVER_GPIO 13 GPIO Driver
MODULE_DRIVER_ANALOG 14 Analog Driver MODULE_DRIVER_ANALOG 14 Analog Driver
@ -231,39 +231,39 @@ typedef enum _mbed_error_type_t
MODULE_DRIVER_USB 21 USB Driver MODULE_DRIVER_USB 21 USB Driver
MODULE_TARGET_SDK 22 SDK MODULE_TARGET_SDK 22 SDK
MODULE_UNKNOWN 255 Unknown module MBED_MODULE_UNKNOWN 255 Unknown module
\endverbatim \endverbatim
* *
*/ */
typedef enum _mbed_module_type typedef enum _mbed_module_type
{ {
MODULE_APPLICATION = 0, MBED_MODULE_APPLICATION = 0,
MODULE_PLATFORM, MBED_MODULE_PLATFORM,
MODULE_KERNEL, MBED_MODULE_KERNEL,
MODULE_NETWORK_STACK, MBED_MODULE_NETWORK_STACK,
MODULE_HAL, MBED_MODULE_HAL,
MODULE_MEMORY_SUBSYSTEM, MBED_MODULE_NETWORK_STACKMODULE_MEMORY_SUBSYSTEM,
MODULE_FILESYSTEM, MBED_MODULE_FILESYSTEM,
MODULE_BLOCK_DEVICE, MBED_MODULE_BLOCK_DEVICE,
MODULE_DRIVER, MBED_MODULE_DRIVER,
MODULE_DRIVER_SERIAL, MBED_MODULE_DRIVER_SERIAL,
MODULE_DRIVER_RTC, MBED_MODULE_DRIVER_RTC,
MODULE_DRIVER_I2C, MBED_MODULE_DRIVER_I2C,
MODULE_DRIVER_SPI, MBED_MODULE_DRIVER_SPI,
MODULE_DRIVER_GPIO, MBED_MODULE_DRIVER_GPIO,
MODULE_DRIVER_ANALOG, MBED_MODULE_DRIVER_ANALOG,
MODULE_DRIVER_DIGITAL, MBED_MODULE_DRIVER_DIGITAL,
MODULE_DRIVER_CAN, MBED_MODULE_DRIVER_CAN,
MODULE_DRIVER_ETHERNET, MBED_MODULE_DRIVER_ETHERNET,
MODULE_DRIVER_CRC, MBED_MODULE_DRIVER_CRC,
MODULE_DRIVER_PWM, MBED_MODULE_DRIVER_PWM,
MODULE_DRIVER_QSPI, MBED_MODULE_DRIVER_QSPI,
MODULE_DRIVER_USB, MBED_MODULE_DRIVER_USB,
MODULE_TARGET_SDK, MBED_MODULE_TARGET_SDK,
/* Add More entities here as required */ /* Add More entities here as required */
MODULE_UNKNOWN = 255, MBED_MODULE_UNKNOWN = 255,
MODULE_MAX = MODULE_UNKNOWN MBED_MODULE_MAX = MBED_MODULE_UNKNOWN
} mbed_module_type_t; } mbed_module_type_t;
//Use MBED_SUCCESS(=0) or any postive number for successful returns //Use MBED_SUCCESS(=0) or any postive number for successful returns
@ -276,7 +276,7 @@ typedef enum _mbed_module_type
//Error Code definitions //Error Code definitions
/** mbed_error_code_t definition /** 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 * It defines all of Posix Error Codes/Statuses and Mbed System Error Codes/Statuses.\n\n
* *
* @note * @note
@ -432,10 +432,10 @@ typedef enum _mbed_module_type
* MbedOS System Error codes are defined using the macro MBED_DEFINE_SYSTEM_ERROR\n * 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 * 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_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 * Its effectively equivalent to:\n
* ERROR_CODE_INVALID_ARGUMENT = 1\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 * 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 * passed as the second argument in the MBED_DEFINE_SYSTEM_ERROR macro.\n\n
* Below are the Mbed System error codes and the description: * 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. * 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 * 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_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 * Its effectively equivalent to:\n
* ERROR_CODE_MY_CUSTOM_ERROR = 4097\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 * @note
* **Using error codes:** \n * **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 * 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. * @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 * @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 * @endcode
* @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_SYSTEM * @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 * 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. * @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 * @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 * @endcode
* @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_CUSTOM * @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 * 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. * @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 * @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 * @endcode
* @note This macro generate mbed_error_status_t-es with error type set to MBED_ERROR_TYPE_SYSTEM * @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 * 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. * 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. * @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 * //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 * @endcode
* @note The erro hook function implementation should be re-entrant. * @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. * 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_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. * 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_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. * Clears all the last error, error count and all entries in the error log.
* @return 0 or MBED_SUCCESS on success. * @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. * 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. * @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. * 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. * @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. * 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_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 * 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. * @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 #ifdef __cplusplus
} }

16
platform/mbed_retarget.cpp
View File

@ -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 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()) { 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 #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 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()) { 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 #endif
@ -1088,7 +1088,7 @@ extern "C" int statvfs(const char *path, struct statvfs *buf) {
#include "mbed_error.h" #include "mbed_error.h"
namespace __gnu_cxx { namespace __gnu_cxx {
void __verbose_terminate_handler() { 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); 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()); void *buffer = malloc_wrapper(count, MBED_CALLER_ADDR());
if (NULL == buffer) { 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; return buffer;
} }
@ -1431,7 +1431,7 @@ void *operator new(std::size_t count)
{ {
void *buffer = malloc_wrapper(_REENT, count, MBED_CALLER_ADDR()); void *buffer = malloc_wrapper(_REENT, count, MBED_CALLER_ADDR());
if (NULL == buffer) { 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; return buffer;
} }
@ -1440,7 +1440,7 @@ void *operator new[](std::size_t count)
{ {
void *buffer = malloc_wrapper(_REENT, count, MBED_CALLER_ADDR()); void *buffer = malloc_wrapper(_REENT, count, MBED_CALLER_ADDR());
if (NULL == buffer) { 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; return buffer;
} }
@ -1471,7 +1471,7 @@ void *operator new(std::size_t count)
{ {
void *buffer = malloc(count); void *buffer = malloc(count);
if (NULL == buffer) { 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; return buffer;
} }
@ -1480,7 +1480,7 @@ void *operator new[](std::size_t count)
{ {
void *buffer = malloc(count); void *buffer = malloc(count);
if (NULL == buffer) { 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; return buffer;
} }

2
rtos/TARGET_CORTEX/TARGET_CORTEX_M/mbed_rtx_fault_handler.c
View File

@ -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); mbed_error_print("\n\n-- MbedOS Fault Handler --\n\n",NULL);
//Now call mbed_error, to log the error and halt the system //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 */ /* In case we return, just spin here, we have already crashed */
for (;;) { for (;;) {

2
rtos/TARGET_CORTEX/mbed_boot.c
View File

@ -323,7 +323,7 @@ void mbed_start_main(void)
_main_thread_attr.name = "main_thread"; _main_thread_attr.name = "main_thread";
osThreadId_t result = osThreadNew((osThreadFunc_t)pre_main, NULL, &_main_thread_attr); osThreadId_t result = osThreadNew((osThreadFunc_t)pre_main, NULL, &_main_thread_attr);
if ((void *)result == NULL) { 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(); osKernelStart();

28
rtos/TARGET_CORTEX/mbed_rtx_handlers.c
View File

@ -47,27 +47,27 @@ __NO_RETURN uint32_t osRtxErrorNotify (uint32_t code, void *object_id)
case osRtxErrorStackUnderflow: case osRtxErrorStackUnderflow:
// Stack underflow detected for thread (thread_id=object_id) // Stack underflow detected for thread (thread_id=object_id)
// Note: "overflow" is printed instead of "underflow" due to end user familiarity with overflow errors // 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; break;
case osRtxErrorISRQueueOverflow: case osRtxErrorISRQueueOverflow:
// ISR Queue overflow detected when inserting object (object_id) // 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; break;
case osRtxErrorTimerQueueOverflow: case osRtxErrorTimerQueueOverflow:
// User Timer Callback Queue overflow detected for timer (timer_id=object_id) // 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; break;
case osRtxErrorClibSpace: case osRtxErrorClibSpace:
// Standard C/C++ library libspace not available: increase OS_THREAD_LIBSPACE_NUM // 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; break;
case osRtxErrorClibMutex: case osRtxErrorClibMutex:
// Standard C/C++ library mutex initialization failed // 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; break;
default: default:
//Unknown error flagged from kernel //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; break;
} }
@ -99,27 +99,27 @@ static const char* error_msg(int32_t status)
void EvrRtxKernelError (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) 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) 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) 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) 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) void EvrRtxSemaphoreError (osSemaphoreId_t semaphore_id, int32_t status)
@ -129,17 +129,17 @@ void EvrRtxSemaphoreError (osSemaphoreId_t semaphore_id, int32_t status)
return; 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) 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) 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 #endif

6
rtos/Thread.cpp
View File

@ -78,13 +78,13 @@ void Thread::constructor(Callback<void()> task,
switch (start(task)) { switch (start(task)) {
case osErrorResource: 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; break;
case osErrorParameter: 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; break;
case osErrorNoMemory: 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: default:
break; break;
} }