void OTA::begin(String hostname, String password, int port) {
yield();
// Port defaults to 8266
ArduinoOTA.setPort(port);
// Hostname defaults to esp8266-[ChipID]
ArduinoOTA.setHostname(hostname.c_str());
// No authentication by default
// ArduinoOTA.setPassword(password.c_str());
ArduinoOTA.onStart([]() {
println_dbg("Start");
});
ArduinoOTA.onEnd([]() {
println_dbg("End");
});
ArduinoOTA.onProgress([](unsigned int progress, unsigned int total) {
printf_dbg("Progress: %u%%\r\n", (progress / (total / 100)));
});
ArduinoOTA.onError([](ota_error_t error) {
printf_dbg("Error[%u]: ", error);
if (error == OTA_AUTH_ERROR) println_dbg("Auth Failed");
else if (error == OTA_BEGIN_ERROR) println_dbg("Begin Failed");
else if (error == OTA_CONNECT_ERROR) println_dbg("Connect Failed");
else if (error == OTA_RECEIVE_ERROR) println_dbg("Receive Failed");
else if (error == OTA_END_ERROR) println_dbg("End Failed");
});
ArduinoOTA.begin();
println_dbg("OTA is Ready");
}
void write_req_cb(guint8 status, const guint8 *pdu, guint16 plen,
gpointer user_data)
{
cb_ctx_t *cb_ctx = user_data;
printf_dbg("[CB] IN write_req_cb\n");
if (status) {
cb_ctx->cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ctx->cb_ret_msg, "Write request callback: Failure: %s\n",
att_ecode2str(status));
goto end;
}
if (!dec_write_resp(pdu, plen) && !dec_exec_write_resp(pdu, plen)) {
cb_ctx->cb_ret_val = BL_PROTOCOL_ERROR;
printf("Write request callback: Protocol error\n");
goto end;
}
cb_ctx->cb_ret_val = BL_NO_ERROR;
strcpy(cb_ctx->cb_ret_msg, "Write request callback: Success\n");
end:
g_mutex_unlock(&cb_ctx->pending_cb_mtx);
printf_dbg("[CB] OUT write_req_cb\n");
}
void read_by_uuid_cb(guint8 status, const guint8 *pdu, guint16 plen,
gpointer user_data)
{
struct att_data_list *list;
GSList *bl_value_list = NULL;
cb_ctx_t *cb_ctx = user_data;
printf_dbg("[CB] IN read_by_uuid_cb\n");
if (status) {
cb_ctx->cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ctx->cb_ret_msg, "Read by uuid callback: Failure: %s\n",
att_ecode2str(status));
goto error;
}
list = dec_read_by_type_resp(pdu, plen);
if (list == NULL) {
strcpy(cb_ctx->cb_ret_msg, "Read by uuid callback: Nothing found\n");
cb_ctx->cb_ret_val = BL_NO_ERROR;
goto error;
}
for (int i = 0; i < list->num; i++) {
bl_value_t *bl_value = bl_value_new(NULL, att_get_u16(list->data[i]),
list->len - 2, list->data[i] + 2);
if (bl_value == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Read by uuid callback: Malloc error\n");
goto error;
}
// Add it to the value list
if (bl_value_list == NULL) {
bl_value_list = g_slist_alloc();
if (bl_value_list == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Read by uuid callback: Malloc error\n");
goto error;
}
bl_value_list->data = bl_value;
} else {
bl_value_list = g_slist_append(bl_value_list, bl_value);
}
}
att_data_list_free(list);
cb_ctx->cb_ret_pointer = bl_value_list;
cb_ctx->cb_ret_val = BL_NO_ERROR;
goto exit;
error:
if (bl_value_list)
bl_value_list_free(bl_value_list);
exit:
g_mutex_unlock(&cb_ctx->pending_cb_mtx);
printf_dbg("[CB] OUT read_by_uuid_cb\n");
}
static LinkElement * Link_Reverse(LinkElement **ppHead)
{
int iRet=0;
LinkElement *pHeadNew = *ppHead;
LinkElement *pHeadOld = *ppHead;
LinkElement *pHeadOld2 = *ppHead;
printf_dbg("F:%s, L:%d, -Enter;", __FUNCTION__, __LINE__);
//1. default
pHeadOld = pHeadNew->pNext;
pHeadNew->pNext = NULL;
//2. loop
while(pHeadOld != NULL) {
pHeadOld2 = pHeadOld->pNext;
pHeadOld->pNext=pHeadNew;
printf_dbg("F:%s, L:%d, reverse-link", __FUNCTION__, __LINE__);
pHeadNew = pHeadOld;
pHeadOld = pHeadOld2;
}
*ppHead = pHeadNew;
return iRet;
}
void exchange_mtu_cb(guint8 status, const guint8 *pdu, guint16 plen,
gpointer user_data)
{
uint16_t mtu;
printf_dbg("[CB] IN exchange_mtu_cb\n");
if (status) {
cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ret_msg, "MTU exchange callback: Failure: %s\n",
att_ecode2str(status));
goto error;
}
if (!dec_mtu_resp(pdu, plen, &mtu)) {
cb_ret_val = BL_PROTOCOL_ERROR;
strcpy(cb_ret_msg, "MTU exchange callback: PROTOCOL ERROR\n");
goto error;
}
mtu = MIN(mtu, opt_mtu);
/* Set new value for MTU in client */
if (!g_attrib_set_mtu(attrib, mtu)) {
cb_ret_val = BL_REQUEST_FAIL_ERROR;
strcpy(cb_ret_msg, "MTU exchange callback: Unable to set new MTU value "
"in client\n");
} else {
sprintf(cb_ret_msg, "MTU exchange callback: Success: %d\n", mtu);
cb_ret_val = BL_NO_ERROR;
}
error:
g_mutex_unlock(pending_callback);
printf_dbg("[CB] OUT exchange_mtu_cb\n");
}
void primary_all_cb(GSList *services, guint8 status,
gpointer user_data)
{
GSList *l = NULL;
GSList *bl_primary_list = NULL;
printf_dbg("[CB] IN Primary_all_cb\n");
if (status) {
cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ret_msg, "Primary callback: Failure: %s\n",
att_ecode2str(status));
goto error;
}
if (services == NULL) {
cb_ret_val = BL_NO_ERROR;
strcpy(cb_ret_msg, "Primary callback: Nothing found\n");
goto exit;
}
for (l = services; l; l = l->next) {
struct gatt_primary *prim = l->data;
bl_primary_t *bl_primary = bl_primary_new(prim->uuid, prim->changed,
prim->range.start, prim->range.end);
g_free(prim);
if (bl_primary == NULL) {
cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ret_msg, "Primary callback: Malloc error\n");
goto error;
}
if (bl_primary_list == NULL) {
bl_primary_list = g_slist_alloc();
if (bl_primary_list == NULL) {
cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ret_msg, "Primary callback: Malloc error\n");
goto error;
}
bl_primary_list->data = bl_primary;
} else {
bl_primary_list = g_slist_append(bl_primary_list, bl_primary);
}
}
cb_ret_val = BL_NO_ERROR;
cb_ret_pointer = bl_primary_list;
strcpy(cb_ret_msg, "Primary callback: Sucess\n");
goto exit;
error:
if (bl_primary_list)
bl_primary_list_free(bl_primary_list);
exit:
if (l)
g_slist_free(l);
g_mutex_unlock(pending_callback);
printf_dbg("[CB] OUT primary_all_cb\n");
}
void char_by_uuid_cb(GSList *characteristics, guint8 status,
gpointer user_data)
{
GSList *l = NULL;
GSList *bl_char_list = NULL;
cb_ctx_t *cb_ctx = user_data;
printf_dbg(" IN char_by_uuid\n");
if (status) {
cb_ctx->cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ctx->cb_ret_msg,
"Characteristic by UUID callback: Failure: %s\n",
att_ecode2str(status));
goto error;
}
for (l = characteristics; l; l = l->next) {
// Extract data
struct gatt_char *chars = l->data;
bl_char_t *bl_char = bl_char_new(chars->uuid, chars->handle,
chars->properties,
chars->value_handle);
// Add it to the characteristic
if (bl_char == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Characteristic by UUID callback: Malloc error\n");
goto error;
}
// Append it to the list
if (bl_char_list == NULL) {
bl_char_list = g_slist_alloc();
if (bl_char_list == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Characteristic by UUID callback: Malloc error\n");
goto error;
}
bl_char_list->data = bl_char;
} else {
bl_char_list = g_slist_append(bl_char_list, bl_char);
}
}
cb_ctx->cb_ret_val = BL_NO_ERROR;
cb_ctx->cb_ret_pointer = bl_char_list;
goto exit;
error:
if (bl_char_list)
bl_char_list_free(bl_char_list);
exit:
if (l)
g_slist_free(l);
g_mutex_unlock(&cb_ctx->pending_cb_mtx);
printf_dbg("OUT char_by_uuid\n");
}
void primary_by_uuid_cb(GSList *ranges, guint8 status,
gpointer user_data)
{
GSList *l;
GSList *bl_primary_list = NULL;
cb_ctx_t *cb_ctx = user_data;
printf_dbg("IN primary_by_uuid_cb\n");
if (status) {
cb_ctx->cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ctx->cb_ret_msg, "Primary by UUID callback: Failure: %s\n",
att_ecode2str(status));
goto error;
}
if (ranges == NULL) {
cb_ctx->cb_ret_val = BL_NO_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Primary by UUID callback: Nothing found\n");
goto exit;
}
for (l = ranges; l; l = l->next) {
struct att_range *range = l->data;
bl_primary_t *bl_primary = bl_primary_new(NULL, 0, range->start,
range->end);
free(range);
if (bl_primary == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Primary by UUID callback: Malloc error\n");
goto error;
}
if (bl_primary_list == NULL) {
bl_primary_list = g_slist_alloc();
if (bl_primary_list == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Primary by UUID callback: Malloc error\n");
goto error;
}
bl_primary_list->data = bl_primary;
} else {
bl_primary_list = g_slist_append(bl_primary_list, bl_primary);
}
}
cb_ctx->cb_ret_val = BL_NO_ERROR;
cb_ctx->cb_ret_pointer = bl_primary_list;
goto exit;
error:
if (bl_primary_list)
bl_primary_list_free(bl_primary_list);
exit:
g_mutex_unlock(&cb_ctx->pending_cb_mtx);
printf_dbg("OUT primary_by_uuid_cb\n");
}
void included_cb(GSList *includes, guint8 status, gpointer user_data)
{
GSList *l = NULL;
GSList *bl_included_list = NULL;
cb_ctx_t *cb_ctx = user_data;
printf_dbg("IN included_cb\n");
if (status) {
cb_ctx->cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ctx->cb_ret_msg, "Included callback: Failure: %s\n",
att_ecode2str(status));
goto error;
}
if (includes == NULL) {
cb_ctx->cb_ret_val = BL_NO_ERROR;
strcpy(cb_ctx->cb_ret_msg, "Included callback: Nothing found\n");
goto exit;
}
for (l = includes; l; l = l->next) {
struct gatt_included *incl = l->data;
bl_included_t *bl_included = bl_included_new(incl->uuid, incl->handle,
incl->range.start,
incl->range.end);
if (bl_included == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg, "Included callback: Malloc error\n");
goto error;
}
if (bl_included_list == NULL) {
bl_included_list = g_slist_alloc();
if (bl_included_list == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Included callback: Malloc error\n");
goto error;
}
bl_included_list->data = bl_included;
} else {
bl_included_list = g_slist_append(bl_included_list, bl_included);
}
}
cb_ctx->cb_ret_val = BL_NO_ERROR;
cb_ctx->cb_ret_pointer = bl_included_list;
goto exit;
error:
if (bl_included_list)
bl_included_list_free(bl_included_list);
exit:
if (l)
g_slist_free(l);
g_mutex_unlock(&cb_ctx->pending_cb_mtx);
printf_dbg("OUT included_cb\n");
}
int wait_for_cb(cb_ctx_t *cb_ctx, void **ret_pointer, GError **gerr)
{
int wait_cnt = 0;
if (!g_mutex_trylock(&cb_ctx->pending_cb_mtx) &&
is_event_loop_running()) {
// Reset return value
cb_ctx->cb_ret_val = BL_NO_CALLBACK_ERROR;
cb_ctx->cb_ret_pointer = NULL;
printf_dbg("Waiting for callback\n");
while (is_event_loop_running() &&
!g_mutex_trylock(&cb_ctx->pending_cb_mtx)) {
usleep(100000);
if (wait_cnt < CB_TIMEOUT_S*10) {
wait_cnt++;
} else {
GError *err = g_error_new(BL_ERROR_DOMAIN,
BL_NO_CALLBACK_ERROR,
"Timeout no callback received\n");
printf_dbg("%s", err->message);
PROPAGATE_ERROR;
set_conn_state(cb_ctx->dev_ctx, STATE_DISCONNECTED);
return BL_NO_CALLBACK_ERROR;
}
}
}
if (!is_event_loop_running()) {
set_conn_state(cb_ctx->dev_ctx, STATE_DISCONNECTED);
GError *err = g_error_new(BL_ERROR_DOMAIN, BL_DISCONNECTED_ERROR,
"Event loop is not running\n");
printf_dbg("%s", err->message);
PROPAGATE_ERROR;
return BL_DISCONNECTED_ERROR;
} else
printf_dbg("Callback returned <%d, %p>\n", cb_ctx->cb_ret_val,
cb_ctx->cb_ret_pointer);
if (cb_ctx->cb_ret_val != BL_NO_ERROR) {
GError *err = g_error_new(BL_ERROR_DOMAIN, cb_ctx->cb_ret_val, "%s",
cb_ctx->cb_ret_msg);
PROPAGATE_ERROR;
}
if (*cb_ctx->cb_ret_msg != '\0') {
printf_dbg("%s", cb_ctx->cb_ret_msg);
}
strcpy(cb_ctx->cb_ret_msg, "\0");
if (ret_pointer)
*ret_pointer = cb_ctx->cb_ret_pointer;
return cb_ctx->cb_ret_val;
}
/*
* Event loop thread
*/
static gpointer _event_thread(gpointer data)
{
printf_dbg("Event loop START\n");
g_mutex_lock(cb_mutex);
event_loop = g_main_loop_new(NULL, FALSE);
g_mutex_unlock(cb_mutex);
g_main_loop_run(event_loop);
g_main_loop_unref(event_loop);
event_loop = NULL;
printf_dbg("Event loop EXIT\n");
g_thread_exit(0);
return 0;
}
static LinkElement * Link_Construct(LinkElement *parry, int nNum)
{
int iRet=0;
int i=0;
LinkElement *pHead = NULL;
LinkElement *pItemCur = pHead;
LinkElement *pItemLast = pHead;
LinkElement *pItem = NULL;
printf_dbg("F:%s, L:%d, -Enter; nNum=%d", __FUNCTION__, __LINE__, nNum);
if(parry==NULL) {
return -1;
}
for(i=0; i<nNum; i++) {
printf_dbg("F:%s, L:%d, i=%d", __FUNCTION__, __LINE__, i);
pItem = (LinkElement *)malloc(sizeof(LinkElement));
pItem->key = (parry+i)->key;
pItem->value = (parry+i)->value;
pItem->pNext = NULL;
if(pHead == NULL) {
pHead = pItem;
continue;
}
pItemLast = pItemCur = pHead;
do {
if(pItem->key < pItemCur->key) {
pItem->pNext = pItemCur;
if(pItemLast == pHead) {
pHead = pItem;
} else {
pItemLast->pNext = pItem;
}
break;
} else {
pItemLast = pItemCur;
pItemCur = pItemCur->pNext;
if(pItemCur == NULL) {
pItemLast->pNext = pItem;
break;
}
}
} while(1);
}
return pHead;
}
NEINT32 wait_services()
{
#ifdef WIN32
NEINT32 ch;
while( !ne_host_check_exit() ){
if(kbhit()) {
ch = getch() ;
if(NE_ESC==ch){
printf_dbg("you are hit ESC, program eixt\n") ;
break ;
}
}
else {
ne_sleep(1000) ;
}
}
#else
#ifdef HANDLE_UNIX_SIGNAL
while(!ne_host_check_exit() ){
if(-1==wait_signal_entry() ) {
printf_dbg("exit from wait signal!\n") ;
break ;
}
}
unblock_signal() ;
#else
NEINT32 ch;
#ifndef DEBUG_WITH_GDB
installed_sig_handle();
#endif
while( !ne_host_check_exit() ){
if(kbhit()) {
ch = getch() ;
if(NE_ESC==ch){
printf_dbg("you are hit ESC, program eixt\n") ;
break ;
}
}
else {
ne_sleep(1000) ;
}
}
#endif
#endif
return 0;
}
int Link_Test()
{
int iRet = 0;
int i = 0;
LinkElement *pHead = NULL;
printf_dbg("basic data structure test: link\n");
LinkElement ary_LinkElem[100] = {'\0'};
for(i=0; i<sizeof(ary_LinkElem)/sizeof(LinkElement); i++) {
if(i < 10) {
ary_LinkElem[i].key = i+1000;
ary_LinkElem[i].value = ary_LinkElem[i].key+6;
ary_LinkElem[i].pNext = NULL;
} else {
ary_LinkElem[i].key = i;
ary_LinkElem[i].value = ary_LinkElem[i].key+1;
ary_LinkElem[i].pNext = NULL;
}
}
pHead = Link_Construct(ary_LinkElem, sizeof(ary_LinkElem)/sizeof(LinkElement));
Link_Iterate(pHead);
Link_Reverse(&pHead);
Link_Iterate(pHead);
Link_Destruct(pHead);
return iRet;
}
int start_event_loop(GError **gerr)
{
pending_callback = malloc(sizeof(GMutex));
if (pending_callback == NULL) {
GError *err = g_error_new(BL_ERROR_DOMAIN, BL_MALLOC_ERROR,
"Start event loop: Malloc error\n");
PROPAGATE_ERROR;
goto error1;
}
g_mutex_init(pending_callback);
g_mutex_lock(pending_callback);
cb_mutex = malloc(sizeof(GMutex));
if (cb_mutex == NULL) {
GError *err = g_error_new(BL_ERROR_DOMAIN, BL_MALLOC_ERROR,
"Start event loop: Malloc error\n");
PROPAGATE_ERROR;
goto error2;
}
g_mutex_init(cb_mutex);
event_thread = g_thread_try_new("event_loop", _event_thread, NULL, gerr);
for (int cnt = 0;
(!is_event_loop_running()) && (cnt < 60) && (event_thread != NULL) &&
(get_conn_state() == STATE_CONNECTING);
cnt++) {
sleep(1);
printf_dbg("wait for event loop\n");
}
if (event_thread == NULL) {
printf_dbg("%s\n", (*gerr)->message);
goto error3;
}
return 0;
error3:
free(cb_mutex);
cb_mutex = NULL;
error2:
free(pending_callback);
pending_callback = NULL;
error1:
return -1;
}
static int Link_Iterate(LinkElement *pHead)
{
int iRet=0;
LinkElement* pItem = pHead;
printf_dbg("F:%s, L:%d, -Enter;", __FUNCTION__, __LINE__);
if(pItem == NULL) {
return -1;
}
while(pItem != NULL) {
printf_dbg("<k:%d, v:%d>\n", pItem->key, pItem->value);
pItem = pItem->pNext;
}
return iRet;
}
void read_by_hnd_cb(guint8 status, const guint8 *pdu, guint16 plen,
gpointer user_data)
{
uint8_t data[plen];
ssize_t vlen;
cb_ctx_t *cb_ctx = user_data;
printf_dbg("[CB] IN read_by_hnd_cb\n");
if (status) {
cb_ctx->cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ctx->cb_ret_msg, "Read by handle callback: Failure: %s\n",
att_ecode2str(status));
goto error;
}
if (data == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg, "Read by handle callback: Malloc error\n");
goto error;
}
vlen = dec_read_resp(pdu, plen, data, sizeof(data));
if (vlen < 0) {
cb_ctx->cb_ret_val = BL_PROTOCOL_ERROR;
strcpy(cb_ctx->cb_ret_msg,
"Read by handle callback: Protocol error\n");
goto error;
}
cb_ctx->cb_ret_pointer = bl_value_new(NULL, 0, vlen, data);
if (cb_ctx->cb_ret_pointer == NULL) {
cb_ctx->cb_ret_val = BL_MALLOC_ERROR;
strcpy(cb_ctx->cb_ret_msg, "Read by handle callback: Malloc error\n");
}
cb_ctx->cb_ret_val = BL_NO_ERROR;
goto exit;
error:
if (cb_ctx->cb_ret_pointer)
free(cb_ctx->cb_ret_pointer);
exit:
g_mutex_unlock(&cb_ctx->pending_cb_mtx);
printf_dbg("[CB] OUT read_by_hnd_cb\n");
}
/*
* stack function defination
* */
int stack_construct(stack *pstack, int nlen)
{
int iRet=0;
printf_dbg("[F:%s, L:%d]\n", __FUNCTION__, __LINE__);
if(pstack == NULL || nlen<1) {
return -1;
}
printf_dbg("[F:%s, L:%d]\n", __FUNCTION__, __LINE__);
pstack->pStackBase = (stack_elem *)malloc((nlen+1)*sizeof(stack_elem));
pstack->pStackHeader = pstack->pStackBase;
pstack->nStackMaxSize = nlen;
pstack->nStackCurSize = 0;
return iRet;
}
int maze_test()
{
int iRet=0;
printf_dbg("[F:%s, L:%d]\n", __FUNCTION__, __LINE__);
iRet = maze_findAllway(g_arry_maze, g_nRow, g_nColm);
return 0;
}
/*
* Callback functions
*/
void connect_cb(GIOChannel *io, GError *err, gpointer user_data)
{
printf_dbg("[CB] IN connect_cb\n");
if (err) {
set_conn_state(STATE_DISCONNECTED);
cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ret_msg, "%s", err->message);
goto error;
}
attrib = g_attrib_new(iochannel);
set_conn_state(STATE_CONNECTED);
strcpy(cb_ret_msg, "Connection successful\n");
cb_ret_val = BL_NO_ERROR;
error:
g_mutex_unlock(pending_callback);
printf_dbg("[CB] OUT connect_cb\n");
}
/*
* maze function defination
* */
static int maze_findAllway(int **arry_maze, int nRow, int nColm)
{
int iRet=0;
stack stackM;
stack_elem selemCur;
printf_dbg("[F:%s, L:%d]\n", __FUNCTION__, __LINE__);
if(arry_maze==NULL || nRow<1 || nColm<1) {
return -1;
}
//1. construct stack
iRet = stack_construct(&stackM, nRow*nColm);
//2. init current stack element
selemCur.x = 0;
selemCur.y = 0;
selemCur.nDir = -1;
//3. Deepth-First-Search(DFS) search path
do {
iRet = maze_goNextStep(&stackM, &selemCur);
if(iRet == 1) {
#ifdef DEBUG
printf_dbg("[F:%s, L:%d] goNextStep success\n", __FUNCTION__, __LINE__);
stack_print(&stackM);
#endif
if(selemCur.x==g_nRow-1 && selemCur.y==g_nColm-1 && g_arry_maze[selemCur.x][selemCur.y]==0) {
stack_print(&stackM);
iRet = maze_goLastStep(&stackM, &selemCur);
}
} else if(iRet == 0) {
iRet = maze_goLastStep(&stackM, &selemCur);
}
}while(iRet==1);
//4. search all complete; destruct stack
stack_destruct(&stackM);
return iRet;
}
int stack_print(stack *pstack)
{
int iRet=0;
int i=0;
stack_elem selem;
printf_dbg("[F:%s, L:%d]\n", __FUNCTION__, __LINE__);
if(pstack == NULL || pstack->pStackBase == NULL) {
return -1;
}
printf_dbg("<--maze path length: %d, path print begin<--\n", pstack->nStackCurSize+1);
for(i=1; i<=pstack->nStackCurSize; i++) {
selem = *(pstack->pStackBase+i);
printf_dbg("[%d, %d]\n", selem.x, selem.y);
}
printf_dbg(">--maze path length: %d, path print end >--\n\n", pstack->nStackCurSize+1);
return iRet;
}
/*
* Callback functions
*/
void connect_cb(GIOChannel *io, GError *err, gpointer user_data)
{
cb_ctx_t *cb_ctx = user_data;
printf_dbg("IN connect_cb\n");
if (err) {
set_conn_state(cb_ctx->dev_ctx, STATE_DISCONNECTED);
cb_ctx->cb_ret_val = BL_REQUEST_FAIL_ERROR;
sprintf(cb_ctx->cb_ret_msg, "%s", err->message);
goto error;
}
cb_ctx->dev_ctx->attrib = g_attrib_new(cb_ctx->dev_ctx->iochannel);
set_conn_state(cb_ctx->dev_ctx, STATE_CONNECTED);
strcpy(cb_ctx->cb_ret_msg, "Connection successful\n");
cb_ctx->cb_ret_val = BL_NO_ERROR;
error:
g_mutex_unlock(&cb_ctx->pending_cb_mtx);
printf_dbg("OUT connect_cb\n");
}
static int Link_Destruct(LinkElement *pHead)
{
int iRet=0;
LinkElement *pItemCur=pHead;
LinkElement *pItemLast=pItemCur;
printf_dbg("F:%s, L:%d, -Enter;", __FUNCTION__, __LINE__);
if(pItemCur == NULL) {
return -1;
}
while(pItemCur != NULL) {
pItemLast = pItemCur;
pItemCur = pItemCur->pNext;
free(pItemLast);
printf_dbg("F:%s, L:%d, free one node successfully;", __FUNCTION__, __LINE__);
pItemLast = NULL;
}
return iRet;
}
void mcs_free(MCSPacket *pkt)
{
if(pkt == NULL) {
return;
}
#ifdef DEBUG
/* This is for extreme compliance */
if(pkt->nargs == 0 && pkt->args != NULL) {
printf_dbg("Mismatch between pkt->nargs and pkt->args\n");
free(pkt->args);
}
if(pkt->nargs != 0 && pkt->args == NULL) {
printf_dbg("Mismatch between pkt->nargs and pkt->args\n");
pkt->nargs = 0;
}
if(pkt->data_size == 0 && pkt->data != NULL) {
printf_dbg("Mismatch between pkt->data_size and pkt->data\n");
free(pkt->data);
}
if(pkt->data_size != 0 && pkt->data == NULL) {
printf_dbg("Mismatch between pkt->data_size and pkt->data\n");
pkt->data_size = 0;
}
#endif
if(pkt->nargs != 0) {
free(pkt->args);
}
if(pkt->data_size != 0) {
free(pkt->data);
}
free(pkt);
}
/*
* return value:
* 1 -- success
* 0 -- failed
* -1 -- exception
* */
static int maze_goLastStep(stack *pstack, stack_elem *pselemCur)
{
int iRet=0;
printf_dbg("[F:%s, L:%d]\n", __FUNCTION__, __LINE__);
if(pstack==NULL || pselemCur==NULL) {
return -1;
}
iRet = stack_pop(pstack, pselemCur);
return iRet;
}
int start_event_loop(GError **gerr)
{
g_mutex_init(&cb_mutex);
event_thread = g_thread_try_new("event_loop", _event_thread, NULL, gerr);
for (int cnt = 0;
(!is_event_loop_running()) && (cnt < 60) && (event_thread != NULL);
cnt++) {
sleep(1);
printf_dbg("wait for event loop\n");
}
if (event_thread == NULL) {
printf_dbg("%s\n", (*gerr)->message);
goto error;
}
return 0;
error:
return -1;
}
int stack_destruct(stack *pstack)
{
int iRet=0;
printf_dbg("[F:%s, L:%d]\n", __FUNCTION__, __LINE__);
if(pstack == NULL) {
return -1;
}
if(pstack->pStackBase != NULL) {
free(pstack->pStackBase);
pstack->pStackBase=NULL;
}
return iRet;
}
int stack_isFull(stack *pstack)
{
int iRet=0;
printf_dbg("[F:%s, L:%d]\n", __FUNCTION__, __LINE__);
if(pstack == NULL) {
return -1;
}
if(pstack->nStackCurSize == pstack->nStackMaxSize) {
iRet = 1;
} else {
iRet = 0;
}
return iRet;
}
static int maze_parseDirToXY(int nDir, int *px, int *py)
{
int iRet=0;
printf_dbg("[F:%s, L:%d]\n", __FUNCTION__, __LINE__);
if(px == NULL || py == NULL) {
return -1;
}
switch (nDir) {
case 0:
*px++;
break;
case 1:
*px++;
*py--;
break;
case 2:
*py--;
break;
case 3:
*px--;
*py--;
break;
case 4:
*px--;
break;
case 5:
*px--;
*py++;
break;
case 6:
*py++;
break;
case 7:
*px++;
*py++;
break;
default:
break;
}
return iRet;
}
