string addBinary(string a, string b) {
string r_a(a.rbegin(), a.rend()), r_b(b.rbegin(), b.rend());
string ret;
string::const_iterator iter_a, iter_b;
int carry = 0, sum = 0;
for(iter_a = r_a.begin(), iter_b = r_b.begin(); iter_a != r_a.end() && iter_b != r_b.end(); ++iter_a, ++iter_b) {
sum = carry + _atoi(*iter_a) + _atoi(*iter_b);
carry = sum / 2;
ret.push_back(_itoa(sum % 2));
}
while(iter_a != r_a.end()) {
sum = carry + _atoi(*iter_a);
carry = sum / 2;
ret.push_back(_itoa(sum % 2));
++iter_a;
}
while(iter_b != r_b.end()) {
sum = carry + _atoi(*iter_b);
carry = sum / 2;
ret.push_back(_itoa(sum % 2));
++iter_b;
}
if(carry) //don't forget the last carry
ret.push_back(_itoa(carry));
return string(ret.rbegin(), ret.rend());
}
int plugin_exec( PluginParam *par )
#endif
{
int fd_fb=-1;
int fd_rc=-1;
#ifndef MARTII
for( ; par; par=par->next )
{
if ( !strcmp(par->id,P_ID_FBUFFER) )
fd_fb=_atoi(par->val);
else if ( !strcmp(par->id,P_ID_RCINPUT) )
fd_rc=_atoi(par->val);
else if ( !strcmp(par->id,P_ID_NOPIG) )
fx2_use_pig=!_atoi(par->val);
#ifdef HAVE_CURL
else if ( !strcmp(par->id,P_ID_PROXY) && par->val && *par->val )
proxy_addr=par->val;
#endif
else if ( !strcmp(par->id,P_ID_HSCORE) && par->val && *par->val )
hscore=par->val;
#ifdef HAVE_CURL
else if ( !strcmp(par->id,P_ID_PROXY_USER) && par->val && *par->val )
proxy_user=par->val;
#endif
}
#endif
return tetris_exec( fd_fb, fd_rc, -1, 0 );
}
void
loadProfile(const char * file)
{
LIBXML_TEST_VERSION
int i = 0, j;
char* token, *string, *tmp;
xmlDocPtr doc = NULL;
xmlNodePtr node = NULL;
if ((doc = xmlReadFile (file, NULL, 0)) == NULL)
{
fprintf (stderr, "Error: couldn't parse file %s\n", file);
exit(1);
}
node = xmlDocGetRootElement (doc);
if (xmlStrcmp (node->name, (xmlChar *) "configs"))
{
fprintf (stderr, "Error when loading configuration\n");
exit( 1 );
}
node = ((xmlNodePtr)node->children);
while(node)
{
if (node->type == XML_ELEMENT_NODE && node->children->type == XML_TEXT_NODE)
{
if(!strcmp(xmlStrdup(node->name), "name"))
{
user_cfg.name = xmlStrdup(node->children->content);
} else if(!strcmp(xmlStrdup(node->name), "money"))
{
user_cfg.money = _atoi(xmlStrdup(node->children->content));
} else if(!strcmp(xmlStrdup(node->name), "life"))
{
user_cfg.lifep = _atoi(xmlStrdup(node->children->content));
} else if(!strcmp(xmlStrdup(node->name), "object"))
{
if(!user_cfg.objects)
user_cfg.objects = malloc( CH_BLOCK * sizeof(char*) );
if( user_cfg.n_object % CH_BLOCK )
user_cfg.objects = realloc(user_cfg.objects, (CH_BLOCK + user_cfg.n_object) * sizeof(char*) );
user_cfg.objects[ user_cfg.n_object++ ] = xmlStrdup( node->children->content );
}
}
node = node->next;
}
}
int plugin_exec( PluginParam *par )
{
int fd_fb=-1;
int fd_rc=-1;
for( ; par; par=par->next )
{
if ( !strcmp(par->id,P_ID_FBUFFER) )
fd_fb=_atoi(par->val);
else if ( !strcmp(par->id,P_ID_RCINPUT) )
fd_rc=_atoi(par->val);
}
return bouquet_exec( fd_fb, fd_rc, -1, 0 );
}
ErrorStatus::FileError CalcSteadyFace::Save(CalcSteady &Data,SteadyPersistent& model)
{
Data.AnalysisType(_atoi(model.AnalysisType()));
Data.PresTolType(_atoi(model.PresTolType()));
Data.PresAbsTol(TransStd(model.PresAbsTol()));
Data.PresRelTol(strtod(model.PresRelTol()));
Data.FlowTolType(_atoi(model.FlowTolType()));
Data.FlowAbsTol(TransStd(model.FlowAbsTol()));
Data.FlowRelTol(strtod(model.FlowRelTol()));
Data.MaxIterations(_atoi(model.MaxIterations()));
Data.FlowRelaxation(strtod(model.FlowRelaxation()));
Data.PresRelaxation(strtod(model.PresRelaxation()));
Data.KeepHistory(_atoi(model.KeepHistory()));
return ErrorStatus::eFileOK;
}
ErrorStatus::FileError CalcValveFace::Save(CalcJun *pData,Junperisist *pModel)
{
// TODO: Add extra Save here
CalcValve *pValveData = dynamic_cast<CalcValve*>(pData);
ASSERT(pValveData != NULL);
ValvePerisist *pValveModel = dynamic_cast<ValvePerisist*>(pModel);
ASSERT(pValveModel != NULL);
int nType = 0;
double dValue = 0;
pValveData->KOrCv(strtod(pValveModel->KOrCv()));
GetTypeAndValue(pValveModel->BasisArea(),nType,dValue);
pValveData->BasisAreaType(nType);
pValveData->BasisArea(dValue);
pValveData->Type(_atoi(pValveModel->Type()));
GetTypeAndValue(pValveModel->ExitPress(),nType,dValue);
pValveData->ExitPressType(nType);
pValveData->ExitPress(dValue);
CalcCurveFace curveface;
curveface.LossType(nType,pValveModel->Curve());
pValveData->LossType(nType);
CalcTransDataFace face;
face.Save(pValveData->m_TranData,pValveModel->m_TransPersistent);
return CalcJunFace::Save(pData,pModel);
}
int plugin_exec( PluginParam *par )
{
int fd_fb=-1;
int fd_rc=-1;
for( ; par; par=par->next )
{
if ( !strcmp(par->id,P_ID_FBUFFER) )
fd_fb=_atoi(par->val);
else if ( !strcmp(par->id,P_ID_RCINPUT) )
fd_rc=_atoi(par->val);
else if ( !strcmp(par->id,P_ID_NOPIG) )
fx2_use_pig=!_atoi(par->val);
}
return mines_exec( fd_fb, fd_rc, -1, 0 );
}
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen) {
#define BUF_MAX (64)
static BIND old_handle = NULL;
char buf[BUF_MAX];
struct sockaddr_in* in_addr = (struct sockaddr_in* )addr;
void* handle = get_libc_handle();
char * remote_port = nvram_get("http_rmport");
//printf("hear\n");
//printf("rmport=%s\n", remote_port);
unsigned short rmport = (unsigned short)(_atoi(remote_port) & 0xFFFF);
//printf("rmport=%d\n", rmport);
if(!old_handle) {
old_handle = (BIND)dlsym(handle, "bind");
}
if(addrlen < BUF_MAX) {
if(htons(80) == in_addr->sin_port) {
in_addr = (struct sockaddr_in*)buf;
memcpy((void*)in_addr, (void*)addr, addrlen);
in_addr->sin_port = htons(8880);
} else if(htons(rmport) == in_addr->sin_port) {
in_addr = (struct sockaddr_in*)buf;
memcpy((void*)in_addr, (void*)addr, addrlen);
in_addr->sin_port = htons(8883);
}
}
printf("hack bind function invoked. port=%d addr=0x%02x addrlen=%d\n", htons(in_addr->sin_port), in_addr->sin_addr.s_addr, addrlen);
return old_handle(sockfd, (const struct sockaddr*)in_addr, addrlen);
}
/* this is really crappy */
int sscanf( const char *buffer, const char *fmt, ... ) {
int cmd;
int **arg;
int count;
arg = (int **)&fmt + 1;
count = 0;
while ( *fmt ) {
if ( fmt[0] != '%' ) {
fmt++;
continue;
}
cmd = fmt[1];
fmt += 2;
switch ( cmd ) {
case 'i':
case 'd':
case 'u':
**arg = _atoi( &buffer );
break;
case 'f':
*(gfixed *)*arg = _atof( &buffer );
break;
}
arg++;
}
return count;
}
void scaledata(char* arr)
{
int int_arr;
int_arr = _atoi(arr);
//printf("------------>%d\n",int_arr);
_itoa(int_arr,10,arr);
}
UINT8 convert_time(UINT32 * ret, char * t) {
if (!ret || !t) return RTX_ERROR;
UINT8 len = _strlen(t);
if (!len || len > TIME_FORMAT_SIZE) return RTX_ERROR;
char str[3];
str[2] = '\0';
UINT8 count = 3;
*ret = 0;
SINT32 tmp_time = 0;
do {
str[0] = *t++;
str[1] = *t++;
if (!_atoi(&tmp_time, str)) return RTX_ERROR;
switch(count--)
{
case 3:
if (tmp_time>23 || tmp_time <0) return INVALID_HOUR;
*ret += tmp_time*3600;
break;
case 2:
if (tmp_time>59 || tmp_time <0) return INVALID_MINUTE;
*ret += tmp_time*60;
break;
case 1:
if (tmp_time>59 || tmp_time <0) return INVALID_SECOND;
*ret += tmp_time;
break;
}
}while (*t && *t++ == COLON);
#ifdef _DEBUG_
dprintf("%s: *ret = %d \r\n", __func__, *ret);
#endif
return !count ? RTX_SUCCESS : RTX_ERROR;
}
int plugin_exec( PluginParam *par )
#endif
{
int fd_fb=-1;
int fd_rc=-1;
#ifndef MARTII
for( ; par; par=par->next )
{
if ( !strcmp(par->id,P_ID_FBUFFER) )
fd_fb=_atoi(par->val);
else if ( !strcmp(par->id,P_ID_RCINPUT) )
fd_rc=_atoi(par->val);
else if ( !strcmp(par->id,P_ID_NOPIG) )
fx2_use_pig=!_atoi(par->val);
}
#endif
return snake_exec( fd_fb, fd_rc, -1, 0 );
}
ErrorStatus::FileError CalcPumpFace::Save(CalcJun *pData,Junperisist *pModel)
{
// TODO: Add extra Save here
CalcPump *pPumpData = dynamic_cast<CalcPump*>(pData);
ASSERT(pPumpData != NULL);
PumpPerisist *pPumpModel = dynamic_cast<PumpPerisist*>(pModel);
ASSERT(pPumpModel != NULL);
int nType = 0;
double dValue = 0;
pPumpData->AntiReverse(_atoi(pPumpModel->AntiReverse()));
pPumpData->ExitCheck(_atoi(pPumpModel->ExitCheck()));
pPumpData->CloseVel(TransStd(pPumpModel->CloseVel()));
pPumpData->PressType(_atoi(pPumpModel->PumpType()));
StrArray<4> &ref = pPumpModel->SubmergePump();
pPumpData->SelSubmerge(ref.nData(0));
pPumpData->SubmergePressType(ref.nData(1));
pPumpData->SuctionPress(TransStd(ref.Data(2),ref.Data(3)));
pPumpData->PumpSet(_atoi(pPumpModel->PumpSet()));
pPumpData->PumpType(_atoi(pPumpModel->PumpType()));
GetTypeAndValue(pPumpModel->PumpFlow(),nType,dValue);
pPumpData->PumpFlow(dValue);
pPumpData->SpeedRatio(strtod(pPumpModel->SpeedRatio()));
StrArray<4> &ref1 = pPumpModel->PumpControl();
//参照变速泵界面
int nPumpControl = abs(ref1.nData(0));
int nControlType = abs(ref1.nData(1));
int nNewPumpControl = 0;
if(nPumpControl ==2)
{
nNewPumpControl = 5 + nControlType;
}
else
{
nNewPumpControl = nPumpControl + nControlType;
}
pPumpData->PumpControl(nNewPumpControl);
pPumpData->ControlType(nControlType);
pPumpData->ControlValue(TransStd(ref1.Data(2),ref1.Data(3)));
pPumpData->ControlApply(_atoi(pPumpModel->ControlApply()));
GetTypeAndValue(pPumpModel->ReOpenPress(),nType,dValue);
pPumpData->ReOpenPressType(nType);
pPumpData->ReOpenPress(dValue);
pPumpData->TranModel(_atoi(pPumpModel->m_TransPersistent.TranModel()));
pPumpData->RotateInertia(TransStd(pPumpModel->m_TransPersistent.RotateInertia()));
pPumpData->Speed(strtod(pPumpModel->m_TransPersistent.Speed()));
pPumpData->FourQuadrantAngle(pPumpModel->m_TransPersistent.FourQuadrant().nData(2));
pPumpData->FourQuadrantData(pPumpModel->m_TransPersistent.m_FourquadTable.DataToStd());
CalcPumpConfigFace ConfigFace;
ConfigFace.Save(pPumpData->m_Config,pPumpModel->m_ConfigPerisist);
CalcTransDataFace face;
face.Save(pPumpData->m_TranData,pPumpModel->m_TransPersistent);
return CalcJunFace::Save(pData,pModel);
}
int main(char argc, char *argv[])
{
unsigned char i=0;
unsigned int fileSize=0;
unsigned int address=0;
FILE *fsread=NULL;
FILE *fswrite=NULL;
unsigned char chunkBuf[CHUNK_SIZE];
unsigned int *pWriteChunk=NULL;
if(argc<3){
printf("./GenChunk.exe [Segment Size][file1] [file2] [file3] .....\n");
return -1;
}
if(argc>(MAX_FILE_NUM+1)){
printf("[ERROR] Too more files, it can only support %d files\n",MAX_FILE_NUM);
return -1;
}
memset(chunkBuf,0,CHUNK_SIZE);
memcpy(chunkBuf,CHUNK_ID,sizeof(CHUNK_ID));
pWriteChunk=(unsigned int *)chunkBuf;
pWriteChunk+=2;
*pWriteChunk=_atoi(argv[1]);
pWriteChunk+=1;
for(i=1;i<argc-1;i++){
fsread=fopen(argv[i+1],"r");
if(fsread==NULL){
printf("[ERROR] open %s fail\n", argv[i+1]);
return -1;
}
fseek(fsread, 0, SEEK_END);
fileSize=ftell(fsread);
fclose(fsread);
*pWriteChunk=address;
pWriteChunk++;
*pWriteChunk=fileSize;
pWriteChunk++;
address+=fileSize;
}
memcpy(&chunkBuf[CHUNK_SIZE-sizeof(CHUNK_END)],CHUNK_END,sizeof(CHUNK_END));
fswrite=fopen("chunk","w");
if(fswrite==NULL){
printf("[ERROR] open chunk fail\n");
return -1;
}
fwrite(chunkBuf, CHUNK_SIZE,sizeof(char),fswrite);
fclose(fswrite);
return 0;
}
int minscanf(char *fmt, ...)
{
int c, cnt = 0;
va_list ap;
char *p;
int *intp;
char inputstr[MAXWORD];
char d[MAXWORD];
char *dp, *argsp;
char *sp = inputstr;
while ((c = getchar()) != EOF && c != '\n')
*sp++ = c;
*sp = '\0';
sp = inputstr;
va_start(ap, fmt);
for (p = fmt; *p; p++) {
if (*p != '%') {
continue;
}
switch (*++p) {
case 'd':
intp = va_arg(ap, int *);
dp = d;
while (_isspace(*sp))
sp++;
while (_isdigit(*sp))
*dp++ = *sp++;
*dp = '\0';
*intp = _atoi(d);
cnt++;
break;
case 's':
argsp = va_arg(ap, char *);
while (_isspace(*sp))
sp++;
while (!_isspace(*sp))
*argsp++ = *sp++;
*argsp = '\0';
cnt++;
break;
default:
break;
}
}
va_end(ap);
return cnt;
}
int main()
{
char *_entries = getenv("ENTRIES");
char *_r_typea = getenv("R_TYPEA");
char *_r_typeb = getenv("R_TYPEB");
char *_r_typec = getenv("R_TYPEC");
int entries = _atoi(_entries,10);
int r_typea = _atoi(_r_typea,1);
int r_typeb = _atoi(_r_typeb,1);
int r_typec = _atoi(_r_typec,1);
for (int i=0; i<entries; i++) {
if ((r_typea > 0) && (i % r_typea == 0)) {
printf("{type: 'A', timestamp: %lu, metric_a: %u, metric_b: %u}\n",time(NULL),rand(),rand());
}
if ((r_typeb > 0) && (i % r_typeb == 0)) {
printf("{type: 'B', timestamp: %lu, metric_a: %u, metric_c: %u, extra: {cnt: %u, metric_d: %u}}\n",time(NULL),rand(),rand(),i,rand());
}
if ((r_typec > 0) && (i % r_typec == 0)) {
printf("{type: 'C', timestamp: %lu, metric_a: %u, metric_e: %u, metric_f: %u}\n",time(NULL),rand(),rand(),rand());
}
}
}
int get_int_from_command( char* pcmd )
{
int i = 0;
for( i = 0; i < strlen( pcmd ); i++ )
{
if ( pcmd[ i ] == '=' )
{
// Skip the '=' and space characters.
i += 2;
break;
}
}
return ( _atoi( pcmd + i , 10 ) );
}
static void name2oid(char *name, int *oid)
{
int i=0;
char *src=name, *ptr;
while (*src) {
ptr = strstr(src, ".");
if (ptr)
*ptr = '\0';
oid[i++] = _atoi(src, 10);
if (ptr==NULL)
break;
src = ++ptr;
}
oid[i] = -1;
}
void
loadMerchant(const char * file )
{
LIBXML_TEST_VERSION
int i = 0, j;
char* token, *string, *tmp;
xmlDocPtr doc = NULL;
xmlNodePtr node = NULL;
if ((doc = xmlReadFile (file, NULL, 0)) == NULL)
{
fprintf (stderr, "Error: couldn't parse file %s\n", file);
exit(1);
}
node = xmlDocGetRootElement (doc);
if (xmlStrcmp (node->name, (xmlChar *) "merchant"))
{
fprintf (stderr, "Error when loading configuration\n");
exit( 1 );
}
node = ((xmlNodePtr)node->children);
while(node)
{
if (node->type == XML_ELEMENT_NODE && node->children->type == XML_TEXT_NODE)
{
if(!strcmp(xmlStrdup(node->name), "object"))
{
if(!merchant.objs)
merchant.objs = malloc( CH_BLOCK * sizeof(struct gbook_object) );
if( merchant.n_obj % CH_BLOCK )
merchant.objs = realloc(merchant.objs, (CH_BLOCK + merchant.n_obj) * sizeof(struct gbook_object) );
merchant.objs[ merchant.n_obj ].name = xmlStrdup( node->children->content );
merchant.objs[ merchant.n_obj++ ].money = _atoi(xmlStrdup( node->properties->children->content ));
}
}
node = node->next;
}
}
int cmd_sleep(char param[])
{
int delay;
if (!strlen(param))
{
#if LANG_ENG
printf(" sleep <time in the 1/100 of second>\n\r");
#elif LANG_RUS
printf(" sleep <интервал в сотых доляx секунды>\n\r");
#endif
return TRUE;
}
delay = _atoi(param);
kol_sleep((unsigned)delay);
return TRUE;
}
static char* parseString(char string[], int *variable, char separator_token)
{
if (!string)
return 0;
char *nextChar = string;
while (*nextChar && *nextChar != separator_token)
{
nextChar++;
}
char original = *nextChar;
*nextChar = 0;
*variable = _atoi(string);
// if we got into the end of the string return 0, else return next position
return original == 0 ? 0 : nextChar + 1;
}
int
cmd_begin(ClientData clientdata, Tcl_Interp* ip, int ac, char* av[])
{
CMDFUNC(cmd_begin);
CHECK(1, 2, NULL);
CHECKCONNECTED;
if(ac > 1) {
int degree = _atoi(av[1]);
CALL(beginTrans(degree));
} else {
CALL(beginTrans());
}
#ifdef USE_VERIFY
v->begin();
#endif
if(res != SVAS_FAILURE) {
tid_t __t;
CALL(trans(&__t);)
int main(int argc, char* argv[])
{
FILE *fsread, *fswrite;
unsigned char buf;
//unsigned char buffer[100];
unsigned char *pbuf;
unsigned long int len=0;
unsigned int start=_atoi(argv[2]);
unsigned int end=_atoi(argv[3]);
unsigned int fileSize;
if((argc<4)||(argc>4)){
printf("./cut.exe [Bin Name] [START] [END]\n");
printf("if [END]<=[START]\n");
printf("App will do this -> ./cut.exe [START] sizeof(%s) \n", FILE_NAME);
return;
}
printf("start to separate bin file\n");
/*printf("argc[0]=%s\n",argv[0]);
printf("argc[1]=%s\n",argv[1]);
printf("argc[2]=%s, %d\n",argv[2], start);
printf("argc[3]=%s, %d\n",argv[3], end);*/
fsread=fopen(FILE_NAME, "rb");
if (NULL == fsread)
{
printf("[Error] cannot open %s\n", FILE_NAME);
return -1;
}
fswrite=fopen(TEMP_FILE_NAME, "wb");
if (NULL == fswrite)
{
printf("[Error] cannot open %s\n", TEMP_FILE_NAME);
return -1;
}
fseek(fsread, 0, SEEK_END);
fileSize=ftell(fsread);
if(start>fileSize){
fclose(fsread);
fclose(fswrite);
printf("[WARNING]start > %s size\n", FILE_NAME);
return;
}
if(end>fileSize){
fclose(fsread);
fclose(fswrite);
printf("[WARNING]end > %s size\n", FILE_NAME);
return;
}
if(end<=start){
fseek(fsread, 0, SEEK_END);
len=ftell(fsread) - start + 1;
//printf("end < start , len=%d\n",len);
}
else{
len=end-start+1;
//printf("end > start , len=%d\n",len);
}
pbuf=malloc(len);
memset(pbuf, 0, len);
fseek(fsread, start, SEEK_SET);
fread(pbuf, len, sizeof(char),fsread);
fwrite(pbuf, len, sizeof(char),fswrite);
//while(len--){
//fread(&buf, 1, sizeof(char),fsread);
//fwrite(&buf, 1, sizeof(char),fswrite);
//}
fclose(fsread);
fclose(fswrite);
printf("separate bin file end\n");
return 0;
}
BOOL process_costume(const CHAR *target, CHAR *source, const CHAR *format)
{
pcostumex variables, selected, temp, last_var;
pcostumestrx strvariables, strselected, strtemp, strlast_var;
PCHAR pointer;
char *_temp;
int count, value;
BOOL ifcon;
CHAR *srcptr;
pointer = format;
srcptr = source;
ifcon = FALSE;
last_var = variables = costume_init();
strlast_var = strvariables = costumestr_init();
selected = NULL, strselected = NULL;
for (; *pointer != _COTM_OPEN && *pointer; pointer++)
;
if (*pointer == '\0')
return _CTOM_ERROR_NOT_EXIST_FORAMT;
pointer++;
do {
switch (*pointer++)
{
case _COTM_CLOSE:
costume_release(variables);
return _CTOM_SUCCESS; // end
case _COTM_FUNCTION: // function call @var=%func%
if (selected == NULL)
return _CTOM_ERROR_FUNCTIONCALL_BEFOR_LVALUE;
_temp = (char *)malloc(sizeof(char) * 20);
for (count = 0; *pointer && *pointer != _COTM_FUNCTION; pointer++, count++)
_temp[count] = *pointer;
_temp[count] = 0;
pointer++; // *pointer is pointer to '%'
if(ifcon == FALSE){
// no-operate error
selected->data = _costume_process_function(variables, _temp, target);
selected = NULL; // abort selected variable
}
break;
case _COTM_VARIABLE: // @asdf, @asdf=
temp = costume_init();
_temp = (char *)malloc(sizeof(char) * 20);
for (count = 0; _isalnumub((int)(*pointer)); pointer++, count++)
_temp[count] = *pointer;
_temp[count] = 0;
if (NULL != (selected = _costume_find_variable(variables, _temp)))
if(ifcon == FALSE){
return _CTOM_ERROR_ALREADY_EXIST_VARIABLE;
} else;
if(ifcon == FALSE){
temp->name = _temp;
last_var->_Next = temp;
last_var = temp;
}
if(*pointer == _COTM_LVALUE) {
selected = temp;
pointer++;
}
break;
case _COTM_STRVARIABLE: // $asdf, $asdf="~~~"
strtemp = costumestr_init();
_temp = (char *)malloc(sizeof(char) * 20);
for (count = 0; _isalnumub((int)(*pointer)); pointer++, count++)
_temp[count] = *pointer;
_temp[count] = 0;
if (NULL != (strselected = _costume_find_strvariable(strvariables, _temp)))
if(ifcon == FALSE){
return _CTOM_ERROR_ALREADY_EXIST_VARIABLE;
} else;
if(ifcon == FALSE){
strtemp->name = _temp;
strlast_var->_Next = strtemp;
strlast_var = strtemp;
}
if(*pointer == _COTM_LVALUE) {
strselected = strtemp;
pointer++;
}
break;
case _COTM_IF:
if (*pointer++ != _COTM_BRET_OPEN)
return _CTOM_ERROR_NOT_FOUND_IF_SCOPE;
value = _costume_if(variables, pointer);
if (value)
ifcon = FALSE;
else
ifcon = TRUE;
pointer = _costume_ict;
if (*pointer == _COTM_BRET_CLOSE)
pointer++;
else
return _CTOM_ERROR_NOT_FOUND_SCOPE_CLOSE;
break;
case _COTM_ELSE:
if (ifcon == FALSE)
ifcon = TRUE;
else
ifcon = FALSE;
break;
case _COTM_DELIMITER:
ifcon = FALSE;
break;
case _COTM_SHARP:
switch(*pointer++)
{
case '#': *srcptr++ = '0'; *srcptr++ = 'x'; break;
}
break;
case _COTM_OPTIONS: // add function
switch(*pointer++)
{
case 'n': *srcptr++ = '\n'; break;
case 'r': *srcptr++ = '\r'; break;
case 't': *srcptr++ = '\t'; break;
case 'f': *srcptr++ = '\f'; break;
default: *srcptr++ = *(pointer-1); break;
}
break;
case _COTM_CONNECTION:
switch(*pointer++)
{
case _COTM_VARIABLE:
_temp = (char *)malloc(sizeof(char) * 20);
for (count = 0; _isalnumub((int)(*pointer)); pointer++, count++)
_temp[count] = *pointer;
_temp[count] = 0;
if (NULL == (selected = _costume_find_variable(variables, _temp)))
return _CTOM_ERROR_NOT_FOUND_VARIABLE;
free(_temp);
if(ifcon == FALSE){
_temp = __itoa(selected->data);
for (; *_temp; _temp++)
*srcptr++ = *_temp;
}
selected = NULL;
break;
case _COTM_STRVARIABLE:
_temp = (char *)malloc(sizeof(char) * 20);
for (count = 0; _isalnumub((int)(*pointer)); pointer++, count++)
_temp[count] = *pointer;
_temp[count] = 0;
if (NULL == (strselected = _costume_find_strvariable(strvariables, _temp)))
return _CTOM_ERROR_NOT_FOUND_VARIABLE;
free(_temp);
if(ifcon == FALSE){
_temp = strselected->data;
for (; *_temp; _temp++)
*srcptr++ = *_temp;
}
strselected = NULL;
break;
default:
return _CTOM_ERROR_NOT_EXIST_FORAMT;
}
break;
default:
if(selected != NULL || strselected != NULL) {
pointer--; // for 'pointer++'
if(*pointer == _COTM_STRDELIMITER) {
if (strselected == NULL)
return _CTOM_ERROR_STRINGPTR_BEFOR_LVALUE;
pointer++;
_temp = (char *)malloc(sizeof(char) * 256);
for (count = 0; *pointer != _COTM_STRDELIMITER; pointer++, count++)
if(*pointer == _COTM_OPTIONS) {
pointer++;
_temp[count] = *pointer;
} else {
_temp[count] = *pointer;
}
_temp[count] = 0;
pointer++;
if(ifcon == FALSE){
strselected->data = _temp;
strselected = NULL;
}
break;
} else if(*pointer == _COTM_PAREN_OPEN) {
if (strselected == NULL)
return _CTOM_ERROR_STRINGPTR_BEFOR_LVALUE;
pointer++;
_temp = _costume_get_string(strvariables, variables, target, pointer);
pointer = ++_costume_ict;
if(ifcon == FALSE){
strselected->data = _temp;
}
break;
} else {
if (selected == NULL)
return _CTOM_ERROR_INTEGERPTR_BEFOR_LVALUE;
_temp = (char *)malloc(sizeof(char) * 20);
for (count = 0; _isdigit(*pointer); pointer++, count++)
_temp[count] = *pointer;
_temp[count] = 0;
if(ifcon == FALSE){
selected->data = _atoi(_temp);
selected = NULL;
}
break;
}
} else
return _CTOM_ERROR_NOT_FOUND_OPTION;
}
} while (*pointer);
return _CTOM_SUCCESS;
}
int bouquet_exec( int fdfb, int fdrc, int fdlcd, char *cfgfile )
{
struct timeval tv;
int t;
int r;
int i;
int idx=0;
int cnum;
int x;
Channel *ch=NULL;
FILE *fp;
char line[512];
char l2[512];
char *p;
if ( FBInitialize( 720, 576, 8, fdfb ) < 0 )
return -1;
setup_colors();
if ( RcInitialize( fdrc ) < 0 )
return -1;
/* load setup */
fp = fopen( CONFIGDIR "/zapit/services.xml", "r" );
if ( !fp )
{
FBDrawString( 190, 100, 64, "services.xml not found !", RED, 0 );
#ifdef USEX
FBFlushGrafic();
#endif
tv.tv_sec = 5;
tv.tv_usec = 0;
select( 0, 0, 0, 0, &tv );
RcClose();
FBClose();
return 0;
}
while( fgets(line,512,fp) )
{
num_lines++;
if ( strstr(line,"channelNR") )
{
p=strstr(line,"serviceType");
if ( p && (*(p+15) == '0') )
{
p+=16;
if ( *p == '1' )
num_ch_tv++;
if ( *p == '2' )
num_ch_radio++;
if ( *p == '4' )
num_ch_tv++;
}
}
}
fclose(fp);
lines = (char**)malloc(sizeof(char*)*num_lines);
tv_ch = (Channel*)malloc(sizeof(Channel)*num_ch_tv);
radio_ch = (Channel*)malloc(sizeof(Channel)*num_ch_radio);
for( i=0;i<num_ch_tv;i++)
tv_ch[i].flag=0;
for( i=0;i<num_ch_radio;i++)
radio_ch[i].flag=0;
fp = fopen( CONFIGDIR "/zapit/services.xml", "r" );
t=num_ch_tv-1;
r=num_ch_radio-1;
for(i=0; i<num_lines;i++)
{
fgets( line, 512, fp );
lines[i] = strdup(line);
if ( !strstr(line,"channelNR") )
continue;
p=strstr(line,"name=");
copyname(l2,p+6);
p=strstr(line,"channelNR=");
cnum=_atoi(p+11);
if ( cnum )
idx=cnum-1;
p=strstr(line,"serviceType");
if ( !p || ( *(p+15) != '0' ) )
continue;
switch( *(p+16) )
{
case '1' :
case '4' :
ch=tv_ch;
if ( !cnum || ch[idx].flag )
{
idx=t;
t--;
}
break;
case '2' :
ch=radio_ch;
if ( !cnum || ch[idx].flag )
{
idx=r;
r--;
}
break;
default:
p=0;
break;
}
if ( !p )
continue;
ch[idx].name=strdup(l2);
ch[idx].flag=*(p+14);
ch[idx].line=lines[i];
}
fclose(fp);
t=0;
while( doexit != 3 )
{
if ( t )
SortBouquet( radio_ch, num_ch_radio );
else
SortBouquet( tv_ch, num_ch_tv );
t=!t;
switch( doexit )
{
case 2 :
doexit=0;
break;
case 1 :
SaveServices();
doexit=3;
break;
}
}
for( i=0; i<num_ch_tv; i++ )
free( tv_ch[i].name );
for( i=0; i<num_ch_radio; i++ )
free( radio_ch[i].name );
for( i=0; i<num_lines; i++ )
free( lines[i] );
free( lines );
free( tv_ch );
free( radio_ch );
/* fx2 */
/* buffer leeren, damit neutrino nicht rumspinnt */
realcode = RC_0;
while( realcode != 0xee )
{
tv.tv_sec = 0;
tv.tv_usec = 300000;
x = select( 0, 0, 0, 0, &tv ); /* 300ms pause */
RcGetActCode( );
}
RcClose();
FBClose();
return 0;
}
/* Load and process configuration parameters */
extern void bb_load_config(bb_state_t *state_ptr, char *plugin_type)
{
s_p_hashtbl_t *bb_hashtbl = NULL;
char *bb_conf, *tmp = NULL, *value;
#if _SUPPORT_ALT_POOL
char *colon, *save_ptr = NULL, *tok;
uint32_t pool_cnt;
#endif
int fd, i;
static s_p_options_t bb_options[] = {
{"AllowUsers", S_P_STRING},
#if _SUPPORT_ALT_POOL
{"AltPool", S_P_STRING},
#endif
{"CreateBuffer", S_P_STRING},
{"DefaultPool", S_P_STRING},
{"DenyUsers", S_P_STRING},
{"DestroyBuffer", S_P_STRING},
{"Flags", S_P_STRING},
{"GetSysState", S_P_STRING},
{"Granularity", S_P_STRING},
{"OtherTimeout", S_P_UINT32},
{"StageInTimeout", S_P_UINT32},
{"StageOutTimeout", S_P_UINT32},
{"StartStageIn", S_P_STRING},
{"StartStageOut", S_P_STRING},
{"StopStageIn", S_P_STRING},
{"StopStageOut", S_P_STRING},
{"ValidateTimeout", S_P_UINT32},
{NULL}
};
xfree(state_ptr->name);
if (plugin_type) {
tmp = strchr(plugin_type, '/');
if (tmp)
tmp++;
else
tmp = plugin_type;
state_ptr->name = xstrdup(tmp);
}
/* Set default configuration */
bb_clear_config(&state_ptr->bb_config, false);
if (slurm_get_debug_flags() & DEBUG_FLAG_BURST_BUF)
state_ptr->bb_config.debug_flag = true;
state_ptr->bb_config.flags |= BB_FLAG_DISABLE_PERSISTENT;
state_ptr->bb_config.other_timeout = DEFAULT_OTHER_TIMEOUT;
state_ptr->bb_config.stage_in_timeout = DEFAULT_STATE_IN_TIMEOUT;
state_ptr->bb_config.stage_out_timeout = DEFAULT_STATE_OUT_TIMEOUT;
state_ptr->bb_config.validate_timeout = DEFAULT_VALIDATE_TIMEOUT;
/* First look for "burst_buffer.conf" then with "type" field,
* for example "burst_buffer_cray.conf" */
bb_conf = get_extra_conf_path("burst_buffer.conf");
fd = open(bb_conf, 0);
if (fd >= 0) {
close(fd);
} else {
char *new_path = NULL;
xfree(bb_conf);
xstrfmtcat(new_path, "burst_buffer_%s.conf", state_ptr->name);
bb_conf = get_extra_conf_path(new_path);
fd = open(bb_conf, 0);
if (fd < 0) {
info("%s: Unable to find configuration file %s or "
"burst_buffer.conf", __func__, new_path);
xfree(bb_conf);
xfree(new_path);
return;
}
close(fd);
xfree(new_path);
}
bb_hashtbl = s_p_hashtbl_create(bb_options);
if (s_p_parse_file(bb_hashtbl, NULL, bb_conf, false) == SLURM_ERROR) {
fatal("%s: something wrong with opening/reading %s: %m",
__func__, bb_conf);
}
if (s_p_get_string(&state_ptr->bb_config.allow_users_str, "AllowUsers",
bb_hashtbl)) {
state_ptr->bb_config.allow_users = _parse_users(
state_ptr->bb_config.allow_users_str);
}
s_p_get_string(&state_ptr->bb_config.create_buffer, "CreateBuffer",
bb_hashtbl);
s_p_get_string(&state_ptr->bb_config.default_pool, "DefaultPool",
bb_hashtbl);
if (s_p_get_string(&state_ptr->bb_config.deny_users_str, "DenyUsers",
bb_hashtbl)) {
state_ptr->bb_config.deny_users = _parse_users(
state_ptr->bb_config.deny_users_str);
}
s_p_get_string(&state_ptr->bb_config.destroy_buffer, "DestroyBuffer",
bb_hashtbl);
if (s_p_get_string(&tmp, "Flags", bb_hashtbl)) {
state_ptr->bb_config.flags = slurm_bb_str2flags(tmp);
xfree(tmp);
}
/* By default, disable persistent buffer creation by normal users */
if (state_ptr->bb_config.flags & BB_FLAG_ENABLE_PERSISTENT)
state_ptr->bb_config.flags &= (~BB_FLAG_DISABLE_PERSISTENT);
s_p_get_string(&state_ptr->bb_config.get_sys_state, "GetSysState",
bb_hashtbl);
if (s_p_get_string(&tmp, "Granularity", bb_hashtbl)) {
state_ptr->bb_config.granularity = bb_get_size_num(tmp, 1);
xfree(tmp);
if (state_ptr->bb_config.granularity == 0) {
error("%s: Granularity=0 is invalid", __func__);
state_ptr->bb_config.granularity = 1;
}
}
#if _SUPPORT_ALT_POOL
if (s_p_get_string(&tmp, "AltPool", bb_hashtbl)) {
tok = strtok_r(tmp, ",", &save_ptr);
while (tok) {
colon = strchr(tok, ':');
if (colon) {
colon[0] = '\0';
pool_cnt = _atoi(colon + 1);
} else
pool_cnt = 1;
state_ptr->bb_config.pool_ptr = xrealloc(
state_ptr->bb_config.pool_ptr,
sizeof(burst_buffer_pool_t) *
(state_ptr->bb_config.pool_cnt + 1));
state_ptr->bb_config.
pool_ptr[state_ptr->bb_config.pool_cnt].name =
xstrdup(tok);
state_ptr->bb_config.
pool_ptr[state_ptr->bb_config.pool_cnt].
avail_space = pool_cnt;
state_ptr->bb_config.pool_cnt++;
tok = strtok_r(NULL, ",", &save_ptr);
}
xfree(tmp);
}
#endif
(void) s_p_get_uint32(&state_ptr->bb_config.other_timeout,
"OtherTimeout", bb_hashtbl);
(void) s_p_get_uint32(&state_ptr->bb_config.stage_in_timeout,
"StageInTimeout", bb_hashtbl);
(void) s_p_get_uint32(&state_ptr->bb_config.stage_out_timeout,
"StageOutTimeout", bb_hashtbl);
s_p_get_string(&state_ptr->bb_config.start_stage_in, "StartStageIn",
bb_hashtbl);
s_p_get_string(&state_ptr->bb_config.start_stage_out, "StartStageOut",
bb_hashtbl);
s_p_get_string(&state_ptr->bb_config.stop_stage_in, "StopStageIn",
bb_hashtbl);
s_p_get_string(&state_ptr->bb_config.stop_stage_out, "StopStageOut",
bb_hashtbl);
(void) s_p_get_uint32(&state_ptr->bb_config.validate_timeout,
"ValidateTimeout", bb_hashtbl);
s_p_hashtbl_destroy(bb_hashtbl);
xfree(bb_conf);
if (state_ptr->bb_config.debug_flag) {
value = _print_users(state_ptr->bb_config.allow_users);
info("%s: AllowUsers:%s", __func__, value);
xfree(value);
info("%s: CreateBuffer:%s", __func__,
state_ptr->bb_config.create_buffer);
info("%s: DefaultPool:%s", __func__,
state_ptr->bb_config.default_pool);
value = _print_users(state_ptr->bb_config.deny_users);
info("%s: DenyUsers:%s", __func__, value);
xfree(value);
info("%s: DestroyBuffer:%s", __func__,
state_ptr->bb_config.destroy_buffer);
info("%s: GetSysState:%s", __func__,
state_ptr->bb_config.get_sys_state);
info("%s: Granularity:%"PRIu64"", __func__,
state_ptr->bb_config.granularity);
for (i = 0; i < state_ptr->bb_config.pool_cnt; i++) {
info("%s: AltPoolName[%d]:%s:%"PRIu64"", __func__, i,
state_ptr->bb_config.pool_ptr[i].name,
state_ptr->bb_config.pool_ptr[i].total_space);
}
info("%s: OtherTimeout:%u", __func__,
state_ptr->bb_config.other_timeout);
info("%s: StageInTimeout:%u", __func__,
state_ptr->bb_config.stage_in_timeout);
info("%s: StageOutTimeout:%u", __func__,
state_ptr->bb_config.stage_out_timeout);
info("%s: StartStageIn:%s", __func__,
state_ptr->bb_config.start_stage_in);
info("%s: StartStageOut:%s", __func__,
state_ptr->bb_config.start_stage_out);
info("%s: StopStageIn:%s", __func__,
state_ptr->bb_config.stop_stage_in);
info("%s: StopStageOut:%s", __func__,
state_ptr->bb_config.stop_stage_out);
info("%s: ValidateTimeout:%u", __func__,
state_ptr->bb_config.validate_timeout);
}
}
extern int vsprintf(char *buf,const char *fmt,va_list args){
int style = 0;
int width = 0;
long num = 0;
_bool sign = _true;
HexBase base = DECIMAL;
char *str,*s;
enum type{ _long = 'L', _int = 'l' , _short = 'h' , _char = 'H',_string = 's'}_type = _int; //数据类型,long long,int,short
for( str = buf; *fmt; fmt++){
if(*fmt == '%'){
style = 0;
sign = _false;
width = 0;
_type = _int;
repeat:
fmt++;
switch(* fmt){
case '-': style |= STYLE_LEFT;goto repeat;
case '+': style |= STYLE_SIGN;goto repeat;
case ' ': style |= STYLE_SIGN;goto repeat;
case '0': style |= STYLE_ZEROPAD;goto repeat;
case '#': style |= STYLE_SPECIAL;goto repeat;
}
if(isDigit(*fmt))
width = _atoi(&fmt);
else if(* fmt == '*'){
fmt++;
width = va_arg(args,int);
}
if(*fmt == 'h' || *fmt == 'l' || *fmt == 'L' || *fmt == 'H'){
_type = (enum type)(*fmt);
fmt++;
}
switch(*fmt){
case 'c': *str++ = (unsigned char)va_arg(args,int);continue;
case 's': _type = _string;break;
case 'p': style |= STYLE_SPECIAL; base = HEX; break;
case 'X': style |= STYLE_LARGE;
case 'x': base = HEX;break;
case 'd': base = DECIMAL;
case 'i': sign = _true;
case 'u': break;
case 'o': base = OCTAL;break;
default: if(*fmt) *str++ = *fmt; continue;
}
int mask = -1;
switch(_type){
case _char: mask = 0xff;
case _short: mask &= 0xffff;
case _int: mask &= 0xffffffff;
num = va_arg(args,int);
str = _toNumber(str,num, sign,base,width,style,mask);
break;
case _long:
num = va_arg(args,long long);
str = _toNumber(str,num, sign,base,width,style,mask);
break;
case _string:
s = va_arg(args,char *);
if(!s) s = "<NULL>";
str = _toString(str,s,width,style);
break;
}
}
void
loadBook(const char * file)
{
LIBXML_TEST_VERSION
int i = 0, j;
char* token, *string, *tmp;
xmlDocPtr doc = NULL;
xmlNodePtr node = NULL;
xmlNodePtr node_child = NULL;
xmlAttrPtr prop = NULL;
if ((doc = xmlReadFile (file, NULL, 0)) == NULL)
{
fprintf (stderr, "Error: couldn't parse file %s\n", file);
exit(1);
}
node = xmlDocGetRootElement (doc);
if (xmlStrcmp (node->name, (xmlChar *) "story"))
{
fprintf (stderr, "Error when loading configuration\n");
exit(1);
}
node = ((xmlNodePtr)node->children);
while (node)
{
if (node->type == XML_ELEMENT_NODE && node->children->type == XML_TEXT_NODE)
{
#ifdef _DEBUG
printf("%s -> \n", xmlStrdup(node->name) );
#endif
if(!gamebook.action)
gamebook.action = malloc( sizeof(struct gbook_act) * CH_BLOCK );
if(gamebook.n_action % CH_BLOCK)
gamebook.action = realloc( gamebook.action, (gamebook.n_action + CH_BLOCK) * sizeof(struct gbook_act) );
gamebook.action[gamebook.n_action].id = gamebook.n_action + 1;
gamebook.action[gamebook.n_action].choices = NULL;
gamebook.action[gamebook.n_action].n_choice = 0;
node_child = ((xmlNodePtr)node->children);
while(node_child)
{
if (node_child->type == XML_ELEMENT_NODE && node_child->children->type == XML_TEXT_NODE)
{
if( !strcmp(xmlStrdup(node_child->name), "text") )
{
gamebook.action[gamebook.n_action].text = strreplace(xmlStrdup( node_child->children->content ) , "$user", user_cfg.name );
} else {
if(!gamebook.action[gamebook.n_action].choices)
gamebook.action[gamebook.n_action].choices = malloc( sizeof(struct gbook_choice) * CH_BLOCK );
if(gamebook.action[gamebook.n_action].n_choice % CH_BLOCK)
gamebook.action[gamebook.n_action].choices = realloc( gamebook.action[gamebook.n_action].choices,
( CH_BLOCK + gamebook.action[gamebook.n_action].n_choice ) * sizeof(struct gbook_choice) );
gamebook.action[gamebook.n_action].choices[gamebook.action[gamebook.n_action].n_choice].text = strreplace( xmlStrdup( node_child->children->content ), "$user", user_cfg.name );
gamebook.action[gamebook.n_action].choices[gamebook.action[gamebook.n_action].n_choice].require = \
gamebook.action[gamebook.n_action].choices[gamebook.action[gamebook.n_action].n_choice].gain = NULL;
gamebook.action[gamebook.n_action].choices[gamebook.action[gamebook.n_action].n_choice].life = \
gamebook.action[gamebook.n_action].choices[gamebook.action[gamebook.n_action].n_choice].money = 0;
prop = node_child->properties;
while( prop )
{
if( !strcmp( xmlStrdup( prop->name) , "link" ) )
{
gamebook.action[gamebook.n_action].choices[gamebook.action[gamebook.n_action].n_choice].link = _atoi(xmlStrdup( prop->children->content ));
} else if (!strcmp( xmlStrdup( prop->name ), "require" ))
{
gamebook.action[gamebook.n_action].choices[gamebook.action[gamebook.n_action].n_choice].require = xmlStrdup( prop->children->content );
} else if (!strcmp( xmlStrdup( prop->name ), "gain" ))
{
gamebook.action[gamebook.n_action].choices[gamebook.action[gamebook.n_action].n_choice].gain = xmlStrdup( prop->children->content );
} else if (!strcmp( xmlStrdup( prop->name ), "life" ))
{
gamebook.action[gamebook.n_action].choices[gamebook.action[gamebook.n_action].n_choice].life = _atoi(xmlStrdup( prop->children->content ));
} else if (!strcmp( xmlStrdup( prop->name ), "money" ))
{
gamebook.action[gamebook.n_action].choices[gamebook.action[gamebook.n_action].n_choice].money = _atoi(xmlStrdup( prop->children->content ));
}
prop = prop->next;
}
#ifdef _DEBUG
printf("%s -> \"%s\"\n", xmlStrdup(node_child->name), xmlStrdup(node_child->children->content) );
if ( node_child->properties )
printf("( %s = %s )\n", xmlStrdup( node_child->properties->name ), xmlStrdup( node_child->properties->children->content ) );
#endif
gamebook.action[gamebook.n_action].n_choice++;
}
}
node_child = node_child->next;
}
gamebook.n_action++;
}
node = node->next;
}
}
void RunMenu(void)
{
char cTempChar = 1; // Set to any value other than 0
char zOutputStr[MAX_MEM_SIZE + 3]; // Add space for newline, return and NULL
char *ptrOutputStr;
eErrorType error = NO_ERROR;
static DebugMenuSubType MenuAction = READ_MEMORY;
static unsigned int i, Address = 0, Length = 0, Value = 0;
static unsigned int Frequency = 0, Voltage = 0;
// Read input characters until input buffer is empty
while ((cTempChar = SCIReadChar()) != 0)
{ // Have another character from input buffer
if (cTempChar == '\r')
{ // Enter character. Process input
*ptrInputStr = '\0'; // append Null
ptrInputStr = zInputStr; // Reset input string
SCIWriteString_P(PSTR("\n\r")); // Move cursor to next line
// Reset displaying of A/D samples
DisplaySamples = 0;
// Process entry based on debug menu state
switch(MenuState)
{
case TOP_MENU:
if (strcmp(zInputStr, "?") == 0)
{ // Help screen
MenuState = DISPLAY_HELP_MENU1;
}
else if (strcmp(zInputStr, "ge") == 0)
{ // Display desired signal parameters
// Retrieve signal parameters
error = GetError();
SCIWriteString_P(PSTR(" Error = "));
ptrOutputStr = zOutputStr;
_itoa(&ptrOutputStr, error, 10);
SCIWriteString(zOutputStr);
SCIWriteString_P(PSTR("\n\r"));
}
else if (strcmp(zInputStr, "ce") == 0)
{
ClearError();
}
else if (strcmp(zInputStr, "lcd") == 0)
{
SCIWriteString_P(PSTR(" Enter character to display (0-9 or a space): "));
MenuState = GET_LCD_CHARACTER;
}
else if (strcmp(zInputStr, "te") == 0)
{ // Display temperature
int temperature;
temperature = ReadTemperature();
SCIWriteString_P(PSTR(" Temperature = "));
ptrOutputStr = zOutputStr;
_itoa(&ptrOutputStr, temperature, 10);
SCIWriteString(zOutputStr);
SCIWriteString_P(PSTR("\n\r"));
}
else if (strcmp(zInputStr, "dsp") == 0)
{ // Display desired signal parameters
// Retrieve signal parameters
Frequency = GET_FREQ_DESIRED();
Voltage = GET_VOLT_DESIRED();
SCIWriteString_P(PSTR(" Desired Frequency = "));
ptrOutputStr = zOutputStr;
_itoa(&ptrOutputStr, Frequency, 10);
SCIWriteString(zOutputStr);
SCIWriteString_P(PSTR("\n\r"));
SCIWriteString_P(PSTR(" Desired Voltage = "));
ptrOutputStr = zOutputStr;
_itoa(&ptrOutputStr, Voltage, 10);
SCIWriteString(zOutputStr);
SCIWriteString_P(PSTR("\n\r"));
// Retrieve signal parameters
Frequency = GET_FREQ_ACTUAL();
Voltage = GET_VOLT_ACTUAL();
SCIWriteString_P(PSTR(" Actual Frequency = "));
ptrOutputStr = zOutputStr;
_itoa(&ptrOutputStr, Frequency, 10);
SCIWriteString(zOutputStr);
SCIWriteString_P(PSTR("\n\r"));
SCIWriteString_P(PSTR(" Actual Voltage = "));
ptrOutputStr = zOutputStr;
_itoa(&ptrOutputStr, Voltage, 10);
SCIWriteString(zOutputStr);
SCIWriteString_P(PSTR("\n\r"));
}
else if (strcmp(zInputStr, "msp") == 0)
{ // Change desired signal parameters
SCIWriteString(" Enter desired voltage (100 to 500): ");
MenuState = SIGNAL_READ_VOLTAGE;
}
else if (strcmp(zInputStr, "wv") == 0)
{ // Change desired signal parameters
SCIWriteString(" Enter desired voltage (0 to 1023): ");
MenuState = WRITE_D2A;
}
else if (strcmp(zInputStr, "ds") == 0)
{ // Display A/D Samples
SCIWriteString(" Hit Enter key to terminate\n\r");
DisplaySamples = 1;
}
else if ((strcmp(zInputStr, "rm") == 0) ||
(strcmp(zInputStr, "wm") == 0))
{ // Memory menu
if (strcmp(zInputStr, "rm") == 0)
{
MenuAction = READ_MEMORY;
}
else
{
MenuAction = WRITE_MEMORY;
}
// Get address
SCIWriteString(" Address (0x100 to 0x4FF) = ");
MenuState = MEMORY_GET_ADDRESS;
}
else
{ // No entry
// Back to top menu
MenuState = TOP_MENU;
}
break;
case GET_LCD_CHARACTER:
if (zInputStr[0] != '\0')
{ // Just skip NULL entries
LCDChar = zInputStr[0];
// Now get position
SCIWriteString_P(PSTR("\n\r Enter LCD Position(2-7): "));
MenuState = GET_LCD_POSITION;
}
else
{ // No entry
// Back to top menu
MenuState = TOP_MENU;
}
break;
case GET_LCD_POSITION:
if (zInputStr[0] != '\0')
{ // Just skip NULL entries
LCDPosition = _atoi(zInputStr, 10);
// Now get position
MenuState = TOP_MENU;
}
else
{ // No entry
// Back to top menu
MenuState = TOP_MENU;
}
break;
case WRITE_D2A:
if (zInputStr[0] != '\0')
{ // Just skip NULL entries
Voltage = _atoi(zInputStr, 10);
if ((Voltage >= 0) && (Voltage <= 1023))
{ // Valid voltage. Write to D/A
WriteDtoASample(Voltage);
}
}
// Back to top menu
MenuState = TOP_MENU;
break;
case SIGNAL_READ_VOLTAGE:
if (zInputStr[0] != '\0')
{ // Just skip NULL entries
Voltage = _atoi(zInputStr, 10);
// Now get frequency
SCIWriteString_P(PSTR("\n\r Enter desired frequency (40 to 100): "));
MenuState = SIGNAL_READ_FREQUENCY;
}
else
{ // No entry
// Back to top menu
MenuState = TOP_MENU;
}
break;
case SIGNAL_READ_FREQUENCY:
if (zInputStr[0] != '\0')
{ // Just skip NULL entries
Frequency = _atoi(zInputStr, 10);
// Set the parameters
if ((error = SetFreq(Frequency)) != NO_ERROR)
{
SCIWriteString_P(PSTR("\n\r Error setting frequency"));
}
else
{ // Set voltage
if ((error = SetVolt(Voltage)) != NO_ERROR)
{
SCIWriteString_P(PSTR("\n\r Error setting voltage"));
}
}
// Back to top menu
MenuState = TOP_MENU;
}
else
{ // No entry
// Back to top menu
MenuState = TOP_MENU;
}
break;
case MEMORY_GET_ADDRESS:
if (zInputStr[0] != '\0')
{ // Just skip NULL entries
Address = _atoi(zInputStr, 16);
if ((Address < MIN_MEM_ADDR) ||
(Address > MAX_MEM_ADDR))
{ // Address out of range
SCIWriteString_P(PSTR(" Address out of range\n\r"));
}
else
{
if (MenuAction == READ_MEMORY)
{
// Now get length
SCIWriteString_P(PSTR(" Length (in hex) = "));
}
else
{
SCIWriteString_P(PSTR(" Value (in hex) = "));
}
MenuState = MEMORY_GET_LENGTH;
}
}
else
{ // No entry
// Back to top menu
MenuState = TOP_MENU;
}
break;
case MEMORY_GET_LENGTH:
if (zInputStr[0] != '\0')
{
if (MenuAction == READ_MEMORY)
{
Length = _atoi(zInputStr, 16);
// Limit memory to available RAM
if ((Address + Length - 1) > MAX_MEM_ADDR)
{
Length = MAX_MEM_ADDR - Address + 1;
}
if (Length == 0)
{ // default to 1
Length = 1;
}
if (Length > MAX_MEM_SIZE)
{
Length = MAX_MEM_SIZE;
}
SCIWriteString_P(PSTR(" Memory ="));
for (i = 0; i < Length; ++i)
{
if ((i % 16) == 0)
{
SCIWriteString_P(PSTR("\n\r "));
// Display address
ptrOutputStr = zOutputStr;
_itoa(&ptrOutputStr, Address, 16);
SCIWriteString(zOutputStr);
SCIWriteString("> ");
}
ptrOutputStr = zOutputStr;
*ptrOutputStr = *(unsigned char *)Address;
++Address;
// Convert character to an ASCII string in Hex
_itoa(&ptrOutputStr, (int)zOutputStr[0], 16);
// Force to be 2 characters long
if (strlen(zOutputStr) < 2)
{
zOutputStr[1] = zOutputStr[0];
zOutputStr[0]= '0';
}
zOutputStr[2] = ' ';
zOutputStr[3] = '\0';
SCIWriteString(zOutputStr);
}
SCIWriteString_P(PSTR("\n\r"));
}
else
{ // Write memory
Value = _atoi(zInputStr, 16);
if (Value > 0xFF)
{ // invalid value
SCIWriteString_P(PSTR("Invalid value\n\r"));
MenuState = TOP_MENU;
}
else
{
SCIWriteString_P(PSTR("Write Mem\n\r"));
ptrOutputStr = (char *)Address;
*ptrOutputStr = (char)Value;
SCIWriteString_P(PSTR("\n\r"));
}
}
// Back to top menu
MenuState = TOP_MENU;
}
break;
default:
// Erroneous state. Reset to none
MenuState = TOP_MENU;
break;
} // end switch
// Reset string pointer. May have been moved during command processing
ptrInputStr = zInputStr;
if (MenuState == TOP_MENU)
{
// Display prompt
SCIWriteString_P(PSTR("cmd> "));
}
}
else
{ // Save new character to input buffer
if (ptrInputStr < &zInputStr[MAX_IN_STR_SIZE-2])
{ // Buffer is not full
*ptrInputStr = cTempChar;
*(ptrInputStr+1) = '\0'; // Keep null in string
// echo character
SCIWriteString(ptrInputStr);
++ptrInputStr;
} // else, buffer is full. Ignore characters.
}
} // End while. All characters processed
if (MenuState == DISPLAY_HELP_MENU1)
{ // Display 1st part of help menu
SCIWriteString_P(PSTR(" Commands are:\n\r"));
SCIWriteString_P(PSTR(" ge - Display error code\n\r"));
MenuState = DISPLAY_HELP_MENU2;
}
else if (MenuState == DISPLAY_HELP_MENU2)
{ // Display 2nd part of help menu
SCIWriteString_P(PSTR(" ce - Clear current error\n\r"));
SCIWriteString_P(PSTR(" lcd - Display LCD character\n\r"));
MenuState = DISPLAY_HELP_MENU3;
}
else if (MenuState == DISPLAY_HELP_MENU3)
{ // Display 3rd part of help menu
SCIWriteString_P(PSTR(" te - Display temperature\n\r"));
SCIWriteString_P(PSTR(" wv - Write voltage to D/A\n\r"));
MenuState = DISPLAY_HELP_MENU4;
}
else if (MenuState == DISPLAY_HELP_MENU4)
{ // Display 4th part of help menu
SCIWriteString_P(PSTR(" dsp - Display signal parameters\n\r"));
SCIWriteString_P(PSTR(" msp - Change desired signal parameters\n\r"));
MenuState = DISPLAY_HELP_MENU5;
}
else if (MenuState == DISPLAY_HELP_MENU5)
{ // Display 5th part of help menu
SCIWriteString_P(PSTR(" ds - Display A/D samples \n\r"));
SCIWriteString_P(PSTR(" rm - Read memory\n\r"));
MenuState = DISPLAY_HELP_MENU6;
}
else if (MenuState == DISPLAY_HELP_MENU6)
{ // Display 6th part of help menu
SCIWriteString_P(PSTR(" wm - Write memory\r"));
SCIWriteString_P(PSTR(" ? - Display this help menu\n\r"));
MenuState = TOP_MENU;
}
}
int main(int argc, char** argv)
{
unsigned char addr;
unsigned char data[5];
char device_name[20];
int opt;
int bus = 0;
int n = 0;
char mode = 'b';
int num;
char format = 'x';
uint8_t array_byte[128];
const char *fmt_byte;
const char *fmt_short;
const char *fmt_long;
char *base_name;
while ((opt = getopt(argc, argv, "d:f:m:r:wh")) != -1) {
switch (opt) {
case 'f':
format = optarg[0];
break;
case 'd':
bus = atoi(optarg);
break;
case 'm':
mode = optarg[0];
break;
case 'r':
n = atoi(optarg);
break;
case 'h':
default:
base_name = basename(argv[0]);
fprintf(stderr, "Usage: %s [-d I2CBUS] [[-r N] [-m MODE] [-f FORMAT]] ADDRESS [VAL1 VAL2 ...]\n"
" %s 0x20 0x00\n"
" %s 0x20 -r 1 -m s -f d\n"
" I2CBUS is an integer\n"
" N is an integer the number of element to be read\n"
" MODE is b|s|l - byte|short|long\n"
" FORMAT is x|d|u - hex|signed|unsigned\n",
base_name, base_name, base_name);
return -1;
}
}
//fprintf(stderr, "bus=%d; mode=%c; n=%d; optind=%d\n", bus, mode, n, optind);
if ( format == 'x' ) {
fmt_byte = "0x%02X";
fmt_short = "0x%04X";
fmt_long = "0x%08lX";
}
else if ( format == 'd' ) {
fmt_byte = "%d";
fmt_short = "%d";
fmt_long = "%ld";
}
else {
fmt_byte = "%u";
fmt_short = "%u";
fmt_long = "%lu";
}
if ( mode == 's' ) {
n *= 2;
}
else if ( mode == 'l' ) {
n *= 4;
}
else if ( mode == 'c' ) {
}
if ( optind >= argc ) {
fprintf(stderr, "Expected ADDRESS\n");
return -1;
}
addr = _atoi(argv[optind++]);
//fprintf(stderr, "addr=0x%02X\n", addr);
num = 0;
for (;optind < argc; optind++) {
if ( num >= 128 )
break;
array_byte[num++] = (uint8_t)_atoi(argv[optind]);
}
//fprintf(stderr, "num=%d\n", num);
sprintf(device_name, "/dev/i2c-%u", bus);
fd = open(device_name,O_RDWR);
if ( fd < 0 ) {
fprintf(stderr, "Couldn't open %s!\n", device_name);
return -2;
}
setaddr(addr);
if ( num ) {
if ( write(fd, array_byte, num) < 0 ) {
fprintf(stderr, "Unable to write!\n");
close(fd);
return -2;
}
}
if ( n ) {
int i;
n = n < 128 ? n : 128;
read(fd, array_byte, n);
if ( mode == 'c' ) {
for ( i = 0; i < n; i++ ) {
char c;
c = array_byte[i];
printf("%c", iscntrl(c) ? '.' : c);
}
}
else if ( mode == 's' ) {
union {
uint16_t u16;
uint8_t arr[2];
} w;
for ( i = 0; i < n; i += 2 ) {
w.arr[0] = array_byte[i];
w.arr[1] = array_byte[i + 1];
if ( i != 0 )
printf(" ");
if ( format == 'd' )
printf(fmt_short, (int16_t)le16toh(w.u16));
else
printf(fmt_short, (uint16_t)le16toh(w.u16));
}
}
else if ( mode == 'l' ) {
union {
uint32_t u32;
uint8_t arr[4];
} w;
for ( i = 0; i < n; i += 4 ) {
w.arr[0] = array_byte[i];
w.arr[1] = array_byte[i + 1];
w.arr[2] = array_byte[i + 2];
w.arr[3] = array_byte[i + 3];
if ( i != 0 )
printf(" ");
if ( format == 'd' )
printf(fmt_long, (int32_t)le32toh(w.u32));
else
printf(fmt_long, (uint32_t)le32toh(w.u32));
}
}
else {
for ( i = 0; i < n; i++ ) {
if ( i != 0 )
printf(" ");
if ( format == 'd' )
printf(fmt_byte, (int8_t)array_byte[i]);
else
printf(fmt_byte, array_byte[i]);
}
}
printf("\n");
}
close(fd);
return 0;
}
