From 20d129a8e4b478d2555dd03c12a29711ee63c05a Mon Sep 17 00:00:00 2001 From: Isaac Torres Date: Tue, 5 Apr 2022 14:30:03 -0600 Subject: [PATCH] c: Fix Bitfield Macros [DEVINFRA-655] Fixes a bug in the generated SET macros. Calling SET on a non zero bitfield previously caused unexpected results. --- c/include/libsbp/bootload_macros.h | 62 +- c/include/libsbp/ext_events_macros.h | 32 +- c/include/libsbp/flash_macros.h | 88 +- c/include/libsbp/gnss_macros.h | 26 +- c/include/libsbp/imu_macros.h | 90 +- c/include/libsbp/linux_macros.h | 54 +- c/include/libsbp/logging_macros.h | 17 +- c/include/libsbp/navigation_macros.h | 1481 +++++++++++++---------- c/include/libsbp/ndb_macros.h | 64 +- c/include/libsbp/observation_macros.h | 167 +-- c/include/libsbp/orientation_macros.h | 70 +- c/include/libsbp/piksi_macros.h | 569 +++++---- c/include/libsbp/settings_macros.h | 36 +- c/include/libsbp/solution_meta_macros.h | 211 ++-- c/include/libsbp/ssr_macros.h | 16 +- c/include/libsbp/system_macros.h | 777 ++++++------ c/include/libsbp/tracking_macros.h | 753 +++++++----- c/include/libsbp/vehicle_macros.h | 82 +- c/test/check_bitfield_macros.c | 3 +- docs/sbp.pdf | Bin 462480 -> 462478 bytes generator/sbpg/targets/c.py | 6 +- 21 files changed, 2564 insertions(+), 2040 deletions(-) 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 cff8c8b705..da05dc0b9d 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 (0xff) +#define SBP_STARTUP_CAUSE_OF_STARTUP_MASK (0xffu) #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 (0xff) +#define SBP_STARTUP__MASK (0xffu) #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/c/test/check_bitfield_macros.c b/c/test/check_bitfield_macros.c index 994c7ffb39..b6e2b28dc5 100644 --- a/c/test/check_bitfield_macros.c +++ b/c/test/check_bitfield_macros.c @@ -50,7 +50,8 @@ START_TEST(test_imu_bitfields) { imu.tow, SBP_IMU_RAW_TIME_STATUS_REFERENCE_EPOCH_IS_TIME_OF_SYSTEM_STARTUP); fail_unless(imu.tow == (100 | 0x40000000)); - SBP_IMU_RAW_TIME_STATUS_SET(imu.tow, (u32) SBP_IMU_RAW_TIME_STATUS_REFERENCE_EPOCH_IS_UNKNOWN); + SBP_IMU_RAW_TIME_STATUS_SET( + imu.tow, (u32)SBP_IMU_RAW_TIME_STATUS_REFERENCE_EPOCH_IS_UNKNOWN); fail_unless(imu.tow == (100 | 0x80000000)); uint32_t tow = SBP_IMU_RAW_TIME_SINCE_REFERENCE_EPOCH_IN_MILLISECONDS_GET(imu.tow); diff --git a/docs/sbp.pdf b/docs/sbp.pdf index a991fae63bc23a9969ab2ac5c466742dcba1a4e6..44a43c847757de206a3617e8a931e8a27e89cb50 100644 GIT binary patch delta 20678 zcma%?bzGFe_wU(Ymu}cax%Q*&WA`<$^StLXv-3Q2o-;FNV=_sjGfAs(pTG&F39h|TCi^-@ZTqJ(#)81{cThK( zK#BM+T>M&*Cztp{)tPZGvRaYR=}s>!V&jHYukRO1a${?i*e;+%ge{%#EjFapf%P_Z zDP;KH?vWb*NTJp~=Zi%l+ACH9lZge;%pdP8+ZMJ;--E=5aD-#oB4hI_?Q<2wboG!=&&!R z)T)=cPc?iy@!zf_|GwosFmV?BRr{boQ0tKT4juk6x`6Uh4W24ai7WI+SMiys_dO_u zvR(UM8#o^wps*78JoP(L2)|`%(oN}iM|*Ah~%M5 z6ynNbDOV?)A4p80{+a#SjCuyLou?E^C-Ay|$mi*16qwE-USHkO7YZIq&AN(vf_E+l z6wMy6;D12&_gAR!M3TI-OCL}H2g0h~AB}G5cilbc?1Z=VAHlgb1SR@#N?WWj4{pfl z)_hhIZBaZ~S(%&0S&Mtv10~XF4>MP^^#_xMDu>3_9IIYae94~+kHuwePeh8$SuZj~{cF%BG>lPaY5fSkUnjEBku zjpJwlT_|B9LONIQ4FGirEftL>aa8%5qW>v0S>qF!pivbMPy;0{9x`;TZ8gGYGSzt* zsPnYMW~?3oU%N+Fqre(fKk1FL5}ky9X%CL=yi4q^JQ)C;;tb zDrNvaxOx9K|39lTGhhb-FS#KI5-o(%Zb&n(L`lI9>C^6!$d5mk{zFW;04`AYjBogC zav71lwJ+L+Q&8L+x(6gzVSD@^axVyAg~Bvj%F-?GKxS{ZHUANM z5`Z%(OzV=Z#iOuZT=Ipqb>|m-{+SyJW@3!Bf5bZlz;|Sr`Xv<_og`F2z#+z3fNOcV z>mGnPv}E;<@Kpl{LSV&1Y%Nb;H;7AqmMHB0BJG2I4|SymxF%D*2M{!_=>Qxcgin<< zz8k9j1-iaiehs<@1@M_IJ^~&u0OnBQTxS(mubW*z0&pDX#;cIHk|mrw3OLRe+<)z$ zSOQ3~VVfa4S8;{Ncz92y05nQ(8^`Yf&piG-d6ZFe0R%x{VKh!dMQZ})PBAris!|>z z7x(DUWgyoha_<2^hr*aTz<4?Rvia_wK|M_INwchHV!I>d(8h<}8iR=93k5bUj0(DC zXkVCE3WaU;+rVzybM(=%N0 z2FiU@U#X@IP7u&KNye7S%eWzY-c_&2@L3JorHh8KevjPN zXwDw=1F{*Om$0zoCKE0ITcG?`#kjACMYPmwRDxs!N&DJg!L!-XXK}97A8IMhP$@z~ z_9)+vvJPwDJa3^e8NTM&jO4t(wYM)rLA3k13UR*OFtDfX3=4G>-cs?v3(R$%QX$bI z@UWoQVv_9eY)Y~>No`Su6&5aJ1b)slsCA8h^%C#BCl|hQVK~DbrW@n^)eRc@RHcew z&sp{FQRI3Zmr`y6TJ~2S5b5S}zW84LPd_<)@@YSwdiZ$w*i!{58;0ReH(J}Hup!(m zU>>UVWefASHRL8At>4aW)sm>&?|9u_R>-&NMob`75{_*fRW1>eE-H*x+=WDxsd<4>G-%}^AB_yNFr z#$25zzR5jS;blac_0OHf%|QA=sx$*MB;XXLy6Kd+~NFh#nztG#ou$m;9 z*NxP5m}YF|s~!8Hff}r_91i;|X4g~t5|bC73uWUnZ_z^vtpBLlK1tH#wM0xWe$G8+ zSN{3K)4*)+DZ7zLv(XZsOm)X_IvwVPMmS|*Kah2o>_&IdL9p+*6Ks(e3v86p)Hfez z_I)>8%Aq}SC{F#{>^q7k1;JXZwF|?`1iA1DB&?Q8aWJ<08?a=CK&kEbLPDB^H%l;D z(;fA4OncWwyxk2XA3O#jyswCofIYI=-O#ifbahKUP_S%ooDSWJz09j`tk@s7959K> za)#9KQG*@3rS3Od*^k>*;H&mOa3bB=2>afL9tpFto=FVwuEkmWa$V3;gbIa+rvEwd zuutO@#eH&4$x}cj3?ZO16x({CaCc1$3Cd`ZL`mOse-oys>z1w)p0k0_yt-#)^&>zh zbiXGoj;ocYy9+9*RcSxWSW3x|B=4>I<%5mw@1d<8OOBhcA;Cz8iyEznN`JeYa=so< zyTaulm0V7+5=!le@hJ_mmn*pa0w|~<>}jp(7%hR%GwWb!9qnKkc(C(MP``cw3G!-e zZ^k3_%we=^Vb$(1=G`X3uaSF;`=EN@P}@Ju)UV>%K@bD?3;Z6`Kf^^FFXpoO3dde8 z)(MPVSQ+T{@>j(P4DZrQ1y~RX>9z$HTH-h0_)I8Z1#n>fX|4-7y&b2e0NZURWO!fW zfNcE~Zk*(n&(%{G3=_l%9KoC!^FM^%0*MB2`??a9FpZ18t|(9=mJQ7s@f=fr zS{_v@V?H0a>H0`H!p)y7T6mz&At2pLH`g0azq!4jS`yO@7x_hFnmb>OJ|4>Q(yjnh zio9pef?h^Sx^zQ|exhx0XUM9L+ZPhfZ!W$k5l^0$DA zuUUh08VIFT)U7~pgs<3hWmu8;UYEWl9T7b+shjmPMMh_m*!s0Zi}#6ZZ>64oE5jmsJ1kz^@>kkw28>)eS=`Fn;DTyMe@RRygZpo;G49- z2h3znfg88KOi2R*b7idZ6&Sx+q7dyrvy#wm<|KZJ^D(K@<&YlB61Bczb}TdcAXM+1 zDP&RA3wc$6D-zqDPv+vycg7bu9XN5i?y#DkX_ilRiePSwKSU9?5qebk7KYe|QY&PP z0-J-z{Q-y;0rXT1u#Rz=vS7fEVA<9=Px~5;J7;AVTt~Z>sO$T56p3w@r_$J>>5N); z9B~25fT#rX{{F)Th*e~L)t-3xfD_$KqE7M3l+6zf8RgK!e!nF?{Sdz7Ar~`C=~cl~ ztzbOJNMk+*{~}*GGSt^FT}~PE{%TB}td?gDtc1uvdY5AX*6Fmd4{r#;;%UQ~xs8X@ z=eeLzJz4zGET-MzhJZTGS_^0&Do|_3-naN6RaBJlN)3b}gTA_~%bF6AEdH7sBlbG~ zxoMTm+E%n=bRUl7=l5Pelq^HMjm}3*`RoMoYEtfJonK7Lz@(c7?@Z7KC$EzW7hJ?m zf6fE~#yIhnOs?;2#obaWu<2F1q32gWO}*DJ@?kNTk#|m)UysMDWXtLX*5_Yd+?ST+ zO8~cWMZlty1Lm~ZFHPncR_K1u78h#{+!<=IrEN+8db!jUMK(YBlie@?yId(LgEwQ} zplOpf5OkY4v5SbS68K@8$^WGm~CW23ekZx7%+=-E|&Of0QyMyB?0O|M4TGEOxxTH zpWrD^#&w2<5AWH7mR>nO5+-SYB@of3Oop>4u0hvIF=th^KpW2;=xQkX^CR&x3y^~X zXROw-B-G&(h~!Y7Mdy!fWLLPwyx$<;eq^|c0NX&KpI_kd(-@}S+LV2<|kdxT2S zoXI00RSGzS!srUa%L0Z%``|t5y6qY*KJ(j%!(_*^e@OC+8h|Ru?A5E}@)`g=LSs#p z(J71cLwpZ6iHzS)2JU)x_vyG4(j88YD zE43HR>3*?ST|5*sfDKuGwqjDDTy) zalZj7)Elw!K!CXG&CFlU(Pc@Hxg$H1J?)+K)q7t-puG85CUzLwZ*oHM1JB z@Qdy}!L!#8ucX3=ifnN;-^|WX(=X-t0x<$IIc>kb*r2os-WrzHj|~4PBcP?ebZSUr zi3oAvIdFu;o>?}?qJD^ehY-#eKp}bZN;@r&C znt-R&yt-s9ua770k+PNJAb(N9M$iy|97K3ECY|=6#k@{?&S^j%U4!7&1UCF@ELm|B zK$MI-1b&(vJ__JOe0N#xZ2lh6MP%woIJ&np>eVk1=AQK`$3a3CH$TS|V{!zS#1Z`y z!|Z}U?sI@xc$41;8|Jc~e|{VJU}_rY`EwVYAJyaY>UnYYqJ}U~REDIO&M)pRo_cCW zCb^wHqgKTMIX7cTAb-r+&07@4;A3;c+Agwx+?Zb0jC9WNCOBC!g?or}~? z6n@M?Y4b&X|2$J|ITHvvu8PkjO(5>Ucsm8J#%!kAQeRlF!d6&C$QooHEsCQs*X#1x z?S(+Ce705;RS=v6nRU(_qW15oEp<$zWgSG;O}c8MCPp>TE7K%Q00Z~VX~KE@Hr`9A z=%^3x5v-4gBvxvi`HpSn+(`;7|I$|PHYSEwLJ|W>x_dTG2LS*M^ z*V?-(R+rI!Vy0=E=voR?1fIO=PE&UOHJ!{C`LF%d zDX+wuDwkv)9}LKk|KV@R5dy@B>x0kjsf67@sR@=mSvH<>Wr^>PUvH_7dIs>C~-Km5Uu`p9j0{}96c!BC12@7kY&7IIg0Q1 zlVb(ja_s*glB1>@Rk z{tgcJNj9t}$NUkB%0{K&sJh>trPk0yF zdgJqRg(yLTA(%O$mm=U9!h9J)AyLnOIE2B*rIn(A?-Dj&fax=g2C@sf(oa+wi`}~t zq|WL>lexUPbP=%@JI5k-krdU6n779ENVi2Qlns}wr~^XIv!gRh z8AlF`d#w6uM>~g0`2J;E0UG*yT}+DtJWcqeg1G+PTdammrn8?HbANZ9s0Wczcc^Mm z+#L8#J^167MN`+~@B36x7TRpzym>PgtiUX8HCHMpXjn0K&pfZ@_}p0ZW(fPq@MKR7 zV|ryful2_>@tCA-g?;n73bElkfTuOcDLMD&gKyMY1Ms2{$5v49eVL)*?2UywEujcR zHXLc+Vk265el$Kny#K>@(paUFkOZ&qQ*4ccEdNcB#`^<6BMNcGueuH**#-}Hzf{<& zaka!}59a;*Q&cwnM`->0!2`oiGsAc$A>)=aq{G*gJsJf!nO05HpqR3Djm0MHkOs31G<6W9UWQhB8qD?g`o>s~DVH?#dC zA&dshfD%o)O?o`90dmn+X$NRjxxG1OuTknM1nKAK>SX{wTsG z33La+KVC1XTZBCEFL+`T_O4{k5)pF?A*sO~|HmXx$pDoR`$=nsM-Jm8%2?J3bg8_; z*e;A*{Wx`|aJ%l8qPI!daLEi)_Fq+KXa|Kx6(+aWj4-!;EH?*(CErgzY8bo z5%x3K*FQ>#5yrHl%X>%BQI>{^tMY7C2&AN^;gG{z;9d9gy+!Pw7^_8USaeghV?q=H zE(BjYW0v^bZsxX$SW*9UpqsZzu^@>H1V5MTGFJT^f;e%UKDiC~ka_K}RT|Q+RS`jS z8=|Rp^oL8v<%oa0Bxhm)M`l(u2zN^*9L9g<4cz++>G7`-WpjJFI#yHvCf9d31+Dx_BR$17KS&UDdJBF^P?Z2aQc2M#m- zX?HpS#M>ZUG`c?hT44(~{z}v`hAPF{^OQK(_KK?E6gk@D#WUQX6ZaH?X|dE^Gi|g`or73<#LEXSv|bj0AZMvjif_k=wKmaTBdQS|6Crep5AyK!U9yKVuxKqfDZj5BEi z#B=rP?$<@o*s2-I>A8%~>|wj~Z=a{7d@w>@a-_&^x_vEIWNvEetk}}c8{jdbrC5j& zbuVr+uB?6;8YmGHcZp{kE`K#|%>Fd0Qz1>(X~CGa@WeEwP7qnH`1N(8!yN6e=F-ox zv3-sSbhNMIr#|ay;rCq(FA_ZakmlCVE{RYWYtpmx#i0LrIAZCa7`HWAUf_l2KvOjf zm;C5f!Ni@=K1CpO8C^)&wcpa5qNsn;f%gzDk91Yt4ec9W4ZLADpfKlfgO8B+#0+$4 zfdZA5hnIJS;CvtO3lwFuf^0fTDBUi9lO|<{(YyvvT^`YH1|N})Bq(R%d%!lfD-i{E z2A4OpVqNCHRmIBtyXt(~zcxSXG6auq5ooRT;>6k@IiC3*8=c9r*HQN45425!vUK`! z(NI#DK;5r{wqx9J${VlWQ7A=hS#z*PsKT+h?Iv8_P9!uN6MUE+;BQM#a_mZ*vENBQ z<9*4R>)3!If%?^Xef6jS_4}l>)P|LqC2@j}Q3RJTAtQ=c0&SPOp^Sb-w`+Z`vBs!J zEt;;(U}v^0T>~cR=@ZHYB5bNg(>mH~e?h59u5U?5bY{}6U9P|3F9@Dx_Bm@RS`4wN zddxbMQ=-O%+q?4Gb*!DUZLwD^UF}vyvo|ufhR{42G9Gi z9^KYAZ6N!@c?+5$!E|oF0uFLwdOahd;r1<}?f2@*Bf@P6l!L&F)0t%F)h`)J`biI~ zAs>luY0oJjI^(5}OraUD4+TCI2gaAui>68@Z&LhZNlfm$atSpPGmU#>l5K!AAfg{> z^0=5_>&dU{ZBbLLcOutN^k<+)|Jb-;4=hH3N7A5%zM=`o5(JA+BCvV3ex(omFy@4_ z|5YJOZhrglMO6TPiukCjq_xO_(|)bD!#HlL)9P8)%lf{%PRdYd@KjPTg;sq$C6K-@ z^X|IBgh~JlV_M0wQp{)JYhyUkJIRO>OA(dj%w|Ua@MS~JHbSCADTy(rI=hqzX2DCX z@1ljo265RZ2^&XiYzP+J;Zx5mjTAV6%zz!ch3#~c{?;B(1mf=!y;)Uac-G=p*f5dM z;@CIsM%fRw-mhFZ2SsD#F#eM*>(OV8RtbY zC3uy$815}|%dJtMAUDbO?c}QsMgEoa^MQl|bvF;I>@R^&E5!|D{0=-G=8kRAUW%}0 zgNoL+rLPtnB8|XfGciCklwY*bY05Zse{b<~gB_BVm%ReA>gNapHG$9j<*%VC5_U%p(nPEKbAddK;Ojpf0xkN++dF-E zCK|~n?`;J`4Xldc!JqTWL} zVFfW=y$h$4f4Jp?8;B!w%6>0mU|Fh?1ks|1G_vv)A(U{fjPJ}#{5WN^*!XJQeou@R zg2s>-IS_B(B>mcVujNh)aLjd*ElQOD9p5-lG5!In%1XH*L7t!qi;GnEJ|=-1sFkn!+$!XZ2xf-2nAuGfqv;Y3U!@p`bp$`gRW6dG<2R! z$^>{}uXnjR2TjB;1ExZZDC;g)FM}<;-D-AK#}L^32{c8dsr;^gRxeFSpQ4F0k}_2q ztxv2(sbhxWY`kf=U`Dn}djsVmZ!)4H$GJ=tRh5`Jdsw^c_=WskyE{05&~DS&4sSoz znn{+6FP8t3V4F)npg=#@x@2Le@ZFG$vO29|8`_FBz_;mrPf4c!?8hP_(D7qOO{5N5MgJpE0>lHu5|8O+;pt3uIcRb` zPteL|n-A~Ms}P7}&PWhJf0+wMA zX}#}7Awlz$r5m%3^r*ld*b+1P_Llu`D};@GZNO|GO!*ZaWp7pma|Q8Jw`n(M>&ZQ| z1KpnOu_GTkfgY%Yw)}leN48OnH@fU3+EbYqzYrYezaH{P9>$Y%2|!3Xv&U)pXTmyUB4YFbx6C#9lVc{oEHzF7Jt}dQi`x457tXj}3+5g0xZKHh)lF z|5lvfj{|TzmU+RE5n{L4Lg8|fj||EaP%j9+OSzU{^3;1!fb)B_-bk?kqU0VRYm#sA z$Xt+tDj@Juj)w=5MiuRga9Y|99Vr*a<~@Lg3QzVwKZ+J44}mFOF@-acjY!65ybg&o zt0&v5eKnCVAcu` zd*B3@kx(w@b}OD|9Rdg-J3wCd5pj_P^?+cz3jU~0^sV6xj;c~`1z(L99d)35ljD9w z%oIVtz;J6*RQld5AT!pzQ%x>ZV7rxOkHW-7{2@=~Z%aOEplc8ubs#TgDi(wLHGdpR zwwdJ4s>mHS8nyevBU7LSat6WTwI7oZ#93`n<54<1`!2*VD-jMMb`QKcvp4?+N8(=A{Wr-J%$IgC!X@=eJzw=3-Z zAKGb;A__^MRUk2MvB0J`cDuh!VD|#{1=q?@rp_(8bZEraM@TOfv<8IFyk1KF2gBUjdcV8QCeaQQXtH4ozD#R86U(Hxvj3|<*eIL} z(gDIZ4C28|*uQK8HzWe1O{jVftL{K^!MtJ*NkjOJt@)rM5OEyVLpGlFVq9cA!4o5S zPW)4E@jLX+Ye&(4%v=$u148UXV;*RK&5x%J$4nA$Iohp56kJo3O8nIR$8=SI*1*Kd zdepM>4g8D>g7hn41$QW4((H>7fL*$+WDW5L4>VB=vIP+jM$)SaX1}gB_gBwZnm4EK z{pfm&K54YM{!i#tBWMl^+oX{2pTeR!@CD-DLTlx-kb-n&&(P=6b zuKx;)Ce4K>3%lL7=ryo%nMTpvcEY~RF`8Ddb7hvxmG6Ql$2QO=K89FQqNCwz{aY;m zm$ln~lXqUw)ywt4->sp2?i=^2qR>_TAszR;cL|3>A(}5!LW(nOR^=;hVhJ!;5dt*s z0uHW;NmUt6BJZqHM>4WGM2t6d9#(yyhDMVsLIwI1+>E4&S}E0z74&^Uhenn<`D0F7 z)X0)SMsp5X2@)=c$E6qs(<{dwE?;z9&bdMdOvix^Usm*D6PoIsV~bX!!+ElipL>}2 z2T3$@mMliEkB7K9x;rSc)W2^PLDC`STtC>Xi#d_?vT!n7b$`lU3*(mX<1Li4e0 zJu6hhNjYT-n?@GBjn~}Mxl26Mx*(8JF}%}}D>JDg+7a-TZP$wSx6h`c`^(7~RH|Rk zueiBbJGY*UHTQ*dWuElD>0=o%>Fir^7zBrmqy{v^<+L9SImNOqy6(wr1|t|t`Qktm zE{QIqP@#GpbkQX zpo3P!+2@Z)p6YL0YNFFw7e55OgDwmmT9QxYa^78~rAHBJEpgehsLx)bNekJS4ayQG zpfid2?()maX2GI;B@#a89W!#j8Cl{L$DY%K`dMSIG11+GsxjfR#ngexOPws2f#Y8H z+`G(>HI^U^Wzewk6vvq^G&l3BoQ7SFlR`~l?0d8$`;KuUg@Eg>&054yn@?wsVag>% z-q|~ISy9$9bv*Jw%-V)}9MP5Kur5-Sn^t}f&i+5bu-w_^on7Zs#W(qS1_UVyI!@1w zQMbm5LoBdsOanhLoH?>G$=7pqc=4;E=Bv1Pk~;+(X}o<#Z;HpOT(hZjEF{0o7E#yC zuoNn==~IGiVj@YkldgpRQc`rE+ZSLmUrzdO?n?E56hXvXgAWJGpjjPd9JHv!(&516 z%oYSv(e%OXKc=}KbPR-laFBY4Wuz)B#o1nwHM2~#`d+~B89FNdA#;Nuc@VKerFmdA z8QA5C8E|wPwJ>%eWAq+LRSTN*k5L>2l>y-+Z`ry6=O-OUk=?$ZVQx>^s~u5{k=hbG zI#B8f5GxwIkOUw4zJYE%&MEY#&^je5f8S5U{3)B#KN-&j5C{xUw|ODy|_~^ZoLq@ z5Zh?}#}My>WFGbcZt(gN&ix3)f$&BiNTOA8-yLWlC*AQM5_SyoLV;_vFoj#2RKsx~ zyw>r3D6l2kbHsiAkLrI2`!z@r3j4{?hq7lQLboZtU!JHwJg2a4G8@#g^^eF0f)Aho zuH;xWFg`fwcq8?%HMtcHtbrIijOOS60^(I%l+H1pA|<6Pp@ZV(gk2p8`vN$FQO^8F ze;x22z0p`xVB|!(%3s--@{E-~%D~N+GpnmJh^g0nIEU{w67U`;*V8D&4Eix0+TFO% zWMp;n+*PavZwFstnQPI^&id!8T36gY(Hldbj_1-j-It{|q~j<4oJ|NgawUKx7q1En zN^8y9Ki;*}hKGN*tH@~WO}(tNQd_m)gwKp2F!b`mN=|Z^-CC|{-kX?O?wgc-b@LTysWK=SRdgXFw zXi-S9iz+_fN7i9Y-(VL(Lg86z$?G!bQz#Qzrbx6o-*7RALh}POG6GdfO|=Q~Wl^B~ zJ*87$9p{+c)PJk~Mg-TYCWxC-YStjny!z4N*J4_SgLU1e##k+jRY5be`k}{k8g*{T zbkUFh`I77EcP!O+YvM3&jIux5Qbx>Tu0SVPvGDss2$ttp!b9Ly=H>>LwVVyQyh-DG z^{*j1%J?na+#XT1sb*j($?pU}yvGPyN z7aOyJg@VL6G6jRAx7h82c#&_0=f!T2FB6kBU=K0KIVPAB3TGN$TXbFO(cr)u7(Xou z%L!TUya(NO{Z6jl2je$t5`s4YPdG3MX!cnSFKYzcCKaxZ+0|8lV4Xpm3TG<*D(NE@ z`Tp*X{gN-F^M^|K`H(IMC}djO4`?n*#Z697vp7ACMN@eGkl75w9*R>|&^}4ol>v8c zI{#V3Zbe7&!pHWi9QP&9dWPu3SIeV~rg`JOEkoe+6LkzX%9Q$K`7%Jq_bZqxDiDzh z>FyY3u#Qib`DJ#|ZxJReR7tq|_lC;b;5N0ie$uh1>N1w+Pz?3?MegEF;&`8{!5bNd3m8C{Kk*_l z54gz|zxqjw?5)+s9PpA?jS35_w0m#7p+XkOf=BAlrN_bQgm<}JO0IXAhiS#|3r>Uf z^WA%>HdY=%L=j^jmjst$S*!qxpw&px)v$0e-U!ZS!N-}nUS0WK5=m59xStD`R^rQ2 zNfl8o8gWFzDCLU81v2pFmjU!I{(i-l~%r-tPhCH{$SgcB~q_6ZS zxZ$+5)!kzf%oPg0pI%yVmK;QV6snoC&n4g*M51Uf5B3$zQ0)p;YzTgtLv z`)Xjo?m!xY?tHge?o5Lr^Uc|@WB5PrW4W9jGrf-h(d~U$NV+!0*QeXiTSi_Dqj64sp zE_Ye6?naGAeY-REgiGRfYeFh6;bGYpiX6_lG6#!wRKE6NkB$ zOH^foZ2o6kGKF`C65=!sR&^2v*z`JC-zM_{rQct{nhHAD>&xdP`MId*0xwRQmoy|= zBL^GIm#&JQ7m|3UT@X}9A9RVJSPZ=gu^xy&h?4)rO2)60&hZYBoszKC0yDKQ8aV|7 zaw+v!Y^SE}X8w?BmH8Hyv{=K7)dt_F?U1Ip9S8h6_>}RZs?>7$Ag-Y31 z7-a1XhbiCYIs?oIIbSS6QsVAX^MZq;G+0!_Y@nf42WvBdBs{K#Ua*&njJLf4?~?EX zh*p2a>TEkSm?ZEcG`>@8>MSaehX2k6thU>T3RY=S?!+3I?kdnxT7nIFJW{_IsW$O#fo9SF3Gg-m+^kp)Sre zadjH=ZehVP6_|142ExA-yP2meU>aGrP%ghE!yAtr?3Twva7W+1X%V!x_f=gx+wJGu zmLz#;PQEC_{bT%@7$B6Md_L{Ml^kD zD10)VH)K>0n4XvNb{47%H*Ln^UUeN-aQtcVg&2sT_xC+W*jPgjMgU1pp`lu1?96YC z9Fo5U0@Hh3dS7@g%)H^A67P7#%&5SGP!cAmr-Pd_O!^Uw8=WdJ%iP&XS~E=qXlQ2v z+!)IU9)Q5eqTy!t0o4Vh_r;8sbs;u$S|9ZUK9(T9xD0P=euM&mWKUzfa7MvgnuzMwldfg6=wbBA>PkIRe}@+ z9ny~w2+w4694yVRJocha2TXzr%tuR}G=7M~W!#saJ=$-K!2_toaSoxl{qz~i#g`#6 zKidlYKd5cp10Zj%S^hyGzg~kMKFE!~UPJW5A^e;IoSZz#swWWGf69%vClCm-2G_%m zKd+38l&q|bj3BQRmo%5O44(wIASXYEq%^mnlqjXh{}VAnV^_9vc;)($JkFAMxoMFV%zwRTvUK#*fYI+GT!>b3JzzO22buocP_+or6*w zP#pR(uNb5i4tWQam2otIvvU{ISVj4BGdAVqM;bOqg>HMCj8D6@yBxOZoVEWb(K4YJ zKM~44Yiqc(HWf-S%i`}pc~vEpN>!acrRLGwf8z91Snej+Qj#{r2%#?Rtq zPx-h!!OJl1tvMQQtLifP%YpY(h2S(VvtG%!t!A-t=b1yVx7+kTY%A3Y1c9zNiwbtY z(O6T0>ZRWP>3wj1*Z~7y^cI|B?vH;zmAQp=X^#(eXd})vj?b>NxnWpTp&+U1n8O7rRxHQx&*%WtM2rEEx@*GS_Okhg>y(ey&X z$O=o?1!OTgW==V8FHp_h^WVl4s(!~r4ROUjjc?hZGN%b6%PDzS652sHGb5rqk~ zzGfi8UsQ-MV-yO_qz#ruMiA>nQooJW7gMRJcDxEM*XW&Sq>PWK?xn}y%U7s@t%vQJ z|B{ucf#HV@b{bm8?e|%lW13%-Qhtjl>2-pEjV(t~T zy6tbtzJ(KC!aqU#Euy(s6^90f7T1=dwvSPL#-ngw3u*fQZkFBd+e_u`0;yE$wyPv+Q2#O`t`$9_j@3roe4m4lKp1Kg_$EpIFB|>jRkA zhAD7yRSL)}x2Gw^m$72uYmLb}#I*@XmW9ldrqOyiMW)azJrA;ESH;<*;ftUjG|r&z zm#UyokKOOX;avKZ`uBII%s)4;VH`AWTGYlwY$oqM*w%p6sJ)g)5h7AXHE)QICcCC{ z_!3h9*(n%YK`)Uc%_Blp3ZDaX%$Y+~^1eY9!kD_~r$_-pq1JgR;x4ps8D;M8?rE8w zbY8rv(srbyoSm1=X=-$QNrgiF`0DoG;2&d^S_k96gKW(pd;B^?FxRuP`QKX4eea+ut@rbME$6_|VY6EI&D z)QahG z`b9datE!QzPHkC$EEi9dkcL0Y!c3jM>SO6o@jmejdXZ03-%Bvkf+bt04jDAqIuQ89dy3nD6nTzjgi>goKJ!ZJzRP<^NK7EEr^UNc>N%NEqUOX^9^C zzsdZc!vC=huRmMyAeVmZFYeT_IyUuO=Ok6<5dRZ!**lNVP~0@R*W|e#fm;uSP*N(c z4}T~nH&9|}q@!^KWjEll7LNtQf0h2vf_`O4DCyouoLGxCG-~HEn7DNG*+R&dYU6Vp z!8vAf>H*JcsSW)~mrzm~=g2Rd)C2!Ng&`A_q>vHA^w+`b%lugB2>y$d8c8PC-p}t{ zY_j-{)=W-wjv#HO%sbH5E>TAuQUF7z4EX>d2c9xyx{H*9f(6oo<#7<{A$62!nZj|H z`;Jf_oiF82;kMJ0!Iu-zxBhSp|Me9f0d#=?5hQ!R=`RC*Li%7`e-t~gxAhp^Mp36A zIpRPZG0TRuR)+f6zl`a!_0H zJUC$9l~)Mm;W=Vw*Nw-J=kzq-JvwJ5q@mKBq9p6HLO2yN5yz~ZyViLeQRF*)&q#P7 zKNysNAwTFx&{z~da{Yxa>Vb8pqJwF2QPP1l6IpDwmagUg%Sg!X=+)Bs8G8O21vNGf zy+o17QoJ+|OdM0%TQ%~TU5{5k5jBze%YO^Q3_SCNRK*4|AXSM0LDMznJ#?D}GwY>H zc&S!@ODK~v*QLyLDRW(lw5eNKJ@SA)f$%AgNSXCg=DL)*E=B27cWsw>-@ikH5k6(s zOHn^X^OPwqMcNcCQ>L^O&C`SC{p7M*m?6asDe9+3&3k&DI(XcrsGp*Kirl57brvZ9 zq9II&DYhs*v*+lRluUvp`j);~aKB>Ai6zs2VcEu&^OGerVTlDwX2OzLuN-04@vuID zUrHQNVu2F%OT1As6P74ljyD^>UxTqli3LjL#1e0m%!DOAC{encVK%)>gRw=)oLJ(6 zl9{l?2PMLn%ogQ*v$@+en2E8(2PG~k@j;2w<#MyG0S&^RUBl{F z1J;2pU=!#uyW_d)-2i$)AJ}YmsaqXe!8Wi5>;l`(KGdh)ey|hl1G~-cIjxQXp!cJr z91Vg)V87WXFJI*Wa1a~=hs{2JLLIs+ee4W44V*W=beDQh02TaHxpM+PkR9aKbt;6hz zLG_LVxTJ-1T4T(9{wZ}}sg??Fs+OsYHqq>9PraC{gx3$#=P zbGG>Na`mcsrfQkq5s!1Eq8PSlEim8Srg1o|g}GXotF;{9h}JUmJ9;&L1YfnVN~;@0 zpa-lrf4pvI3%|7ROA8~lHUiAh+F<^)S851;X>A5rs)ch}7^Jn${JC2+WINaaa7haf zwGh6w+x)JkhG3Nz_G#_sve37MEm~NhocjRq4yr}?KNjT-~Tf$?BEmdRtDtaz9|C%;+ECF4dE)}#$<NW zp!(z{psM5+pxUN;%e?Vh`s^C84r~WK=D*=qb*N^!4X9GN15k_P6{^DPQYGp)KfPXq zDM<1jRpE81674tt_J`F$wUPIz3U5yp-jpiQVe{|kRWJ2K-lHnKN452z=I9JKY5rZG z)ev1YbwXaDD$%fi`5(Oe*|Xq0#lnCi=ZKG9Lq{g~7F7SLBQ(!K^Y1&ZCVt8AM%D>N znE$y4)qyQC{F0%5hO`-)XDFSGHvfxn(YUbyzho0RXO%F~JezF(L$Xgc4PcrKZ)8{? zn`!FGAxi$AJ3M511ylCc}6`ubJN3P0~$;j zJi`JR2Fa*wXGoi&ezwN^Cu$mp1u_hhVUP@iWXPQ%a<;|%r(%sm{R~@Vs)wOWhWeT6 z&wGHX&Iq5WhP>1Krz`rbO3$h_$3WF&ERd0O*&*})kZYVu%BmqB2dW(7gG@K}3~y~3 zcgp;~w(CfL1>$o+>SK%Sq6JsoqxV5xt3s7*M*tOSdCLk_p6vv@0ETXzIr>%lglfYo z22+_0s}_vASsfH_Ltf6pNno4>(>v5bwKkOc!yHWkGr?pFYJb*{seo6@a0ZwK=7E|8 z^K%WE4S4Mf=Yj=bDVT3T*DeiN2zVn6mw;t}x6iPD%YyD<4OtF&Wej;`4A+Cz7OY>a z-Zg+%)o>ly1bQskT2rs;th|Yr$LJs}2m3pmeg(g4^~gMoA!lLF8nq1-D3fRdk_5SvtrmRjtBPTe1i6!b z3+{bHF_qO-Qo$C<06_hOs!Oulf=^$eaa3XwT#_6B)H0Go7JT7y?_of7COK-sS0s0T zatt7Ma?*ka?^BHGM}pGH84Ft9QH=CcG9~9NczBPF^sh$G!hNG@=4hTf9~9fv#2Yyl z$SW2+dbMI$CC3r@2n+t_l46)4*MDl951x=qa=el2zcOwr_~}{2^pBeffMQaP1@cK2 z{9>wlaY>F3^68wFafBmsGCp^X_{~j!8iyltYEU^fsGN+?=UMRoE7Xfia;AcO1z;A) zmsse_G&xg7-UZM+Uv6Q?{p!FQIhyCIEbRQ9Vpt_-j>y+qIO(ur+6fs1zscc-VTT*}#A_Biyp|!aqxT;VIox!A%Hj14x%s&c zZ+MZz8(-k?rt2JTxzXXxiNmdTJG|u`4(SUW-pa?`_A-aJ_d49h_q}7H!#hVi+&<6Y zU7XOn=R3TI-~Fd{@T9{Xk2~D?J%@k(k;8jOfIm6h#nD|qba?+W4wvRQ+|6e{xYprA z=Nvx#9EXows~bBXEC36CK_6IT;YaUsLq2xg;p0B|fx{=>;_xrK9PZ)r?|H)E-bWq& z_3I9w!zWt9;+r-stck__tT2m>>VfD;&Pb^?r*J|IaHOzMVNda@HYV=I|X1Qfznluj?JYn>u{&PKQTv z(_{BLeE&NR|NSM0$GLhQCx9e(~= zhyMk?_^QJ%xe-r)WAy*~mBX*`!Ed@8e!I`%cSjw{%QCJ85m*D(f^`=D{wwNTZb_@mwArdJyirG6ta|gOb+py09~smU zyXtD%vZVjQw}E!6KK43~BW+({!&+^mRi7M1tj>S`>+Dy5sgw3~{_$VeUNs&Gb#^t? zXM!4-1=t5rXR|_G``6}zd0;+R02TuFF4WnzQD@&*oxLvgF0c$N2W(}ivv;A+u9rI7 zIqIvxY7l`nfc-CZ9t8FEfGr+%_H@+Q<52Gf+S|w`vAT93YRjSa7_!f!&d#_xJBjLS zm8xsg<1V0oEr;4;$ljSc8;j~}A**Y@;{m`1n)*SY{f^pv$fRFC0@xl>KL(Bib{y5& zW>wdQMD0Kv0&F{~4+A!j)Y(~6*Iq;x1a&rHxk<44+dm;nlRY*~b|p61RniOrsy0!z ziK@+ZfS^qTZL-^@$+oR#Ct$xta|~d6Qj>i*O*YykG})2ToCpxUiSSK?Zz6mX;hPBG ZoMF}9-0M#0kDcD%03Z|sv6p8K2Pxw5X_){3 delta 20712 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%0AH^_y>x&*;V$)d>sKPfJnGMScKM6fIUdffn&R9 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 diff --git a/generator/sbpg/targets/c.py b/generator/sbpg/targets/c.py index 8798ebcf8e..2fb2aaea8f 100644 --- a/generator/sbpg/targets/c.py +++ b/generator/sbpg/targets/c.py @@ -316,14 +316,14 @@ 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) \\ + (({})(({})((flags) >> {}_SHIFT) \\ & {}_MASK))""".format( - base_string, field.basetype, base_string, base_string + base_string, field.basetype, field.basetype, base_string, base_string ) ) ret_list.append(