int parseCommand() {
int result = OK;
do {
switch(cmdRead()) {
case LINE_TERMINATOR:
// Be fair: return after a command line has been processed
break;
case '+':
result = parseCmdClass(ASCII);
break;
case '$':
result = parseCmdClass(BINARY);
break;
}
if (result!=OK) {
// Error on cmds parsing... aborting next commands
break;
}
} while ( cmdAvailable() );
Serial_printFlush();
Serial_printLine("");
if (result==OK)
Serial_printLine("OK");
else
Serial_printLine("ERROR");
return result;
}
/// Copy a command value from UART buffer to local (d_outBuff) buffer
void cmdReadValue() {
short iValRead = 0;
do {
d_outBuff[iValRead] = cmdLook();
if (d_outBuff[iValRead]!=-1 && // uart empty
d_outBuff[iValRead]!=LINE_TERMINATOR && // line end
d_outBuff[iValRead]!='+') { // cmd following
// Removing char from uart buffer
cmdRead();
iValRead++;
} else {
// Null terminating string and returning
d_outBuff[iValRead]=0;
return;
}
} while(1);
}
inline int parseCmdClass(int type) {
switch(cmdRead()) {
case 'A':
// Alarms
return parseAlarmCmd(type);
break;
case 'G':
// GPS
return parseGpsCmd(type);
break;
case 'O':
// Odometer
return parseOdoCmd(type);
break;
case 'Q':
// Query registry
return parseQueryCmd(type);
break;
}
return ERROR;
}
int main()
{
char cmd[256];
char *token;
printf ("Testing for T2FS - v 1.0\n");
cmdMan();
while (1) {
printf ("T2FS> ");
gets(cmd);
if( (token = strtok(cmd," \t")) != NULL ) {
if (strcmp(token,"exit")==0) { cmdExit(); break; }
else if (strcmp(token,"man")==0) cmdMan();
else if (strcmp(token,"who")==0) cmdWho();
else if (strcmp(token,"cp")==0) cmdCp();
else if (strcmp(token,"fscp")==0) cmdFscp();
else if (strcmp(token,"create")==0) cmdCreate();
else if (strcmp(token,"del")==0) cmdDelete();
else if (strcmp(token,"open")==0) cmdOpen();
else if (strcmp(token,"close")==0) cmdClose();
else if (strcmp(token,"read")==0) cmdRead();
else if (strcmp(token,"mkdir")==0) cmdMkdir();
else if (strcmp(token,"md")==0) cmdMkdir();
else if (strcmp(token,"rmdir")==0) cmdRmdir();
else if (strcmp(token,"rm")==0) cmdRmdir();
else if (strcmp(token,"getcwd")==0) cmdGetcwd();
else if (strcmp(token,"chdir")==0) cmdChdir();
else if (strcmp(token,"cd")==0) cmdChdir();
else if (strcmp(token,"ls")==0) cmdLs();
else if (strcmp(token,"dir")==0) cmdLs();
else printf ("???\n");
}
}
return 0;
}
inline int parseOdoCmd(int type) {
switch(cmdRead()) {
case 'C':
switch(cmdRead()) {
case 'P':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '+':
// READ "Pulse conunt"
ShowValueUL(d_pcount);
goto poc_ok;
case '=':
// WRITE "Pulse conunt"
cmdRead();
ReadValueUL(d_pcount);
goto poc_ok;
}
goto poc_error;
}
goto poc_error;
case 'F':
switch(cmdRead()) {
case 'P':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '+':
// READ "Pulse frequency"
ShowValueUL(d_freq);
goto poc_ok;
}
goto poc_error;
}
goto poc_error;
}
poc_error:
return ERROR;
poc_ok:
return OK;
}
int main(int argc, char *argv[]) {
int i, j;
int thisSocket, thatSocket;
int *confPort;
unsigned int tmpSeconds;
char *confConfig, *confEngine, *confPassword;
char magicCookie[] = "TELLUTELLUTELLUTELLUTELLUTELLU";
size_t s;
uid_t *thisUid;
gid_t *thisGid;
/*
*
* Initialize default values.
*
*/
pMainMainInfo = &mainMainInfo;
pMainThreadInfo = &mainThreadInfo;
memset(pMainMainInfo, 0, sizeof(mainMainInfo));
memset(pMainThreadInfo, 0, sizeof(mainThreadInfo));
/*
*
* Read command line and parse configuration file.
*
*/
cmdRead(argv, argc);
if((confConfig = configFetch("config_file", &i)) != NULL) {
if(configRead(confConfig) != 0) {
warningMessage(ERROR_SLIGHT, "Error occurred while trying to read configuration file");
}
}
else {
if(configRead(CONFIG_DEFAULT_FILE) != 0) {
warningMessage(ERROR_SLIGHT, "Error occurred while trying to read configuration file");
}
}
cmdRead(argv, argc);
nodeInitNames();
/*
*
* Initialize thread pool.
*
*/
if((threadPool = malloc(sizeof(struct threadInfo) * THREAD_TELSKIND)) == NULL) {
warningMessage(ERROR_FATAL, "Error occurred while trying to allocate memory for thread pool");
}
memset(threadPool, 0, sizeof(struct threadInfo) * THREAD_TELSKIND);
/*
*
* Initialize configurable subroutines.
*
*/
pMainThreadInfo->threadReady = 1;
for(j = 0; j < THREAD_TELSKIND; j++) {
threadPool[j].threadReady = 1;
threadPool[j].magicCookie = magicCookie;
threadPool[j].pMainInfo = pMainMainInfo;
if((confEngine = configFetch("storage_engine", &i)) != NULL) {
if(strncasecmp(confEngine, "plain", strlen(confEngine)) == 0) {
threadPool[j].dbInfo.connect = plainConnect;
threadPool[j].dbInfo.disconnect = plainDisconnect;
threadPool[j].dbInfo.escape = plainEscape;
threadPool[j].dbInfo.push = plainPush;
threadPool[j].dbInfo.pull = plainPull;
threadPool[j].dbInfo.round = plainRound;
threadPool[j].dbInfo.free = plainFree;
threadPool[j].dbInfo.expire = plainExpire;
threadPool[j].dbInfo.cookie = plainCookie;
threadPool[j].dbInfo.insert = plainInsert;
threadPool[j].dbInfo.login = plainLogin;
threadPool[j].dbInfo.logout = plainLogout;
threadPool[j].dbInfo.session = plainSession;
threadPool[j].dbInfo.permission = plainPermission;
pMainThreadInfo->dbInfo.connect = plainConnect;
pMainThreadInfo->dbInfo.disconnect = plainDisconnect;
pMainThreadInfo->dbInfo.escape = plainEscape;
pMainThreadInfo->dbInfo.push = plainPush;
pMainThreadInfo->dbInfo.pull = plainPull;
pMainThreadInfo->dbInfo.round = plainRound;
pMainThreadInfo->dbInfo.free = plainFree;
pMainThreadInfo->dbInfo.expire = plainExpire;
pMainThreadInfo->dbInfo.cookie = plainCookie;
pMainThreadInfo->dbInfo.insert = plainInsert;
pMainThreadInfo->dbInfo.login = plainLogin;
pMainThreadInfo->dbInfo.logout = plainLogout;
pMainThreadInfo->dbInfo.session = plainSession;
pMainThreadInfo->dbInfo.permission = plainPermission;
continue;
}
}
threadPool[j].dbInfo.connect = mysqlConnect;
threadPool[j].dbInfo.disconnect = mysqlDisconnect;
threadPool[j].dbInfo.escape = mysqlEscape;
threadPool[j].dbInfo.push = mysqlPush;
threadPool[j].dbInfo.pull = mysqlPull;
threadPool[j].dbInfo.round = mysqlRound;
threadPool[j].dbInfo.free = mysqlFree;
threadPool[j].dbInfo.expire = mysqlExpire;
threadPool[j].dbInfo.cookie = mysqlCookie;
threadPool[j].dbInfo.insert = mysqlInsert;
threadPool[j].dbInfo.login = mysqlLogin;
threadPool[j].dbInfo.logout = mysqlLogout;
threadPool[j].dbInfo.session = mysqlSession;
threadPool[j].dbInfo.permission = mysqlPermission;
pMainThreadInfo->dbInfo.connect = mysqlConnect;
pMainThreadInfo->dbInfo.disconnect = mysqlDisconnect;
pMainThreadInfo->dbInfo.escape = mysqlEscape;
pMainThreadInfo->dbInfo.push = mysqlPush;
pMainThreadInfo->dbInfo.pull = mysqlPull;
pMainThreadInfo->dbInfo.round = mysqlRound;
pMainThreadInfo->dbInfo.free = mysqlFree;
pMainThreadInfo->dbInfo.expire = mysqlExpire;
pMainThreadInfo->dbInfo.cookie = mysqlCookie;
pMainThreadInfo->dbInfo.insert = mysqlInsert;
pMainThreadInfo->dbInfo.login = mysqlLogin;
pMainThreadInfo->dbInfo.logout = mysqlLogout;
pMainThreadInfo->dbInfo.session = mysqlSession;
pMainThreadInfo->dbInfo.permission = mysqlPermission;
}
/*
*
* Initialize magick cookie.
*
*/
if((confPassword = configFetch("agent_password", &i)) != NULL) {
s = strlen(confPassword);
if(s > DATA_COOKIE_SIZE) {
s = DATA_COOKIE_SIZE;
}
strncpy(magicCookie, confPassword, s);
}
/*
*
* Initialize main thread.
*
*/
configSetUmask(0077);
if(configSetLocale(CONFIG_DEFAULT_LOCALE) != 0) {
warningMessage(ERROR_SLIGHT, "Error occurred while trying to set default locale");
}
if(configChangeRoot(CONFIG_DEFAULT_ROOT) != 0) {
warningMessage(ERROR_SLIGHT, "Error occurred while trying to change root directory");
}
if(configCloseInput() != 0) {
warningMessage(ERROR_SLIGHT, "Error occurred while trying to close standard input");
}
if(configDaemonize() != 0) {
warningMessage(ERROR_SLIGHT, "Error occurred while trying to daemonize process");
}
threadStack(THREAD_TELSKIND);
beginProcess(pMainThreadInfo);
/*
*
* Initialize timer.
*
*/
if(timerInit(TIMER_RESOLUTION_STATUS, 0, timerStatThreads) != 0) {
warningMessage(ERROR_FATAL, "Error occurred while trying to initialize timer");
}
/*
*
* Initialize worker threads.
*
*/
pMainMainInfo->allRunning = 0;
pMainMainInfo->theEnd = 0;
pMainMainInfo->threadEnd = 0;
for(i = 0; i < THREAD_TELSKIND; i++) {
if(threadInit(&threadPool[i], workerThread, &threadPool[i]) != 0) {
warningMessage(ERROR_FATAL, "Error occurred while trying to initialize worker thread");
}
j = 0;
while(threadPool[i].threadReady != 0) {
timerWait(&tmpSeconds, 0, THREAD_AGAIN);
if(j == 10000 || j == 20000 || j == 30000 || j == 40000 || j == 50000) {
warningMessage(ERROR_SLIGHT, "Waiting for worker threads to start taking too long, still waiting");
}
else if(j >= 60000) {
warningMessage(ERROR_FATAL, "Waiting for threads to start taking too long");
}
j++;
}
}
/*
*
* Create socket to listen.
*
*/
if((confPort = configFetch("listen_port", &i)) != NULL) {
thisSocket = netCreateListenSocket(*confPort);
}
else {
thisSocket = netCreateListenSocket(CONFIG_DEFAULT_PORT);
}
/*
*
* Create process id, shm segment, switch user and group id's.
*
*/
pidCreate();
shmCreate(DAEMON_TELSKIND, THREAD_TELSKIND);
if((thisUid = configFetch("user_id", &i)) != NULL) {
if(*thisUid != -1) {
if(uidSwitch(*thisUid) != 0) {
warningMessage(ERROR_SLIGHT, "Error occurred while trying to change user id");
}
}
}
if((thisGid = configFetch("group_id", &i)) != NULL) {
if(*thisGid != -1) {
if(gidSwitch(*thisGid) != 0) {
warningMessage(ERROR_SLIGHT, "Error occurred while trying to change group id");
}
}
}
/*
*
* Serve connected clients.
*
*/
startProcess(THREAD_TELSKIND);
pMainMainInfo->allRunning++;
pMainMainInfo->rushThreadCounter = 0;
while(pMainMainInfo->theEnd == 0) {
thatSocket = netWaitConnection(thisSocket, pMainThreadInfo);
if(pMainMainInfo->theEnd != 0) {
break;
}
mainLoop:
for(i = 0; i < THREAD_TELSKIND; i++) {
if(threadPool[i].threadReady == 0) {
threadPool[i].threadReady++;
threadPool[i].threadSocket = thatSocket;
shmUpdate(i, DAEMON_TELSKIND);
if(threadWake(&threadPool[i]) != 0) {
netCloseSocket(threadPool[i].threadSocket);
threadPool[i].threadReady = 0;
threadPool[i].threadSocket = 0;
warningMessage(ERROR_SLIGHT, "Error occurred while trying to start worker thread");
}
pMainMainInfo->rushThreadCounter = 0;
break;
}
}
if(i == THREAD_TELSKIND) {
if(pMainMainInfo->rushThreadCounter > 1000) {
pMainMainInfo->rushThreadCounter = 0;
warningMessage(ERROR_SLIGHT, "No free worker thread available, dropping agent");
netCloseSocket(thatSocket);
}
else {
pMainMainInfo->rushThreadCounter++;
if(pMainMainInfo->rushThreadCounter < 2) {
warningMessage(ERROR_SLIGHT, "No free worker thread available, it may be necessary to enlarge the thread pool");
}
timerWait(&tmpSeconds, 0, THREAD_AGAIN);
goto mainLoop;
}
}
}
/*
*
* Free allocated resources and terminate program.
*
*/
netCloseSocket(thisSocket);
pMainMainInfo->threadEnd++;
if(timerInit(TIMER_RESOLUTION_THREADSTOP, 0, timerStopThreads) == 0) {
pMainMainInfo->timerThreadAccess = 1;
for(i = 0; i < THREAD_TELSKIND; i++) {
threadWake(&threadPool[i]);
}
pMainMainInfo->timerThreadAccess = 0;
}
else {
for(i = 0; i < THREAD_TELSKIND; i++) {
threadKill(&threadPool[i]);
}
}
timesProcess(pMainThreadInfo);
pidRemove();
shmRemove(DAEMON_TELSKIND);
free(threadPool);
exitProcess(0);
exit(0);
}
/***
* The loop function is called in an endless loop
*/
void loop() {
char c, argC;
char *argV[ARGV_MAX];
int i, pin;
unsigned long curMs;
// Take care of blinking LED
if (startBlinking == true) {
curMs = millis();
if (curMs > blinkLastChangeMs + blinkingDelayMs) {
blinkLastChangeMs = curMs;
if (digitalRead(blinkingPin) == HIGH) {
digitalWrite(blinkingPin, LOW);
} else {
digitalWrite(blinkingPin, HIGH);
}
}
}
#ifdef USE_PID
// Take care PID-relay variables
for (i = 0; i < PID_RELAY_MAX_VARS; i++) {
if (pidRelayDescs[i].isOn) {
pidRelayDescs[i].inputVar = analogRead(pidRelayDescs[i].pinAnalIn);
pidRelayDescs[i].handler->Compute();
// turn relay on/off according to the PID output
curMs = millis();
if (curMs - pidRelayDescs[i].windowStartTime > pidRelayDescs[i].windowSize) {
//time to shift the Relay Window
pidRelayDescs[i].windowStartTime += pidRelayDescs[i].windowSize;
}
if (pidRelayDescs[i].outputVar > curMs - pidRelayDescs[i].windowStartTime) {
digitalWrite(pidRelayDescs[i].pinDigiOut, HIGH);
}
else {
digitalWrite(pidRelayDescs[i].pinDigiOut, LOW);
}
}
}
#endif
// Read characters from the control serial port and act upon them
if (Serial.available()) {
c = Serial.read();
switch (c) {
case '\n':
break;
case '\r':
// end the string and init pMsg
Serial.println("");
*(pMsg++) = NULL;
pMsg = msg;
// parse the command line statement and break it up into space-delimited
// strings. the array of strings will be saved in the argV array.
i = 0;
argV[i] = strtok(msg, " ");
do {
argV[++i] = strtok(NULL, " ");
} while ((i < ARGV_MAX) && (argV[i] != NULL));
// save off the number of arguments
argC = i;
pin = strtol(argV[1], NULL, 10);
if (strcasecmp(argV[0], "Set") == 0) {
cmdSet(argV);
} else if (strcasecmp(argV[0], "Reset") == 0) {
cmdReset();
} else if (strcasecmp(argV[0], "BlinkPin") == 0) {
cmdBlinkPin(argV);
} else if (strcasecmp(argV[0], "Read") == 0) {
cmdRead(argC, argV);
} else if (strcasecmp(argV[0], "Write") == 0) {
cmdWrite(argV);
} else if (strcasecmp(argV[0], "SetPwmFreq") == 0) {
cmdSetPwmFreq(argV);
#ifdef USE_PID
} else if (strcasecmp(argV[0], "PidRelayCreate") == 0) {
cmdPidRelayCreate(argV);
} else if (strcasecmp(argV[0], "PidRelaySet") == 0) {
cmdPidRelaySet(argV);
} else if (strcasecmp(argV[0], "PidRelayTune") == 0) {
cmdPidRelayTune(argV);
} else if (strcasecmp(argV[0], "PidRelayEnable") == 0) {
cmdPidRelayEnable(argV);
#endif
} else if (strcasecmp(argV[0], "HardSerConnect") == 0) {
cmdHardSerConnect(argV);
} else if (strcasecmp(argV[0], "SoftSerConnect") == 0) {
cmdSoftSerConnect(argV);
} else if (strcasecmp(argV[0], "SerSend") == 0) {
cmdSerSend(argV);
} else if (strcasecmp(argV[0], "SerReceive") == 0) {
cmdSerReceive(argV);
#ifdef USE_WIRE
} else if (strcasecmp(argV[0], "I2cWrite") == 0) {
cmdI2cWrite(argC, argV);
#endif
} else {
// Wrong command
return;
}
// Acknowledge the command
Serial.println(doneString);
break;
default:
// Record the received character
if (isprint(c) && pMsg < msg + sizeof(msg)) {
*(pMsg++) = c;
}
break;
}
}
}
int main(int argc, char **argv)
{
int option = 0; // For getopt temp option
usbDevice_t *dev;
ucp_cmd_t buffer; //room for dummy report ID
int err;
//Initialize globalArgs before we get to work
globalArgs.rFlag = 0; //False
globalArgs.iFlag = 0; //False
globalArgs.wFlag = 0; //False
globalArgs.fFlag = 0; //False
globalArgs.pFlag = 0; //False
globalArgs.hashFlag = 0; //False
globalArgs.kFlag = 0; //False
strncpy(globalArgs.pin,"0000",sizeof(globalArgs.pin)); //Default pin
globalArgs.offset = 0; //Default
globalArgs.size = 512; //Default
globalArgs.fileName = NULL;
globalArgs.file = NULL;
//Check if no arguments at all
if(argc==1) printUsage(argv[0]);
//If there's some argument, parse them
while((option = getopt(argc, argv, "rwif:o:p:Pk:s:h?")) !=-1){
//Check option flags
switch(option){
case 'r':
globalArgs.rFlag = 1; //True
break;
case 'w':
globalArgs.wFlag = 1; //True
break;
case 'i':
globalArgs.iFlag = 1; //True
break;
case 'f':
globalArgs.fFlag = 1; //True
globalArgs.fileName = optarg;
printf("File: %s\n",globalArgs.fileName);
break;
case 'o':
globalArgs.offset = atoi(optarg);
break;
case 'p':
globalArgs.pFlag = 1; //True
strncpy(globalArgs.pin,optarg, sizeof(globalArgs.pin));
break;
case 'P':
globalArgs.hashFlag=1; //True
break;
case 'k':
globalArgs.kFlag = 1; //True
globalArgs.keyboard = optarg;
printf("Keyboard: %s\n", globalArgs.keyboard);
case 's':
globalArgs.size = atoi(optarg);
break;
case 'h':
case '?':
printUsage(argv[0]);
break;
//Unknown flag, don't know what to do
default:
//After getopt prints the error
printUsage(argv[0]);
break;
}
}
//Check that only one action is done at a time
if(globalArgs.rFlag + globalArgs.wFlag + globalArgs.iFlag > 1) printUsage(argv[0]);
//Check that not set PIN and read HASH are given at a time
if(globalArgs.pFlag + globalArgs.hashFlag > 1) printUsage(argv[0]);
//Check that if write from file to device, we are given a file and a pin to encrypt!
if(globalArgs.wFlag && !globalArgs.fFlag) printUsage(argv[0]);
if(globalArgs.wFlag && !globalArgs.pFlag) printUsage(argv[0]);
//Also check pin for read flag
if(globalArgs.rFlag && !globalArgs.pFlag) printUsage(argv[0]);
//Try to open the device, exit if no device present.
if((dev = openDevice()) == NULL) exit(1);
//Clean the buffer before working with it
memset((void*)&buffer, 0, sizeof(buffer));
//Check and perform the desired commands
if(globalArgs.rFlag){ //READ COMMAND
buffer.cmd = UCP_CMD_READ;
deviceRead.offset = globalArgs.offset;
deviceRead.size = globalArgs.size;
memcpy((void*)&buffer.buff, (void*)&deviceRead, sizeof(deviceRead));
//give some feedback
fprintf(stderr,"Reading from the MemType: offset=%d bytes, size=%d bytes.\n",deviceRead.offset, deviceRead.size);
}else if(globalArgs.wFlag){ //WRITE COMMAND
buffer.cmd = UCP_CMD_WRITE;
deviceRead.offset = globalArgs.offset;
deviceRead.size = readXML(globalArgs.fileName);
memcpy((void*)&buffer.buff, (void*)&deviceRead, sizeof(deviceRead));
//give some feedback
fprintf(stderr,"Writing to the MemType: offset=%d bytes, size=%d bytes.\n",deviceRead.offset, deviceRead.size);
}else if(globalArgs.iFlag){ //INFO COMMAND
buffer.cmd = UCP_CMD_INFO;
}else if(globalArgs.hashFlag){ //READ PIN HASH COMMAND
buffer.cmd = UCP_CMD_READ_PIN;
}else if(globalArgs.pFlag){ //SET PIN COMMAND
buffer.cmd = UCP_CMD_SET_PIN;
buffer.buff[0] = 16; //sizeof hash in bytes
}else if(globalArgs.kFlag){
buffer.cmd = UCP_CMD_KEYBOARD;
}
//Add a dummy report ID and send data to device
buffer.reportid = 2;
if((err = usbhidSetReport(dev, (char*)&buffer, sizeof(buffer))) != 0)
fprintf(stderr, "Error sending data to device: %s\n", usbErrorMessage(err));
//Read back report
int len = sizeof(buffer);
if((err = usbhidGetReport(dev, 2, (char*)&buffer, &len)) != 0)
{ //... if not OK, print error
fprintf(stderr, "Error reading data from device: %s\n", usbErrorMessage(err));
}
else //... if OK, do things :)
{
fprintf( stderr, "\nMemType CMD Response: ");
hexdump( (void*)&buffer.cmd, sizeof(buffer.cmd)+sizeof(buffer.buff));
fprintf( stderr, "Received data from the device: \n");
switch(buffer.cmd)
{
case UCP_CMD_RESET:
fprintf( stderr, "RESET\n");
break;
case UCP_CMD_READ:
fprintf( stderr, "READ\n");
cmdRead(dev, deviceRead.size);
break;
case UCP_CMD_WRITE:
fprintf( stderr, "WRITE\n");
cmdWrite(dev, flashMemory, deviceRead.size);
fprintf(stderr, "[ENCRYPTION TEST] only hexdump");
break;
case UCP_CMD_SET_PIN:
fprintf(stderr, "SET PIN\n");
cmdSetPin(dev);
break;
case UCP_CMD_READ_PIN:
fprintf(stderr, "READ PIN HASH\n");
cmdReadPinHash(dev);
break;
case UCP_CMD_KEYBOARD:
fprintf(stderr, "KEYBOARD\n");
cmdKeyboard(dev);
break;
case UCP_CMD_DATA:
fprintf( stderr, "DATA\n");
break;
case UCP_CMD_INFO:
fprintf( stderr, "sizeof(info) -> %lu\n", sizeof(deviceInfo));
memcpy((void*)&deviceInfo, (void*)buffer.buff, sizeof(deviceInfo));
/* Call info */
cmdInfo(&deviceInfo);
break;
case UCP_CMD_ERROR: //Wait! the device returned one error!
switch( (unsigned char) buffer.buff[0] )
{
case UCP_ERR:
fprintf( stderr, "GENERIC ERROR\n");
break;
case UCP_ERR_PACKET:
fprintf( stderr, "PACKET ERROR\n");
break;
case UCP_ERR_CMD:
fprintf( stderr, "CMD ERROR\n");
break;
case UCP_ERR_ADDR:
fprintf( stderr, "ADDR ERROR\n");
break;
case UCP_ERR_SIZE:
fprintf( stderr, "SIZE ERRROR\n");
break;
case UCP_ERR_PROTOCOL:
fprintf( stderr, "PROTOCOL ERROR\n");
break;
case UCP_ERR_LOCKED:
fprintf( stderr, "DEVICE LOCKED ERROR\n");
break;
default:
fprintf( stderr, "UNKNOWN ERROR\n");
}
break;
default:
fprintf( stderr, "UNKNOWN CMD ERROR\n");
}
}
usbhidCloseDevice(dev);
return 0;
}
inline int parseQueryCmd(int type) {
unsigned long events;
switch(cmdRead()) {
case 'C':
switch(cmdRead()) {
case 'M':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '+':
// READ "Continuous monitor"
ShowValueU(d_displayTime);
goto pqc_ok;
case '=':
// WRITE "Continuous monitor"
cmdRead();
ReadValueU(d_displayTime);
goto pqc_ok;
}
goto pqc_error;
}
goto pqc_error;
case 'E':
switch(cmdRead()) {
case 'R':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '+':
// READ "Event register"
events = d_pendingEvents[EVENT_CLASS_GPS];
events <<= 8;
events |= d_pendingEvents[EVENT_CLASS_ODO];
snprintf(d_outBuff, OUTPUT_BUFFER_SIZE, "%lu 0x%02X%02X",
events,
d_pendingEvents[EVENT_CLASS_GPS],
d_pendingEvents[EVENT_CLASS_ODO]);
// Serial_printLine(d_outBuff);
Serial_printValue(d_outBuff);
// Resetting pending event
d_pendingEvents[EVENT_CLASS_GPS] = EVENT_NONE;
d_pendingEvents[EVENT_CLASS_ODO] = EVENT_NONE;
// Releasgin interrupt pin
pinMode(intReq, INPUT);
goto pqc_ok;
}
goto pqc_error;
}
goto pqc_error;
case 'I':
switch(cmdRead()) {
case 'T':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '+':
// READ "Interrupt timeout"
ShowValueU(d_intrTimeout);
goto pqc_ok;
case '=':
// WRITE "Interrupt timeout"
cmdRead();
ReadValueU(d_intrTimeout);
goto pqc_ok;
}
goto pqc_error;
}
goto pqc_error;
}
pqc_error:
return ERROR;
pqc_ok:
return OK;
}
inline int parseGpsCmd(int type) {
switch(cmdRead()) {
case 'F':
switch(cmdRead()) {
case 'V':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '+':
// READ "Fix value"
ShowValueU(gpsFix());
goto pgc_ok;
}
goto pgc_error;
}
goto pgc_error;
case 'G':
switch(cmdRead()) {
case 'S':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '+':
// READ "Ground speed"
ShowValueD(gpsSpeed());
goto pgc_ok;
}
goto pgc_error;
}
goto pgc_error;
case 'H':
switch(cmdRead()) {
case 'P':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '+':
// READ "HDOP"
ShowValueD(gpsHdop());
goto pgc_ok;
}
goto pgc_error;
}
goto pgc_error;
case 'L':
switch(cmdRead()) {
case 'A':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '+':
// READ "Lat"
if (gpsIsPosValid()) {
ShowValueD(gpsLat());
} else
Serial_printStr("NA ");
goto pgc_ok;
}
goto pgc_error;
case 'O':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '+':
// READ "Lon"
if (gpsIsPosValid()) {
ShowValueD(gpsLon());
} else
Serial_printStr("NA ");
goto pgc_ok;
}
goto pgc_error;
}
goto pgc_error;
case 'P':
switch(cmdRead()) {
case 'S':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '+':
// READ "Power State"
ShowValueU(d_gpsPowerState);
goto pgc_ok;
case '=':
// WRITE "Power State"
cmdRead();
ReadValueU(d_gpsPowerState);
goto pgc_ok;
}
goto pgc_error;
}
goto pgc_error;
case 'S':
switch(cmdRead()) {
case 'C':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '=': // WRITE "GPS Command"
cmdRead();
ReadValueUL(d_gpsNextCmd);
goto pgc_ok;
}
goto pgc_error;
}
goto pgc_error;
case 'T':
switch(cmdRead()) {
case 'D':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '+':
// READ "Track Degree"
ShowValueD(gpsDegree());
goto pgc_ok;
}
goto pgc_error;
}
goto pgc_error;
}
pgc_error:
return ERROR;
pgc_ok:
return OK;
}
inline int parseAlarmCmd(int type) {
switch(cmdRead()) {
case 'E':
switch(cmdRead()) {
case 'B':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '+':
// READ "Emergency Break"
ShowValueUL(d_minEmergencyBreak);
goto pac_ok;
case '=':
// WRITE "Emergency Break"
cmdRead();
ReadValueUL(d_minEmergencyBreak);
goto pac_ok;
}
goto pac_error;
}
goto pac_error;
case 'P':
switch(cmdRead()) {
case 'C':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '+':
// READ "Pulse Count Interrupt"
ShowValueU(d_distIntrPCount);
goto pac_ok;
case '=': // WRITE "Pulse Count Interrupt"
cmdRead();
ReadValueU(d_distIntrPCount);
d_distIntrNext = d_pcount+d_distIntrPCount;
goto pac_ok;
}
goto pac_error;
}
goto pac_error;
case 'S':
switch(cmdRead()) {
case 'L':
switch(cmdLook()) {
case LINE_TERMINATOR:
cmdRead();
case '+':
// READ "Speed Limit"
ShowValueUL(d_minOverSpeed);
goto pac_ok;
case '=': // WRITE "Speed Limit"
cmdRead();
ReadValueUL(d_minOverSpeed);
goto pac_ok;
}
goto pac_error;
}
goto pac_error;
}
pac_error:
return ERROR;
pac_ok:
return OK;
}
