[libftdi] / examples / stream_test.c

/* stream_test.c
 *
 * Test reading  from FT2232H in synchronous FIFO mode.
 *
 * The FT2232H must supply data due to an appropriate circuit
 *
 * To check for skipped block with appended code, 
 *     a structure as follows is assumed
 * 1* uint32_t num (incremented in 0x4000 steps)
 * 3* uint32_t dont_care
 *
 * After start, data will be read in streaming until the program is aborted
 * Progess information wil be printed out
 * If a filename is given on the command line, the data read will be
 * written to that file
 *
 */
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>
#include <getopt.h>
#include <signal.h>
#include <errno.h>
#include <ftdi.h>
void check_outfile(char *);

static FILE *outputFile;

static int check = 1;
static int exitRequested = 0;
/*
 * sigintHandler --
 *
 *    SIGINT handler, so we can gracefully exit when the user hits ctrl-C.
 */

static void
sigintHandler(int signum)
{
   exitRequested = 1;
}

static void
usage(const char *argv0)
{
   fprintf(stderr,
           "Usage: %s [tions...] \n"
           "Test streaming read from FT2232H\n"
           "[-P string] only look for product with given string"
           "[-n] don't check for special block structure"
           "\n"
           "If some filename is given, write data read to that file\n"
           "Progess information is printed each second\n"
           "Abort with ^C\n"
           "\n"
           "Options:\n"
           "\n"
           "Copyright (C) 2009 Micah Dowty <micah@navi.cx>\n",
           "Adapted for use with libftdi (C) 2010 Uwe Bonnes <bon@elektron.ikp.physik.tu-darmstadt.de>\n",
           argv0);
   exit(1);
}

static uint32_t start = 0;
static uint32_t offset = 0;
static uint64_t blocks = 0;
static uint32_t skips = 0;
static uint32_t n_err = 0;
static int
readCallback(uint8_t *buffer, int length, FTDIProgressInfo *progress, void *userdata)
{
   if (length)
   {
       if (check)
       {
           int i,rem;
           uint32_t num;
           for (i= offset; i<length-16; i+=16)
           {
               num = *(uint32_t*) (buffer+i);
               if (start && (num != start +0x4000))
               {
                   uint32_t delta = ((num-start)/0x4000)-1;
                   fprintf(stderr, "Skip %7d blocks from 0x%08x to 0x%08x at blocks %10lld \n",
                           delta, start -0x4000, num, blocks);
                   n_err++;
                   skips += delta;
               }
               blocks ++;
               start = num;
           }
           rem = length -i;
           if (rem >3)
           {
               num = *(uint32_t*) (buffer+i);
               if (start && (num != start +0x4000))
               {
                   uint32_t delta = ((num-start)/0x4000)-1;
                   fprintf(stderr, "Skip %7d blocks from 0x%08x to 0x%08x at blocks %10lld \n",
                           delta, start -0x4000, num, blocks);
                   n_err++;
                   skips += delta;
               }
               start = num;
           }
           else if (rem)
               start += 0x4000;
           if (rem != 0);
           {
               blocks ++;
               offset = 16-rem;
           }
       }
       if (outputFile)
       {
           if (fwrite(buffer, length, 1, outputFile) != 1)
           {
               perror("Write error");
               return 1;
           }
       }
   }
   if (progress)
   {
       fprintf(stderr, "%10.02fs total time %9.3f MiB captured %7.1f kB/s curr rate %7.1f kB/s totalrate %d dropouts\n",
               progress->totalTime,
               progress->current.totalBytes / (1024.0 * 1024.0),
               progress->currentRate / 1024.0,
               progress->totalRate / 1024.0,
               n_err);
   }
   return exitRequested ? 1 : 0;
}

int main(int argc, char **argv)
{
   struct ftdi_context ftdic;
   int err, c;
   FILE *of = NULL;
   char const *outfile  = 0;
   outputFile =0;
   exitRequested = 0;
   char *descstring = NULL;
   int option_index;
   static struct option long_options[] = {{NULL},};

   while ((c = getopt_long(argc, argv, "P:n", long_options, &option_index)) !=- 1)
       switch (c) 
       {
       case -1:
           break;
       case 'P':
           descstring = optarg;
           break;
       case 'n':
           check = 0;
           break;
       default:
           usage(argv[0]);
       }
   
   if (optind == argc - 1)
   {
       // Exactly one extra argument- a dump file
       outfile = argv[optind];
   }
   else if (optind < argc)
   {
       // Too many extra args
       usage(argv[0]);
   }
   
   if (ftdi_init(&ftdic) < 0)
   {
       fprintf(stderr, "ftdi_init failed\n");
       return EXIT_FAILURE;
   }
   
   if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0)
   {
       fprintf(stderr, "ftdi_set_interface failed\n");
       return EXIT_FAILURE;
   }
   
   if (ftdi_usb_open_desc(&ftdic, 0x0403, 0x6010, descstring, NULL) < 0)
   {
       fprintf(stderr,"Can't open ftdi device: %s\n",ftdi_get_error_string(&ftdic));
       return EXIT_FAILURE;
   }
   
   /* A timeout value of 1 results in may skipped blocks */
   if(ftdi_set_latency_timer(&ftdic, 2))
   {
       fprintf(stderr,"Can't set latency, Error %s\n",ftdi_get_error_string(&ftdic));
       return EXIT_FAILURE;
   }
   
