libftdi-git Archives

Subject: A library to talk to FTDI chips branch, master, updated. v0.17-288-gcd2ead2

From: libftdi-git@xxxxxxxxxxxxxxxxxxxxxxx
To: libftdi-git@xxxxxxxxxxxxxxxxxxxxxxx
Date: Tue, 4 Oct 2011 18:18:50 +0200 (CEST)
The branch, master has been updated
       via  cd2ead2f23cea38de6fdbf2459c79cb4936fbf8d (commit)
      from  e41d34235570f2b3bae3ea5db9150cddf2597810 (commit)


- Log -----------------------------------------------------------------
commit cd2ead2f23cea38de6fdbf2459c79cb4936fbf8d
Author: Uwe Bonnes <bon@xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx>
Date:   Tue Oct 4 14:57:12 2011 +0200

    Use ftdi_new and not ftdi_init in the examples
    
    At least our examples should use the library allocated buffer
    and not a user allocated one.

-----------------------------------------------------------------------

Summary of changes:
 examples/baud_test.c      |   38 ++++++++++++++--------------
 examples/bitbang.c        |   30 +++++++++++-----------
 examples/bitbang2.c       |   23 ++++++++---------
 examples/bitbang_cbus.c   |   34 +++++++++++++-------------
 examples/bitbang_ft2232.c |   58 ++++++++++++++++++++++----------------------
 examples/find_all.c       |   16 ++++++------
 examples/simple.c         |   26 ++++++++++----------
 examples/stream_test.c    |   46 +++++++++++++++++-----------------
 8 files changed, 135 insertions(+), 136 deletions(-)

diff --git a/examples/baud_test.c b/examples/baud_test.c
index d744a42..ccb5a3d 100644
--- a/examples/baud_test.c
+++ b/examples/baud_test.c
@@ -50,7 +50,7 @@ double get_prec_time()
 
 int main(int argc, char **argv)
 {
-    struct ftdi_context ftdic;
+    struct ftdi_context *ftdi;
     int i, t;
     unsigned char *txbuf;
     unsigned char *rxbuf;
@@ -111,16 +111,16 @@ int main(int argc, char **argv)
         return EXIT_FAILURE;
     }
 
-    if (ftdi_init(&ftdic) < 0)
+    if ((ftdi = ftdi_new()) == 0)
     {
-        fprintf(stderr, "ftdi_init failed\n");
+        fprintf(stderr, "ftdi_new failed\n");
         retval = EXIT_FAILURE;
         goto done;
     }
 
-    if (ftdi_usb_open_string(&ftdic, devicedesc) < 0)
+    if (ftdi_usb_open_string(ftdi, devicedesc) < 0)
     {
-        fprintf(stderr,"Can't open ftdi device: 
%s\n",ftdi_get_error_string(&ftdic));
+        fprintf(stderr,"Can't open ftdi device: 
%s\n",ftdi_get_error_string(ftdi));
         retval = EXIT_FAILURE;
         goto do_deinit;
     }
@@ -132,12 +132,12 @@ int main(int argc, char **argv)
         set_baud=baud/16;
     }
 
-    ftdi_set_baudrate(&ftdic,set_baud);
-    printf("real baudrate used: %d\n",(test_mode==BITMODE_RESET) ? 
ftdic.baudrate : ftdic.baudrate*16);
+    ftdi_set_baudrate(ftdi,set_baud);
+    printf("real baudrate used: %d\n",(test_mode==BITMODE_RESET) ? 
ftdi->baudrate : ftdi->baudrate*16);
 
-    if (ftdi_set_bitmode(&ftdic, 0xFF,test_mode) < 0)
+    if (ftdi_set_bitmode(ftdi, 0xFF,test_mode) < 0)
     {
-        fprintf(stderr,"Can't set mode: %s\n",ftdi_get_error_string(&ftdic));
+        fprintf(stderr,"Can't set mode: %s\n",ftdi_get_error_string(ftdi));
         retval = EXIT_FAILURE;
         goto do_close;
     }
@@ -165,10 +165,10 @@ int main(int argc, char **argv)
             txbuf[i]=(i%2) ? 0xff : 0;
     }
 
