bsDynaMsgs.h

Go to the documentation of this file.

///////////////////////////////////////////////////////////////////////////////
//
// File: bsDynaMsgs.h
//
/*!
 * \file
 *
 * \brief \h_botsense Server/Client Dynamixel NetMsgs XML Definitions.
 *
 * \warning This file was auto-generated on 2018.08.10 13:55:04 from the NetMsgs
 * XML specification bsDynaMsgs.xml.
 *
 * \par Copyright:
 * (C) 2018. RoadNarrows LLC
 * (http://www.roadnarrows.com)
 * All Rights Reserved
 */
///////////////////////////////////////////////////////////////////////////////


#ifndef _BSDYNAMSGS_H
#define _BSDYNAMSGS_H

#include "rnr/rnrconfig.h"
#include "rnr/netmsgs.h"

#include "botsense/BotSense.h"
#include "Dynamixel/Dynamixel.h"


C_DECLS_BEGIN

/*!
 * BsDyna Message Id Enumeration
 */
typedef enum
{
  BsDynaMsgIdNone                       = 0,    ///< no message
  BsDynaMsgIdReqOpenArgs                = 1,    ///< ReqOpenArgs
  BsDynaMsgIdReqSetBaudRate             = 2,    ///< ReqSetBaudRate
  BsDynaMsgIdReqRead8                   = 3,    ///< ReqRead8
  BsDynaMsgIdRspRead8                   = 4,    ///< RspRead8
  BsDynaMsgIdReqRead16                  = 5,    ///< ReqRead16
  BsDynaMsgIdRspRead16                  = 6,    ///< RspRead16
  BsDynaMsgIdReqWrite8                  = 7,    ///< ReqWrite8
  BsDynaMsgIdRspWrite8                  = 8,    ///< RspWrite8
  BsDynaMsgIdReqWrite16                 = 9,    ///< ReqWrite16
  BsDynaMsgIdRspWrite16                 = 10,   ///< RspWrite16
  BsDynaMsgIdReqSyncWrite               = 11,   ///< ReqSyncWrite
  BsDynaMsgIdReqPing                    = 12,   ///< ReqPing
  BsDynaMsgIdRspPing                    = 13,   ///< RspPing
  BsDynaMsgIdReqReset                   = 14,   ///< ReqReset
  BsDynaMsgIdReqSetHalfDuplexCtl        = 15,   ///< ReqSetHalfDuplexCtl
  BsDynaMsgIdNumOf                      = 16    ///< number of message ids
} BsDynaMsgId_T;


//-----------------------------------------------------------------------------
// Extended Field Types
//-----------------------------------------------------------------------------


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Field Type BsDynaWriteTuple Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * WriteTuple Field Type
 */
typedef struct
{
  byte_t                  m_servo_id;         ///< servo_id
  ushort_t                m_val;              ///< val
} BsDynaWriteTuple_T;                         ///< WriteTuple structure


//-----------------------------------------------------------------------------
// Message Types
//-----------------------------------------------------------------------------


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsDynaReqOpenArgs Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqOpenArgs Structure
 */
typedef struct
{
  uint_t                  m_baudrate;         ///< baudrate
} BsDynaReqOpenArgs_T;                        ///< ReqOpenArgs structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsDynaReqSetBaudRate Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqSetBaudRate Structure
 */
typedef struct
{
  uint_t                  m_baudrate;         ///< baudrate
} BsDynaReqSetBaudRate_T;                     ///< ReqSetBaudRate structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsDynaReqRead8 Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqRead8 Structure
 */
typedef struct
{
  byte_t                  m_servo_id;         ///< servo_id
  byte_t                  m_addr;             ///< addr
} BsDynaReqRead8_T;                           ///< ReqRead8 structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsDynaRspRead8 Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message RspRead8 Structure
 */
typedef struct
{
  byte_t                  m_alarms;           ///< alarms
  byte_t                  m_val;              ///< val
} BsDynaRspRead8_T;                           ///< RspRead8 structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsDynaReqRead16 Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqRead16 Structure
 */
typedef struct
{
  byte_t                  m_servo_id;         ///< servo_id
  byte_t                  m_addr;             ///< addr
} BsDynaReqRead16_T;                          ///< ReqRead16 structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsDynaRspRead16 Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message RspRead16 Structure
 */
typedef struct
{
  byte_t                  m_alarms;           ///< alarms
  ushort_t                m_val;              ///< val
} BsDynaRspRead16_T;                          ///< RspRead16 structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsDynaReqWrite8 Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqWrite8 Structure
 */