/*   if(ftdi_usb_purge_rx_buffer(&ftdic) < 0)
   {
       fprintf(stderr,"Can't rx purge\n",ftdi_get_error_string(&ftdic));
       return EXIT_FAILURE;
       }*/
   if (outfile)
       if ((of = fopen(outfile,"w+")) == 0)
           fprintf(stderr,"Can't open logfile %s, Error %s\n", outfile, strerror(errno));
   if (of)
       if (setvbuf(of, NULL, _IOFBF , 1<<16) == 0)
           outputFile = of;
   signal(SIGINT, sigintHandler);
   
   err = ftdi_readstream(&ftdic, readCallback, NULL, 8, 256);
   if (err < 0 && !exitRequested)
       exit(1);
   
   if (outputFile) {
       fclose(outputFile);
       outputFile = NULL;
   }
   fprintf(stderr, "Capture ended.\n");
   
   if (ftdi_set_bitmode(&ftdic,  0xff, BITMODE_RESET) < 0)
   {
       fprintf(stderr,"Can't set synchronous fifo mode, Error %s\n",ftdi_get_error_string(&ftdic));
       return EXIT_FAILURE;
   }
   ftdi_usb_close(&ftdic);
   ftdi_deinit(&ftdic);
   signal(SIGINT, SIG_DFL);
   if (check && outfile)
   {
       if ((outputFile = fopen(outfile,"r")) == 0)
       {
           fprintf(stderr,"Can't open logfile %s, Error %s\n", outfile, strerror(errno));
           return EXIT_FAILURE;
       }
       check_outfile(descstring);
       fclose(outputFile);
   }
   else if (check)
       fprintf(stderr,"%d errors of %lld blocks (%Le), %d (%Le) blocks skipped\n",
               n_err, blocks, (long double)n_err/(long double) blocks,
               skips, (long double)skips/(long double) blocks);
   exit (0);
}

