Program Listing for File imu6.h
↰ Return to documentation for file (include/libcaer/events/imu6.h
)
#ifndef LIBCAER_EVENTS_IMU6_H_
#define LIBCAER_EVENTS_IMU6_H_
#include "common.h"
#ifdef __cplusplus
extern "C" {
#endif
PACKED_STRUCT(struct caer_imu6_event {
uint32_t info;
int32_t timestamp;
float accel_x;
float accel_y;
float accel_z;
float gyro_x;
float gyro_y;
float gyro_z;
float temp;
});
typedef struct caer_imu6_event *caerIMU6Event;
typedef const struct caer_imu6_event *caerIMU6EventConst;
PACKED_STRUCT(struct caer_imu6_event_packet {
struct caer_event_packet_header packetHeader;
struct caer_imu6_event events[];
});
typedef struct caer_imu6_event_packet *caerIMU6EventPacket;
typedef const struct caer_imu6_event_packet *caerIMU6EventPacketConst;
static inline caerIMU6EventPacket caerIMU6EventPacketAllocate(
int32_t eventCapacity, int16_t eventSource, int32_t tsOverflow) {
return ((caerIMU6EventPacket) caerEventPacketAllocate(eventCapacity, eventSource, tsOverflow, IMU6_EVENT,
sizeof(struct caer_imu6_event), offsetof(struct caer_imu6_event, timestamp)));
}
static inline caerIMU6EventPacket caerIMU6EventPacketFromPacketHeader(caerEventPacketHeader header) {
if (caerEventPacketHeaderGetEventType(header) != IMU6_EVENT) {
return (NULL);
}
return ((caerIMU6EventPacket) header);
}
static inline caerIMU6EventPacketConst caerIMU6EventPacketFromPacketHeaderConst(caerEventPacketHeaderConst header) {
if (caerEventPacketHeaderGetEventType(header) != IMU6_EVENT) {
return (NULL);
}
return ((caerIMU6EventPacketConst) header);
}
static inline caerIMU6Event caerIMU6EventPacketGetEvent(caerIMU6EventPacket packet, int32_t n) {
// Check that we're not out of bounds.
if (n < 0 || n >= caerEventPacketHeaderGetEventCapacity(&packet->packetHeader)) {
caerLogEHO(CAER_LOG_CRITICAL, "IMU6 Event",
"Called caerIMU6EventPacketGetEvent() with invalid event offset %" PRIi32
", while maximum allowed value is %" PRIi32 ".",
n, caerEventPacketHeaderGetEventCapacity(&packet->packetHeader) - 1);
return (NULL);
}
// Return a pointer to the specified event.
return (packet->events + n);
}
static inline caerIMU6EventConst caerIMU6EventPacketGetEventConst(caerIMU6EventPacketConst packet, int32_t n) {
// Check that we're not out of bounds.
if (n < 0 || n >= caerEventPacketHeaderGetEventCapacity(&packet->packetHeader)) {
caerLogEHO(CAER_LOG_CRITICAL, "IMU6 Event",
"Called caerIMU6EventPacketGetEventConst() with invalid event offset %" PRIi32
", while maximum allowed value is %" PRIi32 ".",
n, caerEventPacketHeaderGetEventCapacity(&packet->packetHeader) - 1);
return (NULL);
}
// Return a pointer to the specified event.
return (packet->events + n);
}
static inline int32_t caerIMU6EventGetTimestamp(caerIMU6EventConst event) {
return (I32T(le32toh(U32T(event->timestamp))));
}
static inline int64_t caerIMU6EventGetTimestamp64(caerIMU6EventConst event, caerIMU6EventPacketConst packet) {
return (I64T((U64T(caerEventPacketHeaderGetEventTSOverflow(&packet->packetHeader)) << TS_OVERFLOW_SHIFT)
| U64T(caerIMU6EventGetTimestamp(event))));
}
static inline void caerIMU6EventSetTimestamp(caerIMU6Event event, int32_t timestamp) {
if (timestamp < 0) {
// Negative means using the 31st bit!
caerLogEHO(CAER_LOG_CRITICAL, "IMU6 Event", "Called caerIMU6EventSetTimestamp() with negative value!");
return;
}
event->timestamp = I32T(htole32(U32T(timestamp)));
}
static inline bool caerIMU6EventIsValid(caerIMU6EventConst event) {
return (GET_NUMBITS32(event->info, VALID_MARK_SHIFT, VALID_MARK_MASK));
}
static inline void caerIMU6EventValidate(caerIMU6Event event, caerIMU6EventPacket packet) {
if (!caerIMU6EventIsValid(event)) {
SET_NUMBITS32(event->info, VALID_MARK_SHIFT, VALID_MARK_MASK, 1);
// Also increase number of events and valid events.
// Only call this on (still) invalid events!
caerEventPacketHeaderSetEventNumber(
&packet->packetHeader, caerEventPacketHeaderGetEventNumber(&packet->packetHeader) + 1);
caerEventPacketHeaderSetEventValid(
&packet->packetHeader, caerEventPacketHeaderGetEventValid(&packet->packetHeader) + 1);
}
else {
caerLogEHO(CAER_LOG_CRITICAL, "IMU6 Event", "Called caerIMU6EventValidate() on already valid event.");
}
}
static inline void caerIMU6EventInvalidate(caerIMU6Event event, caerIMU6EventPacket packet) {
if (caerIMU6EventIsValid(event)) {
CLEAR_NUMBITS32(event->info, VALID_MARK_SHIFT, VALID_MARK_MASK);
// Also decrease number of valid events. Number of total events doesn't change.
// Only call this on valid events!
caerEventPacketHeaderSetEventValid(
&packet->packetHeader, caerEventPacketHeaderGetEventValid(&packet->packetHeader) - 1);
}
else {
caerLogEHO(CAER_LOG_CRITICAL, "IMU6 Event", "Called caerIMU6EventInvalidate() on already invalid event.");
}
}
static inline float caerIMU6EventGetAccelX(caerIMU6EventConst event) {
return (leflttoh(event->accel_x));
}
static inline void caerIMU6EventSetAccelX(caerIMU6Event event, float accelX) {
event->accel_x = htoleflt(accelX);
}
static inline float caerIMU6EventGetAccelY(caerIMU6EventConst event) {
return (leflttoh(event->accel_y));
}
static inline void caerIMU6EventSetAccelY(caerIMU6Event event, float accelY) {
event->accel_y = htoleflt(accelY);
}
static inline float caerIMU6EventGetAccelZ(caerIMU6EventConst event) {
return (leflttoh(event->accel_z));
}
static inline void caerIMU6EventSetAccelZ(caerIMU6Event event, float accelZ) {
event->accel_z = htoleflt(accelZ);
}
static inline float caerIMU6EventGetGyroX(caerIMU6EventConst event) {
return (leflttoh(event->gyro_x));
}
static inline void caerIMU6EventSetGyroX(caerIMU6Event event, float gyroX) {
event->gyro_x = htoleflt(gyroX);
}
static inline float caerIMU6EventGetGyroY(caerIMU6EventConst event) {
return (leflttoh(event->gyro_y));
}
static inline void caerIMU6EventSetGyroY(caerIMU6Event event, float gyroY) {
event->gyro_y = htoleflt(gyroY);
}
static inline float caerIMU6EventGetGyroZ(caerIMU6EventConst event) {
return (leflttoh(event->gyro_z));
}
static inline void caerIMU6EventSetGyroZ(caerIMU6Event event, float gyroZ) {
event->gyro_z = htoleflt(gyroZ);
}
static inline float caerIMU6EventGetTemp(caerIMU6EventConst event) {
return (leflttoh(event->temp));
}
static inline void caerIMU6EventSetTemp(caerIMU6Event event, float temp) {
event->temp = htoleflt(temp);
}
#define CAER_IMU6_ITERATOR_ALL_START(IMU6_PACKET) \
for (int32_t caerIMU6IteratorCounter = 0; \
caerIMU6IteratorCounter < caerEventPacketHeaderGetEventNumber(&(IMU6_PACKET)->packetHeader); \
caerIMU6IteratorCounter++) { \
caerIMU6Event caerIMU6IteratorElement = caerIMU6EventPacketGetEvent(IMU6_PACKET, caerIMU6IteratorCounter);
#define CAER_IMU6_CONST_ITERATOR_ALL_START(IMU6_PACKET) \
for (int32_t caerIMU6IteratorCounter = 0; \
caerIMU6IteratorCounter < caerEventPacketHeaderGetEventNumber(&(IMU6_PACKET)->packetHeader); \
caerIMU6IteratorCounter++) { \
caerIMU6EventConst caerIMU6IteratorElement \
= caerIMU6EventPacketGetEventConst(IMU6_PACKET, caerIMU6IteratorCounter);
#define CAER_IMU6_ITERATOR_ALL_END }
#define CAER_IMU6_ITERATOR_VALID_START(IMU6_PACKET) \
for (int32_t caerIMU6IteratorCounter = 0; \
caerIMU6IteratorCounter < caerEventPacketHeaderGetEventNumber(&(IMU6_PACKET)->packetHeader); \
caerIMU6IteratorCounter++) { \
caerIMU6Event caerIMU6IteratorElement = caerIMU6EventPacketGetEvent(IMU6_PACKET, caerIMU6IteratorCounter); \
if (!caerIMU6EventIsValid(caerIMU6IteratorElement)) { \
continue; \
} // Skip invalid IMU6 events.
#define CAER_IMU6_CONST_ITERATOR_VALID_START(IMU6_PACKET) \
for (int32_t caerIMU6IteratorCounter = 0; \
caerIMU6IteratorCounter < caerEventPacketHeaderGetEventNumber(&(IMU6_PACKET)->packetHeader); \
caerIMU6IteratorCounter++) { \
caerIMU6EventConst caerIMU6IteratorElement \
= caerIMU6EventPacketGetEventConst(IMU6_PACKET, caerIMU6IteratorCounter); \
if (!caerIMU6EventIsValid(caerIMU6IteratorElement)) { \
continue; \
} // Skip invalid IMU6 events.
#define CAER_IMU6_ITERATOR_VALID_END }
#define CAER_IMU6_REVERSE_ITERATOR_ALL_START(IMU6_PACKET) \
for (int32_t caerIMU6IteratorCounter = caerEventPacketHeaderGetEventNumber(&(IMU6_PACKET)->packetHeader) - 1; \
caerIMU6IteratorCounter >= 0; caerIMU6IteratorCounter--) { \
caerIMU6Event caerIMU6IteratorElement = caerIMU6EventPacketGetEvent(IMU6_PACKET, caerIMU6IteratorCounter);
#define CAER_IMU6_CONST_REVERSE_ITERATOR_ALL_START(IMU6_PACKET) \
for (int32_t caerIMU6IteratorCounter = caerEventPacketHeaderGetEventNumber(&(IMU6_PACKET)->packetHeader) - 1; \
caerIMU6IteratorCounter >= 0; caerIMU6IteratorCounter--) { \
caerIMU6EventConst caerIMU6IteratorElement \
= caerIMU6EventPacketGetEventConst(IMU6_PACKET, caerIMU6IteratorCounter);
#define CAER_IMU6_REVERSE_ITERATOR_ALL_END }
#define CAER_IMU6_REVERSE_ITERATOR_VALID_START(IMU6_PACKET) \
for (int32_t caerIMU6IteratorCounter = caerEventPacketHeaderGetEventNumber(&(IMU6_PACKET)->packetHeader) - 1; \
caerIMU6IteratorCounter >= 0; caerIMU6IteratorCounter--) { \
caerIMU6Event caerIMU6IteratorElement = caerIMU6EventPacketGetEvent(IMU6_PACKET, caerIMU6IteratorCounter); \
if (!caerIMU6EventIsValid(caerIMU6IteratorElement)) { \
continue; \
} // Skip invalid IMU6 events.
#define CAER_IMU6_CONST_REVERSE_ITERATOR_VALID_START(IMU6_PACKET) \
for (int32_t caerIMU6IteratorCounter = caerEventPacketHeaderGetEventNumber(&(IMU6_PACKET)->packetHeader) - 1; \
caerIMU6IteratorCounter >= 0; caerIMU6IteratorCounter--) { \
caerIMU6EventConst caerIMU6IteratorElement \
= caerIMU6EventPacketGetEventConst(IMU6_PACKET, caerIMU6IteratorCounter); \
if (!caerIMU6EventIsValid(caerIMU6IteratorElement)) { \
continue; \
} // Skip invalid IMU6 events.
#define CAER_IMU6_REVERSE_ITERATOR_VALID_END }
#ifdef __cplusplus
}
#endif
#endif /* LIBCAER_EVENTS_IMU6_H_ */