diff --git a/c/include/libsbp/bootload_macros.h b/c/include/libsbp/bootload_macros.h index cce2ca506c..eb9771fa39 100644 --- a/c/include/libsbp/bootload_macros.h +++ b/c/include/libsbp/bootload_macros.h @@ -27,43 +27,49 @@ #define SBP_MSG_BOOTLOADER_HANDSHAKE_RESP 0x00B4 #define SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK \ - (0xff) + (0xffu) #define SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT \ (8u) -#define SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_GET( \ - flags) \ - ((u32)( \ - ((flags) >> \ - SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT) & \ +#define SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_GET( \ + flags) \ + ((u32)( \ + (u32)( \ + (flags) >> \ + SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT) & \ SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK)) -#define SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SET( \ - flags, val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK)) \ - << (SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT))); \ +#define SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SET( \ + flags, val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK \ + << SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT))) | \ + (((val) & \ + (SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK)) \ + << (SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT))); \ } while (0) #define SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK \ - (0xff) + (0xffu) #define SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT \ (0u) -#define SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MINOR_PROTOCOL_VERSION_NUMBER_GET( \ - flags) \ - ((u32)( \ - ((flags) >> \ - SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT) & \ +#define SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MINOR_PROTOCOL_VERSION_NUMBER_GET( \ + flags) \ + ((u32)( \ + (u32)( \ + (flags) >> \ + SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT) & \ SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK)) -#define SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SET( \ - flags, val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK)) \ - << (SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT))); \ +#define SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SET( \ + flags, val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK \ + << SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT))) | \ + (((val) & \ + (SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK)) \ + << (SBP_BOOTLOADER_HANDSHAKE_RESP_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT))); \ } while (0) /** diff --git a/c/include/libsbp/ext_events_macros.h b/c/include/libsbp/ext_events_macros.h index 651580cf95..9637908da2 100644 --- a/c/include/libsbp/ext_events_macros.h +++ b/c/include/libsbp/ext_events_macros.h @@ -19,28 +19,32 @@ #define LIBSBP_EXT_EVENTS_MACROS_H #define SBP_MSG_EXT_EVENT 0x0101 -#define SBP_EXT_EVENT_TIME_QUALITY_MASK (0x1) +#define SBP_EXT_EVENT_TIME_QUALITY_MASK (0x1u) #define SBP_EXT_EVENT_TIME_QUALITY_SHIFT (1u) -#define SBP_EXT_EVENT_TIME_QUALITY_GET(flags) \ - ((u8)(((flags) >> SBP_EXT_EVENT_TIME_QUALITY_SHIFT) & \ +#define SBP_EXT_EVENT_TIME_QUALITY_GET(flags) \ + ((u8)((u8)((flags) >> SBP_EXT_EVENT_TIME_QUALITY_SHIFT) & \ SBP_EXT_EVENT_TIME_QUALITY_MASK)) -#define SBP_EXT_EVENT_TIME_QUALITY_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_EXT_EVENT_TIME_QUALITY_MASK)) \ - << (SBP_EXT_EVENT_TIME_QUALITY_SHIFT))); \ +#define SBP_EXT_EVENT_TIME_QUALITY_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_EXT_EVENT_TIME_QUALITY_MASK \ + << SBP_EXT_EVENT_TIME_QUALITY_SHIFT))) | \ + (((val) & (SBP_EXT_EVENT_TIME_QUALITY_MASK)) \ + << (SBP_EXT_EVENT_TIME_QUALITY_SHIFT))); \ } while (0) #define SBP_EXT_EVENT_TIME_QUALITY_UNKNOWN_DONT_HAVE_NAV_SOLUTION (0) #define SBP_EXT_EVENT_TIME_QUALITY_GOOD (1) -#define SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_MASK (0x1) +#define SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_MASK (0x1u) #define SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_SHIFT (0u) -#define SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_GET(flags) \ - ((u8)(((flags) >> SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_SHIFT) & \ +#define SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_GET(flags) \ + ((u8)((u8)((flags) >> SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_SHIFT) & \ SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_MASK)) -#define SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_MASK)) \ - << (SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_SHIFT))); \ +#define SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_MASK \ + << SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_SHIFT))) | \ + (((val) & (SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_MASK)) \ + << (SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_SHIFT))); \ } while (0) #define SBP_EXT_EVENT_NEW_LEVEL_OF_PIN_LOW (0) diff --git a/c/include/libsbp/flash_macros.h b/c/include/libsbp/flash_macros.h index 2e5f719660..39a8e87666 100644 --- a/c/include/libsbp/flash_macros.h +++ b/c/include/libsbp/flash_macros.h @@ -19,16 +19,18 @@ #define LIBSBP_FLASH_MACROS_H #define SBP_MSG_FLASH_PROGRAM 0x00E6 -#define SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_MASK (0x1) +#define SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_MASK (0x1u) #define SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_SHIFT (0u) -#define SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_GET(flags) \ - ((u8)(((flags) >> SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_SHIFT) & \ +#define SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_GET(flags) \ + ((u8)((u8)((flags) >> SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_SHIFT) & \ SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_MASK)) -#define SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_MASK)) \ - << (SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_SHIFT))); \ +#define SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_MASK \ + << SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_SHIFT))) | \ + (((val) & (SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_MASK)) \ + << (SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_SHIFT))); \ } while (0) #define SBP_FLASH_PROGRAM_FLASH_TARGET_TO_READ_FLASH_STM (0) @@ -64,15 +66,17 @@ #define SBP_MSG_FLASH_PROGRAM_ENCODED_OVERHEAD 5u #define SBP_MSG_FLASH_DONE 0x00E0 -#define SBP_FLASH_DONE_RESPONSE_CODE_MASK (0x7) +#define SBP_FLASH_DONE_RESPONSE_CODE_MASK (0x7u) #define SBP_FLASH_DONE_RESPONSE_CODE_SHIFT (0u) -#define SBP_FLASH_DONE_RESPONSE_CODE_GET(flags) \ - ((u8)(((flags) >> SBP_FLASH_DONE_RESPONSE_CODE_SHIFT) & \ +#define SBP_FLASH_DONE_RESPONSE_CODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_FLASH_DONE_RESPONSE_CODE_SHIFT) & \ SBP_FLASH_DONE_RESPONSE_CODE_MASK)) -#define SBP_FLASH_DONE_RESPONSE_CODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_FLASH_DONE_RESPONSE_CODE_MASK)) \ - << (SBP_FLASH_DONE_RESPONSE_CODE_SHIFT))); \ +#define SBP_FLASH_DONE_RESPONSE_CODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_FLASH_DONE_RESPONSE_CODE_MASK \ + << SBP_FLASH_DONE_RESPONSE_CODE_SHIFT))) | \ + (((val) & (SBP_FLASH_DONE_RESPONSE_CODE_MASK)) \ + << (SBP_FLASH_DONE_RESPONSE_CODE_SHIFT))); \ } while (0) #define SBP_FLASH_DONE_RESPONSE_CODE_FLASH_OK (0) @@ -88,16 +92,18 @@ #define SBP_MSG_FLASH_DONE_ENCODED_LEN 1u #define SBP_MSG_FLASH_READ_REQ 0x00E7 -#define SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_MASK (0x1) +#define SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_MASK (0x1u) #define SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_SHIFT (0u) -#define SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_GET(flags) \ - ((u8)(((flags) >> SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_SHIFT) & \ +#define SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_GET(flags) \ + ((u8)((u8)((flags) >> SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_SHIFT) & \ SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_MASK)) -#define SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_MASK)) \ - << (SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_SHIFT))); \ +#define SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_MASK \ + << SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_SHIFT))) | \ + (((val) & (SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_MASK)) \ + << (SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_SHIFT))); \ } while (0) #define SBP_FLASH_READ_REQ_FLASH_TARGET_TO_READ_FLASH_STM (0) @@ -117,16 +123,18 @@ #define SBP_MSG_FLASH_READ_REQ_ENCODED_LEN 5u #define SBP_MSG_FLASH_READ_RESP 0x00E1 -#define SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_MASK (0x1) +#define SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_MASK (0x1u) #define SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_SHIFT (0u) -#define SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_GET(flags) \ - ((u8)(((flags) >> SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_SHIFT) & \ +#define SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_GET(flags) \ + ((u8)((u8)((flags) >> SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_SHIFT) & \ SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_MASK)) -#define SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_MASK)) \ - << (SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_SHIFT))); \ +#define SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_MASK \ + << SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_SHIFT))) | \ + (((val) & (SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_MASK)) \ + << (SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_SHIFT))); \ } while (0) #define SBP_FLASH_READ_RESP_FLASH_TARGET_TO_READ_FLASH_STM (0) @@ -146,16 +154,18 @@ #define SBP_MSG_FLASH_READ_RESP_ENCODED_LEN 5u #define SBP_MSG_FLASH_ERASE 0x00E2 -#define SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_MASK (0x1) +#define SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_MASK (0x1u) #define SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_SHIFT (0u) -#define SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_GET(flags) \ - ((u8)(((flags) >> SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_SHIFT) & \ +#define SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_GET(flags) \ + ((u8)((u8)((flags) >> SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_SHIFT) & \ SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_MASK)) -#define SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_MASK)) \ - << (SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_SHIFT))); \ +#define SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_MASK \ + << SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_SHIFT))) | \ + (((val) & (SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_MASK)) \ + << (SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_SHIFT))); \ } while (0) #define SBP_FLASH_ERASE_FLASH_TARGET_TO_READ_FLASH_STM (0) diff --git a/c/include/libsbp/gnss_macros.h b/c/include/libsbp/gnss_macros.h index 1ac7e581e9..1ee31a667d 100644 --- a/c/include/libsbp/gnss_macros.h +++ b/c/include/libsbp/gnss_macros.h @@ -18,14 +18,15 @@ #ifndef LIBSBP_GNSS_MACROS_H #define LIBSBP_GNSS_MACROS_H -#define SBP_GNSSSIGNAL__MASK (0xff) +#define SBP_GNSSSIGNAL__MASK (0xffu) #define SBP_GNSSSIGNAL__SHIFT (0u) #define SBP_GNSSSIGNAL__GET(flags) \ - ((u8)(((flags) >> SBP_GNSSSIGNAL__SHIFT) & SBP_GNSSSIGNAL__MASK)) -#define SBP_GNSSSIGNAL__SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_GNSSSIGNAL__MASK)) \ - << (SBP_GNSSSIGNAL__SHIFT))); \ + ((u8)((u8)((flags) >> SBP_GNSSSIGNAL__SHIFT) & SBP_GNSSSIGNAL__MASK)) +#define SBP_GNSSSIGNAL__SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_GNSSSIGNAL__MASK << SBP_GNSSSIGNAL__SHIFT))) | \ + (((val) & (SBP_GNSSSIGNAL__MASK)) << (SBP_GNSSSIGNAL__SHIFT))); \ } while (0) #define SBP_GNSSSIGNAL_GPS_L1CA (0) @@ -52,14 +53,15 @@ */ #define SBP_SV_ID_ENCODED_LEN 2u -#define SBP_GNSSSIGNALDEP__MASK (0xff) +#define SBP_GNSSSIGNALDEP__MASK (0xffu) #define SBP_GNSSSIGNALDEP__SHIFT (0u) #define SBP_GNSSSIGNALDEP__GET(flags) \ - ((u8)(((flags) >> SBP_GNSSSIGNALDEP__SHIFT) & SBP_GNSSSIGNALDEP__MASK)) -#define SBP_GNSSSIGNALDEP__SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_GNSSSIGNALDEP__MASK)) \ - << (SBP_GNSSSIGNALDEP__SHIFT))); \ + ((u8)((u8)((flags) >> SBP_GNSSSIGNALDEP__SHIFT) & SBP_GNSSSIGNALDEP__MASK)) +#define SBP_GNSSSIGNALDEP__SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_GNSSSIGNALDEP__MASK << SBP_GNSSSIGNALDEP__SHIFT))) | \ + (((val) & (SBP_GNSSSIGNALDEP__MASK)) << (SBP_GNSSSIGNALDEP__SHIFT))); \ } while (0) #define SBP_GNSSSIGNALDEP_GPS_L1CA (0) diff --git a/c/include/libsbp/imu_macros.h b/c/include/libsbp/imu_macros.h index e410ec29fc..0a198993fe 100644 --- a/c/include/libsbp/imu_macros.h +++ b/c/include/libsbp/imu_macros.h @@ -19,34 +19,39 @@ #define LIBSBP_IMU_MACROS_H #define SBP_MSG_IMU_RAW 0x0900 -#define SBP_IMU_RAW_TIME_STATUS_MASK (0x3) +#define SBP_IMU_RAW_TIME_STATUS_MASK (0x3u) #define SBP_IMU_RAW_TIME_STATUS_SHIFT (30u) -#define SBP_IMU_RAW_TIME_STATUS_GET(flags) \ - ((u32)(((flags) >> SBP_IMU_RAW_TIME_STATUS_SHIFT) & \ +#define SBP_IMU_RAW_TIME_STATUS_GET(flags) \ + ((u32)((u32)((flags) >> SBP_IMU_RAW_TIME_STATUS_SHIFT) & \ SBP_IMU_RAW_TIME_STATUS_MASK)) -#define SBP_IMU_RAW_TIME_STATUS_SET(flags, val) \ - do { \ - (flags) = (u32)((flags) | (((val) & (SBP_IMU_RAW_TIME_STATUS_MASK)) \ - << (SBP_IMU_RAW_TIME_STATUS_SHIFT))); \ +#define SBP_IMU_RAW_TIME_STATUS_SET(flags, val) \ + do { \ + (flags) = (u32)((flags & (~(SBP_IMU_RAW_TIME_STATUS_MASK \ + << SBP_IMU_RAW_TIME_STATUS_SHIFT))) | \ + (((val) & (SBP_IMU_RAW_TIME_STATUS_MASK)) \ + << (SBP_IMU_RAW_TIME_STATUS_SHIFT))); \ } while (0) #define SBP_IMU_RAW_TIME_STATUS_REFERENCE_EPOCH_IS_START_OF_CURRENT_GPS_WEEK (0) #define SBP_IMU_RAW_TIME_STATUS_REFERENCE_EPOCH_IS_TIME_OF_SYSTEM_STARTUP (1) #define SBP_IMU_RAW_TIME_STATUS_REFERENCE_EPOCH_IS_UNKNOWN (2) #define SBP_IMU_RAW_TIME_STATUS_REFERENCE_EPOCH_IS_LAST_PPS (3) -#define SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_MASK (0x3fffffff) +#define SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_MASK \ + (0x3fffffffu) #define SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_SHIFT (0u) -#define SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_GET(flags) \ - ((u32)(((flags) >> \ - SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_SHIFT) & \ +#define SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_GET(flags) \ + ((u32)((u32)((flags) >> \ + SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_SHIFT) & \ SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_MASK)) -#define SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_SET(flags, val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_MASK)) \ - << (SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_SHIFT))); \ +#define SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_SET(flags, val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_MASK \ + << SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_SHIFT))) | \ + (((val) & \ + (SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_MASK)) \ + << (SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_SHIFT))); \ } while (0) /** @@ -56,27 +61,32 @@ #define SBP_MSG_IMU_RAW_ENCODED_LEN 17u #define SBP_MSG_IMU_AUX 0x0901 -#define SBP_IMU_AUX_IMU_TYPE_MASK (0xff) +#define SBP_IMU_AUX_IMU_TYPE_MASK (0xffu) #define SBP_IMU_AUX_IMU_TYPE_SHIFT (0u) -#define SBP_IMU_AUX_IMU_TYPE_GET(flags) \ - ((u8)(((flags) >> SBP_IMU_AUX_IMU_TYPE_SHIFT) & SBP_IMU_AUX_IMU_TYPE_MASK)) -#define SBP_IMU_AUX_IMU_TYPE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_IMU_AUX_IMU_TYPE_MASK)) \ - << (SBP_IMU_AUX_IMU_TYPE_SHIFT))); \ +#define SBP_IMU_AUX_IMU_TYPE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_IMU_AUX_IMU_TYPE_SHIFT) & \ + SBP_IMU_AUX_IMU_TYPE_MASK)) +#define SBP_IMU_AUX_IMU_TYPE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_IMU_AUX_IMU_TYPE_MASK \ + << SBP_IMU_AUX_IMU_TYPE_SHIFT))) | \ + (((val) & (SBP_IMU_AUX_IMU_TYPE_MASK)) \ + << (SBP_IMU_AUX_IMU_TYPE_SHIFT))); \ } while (0) #define SBP_IMU_AUX_IMU_TYPE_BOSCH_BMI160 (0) #define SBP_IMU_AUX_IMU_TYPE_ST_MICROELECTRONICS_ASM330LLH (1) -#define SBP_IMU_AUX_GYROSCOPE_RANGE_MASK (0xf) +#define SBP_IMU_AUX_GYROSCOPE_RANGE_MASK (0xfu) #define SBP_IMU_AUX_GYROSCOPE_RANGE_SHIFT (4u) -#define SBP_IMU_AUX_GYROSCOPE_RANGE_GET(flags) \ - ((u8)(((flags) >> SBP_IMU_AUX_GYROSCOPE_RANGE_SHIFT) & \ +#define SBP_IMU_AUX_GYROSCOPE_RANGE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_IMU_AUX_GYROSCOPE_RANGE_SHIFT) & \ SBP_IMU_AUX_GYROSCOPE_RANGE_MASK)) -#define SBP_IMU_AUX_GYROSCOPE_RANGE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_IMU_AUX_GYROSCOPE_RANGE_MASK)) \ - << (SBP_IMU_AUX_GYROSCOPE_RANGE_SHIFT))); \ +#define SBP_IMU_AUX_GYROSCOPE_RANGE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_IMU_AUX_GYROSCOPE_RANGE_MASK \ + << SBP_IMU_AUX_GYROSCOPE_RANGE_SHIFT))) | \ + (((val) & (SBP_IMU_AUX_GYROSCOPE_RANGE_MASK)) \ + << (SBP_IMU_AUX_GYROSCOPE_RANGE_SHIFT))); \ } while (0) #define SBP_IMU_AUX_GYROSCOPE_RANGE__2000_DEG__S (0) @@ -89,15 +99,17 @@ #define SBP_IMU_AUX_GYROSCOPE_RANGE_250_DEG_S (3) #define SBP_IMU_AUX_GYROSCOPE_RANGE__125_DEG__S (4) #define SBP_IMU_AUX_GYROSCOPE_RANGE_125_DEG_S (4) -#define SBP_IMU_AUX_ACCELEROMETER_RANGE_MASK (0xf) +#define SBP_IMU_AUX_ACCELEROMETER_RANGE_MASK (0xfu) #define SBP_IMU_AUX_ACCELEROMETER_RANGE_SHIFT (0u) -#define SBP_IMU_AUX_ACCELEROMETER_RANGE_GET(flags) \ - ((u8)(((flags) >> SBP_IMU_AUX_ACCELEROMETER_RANGE_SHIFT) & \ +#define SBP_IMU_AUX_ACCELEROMETER_RANGE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_IMU_AUX_ACCELEROMETER_RANGE_SHIFT) & \ SBP_IMU_AUX_ACCELEROMETER_RANGE_MASK)) -#define SBP_IMU_AUX_ACCELEROMETER_RANGE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_IMU_AUX_ACCELEROMETER_RANGE_MASK)) \ - << (SBP_IMU_AUX_ACCELEROMETER_RANGE_SHIFT))); \ +#define SBP_IMU_AUX_ACCELEROMETER_RANGE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_IMU_AUX_ACCELEROMETER_RANGE_MASK \ + << SBP_IMU_AUX_ACCELEROMETER_RANGE_SHIFT))) | \ + (((val) & (SBP_IMU_AUX_ACCELEROMETER_RANGE_MASK)) \ + << (SBP_IMU_AUX_ACCELEROMETER_RANGE_SHIFT))); \ } while (0) #define SBP_IMU_AUX_ACCELEROMETER_RANGE__2G (0) diff --git a/c/include/libsbp/linux_macros.h b/c/include/libsbp/linux_macros.h index e9386af897..fd3308e643 100644 --- a/c/include/libsbp/linux_macros.h +++ b/c/include/libsbp/linux_macros.h @@ -217,16 +217,18 @@ #define SBP_MSG_LINUX_PROCESS_FD_SUMMARY_ENCODED_OVERHEAD 4u #define SBP_MSG_LINUX_CPU_STATE 0x7F08 -#define SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_MASK (0x7) +#define SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_MASK (0x7u) #define SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_SHIFT (0u) -#define SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_GET(flags) \ - ((u8)(((flags) >> SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_SHIFT) & \ +#define SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_SHIFT) & \ SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_MASK)) -#define SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_MASK)) \ - << (SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_SHIFT))); \ +#define SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_MASK \ + << SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_SHIFT))) | \ + (((val) & (SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_MASK)) \ + << (SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_SHIFT))); \ } while (0) #define SBP_LINUX_CPU_STATE_TIMESTAMP_TYPE_SYSTEM_TIME_IN_SECONDS (0) @@ -261,16 +263,18 @@ #define SBP_MSG_LINUX_CPU_STATE_ENCODED_OVERHEAD 24u #define SBP_MSG_LINUX_MEM_STATE 0x7F09 -#define SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_MASK (0x7) +#define SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_MASK (0x7u) #define SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_SHIFT (0u) -#define SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_GET(flags) \ - ((u8)(((flags) >> SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_SHIFT) & \ +#define SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_SHIFT) & \ SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_MASK)) -#define SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_MASK)) \ - << (SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_SHIFT))); \ +#define SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_MASK \ + << SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_SHIFT))) | \ + (((val) & (SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_MASK)) \ + << (SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_SHIFT))); \ } while (0) #define SBP_LINUX_MEM_STATE_TIMESTAMP_TYPE_SYSTEM_TIME_IN_SECONDS (0) @@ -305,16 +309,18 @@ #define SBP_MSG_LINUX_MEM_STATE_ENCODED_OVERHEAD 24u #define SBP_MSG_LINUX_SYS_STATE 0x7F0A -#define SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_MASK (0x7) +#define SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_MASK (0x7u) #define SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_SHIFT (0u) -#define SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_GET(flags) \ - ((u8)(((flags) >> SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_SHIFT) & \ +#define SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_SHIFT) & \ SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_MASK)) -#define SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_MASK)) \ - << (SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_SHIFT))); \ +#define SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_MASK \ + << SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_SHIFT))) | \ + (((val) & (SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_MASK)) \ + << (SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_SHIFT))); \ } while (0) #define SBP_LINUX_SYS_STATE_TIMESTAMP_TYPE_SYSTEM_TIME_IN_SECONDS (0) diff --git a/c/include/libsbp/logging_macros.h b/c/include/libsbp/logging_macros.h index fe74d8e312..66791cb801 100644 --- a/c/include/libsbp/logging_macros.h +++ b/c/include/libsbp/logging_macros.h @@ -19,14 +19,17 @@ #define LIBSBP_LOGGING_MACROS_H #define SBP_MSG_LOG 0x0401 -#define SBP_LOG_LOGGING_LEVEL_MASK (0x7) +#define SBP_LOG_LOGGING_LEVEL_MASK (0x7u) #define SBP_LOG_LOGGING_LEVEL_SHIFT (0u) -#define SBP_LOG_LOGGING_LEVEL_GET(flags) \ - ((u8)(((flags) >> SBP_LOG_LOGGING_LEVEL_SHIFT) & SBP_LOG_LOGGING_LEVEL_MASK)) -#define SBP_LOG_LOGGING_LEVEL_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_LOG_LOGGING_LEVEL_MASK)) \ - << (SBP_LOG_LOGGING_LEVEL_SHIFT))); \ +#define SBP_LOG_LOGGING_LEVEL_GET(flags) \ + ((u8)((u8)((flags) >> SBP_LOG_LOGGING_LEVEL_SHIFT) & \ + SBP_LOG_LOGGING_LEVEL_MASK)) +#define SBP_LOG_LOGGING_LEVEL_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_LOG_LOGGING_LEVEL_MASK \ + << SBP_LOG_LOGGING_LEVEL_SHIFT))) | \ + (((val) & (SBP_LOG_LOGGING_LEVEL_MASK)) \ + << (SBP_LOG_LOGGING_LEVEL_SHIFT))); \ } while (0) #define SBP_LOG_LOGGING_LEVEL_EMERG (0) diff --git a/c/include/libsbp/navigation_macros.h b/c/include/libsbp/navigation_macros.h index 3084f492ca..886b77ff02 100644 --- a/c/include/libsbp/navigation_macros.h +++ b/c/include/libsbp/navigation_macros.h @@ -19,15 +19,17 @@ #define LIBSBP_NAVIGATION_MACROS_H #define SBP_MSG_GPS_TIME 0x0102 -#define SBP_GPS_TIME_TIME_SOURCE_MASK (0x7) +#define SBP_GPS_TIME_TIME_SOURCE_MASK (0x7u) #define SBP_GPS_TIME_TIME_SOURCE_SHIFT (0u) -#define SBP_GPS_TIME_TIME_SOURCE_GET(flags) \ - ((u8)(((flags) >> SBP_GPS_TIME_TIME_SOURCE_SHIFT) & \ +#define SBP_GPS_TIME_TIME_SOURCE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_GPS_TIME_TIME_SOURCE_SHIFT) & \ SBP_GPS_TIME_TIME_SOURCE_MASK)) -#define SBP_GPS_TIME_TIME_SOURCE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_GPS_TIME_TIME_SOURCE_MASK)) \ - << (SBP_GPS_TIME_TIME_SOURCE_SHIFT))); \ +#define SBP_GPS_TIME_TIME_SOURCE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_GPS_TIME_TIME_SOURCE_MASK \ + << SBP_GPS_TIME_TIME_SOURCE_SHIFT))) | \ + (((val) & (SBP_GPS_TIME_TIME_SOURCE_MASK)) \ + << (SBP_GPS_TIME_TIME_SOURCE_SHIFT))); \ } while (0) #define SBP_GPS_TIME_TIME_SOURCE_NONE (0) @@ -40,15 +42,17 @@ #define SBP_MSG_GPS_TIME_ENCODED_LEN 11u #define SBP_MSG_GPS_TIME_GNSS 0x0104 -#define SBP_GPS_TIME_GNSS_TIME_SOURCE_MASK (0x7) +#define SBP_GPS_TIME_GNSS_TIME_SOURCE_MASK (0x7u) #define SBP_GPS_TIME_GNSS_TIME_SOURCE_SHIFT (0u) -#define SBP_GPS_TIME_GNSS_TIME_SOURCE_GET(flags) \ - ((u8)(((flags) >> SBP_GPS_TIME_GNSS_TIME_SOURCE_SHIFT) & \ +#define SBP_GPS_TIME_GNSS_TIME_SOURCE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_GPS_TIME_GNSS_TIME_SOURCE_SHIFT) & \ SBP_GPS_TIME_GNSS_TIME_SOURCE_MASK)) -#define SBP_GPS_TIME_GNSS_TIME_SOURCE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_GPS_TIME_GNSS_TIME_SOURCE_MASK)) \ - << (SBP_GPS_TIME_GNSS_TIME_SOURCE_SHIFT))); \ +#define SBP_GPS_TIME_GNSS_TIME_SOURCE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_GPS_TIME_GNSS_TIME_SOURCE_MASK \ + << SBP_GPS_TIME_GNSS_TIME_SOURCE_SHIFT))) | \ + (((val) & (SBP_GPS_TIME_GNSS_TIME_SOURCE_MASK)) \ + << (SBP_GPS_TIME_GNSS_TIME_SOURCE_SHIFT))); \ } while (0) #define SBP_GPS_TIME_GNSS_TIME_SOURCE_NONE (0) @@ -61,29 +65,33 @@ #define SBP_MSG_GPS_TIME_GNSS_ENCODED_LEN 11u #define SBP_MSG_UTC_TIME 0x0103 -#define SBP_UTC_TIME_UTC_OFFSET_SOURCE_MASK (0x3) +#define SBP_UTC_TIME_UTC_OFFSET_SOURCE_MASK (0x3u) #define SBP_UTC_TIME_UTC_OFFSET_SOURCE_SHIFT (3u) -#define SBP_UTC_TIME_UTC_OFFSET_SOURCE_GET(flags) \ - ((u8)(((flags) >> SBP_UTC_TIME_UTC_OFFSET_SOURCE_SHIFT) & \ +#define SBP_UTC_TIME_UTC_OFFSET_SOURCE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_UTC_TIME_UTC_OFFSET_SOURCE_SHIFT) & \ SBP_UTC_TIME_UTC_OFFSET_SOURCE_MASK)) -#define SBP_UTC_TIME_UTC_OFFSET_SOURCE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_UTC_TIME_UTC_OFFSET_SOURCE_MASK)) \ - << (SBP_UTC_TIME_UTC_OFFSET_SOURCE_SHIFT))); \ +#define SBP_UTC_TIME_UTC_OFFSET_SOURCE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_UTC_TIME_UTC_OFFSET_SOURCE_MASK \ + << SBP_UTC_TIME_UTC_OFFSET_SOURCE_SHIFT))) | \ + (((val) & (SBP_UTC_TIME_UTC_OFFSET_SOURCE_MASK)) \ + << (SBP_UTC_TIME_UTC_OFFSET_SOURCE_SHIFT))); \ } while (0) #define SBP_UTC_TIME_UTC_OFFSET_SOURCE_FACTORY_DEFAULT (0) #define SBP_UTC_TIME_UTC_OFFSET_SOURCE_NON_VOLATILE_MEMORY (1) #define SBP_UTC_TIME_UTC_OFFSET_SOURCE_DECODED_THIS_SESSION (2) -#define SBP_UTC_TIME_TIME_SOURCE_MASK (0x7) +#define SBP_UTC_TIME_TIME_SOURCE_MASK (0x7u) #define SBP_UTC_TIME_TIME_SOURCE_SHIFT (0u) -#define SBP_UTC_TIME_TIME_SOURCE_GET(flags) \ - ((u8)(((flags) >> SBP_UTC_TIME_TIME_SOURCE_SHIFT) & \ +#define SBP_UTC_TIME_TIME_SOURCE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_UTC_TIME_TIME_SOURCE_SHIFT) & \ SBP_UTC_TIME_TIME_SOURCE_MASK)) -#define SBP_UTC_TIME_TIME_SOURCE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_UTC_TIME_TIME_SOURCE_MASK)) \ - << (SBP_UTC_TIME_TIME_SOURCE_SHIFT))); \ +#define SBP_UTC_TIME_TIME_SOURCE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_UTC_TIME_TIME_SOURCE_MASK \ + << SBP_UTC_TIME_TIME_SOURCE_SHIFT))) | \ + (((val) & (SBP_UTC_TIME_TIME_SOURCE_MASK)) \ + << (SBP_UTC_TIME_TIME_SOURCE_SHIFT))); \ } while (0) #define SBP_UTC_TIME_TIME_SOURCE_NONE (0) @@ -96,30 +104,34 @@ #define SBP_MSG_UTC_TIME_ENCODED_LEN 16u #define SBP_MSG_UTC_TIME_GNSS 0x0105 -#define SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_MASK (0x3) +#define SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_MASK (0x3u) #define SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_SHIFT (3u) -#define SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_GET(flags) \ - ((u8)(((flags) >> SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_SHIFT) & \ +#define SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_SHIFT) & \ SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_MASK)) -#define SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_MASK)) \ - << (SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_SHIFT))); \ +#define SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_MASK \ + << SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_SHIFT))) | \ + (((val) & (SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_MASK)) \ + << (SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_SHIFT))); \ } while (0) #define SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_FACTORY_DEFAULT (0) #define SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_NON_VOLATILE_MEMORY (1) #define SBP_UTC_TIME_GNSS_UTC_OFFSET_SOURCE_DECODED_THIS_SESSION (2) -#define SBP_UTC_TIME_GNSS_TIME_SOURCE_MASK (0x7) +#define SBP_UTC_TIME_GNSS_TIME_SOURCE_MASK (0x7u) #define SBP_UTC_TIME_GNSS_TIME_SOURCE_SHIFT (0u) -#define SBP_UTC_TIME_GNSS_TIME_SOURCE_GET(flags) \ - ((u8)(((flags) >> SBP_UTC_TIME_GNSS_TIME_SOURCE_SHIFT) & \ +#define SBP_UTC_TIME_GNSS_TIME_SOURCE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_UTC_TIME_GNSS_TIME_SOURCE_SHIFT) & \ SBP_UTC_TIME_GNSS_TIME_SOURCE_MASK)) -#define SBP_UTC_TIME_GNSS_TIME_SOURCE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_UTC_TIME_GNSS_TIME_SOURCE_MASK)) \ - << (SBP_UTC_TIME_GNSS_TIME_SOURCE_SHIFT))); \ +#define SBP_UTC_TIME_GNSS_TIME_SOURCE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_UTC_TIME_GNSS_TIME_SOURCE_MASK \ + << SBP_UTC_TIME_GNSS_TIME_SOURCE_SHIFT))) | \ + (((val) & (SBP_UTC_TIME_GNSS_TIME_SOURCE_MASK)) \ + << (SBP_UTC_TIME_GNSS_TIME_SOURCE_SHIFT))); \ } while (0) #define SBP_UTC_TIME_GNSS_TIME_SOURCE_NONE (0) @@ -132,25 +144,28 @@ #define SBP_MSG_UTC_TIME_GNSS_ENCODED_LEN 16u #define SBP_MSG_DOPS 0x0208 -#define SBP_DOPS_RAIM_REPAIR_FLAG_MASK (0x1) +#define SBP_DOPS_RAIM_REPAIR_FLAG_MASK (0x1u) #define SBP_DOPS_RAIM_REPAIR_FLAG_SHIFT (7u) -#define SBP_DOPS_RAIM_REPAIR_FLAG_GET(flags) \ - ((u8)(((flags) >> SBP_DOPS_RAIM_REPAIR_FLAG_SHIFT) & \ +#define SBP_DOPS_RAIM_REPAIR_FLAG_GET(flags) \ + ((u8)((u8)((flags) >> SBP_DOPS_RAIM_REPAIR_FLAG_SHIFT) & \ SBP_DOPS_RAIM_REPAIR_FLAG_MASK)) -#define SBP_DOPS_RAIM_REPAIR_FLAG_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_DOPS_RAIM_REPAIR_FLAG_MASK)) \ - << (SBP_DOPS_RAIM_REPAIR_FLAG_SHIFT))); \ +#define SBP_DOPS_RAIM_REPAIR_FLAG_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_DOPS_RAIM_REPAIR_FLAG_MASK \ + << SBP_DOPS_RAIM_REPAIR_FLAG_SHIFT))) | \ + (((val) & (SBP_DOPS_RAIM_REPAIR_FLAG_MASK)) \ + << (SBP_DOPS_RAIM_REPAIR_FLAG_SHIFT))); \ } while (0) -#define SBP_DOPS_FIX_MODE_MASK (0x7) +#define SBP_DOPS_FIX_MODE_MASK (0x7u) #define SBP_DOPS_FIX_MODE_SHIFT (0u) #define SBP_DOPS_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_DOPS_FIX_MODE_SHIFT) & SBP_DOPS_FIX_MODE_MASK)) -#define SBP_DOPS_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_DOPS_FIX_MODE_MASK)) \ - << (SBP_DOPS_FIX_MODE_SHIFT))); \ + ((u8)((u8)((flags) >> SBP_DOPS_FIX_MODE_SHIFT) & SBP_DOPS_FIX_MODE_MASK)) +#define SBP_DOPS_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_DOPS_FIX_MODE_MASK << SBP_DOPS_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_DOPS_FIX_MODE_MASK)) << (SBP_DOPS_FIX_MODE_SHIFT))); \ } while (0) #define SBP_DOPS_FIX_MODE_INVALID (0) @@ -167,40 +182,48 @@ #define SBP_MSG_DOPS_ENCODED_LEN 15u #define SBP_MSG_POS_ECEF 0x0209 -#define SBP_POS_ECEF_TOW_TYPE_MASK (0x1) +#define SBP_POS_ECEF_TOW_TYPE_MASK (0x1u) #define SBP_POS_ECEF_TOW_TYPE_SHIFT (5u) -#define SBP_POS_ECEF_TOW_TYPE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_ECEF_TOW_TYPE_SHIFT) & SBP_POS_ECEF_TOW_TYPE_MASK)) -#define SBP_POS_ECEF_TOW_TYPE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_POS_ECEF_TOW_TYPE_MASK)) \ - << (SBP_POS_ECEF_TOW_TYPE_SHIFT))); \ +#define SBP_POS_ECEF_TOW_TYPE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_ECEF_TOW_TYPE_SHIFT) & \ + SBP_POS_ECEF_TOW_TYPE_MASK)) +#define SBP_POS_ECEF_TOW_TYPE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_ECEF_TOW_TYPE_MASK \ + << SBP_POS_ECEF_TOW_TYPE_SHIFT))) | \ + (((val) & (SBP_POS_ECEF_TOW_TYPE_MASK)) \ + << (SBP_POS_ECEF_TOW_TYPE_SHIFT))); \ } while (0) #define SBP_POS_ECEF_TOW_TYPE_TIME_OF_MEASUREMENT (0) #define SBP_POS_ECEF_TOW_TYPE_OTHER (1) -#define SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_MASK (0x3) +#define SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_MASK (0x3u) #define SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_SHIFT (3u) -#define SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_SHIFT) & \ +#define SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_SHIFT) & \ SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_MASK)) -#define SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_MASK)) \ - << (SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_SHIFT))); \ +#define SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_MASK \ + << SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_SHIFT))) | \ + (((val) & (SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_MASK)) \ + << (SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_SHIFT))); \ } while (0) #define SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_NONE (0) #define SBP_POS_ECEF_INERTIAL_NAVIGATION_MODE_INS_USED (1) -#define SBP_POS_ECEF_FIX_MODE_MASK (0x7) +#define SBP_POS_ECEF_FIX_MODE_MASK (0x7u) #define SBP_POS_ECEF_FIX_MODE_SHIFT (0u) -#define SBP_POS_ECEF_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_ECEF_FIX_MODE_SHIFT) & SBP_POS_ECEF_FIX_MODE_MASK)) -#define SBP_POS_ECEF_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_POS_ECEF_FIX_MODE_MASK)) \ - << (SBP_POS_ECEF_FIX_MODE_SHIFT))); \ +#define SBP_POS_ECEF_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_ECEF_FIX_MODE_SHIFT) & \ + SBP_POS_ECEF_FIX_MODE_MASK)) +#define SBP_POS_ECEF_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_ECEF_FIX_MODE_MASK \ + << SBP_POS_ECEF_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_POS_ECEF_FIX_MODE_MASK)) \ + << (SBP_POS_ECEF_FIX_MODE_SHIFT))); \ } while (0) #define SBP_POS_ECEF_FIX_MODE_INVALID (0) @@ -217,43 +240,49 @@ #define SBP_MSG_POS_ECEF_ENCODED_LEN 32u #define SBP_MSG_POS_ECEF_COV 0x0214 -#define SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_MASK (0x1) +#define SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_MASK (0x1u) #define SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_SHIFT (5u) -#define SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_GET(flags) \ - ((u8)(((flags) >> SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_SHIFT) & \ +#define SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_SHIFT) & \ SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_MASK)) -#define SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_MASK)) \ - << (SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_SHIFT))); \ +#define SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_MASK \ + << SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_SHIFT))) | \ + (((val) & (SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_MASK)) \ + << (SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_SHIFT))); \ } while (0) #define SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_TIME_OF_MEASUREMENT (0) #define SBP_POS_ECEF_COV_TYPE_OF_REPORTED_TOW_OTHER (1) -#define SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_MASK (0x3) +#define SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_MASK (0x3u) #define SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_SHIFT (3u) -#define SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_SHIFT) & \ +#define SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_SHIFT) & \ SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_MASK)) -#define SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_MASK)) \ - << (SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_SHIFT))); \ +#define SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_MASK \ + << SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_SHIFT))) | \ + (((val) & (SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_MASK)) \ + << (SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_SHIFT))); \ } while (0) #define SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_NONE (0) #define SBP_POS_ECEF_COV_INERTIAL_NAVIGATION_MODE_INS_USED (1) -#define SBP_POS_ECEF_COV_FIX_MODE_MASK (0x7) +#define SBP_POS_ECEF_COV_FIX_MODE_MASK (0x7u) #define SBP_POS_ECEF_COV_FIX_MODE_SHIFT (0u) -#define SBP_POS_ECEF_COV_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_ECEF_COV_FIX_MODE_SHIFT) & \ +#define SBP_POS_ECEF_COV_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_ECEF_COV_FIX_MODE_SHIFT) & \ SBP_POS_ECEF_COV_FIX_MODE_MASK)) -#define SBP_POS_ECEF_COV_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_POS_ECEF_COV_FIX_MODE_MASK)) \ - << (SBP_POS_ECEF_COV_FIX_MODE_SHIFT))); \ +#define SBP_POS_ECEF_COV_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_ECEF_COV_FIX_MODE_MASK \ + << SBP_POS_ECEF_COV_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_POS_ECEF_COV_FIX_MODE_MASK)) \ + << (SBP_POS_ECEF_COV_FIX_MODE_SHIFT))); \ } while (0) #define SBP_POS_ECEF_COV_FIX_MODE_INVALID (0) @@ -270,42 +299,48 @@ #define SBP_MSG_POS_ECEF_COV_ENCODED_LEN 54u #define SBP_MSG_POS_LLH 0x020A -#define SBP_POS_LLH_TYPE_OF_REPORTED_TOW_MASK (0x1) +#define SBP_POS_LLH_TYPE_OF_REPORTED_TOW_MASK (0x1u) #define SBP_POS_LLH_TYPE_OF_REPORTED_TOW_SHIFT (5u) -#define SBP_POS_LLH_TYPE_OF_REPORTED_TOW_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_TYPE_OF_REPORTED_TOW_SHIFT) & \ +#define SBP_POS_LLH_TYPE_OF_REPORTED_TOW_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_TYPE_OF_REPORTED_TOW_SHIFT) & \ SBP_POS_LLH_TYPE_OF_REPORTED_TOW_MASK)) -#define SBP_POS_LLH_TYPE_OF_REPORTED_TOW_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_POS_LLH_TYPE_OF_REPORTED_TOW_MASK)) \ - << (SBP_POS_LLH_TYPE_OF_REPORTED_TOW_SHIFT))); \ +#define SBP_POS_LLH_TYPE_OF_REPORTED_TOW_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_LLH_TYPE_OF_REPORTED_TOW_MASK \ + << SBP_POS_LLH_TYPE_OF_REPORTED_TOW_SHIFT))) | \ + (((val) & (SBP_POS_LLH_TYPE_OF_REPORTED_TOW_MASK)) \ + << (SBP_POS_LLH_TYPE_OF_REPORTED_TOW_SHIFT))); \ } while (0) #define SBP_POS_LLH_TYPE_OF_REPORTED_TOW_TIME_OF_MEASUREMENT (0) #define SBP_POS_LLH_TYPE_OF_REPORTED_TOW_OTHER (1) -#define SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_MASK (0x3) +#define SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_MASK (0x3u) #define SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_SHIFT (3u) -#define SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_SHIFT) & \ +#define SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_SHIFT) & \ SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_MASK)) -#define SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_MASK)) \ - << (SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_SHIFT))); \ +#define SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_MASK \ + << SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_SHIFT))) | \ + (((val) & (SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_MASK)) \ + << (SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_SHIFT))); \ } while (0) #define SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_NONE (0) #define SBP_POS_LLH_INERTIAL_NAVIGATION_MODE_INS_USED (1) -#define SBP_POS_LLH_FIX_MODE_MASK (0x7) +#define SBP_POS_LLH_FIX_MODE_MASK (0x7u) #define SBP_POS_LLH_FIX_MODE_SHIFT (0u) -#define SBP_POS_LLH_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_FIX_MODE_SHIFT) & SBP_POS_LLH_FIX_MODE_MASK)) -#define SBP_POS_LLH_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_POS_LLH_FIX_MODE_MASK)) \ - << (SBP_POS_LLH_FIX_MODE_SHIFT))); \ +#define SBP_POS_LLH_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_FIX_MODE_SHIFT) & \ + SBP_POS_LLH_FIX_MODE_MASK)) +#define SBP_POS_LLH_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_LLH_FIX_MODE_MASK \ + << SBP_POS_LLH_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_POS_LLH_FIX_MODE_MASK)) \ + << (SBP_POS_LLH_FIX_MODE_SHIFT))); \ } while (0) #define SBP_POS_LLH_FIX_MODE_INVALID (0) @@ -322,43 +357,49 @@ #define SBP_MSG_POS_LLH_ENCODED_LEN 34u #define SBP_MSG_POS_LLH_COV 0x0211 -#define SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_MASK (0x1) +#define SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_MASK (0x1u) #define SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_SHIFT (5u) -#define SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_SHIFT) & \ +#define SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_SHIFT) & \ SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_MASK)) -#define SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_MASK)) \ - << (SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_SHIFT))); \ +#define SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_MASK \ + << SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_SHIFT))) | \ + (((val) & (SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_MASK)) \ + << (SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_SHIFT))); \ } while (0) #define SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_TIME_OF_MEASUREMENT (0) #define SBP_POS_LLH_COV_TYPE_OF_REPORTED_TOW_OTHER (1) -#define SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_MASK (0x3) +#define SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_MASK (0x3u) #define SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_SHIFT (3u) -#define SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_SHIFT) & \ +#define SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_SHIFT) & \ SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_MASK)) -#define SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_MASK)) \ - << (SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_SHIFT))); \ +#define SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_MASK \ + << SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_SHIFT))) | \ + (((val) & (SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_MASK)) \ + << (SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_SHIFT))); \ } while (0) #define SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_NONE (0) #define SBP_POS_LLH_COV_INERTIAL_NAVIGATION_MODE_INS_USED (1) -#define SBP_POS_LLH_COV_FIX_MODE_MASK (0x7) +#define SBP_POS_LLH_COV_FIX_MODE_MASK (0x7u) #define SBP_POS_LLH_COV_FIX_MODE_SHIFT (0u) -#define SBP_POS_LLH_COV_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_COV_FIX_MODE_SHIFT) & \ +#define SBP_POS_LLH_COV_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_COV_FIX_MODE_SHIFT) & \ SBP_POS_LLH_COV_FIX_MODE_MASK)) -#define SBP_POS_LLH_COV_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_POS_LLH_COV_FIX_MODE_MASK)) \ - << (SBP_POS_LLH_COV_FIX_MODE_SHIFT))); \ +#define SBP_POS_LLH_COV_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_LLH_COV_FIX_MODE_MASK \ + << SBP_POS_LLH_COV_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_POS_LLH_COV_FIX_MODE_MASK)) \ + << (SBP_POS_LLH_COV_FIX_MODE_SHIFT))); \ } while (0) #define SBP_POS_LLH_COV_FIX_MODE_INVALID (0) @@ -381,72 +422,81 @@ #define SBP_ESTIMATED_HORIZONTAL_ERROR_ELLIPSE_ENCODED_LEN 12u #define SBP_MSG_POS_LLH_ACC 0x0218 -#define SBP_POS_LLH_ACC_GEOID_MODEL_MASK (0x7) +#define SBP_POS_LLH_ACC_GEOID_MODEL_MASK (0x7u) #define SBP_POS_LLH_ACC_GEOID_MODEL_SHIFT (4u) -#define SBP_POS_LLH_ACC_GEOID_MODEL_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_ACC_GEOID_MODEL_SHIFT) & \ +#define SBP_POS_LLH_ACC_GEOID_MODEL_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_ACC_GEOID_MODEL_SHIFT) & \ SBP_POS_LLH_ACC_GEOID_MODEL_MASK)) -#define SBP_POS_LLH_ACC_GEOID_MODEL_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_POS_LLH_ACC_GEOID_MODEL_MASK)) \ - << (SBP_POS_LLH_ACC_GEOID_MODEL_SHIFT))); \ +#define SBP_POS_LLH_ACC_GEOID_MODEL_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_LLH_ACC_GEOID_MODEL_MASK \ + << SBP_POS_LLH_ACC_GEOID_MODEL_SHIFT))) | \ + (((val) & (SBP_POS_LLH_ACC_GEOID_MODEL_MASK)) \ + << (SBP_POS_LLH_ACC_GEOID_MODEL_SHIFT))); \ } while (0) #define SBP_POS_LLH_ACC_GEOID_MODEL_NO_MODEL (0) #define SBP_POS_LLH_ACC_GEOID_MODEL_EGM96 (1) #define SBP_POS_LLH_ACC_GEOID_MODEL_EGM2008 (2) -#define SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_MASK (0xf) +#define SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_MASK (0xfu) #define SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_SHIFT (0u) -#define SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_SHIFT) & \ +#define SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_SHIFT) & \ SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_MASK)) -#define SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_MASK)) \ - << (SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_SHIFT))); \ +#define SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_MASK \ + << SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_SHIFT))) | \ + (((val) & (SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_MASK)) \ + << (SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_SHIFT))); \ } while (0) #define SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_3935 (1) #define SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_6827 (2) #define SBP_POS_LLH_ACC_CONFIDENCE_LEVEL_9545 (3) -#define SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_MASK (0x1) +#define SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_MASK (0x1u) #define SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_SHIFT (5u) -#define SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_SHIFT) & \ +#define SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_SHIFT) & \ SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_MASK)) -#define SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_MASK)) \ - << (SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_SHIFT))); \ +#define SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_MASK \ + << SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_SHIFT))) | \ + (((val) & (SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_MASK)) \ + << (SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_SHIFT))); \ } while (0) #define SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_TIME_OF_MEASUREMENT (0) #define SBP_POS_LLH_ACC_TYPE_OF_REPORTED_TOW_OTHER (1) -#define SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_MASK (0x3) +#define SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_MASK (0x3u) #define SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_SHIFT (3u) -#define SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_SHIFT) & \ +#define SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_SHIFT) & \ SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_MASK)) -#define SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_MASK)) \ - << (SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_SHIFT))); \ +#define SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_MASK \ + << SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_SHIFT))) | \ + (((val) & (SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_MASK)) \ + << (SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_SHIFT))); \ } while (0) #define SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_NONE (0) #define SBP_POS_LLH_ACC_INERTIAL_NAVIGATION_MODE_INS_USED (1) -#define SBP_POS_LLH_ACC_FIX_MODE_MASK (0x7) +#define SBP_POS_LLH_ACC_FIX_MODE_MASK (0x7u) #define SBP_POS_LLH_ACC_FIX_MODE_SHIFT (0u) -#define SBP_POS_LLH_ACC_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_ACC_FIX_MODE_SHIFT) & \ +#define SBP_POS_LLH_ACC_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_ACC_FIX_MODE_SHIFT) & \ SBP_POS_LLH_ACC_FIX_MODE_MASK)) -#define SBP_POS_LLH_ACC_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_POS_LLH_ACC_FIX_MODE_MASK)) \ - << (SBP_POS_LLH_ACC_FIX_MODE_SHIFT))); \ +#define SBP_POS_LLH_ACC_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_LLH_ACC_FIX_MODE_MASK \ + << SBP_POS_LLH_ACC_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_POS_LLH_ACC_FIX_MODE_MASK)) \ + << (SBP_POS_LLH_ACC_FIX_MODE_SHIFT))); \ } while (0) #define SBP_POS_LLH_ACC_FIX_MODE_INVALID (0) @@ -463,15 +513,17 @@ #define SBP_MSG_POS_LLH_ACC_ENCODED_LEN 67u #define SBP_MSG_BASELINE_ECEF 0x020B -#define SBP_BASELINE_ECEF_FIX_MODE_MASK (0x7) +#define SBP_BASELINE_ECEF_FIX_MODE_MASK (0x7u) #define SBP_BASELINE_ECEF_FIX_MODE_SHIFT (0u) -#define SBP_BASELINE_ECEF_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_BASELINE_ECEF_FIX_MODE_SHIFT) & \ +#define SBP_BASELINE_ECEF_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_BASELINE_ECEF_FIX_MODE_SHIFT) & \ SBP_BASELINE_ECEF_FIX_MODE_MASK)) -#define SBP_BASELINE_ECEF_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_BASELINE_ECEF_FIX_MODE_MASK)) \ - << (SBP_BASELINE_ECEF_FIX_MODE_SHIFT))); \ +#define SBP_BASELINE_ECEF_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_BASELINE_ECEF_FIX_MODE_MASK \ + << SBP_BASELINE_ECEF_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_BASELINE_ECEF_FIX_MODE_MASK)) \ + << (SBP_BASELINE_ECEF_FIX_MODE_SHIFT))); \ } while (0) #define SBP_BASELINE_ECEF_FIX_MODE_INVALID (0) @@ -485,15 +537,17 @@ #define SBP_MSG_BASELINE_ECEF_ENCODED_LEN 20u #define SBP_MSG_BASELINE_NED 0x020C -#define SBP_BASELINE_NED_FIX_MODE_MASK (0x7) +#define SBP_BASELINE_NED_FIX_MODE_MASK (0x7u) #define SBP_BASELINE_NED_FIX_MODE_SHIFT (0u) -#define SBP_BASELINE_NED_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_BASELINE_NED_FIX_MODE_SHIFT) & \ +#define SBP_BASELINE_NED_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_BASELINE_NED_FIX_MODE_SHIFT) & \ SBP_BASELINE_NED_FIX_MODE_MASK)) -#define SBP_BASELINE_NED_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_BASELINE_NED_FIX_MODE_MASK)) \ - << (SBP_BASELINE_NED_FIX_MODE_SHIFT))); \ +#define SBP_BASELINE_NED_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_BASELINE_NED_FIX_MODE_MASK \ + << SBP_BASELINE_NED_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_BASELINE_NED_FIX_MODE_MASK)) \ + << (SBP_BASELINE_NED_FIX_MODE_SHIFT))); \ } while (0) #define SBP_BASELINE_NED_FIX_MODE_INVALID (0) @@ -507,43 +561,47 @@ #define SBP_MSG_BASELINE_NED_ENCODED_LEN 22u #define SBP_MSG_VEL_ECEF 0x020D -#define SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_MASK (0x1) +#define SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_MASK (0x1u) #define SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_SHIFT (5u) -#define SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_SHIFT) & \ +#define SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_SHIFT) & \ SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_MASK)) -#define SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_MASK)) \ - << (SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_SHIFT))); \ +#define SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_MASK \ + << SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_SHIFT))) | \ + (((val) & (SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_MASK)) \ + << (SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_SHIFT))); \ } while (0) #define SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_TIME_OF_MEASUREMENT (0) #define SBP_VEL_ECEF_TYPE_OF_REPORTED_TOW_OTHER (1) -#define SBP_VEL_ECEF_INS_NAVIGATION_MODE_MASK (0x3) +#define SBP_VEL_ECEF_INS_NAVIGATION_MODE_MASK (0x3u) #define SBP_VEL_ECEF_INS_NAVIGATION_MODE_SHIFT (3u) -#define SBP_VEL_ECEF_INS_NAVIGATION_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_ECEF_INS_NAVIGATION_MODE_SHIFT) & \ +#define SBP_VEL_ECEF_INS_NAVIGATION_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_ECEF_INS_NAVIGATION_MODE_SHIFT) & \ SBP_VEL_ECEF_INS_NAVIGATION_MODE_MASK)) -#define SBP_VEL_ECEF_INS_NAVIGATION_MODE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_VEL_ECEF_INS_NAVIGATION_MODE_MASK)) \ - << (SBP_VEL_ECEF_INS_NAVIGATION_MODE_SHIFT))); \ +#define SBP_VEL_ECEF_INS_NAVIGATION_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_VEL_ECEF_INS_NAVIGATION_MODE_MASK \ + << SBP_VEL_ECEF_INS_NAVIGATION_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_ECEF_INS_NAVIGATION_MODE_MASK)) \ + << (SBP_VEL_ECEF_INS_NAVIGATION_MODE_SHIFT))); \ } while (0) #define SBP_VEL_ECEF_INS_NAVIGATION_MODE_NONE (0) #define SBP_VEL_ECEF_INS_NAVIGATION_MODE_INS_USED (1) -#define SBP_VEL_ECEF_VELOCITY_MODE_MASK (0x7) +#define SBP_VEL_ECEF_VELOCITY_MODE_MASK (0x7u) #define SBP_VEL_ECEF_VELOCITY_MODE_SHIFT (0u) -#define SBP_VEL_ECEF_VELOCITY_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_ECEF_VELOCITY_MODE_SHIFT) & \ +#define SBP_VEL_ECEF_VELOCITY_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_ECEF_VELOCITY_MODE_SHIFT) & \ SBP_VEL_ECEF_VELOCITY_MODE_MASK)) -#define SBP_VEL_ECEF_VELOCITY_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_VEL_ECEF_VELOCITY_MODE_MASK)) \ - << (SBP_VEL_ECEF_VELOCITY_MODE_SHIFT))); \ +#define SBP_VEL_ECEF_VELOCITY_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_VEL_ECEF_VELOCITY_MODE_MASK \ + << SBP_VEL_ECEF_VELOCITY_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_ECEF_VELOCITY_MODE_MASK)) \ + << (SBP_VEL_ECEF_VELOCITY_MODE_SHIFT))); \ } while (0) #define SBP_VEL_ECEF_VELOCITY_MODE_INVALID (0) @@ -557,43 +615,49 @@ #define SBP_MSG_VEL_ECEF_ENCODED_LEN 20u #define SBP_MSG_VEL_ECEF_COV 0x0215 -#define SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_MASK (0x1) +#define SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_MASK (0x1u) #define SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_SHIFT (5u) -#define SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_SHIFT) & \ +#define SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_SHIFT) & \ SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_MASK)) -#define SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_MASK)) \ - << (SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_SHIFT))); \ +#define SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_MASK \ + << SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_SHIFT))) | \ + (((val) & (SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_MASK)) \ + << (SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_SHIFT))); \ } while (0) #define SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_TIME_OF_MEASUREMENT (0) #define SBP_VEL_ECEF_COV_TYPE_OF_REPORTED_TOW_OTHER (1) -#define SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_MASK (0x3) +#define SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_MASK (0x3u) #define SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_SHIFT (3u) -#define SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_SHIFT) & \ +#define SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_SHIFT) & \ SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_MASK)) -#define SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_MASK)) \ - << (SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_SHIFT))); \ +#define SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_MASK \ + << SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_MASK)) \ + << (SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_SHIFT))); \ } while (0) #define SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_NONE (0) #define SBP_VEL_ECEF_COV_INS_NAVIGATION_MODE_INS_USED (1) -#define SBP_VEL_ECEF_COV_VELOCITY_MODE_MASK (0x7) +#define SBP_VEL_ECEF_COV_VELOCITY_MODE_MASK (0x7u) #define SBP_VEL_ECEF_COV_VELOCITY_MODE_SHIFT (0u) -#define SBP_VEL_ECEF_COV_VELOCITY_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_ECEF_COV_VELOCITY_MODE_SHIFT) & \ +#define SBP_VEL_ECEF_COV_VELOCITY_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_ECEF_COV_VELOCITY_MODE_SHIFT) & \ SBP_VEL_ECEF_COV_VELOCITY_MODE_MASK)) -#define SBP_VEL_ECEF_COV_VELOCITY_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_VEL_ECEF_COV_VELOCITY_MODE_MASK)) \ - << (SBP_VEL_ECEF_COV_VELOCITY_MODE_SHIFT))); \ +#define SBP_VEL_ECEF_COV_VELOCITY_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_VEL_ECEF_COV_VELOCITY_MODE_MASK \ + << SBP_VEL_ECEF_COV_VELOCITY_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_ECEF_COV_VELOCITY_MODE_MASK)) \ + << (SBP_VEL_ECEF_COV_VELOCITY_MODE_SHIFT))); \ } while (0) #define SBP_VEL_ECEF_COV_VELOCITY_MODE_INVALID (0) @@ -607,42 +671,47 @@ #define SBP_MSG_VEL_ECEF_COV_ENCODED_LEN 42u #define SBP_MSG_VEL_NED 0x020E -#define SBP_VEL_NED_TYPE_OF_REPORTED_TOW_MASK (0x1) +#define SBP_VEL_NED_TYPE_OF_REPORTED_TOW_MASK (0x1u) #define SBP_VEL_NED_TYPE_OF_REPORTED_TOW_SHIFT (5u) -#define SBP_VEL_NED_TYPE_OF_REPORTED_TOW_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_NED_TYPE_OF_REPORTED_TOW_SHIFT) & \ +#define SBP_VEL_NED_TYPE_OF_REPORTED_TOW_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_NED_TYPE_OF_REPORTED_TOW_SHIFT) & \ SBP_VEL_NED_TYPE_OF_REPORTED_TOW_MASK)) -#define SBP_VEL_NED_TYPE_OF_REPORTED_TOW_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_VEL_NED_TYPE_OF_REPORTED_TOW_MASK)) \ - << (SBP_VEL_NED_TYPE_OF_REPORTED_TOW_SHIFT))); \ +#define SBP_VEL_NED_TYPE_OF_REPORTED_TOW_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_VEL_NED_TYPE_OF_REPORTED_TOW_MASK \ + << SBP_VEL_NED_TYPE_OF_REPORTED_TOW_SHIFT))) | \ + (((val) & (SBP_VEL_NED_TYPE_OF_REPORTED_TOW_MASK)) \ + << (SBP_VEL_NED_TYPE_OF_REPORTED_TOW_SHIFT))); \ } while (0) #define SBP_VEL_NED_TYPE_OF_REPORTED_TOW_TIME_OF_MEASUREMENT (0) #define SBP_VEL_NED_TYPE_OF_REPORTED_TOW_OTHER (1) -#define SBP_VEL_NED_INS_NAVIGATION_MODE_MASK (0x3) +#define SBP_VEL_NED_INS_NAVIGATION_MODE_MASK (0x3u) #define SBP_VEL_NED_INS_NAVIGATION_MODE_SHIFT (3u) -#define SBP_VEL_NED_INS_NAVIGATION_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_NED_INS_NAVIGATION_MODE_SHIFT) & \ +#define SBP_VEL_NED_INS_NAVIGATION_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_NED_INS_NAVIGATION_MODE_SHIFT) & \ SBP_VEL_NED_INS_NAVIGATION_MODE_MASK)) -#define SBP_VEL_NED_INS_NAVIGATION_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_VEL_NED_INS_NAVIGATION_MODE_MASK)) \ - << (SBP_VEL_NED_INS_NAVIGATION_MODE_SHIFT))); \ +#define SBP_VEL_NED_INS_NAVIGATION_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_VEL_NED_INS_NAVIGATION_MODE_MASK \ + << SBP_VEL_NED_INS_NAVIGATION_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_NED_INS_NAVIGATION_MODE_MASK)) \ + << (SBP_VEL_NED_INS_NAVIGATION_MODE_SHIFT))); \ } while (0) #define SBP_VEL_NED_INS_NAVIGATION_MODE_NONE (0) #define SBP_VEL_NED_INS_NAVIGATION_MODE_INS_USED (1) -#define SBP_VEL_NED_VELOCITY_MODE_MASK (0x7) +#define SBP_VEL_NED_VELOCITY_MODE_MASK (0x7u) #define SBP_VEL_NED_VELOCITY_MODE_SHIFT (0u) -#define SBP_VEL_NED_VELOCITY_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_NED_VELOCITY_MODE_SHIFT) & \ +#define SBP_VEL_NED_VELOCITY_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_NED_VELOCITY_MODE_SHIFT) & \ SBP_VEL_NED_VELOCITY_MODE_MASK)) -#define SBP_VEL_NED_VELOCITY_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_VEL_NED_VELOCITY_MODE_MASK)) \ - << (SBP_VEL_NED_VELOCITY_MODE_SHIFT))); \ +#define SBP_VEL_NED_VELOCITY_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_VEL_NED_VELOCITY_MODE_MASK \ + << SBP_VEL_NED_VELOCITY_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_NED_VELOCITY_MODE_MASK)) \ + << (SBP_VEL_NED_VELOCITY_MODE_SHIFT))); \ } while (0) #define SBP_VEL_NED_VELOCITY_MODE_INVALID (0) @@ -656,43 +725,49 @@ #define SBP_MSG_VEL_NED_ENCODED_LEN 22u #define SBP_MSG_VEL_NED_COV 0x0212 -#define SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_MASK (0x1) +#define SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_MASK (0x1u) #define SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_SHIFT (5u) -#define SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_SHIFT) & \ +#define SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_SHIFT) & \ SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_MASK)) -#define SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_MASK)) \ - << (SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_SHIFT))); \ +#define SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_MASK \ + << SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_SHIFT))) | \ + (((val) & (SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_MASK)) \ + << (SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_SHIFT))); \ } while (0) #define SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_TIME_OF_MEASUREMENT (0) #define SBP_VEL_NED_COV_TYPE_OF_REPORTED_TOW_OTHER (1) -#define SBP_VEL_NED_COV_INS_NAVIGATION_MODE_MASK (0x3) +#define SBP_VEL_NED_COV_INS_NAVIGATION_MODE_MASK (0x3u) #define SBP_VEL_NED_COV_INS_NAVIGATION_MODE_SHIFT (3u) -#define SBP_VEL_NED_COV_INS_NAVIGATION_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_NED_COV_INS_NAVIGATION_MODE_SHIFT) & \ +#define SBP_VEL_NED_COV_INS_NAVIGATION_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_NED_COV_INS_NAVIGATION_MODE_SHIFT) & \ SBP_VEL_NED_COV_INS_NAVIGATION_MODE_MASK)) -#define SBP_VEL_NED_COV_INS_NAVIGATION_MODE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_VEL_NED_COV_INS_NAVIGATION_MODE_MASK)) \ - << (SBP_VEL_NED_COV_INS_NAVIGATION_MODE_SHIFT))); \ +#define SBP_VEL_NED_COV_INS_NAVIGATION_MODE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_VEL_NED_COV_INS_NAVIGATION_MODE_MASK \ + << SBP_VEL_NED_COV_INS_NAVIGATION_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_NED_COV_INS_NAVIGATION_MODE_MASK)) \ + << (SBP_VEL_NED_COV_INS_NAVIGATION_MODE_SHIFT))); \ } while (0) #define SBP_VEL_NED_COV_INS_NAVIGATION_MODE_NONE (0) #define SBP_VEL_NED_COV_INS_NAVIGATION_MODE_INS_USED (1) -#define SBP_VEL_NED_COV_VELOCITY_MODE_MASK (0x7) +#define SBP_VEL_NED_COV_VELOCITY_MODE_MASK (0x7u) #define SBP_VEL_NED_COV_VELOCITY_MODE_SHIFT (0u) -#define SBP_VEL_NED_COV_VELOCITY_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_NED_COV_VELOCITY_MODE_SHIFT) & \ +#define SBP_VEL_NED_COV_VELOCITY_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_NED_COV_VELOCITY_MODE_SHIFT) & \ SBP_VEL_NED_COV_VELOCITY_MODE_MASK)) -#define SBP_VEL_NED_COV_VELOCITY_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_VEL_NED_COV_VELOCITY_MODE_MASK)) \ - << (SBP_VEL_NED_COV_VELOCITY_MODE_SHIFT))); \ +#define SBP_VEL_NED_COV_VELOCITY_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_VEL_NED_COV_VELOCITY_MODE_MASK \ + << SBP_VEL_NED_COV_VELOCITY_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_NED_COV_VELOCITY_MODE_MASK)) \ + << (SBP_VEL_NED_COV_VELOCITY_MODE_SHIFT))); \ } while (0) #define SBP_VEL_NED_COV_VELOCITY_MODE_INVALID (0) @@ -706,15 +781,17 @@ #define SBP_MSG_VEL_NED_COV_ENCODED_LEN 42u #define SBP_MSG_POS_ECEF_GNSS 0x0229 -#define SBP_POS_ECEF_GNSS_FIX_MODE_MASK (0x7) +#define SBP_POS_ECEF_GNSS_FIX_MODE_MASK (0x7u) #define SBP_POS_ECEF_GNSS_FIX_MODE_SHIFT (0u) -#define SBP_POS_ECEF_GNSS_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_ECEF_GNSS_FIX_MODE_SHIFT) & \ +#define SBP_POS_ECEF_GNSS_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_ECEF_GNSS_FIX_MODE_SHIFT) & \ SBP_POS_ECEF_GNSS_FIX_MODE_MASK)) -#define SBP_POS_ECEF_GNSS_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_POS_ECEF_GNSS_FIX_MODE_MASK)) \ - << (SBP_POS_ECEF_GNSS_FIX_MODE_SHIFT))); \ +#define SBP_POS_ECEF_GNSS_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_ECEF_GNSS_FIX_MODE_MASK \ + << SBP_POS_ECEF_GNSS_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_POS_ECEF_GNSS_FIX_MODE_MASK)) \ + << (SBP_POS_ECEF_GNSS_FIX_MODE_SHIFT))); \ } while (0) #define SBP_POS_ECEF_GNSS_FIX_MODE_INVALID (0) @@ -730,15 +807,17 @@ #define SBP_MSG_POS_ECEF_GNSS_ENCODED_LEN 32u #define SBP_MSG_POS_ECEF_COV_GNSS 0x0234 -#define SBP_POS_ECEF_COV_GNSS_FIX_MODE_MASK (0x7) +#define SBP_POS_ECEF_COV_GNSS_FIX_MODE_MASK (0x7u) #define SBP_POS_ECEF_COV_GNSS_FIX_MODE_SHIFT (0u) -#define SBP_POS_ECEF_COV_GNSS_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_ECEF_COV_GNSS_FIX_MODE_SHIFT) & \ +#define SBP_POS_ECEF_COV_GNSS_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_ECEF_COV_GNSS_FIX_MODE_SHIFT) & \ SBP_POS_ECEF_COV_GNSS_FIX_MODE_MASK)) -#define SBP_POS_ECEF_COV_GNSS_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_POS_ECEF_COV_GNSS_FIX_MODE_MASK)) \ - << (SBP_POS_ECEF_COV_GNSS_FIX_MODE_SHIFT))); \ +#define SBP_POS_ECEF_COV_GNSS_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_ECEF_COV_GNSS_FIX_MODE_MASK \ + << SBP_POS_ECEF_COV_GNSS_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_POS_ECEF_COV_GNSS_FIX_MODE_MASK)) \ + << (SBP_POS_ECEF_COV_GNSS_FIX_MODE_SHIFT))); \ } while (0) #define SBP_POS_ECEF_COV_GNSS_FIX_MODE_INVALID (0) @@ -754,15 +833,17 @@ #define SBP_MSG_POS_ECEF_COV_GNSS_ENCODED_LEN 54u #define SBP_MSG_POS_LLH_GNSS 0x022A -#define SBP_POS_LLH_GNSS_FIX_MODE_MASK (0x7) +#define SBP_POS_LLH_GNSS_FIX_MODE_MASK (0x7u) #define SBP_POS_LLH_GNSS_FIX_MODE_SHIFT (0u) -#define SBP_POS_LLH_GNSS_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_GNSS_FIX_MODE_SHIFT) & \ +#define SBP_POS_LLH_GNSS_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_GNSS_FIX_MODE_SHIFT) & \ SBP_POS_LLH_GNSS_FIX_MODE_MASK)) -#define SBP_POS_LLH_GNSS_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_POS_LLH_GNSS_FIX_MODE_MASK)) \ - << (SBP_POS_LLH_GNSS_FIX_MODE_SHIFT))); \ +#define SBP_POS_LLH_GNSS_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_LLH_GNSS_FIX_MODE_MASK \ + << SBP_POS_LLH_GNSS_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_POS_LLH_GNSS_FIX_MODE_MASK)) \ + << (SBP_POS_LLH_GNSS_FIX_MODE_SHIFT))); \ } while (0) #define SBP_POS_LLH_GNSS_FIX_MODE_INVALID (0) @@ -778,15 +859,17 @@ #define SBP_MSG_POS_LLH_GNSS_ENCODED_LEN 34u #define SBP_MSG_POS_LLH_COV_GNSS 0x0231 -#define SBP_POS_LLH_COV_GNSS_FIX_MODE_MASK (0x7) +#define SBP_POS_LLH_COV_GNSS_FIX_MODE_MASK (0x7u) #define SBP_POS_LLH_COV_GNSS_FIX_MODE_SHIFT (0u) -#define SBP_POS_LLH_COV_GNSS_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_COV_GNSS_FIX_MODE_SHIFT) & \ +#define SBP_POS_LLH_COV_GNSS_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_COV_GNSS_FIX_MODE_SHIFT) & \ SBP_POS_LLH_COV_GNSS_FIX_MODE_MASK)) -#define SBP_POS_LLH_COV_GNSS_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_POS_LLH_COV_GNSS_FIX_MODE_MASK)) \ - << (SBP_POS_LLH_COV_GNSS_FIX_MODE_SHIFT))); \ +#define SBP_POS_LLH_COV_GNSS_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_LLH_COV_GNSS_FIX_MODE_MASK \ + << SBP_POS_LLH_COV_GNSS_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_POS_LLH_COV_GNSS_FIX_MODE_MASK)) \ + << (SBP_POS_LLH_COV_GNSS_FIX_MODE_SHIFT))); \ } while (0) #define SBP_POS_LLH_COV_GNSS_FIX_MODE_INVALID (0) @@ -803,15 +886,17 @@ #define SBP_MSG_POS_LLH_COV_GNSS_ENCODED_LEN 54u #define SBP_MSG_VEL_ECEF_GNSS 0x022D -#define SBP_VEL_ECEF_GNSS_VELOCITY_MODE_MASK (0x7) +#define SBP_VEL_ECEF_GNSS_VELOCITY_MODE_MASK (0x7u) #define SBP_VEL_ECEF_GNSS_VELOCITY_MODE_SHIFT (0u) -#define SBP_VEL_ECEF_GNSS_VELOCITY_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_ECEF_GNSS_VELOCITY_MODE_SHIFT) & \ +#define SBP_VEL_ECEF_GNSS_VELOCITY_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_ECEF_GNSS_VELOCITY_MODE_SHIFT) & \ SBP_VEL_ECEF_GNSS_VELOCITY_MODE_MASK)) -#define SBP_VEL_ECEF_GNSS_VELOCITY_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_VEL_ECEF_GNSS_VELOCITY_MODE_MASK)) \ - << (SBP_VEL_ECEF_GNSS_VELOCITY_MODE_SHIFT))); \ +#define SBP_VEL_ECEF_GNSS_VELOCITY_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_VEL_ECEF_GNSS_VELOCITY_MODE_MASK \ + << SBP_VEL_ECEF_GNSS_VELOCITY_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_ECEF_GNSS_VELOCITY_MODE_MASK)) \ + << (SBP_VEL_ECEF_GNSS_VELOCITY_MODE_SHIFT))); \ } while (0) #define SBP_VEL_ECEF_GNSS_VELOCITY_MODE_INVALID (0) @@ -824,16 +909,18 @@ #define SBP_MSG_VEL_ECEF_GNSS_ENCODED_LEN 20u #define SBP_MSG_VEL_ECEF_COV_GNSS 0x0235 -#define SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_MASK (0x7) +#define SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_MASK (0x7u) #define SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_SHIFT (0u) -#define SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_SHIFT) & \ +#define SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_SHIFT) & \ SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_MASK)) -#define SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_MASK)) \ - << (SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_SHIFT))); \ +#define SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_MASK \ + << SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_MASK)) \ + << (SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_SHIFT))); \ } while (0) #define SBP_VEL_ECEF_COV_GNSS_VELOCITY_MODE_INVALID (0) @@ -846,15 +933,17 @@ #define SBP_MSG_VEL_ECEF_COV_GNSS_ENCODED_LEN 42u #define SBP_MSG_VEL_NED_GNSS 0x022E -#define SBP_VEL_NED_GNSS_VELOCITY_MODE_MASK (0x7) +#define SBP_VEL_NED_GNSS_VELOCITY_MODE_MASK (0x7u) #define SBP_VEL_NED_GNSS_VELOCITY_MODE_SHIFT (0u) -#define SBP_VEL_NED_GNSS_VELOCITY_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_NED_GNSS_VELOCITY_MODE_SHIFT) & \ +#define SBP_VEL_NED_GNSS_VELOCITY_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_NED_GNSS_VELOCITY_MODE_SHIFT) & \ SBP_VEL_NED_GNSS_VELOCITY_MODE_MASK)) -#define SBP_VEL_NED_GNSS_VELOCITY_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_VEL_NED_GNSS_VELOCITY_MODE_MASK)) \ - << (SBP_VEL_NED_GNSS_VELOCITY_MODE_SHIFT))); \ +#define SBP_VEL_NED_GNSS_VELOCITY_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_VEL_NED_GNSS_VELOCITY_MODE_MASK \ + << SBP_VEL_NED_GNSS_VELOCITY_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_NED_GNSS_VELOCITY_MODE_MASK)) \ + << (SBP_VEL_NED_GNSS_VELOCITY_MODE_SHIFT))); \ } while (0) #define SBP_VEL_NED_GNSS_VELOCITY_MODE_INVALID (0) @@ -867,16 +956,18 @@ #define SBP_MSG_VEL_NED_GNSS_ENCODED_LEN 22u #define SBP_MSG_VEL_NED_COV_GNSS 0x0232 -#define SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_MASK (0x7) +#define SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_MASK (0x7u) #define SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_SHIFT (0u) -#define SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_SHIFT) & \ +#define SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_SHIFT) & \ SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_MASK)) -#define SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_MASK)) \ - << (SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_SHIFT))); \ +#define SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_MASK \ + << SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_MASK)) \ + << (SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_SHIFT))); \ } while (0) #define SBP_VEL_NED_COV_GNSS_VELOCITY_MODE_INVALID (0) @@ -889,29 +980,32 @@ #define SBP_MSG_VEL_NED_COV_GNSS_ENCODED_LEN 42u #define SBP_MSG_VEL_BODY 0x0213 -#define SBP_VEL_BODY_INS_NAVIGATION_MODE_MASK (0x3) +#define SBP_VEL_BODY_INS_NAVIGATION_MODE_MASK (0x3u) #define SBP_VEL_BODY_INS_NAVIGATION_MODE_SHIFT (3u) -#define SBP_VEL_BODY_INS_NAVIGATION_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_BODY_INS_NAVIGATION_MODE_SHIFT) & \ +#define SBP_VEL_BODY_INS_NAVIGATION_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_BODY_INS_NAVIGATION_MODE_SHIFT) & \ SBP_VEL_BODY_INS_NAVIGATION_MODE_MASK)) -#define SBP_VEL_BODY_INS_NAVIGATION_MODE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_VEL_BODY_INS_NAVIGATION_MODE_MASK)) \ - << (SBP_VEL_BODY_INS_NAVIGATION_MODE_SHIFT))); \ +#define SBP_VEL_BODY_INS_NAVIGATION_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_VEL_BODY_INS_NAVIGATION_MODE_MASK \ + << SBP_VEL_BODY_INS_NAVIGATION_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_BODY_INS_NAVIGATION_MODE_MASK)) \ + << (SBP_VEL_BODY_INS_NAVIGATION_MODE_SHIFT))); \ } while (0) #define SBP_VEL_BODY_INS_NAVIGATION_MODE_NONE (0) #define SBP_VEL_BODY_INS_NAVIGATION_MODE_INS_USED (1) -#define SBP_VEL_BODY_VELOCITY_MODE_MASK (0x7) +#define SBP_VEL_BODY_VELOCITY_MODE_MASK (0x7u) #define SBP_VEL_BODY_VELOCITY_MODE_SHIFT (0u) -#define SBP_VEL_BODY_VELOCITY_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_VEL_BODY_VELOCITY_MODE_SHIFT) & \ +#define SBP_VEL_BODY_VELOCITY_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_VEL_BODY_VELOCITY_MODE_SHIFT) & \ SBP_VEL_BODY_VELOCITY_MODE_MASK)) -#define SBP_VEL_BODY_VELOCITY_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_VEL_BODY_VELOCITY_MODE_MASK)) \ - << (SBP_VEL_BODY_VELOCITY_MODE_SHIFT))); \ +#define SBP_VEL_BODY_VELOCITY_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_VEL_BODY_VELOCITY_MODE_MASK \ + << SBP_VEL_BODY_VELOCITY_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_BODY_VELOCITY_MODE_MASK)) \ + << (SBP_VEL_BODY_VELOCITY_MODE_SHIFT))); \ } while (0) #define SBP_VEL_BODY_VELOCITY_MODE_INVALID (0) @@ -925,96 +1019,108 @@ #define SBP_MSG_VEL_BODY_ENCODED_LEN 42u #define SBP_MSG_VEL_COG 0x021C -#define SBP_VEL_COG_COG_FROZEN_MASK (0x1) +#define SBP_VEL_COG_COG_FROZEN_MASK (0x1u) #define SBP_VEL_COG_COG_FROZEN_SHIFT (9u) -#define SBP_VEL_COG_COG_FROZEN_GET(flags) \ - ((u16)(((flags) >> SBP_VEL_COG_COG_FROZEN_SHIFT) & \ +#define SBP_VEL_COG_COG_FROZEN_GET(flags) \ + ((u16)((u16)((flags) >> SBP_VEL_COG_COG_FROZEN_SHIFT) & \ SBP_VEL_COG_COG_FROZEN_MASK)) -#define SBP_VEL_COG_COG_FROZEN_SET(flags, val) \ - do { \ - (flags) = (u16)((flags) | (((val) & (SBP_VEL_COG_COG_FROZEN_MASK)) \ - << (SBP_VEL_COG_COG_FROZEN_SHIFT))); \ +#define SBP_VEL_COG_COG_FROZEN_SET(flags, val) \ + do { \ + (flags) = (u16)((flags & (~(SBP_VEL_COG_COG_FROZEN_MASK \ + << SBP_VEL_COG_COG_FROZEN_SHIFT))) | \ + (((val) & (SBP_VEL_COG_COG_FROZEN_MASK)) \ + << (SBP_VEL_COG_COG_FROZEN_SHIFT))); \ } while (0) #define SBP_VEL_COG_COG_FROZEN_NOT_FROZEN (0) #define SBP_VEL_COG_COG_FROZEN_FROZEN (1) -#define SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_MASK (0x1) +#define SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_MASK (0x1u) #define SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_SHIFT (8u) -#define SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_GET(flags) \ - ((u16)(((flags) >> SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_SHIFT) & \ +#define SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_GET(flags) \ + ((u16)((u16)((flags) >> SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_SHIFT) & \ SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_MASK)) -#define SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_SET(flags, val) \ - do { \ - (flags) = (u16)((flags) | \ - (((val) & (SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_MASK)) \ - << (SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_SHIFT))); \ +#define SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_SET(flags, val) \ + do { \ + (flags) = \ + (u16)((flags & (~(SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_MASK \ + << SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_SHIFT))) | \ + (((val) & (SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_MASK)) \ + << (SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_SHIFT))); \ } while (0) #define SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_INVALID (0) #define SBP_VEL_COG_VERTICAL_VELOCITY_VALIDITY_VERTICAL_VELOCITY_VALID (1) -#define SBP_VEL_COG_SOG_VALIDITY_MASK (0x1) +#define SBP_VEL_COG_SOG_VALIDITY_MASK (0x1u) #define SBP_VEL_COG_SOG_VALIDITY_SHIFT (7u) -#define SBP_VEL_COG_SOG_VALIDITY_GET(flags) \ - ((u16)(((flags) >> SBP_VEL_COG_SOG_VALIDITY_SHIFT) & \ +#define SBP_VEL_COG_SOG_VALIDITY_GET(flags) \ + ((u16)((u16)((flags) >> SBP_VEL_COG_SOG_VALIDITY_SHIFT) & \ SBP_VEL_COG_SOG_VALIDITY_MASK)) -#define SBP_VEL_COG_SOG_VALIDITY_SET(flags, val) \ - do { \ - (flags) = (u16)((flags) | (((val) & (SBP_VEL_COG_SOG_VALIDITY_MASK)) \ - << (SBP_VEL_COG_SOG_VALIDITY_SHIFT))); \ +#define SBP_VEL_COG_SOG_VALIDITY_SET(flags, val) \ + do { \ + (flags) = (u16)((flags & (~(SBP_VEL_COG_SOG_VALIDITY_MASK \ + << SBP_VEL_COG_SOG_VALIDITY_SHIFT))) | \ + (((val) & (SBP_VEL_COG_SOG_VALIDITY_MASK)) \ + << (SBP_VEL_COG_SOG_VALIDITY_SHIFT))); \ } while (0) #define SBP_VEL_COG_SOG_VALIDITY_INVALID (0) #define SBP_VEL_COG_SOG_VALIDITY_SOG_VALID (1) -#define SBP_VEL_COG_COG_VALIDITY_MASK (0x1) +#define SBP_VEL_COG_COG_VALIDITY_MASK (0x1u) #define SBP_VEL_COG_COG_VALIDITY_SHIFT (6u) -#define SBP_VEL_COG_COG_VALIDITY_GET(flags) \ - ((u16)(((flags) >> SBP_VEL_COG_COG_VALIDITY_SHIFT) & \ +#define SBP_VEL_COG_COG_VALIDITY_GET(flags) \ + ((u16)((u16)((flags) >> SBP_VEL_COG_COG_VALIDITY_SHIFT) & \ SBP_VEL_COG_COG_VALIDITY_MASK)) -#define SBP_VEL_COG_COG_VALIDITY_SET(flags, val) \ - do { \ - (flags) = (u16)((flags) | (((val) & (SBP_VEL_COG_COG_VALIDITY_MASK)) \ - << (SBP_VEL_COG_COG_VALIDITY_SHIFT))); \ +#define SBP_VEL_COG_COG_VALIDITY_SET(flags, val) \ + do { \ + (flags) = (u16)((flags & (~(SBP_VEL_COG_COG_VALIDITY_MASK \ + << SBP_VEL_COG_COG_VALIDITY_SHIFT))) | \ + (((val) & (SBP_VEL_COG_COG_VALIDITY_MASK)) \ + << (SBP_VEL_COG_COG_VALIDITY_SHIFT))); \ } while (0) #define SBP_VEL_COG_COG_VALIDITY_INVALID (0) #define SBP_VEL_COG_COG_VALIDITY_COG_VALID (1) -#define SBP_VEL_COG_TYPE_OF_REPORTED_TOW_MASK (0x1) +#define SBP_VEL_COG_TYPE_OF_REPORTED_TOW_MASK (0x1u) #define SBP_VEL_COG_TYPE_OF_REPORTED_TOW_SHIFT (5u) -#define SBP_VEL_COG_TYPE_OF_REPORTED_TOW_GET(flags) \ - ((u16)(((flags) >> SBP_VEL_COG_TYPE_OF_REPORTED_TOW_SHIFT) & \ +#define SBP_VEL_COG_TYPE_OF_REPORTED_TOW_GET(flags) \ + ((u16)((u16)((flags) >> SBP_VEL_COG_TYPE_OF_REPORTED_TOW_SHIFT) & \ SBP_VEL_COG_TYPE_OF_REPORTED_TOW_MASK)) -#define SBP_VEL_COG_TYPE_OF_REPORTED_TOW_SET(flags, val) \ - do { \ - (flags) = \ - (u16)((flags) | (((val) & (SBP_VEL_COG_TYPE_OF_REPORTED_TOW_MASK)) \ - << (SBP_VEL_COG_TYPE_OF_REPORTED_TOW_SHIFT))); \ +#define SBP_VEL_COG_TYPE_OF_REPORTED_TOW_SET(flags, val) \ + do { \ + (flags) = (u16)((flags & (~(SBP_VEL_COG_TYPE_OF_REPORTED_TOW_MASK \ + << SBP_VEL_COG_TYPE_OF_REPORTED_TOW_SHIFT))) | \ + (((val) & (SBP_VEL_COG_TYPE_OF_REPORTED_TOW_MASK)) \ + << (SBP_VEL_COG_TYPE_OF_REPORTED_TOW_SHIFT))); \ } while (0) #define SBP_VEL_COG_TYPE_OF_REPORTED_TOW_TIME_OF_MEASUREMENT (0) #define SBP_VEL_COG_TYPE_OF_REPORTED_TOW_OTHER (1) -#define SBP_VEL_COG_INS_NAVIGATION_MODE_MASK (0x3) +#define SBP_VEL_COG_INS_NAVIGATION_MODE_MASK (0x3u) #define SBP_VEL_COG_INS_NAVIGATION_MODE_SHIFT (3u) -#define SBP_VEL_COG_INS_NAVIGATION_MODE_GET(flags) \ - ((u16)(((flags) >> SBP_VEL_COG_INS_NAVIGATION_MODE_SHIFT) & \ +#define SBP_VEL_COG_INS_NAVIGATION_MODE_GET(flags) \ + ((u16)((u16)((flags) >> SBP_VEL_COG_INS_NAVIGATION_MODE_SHIFT) & \ SBP_VEL_COG_INS_NAVIGATION_MODE_MASK)) -#define SBP_VEL_COG_INS_NAVIGATION_MODE_SET(flags, val) \ - do { \ - (flags) = \ - (u16)((flags) | (((val) & (SBP_VEL_COG_INS_NAVIGATION_MODE_MASK)) \ - << (SBP_VEL_COG_INS_NAVIGATION_MODE_SHIFT))); \ +#define SBP_VEL_COG_INS_NAVIGATION_MODE_SET(flags, val) \ + do { \ + (flags) = (u16)((flags & (~(SBP_VEL_COG_INS_NAVIGATION_MODE_MASK \ + << SBP_VEL_COG_INS_NAVIGATION_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_COG_INS_NAVIGATION_MODE_MASK)) \ + << (SBP_VEL_COG_INS_NAVIGATION_MODE_SHIFT))); \ } while (0) #define SBP_VEL_COG_INS_NAVIGATION_MODE_NONE (0) #define SBP_VEL_COG_INS_NAVIGATION_MODE_INS_USED (1) -#define SBP_VEL_COG_VELOCITY_MODE_MASK (0x7) +#define SBP_VEL_COG_VELOCITY_MODE_MASK (0x7u) #define SBP_VEL_COG_VELOCITY_MODE_SHIFT (0u) -#define SBP_VEL_COG_VELOCITY_MODE_GET(flags) \ - ((u16)(((flags) >> SBP_VEL_COG_VELOCITY_MODE_SHIFT) & \ +#define SBP_VEL_COG_VELOCITY_MODE_GET(flags) \ + ((u16)((u16)((flags) >> SBP_VEL_COG_VELOCITY_MODE_SHIFT) & \ SBP_VEL_COG_VELOCITY_MODE_MASK)) -#define SBP_VEL_COG_VELOCITY_MODE_SET(flags, val) \ - do { \ - (flags) = (u16)((flags) | (((val) & (SBP_VEL_COG_VELOCITY_MODE_MASK)) \ - << (SBP_VEL_COG_VELOCITY_MODE_SHIFT))); \ +#define SBP_VEL_COG_VELOCITY_MODE_SET(flags, val) \ + do { \ + (flags) = (u16)((flags & (~(SBP_VEL_COG_VELOCITY_MODE_MASK \ + << SBP_VEL_COG_VELOCITY_MODE_SHIFT))) | \ + (((val) & (SBP_VEL_COG_VELOCITY_MODE_MASK)) \ + << (SBP_VEL_COG_VELOCITY_MODE_SHIFT))); \ } while (0) #define SBP_VEL_COG_VELOCITY_MODE_INVALID (0) @@ -1049,44 +1155,50 @@ #define SBP_MSG_DOPS_DEP_A_ENCODED_LEN 14u #define SBP_MSG_POS_ECEF_DEP_A 0x0200 -#define SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_MASK (0x1) +#define SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_MASK (0x1u) #define SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_SHIFT (4u) -#define SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_GET(flags) \ - ((u8)(((flags) >> SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_SHIFT) & \ +#define SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_SHIFT) & \ SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_MASK)) -#define SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_MASK)) \ - << (SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_SHIFT))); \ +#define SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_MASK \ + << SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_SHIFT))) | \ + (((val) & (SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_MASK)) \ + << (SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_SHIFT))); \ } while (0) #define SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_NO_REPAIR (0) #define SBP_POS_ECEF_DEP_A_RAIM_REPAIR_FLAG_SOLUTION_CAME_FROM_RAIM_REPAIR (1) -#define SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_MASK (0x1) +#define SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_MASK (0x1u) #define SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT (3u) -#define SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_GET(flags) \ - ((u8)(((flags) >> SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT) & \ +#define SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT) & \ SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_MASK)) -#define SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_MASK)) \ - << (SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT))); \ +#define SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_MASK \ + << SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT))) | \ + (((val) & (SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_MASK)) \ + << (SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT))); \ } while (0) #define SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_RAIM_CHECK_WAS_EXPLICITLY_DISABLED_OR_UNAVAILABLE \ (0) #define SBP_POS_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_RAIM_CHECK_WAS_AVAILABLE (1) -#define SBP_POS_ECEF_DEP_A_FIX_MODE_MASK (0x7) +#define SBP_POS_ECEF_DEP_A_FIX_MODE_MASK (0x7u) #define SBP_POS_ECEF_DEP_A_FIX_MODE_SHIFT (0u) -#define SBP_POS_ECEF_DEP_A_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_ECEF_DEP_A_FIX_MODE_SHIFT) & \ +#define SBP_POS_ECEF_DEP_A_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_ECEF_DEP_A_FIX_MODE_SHIFT) & \ SBP_POS_ECEF_DEP_A_FIX_MODE_MASK)) -#define SBP_POS_ECEF_DEP_A_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_POS_ECEF_DEP_A_FIX_MODE_MASK)) \ - << (SBP_POS_ECEF_DEP_A_FIX_MODE_SHIFT))); \ +#define SBP_POS_ECEF_DEP_A_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_ECEF_DEP_A_FIX_MODE_MASK \ + << SBP_POS_ECEF_DEP_A_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_POS_ECEF_DEP_A_FIX_MODE_MASK)) \ + << (SBP_POS_ECEF_DEP_A_FIX_MODE_SHIFT))); \ } while (0) #define SBP_POS_ECEF_DEP_A_FIX_MODE_SINGLE_POINT_POSITIONING (0) @@ -1099,57 +1211,65 @@ #define SBP_MSG_POS_ECEF_DEP_A_ENCODED_LEN 32u #define SBP_MSG_POS_LLH_DEP_A 0x0201 -#define SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_MASK (0x1) +#define SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_MASK (0x1u) #define SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_SHIFT (5u) -#define SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_SHIFT) & \ +#define SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_SHIFT) & \ SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_MASK)) -#define SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_MASK)) \ - << (SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_SHIFT))); \ +#define SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_MASK \ + << SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_SHIFT))) | \ + (((val) & (SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_MASK)) \ + << (SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_SHIFT))); \ } while (0) #define SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_NO_REPAIR (0) #define SBP_POS_LLH_DEP_A_RAIM_REPAIR_FLAG_SOLUTION_CAME_FROM_RAIM_REPAIR (1) -#define SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_MASK (0x1) +#define SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_MASK (0x1u) #define SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT (4u) -#define SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT) & \ +#define SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT) & \ SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_MASK)) -#define SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_MASK)) \ - << (SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT))); \ +#define SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_MASK \ + << SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT))) | \ + (((val) & (SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_MASK)) \ + << (SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT))); \ } while (0) #define SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_RAIM_CHECK_WAS_EXPLICITLY_DISABLED_OR_UNAVAILABLE \ (0) #define SBP_POS_LLH_DEP_A_RAIM_AVAILABILITY_FLAG_RAIM_CHECK_WAS_AVAILABLE (1) -#define SBP_POS_LLH_DEP_A_HEIGHT_MODE_MASK (0x1) +#define SBP_POS_LLH_DEP_A_HEIGHT_MODE_MASK (0x1u) #define SBP_POS_LLH_DEP_A_HEIGHT_MODE_SHIFT (3u) -#define SBP_POS_LLH_DEP_A_HEIGHT_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_DEP_A_HEIGHT_MODE_SHIFT) & \ +#define SBP_POS_LLH_DEP_A_HEIGHT_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_DEP_A_HEIGHT_MODE_SHIFT) & \ SBP_POS_LLH_DEP_A_HEIGHT_MODE_MASK)) -#define SBP_POS_LLH_DEP_A_HEIGHT_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_POS_LLH_DEP_A_HEIGHT_MODE_MASK)) \ - << (SBP_POS_LLH_DEP_A_HEIGHT_MODE_SHIFT))); \ +#define SBP_POS_LLH_DEP_A_HEIGHT_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_LLH_DEP_A_HEIGHT_MODE_MASK \ + << SBP_POS_LLH_DEP_A_HEIGHT_MODE_SHIFT))) | \ + (((val) & (SBP_POS_LLH_DEP_A_HEIGHT_MODE_MASK)) \ + << (SBP_POS_LLH_DEP_A_HEIGHT_MODE_SHIFT))); \ } while (0) #define SBP_POS_LLH_DEP_A_HEIGHT_MODE_HEIGHT_ABOVE_WGS84_ELLIPSOID (0) #define SBP_POS_LLH_DEP_A_HEIGHT_MODE_HEIGHT_ABOVE_MEAN_SEA_LEVEL (1) -#define SBP_POS_LLH_DEP_A_FIX_MODE_MASK (0x7) +#define SBP_POS_LLH_DEP_A_FIX_MODE_MASK (0x7u) #define SBP_POS_LLH_DEP_A_FIX_MODE_SHIFT (0u) -#define SBP_POS_LLH_DEP_A_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_POS_LLH_DEP_A_FIX_MODE_SHIFT) & \ +#define SBP_POS_LLH_DEP_A_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_POS_LLH_DEP_A_FIX_MODE_SHIFT) & \ SBP_POS_LLH_DEP_A_FIX_MODE_MASK)) -#define SBP_POS_LLH_DEP_A_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_POS_LLH_DEP_A_FIX_MODE_MASK)) \ - << (SBP_POS_LLH_DEP_A_FIX_MODE_SHIFT))); \ +#define SBP_POS_LLH_DEP_A_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_POS_LLH_DEP_A_FIX_MODE_MASK \ + << SBP_POS_LLH_DEP_A_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_POS_LLH_DEP_A_FIX_MODE_MASK)) \ + << (SBP_POS_LLH_DEP_A_FIX_MODE_SHIFT))); \ } while (0) #define SBP_POS_LLH_DEP_A_FIX_MODE_SINGLE_POINT_POSITIONING (0) @@ -1162,30 +1282,35 @@ #define SBP_MSG_POS_LLH_DEP_A_ENCODED_LEN 34u #define SBP_MSG_BASELINE_ECEF_DEP_A 0x0202 -#define SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_MASK (0x1) +#define SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_MASK (0x1u) #define SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_SHIFT (4u) -#define SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_GET(flags) \ - ((u8)(((flags) >> SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_SHIFT) & \ +#define SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_GET(flags) \ + ((u8)((u8)((flags) >> SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_SHIFT) & \ SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_MASK)) -#define SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_MASK)) \ - << (SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_SHIFT))); \ +#define SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_MASK \ + << SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_SHIFT))) | \ + (((val) & (SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_MASK)) \ + << (SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_SHIFT))); \ } while (0) #define SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_NO_REPAIR (0) #define SBP_BASELINE_ECEF_DEP_A_RAIM_REPAIR_FLAG_SOLUTION_CAME_FROM_RAIM_REPAIR \ (1) -#define SBP_BASELINE_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_MASK (0x1) +#define SBP_BASELINE_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_MASK (0x1u) #define SBP_BASELINE_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT (3u) -#define SBP_BASELINE_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_GET(flags) \ - ((u8)(((flags) >> SBP_BASELINE_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT) & \ - SBP_BASELINE_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_MASK)) +#define SBP_BASELINE_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_GET(flags) \ + ((u8)( \ + (u8)((flags) >> SBP_BASELINE_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT) & \ + SBP_BASELINE_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_MASK)) #define SBP_BASELINE_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_SET(flags, val) \ do { \ (flags) = \ - (u8)((flags) | \ + (u8)((flags & \ + (~(SBP_BASELINE_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_MASK \ + << SBP_BASELINE_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT))) | \ (((val) & (SBP_BASELINE_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_MASK)) \ << (SBP_BASELINE_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT))); \ } while (0) @@ -1194,16 +1319,17 @@ (0) #define SBP_BASELINE_ECEF_DEP_A_RAIM_AVAILABILITY_FLAG_RAIM_CHECK_WAS_AVAILABLE \ (1) -#define SBP_BASELINE_ECEF_DEP_A_FIX_MODE_MASK (0x7) +#define SBP_BASELINE_ECEF_DEP_A_FIX_MODE_MASK (0x7u) #define SBP_BASELINE_ECEF_DEP_A_FIX_MODE_SHIFT (0u) -#define SBP_BASELINE_ECEF_DEP_A_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_BASELINE_ECEF_DEP_A_FIX_MODE_SHIFT) & \ +#define SBP_BASELINE_ECEF_DEP_A_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_BASELINE_ECEF_DEP_A_FIX_MODE_SHIFT) & \ SBP_BASELINE_ECEF_DEP_A_FIX_MODE_MASK)) -#define SBP_BASELINE_ECEF_DEP_A_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_BASELINE_ECEF_DEP_A_FIX_MODE_MASK)) \ - << (SBP_BASELINE_ECEF_DEP_A_FIX_MODE_SHIFT))); \ +#define SBP_BASELINE_ECEF_DEP_A_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_BASELINE_ECEF_DEP_A_FIX_MODE_MASK \ + << SBP_BASELINE_ECEF_DEP_A_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_BASELINE_ECEF_DEP_A_FIX_MODE_MASK)) \ + << (SBP_BASELINE_ECEF_DEP_A_FIX_MODE_SHIFT))); \ } while (0) #define SBP_BASELINE_ECEF_DEP_A_FIX_MODE_FLOAT_RTK (0) @@ -1215,30 +1341,34 @@ #define SBP_MSG_BASELINE_ECEF_DEP_A_ENCODED_LEN 20u #define SBP_MSG_BASELINE_NED_DEP_A 0x0203 -#define SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_MASK (0x1) +#define SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_MASK (0x1u) #define SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_SHIFT (4u) -#define SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_GET(flags) \ - ((u8)(((flags) >> SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_SHIFT) & \ +#define SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_GET(flags) \ + ((u8)((u8)((flags) >> SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_SHIFT) & \ SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_MASK)) -#define SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_MASK)) \ - << (SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_SHIFT))); \ +#define SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_MASK \ + << SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_SHIFT))) | \ + (((val) & (SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_MASK)) \ + << (SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_SHIFT))); \ } while (0) #define SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_NO_REPAIR (0) #define SBP_BASELINE_NED_DEP_A_RAIM_REPAIR_FLAG_SOLUTION_CAME_FROM_RAIM_REPAIR \ (1) -#define SBP_BASELINE_NED_DEP_A_RAIM_AVAILABILITY_FLAG_MASK (0x1) +#define SBP_BASELINE_NED_DEP_A_RAIM_AVAILABILITY_FLAG_MASK (0x1u) #define SBP_BASELINE_NED_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT (3u) -#define SBP_BASELINE_NED_DEP_A_RAIM_AVAILABILITY_FLAG_GET(flags) \ - ((u8)(((flags) >> SBP_BASELINE_NED_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT) & \ +#define SBP_BASELINE_NED_DEP_A_RAIM_AVAILABILITY_FLAG_GET(flags) \ + ((u8)((u8)((flags) >> SBP_BASELINE_NED_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT) & \ SBP_BASELINE_NED_DEP_A_RAIM_AVAILABILITY_FLAG_MASK)) #define SBP_BASELINE_NED_DEP_A_RAIM_AVAILABILITY_FLAG_SET(flags, val) \ do { \ (flags) = \ - (u8)((flags) | \ + (u8)((flags & \ + (~(SBP_BASELINE_NED_DEP_A_RAIM_AVAILABILITY_FLAG_MASK \ + << SBP_BASELINE_NED_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT))) | \ (((val) & (SBP_BASELINE_NED_DEP_A_RAIM_AVAILABILITY_FLAG_MASK)) \ << (SBP_BASELINE_NED_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT))); \ } while (0) @@ -1247,15 +1377,17 @@ (0) #define SBP_BASELINE_NED_DEP_A_RAIM_AVAILABILITY_FLAG_RAIM_CHECK_WAS_AVAILABLE \ (1) -#define SBP_BASELINE_NED_DEP_A_FIX_MODE_MASK (0x7) +#define SBP_BASELINE_NED_DEP_A_FIX_MODE_MASK (0x7u) #define SBP_BASELINE_NED_DEP_A_FIX_MODE_SHIFT (0u) -#define SBP_BASELINE_NED_DEP_A_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_BASELINE_NED_DEP_A_FIX_MODE_SHIFT) & \ +#define SBP_BASELINE_NED_DEP_A_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_BASELINE_NED_DEP_A_FIX_MODE_SHIFT) & \ SBP_BASELINE_NED_DEP_A_FIX_MODE_MASK)) -#define SBP_BASELINE_NED_DEP_A_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_BASELINE_NED_DEP_A_FIX_MODE_MASK)) \ - << (SBP_BASELINE_NED_DEP_A_FIX_MODE_SHIFT))); \ +#define SBP_BASELINE_NED_DEP_A_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_BASELINE_NED_DEP_A_FIX_MODE_MASK \ + << SBP_BASELINE_NED_DEP_A_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_BASELINE_NED_DEP_A_FIX_MODE_MASK)) \ + << (SBP_BASELINE_NED_DEP_A_FIX_MODE_SHIFT))); \ } while (0) #define SBP_BASELINE_NED_DEP_A_FIX_MODE_FLOAT_RTK (0) @@ -1281,31 +1413,35 @@ #define SBP_MSG_VEL_NED_DEP_A_ENCODED_LEN 22u #define SBP_MSG_BASELINE_HEADING_DEP_A 0x0207 -#define SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_MASK (0x1) +#define SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_MASK (0x1u) #define SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_SHIFT (4u) -#define SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_GET(flags) \ - ((u8)(((flags) >> SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_SHIFT) & \ +#define SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_GET(flags) \ + ((u8)((u8)((flags) >> SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_SHIFT) & \ SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_MASK)) -#define SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | \ - (((val) & (SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_MASK)) \ - << (SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_SHIFT))); \ +#define SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_MASK \ + << SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_SHIFT))) | \ + (((val) & (SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_MASK)) \ + << (SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_SHIFT))); \ } while (0) #define SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_NO_REPAIR (0) #define SBP_BASELINE_HEADING_DEP_A_RAIM_REPAIR_FLAG_SOLUTION_CAME_FROM_RAIM_REPAIR \ (1) -#define SBP_BASELINE_HEADING_DEP_A_RAIM_AVAILABILITY_FLAG_MASK (0x1) +#define SBP_BASELINE_HEADING_DEP_A_RAIM_AVAILABILITY_FLAG_MASK (0x1u) #define SBP_BASELINE_HEADING_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT (3u) -#define SBP_BASELINE_HEADING_DEP_A_RAIM_AVAILABILITY_FLAG_GET(flags) \ - ((u8)(((flags) >> SBP_BASELINE_HEADING_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT) & \ +#define SBP_BASELINE_HEADING_DEP_A_RAIM_AVAILABILITY_FLAG_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_BASELINE_HEADING_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT) & \ SBP_BASELINE_HEADING_DEP_A_RAIM_AVAILABILITY_FLAG_MASK)) #define SBP_BASELINE_HEADING_DEP_A_RAIM_AVAILABILITY_FLAG_SET(flags, val) \ do { \ (flags) = (u8)( \ - (flags) | \ + (flags & \ + (~(SBP_BASELINE_HEADING_DEP_A_RAIM_AVAILABILITY_FLAG_MASK \ + << SBP_BASELINE_HEADING_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT))) | \ (((val) & (SBP_BASELINE_HEADING_DEP_A_RAIM_AVAILABILITY_FLAG_MASK)) \ << (SBP_BASELINE_HEADING_DEP_A_RAIM_AVAILABILITY_FLAG_SHIFT))); \ } while (0) @@ -1314,16 +1450,18 @@ (0) #define SBP_BASELINE_HEADING_DEP_A_RAIM_AVAILABILITY_FLAG_RAIM_CHECK_WAS_AVAILABLE \ (1) -#define SBP_BASELINE_HEADING_DEP_A_FIX_MODE_MASK (0x7) +#define SBP_BASELINE_HEADING_DEP_A_FIX_MODE_MASK (0x7u) #define SBP_BASELINE_HEADING_DEP_A_FIX_MODE_SHIFT (0u) -#define SBP_BASELINE_HEADING_DEP_A_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_BASELINE_HEADING_DEP_A_FIX_MODE_SHIFT) & \ +#define SBP_BASELINE_HEADING_DEP_A_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_BASELINE_HEADING_DEP_A_FIX_MODE_SHIFT) & \ SBP_BASELINE_HEADING_DEP_A_FIX_MODE_MASK)) -#define SBP_BASELINE_HEADING_DEP_A_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_BASELINE_HEADING_DEP_A_FIX_MODE_MASK)) \ - << (SBP_BASELINE_HEADING_DEP_A_FIX_MODE_SHIFT))); \ +#define SBP_BASELINE_HEADING_DEP_A_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_BASELINE_HEADING_DEP_A_FIX_MODE_MASK \ + << SBP_BASELINE_HEADING_DEP_A_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_BASELINE_HEADING_DEP_A_FIX_MODE_MASK)) \ + << (SBP_BASELINE_HEADING_DEP_A_FIX_MODE_SHIFT))); \ } while (0) #define SBP_BASELINE_HEADING_DEP_A_FIX_MODE_FLOAT_RTK (0) @@ -1335,20 +1473,23 @@ #define SBP_MSG_BASELINE_HEADING_DEP_A_ENCODED_LEN 10u #define SBP_MSG_PROTECTION_LEVEL_DEP_A 0x0216 -#define SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_MASK (0x7) +#define SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_MASK (0x7u) #define SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_SHIFT (0u) -#define SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_GET(flags) \ - ((u8)(((flags) >> \ - SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_SHIFT) & \ - SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_MASK)) -#define SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_SET(flags, \ - val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_MASK)) \ - << (SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_SHIFT))); \ +#define SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_GET(flags) \ + ((u8)( \ + (u8)((flags) >> \ + SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_SHIFT) & \ + SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_MASK)) +#define SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_SET(flags, \ + val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_MASK \ + << SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_SHIFT))) | \ + (((val) & \ + (SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_MASK)) \ + << (SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_SHIFT))); \ } while (0) #define SBP_PROTECTION_LEVEL_DEP_A_TARGET_INTEGRITY_RISK_TIR_LEVEL_SAFE_STATE_PROTECTION_LEVEL_SHALL_NOT_BE_USED_FOR_SAFETY_CRITICAL_APPLICATION \ @@ -1366,29 +1507,33 @@ #define SBP_MSG_PROTECTION_LEVEL_DEP_A_ENCODED_LEN 33u #define SBP_MSG_PROTECTION_LEVEL 0x0217 -#define SBP_PROTECTION_LEVEL_TARGET_INTEGRITY_RISK_TIR_LEVEL_MASK (0x7) +#define SBP_PROTECTION_LEVEL_TARGET_INTEGRITY_RISK_TIR_LEVEL_MASK (0x7u) #define SBP_PROTECTION_LEVEL_TARGET_INTEGRITY_RISK_TIR_LEVEL_SHIFT (0u) -#define SBP_PROTECTION_LEVEL_TARGET_INTEGRITY_RISK_TIR_LEVEL_GET(flags) \ - ((u32)(((flags) >> \ - SBP_PROTECTION_LEVEL_TARGET_INTEGRITY_RISK_TIR_LEVEL_SHIFT) & \ +#define SBP_PROTECTION_LEVEL_TARGET_INTEGRITY_RISK_TIR_LEVEL_GET(flags) \ + ((u32)((u32)((flags) >> \ + SBP_PROTECTION_LEVEL_TARGET_INTEGRITY_RISK_TIR_LEVEL_SHIFT) & \ SBP_PROTECTION_LEVEL_TARGET_INTEGRITY_RISK_TIR_LEVEL_MASK)) #define SBP_PROTECTION_LEVEL_TARGET_INTEGRITY_RISK_TIR_LEVEL_SET(flags, val) \ do { \ (flags) = (u32)( \ - (flags) | \ + (flags & \ + (~(SBP_PROTECTION_LEVEL_TARGET_INTEGRITY_RISK_TIR_LEVEL_MASK \ + << SBP_PROTECTION_LEVEL_TARGET_INTEGRITY_RISK_TIR_LEVEL_SHIFT))) | \ (((val) & (SBP_PROTECTION_LEVEL_TARGET_INTEGRITY_RISK_TIR_LEVEL_MASK)) \ << (SBP_PROTECTION_LEVEL_TARGET_INTEGRITY_RISK_TIR_LEVEL_SHIFT))); \ } while (0) -#define SBP_PROTECTION_LEVEL_FIX_MODE_MASK (0x7) +#define SBP_PROTECTION_LEVEL_FIX_MODE_MASK (0x7u) #define SBP_PROTECTION_LEVEL_FIX_MODE_SHIFT (15u) -#define SBP_PROTECTION_LEVEL_FIX_MODE_GET(flags) \ - ((u32)(((flags) >> SBP_PROTECTION_LEVEL_FIX_MODE_SHIFT) & \ +#define SBP_PROTECTION_LEVEL_FIX_MODE_GET(flags) \ + ((u32)((u32)((flags) >> SBP_PROTECTION_LEVEL_FIX_MODE_SHIFT) & \ SBP_PROTECTION_LEVEL_FIX_MODE_MASK)) -#define SBP_PROTECTION_LEVEL_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u32)((flags) | (((val) & (SBP_PROTECTION_LEVEL_FIX_MODE_MASK)) \ - << (SBP_PROTECTION_LEVEL_FIX_MODE_SHIFT))); \ +#define SBP_PROTECTION_LEVEL_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u32)((flags & (~(SBP_PROTECTION_LEVEL_FIX_MODE_MASK \ + << SBP_PROTECTION_LEVEL_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_PROTECTION_LEVEL_FIX_MODE_MASK)) \ + << (SBP_PROTECTION_LEVEL_FIX_MODE_SHIFT))); \ } while (0) #define SBP_PROTECTION_LEVEL_FIX_MODE_INVALID (0) @@ -1398,165 +1543,191 @@ #define SBP_PROTECTION_LEVEL_FIX_MODE_FIXED_RTK (4) #define SBP_PROTECTION_LEVEL_FIX_MODE_DEAD_RECKONING (5) #define SBP_PROTECTION_LEVEL_FIX_MODE_SBAS_POSITION (6) -#define SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_MASK (0x3) +#define SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_MASK (0x3u) #define SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_SHIFT (18u) -#define SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_GET(flags) \ - ((u32)(((flags) >> SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_SHIFT) & \ - SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_MASK)) +#define SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_GET(flags) \ + ((u32)( \ + (u32)((flags) >> SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_SHIFT) & \ + SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_MASK)) #define SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_SET(flags, val) \ do { \ (flags) = \ - (u32)((flags) | \ + (u32)((flags & \ + (~(SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_MASK \ + << SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_SHIFT))) | \ (((val) & (SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_MASK)) \ << (SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_SHIFT))); \ } while (0) #define SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_NONE (0) #define SBP_PROTECTION_LEVEL_INERTIAL_NAVIGATION_MODE_INS_USED (1) -#define SBP_PROTECTION_LEVEL_TIME_STATUS_MASK (0x1) +#define SBP_PROTECTION_LEVEL_TIME_STATUS_MASK (0x1u) #define SBP_PROTECTION_LEVEL_TIME_STATUS_SHIFT (20u) -#define SBP_PROTECTION_LEVEL_TIME_STATUS_GET(flags) \ - ((u32)(((flags) >> SBP_PROTECTION_LEVEL_TIME_STATUS_SHIFT) & \ +#define SBP_PROTECTION_LEVEL_TIME_STATUS_GET(flags) \ + ((u32)((u32)((flags) >> SBP_PROTECTION_LEVEL_TIME_STATUS_SHIFT) & \ SBP_PROTECTION_LEVEL_TIME_STATUS_MASK)) -#define SBP_PROTECTION_LEVEL_TIME_STATUS_SET(flags, val) \ - do { \ - (flags) = \ - (u32)((flags) | (((val) & (SBP_PROTECTION_LEVEL_TIME_STATUS_MASK)) \ - << (SBP_PROTECTION_LEVEL_TIME_STATUS_SHIFT))); \ +#define SBP_PROTECTION_LEVEL_TIME_STATUS_SET(flags, val) \ + do { \ + (flags) = (u32)((flags & (~(SBP_PROTECTION_LEVEL_TIME_STATUS_MASK \ + << SBP_PROTECTION_LEVEL_TIME_STATUS_SHIFT))) | \ + (((val) & (SBP_PROTECTION_LEVEL_TIME_STATUS_MASK)) \ + << (SBP_PROTECTION_LEVEL_TIME_STATUS_SHIFT))); \ } while (0) #define SBP_PROTECTION_LEVEL_TIME_STATUS_GNSS_TIME_OF_VALIDITY (0) #define SBP_PROTECTION_LEVEL_TIME_STATUS_OTHER (1) -#define SBP_PROTECTION_LEVEL_VELOCITY_VALID_MASK (0x1) +#define SBP_PROTECTION_LEVEL_VELOCITY_VALID_MASK (0x1u) #define SBP_PROTECTION_LEVEL_VELOCITY_VALID_SHIFT (21u) -#define SBP_PROTECTION_LEVEL_VELOCITY_VALID_GET(flags) \ - ((u32)(((flags) >> SBP_PROTECTION_LEVEL_VELOCITY_VALID_SHIFT) & \ +#define SBP_PROTECTION_LEVEL_VELOCITY_VALID_GET(flags) \ + ((u32)((u32)((flags) >> SBP_PROTECTION_LEVEL_VELOCITY_VALID_SHIFT) & \ SBP_PROTECTION_LEVEL_VELOCITY_VALID_MASK)) -#define SBP_PROTECTION_LEVEL_VELOCITY_VALID_SET(flags, val) \ - do { \ - (flags) = \ - (u32)((flags) | (((val) & (SBP_PROTECTION_LEVEL_VELOCITY_VALID_MASK)) \ - << (SBP_PROTECTION_LEVEL_VELOCITY_VALID_SHIFT))); \ +#define SBP_PROTECTION_LEVEL_VELOCITY_VALID_SET(flags, val) \ + do { \ + (flags) = \ + (u32)((flags & (~(SBP_PROTECTION_LEVEL_VELOCITY_VALID_MASK \ + << SBP_PROTECTION_LEVEL_VELOCITY_VALID_SHIFT))) | \ + (((val) & (SBP_PROTECTION_LEVEL_VELOCITY_VALID_MASK)) \ + << (SBP_PROTECTION_LEVEL_VELOCITY_VALID_SHIFT))); \ } while (0) -#define SBP_PROTECTION_LEVEL_ATTITUDE_VALID_MASK (0x1) +#define SBP_PROTECTION_LEVEL_ATTITUDE_VALID_MASK (0x1u) #define SBP_PROTECTION_LEVEL_ATTITUDE_VALID_SHIFT (22u) -#define SBP_PROTECTION_LEVEL_ATTITUDE_VALID_GET(flags) \ - ((u32)(((flags) >> SBP_PROTECTION_LEVEL_ATTITUDE_VALID_SHIFT) & \ +#define SBP_PROTECTION_LEVEL_ATTITUDE_VALID_GET(flags) \ + ((u32)((u32)((flags) >> SBP_PROTECTION_LEVEL_ATTITUDE_VALID_SHIFT) & \ SBP_PROTECTION_LEVEL_ATTITUDE_VALID_MASK)) -#define SBP_PROTECTION_LEVEL_ATTITUDE_VALID_SET(flags, val) \ - do { \ - (flags) = \ - (u32)((flags) | (((val) & (SBP_PROTECTION_LEVEL_ATTITUDE_VALID_MASK)) \ - << (SBP_PROTECTION_LEVEL_ATTITUDE_VALID_SHIFT))); \ +#define SBP_PROTECTION_LEVEL_ATTITUDE_VALID_SET(flags, val) \ + do { \ + (flags) = \ + (u32)((flags & (~(SBP_PROTECTION_LEVEL_ATTITUDE_VALID_MASK \ + << SBP_PROTECTION_LEVEL_ATTITUDE_VALID_SHIFT))) | \ + (((val) & (SBP_PROTECTION_LEVEL_ATTITUDE_VALID_MASK)) \ + << (SBP_PROTECTION_LEVEL_ATTITUDE_VALID_SHIFT))); \ } while (0) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_MASK (0x1) +#define SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_MASK (0x1u) #define SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_SHIFT (23u) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_GET(flags) \ - ((u32)(((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_SHIFT) & \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_GET(flags) \ + ((u32)((u32)((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_SHIFT) & \ SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_MASK)) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_SET(flags, val) \ - do { \ - (flags) = \ - (u32)((flags) | (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_MASK)) \ - << (SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_SHIFT))); \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_SET(flags, val) \ + do { \ + (flags) = \ + (u32)((flags & (~(SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_MASK \ + << SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_SHIFT))) | \ + (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_MASK)) \ + << (SBP_PROTECTION_LEVEL_SAFE_STATE_HPL_SHIFT))); \ } while (0) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_MASK (0x1) +#define SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_MASK (0x1u) #define SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_SHIFT (24u) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_GET(flags) \ - ((u32)(((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_SHIFT) & \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_GET(flags) \ + ((u32)((u32)((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_SHIFT) & \ SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_MASK)) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_SET(flags, val) \ - do { \ - (flags) = \ - (u32)((flags) | (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_MASK)) \ - << (SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_SHIFT))); \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_SET(flags, val) \ + do { \ + (flags) = \ + (u32)((flags & (~(SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_MASK \ + << SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_SHIFT))) | \ + (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_MASK)) \ + << (SBP_PROTECTION_LEVEL_SAFE_STATE_VPL_SHIFT))); \ } while (0) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_MASK (0x1) +#define SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_MASK (0x1u) #define SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_SHIFT (25u) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_GET(flags) \ - ((u32)(((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_SHIFT) & \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_GET(flags) \ + ((u32)((u32)((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_SHIFT) & \ SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_MASK)) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_SET(flags, val) \ - do { \ - (flags) = \ - (u32)((flags) | (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_MASK)) \ - << (SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_SHIFT))); \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_SET(flags, val) \ + do { \ + (flags) = \ + (u32)((flags & (~(SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_MASK \ + << SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_SHIFT))) | \ + (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_MASK)) \ + << (SBP_PROTECTION_LEVEL_SAFE_STATE_ATPL_SHIFT))); \ } while (0) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_MASK (0x1) +#define SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_MASK (0x1u) #define SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_SHIFT (26u) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_GET(flags) \ - ((u32)(((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_SHIFT) & \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_GET(flags) \ + ((u32)((u32)((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_SHIFT) & \ SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_MASK)) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_SET(flags, val) \ - do { \ - (flags) = \ - (u32)((flags) | (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_MASK)) \ - << (SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_SHIFT))); \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_SET(flags, val) \ + do { \ + (flags) = \ + (u32)((flags & (~(SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_MASK \ + << SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_SHIFT))) | \ + (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_MASK)) \ + << (SBP_PROTECTION_LEVEL_SAFE_STATE_CTPL_SHIFT))); \ } while (0) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_MASK (0x1) +#define SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_MASK (0x1u) #define SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_SHIFT (27u) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_GET(flags) \ - ((u32)(((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_SHIFT) & \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_GET(flags) \ + ((u32)((u32)((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_SHIFT) & \ SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_MASK)) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_SET(flags, val) \ - do { \ - (flags) = \ - (u32)((flags) | (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_MASK)) \ - << (SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_SHIFT))); \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_SET(flags, val) \ + do { \ + (flags) = \ + (u32)((flags & (~(SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_MASK \ + << SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_SHIFT))) | \ + (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_MASK)) \ + << (SBP_PROTECTION_LEVEL_SAFE_STATE_HVPL_SHIFT))); \ } while (0) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_MASK (0x1) +#define SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_MASK (0x1u) #define SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_SHIFT (28u) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_GET(flags) \ - ((u32)(((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_SHIFT) & \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_GET(flags) \ + ((u32)((u32)((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_SHIFT) & \ SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_MASK)) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_SET(flags, val) \ - do { \ - (flags) = \ - (u32)((flags) | (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_MASK)) \ - << (SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_SHIFT))); \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_SET(flags, val) \ + do { \ + (flags) = \ + (u32)((flags & (~(SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_MASK \ + << SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_SHIFT))) | \ + (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_MASK)) \ + << (SBP_PROTECTION_LEVEL_SAFE_STATE_VVPL_SHIFT))); \ } while (0) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_MASK (0x1) +#define SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_MASK (0x1u) #define SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_SHIFT (29u) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_GET(flags) \ - ((u32)(((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_SHIFT) & \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_GET(flags) \ + ((u32)((u32)((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_SHIFT) & \ SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_MASK)) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_SET(flags, val) \ - do { \ - (flags) = \ - (u32)((flags) | (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_MASK)) \ - << (SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_SHIFT))); \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_SET(flags, val) \ + do { \ + (flags) = \ + (u32)((flags & (~(SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_MASK \ + << SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_SHIFT))) | \ + (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_MASK)) \ + << (SBP_PROTECTION_LEVEL_SAFE_STATE_HOPL_SHIFT))); \ } while (0) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_MASK (0x1) +#define SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_MASK (0x1u) #define SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_SHIFT (30u) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_GET(flags) \ - ((u32)(((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_SHIFT) & \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_GET(flags) \ + ((u32)((u32)((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_SHIFT) & \ SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_MASK)) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_SET(flags, val) \ - do { \ - (flags) = \ - (u32)((flags) | (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_MASK)) \ - << (SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_SHIFT))); \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_SET(flags, val) \ + do { \ + (flags) = \ + (u32)((flags & (~(SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_MASK \ + << SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_SHIFT))) | \ + (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_MASK)) \ + << (SBP_PROTECTION_LEVEL_SAFE_STATE_POPL_SHIFT))); \ } while (0) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_MASK (0x1) +#define SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_MASK (0x1u) #define SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_SHIFT (31u) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_GET(flags) \ - ((u32)(((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_SHIFT) & \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_GET(flags) \ + ((u32)((u32)((flags) >> SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_SHIFT) & \ SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_MASK)) -#define SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_SET(flags, val) \ - do { \ - (flags) = \ - (u32)((flags) | (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_MASK)) \ - << (SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_SHIFT))); \ +#define SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_SET(flags, val) \ + do { \ + (flags) = \ + (u32)((flags & (~(SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_MASK \ + << SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_SHIFT))) | \ + (((val) & (SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_MASK)) \ + << (SBP_PROTECTION_LEVEL_SAFE_STATE_ROPL_SHIFT))); \ } while (0) /** diff --git a/c/include/libsbp/ndb_macros.h b/c/include/libsbp/ndb_macros.h index e4fb791c9d..e034bb4447 100644 --- a/c/include/libsbp/ndb_macros.h +++ b/c/include/libsbp/ndb_macros.h @@ -19,30 +19,34 @@ #define LIBSBP_NDB_MACROS_H #define SBP_MSG_NDB_EVENT 0x0400 -#define SBP_NDB_EVENT_EVENT_TYPE_MASK (0x3) +#define SBP_NDB_EVENT_EVENT_TYPE_MASK (0x3u) #define SBP_NDB_EVENT_EVENT_TYPE_SHIFT (0u) -#define SBP_NDB_EVENT_EVENT_TYPE_GET(flags) \ - ((u8)(((flags) >> SBP_NDB_EVENT_EVENT_TYPE_SHIFT) & \ +#define SBP_NDB_EVENT_EVENT_TYPE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_NDB_EVENT_EVENT_TYPE_SHIFT) & \ SBP_NDB_EVENT_EVENT_TYPE_MASK)) -#define SBP_NDB_EVENT_EVENT_TYPE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_NDB_EVENT_EVENT_TYPE_MASK)) \ - << (SBP_NDB_EVENT_EVENT_TYPE_SHIFT))); \ +#define SBP_NDB_EVENT_EVENT_TYPE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_NDB_EVENT_EVENT_TYPE_MASK \ + << SBP_NDB_EVENT_EVENT_TYPE_SHIFT))) | \ + (((val) & (SBP_NDB_EVENT_EVENT_TYPE_MASK)) \ + << (SBP_NDB_EVENT_EVENT_TYPE_SHIFT))); \ } while (0) #define SBP_NDB_EVENT_EVENT_TYPE_UNKNOWN (0) #define SBP_NDB_EVENT_EVENT_TYPE_STORE (1) #define SBP_NDB_EVENT_EVENT_TYPE_FETCH (2) #define SBP_NDB_EVENT_EVENT_TYPE_ERASE (3) -#define SBP_NDB_EVENT_EVENT_OBJECT_TYPE_MASK (0x7) +#define SBP_NDB_EVENT_EVENT_OBJECT_TYPE_MASK (0x7u) #define SBP_NDB_EVENT_EVENT_OBJECT_TYPE_SHIFT (0u) -#define SBP_NDB_EVENT_EVENT_OBJECT_TYPE_GET(flags) \ - ((u8)(((flags) >> SBP_NDB_EVENT_EVENT_OBJECT_TYPE_SHIFT) & \ +#define SBP_NDB_EVENT_EVENT_OBJECT_TYPE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_NDB_EVENT_EVENT_OBJECT_TYPE_SHIFT) & \ SBP_NDB_EVENT_EVENT_OBJECT_TYPE_MASK)) -#define SBP_NDB_EVENT_EVENT_OBJECT_TYPE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_NDB_EVENT_EVENT_OBJECT_TYPE_MASK)) \ - << (SBP_NDB_EVENT_EVENT_OBJECT_TYPE_SHIFT))); \ +#define SBP_NDB_EVENT_EVENT_OBJECT_TYPE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_NDB_EVENT_EVENT_OBJECT_TYPE_MASK \ + << SBP_NDB_EVENT_EVENT_OBJECT_TYPE_SHIFT))) | \ + (((val) & (SBP_NDB_EVENT_EVENT_OBJECT_TYPE_MASK)) \ + << (SBP_NDB_EVENT_EVENT_OBJECT_TYPE_SHIFT))); \ } while (0) #define SBP_NDB_EVENT_EVENT_OBJECT_TYPE_UNKNOWN (0) @@ -52,15 +56,17 @@ #define SBP_NDB_EVENT_EVENT_OBJECT_TYPE_IONO (4) #define SBP_NDB_EVENT_EVENT_OBJECT_TYPE_L2C_CAP (5) #define SBP_NDB_EVENT_EVENT_OBJECT_TYPE_LGF (6) -#define SBP_NDB_EVENT_EVENT_RESULT_MASK (0xf) +#define SBP_NDB_EVENT_EVENT_RESULT_MASK (0xfu) #define SBP_NDB_EVENT_EVENT_RESULT_SHIFT (0u) -#define SBP_NDB_EVENT_EVENT_RESULT_GET(flags) \ - ((u8)(((flags) >> SBP_NDB_EVENT_EVENT_RESULT_SHIFT) & \ +#define SBP_NDB_EVENT_EVENT_RESULT_GET(flags) \ + ((u8)((u8)((flags) >> SBP_NDB_EVENT_EVENT_RESULT_SHIFT) & \ SBP_NDB_EVENT_EVENT_RESULT_MASK)) -#define SBP_NDB_EVENT_EVENT_RESULT_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_NDB_EVENT_EVENT_RESULT_MASK)) \ - << (SBP_NDB_EVENT_EVENT_RESULT_SHIFT))); \ +#define SBP_NDB_EVENT_EVENT_RESULT_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_NDB_EVENT_EVENT_RESULT_MASK \ + << SBP_NDB_EVENT_EVENT_RESULT_SHIFT))) | \ + (((val) & (SBP_NDB_EVENT_EVENT_RESULT_MASK)) \ + << (SBP_NDB_EVENT_EVENT_RESULT_SHIFT))); \ } while (0) #define SBP_NDB_EVENT_EVENT_RESULT_NDB_ERR_NONE (0) @@ -74,15 +80,17 @@ #define SBP_NDB_EVENT_EVENT_RESULT_NDB_ERR_NO_DATA (8) #define SBP_NDB_EVENT_EVENT_RESULT_NDB_ERR_NO_CHANGE (9) #define SBP_NDB_EVENT_EVENT_RESULT_NDB_ERR_OLDER_DATA (10) -#define SBP_NDB_EVENT_DATA_SOURCE_MASK (0x3) +#define SBP_NDB_EVENT_DATA_SOURCE_MASK (0x3u) #define SBP_NDB_EVENT_DATA_SOURCE_SHIFT (0u) -#define SBP_NDB_EVENT_DATA_SOURCE_GET(flags) \ - ((u8)(((flags) >> SBP_NDB_EVENT_DATA_SOURCE_SHIFT) & \ +#define SBP_NDB_EVENT_DATA_SOURCE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_NDB_EVENT_DATA_SOURCE_SHIFT) & \ SBP_NDB_EVENT_DATA_SOURCE_MASK)) -#define SBP_NDB_EVENT_DATA_SOURCE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_NDB_EVENT_DATA_SOURCE_MASK)) \ - << (SBP_NDB_EVENT_DATA_SOURCE_SHIFT))); \ +#define SBP_NDB_EVENT_DATA_SOURCE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_NDB_EVENT_DATA_SOURCE_MASK \ + << SBP_NDB_EVENT_DATA_SOURCE_SHIFT))) | \ + (((val) & (SBP_NDB_EVENT_DATA_SOURCE_MASK)) \ + << (SBP_NDB_EVENT_DATA_SOURCE_SHIFT))); \ } while (0) #define SBP_NDB_EVENT_DATA_SOURCE_NDB_DS_UNDEFINED (0) diff --git a/c/include/libsbp/observation_macros.h b/c/include/libsbp/observation_macros.h index ac2d88033a..1825d69d06 100644 --- a/c/include/libsbp/observation_macros.h +++ b/c/include/libsbp/observation_macros.h @@ -30,77 +30,87 @@ */ #define SBP_DOPPLER_ENCODED_LEN 3u -#define SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_MASK (0x1) +#define SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_MASK (0x1u) #define SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_SHIFT (7u) -#define SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_GET(flags) \ - ((u8)(((flags) >> SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_SHIFT) & \ +#define SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_GET(flags) \ + ((u8)((u8)((flags) >> SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_SHIFT) & \ SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_MASK)) -#define SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_MASK)) \ - << (SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_SHIFT))); \ +#define SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_MASK \ + << SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_SHIFT))) | \ + (((val) & (SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_MASK)) \ + << (SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_SHIFT))); \ } while (0) #define SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_NO_EXCLUSION (0) #define SBP_PACKEDOBSCONTENT_RAIM_EXCLUSION_MEASUREMENT_WAS_EXCLUDED_BY_SPP_RAIM_USE_WITH_CARE \ (1) -#define SBP_PACKEDOBSCONTENT_DOPPLER_VALID_MASK (0x1) +#define SBP_PACKEDOBSCONTENT_DOPPLER_VALID_MASK (0x1u) #define SBP_PACKEDOBSCONTENT_DOPPLER_VALID_SHIFT (3u) -#define SBP_PACKEDOBSCONTENT_DOPPLER_VALID_GET(flags) \ - ((u8)(((flags) >> SBP_PACKEDOBSCONTENT_DOPPLER_VALID_SHIFT) & \ +#define SBP_PACKEDOBSCONTENT_DOPPLER_VALID_GET(flags) \ + ((u8)((u8)((flags) >> SBP_PACKEDOBSCONTENT_DOPPLER_VALID_SHIFT) & \ SBP_PACKEDOBSCONTENT_DOPPLER_VALID_MASK)) -#define SBP_PACKEDOBSCONTENT_DOPPLER_VALID_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_PACKEDOBSCONTENT_DOPPLER_VALID_MASK)) \ - << (SBP_PACKEDOBSCONTENT_DOPPLER_VALID_SHIFT))); \ +#define SBP_PACKEDOBSCONTENT_DOPPLER_VALID_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_PACKEDOBSCONTENT_DOPPLER_VALID_MASK \ + << SBP_PACKEDOBSCONTENT_DOPPLER_VALID_SHIFT))) | \ + (((val) & (SBP_PACKEDOBSCONTENT_DOPPLER_VALID_MASK)) \ + << (SBP_PACKEDOBSCONTENT_DOPPLER_VALID_SHIFT))); \ } while (0) #define SBP_PACKEDOBSCONTENT_DOPPLER_VALID_INVALID_DOPPLER_MEASUREMENT (0) #define SBP_PACKEDOBSCONTENT_DOPPLER_VALID_VALID_DOPPLER_MEASUREMENT (1) -#define SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_MASK (0x1) +#define SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_MASK (0x1u) #define SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_SHIFT (2u) -#define SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_GET(flags) \ - ((u8)(((flags) >> SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_SHIFT) & \ +#define SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_GET(flags) \ + ((u8)((u8)((flags) >> SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_SHIFT) & \ SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_MASK)) -#define SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_MASK)) \ - << (SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_SHIFT))); \ +#define SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_MASK \ + << SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_SHIFT))) | \ + (((val) & (SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_MASK)) \ + << (SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_SHIFT))); \ } while (0) #define SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_HALF_CYCLE_PHASE_AMBIGUITY_UNRESOLVED \ (0) #define SBP_PACKEDOBSCONTENT_HALFCYCLE_AMBIGUITY_HALF_CYCLE_PHASE_AMBIGUITY_RESOLVED \ (1) -#define SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_MASK (0x1) +#define SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_MASK (0x1u) #define SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_SHIFT (1u) -#define SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_GET(flags) \ - ((u8)(((flags) >> SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_SHIFT) & \ +#define SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_GET(flags) \ + ((u8)((u8)((flags) >> SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_SHIFT) & \ SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_MASK)) -#define SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_MASK)) \ - << (SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_SHIFT))); \ +#define SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_MASK \ + << SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_SHIFT))) | \ + (((val) & (SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_MASK)) \ + << (SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_SHIFT))); \ } while (0) #define SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_INVALID_CARRIER_PHASE_MEASUREMENT \ (0) #define SBP_PACKEDOBSCONTENT_CARRIER_PHASE_VALID_VALID_CARRIER_PHASE_MEASUREMENT \ (1) -#define SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_MASK (0x1) +#define SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_MASK (0x1u) #define SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_SHIFT (0u) -#define SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_GET(flags) \ - ((u8)(((flags) >> SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_SHIFT) & \ +#define SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_GET(flags) \ + ((u8)((u8)((flags) >> SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_SHIFT) & \ SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_MASK)) -#define SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_MASK)) \ - << (SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_SHIFT))); \ +#define SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_MASK \ + << SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_SHIFT))) | \ + (((val) & (SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_MASK)) \ + << (SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_SHIFT))); \ } while (0) #define SBP_PACKEDOBSCONTENT_PSEUDORANGE_VALID_INVALID_PSEUDORANGE_MEASUREMENT \ @@ -113,15 +123,18 @@ */ #define SBP_PACKED_OBS_CONTENT_ENCODED_LEN 17u -#define SBP_PACKEDOSRCONTENT_INVALID_PHASE_CORRECTIONS_MASK (0x1) +#define SBP_PACKEDOSRCONTENT_INVALID_PHASE_CORRECTIONS_MASK (0x1u) #define SBP_PACKEDOSRCONTENT_INVALID_PHASE_CORRECTIONS_SHIFT (4u) -#define SBP_PACKEDOSRCONTENT_INVALID_PHASE_CORRECTIONS_GET(flags) \ - ((u8)(((flags) >> SBP_PACKEDOSRCONTENT_INVALID_PHASE_CORRECTIONS_SHIFT) & \ - SBP_PACKEDOSRCONTENT_INVALID_PHASE_CORRECTIONS_MASK)) +#define SBP_PACKEDOSRCONTENT_INVALID_PHASE_CORRECTIONS_GET(flags) \ + ((u8)( \ + (u8)((flags) >> SBP_PACKEDOSRCONTENT_INVALID_PHASE_CORRECTIONS_SHIFT) & \ + SBP_PACKEDOSRCONTENT_INVALID_PHASE_CORRECTIONS_MASK)) #define SBP_PACKEDOSRCONTENT_INVALID_PHASE_CORRECTIONS_SET(flags, val) \ do { \ (flags) = \ - (u8)((flags) | \ + (u8)((flags & \ + (~(SBP_PACKEDOSRCONTENT_INVALID_PHASE_CORRECTIONS_MASK \ + << SBP_PACKEDOSRCONTENT_INVALID_PHASE_CORRECTIONS_SHIFT))) | \ (((val) & (SBP_PACKEDOSRCONTENT_INVALID_PHASE_CORRECTIONS_MASK)) \ << (SBP_PACKEDOSRCONTENT_INVALID_PHASE_CORRECTIONS_SHIFT))); \ } while (0) @@ -130,15 +143,17 @@ (0) #define SBP_PACKEDOSRCONTENT_INVALID_PHASE_CORRECTIONS_DO_NOT_USE_PHASE_CORRECTIONS \ (1) -#define SBP_PACKEDOSRCONTENT_INVALID_CODE_CORRECTIONS_MASK (0x1) +#define SBP_PACKEDOSRCONTENT_INVALID_CODE_CORRECTIONS_MASK (0x1u) #define SBP_PACKEDOSRCONTENT_INVALID_CODE_CORRECTIONS_SHIFT (3u) -#define SBP_PACKEDOSRCONTENT_INVALID_CODE_CORRECTIONS_GET(flags) \ - ((u8)(((flags) >> SBP_PACKEDOSRCONTENT_INVALID_CODE_CORRECTIONS_SHIFT) & \ +#define SBP_PACKEDOSRCONTENT_INVALID_CODE_CORRECTIONS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_PACKEDOSRCONTENT_INVALID_CODE_CORRECTIONS_SHIFT) & \ SBP_PACKEDOSRCONTENT_INVALID_CODE_CORRECTIONS_MASK)) #define SBP_PACKEDOSRCONTENT_INVALID_CODE_CORRECTIONS_SET(flags, val) \ do { \ (flags) = \ - (u8)((flags) | \ + (u8)((flags & \ + (~(SBP_PACKEDOSRCONTENT_INVALID_CODE_CORRECTIONS_MASK \ + << SBP_PACKEDOSRCONTENT_INVALID_CODE_CORRECTIONS_SHIFT))) | \ (((val) & (SBP_PACKEDOSRCONTENT_INVALID_CODE_CORRECTIONS_MASK)) \ << (SBP_PACKEDOSRCONTENT_INVALID_CODE_CORRECTIONS_SHIFT))); \ } while (0) @@ -146,44 +161,50 @@ #define SBP_PACKEDOSRCONTENT_INVALID_CODE_CORRECTIONS_VALID_CODE_CORRECTIONS (0) #define SBP_PACKEDOSRCONTENT_INVALID_CODE_CORRECTIONS_DO_NOT_USE_CODE_CORRECTIONS \ (1) -#define SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_MASK (0x1) +#define SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_MASK (0x1u) #define SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_SHIFT (2u) -#define SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_GET(flags) \ - ((u8)(((flags) >> SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_SHIFT) & \ +#define SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_GET(flags) \ + ((u8)((u8)((flags) >> SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_SHIFT) & \ SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_MASK)) -#define SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_MASK)) \ - << (SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_SHIFT))); \ +#define SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_MASK \ + << SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_SHIFT))) | \ + (((val) & (SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_MASK)) \ + << (SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_SHIFT))); \ } while (0) #define SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_FULL_FIXING_UNAVAILABLE (0) #define SBP_PACKEDOSRCONTENT_FULL_FIXING_FLAG_FULL_FIXING_AVAILABLE (1) -#define SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_MASK (0x1) +#define SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_MASK (0x1u) #define SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_SHIFT (1u) -#define SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_GET(flags) \ - ((u8)(((flags) >> SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_SHIFT) & \ +#define SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_GET(flags) \ + ((u8)((u8)((flags) >> SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_SHIFT) & \ SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_MASK)) -#define SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_MASK)) \ - << (SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_SHIFT))); \ +#define SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_MASK \ + << SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_SHIFT))) | \ + (((val) & (SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_MASK)) \ + << (SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_SHIFT))); \ } while (0) #define SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_PARTIAL_FIXING_UNAVAILABLE (0) #define SBP_PACKEDOSRCONTENT_PARTIAL_FIXING_FLAG_PARTIAL_FIXING_AVAILABLE (1) -#define SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_MASK (0x1) +#define SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_MASK (0x1u) #define SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_SHIFT (0u) -#define SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_GET(flags) \ - ((u8)(((flags) >> SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_SHIFT) & \ +#define SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_GET(flags) \ + ((u8)((u8)((flags) >> SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_SHIFT) & \ SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_MASK)) -#define SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_MASK)) \ - << (SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_SHIFT))); \ +#define SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_MASK \ + << SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_SHIFT))) | \ + (((val) & (SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_MASK)) \ + << (SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_SHIFT))); \ } while (0) #define SBP_PACKEDOSRCONTENT_CORRECTION_VALIDITY_DO_NOT_USE_SIGNAL (0) diff --git a/c/include/libsbp/orientation_macros.h b/c/include/libsbp/orientation_macros.h index d862d4dfb0..b29f3e9077 100644 --- a/c/include/libsbp/orientation_macros.h +++ b/c/include/libsbp/orientation_macros.h @@ -19,15 +19,17 @@ #define LIBSBP_ORIENTATION_MACROS_H #define SBP_MSG_BASELINE_HEADING 0x020F -#define SBP_BASELINE_HEADING_FIX_MODE_MASK (0x7) +#define SBP_BASELINE_HEADING_FIX_MODE_MASK (0x7u) #define SBP_BASELINE_HEADING_FIX_MODE_SHIFT (0u) -#define SBP_BASELINE_HEADING_FIX_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_BASELINE_HEADING_FIX_MODE_SHIFT) & \ +#define SBP_BASELINE_HEADING_FIX_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_BASELINE_HEADING_FIX_MODE_SHIFT) & \ SBP_BASELINE_HEADING_FIX_MODE_MASK)) -#define SBP_BASELINE_HEADING_FIX_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_BASELINE_HEADING_FIX_MODE_MASK)) \ - << (SBP_BASELINE_HEADING_FIX_MODE_SHIFT))); \ +#define SBP_BASELINE_HEADING_FIX_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_BASELINE_HEADING_FIX_MODE_MASK \ + << SBP_BASELINE_HEADING_FIX_MODE_SHIFT))) | \ + (((val) & (SBP_BASELINE_HEADING_FIX_MODE_MASK)) \ + << (SBP_BASELINE_HEADING_FIX_MODE_SHIFT))); \ } while (0) #define SBP_BASELINE_HEADING_FIX_MODE_INVALID (0) @@ -41,16 +43,18 @@ #define SBP_MSG_BASELINE_HEADING_ENCODED_LEN 10u #define SBP_MSG_ORIENT_QUAT 0x0220 -#define SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_MASK (0x7) +#define SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_MASK (0x7u) #define SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_SHIFT (0u) -#define SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_SHIFT) & \ +#define SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_SHIFT) & \ SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_MASK)) -#define SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_MASK)) \ - << (SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_SHIFT))); \ +#define SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_MASK \ + << SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_SHIFT))) | \ + (((val) & (SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_MASK)) \ + << (SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_SHIFT))); \ } while (0) #define SBP_ORIENT_QUAT_INS_NAVIGATION_MODE_INVALID (0) @@ -62,16 +66,18 @@ #define SBP_MSG_ORIENT_QUAT_ENCODED_LEN 37u #define SBP_MSG_ORIENT_EULER 0x0221 -#define SBP_ORIENT_EULER_INS_NAVIGATION_MODE_MASK (0x7) +#define SBP_ORIENT_EULER_INS_NAVIGATION_MODE_MASK (0x7u) #define SBP_ORIENT_EULER_INS_NAVIGATION_MODE_SHIFT (0u) -#define SBP_ORIENT_EULER_INS_NAVIGATION_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_ORIENT_EULER_INS_NAVIGATION_MODE_SHIFT) & \ +#define SBP_ORIENT_EULER_INS_NAVIGATION_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_ORIENT_EULER_INS_NAVIGATION_MODE_SHIFT) & \ SBP_ORIENT_EULER_INS_NAVIGATION_MODE_MASK)) -#define SBP_ORIENT_EULER_INS_NAVIGATION_MODE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_ORIENT_EULER_INS_NAVIGATION_MODE_MASK)) \ - << (SBP_ORIENT_EULER_INS_NAVIGATION_MODE_SHIFT))); \ +#define SBP_ORIENT_EULER_INS_NAVIGATION_MODE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_ORIENT_EULER_INS_NAVIGATION_MODE_MASK \ + << SBP_ORIENT_EULER_INS_NAVIGATION_MODE_SHIFT))) | \ + (((val) & (SBP_ORIENT_EULER_INS_NAVIGATION_MODE_MASK)) \ + << (SBP_ORIENT_EULER_INS_NAVIGATION_MODE_SHIFT))); \ } while (0) #define SBP_ORIENT_EULER_INS_NAVIGATION_MODE_INVALID (0) @@ -83,16 +89,18 @@ #define SBP_MSG_ORIENT_EULER_ENCODED_LEN 29u #define SBP_MSG_ANGULAR_RATE 0x0222 -#define SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_MASK (0x7) +#define SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_MASK (0x7u) #define SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_SHIFT (0u) -#define SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_SHIFT) & \ +#define SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_SHIFT) & \ SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_MASK)) -#define SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_MASK)) \ - << (SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_SHIFT))); \ +#define SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_MASK \ + << SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_SHIFT))) | \ + (((val) & (SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_MASK)) \ + << (SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_SHIFT))); \ } while (0) #define SBP_ANGULAR_RATE_INS_NAVIGATION_MODE_INVALID (0) diff --git a/c/include/libsbp/piksi_macros.h b/c/include/libsbp/piksi_macros.h index a0dfc0152a..651616a3c5 100644 --- a/c/include/libsbp/piksi_macros.h +++ b/c/include/libsbp/piksi_macros.h @@ -33,15 +33,17 @@ #define SBP_MSG_SET_TIME_ENCODED_LEN 0u #define SBP_MSG_RESET 0x00B6 -#define SBP_RESET_DEFAULT_SETTINGS_MASK (0x1) +#define SBP_RESET_DEFAULT_SETTINGS_MASK (0x1u) #define SBP_RESET_DEFAULT_SETTINGS_SHIFT (0u) -#define SBP_RESET_DEFAULT_SETTINGS_GET(flags) \ - ((u32)(((flags) >> SBP_RESET_DEFAULT_SETTINGS_SHIFT) & \ +#define SBP_RESET_DEFAULT_SETTINGS_GET(flags) \ + ((u32)((u32)((flags) >> SBP_RESET_DEFAULT_SETTINGS_SHIFT) & \ SBP_RESET_DEFAULT_SETTINGS_MASK)) -#define SBP_RESET_DEFAULT_SETTINGS_SET(flags, val) \ - do { \ - (flags) = (u32)((flags) | (((val) & (SBP_RESET_DEFAULT_SETTINGS_MASK)) \ - << (SBP_RESET_DEFAULT_SETTINGS_SHIFT))); \ +#define SBP_RESET_DEFAULT_SETTINGS_SET(flags, val) \ + do { \ + (flags) = (u32)((flags & (~(SBP_RESET_DEFAULT_SETTINGS_MASK \ + << SBP_RESET_DEFAULT_SETTINGS_SHIFT))) | \ + (((val) & (SBP_RESET_DEFAULT_SETTINGS_MASK)) \ + << (SBP_RESET_DEFAULT_SETTINGS_SHIFT))); \ } while (0) #define SBP_RESET_DEFAULT_SETTINGS_PRESERVE_EXISTING_SETTINGS (0) @@ -74,17 +76,18 @@ #define SBP_MSG_CW_START_ENCODED_LEN 0u #define SBP_MSG_RESET_FILTERS 0x0022 -#define SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_MASK (0x3) +#define SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_MASK (0x3u) #define SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_SHIFT (0u) -#define SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_GET(flags) \ - ((u8)(((flags) >> SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_SHIFT) & \ +#define SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_GET(flags) \ + ((u8)((u8)((flags) >> SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_SHIFT) & \ SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_MASK)) -#define SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | \ - (((val) & (SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_MASK)) \ - << (SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_SHIFT))); \ +#define SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_MASK \ + << SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_SHIFT))) | \ + (((val) & (SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_MASK)) \ + << (SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_SHIFT))); \ } while (0) #define SBP_RESET_FILTERS_FILTER_OR_PROCESS_TO_RESET_DGNSS_FILTER (0) @@ -157,31 +160,35 @@ #define SBP_MSG_IAR_STATE_ENCODED_LEN 4u #define SBP_MSG_MASK_SATELLITE 0x002B -#define SBP_MASK_SATELLITE_TRACKING_CHANNELS_MASK (0x1) +#define SBP_MASK_SATELLITE_TRACKING_CHANNELS_MASK (0x1u) #define SBP_MASK_SATELLITE_TRACKING_CHANNELS_SHIFT (1u) -#define SBP_MASK_SATELLITE_TRACKING_CHANNELS_GET(flags) \ - ((u8)(((flags) >> SBP_MASK_SATELLITE_TRACKING_CHANNELS_SHIFT) & \ +#define SBP_MASK_SATELLITE_TRACKING_CHANNELS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_MASK_SATELLITE_TRACKING_CHANNELS_SHIFT) & \ SBP_MASK_SATELLITE_TRACKING_CHANNELS_MASK)) -#define SBP_MASK_SATELLITE_TRACKING_CHANNELS_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_MASK_SATELLITE_TRACKING_CHANNELS_MASK)) \ - << (SBP_MASK_SATELLITE_TRACKING_CHANNELS_SHIFT))); \ +#define SBP_MASK_SATELLITE_TRACKING_CHANNELS_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_MASK_SATELLITE_TRACKING_CHANNELS_MASK \ + << SBP_MASK_SATELLITE_TRACKING_CHANNELS_SHIFT))) | \ + (((val) & (SBP_MASK_SATELLITE_TRACKING_CHANNELS_MASK)) \ + << (SBP_MASK_SATELLITE_TRACKING_CHANNELS_SHIFT))); \ } while (0) #define SBP_MASK_SATELLITE_TRACKING_CHANNELS_ENABLED (0) #define SBP_MASK_SATELLITE_TRACKING_CHANNELS_DROP_THIS_PRN_IF_CURRENTLY_TRACKING \ (1) -#define SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_MASK (0x1) +#define SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_MASK (0x1u) #define SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_SHIFT (0u) -#define SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_GET(flags) \ - ((u8)(((flags) >> SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_SHIFT) & \ +#define SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_GET(flags) \ + ((u8)((u8)((flags) >> SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_SHIFT) & \ SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_MASK)) -#define SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_MASK)) \ - << (SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_SHIFT))); \ +#define SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_MASK \ + << SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_SHIFT))) | \ + (((val) & (SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_MASK)) \ + << (SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_SHIFT))); \ } while (0) #define SBP_MASK_SATELLITE_ACQUISITION_CHANNEL_ENABLED (0) @@ -194,31 +201,35 @@ #define SBP_MSG_MASK_SATELLITE_ENCODED_LEN 3u #define SBP_MSG_MASK_SATELLITE_DEP 0x001B -#define SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_MASK (0x1) +#define SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_MASK (0x1u) #define SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_SHIFT (1u) -#define SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_GET(flags) \ - ((u8)(((flags) >> SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_SHIFT) & \ +#define SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_SHIFT) & \ SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_MASK)) -#define SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | \ - (((val) & (SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_MASK)) \ - << (SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_SHIFT))); \ +#define SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_MASK \ + << SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_SHIFT))) | \ + (((val) & (SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_MASK)) \ + << (SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_SHIFT))); \ } while (0) #define SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_ENABLED (0) #define SBP_MASK_SATELLITE_DEP_TRACKING_CHANNELS_DROP_THIS_PRN_IF_CURRENTLY_TRACKING \ (1) -#define SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_MASK (0x1) +#define SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_MASK (0x1u) #define SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_SHIFT (0u) -#define SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_GET(flags) \ - ((u8)(((flags) >> SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_SHIFT) & \ +#define SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_GET(flags) \ + ((u8)((u8)((flags) >> SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_SHIFT) & \ SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_MASK)) -#define SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_SET(flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | (((val) & (SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_MASK)) \ - << (SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_SHIFT))); \ +#define SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_MASK \ + << SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_SHIFT))) | \ + (((val) & (SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_MASK)) \ + << (SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_SHIFT))); \ } while (0) #define SBP_MASK_SATELLITE_DEP_ACQUISITION_CHANNEL_ENABLED (0) @@ -322,282 +333,330 @@ */ #define SBP_MSG_NETWORK_STATE_RESP_INTERFACE_NAME_MAX 16u -#define SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_MASK (0x1) +#define SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_MASK (0x1u) #define SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_SHIFT (15u) -#define SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_GET(flags) \ - ((u32)(((flags) >> \ - SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_SHIFT) & \ - SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_MASK)) -#define SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_SET(flags, \ - val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_MASK)) \ - << (SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_SHIFT))); \ +#define SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_GET(flags) \ + ((u32)( \ + (u32)((flags) >> \ + SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_SHIFT) & \ + SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_MASK)) +#define SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_SET(flags, \ + val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_SHIFT))) | \ + (((val) & \ + (SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_MASK)) \ + << (SBP_NETWORK_STATE_RESP_IFF_MULTICAST__SUPPORTS_MULTICAST_SHIFT))); \ } while (0) -#define SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_MASK (0x1) +#define SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_MASK (0x1u) #define SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_SHIFT (14u) -#define SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_GET( \ - flags) \ - ((u32)( \ - ((flags) >> \ - SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_SHIFT) & \ +#define SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_GET( \ + flags) \ + ((u32)( \ + (u32)( \ + (flags) >> \ + SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_SHIFT) & \ SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_MASK)) -#define SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_SET( \ - flags, val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_MASK)) \ - << (SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_SHIFT))); \ +#define SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_SET( \ + flags, val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_SHIFT))) | \ + (((val) & \ + (SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_MASK)) \ + << (SBP_NETWORK_STATE_RESP_IFF_LINK2__PER_LINK_LAYER_DEFINED_BIT_SHIFT))); \ } while (0) -#define SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_MASK (0x1) +#define SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_MASK (0x1u) #define SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_SHIFT (13u) -#define SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_GET( \ - flags) \ - ((u32)( \ - ((flags) >> \ - SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_SHIFT) & \ +#define SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_GET( \ + flags) \ + ((u32)( \ + (u32)( \ + (flags) >> \ + SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_SHIFT) & \ SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_MASK)) -#define SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_SET( \ - flags, val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_MASK)) \ - << (SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_SHIFT))); \ +#define SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_SET( \ + flags, val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_SHIFT))) | \ + (((val) & \ + (SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_MASK)) \ + << (SBP_NETWORK_STATE_RESP_IFF_LINK1__PER_LINK_LAYER_DEFINED_BIT_SHIFT))); \ } while (0) -#define SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_MASK (0x1) +#define SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_MASK (0x1u) #define SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_SHIFT (12u) -#define SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_GET( \ - flags) \ - ((u32)( \ - ((flags) >> \ - SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_SHIFT) & \ +#define SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_GET( \ + flags) \ + ((u32)( \ + (u32)( \ + (flags) >> \ + SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_SHIFT) & \ SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_MASK)) -#define SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_SET( \ - flags, val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_MASK)) \ - << (SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_SHIFT))); \ +#define SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_SET( \ + flags, val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_SHIFT))) | \ + (((val) & \ + (SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_MASK)) \ + << (SBP_NETWORK_STATE_RESP_IFF_LINK0__PER_LINK_LAYER_DEFINED_BIT_SHIFT))); \ } while (0) #define SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_MASK \ - (0x1) + (0x1u) #define SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_SHIFT \ (11u) -#define SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_GET( \ +#define SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_GET( \ + flags) \ + ((u32)( \ + (u32)( \ + (flags) >> \ + SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_SHIFT) & \ + SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_MASK)) +#define SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_SET( \ + flags, val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_SHIFT))) | \ + (((val) & \ + (SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_MASK)) \ + << (SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_SHIFT))); \ + } while (0) + +#define SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_MASK (0x1u) +#define SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_SHIFT (10u) +#define SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_GET( \ flags) \ ((u32)( \ - ((flags) >> \ - SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_SHIFT) & \ - SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_MASK)) -#define SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_SET( \ + (u32)( \ + (flags) >> \ + SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_SHIFT) & \ + SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_MASK)) +#define SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_SET( \ flags, val) \ do { \ (flags) = (u32)( \ - (flags) | \ + (flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_SHIFT))) | \ (((val) & \ - (SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_MASK)) \ - << (SBP_NETWORK_STATE_RESP_IFF_SIMPLEX__CANT_HEAR_OWN_TRANSMISSIONS_SHIFT))); \ - } while (0) - -#define SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_MASK (0x1) -#define SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_SHIFT (10u) -#define SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_GET( \ - flags) \ - ((u32)( \ - ((flags) >> \ - SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_SHIFT) & \ - SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_MASK)) -#define SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_SET( \ - flags, val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_MASK)) \ - << (SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_SHIFT))); \ + (SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_MASK)) \ + << (SBP_NETWORK_STATE_RESP_IFF_OACTIVE__TRANSMISSION_IN_PROGRESS_SHIFT))); \ } while (0) #define SBP_NETWORK_STATE_RESP_IFF_ALLMULTI__RECEIVE_ALL_MULTICAST_PACKETS_MASK \ - (0x1) + (0x1u) #define SBP_NETWORK_STATE_RESP_IFF_ALLMULTI__RECEIVE_ALL_MULTICAST_PACKETS_SHIFT \ (9u) -#define SBP_NETWORK_STATE_RESP_IFF_ALLMULTI__RECEIVE_ALL_MULTICAST_PACKETS_GET( \ - flags) \ - ((u32)( \ - ((flags) >> \ - SBP_NETWORK_STATE_RESP_IFF_ALLMULTI__RECEIVE_ALL_MULTICAST_PACKETS_SHIFT) & \ +#define SBP_NETWORK_STATE_RESP_IFF_ALLMULTI__RECEIVE_ALL_MULTICAST_PACKETS_GET( \ + flags) \ + ((u32)( \ + (u32)( \ + (flags) >> \ + SBP_NETWORK_STATE_RESP_IFF_ALLMULTI__RECEIVE_ALL_MULTICAST_PACKETS_SHIFT) & \ SBP_NETWORK_STATE_RESP_IFF_ALLMULTI__RECEIVE_ALL_MULTICAST_PACKETS_MASK)) -#define SBP_NETWORK_STATE_RESP_IFF_ALLMULTI__RECEIVE_ALL_MULTICAST_PACKETS_SET( \ - flags, val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_NETWORK_STATE_RESP_IFF_ALLMULTI__RECEIVE_ALL_MULTICAST_PACKETS_MASK)) \ - << (SBP_NETWORK_STATE_RESP_IFF_ALLMULTI__RECEIVE_ALL_MULTICAST_PACKETS_SHIFT))); \ +#define SBP_NETWORK_STATE_RESP_IFF_ALLMULTI__RECEIVE_ALL_MULTICAST_PACKETS_SET( \ + flags, val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_ALLMULTI__RECEIVE_ALL_MULTICAST_PACKETS_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_ALLMULTI__RECEIVE_ALL_MULTICAST_PACKETS_SHIFT))) | \ + (((val) & \ + (SBP_NETWORK_STATE_RESP_IFF_ALLMULTI__RECEIVE_ALL_MULTICAST_PACKETS_MASK)) \ + << (SBP_NETWORK_STATE_RESP_IFF_ALLMULTI__RECEIVE_ALL_MULTICAST_PACKETS_SHIFT))); \ } while (0) -#define SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_MASK (0x1) +#define SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_MASK (0x1u) #define SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_SHIFT (8u) -#define SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_GET(flags) \ - ((u32)(((flags) >> \ - SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_SHIFT) & \ - SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_MASK)) -#define SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_SET(flags, \ - val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_MASK)) \ - << (SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_SHIFT))); \ +#define SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_GET(flags) \ + ((u32)( \ + (u32)((flags) >> \ + SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_SHIFT) & \ + SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_MASK)) +#define SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_SET(flags, \ + val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_SHIFT))) | \ + (((val) & \ + (SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_MASK)) \ + << (SBP_NETWORK_STATE_RESP_IFF_PROMISC__RECEIVE_ALL_PACKETS_SHIFT))); \ } while (0) #define SBP_NETWORK_STATE_RESP_IFF_NOARP__NO_ADDRESS_RESOLUTION_PROTOCOL_MASK \ - (0x1) + (0x1u) #define SBP_NETWORK_STATE_RESP_IFF_NOARP__NO_ADDRESS_RESOLUTION_PROTOCOL_SHIFT \ (7u) -#define SBP_NETWORK_STATE_RESP_IFF_NOARP__NO_ADDRESS_RESOLUTION_PROTOCOL_GET( \ - flags) \ - ((u32)( \ - ((flags) >> \ - SBP_NETWORK_STATE_RESP_IFF_NOARP__NO_ADDRESS_RESOLUTION_PROTOCOL_SHIFT) & \ +#define SBP_NETWORK_STATE_RESP_IFF_NOARP__NO_ADDRESS_RESOLUTION_PROTOCOL_GET( \ + flags) \ + ((u32)( \ + (u32)( \ + (flags) >> \ + SBP_NETWORK_STATE_RESP_IFF_NOARP__NO_ADDRESS_RESOLUTION_PROTOCOL_SHIFT) & \ SBP_NETWORK_STATE_RESP_IFF_NOARP__NO_ADDRESS_RESOLUTION_PROTOCOL_MASK)) -#define SBP_NETWORK_STATE_RESP_IFF_NOARP__NO_ADDRESS_RESOLUTION_PROTOCOL_SET( \ - flags, val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_NETWORK_STATE_RESP_IFF_NOARP__NO_ADDRESS_RESOLUTION_PROTOCOL_MASK)) \ - << (SBP_NETWORK_STATE_RESP_IFF_NOARP__NO_ADDRESS_RESOLUTION_PROTOCOL_SHIFT))); \ +#define SBP_NETWORK_STATE_RESP_IFF_NOARP__NO_ADDRESS_RESOLUTION_PROTOCOL_SET( \ + flags, val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_NOARP__NO_ADDRESS_RESOLUTION_PROTOCOL_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_NOARP__NO_ADDRESS_RESOLUTION_PROTOCOL_SHIFT))) | \ + (((val) & \ + (SBP_NETWORK_STATE_RESP_IFF_NOARP__NO_ADDRESS_RESOLUTION_PROTOCOL_MASK)) \ + << (SBP_NETWORK_STATE_RESP_IFF_NOARP__NO_ADDRESS_RESOLUTION_PROTOCOL_SHIFT))); \ } while (0) -#define SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_MASK (0x1) +#define SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_MASK (0x1u) #define SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_SHIFT (6u) -#define SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_GET(flags) \ - ((u32)(((flags) >> \ - SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_SHIFT) & \ - SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_MASK)) -#define SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_SET(flags, \ - val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_MASK)) \ - << (SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_SHIFT))); \ +#define SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_GET(flags) \ + ((u32)( \ + (u32)((flags) >> \ + SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_SHIFT) & \ + SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_MASK)) +#define SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_SET(flags, \ + val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_SHIFT))) | \ + (((val) & \ + (SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_MASK)) \ + << (SBP_NETWORK_STATE_RESP_IFF_RUNNING__RESOURCES_ALLOCATED_SHIFT))); \ } while (0) -#define SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_MASK (0x1) +#define SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_MASK (0x1u) #define SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_SHIFT (5u) -#define SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_GET( \ - flags) \ - ((u32)( \ - ((flags) >> \ - SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_SHIFT) & \ +#define SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_GET( \ + flags) \ + ((u32)( \ + (u32)( \ + (flags) >> \ + SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_SHIFT) & \ SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_MASK)) -#define SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_SET( \ - flags, val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_MASK)) \ - << (SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_SHIFT))); \ +#define SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_SET( \ + flags, val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_SHIFT))) | \ + (((val) & \ + (SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_MASK)) \ + << (SBP_NETWORK_STATE_RESP_IFF_NOTRAILERS__AVOID_USE_OF_TRAILERS_SHIFT))); \ } while (0) #define SBP_NETWORK_STATE_RESP_IFF_POINTOPOINT__INTERFACE_IS_POINTTOPOINT_LINK_MASK \ - (0x1) + (0x1u) #define SBP_NETWORK_STATE_RESP_IFF_POINTOPOINT__INTERFACE_IS_POINTTOPOINT_LINK_SHIFT \ (4u) -#define SBP_NETWORK_STATE_RESP_IFF_POINTOPOINT__INTERFACE_IS_POINTTOPOINT_LINK_GET( \ - flags) \ - ((u32)( \ - ((flags) >> \ - SBP_NETWORK_STATE_RESP_IFF_POINTOPOINT__INTERFACE_IS_POINTTOPOINT_LINK_SHIFT) & \ +#define SBP_NETWORK_STATE_RESP_IFF_POINTOPOINT__INTERFACE_IS_POINTTOPOINT_LINK_GET( \ + flags) \ + ((u32)( \ + (u32)( \ + (flags) >> \ + SBP_NETWORK_STATE_RESP_IFF_POINTOPOINT__INTERFACE_IS_POINTTOPOINT_LINK_SHIFT) & \ SBP_NETWORK_STATE_RESP_IFF_POINTOPOINT__INTERFACE_IS_POINTTOPOINT_LINK_MASK)) -#define SBP_NETWORK_STATE_RESP_IFF_POINTOPOINT__INTERFACE_IS_POINTTOPOINT_LINK_SET( \ - flags, val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_NETWORK_STATE_RESP_IFF_POINTOPOINT__INTERFACE_IS_POINTTOPOINT_LINK_MASK)) \ - << (SBP_NETWORK_STATE_RESP_IFF_POINTOPOINT__INTERFACE_IS_POINTTOPOINT_LINK_SHIFT))); \ +#define SBP_NETWORK_STATE_RESP_IFF_POINTOPOINT__INTERFACE_IS_POINTTOPOINT_LINK_SET( \ + flags, val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_POINTOPOINT__INTERFACE_IS_POINTTOPOINT_LINK_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_POINTOPOINT__INTERFACE_IS_POINTTOPOINT_LINK_SHIFT))) | \ + (((val) & \ + (SBP_NETWORK_STATE_RESP_IFF_POINTOPOINT__INTERFACE_IS_POINTTOPOINT_LINK_MASK)) \ + << (SBP_NETWORK_STATE_RESP_IFF_POINTOPOINT__INTERFACE_IS_POINTTOPOINT_LINK_SHIFT))); \ } while (0) -#define SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_MASK (0x1) +#define SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_MASK (0x1u) #define SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_SHIFT (3u) -#define SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_GET(flags) \ - ((u32)(((flags) >> \ - SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_SHIFT) & \ +#define SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_GET(flags) \ + ((u32)((u32)((flags) >> \ + SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_SHIFT) & \ SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_MASK)) -#define SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_SET(flags, val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_MASK)) \ - << (SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_SHIFT))); \ - } while (0) - -#define SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_MASK (0x1) -#define SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_SHIFT (2u) -#define SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_GET(flags) \ - ((u32)(((flags) >> \ - SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_SHIFT) & \ - SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_MASK)) -#define SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_SET(flags, \ - val) \ +#define SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_SET(flags, val) \ do { \ (flags) = (u32)( \ - (flags) | \ + (flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_SHIFT))) | \ (((val) & \ - (SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_MASK)) \ - << (SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_SHIFT))); \ + (SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_MASK)) \ + << (SBP_NETWORK_STATE_RESP_IFF_LOOPBACK__IS_A_LOOPBACK_NET_SHIFT))); \ } while (0) -#define SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_MASK (0x1) +#define SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_MASK (0x1u) +#define SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_SHIFT (2u) +#define SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_GET(flags) \ + ((u32)( \ + (u32)((flags) >> \ + SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_SHIFT) & \ + SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_MASK)) +#define SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_SET(flags, \ + val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_SHIFT))) | \ + (((val) & \ + (SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_MASK)) \ + << (SBP_NETWORK_STATE_RESP_IFF_DEBUG__BROADCAST_ADDRESS_VALID_SHIFT))); \ + } while (0) + +#define SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_MASK \ + (0x1u) #define SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_SHIFT (1u) -#define SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_GET( \ - flags) \ - ((u32)( \ - ((flags) >> \ - SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_SHIFT) & \ +#define SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_GET( \ + flags) \ + ((u32)( \ + (u32)( \ + (flags) >> \ + SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_SHIFT) & \ SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_MASK)) -#define SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_SET( \ - flags, val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_MASK)) \ - << (SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_SHIFT))); \ +#define SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_SET( \ + flags, val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_SHIFT))) | \ + (((val) & \ + (SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_MASK)) \ + << (SBP_NETWORK_STATE_RESP_IFF_BROADCAST__BROADCAST_ADDRESS_VALID_SHIFT))); \ } while (0) -#define SBP_NETWORK_STATE_RESP_IFF_UP__INTERFACE_IS_UP_MASK (0x1) +#define SBP_NETWORK_STATE_RESP_IFF_UP__INTERFACE_IS_UP_MASK (0x1u) #define SBP_NETWORK_STATE_RESP_IFF_UP__INTERFACE_IS_UP_SHIFT (0u) -#define SBP_NETWORK_STATE_RESP_IFF_UP__INTERFACE_IS_UP_GET(flags) \ - ((u32)(((flags) >> SBP_NETWORK_STATE_RESP_IFF_UP__INTERFACE_IS_UP_SHIFT) & \ - SBP_NETWORK_STATE_RESP_IFF_UP__INTERFACE_IS_UP_MASK)) +#define SBP_NETWORK_STATE_RESP_IFF_UP__INTERFACE_IS_UP_GET(flags) \ + ((u32)( \ + (u32)((flags) >> SBP_NETWORK_STATE_RESP_IFF_UP__INTERFACE_IS_UP_SHIFT) & \ + SBP_NETWORK_STATE_RESP_IFF_UP__INTERFACE_IS_UP_MASK)) #define SBP_NETWORK_STATE_RESP_IFF_UP__INTERFACE_IS_UP_SET(flags, val) \ do { \ (flags) = \ - (u32)((flags) | \ + (u32)((flags & \ + (~(SBP_NETWORK_STATE_RESP_IFF_UP__INTERFACE_IS_UP_MASK \ + << SBP_NETWORK_STATE_RESP_IFF_UP__INTERFACE_IS_UP_SHIFT))) | \ (((val) & (SBP_NETWORK_STATE_RESP_IFF_UP__INTERFACE_IS_UP_MASK)) \ << (SBP_NETWORK_STATE_RESP_IFF_UP__INTERFACE_IS_UP_SHIFT))); \ } while (0) diff --git a/c/include/libsbp/settings_macros.h b/c/include/libsbp/settings_macros.h index ee6d825897..3611fcecb1 100644 --- a/c/include/libsbp/settings_macros.h +++ b/c/include/libsbp/settings_macros.h @@ -49,16 +49,18 @@ #define SBP_MSG_SETTINGS_WRITE_ENCODED_OVERHEAD 0u #define SBP_MSG_SETTINGS_WRITE_RESP 0x00AF -#define SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_MASK (0x3) +#define SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_MASK (0x3u) #define SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_SHIFT (0u) -#define SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_GET(flags) \ - ((u8)(((flags) >> SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_SHIFT) & \ +#define SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_SHIFT) & \ SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_MASK)) -#define SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_MASK)) \ - << (SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_SHIFT))); \ +#define SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_MASK \ + << SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_SHIFT))) | \ + (((val) & (SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_MASK)) \ + << (SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_SHIFT))); \ } while (0) #define SBP_SETTINGS_WRITE_RESP_WRITE_STATUS_ACCEPTED_VALUE_UPDATED (0) @@ -206,16 +208,18 @@ #define SBP_MSG_SETTINGS_REGISTER_ENCODED_OVERHEAD 0u #define SBP_MSG_SETTINGS_REGISTER_RESP 0x01AF -#define SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_MASK (0x3) +#define SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_MASK (0x3u) #define SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_SHIFT (0u) -#define SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_GET(flags) \ - ((u8)(((flags) >> SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_SHIFT) & \ +#define SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_SHIFT) & \ SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_MASK)) -#define SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_SET(flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | (((val) & (SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_MASK)) \ - << (SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_SHIFT))); \ +#define SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_MASK \ + << SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_SHIFT))) | \ + (((val) & (SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_MASK)) \ + << (SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_SHIFT))); \ } while (0) #define SBP_SETTINGS_REGISTER_RESP_REGISTER_STATUS_ACCEPTED_REQUESTED_DEFAULT_VALUE_RETURNED \ diff --git a/c/include/libsbp/solution_meta_macros.h b/c/include/libsbp/solution_meta_macros.h index aef24e5862..7bb333cc5b 100644 --- a/c/include/libsbp/solution_meta_macros.h +++ b/c/include/libsbp/solution_meta_macros.h @@ -18,31 +18,34 @@ #ifndef LIBSBP_SOLUTION_META_MACROS_H #define LIBSBP_SOLUTION_META_MACROS_H -#define SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_MASK (0x3) +#define SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_MASK (0x3u) #define SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_SHIFT (3u) -#define SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_GET(flags) \ - ((u8)(((flags) >> SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_SHIFT) & \ +#define SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_SHIFT) & \ SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_MASK)) -#define SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_MASK)) \ - << (SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_SHIFT))); \ +#define SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_MASK \ + << SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_SHIFT))) | \ + (((val) & (SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_MASK)) \ + << (SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_SHIFT))); \ } while (0) #define SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_UNKNOWN (0) #define SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_RECEIVED_AND_USED (1) #define SBP_SOLUTIONINPUTTYPE_SENSOR_USAGE_RECEIVED_BUT_NOT_USED (2) -#define SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_MASK (0x7) +#define SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_MASK (0x7u) #define SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_SHIFT (0u) -#define SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_GET(flags) \ - ((u8)(((flags) >> SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_SHIFT) & \ +#define SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_SHIFT) & \ SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_MASK)) -#define SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_MASK)) \ - << (SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_SHIFT))); \ +#define SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_MASK \ + << SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_SHIFT))) | \ + (((val) & (SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_MASK)) \ + << (SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_SHIFT))); \ } while (0) #define SBP_SOLUTIONINPUTTYPE_SENSOR_TYPE_INVALID (0) @@ -59,16 +62,18 @@ #define SBP_SOLUTION_INPUT_TYPE_ENCODED_LEN 2u #define SBP_MSG_SOLN_META_DEP_A 0xFF0F -#define SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_MASK (0x7) +#define SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_MASK (0x7u) #define SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_SHIFT (0u) -#define SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_GET(flags) \ - ((u8)(((flags) >> SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_SHIFT) & \ +#define SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_SHIFT) & \ SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_MASK)) -#define SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_MASK)) \ - << (SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_SHIFT))); \ +#define SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_MASK \ + << SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_SHIFT))) | \ + (((val) & (SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_MASK)) \ + << (SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_SHIFT))); \ } while (0) #define SBP_SOLN_META_DEP_A_ALIGNMENT_STATUS_UNKNOWN_REASON_OR_ALREADY_ALIGNED \ @@ -104,34 +109,40 @@ #define SBP_MSG_SOLN_META_DEP_A_ENCODED_OVERHEAD 18u #define SBP_MSG_SOLN_META 0xFF0E -#define SBP_SOLN_META_TIME_STATUS_MASK (0x3) +#define SBP_SOLN_META_TIME_STATUS_MASK (0x3u) #define SBP_SOLN_META_TIME_STATUS_SHIFT (30u) -#define SBP_SOLN_META_TIME_STATUS_GET(flags) \ - ((u32)(((flags) >> SBP_SOLN_META_TIME_STATUS_SHIFT) & \ +#define SBP_SOLN_META_TIME_STATUS_GET(flags) \ + ((u32)((u32)((flags) >> SBP_SOLN_META_TIME_STATUS_SHIFT) & \ SBP_SOLN_META_TIME_STATUS_MASK)) -#define SBP_SOLN_META_TIME_STATUS_SET(flags, val) \ - do { \ - (flags) = (u32)((flags) | (((val) & (SBP_SOLN_META_TIME_STATUS_MASK)) \ - << (SBP_SOLN_META_TIME_STATUS_SHIFT))); \ +#define SBP_SOLN_META_TIME_STATUS_SET(flags, val) \ + do { \ + (flags) = (u32)((flags & (~(SBP_SOLN_META_TIME_STATUS_MASK \ + << SBP_SOLN_META_TIME_STATUS_SHIFT))) | \ + (((val) & (SBP_SOLN_META_TIME_STATUS_MASK)) \ + << (SBP_SOLN_META_TIME_STATUS_SHIFT))); \ } while (0) #define SBP_SOLN_META_TIME_STATUS_AGE_CAN_NOT_BE_USED_TO_RETRIEVE_TOM (0) #define SBP_SOLN_META_TIME_STATUS_AGE_CAN_BE_USED_TO_RETRIEVE_TOM (1) #define SBP_SOLN_META_AGE_OF_THE_LAST_RECEIVED_VALID_GNSS_SOLUTION_MASK \ - (0x3fffffff) + (0x3fffffffu) #define SBP_SOLN_META_AGE_OF_THE_LAST_RECEIVED_VALID_GNSS_SOLUTION_SHIFT (0u) #define SBP_SOLN_META_AGE_OF_THE_LAST_RECEIVED_VALID_GNSS_SOLUTION_GET(flags) \ - ((u32)(((flags) >> \ + ((u32)( \ + (u32)( \ + (flags) >> \ SBP_SOLN_META_AGE_OF_THE_LAST_RECEIVED_VALID_GNSS_SOLUTION_SHIFT) & \ - SBP_SOLN_META_AGE_OF_THE_LAST_RECEIVED_VALID_GNSS_SOLUTION_MASK)) -#define SBP_SOLN_META_AGE_OF_THE_LAST_RECEIVED_VALID_GNSS_SOLUTION_SET(flags, \ - val) \ - do { \ - (flags) = (u32)( \ - (flags) | \ - (((val) & \ - (SBP_SOLN_META_AGE_OF_THE_LAST_RECEIVED_VALID_GNSS_SOLUTION_MASK)) \ - << (SBP_SOLN_META_AGE_OF_THE_LAST_RECEIVED_VALID_GNSS_SOLUTION_SHIFT))); \ + SBP_SOLN_META_AGE_OF_THE_LAST_RECEIVED_VALID_GNSS_SOLUTION_MASK)) +#define SBP_SOLN_META_AGE_OF_THE_LAST_RECEIVED_VALID_GNSS_SOLUTION_SET(flags, \ + val) \ + do { \ + (flags) = (u32)( \ + (flags & \ + (~(SBP_SOLN_META_AGE_OF_THE_LAST_RECEIVED_VALID_GNSS_SOLUTION_MASK \ + << SBP_SOLN_META_AGE_OF_THE_LAST_RECEIVED_VALID_GNSS_SOLUTION_SHIFT))) | \ + (((val) & \ + (SBP_SOLN_META_AGE_OF_THE_LAST_RECEIVED_VALID_GNSS_SOLUTION_MASK)) \ + << (SBP_SOLN_META_AGE_OF_THE_LAST_RECEIVED_VALID_GNSS_SOLUTION_SHIFT))); \ } while (0) /** @@ -156,16 +167,18 @@ */ #define SBP_MSG_SOLN_META_ENCODED_OVERHEAD 16u -#define SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_MASK (0x3) +#define SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_MASK (0x3u) #define SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_SHIFT (0u) -#define SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_GET(flags) \ - ((u8)(((flags) >> SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_SHIFT) & \ +#define SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_GET(flags) \ + ((u8)((u8)((flags) >> SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_SHIFT) & \ SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_MASK)) -#define SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_SET(flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | (((val) & (SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_MASK)) \ - << (SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_SHIFT))); \ +#define SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_MASK \ + << SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_SHIFT))) | \ + (((val) & (SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_MASK)) \ + << (SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_SHIFT))); \ } while (0) #define SBP_GNSSINPUTTYPE_TYPE_OF_GNSS_MEASUREMENT_GNSS_POSITION (0) @@ -178,15 +191,17 @@ */ #define SBP_GNSS_INPUT_TYPE_ENCODED_LEN 1u -#define SBP_IMUINPUTTYPE_TIME_STATUS_MASK (0x3) +#define SBP_IMUINPUTTYPE_TIME_STATUS_MASK (0x3u) #define SBP_IMUINPUTTYPE_TIME_STATUS_SHIFT (4u) -#define SBP_IMUINPUTTYPE_TIME_STATUS_GET(flags) \ - ((u8)(((flags) >> SBP_IMUINPUTTYPE_TIME_STATUS_SHIFT) & \ +#define SBP_IMUINPUTTYPE_TIME_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_IMUINPUTTYPE_TIME_STATUS_SHIFT) & \ SBP_IMUINPUTTYPE_TIME_STATUS_MASK)) -#define SBP_IMUINPUTTYPE_TIME_STATUS_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_IMUINPUTTYPE_TIME_STATUS_MASK)) \ - << (SBP_IMUINPUTTYPE_TIME_STATUS_SHIFT))); \ +#define SBP_IMUINPUTTYPE_TIME_STATUS_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_IMUINPUTTYPE_TIME_STATUS_MASK \ + << SBP_IMUINPUTTYPE_TIME_STATUS_SHIFT))) | \ + (((val) & (SBP_IMUINPUTTYPE_TIME_STATUS_MASK)) \ + << (SBP_IMUINPUTTYPE_TIME_STATUS_SHIFT))); \ } while (0) #define SBP_IMUINPUTTYPE_TIME_STATUS_REFERENCE_EPOCH_IS_START_OF_CURRENT_GPS_WEEK \ @@ -195,31 +210,34 @@ (1) #define SBP_IMUINPUTTYPE_TIME_STATUS_REFERENCE_EPOCH_IS_UNKNOWN (2) #define SBP_IMUINPUTTYPE_TIME_STATUS_REFERENCE_EPOCH_IS_LAST_PPS (3) -#define SBP_IMUINPUTTYPE_IMU_GRADE_MASK (0x3) +#define SBP_IMUINPUTTYPE_IMU_GRADE_MASK (0x3u) #define SBP_IMUINPUTTYPE_IMU_GRADE_SHIFT (2u) -#define SBP_IMUINPUTTYPE_IMU_GRADE_GET(flags) \ - ((u8)(((flags) >> SBP_IMUINPUTTYPE_IMU_GRADE_SHIFT) & \ +#define SBP_IMUINPUTTYPE_IMU_GRADE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_IMUINPUTTYPE_IMU_GRADE_SHIFT) & \ SBP_IMUINPUTTYPE_IMU_GRADE_MASK)) -#define SBP_IMUINPUTTYPE_IMU_GRADE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_IMUINPUTTYPE_IMU_GRADE_MASK)) \ - << (SBP_IMUINPUTTYPE_IMU_GRADE_SHIFT))); \ +#define SBP_IMUINPUTTYPE_IMU_GRADE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_IMUINPUTTYPE_IMU_GRADE_MASK \ + << SBP_IMUINPUTTYPE_IMU_GRADE_SHIFT))) | \ + (((val) & (SBP_IMUINPUTTYPE_IMU_GRADE_MASK)) \ + << (SBP_IMUINPUTTYPE_IMU_GRADE_SHIFT))); \ } while (0) #define SBP_IMUINPUTTYPE_IMU_GRADE_CONSUMER_GRADE (0) #define SBP_IMUINPUTTYPE_IMU_GRADE_TACTICAL_GRADE (1) #define SBP_IMUINPUTTYPE_IMU_GRADE_INTERMEDIATE_GRADE (2) #define SBP_IMUINPUTTYPE_IMU_GRADE_SUPERIOR_GRADE (3) -#define SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_MASK (0x3) +#define SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_MASK (0x3u) #define SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_SHIFT (0u) -#define SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_GET(flags) \ - ((u8)(((flags) >> SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_SHIFT) & \ +#define SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_SHIFT) & \ SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_MASK)) -#define SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_MASK)) \ - << (SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_SHIFT))); \ +#define SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_MASK \ + << SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_SHIFT))) | \ + (((val) & (SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_MASK)) \ + << (SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_SHIFT))); \ } while (0) #define SBP_IMUINPUTTYPE_IMU_ARCHITECTURE_6_AXIS_MEMS (0) @@ -230,41 +248,48 @@ */ #define SBP_IMU_INPUT_TYPE_ENCODED_LEN 1u -#define SBP_ODOINPUTTYPE_RATE_MASK (0x3) +#define SBP_ODOINPUTTYPE_RATE_MASK (0x3u) #define SBP_ODOINPUTTYPE_RATE_SHIFT (4u) -#define SBP_ODOINPUTTYPE_RATE_GET(flags) \ - ((u8)(((flags) >> SBP_ODOINPUTTYPE_RATE_SHIFT) & SBP_ODOINPUTTYPE_RATE_MASK)) -#define SBP_ODOINPUTTYPE_RATE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_ODOINPUTTYPE_RATE_MASK)) \ - << (SBP_ODOINPUTTYPE_RATE_SHIFT))); \ +#define SBP_ODOINPUTTYPE_RATE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_ODOINPUTTYPE_RATE_SHIFT) & \ + SBP_ODOINPUTTYPE_RATE_MASK)) +#define SBP_ODOINPUTTYPE_RATE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_ODOINPUTTYPE_RATE_MASK \ + << SBP_ODOINPUTTYPE_RATE_SHIFT))) | \ + (((val) & (SBP_ODOINPUTTYPE_RATE_MASK)) \ + << (SBP_ODOINPUTTYPE_RATE_SHIFT))); \ } while (0) #define SBP_ODOINPUTTYPE_RATE_FIXED_INCOMING_RATE (0) #define SBP_ODOINPUTTYPE_RATE_TRIGGERED_BY_MINIMUM_DISTANCE_OR_SPEED (1) -#define SBP_ODOINPUTTYPE_ODOMETER_GRADE_MASK (0x3) +#define SBP_ODOINPUTTYPE_ODOMETER_GRADE_MASK (0x3u) #define SBP_ODOINPUTTYPE_ODOMETER_GRADE_SHIFT (2u) -#define SBP_ODOINPUTTYPE_ODOMETER_GRADE_GET(flags) \ - ((u8)(((flags) >> SBP_ODOINPUTTYPE_ODOMETER_GRADE_SHIFT) & \ +#define SBP_ODOINPUTTYPE_ODOMETER_GRADE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_ODOINPUTTYPE_ODOMETER_GRADE_SHIFT) & \ SBP_ODOINPUTTYPE_ODOMETER_GRADE_MASK)) -#define SBP_ODOINPUTTYPE_ODOMETER_GRADE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_ODOINPUTTYPE_ODOMETER_GRADE_MASK)) \ - << (SBP_ODOINPUTTYPE_ODOMETER_GRADE_SHIFT))); \ +#define SBP_ODOINPUTTYPE_ODOMETER_GRADE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_ODOINPUTTYPE_ODOMETER_GRADE_MASK \ + << SBP_ODOINPUTTYPE_ODOMETER_GRADE_SHIFT))) | \ + (((val) & (SBP_ODOINPUTTYPE_ODOMETER_GRADE_MASK)) \ + << (SBP_ODOINPUTTYPE_ODOMETER_GRADE_SHIFT))); \ } while (0) #define SBP_ODOINPUTTYPE_ODOMETER_GRADE_LOW_GRADE (0) #define SBP_ODOINPUTTYPE_ODOMETER_GRADE_MEDIUM_GRADE (1) #define SBP_ODOINPUTTYPE_ODOMETER_GRADE_SUPERIOR_GRADE (2) -#define SBP_ODOINPUTTYPE_ODOMETER_CLASS_MASK (0x3) +#define SBP_ODOINPUTTYPE_ODOMETER_CLASS_MASK (0x3u) #define SBP_ODOINPUTTYPE_ODOMETER_CLASS_SHIFT (0u) -#define SBP_ODOINPUTTYPE_ODOMETER_CLASS_GET(flags) \ - ((u8)(((flags) >> SBP_ODOINPUTTYPE_ODOMETER_CLASS_SHIFT) & \ +#define SBP_ODOINPUTTYPE_ODOMETER_CLASS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_ODOINPUTTYPE_ODOMETER_CLASS_SHIFT) & \ SBP_ODOINPUTTYPE_ODOMETER_CLASS_MASK)) -#define SBP_ODOINPUTTYPE_ODOMETER_CLASS_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_ODOINPUTTYPE_ODOMETER_CLASS_MASK)) \ - << (SBP_ODOINPUTTYPE_ODOMETER_CLASS_SHIFT))); \ +#define SBP_ODOINPUTTYPE_ODOMETER_CLASS_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_ODOINPUTTYPE_ODOMETER_CLASS_MASK \ + << SBP_ODOINPUTTYPE_ODOMETER_CLASS_SHIFT))) | \ + (((val) & (SBP_ODOINPUTTYPE_ODOMETER_CLASS_MASK)) \ + << (SBP_ODOINPUTTYPE_ODOMETER_CLASS_SHIFT))); \ } while (0) #define SBP_ODOINPUTTYPE_ODOMETER_CLASS_SINGLE_OR_AVERAGED_TICKS (0) diff --git a/c/include/libsbp/ssr_macros.h b/c/include/libsbp/ssr_macros.h index 4d0dfcdae4..a3a86456d8 100644 --- a/c/include/libsbp/ssr_macros.h +++ b/c/include/libsbp/ssr_macros.h @@ -187,15 +187,17 @@ */ #define SBP_MSG_SSR_TILE_DEFINITION_ENCODED_LEN 24u -#define SBP_SATELLITEAPC_SATELLITE_TYPE_MASK (0x1f) +#define SBP_SATELLITEAPC_SATELLITE_TYPE_MASK (0x1fu) #define SBP_SATELLITEAPC_SATELLITE_TYPE_SHIFT (0u) -#define SBP_SATELLITEAPC_SATELLITE_TYPE_GET(flags) \ - ((u8)(((flags) >> SBP_SATELLITEAPC_SATELLITE_TYPE_SHIFT) & \ +#define SBP_SATELLITEAPC_SATELLITE_TYPE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_SATELLITEAPC_SATELLITE_TYPE_SHIFT) & \ SBP_SATELLITEAPC_SATELLITE_TYPE_MASK)) -#define SBP_SATELLITEAPC_SATELLITE_TYPE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_SATELLITEAPC_SATELLITE_TYPE_MASK)) \ - << (SBP_SATELLITEAPC_SATELLITE_TYPE_SHIFT))); \ +#define SBP_SATELLITEAPC_SATELLITE_TYPE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_SATELLITEAPC_SATELLITE_TYPE_MASK \ + << SBP_SATELLITEAPC_SATELLITE_TYPE_SHIFT))) | \ + (((val) & (SBP_SATELLITEAPC_SATELLITE_TYPE_MASK)) \ + << (SBP_SATELLITEAPC_SATELLITE_TYPE_SHIFT))); \ } while (0) #define SBP_SATELLITEAPC_SATELLITE_TYPE_UNKNOWN_TYPE (0) diff --git a/c/include/libsbp/system_macros.h b/c/include/libsbp/system_macros.h index 8121fe768d..7a27d126a6 100644 --- a/c/include/libsbp/system_macros.h +++ b/c/include/libsbp/system_macros.h @@ -19,27 +19,29 @@ #define LIBSBP_SYSTEM_MACROS_H #define SBP_MSG_STARTUP 0xFF00 -#define SBP_STARTUP_CAUSE_OF_STARTUP_MASK (0x1ff) +#define SBP_STARTUP_CAUSE_OF_STARTUP_MASK (0x1ffu) #define SBP_STARTUP_CAUSE_OF_STARTUP_SHIFT (0u) -#define SBP_STARTUP_CAUSE_OF_STARTUP_GET(flags) \ - ((u8)(((flags) >> SBP_STARTUP_CAUSE_OF_STARTUP_SHIFT) & \ +#define SBP_STARTUP_CAUSE_OF_STARTUP_GET(flags) \ + ((u8)((u8)((flags) >> SBP_STARTUP_CAUSE_OF_STARTUP_SHIFT) & \ SBP_STARTUP_CAUSE_OF_STARTUP_MASK)) -#define SBP_STARTUP_CAUSE_OF_STARTUP_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_STARTUP_CAUSE_OF_STARTUP_MASK)) \ - << (SBP_STARTUP_CAUSE_OF_STARTUP_SHIFT))); \ +#define SBP_STARTUP_CAUSE_OF_STARTUP_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_STARTUP_CAUSE_OF_STARTUP_MASK \ + << SBP_STARTUP_CAUSE_OF_STARTUP_SHIFT))) | \ + (((val) & (SBP_STARTUP_CAUSE_OF_STARTUP_MASK)) \ + << (SBP_STARTUP_CAUSE_OF_STARTUP_SHIFT))); \ } while (0) #define SBP_STARTUP_CAUSE_OF_STARTUP_POWER_ON (0) #define SBP_STARTUP_CAUSE_OF_STARTUP_SOFTWARE_RESET (1) #define SBP_STARTUP_CAUSE_OF_STARTUP_WATCHDOG_RESET (2) -#define SBP_STARTUP__MASK (0x1ff) +#define SBP_STARTUP__MASK (0x1ffu) #define SBP_STARTUP__SHIFT (0u) #define SBP_STARTUP__GET(flags) \ - ((u8)(((flags) >> SBP_STARTUP__SHIFT) & SBP_STARTUP__MASK)) + ((u8)((u8)((flags) >> SBP_STARTUP__SHIFT) & SBP_STARTUP__MASK)) #define SBP_STARTUP__SET(flags, val) \ do { \ - (flags) = (u8)((flags) | \ + (flags) = (u8)((flags & (~(SBP_STARTUP__MASK << SBP_STARTUP__SHIFT))) | \ (((val) & (SBP_STARTUP__MASK)) << (SBP_STARTUP__SHIFT))); \ } while (0) @@ -55,16 +57,18 @@ #define SBP_MSG_STARTUP_ENCODED_LEN 4u #define SBP_MSG_DGNSS_STATUS 0xFF02 -#define SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_MASK (0xf) +#define SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_MASK (0xfu) #define SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_SHIFT (0u) -#define SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_GET(flags) \ - ((u8)(((flags) >> SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_SHIFT) & \ +#define SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_SHIFT) & \ SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_MASK)) -#define SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_MASK)) \ - << (SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_SHIFT))); \ +#define SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_MASK \ + << SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_SHIFT))) | \ + (((val) & (SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_MASK)) \ + << (SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_SHIFT))); \ } while (0) #define SBP_DGNSS_STATUS_DIFFERENTIAL_TYPE_INVALID (0) @@ -93,96 +97,111 @@ #define SBP_MSG_DGNSS_STATUS_ENCODED_OVERHEAD 4u #define SBP_MSG_HEARTBEAT 0xFFFF -#define SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_MASK (0x1) +#define SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_MASK (0x1u) #define SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_SHIFT (31u) -#define SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_GET(flags) \ - ((u32)(((flags) >> SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_SHIFT) & \ +#define SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_GET(flags) \ + ((u32)((u32)((flags) >> SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_SHIFT) & \ SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_MASK)) -#define SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_SET(flags, val) \ - do { \ - (flags) = (u32)((flags) | \ - (((val) & (SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_MASK)) \ - << (SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_SHIFT))); \ +#define SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_SET(flags, val) \ + do { \ + (flags) = \ + (u32)((flags & (~(SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_MASK \ + << SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_SHIFT))) | \ + (((val) & (SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_MASK)) \ + << (SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_SHIFT))); \ } while (0) #define SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_NO_EXTERNAL_ANTENNA_DETECTED (0) #define SBP_HEARTBEAT_EXTERNAL_ANTENNA_PRESENT_EXTERNAL_ANTENNA_IS_PRESENT (1) -#define SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_MASK (0x1) +#define SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_MASK (0x1u) #define SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_SHIFT (30u) -#define SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_GET(flags) \ - ((u32)(((flags) >> SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_SHIFT) & \ +#define SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_GET(flags) \ + ((u32)((u32)((flags) >> SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_SHIFT) & \ SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_MASK)) -#define SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_SET(flags, val) \ - do { \ - (flags) = \ - (u32)((flags) | (((val) & (SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_MASK)) \ - << (SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_SHIFT))); \ +#define SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_SET(flags, val) \ + do { \ + (flags) = \ + (u32)((flags & (~(SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_MASK \ + << SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_SHIFT))) | \ + (((val) & (SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_MASK)) \ + << (SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_SHIFT))); \ } while (0) #define SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_NO_SHORT_DETECTED (0) #define SBP_HEARTBEAT_EXTERNAL_ANTENNA_SHORT_SHORT_DETECTED (1) -#define SBP_HEARTBEAT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK (0xff) +#define SBP_HEARTBEAT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK (0xffu) #define SBP_HEARTBEAT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT (16u) -#define SBP_HEARTBEAT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_GET(flags) \ - ((u32)(((flags) >> SBP_HEARTBEAT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT) & \ +#define SBP_HEARTBEAT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_GET(flags) \ + ((u32)((u32)((flags) >> \ + SBP_HEARTBEAT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT) & \ SBP_HEARTBEAT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK)) #define SBP_HEARTBEAT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SET(flags, val) \ do { \ (flags) = (u32)( \ - (flags) | \ + (flags & \ + (~(SBP_HEARTBEAT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK \ + << SBP_HEARTBEAT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT))) | \ (((val) & (SBP_HEARTBEAT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK)) \ << (SBP_HEARTBEAT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT))); \ } while (0) -#define SBP_HEARTBEAT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK (0xff) +#define SBP_HEARTBEAT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK (0xffu) #define SBP_HEARTBEAT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT (8u) -#define SBP_HEARTBEAT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_GET(flags) \ - ((u32)(((flags) >> SBP_HEARTBEAT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT) & \ +#define SBP_HEARTBEAT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_GET(flags) \ + ((u32)((u32)((flags) >> \ + SBP_HEARTBEAT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT) & \ SBP_HEARTBEAT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK)) #define SBP_HEARTBEAT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SET(flags, val) \ do { \ (flags) = (u32)( \ - (flags) | \ + (flags & \ + (~(SBP_HEARTBEAT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK \ + << SBP_HEARTBEAT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT))) | \ (((val) & (SBP_HEARTBEAT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK)) \ << (SBP_HEARTBEAT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT))); \ } while (0) -#define SBP_HEARTBEAT_SWIFTNAP_ERROR_MASK (0x1) +#define SBP_HEARTBEAT_SWIFTNAP_ERROR_MASK (0x1u) #define SBP_HEARTBEAT_SWIFTNAP_ERROR_SHIFT (2u) -#define SBP_HEARTBEAT_SWIFTNAP_ERROR_GET(flags) \ - ((u32)(((flags) >> SBP_HEARTBEAT_SWIFTNAP_ERROR_SHIFT) & \ +#define SBP_HEARTBEAT_SWIFTNAP_ERROR_GET(flags) \ + ((u32)((u32)((flags) >> SBP_HEARTBEAT_SWIFTNAP_ERROR_SHIFT) & \ SBP_HEARTBEAT_SWIFTNAP_ERROR_MASK)) -#define SBP_HEARTBEAT_SWIFTNAP_ERROR_SET(flags, val) \ - do { \ - (flags) = (u32)((flags) | (((val) & (SBP_HEARTBEAT_SWIFTNAP_ERROR_MASK)) \ - << (SBP_HEARTBEAT_SWIFTNAP_ERROR_SHIFT))); \ +#define SBP_HEARTBEAT_SWIFTNAP_ERROR_SET(flags, val) \ + do { \ + (flags) = (u32)((flags & (~(SBP_HEARTBEAT_SWIFTNAP_ERROR_MASK \ + << SBP_HEARTBEAT_SWIFTNAP_ERROR_SHIFT))) | \ + (((val) & (SBP_HEARTBEAT_SWIFTNAP_ERROR_MASK)) \ + << (SBP_HEARTBEAT_SWIFTNAP_ERROR_SHIFT))); \ } while (0) #define SBP_HEARTBEAT_SWIFTNAP_ERROR_SYSTEM_HEALTHY (0) #define SBP_HEARTBEAT_SWIFTNAP_ERROR_AN_ERROR_HAS_OCCURRED_IN_THE_SWIFTNAP (1) -#define SBP_HEARTBEAT_IO_ERROR_MASK (0x1) +#define SBP_HEARTBEAT_IO_ERROR_MASK (0x1u) #define SBP_HEARTBEAT_IO_ERROR_SHIFT (1u) -#define SBP_HEARTBEAT_IO_ERROR_GET(flags) \ - ((u32)(((flags) >> SBP_HEARTBEAT_IO_ERROR_SHIFT) & \ +#define SBP_HEARTBEAT_IO_ERROR_GET(flags) \ + ((u32)((u32)((flags) >> SBP_HEARTBEAT_IO_ERROR_SHIFT) & \ SBP_HEARTBEAT_IO_ERROR_MASK)) -#define SBP_HEARTBEAT_IO_ERROR_SET(flags, val) \ - do { \ - (flags) = (u32)((flags) | (((val) & (SBP_HEARTBEAT_IO_ERROR_MASK)) \ - << (SBP_HEARTBEAT_IO_ERROR_SHIFT))); \ +#define SBP_HEARTBEAT_IO_ERROR_SET(flags, val) \ + do { \ + (flags) = (u32)((flags & (~(SBP_HEARTBEAT_IO_ERROR_MASK \ + << SBP_HEARTBEAT_IO_ERROR_SHIFT))) | \ + (((val) & (SBP_HEARTBEAT_IO_ERROR_MASK)) \ + << (SBP_HEARTBEAT_IO_ERROR_SHIFT))); \ } while (0) #define SBP_HEARTBEAT_IO_ERROR_SYSTEM_HEALTHY (0) #define SBP_HEARTBEAT_IO_ERROR_AN_IO_ERROR_HAS_OCCURRED (1) -#define SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_MASK (0x1) +#define SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_MASK (0x1u) #define SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_SHIFT (0u) -#define SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_GET(flags) \ - ((u32)(((flags) >> SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_SHIFT) & \ +#define SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_GET(flags) \ + ((u32)((u32)((flags) >> SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_SHIFT) & \ SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_MASK)) -#define SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_SET(flags, val) \ - do { \ - (flags) = \ - (u32)((flags) | (((val) & (SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_MASK)) \ - << (SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_SHIFT))); \ +#define SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_SET(flags, val) \ + do { \ + (flags) = (u32)((flags & (~(SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_MASK \ + << SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_SHIFT))) | \ + (((val) & (SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_MASK)) \ + << (SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_SHIFT))); \ } while (0) #define SBP_HEARTBEAT_SYSTEM_ERROR_FLAG_SYSTEM_HEALTHY (0) @@ -193,15 +212,17 @@ */ #define SBP_MSG_HEARTBEAT_ENCODED_LEN 4u -#define SBP_SUBSYSTEMREPORT_SUBSYSTEM_MASK (0xffff) +#define SBP_SUBSYSTEMREPORT_SUBSYSTEM_MASK (0xffffu) #define SBP_SUBSYSTEMREPORT_SUBSYSTEM_SHIFT (0u) -#define SBP_SUBSYSTEMREPORT_SUBSYSTEM_GET(flags) \ - ((u16)(((flags) >> SBP_SUBSYSTEMREPORT_SUBSYSTEM_SHIFT) & \ +#define SBP_SUBSYSTEMREPORT_SUBSYSTEM_GET(flags) \ + ((u16)((u16)((flags) >> SBP_SUBSYSTEMREPORT_SUBSYSTEM_SHIFT) & \ SBP_SUBSYSTEMREPORT_SUBSYSTEM_MASK)) -#define SBP_SUBSYSTEMREPORT_SUBSYSTEM_SET(flags, val) \ - do { \ - (flags) = (u16)((flags) | (((val) & (SBP_SUBSYSTEMREPORT_SUBSYSTEM_MASK)) \ - << (SBP_SUBSYSTEMREPORT_SUBSYSTEM_SHIFT))); \ +#define SBP_SUBSYSTEMREPORT_SUBSYSTEM_SET(flags, val) \ + do { \ + (flags) = (u16)((flags & (~(SBP_SUBSYSTEMREPORT_SUBSYSTEM_MASK \ + << SBP_SUBSYSTEMREPORT_SUBSYSTEM_SHIFT))) | \ + (((val) & (SBP_SUBSYSTEMREPORT_SUBSYSTEM_MASK)) \ + << (SBP_SUBSYSTEMREPORT_SUBSYSTEM_SHIFT))); \ } while (0) #define SBP_SUBSYSTEMREPORT_SUBSYSTEM_PRIMARY_GNSS_ANTENNA (0) @@ -211,15 +232,17 @@ #define SBP_SUBSYSTEMREPORT_SUBSYSTEM_CAN (4) #define SBP_SUBSYSTEMREPORT_SUBSYSTEM_WHEEL_ODOMETRY (5) #define SBP_SUBSYSTEMREPORT_SUBSYSTEM_SENSOR_FUSION_ENGINE (6) -#define SBP_SUBSYSTEMREPORT_GENERIC_MASK (0xff) +#define SBP_SUBSYSTEMREPORT_GENERIC_MASK (0xffu) #define SBP_SUBSYSTEMREPORT_GENERIC_SHIFT (0u) -#define SBP_SUBSYSTEMREPORT_GENERIC_GET(flags) \ - ((u8)(((flags) >> SBP_SUBSYSTEMREPORT_GENERIC_SHIFT) & \ +#define SBP_SUBSYSTEMREPORT_GENERIC_GET(flags) \ + ((u8)((u8)((flags) >> SBP_SUBSYSTEMREPORT_GENERIC_SHIFT) & \ SBP_SUBSYSTEMREPORT_GENERIC_MASK)) -#define SBP_SUBSYSTEMREPORT_GENERIC_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_SUBSYSTEMREPORT_GENERIC_MASK)) \ - << (SBP_SUBSYSTEMREPORT_GENERIC_SHIFT))); \ +#define SBP_SUBSYSTEMREPORT_GENERIC_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_SUBSYSTEMREPORT_GENERIC_MASK \ + << SBP_SUBSYSTEMREPORT_GENERIC_SHIFT))) | \ + (((val) & (SBP_SUBSYSTEMREPORT_GENERIC_MASK)) \ + << (SBP_SUBSYSTEMREPORT_GENERIC_SHIFT))); \ } while (0) #define SBP_SUBSYSTEMREPORT_GENERIC_OKNOMINAL (0) @@ -234,43 +257,49 @@ #define SBP_SUB_SYSTEM_REPORT_ENCODED_LEN 4u #define SBP_MSG_STATUS_REPORT 0xFFFE -#define SBP_STATUS_REPORT_SYSTEM_MASK (0xffff) +#define SBP_STATUS_REPORT_SYSTEM_MASK (0xffffu) #define SBP_STATUS_REPORT_SYSTEM_SHIFT (0u) -#define SBP_STATUS_REPORT_SYSTEM_GET(flags) \ - ((u16)(((flags) >> SBP_STATUS_REPORT_SYSTEM_SHIFT) & \ +#define SBP_STATUS_REPORT_SYSTEM_GET(flags) \ + ((u16)((u16)((flags) >> SBP_STATUS_REPORT_SYSTEM_SHIFT) & \ SBP_STATUS_REPORT_SYSTEM_MASK)) -#define SBP_STATUS_REPORT_SYSTEM_SET(flags, val) \ - do { \ - (flags) = (u16)((flags) | (((val) & (SBP_STATUS_REPORT_SYSTEM_MASK)) \ - << (SBP_STATUS_REPORT_SYSTEM_SHIFT))); \ +#define SBP_STATUS_REPORT_SYSTEM_SET(flags, val) \ + do { \ + (flags) = (u16)((flags & (~(SBP_STATUS_REPORT_SYSTEM_MASK \ + << SBP_STATUS_REPORT_SYSTEM_SHIFT))) | \ + (((val) & (SBP_STATUS_REPORT_SYSTEM_MASK)) \ + << (SBP_STATUS_REPORT_SYSTEM_SHIFT))); \ } while (0) #define SBP_STATUS_REPORT_SYSTEM_STARLING (0) #define SBP_STATUS_REPORT_SYSTEM_PRECISION_GNSS_MODULE (1) -#define SBP_STATUS_REPORT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK (0xff) +#define SBP_STATUS_REPORT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK (0xffu) #define SBP_STATUS_REPORT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT (8u) -#define SBP_STATUS_REPORT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_GET(flags) \ - ((u16)( \ - ((flags) >> SBP_STATUS_REPORT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT) & \ - SBP_STATUS_REPORT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK)) +#define SBP_STATUS_REPORT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_GET(flags) \ + ((u16)((u16)((flags) >> \ + SBP_STATUS_REPORT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT) & \ + SBP_STATUS_REPORT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK)) #define SBP_STATUS_REPORT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SET(flags, val) \ do { \ (flags) = (u16)( \ - (flags) | \ + (flags & \ + (~(SBP_STATUS_REPORT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK \ + << SBP_STATUS_REPORT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT))) | \ (((val) & (SBP_STATUS_REPORT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_MASK)) \ << (SBP_STATUS_REPORT_SBP_MAJOR_PROTOCOL_VERSION_NUMBER_SHIFT))); \ } while (0) -#define SBP_STATUS_REPORT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK (0xff) +#define SBP_STATUS_REPORT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK (0xffu) #define SBP_STATUS_REPORT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT (0u) -#define SBP_STATUS_REPORT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_GET(flags) \ - ((u16)( \ - ((flags) >> SBP_STATUS_REPORT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT) & \ - SBP_STATUS_REPORT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK)) +#define SBP_STATUS_REPORT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_GET(flags) \ + ((u16)((u16)((flags) >> \ + SBP_STATUS_REPORT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT) & \ + SBP_STATUS_REPORT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK)) #define SBP_STATUS_REPORT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SET(flags, val) \ do { \ (flags) = (u16)( \ - (flags) | \ + (flags & \ + (~(SBP_STATUS_REPORT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK \ + << SBP_STATUS_REPORT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT))) | \ (((val) & (SBP_STATUS_REPORT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_MASK)) \ << (SBP_STATUS_REPORT_SBP_MINOR_PROTOCOL_VERSION_NUMBER_SHIFT))); \ } while (0) @@ -298,97 +327,112 @@ #define SBP_MSG_STATUS_REPORT_ENCODED_OVERHEAD 12u #define SBP_MSG_INS_STATUS 0xFF03 -#define SBP_INS_STATUS_INS_TYPE_MASK (0x7) +#define SBP_INS_STATUS_INS_TYPE_MASK (0x7u) #define SBP_INS_STATUS_INS_TYPE_SHIFT (29u) -#define SBP_INS_STATUS_INS_TYPE_GET(flags) \ - ((u32)(((flags) >> SBP_INS_STATUS_INS_TYPE_SHIFT) & \ +#define SBP_INS_STATUS_INS_TYPE_GET(flags) \ + ((u32)((u32)((flags) >> SBP_INS_STATUS_INS_TYPE_SHIFT) & \ SBP_INS_STATUS_INS_TYPE_MASK)) -#define SBP_INS_STATUS_INS_TYPE_SET(flags, val) \ - do { \ - (flags) = (u32)((flags) | (((val) & (SBP_INS_STATUS_INS_TYPE_MASK)) \ - << (SBP_INS_STATUS_INS_TYPE_SHIFT))); \ +#define SBP_INS_STATUS_INS_TYPE_SET(flags, val) \ + do { \ + (flags) = (u32)((flags & (~(SBP_INS_STATUS_INS_TYPE_MASK \ + << SBP_INS_STATUS_INS_TYPE_SHIFT))) | \ + (((val) & (SBP_INS_STATUS_INS_TYPE_MASK)) \ + << (SBP_INS_STATUS_INS_TYPE_SHIFT))); \ } while (0) #define SBP_INS_STATUS_INS_TYPE_SMOOTHPOSE_LOOSELY_COUPLED (0) #define SBP_INS_STATUS_INS_TYPE_STARLING (1) -#define SBP_INS_STATUS_MOTION_STATE_MASK (0x7) +#define SBP_INS_STATUS_MOTION_STATE_MASK (0x7u) #define SBP_INS_STATUS_MOTION_STATE_SHIFT (11u) -#define SBP_INS_STATUS_MOTION_STATE_GET(flags) \ - ((u32)(((flags) >> SBP_INS_STATUS_MOTION_STATE_SHIFT) & \ +#define SBP_INS_STATUS_MOTION_STATE_GET(flags) \ + ((u32)((u32)((flags) >> SBP_INS_STATUS_MOTION_STATE_SHIFT) & \ SBP_INS_STATUS_MOTION_STATE_MASK)) -#define SBP_INS_STATUS_MOTION_STATE_SET(flags, val) \ - do { \ - (flags) = (u32)((flags) | (((val) & (SBP_INS_STATUS_MOTION_STATE_MASK)) \ - << (SBP_INS_STATUS_MOTION_STATE_SHIFT))); \ +#define SBP_INS_STATUS_MOTION_STATE_SET(flags, val) \ + do { \ + (flags) = (u32)((flags & (~(SBP_INS_STATUS_MOTION_STATE_MASK \ + << SBP_INS_STATUS_MOTION_STATE_SHIFT))) | \ + (((val) & (SBP_INS_STATUS_MOTION_STATE_MASK)) \ + << (SBP_INS_STATUS_MOTION_STATE_SHIFT))); \ } while (0) #define SBP_INS_STATUS_MOTION_STATE_UNKNOWN_OR_INIT (0) #define SBP_INS_STATUS_MOTION_STATE_ARBITRARY_MOTION (1) #define SBP_INS_STATUS_MOTION_STATE_STRAIGHT_MOTION (2) #define SBP_INS_STATUS_MOTION_STATE_STATIONARY (3) -#define SBP_INS_STATUS_ODOMETRY_SYNCH_MASK (0x1) +#define SBP_INS_STATUS_ODOMETRY_SYNCH_MASK (0x1u) #define SBP_INS_STATUS_ODOMETRY_SYNCH_SHIFT (10u) -#define SBP_INS_STATUS_ODOMETRY_SYNCH_GET(flags) \ - ((u32)(((flags) >> SBP_INS_STATUS_ODOMETRY_SYNCH_SHIFT) & \ +#define SBP_INS_STATUS_ODOMETRY_SYNCH_GET(flags) \ + ((u32)((u32)((flags) >> SBP_INS_STATUS_ODOMETRY_SYNCH_SHIFT) & \ SBP_INS_STATUS_ODOMETRY_SYNCH_MASK)) -#define SBP_INS_STATUS_ODOMETRY_SYNCH_SET(flags, val) \ - do { \ - (flags) = (u32)((flags) | (((val) & (SBP_INS_STATUS_ODOMETRY_SYNCH_MASK)) \ - << (SBP_INS_STATUS_ODOMETRY_SYNCH_SHIFT))); \ +#define SBP_INS_STATUS_ODOMETRY_SYNCH_SET(flags, val) \ + do { \ + (flags) = (u32)((flags & (~(SBP_INS_STATUS_ODOMETRY_SYNCH_MASK \ + << SBP_INS_STATUS_ODOMETRY_SYNCH_SHIFT))) | \ + (((val) & (SBP_INS_STATUS_ODOMETRY_SYNCH_MASK)) \ + << (SBP_INS_STATUS_ODOMETRY_SYNCH_SHIFT))); \ } while (0) #define SBP_INS_STATUS_ODOMETRY_SYNCH_ODOMETRY_TIMESTAMP_NOMINAL (0) #define SBP_INS_STATUS_ODOMETRY_SYNCH_ODOMETRY_TIMESTAMP_OUT_OF_BOUNDS (1) -#define SBP_INS_STATUS_ODOMETRY_STATUS_MASK (0x3) +#define SBP_INS_STATUS_ODOMETRY_STATUS_MASK (0x3u) #define SBP_INS_STATUS_ODOMETRY_STATUS_SHIFT (8u) -#define SBP_INS_STATUS_ODOMETRY_STATUS_GET(flags) \ - ((u32)(((flags) >> SBP_INS_STATUS_ODOMETRY_STATUS_SHIFT) & \ +#define SBP_INS_STATUS_ODOMETRY_STATUS_GET(flags) \ + ((u32)((u32)((flags) >> SBP_INS_STATUS_ODOMETRY_STATUS_SHIFT) & \ SBP_INS_STATUS_ODOMETRY_STATUS_MASK)) -#define SBP_INS_STATUS_ODOMETRY_STATUS_SET(flags, val) \ - do { \ - (flags) = (u32)((flags) | (((val) & (SBP_INS_STATUS_ODOMETRY_STATUS_MASK)) \ - << (SBP_INS_STATUS_ODOMETRY_STATUS_SHIFT))); \ +#define SBP_INS_STATUS_ODOMETRY_STATUS_SET(flags, val) \ + do { \ + (flags) = (u32)((flags & (~(SBP_INS_STATUS_ODOMETRY_STATUS_MASK \ + << SBP_INS_STATUS_ODOMETRY_STATUS_SHIFT))) | \ + (((val) & (SBP_INS_STATUS_ODOMETRY_STATUS_MASK)) \ + << (SBP_INS_STATUS_ODOMETRY_STATUS_SHIFT))); \ } while (0) #define SBP_INS_STATUS_ODOMETRY_STATUS_NO_ODOMETRY (0) #define SBP_INS_STATUS_ODOMETRY_STATUS_ODOMETRY_RECEIVED_WITHIN_LAST_SECOND (1) #define SBP_INS_STATUS_ODOMETRY_STATUS_ODOMETRY_NOT_RECEIVED_WITHIN_LAST_SECOND \ (2) -#define SBP_INS_STATUS_INS_ERROR_MASK (0xf) +#define SBP_INS_STATUS_INS_ERROR_MASK (0xfu) #define SBP_INS_STATUS_INS_ERROR_SHIFT (4u) -#define SBP_INS_STATUS_INS_ERROR_GET(flags) \ - ((u32)(((flags) >> SBP_INS_STATUS_INS_ERROR_SHIFT) & \ +#define SBP_INS_STATUS_INS_ERROR_GET(flags) \ + ((u32)((u32)((flags) >> SBP_INS_STATUS_INS_ERROR_SHIFT) & \ SBP_INS_STATUS_INS_ERROR_MASK)) -#define SBP_INS_STATUS_INS_ERROR_SET(flags, val) \ - do { \ - (flags) = (u32)((flags) | (((val) & (SBP_INS_STATUS_INS_ERROR_MASK)) \ - << (SBP_INS_STATUS_INS_ERROR_SHIFT))); \ +#define SBP_INS_STATUS_INS_ERROR_SET(flags, val) \ + do { \ + (flags) = (u32)((flags & (~(SBP_INS_STATUS_INS_ERROR_MASK \ + << SBP_INS_STATUS_INS_ERROR_SHIFT))) | \ + (((val) & (SBP_INS_STATUS_INS_ERROR_MASK)) \ + << (SBP_INS_STATUS_INS_ERROR_SHIFT))); \ } while (0) #define SBP_INS_STATUS_INS_ERROR_IMU_DATA_ERROR (1) #define SBP_INS_STATUS_INS_ERROR_INS_LICENSE_ERROR (2) #define SBP_INS_STATUS_INS_ERROR_IMU_CALIBRATION_DATA_ERROR (3) -#define SBP_INS_STATUS_GNSS_FIX_MASK (0x1) +#define SBP_INS_STATUS_GNSS_FIX_MASK (0x1u) #define SBP_INS_STATUS_GNSS_FIX_SHIFT (3u) -#define SBP_INS_STATUS_GNSS_FIX_GET(flags) \ - ((u32)(((flags) >> SBP_INS_STATUS_GNSS_FIX_SHIFT) & \ +#define SBP_INS_STATUS_GNSS_FIX_GET(flags) \ + ((u32)((u32)((flags) >> SBP_INS_STATUS_GNSS_FIX_SHIFT) & \ SBP_INS_STATUS_GNSS_FIX_MASK)) -#define SBP_INS_STATUS_GNSS_FIX_SET(flags, val) \ - do { \ - (flags) = (u32)((flags) | (((val) & (SBP_INS_STATUS_GNSS_FIX_MASK)) \ - << (SBP_INS_STATUS_GNSS_FIX_SHIFT))); \ +#define SBP_INS_STATUS_GNSS_FIX_SET(flags, val) \ + do { \ + (flags) = (u32)((flags & (~(SBP_INS_STATUS_GNSS_FIX_MASK \ + << SBP_INS_STATUS_GNSS_FIX_SHIFT))) | \ + (((val) & (SBP_INS_STATUS_GNSS_FIX_MASK)) \ + << (SBP_INS_STATUS_GNSS_FIX_SHIFT))); \ } while (0) #define SBP_INS_STATUS_GNSS_FIX_NO_GNSS_FIX_AVAILABLE (0) #define SBP_INS_STATUS_GNSS_FIX_GNSS_FIX (1) -#define SBP_INS_STATUS_MODE_MASK (0x7) +#define SBP_INS_STATUS_MODE_MASK (0x7u) #define SBP_INS_STATUS_MODE_SHIFT (0u) -#define SBP_INS_STATUS_MODE_GET(flags) \ - ((u32)(((flags) >> SBP_INS_STATUS_MODE_SHIFT) & SBP_INS_STATUS_MODE_MASK)) -#define SBP_INS_STATUS_MODE_SET(flags, val) \ - do { \ - (flags) = (u32)((flags) | (((val) & (SBP_INS_STATUS_MODE_MASK)) \ - << (SBP_INS_STATUS_MODE_SHIFT))); \ +#define SBP_INS_STATUS_MODE_GET(flags) \ + ((u32)((u32)((flags) >> SBP_INS_STATUS_MODE_SHIFT) & \ + SBP_INS_STATUS_MODE_MASK)) +#define SBP_INS_STATUS_MODE_SET(flags, val) \ + do { \ + (flags) = (u32)( \ + (flags & (~(SBP_INS_STATUS_MODE_MASK << SBP_INS_STATUS_MODE_SHIFT))) | \ + (((val) & (SBP_INS_STATUS_MODE_MASK)) \ + << (SBP_INS_STATUS_MODE_SHIFT))); \ } while (0) #define SBP_INS_STATUS_MODE_AWAITING_INITIALIZATION (0) @@ -454,243 +498,279 @@ #define SBP_MSG_INS_UPDATES 0xFF06 #define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_MASK \ - (0xf) + (0xfu) #define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SHIFT \ (4u) -#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ +#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_MASK)) -#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ - << (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ +#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_MASK \ + << SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SHIFT))) | \ + (((val) & \ + (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ + << (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ } while (0) #define SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_MASK \ - (0xf) + (0xfu) #define SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SHIFT \ (0u) -#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ +#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_MASK)) -#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ - << (SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ +#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_MASK \ + << SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SHIFT))) | \ + (((val) & \ + (SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ + << (SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_POSITION_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ } while (0) #define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK \ - (0xf) + (0xfu) #define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT \ (4u) -#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ +#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK)) -#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ - << (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ +#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK \ + << SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT))) | \ + (((val) & \ + (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ + << (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ } while (0) #define SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK \ - (0xf) + (0xfu) #define SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT \ (0u) -#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ +#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK)) -#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ - << (SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ +#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK \ + << SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT))) | \ + (((val) & \ + (SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ + << (SBP_INS_UPDATES_NUMBER_OF_REJECTED_GNSS_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ } while (0) #define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_MASK \ - (0xf) + (0xfu) #define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SHIFT \ (4u) -#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ +#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_MASK)) -#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ - << (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ +#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_MASK \ + << SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SHIFT))) | \ + (((val) & \ + (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ + << (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ } while (0) #define SBP_INS_UPDATES_NUMBER_OF_REJECTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_MASK \ - (0xf) + (0xfu) #define SBP_INS_UPDATES_NUMBER_OF_REJECTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SHIFT \ (0u) -#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_INS_UPDATES_NUMBER_OF_REJECTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ +#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_INS_UPDATES_NUMBER_OF_REJECTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ SBP_INS_UPDATES_NUMBER_OF_REJECTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_MASK)) -#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_INS_UPDATES_NUMBER_OF_REJECTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ - << (SBP_INS_UPDATES_NUMBER_OF_REJECTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ +#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_INS_UPDATES_NUMBER_OF_REJECTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_MASK \ + << SBP_INS_UPDATES_NUMBER_OF_REJECTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SHIFT))) | \ + (((val) & \ + (SBP_INS_UPDATES_NUMBER_OF_REJECTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ + << (SBP_INS_UPDATES_NUMBER_OF_REJECTED_WHEELTICK_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ } while (0) #define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_MASK \ - (0xf) + (0xfu) #define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SHIFT \ (4u) -#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ +#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_MASK)) -#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ - << (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ +#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_MASK \ + << SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SHIFT))) | \ + (((val) & \ + (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ + << (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ } while (0) #define SBP_INS_UPDATES_NUMBER_OF_REJECTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_MASK \ - (0xf) + (0xfu) #define SBP_INS_UPDATES_NUMBER_OF_REJECTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SHIFT \ (0u) -#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_INS_UPDATES_NUMBER_OF_REJECTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ +#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_INS_UPDATES_NUMBER_OF_REJECTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ SBP_INS_UPDATES_NUMBER_OF_REJECTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_MASK)) -#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_INS_UPDATES_NUMBER_OF_REJECTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ - << (SBP_INS_UPDATES_NUMBER_OF_REJECTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ +#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_INS_UPDATES_NUMBER_OF_REJECTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_MASK \ + << SBP_INS_UPDATES_NUMBER_OF_REJECTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SHIFT))) | \ + (((val) & \ + (SBP_INS_UPDATES_NUMBER_OF_REJECTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ + << (SBP_INS_UPDATES_NUMBER_OF_REJECTED_SPEED_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ } while (0) #define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_NHC_UPDATES_SINCE_LAST_MESSAGE_MASK \ - (0xf) + (0xfu) #define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SHIFT \ (4u) -#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_NHC_UPDATES_SINCE_LAST_MESSAGE_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ +#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_NHC_UPDATES_SINCE_LAST_MESSAGE_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_NHC_UPDATES_SINCE_LAST_MESSAGE_MASK)) -#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_NHC_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ - << (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ +#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_NHC_UPDATES_SINCE_LAST_MESSAGE_MASK \ + << SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SHIFT))) | \ + (((val) & \ + (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_NHC_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ + << (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ } while (0) #define SBP_INS_UPDATES_NUMBER_OF_REJECTED_NHC_UPDATES_SINCE_LAST_MESSAGE_MASK \ - (0xf) + (0xfu) #define SBP_INS_UPDATES_NUMBER_OF_REJECTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SHIFT \ (0u) -#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_NHC_UPDATES_SINCE_LAST_MESSAGE_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_INS_UPDATES_NUMBER_OF_REJECTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ +#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_NHC_UPDATES_SINCE_LAST_MESSAGE_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_INS_UPDATES_NUMBER_OF_REJECTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ SBP_INS_UPDATES_NUMBER_OF_REJECTED_NHC_UPDATES_SINCE_LAST_MESSAGE_MASK)) -#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_INS_UPDATES_NUMBER_OF_REJECTED_NHC_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ - << (SBP_INS_UPDATES_NUMBER_OF_REJECTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ +#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_INS_UPDATES_NUMBER_OF_REJECTED_NHC_UPDATES_SINCE_LAST_MESSAGE_MASK \ + << SBP_INS_UPDATES_NUMBER_OF_REJECTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SHIFT))) | \ + (((val) & \ + (SBP_INS_UPDATES_NUMBER_OF_REJECTED_NHC_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ + << (SBP_INS_UPDATES_NUMBER_OF_REJECTED_NHC_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ } while (0) #define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK \ - (0xf) + (0xfu) #define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT \ (4u) -#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ +#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK)) -#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ - << (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ +#define SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK \ + << SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT))) | \ + (((val) & \ + (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ + << (SBP_INS_UPDATES_NUMBER_OF_ATTEMPTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ } while (0) #define SBP_INS_UPDATES_NUMBER_OF_REJECTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK \ - (0xf) + (0xfu) #define SBP_INS_UPDATES_NUMBER_OF_REJECTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT \ (0u) -#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_INS_UPDATES_NUMBER_OF_REJECTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ +#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_INS_UPDATES_NUMBER_OF_REJECTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT) & \ SBP_INS_UPDATES_NUMBER_OF_REJECTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK)) -#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_INS_UPDATES_NUMBER_OF_REJECTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ - << (SBP_INS_UPDATES_NUMBER_OF_REJECTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ +#define SBP_INS_UPDATES_NUMBER_OF_REJECTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_INS_UPDATES_NUMBER_OF_REJECTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK \ + << SBP_INS_UPDATES_NUMBER_OF_REJECTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT))) | \ + (((val) & \ + (SBP_INS_UPDATES_NUMBER_OF_REJECTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_MASK)) \ + << (SBP_INS_UPDATES_NUMBER_OF_REJECTED_ZERO_VELOCITY_UPDATES_SINCE_LAST_MESSAGE_SHIFT))); \ } while (0) /** @@ -707,27 +787,30 @@ #define SBP_MSG_GNSS_TIME_OFFSET_ENCODED_LEN 9u #define SBP_MSG_PPS_TIME 0xFF08 -#define SBP_PPS_TIME_RESERVED_SET_TO_ZERO_MASK (0x3f) +#define SBP_PPS_TIME_RESERVED_SET_TO_ZERO_MASK (0x3fu) #define SBP_PPS_TIME_RESERVED_SET_TO_ZERO_SHIFT (2u) -#define SBP_PPS_TIME_RESERVED_SET_TO_ZERO_GET(flags) \ - ((u8)(((flags) >> SBP_PPS_TIME_RESERVED_SET_TO_ZERO_SHIFT) & \ +#define SBP_PPS_TIME_RESERVED_SET_TO_ZERO_GET(flags) \ + ((u8)((u8)((flags) >> SBP_PPS_TIME_RESERVED_SET_TO_ZERO_SHIFT) & \ SBP_PPS_TIME_RESERVED_SET_TO_ZERO_MASK)) -#define SBP_PPS_TIME_RESERVED_SET_TO_ZERO_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_PPS_TIME_RESERVED_SET_TO_ZERO_MASK)) \ - << (SBP_PPS_TIME_RESERVED_SET_TO_ZERO_SHIFT))); \ +#define SBP_PPS_TIME_RESERVED_SET_TO_ZERO_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_PPS_TIME_RESERVED_SET_TO_ZERO_MASK \ + << SBP_PPS_TIME_RESERVED_SET_TO_ZERO_SHIFT))) | \ + (((val) & (SBP_PPS_TIME_RESERVED_SET_TO_ZERO_MASK)) \ + << (SBP_PPS_TIME_RESERVED_SET_TO_ZERO_SHIFT))); \ } while (0) -#define SBP_PPS_TIME_TIME_UNCERTAINTY_MASK (0x3) +#define SBP_PPS_TIME_TIME_UNCERTAINTY_MASK (0x3u) #define SBP_PPS_TIME_TIME_UNCERTAINTY_SHIFT (0u) -#define SBP_PPS_TIME_TIME_UNCERTAINTY_GET(flags) \ - ((u8)(((flags) >> SBP_PPS_TIME_TIME_UNCERTAINTY_SHIFT) & \ +#define SBP_PPS_TIME_TIME_UNCERTAINTY_GET(flags) \ + ((u8)((u8)((flags) >> SBP_PPS_TIME_TIME_UNCERTAINTY_SHIFT) & \ SBP_PPS_TIME_TIME_UNCERTAINTY_MASK)) -#define SBP_PPS_TIME_TIME_UNCERTAINTY_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_PPS_TIME_TIME_UNCERTAINTY_MASK)) \ - << (SBP_PPS_TIME_TIME_UNCERTAINTY_SHIFT))); \ +#define SBP_PPS_TIME_TIME_UNCERTAINTY_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_PPS_TIME_TIME_UNCERTAINTY_MASK \ + << SBP_PPS_TIME_TIME_UNCERTAINTY_SHIFT))) | \ + (((val) & (SBP_PPS_TIME_TIME_UNCERTAINTY_MASK)) \ + << (SBP_PPS_TIME_TIME_UNCERTAINTY_SHIFT))); \ } while (0) #define SBP_PPS_TIME_TIME_UNCERTAINTY_UNKNOWN (0) @@ -745,16 +828,18 @@ #define SBP_MSG_PPS_TIME_ENCODED_LEN 9u #define SBP_MSG_SENSOR_AID_EVENT 0xFF09 -#define SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_MASK (0xff) +#define SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_MASK (0xffu) #define SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_SHIFT (0u) -#define SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_GET(flags) \ - ((u8)(((flags) >> SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_SHIFT) & \ +#define SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_GET(flags) \ + ((u8)((u8)((flags) >> SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_SHIFT) & \ SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_MASK)) -#define SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_MASK)) \ - << (SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_SHIFT))); \ +#define SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_MASK \ + << SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_SHIFT))) | \ + (((val) & (SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_MASK)) \ + << (SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_SHIFT))); \ } while (0) #define SBP_SENSOR_AID_EVENT_TYPE_IDENTIFIER_GNSS_POSITION (0) @@ -772,16 +857,18 @@ #define SBP_MSG_SENSOR_AID_EVENT_ENCODED_LEN 15u #define SBP_MSG_GROUP_META 0xFF0A -#define SBP_GROUP_META_SOLUTION_GROUP_TYPE_MASK (0x3) +#define SBP_GROUP_META_SOLUTION_GROUP_TYPE_MASK (0x3u) #define SBP_GROUP_META_SOLUTION_GROUP_TYPE_SHIFT (0u) -#define SBP_GROUP_META_SOLUTION_GROUP_TYPE_GET(flags) \ - ((u8)(((flags) >> SBP_GROUP_META_SOLUTION_GROUP_TYPE_SHIFT) & \ +#define SBP_GROUP_META_SOLUTION_GROUP_TYPE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_GROUP_META_SOLUTION_GROUP_TYPE_SHIFT) & \ SBP_GROUP_META_SOLUTION_GROUP_TYPE_MASK)) -#define SBP_GROUP_META_SOLUTION_GROUP_TYPE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_GROUP_META_SOLUTION_GROUP_TYPE_MASK)) \ - << (SBP_GROUP_META_SOLUTION_GROUP_TYPE_SHIFT))); \ +#define SBP_GROUP_META_SOLUTION_GROUP_TYPE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_GROUP_META_SOLUTION_GROUP_TYPE_MASK \ + << SBP_GROUP_META_SOLUTION_GROUP_TYPE_SHIFT))) | \ + (((val) & (SBP_GROUP_META_SOLUTION_GROUP_TYPE_MASK)) \ + << (SBP_GROUP_META_SOLUTION_GROUP_TYPE_SHIFT))); \ } while (0) #define SBP_GROUP_META_SOLUTION_GROUP_TYPE_NONE (0) diff --git a/c/include/libsbp/tracking_macros.h b/c/include/libsbp/tracking_macros.h index 5169ef8176..3009594582 100644 --- a/c/include/libsbp/tracking_macros.h +++ b/c/include/libsbp/tracking_macros.h @@ -19,20 +19,22 @@ #define LIBSBP_TRACKING_MACROS_H #define SBP_MSG_TRACKING_STATE_DETAILED_DEP_A 0x0021 -#define SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_MASK (0x7) +#define SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_MASK (0x7u) #define SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_SHIFT (0u) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_GET(flags) \ - ((u8)(((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_SET(flags, \ - val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_SET(flags, \ + val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_NO_SYNCHRONIZATION \ @@ -43,39 +45,44 @@ (2) #define SBP_TRACKING_STATE_DETAILED_DEP_A_SYNCHRONIZATION_STATUS_SUB_FRAME_SYNCHRONIZATION_MESSAGE_SYNCHRONIZATION \ (3) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_MASK (0x1) +#define SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_MASK \ + (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_SHIFT (3u) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_WEEK_NUMBER_IS_NOT_VALID \ (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_WEEK_NUMBER_VALIDITY_STATUS_WEEK_NUMBER_IS_VALID \ (1) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_MASK (0x7) +#define SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_MASK (0x7u) #define SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_SHIFT (0u) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_GET(flags) \ - ((u8)(((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | \ - (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_SHIFT))) | \ + (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_TOW_IS_NOT_AVAILABLE (0) @@ -83,49 +90,53 @@ (1) #define SBP_TRACKING_STATE_DETAILED_DEP_A_TOW_STATUS_PROPAGATED_TOW_IS_AVAILABLE \ (2) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_MASK (0x1) +#define SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_MASK (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_SHIFT (4u) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_GET(flags) \ - ((u8)(((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | \ - (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_SHIFT))) | \ + (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_FLL_IS_INACTIVE (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_FLL_STATUS_FLL_IS_ACTIVE (1) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_MASK (0x1) +#define SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_MASK (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_SHIFT (3u) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_GET(flags) \ - ((u8)(((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | \ - (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_SHIFT))) | \ + (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_PLL_IS_INACTIVE (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_PLL_STATUS_PLL_IS_ACTIVE (1) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_MASK (0x7) +#define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_MASK (0x7u) #define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_SHIFT (0u) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_GET(flags) \ - ((u8)(((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_SET(flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_NO_LOCKS (0) @@ -134,22 +145,26 @@ (2) #define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_LOOP_STATUS_PLL_PESSIMISTIC_LOCK \ (3) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_MASK (0x1) +#define SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_MASK \ + (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_SHIFT (4u) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_ALMANAC_IS_NOT_AVAILABLE \ @@ -157,38 +172,44 @@ #define SBP_TRACKING_STATE_DETAILED_DEP_A_ALMANAC_AVAILABILITY_STATUS_ALMANAC_IS_AVAILABLE \ (1) #define SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_MASK \ - (0x1) + (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_SHIFT \ (3u) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_EPHEMERIS_IS_NOT_AVAILABLE \ (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_EPHEMERIS_AVAILABILITY_STATUS_EPHEMERIS_IS_AVAILABLE \ (1) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_MASK (0x7) +#define SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_MASK (0x7u) #define SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_SHIFT (0u) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_GET(flags) \ - ((u8)(((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_SHIFT) & \ - SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_MASK)) +#define SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_GET(flags) \ + ((u8)( \ + (u8)((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_SHIFT) & \ + SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_MASK)) #define SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_SET(flags, val) \ do { \ (flags) = \ - (u8)((flags) | \ + (u8)((flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_SHIFT))) | \ (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_MASK)) \ << (SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_SHIFT))); \ } while (0) @@ -196,15 +217,18 @@ #define SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_HEALTH_IS_UNKNOWN (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_SIGNAL_IS_UNHEALTHY (1) #define SBP_TRACKING_STATE_DETAILED_DEP_A_HEALTH_STATUS_SIGNAL_IS_HEALTHY (2) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_PARAMETER_SETS_MASK (0x7) +#define SBP_TRACKING_STATE_DETAILED_DEP_A_PARAMETER_SETS_MASK (0x7u) #define SBP_TRACKING_STATE_DETAILED_DEP_A_PARAMETER_SETS_SHIFT (0u) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_PARAMETER_SETS_GET(flags) \ - ((u8)(((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_A_PARAMETER_SETS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_PARAMETER_SETS_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_A_PARAMETER_SETS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_A_PARAMETER_SETS_MASK)) #define SBP_TRACKING_STATE_DETAILED_DEP_A_PARAMETER_SETS_SET(flags, val) \ do { \ (flags) = (u8)( \ - (flags) | \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_A_PARAMETER_SETS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_A_PARAMETER_SETS_SHIFT))) | \ (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_A_PARAMETER_SETS_MASK)) \ << (SBP_TRACKING_STATE_DETAILED_DEP_A_PARAMETER_SETS_SHIFT))); \ } while (0) @@ -217,42 +241,48 @@ (2) #define SBP_TRACKING_STATE_DETAILED_DEP_A_PARAMETER_SETS_20_MS_INTEGRATION_TIME \ (3) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_MASK (0x1) +#define SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_MASK (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_SHIFT (5u) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_GET(flags) \ - ((u8)(((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_SET(flags, \ - val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_SET(flags, \ + val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_CLOCK_OFFSET_AND_DRIFT_IS_NOT_VALID \ (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_CLOCK_VALIDITY_STATUS_CLOCK_OFFSET_AND_DRIFT_IS_VALID \ (1) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_MASK (0x1) +#define SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_MASK \ + (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_SHIFT (4u) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_PSEUDORANGE_IS_NOT_VALID \ @@ -260,23 +290,26 @@ #define SBP_TRACKING_STATE_DETAILED_DEP_A_PSEUDORANGE_VALIDITY_STATUS_PSEUDORANGE_IS_VALID \ (1) #define SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_MASK \ - (0x1) + (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_SHIFT \ (3u) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_ACCELERATION_IS_NOT_VALID \ @@ -284,43 +317,49 @@ #define SBP_TRACKING_STATE_DETAILED_DEP_A_ACCELERATION_VALIDITY_STATUS_ACCELERATION_IS_VALID \ (1) #define SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_MASK \ - (0x1) + (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SHIFT \ (2u) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_UNRESOLVED \ (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_RESOLVED \ (1) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_MASK (0x3) +#define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_MASK (0x3u) #define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_SHIFT (0u) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_GET(flags) \ - ((u8)(((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_SHIFT) & \ - SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_SET(flags, \ - val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_GET(flags) \ + ((u8)( \ + (u8)((flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_SHIFT) & \ + SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_MASK)) +#define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_SET(flags, \ + val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_A_TRACKING_CHANNEL_STATUS_RE_ACQUISITION \ @@ -333,19 +372,21 @@ #define SBP_MSG_TRACKING_STATE_DETAILED_DEP_A_ENCODED_LEN 57u #define SBP_MSG_TRACKING_STATE_DETAILED_DEP 0x0011 -#define SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_MASK (0x7) +#define SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_MASK (0x7u) #define SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_SHIFT (0u) -#define SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_GET(flags) \ - ((u8)(((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_SET(flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_NO_SYNCHRONIZATION \ @@ -356,80 +397,92 @@ (2) #define SBP_TRACKING_STATE_DETAILED_DEP_SYNCHRONIZATION_STATUS_SUB_FRAME_SYNCHRONIZATION_MESSAGE_SYNCHRONIZATION \ (3) -#define SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_MASK (0x1) +#define SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_MASK (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_SHIFT (3u) #define SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_GET(flags) \ - ((u8)(((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_SHIFT) & \ - SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_SET(flags, \ - val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_SHIFT))); \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_SHIFT) & \ + SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_MASK)) +#define SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_SET(flags, \ + val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_WEEK_NUMBER_IS_NOT_VALID \ (0) #define SBP_TRACKING_STATE_DETAILED_DEP_WEEK_NUMBER_VALIDITY_STATUS_WEEK_NUMBER_IS_VALID \ (1) -#define SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_MASK (0x7) +#define SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_MASK (0x7u) #define SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_SHIFT (0u) -#define SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_GET(flags) \ - ((u8)(((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_SET(flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_SHIFT))) | \ + (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_TOW_IS_NOT_AVAILABLE (0) #define SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_DECODED_TOW_IS_AVAILABLE (1) #define SBP_TRACKING_STATE_DETAILED_DEP_TOW_STATUS_PROPAGATED_TOW_IS_AVAILABLE \ (2) -#define SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_MASK (0x1) +#define SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_MASK (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_SHIFT (4u) -#define SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_GET(flags) \ - ((u8)(((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_SET(flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_SHIFT))) | \ + (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_FLL_IS_INACTIVE (0) #define SBP_TRACKING_STATE_DETAILED_DEP_FLL_STATUS_FLL_IS_ACTIVE (1) -#define SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_MASK (0x1) +#define SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_MASK (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_SHIFT (3u) -#define SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_GET(flags) \ - ((u8)(((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_SET(flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_SHIFT))) | \ + (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_PLL_IS_INACTIVE (0) #define SBP_TRACKING_STATE_DETAILED_DEP_PLL_STATUS_PLL_IS_ACTIVE (1) -#define SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_LOOP_STATUS_MASK (0x7) +#define SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_LOOP_STATUS_MASK (0x7u) #define SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_LOOP_STATUS_SHIFT (0u) -#define SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_LOOP_STATUS_GET(flags) \ - ((u8)(((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_LOOP_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_LOOP_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_LOOP_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_LOOP_STATUS_MASK)) #define SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_LOOP_STATUS_SET(flags, val) \ do { \ (flags) = (u8)( \ - (flags) | \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_LOOP_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_LOOP_STATUS_SHIFT))) | \ (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_LOOP_STATUS_MASK)) \ << (SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_LOOP_STATUS_SHIFT))); \ } while (0) @@ -440,57 +493,67 @@ (2) #define SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_LOOP_STATUS_PLL_PESSIMISTIC_LOCK \ (3) -#define SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_MASK (0x1) +#define SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_MASK (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_SHIFT (4u) #define SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_GET(flags) \ - ((u8)(((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_SHIFT) & \ - SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_SET(flags, \ - val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_SHIFT))); \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_SHIFT) & \ + SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_MASK)) +#define SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_SET(flags, \ + val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_ALMANAC_IS_NOT_AVAILABLE \ (0) #define SBP_TRACKING_STATE_DETAILED_DEP_ALMANAC_AVAILABILITY_STATUS_ALMANAC_IS_AVAILABLE \ (1) -#define SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_MASK (0x1) +#define SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_MASK \ + (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_SHIFT (3u) -#define SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_EPHEMERIS_IS_NOT_AVAILABLE \ (0) #define SBP_TRACKING_STATE_DETAILED_DEP_EPHEMERIS_AVAILABILITY_STATUS_EPHEMERIS_IS_AVAILABLE \ (1) -#define SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_MASK (0x7) +#define SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_MASK (0x7u) #define SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_SHIFT (0u) -#define SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_GET(flags) \ - ((u8)(((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_MASK)) #define SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_SET(flags, val) \ do { \ (flags) = \ - (u8)((flags) | \ + (u8)((flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_SHIFT))) | \ (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_MASK)) \ << (SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_SHIFT))); \ } while (0) @@ -498,15 +561,18 @@ #define SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_HEALTH_IS_UNKNOWN (0) #define SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_SIGNAL_IS_UNHEALTHY (1) #define SBP_TRACKING_STATE_DETAILED_DEP_HEALTH_STATUS_SIGNAL_IS_HEALTHY (2) -#define SBP_TRACKING_STATE_DETAILED_DEP_PARAMETER_SETS_MASK (0x7) +#define SBP_TRACKING_STATE_DETAILED_DEP_PARAMETER_SETS_MASK (0x7u) #define SBP_TRACKING_STATE_DETAILED_DEP_PARAMETER_SETS_SHIFT (0u) -#define SBP_TRACKING_STATE_DETAILED_DEP_PARAMETER_SETS_GET(flags) \ - ((u8)(((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_PARAMETER_SETS_SHIFT) & \ - SBP_TRACKING_STATE_DETAILED_DEP_PARAMETER_SETS_MASK)) +#define SBP_TRACKING_STATE_DETAILED_DEP_PARAMETER_SETS_GET(flags) \ + ((u8)( \ + (u8)((flags) >> SBP_TRACKING_STATE_DETAILED_DEP_PARAMETER_SETS_SHIFT) & \ + SBP_TRACKING_STATE_DETAILED_DEP_PARAMETER_SETS_MASK)) #define SBP_TRACKING_STATE_DETAILED_DEP_PARAMETER_SETS_SET(flags, val) \ do { \ (flags) = \ - (u8)((flags) | \ + (u8)((flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_PARAMETER_SETS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_PARAMETER_SETS_SHIFT))) | \ (((val) & (SBP_TRACKING_STATE_DETAILED_DEP_PARAMETER_SETS_MASK)) \ << (SBP_TRACKING_STATE_DETAILED_DEP_PARAMETER_SETS_SHIFT))); \ } while (0) @@ -517,60 +583,70 @@ (2) #define SBP_TRACKING_STATE_DETAILED_DEP_PARAMETER_SETS_20_MS_INTEGRATION_TIME \ (3) -#define SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_MASK (0x1) +#define SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_MASK (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_SHIFT (5u) -#define SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_GET(flags) \ - ((u8)(((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_SET(flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_CLOCK_OFFSET_AND_DRIFT_IS_NOT_VALID \ (0) #define SBP_TRACKING_STATE_DETAILED_DEP_CLOCK_VALIDITY_STATUS_CLOCK_OFFSET_AND_DRIFT_IS_VALID \ (1) -#define SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_MASK (0x1) +#define SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_MASK (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_SHIFT (4u) #define SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_GET(flags) \ - ((u8)(((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_SHIFT) & \ - SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_SET(flags, \ - val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_SHIFT))); \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_SHIFT) & \ + SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_MASK)) +#define SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_SET(flags, \ + val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_PSEUDORANGE_IS_NOT_VALID \ (0) #define SBP_TRACKING_STATE_DETAILED_DEP_PSEUDORANGE_VALIDITY_STATUS_PSEUDORANGE_IS_VALID \ (1) -#define SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_MASK (0x1) +#define SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_MASK (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_SHIFT (3u) -#define SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_GET( \ - flags) \ - ((u8)(((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_SHIFT) & \ - SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_SHIFT) & \ + SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_MASK)) +#define SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_ACCELERATION_IS_NOT_VALID \ @@ -578,43 +654,48 @@ #define SBP_TRACKING_STATE_DETAILED_DEP_ACCELERATION_VALIDITY_STATUS_ACCELERATION_IS_VALID \ (1) #define SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_MASK \ - (0x1) + (0x1u) #define SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SHIFT \ (2u) -#define SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_GET( \ - flags) \ - ((u8)( \ - ((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_GET( \ + flags) \ + ((u8)( \ + (u8)( \ + (flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SET( \ - flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SET( \ + flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_UNRESOLVED \ (0) #define SBP_TRACKING_STATE_DETAILED_DEP_CARRIER_HALF_CYCLE_AMBIGUITY_STATUS_RESOLVED \ (1) -#define SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_MASK (0x3) +#define SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_MASK (0x3u) #define SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_SHIFT (0u) -#define SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_GET(flags) \ - ((u8)(((flags) >> \ - SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_SHIFT) & \ +#define SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_GET(flags) \ + ((u8)((u8)((flags) >> \ + SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_SHIFT) & \ SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_MASK)) -#define SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_SET(flags, \ - val) \ - do { \ - (flags) = (u8)( \ - (flags) | \ - (((val) & \ - (SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_MASK)) \ - << (SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_SHIFT))); \ +#define SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_SET(flags, \ + val) \ + do { \ + (flags) = (u8)( \ + (flags & \ + (~(SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_MASK \ + << SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_SHIFT))) | \ + (((val) & \ + (SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_MASK)) \ + << (SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_SHIFT))); \ } while (0) #define SBP_TRACKING_STATE_DETAILED_DEP_TRACKING_CHANNEL_STATUS_RE_ACQUISITION \ @@ -739,16 +820,18 @@ */ #define SBP_MSG_TRACKING_IQ_DEP_A_ENCODED_LEN 29u -#define SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_MASK (0x3) +#define SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_MASK (0x3u) #define SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_SHIFT (0u) -#define SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_SHIFT) & \ +#define SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_SHIFT) & \ SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_MASK)) -#define SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | (((val) & (SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_MASK)) \ - << (SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_SHIFT))); \ +#define SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_MASK \ + << SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_SHIFT))) | \ + (((val) & (SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_MASK)) \ + << (SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_SHIFT))); \ } while (0) #define SBP_TRACKINGCHANNELSTATEDEPA_TRACKING_MODE_DISABLED (0) @@ -783,16 +866,18 @@ */ #define SBP_MSG_TRACKING_STATE_DEP_A_ENCODED_OVERHEAD 0u -#define SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_MASK (0x3) +#define SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_MASK (0x3u) #define SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_SHIFT (0u) -#define SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_GET(flags) \ - ((u8)(((flags) >> SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_SHIFT) & \ +#define SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_SHIFT) & \ SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_MASK)) -#define SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_SET(flags, val) \ - do { \ - (flags) = (u8)( \ - (flags) | (((val) & (SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_MASK)) \ - << (SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_SHIFT))); \ +#define SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_SET(flags, val) \ + do { \ + (flags) = (u8)( \ + (flags & (~(SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_MASK \ + << SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_SHIFT))) | \ + (((val) & (SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_MASK)) \ + << (SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_SHIFT))); \ } while (0) #define SBP_TRACKINGCHANNELSTATEDEPB_TRACKING_MODE_DISABLED (0) diff --git a/c/include/libsbp/vehicle_macros.h b/c/include/libsbp/vehicle_macros.h index 287afb36ce..0a77db95a6 100644 --- a/c/include/libsbp/vehicle_macros.h +++ b/c/include/libsbp/vehicle_macros.h @@ -19,45 +19,51 @@ #define LIBSBP_VEHICLE_MACROS_H #define SBP_MSG_ODOMETRY 0x0903 -#define SBP_ODOMETRY_VEHICLE_METADATA_MASK (0x3) +#define SBP_ODOMETRY_VEHICLE_METADATA_MASK (0x3u) #define SBP_ODOMETRY_VEHICLE_METADATA_SHIFT (5u) -#define SBP_ODOMETRY_VEHICLE_METADATA_GET(flags) \ - ((u8)(((flags) >> SBP_ODOMETRY_VEHICLE_METADATA_SHIFT) & \ +#define SBP_ODOMETRY_VEHICLE_METADATA_GET(flags) \ + ((u8)((u8)((flags) >> SBP_ODOMETRY_VEHICLE_METADATA_SHIFT) & \ SBP_ODOMETRY_VEHICLE_METADATA_MASK)) -#define SBP_ODOMETRY_VEHICLE_METADATA_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_ODOMETRY_VEHICLE_METADATA_MASK)) \ - << (SBP_ODOMETRY_VEHICLE_METADATA_SHIFT))); \ +#define SBP_ODOMETRY_VEHICLE_METADATA_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_ODOMETRY_VEHICLE_METADATA_MASK \ + << SBP_ODOMETRY_VEHICLE_METADATA_SHIFT))) | \ + (((val) & (SBP_ODOMETRY_VEHICLE_METADATA_MASK)) \ + << (SBP_ODOMETRY_VEHICLE_METADATA_SHIFT))); \ } while (0) #define SBP_ODOMETRY_VEHICLE_METADATA_UNAVAILABLE (0) #define SBP_ODOMETRY_VEHICLE_METADATA_FORWARD (1) #define SBP_ODOMETRY_VEHICLE_METADATA_REVERSE (2) #define SBP_ODOMETRY_VEHICLE_METADATA_PARK (3) -#define SBP_ODOMETRY_VELOCITY_SOURCE_MASK (0x3) +#define SBP_ODOMETRY_VELOCITY_SOURCE_MASK (0x3u) #define SBP_ODOMETRY_VELOCITY_SOURCE_SHIFT (3u) -#define SBP_ODOMETRY_VELOCITY_SOURCE_GET(flags) \ - ((u8)(((flags) >> SBP_ODOMETRY_VELOCITY_SOURCE_SHIFT) & \ +#define SBP_ODOMETRY_VELOCITY_SOURCE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_ODOMETRY_VELOCITY_SOURCE_SHIFT) & \ SBP_ODOMETRY_VELOCITY_SOURCE_MASK)) -#define SBP_ODOMETRY_VELOCITY_SOURCE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_ODOMETRY_VELOCITY_SOURCE_MASK)) \ - << (SBP_ODOMETRY_VELOCITY_SOURCE_SHIFT))); \ +#define SBP_ODOMETRY_VELOCITY_SOURCE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_ODOMETRY_VELOCITY_SOURCE_MASK \ + << SBP_ODOMETRY_VELOCITY_SOURCE_SHIFT))) | \ + (((val) & (SBP_ODOMETRY_VELOCITY_SOURCE_MASK)) \ + << (SBP_ODOMETRY_VELOCITY_SOURCE_SHIFT))); \ } while (0) #define SBP_ODOMETRY_VELOCITY_SOURCE_SOURCE_0 (0) #define SBP_ODOMETRY_VELOCITY_SOURCE_SOURCE_1 (1) #define SBP_ODOMETRY_VELOCITY_SOURCE_SOURCE_2 (2) #define SBP_ODOMETRY_VELOCITY_SOURCE_SOURCE_3 (3) -#define SBP_ODOMETRY_TIME_SOURCE_MASK (0x7) +#define SBP_ODOMETRY_TIME_SOURCE_MASK (0x7u) #define SBP_ODOMETRY_TIME_SOURCE_SHIFT (0u) -#define SBP_ODOMETRY_TIME_SOURCE_GET(flags) \ - ((u8)(((flags) >> SBP_ODOMETRY_TIME_SOURCE_SHIFT) & \ +#define SBP_ODOMETRY_TIME_SOURCE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_ODOMETRY_TIME_SOURCE_SHIFT) & \ SBP_ODOMETRY_TIME_SOURCE_MASK)) -#define SBP_ODOMETRY_TIME_SOURCE_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_ODOMETRY_TIME_SOURCE_MASK)) \ - << (SBP_ODOMETRY_TIME_SOURCE_SHIFT))); \ +#define SBP_ODOMETRY_TIME_SOURCE_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_ODOMETRY_TIME_SOURCE_MASK \ + << SBP_ODOMETRY_TIME_SOURCE_SHIFT))) | \ + (((val) & (SBP_ODOMETRY_TIME_SOURCE_MASK)) \ + << (SBP_ODOMETRY_TIME_SOURCE_SHIFT))); \ } while (0) #define SBP_ODOMETRY_TIME_SOURCE_NONE (0) @@ -70,31 +76,35 @@ #define SBP_MSG_ODOMETRY_ENCODED_LEN 9u #define SBP_MSG_WHEELTICK 0x0904 -#define SBP_WHEELTICK_VEHICLE_METADATA_MASK (0x3) +#define SBP_WHEELTICK_VEHICLE_METADATA_MASK (0x3u) #define SBP_WHEELTICK_VEHICLE_METADATA_SHIFT (2u) -#define SBP_WHEELTICK_VEHICLE_METADATA_GET(flags) \ - ((u8)(((flags) >> SBP_WHEELTICK_VEHICLE_METADATA_SHIFT) & \ +#define SBP_WHEELTICK_VEHICLE_METADATA_GET(flags) \ + ((u8)((u8)((flags) >> SBP_WHEELTICK_VEHICLE_METADATA_SHIFT) & \ SBP_WHEELTICK_VEHICLE_METADATA_MASK)) -#define SBP_WHEELTICK_VEHICLE_METADATA_SET(flags, val) \ - do { \ - (flags) = (u8)((flags) | (((val) & (SBP_WHEELTICK_VEHICLE_METADATA_MASK)) \ - << (SBP_WHEELTICK_VEHICLE_METADATA_SHIFT))); \ +#define SBP_WHEELTICK_VEHICLE_METADATA_SET(flags, val) \ + do { \ + (flags) = (u8)((flags & (~(SBP_WHEELTICK_VEHICLE_METADATA_MASK \ + << SBP_WHEELTICK_VEHICLE_METADATA_SHIFT))) | \ + (((val) & (SBP_WHEELTICK_VEHICLE_METADATA_MASK)) \ + << (SBP_WHEELTICK_VEHICLE_METADATA_SHIFT))); \ } while (0) #define SBP_WHEELTICK_VEHICLE_METADATA_UNAVAILABLE (0) #define SBP_WHEELTICK_VEHICLE_METADATA_FORWARD (1) #define SBP_WHEELTICK_VEHICLE_METADATA_REVERSE (2) #define SBP_WHEELTICK_VEHICLE_METADATA_PARK (3) -#define SBP_WHEELTICK_SYNCHRONIZATION_TYPE_MASK (0x3) +#define SBP_WHEELTICK_SYNCHRONIZATION_TYPE_MASK (0x3u) #define SBP_WHEELTICK_SYNCHRONIZATION_TYPE_SHIFT (0u) -#define SBP_WHEELTICK_SYNCHRONIZATION_TYPE_GET(flags) \ - ((u8)(((flags) >> SBP_WHEELTICK_SYNCHRONIZATION_TYPE_SHIFT) & \ +#define SBP_WHEELTICK_SYNCHRONIZATION_TYPE_GET(flags) \ + ((u8)((u8)((flags) >> SBP_WHEELTICK_SYNCHRONIZATION_TYPE_SHIFT) & \ SBP_WHEELTICK_SYNCHRONIZATION_TYPE_MASK)) -#define SBP_WHEELTICK_SYNCHRONIZATION_TYPE_SET(flags, val) \ - do { \ - (flags) = \ - (u8)((flags) | (((val) & (SBP_WHEELTICK_SYNCHRONIZATION_TYPE_MASK)) \ - << (SBP_WHEELTICK_SYNCHRONIZATION_TYPE_SHIFT))); \ +#define SBP_WHEELTICK_SYNCHRONIZATION_TYPE_SET(flags, val) \ + do { \ + (flags) = \ + (u8)((flags & (~(SBP_WHEELTICK_SYNCHRONIZATION_TYPE_MASK \ + << SBP_WHEELTICK_SYNCHRONIZATION_TYPE_SHIFT))) | \ + (((val) & (SBP_WHEELTICK_SYNCHRONIZATION_TYPE_MASK)) \ + << (SBP_WHEELTICK_SYNCHRONIZATION_TYPE_SHIFT))); \ } while (0) #define SBP_WHEELTICK_SYNCHRONIZATION_TYPE_MICROSECONDS_SINCE_LAST_PPS (0) diff --git a/generator/sbpg/targets/c.py b/generator/sbpg/targets/c.py index 3f78b4acfc..dbf6d7eba6 100644 --- a/generator/sbpg/targets/c.py +++ b/generator/sbpg/targets/c.py @@ -316,23 +316,22 @@ def create_bitfield_macros(field, msg): bitrange = (item.get("range")).split(":") start_bit = int(bitrange[0]) ret_list.append( - "#define {}_MASK ({})".format(base_string, hex((1 << nbits) - 1)) + "#define {}_MASK ({}u)".format(base_string, hex((1 << nbits) - 1)) ) ret_list.append("#define {}_SHIFT ({}u)".format(base_string, start_bit)) ret_list.append( """#define {}_GET(flags) \\ - (({})(((flags) >> {}_SHIFT) \\ - & {}_MASK))""".format( - base_string, field.basetype, base_string, base_string + (({})(({})((flags) >> {}_SHIFT) & {}_MASK))""".format( + base_string, field.basetype, field.basetype, base_string, base_string ) ) ret_list.append( """#define {}_SET(flags, val) \\ - do {{(flags) = ({})((flags) | \\ + do {{(flags) = ({})((flags & (~({}_MASK << {}_SHIFT))) | \\ (((val) & ({}_MASK)) \\ << ({}_SHIFT)));}} while(0) """.format( - base_string, field.basetype, base_string, base_string + base_string, field.basetype, base_string, base_string, base_string, base_string ) ) ret_list.append("") diff --git a/package-lock.json b/package-lock.json index e8489d40a0..3c5ddbd225 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "sbp", - "version": "4.1.4", + "version": "4.1.5-alpha", "lockfileVersion": 2, "requires": true, "packages": { "": { "name": "sbp", - "version": "4.1.4", + "version": "4.1.5-alpha", "license": "MIT", "dependencies": { "binary-parser": "^1.7.0", diff --git a/package.json b/package.json index 83feb4f2f9..eb2525452f 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "sbp", - "version": "4.1.4", + "version": "4.1.5-alpha", "description": "libsbp bindings for JavaScript. More information here: http://swift-nav.github.io/libsbp/", "files": [ "javascript/*",