typedef struct
{
  byte_t                  m_servo_id;         ///< servo_id
  byte_t                  m_addr;             ///< addr
  byte_t                  m_val;              ///< val
} BsDynaReqWrite8_T;                          ///< ReqWrite8 structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsDynaRspWrite8 Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message RspWrite8 Structure
 */
typedef struct
{
  byte_t                  m_alarms;           ///< alarms
} BsDynaRspWrite8_T;                          ///< RspWrite8 structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsDynaReqWrite16 Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqWrite16 Structure
 */
typedef struct
{
  byte_t                  m_servo_id;         ///< servo_id
  byte_t                  m_addr;             ///< addr
  ushort_t                m_val;              ///< val
} BsDynaReqWrite16_T;                         ///< ReqWrite16 structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsDynaRspWrite16 Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message RspWrite16 Structure
 */
typedef struct
{
  byte_t                  m_alarms;           ///< alarms
} BsDynaRspWrite16_T;                         ///< RspWrite16 structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsDynaReqSyncWrite Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqSyncWrite Structure
 */
typedef struct
{
  byte_t                  m_addr;             ///< addr
  byte_t                  m_data_size;        ///< data_size
  struct
  {
    size_t                m_count;            ///< vector item count
    union
    {
      void                *m_pAlign;          ///< force alignment
      BsDynaWriteTuple_T  m_buf[DYNA_ID_NUMOF];
                                              ///< the item vector
    } u; ///< aligned vector items
  } m_tuples;                                 ///< vector
} BsDynaReqSyncWrite_T;                       ///< ReqSyncWrite structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsDynaReqPing Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqPing Structure
 */
typedef struct
{
  byte_t                  m_servo_id;         ///< servo_id
} BsDynaReqPing_T;                            ///< ReqPing structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsDynaRspPing Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message RspPing Structure
 */
typedef struct
{
  bool_t                  m_pong;             ///< pong
} BsDynaRspPing_T;                            ///< RspPing structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsDynaReqReset Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqReset Structure
 */
typedef struct
{
  byte_t                  m_servo_id;         ///< servo_id
} BsDynaReqReset_T;                           ///< ReqReset structure


// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
// Message BsDynaReqSetHalfDuplexCtl Declarations
// . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

/*!
 * Message ReqSetHalfDuplexCtl Structure
 */
typedef struct
{
  uint_t                  m_signal;           ///< signal
} BsDynaReqSetHalfDuplexCtl_T;                ///< ReqSetHalfDuplexCtl structure


//-----------------------------------------------------------------------------
// External Data
//-----------------------------------------------------------------------------

//
// BsDyna Message Definition Look-Up Table.
// (indexed by BsDynaMsgId_T enum)
// 
extern const NMMsgDef_T *BsDynaMsgDefLookupTbl[];

//
// BsDyna Maximum Message Body Length (bytes) Look-Up Table.
// (indexed by BsDynaMsgId_T enum)
// 
extern size_t BsDynaMsgMaxLenLookupTbl[];


//-----------------------------------------------------------------------------
// Function Prototypes
//-----------------------------------------------------------------------------

extern const NMMsgDef_T * BsDynaLookupMsgDef( BsDynaMsgId_T eMsgId );

extern size_t BsDynaLookupMsgMaxLen( BsDynaMsgId_T eMsgId );

extern int BsDynaPackMsg( BsDynaMsgId_T eMsgId,
                          void * pStruct,
                          byte_t buf[],
                          size_t bufSize,
                          bool_t bTrace );

extern int BsDynaUnpackMsg( BsDynaMsgId_T eMsgId,
                            byte_t buf[],
                            size_t uMsgLen,
                            void * pStruct,
                            bool_t bTrace );