-    if (ftdi_write_data_set_chunksize(&ftdic, txchunksize) < 0 ||
-            ftdi_read_data_set_chunksize(&ftdic, txchunksize) < 0)
+    if (ftdi_write_data_set_chunksize(ftdi, txchunksize) < 0 ||
+            ftdi_read_data_set_chunksize(ftdi, txchunksize) < 0)
     {
-        fprintf(stderr,"Can't set chunksize: 
%s\n",ftdi_get_error_string(&ftdic));
+        fprintf(stderr,"Can't set chunksize: 
%s\n",ftdi_get_error_string(ftdi));
         retval = EXIT_FAILURE;
         goto do_close;
     }
@@ -176,14 +176,14 @@ int main(int argc, char **argv)
     if (test_mode==BITMODE_SYNCBB)
     {
         // completely clear the receive buffer before beginning
-        while (ftdi_read_data(&ftdic, rxbuf, txchunksize)>0);
+        while (ftdi_read_data(ftdi, rxbuf, txchunksize)>0);
     }
 
     start=get_prec_time();
 
     // don't wait for more data to arrive, take what we get and keep on sending
     // yes, we really would like to have libusb 1.0+ with async read/write...
-    ftdic.usb_read_timeout=1;
+    ftdi->usb_read_timeout=1;
 
     i=0;
     while (i < datasize)
@@ -192,10 +192,10 @@ int main(int argc, char **argv)
         if (i+sendsize > datasize)
             sendsize=datasize-i;
 
-        if ((sendsize=ftdi_write_data(&ftdic, txbuf, sendsize)) < 0)
+        if ((sendsize=ftdi_write_data(ftdi, txbuf, sendsize)) < 0)
         {
             fprintf(stderr,"write failed at %d: %s\n",
-                    i, ftdi_get_error_string(&ftdic));
+                    i, ftdi_get_error_string(ftdi));
             retval = EXIT_FAILURE;
             goto do_close;
         }
@@ -205,16 +205,16 @@ int main(int argc, char **argv)
         if (test_mode==BITMODE_SYNCBB)
         {
             // read the same amount of data as sent
-            ftdi_read_data(&ftdic, rxbuf, sendsize);
+            ftdi_read_data(ftdi, rxbuf, sendsize);
         }
     }
 
     duration=get_prec_time()-start;
     printf("and took %.4f seconds, this is %.0f baud or factor 
%.3f\n",duration,(plan*baud)/duration,plan/duration);
 do_close:
-    ftdi_usb_close(&ftdic);
+    ftdi_usb_close(ftdi);
 do_deinit:
-    ftdi_deinit(&ftdic);
+    ftdi_free(ftdi);
 done:
     if(rxbuf)
         free(rxbuf);
diff --git a/examples/bitbang.c b/examples/bitbang.c
index f4168ac..1d69e2e 100644
--- a/examples/bitbang.c
+++ b/examples/bitbang.c
@@ -10,22 +10,22 @@
 
 int main(int argc, char **argv)
 {
-    struct ftdi_context ftdic;
+    struct ftdi_context *ftdi;
     int f,i;
     unsigned char buf[1];
     int retval = 0;
 
-    if (ftdi_init(&ftdic) < 0)
+    if ((ftdi = ftdi_new()) == 0)
     {
-        fprintf(stderr, "ftdi_init failed\n");
+        fprintf(stderr, "ftdi_new failed\n");
         return EXIT_FAILURE;
     }
 
-    f = ftdi_usb_open(&ftdic, 0x0403, 0x6001);
+    f = ftdi_usb_open(ftdi, 0x0403, 0x6001);
 
     if (f < 0 && f != -5)
     {
-        fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, 
ftdi_get_error_string(&ftdic));
+        fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, 
ftdi_get_error_string(ftdi));
         retval = 1;
         goto done;
     }
@@ -33,26 +33,26 @@ int main(int argc, char **argv)
     printf("ftdi open succeeded: %d\n",f);
 
     printf("enabling bitbang mode\n");
