---

jaus_message.h

Go to the documentation of this file.

/*
DASI Library Copyright (C) 2004-2007  Derek Jones
This software is free for educational use only--no commercial use allowed.

This library is  distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY;  without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A  PARTICULAR PURPOSE.  
*/
#ifndef JAUS_MESSAGE_H
#define JAUS_MESSAGE_H
#include <types.h>
#include <fixedpoint.h>
#include <utility/status.h>

// Specify Instance 0 if you don't care which component it uses.
#define DONT_CARE 0
#define BAD_INSTANCE 0
#define BAD_SUBTYPE 0

#define DEFAULT_SUBTYPE 0
#define IR_SUBTYPE 1
#define SONAR_SUBTYPE 2


//#define JAUS_MESSAGE_LENGTH 104
// add adler-32 (hexcoded) checksum.
// declare jaus_message buffer's the below length.
//#define JAUS_DECLARATION_LENGTH 164
#define JAUS_DECLARATION_LENGTH 176
//#define JAUS_DECLARATION_LENGTH 82
// This is the maximum length of the data portion of a jaus_message (thus data_size == Max_JAUS_Output_MS+JAUS_HEADER_LENGTH)
// NOTE: should be divisable by 4 so that the map can easily be transferred.
#define Maximum_JAUS_Output_Message_Size 48
// Maximum for downloading the map.
#define Maximum_JAUS_MAP_Output_Message_Size 32
// This is maximum UU encoded length of a jaus message with adler-32 string, time stamp etc.
#define MAX_JAUS_MESSAGE_LENGTH JAUS_DECLARATION_LENGTH
#define JAUS_PRIORITY(jaus_pointer) (jaus_pointer->_message.header.properties.bits.priority)
#define JAUS_SOURCE_INSTANCE(jaus_pointer) (jaus_pointer->_message.header.source.bits.instance)
#define JAUS_DEST_INSTANCE(jaus_pointer) (jaus_pointer->_message.header.destination.bits.instance)
#define JAUS_SOURCE_COMPONENT(jaus_pointer) (jaus_pointer->_message.header.source.bits.component)
#define JAUS_DEST_COMPONENT(jaus_pointer) (jaus_pointer->_message.header.destination.bits.component)
#define JAUS_SOURCE_NODE(jaus_pointer) (jaus_pointer->_message.header.source.bits.node)
#define JAUS_DEST_NODE(jaus_pointer) (jaus_pointer->_message.header.destination.bits.node)
#define JAUS_SUSSYSTEM(jaus_pointer) (jaus_pointer->_message.header.source.bits.subsystem)
#define JAUS_COMMAND_CODE(jaus_pointer) (JAUS_MESSAGE(jaus_pointer->_message.header.command_code))
#define JAUS_COPY(pjausD,pjausS) for (short imxxx=0; imxxx<(Maximum_JAUS_Output_Message_Size+JAUS_HEADER_LENGTH); imxxx++) ((char*)pjausD)[imxxx] = ((char*)pjausS)[imxxx]

#define DEFAULT_JAUS_MESSAGE_LENGTH 112
#define JAUS_HEADER_LENGTH 16
#define JAUS_UU_HEADER_LENGTH 32

enum Destination_Node_Class { NO_DESTINATION_NODE_CLASS, INTRANODE_MESSAGE, INTERNODE_MESSAGE };

//#define MAX_JAUS_MESSAGE_LENGTH 1058

