Objective Development Forums

Code: Select all

#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/pgmspace.h>
#include <util/delay.h>
#include <string.h>

#include "usbdrv.h"
#include "keyboard.h"

void setCol(uchar col);

/*   LED PW   C1      01 - 02      C6   Column
   Row      C2      03 - 04      C7   Break
   Row      C3      05 - 06      E2   Row
   Column   C4      07 - 08      E1   Row
   Column   C5      09 - 10      E0   Column
   Column   C0      11 - 12      A7   Column
   Column   D5      13 - 14      A6   Column
   Column   D4      15 - 16      A5   Column
   Column   B4      17 - 18      A4   Column
   Row      B3      19 - 20      A3   SHIFT+CTRL
   Row      B2      21 - 22      A2   Column
   LED CA   B1      23 - 24      A1   Column
   LED A   B0      25 - 26      A0   LED SH
*/

#define   LED_CAB      1
#define   LED_CAP      PORTB
#define   LED_SHB      0
#define   LED_SHP      PORTA
#define   LED_PWB      1
#define   LED_PWP      PORTC

#define   NUMROWS      7
#define   NUMCOLS      13

static uchar    reportBuffer[8];    /* buffer for HID reports */
static uchar    idleRate;           /* in 4 ms units */
static uchar   LEDstate = 0;
static uchar   expectReport = 0;
static uchar   protocolVer = 1;    /* 0 is boot protocol, 1 is report protocol */
static uchar   cache[NUMCOLS+1];

//static uchar   testkey = K_A;

const uchar bitmask[8] = {
   0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80
};

/*
{   N8   W   9   N9   T   7      0   _   I   DN   F10   E      }   // 0 E1
{   N+   2   O   N-   R   6   Ne   P   [   U   UP   1   D      }   // 1 E2
{   N4   F1   F8   N5   F3   F5   N2   F9   <<   F6   RT   ESC   F2      }   // 2 B3
{   N6   3   F7   N7   5   F4      -   ^   8   LF   Q   4      }   // 3 B4
{   #   S   L   Na   G   H   N,   ;   ]   N   BKS   SL   C      }   // 4 D4
{   N0   Z   ,   N1   V   B   N3   .   /   M   CPY   TAB   SPC      }   // 5 C3
{   N/   A   K   DEL   F   Y   Nd   []   :   J   ENT   CL   X      }   // 6 C2
*/

const unsigned char keymap[NUMROWS][NUMCOLS] PROGMEM = {
//   E0      A1      A2      C4      A4      A5      A6      A7      C0      D5      C5      B2      C6
//   0      1      2      3      4      5      6      7      8      9      A      B      C
{   K_NUM8,   K_W,   K_9,   K_NUM9,   K_T,   K_7,   K_NON,   K_0,   S_UND,   K_I,   K_DARR,   K_F10,   K_E      },   // 0 E1
{   K_NUMp,   K_2,   K_O,   K_NUMm,   K_R,   K_6,   K_NUMe,   K_P,   K_LSQB,   K_U,   K_UARR,   K_1,   K_D      },   // 1 E2
{   K_NUM4,   K_F1,   K_F8,   K_NUM5,   K_F3,   K_F5,   K_NUM2,   K_F9,   S_BKSL,   K_F6,   K_RARR,   K_ESC,   K_F2   },   // 2 B3
{   K_NUM6,   K_3,   K_F7,   K_NUM7,   K_5,   K_F4,   K_NON,   K_MIN,   S_KARA,   K_8,   K_LARR,   K_Q,   K_4      },   // 3 B4
{   S_NUMH,   K_S,   K_L,   K_NUMa,   K_G,   K_H,   S_NUMc,   K_SCOL,   K_RSQB,   K_N,   K_BKS,   S_SLK,   K_C      },   // 4 D4
{   K_NUM0,   K_Z,   K_COMM,   K_NUM1,   K_V,   K_B,   K_NUM3,   K_DOT,   K_SLSH,   K_M,   S_COPY,   K_TAB,   K_SPC   },   // 5 C3
{   K_NUMs,   K_A,   K_K,   S_DEL,   K_F,   K_Y,   S_NUMd,   S_CODE,   S_COL,   K_J,   K_ENT,   K_CPSL,   K_X      },   // 6 C2
//{   K_NON,   M_CTRL,   K_NON,   K_NON,   K_NON,   K_NON,   K_NON,   K_NON,   K_NON,   K_NON,   K_NON,   M_SHIFT,K_NON   }   // 7 A3
};
//   SHIFT   BREAK   CTRL

