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

uint8_t AJRouter_Connect(AJ_BusAttachment* busAttachment, const char* routerName){    while (TRUE) {        AJ_Status status = AJ_OK;#ifdef ONBOARDING_SERVICE        status = AJOBS_EstablishWiFi();        if (status != AJ_OK) {            AJ_AlwaysPrintf(("Failed to establish WiFi connectivity with status=%s/n", AJ_StatusText(status)));            AJ_Sleep(AJAPP_CONNECT_PAUSE);            return FALSE;        }#endif        AJ_AlwaysPrintf(("Attempting to connect to bus '%s'/n", routerName));        status = AJ_FindBusAndConnect(busAttachment, routerName, AJAPP_CONNECT_TIMEOUT);        if (status != AJ_OK) {            AJ_AlwaysPrintf(("Failed to connect to bus sleeping for %d seconds/n", AJAPP_CONNECT_PAUSE / 1000));            AJ_Sleep(AJAPP_CONNECT_PAUSE);#ifdef ONBOARDING_SERVICE            if (status == AJ_ERR_DHCP) {                AJOBS_SwitchToRetry();            }#endif            continue;        }        const char* busUniqueName = AJ_GetUniqueName(busAttachment);        if (busUniqueName == NULL) {            AJ_AlwaysPrintf(("Failed to GetUniqueName() from newly connected bus, retrying/n"));            continue;        }        AJ_AlwaysPrintf(("Connected to router with BusUniqueName=%s/n", busUniqueName));        break;    }    return TRUE;}

static uint32_t PasswordCallback(uint8_t* buffer, uint32_t bufLen){    AJ_Status status = AJ_OK;#ifdef CONFIG_SERVICE    const char* hexPassword = AJSVC_PropertyStore_GetValue(AJSVC_PROPERTY_STORE_PASSCODE);#else    const char* hexPassword = "303030303030";#endif    size_t hexPasswordLen;    uint32_t len = 0;    if (hexPassword == NULL) {        AJ_AlwaysPrintf(("Password is NULL!/n"));        return len;    }    AJ_AlwaysPrintf(("Configured password=%s/n", hexPassword));    hexPasswordLen = strlen(hexPassword);    len = hexPasswordLen / 2;    status = AJ_HexToRaw(hexPassword, hexPasswordLen, buffer, bufLen);    if (status == AJ_ERR_RESOURCES) {        len = 0;    }    return len;}

static AJ_Status SendEvent(AJ_BusAttachment* busAttachment, uint32_t eventId){    AJ_Status status = AJ_OK;    AJ_Message msg;    status = AJ_MarshalSignal(busAttachment, &msg, eventId, NULL, 0, AJ_FLAG_SESSIONLESS, 0);    if (status != AJ_OK) {        goto ErrorExit;    }    status = AJ_DeliverMsg(&msg);    if (status != AJ_OK) {        goto ErrorExit;    }    status = AJ_CloseMsg(&msg);    if (status != AJ_OK) {        goto ErrorExit;    }    AJ_AlwaysPrintf(("Event sent successfully/n"));    return status;ErrorExit:    AJ_AlwaysPrintf(("Event sending failed with status=%s/n", AJ_StatusText(status)));    return status;}

static AJ_Status AppHandlePing(AJ_Message* msg){    AJ_Status status;    AJ_Message reply;    AJ_Arg arg;    status = AJ_UnmarshalArg(msg, &arg);    if (AJ_OK == status) {        if (arg.typeId == AJ_ARG_STRING) {            AJ_AlwaysPrintf(("Received ping request '%s'./n", arg.val.v_string));        } else {            AJ_AlwaysPrintf(("Unexpected arg type '%d' in ping request./n", arg.typeId));        }        status = AJ_MarshalReplyMsg(msg, &reply);        if (AJ_OK == status) {            /*             * Just return the arg we received             */            status = AJ_MarshalArg(&reply, &arg);            if (AJ_OK == status) {                status = AJ_DeliverMsg(&reply);            }        }    }    return status;}

static void AJ_WSL_HTCProcessControlMessageResponse_Fake(AJ_BufNode* pNodeHTCBody){    wsl_wmi_cmd_hdr* wmiCmdHdr2;    wmiCmdHdr2 = (wsl_wmi_cmd_hdr*)pNodeHTCBody->buffer;    AJ_WSL_WMI_CMD_HDR_FROM_WIRE(wmiCmdHdr2);    AJ_WSL_WMI_CMD_HDR_Print(wmiCmdHdr2);    AJ_BufNodePullBytes(pNodeHTCBody, sizeof(wsl_wmi_cmd_hdr));    if (wmiCmdHdr2->commandID == WMI_SOCKET_CMDID) {        wsl_wmi_socket_response_event* pSocketResp = (wsl_wmi_socket_response_event*)pNodeHTCBody->buffer;        AJ_WSL_WMI_SOCK_RESPONSE_FROM_WIRE(pSocketResp);        switch (pSocketResp->responseType) {        case WSL_SOCK_OPEN: {                //AJ_AlwaysPrintf(("PING response was received over the wire: addr 0x%x, size 0x%x/n/n", ping->ip_addr, ping->size));                AJ_AlwaysPrintf(("OPEN response was received over the wire, Handle is %x/n/n", pSocketResp->socketHandle));                break;            }        case WSL_SOCK_PING: {                //wsl_wmi_sock_ping* ping = (wsl_wmi_sock_ping*)pNodeHTCBody->buffer;                //AJ_WSL_WMI_SOCK_PING_FROM_WIRE(ping);                //AJ_AlwaysPrintf(("PING response was received over the wire: addr 0x%x, size 0x%x/n/n", ping->ip_addr, ping->size));                AJ_AlwaysPrintf(("PING response was received over the wire, Handle is %x/n/n", pSocketResp->socketHandle));                break;            }        default:            AJ_ASSERT("unknown socket command/n/n");        }    }}

static void handleOptionalProperty(const char* peerName, const char* key, const char* sig, const AJ_Arg* value) {    if (strcmp(sig, "s") == 0) {        AJ_AlwaysPrintf(("Optional Prop: %s=/"%s/"/n", key, value->val.v_string));    } else {        AJ_AlwaysPrintf(("Optional Prop: %s=[Not A String]/n", key));    }}

void AllJoyn_Start() {	AJ_Status status = AJ_OK;    AJ_AlwaysPrintf(("AllJoyn Version %s/n", AJ_GetVersion()));	//	status = AJ_WiFiScan(NULL, ScanResult, 32);//    if (status != AJ_OK) {//        AJ_AlwaysPrintf(("WiFi scan failed/n"));//    }//	status = ConfigureSoftAP();	esp_init(115200);	status = ConfigureWifi();//	esp_serial_proxy();	    if (status == AJ_OK) {//		AJ_Initialize();        AJ_Main();    }    AJ_AlwaysPrintf(("Quitting/n"));    while (TRUE) {    }}

/** * Callback function prototype for requesting a password or pincode from an application. * * @param buffer  The buffer to receive the password. * @param bufLen  The size of the buffer * * @return  Returns the length of the password. If the length is zero this will be *          treated as a rejected password request. */static uint32_t PasswordCallback(uint8_t* buffer, uint32_t bufLen){    char inputBuffer[16];    const uint32_t bufSize = sizeof(inputBuffer) / sizeof(inputBuffer[0]);    uint32_t maxCopyLength;#ifdef AJ_NO_CONSOLE                    /* If there is no console to read/write from/to. */    const char password[] = "107734";   /* Upside down this can be read as 'hELLO!'. */    maxCopyLength = sizeof(password) - 1;    if (maxCopyLength > bufSize) {        maxCopyLength = bufSize;    }    memcpy(inputBuffer, password, maxCopyLength);#else    /* Take input from stdin and send it. */    AJ_AlwaysPrintf(("Please enter one time password : "));    /* Use 'bufSize - 1' to allow for '/0' termination. */    maxCopyLength = get_line(inputBuffer, bufSize - 1, stdin);#endif    if (maxCopyLength > bufLen) {        maxCopyLength = bufLen;    }    /* Always terminated with a '/0' for following AJ_Printf(). */    inputBuffer[maxCopyLength] = '/0';    memcpy(buffer, inputBuffer, maxCopyLength);    AJ_AlwaysPrintf(("Responding with password of '%s' length %u./n", inputBuffer, maxCopyLength));    return maxCopyLength;}

AJ_Status ReceiveNewName(AJ_Message*msg){    AJ_Arg arg;    AJ_Status status = AJ_UnmarshalArg(msg, &arg);    if (status == AJ_OK) {        AJ_AlwaysPrintf(("--==## signalConsumer: Name Changed signal Received ##==--/n"));        AJ_AlwaysPrintf(("/tNew name: '%s'./n", arg.val.v_string));    }    return status;}

void TimerCallbackEndProc(uint32_t timerId, void* context){    AJ_AlwaysPrintf(("TimerCallbackEndProc %.6d /n", timerId));#ifdef READTEST    if (0 == memcmp(txBuffer, rxBuffer, sizeof(rxBuffer))) {        AJ_AlwaysPrintf(("Passed: buffers match./n"));    } else {        AJ_AlwaysPrintf(("FAILED: buffers mismatch./n"));        exit(-1);    }#endif    exit(0);}

static AJ_Status ApplicationHandleDismiss(int32_t notificationId, const char* appId){    AJ_AlwaysPrintf(("******************** Begin New Dismiss Received ********************/n"));    AJ_AlwaysPrintf(("Notification Id: %d/nApp Id: %s/n", notificationId, appId));    if (savedNotification.version > 0 && !strcmp(appId, savedNotification.appId) && notificationId == savedNotification.notificationId) {        AJ_AlwaysPrintf(("Notification dimissed: Version %u sent from OriginalSender %s/n", savedNotification.version, savedNotification.originalSenderName));        if (processingAction == FALSE) {            savedNotification.version = 0;        }    }    AJ_AlwaysPrintf(("******************** End New Dismiss Received ********************/n"));    return AJ_OK;}

AJ_Status NotificationConsumer_Init(){    AJ_Status status = AJ_OK;    Consumer_SetupEnv(&inputMode, &superAgentMode);    AJ_AlwaysPrintf(("Init(): Set Consumer to detect SuperAgent option is turned %s/n", superAgentMode ? "ON" : "off"));    status = AJNS_Consumer_Start(superAgentMode, &ApplicationHandleNotify, &ApplicationHandleDismiss);    memset(&savedNotification, 0, sizeof(AJNS_Consumer_NotificationReference));    AJ_AlwaysPrintf(("/n---------------------/nNotification Consumer started!/n"));    AJ_AlwaysPrintf(("DISMISS_DELAY_PERIOD: %u ms/n", DISMISS_DELAY_PERIOD));    AJ_AlwaysPrintf(("---------------------/n/n"));    return status;}

void WSL_PrintScan(void){    int i;    for (i = 0; i < list.size; i++) {        AJ_AlwaysPrintf(("%-17.17s ", list.list[i].ssid));        AJ_AlwaysPrintf(("RSSI: %u ", list.list[i].rssi));        AJ_AlwaysPrintf(("BSSID: %02x:%02x:%02x:%02x:%02x:%02x/n",                         list.list[i].bssid[0],                         list.list[i].bssid[1],                         list.list[i].bssid[2],                         list.list[i].bssid[3],                         list.list[i].bssid[4],                         list.list[i].bssid[5]));    }}

static void AppDoWork(){    /*     * This function is called if there are no messages to unmarshal     */    AJ_AlwaysPrintf(("do work/n"));}

/* * This test builds a ping response in a simulated wire buffer, and then parses the response */static void run_wsl_simulate_ping_recv(const struct test_case* test){    AJ_AlwaysPrintf(("/n/n**************/nTEST:  %s/n/n", __FUNCTION__));    ResetFakeWireBuffers();    AJ_WSL_NET_ping_FAKERESPONSE();    AJ_WSL_HTC_ProcessIncoming();}

AJ_Status OnboardingReadInfo(AJOBS_Info* info){    AJ_Status status = AJ_OK;    size_t size = sizeof(AJOBS_Info);    AJ_NV_DATASET* nvramHandle;    int sizeRead;    if (NULL == info) {        return AJ_ERR_NULL;    }    memset(info, 0, size);    if (!AJ_NVRAM_Exist(AJ_OBS_OBINFO_NV_ID)) {        return AJ_ERR_INVALID;    }    nvramHandle = AJ_NVRAM_Open(AJ_OBS_OBINFO_NV_ID, "r", 0);    if (nvramHandle != NULL) {        sizeRead = AJ_NVRAM_Read(info, size, nvramHandle);        status = AJ_NVRAM_Close(nvramHandle);        if (sizeRead != sizeRead) {            status = AJ_ERR_READ;        } else {            AJ_AlwaysPrintf(("Read Info values: state=%d, ssid=%s authType=%d pc=%s/n", info->state, info->ssid, info->authType, info->pc));        }    }    return status;}

AJ_Status AppHandleCat(AJ_Message* msg){    AJ_Status status = AJ_OK;    AJ_Message reply;    char* partA;    char* partB;    char* totalString;    AJ_AlwaysPrintf(("%s:%d:%s %d/n", __FILE__, __LINE__, __FUNCTION__, 0));    AJ_UnmarshalArgs(msg, "ss", &partA, &partB);    totalString = (char*) AJ_Malloc(strlen(partA) + strlen(partB) + 1);    if (!totalString) {        return AJ_ERR_RESOURCES;    }    strcpy(totalString, partA);    strcpy(totalString + strlen(partA), partB);    AJ_MarshalReplyMsg(msg, &reply);    AJ_MarshalArgs(&reply, "s", totalString);    status = AJ_DeliverMsg(&reply);    AJ_Free(totalString);    return status;}

void TestTimeConversion(){    TS_Time time;    TS_Date date;    AJ_Time ajtime;    uint8_t dow;    const char* WEEKDAYS[] = { "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat" };    ajtime.seconds = 1409262479; // Thu, 28 Aug 2014 21:47:59 GMT    ajtime.milliseconds = 66;    AJ_AlwaysPrintf(("epoch %u.%03u/n", ajtime.seconds, ajtime.milliseconds));    AJTime2TSDateTime(&ajtime, &date, &time);    dow = TSDateTime2AJTime(&date, &time, &ajtime);    AJ_AlwaysPrintf(("%s %02u/%02u/%02u %02u:%02u:%02u.%03u/n", WEEKDAYS[dow - 1], date.day, date.month, date.year, time.hour, time.minute, time.second, time.milliseconds));    AJ_AlwaysPrintf(("epoch %u.%03u/n", ajtime.seconds, ajtime.milliseconds));}

static AJ_Status AuthListenerCallback(uint32_t authmechanism, uint32_t command, AJ_Credential* cred){    AJ_Status status = AJ_ERR_INVALID;    AJ_AlwaysPrintf(("AuthListenerCallback authmechanism %08X command %d/n", authmechanism, command));    switch (authmechanism) {    case AUTH_SUITE_ECDHE_NULL:        cred->expiration = keyexpiration;        status = AJ_OK;        break;    case AUTH_SUITE_ECDHE_PSK:        switch (command) {        case AJ_CRED_PUB_KEY:            cred->data = (uint8_t*) psk_hint;            cred->len = strlen(psk_hint);            cred->expiration = keyexpiration;            status = AJ_OK;            break;        case AJ_CRED_PRV_KEY:            cred->data = (uint8_t*) psk_char;            cred->len = strlen(psk_char);            cred->expiration = keyexpiration;            status = AJ_OK;            break;        }        break;    default:        break;    }    return status;}

static void ScanResult(void* context, const char* ssid, const uint8_t mac[6], uint8_t rssi, AJ_WiFiSecurityType secType, AJ_WiFiCipherType cipherType){    static const char* const sec[] = { "OPEN", "WEP", "WPA", "WPA2" };    static const char* const typ[] = { "", ":TKIP", ":CCMP", ":WEP" };    AJ_AlwaysPrintf(("SSID %s [%02x:%02X:%02x:%02x:%02x:%02x] RSSI=%d security=%s%s/n", ssid, mac[0], mac[1], mac[2], mac[3], mac[4], mac[5], rssi, sec[secType], typ[cipherType]));}

void ram_diag(){    AJ_AlwaysPrintf(("SRAM usage (stack, heap, static): %d, %d, %d/n",                     stack_used(),                     heap_used(),                     static_used()));}

static AJSVC_ServiceStatus AJApp_MessageProcessor(AJ_BusAttachment* busAttachment, AJ_Message* msg, AJ_Status* status){    AJSVC_ServiceStatus serviceStatus = AJSVC_SERVICE_STATUS_HANDLED;    uint16_t port;    char* joiner;    uint32_t sessionId = 0;    uint8_t session_accepted = FALSE;    if (msg->msgId == AJ_METHOD_ACCEPT_SESSION) {    // Process all incoming request to join a session and pass request for acceptance by all services        *status = AJ_UnmarshalArgs(msg, "qus", &port, &sessionId, &joiner);        if (*status != AJ_OK) {            return serviceStatus;        }        session_accepted |= (port == AJ_ABOUT_SERVICE_PORT);        session_accepted |= AJSVC_CheckSessionAccepted(port, sessionId, joiner);        *status = AJ_BusReplyAcceptSession(msg, session_accepted);        AJ_AlwaysPrintf(("%s session session_id=%u joiner=%s for port %u/n", (session_accepted ? "Accepted" : "Rejected"), sessionId, joiner, port));    } else {        switch (currentServicesInitializationState) {        case INIT_SERVICES_PORT:            if (msg->msgId == AJ_REPLY_ID(AJ_METHOD_BIND_SESSION_PORT)) {                currentServicesInitializationState = nextServicesInitializationState;            }            break;        default:            serviceStatus = AJSVC_MessageProcessorAndDispatcher(busAttachment, msg, status);            break;        }    }    return serviceStatus;}

static void run_buflist_external(const struct test_case* test){    uint8_t externA[10];    uint8_t externB[10];    /*     * verify the buffer list management     */    AJ_BufList* list1 = AJ_BufListCreate();    AJ_BufNode* pNode1 = AJ_BufListCreateNodeExternalBuffer((uint8_t*)&externA, sizeof(externA));    AJ_BufNode* pNode2 = AJ_BufListCreateNodeExternalBuffer((uint8_t*)&externB, sizeof(externB));    AJ_AlwaysPrintf(("/n/n**************/nTEST:  %s/n/n", __FUNCTION__));    memset(pNode1->buffer, 0x1, pNode1->length);    memset(pNode2->buffer, 0x2, pNode2->length);    AJ_BufListPushHead(list1, pNode1);    AJ_BufListPushTail(list1, pNode2);    AJ_BufNodeIterate(AJ_BufListNodePrint, list1, NULL);    AJ_BufNodeIterate(AJ_BufListNodePrintDump, list1, NULL);    AJ_BufListFree(list1, 1);}

AJ_Status SendPing(AJ_BusAttachment* bus, uint32_t sessionId){    AJ_Status status;    AJ_Message msg;    AJ_AlwaysPrintf(("Sending ping request '%s'./n", pingString));    status = AJ_MarshalMethodCall(bus,                                  &msg,                                  PRX_PING,                                  fullServiceName,                                  sessionId,                                  AJ_FLAG_ENCRYPTED,                                  METHOD_TIMEOUT);    if (AJ_OK == status) {        status = AJ_MarshalArgs(&msg, "s", pingString);    } else {        AJ_InfoPrintf(("In SendPing() AJ_MarshalMethodCall() status = %d./n", status));    }    if (AJ_OK == status) {        status = AJ_DeliverMsg(&msg);    } else {        AJ_InfoPrintf(("In SendPing() AJ_MarshalArgs() status = %d./n", status));    }    if (AJ_OK != status) {        AJ_InfoPrintf(("In SendPing() AJ_DeliverMsg() status = %d./n", status));    }    return status;}

static void PasswordGenerate(){#ifdef AJ_NO_CONSOLE                    /* If there is no console to read/write from/to. */    const char password[] = "107734";   /* Upside down this can be read as 'hELLO!'. */    const int maxPinSize = sizeof(pinStr) / sizeof(pinStr[0]) - 1;    pinLength = sizeof(password) - 1;    if (pinLength > maxPinSize) {        pinLength = maxPinSize;    }    memcpy(pinStr, password, pinLength);    pinStr[pinLength] = '/0';#else    int pin;    /* seed the random number */    srand((unsigned int) time(NULL));    pin = 1000 * (rand() % 1000) + (rand() % 1000);    sprintf(pinStr, "%06d", pin);    AJ_AlwaysPrintf(("One Time Password : '%s'./n", pinStr));    pinLength = (uint32_t)strlen(pinStr);#endif}

AJ_Status NotificationConsumer_Init(AJ_Object* proxyObjects){    AJ_Status status = AJ_OK;    Consumer_SetupEnv(&inputMode, &superAgentMode);    AJ_AlwaysPrintf(("Init(): Set Consumer to detect SuperAgent option is turned %s/n", superAgentMode ? "ON" : "off"));    status = AJNS_Consumer_Start(superAgentMode, proxyObjects, &ApplicationHandleNotify, &ApplicationHandleDismiss);    memset(&savedNotification, 0, sizeof(AJNS_Consumer_NotificationReference));    return status;}

static void set_SPI_registers(void){    volatile uint16_t spi_API = 0;    AJ_AlwaysPrintf(("/n/n**************/nTEST:  %s/n/n", __FUNCTION__));    // reset the target    //    spi_API = (1 << 15);    //    AJ_WSL_SPI_RegisterWrite(AJ_WSL_SPI_REG_SPI_CONFIG, spi_API);    //    AJ_Sleep(1 << 22);    // one extra write to force the device out of the reset state.    spi_API = 0x80;    AJ_WSL_SPI_RegisterWrite(AJ_WSL_SPI_REG_SPI_CONFIG, spi_API);    AJ_Sleep(100);    // write    spi_API = 0x80; // same as capture    AJ_WSL_SPI_RegisterWrite(AJ_WSL_SPI_REG_SPI_CONFIG, spi_API);    //    AJ_InfoPrintf(("AJ_WSL_SPI_REG_SPI_CONFIG    was %04x/n", spi_API));    AJ_WSL_SPI_RegisterRead(AJ_WSL_SPI_REG_WRBUF_SPC_AVA, (uint8_t*)&spi_API);    spi_API = LE16_TO_CPU(spi_API);    AJ_InfoPrintf(("AJ_WSL_SPI_REG_WRBUF_SPC_AVA          was %04x/n", spi_API));    spi_API = 0x40; // same as capture    AJ_WSL_SPI_RegisterWrite(AJ_WSL_SPI_REG_WRBUF_WATERMARK, spi_API);    //    AJ_InfoPrintf(("AJ_WSL_SPI_REG_SPI_CONFIG    was %04x/n", spi_API));    spi_API = 0x400; // same as capture    AJ_WSL_SPI_RegisterWrite(AJ_WSL_SPI_REG_INTR_CAUSE, spi_API);    AJ_InfoPrintf(("AJ_WSL_SPI_REG_INTR_CAUSE             was %04x/n", spi_API));    spi_API = 0x3ff;    AJ_WSL_SPI_RegisterWrite(AJ_WSL_SPI_REG_INTR_ENABLE, spi_API);    AJ_InfoPrintf(("AJ_WSL_SPI_REG_INTR_ENABLE    was %04x/n", spi_API));    spi_API = 0x0e;    AJ_WSL_SPI_RegisterWrite(AJ_WSL_SPI_REG_INTR_ENABLE, spi_API);    AJ_InfoPrintf(("AJ_WSL_SPI_REG_INTR_ENABLE    was %04x/n", spi_API));    spi_API = 0x1e;    AJ_WSL_SPI_RegisterWrite(AJ_WSL_SPI_REG_INTR_ENABLE, spi_API);    AJ_InfoPrintf(("AJ_WSL_SPI_REG_INTR_ENABLE    was %04x/n", spi_API));    spi_API = 0x0;    AJ_WSL_SPI_RegisterWrite(AJ_WSL_SPI_REG_INTR_ENABLE, spi_API);    AJ_InfoPrintf(("AJ_WSL_SPI_REG_INTR_ENABLE    was %04x/n", spi_API));    spi_API = 0x1e;    AJ_WSL_SPI_RegisterWrite(AJ_WSL_SPI_REG_INTR_ENABLE, spi_API);    AJ_InfoPrintf(("AJ_WSL_SPI_REG_INTR_ENABLE    was %04x/n", spi_API));    AJ_Sleep(100);}

AJ_Status AppHandleChatSignal(AJ_Message* msg){    AJ_Status status = AJ_OK;    char* chatString;    AJ_UnmarshalArgs(msg, "s", &chatString);    AJ_AlwaysPrintf(("RX chat from %s[%u]: %s/n", msg->sender, msg->sessionId, chatString));    return status;}

void AJ_NVRAM_Init(){    nvm_init(INT_FLASH);    nvm_get_page_size(INT_FLASH, &AJ_NVRAM_PageSize);    if (*((uint32_t*)AJ_NVRAM_BASE_ADDRESS) != AJ_NV_SENTINEL) {        AJ_AlwaysPrintf(("Sentinel has not been set, clearing NVRAM/n"));        _AJ_NVRAM_Clear();    }}

static uint8_t AcceptNewTestPeer(const char* peerName){    AJ_AlwaysPrintf(("AcceptNewTestPeer: name:%s/n", peerName));    if ((strcmp(g_peerServiceName, peerName) == 0)) {        return TRUE;    }    return FALSE;}