Compiler and Platform specific definitions and typedefs common to all platforms.

Macros

#define MEMSET(d, v, l)   memset(d, v, l)
 Friendly convenience macro pointing to the C Stdlib functions.
 
#define MEMCOPY(d, s, l)   memcpy(d, s, l)
 
#define MEMMOVE(d, s, l)   memmove(d, s, l)
 
#define MEMPGMCOPY(d, s, l)   memcpy(d, s, l)
 
#define MEMCOMPARE(s0, s1, l)   memcmp(s0, s1, l)
 
#define MEMPGMCOMPARE(s0, s1, l)   memcmp(s0, s1, l)

Generic Types

#define TRUE   1
 An alias for one, used for clarity.
 
#define FALSE   0
 An alias for zero, used for clarity.
 
#define NULL   ((void *)0)
 The null pointer.

Bit Manipulation Macros

#define BIT(x)   (1U << (x))
 Useful to reference a single bit of a byte.
 
#define BIT32(x)   (((uint32_t) 1) << (x))
 Useful to reference a single bit of an uint32_t type.
 
#define SETBIT(reg, bit)   (reg) |= BIT(bit)
 Sets bit in the reg register or byte.
 
#define SETBITS(reg, bits)   (reg) |= (bits)
 Sets the bits in the reg register or the byte as specified in the bitmask bits.
 
#define CLEARBIT(reg, bit)   (reg) &= ~(BIT(bit))
 Clears a bit in the reg register or byte.
 
#define CLEARBITS(reg, bits)   (reg) &= ~(bits)
 Clears the bits in the reg register or byte as specified in the bitmask bits.
 
#define READBIT(reg, bit)   ((reg) & (BIT(bit)))
 Returns the value of bit within the register or byte reg.
 
#define READBITS(reg, bits)   ((reg) & (bits))
 Returns the value of the bitmask bits within the register or byte reg.

Byte Manipulation Macros

#define LOW_BYTE(n)   ((uint8_t)((n) & 0xFF))
 Returns the low byte of the 16-bit value n as an uint8_t.
 
#define HIGH_BYTE(n)   ((uint8_t)(LOW_BYTE((n) >> 8)))
 Returns the high byte of the 16-bit value n as an uint8_t.
 
#define HIGH_LOW_TO_INT(high, low)
 Returns the value built from the two uint8_t values high and low.
 
#define INT8U_TO_INT32U(byte3, byte2, byte1, byte0)
 Returns the value built from the four uint8_t as an uint32_t.
 
#define BYTE_0(n)   ((uint8_t)((n) & 0xFF))
 Returns the low byte of the 32-bit value n as an uint8_t.
 
#define BYTE_1(n)   BYTE_0((n) >> 8)
 Returns the second byte of the 32-bit value n as an uint8_t.
 
#define BYTE_2(n)   BYTE_0((n) >> 16)
 Returns the third byte of the 32-bit value n as an uint8_t.
 
#define BYTE_3(n)   BYTE_0((n) >> 24)
 Returns the high byte of the 32-bit value n as an uint8_t.
 
#define BYTE_4(n)   BYTE_0((n) >> 32)
 Returns the fifth byte of the 64-bit value n as an uint8_t.
 
#define BYTE_5(n)   BYTE_0((n) >> 40)
 Returns the sixth byte of the 64-bit value n as an uint8_t.
 
#define BYTE_6(n)   BYTE_0((n) >> 48)
 Returns the seventh byte of the 64-bit value n as an uint8_t.
 
#define BYTE_7(n)   BYTE_0((n) >> 56)
 Returns the high byte of the 64-bit value n as an uint8_t.
 
#define COUNTOF(a)   (sizeof(a) / sizeof(a[0]))
 Returns the number of entries in an array.

Time Manipulation Macros

