From 84b980994934d54b3dad6dd2184830f4464b9933 Mon Sep 17 00:00:00 2001 From: Florian Jung Date: Sun, 29 Nov 2015 00:30:43 +0100 Subject: usb hello world \o/ --- pc/a.out | Bin 0 -> 12696 bytes pc/main.c | 134 ++++++++++++++++++++++++++++++++++++++++ pc/usbtest.c | 199 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 3 files changed, 333 insertions(+) create mode 100755 pc/a.out create mode 100644 pc/main.c create mode 100644 pc/usbtest.c (limited to 'pc') diff --git a/pc/a.out b/pc/a.out new file mode 100755 index 0000000..f1b6c1b Binary files /dev/null and b/pc/a.out differ diff --git a/pc/main.c b/pc/main.c new file mode 100644 index 0000000..fe0d75d --- /dev/null +++ b/pc/main.c @@ -0,0 +1,134 @@ +/* Name: set-led.c + * Project: custom-class, a basic USB example + * Author: Christian Starkjohann + * Creation Date: 2008-04-10 + * Tabsize: 4 + * Copyright: (c) 2008 by OBJECTIVE DEVELOPMENT Software GmbH + * License: GNU GPL v2 (see License.txt), GNU GPL v3 or proprietary (CommercialLicense.txt) + */ + +/* +General Description: +This is the host-side driver for the custom-class example device. It searches +the USB for the LEDControl device and sends the requests understood by this +device. +This program must be linked with libusb on Unix and libusb-win32 on Windows. +See http://libusb.sourceforge.net/ or http://libusb-win32.sourceforge.net/ +respectively. +*/ + +#include +#include +#include +#include /* this is libusb */ +#include "opendevice.h" /* common code moved to separate module */ + +#include "../firmware/requests.h" /* custom request numbers */ +#include "../firmware/usbconfig.h" /* device's VID/PID and names */ + +static void usage(char *name) +{ + fprintf(stderr, "usage:\n"); + fprintf(stderr, " %s on ....... turn on LED\n", name); + fprintf(stderr, " %s off ...... turn off LED\n", name); + fprintf(stderr, " %s status ... ask current status of LED\n", name); +#if ENABLE_TEST + fprintf(stderr, " %s test ..... run driver reliability test\n", name); +#endif /* ENABLE_TEST */ +} + +int main(int argc, char **argv) +{ +usb_dev_handle *handle = NULL; +const unsigned char rawVid[2] = {USB_CFG_VENDOR_ID}, rawPid[2] = {USB_CFG_DEVICE_ID}; +char vendor[] = {USB_CFG_VENDOR_NAME, 0}, product[] = {USB_CFG_DEVICE_NAME, 0}; +char buffer[4]; +int cnt, vid, pid, isOn; + + usb_init(); + if(argc < 2){ /* we need at least one argument */ + usage(argv[0]); + exit(1); + } + /* compute VID/PID from usbconfig.h so that there is a central source of information */ + vid = rawVid[1] * 256 + rawVid[0]; + pid = rawPid[1] * 256 + rawPid[0]; + /* The following function is in opendevice.c: */ + if(usbOpenDevice(&handle, vid, vendor, pid, product, NULL, NULL, NULL) != 0){ + fprintf(stderr, "Could not find USB device \"%s\" with vid=0x%x pid=0x%x\n", product, vid, pid); + exit(1); + } + /* Since we use only control endpoint 0, we don't need to choose a + * configuration and interface. Reading device descriptor and setting a + * configuration and interface is done through endpoint 0 after all. + * However, newer versions of Linux require that we claim an interface + * even for endpoint 0. Enable the following code if your operating system + * needs it: */ +#if 0 + int retries = 1, usbConfiguration = 1, usbInterface = 0; + if(usb_set_configuration(handle, usbConfiguration) && showWarnings){ + fprintf(stderr, "Warning: could not set configuration: %s\n", usb_strerror()); + } + /* now try to claim the interface and detach the kernel HID driver on + * Linux and other operating systems which support the call. */ + while((len = usb_claim_interface(handle, usbInterface)) != 0 && retries-- > 0){ +#ifdef LIBUSB_HAS_DETACH_KERNEL_DRIVER_NP + if(usb_detach_kernel_driver_np(handle, 0) < 0 && showWarnings){ + fprintf(stderr, "Warning: could not detach kernel driver: %s\n", usb_strerror()); + } +#endif + } +#endif + + if(strcasecmp(argv[1], "status") == 0){ + cnt = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, CUSTOM_RQ_GET_STATUS, 0, 0, buffer, sizeof(buffer), 5000); + if(cnt < 1){ + if(cnt < 0){ + fprintf(stderr, "USB error: %s\n", usb_strerror()); + }else{ + fprintf(stderr, "only %d bytes received.\n", cnt); + } + }else{ + printf("LED is %s\n", buffer[0] ? "on" : "off"); + } + }else if((isOn = (strcasecmp(argv[1], "on") == 0)) || strcasecmp(argv[1], "off") == 0){ + cnt = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT, CUSTOM_RQ_SET_STATUS, isOn, 0, buffer, 0, 5000); + if(cnt < 0){ + fprintf(stderr, "USB error: %s\n", usb_strerror()); + } +#if ENABLE_TEST + }else if(strcasecmp(argv[1], "test") == 0){ + int i; + srandomdev(); + for(i = 0; i < 50000; i++){ + int value = random() & 0xffff, index = random() & 0xffff; + int rxValue, rxIndex; + if((i+1) % 100 == 0){ + fprintf(stderr, "\r%05d", i+1); + fflush(stderr); + } + cnt = usb_control_msg(handle, USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, CUSTOM_RQ_ECHO, value, index, buffer, sizeof(buffer), 5000); + if(cnt < 0){ + fprintf(stderr, "\nUSB error in iteration %d: %s\n", i, usb_strerror()); + break; + }else if(cnt != 4){ + fprintf(stderr, "\nerror in iteration %d: %d bytes received instead of 4\n", i, cnt); + break; + } + rxValue = ((int)buffer[0] & 0xff) | (((int)buffer[1] & 0xff) << 8); + rxIndex = ((int)buffer[2] & 0xff) | (((int)buffer[3] & 0xff) << 8); + if(rxValue != value || rxIndex != index){ + fprintf(stderr, "\ndata error in iteration %d:\n", i); + fprintf(stderr, "rxValue = 0x%04x value = 0x%04x\n", rxValue, value); + fprintf(stderr, "rxIndex = 0x%04x index = 0x%04x\n", rxIndex, index); + } + } + fprintf(stderr, "\nTest completed.\n"); +#endif /* ENABLE_TEST */ + }else{ + usage(argv[0]); + exit(1); + } + usb_close(handle); + return 0; +} diff --git a/pc/usbtest.c b/pc/usbtest.c new file mode 100644 index 0000000..002add4 --- /dev/null +++ b/pc/usbtest.c @@ -0,0 +1,199 @@ +/** + * Project: AVR ATtiny USB Tutorial at http://codeandlife.com/ + * Author: Joonas Pihlajamaa, joonas.pihlajamaa@iki.fi + * Based on V-USB example code by Christian Starkjohann + * Copyright: (C) 2012 by Joonas Pihlajamaa + * License: GNU GPL v3 (see License.txt) + */ +#include +#include +#include +#include + +// 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 shorter 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_set_debug(3); + + 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; +} + +int main(int argc, char **argv) +{ + usb_dev_handle *handle = NULL; + int nBytes = 0; + char buffer[256]; + + handle = usbOpenDevice(0x16C0, "windfisch.org", 0x05DC, "DS1992 Dumper"); + + if(handle == NULL) + { + fprintf(stderr, "Could not find USB device!\n"); + exit(1); + } + + printf("got device\n"); + + // read from device + nBytes = usb_control_msg(handle, + USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, + 0x21, 0, 0, (char *)buffer, sizeof(buffer), 1000); + printf("Got %d bytes: %s;\n", nBytes, buffer); + + // write to device + nBytes = usb_control_msg(handle, + USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT, + 0x42, 0, 0, "Tschuess", strlen("Tschuess"), 1000); + printf("Wrote %d bytes\n", nBytes); + + + + + // read from device + nBytes = usb_control_msg(handle, + USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, + 0x21, 0, 0, (char *)buffer, sizeof(buffer), 1000); + printf("Got %d bytes: %s;\n", nBytes, buffer); + +/* + + nBytes = usb_control_msg(handle, + USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, + 0x42, 0,0, + (char *)buffer, sizeof(buffer), 5000); + if(strcmp(argv[1], "on") == 0) + { + nBytes = usb_control_msg(handle, + USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, + USB_LED_ON, 0, 0, (char *)buffer, sizeof(buffer), 5000); + } + else if(strcmp(argv[1], "off") == 0) + { + nBytes = usb_control_msg(handle, + USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, + USB_LED_OFF, 0, 0, (char *)buffer, sizeof(buffer), 5000); + } + else if(strcmp(argv[1], "out") == 0) + { + nBytes = usb_control_msg(handle, + USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, + USB_DATA_OUT, 0, 0, (char *)buffer, sizeof(buffer), 5000); + printf("Got %d bytes: %s\n", nBytes, buffer); + } + else if(strcmp(argv[1], "write") == 0) + { + nBytes = usb_control_msg(handle, + USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_IN, + USB_DATA_WRITE, 'T' + ('E' << 8), 'S' + ('T' << 8), + (char *)buffer, sizeof(buffer), 5000); + } + else if(strcmp(argv[1], "in") == 0 && argc > 2) + { + nBytes = usb_control_msg(handle, + USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_ENDPOINT_OUT, + USB_DATA_IN, 0, 0, argv[2], strlen(argv[2])+1, 5000); + } +*/ + if(nBytes < 0) + fprintf(stderr, "USB error: %s\n", usb_strerror()); + + usb_close(handle); + + return 0; +} -- cgit v1.2.1