uchar   reportcount;

void addKey(uchar key)
{
   if ((reportcount < 8) && (key != 0))
   {
      if (key > K_Modifiers)
      {
         switch (key)
         {
            case M_SHIFT:
               reportBuffer[0] |= MOD_SHIFT_LEFT;
               break;
            case M_CTRL:
               reportBuffer[0] |= MOD_CONTROL_LEFT;
               break;
            case M_ALT:
               reportBuffer[0] |= MOD_ALT_LEFT;
               break;
         }
      }
      else
      {
         reportBuffer[reportcount] = key;
         reportcount++;
      }
   }
}

static uchar scanKeys(void)
{
   //uchar   temp;
   uchar   i;
   uchar   bitmap[NUMCOLS+1];
   uchar   changed = 0;

   memset(reportBuffer, 0, sizeof(reportBuffer));
   memset(bitmap, 0xff, sizeof(bitmap));

   for (i = 0; i < NUMCOLS; i++)
   {
      setCol(i);
      if (!(PINE & (1<<1))) bitmap[i] &= ~(1<<0);
      if (!(PINE & (1<<2))) bitmap[i] &= ~(1<<1);
      if (!(PINB & (1<<3))) bitmap[i] &= ~(1<<2);
      if (!(PINB & (1<<4))) bitmap[i] &= ~(1<<3);
      if (!(PIND & (1<<4))) bitmap[i] &= ~(1<<4);
      if (!(PINC & (1<<3))) bitmap[i] &= ~(1<<5);
      if (!(PINC & (1<<2))) bitmap[i] &= ~(1<<6);
      if (bitmap[i] ^ cache[i]) changed = 1;
   }

   // CTRL
   setCol(1);
   if (!(PINA & (1<<3)))
   {
      bitmap[NUMCOLS] &= ~(1<<2);
   }

   // SHIFT
   setCol(11);
   if (!(PINA & (1<<3)))
   {
      bitmap[NUMCOLS] &= ~(1<<0);
   }

   // BREAK
   LED_PWP &= ~(1<<LED_PWB);
   if (!(PINC & (1<<7)))
   {
      bitmap[NUMCOLS] &= ~(1<<1);
   }
   if (LEDstate & LED_SCROLL)      // reset power LED state
      LED_PWP |= (1<<LED_PWB);
   else
      LED_PWP &= ~(1<<LED_PWB);

   if (bitmap[NUMCOLS] ^ cache[NUMCOLS]) changed = 1;

   if (changed)
   {
      reportcount = 1;
      for (i = 0; i < NUMCOLS; i++)
      {
         //if (!(bitmap[i])){ addKey(testkey); testkey++; }
         if (!(bitmap[i] & (1<<0))) addKey(pgm_read_byte(&keymap[0][i]));
         if (!(bitmap[i] & (1<<1))) addKey(pgm_read_byte(&keymap[1][i]));
         if (!(bitmap[i] & (1<<2))) addKey(pgm_read_byte(&keymap[2][i]));
         if (!(bitmap[i] & (1<<3))) addKey(pgm_read_byte(&keymap[3][i]));
         if (!(bitmap[i] & (1<<4))) addKey(pgm_read_byte(&keymap[4][i]));
         if (!(bitmap[i] & (1<<5))) addKey(pgm_read_byte(&keymap[5][i]));
         if (!(bitmap[i] & (1<<6))) addKey(pgm_read_byte(&keymap[6][i]));
      }
      if (!(bitmap[NUMCOLS] & (1<<0))) addKey(M_SHIFT);
      if (!(bitmap[NUMCOLS] & (1<<2))) addKey(M_CTRL);
      if (!(bitmap[NUMCOLS] & (1<<1))) addKey(K_F12); // K_BREAK

      memcpy(cache, bitmap, sizeof(bitmap));

      return 1;
   }
   else
      return 0;
}

