自学教程：C++ APP_DEBUG函数代码示例

// timer callback functionvoid Timer_handler(u32 timerId, void* param){    *((s32*)param) +=1;    if(Stack_timer == timerId)    {        APP_DEBUG("<-- stack Timer_handler, param:%d -->/r/n", *((s32*)param));        // stack_timer repeat        if(*((s32*)param) >= TIMEOUT_COUNT)        {            s32 ret;            ret = Ql_Timer_Stop(Stack_timer);            if(ret < 0)            {                APP_DEBUG("/r/n<--failed!! stack timer Ql_Timer_Stop ret=%d-->/r/n",ret);            }            APP_DEBUG("/r/n<--stack timer Ql_Timer_Stop(ID=%d,) ret=%d-->/r/n",Stack_timer,ret);        }    }    if(GP_timer == timerId)    {        APP_DEBUG("<-- GP-Timer_handler, param:%d -->/r/n", *((s32*)param));        //not repeat    }}

static void * idigi_run_thread(void * arg){    idigi_status_t status = idigi_success;    APP_DEBUG("idigi_run thread starts/n");    while (status == idigi_success)    {        status = idigi_run((idigi_handle_t)arg);        if (status == idigi_receive_error ||            status == idigi_send_error ||            status == idigi_connect_error)        {            /* server may disconnect us, so             * let's try to reconnect.             */            status = idigi_success;        }        /* if status is not idigi_success, calling idigi_run         * again will cause to re-connect to idigi.         */    }    APP_DEBUG("idigi_run thread exits %d/n", status);    pthread_exit(arg);}

