sct.c

应用平台 Unix/Linux <br> sct(Serial Communication Tracer的缩写)是一个很有用的Linux/Unix串行通信调试工具

	
	//init buf
	if (!bufstat[bufno].used) {
		bufstat[bufno].buf = malloc(MAXBUFSIZE);
		bufstat[bufno].used = true;
	}
	bufstat[bufno].size = 0;
	
	//set terminal to nonblock and raw mode
	tio_saveset(STDIN_FILENO, &in_tios);
	tio_raw(STDIN_FILENO);
	//setbuf as ascii form
	if (inpmode == INP_ASC) {
		printf("Set buf as ascii form\x0d\x0a");
		printf("Enter text and input Ctrl-Z for end\x0d\x0a");
		i = 0;
		while(i<MAXBUFSIZE) {
			if (read(STDIN_FILENO,&ch,1) > 0) {
				if (ch == 26)
					break;
				write(STDOUT_FILENO,&ch,1);
				bufstat[bufno].buf[i++] = ch;
				if (ch == 0x0d) {
					bufstat[bufno].buf[i++] = 0x0a;
					write(STDOUT_FILENO,"\x0a",1);
				}
			}
		}
		bufstat[bufno].size=i;	
	} else {
		printf("Set buf as hex form\x0d\x0a");
		printf("Enter hex data and input Ctrl-Z for end\x0d\x0a");
		i = 0;
		while(i<MAXBUFSIZE) {
			if (read(STDIN_FILENO,&ch,1) > 0) {
				if (ch == 26)
					break;
				if (!isxdigit(ch))
					continue;
				write(STDOUT_FILENO,&ch,1);
				buf[i++] = ch;
			}
		}
		if(i%2) {
			printf("\x0d\x0alength of hex bits is not multiple to 2\x0d\x0a");
	       		printf("Fail to set data to the buf");
		} else if(i>0) {
			ascs2hex(bufstat[bufno].buf, buf, i);
			bufstat[bufno].size = i/2;
		}
	}	
	tio_reset(STDIN_FILENO, &in_tios);
	printf("\nBuf %d setted %d bytes\n",bufno,bufstat[bufno].size);
}

void cmd_dispbuf(int parc, char *parv[])
{
	int i,totbuf,bufno;
	totbuf=0;
	if (parc == 1) {
		for (i=0;i<MAXBUFS;i++)
			if(bufstat[i].used) totbuf++;
		printf("Used %d bufs inall\n",totbuf);
		for(i=0;i<MAXBUFS;i++)
			if(bufstat[i].used)
				printf("Buf %d, Used, Size = %d\n",i,bufstat[i].size);
			else
				printf("Buf %d, Unused\n",i);
	} else if (parc == 2) {
		bufno=atoi(parv[1]);
		if ( (bufno < 0) || (bufno>MAXBUFS)) {
			printf("BufNo out of range\n");
			return;
		}
		if (bufstat[bufno].used)
			disp_hexasc(bufstat[bufno].buf, bufstat[bufno].size);
		else
			printf("Buf %d unused\n",bufno);
	
	} else {
		deal_with_errarg();
	}		

}

void cmd_send(int parc, char *parv[])
{
	int bufno;
	if (parc != 2)
		deal_with_errarg();
	
	bufno=atoi(parv[1]);
	if (bufno<0 || bufno>MAXBUFS) {
		printf("Buffer_no must be 0 to %d",MAXBUFS-1);
		return;
	}
	
	if (!bufstat[bufno].used) {
		printf("No Data in buf\n");
		return;
	}
	
	if (!devstat.opened) {
		printf("Please open port first\n");
		return;
	}

	printf("Sending %d bytes in Buf %d ...\n",bufstat[bufno].size,bufno);
	write(devstat.fd, bufstat[bufno].buf, bufstat[bufno].size);
	printf("Send done\n");
}