void check_outfile(char *descstring)
{
    if(strcmp(descstring,"FT2232HTEST") == 0)
    {
       char buf0[1024];
       char buf1[1024];
       char bufr[1024];
       char *pa, *pb, *pc;
       unsigned int num_lines = 0, line_num = 1;
       int err_count = 0;
       unsigned int num_start, num_end;

       pa = buf0;
       pb = buf1;
       pc = buf0;
       if(fgets(pa, 1023, outputFile) == NULL)
       {
           fprintf(stderr,"Empty output file\n");
           return;
       }
       while(fgets(pb, 1023, outputFile) != NULL)
       {
           num_lines++;
           unsigned int num_save = num_start;
           if( sscanf(pa,"%6u%94s%6u",&num_start, bufr,&num_end) !=3)
           {
               fprintf(stdout,"Format doesn't match at line %8d \"%s",
                       num_lines, pa);
               err_count++;
               line_num = num_save +2;
           }
           else
           {
               if ((num_start+1)%100000 != num_end)
               {
                   if (err_count < 20)
                       fprintf(stdout,"Malformed line %d \"%s\"\n", 
                               num_lines, pa);
                   err_count++;
               }
               else if(num_start != line_num)
               {
                   if (err_count < 20)
                       fprintf(stdout,"Skipping from %d to %d\n", 
                               line_num, num_start);
                   err_count++;
                  
               }
               line_num = num_end;
           }
           pa = pb;
           pb = pc;
           pc = pa;
       }
       if(err_count)
           fprintf(stdout,"\n%d errors of %d data sets %f\n", err_count, num_lines, (double) err_count/(double)num_lines);
       else
           fprintf(stdout,"No errors for %d lines\n",num_lines);
   }
    else if(strcmp(descstring,"LLBBC10") == 0)
    { 
        uint32_t block0[4];
        uint32_t block1[4];
        uint32_t *pa = block0;
        uint32_t *pb = block1;
        uint32_t *pc = block0;
        uint32_t start= 0;
        uint32_t nread = 0;
        int n_shown = 0;
        int n_errors = 0;
        if (fread(pa, sizeof(uint32_t), 4,outputFile) < 4)
        {
            fprintf(stderr,"Empty result file\n");
            return;
        }
        while(fread(pb, sizeof(uint32_t), 4,outputFile) != 0)
        {
            blocks++;
            nread =  pa[0];
            if(start>0 && (nread != start))
            {
                if(n_shown < 30)
                {
                    fprintf(stderr, "Skip %7d blocks from 0x%08x to 0x%08x at blocks %10lld \n",
                            (nread-start)/0x4000, start -0x4000, nread, blocks);
                    n_shown ++;
                }
                n_errors++;
            }
            else if (n_shown >0) 
                n_shown--; 
            start = nread + 0x4000;
            pa = pb;
            pb = pc;
            pc = pa;
        }
        if(n_errors)
            fprintf(stderr, "%d blocks wrong from %lld blocks read\n",
                    n_errors, blocks);
        else
            fprintf(stderr, "%lld blocks all fine\n",blocks);
    }
}
Commit	Line	Data
40da63b1 UB	1	/* stream_test.c
	2	*
	3	* Test reading from FT2232H in synchronous FIFO mode.
	4	*
	5	* The FT2232H must supply data due to an appropriate circuit
	6	*
	7	* To check for skipped block with appended code,
	8	* a structure as follows is assumed
	9	* 1* uint32_t num (incremented in 0x4000 steps)
	10	* 3* uint32_t dont_care
	11	*
	12	* After start, data will be read in streaming until the program is aborted
	13	* Progess information wil be printed out
	14	* If a filename is given on the command line, the data read will be
	15	* written to that file
	16	*
	17	*/
	18	#include <stdio.h>
	19	#include <stdlib.h>
	20	#include <stdint.h>
	21	#include <string.h>
	22	#include <unistd.h>
	23	#include <getopt.h>
	24	#include <signal.h>
	25	#include <errno.h>
	26	#include <ftdi.h>
	27	void check_outfile(char *);
	28
	29	static FILE *outputFile;
	30
	31	static int check = 1;
	32	static int exitRequested = 0;
	33	/*
	34	* sigintHandler --
	35	*
	36	* SIGINT handler, so we can gracefully exit when the user hits ctrl-C.
	37	*/
	38
	39	static void
	40	sigintHandler(int signum)
	41	{
	42	exitRequested = 1;
	43	}
	44
	45	static void
	46	usage(const char *argv0)
	47	{
	48	fprintf(stderr,
	49	"Usage: %s [tions...] \n"
	50	"Test streaming read from FT2232H\n"
	51	"[-P string] only look for product with given string"
	52	"[-n] don't check for special block structure"
	53	"\n"
	54	"If some filename is given, write data read to that file\n"
	55	"Progess information is printed each second\n"
	56	"Abort with ^C\n"
	57	"\n"
	58	"Options:\n"
	59	"\n"
	60	"Copyright (C) 2009 Micah Dowty <micah@navi.cx>\n",
	61	"Adapted for use with libftdi (C) 2010 Uwe Bonnes <bon@elektron.ikp.physik.tu-darmstadt.de>\n",
	62	argv0);
	63	exit(1);
	64	}