void setCol(uchar col)
{
   PORTA   |= 0b11110110;
   DDRA   &= ~0b11110110;
   PORTB   |= (1<<2);
   DDRB   &= ~(1<<2);
   PORTC   |= 0b01110001;
   DDRC   &= ~0b01110001;
   PORTD   |= (1<<5);
   DDRD   &= ~(1<<5);
   PORTE   |= (1<<0);
   DDRE   &= ~(1<<0);

   switch (col)
   {
      case 0:
         PORTE &= ~(1<<0);
         DDRE |= (1<<0);
         break;
      case 1:
         PORTA &= ~(1<<1);
         DDRA |= (1<<1);
         break;
      case 2:
         PORTA &= ~(1<<2);
         DDRA |= (1<<2);
         break;
      case 3:
         PORTC &= ~(1<<4);
         DDRC |= (1<<4);
         break;
      case 4:
         PORTA &= ~(1<<4);
         DDRA |= (1<<4);
         break;
      case 5:
         PORTA &= ~(1<<5);
         DDRA |= (1<<5);
         break;
      case 6:
         PORTA &= ~(1<<6);
         DDRA |= (1<<6);
         break;
      case 7:
         PORTA &= ~(1<<7);
         DDRA |= (1<<7);
         break;
      case 8:
         PORTC &= ~(1<<0);
         DDRC |= (1<<0);
         break;
      case 9:
         PORTD &= ~(1<<5);
         DDRD |= (1<<5);
         break;
      case 10:
         PORTC &= ~(1<<5);
         DDRC |= (1<<5);
         break;
      case 11:
         PORTB &= ~(1<<2);
         DDRB |= (1<<2);
         break;
      case 12:
         PORTC &= ~(1<<6);
         DDRC |= (1<<6);
         break;
   }

   _delay_us(100);
}

/* ----------------------- hardware I/O abstraction ------------------------ */

static void hardwareInit(void)
{
   PORTA   = 0b11111110;
   DDRA   = 0b00000001;

   PORTB   = 0b11111111;
   DDRB   = 0b00000011;

   PORTC   = 0b11111111;
   DDRC   = 0b00000010;

   PORTD   = 0b11110011;
   DDRD   = 0b00000000;

   PORTE   = 0b11111111;
   DDRE   = 0b00000000;

   TCCR0   = 5;         // timer 0 prescaler: 1024, 45.78Hz

   memset(cache, 0xff, sizeof(cache));
}

/* ------------------------------------------------------------------------- */

