예제 #1
0
StringArray MainMenuModel::getMenuBarNames()
{

    //OLD METHOD - caused an assertion when trying to display non-standard characters (e.g. japanese characters)
    /*
    //const char* const names[] = { file.toUTF8(), edit.toUTF8(), options.toUTF8(), controls.toUTF8(), help.toUTF8(), 0 };
    const char* const names[] = { "File", "Edit", "Options", "Controls", "Help", 0 };
    return StringArray ((const char**) names);
     */
    
    StringArray names;
    
    String file(translate("File"));
    String edit(translate("Edit"));
    String view(translate("View"));
    String options(translate("Options"));
    String controls(translate("Controls"));
    String hardware(translate("Hardware"));
    String help(translate("Help"));
    
    names.add(file);
    names.add(edit);
    names.add(view);
    names.add(options);
    names.add(controls);
    names.add(hardware);
    names.add(help);
    
    return names;
}
sp<CameraHardwareInterface> CameraHardwareStub::createInstance()
{
    if (singleton != 0) {
        sp<CameraHardwareInterface> hardware = singleton.promote();
        if (hardware != 0) {
            return hardware;
        }
    }
    sp<CameraHardwareInterface> hardware(new CameraHardwareStub());
    singleton = hardware;
    return hardware;
}
예제 #3
0
int main()
{
    hardware();
    
    led_init();
    delay_init();
    sx1276_cfg_init();
    
    xTaskCreate(task_led, "led", configMINIMAL_STACK_SIZE, NULL, 0, NULL);

    vTaskStartScheduler();
}
예제 #4
0
void Connection::disconnect() {

    qDebug() << "Connection::disconnect Line " << __LINE__;

    if(tcpSocket!=NULL) {
        tcpSocket->close();
        // object deletion moved in connect method 
        // tcpSocket=NULL;

    }
    // close the hardware panel, if any
    emit hardware (QString(""));
}
예제 #5
0
파일: numa_node_size.c 프로젝트: 1587/ltp
int main(void)
{
#if HAVE_NUMA_H
	nodemask_t nodemask;
	void hardware();
	if (numa_available() < 0) {
		printf("This system does not support NUMA policy\n");
		numa_error("numa_available");
		numa_exit_on_error = 1;
		exit(numa_exit_on_error);
	}
	nodemask_zero(&nodemask);
	nodemask_set(&nodemask, 1);
	numa_bind(&nodemask);
	hardware();
	return numa_exit_on_error;
#else
	printf("NUMA is not available\n");
	return 1;
#endif
}
예제 #6
0
int main(int argc, char *argv[])
#endif
{
int i;                  /* Index */
int iter;
time_t time_and_date;   /* Self-explanatory */
struct tm *loctime;
double bmean;           /* Benchmark mean */
double bstdev;          /* Benchmark stdev */
double lx_memindex;     /* Linux memory index (mainly integer operations)*/
double lx_intindex;     /* Linux integer index */
double lx_fpindex;      /* Linux floating-point index */
double intindex;        /* Integer index */
double fpindex;         /* Floating-point index */
ulong bnumrun;          /* # of runs */

#ifdef MAC
        MaxApplZone();
#endif

#ifdef MACTIMEMGR
/* Set up high res timer */
MacHSTdelay=600*1000*1000;      /* Delay is 10 minutes */

memset((char *)&myTMTask,0,sizeof(TMTask));

/* Prime and remove the task, calculating overhead */
PrimeTime((QElemPtr)&myTMTask,-MacHSTdelay);
RmvTime((QElemPtr)&myTMTask);
MacHSTohead=MacHSTdelay+myTMTask.tmCount;
#endif

#ifdef WIN31TIMER
/* Set up the size of the timer info structure */
win31tinfo.dwSize=(DWORD)sizeof(TIMERINFO);
/* Load library */
if((hThlp=LoadLibrary("TOOLHELP.DLL"))<32)
{       printf("Error loading TOOLHELP\n");
        exit(0);
}
if(!(lpfn=GetProcAddress(hThlp,"TimerCount")))
{       printf("TOOLHELP error\n");
        exit(0);
}
#endif

/*
** Set global parameters to default.
*/
global_min_ticks=MINIMUM_TICKS;
global_min_seconds=MINIMUM_SECONDS;
global_allstats=0;
global_custrun=0;
global_align=8;
write_to_file=0;
lx_memindex=(double)1.0;        /* set for geometric mean computations */
lx_intindex=(double)1.0;
lx_fpindex=(double)1.0;
intindex=(double)1.0;
fpindex=(double)1.0;
mem_array_ents=0;               /* Nothing in mem array */

/*
** We presume all tests will be run unless told
** otherwise
*/
for(i=0;i<NUMTESTS;i++)
        tests_to_do[i]=1;

/*
** Initialize test data structures to default
** values.
*/
set_request_secs();     /* Set all request_secs fields */
global_numsortstruct.adjust=0;
global_numsortstruct.arraysize=NUMARRAYSIZE;

global_strsortstruct.adjust=0;
global_strsortstruct.arraysize=STRINGARRAYSIZE;

global_bitopstruct.adjust=0;
global_bitopstruct.bitfieldarraysize=BITFARRAYSIZE;

global_emfloatstruct.adjust=0;
global_emfloatstruct.arraysize=EMFARRAYSIZE;

global_fourierstruct.adjust=0;

global_assignstruct.adjust=0;

global_ideastruct.adjust=0;
global_ideastruct.arraysize=IDEAARRAYSIZE;

global_huffstruct.adjust=0;
global_huffstruct.arraysize=HUFFARRAYSIZE;

global_nnetstruct.adjust=0;

global_lustruct.adjust=0;

/*
** For Macintosh -- read the command line.
*/
#ifdef MAC
UCommandLine();
#endif

/*
** Handle any command-line arguments.
*/
if(argc>1)
        for(i=1;i<argc;i++)
                if(parse_arg(argv[i])==-1)
                {       display_help(argv[0]);
                        exit(0);
                }
/*
** Output header
*/
#ifdef LINUX
output_string("\nBYTEmark* Native Mode Benchmark ver. 2 (10/95)\n");
output_string("Index-split by Andrew D. Balsa (11/97)\n");
output_string("Linux/Unix* port by Uwe F. Mayer (12/96,11/97)\n");
#else
output_string("BBBBBB   YYY   Y  TTTTTTT  EEEEEEE\n");
output_string("BBB   B  YYY   Y    TTT    EEE\n");
output_string("BBB   B  YYY   Y    TTT    EEE\n");
output_string("BBBBBB    YYY Y     TTT    EEEEEEE\n");
output_string("BBB   B    YYY      TTT    EEE\n");
output_string("BBB   B    YYY      TTT    EEE\n");
output_string("BBBBBB     YYY      TTT    EEEEEEE\n\n");
output_string("\nBYTEmark (tm) Native Mode Benchmark ver. 2 (10/95)\n");
#endif
/*
** See if the user wants all stats.  Output heading info
** if so.
*/
if(global_allstats)
{
                output_string("\n");
                output_string("============================== ALL STATISTICS ===============================\n");
        time(&time_and_date);
        loctime=localtime(&time_and_date);
        sprintf(buffer,"**Date and time of benchmark run: %s",asctime(loctime));
        output_string(buffer);
        sprintf(buffer,"**Sizeof: char:%u short:%u int:%u long:%u u8:%u u16:%u u32:%u int32:%u\n",
                (unsigned int)sizeof(char),
                (unsigned int)sizeof(short),
                (unsigned int)sizeof(int),
                (unsigned int)sizeof(long),
                (unsigned int)sizeof(u8),
                (unsigned int)sizeof(u16),
                (unsigned int)sizeof(u32),
                (unsigned int)sizeof(int32));
        output_string(buffer);
#ifdef LINUX
#include "sysinfo.c"
#else
        sprintf(buffer,"**%s\n",sysname);
        output_string(buffer);
        sprintf(buffer,"**%s\n",compilername);
        output_string(buffer);
        sprintf(buffer,"**%s\n",compilerversion);
        output_string(buffer);
#endif
                output_string("=============================================================================\n");
}

/*
** Execute the tests.
*/
output_string("\nNOTE!!! Iteration display disabled to prevent diffs from failing!\n");
#ifdef LINUX
output_string("\nTEST                : Iterations/sec.  : Old Index   : New Index\n");
output_string("                    :                  : Pentium 90* : AMD K6/233*\n");
output_string("--------------------:------------------:-------------:------------\n");
#endif

for(i=0;i<NUMTESTS;i++)
{
        if(tests_to_do[i])
        {       sprintf(buffer,"%s    :",ftestnames[i]);
                                output_string(buffer);
#if 0
                if (0!=bench_with_confidence(i,
                        &bmean,
                        &bstdev,
                        &bnumrun)){
		  output_string("\n** WARNING: The current test result is NOT 95 % statistically certain.\n");
		  output_string("** WARNING: The variation among the individual results is too large.\n");
		  output_string("                    :");
		}
#endif
                for (iter = 0; iter < N_ITERATIONS; ++iter) {
                  (*funcpointer[i])();
                }
#ifdef LINUX
                sprintf(buffer," %15.5g  :  %9.2f  :  %9.2f\n",
                        bmean,bmean/bindex[i],bmean/lx_bindex[i]);
#else
		sprintf(buffer,"  Iterations/sec.: %13.2f  Index: %6.2f\n",
                        /*bmean,bmean/bindex[i],*/ 0.0, 0.0);
#endif
                output_string(buffer);
		/*
		** Gather integer or FP indexes
		*/
		if((i==4)||(i==8)||(i==9)){
		  /* FP index */
		  fpindex=fpindex*(bmean/bindex[i]);
		  /* Linux FP index */
		  lx_fpindex=lx_fpindex*(bmean/lx_bindex[i]);
		}
		else{
		  /* Integer index */
		  intindex=intindex*(bmean/bindex[i]);
		  if((i==0)||(i==3)||(i==6)||(i==7))
		    /* Linux integer index */
		    lx_intindex=lx_intindex*(bmean/lx_bindex[i]);
		  else
		    /* Linux memory index */
		    lx_memindex=lx_memindex*(bmean/lx_bindex[i]);
		}

                if(global_allstats)
                {
                        sprintf(buffer,"  Absolute standard deviation: %g\n",bstdev);
                        output_string(buffer);
			if (bmean>(double)1e-100){
			  /* avoid division by zero */
			  sprintf(buffer,"  Relative standard deviation: %g %%\n",
				  (double)100*bstdev/bmean);
			  output_string(buffer);
			}
                        sprintf(buffer,"  Number of runs: %lu\n",bnumrun);
                        output_string(buffer);
                        show_stats(i);
                        sprintf(buffer,"Done with %s\n\n",ftestnames[i]);
                        output_string(buffer);
                }
        }
}
/* printf("...done...\n"); */

/*
** Output the total indexes
*/
if(global_custrun==0)
{
        output_string("==========================ORIGINAL BYTEMARK RESULTS==========================\n");
        sprintf(buffer,"INTEGER INDEX       : %.3f\n",
                       /*pow(intindex,(double).142857)*/ 0.0);
        output_string(buffer);
        sprintf(buffer,"FLOATING-POINT INDEX: %.3f\n",
                        /*pow(fpindex,(double).33333)*/ 0.0);
        output_string(buffer);
        output_string("Baseline (MSDOS*)   : Pentium* 90, 256 KB L2-cache, Watcom* compiler 10.0\n");
#ifdef LINUX
        output_string("==============================LINUX DATA BELOW===============================\n");
	hardware(write_to_file, global_ofile);
#include "sysinfoc.c"
        sprintf(buffer,"MEMORY INDEX        : %.3f\n",
                       pow(lx_memindex,(double).3333333333));
        output_string(buffer);
        sprintf(buffer,"INTEGER INDEX       : %.3f\n",
                       pow(lx_intindex,(double).25));
        output_string(buffer);
        sprintf(buffer,"FLOATING-POINT INDEX: %.3f\n",
                        pow(lx_fpindex,(double).3333333333));
        output_string(buffer);
        output_string("Baseline (LINUX)    : AMD K6/233*, 512 KB L2-cache, gcc 2.7.2.3, libc-5.4.38\n");
#endif
output_string("* Trademarks are property of their respective holder.\n");
}

exit(0);
}
예제 #7
0
int main(int ac, char **av)
{
	int c, i, nnodes=0;
	long node=-1;
	char *end;
	char shortopts[array_len(opts)*2 + 1];
	struct bitmask *mask = NULL;

	get_short_opts(opts,shortopts);
	while ((c = getopt_long(ac, av, shortopts, opts, NULL)) != -1) {
		switch (c) {
		case 's': /* --show */
			show();
			exit(0);
		case 'H': /* --hardware */
			nopolicy();
			hardware();
			exit(0);
		case 'i': /* --interleave */
			checknuma();
			mask = numactl_parse_nodestring(optarg);
			if (!mask) {
				printf ("<%s> is invalid\n", optarg);
				usage();
			}

			errno = 0;
			setpolicy(MPOL_INTERLEAVE);
			if (shmfd >= 0)
				numa_interleave_memory(shmptr, shmlen, mask);
			else
				numa_set_interleave_mask(mask);
			checkerror("setting interleave mask");
			break;
		case 'N': /* --cpunodebind */
		case 'c': /* --cpubind */
			dontshm("-c/--cpubind/--cpunodebind");
			checknuma();
			mask = numactl_parse_nodestring(optarg);
			if (!mask) {
				printf ("<%s> is invalid\n", optarg);
				usage();
			}
			errno = 0;
			check_cpubind(do_shm);
			did_cpubind = 1;
			numa_run_on_node_mask(mask);
			checkerror("sched_setaffinity");
			break;
		case 'C': /* --physcpubind */
		{
			struct bitmask *cpubuf;
			dontshm("-C/--physcpubind");
			cpubuf = numa_parse_cpustring(optarg);
			if (!cpubuf) {
				printf ("<%s> is invalid\n", optarg);
				usage();
			}
			errno = 0;
			check_cpubind(do_shm);
			did_cpubind = 1;
			numa_sched_setaffinity(0, cpubuf);
			checkerror("sched_setaffinity");
			free(cpubuf);
			break;
		}
		case 'm': /* --membind */
			checknuma();
			setpolicy(MPOL_BIND);
			mask = numactl_parse_nodestring(optarg);
			if (!mask) {
				printf ("<%s> is invalid\n", optarg);
				usage();
			}
			errno = 0;
			numa_set_bind_policy(1);
			if (shmfd >= 0) {
				numa_tonodemask_memory(shmptr, shmlen, mask);
			} else {
				numa_set_membind(mask);
			}
			numa_set_bind_policy(0);
			checkerror("setting membind");
			break;
		case 'p': /* --preferred */
			checknuma();
			setpolicy(MPOL_PREFERRED);
			mask = numactl_parse_nodestring(optarg);
			if (!mask) {
				printf ("<%s> is invalid\n", optarg);
				usage();
			}
			for (i=0; i<mask->size; i++) {
				if (numa_bitmask_isbitset(mask, i)) {
					node = i;
					nnodes++;
				}
			}
			if (nnodes != 1)
				usage();
			numa_bitmask_free(mask);
			errno = 0;
			numa_set_bind_policy(0);
			if (shmfd >= 0)
				numa_tonode_memory(shmptr, shmlen, node);
			else
				numa_set_preferred(node);
			checkerror("setting preferred node");
			break;
		case 'l': /* --local */
			checknuma();
			setpolicy(MPOL_DEFAULT);
			errno = 0;
			if (shmfd >= 0)
				numa_setlocal_memory(shmptr, shmlen);
			else
				numa_set_localalloc();
			checkerror("local allocation");
			break;
		case 'S': /* --shm */
			check_cpubind(did_cpubind);
			nopolicy();
			attach_sysvshm(optarg, "--shm");
			shmattached = 1;
			break;
		case 'f': /* --file */
			check_cpubind(did_cpubind);
			nopolicy();
			attach_shared(optarg, "--file");
			shmattached = 1;
			break;
		case 'L': /* --length */
			noshm("--length");
			shmlen = memsize(optarg);
			break;
		case 'M': /* --shmmode */
			noshm("--shmmode");
			shmmode = strtoul(optarg, &end, 8);
			if (end == optarg || *end)
				usage();
			break;
		case 'd': /* --dump */
			if (shmfd < 0)
				complain(
				"Cannot do --dump without shared memory.\n");
			dump_shm();
			do_dump = 1;
			break;
		case 'D': /* --dump-nodes */
			if (shmfd < 0)
				complain(
			    "Cannot do --dump-nodes without shared memory.\n");
			dump_shm_nodes();
			do_dump = 1;
			break;
		case 't': /* --strict */
			did_strict = 1;
			numa_set_strict(1);
			break;
		case 'I': /* --shmid */
			shmid = strtoul(optarg, &end, 0);
			if (end == optarg || *end)
				usage();
			break;

		case 'u': /* --huge */
			noshm("--huge");
			shmflags |= SHM_HUGETLB;
			break;

		case 'o':  /* --offset */
			noshm("--offset");
			shmoffset = memsize(optarg);
			break;			

		case 'T': /* --touch */
			needshm("--touch");
			check_shmbeyond("--touch");
			numa_police_memory(shmptr, shmlen);
			break;

		case 'V': /* --verify */
			needshm("--verify");
			if (set_policy < 0)
				complain("Need a policy first to verify");
			check_shmbeyond("--verify");
			numa_police_memory(shmptr, shmlen);
			if (!mask)
				complain("Need a mask to verify");
			else
				verify_shm(set_policy, mask);
			break;

		default:
			usage();
		}
	}

	av += optind;
	ac -= optind;

	if (shmfd >= 0) {
		if (*av)
			usage();
		exit(exitcode);
	}

	if (did_strict)
		fprintf(stderr,
			"numactl: warning. Strict flag for process ignored.\n");

	if (do_dump)
		usage_msg("cannot do --dump|--dump-shm for process");

	if (shmoption)
		usage_msg("shm related option %s for process", shmoption);
	
	if (*av == NULL)
		usage();
	execvp(*av, av);
	complain("execution of `%s': %s\n", av[0], strerror(errno));
	return 0; /* not reached */
}
예제 #8
0
void Connection::socketData() {

    int toRead;
    int bytesRead=0;
    int thisRead=0;
    int version;
    int subversion;
    int header_size=0;
    int answer_size=0;
    char* ans;
    QString answer;

    if (bytes < 0) {
        //fprintf(stderr,"QtRadio: FATAL: INVALID byte counter: %d\n", bytes);
        //tcpSocket->close();
        return;
    }            
    toRead=tcpSocket->bytesAvailable();
    if (toRead <= 0) {
        return;
    }
    while(bytesRead<toRead) {
        //fprintf (stderr, "%d of %d [%d]\n", bytesRead, toRead, state);
        switch(state) {
        case READ_HEADER_TYPE:
            thisRead=tcpSocket->read(&hdr[bytes],3 - bytes);
            if (thisRead < 0) {
               fprintf(stderr,"QtRadio: FATAL: READ_AUDIO_HEADER: error in read: %d\n", thisRead);
               tcpSocket->close();
               return;
            }
            bytes+=thisRead;
            if (bytes == 3){

                switch(hdr[0]) {
                    case AUDIO_BUFFER:
                        state=READ_AUDIO_HEADER;
                        break;
                    case SPECTRUM_BUFFER:
                        version=hdr[1];
                        subversion=hdr[2];
                        switch(version) {
                            case 2:
                                switch(subversion) {
                                    case 0:
                                        header_size=HEADER_SIZE_2_0;
                                        break;
                                    case 1:
                                        header_size=HEADER_SIZE_2_1;
                                        break;
                                    default:
                                        fprintf(stderr,"QtRadio: Invalid subversion. Expected %d.%d got %d.%d\n",HEADER_VERSION,HEADER_SUBVERSION,version,subversion);
                                        break;
                                }
                                break;
                            default:
                                fprintf(stderr,"QtRadio: Invalid version. Expected %d.%d got %d.%d\n",HEADER_VERSION,HEADER_SUBVERSION,version,subversion);
                                break;
                        }
                        state=READ_HEADER;
                        break;
                   case BANDSCOPE_BUFFER:
                        break;

                   case RTP_REPLY_BUFFER:
                        state=READ_RTP_REPLY;
                        break;
                   case 52: //ANSWER_BUFFER
                        // answer size is in hdr pos 1 & 2 max 99
                        state = READ_ANSWER;
                        bytes = 0;
                        answer_size = atoi(hdr) - 400 ; // 1st digt is buffer type 4
                        ans = (char*)malloc(answer_size +1);
                        break;
                }
            }
            break;

        case READ_AUDIO_HEADER:
            //fprintf (stderr, "READ_AUDIO_HEADER: hdr size: %d bytes: %d\n", AUDIO_HEADER_SIZE, bytes);
            thisRead=tcpSocket->read(&hdr[bytes],AUDIO_HEADER_SIZE - bytes);
            if (thisRead < 0) {
               fprintf(stderr,"QtRadio: FATAL: READ_AUDIO_HEADER: error in read: %d\n", thisRead);
               tcpSocket->close();
               return;
            }
            bytes+=thisRead;
            if (bytes == AUDIO_HEADER_SIZE){
// g0orx binary header
                //length = atoi(&hdr[AUDIO_LENGTH_POSITION]);
                length=((hdr[3]&0xFF)<<8)+(hdr[4]&0xFF);
                buffer = (char*)malloc(length);
                bytes = 0;
                state = READ_BUFFER;
            }
            break;

         case READ_HEADER:
            //fprintf (stderr, "READ_HEADER: hdr size: %d bytes: %d\n", header_size, bytes);
            thisRead=tcpSocket->read(&hdr[bytes],header_size - bytes);
            if (thisRead < 0) {
               fprintf(stderr,"QtRadio: FATAL: READ_HEADER: error in read: %d\n", thisRead);
               tcpSocket->close();
               return;
            }
            bytes+=thisRead;
            if(bytes==header_size) {
// g0orx binary header
                length=((hdr[3]&0xFF)<<8)+(hdr[4]&0xFF);
                if ((length < 0) || (length > 4096)){
                        state = READ_HEADER_TYPE;
                }
                else {
                    buffer=(char*)malloc(length);
                    bytes=0;
                    state=READ_BUFFER;
                }
            }
            break;

        case READ_BUFFER:
            //fprintf (stderr, "READ_BUFFER: length: %d bytes: %d\n", length, bytes);
            thisRead=tcpSocket->read(&buffer[bytes],length-bytes);
            if (thisRead < 0) {
               fprintf(stderr,"QtRadio: FATAL: READ_BUFFER: error in read: %d\n", thisRead);
               tcpSocket->close();
               return;
            }
            bytes+=thisRead;
            //qDebug() << "READ_BUFFER: read " << bytes << " of " << length;
            if(bytes==length) {
                version=hdr[1];
                subversion=hdr[2];
                queue.enqueue(new Buffer(hdr,buffer));
                QTimer::singleShot(0,this,SLOT(processBuffer()));
                hdr=(char*)malloc(HEADER_SIZE_2_1);
                bytes=0;
                state=READ_HEADER_TYPE;
            }
            break;

        case READ_RTP_REPLY:
            thisRead=tcpSocket->read(&hdr[bytes],7-bytes); // length and port
            bytes+=thisRead;
            if(bytes==7) {
                /*
                int port;
                port=((hdr[5]&0xFF)<<8) + (hdr[6]&0xFF);
                // configure this ends rtp so we can send to remote
qDebug() << "Connection emit remoteRTP "<<host<<":"<<port;
                emit remoteRTP((char*)host.toUtf8().constData(),port);
                */
                bytes=0;
                state=READ_HEADER_TYPE;
            }
            break;

        case READ_ANSWER:
            //qDebug() << "Connection READ ANSWER";
            thisRead=tcpSocket->read(&ans[bytes],answer_size - bytes);
            if (thisRead < 0) {
               fprintf(stderr,"QtRadio: FATAL: READ_BUFFER: error in read: %d\n", thisRead);
               tcpSocket->close();
               return;
            }
            bytes+=thisRead;
            if(bytes==answer_size) {
                //fprintf(stderr,"ans length = %lu\n",strlen(ans));
                ans[answer_size] = '\0';
                answer = ans;
                QRegExp rx;
                if(answer.contains("q-version")){
                    //"20120107;-rxtx-rtp"; YYYYMMDD; text desc
                    rx.setPattern(":(\\d+);-(\\S+)");
                    rx.indexIn(answer);
#if QT_VERSION >= 0x050000
                    emit setdspversion(rx.cap(1).toLong(),rx.cap(2).toUtf8());
#else
                    emit setdspversion(rx.cap(1).toLong(),rx.cap(2).toAscii());
#endif
                    serverver = rx.cap(1).toLong();
                    if (serverver < 20120201){  // tx login start
                       emit setCanTX(true);  //server to old to tell
                    }
                    sendCommand("q-master");
                }else if(answer.contains("q-server")){
                    rx.setPattern("q-server:(\\S+)");
                    rx.indexIn(answer);
                    QString servername = rx.cap(1);
                    emit setservername(servername);
                    rx.setPattern("([YNP])$"); // Y no checking, N no TX, P depend who  and where we are
                    rx.indexIn(answer);
                    QString hasTX = rx.cap(1);
                    if (hasTX.compare("N") == 0){
                        emit setCanTX(false);
                    }else if(hasTX.compare("P") == 0){
                        emit setCanTX(false);
                        emit setChkTX(true);
                    }else{  // must be yes
                        //qDebug() <<"Yes Master";
                        if (amSlave){
                            emit setCanTX(false);
                            emit setChkTX(false);
                        }else{
                            emit setCanTX(true);
                            emit setChkTX(false);
                        }
                    }
                }else if(answer.contains("q-master")){
                    //qDebug() << "q-master:" << answer;
                    if (answer.contains("slave")){
                        amSlave = true;
                        emit printStatusBar("  ...Slave Mode. ");
                    }else{
                        amSlave = false;
                        emit printStatusBar("  ...Master Mode. ");
                    }
                }else if(answer.contains("q-rtpport")){
                    rx.setPattern("rtpport:(\\d+);");
                    rx.indexIn(answer);
                    QString p = rx.cap(1);
                    emit setRemoteRTPPort(host,p.toInt());
                }else if(answer.contains("q-cantx:")){
                    rx.setPattern("([YN])$");
                    rx.indexIn(answer);
                    QString TXNow= rx.cap(1);
                    if (TXNow.compare("Y") == 0){
                        emit setCanTX(true);
                    }else{
                        emit setCanTX(false);
                    }

                }else if(answer.contains("q-loffset:")){
                    rx.setPattern("q-loffset:(\\d+)\\.");
                    rx.indexIn(answer);
                    double loffset= rx.cap(1).toDouble();
                    emit resetbandedges(loffset);

                }else if(answer.contains("q-info")){
                    rx.setPattern("info:s;(\\d+);f;(\\d+);m;(\\d+);z;(\\d+);l;(\\d+|-\\d+);r;(\\d+|-\\d+)");
                    rx.indexIn(answer);
                    QString f = rx.cap(2);
                    QString m = rx.cap(3);
                    QString z = rx.cap(4);
                    QString l = rx.cap(5);
                    QString r = rx.cap(6);
                    long long newf = f.toLongLong();
                    int newmode = m.toInt();
                    int zoom = z.toInt();
                    int left = l.toInt();
                    int right = r.toInt();
                    emit slaveSetFreq(newf);
                    emit slaveSetFilter(left, right);
                    emit slaveSetZoom(zoom);
                    if(newmode != lastMode){
                      emit slaveSetMode(newmode);
                    }


                    lastFreq = newf;
                    lastMode = newmode;

                } else if (answer.contains("q-protocol3")){
                    rx.setPattern("([YN])$");
                    rx.indexIn(answer);
                    QString protocol3= rx.cap(1);
                    if (protocol3.compare("Y") == 0){
                        emit setProtocol3(true);
                        emit setFPS();
                    }
                } else if (answer[0] == '*') {
                    qDebug() << "--------------->" << answer;
                    
                    emit hardware (QString(answer));
                }

                //answer.prepend("  Question/Answer ");
                //emit printStatusBar(answer);
                qDebug() << "ANSWER bytes "<< bytes <<" answer "<< ans;
                free(ans);
                bytes=0;
                state=READ_HEADER_TYPE;
            }
            break;

        default:
            fprintf (stderr, "FATAL: WRONG STATUS !!!!!\n");         
        }
        bytesRead+=thisRead;
    }
}