-    ftdi_set_bitmode(&ftdic, 0xFF, BITMODE_BITBANG);
+    ftdi_set_bitmode(ftdi, 0xFF, BITMODE_BITBANG);
 
     sleep(3);
 
     buf[0] = 0x0;
     printf("turning everything on\n");
-    f = ftdi_write_data(&ftdic, buf, 1);
+    f = ftdi_write_data(ftdi, buf, 1);
     if (f < 0)
     {
-        fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, 
ftdi_get_error_string(&ftdic));
+        fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, 
ftdi_get_error_string(ftdi));
     }
 
     sleep(3);
 
     buf[0] = 0xFF;
     printf("turning everything off\n");
-    f = ftdi_write_data(&ftdic, buf, 1);
+    f = ftdi_write_data(ftdi, buf, 1);
     if (f < 0)
     {
-        fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, 
ftdi_get_error_string(&ftdic));
+        fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, 
ftdi_get_error_string(ftdi));
     }
 
     sleep(3);
@@ -66,10 +66,10 @@ int main(int argc, char **argv)
         }
         printf("%02hhx ",buf[0]);
         fflush(stdout);
-        f = ftdi_write_data(&ftdic, buf, 1);
+        f = ftdi_write_data(ftdi, buf, 1);
         if (f < 0)
         {
-            fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, 
ftdi_get_error_string(&ftdic));
+            fprintf(stderr,"write failed for 0x%x, error %d (%s)\n",buf[0],f, 
ftdi_get_error_string(ftdi));
         }
         sleep(1);
     }
@@ -77,11 +77,11 @@ int main(int argc, char **argv)
     printf("\n");
 
     printf("disabling bitbang mode\n");
-    ftdi_disable_bitbang(&ftdic);
+    ftdi_disable_bitbang(ftdi);
 
-    ftdi_usb_close(&ftdic);
+    ftdi_usb_close(ftdi);
 done:
-    ftdi_deinit(&ftdic);
+    ftdi_free(ftdi);
 
     return retval;
 }
diff --git a/examples/bitbang2.c b/examples/bitbang2.c
index fa588f9..1582da0 100644
--- a/examples/bitbang2.c
+++ b/examples/bitbang2.c
@@ -47,7 +47,7 @@ void ftdi_fatal (struct ftdi_context *ftdi, char *str)
 
 int main(int argc, char **argv)
 {
-    struct ftdi_context ftdic;
+    struct ftdi_context *ftdi;
     int i, t;
     unsigned char data;
     int delay = 100000; /* 100 thousand microseconds: 1 tenth of a second */
@@ -62,32 +62,31 @@ int main(int argc, char **argv)
         }
     }
 
-    if (ftdi_init(&ftdic) < 0)
+    if ((ftdi = ftdi_new()) == 0)
     {
-        fprintf(stderr, "ftdi_init failed\n");
-        ftdi_deinit(&ftdic);
+        fprintf(stderr, "ftdi_bew failed\n");
         return EXIT_FAILURE;
     }
 
-    if (ftdi_usb_open(&ftdic, 0x0403, 0x6001) < 0)
-        ftdi_fatal (&ftdic, "Can't open ftdi device");
+    if (ftdi_usb_open(ftdi, 0x0403, 0x6001) < 0)
+        ftdi_fatal (ftdi, "Can't open ftdi device");
 
-    if (ftdi_set_bitmode(&ftdic, 0xFF, BITMODE_BITBANG) < 0)
-        ftdi_fatal (&ftdic, "Can't enable bitbang");
+    if (ftdi_set_bitmode(ftdi, 0xFF, BITMODE_BITBANG) < 0)
+        ftdi_fatal (ftdi, "Can't enable bitbang");
 
     for (i=optind; i < argc ; i++)
     {
         sscanf (argv[i], "%x", &t);
         data = t;
-        if (ftdi_write_data(&ftdic, &data, 1) < 0)
+        if (ftdi_write_data(ftdi, &data, 1) < 0)
         {
             fprintf(stderr,"write failed for 0x%x: %s\n",
-                    data, ftdi_get_error_string(&ftdic));
+                    data, ftdi_get_error_string(ftdi));
         }
         usleep(delay);
     }
 
