Time FTDI bitbang output to figure out actual bitrate

time.c

/* $ cc -lftdi time.c -o time 
   $ ./time 9600
   Desired bitrate: 9600
   Writing data..
   100000 bits written in 10.368 seconds = 9645.0 bits per second
   $ ./time 76000
   Desired bitrate: 76000
   Writing data..
   100000 bits written in 1.30888 seconds = 76401.0 bits per second
   $ ./time 1000000
   Desired bitrate: 1000000
   Writing data..
   100000 bits written in 0.0997873 seconds = 1002131.9 bits per second
*/

#include <stdio.h>
#include <ftdi.h>
#include <time.h>
#include <err.h>
#include <stdlib.h>
#include <stdbool.h>
#include <string.h>
#include <ctype.h>

void ftdi_error(struct ftdi_context *ftdic, const char *why)
{
        errx(1, "%s: %s", why, ftdi_get_error_string(ftdic));
}

int main(int argc, char **argv)
{
        struct ftdi_context ftdic;
        int ret;
        uint8_t *buf;
        int buflen = 100000;
        struct timespec start, end;
        float diff;

        int desired_bitrate = 76000;
        if (argc == 2)
                desired_bitrate = atoi(argv[1]);
        printf("Desired bitrate: %d\n", desired_bitrate);

        /* Initialize FTDI */
        ftdi_init(&ftdic);

        ret = ftdi_usb_open_desc(&ftdic, 0x0403, 0x6015, NULL, NULL);
        if (ret < 0)
                ftdi_error(&ftdic, "open");

        ret = ftdi_set_bitmode(&ftdic, 1, BITMODE_BITBANG);
        if (ret < 0)
                ftdi_error(&ftdic, "bitbang");

        /* FTDI chip scales bitrates up by 16 in bitbang mode.
           libftdi scales bitrates up by 4 in bitbang mode. */
        ret = ftdi_set_baudrate(&ftdic, desired_bitrate / 16 / 4);
        if (ret < 0)
                ftdi_error(&ftdic, "baudrate");

        ret = ftdi_write_data_set_chunksize(&ftdic, 1024);
        if (ret < 0)
                ftdi_error(&ftdic, "chunksize");

        buf = calloc(1, buflen);

        printf("Writing data..\n");
        clock_gettime(CLOCK_MONOTONIC, &start);
        ret = ftdi_write_data(&ftdic, buf, buflen);
        clock_gettime(CLOCK_MONOTONIC, &end);

        if (ret != buflen)
                ftdi_error(&ftdic, "write");

        diff = (end.tv_sec + end.tv_nsec / 1e9) -
                (start.tv_sec + start.tv_nsec / 1e9);

        printf("%d bits written in %g seconds = %.1f bits per second\n",
               buflen, diff, buflen / diff);

        free(buf);
        ftdi_usb_close(&ftdic);
        ftdi_deinit(&ftdic);

        return 0;
}