/*!
 * \brief Pack a BsDynaReqOpenArgs ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaPackReqOpenArgs( BsDynaReqOpenArgs_T * pStruct,
                                       byte_t buf[],
                                       size_t bufSize,
                                       bool_t bTrace )
{
  return BsDynaPackMsg(BsDynaMsgIdReqOpenArgs, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsDynaReqOpenArgs ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaUnpackReqOpenArgs( byte_t buf[],
                                         size_t uMsgLen,
                                         BsDynaReqOpenArgs_T * pStruct,
                                         bool_t bTrace )
{
  return BsDynaUnpackMsg(BsDynaMsgIdReqOpenArgs, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsDynaReqSetBaudRate ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaPackReqSetBaudRate( BsDynaReqSetBaudRate_T * pStruct,
                                          byte_t buf[],
                                          size_t bufSize,
                                          bool_t bTrace )
{
  return BsDynaPackMsg(BsDynaMsgIdReqSetBaudRate, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsDynaReqSetBaudRate ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaUnpackReqSetBaudRate( byte_t buf[],
                                            size_t uMsgLen,
                                            BsDynaReqSetBaudRate_T * pStruct,
                                            bool_t bTrace )
{
  return BsDynaUnpackMsg(BsDynaMsgIdReqSetBaudRate, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsDynaReqRead8 ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaPackReqRead8( BsDynaReqRead8_T * pStruct,
                                    byte_t buf[],
                                    size_t bufSize,
                                    bool_t bTrace )
{
  return BsDynaPackMsg(BsDynaMsgIdReqRead8, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsDynaReqRead8 ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaUnpackReqRead8( byte_t buf[],
                                      size_t uMsgLen,
                                      BsDynaReqRead8_T * pStruct,
                                      bool_t bTrace )
{
  return BsDynaUnpackMsg(BsDynaMsgIdReqRead8, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsDynaRspRead8 ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaPackRspRead8( BsDynaRspRead8_T * pStruct,
                                    byte_t buf[],
                                    size_t bufSize,
                                    bool_t bTrace )
{
  return BsDynaPackMsg(BsDynaMsgIdRspRead8, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsDynaRspRead8 ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaUnpackRspRead8( byte_t buf[],
                                      size_t uMsgLen,
                                      BsDynaRspRead8_T * pStruct,
                                      bool_t bTrace )
{
  return BsDynaUnpackMsg(BsDynaMsgIdRspRead8, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsDynaReqRead16 ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaPackReqRead16( BsDynaReqRead16_T * pStruct,
                                     byte_t buf[],
                                     size_t bufSize,
                                     bool_t bTrace )
{
  return BsDynaPackMsg(BsDynaMsgIdReqRead16, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsDynaReqRead16 ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaUnpackReqRead16( byte_t buf[],
                                       size_t uMsgLen,
                                       BsDynaReqRead16_T * pStruct,
                                       bool_t bTrace )
{
  return BsDynaUnpackMsg(BsDynaMsgIdReqRead16, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsDynaRspRead16 ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaPackRspRead16( BsDynaRspRead16_T * pStruct,
                                     byte_t buf[],
                                     size_t bufSize,
                                     bool_t bTrace )
{
  return BsDynaPackMsg(BsDynaMsgIdRspRead16, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsDynaRspRead16 ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaUnpackRspRead16( byte_t buf[],
                                       size_t uMsgLen,
                                       BsDynaRspRead16_T * pStruct,
                                       bool_t bTrace )
{
  return BsDynaUnpackMsg(BsDynaMsgIdRspRead16, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsDynaReqWrite8 ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaPackReqWrite8( BsDynaReqWrite8_T * pStruct,
                                     byte_t buf[],
                                     size_t bufSize,
                                     bool_t bTrace )
{
  return BsDynaPackMsg(BsDynaMsgIdReqWrite8, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsDynaReqWrite8 ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaUnpackReqWrite8( byte_t buf[],
                                       size_t uMsgLen,
                                       BsDynaReqWrite8_T * pStruct,
                                       bool_t bTrace )
{
  return BsDynaUnpackMsg(BsDynaMsgIdReqWrite8, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsDynaRspWrite8 ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaPackRspWrite8( BsDynaRspWrite8_T * pStruct,
                                     byte_t buf[],
                                     size_t bufSize,
                                     bool_t bTrace )
{
  return BsDynaPackMsg(BsDynaMsgIdRspWrite8, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsDynaRspWrite8 ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaUnpackRspWrite8( byte_t buf[],
                                       size_t uMsgLen,
                                       BsDynaRspWrite8_T * pStruct,
                                       bool_t bTrace )
{
  return BsDynaUnpackMsg(BsDynaMsgIdRspWrite8, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsDynaReqWrite16 ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaPackReqWrite16( BsDynaReqWrite16_T * pStruct,
                                      byte_t buf[],
                                      size_t bufSize,
                                      bool_t bTrace )
{
  return BsDynaPackMsg(BsDynaMsgIdReqWrite16, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsDynaReqWrite16 ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaUnpackReqWrite16( byte_t buf[],
                                        size_t uMsgLen,
                                        BsDynaReqWrite16_T * pStruct,
                                        bool_t bTrace )
{
  return BsDynaUnpackMsg(BsDynaMsgIdReqWrite16, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsDynaRspWrite16 ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaPackRspWrite16( BsDynaRspWrite16_T * pStruct,
                                      byte_t buf[],
                                      size_t bufSize,
                                      bool_t bTrace )
{
  return BsDynaPackMsg(BsDynaMsgIdRspWrite16, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsDynaRspWrite16 ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaUnpackRspWrite16( byte_t buf[],
                                        size_t uMsgLen,
                                        BsDynaRspWrite16_T * pStruct,
                                        bool_t bTrace )
{
  return BsDynaUnpackMsg(BsDynaMsgIdRspWrite16, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsDynaReqSyncWrite ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaPackReqSyncWrite( BsDynaReqSyncWrite_T * pStruct,
                                        byte_t buf[],
                                        size_t bufSize,
                                        bool_t bTrace )
{
  return BsDynaPackMsg(BsDynaMsgIdReqSyncWrite, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsDynaReqSyncWrite ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaUnpackReqSyncWrite( byte_t buf[],
                                          size_t uMsgLen,
                                          BsDynaReqSyncWrite_T * pStruct,
                                          bool_t bTrace )
{
  return BsDynaUnpackMsg(BsDynaMsgIdReqSyncWrite, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsDynaReqPing ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaPackReqPing( BsDynaReqPing_T * pStruct,
                                   byte_t buf[],
                                   size_t bufSize,
                                   bool_t bTrace )
{
  return BsDynaPackMsg(BsDynaMsgIdReqPing, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsDynaReqPing ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaUnpackReqPing( byte_t buf[],
                                     size_t uMsgLen,
                                     BsDynaReqPing_T * pStruct,
                                     bool_t bTrace )
{
  return BsDynaUnpackMsg(BsDynaMsgIdReqPing, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsDynaRspPing ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaPackRspPing( BsDynaRspPing_T * pStruct,
                                   byte_t buf[],
                                   size_t bufSize,
                                   bool_t bTrace )
{
  return BsDynaPackMsg(BsDynaMsgIdRspPing, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsDynaRspPing ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaUnpackRspPing( byte_t buf[],
                                     size_t uMsgLen,
                                     BsDynaRspPing_T * pStruct,
                                     bool_t bTrace )
{
  return BsDynaUnpackMsg(BsDynaMsgIdRspPing, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsDynaReqReset ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaPackReqReset( BsDynaReqReset_T * pStruct,
                                    byte_t buf[],
                                    size_t bufSize,
                                    bool_t bTrace )
{
  return BsDynaPackMsg(BsDynaMsgIdReqReset, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsDynaReqReset ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaUnpackReqReset( byte_t buf[],
                                      size_t uMsgLen,
                                      BsDynaReqReset_T * pStruct,
                                      bool_t bTrace )
{
  return BsDynaUnpackMsg(BsDynaMsgIdReqReset, buf, uMsgLen, pStruct, bTrace);
}

/*!
 * \brief Pack a BsDynaReqSetHalfDuplexCtl ITV message in big-endian byte order
 *        into the output buffer.
 * 
 * \param [in] pStruct    Pointer to the associated, populated message
 *                        structure.
 * \param [out] buf       Output message buffer.
 * \param bufSize         Size of output buffer.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes packed.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaPackReqSetHalfDuplexCtl( BsDynaReqSetHalfDuplexCtl_T * pStruct,
                                               byte_t buf[],
                                               size_t bufSize,
                                               bool_t bTrace )
{
  return BsDynaPackMsg(BsDynaMsgIdReqSetHalfDuplexCtl, pStruct, buf, bufSize, bTrace);
}

/*!
 * \brief Unpack a BsDynaReqSetHalfDuplexCtl ITV message in big-endian byte order
 *        from the input buffer.
 * 
 * \param [in] buf        Output message buffer.
 * \param uMsgLen         Length of message (bytes) in input buffer.
 * \param [out] pStruct   Pointer to the associated message structure.
 * \param bTrace          Do [not] trace packing.
 * 
 * \return
 * On success, returns the number of bytes unpacked.
 * On error, returns the appropriate \h_lt 0 negated NM_ECODE.
 */
INLINE_IN_H int BsDynaUnpackReqSetHalfDuplexCtl( byte_t buf[],
                                                 size_t uMsgLen,
                                                 BsDynaReqSetHalfDuplexCtl_T * pStruct,
                                                 bool_t bTrace )
{
  return BsDynaUnpackMsg(BsDynaMsgIdReqSetHalfDuplexCtl, buf, uMsgLen, pStruct, bTrace);
}


C_DECLS_END


#endif // _BSDYNAMSGS_H