PROGMEM char usbHidReportDescriptor[USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH] = {
   0x05, 0x01,            // USAGE_PAGE (Generic Desktop)
   0x09, 0x06,            // USAGE (Keyboard)
   0xa1, 0x01,            // COLLECTION (Application)
   0x05, 0x07,            //   USAGE_PAGE (Keyboard)
   0x19, 0xe0,            //   USAGE_MINIMUM (Keyboard LeftControl)
   0x29, 0xe7,            //   USAGE_MAXIMUM (Keyboard Right GUI)
   0x15, 0x00,            //   LOGICAL_MINIMUM (0)
   0x25, 0x01,            //   LOGICAL_MAXIMUM (1)
   0x75, 0x01,            //   REPORT_SIZE (1)
   0x95, 0x08,            //   REPORT_COUNT (8)
   0x81, 0x02,            //   INPUT (Data,Var,Abs)
   0x95, 0x01,            //   REPORT_COUNT (1)
   0x75, 0x08,            //   REPORT_SIZE (8)
   0x81, 0x03,            //   INPUT (Cnst,Var,Abs)
   0x95, 0x05,            //   REPORT_COUNT (5)
   0x75, 0x01,            //   REPORT_SIZE (1)
   0x05, 0x08,            //   USAGE_PAGE (LEDs)
   0x19, 0x01,            //   USAGE_MINIMUM (Num Lock)
   0x29, 0x05,            //   USAGE_MAXIMUM (Kana)
   0x91, 0x02,            //   OUTPUT (Data,Var,Abs)
   0x95, 0x01,            //   REPORT_COUNT (1)
   0x75, 0x03,            //   REPORT_SIZE (3)
   0x91, 0x03,            //   OUTPUT (Cnst,Var,Abs)
   0x95, 0x06,            //   REPORT_COUNT (6)
   0x75, 0x08,            //   REPORT_SIZE (8)
   0x15, 0x00,            //   LOGICAL_MINIMUM (0)
   0x25, 0x65,            //   LOGICAL_MAXIMUM (101)
   0x05, 0x07,            //   USAGE_PAGE (Keyboard)
   0x19, 0x00,            //   USAGE_MINIMUM (Reserved (no event indicated))
   0x29, 0x65,            //   USAGE_MAXIMUM (Keyboard Application)
   0x81, 0x00,            //   INPUT (Data,Ary,Abs)
   0xc0                   // END_COLLECTION
};

/* ------------------------------------------------------------------------- */

uchar usbFunctionSetup(uchar data[8])
{
   usbRequest_t    *rq = (void *)data;

    usbMsgPtr = reportBuffer;

    if((rq->bmRequestType & USBRQ_TYPE_MASK) != USBRQ_TYPE_CLASS)
      return 0;

   switch (rq->bRequest)
   {
        case USBRQ_HID_GET_REPORT:
         return sizeof(reportBuffer);

      case USBRQ_HID_SET_REPORT:
         if (rq->wLength.word == 1)
         {
            expectReport = 1;
            return 0xFF;
         }
         return 0;

      case USBRQ_HID_GET_IDLE:
         usbMsgPtr = &idleRate;
         return 1;

      case USBRQ_HID_SET_IDLE:
            idleRate = rq->wValue.bytes[1];
         return 0;

      case USBRQ_HID_GET_PROTOCOL:
         if (rq->wValue.bytes[1] < 1)
            protocolVer = rq->wValue.bytes[1];
         return 0;

      case USBRQ_HID_SET_PROTOCOL:
         usbMsgPtr = &protocolVer;
         return 1;

      default:
         return 0;
   }
}

/* ------------------------------------------------------------------------- */

uchar usbFunctionWrite(uchar *data, uchar len) {
   if ((expectReport) && (len == 1)) {
      // Set the state of all 5 LEDs
      LEDstate = data[0];
      if (LEDstate & LED_CAPS)
         LED_CAP &= ~(1<<LED_CAB);
      else
         LED_CAP |= (1<<LED_CAB);

      // Shift Lock LED is reversed Num Lock
      if (LEDstate & LED_NUM)
         LED_SHP |= (1<<LED_SHB);
      else
         LED_SHP &= ~(1<<LED_SHB);

      // Power LED is reversed Scroll Lock
      if (LEDstate & LED_SCROLL)
         LED_PWP |= (1<<LED_PWB);
      else
         LED_PWP &= ~(1<<LED_PWB);

   }
   expectReport = 0;
   return 0x01;
}

/* ------------------------------------------------------------------------- */