-    ftdi_usb_close(&ftdic);
-    ftdi_deinit(&ftdic);
+    ftdi_usb_close(ftdi);
+    ftdi_free(ftdi);
     exit (0);
 }
diff --git a/examples/bitbang_cbus.c b/examples/bitbang_cbus.c
index f47c359..f881f4c 100644
--- a/examples/bitbang_cbus.c
+++ b/examples/bitbang_cbus.c
@@ -36,24 +36,24 @@
 
 int main(void)
 {
-    struct ftdi_context ftdic;
+    struct ftdi_context *ftdi;
     int f;
     unsigned char buf[1];
     unsigned char bitmask;
     char input[10];
     int retval = 0;
 
-    if (ftdi_init(&ftdic) < 0)
+    if ((ftdi = ftdi_new()) == 0)
     {
-        fprintf(stderr, "ftdi_init failed\n");
+        fprintf(stderr, "ftdi_new failed\n");
         return EXIT_FAILURE;
     }
 
-    f = ftdi_usb_open(&ftdic, 0x0403, 0x6001);
+    f = ftdi_usb_open(ftdi, 0x0403, 0x6001);
     if (f < 0 && f != -5)
     {
-        fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, 
ftdi_get_error_string(&ftdic));
-        ftdi_deinit(&ftdic);
+        fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, 
ftdi_get_error_string(ftdi));
+        ftdi_deinit(ftdi);
         exit(-1);
     }
     printf("ftdi open succeeded: %d\n",f);
@@ -65,31 +65,31 @@ int main(void)
         if (input[0] == '\n') break;
         bitmask = strtol(input, NULL, 0);
         printf("Using bitmask 0x%02x\n", bitmask);
-        f = ftdi_set_bitmode(&ftdic, bitmask, BITMODE_CBUS);
+        f = ftdi_set_bitmode(ftdi, bitmask, BITMODE_CBUS);
         if (f < 0)
         {
-            fprintf(stderr, "set_bitmode failed for 0x%x, error %d (%s)\n", 
bitmask, f, ftdi_get_error_string(&ftdic));
-            ftdi_usb_close(&ftdic);
-            ftdi_deinit(&ftdic);
+            fprintf(stderr, "set_bitmode failed for 0x%x, error %d (%s)\n", 
bitmask, f, ftdi_get_error_string(ftdi));
+            ftdi_usb_close(ftdi);
+            ftdi_deinit(ftdi);
             retval = -1;
         }
 
         // read CBUS
-        f = ftdi_read_pins(&ftdic, &buf[0]);
+        f = ftdi_read_pins(ftdi, &buf[0]);
         if (f < 0)
         {
-            fprintf(stderr, "read_pins failed, error %d (%s)\n", f, 
ftdi_get_error_string(&ftdic));
-            ftdi_usb_close(&ftdic);
-            ftdi_deinit(&ftdic);
+            fprintf(stderr, "read_pins failed, error %d (%s)\n", f, 
ftdi_get_error_string(ftdi));
+            ftdi_usb_close(ftdi);
+            ftdi_deinit(ftdi);
             exit(-1);
         }
         printf("Read returned 0x%01x\n", buf[0] & 0x0f);
     }
     printf("disabling bitbang mode\n");
-    ftdi_disable_bitbang(&ftdic);
+    ftdi_disable_bitbang(ftdi);
 
-    ftdi_usb_close(&ftdic);
-    ftdi_deinit(&ftdic);
+    ftdi_usb_close(ftdi);
+    ftdi_free(ftdi);
 
     return 0;
 }