void cmd_recv(int parc, char *parv[])
{
	int bufno,totrcv,res,i;
	fd_set readset,writeset;
	bool stop;
	struct termios in_tios, out_tios;
	char key,outch[10];
	unsigned char buf[256];
	if (parc != 2)
		deal_with_errarg();
	
	bufno = atoi(parv[1]);
	if (bufno < 0 || bufno > MAXBUFS) {
		printf("Buffer_no must be 0 to %s\n",MAXBUFS-1);
		return;
	}
	
	if (!devstat.opened) {
		printf("Please open port first\n");
		return;
	}
	
	if(!bufstat[bufno].used) {
		bufstat[bufno].buf = malloc(MAXBUFSIZE);
		bufstat[bufno].used = true;
	}
	bufstat[bufno].size = 0;
	
	printf("Start receive now, input 'Ctrl-C' for break\n");

	tio_saveset(STDOUT_FILENO, &out_tios);
	tio_raw(STDOUT_FILENO);
	
	FD_ZERO(&readset);
	FD_ZERO(&writeset);
	
	stop = false;
	totrcv = 0;
	while (!stop) {
		FD_SET(STDIN_FILENO, &readset);
		FD_SET(devstat.fd, &readset);
		if ( (select(devstat.fd+1, &readset, &writeset, NULL, NULL) < 0)){
			stop = true;
			continue;
		}
		if (FD_ISSET(devstat.fd, &readset)) {
			res = read(devstat.fd, buf, sizeof(buf));
			memcpy(&bufstat[bufno].buf[totrcv], buf, res);
			for (i = 0; i < res; i++) {
				if(!(totrcv % 24))
					write(STDOUT_FILENO,"\x0d\x0a",2);
				sprintf(outch,"%02X ",buf[i]);
				write(STDOUT_FILENO,outch,strlen(outch));
				totrcv++;
			}
			bufstat[bufno].size = totrcv;
		}
		if ( FD_ISSET(STDIN_FILENO, &readset)) {
			read(STDIN_FILENO, &key, 1); 
			if(key == 3) {	//ctrl-c
				stop = true;
				sleep(1);
			}
		}
	}//end of while			
	
	tio_reset(STDOUT_FILENO, &out_tios);
	printf("\nReceive stopped,%d bytes received into buffer %d inall\n",totrcv,bufno);
	
}

bool load_deflcfg()
{
	bool ret = false;
	int fd;
	FILE *fp;
	struct stat buf;
	mode_t mode;

	//default set
	memset(&defl_devstat,0,sizeof(defl_devstat));
	strcpy(devstat.devname,"/dev/ttyS0");
	strcpy(devstat.frameset,"9600,n,8,1");
	devstat.opened = false;
	devstat.hsflag = 0;
	
	if (stat(FPATH_CONF,&buf) != 0) { //create new config file
		printf("\nCreat config file \\etc\\sct.conf ");
		mode = umask(0);
		fd = creat(FPATH_CONF,S_IRUSR
				|S_IWUSR
				|S_IRGRP
				|S_IWGRP
				|S_IROTH
				|S_IWOTH);
		umask(mode);
		if(fd<0) {
			printf("Fail\n");
			ret = false;
		} else {
			printf("OK\n");
			close(fd);
			fp = fopen(FPATH_CONF,"a+");
			fprintf(fp,"%s\n",devstat.devname);
			fprintf(fp,"%s\n",devstat.frameset);
			memcpy(&defl_devstat,&devstat,sizeof(devstat));
			fclose(fp);
			ret = true;
		}
	} else { //read config file
        	fp = fopen(FPATH_CONF,"r");
		if(fp == NULL) {
			printf("\nFail to open config file\n");
			ret = false;
		}	
		if( fgets(defl_devstat.devname,sizeof(devstat.devname),fp)
			&& fgets(defl_devstat.frameset,
				sizeof(devstat.frameset),fp)) {
			//trim '\n'
			defl_devstat.devname[strlen(defl_devstat.devname)-1]=0;
			defl_devstat.frameset[strlen(defl_devstat.frameset)-1]=0;
			memcpy(&devstat,&defl_devstat,sizeof(devstat));
			fclose(fp);
			ret = true;
		} else {
			fclose(fp);
			ret = false;
		}	
	}
	printf("\nCurrent port: %s\n",devstat.devname);
	printf("Frameset: %s\n",devstat.frameset);
	return true;
}

void update_deflcfg()
{
	FILE *fp;
	if(strcmp(defl_devstat.devname,devstat.devname)
		|| strcmp(defl_devstat.frameset,devstat.frameset)){
		fp = fopen(FPATH_CONF,"w+");
		fprintf(fp,"%s\n",devstat.devname);
		fprintf(fp,"%s\n",devstat.frameset);
		fclose(fp);
	}
		
}

void init_buf()
{
	int i;
	for(i=0;i<MAXBUFS;i++) {
		bufstat[i].used=false;
		bufstat[i].size=0;
	}
}




