error: expected '=', ',', ';', 'asm' or '__attribute__' bef

Go To Last Post
7 posts / 0 new
  • 1
  • 2
  • 3
  • 4
  • 5
Total votes: 0

I'm using a known package called v-usb. For some reason I'm running in to this error and can't quite understand why? I know the package I'm using is good as I have an example that compiles. I tried to find any difference in the good and the bad but see nothing.

Here is the code that causes the error.

#ifndef __ASSEMBLER__
char usbDescriptorDevice[];

If I do this.

#ifndef __ASSEMBLER__
char i;//just some dummy code.
char usbDescriptorDevice[];

it passes the issue and on the the next define. not sure why the PROGMEM would be an issue. I'm sure there is nothing wrong with the code itself but I'm so baffled as to what would cause this. Maybe a make file switch? I can't really post much of the code as these files are quite big.

Here is the error
usbdrv/usbdrv.h:452: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'char'
I get about 10 of them.

Does it have to do with the char not being used right not going in to eprom memory? Here is how its used.

const char usbDescrDevice[] PROGMEM = {    /* USB device descriptor */
    18,         /* sizeof(usbDescrDevice): length of descriptor in bytes */
    USBDESCR_DEVICE,    /* descriptor type */
    0x01, 0x01, /* USB version supported */
    0,          /* protocol */
    8,          /* max packet size */
    USB_CFG_VENDOR_ID,  /* 2 bytes */
    USB_CFG_DEVICE_ID,  /* 2 bytes */
    USB_CFG_DEVICE_VERSION, /* 2 bytes */

    1,          /* manufacturer string index */
    0,          /* manufacturer string index */
    2,          /* product string index */
    0,          /* product string index */
    3,          /* serial number string index */
    0,          /* serial number string index */
    1,          /* number of configurations */
  • 1
  • 2
  • 3
  • 4
  • 5
Total votes: 0

The #endifs are not balanced so that snippet does not make sense.

  • 1
  • 2
  • 3
  • 4
  • 5
Total votes: 0

ok let me dump that entire header on here. I think you just need to remove the
#ifndef __ASSEMBLER__
to balance it but this may answer further questions.

/* Name: usbdrv.h
 * Project: AVR USB driver
 * Author: Christian Starkjohann
 * Creation Date: 2004-12-29
 * Tabsize: 4
 * Copyright: (c) 2005 by OBJECTIVE DEVELOPMENT Software GmbH
 * License: GNU GPL v2 (see License.txt) or proprietary (CommercialLicense.txt)
 * This Revision: $Id: usbdrv.h 607 2008-05-13 15:57:28Z cs $

#ifndef __usbdrv_h_included__
#define __usbdrv_h_included__
#include "usbconfig.h"
#include "iarcompat.h"

Hardware Prerequisites:
USB lines D+ and D- MUST be wired to the same I/O port. We recommend that D+
triggers the interrupt (best achieved by using INT0 for D+), but it is also
possible to trigger the interrupt from D-. If D- is used, interrupts are also
triggered by SOF packets. D- requires a pull-up of 1.5k to +3.5V (and the
device must be powered at 3.5V) to identify as low-speed USB device. A
pull-down or pull-up of 1M SHOULD be connected from D+ to +3.5V to prevent
interference when no USB master is connected. If you use Zener diodes to limit
the voltage on D+ and D-, you MUST use a pull-down resistor, not a pull-up.
We use D+ as interrupt source and not D- because it does not trigger on
keep-alive and RESET states. If you want to count keep-alive events with
USB_COUNT_SOF, you MUST use D- as an interrupt source.

As a compile time option, the 1.5k pull-up resistor on D- can be made
switchable to allow the device to disconnect at will. See the definition of
usbDeviceConnect() and usbDeviceDisconnect() further down in this file.

Please adapt the values in usbconfig.h according to your hardware!

The device MUST be clocked at exactly 12 MHz, 15 MHz or 16 MHz
or at 16.5 MHz +/- 1%. See usbconfig-prototype.h for details.

Robustness with respect to communication errors:
The driver assumes error-free communication. It DOES check for errors in
the PID, but does NOT check bit stuffing errors, SE0 in middle of a byte,
token CRC (5 bit) and data CRC (16 bit). CRC checks can not be performed due
to timing constraints: We must start sending a reply within 7 bit times.
Bit stuffing and misplaced SE0 would have to be checked in real-time, but CPU
performance does not permit that. The driver does not check Data0/Data1
toggling, but application software can implement the check.

Input characteristics:
Since no differential receiver circuit is used, electrical interference
robustness may suffer. The driver samples only one of the data lines with
an ordinary I/O pin's input characteristics. However, since this is only a
low speed USB implementation and the specification allows for 8 times the
bit rate over the same hardware, we should be on the safe side. Even the spec
requires detection of asymmetric states at high bit rate for SE0 detection.

Number of endpoints:
The driver supports the following endpoints:

- Endpoint 0, the default control endpoint.
- Any number of interrupt- or bulk-out endpoints. The data is sent to
  usbFunctionWriteOut() and USB_CFG_IMPLEMENT_FN_WRITEOUT must be defined
  to 1 to activate this feature. The endpoint number can be found in the
  global variable 'usbRxToken'.
- One default interrupt- or bulk-in endpoint. This endpoint is used for
  interrupt- or bulk-in transfers which are not handled by any other endpoint.
  You must define USB_CFG_HAVE_INTRIN_ENDPOINT in order to activate this
  feature and call usbSetInterrupt() to send interrupt/bulk data.
- One additional interrupt- or bulk-in endpoint. This was endpoint 3 in
  previous versions of this driver but can now be configured to any endpoint
  number. You must define USB_CFG_HAVE_INTRIN_ENDPOINT3 in order to activate
  this feature and call usbSetInterrupt3() to send interrupt/bulk data. The
  endpoint number can be set with USB_CFG_EP3_NUMBER.

Please note that the USB standard forbids bulk endpoints for low speed devices!
Most operating systems allow them anyway, but the AVR will spend 90% of the CPU
time in the USB interrupt polling for bulk data.

Maximum data payload:
Data payload of control in and out transfers may be up to 254 bytes. In order
to accept payload data of out transfers, you need to implement

USB Suspend Mode supply current:
The USB standard limits power consumption to 500uA when the bus is in suspend
mode. This is not a problem for self-powered devices since they don't need
bus power anyway. Bus-powered devices can achieve this only by putting the
CPU in sleep mode. The driver does not implement suspend handling by itself.
However, the application may implement activity monitoring and wakeup from
sleep. The host sends regular SE0 states on the bus to keep it active. These
SE0 states can be detected by using D- as the interrupt source. Define
USB_COUNT_SOF to 1 and use the global variable usbSofCount to check for bus

Operation without an USB master:
The driver behaves neutral without connection to an USB master if D- reads
as 1. To avoid spurious interrupts, we recommend a high impedance (e.g. 1M)
pull-down or pull-up resistor on D+ (interrupt). If Zener diodes are used,
use a pull-down. If D- becomes statically 0, the driver may block in the
interrupt routine.

Interrupt latency:
The application must ensure that the USB interrupt is not disabled for more
than 25 cycles (this is for 12 MHz, faster clocks allow longer latency).
This implies that all interrupt routines must either be declared as "INTERRUPT"
instead of "SIGNAL" (see "avr/signal.h") or that they are written in assembler
with "sei" as the first instruction.

Maximum interrupt duration / CPU cycle consumption:
The driver handles all USB communication during the interrupt service
routine. The routine will not return before an entire USB message is received
and the reply is sent. This may be up to ca. 1200 cycles @ 12 MHz (= 100us) if
the host conforms to the standard. The driver will consume CPU cycles for all
USB messages, even if they address another (low-speed) device on the same bus.


/* ------------------------------------------------------------------------- */
/* --------------------------- Module Interface ---------------------------- */
/* ------------------------------------------------------------------------- */

#define USBDRV_VERSION  20080513
/* This define uniquely identifies a driver version. It is a decimal number
 * constructed from the driver's release date in the form YYYYMMDD. If the
 * driver's behavior or interface changes, you can use this constant to
 * distinguish versions. If it is not defined, the driver's release date is
 * older than 2006-01-25.

#ifndef USB_PUBLIC
#define USB_PUBLIC
/* USB_PUBLIC is used as declaration attribute for all functions exported by
 * the USB driver. The default is no attribute (see above). You may define it
 * to static either in usbconfig.h or from the command line if you include
 * usbdrv.c instead of linking against it. Including the C module of the driver
 * directly in your code saves a couple of bytes in flash memory.

#ifndef __ASSEMBLER__
#ifndef uchar
#define uchar   unsigned char
#ifndef schar
#define schar   signed char
/* shortcuts for well defined 8 bit integer types */

#if USB_CFG_LONG_TRANSFERS  /* if more than 254 bytes transfer size required */
#   define usbMsgLen_t unsigned
#   define usbMsgLen_t uchar
/* usbMsgLen_t is the data type used for transfer lengths. By default, it is
 * defined to uchar, allowing a maximum of 254 bytes (255 is reserved for
 * USB_NO_MSG below). If the usbconfig.h defines USB_CFG_LONG_TRANSFERS to 1,
 * a 16 bit data type is used, allowing up to 16384 bytes (the rest is used
 * for flags in the descriptor configuration).
#define USB_NO_MSG  ((usbMsgLen_t)-1)   /* constant meaning "no message" */

struct usbRequest;  /* forward declaration */

USB_PUBLIC void usbInit(void);
/* This function must be called before interrupts are enabled and the main
 * loop is entered.
USB_PUBLIC void usbPoll(void);
/* This function must be called at regular intervals from the main loop.
 * Maximum delay between calls is somewhat less than 50ms (USB timeout for
 * accepting a Setup message). Otherwise the device will not be recognized.
 * Please note that debug outputs through the UART take ~ 0.5ms per byte
 * at 19200 bps.
extern uchar *usbMsgPtr;
/* This variable may be used to pass transmit data to the driver from the
 * implementation of usbFunctionWrite(). It is also used internally by the
 * driver for standard control requests.
USB_PUBLIC usbMsgLen_t usbFunctionSetup(uchar data[8]);
/* This function is called when the driver receives a SETUP transaction from
 * the host which is not answered by the driver itself (in practice: class and
 * vendor requests). All control transfers start with a SETUP transaction where
 * the host communicates the parameters of the following (optional) data
 * transfer. The SETUP data is available in the 'data' parameter which can
 * (and should) be casted to 'usbRequest_t *' for a more user-friendly access
 * to parameters.
 * If the SETUP indicates a control-in transfer, you should provide the
 * requested data to the driver. There are two ways to transfer this data:
 * (1) Set the global pointer 'usbMsgPtr' to the base of the static RAM data
 * block and return the length of the data in 'usbFunctionSetup()'. The driver
 * will handle the rest. Or (2) return USB_NO_MSG in 'usbFunctionSetup()'. The
 * driver will then call 'usbFunctionRead()' when data is needed. See the
 * documentation for usbFunctionRead() for details.
 * If the SETUP indicates a control-out transfer, the only way to receive the
 * data from the host is through the 'usbFunctionWrite()' call. If you
 * implement this function, you must return USB_NO_MSG in 'usbFunctionSetup()'
 * to indicate that 'usbFunctionWrite()' should be used. See the documentation
 * of this function for more information. If you just want to ignore the data
 * sent by the host, return 0 in 'usbFunctionSetup()'.
 * Note that calls to the functions usbFunctionRead() and usbFunctionWrite()
 * are only done if enabled by the configuration in usbconfig.h.
USB_PUBLIC usbMsgLen_t usbFunctionDescriptor(struct usbRequest *rq);
/* You need to implement this function ONLY if you provide USB descriptors at
 * runtime (which is an expert feature). It is very similar to
 * usbFunctionSetup() above, but it is called only to request USB descriptor
 * data. See the documentation of usbFunctionSetup() above for more info.
#define USB_READY_BIT		4

USB_PUBLIC void usbSetInterrupt(uchar *data, uchar len);
/* This function sets the message which will be sent during the next interrupt
 * IN transfer. The message is copied to an internal buffer and must not exceed
 * a length of 8 bytes. The message may be 0 bytes long just to indicate the
 * interrupt status to the host.
 * If you need to transfer more bytes, use a control read after the interrupt.
#define usbInterruptIsReady()   (usbTxLen1 & USB_READY_MASK)
/* This macro indicates whether the last interrupt message has already been
 * sent. If you set a new interrupt message before the old was sent, the
 * message already buffered will be lost.
USB_PUBLIC void usbSetInterrupt3(uchar *data, uchar len);
#define usbInterruptIsReady3()   (usbTxLen3 & (1<<6))
/* Same as above for endpoint 3, but using another bit, has to be alligned with assembler code in */
#if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH    /* simplified interface for backward compatibility */
#define usbHidReportDescriptor  usbDescriptorHidReport
/* should be declared as: PROGMEM char usbHidReportDescriptor[]; */
/* If you implement an HID device, you need to provide a report descriptor.
 * The HID report descriptor syntax is a bit complex. If you understand how
 * report descriptors are constructed, we recommend that you use the HID
 * Descriptor Tool from, see
 * Otherwise you should probably start with a working example.
USB_PUBLIC uchar usbFunctionWrite(uchar *data, uchar len);
/* This function is called by the driver to provide a control transfer's
 * payload data (control-out). It is called in chunks of up to 8 bytes. The
 * total count provided in the current control transfer can be obtained from
 * the 'length' property in the setup data. If an error occurred during
 * processing, return 0xff (== -1). The driver will answer the entire transfer
 * with a STALL token in this case. If you have received the entire payload
 * successfully, return 1. If you expect more data, return 0. If you don't
 * know whether the host will send more data (you should know, the total is
 * provided in the usbFunctionSetup() call!), return 1.
 * NOTE: If you return 0xff for STALL, 'usbFunctionWrite()' may still be called
 * for the remaining data. You must continue to return 0xff for STALL in these
 * calls.
 * In order to get usbFunctionWrite() called, define USB_CFG_IMPLEMENT_FN_WRITE
 * to 1 in usbconfig.h and return 0xff in usbFunctionSetup()..
USB_PUBLIC uchar usbFunctionRead(uchar *data, uchar len);
/* This function is called by the driver to ask the application for a control
 * transfer's payload data (control-in). It is called in chunks of up to 8
 * bytes each. You should copy the data to the location given by 'data' and
 * return the actual number of bytes copied. If you return less than requested,
 * the control-in transfer is terminated. If you return 0xff, the driver aborts
 * the transfer with a STALL token.
 * In order to get usbFunctionRead() called, define USB_CFG_IMPLEMENT_FN_READ
 * to 1 in usbconfig.h and return 0xff in usbFunctionSetup()..
USB_PUBLIC void usbFunctionWriteOut(uchar *data, uchar len);
/* This function is called by the driver when data is received on an interrupt-
 * or bulk-out endpoint. The endpoint number can be found in the global
 * variable usbRxToken. You must define USB_CFG_IMPLEMENT_FN_WRITEOUT to 1 in
 * usbconfig.h to get this function called.
#define usbDeviceConnect()      ((USB_PULLUP_DDR |= (1<<USB_CFG_PULLUP_BIT)), \
                                  (USB_PULLUP_OUT |= (1<<USB_CFG_PULLUP_BIT)))
#define usbDeviceDisconnect()   ((USB_PULLUP_DDR &= ~(1<<USB_CFG_PULLUP_BIT)), \
                                  (USB_PULLUP_OUT &= ~(1<<USB_CFG_PULLUP_BIT)))
#define usbDeviceConnect()      (USBDDR &= ~(1<<USBMINUS))
#define usbDeviceDisconnect()   (USBDDR |= (1<<USBMINUS))
/* The macros usbDeviceConnect() and usbDeviceDisconnect() (intended to look
 * like a function) connect resp. disconnect the device from the host's USB.
 * If the constants USB_CFG_PULLUP_IOPORT and USB_CFG_PULLUP_BIT are defined
 * in usbconfig.h, a disconnect consists of removing the pull-up resisitor
 * from D-, otherwise the disconnect is done by brute-force pulling D- to GND.
 * This does not conform to the spec, but it works.
 * Please note that the USB interrupt must be disabled while the device is
 * in disconnected state, or the interrupt handler will hang! You can either
 * turn off the USB interrupt selectively with
 * or use cli() to disable interrupts globally.
extern unsigned usbCrc16(unsigned data, uchar len);
#define usbCrc16(data, len) usbCrc16((unsigned)(data), len)
/* This function calculates the binary complement of the data CRC used in
 * USB data packets. The value is used to build raw transmit packets.
 * You may want to use this function for data checksums or to verify received
 * data. We enforce 16 bit calling conventions for compatibility with IAR's
 * tiny memory model.
extern unsigned usbCrc16Append(unsigned data, uchar len);
#define usbCrc16Append(data, len)    usbCrc16Append((unsigned)(data), len)
/* This function is equivalent to usbCrc16() above, except that it appends
 * the 2 bytes CRC (lowbyte first) in the 'data' buffer after reading 'len'
 * bytes.
extern unsigned usbMeasureFrameLength(void);
/* This function MUST be called IMMEDIATELY AFTER USB reset and measures 1/7 of
 * the number of CPU cycles during one USB frame minus one low speed bit
 * length. In other words: return value = 1499 * (F_CPU / 10.5 MHz)
 * Since this is a busy wait, you MUST disable all interrupts with cli() before
 * calling this function.
 * This can be used to calibrate the AVR's RC oscillator.
extern uchar    usbConfiguration;
/* This value contains the current configuration set by the host. The driver
 * allows setting and querying of this variable with the USB SET_CONFIGURATION
 * and GET_CONFIGURATION requests, but does not use it otherwise.
 * You may want to reflect the "configured" status with a LED on the device or
 * switch on high power parts of the circuit only if the device is configured.
extern volatile uchar   usbSofCount;
/* This variable is incremented on every SOF packet. It is only available if
 * the macro USB_COUNT_SOF is defined to a value != 0.

#define USB_STRING_DESCRIPTOR_HEADER(stringLength) ((2*(stringLength)+2) | (3<<8))
/* This macro builds a descriptor header for a string descriptor given the
 * string's length. See usbdrv.c for an example how to use it.
extern volatile schar   usbRxLen;
#define usbDisableAllRequests()     usbRxLen = -1
/* Must be called from usbFunctionWrite(). This macro disables all data input
 * from the USB interface. Requests from the host are answered with a NAK
 * while they are disabled.
#define usbEnableAllRequests()      usbRxLen = 0
/* May only be called if requests are disabled. This macro enables input from
 * the USB interface after it has been disabled with usbDisableAllRequests().
#define usbAllRequestsAreDisabled() (usbRxLen < 0)
/* Use this macro to find out whether requests are disabled. It may be needed
 * to ensure that usbEnableAllRequests() is never called when requests are
 * enabled.

#define USB_SET_DATATOKEN1(token)   usbTxBuf1[0] = token
#define USB_SET_DATATOKEN3(token)   usbTxBuf3[0] = token
/* These two macros can be used by application software to reset data toggling
 * for interrupt-in endpoints 1 and 3. Since the token is toggled BEFORE
 * sending data, you must set the opposite value of the token which should come
 * first.

#endif  /* __ASSEMBLER__ */

/* ------------------------------------------------------------------------- */
/* ----------------- Definitions for Descriptor Properties ----------------- */
/* ------------------------------------------------------------------------- */
/* This is advanced stuff. See usbconfig-prototype.h for more information
 * about the various methods to define USB descriptors. If you do nothing,
 * the default descriptors will be used.
#define USB_PROP_IS_DYNAMIC     (1 << 14)
/* If this property is set for a descriptor, usbFunctionDescriptor() will be
 * used to obtain the particular descriptor.
#define USB_PROP_IS_RAM         (1 << 15)
/* If this property is set for a descriptor, the data is read from RAM
 * memory instead of Flash. The property is used for all methods to provide
 * external descriptors.
#define USB_PROP_LENGTH(len)    ((len) & 0x3fff)
/* If a static external descriptor is used, this is the total length of the
 * descriptor in bytes.

/* all descriptors which may have properties: */
#define USB_CFG_DESCR_PROPS_DEVICE                  0
#define USB_CFG_DESCR_PROPS_STRINGS                 0
#define USB_CFG_DESCR_PROPS_STRING_0                0
#define USB_CFG_DESCR_PROPS_HID                     0
#   if USB_CFG_HID_REPORT_DESCRIPTOR_LENGTH /* do some backward compatibility tricks */
#   else
#       define USB_CFG_DESCR_PROPS_HID_REPORT       0
#   endif
#define USB_CFG_DESCR_PROPS_UNKNOWN                 0

/* ------------------ forward declaration of descriptors ------------------- */
/* If you use external static descriptors, they must be stored in global
 * arrays as declared below:
#ifndef __ASSEMBLER__
char usbDescriptorDevice[];

char usbDescriptorConfiguration[];

char usbDescriptorHidReport[];

char usbDescriptorString0[];

int usbDescriptorStringVendor[];

int usbDescriptorStringDevice[];

int usbDescriptorStringSerialNumber[];

#endif /* __ASSEMBLER__ */

/* ------------------------------------------------------------------------- */
/* ------------------------ General Purpose Macros ------------------------- */
/* ------------------------------------------------------------------------- */

#define USB_CONCAT(a, b)            a ## b
#define USB_CONCAT_EXPANDED(a, b)   USB_CONCAT(a, b)

#define USB_OUTPORT(name)           USB_CONCAT(PORT, name)
#define USB_INPORT(name)            USB_CONCAT(PIN, name)
#define USB_DDRPORT(name)           USB_CONCAT(DDR, name)
/* The double-define trick above lets us concatenate strings which are
 * defined by macros.

/* ------------------------------------------------------------------------- */
/* ------------------------- Constant definitions -------------------------- */
/* ------------------------------------------------------------------------- */

#if !defined __ASSEMBLER__ && (!defined USB_CFG_VENDOR_ID || !defined USB_CFG_DEVICE_ID)
#warning "You should define USB_CFG_VENDOR_ID and USB_CFG_DEVICE_ID in usbconfig.h"
/* If the user has not defined IDs, we default to obdev's free IDs.
 * See USBID-License.txt for details.

/* make sure we have a VID and PID defined, byte order is lowbyte, highbyte */
#   define  USB_CFG_VENDOR_ID   0xc0, 0x16  /* 5824 in dec, stands for VOTI */

#       define USB_CFG_DEVICE_ID    0xdf, 0x05  /* 1503 in dec, shared PID for HIDs */
#       define USB_CFG_DEVICE_ID    0xe1, 0x05  /* 1505 in dec, shared PID for CDC Modems */
#   else
#       define USB_CFG_DEVICE_ID    0xdc, 0x05  /* 1500 in dec, obdev's free PID */
#   endif

/* Derive Output, Input and DataDirection ports from port names */
#error "You must define USB_CFG_IOPORTNAME in usbconfig.h, see usbconfig-prototype.h"


#define USBIDLE     (1<<USB_CFG_DMINUS_BIT) /* value representing J state */
#define USBMASK     ((1<<USB_CFG_DPLUS_BIT) | (1<<USB_CFG_DMINUS_BIT))  /* mask for USB I/O bits */

/* defines for backward compatibility with older driver versions: */

#ifndef USB_CFG_EP3_NUMBER  /* if not defined in usbconfig.h */
#define USB_CFG_EP3_NUMBER  3

#define USB_MAX_PACKET_SIZE	8 /* maximum packet size for interrupt in */
#define USB_BUFSIZE     	(3+USB_MAX_PACKET_SIZE)  /* PID, data, 2 bytes CRC */

/* ----- Try to find registers and bits responsible for ext interrupt 0 ----- */

#ifndef USB_INTR_CFG    /* allow user to override our default */
#   if defined  EICRA
#       define USB_INTR_CFG EICRA
#   else
#       define USB_INTR_CFG MCUCR
#   endif
#ifndef USB_INTR_CFG_SET    /* allow user to override our default */
#   define USB_INTR_CFG_SET ((1 << ISC00) | (1 << ISC01))    /* cfg for rising edge */
#ifndef USB_INTR_CFG_CLR    /* allow user to override our default */
#   define USB_INTR_CFG_CLR 0    /* no bits to clear */

#ifndef USB_INTR_ENABLE     /* allow user to override our default */
#   if defined GIMSK
#       define USB_INTR_ENABLE  GIMSK
#   elif defined EIMSK
#       define USB_INTR_ENABLE  EIMSK
#   else
#       define USB_INTR_ENABLE  GICR
#   endif
#ifndef USB_INTR_ENABLE_BIT /* allow user to override our default */

#ifndef USB_INTR_PENDING    /* allow user to override our default */
#   if defined  EIFR
#       define USB_INTR_PENDING EIFR
#   else
#       define USB_INTR_PENDING GIFR
#   endif
#ifndef USB_INTR_PENDING_BIT    /* allow user to override our default */

The defines above don't work for the following chips
at90c8534: no ISC0?, no PORTB, can't find a data sheet
at86rf401: no PORTB, no MCUCR etc, low clock rate
atmega103: no ISC0? (maybe omission in header, can't find data sheet)
atmega603: not defined in avr-libc
at43usb320, at43usb355, at76c711: have USB anyway
at94k: is different...

at90s1200, attiny11, attiny12, attiny15, attiny28: these have no RAM

/* ------------------------------------------------------------------------- */
/* ----------------- USB Specification Constants and Types ----------------- */
/* ------------------------------------------------------------------------- */

/* USB PID definitions, low byte is the PID value, the high byte the logical inverse. */

/* Token PIDs */
#define USBPID_OUT      0xe1 // PID: 0b0001
#define USBPID_IN       0x69 // PID: 0b1001
#define USBPID_SETUP    0x2d // PID: 0b1101

/* Data PIDs */
#define USBPID_DATA0    0xc3 // PID: 0b0011
#define USBPID_DATA1    0x4b // PID: 0b1011

/* Handshake PIDs */
#define USBPID_ACK      0xd2 // PID: 0b0010
#define USBPID_NAK      0x5a // PID: 0b1010
#define USBPID_STALL    0x1e // PID: 0b1110


#ifndef __ASSEMBLER__
typedef struct usbTxStatus{
    volatile uchar   len;
    uchar   buffer[USB_BUFSIZE + 23]; // added 23 to allow up to 31 bytes to transfer

extern usbTxStatus_t   usbTxStatus1, usbTxStatus3;

	usbTxLen? bits:
	[USB_READY_BIT]: transfer finished
#define usbTxLen1   usbTxStatus1.len
#define usbTxBuf1   usbTxStatus1.buffer
#define usbTxLen3   usbTxStatus3.len
#define usbTxBuf3   usbTxStatus3.buffer

typedef union usbWord{
    unsigned    word;
    uchar       bytes[2];

typedef struct usbRequest{
    uchar       bmRequestType;
    uchar       bRequest;
    usbWord_t   wValue;
    usbWord_t   wIndex;
    usbWord_t   wLength;
/* This structure matches the 8 byte setup request */

/* bmRequestType field in USB setup:
 * d t t r r r r r, where
 * d ..... direction: 0=host->device, 1=device->host
 * t ..... type: 0=standard, 1=class, 2=vendor, 3=reserved
 * r ..... recipient: 0=device, 1=interface, 2=endpoint, 3=other

/* USB setup recipient values */
#define USBRQ_RCPT_MASK         0x1f
#define USBRQ_RCPT_DEVICE       0

/* USB request type values */
#define USBRQ_TYPE_MASK         0x60
#define USBRQ_TYPE_STANDARD     (0<<5)
#define USBRQ_TYPE_CLASS        (1<<5)
#define USBRQ_TYPE_VENDOR       (2<<5)

/* USB direction values: */
#define USBRQ_DIR_MASK              0x80
#define USBRQ_DIR_HOST_TO_DEVICE    (0<<7)
#define USBRQ_DIR_DEVICE_TO_HOST    (1<<7)

/* USB Standard Requests */
#define USBRQ_GET_STATUS        0
#define USBRQ_SET_FEATURE       3
#define USBRQ_SET_ADDRESS       5
#define USBRQ_GET_INTERFACE     10
#define USBRQ_SET_INTERFACE     11
#define USBRQ_SYNCH_FRAME       12

/* USB descriptor constants */
#define USBDESCR_DEVICE         1
#define USBDESCR_CONFIG         2
#define USBDESCR_STRING         3
#define USBDESCR_ENDPOINT       5
#define USBDESCR_HID            0x21
#define USBDESCR_HID_REPORT     0x22
#define USBDESCR_HID_PHYS       0x23

#define USBATTR_BUSPOWER        0x80
#define USBATTR_SELFPOWER       0x40
#define USBATTR_REMOTEWAKE      0x20

/* USB HID Requests */
#define USBRQ_HID_GET_REPORT    0x01
#define USBRQ_HID_GET_IDLE      0x02
#define USBRQ_HID_SET_REPORT    0x09
#define USBRQ_HID_SET_IDLE      0x0a

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

#endif /* __usbdrv_h_included__ */
  • 1
  • 2
  • 3
  • 4
  • 5
Total votes: 0

Don't know about IAR but gcc would want #include

  • 1
  • 2
  • 3
  • 4
  • 5
Total votes: 0

wow, that filled in the mystery. I used to have it in main, the newer v-usb put it in usbdrv.h. Now that I'm unsing an old verion of usbdrv.h I need it back in my main. dak664, thx so much for spotting that!

  • 1
  • 2
  • 3
  • 4
  • 5
Total votes: 0

Added to widen the display format of the above header file post.

"I may make you feel but I can't make you think" - Jethro Tull - Thick As A Brick

"void transmigratus(void) {transmigratus();} // recursio infinitus" - larryvc

"It's much more practical to rely on the processing powers of the real debugger, i.e. the one between the keyboard and chair." - JW wek3

"When you arise in the morning think of what a privilege it is to be alive: to breathe, to think, to enjoy, to love." -  Marcus Aurelius

  • 1
  • 2
  • 3
  • 4
  • 5
Total votes: 0


wow, that filled in the mystery.

You do realise you could have worked this out for yourself? Almost always when you see the "error: expected '=', ',', ';', 'asm' or '__attribute__' before" it's because a type or attribute has been used for which the compiler has not seen a definition. In this case it was "PROGMEM". Another example would be:

// main.c
uint16_t n;
int main(void) {

In this case the compiler would throw the error on the line that defines 'n'.

test.c:2: error: expected '=', ',', ';', 'asm' or '__attribute__' before 'n'

In either case you just need to find where "PROGMEM" or "uint16_t" or whatever is defined. Start by grep'ing the local project .h files as it could be a locally invented type/macro/whatever. If that fails search the system header files:

E:\WinAVR-20100110\avr\include\avr[i386_vc]>grep " PROGMEM " *.h
pgmspace.h:#define PROGMEM __ATTR_PROGMEM__
pgmspace.h:typedef void PROGMEM prog_void;
pgmspace.h:typedef char PROGMEM prog_char;
pgmspace.h:typedef unsigned char PROGMEM prog_uchar;
pgmspace.h:typedef int8_t PROGMEM prog_int8_t;
pgmspace.h:typedef uint8_t PROGMEM prog_uint8_t;
pgmspace.h:typedef int16_t PROGMEM prog_int16_t;
pgmspace.h:typedef uint16_t PROGMEM prog_uint16_t;
pgmspace.h:typedef int32_t PROGMEM prog_int32_t;
pgmspace.h:typedef uint32_t PROGMEM prog_uint32_t;
pgmspace.h:typedef int64_t PROGMEM prog_int64_t;
pgmspace.h:typedef uint64_t PROGMEM prog_uint64_t;
pgmspace.h:# define PSTR(s) ((const PROGMEM char *)(s))
pgmspace.h:# define PSTR(s) (__extension__({static char __c[] PROGMEM = (s); &__c[0];}))

So here you'd know it was pgmspace.h that needed to be included before the use of the symbol. Similarly:

E:\WinAVR-20100110\avr\include[i386_vc]>grep uint16_t *.h
inttypes.h:    octal printf format for uint16_t */
inttypes.h:    decimal printf format for uint16_t */
inttypes.h:    hexadecimal printf format for uint16_t */
inttypes.h:    uppercase hexadecimal printf format for uint16_t */
inttypes.h:    octal scanf format for uint16_t */
inttypes.h:    decimal scanf format for uint16_t */
inttypes.h:    hexadecimal scanf format for uint16_t */
stdint.h:typedef unsigned int uint16_t;
stdint.h:typedef unsigned int uint16_t __attribute__ ((__mode__ (__HI__)));
stdint.h:typedef uint16_t uintptr_t;
stdint.h:typedef uint16_t uint_least16_t;
stdint.h:typedef uint16_t uint_fast16_t;
stdint.h:    largest value an uint16_t can hold. */
stdint.h:    define a constant of type uint16_t */
stdio.h:/* possible future extensions, will require uint16_t flags */

So it's stdint.h needed for:

// main.c
uint16_t n;
int main(void) {