int   main(void)
{
   uchar   updateNeeded = 0;
   uchar   idleCounter = 0;

    hardwareInit();

   usbInit();

   cli();                  // disable interrupts
    usbDeviceDisconnect();
   DDRD |= (1<<2) | (1<<3);   // USB reset

   _delay_ms(255);            // disconnect for >250ms

    usbDeviceConnect();
   DDRD &= ~((1<<2) | (1<<3));   // clear reset
   sei();                  // restart interrupts

   LED_PWP &= ~(1<<LED_PWB);
   LED_CAP |= (1<<LED_CAB);
   //LED_SHP |= (1<<LED_SHB);
   LED_SHP &= ~(1<<LED_SHB);

   for(;;)
   {
      usbPoll();

      updateNeeded = scanKeys();

      // Check timer if we need periodic reports
      if (TIFR & (1 << TOV0))
      {
         // Reset flag
         TIFR = 1 << TOV0;
         // Do we need periodic reports?
         if (idleRate != 0)
         {
            if (idleCounter > 4)
            {
               // Yes, but not yet
               // 22 ms in units of 4 ms
               idleCounter -= 5;
            }
            else
            {
               // Yes, it is time now
               updateNeeded = 1;
               idleCounter = idleRate;
            }
         }
      }

      if (updateNeeded && usbInterruptIsReady())
      {
         updateNeeded = 0;
         usbSetInterrupt(reportBuffer, sizeof(reportBuffer));
      }
   }
   return 0;
}

Code: Select all

/* Name: usbconfig.h
 * Project: AVR USB driver
 * Author: Christian Starkjohann
 * Creation Date: 2005-04-01
 * Tabsize: 4
 * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
 * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt)
 * This Revision: $Id: usbconfig-prototype.h 600 2008-05-13 10:34:56Z cs $
 */

#ifndef __usbconfig_h_included__
#define __usbconfig_h_included__

/*
General Description:
This file is an example configuration (with inline documentation) for the USB
driver. It configures AVR-USB for USB D+ connected to Port D bit 2 (which is
also hardware interrupt 0 on many devices) and USB D- to Port D bit 4. You may
wire the lines to any other port, as long as D+ is also wired to INT0 (or any
other hardware interrupt, as long as it is the highest level interrupt, see
section at the end of this file).
*/

/* ---------------------------- Hardware Config ---------------------------- */

#define USB_CFG_IOPORTNAME      D
/* This is the port where the USB bus is connected. When you configure it to
 * "B", the registers PORTB, PINB and DDRB will be used.
 */
#define USB_CFG_DMINUS_BIT      3
/* This is the bit number in USB_CFG_IOPORT where the USB D- line is connected.
 * This may be any bit in the port.
 */
#define USB_CFG_DPLUS_BIT       2
/* This is the bit number in USB_CFG_IOPORT where the USB D+ line is connected.
 * This may be any bit in the port. Please note that D+ must also be connected
 * to interrupt pin INT0! [You can also use other interrupts, see section
 * "Optional MCU Description" below, or you can connect D- to the interrupt, as
 * it is required if you use the USB_COUNT_SOF feature. If you use D- for the
 * interrupt, the USB interrupt will also be triggered at Start-Of-Frame
 * markers every millisecond.]
 */
#define USB_CFG_CLOCK_KHZ       (F_CPU/1000)
/* Clock rate of the AVR in MHz. Legal values are 12000, 15000, 16000, 16500
 * and 20000. The 16.5 MHz version of the code requires no crystal, it
 * tolerates +/- 1% deviation from the nominal frequency. All other rates
 * require a precision of 2000 ppm and thus a crystal!
 * Default if not specified: 12 MHz
 */

/* ----------------------- Optional Hardware Config ------------------------ */

/* #define USB_CFG_PULLUP_IOPORTNAME   D */
/* If you connect the 1.5k pullup resistor from D- to a port pin instead of
 * V+, you can connect and disconnect the device from firmware by calling
 * the macros usbDeviceConnect() and usbDeviceDisconnect() (see usbdrv.h).
 * This constant defines the port on which the pullup resistor is connected.
 */
/* #define USB_CFG_PULLUP_BIT          4 */
/* This constant defines the bit number in USB_CFG_PULLUP_IOPORT (defined
 * above) where the 1.5k pullup resistor is connected. See description
 * above for details.
 */

/* --------------------------- Functional Range ---------------------------- */

#define USB_CFG_HAVE_INTRIN_ENDPOINT    1
/* Define this to 1 if you want to compile a version with two endpoints: The
 * default control endpoint 0 and an interrupt-in endpoint (any other endpoint
 * number).
 */