/* Ref. JAUS Reference Architecture
Command 0000h - 1FFFh
Query   2000h - 3FFFh
Inform  4000h - 5FFFh
Event Setup     6000h - 7FFFh
Event Notification      8000h - 9FFFh
Node Management A000h - BFFFh
Reserved        C000h - CFFFh
User Defined Message    D000h - FFFFh
  Ideally, there will be some sort of system registry like the SGML public DTD registration process,
  but with only 255 system IDs allowed; I don't think  the current implementation will be extensible.

  WARNING: it is the responsibility of each component to reverse the endian order [ntoh(...)].  This is because
  apart from the header, each message is divided differently thus no one solution will work.  Another solution
  if it proves worthy is to have a switch for used message and reverse all needed fields.  I choose the former
  because many times, a component will not need each every field, but if too much redudant switching occurs, then...

  NOTE: Deviations from JAUS
  1) The presence vector is not used--all fields are sent.  In fact, the transmission is composed of the largest
     JAUS message defined since it is built from a union.  
  2) [struct peculiarity] If the presence vector is not aligned on a word/long word  boundary
     then a pad uint8/word is inserted.
     This is a side effect of the way I serialize the struct message for transmission into a character uint8 stream.
     The serialize version does not have the pad uint8s and thus, when rearranged on the other end, the struct
     format is messed up.
       Some processors/compilers can address only to 32 bit boundary.  
     Thus, the short presence vector followed by an int
     internally inserts a pad short to align to 32 bit boundary.  This is true of internal fields also and
     not just the presence vector.  if a short is follwed by and int, then it will be padded unless there are
     an even number of shorts preceding the int.  So far all have aligned on a 32 bit boundary except for the
     need for padding after the presence vector.
  NOTE: an interface can be built to post process this format into a true JAUS format unless I think of another
        way of handling this.
*/
enum MESSAGE_CLASS { COMMAND_CLASS, QUERY_CLASS, INFORM_CLASS, EVENT_SETUP_CLASS, EVENT_NOTIFICATON_CLASS,
                     NODE_MANAGEMENT_CLASS, EXPERIMENTAL_CLASS };
enum JAUS_DATA_FLAG {
  ONLY_DATA_PACKET = 0,
  FIRST_DATA_PACKET=1,
  NORMAL_DATA_PACKET=2,
  RETRANSMITTED_DATA_PACKET=4,
  LAST_DATA_PACKET=8};
  
enum JAUS_MESSAGE { 
  Error_Message=0x00,
  Set_Component_Authority_Message=0x01,
  Shutdown_Message=0x02,
  Standby_Message=0x03,
  Resume_Message=0x04,
  Reset_Message=0x05,
  Set_Emergency_Message=0x06,
  Clear_Emergency_Message=0x07,
  Create_Service_Connection_Message=0x08,
  Confirm_Service_Connection_Message=0x09,
  Activate_Service_Connection_Message=0x0A,
  Suspend_Service_Connection_Message=0x0B,
  Terminate_Service_Connection_Message=0x0C,
  Set_Local_Pose_Message=0x403, // this is oversight; not in JAUS RA.
  Set_Wrench_Effort_Message=0x405,
  Set_Discrete_Devices=0x406,
  Set_Local_Vector_Message=0x408,
  Set_Travel_Speed_Message=0x040A,
  Set_Local_Waypoint_Message=0x040D,
  Set_Camera_Capabilities_Message=0x805,
  Set_Camera_Format_Options_Message=0x806,
  Set_Camera_Settings_Message=0x808, // non JAUS but the way it should be
  Query_Component_Status_Message=0x2002,
  Query_Local_Pose_Message=0x2003,
  Query_Time_Message=0x2011,
  Query_Heartbeat_Pulse_Message=0x2202,
  Query_Platform_Specifications_Message=0x2400,
  Query_Platform_Operational_Data_Message=0x2401,
  Query_Velocity_State_Message=0x2404,
  Query_Local_Vector_Message=0x2408,
  Query_Travel_Speed_Message=0x240A,
  Query_Waypoint_Count_Message=0x0240B,
  Query_Local_Waypoint_Message=0x0240D,
  Query_Camera_Count_Message=0x2801,
  Query_Relative_Object_Position_Message=0x2802,
  Query_Selected_Camera_Message=0x2804,
  Query_Camera_Capabilities_Message=0x2805,
  Query_Camera_Format_Options_Message=0x2806,
  Query_Image_Message=0x2807,
  Query_Camera_Settings_Message=0x2808, // non JAUS but the way it should be
  Report_Component_Authority=0x4001,
  Report_Component_Status_Message=0x4002,
  Report_Local_Pose_Message=0x4003,
  Report_Time_Message=0x4011,
  Report_Heartbeat_Pulse_Message=0x4202,
  Report_Platform_Specifications_Message=0x4400,
  Report_Platform_Operational_Data_Message=0x4401,
  Report_Velocity_State_Message=0x4404,
  Report_Local_Vector_Message=0x4408,
  Report_Travel_Speed_Message=0x440A, // Reports the last commanded (desired) travel speed given
  Report_Waypoint_Count_Message=0x440B,
  Report_Local_Waypoint_Message=0x440D,
  Report_Camera_Pose_Message=0x4800,
  Report_Camera_Count_Message=0x4801,
  Report_Relative_Object_Position_Message=0x4802,
  Report_Selected_Camera_Message=0x4804,
  Report_Camera_Capabilities_Message=0x4805,
  Report_Camera_Format_Options_Message=0x4806,
  Report_Image_Message=0x4807,
  Report_Camera_Settings_Message=0x4808, // non JAUS but way it should be.
  // User Group
  Query_Identity_Message  =0xD001,     // Similar to ping, receiver must reply with Identity_Message to source ID
  Report_Identity_Message =0xD002,     // Message simply identifying system#, subsystem#, node#, of an active node.
  Query_Component_Message =0xD003,     // request a list of all defined components on node.
  Set_Platform_Specifications_Message=0xD004, // JAUS did not imagine dynamically configuring your vehicle!
  // very first node reported in component list is node_manager, thus it simply serves as a start sequence of list.
  // Only component required are Node_Manager
  Report_Component_Message=0xD005,      // A message identifying a single component on a node. will usually have a sequence number/end data indicator.
  Query_IS_Message=0xD006,
  Report_IS_Message=0xD007,
  Set_IS_Message=0xD008,
//  Report_Motion_Message=0xD009,         // a message identifying a single motion in the motion list
//  Query_Motion_Message          =0xD00A,     // request a tranformation from a waypoint to a motion list.
  Query_Error_Message=0xD00B,
  Report_Error_Message=0xD00C,
  Query_Map_Message=0xD00D,           // Marks beginning of a grid transfer.  Only other characters allowed are to be part of grid transfer.
  Report_Map_Message=0xD00E,
  Query_Binary_Status_Message=0xD00F,
  Set_Binary_Status_Message=0xD010,
//  XMIT_Grid_Message=0xD00D,           // Marks beginning of a grid transfer.  Only other characters allowed are to be part of grid transfer.
//  RECV_Grid_Message=0xD00E,
  Last_Message=0xD00F
};


