/// @cond debug //**************************************************************************** // Only internal use: // cTCPStatus callback function //**************************************************************************** int cTCPStatus() { char cmdReply[200]; char msg2send[200]; int resCheck = 0; DWORD tick; int countData; int chars2read; switch(smInternal) { case 0: // Check if Buffer is free if(GSMBufferSize() > 0) { // Parse Unsol Message mainGSMStateMachine = SM_GSM_CMD_PENDING; return -1; } else smInternal++; case 1: // Send first AT command // ---------- TCP Status Update ---------- sprintf(msg2send, "AT+KTCPSTAT=%d\r",xSocket->number); GSMWrite(msg2send); // Start timeout count tick = TickGetDiv64K(); // 1 tick every seconds maxtimeout = 60; smInternal++; case 2: vTaskDelay(20); // Check ECHO countData = 0; resCheck = CheckEcho(countData, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } case 3: // Get reply "\r\n+KTCPSTAT: <status>,<tcp_notif>,<rem_data>,<rcv_data>\r\n" vTaskDelay(20); sprintf(msg2send, "+KTCPSTAT"); chars2read = 2; countData = 2; // GSM buffer should be: <CR><LF>+KTCPSTAT: <status>,<tcp_notif>,<rem_data>,<rcv_data><CR><LF> resCheck = CheckCmd(countData, chars2read, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } else { // Get status char temp[25]; int res = getfield(':', ',', 5, 1, cmdReply, temp, 500); if(res != 1) { // Execute Error Handler gsmDebugPrint( "Error in getfield for +KTCP_DATA socket\r\n"); break; } else { xSocket->status = atoi(temp); } // Get tcp_notif res = getfield(',', ',', 5, 1, cmdReply, temp, 500); if(res != 1) { // Execute Error Handler gsmDebugPrint( "Error in getfield for +KTCP_DATA socket\r\n"); break; } else { xSocket->notif = atoi(temp); } // Get rcv_data res = getfield(',', '\r', 6, 3, cmdReply, temp, 500); if(res != 1) { // Execute Error Handler gsmDebugPrint( "Error in getfield for +KTCP_DATA socket\r\n"); break; } else { xSocket->rxLen = atoi(temp); } } case 4: // Get reply (\r\nOK\r\n) vTaskDelay(1); // Get OK sprintf(msg2send, "OK"); chars2read = 2; countData = 2; // GSM buffer should be: <CR><LF>OK<CR><LF> resCheck = CheckCmd(countData, chars2read, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } default: break; } smInternal = 0; // Cmd = 0 only if the last command successfully executed mainOpStatus.ExecStat = OP_SUCCESS; mainOpStatus.Function = 0; mainOpStatus.ErrorCode = 0; mainGSMStateMachine = SM_GSM_IDLE; return -1; }
/* Play some music from a URI */ void TestPlayUri( SLObjectItf sl, const char* path) { SLEngineItf EngineItf; SLint32 numOutputs = 0; SLuint32 deviceID = 0; SLresult res; SLDataSource audioSource; SLDataLocator_URI uri; SLDataFormat_MIME mime; SLDataSink audioSink; SLDataLocator_OutputMix locator_outputmix; SLObjectItf player; SLPlayItf playItf; SLVolumeItf volItf; SLPrefetchStatusItf prefetchItf; SLObjectItf OutputMix; SLboolean required[MAX_NUMBER_INTERFACES]; SLInterfaceID iidArray[MAX_NUMBER_INTERFACES]; /* Get the SL Engine Interface which is implicit */ res = (*sl)->GetInterface(sl, SL_IID_ENGINE, (void*)&EngineItf); CheckErr(res); /* Initialize arrays required[] and iidArray[] */ for (int i=0 ; i < MAX_NUMBER_INTERFACES ; i++) { required[i] = SL_BOOLEAN_FALSE; iidArray[i] = SL_IID_NULL; } // Set arrays required[] and iidArray[] for VOLUME and PREFETCHSTATUS interface required[0] = SL_BOOLEAN_TRUE; iidArray[0] = SL_IID_VOLUME; required[1] = SL_BOOLEAN_TRUE; iidArray[1] = SL_IID_PREFETCHSTATUS; // Create Output Mix object to be used by player res = (*EngineItf)->CreateOutputMix(EngineItf, &OutputMix, 0, iidArray, required); CheckErr(res); // Realizing the Output Mix object in synchronous mode. res = (*OutputMix)->Realize(OutputMix, SL_BOOLEAN_FALSE); CheckErr(res); /* Setup the data source structure for the URI */ uri.locatorType = SL_DATALOCATOR_URI; uri.URI = (SLchar*) path; mime.formatType = SL_DATAFORMAT_MIME; mime.mimeType = (SLchar*)NULL; mime.containerType = SL_CONTAINERTYPE_UNSPECIFIED; audioSource.pFormat = (void *)&mime; audioSource.pLocator = (void *)&uri; /* Setup the data sink structure */ locator_outputmix.locatorType = SL_DATALOCATOR_OUTPUTMIX; locator_outputmix.outputMix = OutputMix; audioSink.pLocator = (void *)&locator_outputmix; audioSink.pFormat = NULL; /* Create the audio player */ res = (*EngineItf)->CreateAudioPlayer(EngineItf, &player, &audioSource, &audioSink, MAX_NUMBER_INTERFACES, iidArray, required); CheckErr(res); /* Realizing the player in synchronous mode. */ res = (*player)->Realize(player, SL_BOOLEAN_FALSE); CheckErr(res); fprintf(stdout, "URI example: after Realize\n"); /* Get interfaces */ res = (*player)->GetInterface(player, SL_IID_PLAY, (void*)&playItf); CheckErr(res); res = (*player)->GetInterface(player, SL_IID_VOLUME, (void*)&volItf); CheckErr(res); res = (*player)->GetInterface(player, SL_IID_PREFETCHSTATUS, (void*)&prefetchItf); CheckErr(res); res = (*prefetchItf)->RegisterCallback(prefetchItf, PrefetchEventCallback, &prefetchItf); CheckErr(res); res = (*prefetchItf)->SetCallbackEventsMask(prefetchItf, SL_PREFETCHEVENT_FILLLEVELCHANGE | SL_PREFETCHEVENT_STATUSCHANGE); CheckErr(res); /* Configure fill level updates every 5 percent */ (*prefetchItf)->SetFillUpdatePeriod(prefetchItf, 50); /* Set up the player callback to get events during the decoding */ res = (*playItf)->SetMarkerPosition(playItf, 2000); CheckErr(res); res = (*playItf)->SetPositionUpdatePeriod(playItf, 500); CheckErr(res); res = (*playItf)->SetCallbackEventsMask(playItf, SL_PLAYEVENT_HEADATMARKER | SL_PLAYEVENT_HEADATNEWPOS | SL_PLAYEVENT_HEADATEND); CheckErr(res); res = (*playItf)->RegisterCallback(playItf, PlayEventCallback, NULL); CheckErr(res); /* Display duration */ SLmillisecond durationInMsec = SL_TIME_UNKNOWN; res = (*playItf)->GetDuration(playItf, &durationInMsec); CheckErr(res); if (durationInMsec == SL_TIME_UNKNOWN) { fprintf(stdout, "Content duration is unknown (before starting to prefetch)\n"); } else { fprintf(stdout, "Content duration is %u ms (before starting to prefetch)\n", durationInMsec); } /* Set the player volume */ res = (*volItf)->SetVolumeLevel( volItf, -300); CheckErr(res); /* Play the URI */ /* first cause the player to prefetch the data */ fprintf(stdout, "Before set to PAUSED\n"); res = (*playItf)->SetPlayState( playItf, SL_PLAYSTATE_PAUSED ); fprintf(stdout, "After set to PAUSED\n"); CheckErr(res); usleep(100 * 1000); /* wait until there's data to play */ //SLpermille fillLevel = 0; SLuint32 prefetchStatus = SL_PREFETCHSTATUS_UNDERFLOW; SLuint32 timeOutIndex = 100; // 10s while ((prefetchStatus != SL_PREFETCHSTATUS_SUFFICIENTDATA) && (timeOutIndex > 0) && !prefetchError) { usleep(100 * 1000); (*prefetchItf)->GetPrefetchStatus(prefetchItf, &prefetchStatus); timeOutIndex--; } if (timeOutIndex == 0 || prefetchError) { fprintf(stderr, "We\'re done waiting, failed to prefetch data in time, exiting\n"); goto destroyRes; } /* Display duration again, */ res = (*playItf)->GetDuration(playItf, &durationInMsec); CheckErr(res); if (durationInMsec == SL_TIME_UNKNOWN) { fprintf(stdout, "Content duration is unknown (after prefetch completed)\n"); } else { fprintf(stdout, "Content duration is %u ms (after prefetch completed)\n", durationInMsec); } fprintf(stdout, "URI example: starting to play\n"); res = (*playItf)->SetPlayState( playItf, SL_PLAYSTATE_PLAYING ); CheckErr(res); #ifdef TEST_VOLUME_ITF usleep(5*1000 * 1000); fprintf(stdout, "setting vol to 0\n"); (*volItf)->SetVolumeLevel( volItf, 0); usleep(3*1000 * 1000); fprintf(stdout, "setting vol to -20dB\n"); (*volItf)->SetVolumeLevel( volItf, -2000); usleep(3*1000 * 1000); fprintf(stdout, "mute\n"); (*volItf)->SetMute( volItf, SL_BOOLEAN_TRUE); usleep(3*1000 * 1000); fprintf(stdout, "setting vol to 0dB while muted\n"); (*volItf)->SetVolumeLevel( volItf, 0); usleep(3*1000 * 1000); fprintf(stdout, "unmuting\n"); (*volItf)->SetMute( volItf, SL_BOOLEAN_FALSE); usleep(3*1000 * 1000); #endif #ifndef TEST_COLD_START usleep(durationInMsec * 1000); #else /* Wait as long as the duration of the content before stopping */ /* Experiment: wait for the duration + 200ms: with a cold start of the audio hardware, we */ /* won't see the SL_PLAYEVENT_HEADATEND event, due to hw wake up induced latency, but */ /* with a warm start it will be received. */ usleep((durationInMsec + 200) * 1000); #endif /* Make sure player is stopped */ fprintf(stdout, "URI example: stopping playback\n"); res = (*playItf)->SetPlayState(playItf, SL_PLAYSTATE_STOPPED); CheckErr(res); destroyRes: /* Destroy the player */ (*player)->Destroy(player); /* Destroy Output Mix object */ (*OutputMix)->Destroy(OutputMix); }
/// @cond debug //**************************************************************************** // Only internal use: // cTCPWrite callback function //**************************************************************************** int cTCPWrite() { char cmdReply[200]; char msg2send[200]; int resCheck = 0; DWORD tick; int countData; int chars2read; switch(smInternal) { case 0: // Check if Buffer is free if(GSMBufferSize() > 0) { // Parse Unsol Message mainGSMStateMachine = SM_GSM_CMD_PENDING; return -1; } else smInternal++; case 1: // Send first AT command // ---------- TCP Write Command ---------- sprintf(msg2send, "AT+KTCPSND=%d,%d\r",xSocket->number, tcpWriteBufferCount); GSMWrite(msg2send); // Start timeout count tick = TickGetDiv64K(); // 1 tick every seconds maxtimeout = 120; smInternal++; case 2: vTaskDelay(20); // Check ECHO countData = 0; resCheck = CheckEcho(countData, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } case 3: // Get reply "\r\nCONNECT\r\n" vTaskDelay(20); sprintf(msg2send, "\r\nCONNECT"); chars2read = 2; countData = 4; // GSM buffer should be: <CR><LF>CONNECT<CR><LF> resCheck = CheckCmd(countData, chars2read, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } else { int counterLen = 0; while(counterLen < tcpWriteBufferCount) { GSMWriteCh(tcpWriteBuffer[counterLen]); counterLen++; } // and write --EOF--Pattern-- (without \r) GSMWrite("--EOF--Pattern--"); } case 4: // Get reply (\r\nOK\r\n) vTaskDelay(20); // Get OK sprintf(msg2send, "OK"); chars2read = 2; countData = 2; // GSM buffer should be: <CR><LF>OK<CR><LF> resCheck = CheckCmd(countData, chars2read, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } default: break; } smInternal = 0; // Cmd = 0 only if the last command successfully executed mainOpStatus.ExecStat = OP_SUCCESS; mainOpStatus.Function = 0; mainOpStatus.ErrorCode = 0; mainGSMStateMachine = SM_GSM_IDLE; return -1; }
/// @cond debug //**************************************************************************** // Only internal use: // cTCPRead callback function //**************************************************************************** int cTCPRead() { char cmdReply[200]; char msg2send[200]; int resCheck = 0; DWORD tick; int countData; int chars2read; switch(smInternal) { case 0: // Check if Buffer is free if(GSMBufferSize() > 0) { // Parse Unsol Message mainGSMStateMachine = SM_GSM_CMD_PENDING; return -1; } else smInternal++; case 1: // Send first AT command // ---------- TCP Status Update ---------- sprintf(msg2send, "AT+KTCPSTAT=%d\r",xSocket->number); GSMWrite(msg2send); // Start timeout count tick = TickGetDiv64K(); // 1 tick every seconds maxtimeout = 60; smInternal++; case 2: vTaskDelay(20); // Check ECHO countData = 0; resCheck = CheckEcho(countData, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { #if defined (STACK_USE_UART) char debugStr[100]; sprintf(debugStr, "error on function %d, smInternal %d\r\n", mainOpStatus.Function, smInternal); gsmDebugPrint( debugStr); vTaskDelay(20); #endif return mainOpStatus.ErrorCode; } case 3: // Get reply "\r\n+KTCPSTAT: <status>,<tcp_notif>,<rem_data>,<rcv_data>\r\n" vTaskDelay(20); sprintf(msg2send, "+KTCPSTAT"); chars2read = 2; countData = 2; // GSM buffer should be: <CR><LF>+KTCPSTAT: <status>,<tcp_notif>,<rem_data>,<rcv_data><CR><LF> resCheck = CheckCmd(countData, chars2read, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } else { // Get status char temp[25]; int res = getfield(':', ',', 5, 1, cmdReply, temp, 500); if(res != 1) { // Execute Error Handler gsmDebugPrint( "Error in getfield for +KTCPSTAT socket\r\n"); break; } else { xSocket->status = atoi(temp); } // Get tcp_notif res = getfield(',', ',', 5, 1, cmdReply, temp, 500); if(res != 1) { // Execute Error Handler gsmDebugPrint( "Error in getfield for +KTCPSTAT socket\r\n"); break; } else { xSocket->notif = atoi(temp); } // Get rcv_data res = getfield(',', '\r', 6, 3, cmdReply, temp, 500); if(res != 1) { // Execute Error Handler gsmDebugPrint( "Error in getfield for +KTCPSTAT socket\r\n"); break; } else { xSocket->rxLen = atoi(temp); } } case 4: // Get reply (\r\nOK\r\n) vTaskDelay(1); // Get OK sprintf(msg2send, "OK"); chars2read = 2; countData = 2; // GSM buffer should be: <CR><LF>OK<CR><LF> resCheck = CheckCmd(countData, chars2read, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } case 5: if(xSocket->rxLen == 0) { // Break operation break; } // Send first AT command // ---------- TCP Read Command ---------- if(tcpReadBufferCount > xSocket->rxLen) tcpReadBufferCount = xSocket->rxLen; if(tcpReadBufferCount > GSM_BUFFER_SIZE) tcpReadBufferCount = GSM_BUFFER_SIZE; sprintf(msg2send, "AT+KTCPRCV=%d,%d\r",xSocket->number, tcpReadBufferCount); GSMWrite(msg2send); // Start timeout count tick = TickGetDiv64K(); // 1 tick every seconds maxtimeout = 60; smInternal++; case 6: vTaskDelay(1); // Check ECHO countData = 0; resCheck = CheckEcho(countData, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } case 7: // Get reply "\r\nCONNECT\r\n" vTaskDelay(1); sprintf(msg2send, "CONNECT"); chars2read = 2; countData = 2; // GSM buffer should be: <CR><LF>CONNECT<CR><LF> resCheck = CheckCmd(countData, chars2read, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } else { // Read data from TCP Socket int rxCount = 0; int retCount = 0; while(rxCount < tcpReadBufferCount) { char tmp[1]; retCount = GSMRead(tmp, 1); *(tcpReadBuffer+rxCount) = tmp[0]; rxCount += retCount; if(retCount == 0) vTaskDelay(1); } // Set tcpReadBufferCount as the effective number of BYTEs read tcpReadBufferCount = rxCount; } case 8: // Get reply (--EOF--Pattern--\r\nOK\r\n) vTaskDelay(1); // Get OK sprintf(msg2send, "--EOF--Pattern--\r\nOK"); chars2read = 2; countData = 0; // GSM buffer should be: --EOF--Pattern--<CR><LF>OK<CR><LF> resCheck = CheckCmd(countData, chars2read, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } default: break; } smInternal = 0; // Cmd = 0 only if the last command successfully executed mainOpStatus.ExecStat = OP_SUCCESS; mainOpStatus.Function = 0; mainOpStatus.ErrorCode = 0; mainGSMStateMachine = SM_GSM_IDLE; return -1; }
/// @cond debug //**************************************************************************** // Only internal use: // cTCPClientClose callback function //**************************************************************************** int cTCPClientClose() { char cmdReply[200]; char msg2send[200]; int resCheck = 0; DWORD tick; int countData; int chars2read; switch(smInternal) { case 0: // Check if Buffer is free if(GSMBufferSize() > 0) { // Parse Unsol Message mainGSMStateMachine = SM_GSM_CMD_PENDING; return -1; } else smInternal++; case 1: // Send first AT command // ---------- TCP Connection Close ---------- sprintf(msg2send, "AT+KTCPCLOSE=%d,1\r",xSocket->number); GSMWrite(msg2send); // Start timeout count tick = TickGetDiv64K(); // 1 tick every seconds maxtimeout = 60; smInternal++; case 2: vTaskDelay(20); // Check ECHO countData = 0; resCheck = CheckEcho(countData, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } case 3: // Get reply (\r\nOK\r\n) vTaskDelay(1); // Get OK sprintf(msg2send, "OK"); chars2read = 2; countData = 2; // GSM buffer should be: <CR><LF>OK<CR><LF> resCheck = CheckCmd(countData, chars2read, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } case 4: // Send AT command // ---------- Delete TCP Socket ---------- sprintf(msg2send, "AT+KTCPDEL=%d\r",xSocket->number); GSMWrite(msg2send); // Start timeout count tick = TickGetDiv64K(); // 1 tick every seconds maxtimeout = 2; smInternal++; case 5: vTaskDelay(20); // Check ECHO countData = 0; resCheck = CheckEcho(countData, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } case 6: // Get reply (\r\nOK\r\n) vTaskDelay(1); // Get OK sprintf(msg2send, "OK"); chars2read = 2; countData = 2; // GSM buffer should be: <CR><LF>OK<CR><LF> resCheck = CheckCmd(countData, chars2read, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } else { xSocket->number = INVALID_SOCKET; } default: break; } smInternal = 0; // Cmd = 0 only if the last command successfully executed mainOpStatus.ExecStat = OP_SUCCESS; mainOpStatus.Function = 0; mainOpStatus.ErrorCode = 0; mainGSMStateMachine = SM_GSM_IDLE; return -1; }
/// @cond debug //**************************************************************************** // Only internal use: // cTCPClientOpen callback function //**************************************************************************** int cTCPClientOpen() { char cmdReply[200]; char msg2send[200]; int resCheck = 0; DWORD tick; int countData; int chars2read; switch(smInternal) { case 0: // Check if Buffer is free if(GSMBufferSize() > 0) { // Parse Unsol Message mainGSMStateMachine = SM_GSM_CMD_PENDING; return -1; } else smInternal++; case 1: // Send first AT command // ---------- TCP Connection Configuration ---------- sprintf(msg2send, "AT+KTCPCFG=0,0,\"%s\",%d\r",xIPAddress, xTCPPort); GSMWrite(msg2send); // Start timeout count tick = TickGetDiv64K(); // 1 tick every seconds maxtimeout = 2; smInternal++; case 2: vTaskDelay(1); // Check ECHO countData = 0; resCheck = CheckEcho(countData, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } case 3: // Get reply "+KTCPCFG: <socket>" vTaskDelay(1); sprintf(msg2send, "+KTCPCFG"); chars2read = 2; countData = 2; // GSM buffer should be: <CR><LF>+KTCPCFG: <socket><CR><LF> resCheck = CheckCmd(countData, chars2read, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } else { // Get socket number char temp[25]; int res = getfield(':', '\r', 5, 1, cmdReply, temp, 500); if(res != 1) { // Execute Error Handler gsmDebugPrint( "Error in getfield\r\n"); break; } else { xSocket->number = atoi(temp); } } case 4: // Get reply (\r\nOK\r\n) vTaskDelay(1); // Get OK sprintf(msg2send, "OK"); chars2read = 2; countData = 2; // GSM buffer should be: <CR><LF>OK<CR><LF> resCheck = CheckCmd(countData, chars2read, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } case 5: // ---------- Initiate TCP Connection ---------- sprintf(msg2send, "AT+KTCPCNX=%d\r",xSocket->number); GSMWrite(msg2send); // Start timeout count tick = TickGetDiv64K(); // 1 tick every seconds maxtimeout = 180; smInternal++; case 6: vTaskDelay(1); // Check ECHO countData = 0; resCheck = CheckEcho(countData, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { xSocket->number = INVALID_SOCKET; return mainOpStatus.ErrorCode; } case 7: // Get reply (\r\nOK\r\n) vTaskDelay(1); // Get OK sprintf(msg2send, "\r\nOK"); chars2read = 2; countData = 2; // GSM buffer should be: <CR><LF>OK<CR><LF> resCheck = CheckCmd(countData, chars2read, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { xSocket->number = INVALID_SOCKET; return mainOpStatus.ErrorCode; } default: break; } smInternal = 0; // Cmd = 0 only if the last command successfully executed mainOpStatus.ExecStat = OP_SUCCESS; mainOpStatus.Function = 0; mainOpStatus.ErrorCode = 0; mainGSMStateMachine = SM_GSM_IDLE; return -1; }
/// @cond debug int cCALLVoiceStart() { char cmdReply[200]; char msg2send[200]; int resCheck = 0; DWORD tick; int countData; int chars2read; switch (smInternal) { case 0: // Check if Buffer is free if(GSMBufferSize() > 0) { // Parse Unsol Message mainGSMStateMachine = SM_GSM_CMD_PENDING; return -1; } else smInternal++; case 1: // Send first AT command sprintf(msg2send, "ATD=\"%s\";\r", mainCall.CallerID); GSMWrite(msg2send); // Start timeout count tick = TickGetDiv64K(); // 1 tick every seconds maxtimeout = 60; smInternal++; case 2: // Check ECHO countData = 0; resCheck = CheckEcho(countData, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } case 3: // Get reply (OK, BUSY, ERROR, etc...) vTaskDelay(1); // Get OK sprintf(msg2send, "OK"); chars2read = 2; countData = 2; // GSM buffer should be: <CR><LF>OK<CR><LF> resCheck = CheckCmd(countData, chars2read, tick, cmdReply, msg2send, maxtimeout); CheckErr(resCheck, &smInternal, &tick); if(resCheck) { return mainOpStatus.ErrorCode; } default: break; } mainCall.Status = CALL_IN_PROG; smInternal = 0; // Cmd = 0 only if the last command successfully executed mainOpStatus.ExecStat = OP_SUCCESS; mainOpStatus.Function = 0; mainOpStatus.ErrorCode = 0; mainGSMStateMachine = SM_GSM_IDLE; return -1; }