void cmd_sendrecv(int parc, char *parv[])
{
	
	char *parv_send[2];
	char *parv_recv[2];
	int send_bufno,recv_bufno;
	if(parc!=3)
		deal_with_errarg();
	
	send_bufno = atoi(parv[1]);
	recv_bufno = atoi(parv[2]);
	
	if(send_bufno<0 || send_bufno>=MAXBUFS) {
		printf("Buffer no bust be 0 to %d",MAXBUFS-1);
		return;
	}
	
	if(recv_bufno<0 || send_bufno>=MAXBUFS) {
		printf("Buffer no bust be 0 to %d",MAXBUFS-1);
		return;
	}
	
	parv_send[0] = NULL;
	parv_send[1] = parv[1];
	parv_recv[0] = NULL;
	parv_recv[1] = parv[2];
	cmd_send(2,parv_send);
	cmd_recv(2,parv_recv);
}

void cmd_loadbuf(int parc, char *parv[])
{
	FILE *f;
	int dest_bufno,flen;
	char src_fpath[256];
	struct stat buf;
	if(parc != 3)
		deal_with_errarg();
	strcpy(src_fpath,parv[2]);
	dest_bufno = atoi(parv[1]);
	
	if(stat(src_fpath,&buf) == 0) {
		flen = buf.st_size;
		if (flen == 0) {
			printf("The file is empty!\n");
			return;
		} else if(flen>MAXBUFSIZE) {
			printf("The file size must less than %d bytes",MAXBUFSIZE);
			return;
		}	
	} else {
		printf("Can not stat file or the file does not exist!\n");
		return;
	}	

	f = fopen(src_fpath,"r");
	if (f == NULL) {
		printf("Fail to open file %s\nFile error = %s\n",src_fpath,strerror(errno));
		return;
	}
	
	if (!bufstat[dest_bufno].used) {
		bufstat[dest_bufno].buf = malloc(MAXBUFSIZE);
		bufstat[dest_bufno].used = true;
	}
	bufstat[dest_bufno].size = 0;
	
	if (fread(bufstat[dest_bufno].buf,1,flen,f) != flen) 
		printf("Fail to load file to buf\n");
	else {
		printf("%d bytes of data from file %s has been loaded to buf %d\n",flen,src_fpath,dest_bufno);
		bufstat[dest_bufno].size = flen;
	}
	fclose(f);
}

void cmd_savebuf(int parc, char *parv[])
{
	FILE *f;
	int src_bufno;
	char dest_fpath[256];
	if (parc != 3)
		deal_with_errarg();
	strcpy(dest_fpath,parv[1]);
	src_bufno = atoi(parv[2]);
	
	if (!bufstat[src_bufno].used) {
		printf("Source buf is empty,no data to save!\n");
		return;
	}
			
	f = fopen(dest_fpath,"w");
	if (f == NULL) {
		printf("Fail to create file %s for saving buf\nFile error: %s",dest_fpath,strerror(errno));
		return;
	} 
	if (fwrite(bufstat[src_bufno].buf,1,bufstat[src_bufno].size,f) != bufstat[src_bufno].size)
		printf("Fail to save data to file!\n");
	else
		printf("Buf %d has been saved to file %s\n", src_bufno,dest_fpath);
	fclose(f);
}

void cmd_copybuf(int parc, char *parv[])
{
	int dest_bufno,src_bufno;
	if (parc != 3)
		deal_with_errarg();
	dest_bufno = atoi(parv[1]);
	src_bufno = atoi(parv[2]);
	if (dest_bufno >= MAXBUFS 
		|| dest_bufno < 0
		|| src_bufno >= MAXBUFS
		|| src_bufno < 0)
		printf("the buffer_no not exist!\n");
	else if (!bufstat[src_bufno].used)
		printf("source buf is empty,no data to copy!");
	else {
		if (!bufstat[dest_bufno].used) {
			bufstat[dest_bufno].buf = malloc(MAXBUFSIZE);
			bufstat[dest_bufno].used = true;
			bufstat[dest_bufno].size = 0;
		}
		memcpy(bufstat[dest_bufno].buf,
			bufstat[src_bufno].buf,
			bufstat[src_bufno].size);
		bufstat[dest_bufno].size = bufstat[src_bufno].size;
	}	
}

void cmd_clrbuf(int parc, char *parv[])
{
	int dest_bufno,i;
	if (parc != 2)
		deal_with_errarg();
	
	if (!strcmp(parv[1],"all")) {
		for(i=0;i<MAXBUFS;i++) {
			if(bufstat[i].used) {
				free(bufstat[i].buf);
				bufstat[i].used = false;
				bufstat[i].size = 0;
			}
		}
	} else {
		dest_bufno = atoi(parv[1]);
		if (dest_bufno >= 0 && dest_bufno < MAXBUFS) {
			bufstat[dest_bufno].used = false;
			bufstat[dest_bufno].size = 0;
			free(bufstat[dest_bufno].buf);
		} else  
			printf("the buffer_no not exist!\n");
	}
}