diff --git a/examples/bitbang_ft2232.c b/examples/bitbang_ft2232.c
index 6eb223e..41376a9 100644
--- a/examples/bitbang_ft2232.c
+++ b/examples/bitbang_ft2232.c
@@ -18,48 +18,48 @@
 
 int main(int argc, char **argv)
 {
-    struct ftdi_context ftdic, ftdic2;
+    struct ftdi_context *ftdi, *ftdi2;
     unsigned char buf[1];
     int f,i;
 
     // Init 1. channel
-    if (ftdi_init(&ftdic) < 0)
+    if ((ftdi = ftdi_new()) == 0)
     {
-        fprintf(stderr, "ftdi_init failed\n");
+        fprintf(stderr, "ftdi_new failed\n");
         return EXIT_FAILURE;
     }
 
-    ftdi_set_interface(&ftdic, INTERFACE_A);
-    f = ftdi_usb_open(&ftdic, 0x0403, 0x6001);
+    ftdi_set_interface(ftdi, INTERFACE_A);
+    f = ftdi_usb_open(ftdi, 0x0403, 0x6001);
     if (f < 0 && f != -5)
     {
-        fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, 
ftdi_get_error_string(&ftdic));
-        ftdi_deinit(&ftdic);
+        fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, 
ftdi_get_error_string(ftdi));
+        ftdi_deinit(ftdi);
         exit(-1);
     }
     printf("ftdi open succeeded(channel 1): %d\n",f);
 
     printf("enabling bitbang mode(channel 1)\n");
-    ftdi_set_bitmode(&ftdic, 0xFF, BITMODE_BITBANG);
+    ftdi_set_bitmode(ftdi, 0xFF, BITMODE_BITBANG);
 
     // Init 2. channel
-    if (ftdi_init(&ftdic2) < 0)
+    if ((ftdi2 = ftdi_new()) == 0)
     {
-        fprintf(stderr, "ftdi_init failed\n");
+        fprintf(stderr, "ftdi_new failed\n");
         return EXIT_FAILURE;
     }
-    ftdi_set_interface(&ftdic2, INTERFACE_B);
-    f = ftdi_usb_open(&ftdic2, 0x0403, 0x6001);
+    ftdi_set_interface(ftdi2, INTERFACE_B);
+    f = ftdi_usb_open(ftdi2, 0x0403, 0x6001);
     if (f < 0 && f != -5)
     {
-        fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, 
ftdi_get_error_string(&ftdic2));
-        ftdi_deinit(&ftdic2);
+        fprintf(stderr, "unable to open ftdi device: %d (%s)\n", f, 
ftdi_get_error_string(ftdi2));
+        ftdi_deinit(ftdi2);
         exit(-1);
     }
     printf("ftdi open succeeded(channel 2): %d\n",f);
 
     printf("enabling bitbang mode (channel 2)\n");
-    ftdi_set_bitmode(&ftdic2, 0xFF, BITMODE_BITBANG);
+    ftdi_set_bitmode(ftdi2, 0xFF, BITMODE_BITBANG);
 
     // Write data
     printf("startloop\n");