#define elapsedTimeInt8u(oldTime, newTime)   ((uint8_t) ((uint8_t)(newTime) - (uint8_t)(oldTime)))
 Returns the elapsed time between two 8 bit values. Result may not be valid if the time samples differ by more than 127.
 
#define elapsedTimeInt16u(oldTime, newTime)   ((uint16_t) ((uint16_t)(newTime) - (uint16_t)(oldTime)))
 Returns the elapsed time between two 16 bit values. Result may not be valid if the time samples differ by more than 32767.
 
#define elapsedTimeInt32u(oldTime, newTime)   ((uint32_t) ((uint32_t)(newTime) - (uint32_t)(oldTime)))
 Returns the elapsed time between two 32 bit values. Result may not be valid if the time samples differ by more than 2147483647.
 
#define MAX_INT8U_VALUE   (0xFF)
 Returns true if t1 is greater than t2. Can only account for 1 wrap around of the variable before it is wrong.
 
#define HALF_MAX_INT8U_VALUE   (0x80)
 Returns the elapsed time between two 8 bit values. Result may not be valid if the time samples differ by more than 127.
 
#define timeGTorEqualInt8u(t1, t2)   (elapsedTimeInt8u(t2, t1) <= (HALF_MAX_INT8U_VALUE))
 Returns the elapsed time between two 8 bit values. Result may not be valid if the time samples differ by more than 127.
 
#define MAX_INT16U_VALUE   (0xFFFF)
 Returns true if t1 is greater than t2. Can only account for 1 wrap around of the variable before it is wrong.
 
#define HALF_MAX_INT16U_VALUE   (0x8000)
 Returns the elapsed time between two 8 bit values. Result may not be valid if the time samples differ by more than 127.
 
#define timeGTorEqualInt16u(t1, t2)   (elapsedTimeInt16u(t2, t1) <= (HALF_MAX_INT16U_VALUE))
 Returns the elapsed time between two 8 bit values. Result may not be valid if the time samples differ by more than 127.
 
#define MAX_INT32U_VALUE   (0xFFFFFFFFUL)
 Returns true if t1 is greater than t2. Can only account for 1 wrap around of the variable before it is wrong.
 
#define HALF_MAX_INT32U_VALUE   (0x80000000UL)
 Returns the elapsed time between two 8 bit values. Result may not be valid if the time samples differ by more than 127.
 
#define timeGTorEqualInt32u(t1, t2)   (elapsedTimeInt32u(t2, t1) <= (HALF_MAX_INT32U_VALUE))
 Returns the elapsed time between two 8 bit values. Result may not be valid if the time samples differ by more than 127.

Miscellaneous Macros

#define UNUSED_VAR(x)   (void)(x)
 
#define DEBUG_LEVEL   BASIC_DEBUG
 Set debug level based on whether DEBUG or DEBUG_STRIPPED are defined.
 
#define STATIC_ASSERT(__condition, __errorstr)
 Disable static assertions on compilers that don't support them.

Detailed Description

platform-common.h provides PLATFORM_HEADER defaults and common definitions. This head should never be included directly, it should only be included by the specific PLATFORM_HEADER used by your platform.

See platform-common.h for source code.

Macro Definition Documentation

#define BIT (   x)    (1U << (x))
#define BIT32 (   x)    (((uint32_t) 1) << (x))
#define BYTE_0 (   n)    ((uint8_t)((n) & 0xFF))
#define BYTE_1 (   n)    BYTE_0((n) >> 8)
#define BYTE_2 (   n)    BYTE_0((n) >> 16)
#define BYTE_3 (   n)    BYTE_0((n) >> 24)
#define BYTE_4 (   n)    BYTE_0((n) >> 32)
#define BYTE_5 (   n)    BYTE_0((n) >> 40)
#define BYTE_6 (   n)    BYTE_0((n) >> 48)
#define BYTE_7 (   n)    BYTE_0((n) >> 56)
#define CLEARBIT (   reg,
  bit 
)    (reg) &= ~(BIT(bit))
Note
Assuming reg is an IO register, some platforms (such as the AVR) can implement this in a single atomic operation.
#define CLEARBITS (   reg,
  bits 
)    (reg) &= ~(bits)
Note
This is never a single atomic operation.
#define COUNTOF (   a)    (sizeof(a) / sizeof(a[0]))
#define DEBUG_LEVEL   BASIC_DEBUG
#define elapsedTimeInt16u (   oldTime,
  newTime 
)    ((uint16_t) ((uint16_t)(newTime) - (uint16_t)(oldTime)))