#define USB_CFG_HAVE_INTRIN_ENDPOINT3   0
/* Define this to 1 if you want to compile a version with three endpoints: The
 * default control endpoint 0, an interrupt-in endpoint 3 (or the number
 * configured below) and a catch-all default interrupt-in endpoint as above.
 * You must also define USB_CFG_HAVE_INTRIN_ENDPOINT to 1 for this feature.
 */
//#define USB_CFG_EP3_NUMBER              3
/* If the so-called endpoint 3 is used, it can now be configured to any other
 * endpoint number (except 0) with this macro. Default if undefined is 3.
 */
/* #define USB_INITIAL_DATATOKEN           USBPID_DATA1 */
/* The above macro defines the startup condition for data toggling on the
 * interrupt/bulk endpoints 1 and 3. Defaults to USBPID_DATA1.
 * Since the token is toggled BEFORE sending any data, the first packet is
 * sent with the oposite value of this configuration!
 */
#define USB_CFG_IMPLEMENT_HALT          0
/* Define this to 1 if you also want to implement the ENDPOINT_HALT feature
 * for endpoint 1 (interrupt endpoint). Although you may not need this feature,
 * it is required by the standard. We have made it a config option because it
 * bloats the code considerably.
 */
#define USB_CFG_INTR_POLL_INTERVAL      10
/* If you compile a version with endpoint 1 (interrupt-in), this is the poll
 * interval. The value is in milliseconds and must not be less than 10 ms for
 * low speed devices.
 */
#define USB_CFG_IS_SELF_POWERED         0
/* Define this to 1 if the device has its own power supply. Set it to 0 if the
 * device is powered from the USB bus.
 */
#define USB_CFG_MAX_BUS_POWER           200
/* Set this variable to the maximum USB bus power consumption of your device.
 * The value is in milliamperes. [It will be divided by two since USB
 * communicates power requirements in units of 2 mA.]
 */
#define USB_CFG_IMPLEMENT_FN_WRITE      1
/* Set this to 1 if you want usbFunctionWrite() to be called for control-out
 * transfers. Set it to 0 if you don't need it and want to save a couple of
 * bytes.
 */
#define USB_CFG_IMPLEMENT_FN_READ       0
/* Set this to 1 if you need to send control replies which are generated
 * "on the fly" when usbFunctionRead() is called. If you only want to send
 * data from a static buffer, set it to 0 and return the data from
 * usbFunctionSetup(). This saves a couple of bytes.
 */
#define USB_CFG_IMPLEMENT_FN_WRITEOUT   0
/* Define this to 1 if you want to use interrupt-out (or bulk out) endpoints.
 * You must implement the function usbFunctionWriteOut() which receives all
 * interrupt/bulk data sent to any endpoint other than 0. The endpoint number
 * can be found in 'usbRxToken'.
 */
#define USB_CFG_HAVE_FLOWCONTROL        0
/* Define this to 1 if you want flowcontrol over USB data. See the definition
 * of the macros usbDisableAllRequests() and usbEnableAllRequests() in
 * usbdrv.h.
 */
#define USB_CFG_LONG_TRANSFERS          0
/* Define this to 1 if you want to send/receive blocks of more than 254 bytes
 * in a single control-in or control-out transfer. Note that the capability
 * for long transfers increases the driver size.
 */
/* #define USB_RX_USER_HOOK(data, len)     if(usbRxToken == (uchar)USBPID_SETUP) blinkLED(); */
/* This macro is a hook if you want to do unconventional things. If it is
 * defined, it's inserted at the beginning of received message processing.
 * If you eat the received message and don't want default processing to
 * proceed, do a return after doing your things. One possible application
 * (besides debugging) is to flash a status LED on each packet.
 */
/* #define USB_RESET_HOOK(resetStarts)     if(!resetStarts){hadUsbReset();} */
/* This macro is a hook if you need to know when an USB RESET occurs. It has
 * one parameter which distinguishes between the start of RESET state and its
 * end.
 */
/* #define USB_SET_ADDRESS_HOOK()              hadAddressAssigned(); */
/* This macro (if defined) is executed when a USB SET_ADDRESS request was
 * received.
 */