65
66	static uint32_t start = 0;
67	static uint32_t offset = 0;
705f012d	68	static uint64_t blocks = 0;
40da63b1 UB	69	static uint32_t skips = 0;
	70	static uint32_t n_err = 0;
	71	static int
	72	readCallback(uint8_t buffer, int length, FTDIProgressInfo progress, void *userdata)
	73	{
	74	if (length)
	75	{
	76	if (check)
	77	{
	78	int i,rem;
	79	uint32_t num;
	80	for (i= offset; i<length-16; i+=16)
	81	{
	82	num = (uint32_t) (buffer+i);
	83	if (start && (num != start +0x4000))
	84	{
	85	uint32_t delta = ((num-start)/0x4000)-1;
604ec22b	86	fprintf(stderr, "Skip %7d blocks from 0x%08x to 0x%08x at blocks %10lld \n",
40da63b1 UB	87	delta, start -0x4000, num, blocks);
	88	n_err++;
	89	skips += delta;
	90	}
	91	blocks ++;
	92	start = num;
	93	}
	94	rem = length -i;
	95	if (rem >3)
	96	{
	97	num = (uint32_t) (buffer+i);
	98	if (start && (num != start +0x4000))
	99	{
	100	uint32_t delta = ((num-start)/0x4000)-1;
604ec22b	101	fprintf(stderr, "Skip %7d blocks from 0x%08x to 0x%08x at blocks %10lld \n",
40da63b1 UB	102	delta, start -0x4000, num, blocks);
	103	n_err++;
	104	skips += delta;
	105	}
	106	start = num;
	107	}
	108	else if (rem)
	109	start += 0x4000;
	110	if (rem != 0);
	111	{
	112	blocks ++;
	113	offset = 16-rem;
	114	}
	115	}
	116	if (outputFile)
	117	{
	118	if (fwrite(buffer, length, 1, outputFile) != 1)
	119	{
	120	perror("Write error");
	121	return 1;
	122	}
	123	}
	124	}
	125	if (progress)
	126	{
705f012d	127	fprintf(stderr, "%10.02fs total time %9.3f MiB captured %7.1f kB/s curr rate %7.1f kB/s totalrate %d dropouts\n",
40da63b1 UB	128	progress->totalTime,
	129	progress->current.totalBytes / (1024.0 * 1024.0),
	130	progress->currentRate / 1024.0,
705f012d UB	131	progress->totalRate / 1024.0,
705f012d UB	132	n_err);
40da63b1 UB	133	}
	134	return exitRequested ? 1 : 0;
	135	}
	136
	137	int main(int argc, char **argv)
	138	{
	139	struct ftdi_context ftdic;
	140	int err, c;
	141	FILE *of = NULL;
	142	char const *outfile = 0;
	143	outputFile =0;
	144	exitRequested = 0;
	145	char *descstring = NULL;
	146	int option_index;
	147	static struct option long_options[] = {{NULL},};
	148
	149	while ((c = getopt_long(argc, argv, "P:n", long_options, &option_index)) !=- 1)
	150	switch (c)
	151	{
	152	case -1:
	153	break;
	154	case 'P':
	155	descstring = optarg;
	156	break;
	157	case 'n':
	158	check = 0;
	159	break;
	160	default:
	161	usage(argv[0]);
	162	}
	163
	164	if (optind == argc - 1)
	165	{
	166	// Exactly one extra argument- a dump file
	167	outfile = argv[optind];
	168	}
	169	else if (optind < argc)
	170	{
	171	// Too many extra args
	172	usage(argv[0]);
	173	}
	174
	175	if (ftdi_init(&ftdic) < 0)
	176	{
	177	fprintf(stderr, "ftdi_init failed\n");
	178	return EXIT_FAILURE;
	179	}
	180
	181	if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0)
	182	{
	183	fprintf(stderr, "ftdi_set_interface failed\n");
	184	return EXIT_FAILURE;
	185	}
	186
	187	if (ftdi_usb_open_desc(&ftdic, 0x0403, 0x6010, descstring, NULL) < 0)
	188	{
	189	fprintf(stderr,"Can't open ftdi device: %s\n",ftdi_get_error_string(&ftdic));
	190	return EXIT_FAILURE;
	191	}
	192
	193	/* A timeout value of 1 results in may skipped blocks */
	194	if(ftdi_set_latency_timer(&ftdic, 2))
	195	{
705f012d	196	fprintf(stderr,"Can't set latency, Error %s\n",ftdi_get_error_string(&ftdic));
40da63b1 UB	197	return EXIT_FAILURE;
	198	}
	199
	200	/* if(ftdi_usb_purge_rx_buffer(&ftdic) < 0)
	201	{
	202	fprintf(stderr,"Can't rx purge\n",ftdi_get_error_string(&ftdic));
	203	return EXIT_FAILURE;
	204	}*/
	205	if (outfile)
	206	if ((of = fopen(outfile,"w+")) == 0)
	207	fprintf(stderr,"Can't open logfile %s, Error %s\n", outfile, strerror(errno));
	208	if (of)
	209	if (setvbuf(of, NULL, _IOFBF , 1<<16) == 0)
	210	outputFile = of;
	211	signal(SIGINT, sigintHandler);
	212
	213	err = ftdi_readstream(&ftdic, readCallback, NULL, 8, 256);
	214	if (err < 0 && !exitRequested)
	215	exit(1);
	216
	217	if (outputFile) {
	218	fclose(outputFile);
	219	outputFile = NULL;
	220	}
	221	fprintf(stderr, "Capture ended.\n");
	222
	223	if (ftdi_set_bitmode(&ftdic, 0xff, BITMODE_RESET) < 0)
	224	{
705f012d	225	fprintf(stderr,"Can't set synchronous fifo mode, Error %s\n",ftdi_get_error_string(&ftdic));
40da63b1 UB	226	return EXIT_FAILURE;
	227	}
	228	ftdi_usb_close(&ftdic);
	229	ftdi_deinit(&ftdic);
	230	signal(SIGINT, SIG_DFL);
	231	if (check && outfile)
	232	{
	233	if ((outputFile = fopen(outfile,"r")) == 0)
	234	{
	235	fprintf(stderr,"Can't open logfile %s, Error %s\n", outfile, strerror(errno));
	236	return EXIT_FAILURE;
	237	}
	238	check_outfile(descstring);
	239	fclose(outputFile);
	240	}
	241	else if (check)