Referenced by USBD_RemoteWakeup().

#define elapsedTimeInt32u (   oldTime,
  newTime 
)    ((uint32_t) ((uint32_t)(newTime) - (uint32_t)(oldTime)))
#define elapsedTimeInt8u (   oldTime,
  newTime 
)    ((uint8_t) ((uint8_t)(newTime) - (uint8_t)(oldTime)))
#define HALF_MAX_INT16U_VALUE   (0x8000)
#define HALF_MAX_INT32U_VALUE   (0x80000000UL)
#define HALF_MAX_INT8U_VALUE   (0x80)
#define HIGH_BYTE (   n)    ((uint8_t)(LOW_BYTE((n) >> 8)))
#define HIGH_LOW_TO_INT (   high,
  low 
)
Value:
( \
((uint16_t) (((uint16_t) (high)) << 8)) \
+ ((uint16_t) ((low) & 0xFF)) \
)
#define INT8U_TO_INT32U (   byte3,
  byte2,
  byte1,
  byte0 
)
Value:
( \
(((uint32_t) (byte3)) << 24) \
+ (((uint32_t) (byte2)) << 16) \
+ (((uint32_t) (byte1)) << 8) \
+ ((uint32_t) ((byte0) & 0xFF)) \
)
#define LOW_BYTE (   n)    ((uint8_t)((n) & 0xFF))
#define MAX_INT16U_VALUE   (0xFFFF)
#define MAX_INT32U_VALUE   (0xFFFFFFFFUL)
#define MAX_INT8U_VALUE   (0xFF)
#define MEMCOMPARE (   s0,
  s1,
 
)    memcmp(s0, s1, l)
#define MEMCOPY (   d,
  s,
 
)    memcpy(d, s, l)
#define MEMMOVE (   d,
  s,
 
)    memmove(d, s, l)
#define MEMPGMCOMPARE (   s0,
  s1,
 
)    memcmp(s0, s1, l)
#define MEMPGMCOPY (   d,
  s,
 
)    memcpy(d, s, l)
#define MEMSET (   d,
  v,
 
)    memset(d, v, l)

Referenced by USBD_Init(), and USBD_RemoteWakeup().

#define READBIT (   reg,
  bit 
)    ((reg) & (BIT(bit)))
#define READBITS (   reg,
  bits 
)    ((reg) & (bits))
#define SETBIT (   reg,
  bit 
)    (reg) |= BIT(bit)
Note
Assuming reg is an IO register, some platforms (such as the AVR) can implement this in a single atomic operation.
#define SETBITS (   reg,
  bits 
)    (reg) |= (bits)
Note
This is never a single atomic operation.
#define STATIC_ASSERT (   __condition,
  __errorstr 
)
#define timeGTorEqualInt16u (   t1,
  t2 
)    (elapsedTimeInt16u(t2, t1) <= (HALF_MAX_INT16U_VALUE))
#define timeGTorEqualInt32u (   t1,
  t2 
)    (elapsedTimeInt32u(t2, t1) <= (HALF_MAX_INT32U_VALUE))
#define timeGTorEqualInt8u (   t1,
  t2 
)    (elapsedTimeInt8u(t2, t1) <= (HALF_MAX_INT8U_VALUE))
#define TRUE   1
#define UNUSED_VAR (   x)    (void)(x)

Useful macro for avoiding compiler warnings related to unused function arguments or unused variables.