#define USB_COUNT_SOF                   0
/* define this macro to 1 if you need the global variable "usbSofCount" which
 * counts SOF packets. This feature requires that the hardware interrupt is
 * connected to D- instead of D+.
 */
#define USB_CFG_HAVE_MEASURE_FRAME_LENGTH   0
/* define this macro to 1 if you want the function usbMeasureFrameLength()
 * compiled in. This function can be used to calibrate the AVR's RC oscillator.
 */

/* -------------------------- Device Description --------------------------- */

#define  USB_CFG_VENDOR_ID       0x82, 0x82
/* USB vendor ID for the device, low byte first. If you have registered your
 * own Vendor ID, define it here. Otherwise you use one of obdev's free shared
 * VID/PID pairs. Be sure to read USBID-License.txt for rules!
 */
#define  USB_CFG_DEVICE_ID       0x80, 0x03 /* obdev's shared PID for HIDs */
/* This is the ID of the product, low byte first. It is interpreted in the
 * scope of the vendor ID. If you have registered your own VID with usb.org
 * or if you have licensed a PID from somebody else, define it here. Otherwise
 * you use obdev's free shared VID/PID pair. Be sure to read the rules in
 * USBID-License.txt!
 */
#define USB_CFG_DEVICE_VERSION  0x02, 0x02
/* Version number of the device: Minor number first, then major number.
 */
#define USB_CFG_VENDOR_NAME     'M', 'o', 'J', 'o'
#define USB_CFG_VENDOR_NAME_LEN 4
/* These two values define the vendor name returned by the USB device. The name
 * must be given as a list of characters under single quotes. The characters
 * are interpreted as Unicode (UTF-16) entities.
 * If you don't want a vendor name string, undefine these macros.
 * ALWAYS define a vendor name containing your Internet domain name if you use
 * obdev's free shared VID/PID pair. See the file USBID-License.txt for
 * details.
 */
#define USB_CFG_DEVICE_NAME     'B', 'B', 'C', ' ', 'K', 'e', 'y', 'b', 'o', 'a', 'r', 'd'
#define USB_CFG_DEVICE_NAME_LEN 12
/* Same as above for the device name. If you don't want a device name, undefine
 * the macros. See the file USBID-License.txt before you assign a name if you
 * use a shared VID/PID.
 */
#define USB_CFG_SERIAL_NUMBER   '4', '2'
#define USB_CFG_SERIAL_NUMBER_LEN   2
/* Same as above for the serial number. If you don't want a serial number,
 * undefine the macros.
 * It may be useful to provide the serial number through other means than at
 * compile time. See the section about descriptor properties below for how
 * to fine tune control over USB descriptors such as the string descriptor
 * for the serial number.
 */
#define USB_CFG_DEVICE_CLASS        0
#define USB_CFG_DEVICE_SUBCLASS     0
/* See USB specification if you want to conform to an existing device class.
 * Class 0xff is "vendor specific".
 */
#define USB_CFG_INTERFACE_CLASS     0x03
#define USB_CFG_INTERFACE_SUBCLASS  0x01
#define USB_CFG_INTERFACE_PROTOCOL  0x01
/* See USB specification if you want to conform to an existing device class or
 * protocol. The following classes must be set at interface level:
 * HID class is 3, no subclass and protocol required (but may be useful!)
 * CDC class is 2, use subclass 2 and protocol 1 for ACM
 */
#define USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH    63
/* Define this to the length of the HID report descriptor, if you implement
 * an HID device. Otherwise don't define it or define it to 0.
 * If you use this define, you must add a PROGMEM character array named
 * "usbHidReportDescriptor" to your code which contains the report descriptor.
 * Don't forget to keep the array and this define in sync!
 */

/* #define USB_PUBLIC static */
/* Use the define above if you #include usbdrv.c instead of linking against it.
 * This technique saves a couple of bytes in flash memory.
 */