struct Data_Size_T
{
  JAUS_MESSAGE command;
  short size;
};


/* Structures with no data can just read the header command code.
struct component_list_t
{
};

*/
struct authority_code_t
{
  uint8 code;
};
struct respond_component_t
{
  uint8 subclass;
};
struct set_emergency_t
{
  unsigned short code;
};
struct clear_emergency_t
{
  unsigned short code;
};

// A maximum 255 value status (for exampel an LED is a 2 value indicator)
struct status_indicator_t
{
  uint16 value;    // value to set/report.
};


struct camera_settings_t
{
  unsigned short horizontal; // resolution.
  unsigned short vertical;
  unsigned short shutter;   // using direct exposure from GB camera for now.
  unsigned short image_control; // reserved for line modes.
};


struct camera_format_t
{
  unsigned char audio_format;
  unsigned char image_format;
  unsigned short _pad;
  unsigned int format_option;
};

struct travel_speed_t
{
  unsigned short speed; // 2
};
struct IS_t
{
  int  sid;    // 4
  int  pid;    // 8
  int   value; // 12
  short x;     // 14
  short y;     // 16
};
// Structure used to report system log messages (Query_Error_Message/Report_Error_Message)
typedef OOMRM_Message system_message_t; // 8 bytes

struct system_error_t
{
  int  error; // 4
  int  level; // 8
};
// -----------------------
// Set_Local_Vector2 0408h 
// Localized version (with distance to travel).
// Turns to angle  and travels "distance" millimeters at "speed" millimeters/second.
// I think lack of distance is oversight.  Prescense vector for distance would take up 3 less bytes.
// -----------------------
struct local_vector_t
{
  int speed; // 4  millimeters per second
  int radians; // 8 fixed point radians.
  int distance; // 12 Local addition (distance to travel at that speed.)
};
// -----------------------

