C getData Driver code

char* encode(const char* input)
{
    /* set up a destination buffer large enough to hold the encoded data */
    char* output = (char*)malloc(SIZE);
    /* keep track of our encoded position */
    char* c = output;
    /* store the number of bytes encoded by a single call */
    int cnt = 0;
    /* we need an encoder state */
    base64_encodestate s;

    /*---------- START ENCODING ----------*/
    /* initialise the encoder state */
    base64_init_encodestate(&s);
    /* gather data from the input and send it to the output */
    cnt = base64_encode_block(input, strlen(input), c, &s);
    c += cnt;
    /* since we have encoded the entire input string, we know that
     there is no more input data; finalise the encoding */
    cnt = base64_encode_blockend(c, &s);
    c += cnt;
    /*---------- STOP ENCODING  ----------*/

    /* we want to print the encoded data, so null-terminate it: */
    *c = 0;

    return output;
}

void getData(unsigned char* bufferString, int user)
{
    #pragma mark - Constants
        static const UInt32 GDHEM6310FProductID = 0x0094;
        static const UInt32 GDHEM6310FVendorID = 0x0590;
        static const size_t AccessEndOkResonposeSize = 9;
        static const size_t AccessStartResonposeSize = 25;

    #pragma mark - Variables
        int response;
        bool found = FALSE;
        unsigned char buf[64];
        hid_device *device;
        int i;
        size_t buffer_length = 0;
        const char *encodedBuffer;

    #pragma mark - Params (When converted to a function)
        unsigned char buffer[SIZE] = "";


    #pragma mark - Device Lookup
        struct hid_device_info *devs, *cur_dev;
        devs = hid_enumerate(GDHEM6310FVendorID, GDHEM6310FProductID);
        cur_dev = devs;

        hid_free_enumeration(devs);

        // Open the device using the VID, PID, last param optional
        device = hid_open(GDHEM6310FVendorID, GDHEM6310FProductID, NULL);
        if (device == NULL) {
            printf("NFC Tray not found\n");
            //return 1;
        }

        hid_set_nonblocking(device, 0);

    #pragma mark - Access Start Command
        for (i = 0; i < 24; i++)
        {
            printf("\nSending AccessStart Command\n");

            buf[0] = 0x02; // reportID
            buf[1] = 0x08;
            buf[2] = 0x00;
            buf[3] = 0x00;
            buf[4] = 0x00;
            buf[5] = 0x00;
            buf[6] = 0x10;
            buf[7] = 0x00;
            buf[8] = 0x18;

            printf("\nBytes to Write \n");
            for (size_t i = 0; i < sizeof(buf); i++) {
                printf("%02X ", buf[i]);
            }

            //send acces start command
            bool result = hid_write(device, buf, 9);
            if (!result) {
                printf("Device Error");
                printf("Error: %ls\n", hid_error(device));
                //return 1;
            }

            // Read start command response from device
            response = hid_read(device, buf, AccessStartResonposeSize);

            // Log out our response
            printf("\n");
            printf("\nResponse Size: %i\n", response);
            for (size_t i = 0; i < sizeof(buf); i++){
                printf("%02X ", buf[i]);
            }

            if (response < 0) {
                printf("Unable to read()\n");
            }

            if (buf[2] == 0xFF) {
                printf("Device Error buf[1] == 0xFF");
                printf("Error: %ls\n", hid_error(device));
                //return 1;
            }

            if (buf[1] == 0x08 && buf[7] == 0x00) {
                printf("Device Error buf[0] == 0x08 && buf[6] == 0x00 \n");
                printf("Error: %ls\n", hid_error(device));
                //return 1;
            }

            if (buf[1] != 0x18) {
                continue;
            }

            if (buf[7]  != 0x00 ||
                buf[8]  != 0x00 ||
                buf[9]  != 0x00 ||
                buf[10] != 0x94 ||
                buf[11] != 0x00 ||
                buf[12] != 0x03 )
            {
                printf("unknown model \n");
                printf("Error:  %ls\n", hid_error(device));
            }

            found = TRUE;

            // Add elements to the buffer array
            memcpy(buffer + buffer_length, buf + 8, 16);
            buffer_length += 16;

            break;
        }

        if (!found) {
            printf("\nDevice not found \n");
            printf("Error:  %ls\n", hid_error(device));
            //return 1;
        }

    #pragma mark - Read Settings Index
        if (true)
        {
            printf("\nReading setting index \n");

            buf[0] = 0x02;
            buf[1] = 0x08;
            buf[2] = 0x01;
            buf[3] = 0x00;
            buf[4] = 0x0F;
            buf[5] = 0x74;
            buf[6] = 0x1E;
            buf[7] = 0x00;
            buf[8] = 0x6C;

            // TODO: Check for Cancellation Here

            printf("Bytes to write for setting index: \n");
            for (size_t i = 0; i < sizeof(buf); i++) {
                printf("%02X ", buf[i]);
            }

            // Write Command
            bool result = hid_write(device, buf, 64);

            if (!result) {
                printf("Device Error result from write failed");
                printf("Error: %ls\n", hid_error(device));
                //return 1;
            }

            // TODO: Check For Cancellation

            // Read Report
            response = hid_read(device, buf, 64);
            printf("\n");
            printf("Bytes read from setting index \n");
            for (size_t i = 0; i < 64; i++) {
                printf("%02X ", buf[i]);
        }

            // TODO: Check For Cancellation

            if (buf[2] == 0xFF) {
                printf("\nDevice Error on setting index read\n");
                printf("Error: %ls\n", hid_error(device));
                //return 1;
            }

            // Add items to buffer
            memcpy(buffer + buffer_length, buf + 8, 30);
            buffer_length += 30;
        }

    #pragma mark - Read Data
        for (int address = 0x0370; address < 0x0370 + 1400 + 1400; address += 28)
        {
            printf("\nReading Data: 0x%04x \n", address);

            buf[0] = 0x02;
            buf[1] = 0x08;
            buf[2] = 0x01;
            buf[3] = 0x00;
            buf[4] = (address >> 8) & 0xff;
            buf[5] = (address & 0xff);
            buf[6] = 0x1C;
            buf[7] = 0x00;
            buf[8] = (buf[1] ^ buf[2] ^ buf[3] ^ buf[4] ^ buf[5] ^ buf[6] ^ buf[7]);

            // TODO: Check For Cancellation

            printf("\nBytes to write for reading data: \n");
            for (size_t i = 0; i < 64; i++) {
                printf("%02X ", buf[i]);
            }

            // Write Command
            bool result = hid_write(device, buf, 64);
            if (!result) {
                printf("Device Error result from write failed");
                printf("Error: %ls\n", hid_error(device));
                //return 1;
            }

            // TODO: Check For Cancellation

            // Read Report
            response = hid_read(device, buf, 64);

            // Log out our response
            printf("\n");
            printf("\nRead Data response size: %i\n", response);
            for (size_t i = 0; i < 64; i++) {
                printf("%02X ", buf[i]);
            }

            // TODO: Check For Cancellation

            if (buf[2] == 0xFF) {
                printf("read data device error");
                //return 1;
            }

            // Add elements to buffer array
            memcpy(buffer + buffer_length, buf + 8, 28);
            buffer_length += 28;
            printf("buffer_length = %zu", buffer_length);
        }

    #pragma mark - User Conditions
        if (user == 1)
        {
            // Zero out setting index, block 0, bytes 3 and 4
            for (size_t i = 16 + 2; i < 16; i++){
                buffer[i] = 0x00;
            }

            // Zero out setting index, block 0, bytes 7 and 8
            for (size_t i = 16 + 6; i < 16 + 2; i++){
                buffer[i] = 0x00;
            }

            // Zero out setting index, block 2
            for (size_t i = 16 + 8 + 6; i < 16 + 8 + 6 + 6; i++){
                buffer[i] = 0x00;
            }

            // Zero out user2 blood pressure data
            for (size_t i = 16 + 30 + 1400; i < 16 + 30 + 1400 + 1400; i++){
                buffer[i] = 0x00;
            }
            // Log out the buffer
            for (size_t i= 0; i < sizeof(buffer); i++) {
                printf("%02X ", buffer[i]);
            }
            //printf("\n size of buffer %lu", sizeof(buffer));

            // Convert the buffer into a a string
            char bufferString[SIZE] = "";
            for (int x = 0; x < sizeof(buffer); x++) {
                sprintf(bufferString+(x*2), "%02X ", buffer[x]);
            }
            printf("\n Buffer String %s", bufferString);
            encodedBuffer = encode(bufferString);
            printf("encoded string %s", encodedBuffer);
            /* encode the data */

        }
        else
        {
            // Zero out setting index, block 0, bytes 1 and 2
            for (size_t i = 16; i < 16 + 2; i++){
                buffer[i] = 0x00;
            }

            // Zero out setting index, block 0, bytes 5 and 6
            for (size_t i = 16 + 4; i < 16 + 4 +2; i++){
                buffer[i] = 0x00;
            }

            // Zero out setting index, block 1
            for (size_t i = 16 + 8; i < 16 + 8 + 6; i++){
                buffer[i] = 0x00;
            }

            // Zero out user1 blood pressure data
            for (size_t i = 16 + 30; i < 16 + 30 + 1400; i++){
                buffer[i] = 0x00;
            }
            // Log out the buffer
            for (size_t i= 0; i < sizeof(buffer); i++) {
                printf("%02X ", buffer[i]);
            }
        }

    #pragma mark - Access End Command
        if (true)
        {
            printf("\nSending AccessEnd Command \n");

            buf[0] = 0x02;
            buf[1] = 0x08;
            buf[2] = 0x0f;
            buf[3] = 0x00;
            buf[4] = 0x00;
            buf[5] = 0x00;
            buf[6] = 0x00;
            buf[7] = 0x00;
            buf[8] = 0x07;

            printf("\nBytes to write for AccessEnd command \n");
            for (int i = 0; i < 9; i++){
                printf("%02X ", buf[i]);
            }

            // Write Commmand
            bool result = hid_write(device, buf, 9);
            if (!result){
                printf("Device Error writing AccessEnd Command");
                //return 1;
            }

            // Read Response
            response = hid_read(device, buf, AccessEndOkResonposeSize);

            // Log Response
            printf("\n");
            printf("\nresponse size: %i\n", response);
            for (int i = 0; i < AccessEndOkResonposeSize; i++){
                printf("%02X ", buf[i]);
            }

            if (buf[2] == 0xFF){
                printf("\nDevice error in AccessEnd Command \n");
                //return 1;
            }

            printf("Closing Device");
            //hid_close(device);
        }
    }