/* AT command callback, which will be called after the AT command is sent from the Monitor tool */ static void at_callback(vm_cmd_command_t* param, void* user_data) { VMINT result; if(strcmp("Test01",(char*)param->command_buffer) == 0) { /* Opens the cell when receiving AT command: AT+[1000]Test01 */ result = vm_gsm_cell_open(); vm_log_info("open result = %d",result); } else if(strcmp("Test02",(char*)param->command_buffer) == 0) { /* Gets the current cell info when receiving AT command: AT+[1000]Test02 */ vm_gsm_cell_get_current_cell_info(&g_info); vm_log_info("ar=%d, bsic=%d, rxlev=%d, mcc=%d, mnc=%d, lac=%d, ci=%d", g_info.arfcn, g_info.bsic, g_info.rxlev, g_info.mcc, g_info.mnc, g_info.lac, g_info.ci); } else if(strcmp("Test03",(char*)param->command_buffer) == 0) { /* Gets the neighboring cell info when receiving AT command: AT+[1000]Test03 */ int i, count; count = vm_gsm_cell_get_neighbor_number(); vm_log_info("neighbor count=%d", count); for(i=0; i<count; i++) { vm_gsm_cell_get_neighbor_cell_info(&g_info, i); vm_log_info("ar=%d, bsic=%d, rxlev=%d, mcc=%d, mnc=%d, lac=%d, ci=%d", g_info.arfcn, g_info.bsic, g_info.rxlev, g_info.mcc, g_info.mnc, g_info.lac, g_info.ci); } } else if(strcmp("Test04",(char*)param->command_buffer) == 0) { /* Closes the cell when receiving AT command: AT+[1000]Test04 */ vm_gsm_cell_close(); } }
static void onWifiConnected(void *user_data, vm_wlan_conn_res_struct *conn_res) { vm_log_info("onWifiConnected (MMI)"); LWiFiConnectContext *pContext = (LWiFiConnectContext*)user_data; // connect result pContext->result = *conn_res; vm_log_info("onWifiConnected result=%d", conn_res->result); if (VM_WLAN_RESULT_SUCCESS != pContext->result.result) { vm_log_info("FAILED ret=%d cause=%d", conn_res->result, conn_res->cause); // connect fail, // wakeup Arduino thread directly LTask.post_signal(); } else { // connect OK, // retrieve AP & IP info. // in DHCP case, we may need to wait for IP ready vm_wlan_get_connected_ap_info((void*)&pContext->connectedInfo, VM_WLAN_AP_INFO_ALL); // We should then wait for IP info, which will be callbacked } return; }
static void onWiFiSnifferOn(void *userData, vm_wlan_sniffer_on_res_struct *res) { LWiFiConnectContext *pContext = (LWiFiConnectContext*)userData; vm_log_info("onWiFiSnifferOn result=%d, cb_type=%d", res->result, res->cb_type); if(VM_WLAN_SNIFFER_SUCCESS == res->result) { if(VM_WLAN_SNIFFER_ON_RES == res->cb_type) { } else if(VM_WLAN_SNIFFER_ON_AP_INFO == res->cb_type) { vm_wlan_prof_struct prof; memset(&prof, 0, sizeof(vm_wlan_prof_struct)); memcpy(&prof, &(res->profile), sizeof(vm_wlan_prof_struct)); pContext->apInfo.auth_mode = prof.auth_mode; strncpy((char*)pContext->apInfo.ssid, (char*)prof.ssid, VM_WLAN_PROF_MAX_SSID_LEN); strncpy((char*)pContext->apInfo.password, (char*)prof.password, VM_WLAN_PROF_PSWD_MAX_LEN); vm_log_info("auth_mode: %d", res->profile.auth_mode); vm_log_info("ssid: %s", (char*)pContext->apInfo.ssid); vm_log_info("password: %s", (char*)pContext->apInfo.password); vm_wlan_sniffer_off(onWiFiSnifferOff, pContext); } } else { vm_log_info("vm_wlan_sniffer_on fails, result=%d", res->result); pContext->result.result = VM_WLAN_RESULT_FAILED; LTask.post_signal(); } }
int LGPRSClass::hostByName(const char* aHostname, IPAddress& aResult) { vm_log_info("hostByName"); LGPRSResolveContext context; // no memory copy since we're blocking call context.domainName = aHostname; LTask.remoteCall(&gprsResolveDomainName, (void*)&context); vm_log_info("context.resolveState = %d", context.resolveState); unsigned char* ipArray = (unsigned char*)&context.dns.address[0]; vm_log_info("Arduino DNS resolve callback, cause=%d, num=%d, address=%d.%d.%d.%d", context.dns.error_cause, context.dns.num, ipArray[0], ipArray[1], ipArray[2], ipArray[3]); // parse result if (VM_E_SOC_SUCCESS == context.resolveState) { // There may have multiple ip addresses. We take the 1st one. aResult = context.dns.address[0]; vm_log_info("get IP=%d.%d.%d.%d", aResult[0], aResult[1], aResult[2], aResult[3]); return 1; } else { return 0; } }
static boolean gprsResolveDomainName(void *userData) { LGPRSResolveContext *pContext = (LGPRSResolveContext*)userData; vm_log_info("vm_soc_get_host_by_name_ex: %s", pContext->domainName); pContext->resolveState = vm_soc_get_host_by_name_ex(VM_TCP_APN_CMNET, pContext->domainName, &pContext->dns, &gprsResolveCallback, pContext); vm_log_info("vm_soc_get_host_by_name_ex ret = %d", pContext->resolveState); if (pContext->resolveState > 0) { // not done yet return false; } switch(pContext->resolveState) { case VM_E_SOC_SUCCESS: // Get IP address successfully, result is filled. return true; case VM_E_SOC_WOULDBLOCK: // wait response from network, result could be gotten from callback. // need to wait, return directly // so MMI message loop may continue. return false; case VM_E_SOC_INVAL: // invalid arguments: null domain_name, etc. case VM_E_SOC_ERROR: // unspecified error case VM_E_SOC_LIMIT_RESOURCE: // socket resources not available case VM_E_SOC_INVALID_ACCOUNT: // invalid data account id return true; } }
boolean LTcpClient::wifiRead(void *userData) { LTcpReadWriteContext *pContext = (LTcpReadWriteContext*)userData; LTcpClient *pThis = pContext->pInst; pContext->lenProcessed = 0; // parameter check if(pContext->len <= 0) { return true; } vm_log_info("wifiRead len=%d", pContext->len); // check peek state if(pThis->m_peekBuffered) { // insert the peeked byte *((VMINT8*)pContext->buf) = pThis->m_peekByte; pContext->lenProcessed += 1; pContext->len--; // clear peek state pThis->m_peekByte = -1; pThis->m_peekBuffered = false; } VMINT readResult = VM_TCP_READ_EOF; // actually read from TCP socket if (pContext->serverHandle != -1) { readResult = vm_soc_svr_read(pContext->serverHandle, pContext->handle, pContext->buf, pContext->len); } else { readResult = vm_tcp_read(pContext->handle, pContext->buf, pContext->len); } if (readResult > 0) { pContext->lenProcessed += readResult; } if (readResult == VM_TCP_READ_EOF) { // we may cache a peek byte even if the socket is disconnected vm_log_info("wifiRead socket disconnected"); } vm_log_info("wifiRead %d bytes", pContext->lenProcessed); return true; }
int8_t LWiFiClass::scanNetworks() { vm_log_info("scanNetworks"); LWiFiScanContext context; LTask.remoteCall(&LWiFiScanContext::mmiCall, &context); m_scanInfo = context.result; vm_log_info("scanNetworks ret=%d", m_scanInfo.ap_list_num); return m_scanInfo.ap_list_num; }
boolean LUDP::udpSend(void* userdata) { LUDPSendContext *pCntx = (LUDPSendContext*)userdata; LUDP* pThis = pCntx->pThis; VMINT remainBuffer = pThis->m_writePos; VMUINT8 *pBuf = &pThis->m_writeBuffer[0]; vm_sockaddr_struct sendto = {0}; sendto.addr[0] = pThis->m_sendToIP[0]; sendto.addr[1] = pThis->m_sendToIP[1]; sendto.addr[2] = pThis->m_sendToIP[2]; sendto.addr[3] = pThis->m_sendToIP[3]; sendto.addr_len = 4; sendto.port = pThis->m_sendToPort; vm_log_info("send packet len:%d to %d.%d.%d.%d:%d", remainBuffer, sendto.addr[0], sendto.addr[1], sendto.addr[2], sendto.addr[3], sendto.port); while(remainBuffer > 0) { VMINT sentBytes = 0; sentBytes = vm_udp_sendto(pThis->m_serverHandle, pBuf, remainBuffer, &sendto); vm_log_info("vm_udp_sendto returns %d", sentBytes); if(sentBytes <= 0) { vm_log_error("vm_udp_sendto sent no content"); break; } pBuf += sentBytes; remainBuffer -= sentBytes; } // check if buffer is completely sent if(remainBuffer <= 0) { pCntx->sentComplete = 1; } else { pCntx->sentComplete = 0; } return true; }
/* The callback to be invoked by the system engine. */ void handle_sysevt(VMINT message, VMINT param) { switch (message) { case VM_EVENT_CREATE: vm_log_info("reboot test create"); reboot_test_main(); break; case VM_EVENT_QUIT: vm_log_info("reboot test quit"); break; } }
VMUINT8 gsm_sms_get_unread(void* userdata) { sms_unread_msg_struct *dest = (sms_unread_msg_struct*)userdata; VMINT16 message_id; vm_gsm_sms_read_message_data_t* message_data = NULL; VMWCHAR* content_buff; VMINT res; //message_id = vm_gsm_sms_get_message_id(VM_GSM_SMS_BOX_INBOX, 0); //dest -> id = message_id; message_id = dest->id; if(message_id >= 0) { // Allocates memory for the message data message_data = (vm_gsm_sms_read_message_data_t*)vm_calloc(sizeof(vm_gsm_sms_read_message_data_t)); if(message_data == NULL) { vm_log_info("sms read malloc message data fail"); return FALSE; } // Allocates memory for the content buffer of the message content_buff = (VMWCHAR*)vm_calloc((500+1)*sizeof(VMWCHAR)); if(content_buff == NULL) { vm_free(message_data); vm_log_info("sms read malloc content fail"); return FALSE; } message_data->content_buffer = content_buff; message_data->content_buffer_size = 500; // Reads the message res = vm_gsm_sms_read_message(message_id, VM_TRUE, message_data, sms_read_callback, NULL); //vm_log_info("vm_gsm_sms_read_message message_id is %d", message_id); if(res != VM_GSM_SMS_RESULT_OK) { vm_free(content_buff); vm_free(message_data); vm_log_info("register read callback fail"); return FALSE; } else { return TRUE; } } }
static void onWiFiEnabled(void *userData, vm_wlan_req_res_enum result) { LWiFiConnectContext *pContext = (LWiFiConnectContext*)userData; vm_log_info("onWiFiEnabled result=%d", result); do { if (VM_WLAN_REQ_RES_DONE != result) { vm_log_info("wifi status change error=%d", result); break; } if(true == pContext->isWaitApInfo) { VMINT snifferOnRet = vm_wlan_sniffer_on(NULL, &onWiFiSnifferOn, pContext); if(VM_WLAN_RESULT_PROCESSING != snifferOnRet) { vm_log_info("wlan sniffer on fails ret=%d", snifferOnRet); break; } vm_log_info("start waiting AP info"); return; } vm_log_info("vm_wlan_reg_noti"); // register IP callback vm_wlan_reg_noti(VM_WLAN_NOTI_IP_AVAILABLE, &onWiFiIPReady, pContext); vm_log_info("vm_wlan_connect"); // connect to AP VMINT connectRet = vm_wlan_connect(&pContext->apInfo, &onWifiConnected, pContext); vm_log_info("vm_wlan_connect ret =%d", connectRet); if (connectRet != VM_WLAN_RESULT_PROCESSING) { vm_log_info("vm_wlan_connect fails ret=%d", connectRet); break; } vm_log_info("start waiting connect & IP address"); return; } while (0); // fail and allow arduino thread to keep going vm_log_info("vm_wlan_mode_set cb result=%d", result); pContext->result.result = VM_WLAN_RESULT_FAILED; LTask.post_signal(); }
boolean LTcpClient::connectIP(void *userData) { LTcpConnectContext *pContext = (LTcpConnectContext*)userData; // async api vm_log_info("connectIP, IP=%s, port=%d", pContext->ipAddr, pContext->port); VMINT clientHandle = vm_tcp_connect_ex(pContext->ipAddr, pContext->port, pContext->pInstance->getAPN(), pContext->pInstance, &connectCallback); vm_log_info("vm_tcp_connect returns %d", clientHandle); return false; }
int LTcpClient::connect(IPAddress ip, uint16_t port) { vm_log_info("connect(IPAddress)"); char ipAddr[50] = {0}; sprintf(ipAddr, "%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]); vm_log_info("connect to %s", ipAddr); return connect(ipAddr, port); }
static boolean wifiMacAddress(void* userData) { vm_log_info("wifiMacAddress called"); LWiFiClass *pThis = (LWiFiClass*)userData; vm_wlan_prof_str_info_qry_struct qry; qry.dest = pThis->m_macAddress; qry.dest_len = VM_WLAN_WNDRV_MAC_ADDRESS_LEN; qry.req_len = VM_WLAN_WNDRV_MAC_ADDRESS_LEN; pThis->m_lastError = vm_wlan_get_mac_address(&qry); vm_log_info("wifiMacAddress called, result = %d", pThis->m_lastError); vm_log_info("req_len=%d", qry.req_len); return true; }
size_t LTcpClient::write(uint8_t b) { vm_log_info("wifiWrite arduino (byte)"); LTcpReadWriteContext c; c.handle = m_handle.m_handle; c.serverHandle = m_handle.m_serverHandle; c.buf = &b; c.len = 1; c.pInst = this; LTask.remoteCall(&wifiWrite, &c); vm_log_info("written %d bytes", c.lenProcessed); return c.lenProcessed; }
size_t LTcpClient::write(const uint8_t *buf, size_t size) { vm_log_info("wifiWrite arduino (buffered)"); LTcpReadWriteContext c; c.handle = m_handle.m_handle; c.serverHandle = m_handle.m_serverHandle; c.buf = (void*)buf; c.len = size; c.pInst = this; LTask.remoteCall(&wifiWrite, &c); vm_log_info("written %d bytes", c.lenProcessed); return c.lenProcessed; }
int LTcpClient::read(uint8_t *buf, size_t size) { // read a single byte LTcpReadWriteContext c; uint8_t ret = 0; c.handle = m_handle.m_handle; c.serverHandle = m_handle.m_serverHandle; c.buf = buf; c.len = size; c.pInst = this; vm_log_info("wifiRead call with buf=%d, size=%d", c.buf, c.len); LTask.remoteCall(&wifiRead, &c); vm_log_info("LTcpClient::read return %d", c.lenProcessed); return c.lenProcessed; }
SharedHandle::SharedHandle(VMINT clientHandle, VMINT serverHandle): m_handle(clientHandle), m_serverHandle(serverHandle), m_pSharedCount(new VMINT(1)) { vm_log_info("SharedHandle create: c:%d, s:%d", m_handle, m_serverHandle); }
void UartIrqHandler(void* parameter, VM_DCL_EVENT event, VM_DCL_HANDLE device_handle) { if(event == VM_UART_READY_TO_READ) { char data[SERIAL_BUFFER_SIZE]; int i; VM_DCL_STATUS status; VM_DCL_BUFF_LEN returned_len; status = vm_dcl_read(device_handle,(VM_DCL_BUFF*)data,SERIAL_BUFFER_SIZE,&returned_len,vm_dcl_get_ownerid()); if(status<VM_DCL_STATUS_OK) { vm_log_info((char*)"read failed"); } if(device_handle == g_APinDescription[0].ulHandle) { for(i=0;i<returned_len;i++) { Serial1._rx_buffer->store_char(data[i]); } } else { for(i=0;i<returned_len;i++) { Serial._rx_buffer->store_char(data[i]); } } } else { } }
uint8_t TwoWire::endTransmission(uint8_t sendStop) { vm_i2c_ctrl_config_t conf_data; vm_i2c_ctrl_single_write_t write_data; VM_DCL_STATUS ret = 0; int32_t sent = 0; if(i2c_handle==-1) { vm_log_info("endTransmission,i2c handle is invalid.i2c_handle:%d",i2c_handle); return 0; } if(0 < txBufferLength) { conf_data.Reserved0 = (VM_DCL_I2C_OWNER)0; conf_data.eTransactionMode = VM_DCL_I2C_TRANSACTION_FAST_MODE; conf_data.fgGetHandleWait = 0; conf_data.Reserved1 = 0; conf_data.u1DelayLen = 0; conf_data.u1SlaveAddress = txAddress; conf_data.u4FastModeSpeed = 100; conf_data.u4HSModeSpeed = 0; ret = vm_dcl_control(i2c_handle,VM_I2C_CMD_CONFIG,(void *)&conf_data); write_data.pu1Data = &(txBuffer[0]); write_data.u4DataLen = txBufferLength; ret = vm_dcl_control(i2c_handle,VM_I2C_CMD_SINGLE_WRITE,(void *)&write_data); sent = txBufferLength; } txBufferLength = 0; status = MASTER_IDLE; return sent; }
void TwoWire::beginTransmission(uint8_t address) { if(i2c_handle==-1) { vm_log_info("[TwoWire]beginTransmission:i2c handle is invalid,return"); return; } status = MASTER_SEND; // save address of target and empty buffer txAddress = address<<1; // frist transfer if (txBufferLength == 0) { bytes_per_transfer = 0; num_transfer = 1; } else { // conut the number of repeated start signal num_transfer++; } rxBufferLength = 0; bytes_per_read = 0; num_read = 0; }
SharedHandle::SharedHandle(VMINT handle): m_handle(handle), m_serverHandle(INVALID_HANDLE), m_pSharedCount(new VMINT(1)) { vm_log_info("SharedHandle create: c:%d, s:%d", m_handle, m_serverHandle); }
uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity, uint8_t sendStop) { // perform blocking read into buffer int readed = 0; VM_DCL_STATUS ret = 0; vm_i2c_ctrl_config_t conf_data; vm_i2c_ctrl_single_read_t read_data; if(i2c_handle==-1) { vm_log_info("requestFrom,i2c handle is invalid.i2c_handle:%d",i2c_handle); return 0; } if (quantity > BUFFER_LENGTH) quantity = BUFFER_LENGTH; conf_data.Reserved0 = (VM_DCL_I2C_OWNER)0; conf_data.eTransactionMode = VM_DCL_I2C_TRANSACTION_FAST_MODE; conf_data.fgGetHandleWait = 0; conf_data.Reserved1 = 0; conf_data.u1DelayLen = 0; conf_data.u1SlaveAddress = address<<1; conf_data.u4FastModeSpeed = 100; conf_data.u4HSModeSpeed = 0; ret = vm_dcl_control(i2c_handle,VM_I2C_CMD_CONFIG,(void *)&conf_data); read_data.pu1Data = &(rxBuffer[0]); read_data.u4DataLen = quantity; ret = vm_dcl_control(i2c_handle,VM_I2C_CMD_SINGLE_READ,(void *)&read_data); rxBufferIndex = 0; rxBufferLength = quantity; return quantity; }
static void call_voiceCall_callback(vm_gsm_tel_call_actions_callback_data_t *data) { vm_log_info("call_voiceCall_callback"); if (data->type_action == VM_GSM_TEL_CALL_ACTION_DIAL) { if (data->data_act_rsp.result_info.result == VM_GSM_TEL_OK) { g_call_status = CALLING; } else { g_call_status = IDLE_CALL; } } else if (data->type_action == VM_GSM_TEL_CALL_ACTION_ACCEPT) { if (data->data_act_rsp.result_info.result == VM_GSM_TEL_OK) { g_call_status = TALKING; } else { g_call_status = IDLE_CALL; } } else if (data->type_action == VM_GSM_TEL_CALL_ACTION_HOLD) { } else if (data->type_action == VM_GSM_TEL_CALL_ACTION_END_SINGLE) { g_call_status = IDLE_CALL; } else { } }
void adc_callback(void* parameter, VM_DCL_EVENT event, VM_DCL_HANDLE device_handle) { vm_dcl_callback_data_t *data; vm_dcl_adc_measure_done_confirm_t * result; vm_dcl_adc_control_send_stop_t stop_data; VMINT status = 0; if(parameter!=NULL) { data = ( vm_dcl_callback_data_t*)parameter; result = (vm_dcl_adc_measure_done_confirm_t *)(data->local_parameters); if( result != NULL ) { double *p; p =(double*)&(result->value); g_adc_result = (unsigned int)*p; vm_log_info("get adc data is %d",g_adc_result); } } // Stop ADC stop_data.owner_id = vm_dcl_get_owner_id(); status = vm_dcl_control(g_adc_handle,VM_DCL_ADC_COMMAND_SEND_STOP,(void *)&stop_data); vm_dcl_close(g_adc_handle); }
void LTcpClient::connectCallback(VMINT handle, VMINT event, void *userData) { LTcpClient *pThis = (LTcpClient*)userData; vm_log_info("connectCallback handle=%d event=%d userData=%d", handle, event, userData); switch(event) { case VM_TCP_EVT_CONNECTED: pThis->m_handle = SharedHandle(handle); LTask.post_signal(); break; case VM_TCP_EVT_CAN_WRITE: break; case VM_TCP_EVT_CAN_READ: break; case VM_TCP_EVT_PIPE_BROKEN: pThis->m_handle.invalidateHandle(); LTask.post_signal(); break; case VM_TCP_EVT_HOST_NOT_FOUND: pThis->m_handle.invalidateHandle(); LTask.post_signal(); break; case VM_TCP_EVT_PIPE_CLOSED: pThis->m_handle.invalidateHandle(); LTask.post_signal(); break; } return; }
static boolean wifiBegin(void* userData) { vm_log_info("wifiBegin (in MMI)"); LWiFiConnectContext *pContext = (LWiFiConnectContext*)userData; const VMINT wlanStatus = vm_wlan_status(); // check if we already connected if (wlanStatus & VM_WLAN_STA_STATUS_CONNECTED) { pContext->result.result = VM_WLAN_RESULT_STATE_ERROR; return true; } // first we enable WiFi and wait for callback if (VM_WLAN_SET_MODE_STA != vm_wlan_mode_get()) { vm_wlan_mode_set(VM_WLAN_SET_MODE_STA, &onWiFiEnabled, pContext); } else { onWiFiEnabled(pContext, VM_WLAN_REQ_RES_DONE); } // block Arduino thread return false; }
extern caddr_t _sbrk ( int incr ) { static void* heap = NULL ; static void* base = NULL ; void* prev_heap ; if ( heap == NULL ) { base = (unsigned char *)g_base_address; if(base == NULL) { vm_log_fatal("malloc failed"); } else { heap = base; vm_log_info("init memory success"); } } if (heap + incr > g_base_address + g_memory_size) { vm_log_fatal("memory not enough"); } prev_heap = heap; heap += incr ; return (caddr_t) prev_heap ; }
int LTcpClient::connect(const char *host, uint16_t port) { vm_log_info("LTcpClient::connect(char) to %s:%d", host, port); if(connected()) { vm_log_info("LTcpClient::connect() while already connected. stop() first."); stop(); } LTcpConnectContext context; context.ipAddr = host; context.port = port; context.pInstance = this; LTask.remoteCall(&connectIP, &context); return connected(); }
void handle_sysevt(VMINT message, VMINT param) { switch (message) { case VM_EVENT_CREATE: /* delay for catch logs */ vm_thread_sleep(8000); vm_log_info("Sample of FS list file - Start."); fs_demo_find_files(); break; case VM_EVENT_QUIT: vm_log_info("Sample of FS list file - End."); break; } }