/* ------------------- Fine Control over USB Descriptors ------------------- */
/* If you don't want to use the driver's default USB descriptors, you can
 * provide our own. These can be provided as (1) fixed length static data in
 * flash memory, (2) fixed length static data in RAM or (3) dynamically at
 * runtime in the function usbFunctionDescriptor(). See usbdrv.h for more
 * information about this function.
 * Descriptor handling is configured through the descriptor's properties. If
 * no properties are defined or if they are 0, the default descriptor is used.
 * Possible properties are:
 *   + USB_PROP_IS_DYNAMIC: The data for the descriptor should be fetched
 *     at runtime via usbFunctionDescriptor().
 *   + USB_PROP_IS_RAM: The data returned by usbFunctionDescriptor() or found
 *     in static memory is in RAM, not in flash memory.
 *   + USB_PROP_LENGTH(len): If the data is in static memory (RAM or flash),
 *     the driver must know the descriptor's length. The descriptor itself is
 *     found at the address of a well known identifier (see below).
 * List of static descriptor names (must be declared PROGMEM if in flash):
 *   char usbDescriptorDevice[];
 *   char usbDescriptorConfiguration[];
 *   char usbDescriptorHidReport[];
 *   char usbDescriptorString0[];
 *   int usbDescriptorStringVendor[];
 *   int usbDescriptorStringDevice[];
 *   int usbDescriptorStringSerialNumber[];
 * Other descriptors can't be provided statically, they must be provided
 * dynamically at runtime.
 *
 * Descriptor properties are or-ed or added together, e.g.:
 * #define USB_CFG_DESCR_PROPS_DEVICE   (USB_PROP_IS_RAM | USB_PROP_LENGTH(18))
 *
 * The following descriptors are defined:
 *   USB_CFG_DESCR_PROPS_DEVICE
 *   USB_CFG_DESCR_PROPS_CONFIGURATION
 *   USB_CFG_DESCR_PROPS_STRINGS
 *   USB_CFG_DESCR_PROPS_STRING_0
 *   USB_CFG_DESCR_PROPS_STRING_VENDOR
 *   USB_CFG_DESCR_PROPS_STRING_PRODUCT
 *   USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER
 *   USB_CFG_DESCR_PROPS_HID
 *   USB_CFG_DESCR_PROPS_HID_REPORT
 *   USB_CFG_DESCR_PROPS_UNKNOWN (for all descriptors not handled by the driver)
 *
 */

#define USB_CFG_DESCR_PROPS_DEVICE                  0
#define USB_CFG_DESCR_PROPS_CONFIGURATION           0
#define USB_CFG_DESCR_PROPS_STRINGS                 0
#define USB_CFG_DESCR_PROPS_STRING_0                0
#define USB_CFG_DESCR_PROPS_STRING_VENDOR           0
#define USB_CFG_DESCR_PROPS_STRING_PRODUCT          0
#define USB_CFG_DESCR_PROPS_STRING_SERIAL_NUMBER    0
#define USB_CFG_DESCR_PROPS_HID                     0
#define USB_CFG_DESCR_PROPS_HID_REPORT              0
#define USB_CFG_DESCR_PROPS_UNKNOWN                 0

/* ----------------------- Optional MCU Description ------------------------ */

/* The following configurations have working defaults in usbdrv.h. You
 * usually don't need to set them explicitly. Only if you want to run
 * the driver on a device which is not yet supported or with a compiler
 * which is not fully supported (such as IAR C) or if you use a differnt
 * interrupt than INT0, you may have to define some of these.
 */
/* #define USB_INTR_CFG            MCUCR */
/* #define USB_INTR_CFG_SET        ((1 << ISC00) | (1 << ISC01)) */
/* #define USB_INTR_CFG_CLR        0 */
/* #define USB_INTR_ENABLE         GIMSK */
/* #define USB_INTR_ENABLE_BIT     INT0 */
/* #define USB_INTR_PENDING        GIFR */
/* #define USB_INTR_PENDING_BIT    INTF0 */
/* #define USB_INTR_VECTOR         SIG_INTERRUPT0 */

#endif /* __usbconfig_h_included__ */