@@ -67,43 +67,43 @@ int main(int argc, char **argv)
     {
         buf[0] =  0x1;
         printf("porta: %02i: 0x%02x \n",i,buf[0]);
-        f = ftdi_write_data(&ftdic, buf, 1);
+        f = ftdi_write_data(ftdi, buf, 1);
         if (f < 0)
-            fprintf(stderr,"write failed on channel 1 for 0x%x, error %d 
(%s)\n", buf[0], f, ftdi_get_error_string(&ftdic));
+            fprintf(stderr,"write failed on channel 1 for 0x%x, error %d 
(%s)\n", buf[0], f, ftdi_get_error_string(ftdi));
         sleep(1);
 
         buf[0] =  0x2;
         printf("porta: %02i: 0x%02x \n",i,buf[0]);
-        f = ftdi_write_data(&ftdic, buf, 1);
+        f = ftdi_write_data(ftdi, buf, 1);
         if (f < 0)
-            fprintf(stderr,"write failed on channel 1 for 0x%x, error %d 
(%s)\n", buf[0], f, ftdi_get_error_string(&ftdic));
+            fprintf(stderr,"write failed on channel 1 for 0x%x, error %d 
(%s)\n", buf[0], f, ftdi_get_error_string(ftdi));
         sleep(1);
 
         buf[0] =  0x1;
         printf("portb: %02i: 0x%02x \n",i,buf[0]);
-        f = ftdi_write_data(&ftdic2, buf, 1);
+        f = ftdi_write_data(ftdi2, buf, 1);
         if (f < 0)
-            fprintf(stderr,"write failed on channel 2 for 0x%x, error %d 
(%s)\n", buf[0], f, ftdi_get_error_string(&ftdic2));
+            fprintf(stderr,"write failed on channel 2 for 0x%x, error %d 
(%s)\n", buf[0], f, ftdi_get_error_string(ftdi2));
         sleep(1);
 
         buf[0] =  0x2;
         printf("portb: %02i: 0x%02x \n",i,buf[0]);
-        f = ftdi_write_data(&ftdic2, buf, 1);
+        f = ftdi_write_data(ftdi2, buf, 1);
         if (f < 0)
-            fprintf(stderr,"write failed on channel 2 for 0x%x, error %d 
(%s)\n", buf[0], f, ftdi_get_error_string(&ftdic2));
+            fprintf(stderr,"write failed on channel 2 for 0x%x, error %d 
(%s)\n", buf[0], f, ftdi_get_error_string(ftdi2));
         sleep(1);
     }
     printf("\n");
 
     printf("disabling bitbang mode(channel 1)\n");
-    ftdi_disable_bitbang(&ftdic);
-    ftdi_usb_close(&ftdic);
-    ftdi_deinit(&ftdic);
+    ftdi_disable_bitbang(ftdi);
+    ftdi_usb_close(ftdi);
+    ftdi_deinit(ftdi);
 
     printf("disabling bitbang mode(channel 2)\n");
-    ftdi_disable_bitbang(&ftdic2);
-    ftdi_usb_close(&ftdic2);
-    ftdi_deinit(&ftdic2);
+    ftdi_disable_bitbang(ftdi2);
+    ftdi_usb_close(ftdi2);
+    ftdi_free(ftdi2);
 
     return 0;
 }
diff --git a/examples/find_all.c b/examples/find_all.c
index 113904c..4a70650 100644
--- a/examples/find_all.c
+++ b/examples/find_all.c
@@ -12,20 +12,20 @@
 int main(void)
 {
     int ret, i;
-    struct ftdi_context ftdic;
+    struct ftdi_context *ftdi;
     struct ftdi_device_list *devlist, *curdev;
     char manufacturer[128], description[128];
     int retval = EXIT_SUCCESS;
 
-    if (ftdi_init(&ftdic) < 0)
+    if ((ftdi = ftdi_new()) == 0)
     {
-        fprintf(stderr, "ftdi_init failed\n");
+        fprintf(stderr, "ftdi_new failed\n");
         return EXIT_FAILURE;
     }
 
-    if ((ret = ftdi_usb_find_all(&ftdic, &devlist, 0, 0)) < 0)
+    if ((ret = ftdi_usb_find_all(ftdi, &devlist, 0, 0)) < 0)
     {
-        fprintf(stderr, "ftdi_usb_find_all failed: %d (%s)\n", ret, 
ftdi_get_error_string(&ftdic));
+        fprintf(stderr, "ftdi_usb_find_all failed: %d (%s)\n", ret, 
ftdi_get_error_string(ftdi));
         retval =  EXIT_FAILURE;
         goto do_deinit;
     }
@@ -36,9 +36,9 @@ int main(void)
     for (curdev = devlist; curdev != NULL; i++)
     {
         printf("Checking device: %d\n", i);
-        if ((ret = ftdi_usb_get_strings(&ftdic, curdev->dev, manufacturer, 
128, description, 128, NULL, 0)) < 0)
+        if ((ret = ftdi_usb_get_strings(ftdi, curdev->dev, manufacturer, 128, 
description, 128, NULL, 0)) < 0)
         {
-            fprintf(stderr, "ftdi_usb_get_strings failed: %d (%s)\n", ret, 
ftdi_get_error_string(&ftdic));
+            fprintf(stderr, "ftdi_usb_get_strings failed: %d (%s)\n", ret, 
ftdi_get_error_string(ftdi));
             retval = EXIT_FAILURE;
             goto done;
         }
@@ -48,7 +48,7 @@ int main(void)
 done:
     ftdi_list_free(&devlist);
 do_deinit:
-    ftdi_deinit(&ftdic);
+    ftdi_free(ftdi);
 
     return retval;
 }
diff --git a/examples/simple.c b/examples/simple.c
index 9fac121..cfd674b 100644
--- a/examples/simple.c
+++ b/examples/simple.c
@@ -12,11 +12,11 @@
 int main(void)
 {
     int ret;
-    struct ftdi_context ftdic;
+    struct ftdi_context *ftdi;
     struct ftdi_version_info version;
-    if (ftdi_init(&ftdic) < 0)
-    {
-        fprintf(stderr, "ftdi_init failed\n");
+    if ((ftdi = ftdi_new()) == 0)
+   {
+        fprintf(stderr, "ftdi_new failed\n");
         return EXIT_FAILURE;
     }
 
@@ -25,29 +25,29 @@ int main(void)
         version.version_str, version.major, version.minor, version.micro,
         version.snapshot_str);
 
-    if ((ret = ftdi_usb_open(&ftdic, 0x0403, 0x6001)) < 0)
+    if ((ret = ftdi_usb_open(ftdi, 0x0403, 0x6001)) < 0)
     {
-        fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, 
ftdi_get_error_string(&ftdic));
-        ftdi_deinit(&ftdic);
+        fprintf(stderr, "unable to open ftdi device: %d (%s)\n", ret, 
ftdi_get_error_string(ftdi));
+        ftdi_free(ftdi);
         return EXIT_FAILURE;
     }
 
     // Read out FTDIChip-ID of R type chips
-    if (ftdic.type == TYPE_R)
+    if (ftdi->type == TYPE_R)
     {
         unsigned int chipid;
-        printf("ftdi_read_chipid: %d\n", ftdi_read_chipid(&ftdic, &chipid));
+        printf("ftdi_read_chipid: %d\n", ftdi_read_chipid(ftdi, &chipid));
         printf("FTDI chipid: %X\n", chipid);
     }
 
-    if ((ret = ftdi_usb_close(&ftdic)) < 0)
+    if ((ret = ftdi_usb_close(ftdi)) < 0)
     {
-        fprintf(stderr, "unable to close ftdi device: %d (%s)\n", ret, 
ftdi_get_error_string(&ftdic));
-        ftdi_deinit(&ftdic);
+        fprintf(stderr, "unable to close ftdi device: %d (%s)\n", ret, 
ftdi_get_error_string(ftdi));
+        ftdi_free(ftdi);
         return EXIT_FAILURE;
     }
 
-    ftdi_deinit(&ftdic);
+    ftdi_free(ftdi);
 
     return EXIT_SUCCESS;
 }
diff --git a/examples/stream_test.c b/examples/stream_test.c
index c510b74..8f49202 100644
--- a/examples/stream_test.c
+++ b/examples/stream_test.c
@@ -136,7 +136,7 @@ readCallback(uint8_t *buffer, int length, FTDIProgressInfo 
*progress, void *user
 
 int main(int argc, char **argv)
 {
-   struct ftdi_context ftdic;
+   struct ftdi_context *ftdi;
    int err, c;
    FILE *of = NULL;
    char const *outfile  = 0;
@@ -172,38 +172,38 @@ int main(int argc, char **argv)
        usage(argv[0]);
    }
    
-   if (ftdi_init(&ftdic) < 0)
+   if ((ftdi = ftdi_new()) == 0)
    {
-       fprintf(stderr, "ftdi_init failed\n");
+       fprintf(stderr, "ftdi_new failed\n");
        return EXIT_FAILURE;
    }
    
-   if (ftdi_set_interface(&ftdic, INTERFACE_A) < 0)
+   if (ftdi_set_interface(ftdi, INTERFACE_A) < 0)
    {
        fprintf(stderr, "ftdi_set_interface failed\n");
-       ftdi_deinit(&ftdic);
+       ftdi_free(ftdi);
        return EXIT_FAILURE;
    }
    
-   if (ftdi_usb_open_desc(&ftdic, 0x0403, 0x6010, descstring, NULL) < 0)
+   if (ftdi_usb_open_desc(ftdi, 0x0403, 0x6010, descstring, NULL) < 0)
    {
-       fprintf(stderr,"Can't open ftdi device: 
%s\n",ftdi_get_error_string(&ftdic));
-       ftdi_deinit(&ftdic);
+       fprintf(stderr,"Can't open ftdi device: 
%s\n",ftdi_get_error_string(ftdi));
+       ftdi_free(ftdi);
        return EXIT_FAILURE;
    }
    
    /* A timeout value of 1 results in may skipped blocks */
-   if(ftdi_set_latency_timer(&ftdic, 2))
+   if(ftdi_set_latency_timer(ftdi, 2))
    {
-       fprintf(stderr,"Can't set latency, Error 
%s\n",ftdi_get_error_string(&ftdic));
-       ftdi_usb_close(&ftdic);
-       ftdi_deinit(&ftdic);
+       fprintf(stderr,"Can't set latency, Error 
%s\n",ftdi_get_error_string(ftdi));
+       ftdi_usb_close(ftdi);
+       ftdi_free(ftdi);
        return EXIT_FAILURE;
    }
    
-/*   if(ftdi_usb_purge_rx_buffer(&ftdic) < 0)
+/*   if(ftdi_usb_purge_rx_buffer(ftdi) < 0)
    {
-       fprintf(stderr,"Can't rx purge\n",ftdi_get_error_string(&ftdic));
+       fprintf(stderr,"Can't rx purge\n",ftdi_get_error_string(ftdi));
        return EXIT_FAILURE;
        }*/
    if (outfile)
@@ -214,7 +214,7 @@ int main(int argc, char **argv)
            outputFile = of;
    signal(SIGINT, sigintHandler);
    
-   err = ftdi_readstream(&ftdic, readCallback, NULL, 8, 256);
+   err = ftdi_readstream(ftdi, readCallback, NULL, 8, 256);
    if (err < 0 && !exitRequested)
        exit(1);
    
@@ -224,23 +224,23 @@ int main(int argc, char **argv)
    }
    fprintf(stderr, "Capture ended.\n");
    
-   if (ftdi_set_bitmode(&ftdic,  0xff, BITMODE_RESET) < 0)
+   if (ftdi_set_bitmode(ftdi,  0xff, BITMODE_RESET) < 0)
    {
-       fprintf(stderr,"Can't set synchronous fifo mode, Error 
%s\n",ftdi_get_error_string(&ftdic));
-       ftdi_usb_close(&ftdic);
-       ftdi_deinit(&ftdic);
+       fprintf(stderr,"Can't set synchronous fifo mode, Error 
%s\n",ftdi_get_error_string(ftdi));
+       ftdi_usb_close(ftdi);
+       ftdi_free(ftdi);
        return EXIT_FAILURE;
    }
-   ftdi_usb_close(&ftdic);
-   ftdi_deinit(&ftdic);
+   ftdi_usb_close(ftdi);
+   ftdi_free(ftdi);
    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));
-           ftdi_usb_close(&ftdic);
-           ftdi_deinit(&ftdic);
+           ftdi_usb_close(ftdi);
+           ftdi_free(ftdi);
            return EXIT_FAILURE;
        }
        check_outfile(descstring);


hooks/post-receive
-- 
A library to talk to FTDI chips

--
libftdi-git - see http://www.intra2net.com/en/developer/libftdi for details.
To unsubscribe send a mail to libftdi-git+unsubscribe@xxxxxxxxxxxxxxxxxxxxxxx   

Current Thread
  • A library to talk to FTDI chips branch, master, updated. v0.17-288-gcd2ead2, libftdi-git <=