604ec22b	242	fprintf(stderr,"%d errors of %lld blocks (%Le), %d (%Le) blocks skipped\n",
40da63b1 UB	243	n_err, blocks, (long double)n_err/(long double) blocks,
	244	skips, (long double)skips/(long double) blocks);
	245	exit (0);
	246	}
	247
	248	void check_outfile(char *descstring)
	249	{
	250	if(strcmp(descstring,"FT2232HTEST") == 0)
	251	{
	252	char buf0[1024];
	253	char buf1[1024];
	254	char bufr[1024];
	255	char pa, pb, *pc;
	256	unsigned int num_lines = 0, line_num = 1;
	257	int err_count = 0;
	258	unsigned int num_start, num_end;
	259
40da63b1 UB	260	pa = buf0;
	261	pb = buf1;
	262	pc = buf0;
	263	if(fgets(pa, 1023, outputFile) == NULL)
	264	{
	265	fprintf(stderr,"Empty output file\n");
	266	return;
	267	}
	268	while(fgets(pb, 1023, outputFile) != NULL)
	269	{
	270	num_lines++;
	271	unsigned int num_save = num_start;
	272	if( sscanf(pa,"%6u%94s%6u",&num_start, bufr,&num_end) !=3)
	273	{
	274	fprintf(stdout,"Format doesn't match at line %8d \"%s",
	275	num_lines, pa);
	276	err_count++;
	277	line_num = num_save +2;
	278	}
	279	else
	280	{
	281	if ((num_start+1)%100000 != num_end)
	282	{
	283	if (err_count < 20)
	284	fprintf(stdout,"Malformed line %d \"%s\"\n",
	285	num_lines, pa);
	286	err_count++;
	287	}
	288	else if(num_start != line_num)
	289	{
	290	if (err_count < 20)
	291	fprintf(stdout,"Skipping from %d to %d\n",
	292	line_num, num_start);
	293	err_count++;
	294
	295	}
	296	line_num = num_end;
	297	}
	298	pa = pb;
	299	pb = pc;
	300	pc = pa;
	301	}
	302	if(err_count)
	303	fprintf(stdout,"\n%d errors of %d data sets %f\n", err_count, num_lines, (double) err_count/(double)num_lines);
	304	else
	305	fprintf(stdout,"No errors for %d lines\n",num_lines);
	306	}
	307	else if(strcmp(descstring,"LLBBC10") == 0)
	308	{
	309	uint32_t block0[4];
	310	uint32_t block1[4];
	311	uint32_t *pa = block0;
	312	uint32_t *pb = block1;
	313	uint32_t *pc = block0;
	314	uint32_t start= 0;
	315	uint32_t nread = 0;
40da63b1 UB	316	int n_shown = 0;
	317	int n_errors = 0;
	318	if (fread(pa, sizeof(uint32_t), 4,outputFile) < 4)
	319	{
	320	fprintf(stderr,"Empty result file\n");
	321	return;
	322	}
	323	while(fread(pb, sizeof(uint32_t), 4,outputFile) != 0)
	324	{
	325	blocks++;
	326	nread = pa[0];
	327	if(start>0 && (nread != start))
	328	{
	329	if(n_shown < 30)
	330	{
604ec22b	331	fprintf(stderr, "Skip %7d blocks from 0x%08x to 0x%08x at blocks %10lld \n",
40da63b1 UB	332	(nread-start)/0x4000, start -0x4000, nread, blocks);
	333	n_shown ++;
	334	}
	335	n_errors++;
	336	}
	337	else if (n_shown >0)
	338	n_shown--;
	339	start = nread + 0x4000;
	340	pa = pb;
	341	pb = pc;
	342	pc = pa;
	343	}
	344	if(n_errors)
604ec22b	345	fprintf(stderr, "%d blocks wrong from %lld blocks read\n",
40da63b1 UB	346	n_errors, blocks);
40da63b1 UB	347	else
604ec22b	348	fprintf(stderr, "%lld blocks all fine\n",blocks);
40da63b1 UB	349	}
40da63b1 UB	350	}