void proc_main_task(s32 taskId){    ST_MSG msg;    s32 ret;    // Register & open UART port    ret = Ql_UART_Register(UART_PORT1, CallBack_UART_Hdlr, NULL);    Ql_UART_Register(UART_PORT2, CallBack_UART_Hdlr, NULL);    Ql_UART_Register(UART_PORT3, CallBack_UART_Hdlr, NULL);    ret = Ql_UART_Open(UART_PORT1, 115200, FC_NONE);    Ql_UART_Open(UART_PORT2, 115200, FC_NONE);    Ql_UART_Open(UART_PORT3, 115200, FC_NONE);    APP_DEBUG("<--OpenCPU: system.-->/r/n");    while(TRUE)    {        Ql_OS_GetMessage(&msg);        switch(msg.message)        {#ifdef __OCPU_RIL_SUPPORT__        case MSG_ID_RIL_READY:            APP_DEBUG("<-- RIL is ready -->/r/n");            Ql_RIL_Initialize();            break;#endif        default:            break;        }    }}

static void CallBack_UART_Hdlr(Enum_SerialPort port, Enum_UARTEventType msg, bool level, void* customizedPara){    switch (msg)    {    case EVENT_UART_READY_TO_READ:    {        s32 totalBytes = ReadSerialPort(port, m_RxBuf_Uart, sizeof(m_RxBuf_Uart));        if (totalBytes > 0)        {            proc_handle(m_RxBuf_Uart,sizeof(m_RxBuf_Uart));        }        break;    }    case EVENT_UART_DTR_IND:// DTR level changed, developer can wake up the module in here    {        if(0 == level)        {            APP_DEBUG("DTR set to low =%d  wake !!/r/n", level);            Ql_SleepDisable();        }        else        {            APP_DEBUG("DTR set to high =%d  Sleep /r/n", level);            Ql_SleepEnable();        }    }    case EVENT_UART_READY_TO_WRITE:        break;    default:        break;    }}

static void InitializeSerialPort(void){    s32 ret;     // Register & open UART port    // UART port    ret = Ql_UART_Register(m_myUartPort, CallBack_UART_Hdlr, NULL);    if (ret < QL_RET_OK)    {        Ql_Debug_Trace("Fail to register serial port[%d], ret=%d/r/n", m_myUartPort, ret);    }    ret = Ql_UART_Open(m_myUartPort, 115200, FC_NONE);    if (ret < QL_RET_OK)    {        Ql_Debug_Trace("Fail to open serial port[%d], ret=%d/r/n", m_myUartPort, ret);    }     Ql_UART_Write(m_myUartPort, "/r/nRDY/r/n", Ql_strlen("/r/nRDY/r/n"));     // Register & open virtual serial port    ret = Ql_UART_Register(m_myVirtualPort, CallBack_UART_Hdlr, NULL);    if (ret < QL_RET_OK)    {        APP_DEBUG("Fail to register serial port[%d], ret=%d/r/n", m_myVirtualPort, ret);    }    ret = Ql_UART_Open(m_myVirtualPort, 115200, FC_NONE);    if (ret < QL_RET_OK)    {        APP_DEBUG("Fail to open serial port[%d], ret=%d/r/n", m_myVirtualPort, ret);    }}

void CSD_Disconnect(void){    // -------- Received END command, exit from CSD data mode -------    APP_DEBUG("<-- Exit from CSD data mode -->/r/n");    Ql_UART_SendEscap(m_myVirtualPort);    // -------- Close CSD connection -------    APP_DEBUG("<-- Close CSD connection -->/r/n");    Ql_UART_Write(m_myVirtualPort, "ATH/n", 4);}

void CallBack_GPRS_Deactived(u8 contextId, s32 errCode, void* customParam ){    if (errCode == SOC_SUCCESS)    {        APP_DEBUG("<--CallBack: deactived GPRS successfully.-->/r/n");         m_tcp_state = STATE_NW_GET_SIMSTATE;    }else    {        APP_DEBUG("<--CallBack: deactived GPRS failure,(contexid=%d,error_cause=%d)-->/r/n",contextId,errCode);     }}

void UserData_BackUp_callback(s8 result, u8* pUserData, s32 len){    if(result)// 1 means backup successfully    {        APP_DEBUG("<--callback:Sysparam backUp successfully !!!-->/r/n");    }    else  // -1 means backup failed.    {        APP_DEBUG("<--callback:User Data backUP failed!!!-->/r/n");    }}

void Callback_GPRS_Actived(u8 contexId, s32 errCode, void* customParam){    if(errCode == SOC_SUCCESS)    {        APP_DEBUG("<--CallBack: active GPRS successfully.-->/r/n");        m_tcp_state = STATE_GPRS_GET_DNSADDRESS;    }else    {        APP_DEBUG("<--CallBack: active GPRS successfully,errCode=%d-->/r/n",errCode);        m_tcp_state = STATE_GPRS_ACTIVATE;    }      }

static void * application_run_thread(void * arg){    int status;    APP_DEBUG("idigi_run thread starts/n");    status = application_run((idigi_handle_t)arg);    APP_DEBUG("application_run thread exits %d/n", status);    pthread_exit(arg);}

static void Telephony_CallOut(void){    s32 ret;    s32 callState;    char callOutPhoneNum[] = "15056083774/0";    ret = RIL_Telephony_Dial(0, callOutPhoneNum, &callState);    if (RIL_AT_SUCCESS == ret && CALL_STATE_OK == callState)    {        APP_DEBUG("<-- Dial /"%s/" successfully -->/r/n", callOutPhoneNum);    } else {        APP_DEBUG("<-- Fail to dial /"%s/", cause: %d -->/r/n", ret);    }}

void UserData_Read_callback(s8 result, u8* pUserData, s32 len){    ST_UARTDCB* pBackupData = (ST_UARTDCB* )pUserData;    if(result)// 1 means backup successfully    {        APP_DEBUG("<--callback: Sysparam(len=%d) Read out successfully! BaudRate=%d,DataBit=%d,FlowCtrl=%d,Parity=%d,StopBit=%d-->/r/n", /                  len,pBackupData->baudrate,pBackupData->dataBits,pBackupData->flowCtrl,pBackupData->parity,pBackupData->stopBits);    }    else  // -1 means backup failed.    {        APP_DEBUG("<--callback: User Data Read out failed!!!-->/r/n");    }}

void CSD_Establish(char* csdNumber){    char strCsdDialAT[30];    s32 len = Ql_sprintf(strCsdDialAT, "ATD%s/r/n", csdNumber);    APP_DEBUG("<-- Dialing CSD number: %s -->/r/n", csdNumber);    Ql_UART_Write(m_myVirtualPort, strCsdDialAT, len);}

void proc_main_task(){    s32 ret;    ST_MSG msg;    bool keepGoing = TRUE;         // Register & open UART port    Ql_UART_Register(UART_PORT1, CallBack_UART_Hdlr, NULL);    Ql_UART_Open(UART_PORT1, 115200, FC_NONE);    Ql_UART_Register(UART_PORT2, CallBack_UART_Hdlr, NULL);    Ql_UART_Open(UART_PORT2, 115200, FC_NONE);    APP_DEBUG("/r/n<--OpenCPU: IIC TEST!-->/r/n");     while (keepGoing)    {         Ql_OS_GetMessage(&msg);        switch(msg.message)        {        case 0:            break;        default:            break;        }            }}

static int app_server_reboot(void){    APP_DEBUG("Reboot from server/n");    /* should not return from rebooting the system */    return 0;}

idigi_callback_status_t iDigiFileSystem::app_process_file_stat(idigi_file_stat_request_t * const request_data,                                                     idigi_file_stat_response_t * const response_data){    idigi_file_stat_t *pstat = &response_data->statbuf;    idigi_callback_status_t status = idigi_callback_continue;    SdFile entry = DigiSD.open(request_data->path);    if (!entry.isOpen())    {     	APP_DEBUG("stat cannot open: %s/n", request_data->path);        goto done;   	    }    pstat->last_modified = 0;					// Last modified date unsupported:    pstat->hash_alg = idigi_file_hash_none;	// File hash not supported    pstat->file_size = (size_t) entry.fileSize();    pstat->flags = 0;    if (entry.isDir())    	pstat->flags |= IDIGI_FILE_IS_DIR;    else    	pstat->flags |= IDIGI_FILE_IS_REG;    entry.close();done:    return status;}

static s32 ReadSerialPort(Enum_SerialPort port, /*[out]*/u8* pBuffer, /*[in]*/u32 bufLen){    s32 rdLen = 0;    s32 rdTotalLen = 0;    int loopi = 0;    if (NULL == pBuffer || 0 == bufLen)    {        return -1;    }    Ql_memset(pBuffer, 0x0, bufLen);    while (1)    {        rdLen = Ql_UART_Read(port, pBuffer + rdTotalLen, bufLen - rdTotalLen);               if (rdLen <= 0)  // All data is read out, or Serial Port Error!        {            break;        }        rdTotalLen += rdLen;        // Continue to read...    }    if (rdLen < 0) // Serial Port Error!    {        APP_DEBUG("Fail to read from port[%d]/r/n", port);        return -99;    }    return rdTotalLen;}

void proc_main_task(void){    s32 ret;    ST_MSG msg;    bool keepGoing = TRUE;        // Init serial port    InitializeSerialPort();    APP_DEBUG(MY_FILE_TAG);        // START MESSAGE LOOP OF THIS TASK    while (keepGoing)    {         Ql_OS_GetMessage(&msg);        switch(msg.message)        {                       case 0:            {                                break;            }                        default:                break;                  }            }}

void proc_main_task(s32 taskId){    s32 ret;    ST_MSG msg;    // Register & open UART port    ret = Ql_UART_Register(UART_PORT1, CallBack_UART_Hdlr, NULL);    if (ret < QL_RET_OK)    {        Ql_Debug_Trace("Fail to register serial port[%d], ret=%d/r/n", m_myUartPort, ret);    }    ret = Ql_UART_Open(UART_PORT1, 115200, FC_NONE);    if (ret < QL_RET_OK)    {        Ql_Debug_Trace("Fail to open serial port[%d], ret=%d/r/n", m_myUartPort, ret);    }    APP_DEBUG("/r/n<-- OpenCPU: ADC Example -->/r/n")             // Start to program ADC    ADC_Program();    // Start message loop of this task    while (TRUE)    {        Ql_OS_GetMessage(&msg);        switch(msg.message)        {        case MSG_ID_USER_START:            break;        default:            break;        }    }}

bool SendMtkBinCmd(u8 *strCmd){        int len = 0,ret = 0;        unsigned char outBuffer[256];    	// At initial, the protocol setting of the communication UART is supposed to be PMTK protocol.	// Since EPO data are transferred using MTK Binary Packet, you have to change the protocol setting to MTK Binary Protocol	// before starting EPO Transfer Protocol. You can use PMTK command 253 to change the UART protocol setting.	// Please refer to 7.1 for the details of PMTK command 253.        Ql_memset(outBuffer,0,sizeof(outBuffer));                        Ql_memcpy((void *)outBuffer, strCmd, Ql_strlen(strCmd));        len = Ql_strlen(outBuffer);        outBuffer[len++] = 0x0D;        outBuffer[len++] = 0x0A;        outBuffer[len] = '/0';      	/*send the data of outBuffer to the GPS module example L70 ect. */        ret = Ql_UART_Write(m_gnssUartPort,outBuffer,len);        if (ret < len)        {            APP_DEBUG("SendMtkBinCmd Only part of bytes are written, %d/%d /r/n", ret, len);            return FALSE;        }                return TRUE;	}

idigi_status_t app_send_put_request(idigi_handle_t handle){    idigi_status_t status = idigi_no_resource;    static idigi_data_service_put_request_t header; /* idigi connector will hold this until we get a response/error callback */    static char const file_path[] = "test/test.txt";    static char const file_type[] = "text/plain";    static char const buffer[] = "iDigi data service sample/n";    client_data_t * const app_data = malloc(sizeof *app_data);    if (app_data == NULL)        goto error;    app_data->data_ptr = buffer;    app_data->bytes = strlen(buffer);    header.flags = IDIGI_DATA_PUT_APPEND;    header.path  = file_path;    header.content_type = file_type;    header.context = app_data; /* will be returned in all subsequent callbacks */    status = idigi_initiate_action(handle, idigi_initiate_data_service, &header, NULL);    APP_DEBUG("Status: %d, file: %s/n", status, file_path);    if (status != idigi_success)        free(app_data);error:    return status;}

bool PeerConnector::IsBusy() const{	int maxConn = m_AppModule.GetSysInfo().MaxConnectPendingCount;#if 0	maxConn = 10;#pragma message("!!!!!使用固定的并发连接限制值10")#endif	int pendingCount = tcp_socket::pending_connection_count();	APP_DEBUG("TCPConnectIsBusy: " << make_tuple(maxConn, pendingCount, GetTotalPendingPeerCount()));	//? 是否需要考虑对maxConn加以限制	LIMIT_MAX(maxConn, 100);// 	if (pendingCount < (int)GetTotalPendingPeerCount())// 	{// 		// 取pendingCount和m_PendingConnections中个数的最大值// 		pendingCount = (int)GetTotalPendingPeerCount();// 	}	if (pendingCount < (int)m_TCPConnector->GetConnectingPeerCount())	{		// 取pendingCount和m_PendingConnections中个数的最大值		pendingCount = (int)m_TCPConnector->GetConnectingPeerCount();	}	return pendingCount >= maxConn;}

void callback_socket_close(s32 socketId, s32 errCode, void* customParam ){    m_nSentLen  = 0;        if (errCode == SOC_SUCCESS)    {        APP_DEBUG("<--CallBack: close socket successfully.-->/r/n");     }else if(errCode == SOC_BEARER_FAIL)    {           m_tcp_state = STATE_GPRS_DEACTIVATE;        APP_DEBUG("<--CallBack: close socket failure,(socketId=%d,error_cause=%d)-->/r/n",socketId,errCode);     }else    {        m_tcp_state = STATE_GPRS_GET_DNSADDRESS;        APP_DEBUG("<--CallBack: close socket failure,(socketId=%d,error_cause=%d)-->/r/n",socketId,errCode);     }}

static void InitializeSerialPort(void){    s32 ret;    // Register & open UART port    // UART1 for MCU    ret = Ql_UART_Register(m_mcuUartPort, CallBack_UART_Hdlr, NULL);    if (ret < QL_RET_OK)    {        Ql_Debug_Trace("Fail to register serial port[%d], ret=%d/r/n", m_mcuUartPort, ret);    }    ret = Ql_UART_Open(m_mcuUartPort, 115200, FC_NONE);    if (ret < QL_RET_OK)    {        Ql_Debug_Trace("Fail to open serial port[%d], ret=%d/r/n", m_mcuUartPort, ret);    }        // Register & open UART port    // UART3 for MCU    ret = Ql_UART_Register(m_gnssUartPort, CallBack_UART_Hdlr, NULL);    if (ret < QL_RET_OK)    {        APP_DEBUG("Fail to register serial port[%d], ret=%d/r/n", m_gnssUartPort, ret);    }    ret = Ql_UART_Open(m_gnssUartPort, 9600, FC_NONE);    if (ret < QL_RET_OK)    {        APP_DEBUG("Fail to open serial port[%d], ret=%d/r/n", m_gnssUartPort, ret);    }        // Register & open Modem port    ret = Ql_UART_Register(m_myVirtualPort, CallBack_UART_Hdlr, NULL);    if (ret < QL_RET_OK)    {        APP_DEBUG("Fail to register serial port[%d], ret=%d/r/n", m_myVirtualPort, ret);    }    ret = Ql_UART_Open(m_myVirtualPort, 0, FC_NONE);    if (ret < QL_RET_OK)    {        APP_DEBUG("Fail to open serial port[%d], ret=%d/r/n", m_myVirtualPort, ret);    }    return;}

/* * This routine reads a specified number of bytes from the iDigi server.  This  * function must not block. If it encounters EAGAIN or EWOULDBLOCK error, 0  * bytes must be returned and IIK will continue calling this function. */static idigi_callback_status_t app_network_receive(idigi_read_request_t * read_data, size_t * read_length){    idigi_callback_status_t rc = idigi_callback_continue;    struct timeval timeout;    fd_set read_set;    int ccode, err;    timeout.tv_sec = read_data->timeout;    timeout.tv_usec = 0;    *read_length = 0;    FD_ZERO(&read_set);    FD_SET(*read_data->network_handle, &read_set);    /* Blocking point for IIK */    ccode = select(*read_data->network_handle+1, &read_set, NULL, NULL, &timeout);    if (ccode < 0)    {        goto done;    }    if (!FD_ISSET(*read_data->network_handle, &read_set))    {        rc = idigi_callback_busy;        goto done;    }    ccode = recv(*read_data->network_handle, (char *)read_data->buffer, (int)read_data->length, 0);    if (ccode == 0)    {        /* EOF on input: the connection was closed. */        APP_DEBUG("network_receive: EOF on socket/r/n");        errno = ECONNRESET;        rc = idigi_callback_abort;    }    else if (ccode < 0)    {        /* An error of some sort occurred: handle it appropriately. */        err = errno;        if (err == EAGAIN || err == EWOULDBLOCK)        {            rc = idigi_callback_busy;        }        else        {            perror("network_receive: recv() failed");            /* if not timeout (no data) return an error */            rc = idigi_callback_abort;        }    }    *read_length = (size_t)ccode;done:    return rc;}

static idigi_callback_status_t app_process_action_end(idigi_remote_group_request_t const * const request,                                                      idigi_remote_group_response_t * const response){    APP_DEBUG("app_process_action_end/n");    UNUSED_ARGUMENT(request);    UNUSED_ARGUMENT(response);    return idigi_callback_continue;}

int main (void){    int status=EXIT_FAILURE;    idigi_handle_t idigi_handle;    APP_DEBUG("main: Starting iDigi/n");    idigi_handle = idigi_init((idigi_callback_t) app_idigi_callback);    if (idigi_handle == NULL)    {        APP_DEBUG("main: idigi_init() failed/n");        goto done;    }    /* Sample program control loop */    for(;;)    {        idigi_status_t status;        /*         * Example of using idigi_step(), we run a portion of the IIK then run         * a portion of the users application.         */        status = idigi_step(idigi_handle);        if (status != idigi_success && status != idigi_receive_error &&            status != idigi_send_error && status != idigi_connect_error)        {            /* We exclude idigi_receive_error, idigi_send_error, &             * idigi_connect_error. We want to reconnect iDigi             * even if idigi_step returns error in receive, send, or connect.             */            APP_DEBUG("main: idigi_step() failed/n");            break;        }        if (application_step(idigi_handle) != 0)        {            APP_DEBUG("main: application_step() failed/n");            goto done;        }        usleep(1000);    }done:    return status;}

void callback_socket_connect(s32 socketId, s32 errCode, void* customParam ){    if (errCode == SOC_SUCCESS)    {        if (timeout_90S_monitor) //stop timeout monitor        {           Ql_Timer_Stop(TIMEOUT_90S_TIMER_ID);           timeout_90S_monitor = FALSE;        }        APP_DEBUG("<--Callback: socket connect successfully.-->/r/n");        m_tcp_state = STATE_SOC_SEND;    }else    {        APP_DEBUG("<--Callback: socket connect failure,(socketId=%d),errCode=%d-->/r/n",socketId,errCode);        Ql_SOC_Close(socketId);        m_tcp_state = STATE_SOC_CREATE;    }}