Subversion Repositories group.electronics

#include <ncurses.h>
#include <malloc.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <usb.h>


static int usbGetDescriptorString(usb_dev_handle *dev, int index, int langid, char *buf, int buflen);
static usb_dev_handle * usbOpenDevice(int vendor, char *vendorName, int product, char *productName);
char sendDigit(char dis, char dig, char val);

char* getBCD(char maxLen);
short getHex();
void printBCD(char* data);
void printB(char *data);

usb_dev_handle *handle = NULL;

main() {


        handle = usbOpenDevice(0x20a0, "newioit.com.au", 0x4236, "NIT Comm/Nav");

        if(handle == NULL) {
                fprintf(stderr, "Could not find USB device!\n");
                exit(1);
        }

        initscr();
        raw();
        keypad(stdscr, TRUE);
        noecho();



        char dis = 0x00;
        char dig = 0x03;
        short val = 0x02;

        char cont = 1;

        //char display[] = {

        while (cont) {
                clear();

                printw("\nCursor: ");
                printw("Dis: %x ", dis);
                printw("Dig %x ", dig);
                printw("Val %x \n", val);

                char key = 0x00;
                key = getch();


                if (key >= 0x30 && key <= 0x39) {
                        val = key - '0';
                } else if  (key == 'w') {
                        if (val != 10)
                                val++;
                } else if (key == 's') {
                        if (val != 0)
                                val--;
                } else if (key == 'd') {
                        if (dig!=0)
                                dig--;
                } else if (key == 'a') {
                        if (dig != 4)
                                dig++;
                } else if (key == 'q') {
                        if (dis != 1)
                                dis++;
                } else if (key == 'e') {
                        if (dis != 0)
                                dis--;
                } else if (key == 'l') {
                        printw(":");
                        char* data = getBCD(5);
                        char i;
                        char n = 4;
                        for (i=0; i<5; i++) {
                                sendDigit(dis, i, data[n]);
                                n--;
                        }
                        free(data);
                } else if (key == 'k') {
                        printw("k");
                        char data1[5] = {0x0a, 0x0a, 0x0a, 0x0a, 0x0a};
                        char data2[5] = {0x0a, 0x0a, 0x0a, 0x0a, 0x0a};
                        char i;
                        for (i=0; i<5; i++) {
                                sendDigit(0, i, data1[i]);
                        }
                        for (i=0; i<5; i++) {
                                sendDigit(1, i, data2[i]);
                        }
                } else if (key == 0x0a) {
                        sendDigit(dis, dig, val);
                } else if (key == 0x1b) {
                        cont = 0;
                }
        }

        printw("\nPress key to exit\n");
        getch();
        endwin();

        usb_close(handle);

        return 0;
}

char sendDigit(char dis, char dig, char val) {
        char nBytes = 0;
        char* usbReplyBuf[64];

        nBytes = usb_control_msg(handle,
                USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
                20,
                (short)dis<<8 | dig,
                val,
                *usbReplyBuf,
                sizeof(usbReplyBuf),
                5000);
}

char* getBCD(char maxLen) {
        if (maxLen > 8) maxLen == 8;
        char* buffer = malloc(sizeof(char) * maxLen);
        char len = 0;


        while (1) {
                char key = 0x00;
                key = getch();
                if ((key >= 0x30 && key <= 0x39) && len < maxLen) {
                        buffer[len] = key - '0';
                        len++;
                        printw("%c", key);
                } else if (key == 0x07) {
                        delch();
                        delch();
                        len--;
                        buffer[len] = 0x00;
                } else if  (key == 0x0a) {
                        return buffer;
                } else if (key == 0x1b) {
                        return malloc(sizeof(char));
                } else if (key == 0x71) {

                }

        }
}



/* Used to get descriptor strings for device identification */
static int usbGetDescriptorString(usb_dev_handle *dev, int index, int langid,
                                  char *buf, int buflen) {
    char buffer[256];
    int rval, i;

        // make standard request GET_DESCRIPTOR, type string and given index
    // (e.g. dev->iProduct)
        rval = usb_control_msg(dev,
        USB_TYPE_STANDARD | USB_RECIP_DEVICE | USB_ENDPOINT_IN,
        USB_REQ_GET_DESCRIPTOR, (USB_DT_STRING << 8) + index, langid,
        buffer, sizeof(buffer), 1000);

    if(rval < 0) // error
                return rval;

    // rval should be bytes read, but buffer[0] contains the actual response size
        if((unsigned char)buffer[0] < rval)
                rval = (unsigned char)buffer[0]; // string is inter than bytes read

        if(buffer[1] != USB_DT_STRING) // second byte is the data type
                return 0; // invalid return type

        // we're dealing with UTF-16LE here so actual chars is half of rval,
        // and index 0 doesn't count
        rval /= 2;

        /* lossy conversion to ISO Latin1 */
        for(i = 1; i < rval && i < buflen; i++) {
                if(buffer[2 * i + 1] == 0)
                        buf[i-1] = buffer[2 * i];
                else
                        buf[i-1] = '?'; /* outside of ISO Latin1 range */
        }
        buf[i-1] = 0;

        return i-1;
}

static usb_dev_handle * usbOpenDevice(int vendor, char *vendorName,
                                      int product, char *productName) {
        struct usb_bus *bus;
        struct usb_device *dev;
        char devVendor[256], devProduct[256];

        usb_dev_handle * handle = NULL;

        usb_init();
        usb_find_busses();
        usb_find_devices();

        for(bus=usb_get_busses(); bus; bus=bus->next) {
                for(dev=bus->devices; dev; dev=dev->next) {

                        if(dev->descriptor.idVendor != vendor ||
                                dev->descriptor.idProduct != product)
                                continue;

                         /* we need to open the device in order to query strings */
                        if(!(handle = usb_open(dev))) {
                                fprintf(stderr, "Warning: cannot open USB device: %s\n",
                                usb_strerror());
                                continue;
                        }

                        /* get vendor name */
                        if(usbGetDescriptorString(handle, dev->descriptor.iManufacturer, 0x0409, devVendor, sizeof(devVendor)) < 0) {
                                fprintf(stderr, "Warning: cannot query manufacturer for device: %s\n", usb_strerror());
                                usb_close(handle);
                                continue;
                        }

                        /* get product name */
                        if(usbGetDescriptorString(handle, dev->descriptor.iProduct, 0x0409, devProduct, sizeof(devVendor)) < 0) {
                                fprintf(stderr, "Warning: cannot query product for device: %s\n", usb_strerror()); usb_close(handle);
                                continue;
                        }

                        if(strcmp(devVendor, vendorName) == 0 && strcmp(devProduct, productName) == 0)
                                return handle;
                        else
                                usb_close(handle);
                }
        }

        return NULL;
}


/*******************************************************/
/*
char* getBCD(char maxLen) {
        if (maxLen > 8) maxLen == 8;
        char* buffer = malloc(sizeof(char) * maxLen);
        char len = 0;


        while (1) {
                char key = 0x00;
                key = getch();
                if ((key >= 0x30 && key <= 0x38) && len < maxLen) {
                        buffer[len] = key - '0';
                        len++;
                        printw("%c", key);
                } else if (key == 0x08) {
                        delch();
                        len--;
                        buffer[len] = 0x00;
                } else if  (key == 0x0a) {
                        return buffer;
                } else if (key == 0x1b) {
                        return malloc(sizeof(char));
                } else if (key == 0x71) {

                }

        }
}
*/