// -----------------------
struct component_status_t
{
  unsigned int secondary_status_code; // 4
  uint8  primary_status_code; // 5 (8)
};
// -----------------------
// DISCRETE_DEVICE
// -----------------------
struct discrete_device_t
{
#if defined(BIG_ENDIAN) && !defined(LITTLE_ENDIAN)
  union  {
    struct  {
    uint8  df2 : 1;
    uint8  df3 : 1;
    uint8  df4 : 1;
    uint8  df5 : 1;
    uint8  R   : 4;
    } pv;
#elif defined(LITTLE_ENDIAN) && !defined(BIG_ENDIAN)
  union  {
    struct  {
    uint8  R   : 4;
    uint8  df5 : 1;
    uint8  df4 : 1;
    uint8  df3 : 1;
    uint8  df2 : 1;
    } pv;
#else
  #error "Either BIG_ENDIAN or LITTLE_ENDIAN must be #defined, but not both."
#endif
    uint8 presence_vector; // this needs htons applied.
  };
  uint8          main_propulsion; 
  uint8          brake_horn;
  uint8          gear;
  uint8          transfer_case;
};
// -----------------------
// Platform Specification
// -----------------------
struct platform_specification_t
{
#if defined(BIG_ENDIAN) && !defined(LITTLE_ENDIAN)
  union  {
    struct  {
    unsigned int  df2 : 1;
    unsigned int  df3 : 1;
    unsigned int  df4 : 1;
    unsigned int  df5 : 1;
    unsigned int  df6 : 1;
    unsigned int  df7 : 1;
    unsigned int  df8 : 1;
    unsigned int  df9 : 1;
    unsigned int  df10 : 1;
    unsigned int  df11 : 1;
    unsigned int  df12 : 1;
    unsigned int  df13 : 1;
    unsigned int  df14 : 1;
    unsigned int  df15 : 1;
    unsigned int  df16 : 1;
    unsigned int  df17 : 1;
    unsigned int  df18 : 1;
    unsigned int  df19 : 1;
    unsigned int  df20 : 1;
    unsigned int  df21 : 1;
    unsigned int  df22 : 1;
    unsigned int  R   : 11;
    } pv;
#elif defined(LITTLE_ENDIAN) && !defined(BIG_ENDIAN)
  union  {
    struct  {
    unsigned int  R    :11;
    unsigned int  df22 : 1;
    unsigned int  df21 : 1;
    unsigned int  df20 : 1;
    unsigned int  df19 : 1;
    unsigned int  df18 : 1;
    unsigned int  df17 : 1;
    unsigned int  df16 : 1;
    unsigned int  df15 : 1;
    unsigned int  df14 : 1;
    unsigned int  df13 : 1;
    unsigned int  df12 : 1;
    unsigned int  df11 : 1;
    unsigned int  df10 : 1;
    unsigned int  df9 : 1;
    unsigned int  df8 : 1;
    unsigned int  df7 : 1;
    unsigned int  df6 : 1;
    unsigned int  df5 : 1;
    unsigned int  df4 : 1;
    unsigned int  df3 : 1;
    unsigned int  df2 : 1;
    } pv;
#else
  #error "Either BIG_ENDIAN or LITTLE_ENDIAN must be #defined, but not both."
#endif
    unsigned int presence_vector; // this needs htons applied.
  };
  char           name[15]; //* 19
  uint8          obstacle;     // 20
  unsigned short wheelbase; // 22
  unsigned short Lwheel_diameter; // 24
  unsigned short Rwheel_diameter; // 26
  unsigned short Lmaximum_velocity; // 28
  unsigned short Rmaximum_velocity; // 30
  unsigned short Lstall;  // 32
  unsigned short Rstall;  // 34
  unsigned short resolution; // 36
  unsigned short robot_diameter; // 38

/* for the real JAUS definition
  unsigned short front;    // 19*2=38+19=57
  unsigned short back;
  unsigned short right;
  unsigned short left;
  unsigned short bottom;
  unsigned short top;
  unsigned short xcg;
  unsigned short ycg;
  unsigned short zcg;
  unsigned short turning_radius;
  unsigned short wheelbase;  // * overloaded.
  unsigned short trackwidth; // *
  unsigned short pitchover;
  unsigned short rollover;
  unsigned short mvx;           // *
  unsigned short mvy;
  unsigned short mvz;
  unsigned short mrr;
  unsigned short myr;
*/
};
// -----------------------
// RELATIVE Object Postion
// -----------------------
struct relative_object_position_t
{
#if defined(BIG_ENDIAN) && !defined(LITTLE_ENDIAN)
  union  {
    struct  {
    unsigned short  df3 : 1;
    unsigned short  df4 : 1;
    unsigned short  df5 : 1;
    unsigned short  df6 : 1;
    unsigned short  df7 : 1;
    unsigned short  df8 : 1;
    unsigned short  df9 : 1;
    unsigned short  df10 : 1;
    unsigned short  df11 : 1;
    unsigned short  df12 : 1;
    unsigned short  R   : 6;
    } pv;
#elif defined(LITTLE_ENDIAN) && !defined(BIG_ENDIAN)
  union  {
    struct  {
    unsigned short  R   : 6;
    unsigned short  df12 : 1;
    unsigned short  df11 : 1;
    unsigned short  df10 : 1;
    unsigned short  df9 : 1;
    unsigned short  df8 : 1;
    unsigned short  df7 : 1;
    unsigned short  df6 : 1;
    unsigned short  df5 : 1;
    unsigned short  df4 : 1;
    unsigned short  df3 : 1;
    } pv;
#else
  #error "Either BIG_ENDIAN or LITTLE_ENDIAN must be #defined, but not both."
#endif
    unsigned short presence_vector; // this needs htons applied.
  };
  short        pad; // 4
  unsigned int time_stamp; // 8
  unsigned int Range; // 12
  unsigned int Range_Error; // 16
  int          Bearing; // 20
  unsigned int Bearing_Error; // 24
  int          Elevation; // 28
  unsigned int Elevation_Error; // 32
  uint8         Confidence; // 33
};
// -----------------------
// Set Local Pose
// -----------------------
struct local_pose_t
{
#if defined(BIG_ENDIAN) && !defined(LITTLE_ENDIAN)
  union  {
    struct  {
    unsigned short  df2 : 1;
    unsigned short  df3 : 1;
    unsigned short  df4 : 1;
    unsigned short  df5 : 1;
    unsigned short  df6 : 1;
    unsigned short  df7 : 1;
    unsigned short  df8 : 1;
    unsigned short  df9 : 1;
    unsigned short  df10: 1;
    unsigned short  df11: 1;
    unsigned short  R   : 6;
    } pv;
#elif defined(LITTLE_ENDIAN) && !defined(BIG_ENDIAN)
  union  {
    struct  {
    unsigned short  R   : 6;
    unsigned short  df11: 1;
    unsigned short  df10: 1;
    unsigned short  df9 : 1;
    unsigned short  df8 : 1;
    unsigned short  df7 : 1;
    unsigned short  df6 : 1;
    unsigned short  df5 : 1;
    unsigned short  df4 : 1;
    unsigned short  df3 : 1;
    unsigned short  df2 : 1;
    } pv;
#else
  #error "Either BIG_ENDIAN or LITTLE_ENDIAN must be #defined, but not both."
#endif
    unsigned short presence_vector; // this needs htons applied.
  };
  short          pad;
  int            X;
  int            Y;
  int            Z;
  unsigned int   position_RMS;
  short          roll;
  short          pitch;
  short          yaw;
  unsigned short attitude_RMS;
  unsigned int   time_stamp;
  unsigned short data_validity;
};
// -----------------------
// VELOCITY STATE
// -----------------------
struct velocity_state_t
{
#if defined(BIG_ENDIAN) && !defined(LITTLE_ENDIAN)
  union  {
    struct  {
    unsigned short  df2 : 1;
    unsigned short  df3 : 1;
    unsigned short  df4 : 1;
    unsigned short  df5 : 1;
    unsigned short  df6 : 1;
    unsigned short  df7 : 1;
    unsigned short  df8 : 1;
    unsigned short  df9 : 1;
    unsigned short  df10: 1;
    unsigned short  df11: 1;
    unsigned short  R   : 6;
    } pv;
#elif defined(LITTLE_ENDIAN) && !defined(BIG_ENDIAN)
  union  {
    struct  {
    unsigned short  R   : 6;
    unsigned short  df11: 1;
    unsigned short  df10: 1;
    unsigned short  df9 : 1;
    unsigned short  df8 : 1;
    unsigned short  df7 : 1;
    unsigned short  df6 : 1;
    unsigned short  df5 : 1;
    unsigned short  df4 : 1;
    unsigned short  df3 : 1;
    unsigned short  df2 : 1;
    } pv;
#else
  #error "Either BIG_ENDIAN or LITTLE_ENDIAN must be #defined, but not both."
#endif
    unsigned short presence_vector; // this needs htons applied.
  };
  short          pad;
  int            X;
  int            Y;
  int            Z;
  unsigned int   velocity_RMS;
  short          roll;
  short          pitch;
  short          yaw;
  unsigned short rate_RMS;
  unsigned int   time_stamp;
  unsigned short data_validity;
};
// -----------------------
// LOCAL VECTOR (this is actually global vector)
// -----------------------
/*
struct local_vector_t
{
#if defined(BIG_ENDIAN) && !defined(LITTLE_ENDIAN)
  union  {
    struct  {
    uint8  df2 : 1;
    uint8  df3 : 1;
    uint8  df4 : 1;
    uint8  df5 : 1;
    uint8  df6 : 1;
    uint8  R   : 3;
    } pv;
#elif defined(LITTLE_ENDIAN) && !defined(BIG_ENDIAN)
  union  {
    struct  {
    uint8  R   : 3;
    uint8  df6 : 1;
    uint8  df5 : 1;
    uint8  df4 : 1;
    uint8  df3 : 1;
    uint8  df2 : 1;
    } pv;
#else
  #error "Either BIG_ENDIAN or LITTLE_ENDIAN must be #defined, but not both."
#endif
    uint8 presence_vector; // this needs htons applied.
  };
  uint8           pad;
  unsigned short speed; 
  int            altitude;
  short          heading;
  short          roll;
  short          pitch;
};
*/
// -----------------------
// Set Local Waypoint
// -----------------------
struct set_local_waypoint_t
{
#if defined(BIG_ENDIAN) && !defined(LITTLE_ENDIAN)
  union  {
    struct  {
    uint8  df5 : 1;
    uint8  df6 : 1;
    uint8  df7 : 1;
    uint8  df8 : 1;
    uint8  R   : 4;
    } pv;
#elif defined(LITTLE_ENDIAN) && !defined(BIG_ENDIAN)
  union  {
    struct  {
    uint8  R   : 4;
    uint8  df8 : 1;
    uint8  df7 : 1;
    uint8  df6 : 1;
    uint8  df5 : 1;
    } pv;
#else
  #error "Either BIG_ENDIAN or LITTLE_ENDIAN must be #defined, but not both."
#endif
    uint8 presence_vector; // this needs htons applied.
  };
  uint8           pad; // 2
  unsigned short number; // 4 these need htons applied.
  int            X; // 8
  int            Y; // 12
  int            Z; // 16
  short          roll; // 18
  short          pitch; // 20
  short          yaw; // 22
  short          function; // 24 non JAUS compliant activity code.
};
typedef set_local_waypoint_t report_local_waypoint_t;

// -----------------------
// Query Local Waypoint
// -----------------------
struct query_local_waypoint_t
{
  short         number;
};
typedef query_local_waypoint_t waypoint_count_t;
// -----------------------
// Set Wrench Effort
// -----------------------
struct set_wrench_effort_t
{
#if defined(BIG_ENDIAN) && !defined(LITTLE_ENDIAN)
  union  {
    struct  {
    unsigned short  df2 : 1;
    unsigned short  df3 : 1;
    unsigned short  df4 : 1;
    unsigned short  df5 : 1;
    unsigned short  df6 : 1;
    unsigned short  df7 : 1;
    unsigned short  df8 : 1;
    unsigned short  df9 : 1;
    unsigned short  df10: 1;
    unsigned short  df11: 1;
    unsigned short  df12: 1;
    unsigned short  df13: 1;
    unsigned short  R   : 4;
    } pv;
#elif defined(LITTLE_ENDIAN) && !defined(BIG_ENDIAN)
  union  {
    struct  {
    unsigned short  R   : 4;
    unsigned short  df13: 1;
    unsigned short  df12: 1;
    unsigned short  df11: 1;
    unsigned short  df10: 1;
    unsigned short  df9 : 1;
    unsigned short  df8 : 1;
    unsigned short  df7 : 1;
    unsigned short  df6 : 1;
    unsigned short  df5 : 1;
    unsigned short  df4 : 1;
    unsigned short  df3 : 1;
    unsigned short  df2 : 1;
    } pv;
#else
  #error "Either BIG_ENDIAN or LITTLE_ENDIAN must be #defined, but not both."
#endif
    unsigned short presence_vector; // this needs htons applied.
  };
 // unfortunately backwards, I need to calculate the speed from the throttle setting.
  short            PLE_x; // 2
  short            PLE_y; // 4
  short            PLE_z; // 6
  short            PRE_x; // 8
  short            PRE_y; // 10
  short            PRE_z; // 12 (rotation turn)
  // probably should define brake(100) as brake() rather than speed(0) which has slightly different semantic.
  uint8             RLE_x;  // 13(brake) uint8s do not need to have network transforms applied (htons, etc.).
  uint8             RLE_y; // 14
  uint8             RLE_z; // 15
  uint8             RRE_x; // 16
  uint8             RRE_y; // 17
  uint8             RRE_z; // 18
};


#define NO_ACKNOWLEDGE 0

#define ACKNOWLEDGE 1

#define ACKNOWLEDGE_NEGATIVE 2

#define ACKNOWLEDGE_OK 3


// PC, etc. (need portable solution) This needs htons applied--I don't think it matters whether you delcare as uint8 or word (in GCC).
#if !defined(BIG_ENDIAN) && defined(LITTLE_ENDIAN)
typedef union
{
struct  {
  volatile word R        : 2;
  volatile word version  : 6;
  volatile word ef       : 1; // ack, spf, ef
  volatile word scf      : 1;

  volatile word acknak   : 2;

  volatile word priority : 4;
} bits;
word FULLWORD;
} properties_t;
#elif defined(BIG_ENDIAN) && !defined(LITTLE_ENDIAN)
// SUN, 68K, etc. 
typedef union
{
struct  {
  volatile word priority : 4;
  volatile word acknak   : 2; // ef, spf, ack
  volatile word scf      : 1;
  volatile word ef       : 1;
  volatile word version  : 6;
  volatile word R        : 2;
} bits;
word FULLWORD;
} properties_t;
#else
  #error "Either BIG_ENDIAN or LITTLE_ENDIAN must be #defined, but not both."
#endif


typedef union
{
struct {
  uint8 instance;
  uint8 component;
  uint8 node;
  uint8 subsystem;
} bits;
long_word FULLWORD;
} ID_T;



typedef union
{
struct {
#if defined(BIG_ENDIAN) && !defined(LITTLE_ENDIAN)
  unsigned short data_size : 12;
  unsigned short data_flag : 4;
#elif defined(LITTLE_ENDIAN) && !defined(BIG_ENDIAN)
  unsigned short data_flag : 4;
  unsigned short data_size : 12;
#else
  #error "Either BIG_ENDIAN or LITTLE_ENDIAN must be #defined, but not both."
#endif
} bits;
word FULLWORD;
} data_control_T2;

struct header_t {
  properties_t            properties; // 2
  unsigned short          command_code; // 2
  ID_T                    destination; // 4
  ID_T                    source; // 4
  data_control_T2         data_control; // 2
  unsigned short          sequence_number; // 2
};

struct service_connection_t
{
  unsigned short command; // 2 command code for service connection
  unsigned short rate; // 4 rate of service connection
//  unsigned int   pv;     // 8 presence vector.
  ID_T           destination; // 14 service proxy node (same subsystem
  uint8          id;  // 9
  uint8          response_code; // 10

};

void hton(header_t* const);
void ntoh(header_t* const);

// represents a JAUS expanded format message consisting of a JAUS compliant header followed by one of the 
// JAUS compliant expanded messages.  An expanded message is one that transmits all field within the prescence vector.
// By requiring all fields, parsing can be done simply by converting the incoming uint8 stream into the appropriate structure
// represented by the data.  the obvious disadvantage is the trasmission of unused uint8s.



struct message {
  header_t             header; // 16
  union {
    IS_t                IS;
    system_message_t   system_message; // 8
    service_connection_t service_connection;
    authority_code_t    authority_code;
    set_emergency_t     set_emergency; 
    set_wrench_effort_t set_wrench_effort; // 20
    set_local_waypoint_t set_local_waypoint; // 24
    discrete_device_t   discrete_device; // 5
    local_pose_t        local_pose; // 32
    velocity_state_t    velocity_state;
    clear_emergency_t   clear_emergency;
    query_local_waypoint_t query_local_waypoint; // 2
    travel_speed_t  travel_speed; // 4
    status_indicator_t  indicators; // 4
    respond_component_t respond_component; // 1
    report_local_waypoint_t report_local_waypoint; // 24
    local_vector_t      local_vector; // 21
    relative_object_position_t relative_object_position; // 31
    platform_specification_t platform_specification; // 38
    component_status_t  component_status; // 3
    waypoint_count_t    waypoint_count;
    system_error_t      system_error;
    camera_settings_t camera_settings;
    camera_format_t   camera_format; // 8
  };
};

extern void jaus_message_send_sci_callback(char c);

//#define COMPONENT_MAX 10
#define NO_SERVICE_CONNECTION 0
#define SERVICE_CONNECTION 1


class jaus_message 
{
public:
  static MESSAGE_CLASS message_class(JAUS_MESSAGE jm);
  // factory used to both create and terminate SC
  void service_connection(unsigned short cc, unsigned short irate);
  void service_connection_confirm(unsigned short cc, unsigned short irate, uint8 rc, uint8 id);
  void service_connection_activate(unsigned short cc, uint8 id);
  void local_vector(int speed, FIXED_POINT radians, uint32 distance);
  void IS(int isid, int ipid, int ivalue, short x=0, short y=0);
  void system_error(int e, int l);
  void local_map_spec(unsigned short);
  void wrench_effort(short, short, short);
  void local_waypoint(short num,int x, int y, short iyaw, short ifn); // added non JAUS compliant activity code.
  void local_waypoint(short num);
  void local_pose(int X, int Y, short yaw); // maybe add others later.
  void system_message(OOMRM_Message m);
  void camera_settings(unsigned short, unsigned short, unsigned short, unsigned short);
  void jaus_message::camera_format(uint32 ioptions);
  void travel_speed(unsigned short ispeed);
  void status_indicator(uint16 value);
  void discrete_device(uint8 horn);
  void component_status(uint8 primary, unsigned int secondary);
  void relative_object_position(unsigned int itime, unsigned int irange, int ibearing);
  void platform_specification(const char* const iname,uint8 obstacle, word wb, word lwd, word rwd, word lmv, word rmv, word lstall, word rstall, word resolution, word rd);
  void respond_component(uint8 subclass);
  // NOTE: last parameter is for OSCPUUsage from uCOS if used.
  void header(uint8 ipriority, word cc, uint8 ack, JAUS_DATA_FLAG flag, // const ID_T& isrc, const ID_T& idest)
                 uint8 Sss, uint8  Snode, uint8 Scomp, uint8 Sinst,
         uint8 Dss, uint8  Dnode, uint8 Dcomp, uint8 Dinst, int8 cpu=0);
  // internal version that does not put in network order.
  void iheader(uint8 ipriority, word cc, uint8 ack, JAUS_DATA_FLAG flag, // const ID_T& isrc, const ID_T& idest)
                 uint8 Sss, uint8  Snode, uint8 Scomp, uint8 Sinst,
         uint8 Dss, uint8  Dnode, uint8 Dcomp, uint8 Dinst, int8 cpu=0);
  void receive(void);
  message* msg(void);
  void send(void);
  void inter_send(void);
  #ifdef DOS
  static const char* log_message(jaus_message &lmsg);
  #endif
  static void send_simple_message(uint8 ipriority, word cc, uint8 ack, JAUS_DATA_FLAG flag, // const ID_T& isrc, const ID_T& idest)
             uint8 Sss, uint8  Snode, uint8 Scomp, uint8 Sinst,
         uint8 Dss, uint8  Dnode, uint8 Dcomp, uint8 Dinst);
  message _message;
};
// Utilities
const char* format_message(char idir, char hexbuf[]);

typedef void (*fooxmit)(jaus_message&, uint8); // uart callback

#endif

---