BOOL CSerialServer::StartThread()
{
m_bRecvReady = FALSE;
m_bSendReady = FALSE;
m_hReadThread = CreateThread(NULL,
4096,
(LPTHREAD_START_ROUTINE)ReadThread,
(LPVOID)this,
CREATE_SUSPENDED,
&m_dwReadThreadID);
SetThreadPriority(m_hReadThread, THREAD_PRIORITY_NORMAL);
m_hSendThread = CreateThread(NULL,
4096,
(LPTHREAD_START_ROUTINE)SendThread,
(LPVOID)this,
CREATE_SUSPENDED,
&m_dwSendThreadID);
SetThreadPriority(m_hSendThread, THREAD_PRIORITY_NORMAL);
ResumeThread(m_hReadThread);
ResumeThread(m_hSendThread);
// Send/Receive 루틴이 준비될때까지 대기
while(!m_bRecvReady || !m_bSendReady) {
//Sleep(100);
USLEEP(100);
}
// Wait로 진입까지 대기
//Sleep(100);
USLEEP(500);
return TRUE;
}
/**
* write a byte to i2c device, strobing EN pin of LCD
*
* @param LcdData_t* lcd handler structure address
* @param u8 byte to send to LCD
* @return none
*
*/
static void _strobe(LcdData_t *lcd, u8 data)
{
_buswrite(lcd, data | (1 << PIN_EN));
USLEEP(1);
_buswrite(lcd, data & (~(1 << PIN_EN)));
USLEEP(50);
}
int CSerialServer::SendStreamToSession(int fd, const char *pszBuffer, int nLength)
{
int nCount, nSend=0;
char * pszBp = const_cast<char *>(pszBuffer);
for(;nSend<nLength;)
{
nCount = WriteData(fd, pszBp + nSend, nLength-nSend);
if (IsCloseWait())
return -1;
if (nCount == 0)
{
XDEBUG("------------------ SERIAL BLOCKING (Total=%d, Current=%d) -------------\r\n", nLength, nSend);
USLEEP(30000);
continue;
}
else if (nCount < 0)
{
USLEEP(300000);
if (!m_bDisableSendFail)
return -1;
continue;
}
nSend += nCount;
}
return nSend;
}
void test_local_no_start()
{
T2 t2(false);
t2.start();
USLEEP(100);
USLEEP(100);
CU_ASSERT_TRUE_FATAL(
RThreadState::state_is(t2, T2::terminatedState));
t2.stop();
}
void test_local_block()
{
{
T1 t1;
t1.start();
}
{
T2 t2(true);
t2.start();
USLEEP(100);
USLEEP(100);
CU_ASSERT_TRUE_FATAL(
RThreadState::state_is(t2, T2::terminatedState));
}
}
void PowerControl(BOOL bOnOff)
{
int fd;
fd = open("/dev/gpio", O_RDWR | O_NDELAY);
if (fd <= 0)
return;
#if defined(__SUPPORT_NZC1__)
ioctl(fd, GPIO_IOCTL_DIR, GPIOSET(GP_CODI_PCTL_OUT)); // Coordinator VDD
#endif
ioctl(fd, GPIO_IOCTL_DIR, GPIOSET(GP_CODI_RST_OUT)); // Coordinator RESET
#if defined(__SUPPORT_NZC1__)
if (bOnOff)
{
ioctl(fd, GPIO_IOCTL_OUT, GPIOHIGH(GP_CODI_PCTL_OUT));
#endif
ioctl(fd, GPIO_IOCTL_OUT, GPIOLOW(GP_CODI_RST_OUT));
USLEEP(1000000);
ioctl(fd, GPIO_IOCTL_OUT, GPIOHIGH(GP_CODI_RST_OUT));
#if defined(__SUPPORT_NZC1__)
}
else
{
ioctl(fd, GPIO_IOCTL_OUT, GPIOLOW(GP_CODI_PCTL_OUT));
}
#endif
close(fd);
}
BOOL CSerialServer::RunDaemon()
{
WORKSESSION *pSession;
char szBuffer[2048+1];
int len;
long lCurTime;
BOOL bForever = TRUE;
m_pSaveSession = pSession = NewSession(m_nFD, m_szDevice);
if (pSession == NULL)
{
return FALSE;
}
if (!EnterSession(pSession))
{
LeaveSession(pSession);
return FALSE;
}
for(;bForever && !m_bExitPending;)
{
// Passive mode에서는 수신을 하지 않는다.
if (m_bPassiveMode)
{
USLEEP(1000000);
continue;
}
len = read(m_nFD, szBuffer, 2048);
if (len == 0)
{
// Timeout Session
if (m_nTimeout != -1)
{
time(&lCurTime);
if ((lCurTime-pSession->lLastInput) >= m_nTimeout)
{
pSession->lLastInput = lCurTime;
if (!OnTimeoutSession(pSession))
break;
}
}
continue;
}
else if (len < 0)
{
// Terminate Session
break;
}
else
{
// Receive Session
time(&pSession->lLastInput);
AddSessionRecvStream(pSession, szBuffer, len);
}
}
LeaveSession(pSession);
return FALSE;
}
void run()
{
RT::ThreadState::move_to(*this, workingState);
if (::check_my_name(name))
T1::St::move_to(*this, check_passedState);
else
T1::St::move_to(*this, check_failedState);
USLEEP(100);
}
void CEndDevicePool::FreeEndDevice(ENDDEVICE *endi)
{
int nRetry = 0;
while(endi->bReference)
{
USLEEP(100000);
nRetry++;
if (nRetry > 50)
{
XDEBUG("WARNNING: --- HANDLE DELETE ERROR ---\r\n");
USLEEP(1000000);
break;
}
}
ClearDataBuffer(endi);
memset(endi, 0, sizeof(ENDDEVICE));
m_nPoolAllocate--;
}
void api_licence_daemon( void* data )
{
apiclient* apis = (apiclient*) data;
int sleepintv = 120*60*1000/INTERVAL;
int counter = 1;
while( 1 ){
counter ++;
if( counter % INTERVAL == 0 ){
api_update_licence(apis);
}
USLEEP( sleepintv );
}
return;
}
/** Issue #1286 종료전에 Battery Fail Status를 검사 한다.
* 이 method가 호출되면 Battery Charging register를 off/on 시키기 때문에 운영중에
* 호출하지 않고 Reset, Shutdown 시 최종적으로 호출한다.
*
*/
void CAgentService::CheckBattery()
{
unsigned int batteryAdcValue = 0;
// Battery Charging resgiter off
GPIOAPI_WriteGpio(GP_BATT_CHG_EN_OUT, 1);
USLEEP(500000);
// Read Battery ADC Value
batteryAdcValue = GPIOAPI_ReadAdc(ADC_BATT_VOL_INPUT);
// Battery Charging resgiter on
GPIOAPI_WriteGpio(GP_BATT_CHG_EN_OUT, 0);
XDEBUG("Check Battery ADC Value %d\r\n", batteryAdcValue);
if(batteryAdcValue < 2000)
{
XDEBUG(ANSI_COLOR_RED "Battery Status : Abnormal\r\n" ANSI_NORMAL);
// Battery Fail
mcuBatteryFailEvent();
USLEEP(1000000*10); // Event 전송을 위해 10초간 대기
}
XDEBUG(ANSI_COLOR_RED "Batrry OK!\r\n" ANSI_NORMAL);
}
BOOL CSerialServer::SessionSender()
{
WORKSESSION *pSession;
SIODATASTREAM *pStream;
BOOL bForever = TRUE;
for(;bForever && !m_bExitPending;)
{
sem_wait(&m_sendSem);
if (m_bPassiveMode)
{
USLEEP(1000000);
continue;
}
if (m_bExitPending)
return FALSE;
while(bForever && !m_bExitPending)
{
pStream = GetStream();
if (pStream == NULL)
break;
pSession = (WORKSESSION *)pStream->pSession;
if (pSession != NULL)
{
OnPrevSendSession(pSession, pStream->pszBuffer, pStream->nLength);
if (SendStreamToSession(pSession->sSocket, pStream->pszBuffer, pStream->nLength) == -1)
{
SessionError(pSession, 0);
bForever = FALSE;
}
else OnSendSession(pSession, pStream->pszBuffer, pStream->nLength);
}
if (pStream->pszBuffer)
{
FREE(pStream->pszBuffer);
pStream->pszBuffer = NULL;
}
FREE(pStream);
}
}
return TRUE;
}
/// This function may cause deadlock. Make sure you call this function
/// correctly. Otherwise use wait_for_ready instead. This function is introduced
/// to solve screen update problem. We may have a better way later.
int wait_until_ready( void )
{
// TODO, change the usleep to nanosleep later.
static const int MAX = 40;
int d = gpio_hrdy( );
int count = 0;
while ( d == 0 && count < MAX)
{
USLEEP(100 * 1000);
d = gpio_hrdy( );
count++;
}
if (d == 0)
{
DBG("Still not ready, should not happen");
}
return count;
}
void CSerialServer::Shutdown()
{
void * nStatus;
if (!IsStarted())
return;
m_bStarted = FALSE;
m_bDisableSendFail = FALSE;
m_bExitPending = TRUE;
while(!m_bWatchExit) USLEEP(100000);
// 전송 쓰레드 종료
sem_post(&m_sendSem);
pthread_join(m_sendThreadID, &nStatus);
// 수신 쓰레드 종료
CloseDaemonDevice();
}
/** 60초 이내에 Case Open을 감지해야 한다.
*/
char* testCaseOpen(const void* waitTime, const void*, const void*, const void*)
{
int nWaitTime = *((int*)waitTime) * 10;
if(IS_FAKE)
{
if(IS_FAKE_FAIL) goto FAIL;
return NULL;
}
for(int cnt=0; cnt<nWaitTime; cnt++)
{
if(GPIOAPI_ReadGpio(GP_CASE_OPEN_INPUT) == 0) return NULL;
USLEEP(100000);
}
FAIL:
sprintf(errMsgBuff,"case-close detect fail");
return errMsgBuff;
}
char* testPowerFail(const void* waitTime, const void*, const void*, const void*)
{
int nWaitTime = *((int*)waitTime) * 10;
if(IS_FAKE)
{
if(IS_FAKE_FAIL) goto FAIL;
return NULL;
}
for(int cnt=0; cnt<nWaitTime; cnt++)
{
if(GPIOAPI_ReadGpio(GP_PWR_FAIL_INPUT) > 0) return NULL;
USLEEP(100000);
}
FAIL:
sprintf(errMsgBuff,"power-fail detect fail");
return errMsgBuff;
}
char* testLowBattery(const void* waitTime, const void*, const void*, const void*)
{
int nWaitTime = *((int*)waitTime) * 10;
if(IS_FAKE)
{
if(IS_FAKE_FAIL) goto FAIL;
return NULL;
}
for(int cnt=0; cnt<nWaitTime; cnt++)
{
if(GPIOAPI_ReadGpio(GP_LOW_BATT_INPUT) == 0) return NULL;
USLEEP(100000);
}
FAIL:
sprintf(errMsgBuff,"low-battery detect fail");
return errMsgBuff;
}
BOOL CSerialServer::Startup(const char *pszDevice, int nMaxSession, int nTimeout, int nSpeed, int nParity, int nOptions)
{
if (IsStarted())
return FALSE;
m_bStarted = FALSE;
m_bExitPending = FALSE;
m_bWatchExit = FALSE;
m_bSendReady = FALSE;
m_bRecvReady = FALSE;
m_nMaxSession = nMaxSession;
m_nTimeout = nTimeout;
#ifndef _WIN32
nSpeed = (nSpeed == -1) ? B9600 : nSpeed;
#else
nSpeed = (nSpeed == -1) ? CBR_9600 : nSpeed;
#endif
if (!CreateDaemonDevice(pszDevice, nMaxSession, nSpeed, nParity, nOptions))
return FALSE;
if (pthread_create(&m_watchThreadID, NULL, WatchThread, (void *)this) != 0)
{
XDEBUG("DELETEME: thread create fail\n");
return FALSE;
}
if (pthread_create(&m_sendThreadID, NULL, SendThread, (void *)this) != 0)
{
XDEBUG("DELETEME: thread create fail\n");
return FALSE;
}
pthread_detach(m_watchThreadID);
while(!m_bSendReady || !m_bRecvReady) USLEEP(10000);
m_bStarted = TRUE;
return TRUE;
}
void bs_sleep( int ms )
{
// TODO: Need the value from datasheet.
USLEEP(1000 * ms);
}
// --- Init(3 params) ---
bool PortAudioStream::init(int channels, int sample_rate, int frame_size)
{
pa_frame_size = frame_size;
int pa_tries = 0;
while ( (pa_tries < 10) && (!initialized) )
{
if (pa_tries > 0)
USLEEP(100 * 1000); // sleepin' 100ms
pa_tries++;
// -- PortAudio Internal Init --
pa_error = Pa_Initialize();
if (pa_error != paNoError)
{
fprintf(stderr, "PortAudio --> Internal Init Failed @Iteration %i\n", pa_tries);
fprintf(stderr, "PortAudio --> Error Description : %s\n", Pa_GetErrorText(pa_error));
Pa_Terminate();
continue;
}
// -- Device Allocation --
pa_info = Pa_GetDeviceInfo(Pa_GetDefaultOutputDevice());
if (pa_info == NULL)
{
fprintf(stderr, "PortAudio --> Device Unavailable @Iteration %i\n", pa_tries);
Pa_Terminate();
continue;
}
// -- Device Configuration --
PaStreamParameters* params = new PaStreamParameters();
params->device = Pa_GetDefaultOutputDevice();
params->channelCount = channels;
params->sampleFormat = paInt16;
// -- Opening Stream --
pa_error = Pa_OpenDefaultStream(&pa_stream, 0, channels, paInt16, (double)sample_rate, paFramesPerBufferUnspecified, NULL, NULL);
if (pa_error != paNoError)
{
fprintf(stderr, "PortAudio --> Output Stream Not Available @Iteration %i\n", pa_tries);
fprintf(stderr, "PortAudio --> Error Description : %s\n", Pa_GetErrorText(pa_error));
terminate();
continue;
}
// -- Starting Stream --
pa_error = Pa_StartStream(pa_stream);
if (pa_error == paNoError)
initialized = true;
else
{
fprintf(stderr, "PortAudio --> Output Stream Not Started @Iteration %i\n", pa_tries);
fprintf(stderr, "PortAudio --> Error Description : %s\n", Pa_GetErrorText(pa_error));
continue;
}
}
if (initialized)
fprintf(stderr, "PortAudio --> Initialization OK : Channels : %i / SampleRate : %i / FrameSize : %i\n", channels, sample_rate, pa_frame_size);
return initialized;
}
int main()
{
SshTimeMeasure total_timer;
SshTimeMeasure timer_1;
SshTimeMeasure timer_2;
SshTimeMeasure timer_3;
SshTimeMeasure timer_4;
SshTimeMeasure timer_5;
static struct SshTimeMeasureRec timer_6_rec = SSH_TIME_MEASURE_INITIALIZER;
SshTimeMeasure timer_6;
int i;
double rv = 0.0;
int ev = 0;
#ifdef HAVE_GETTIMEOFDAY
struct timeval tv;
#endif /* HAVE_GETTIMEOFDAY */
SshUInt64 seconds;
SshUInt32 nanoseconds;
total_timer = ssh_time_measure_allocate();
timer_1 = ssh_time_measure_allocate();
timer_2 = ssh_time_measure_allocate();
timer_3 = ssh_time_measure_allocate();
timer_4 = ssh_time_measure_allocate();
timer_5 = ssh_time_measure_allocate();
timer_6 = &timer_6_rec;
if (ssh_time_measure_get(timer_5, SSH_TIME_GRANULARITY_NANOSECOND) != 0)
{
ssh_warning("Weird initial stamp value.\n");
ev++;
}
if (ssh_time_measure_get(timer_6, SSH_TIME_GRANULARITY_NANOSECOND) != 0)
{
ssh_warning("Weird initial (static) stamp value.\n");
ev++;
}
rv = (double)ssh_time_measure_get(total_timer, SSH_TIME_GRANULARITY_SECOND);
if ((rv < 0.0) || (rv > 0.0))
{
ssh_warning("Weird initial value.\n");
ev++;
}
ssh_time_measure_granularity(&seconds, &nanoseconds);
if ((seconds == 0) && (nanoseconds == 0))
{
ssh_warning("Weird granularity.\n");
ev++;
}
else
{
printf("granularity is %lu sec %lu nsec\n",
(unsigned long)seconds,
(unsigned long)nanoseconds);
}
START(total_timer);
START(timer_1);
START(timer_3);
START(timer_4);
START(timer_5);
STAMP(total_timer);
printf("testing stamps\n");
NANOSTAMP(timer_1);
MICROSTAMP(timer_1);
MILLISTAMP(timer_1);
STAMP(timer_1);
USLEEP(1000000);
NANOSTAMP(timer_1);
MICROSTAMP(timer_1);
MILLISTAMP(timer_1);
STAMP(timer_1);
USLEEP(1000000);
NANOSTAMP(timer_1);
MICROSTAMP(timer_1);
MILLISTAMP(timer_1);
STAMP(timer_1);
USLEEP(1000000);
NANOSTAMP(timer_1);
MICROSTAMP(timer_1);
MILLISTAMP(timer_1);
STAMP(timer_1);
CHECKNANOSTAMP(timer_1);
USLEEP(1000000);
NANOSTAMP(timer_1);
MICROSTAMP(timer_1);
MILLISTAMP(timer_1);
STAMP(timer_1);
CHECKNANOSTAMP(timer_1);
USLEEP(1000000);
NANOSTAMP(timer_1);
MICROSTAMP(timer_1);
MILLISTAMP(timer_1);
STAMP(timer_1);
CHECKNANOSTAMP(timer_1);
USLEEP(1000000);
NANOSTAMP(timer_1);
MICROSTAMP(timer_1);
MILLISTAMP(timer_1);
STAMP(timer_1);
CHECKNANOSTAMP(timer_1);
USLEEP(2000000);
STAMP(total_timer);
SET(timer_5, 12345, 12345678);
INTERMEDIATE(timer_5);
if ((rv < 12345.0) || (rv > 12350.0))
{
ssh_warning("Weird intermediate after running set.\n");
ev++;
}
INTERMEDIATE(timer_1);
if (rv < 1.0)
{
ssh_warning("Weird intermediate.\n");
ev++;
}
STOP(timer_3);
if (rv < 1.0)
{
ssh_warning("Weird stop value.\n");
ev++;
}
START(timer_2);
RESET(timer_4);
USLEEP(3000000);
STAMP(total_timer);
INTERMEDIATE(timer_2);
INTERMEDIATE(timer_5);
START(timer_3);
if (rv < 1.0)
{
ssh_warning("Weird restart value.\n");
ev++;
}
RESET(timer_4);
STOP(timer_1);
USLEEP(4000000);
STAMP(total_timer);
STOP(timer_5);
#ifdef SSHUINT64_IS_64BITS
printf("Setting timer_5 to big value.\n");
ssh_time_measure_set_value(timer_5,
((SshUInt64)0xffffffff) * ((SshUInt64)30),
987654321);
INTERMEDIATE(timer_5);
if ((rv < 128849018000.0) || (rv > 128849019000.0))
{
ssh_warning("Weird intermediate after stopped set.\n");
ev++;
}
#else
SET(timer_5, 1234567890, 987654321);
INTERMEDIATE(timer_5);
if ((rv < 1234567890.0) || (rv > 1234567900.0))
{
ssh_warning("Weird intermediate after stopped set.\n");
ev++;
}
#endif
STOP(timer_4);
STOP(timer_3);
STOP(timer_2);
STOP(timer_1);
#define TIMESTAMPS 1000000
ssh_time_measure_reset(timer_1);
ssh_time_measure_reset(timer_2);
printf("\nGenerating %d timestamps.\n", TIMESTAMPS);
START(timer_2);
START(timer_1);
for (i = 1; i < TIMESTAMPS; i++)
{
ssh_time_measure_stamp(timer_2, SSH_TIME_GRANULARITY_MICROSECOND);
}
STOP(timer_1);
STOP(timer_2);
printf("Time elapsed %.12f seconds (%.12f seconds/timestamp",
(double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND),
(double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND) / (double)TIMESTAMPS);
if ((double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND) > 0.0)
printf(", %d timestamps/second",
(int)((double)TIMESTAMPS / (double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND)));
printf(")\n");
ssh_time_measure_reset(timer_3);
ssh_time_measure_reset(timer_4);
printf("\nFor reference generating %d timestamps with time(3).\n",
TIMESTAMPS);
START(timer_4);
START(timer_3);
for (i = 1; i < TIMESTAMPS; i++)
{
ssh_time();
}
STOP(timer_3);
STOP(timer_4);
printf("Time elapsed %.12f seconds (%.12f seconds/timestamp",
(double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND),
(double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND) / (double)TIMESTAMPS);
if ((double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND) > 0.0)
printf(", %d timestamps/second",
(int)((double)TIMESTAMPS / (double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND)));
printf(")\n");
if (((double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND) > 0.0) &&
((double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND) > 0.0))
printf("Using time(3) is %2.1f%% faster than ssh_..._stamp.\n",
(((double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND) -
(double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND)) /
(double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND)) * 100.0);
#ifdef HAVE_GETTIMEOFDAY
ssh_time_measure_reset(timer_3);
ssh_time_measure_reset(timer_4);
printf("\nFor reference generating %d timestamps with gettimeofday.\n",
TIMESTAMPS);
START(timer_4);
START(timer_3);
for (i = 1; i < TIMESTAMPS; i++)
{
gettimeofday(&tv, NULL);
}
STOP(timer_3);
STOP(timer_4);
printf("Time elapsed %.12f seconds (%.12f seconds/timestamp",
(double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND),
(double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND) / (double)TIMESTAMPS);
if ((double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND) > 0.0)
printf(", %d timestamps/second",
(int)((double)TIMESTAMPS / (double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND)));
printf(")\n");
if (((double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND) > 0.0) &&
((double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND) > 0.0))
printf("Using gettimeofday(3) is %2.1f%% faster than ssh_..._stamp.\n",
(((double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND) -
(double)ssh_time_measure_get(timer_3, SSH_TIME_GRANULARITY_SECOND)) /
(double)ssh_time_measure_get(timer_1, SSH_TIME_GRANULARITY_SECOND)) * 100.0);
#endif /* HAVE_GETTIMEOFDAY */
printf("making start stop test. timers are silently started and stopped.\n");
printf("timer_3 runs while timer_4 is started and stopped in loop.\n");
ssh_time_measure_stop(timer_3);
ssh_time_measure_stop(timer_4);
ssh_time_measure_reset(timer_3);
ssh_time_measure_reset(timer_4);
ssh_time_measure_start(timer_3);
for (i = 0; i < 1000000; i++)
{
ssh_time_measure_start(timer_4);
ssh_time_measure_stop(timer_4);
}
ssh_time_measure_stop(timer_3);
INTERMEDIATE(timer_4);
INTERMEDIATE(timer_3);
STOP(total_timer);
GET_INT(timer_1);
INTERMEDIATE(timer_1);
GET_INT(timer_2);
INTERMEDIATE(timer_2);
GET_INT(timer_3);
INTERMEDIATE(timer_3);
GET_INT(timer_4);
INTERMEDIATE(timer_4);
GET_INT(timer_5);
INTERMEDIATE(timer_5);
GET_INT(total_timer);
INTERMEDIATE(total_timer);
printf("Testing granularities\n");
GET_NANOSECONDS(total_timer);
GET_MICROSECONDS(total_timer);
GET_MILLISECONDS(total_timer);
GET_SECONDS(total_timer);
GET_MINUTES(total_timer);
GET_HOURS(total_timer);
GET_DAYS(total_timer);
GET_WEEKS(total_timer);
GET_MONTHS(total_timer);
GET_YEARS(total_timer);
GET_NANOSECONDS(timer_5);
GET_MICROSECONDS(timer_5);
GET_MILLISECONDS(timer_5);
GET_SECONDS(timer_5);
GET_MINUTES(timer_5);
GET_HOURS(timer_5);
GET_DAYS(timer_5);
GET_WEEKS(timer_5);
GET_MONTHS(timer_5);
GET_MONTHS_2(timer_5);
GET_YEARS(timer_5);
GET_YEARS_2(timer_5);
GET_YEARS_3(timer_5);
ssh_time_measure_free(timer_5);
ssh_time_measure_free(timer_4);
ssh_time_measure_free(timer_3);
ssh_time_measure_free(timer_2);
ssh_time_measure_free(timer_1);
ssh_time_measure_free(total_timer);
exit(ev);
}
void MainProcedure(HANDLE codi)
{
char *pData;
METER_STAT stat;
CMDPARAM param;
BYTE szBuffer[1024];
CChunk chunk;
EUI64 id;
int nError, nLength;
int nState;
UINT nSuccessCount = 0;
UINT nFailCount = 0;
for(nState=STATE_INIT; !m_bCodiExitPending;)
{
switch(nState) {
case STATE_INIT :
printf("--------------------------------\r\n");
printf(" Coordinator Inventory Scanning\r\n");
printf("--------------------------------\r\n");
nState = STATE_READY;
break;
case STATE_READY :
nError = codiGetState(codi);
printf("CODINATOR STATE = %d\r\n", nError);
if (nError != CODISTATE_NORMAL)
{
USLEEP(1000000);
break;
}
nState = STATE_MODULE_PARAM;
break;
case STATE_MODULE_PARAM :
nError = codiGetProperty(codi, CODI_CMD_MODULE_PARAM, (BYTE *)szBuffer, &nLength, 3000);
if (nError != CODIERR_NOERROR) ReportError(NULL, nError);
nState = STATE_SERIAL_PARAM;
break;
case STATE_SERIAL_PARAM :
nError = codiGetProperty(codi, CODI_CMD_SERIAL_PARAM, (BYTE *)szBuffer, &nLength, 3000);
if (nError != CODIERR_NOERROR) ReportError(NULL, nError);
nState = STATE_NETWORK_PARAM;
break;
case STATE_NETWORK_PARAM :
nError = codiGetProperty(codi, CODI_CMD_NETWORK_PARAM, (BYTE *)szBuffer, &nLength, 3000);
if (nError != CODIERR_NOERROR) ReportError(NULL, nError);
nState = STATE_SECURITY_PARAM;
break;
case STATE_SECURITY_PARAM :
nError = codiGetProperty(codi, CODI_CMD_SECURITY_PARAM, (BYTE *)szBuffer, &nLength, 3000);
if (nError != CODIERR_NOERROR) ReportError(NULL, nError);
nState = STATE_STACK_MEMORY;
break;
case STATE_STACK_MEMORY :
nError = codiGetProperty(codi, CODI_CMD_STACK_MEMORY, (BYTE *)szBuffer, &nLength, 3000);
if (nError != CODIERR_NOERROR) ReportError(NULL, nError);
nState = STATE_PERMIT;
break;
case STATE_PERMIT :
nError = codiGetProperty(codi, CODI_CMD_PERMIT, (BYTE *)szBuffer, &nLength, 3000);
if (nError != CODIERR_NOERROR) ReportError(NULL, nError);
nState = STATE_METERING;
break;
case STATE_METERING :
atoeui64(szSensorID, &id);
nState = STATE_GE;
break;
case STATE_GE :
printf("----------------------\r\n");
printf(" GE Metering Start\r\n");
printf("----------------------\r\n");
pData = (char *)malloc(10000);
if (pData == NULL)
{
printf("Memory error!!!\r\n");
nState = STATE_WAIT;
break;
}
memset(pData, 0, 10000);
nLength = 0;
memset(¶m, 0, sizeof(CMDPARAM));
memcpy(¶m.id, &id, sizeof(EUI64));
param.codi = codi;
param.nMeteringType = METERING_TYPE_SPECIAL;
param.nType = PARSE_TYPE_READ;
param.nTable = 1;
param.nInterval = 30;
param.pnReply = &nLength;
param.pszReply = (char *)pData;
memset(&stat, 0, sizeof(METER_STAT));
nError = m_pOndemander->Command(const_cast<char *>("GE"), ¶m, &stat);
if (nError != 0)
{
nFailCount++;
XDEBUG("METERING ERROR(%d)\r\n", nError);
}
else nSuccessCount++;
printf("===========================================\r\n");
printf(" SUCCESS = %d\r\n", nSuccessCount);
printf(" FAIL = %d\r\n", nFailCount);
printf("===========================================\r\n");
nState = STATE_WAIT;
break;
case STATE_METERING_ERROR :
printf("STATE_METERING_ERROR\r\n");
printf("----------------\r\n");
printf(" Metering Error\r\n");
printf("----------------\r\n");
nState = STATE_WAIT;
break;
case STATE_WAIT :
printf("STATE_WAIT\r\n");
USLEEP(3000000);
nState = STATE_READY;
break;
}
}
}
BOOL CStatusMonitor::Initialize()
{
#if defined(__INCLUDE_GPIO__)
int nPowerFail;
#if !defined(__EXCLUDE_LOW_BATTERY__)
int nLowBattery;
#endif
#if defined(__TI_AM335X__)
unsigned int nBattAdc = 0;
#endif
time(&m_nLastTime);
time(&m_nLastLowBattery);
nPowerFail = GPIOAPI_ReadGpio(GP_PWR_FAIL_INPUT);
#if !defined(__EXCLUDE_LOW_BATTERY__)
nLowBattery = GPIOAPI_ReadGpio(GP_LOW_BATT_INPUT);
#endif
#if defined(__SUPPORT_NZC1__) || defined(__SUPPORT_NZC2__) // Issue #959
m_nDcdState = GPIOAPI_ReadGpio(GP_GSM_DCD_INPUT);
#endif
#if defined(__TI_AM335X__)
// Battery Charging resgiter off
GPIOAPI_WriteGpio(GP_BATT_CHG_EN_OUT, 1); USLEEP(500000);
// Read Battery ADC Value
nBattAdc = GPIOAPI_ReadAdc(ADC_BATT_VOL_INPUT);
// Battery Charging resgiter on
GPIOAPI_WriteGpio(GP_BATT_CHG_EN_OUT, 0);
XDEBUG("Check Battery ADC Value %d\r\n", nBattAdc);
if(nBattAdc < 2000)
{
XDEBUG(ANSI_COLOR_RED "Battery Status : Abnormal\r\n" ANSI_NORMAL);
// Battery Fail
mcuBatteryFailEvent();
m_nErrorMask |= GPIONOTIFY_BATTERY_FAIL;
}
#endif
m_nErrorMask |= (!(m_nNzcPowerType & NZC_POWER_TYPE_SOLAR) && nPowerFail) ? GPIONOTIFY_PWR : 0;
#if !defined(__EXCLUDE_LOW_BATTERY__)
m_nErrorMask |= !nLowBattery ? GPIONOTIFY_LOWBAT : 0;
#endif
GPIOAPI_WriteGpio(GP_STA_GREEN_OUT, 0);
#if defined(__SUPPORT_NZC1__) || defined(__SUPPORT_NZC2__) // Issue #959
GPIOAPI_WriteGpio(GP_STA_RED_OUT, 1);
#endif
#endif
if(codiGetState(GetCoordinator()) == CODISTATE_NORMAL)
{
m_nErrorMask &= ~GPIONOTIFY_COORDINATOR;
}
else
{
m_nErrorMask |= GPIONOTIFY_COORDINATOR;
}
if(m_nErrorMask)
{
GPIOAPI_WriteGpio(GP_STA_GREEN_OUT, 1); // Abnormal State
}
if (!CTimeoutThread::StartupThread(2))
return FALSE;
#if defined(__INCLUDE_GPIO__)
GPIOAPI_InstallHooker(GpioNotify, (void *)this, (void *)NULL);
#endif
m_bInitialize = TRUE;
return TRUE;
}
int main(int argc, char **argv)
{
#ifndef _WIN32
struct sigaction handler;
#endif
HANDLE codi;
int nError;
int nDebugMode = 1;
int nPermit=-1, nPowerMode=-1;
int nListSerial = 0;
signed char nRfPower=254;
int opt;
char *pDevicePath = NULL;
#ifndef _WIN32
// 보편적인 시그널 핸들러를 설치한다.
handler.sa_handler = signal_handler;
sigfillset(&handler.sa_mask);
sigaction(SIGINT, &handler, 0);
sigaction(SIGTERM, &handler, 0);
sigaction(SIGCHLD, &handler, 0);
#endif
#ifndef _WIN32
while((opt=getopt(argc, argv, "dp:q:G:")) != -1) {
#else
while((opt=getopt(argc, argv, "d")) != -1) {
#endif
switch(opt) {
case 'd':
nDebugMode = 0;
break;
case 'l':
nListSerial = 1;
break;
case 'q':
nPermit = (int)strtol(optarg,(char **)NULL,10) == 0 ? 0 : 255;
break;
case 'G':
nPowerMode = (int)strtol(optarg,(char **)NULL,10);
break;
case 'p':
nRfPower = (signed char)strtol(optarg,(char **)NULL,10);
break;
case 'h':
default :
Usage(argv[0]);
return (1);
}
}
if((argc - optind) < 1) {
Usage(argv[0]);
return (2);
}
// 디버깅 화면 출력(0), 해제(1)
SET_DEBUG_FILE(stderr);
SET_DEBUG_MODE(nDebugMode);
pDevicePath = strdup(argv[optind]);
memset(g_szCodiId, 0, sizeof(g_szCodiId));
memset(codiDevice.szDevice, 0, sizeof(codiDevice.szDevice));
strncpy(codiDevice.szDevice, pDevicePath, MIN(strlen(pDevicePath), sizeof(codiDevice.szDevice)-1));
// CODIAPI를 초기화 한다.
nError = codiInit();
if (nError != CODIERR_NOERROR)
{
ReportError(NULL, nError);
return (3);
}
// 새로운 Coordinator 장치를 등록한다.
nError = codiRegister(&codi, &codiDevice);
if (nError != CODIERR_NOERROR)
{
ReportError(NULL, nError);
codiExit();
return (3);
}
// Coordinator 서비스를 시작 시킨다.
nError = codiStartup(codi);
if (nError != CODIERR_NOERROR)
{
ReportError(NULL, nError);
codiUnregister(codi);
codiExit();
return (3);
}
// 사용자 프로그램을 여기에 코딩한다.
MainProcedure(codi, nPermit, nRfPower, nPowerMode);
// Coordinator 서비스를 종료한다.
nError = codiShutdown(codi);
if (nError != CODIERR_NOERROR)
ReportError(NULL, nError);
// 등록된 디바이스를 해제한다.
nError = codiUnregister(codi);
if (nError != CODIERR_NOERROR)
ReportError(NULL, nError);
// API를 종료한다.
codiExit();
return (0);
}
const char *GetStateMessage(int nState)
{
switch(nState) {
case CODISTATE_NORMAL : return "Normal";
case CODISTATE_NOT_STARTED : return "Coordinator not started";
case CODISTATE_NOT_CONNECTED : return "Coordinator not connected";
case CODISTATE_STACK_NOT_READY : return "Coordinator Stack not ready";
case CODISTATE_STACK_DOWN : return "Coordinator Stack down";
case CODISTATE_JOIN_FAIL : return "Coordinator Join Fail";
case CODISTATE_NO_RESPONSE : return "Coordinator No Response";
case CODISTATE_ERROR : return "Coordinator Error";
}
return "Unknown State";
}
#define STATE_INIT 0
#define STATE_READY 1
#define STATE_PERMIT 17
#define STATE_SET_PERMIT 40
#define STATE_RF_POWER 41
#define STATE_POWER_MODE 42
#define STATE_RESET 55
#define STATE_WAIT 100
void MainProcedure(HANDLE codi, int nPermit, signed char nRfPower, int nPowerMode)
{
TIMETICK start, prev, cur;
//BYTE szBuffer[1024];
int nError = CODIERR_NOERROR, nLength;
int nState, nElapse;
BOOL bSet;
CODI_PERMIT_PAYLOAD permit;
CODI_NETWORK_PAYLOAD network;
GetTimeTick(&start);
for(nState=STATE_INIT; !m_bCodiExitPending;)
{
GetTimeTick(&prev);
//nError = codiGetState(codi);
//XDEBUG("CODINATOR STATE(%d) = %s\r\n", nError, GetStateMessage(nError));
//XDEBUG("m_bCodiExitPending %d\r\n", m_bCodiExitPending);
switch(nState) {
case STATE_INIT :
nState = STATE_READY;
break;
case STATE_READY :
nError = codiGetState(codi);
XDEBUG("CODINATOR STATE(%d) = %s\r\n", nError, GetStateMessage(nError));
if (nError != CODISTATE_NORMAL)
{
nState = STATE_RESET;
break;
}
nState = STATE_SET_PERMIT;
break;
case STATE_RESET :
nError = codiReset(codi);
if (nError != CODIERR_NOERROR) ReportError(NULL, nError);
USLEEP(10000000);
nState = STATE_READY;
break;
case STATE_SET_PERMIT:
#ifdef __FN_RFSET__
if(nPermit >=0 && nPermit <= 255)
{
memset(&permit, 0, sizeof(CODI_CMD_PERMIT));
permit.permit_time = (BYTE)(nPermit & 0xFF);
nError = codiSetProperty(codi, CODI_CMD_PERMIT, (BYTE *)&permit,
sizeof(CODI_PERMIT_PAYLOAD), 3000);
if (nError != CODIERR_NOERROR) ReportError(NULL, nError);
}
#endif
nState = STATE_PERMIT;
break;
case STATE_PERMIT :
memset(&permit, 0, sizeof(CODI_PERMIT_PAYLOAD));
nError = codiGetProperty(codi, CODI_CMD_PERMIT, (BYTE *)&permit, &nLength, 5000);
if (nError != CODIERR_NOERROR)
{
ReportError(NULL, nError);
}
#ifdef __FN_RFSET__
else
{
PRINT("OUT:PERMIT:%d\n", permit.permit_time);
}
#endif
nState = STATE_RF_POWER;
break;
case STATE_RF_POWER :
bSet = FALSE;
memset(&network, 0, sizeof(CODI_NETWORK_PAYLOAD));
nError = codiGetProperty(codi, CODI_CMD_NETWORK_PARAM, (BYTE *)&network, &nLength, 5000);
if (nError != CODIERR_NOERROR)
{
ReportError(NULL, nError);
}
#ifdef __FN_RFSET__
else
{
if(nRfPower != 254)
{
network.power = nRfPower;
bSet = TRUE;
}
if(nPowerMode >= 0)
{
network.txpowermode = (BYTE)nPowerMode;
bSet = TRUE;
}
if(bSet)
{
nError = codiSetProperty(codi, CODI_CMD_NETWORK_PARAM, (BYTE *)&network, nLength, 3000);
}
PRINT("OUT:CINFO:%d,%d,%d\n", network.channel, network.panid, network.power);
}
#endif
nState = STATE_WAIT;
break;
case STATE_WAIT :
GetTimeTick(&cur);
nElapse = GetTimeInterval(&start, &cur);
USLEEP(30000000);
nState = STATE_WAIT;
break;
}
GetTimeTick(&cur);
nElapse = GetTimeInterval(&prev, &cur);
//XDEBUG("Elapse=%d ms\r\n", nElapse);
}
}
/** GPIO 초기화.
*
* @param bInitialize 초기화 여부 (다수의 Process에서 호출할 경우 최초 1회만 초기화 하면 된다)
* @param nMobileType MOBILE_TYPE_CDMA, MOBILE_TYPE_GSM
*/
BOOL CGpioControl::Initialize(BOOL bInitialize, const char* pMobileType, BOOL bMonitoring)
{
if(pMobileType != NULL && strlen(pMobileType)>0)
{
m_pMobileType = (char*)MALLOC(strlen(pMobileType)+1);
strcpy(m_pMobileType, pMobileType);
}
/** 초기화기 필요 없으면 바로 Return 한다 */
if(bInitialize == FALSE) return TRUE;
#ifdef __TI_AM335X__
/** GPIO Epoll 추가 **/
m_nEpfd = epoll_create(INPUT_GPIO_MAX);
/*---- INPUT ----*/
XDEBUG("** GPIO Initialize Start\r\n");
XDEBUG(" GP_GSM_SYNC_INPUT ................ %d\r\n", GP_GSM_SYNC_INPUT);
gpio_export(GP_GSM_SYNC_INPUT);
if(!gpio_dir_in(GP_GSM_SYNC_INPUT))
{
if(bMonitoring) EpollAdd(GP_GSM_SYNC_INPUT, 1, GPIO_ON); // GPIO 번호, 초기값, GPIO State( gpio, ADC )
}
XDEBUG(" GP_LOW_BATT_INPUT ................ %d\r\n", GP_LOW_BATT_INPUT);
gpio_export(GP_LOW_BATT_INPUT);
gpio_dir_in(GP_LOW_BATT_INPUT);
if(bMonitoring) EpollAdd(GP_LOW_BATT_INPUT,1,GPIO_ON);
XDEBUG(" GP_CASE_OPEN_INPUT ............... %d\r\n", GP_CASE_OPEN_INPUT);
gpio_export(GP_CASE_OPEN_INPUT);
gpio_dir_in(GP_CASE_OPEN_INPUT);
if(bMonitoring) EpollAdd(GP_CASE_OPEN_INPUT,0,GPIO_ON);
XDEBUG(" GP_PWR_FAIL_INPUT ................ %d\r\n", GP_PWR_FAIL_INPUT);
gpio_export(GP_PWR_FAIL_INPUT);
gpio_dir_in(GP_PWR_FAIL_INPUT);
if(bMonitoring) EpollAdd(GP_PWR_FAIL_INPUT,0,GPIO_ON);
XDEBUG(" GP_BATT_CHG_STATUS_INPUT ......... %d\r\n", GP_BATT_CHG_STATUS_INPUT);
gpio_export(GP_BATT_CHG_STATUS_INPUT);
gpio_dir_in(GP_BATT_CHG_STATUS_INPUT);
if(bMonitoring) EpollAdd(GP_BATT_CHG_STATUS_INPUT,0,GPIO_ON);
if(bMonitoring) EpollAdd(ADC_BATT_VOL_INPUT,4095,ADC_ON); // GPIO 번호, 초기값, GPIO State( gpio, ADC )
if(bMonitoring) EpollAdd(ADC_MAIN_VOL_INPUT,4040,ADC_ON);
/*---- OUTPUT ----*/
#if 0
/** GPIO 중 SW Reset은 사용하지 않는다 */
XDEBUG(" GP_SW_RESET_OUT ....... HIGH ..... %d\r\n", GP_SW_RESET_OUT);
gpio_export(GP_SW_RESET_OUT);
gpio_dir_out(GP_SW_RESET_OUT , GPIO_DIR_OUT_HIGH);
gpio_set_value(GP_SW_RESET_OUT , GPIO_HIGH );
#endif
XDEBUG(" GP_STA_GREEN_OUT ...... LOW ..... %d\r\n", GP_STA_GREEN_OUT);
gpio_export(GP_STA_GREEN_OUT);
gpio_dir_out(GP_STA_GREEN_OUT , GPIO_DIR_OUT_LOW); //GPIO_DIR_OUT
gpio_set_value(GP_STA_GREEN_OUT , GPIO_LOW );
XDEBUG(" GP_CODI_PCTL_OUT ...... HIGH ..... %d\r\n", GP_CODI_PCTL_OUT);
gpio_export(GP_CODI_PCTL_OUT);
gpio_dir_out(GP_CODI_PCTL_OUT , GPIO_DIR_OUT_HIGH);
gpio_set_value(GP_CODI_PCTL_OUT , GPIO_HIGH );
XDEBUG(" GP_CODI_RST_OUT ....... HIGH ..... %d\r\n", GP_CODI_RST_OUT);
gpio_export(GP_CODI_RST_OUT);
gpio_dir_out(GP_CODI_RST_OUT , GPIO_DIR_OUT_HIGH);
gpio_set_value(GP_CODI_RST_OUT , GPIO_HIGH );
XDEBUG(" GP_NPLC_PCTL_OUT ...... HIGH ..... %d\r\n", GP_NPLC_PCTL_OUT);
gpio_export(GP_NPLC_PCTL_OUT);
gpio_dir_out(GP_NPLC_PCTL_OUT , GPIO_DIR_OUT_HIGH);
gpio_set_value(GP_NPLC_PCTL_OUT , GPIO_HIGH );
XDEBUG(" GP_NPLC_RST_OUT ....... HIGH ..... %d\r\n", GP_NPLC_RST_OUT);
gpio_export(GP_NPLC_RST_OUT);
gpio_dir_out(GP_NPLC_RST_OUT , GPIO_DIR_OUT_HIGH);
gpio_set_value(GP_NPLC_RST_OUT , GPIO_HIGH );
/** Mobile Module Power Setting.
*
* AMTelecom Module의 경우 GSM_PCTL_OUT 일 Low로 설정하여 전원을 Off 시킨 후
* GSM_INIT_PCTL_OUT 값을 조정해 주어야 한다.
*/
gpio_export(GP_GSM_PCTL_OUT);
XDEBUG(" GP_GSM_PCTL_OUT ....... HIGH ..... %d\r\n", GP_GSM_PCTL_OUT);
gpio_dir_out(GP_GSM_PCTL_OUT , GPIO_DIR_OUT_HIGH); //GPIO_DIR_OUT
gpio_set_value(GP_GSM_PCTL_OUT, GPIO_HIGH);
XDEBUG(" GP_GSM_RST_OUT ........ LOW ..... %d\r\n", GP_GSM_RST_OUT);
gpio_export(GP_GSM_RST_OUT);
gpio_dir_out(GP_GSM_RST_OUT , GPIO_DIR_OUT_LOW); //GPIO_DIR_OUT
gpio_set_value(GP_GSM_RST_OUT , GPIO_LOW );
gpio_export(GP_GSM_INIT_PCTL_OUT);
if(m_pMobileType != NULL)
{
/** TI AM335x는 DTSS800, MC55 를 지원하지 않는다 */
if(!strcasecmp(MOBILE_MODULE_TYPE_AME5210, m_pMobileType))
{
// AM Telecom
XDEBUG(" GP_GSM_INIT_PCTL_OUT .. LOW ..... %d\r\n", GP_GSM_INIT_PCTL_OUT);
gpio_dir_out(GP_GSM_INIT_PCTL_OUT , GPIO_DIR_OUT_LOW); //GPIO_DIR_OUT
XDEBUG(" GP_GSM_PCTL_OUT ....... HIGH ..... %d\r\n", GP_GSM_PCTL_OUT);
gpio_dir_out(GP_GSM_PCTL_OUT , GPIO_DIR_OUT_HIGH); //GPIO_DIR_OUT
#if 0
gpio_set_value(GP_GSM_PCTL_OUT, GPIO_HIGH);
#endif
}
else if(!strcasecmp(MOBILE_MODULE_TYPE_GE910, m_pMobileType) ||
!strcasecmp(MOBILE_MODULE_TYPE_UE910, m_pMobileType))
{
XDEBUG(" GP_GSM_INIT_PCTL_OUT .. LOW ..... %d\r\n", GP_GSM_INIT_PCTL_OUT);
gpio_dir_out(GP_GSM_INIT_PCTL_OUT , GPIO_DIR_OUT_LOW); //GPIO_DIR_OUT
#if 0
XDEBUG(" GP_GSM_INIT_PCTL_OUT .. HIGH ..... %d\r\n", GP_GSM_INIT_PCTL_OUT);
gpio_set_value(GP_GSM_INIT_PCTL_OUT, GPIO_HIGH);
usleep(5000000);
XDEBUG(" GP_GSM_INIT_PCTL_OUT .. LOW ..... %d\r\n", GP_GSM_INIT_PCTL_OUT);
gpio_set_value(GP_GSM_INIT_PCTL_OUT, GPIO_LOW);
#endif
}
}
XDEBUG(" GP_RF_SIG_OUT ......... LOW ..... %d\r\n", GP_RF_SIG_OUT);
gpio_export(GP_RF_SIG_OUT);
gpio_dir_out(GP_RF_SIG_OUT , GPIO_DIR_OUT_LOW); // //GPIO_DIR_OUT
gpio_set_value(GP_RF_SIG_OUT , GPIO_LOW );
XDEBUG(" GP_BATT_CHG_EN_OUT .... LOW ..... %d\r\n", GP_BATT_CHG_EN_OUT);
gpio_export(GP_BATT_CHG_EN_OUT);
gpio_dir_out(GP_BATT_CHG_EN_OUT , GPIO_DIR_OUT_LOW); //GPIO_DIR_OUT
// Battery Charging Reset
gpio_set_value(GP_BATT_CHG_EN_OUT , GPIO_HIGH ); USLEEP(500000);
gpio_set_value(GP_BATT_CHG_EN_OUT , GPIO_LOW );
XDEBUG(" GP_BATT_SW_OUT ........ HIGH ..... %d\r\n", GP_BATT_SW_OUT);
gpio_export(GP_BATT_SW_OUT);
gpio_dir_out(GP_BATT_SW_OUT , GPIO_DIR_OUT_HIGH); //
gpio_set_value(GP_BATT_SW_OUT , GPIO_HIGH );
XDEBUG(" GP_485_TX_EN_OUT ...... HIGH ..... %d\r\n", GP_485_TX_EN_OUT);
gpio_export(GP_485_TX_EN_OUT);
if(!gpio_dir_out(GP_485_TX_EN_OUT , GPIO_DIR_OUT_HIGH))
{
gpio_set_value(GP_485_TX_EN_OUT , GPIO_HIGH );
}
XDEBUG(" GP_DEBUG_LED1_OUT ..... LOW ..... %d\r\n", GP_DEBUG_LED1_OUT);
gpio_export(GP_DEBUG_LED1_OUT);
gpio_dir_out(GP_DEBUG_LED1_OUT , GPIO_DIR_OUT_LOW); //
gpio_set_value(GP_DEBUG_LED1_OUT , GPIO_LOW );
XDEBUG(" GP_DEBUG_LED2_OUT ..... LOW ..... %d\r\n", GP_DEBUG_LED2_OUT);
gpio_export(GP_DEBUG_LED2_OUT);
gpio_dir_out(GP_DEBUG_LED2_OUT , GPIO_DIR_OUT_LOW); //
gpio_set_value(GP_DEBUG_LED2_OUT , GPIO_LOW );
XDEBUG(" GP_DEBUG_LED3_OUT ..... LOW ..... %d\r\n", GP_DEBUG_LED3_OUT);
gpio_export(GP_DEBUG_LED3_OUT);
gpio_dir_out(GP_DEBUG_LED3_OUT , GPIO_DIR_OUT_LOW); //
gpio_set_value(GP_DEBUG_LED3_OUT , GPIO_LOW );
XDEBUG("** GPIO Initialize End\r\n");
#else
if (m_nFD != -1)
return FALSE;
m_nFD = open("/dev/gpio", O_RDWR | O_NDELAY);
if (m_nFD < 0)
{
printf(" -------- GPIO Devive Open Fail -------\n");
m_nFD = -1;
return FALSE;
}
// GPIO 입력 다이렉션
ioctl(m_nFD, GPIO_IOCTL_DIR, GP_PWR_FAIL_INPUT); // PWR FAIL
ioctl(m_nFD, GPIO_IOCTL_DIR, GP_LOW_BATT_INPUT); // LOW BATTERY
ioctl(m_nFD, GPIO_IOCTL_DIR, GP_GSM_DCD_INPUT); // MOBILE DCD
ioctl(m_nFD, GPIO_IOCTL_DIR, GP_GSM_SYNC_INPUT); // MOBILE SYNC
ioctl(m_nFD, GPIO_IOCTL_DIR, GP_GSM_RI_INPUT); // MOBILE RI
ioctl(m_nFD, GPIO_IOCTL_DIR, GP_DOOR_OPEN_INPUT); // DOOR OPEN/CLOSE
ioctl(m_nFD, GPIO_IOCTL_DIR, GP_TEMP_OS_INPUT); // HEATER ON/OFF
ioctl(m_nFD, GPIO_IOCTL_DIR, GP_BATT_CHG_STATUS_INPUT); // BATT CHG STS
// GPIO 포트 초기값 설정
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOHIGH(GP_SW_RST_OUT)); // PWR RESET
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOHIGH(GP_CODI_RST_OUT)); // COORDINATOR RESET
// GPIO Output Direction Setting
ioctl(m_nFD, GPIO_IOCTL_DIR, GPIOSET(GP_SW_RST_OUT)); // SW RESET
ioctl(m_nFD, GPIO_IOCTL_DIR, GPIOSET(GP_CODI_RST_OUT)); // COORDINATOR RESET
ioctl(m_nFD, GPIO_IOCTL_DIR, GPIOSET(GP_BATT_SW_OUT)); // PWR CTRL
ioctl(m_nFD, GPIO_IOCTL_DIR, GPIOSET(GP_BATT_CHG_EN_OUT)); // BATT CHG EN
if(m_pMobileType != NULL)
{
/** PXA는 GE910, UE910 를 지원하지 않는다 */
if(!strcasecmp(MOBILE_MODULE_TYPE_DTSS800, m_pMobileType))
{
ioctl(m_nFD, GPIO_IOCTL_DIR, GP_GSM_IGT_OUT); // MOBILE RESET (IGT)
}
else if(!strcasecmp(MOBILE_MODULE_TYPE_MC55, m_pMobileType))
{
ioctl(m_nFD, GPIO_IOCTL_DIR, GPIOSET(GP_GSM_EMERGOFF_OUT)); // EMERGENCY OFF
ioctl(m_nFD, GPIO_IOCTL_DIR, GPIOSET(GP_GSM_IGT_OUT)); // MOBILE RESET (IGT)
}
}
ioctl(m_nFD, GPIO_IOCTL_DIR, GPIOSET(GP_GSM_PCTL_OUT)); // MOBILE POWER
ioctl(m_nFD, GPIO_IOCTL_DIR, GPIOSET(GP_GSM_DTR_OUT)); // MOBILE DTR
ioctl(m_nFD, GPIO_IOCTL_DIR, GPIOSET(GP_LED_READY_OUT)); // LED READY
ioctl(m_nFD, GPIO_IOCTL_DIR, GPIOSET(GP_STA_GREEN_OUT)); // STATUS GREEN LED
ioctl(m_nFD, GPIO_IOCTL_DIR, GPIOSET(GP_STA_RED_OUT)); // STATUS RED LED
ioctl(m_nFD, GPIO_IOCTL_DIR, GPIOSET(GP_DEBUG_LED1_OUT)); // LED DEBUG1
ioctl(m_nFD, GPIO_IOCTL_DIR, GPIOSET(GP_DEBUG_LED2_OUT)); // LED DEBUG2
ioctl(m_nFD, GPIO_IOCTL_DIR, GPIOSET(GP_DEBUG_LED3_OUT)); // LED DEBUG3
ioctl(m_nFD, GPIO_IOCTL_DIR, GPIOSET(GP_DEBUG_LED4_OUT)); // LED DEBUG4
// 신규 보드는 HIGH, 영국, 스웨덴은 LOW, 구형은 HIGH
#if defined(__SUPPORT_NZC1__)
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOLOW(GP_BATT_SW_OUT)); // BATTERY ENABLE/DISABLE CONTROL
#elif defined(__SUPPORT_NZC2__)
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOHIGH(GP_BATT_SW_OUT)); // BATTERY ENABLE/DISABLE CONTROL
#else
assert(0);
#endif
if(m_pMobileType != NULL && !strcasecmp(MOBILE_MODULE_TYPE_MC55, m_pMobileType))
{
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOLOW(GP_GSM_EMERGOFF_OUT)); // GSM RESET
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOLOW(GP_GSM_IGT_OUT)); // GSM IGT
}
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOHIGH(GP_LED_READY_OUT)); // READY LED OFF
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOHIGH(GP_STA_GREEN_OUT)); // GREEN LED OFF
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOHIGH(GP_STA_RED_OUT)); // RED LED OFF
XDEBUG("** Mobile Power OFF\xd\xa");
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOLOW(GP_BATT_CHG_EN_OUT)); // BATT CHARGE DISABLE
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOLOW(GP_GSM_PCTL_OUT)); // GSM Power Off
usleep(1000000);
XDEBUG("** Mobile Power ON\xd\xa");
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOHIGH(GP_BATT_CHG_EN_OUT)); // BATT CHARGE ENABLE
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOHIGH(GP_GSM_PCTL_OUT));
usleep(1000000);
if(m_pMobileType != NULL && !strcasecmp(MOBILE_MODULE_TYPE_MC55, m_pMobileType))
{
XDEBUG("** Mobile IGT or Reset\xd\xa");
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOHIGH(GP_GSM_IGT_OUT)); // IGT HIGH
usleep(1000000);
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOLOW(GP_GSM_IGT_OUT)); // IGT LOW
usleep(1000000);
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOHIGH(GP_GSM_IGT_OUT)); // IGT HIGH
}
XDEBUG("** Mobile DTR Control\xd\xa");
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOHIGH(GP_GSM_DTR_OUT)); // DTR HIGH
usleep(1000000);
ioctl(m_nFD, GPIO_IOCTL_OUT, GPIOLOW(GP_GSM_DTR_OUT)); // DTR LOW
#endif
/** Monitoring이 필요 없으면 바로 Return 한다 */
if(bMonitoring == FALSE) return TRUE;
// 상태 모니터링 쓰레드 생성
m_bExitPending = FALSE;
if (pthread_create(&m_gpioThreadID, NULL, gpioWatchThread, (void *)this) != 0)
return FALSE;
pthread_detach(m_gpioThreadID);
return TRUE;
}
void CGpioControl::RunMonitoring()
{
#ifdef __TI_AM335X__
int nEvent;
int i = 0;
unsigned int nValue = 0;
struct epoll_event *events;
char buf[64];
int bufsize=sizeof(buf);
GPIOENTRY *pGpio;
events = (struct epoll_event *)malloc(sizeof(*events) * INPUT_GPIO_MAX );
for(;!m_bExitPending;)
{
nEvent = epoll_wait( m_nEpfd ,events , INPUT_GPIO_MAX , 3000000);
for(i =0 ; i < nEvent ; i++)
{
pGpio = (GPIOENTRY*)events[i].data.ptr ;
memset(buf, 0, bufsize);
lseek(pGpio->fd, 0, SEEK_SET);
if ( read(pGpio->fd, buf, bufsize) )
{
nValue = strtol(buf, (char**)NULL, 10);
//if (nValue) nValue = 1;
if (pGpio->nValue != nValue)
{
if (m_bEnableHooker && (m_pfnCallback != NULL))
{
pGpio->nValue = nValue ;
m_Locker.Lock();
m_pfnCallback(pGpio->mask, nValue, m_pParam, m_pArgment);
m_Locker.Unlock();
}
}
}
}
USLEEP(3000000);
}
nEvent = epoll_wait( m_nEpfd ,events , INPUT_GPIO_MAX , 1000000);
for(i =0 ; i < nEvent ; i++)
{
pGpio = (GPIOENTRY*)events[i].data.ptr ;
epoll_ctl(m_nEpfd, EPOLL_CTL_DEL , pGpio->fd, events);
free(events[i].data.ptr);
close(pGpio->fd);
}
free(events);
#else
struct timeval timeout;
fd_set rset;
int fd, n;
int dcd, low, pwr, ring;
int heater, door, charge;
BYTE oldDCD, oldPWR, oldBAT, oldRING;
BYTE oldHEATER, oldDOOR, oldCHARGE;
fd = m_nFD;
m_gpioLocker.Lock();
oldDCD = ioctl(fd, GPIO_IOCTL_IN, GP_GSM_DCD_INPUT);
oldPWR = ioctl(fd, GPIO_IOCTL_IN, GP_PWR_FAIL_INPUT);
oldBAT = ioctl(fd, GPIO_IOCTL_IN, GP_LOW_BATT_INPUT);
oldRING = ioctl(fd, GPIO_IOCTL_IN, GP_GSM_RI_INPUT);
oldDOOR = ioctl(fd, GPIO_IOCTL_IN, GP_DOOR_OPEN_INPUT);
oldHEATER = ioctl(fd, GPIO_IOCTL_IN, GP_TEMP_OS_INPUT);
oldCHARGE = ioctl(fd, GPIO_IOCTL_IN, GP_BATT_CHG_STATUS_INPUT);
m_gpioLocker.Unlock();
for(;!m_bExitPending;)
{
FD_ZERO(&rset);
FD_SET(fd, &rset);
timeout.tv_sec = 3;
timeout.tv_usec = 0;
n = select(fd+1, &rset, NULL, NULL, &timeout);
if (n == -1)
break;
if (FD_ISSET(fd, &rset))
{
m_gpioLocker.Lock();
dcd = ioctl(fd, GPIO_IOCTL_IN, GP_GSM_DCD_INPUT);
pwr = ioctl(fd, GPIO_IOCTL_IN, GP_PWR_FAIL_INPUT);
low = ioctl(fd, GPIO_IOCTL_IN, GP_LOW_BATT_INPUT);
ring = ioctl(fd, GPIO_IOCTL_IN, GP_GSM_RI_INPUT);
door = ioctl(fd, GPIO_IOCTL_IN, GP_DOOR_OPEN_INPUT);
heater = ioctl(fd, GPIO_IOCTL_IN, GP_TEMP_OS_INPUT);
charge = ioctl(fd, GPIO_IOCTL_IN, GP_BATT_CHG_STATUS_INPUT);
m_gpioLocker.Unlock();
// DCD Check
if (dcd != oldDCD)
{
XDEBUG("GPIO: ------ Mobile DCD %s ------\r\n", dcd == 0 ? "Active" : "Normal");
m_Locker.Lock();
if (m_bEnableHooker && (m_pfnCallback != NULL))
m_pfnCallback(GPIONOTIFY_DCD, dcd, m_pParam, m_pArgment);
m_Locker.Unlock();
oldDCD = dcd;
}
if (pwr != oldPWR)
{
// 100ms 후에도 Power Fail인지 검사한다.
usleep(100000);
pwr = ioctl(fd, GPIO_IOCTL_IN, GP_PWR_FAIL_INPUT);
if (pwr != oldPWR)
{
XDEBUG("GPIO: ------ Power %s signal ------\r\n", pwr == 0 ? "UP" : "DOWN");
m_Locker.Lock();
if (m_bEnableHooker && (m_pfnCallback != NULL))
m_pfnCallback(GPIONOTIFY_PWR, pwr, m_pParam, m_pArgment);
m_Locker.Unlock();
oldPWR = pwr;
// Power restore
if (pwr == 0)
{
// Battery Charging
XDEBUG("GPIO: ------ Toggle battery charge ------\r\n");
ioctl(fd, GPIO_IOCTL_OUT, GPIOLOW(GP_BATT_CHG_EN_OUT)); // BATT CHARGE DISABLE
usleep(1000000);
ioctl(fd, GPIO_IOCTL_OUT, GPIOHIGH(GP_BATT_CHG_EN_OUT)); // BATT CHARGE ENABLE
}
}
}
if (low != oldBAT)
{
// 100ms 후에도 Low Battery인지 검사한다.
usleep(100000);
low = ioctl(fd, GPIO_IOCTL_IN, GP_LOW_BATT_INPUT);
if (low != oldBAT)
{
XDEBUG("GPIO: ------ Low Battery %s signal ------\n", low == 0 ? "Low" : "Normal");
m_Locker.Lock();
if (m_bEnableHooker && (m_pfnCallback != NULL))
m_pfnCallback(GPIONOTIFY_LOWBAT, low, m_pParam, m_pArgment);
m_Locker.Unlock();
oldBAT = low;
}
}
if (ring != oldRING)
{
XDEBUG("GPIO: ------ Mobile RING signal %s ------\n", ring == 0 ? "Active" : "Normal");
m_Locker.Lock();
if (m_bEnableHooker && (m_pfnCallback != NULL))
m_pfnCallback(GPIONOTIFY_RING, ring, m_pParam, m_pArgment);
m_Locker.Unlock();
oldRING = ring;
}
// Heater
if (heater != oldHEATER)
{
XDEBUG("GPIO: ------ Heater %s ------\r\n", heater == 0 ? "OFF" : "ON");
m_Locker.Lock();
if (m_bEnableHooker && (m_pfnCallback != NULL))
m_pfnCallback(GPIONOTIFY_HEATER, heater, m_pParam, m_pArgment);
m_Locker.Unlock();
oldHEATER = heater;
}
// Door open
if (door != oldDOOR)
{
XDEBUG("GPIO: ------ Door %s ------\r\n", door == 0 ? "OPEN" : "CLOSE");
m_Locker.Lock();
if (m_bEnableHooker && (m_pfnCallback != NULL))
m_pfnCallback(GPIONOTIFY_DOOR, door, m_pParam, m_pArgment);
m_Locker.Unlock();
oldDOOR = door;
}
// Battery charge
if (charge != oldCHARGE)
{
XDEBUG("GPIO: ------ Battery charge %s ------\r\n", charge == 0 ? "OFF" : "CHARGE");
m_Locker.Lock();
if (m_bEnableHooker && (m_pfnCallback != NULL))
m_pfnCallback(GPIONOTIFY_BATTERY_CHARG, dcd, m_pParam, m_pArgment);
m_Locker.Unlock();
oldCHARGE = charge;
}
}
}
#endif
}
static int
fast_forward_or_merge (const char *repo_id,
SeafCommit *base,
SeafCommit *new_commit)
{
#define MAX_RETRY_COUNT 3
SeafRepo *repo = NULL;
SeafCommit *current_head = NULL, *merged_commit = NULL;
int retry_cnt = 0;
int ret = 0;
repo = seaf_repo_manager_get_repo (seaf->repo_mgr, repo_id);
if (!repo) {
seaf_warning ("Repo %s doesn't exist.\n", repo_id);
ret = -1;
goto out;
}
retry:
current_head = seaf_commit_manager_get_commit (seaf->commit_mgr,
repo->id, repo->version,
repo->head->commit_id);
if (!current_head) {
seaf_warning ("Failed to find head commit of %s.\n", repo_id);
ret = -1;
goto out;
}
/* Merge if base and head are not the same. */
if (strcmp (base->commit_id, current_head->commit_id) != 0) {
MergeOptions opt;
const char *roots[3];
char *desc = NULL;
memset (&opt, 0, sizeof(opt));
opt.n_ways = 3;
memcpy (opt.remote_repo_id, repo_id, 36);
memcpy (opt.remote_head, new_commit->commit_id, 40);
opt.do_merge = TRUE;
roots[0] = base->root_id; /* base */
roots[1] = current_head->root_id; /* head */
roots[2] = new_commit->root_id; /* remote */
if (seaf_merge_trees (repo->store_id, repo->version, 3, roots, &opt) < 0) {
seaf_warning ("Failed to merge.\n");
ret = -1;
goto out;
}
if (!opt.conflict)
desc = g_strdup("Auto merge by system");
else {
desc = gen_merge_description (repo,
opt.merged_tree_root,
current_head->root_id,
new_commit->root_id);
if (!desc)
desc = g_strdup("Auto merge by system");
}
merged_commit = seaf_commit_new(NULL, repo->id, opt.merged_tree_root,
new_commit->creator_name, EMPTY_SHA1,
desc,
0);
g_free (desc);
merged_commit->parent_id = g_strdup (current_head->commit_id);
merged_commit->second_parent_id = g_strdup (new_commit->commit_id);
merged_commit->new_merge = TRUE;
if (opt.conflict)
merged_commit->conflict = TRUE;
seaf_repo_to_commit (repo, merged_commit);
if (seaf_commit_manager_add_commit (seaf->commit_mgr, merged_commit) < 0) {
seaf_warning ("Failed to add commit.\n");
ret = -1;
goto out;
}
} else {
seaf_commit_ref (new_commit);
merged_commit = new_commit;
}
seaf_branch_set_commit(repo->head, merged_commit->commit_id);
if (seaf_branch_manager_test_and_update_branch(seaf->branch_mgr,
repo->head,
current_head->commit_id) < 0)
{
seaf_repo_unref (repo);
repo = NULL;
seaf_commit_unref (current_head);
current_head = NULL;
seaf_commit_unref (merged_commit);
merged_commit = NULL;
repo = seaf_repo_manager_get_repo (seaf->repo_mgr, repo_id);
if (!repo) {
seaf_warning ("Repo %s doesn't exist.\n", repo_id);
ret = -1;
goto out;
}
if (++retry_cnt <= MAX_RETRY_COUNT) {
seaf_message ("Concurrent branch update, retry.\n");
/* Sleep random time between 100 and 1000 millisecs. */
USLEEP (g_random_int_range(1, 11) * 100 * 1000);
goto retry;
} else {
seaf_warning ("Stop retrying.\n");
ret = -1;
goto out;
}
}
out:
seaf_commit_unref (current_head);
seaf_commit_unref (merged_commit);
seaf_repo_unref (repo);
return ret;
}
void MainProcedure(HANDLE codi)
{
TIMETICK start, prev, cur;
char szFileName[256] = "";
BYTE szBuffer[1024];
int nError, nLength;
int nState, nElapse;
strcpy(szFileName, "/app/sw/ZNet3_Coordinator_v10_B16.ebl");
GetTimeTick(&start);
for(nState=STATE_INIT; !m_bCodiExitPending && (nState!=STATE_DONE);)
{
GetTimeTick(&prev);
nError = codiGetState(codi);
printf("CODINATOR STATE(%d) = %s\r\n", nError, GetStateMessage(nError));
switch(nState) {
case STATE_INIT :
nState = STATE_READY;
break;
case STATE_READY :
nError = codiGetState(codi);
printf("CODINATOR STATE(%d) = %s\r\n", nError, GetStateMessage(nError));
if (nError != CODISTATE_NORMAL)
{
USLEEP(1000000);
break;
}
nState = STATE_MODULE_PARAM;
break;
case STATE_MODULE_PARAM :
codiSync(codi, 3);
GetTimeTick(&start);
nError = codiGetProperty(codi, CODI_CMD_MODULE_PARAM, (BYTE *)szBuffer, &nLength, 5000);
if (nError != CODIERR_NOERROR) ReportError(NULL, nError);
nState = STATE_NETWORK_PARAM;
break;
case STATE_NETWORK_PARAM :
nError = codiGetProperty(codi, CODI_CMD_NETWORK_PARAM, (BYTE *)szBuffer, &nLength, 5000);
if (nError != CODIERR_NOERROR) ReportError(NULL, nError);
nState = STATE_SECURITY_PARAM;
break;
case STATE_SECURITY_PARAM :
nError = codiGetProperty(codi, CODI_CMD_SECURITY_PARAM, (BYTE *)szBuffer, &nLength, 5000);
if (nError != CODIERR_NOERROR) ReportError(NULL, nError);
nState = STATE_PERMIT;
break;
case STATE_PERMIT :
nError = codiGetProperty(codi, CODI_CMD_PERMIT, (BYTE *)szBuffer, &nLength, 5000);
if (nError != CODIERR_NOERROR) ReportError(NULL, nError);
nState = STATE_DOWNLOAD;
break;
case STATE_DOWNLOAD :
nError = codiDownload(codi, CODI_MODEMTYPE_XMODEM, szFileName, "ebl");
if (nError != CODIERR_NOERROR) ReportError(NULL, nError);
USLEEP(3000000);
nState = STATE_WAIT;
break;
case STATE_WAIT :
GetTimeTick(&cur);
nElapse = GetTimeInterval(&start, &cur);
printf("\r\n");
printf("-----------------------------------------------------\r\n");
printf(" TOTAL Elapse Time = %d ms\r\n", nElapse);
printf("-----------------------------------------------------\r\n");
nState = STATE_DONE;
break;
}
GetTimeTick(&cur);
nElapse = GetTimeInterval(&prev, &cur);
printf("Elapse=%d ms\r\n", nElapse);
}
}
