bsDynaClient.cxx File Reference

BotSense bsProxy client proxied Dynamixel device. More...

#include <stdio.h>
#include <stdlib.h>
#include <libgen.h>
#include <string.h>
#include "rnr/rnrconfig.h"
#include "rnr/log.h"
#include "rnr/netmsgs.h"
#include "botsense/BotSense.h"
#include "botsense/libBotSense.h"
#include "botsense/bsProxyMsgs.h"
#include "botsense/bsDyna.h"
#include "botsense/bsDynaMsgs.h"

Go to the source code of this file.

Functions
const char *	bsDynaGetMsgName (BsClient_P pClient, BsVConnHnd_T hndVConn, uint_t uMsgId)
	Get the Dynamixel message name. More...
int	bsDynaOpen (BsClient_P pClient, const char *sDevName, int nBaudRate, bool_t bInitTrace)
	Request proxy server to establish a virtual connection to the Dynamixel servo chain using the USB2Dynamixel serial dongle. More...
int	bsDynaClose (BsClient_P pClient, BsVConnHnd_T hndVConn)
	Request proxy server to close client's proxied Dynamixel servo chain vitual connection. More...
int	bsDynaSetBaudRate (BsClient_P pClient, BsVConnHnd_T hndVConn, int nBaudRate)
	Proxied request to set the Dynamixel Bus baud rate. More...
int	bsDynaRead8 (BsClient_P pClient, BsVConnHnd_T hndVConn, int nServoId, uint_t uAddr, byte_t *pVal, uint_t *pAlarms)
	Proxied request to read an 8-bit value from a servo's control table. More...
int	bsDynaRead16 (BsClient_P pClient, BsVConnHnd_T hndVConn, int nServoId, uint_t uAddr, ushort_t *pVal, uint_t *pAlarms)
	Proxied request to read a 16-bit value from a servo's control table. More...
int	bsDynaWrite8 (BsClient_P pClient, BsVConnHnd_T hndVConn, int nServoId, uint_t uAddr, byte_t byVal, uint_t *pAlarms)
	Proxied request to write an 8-bit value to a servo's control table. More...
int	bsDynaWrite16 (BsClient_P pClient, BsVConnHnd_T hndVConn, int nServoId, uint_t uAddr, ushort_t huVal, uint_t *pAlarms)
	Proxied request to write a 16-bit value to a servo's control table. More...
int	bsDynaSyncWrite (BsClient_P pClient, BsVConnHnd_T hndVConn, uint_t uAddr, uint_t uDataSize, DynaSyncWriteTuple_T tuples[], uint_t uCount)
	Proxied request to synchronously write values to servos. More...
int	bsDynaPing (BsClient_P pClient, BsVConnHnd_T hndVConn, int nServoId, bool_t *pPong)
	Proxied request to ping a servo. More...
int	bsDynaReset (BsClient_P pClient, BsVConnHnd_T hndVConn, int nServoId)
	Proxied request to reset a servo to defaults. More...
int	bsDynaSetHalfDuplexCtl (BsClient_P pClient, BsVConnHnd_T hndVConn, int nSignal)
	Proxied request to set the half-duplex control signal. More...

Variables
static BsClientAppInfo_T	bsDynaAppInfo
	client application information. More...

Detailed Description

BotSense bsProxy client proxied Dynamixel device.

LastChangedDate

2015-01-12 10:56:06 -0700 (Mon, 12 Jan 2015)

Rev

3845

Author

Robin Knight (robin.nosp@m..kni.nosp@m.ght@r.nosp@m.oadn.nosp@m.arrow.nosp@m.s.co.nosp@m.m)

Copyright

© 2012-2017. RoadNarrows LLC.
http://www.roadnarrows.com
All Rights Reserved

Definition in file bsDynaClient.cxx.

Function Documentation

int bsDynaClose	(	BsClient_P	pBsClient,
		BsVConnHnd_T	hndBsVConn
	)

Request proxy server to close client's proxied Dynamixel servo chain vitual connection.

Parameters

pClient	client.
hndVConn	Handle to virtual connection to close.

Definition at line 143 of file bsDynaClient.cxx.

{
  return bsServerReqCloseDev(pClient, hndVConn);
}

const char* bsDynaGetMsgName	(	BsClient_P	pBsClient,
		BsVConnHnd_T	hndVConn,
		uint_t	uMsgId
	)

Get the Dynamixel message name.

Each (virtual connection, message id) 2-tuple provides a unique server mapping that can be used associate a name string to the message (provided the id is valid and an application provides the information).

Parameters

pClient	client.
hndVConn	Virtual connection handle.
uMsgId	Message id.

Returns

Returns message name if it can be determined. Otherwise returns "unknown".

Definition at line 89 of file bsDynaClient.cxx.

References BsDynaLookupMsgDef().

{
  const NMMsgDef_T  *pMsgDef;

  pMsgDef = BsDynaLookupMsgDef((BsDynaMsgId_T)uMsgId);

  return pMsgDef!=NULL? pMsgDef->m_sMsgName: "unknown";
}

int bsDynaOpen	(	BsClient_P	pBsClient,
		const char *	sDevName,
		int	nBaudRate,
		bool_t	bInitTrace
	)

Request proxy server to establish a virtual connection to the Dynamixel servo chain using the USB2Dynamixel serial dongle.

Parameters

pClient	client.
sDevName	Proxied USB serial device name (e.g. /dev/ttyUSB0).
nBaudRate	Baud rate.
bInitTrace	Initial message tracing enable(true)/disable(false) state.

Returns

On success, the virtual connection handle is returned.

Definition at line 100 of file bsDynaClient.cxx.

References BS_DYNA_SERVER_MOD, bsDynaAppInfo, BsDynaMsgIdReqOpenArgs, BsDynaPackReqOpenArgs(), and BsDynaReqOpenArgs_T::m_baudrate.

{
  static BsDynaMsgId_T    msgIdReq = BsDynaMsgIdReqOpenArgs;
  
  BsDynaReqOpenArgs_T     msgReq;                   // specific open args
  byte_t                  buf[BSPROXY_MSG_MAX_LEN]; // specific open args buffer
  bool_t                  bTrace;                   // do [not] trace messages
  int                     n;                        // num of bytes/return code

  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, BSPROXY_VCONN_SERVER);
  
  //
  // Set specific open argument values.
  //
  msgReq.m_baudrate = (uint_t)nBaudRate;

  //
  // Pack specific open arguments (returns bytes packed \h_ge 0 on success).
  //
  n = BsDynaPackReqOpenArgs(&msgReq, buf, sizeof(buf), bTrace);

  // check packing return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdReq);


  //
  // Execute server transaction (returns handle \h_ge 0 on success).
  //
  n = bsServerReqOpenDev(pClient, sDevName, BS_DYNA_SERVER_MOD, buf, (size_t)n,
                         &bsDynaAppInfo, bInitTrace);

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "bsServerReqOpenDev(dev='%s') failed.",
      sDevName);

  // return handle
  return n;
}

int bsDynaPing	(	BsClient_P	pBsClient,
		BsVConnHnd_T	hndBsVConn,
		int	nServoId,
		bool_t *	pPong
	)

Proxied request to ping a servo.

Parameters

pClient	client.
hndVConn	Handle to virtual connection to close.
nServoId	Servo id.

Returns

Returns true if the servo responded, else false.

Definition at line 534 of file bsDynaClient.cxx.

References BsDynaMsgIdReqPing, BsDynaMsgIdRspPing, BsDynaPackReqPing(), BsDynaUnpackRspPing(), BsDynaRspPing_T::m_pong, and BsDynaReqPing_T::m_servo_id.

{
  static BsDynaMsgId_T  msgIdReq = BsDynaMsgIdReqPing;
  static BsDynaMsgId_T  msgIdRsp = BsDynaMsgIdRspPing;

  BsDynaReqPing_T       msgReq;                   // response message 
  BsDynaRspPing_T       msgRsp;                   // response message 
  byte_t                buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                bTrace;                   // do [not] trace messages
  int                   n;                        // num of bytes/return code

  //
  // Parameter checks.
  //
  BSCLIENT_TRY_EXPR(pClient, BSCLIENT_HAS_VCONN(pClient, hndVConn),
      BS_ECODE_BAD_VAL, "VConn=%d", hndVConn);

  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, hndVConn);

  //
  // Set request message values.
  //
  msgReq.m_servo_id = (byte_t)nServoId;

  //
  // Pack request.
  //
  n = BsDynaPackReqPing(&msgReq, BSPROXY_BUF_BODY(buf), bTrace);

  // check packing return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdReq);

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  hndVConn,
                    msgIdReq, buf, (size_t)n,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  //
  // Unpack response.
  //
  n = BsDynaUnpackRspPing(buf, (size_t)n, &msgRsp, bTrace);

  // check unpack return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdRsp);

  *pPong = msgRsp.m_pong? true: false;

  return BS_OK;
}

int bsDynaRead16	(	BsClient_P	pBsClient,
		BsVConnHnd_T	hndBsVConn,
		int	nServoId,
		uint_t	uAddr,
		ushort_t *	pVal,
		uint_t *	pAlarms
	)

Proxied request to read a 16-bit value from a servo's control table.

Parameters

	pClient	client.
	hndVConn	Handle to virtual connection to close.
	nServoId	Servo id.
	uAddr	Control table address.
[out]	pVal	Value read.
[out]	pAlarms	Current servo alarms, if any.

Definition at line 266 of file bsDynaClient.cxx.

References BsDynaMsgIdReqRead16, BsDynaMsgIdRspRead16, BsDynaPackReqRead16(), BsDynaUnpackRspRead16(), BsDynaReqRead16_T::m_addr, BsDynaRspRead16_T::m_alarms, BsDynaReqRead16_T::m_servo_id, and BsDynaRspRead16_T::m_val.

{
  static BsDynaMsgId_T  msgIdReq = BsDynaMsgIdReqRead16;
  static BsDynaMsgId_T  msgIdRsp = BsDynaMsgIdRspRead16;

  BsDynaReqRead16_T     msgReq;                   // response message 
  BsDynaRspRead16_T     msgRsp;                   // response message 
  byte_t                buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                bTrace;                   // do [not] trace messages
  int                   n;                        // num of bytes/return code

  //
  // Parameter checks.
  //
  BSCLIENT_TRY_EXPR(pClient, BSCLIENT_HAS_VCONN(pClient, hndVConn),
      BS_ECODE_BAD_VAL, "VConn=%d", hndVConn);

  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, hndVConn);

  //
  // Set request message values.
  //
  msgReq.m_servo_id = (byte_t)nServoId;
  msgReq.m_addr     = (byte_t)uAddr;

  //
  // Pack request.
  //
  n = BsDynaPackReqRead16(&msgReq, BSPROXY_BUF_BODY(buf), bTrace);

  // check packing return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdReq);

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  hndVConn,
                    msgIdReq, buf, (size_t)n,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  //
  // Unpack response.
  //
  n = BsDynaUnpackRspRead16(buf, (size_t)n, &msgRsp, bTrace);

  // check unpack return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdRsp);

  //
  // Set return values from response.
  //
  *pAlarms  = (uint_t)msgRsp.m_alarms;
  *pVal     = msgRsp.m_val;

  LOGDIAG3("%s: Read16: 0x%02x --> 0x%04x.",
      bsClientAttrGetName(pClient), uAddr, *pVal);

  return BS_OK;
}

int bsDynaRead8	(	BsClient_P	pBsClient,
		BsVConnHnd_T	hndBsVConn,
		int	nServoId,
		uint_t	uAddr,
		byte_t *	pVal,
		uint_t *	pAlarms
	)

Proxied request to read an 8-bit value from a servo's control table.

Parameters

	pClient	client.
	hndVConn	Handle to virtual connection to close.
	nServoId	Servo id.
	uAddr	Control table address.
[out]	pVal	Value read.
[out]	pAlarms	Current servo alarms, if any.

Definition at line 197 of file bsDynaClient.cxx.

References BsDynaMsgIdReqRead8, BsDynaMsgIdRspRead8, BsDynaPackReqRead8(), BsDynaUnpackRspRead8(), BsDynaReqRead8_T::m_addr, BsDynaRspRead8_T::m_alarms, BsDynaReqRead8_T::m_servo_id, and BsDynaRspRead8_T::m_val.

{
  static BsDynaMsgId_T  msgIdReq = BsDynaMsgIdReqRead8;
  static BsDynaMsgId_T  msgIdRsp = BsDynaMsgIdRspRead8;

  BsDynaReqRead8_T      msgReq;                   // response message 
  BsDynaRspRead8_T      msgRsp;                   // response message 
  byte_t                buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                bTrace;                   // do [not] trace messages
  int                   n;                        // num of bytes/return code

  //
  // Parameter checks.
  //
  BSCLIENT_TRY_EXPR(pClient, BSCLIENT_HAS_VCONN(pClient, hndVConn),
      BS_ECODE_BAD_VAL, "VConn=%d", hndVConn);

  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, hndVConn);

  //
  // Set request message values.
  //
  msgReq.m_servo_id = (byte_t)nServoId;
  msgReq.m_addr     = (byte_t)uAddr;

  //
  // Pack request.
  //
  n = BsDynaPackReqRead8(&msgReq, BSPROXY_BUF_BODY(buf), bTrace);

  // check packing return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdReq);

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  hndVConn,
                    msgIdReq, buf, (size_t)n,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  //
  // Unpack response.
  //
  n = BsDynaUnpackRspRead8(buf, (size_t)n, &msgRsp, bTrace);

  // check unpack return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdRsp);

  //
  // Set return values from response.
  //
  *pAlarms  = (uint_t)msgRsp.m_alarms;
  *pVal     = msgRsp.m_val;

  LOGDIAG3("%s: Read8: 0x%02x --> 0x%02x.",
      bsClientAttrGetName(pClient), uAddr, *pVal);

  return BS_OK;
}

int bsDynaReset	(	BsClient_P	pBsClient,
		BsVConnHnd_T	hndBsVConn,
		int	nServoId
	)

Proxied request to reset a servo to defaults.

Parameters

pClient	client.
hndVConn	Handle to virtual connection to close.
nServoId	Servo id.

Returns

doc_return_bs_std

Definition at line 593 of file bsDynaClient.cxx.

References BsDynaMsgIdReqReset, BsDynaPackReqReset(), and BsDynaReqReset_T::m_servo_id.

{
  static BsDynaMsgId_T  msgIdReq = BsDynaMsgIdReqReset;
  static BsProxyMsgId_T msgIdRsp = BsProxyMsgIdRspOk;

  BsDynaReqReset_T      msgReq;                   // response message 
  byte_t                buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                bTrace;                   // do [not] trace messages
  int                   n;                        // num of bytes/return code

  //
  // Parameter checks.
  //
  BSCLIENT_TRY_EXPR(pClient, BSCLIENT_HAS_VCONN(pClient, hndVConn),
      BS_ECODE_BAD_VAL, "VConn=%d", hndVConn);

  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, hndVConn);

  //
  // Set request message values.
  //
  msgReq.m_servo_id = (byte_t)nServoId;

  //
  // Pack request.
  //
  n = BsDynaPackReqReset(&msgReq, BSPROXY_BUF_BODY(buf), bTrace);

  // check packing return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdReq);

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  hndVConn,
                    msgIdReq, buf, (size_t)n,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  return BS_OK;
}

int bsDynaSetBaudRate	(	BsClient_P	pBsClient,
		BsVConnHnd_T	hndBsVConn,
		int	nBaudRate
	)

Proxied request to set the Dynamixel Bus baud rate.

Parameters

pClient	client.
hndVConn	Handle to virtual connection to close.
nBaudRate	New baud rate.

Returns

doc_return_bs_std

Definition at line 148 of file bsDynaClient.cxx.

References BsDynaMsgIdReqSetBaudRate, BsDynaPackReqSetBaudRate(), and BsDynaReqSetBaudRate_T::m_baudrate.

{
  static BsDynaMsgId_T  msgIdReq = BsDynaMsgIdReqSetBaudRate;
  static BsProxyMsgId_T msgIdRsp = BsProxyMsgIdRspOk;

  BsDynaReqSetBaudRate_T  msgReq;                   // response message 
  byte_t                  buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                  bTrace;                   // do [not] trace messages
  int                     n;                        // num of bytes/return code

  //
  // Parameter checks.
  //
  BSCLIENT_TRY_EXPR(pClient, BSCLIENT_HAS_VCONN(pClient, hndVConn),
      BS_ECODE_BAD_VAL, "VConn=%d", hndVConn);

  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, hndVConn);

  //
  // Set request message values.
  //
  msgReq.m_baudrate = (uint_t)nBaudRate;

  //
  // Pack request.
  //
  n = BsDynaPackReqSetBaudRate(&msgReq, BSPROXY_BUF_BODY(buf), bTrace);

  // check packing return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdReq);

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  hndVConn,
                    msgIdReq, buf, (size_t)n,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  LOGDIAG3("%s: SetBaudRate: %d", bsClientAttrGetName(pClient), nBaudRate);

  return BS_OK;
}

int bsDynaSetHalfDuplexCtl	(	BsClient_P	pClient,
		BsVConnHnd_T	hndVConn,
		int	nSignal
	)

Proxied request to set the half-duplex control signal.

Parameters

pClient	client.
hndVConn	Handle to virtual connection to close.
nSignal	Signal number.

Returns

doc_return_bs_std

Definition at line 640 of file bsDynaClient.cxx.

References BsDynaMsgIdReqSetHalfDuplexCtl, BsDynaPackReqSetHalfDuplexCtl(), and BsDynaReqSetHalfDuplexCtl_T::m_signal.

{
  static BsDynaMsgId_T  msgIdReq = BsDynaMsgIdReqSetHalfDuplexCtl;
  static BsProxyMsgId_T msgIdRsp = BsProxyMsgIdRspOk;

  BsDynaReqSetHalfDuplexCtl_T msgReq;               // response message 
  byte_t                      buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                      bTrace;               // do [not] trace messages
  int                         n;                    // num of bytes/return code

  //
  // Parameter checks.
  //
  BSCLIENT_TRY_EXPR(pClient, BSCLIENT_HAS_VCONN(pClient, hndVConn),
      BS_ECODE_BAD_VAL, "VConn=%d", hndVConn);

  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, hndVConn);

  //
  // Set request message values.
  //
  msgReq.m_signal = (uint_t)nSignal;

  //
  // Pack request.
  //
  n = BsDynaPackReqSetHalfDuplexCtl(&msgReq, BSPROXY_BUF_BODY(buf), bTrace);

  // check packing return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdReq);

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  hndVConn,
                    msgIdReq, buf, (size_t)n,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  LOGDIAG3("%s: SetHalfDuplexCtl: %d", bsClientAttrGetName(pClient), nSignal);

  return BS_OK;
}

int bsDynaSyncWrite	(	BsClient_P	pBsClient,
		BsVConnHnd_T	hndBsVConn,
		uint_t	uAddr,
		uint_t	uDataSize,
		DynaSyncWriteTuple_T	tuples[],
		uint_t	uCount
	)

Proxied request to synchronously write values to servos.

Parameters

pClient	client.
hndVConn	Handle to virtual connection to close.
uAddr	Control table address.
uDataSize	Size (bytes) of data to write.
tuples	Servo Id, Value 2-tuples
uCount	Number of 2-tuples

Definition at line 473 of file bsDynaClient.cxx.

References BsDynaMsgIdReqSyncWrite, BsDynaPackReqSyncWrite(), DYNA_ID_NUMOF, BsDynaReqSyncWrite_T::m_addr, BsDynaReqSyncWrite_T::m_count, BsDynaReqSyncWrite_T::m_data_size, BsDynaReqSyncWrite_T::m_tuples, and BsDynaReqSyncWrite_T::u.

{
  static BsDynaMsgId_T  msgIdReq = BsDynaMsgIdReqSyncWrite;
  static BsProxyMsgId_T msgIdRsp = BsProxyMsgIdRspOk;

  BsDynaReqSyncWrite_T  msgReq;                   // response message 
  byte_t                buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                bTrace;                   // do [not] trace messages
  int                   n;                        // num of bytes/return code

  //
  // Parameter checks.
  //
  BSCLIENT_TRY_EXPR(pClient, BSCLIENT_HAS_VCONN(pClient, hndVConn),
      BS_ECODE_BAD_VAL, "VConn=%d", hndVConn);

  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, hndVConn);

  //
  // Set request message values.
  //
  msgReq.m_addr       = (byte_t)uAddr;
  msgReq.m_data_size  = (byte_t)uDataSize;

  for(n=0; (n<(int)uCount) && (n<DYNA_ID_NUMOF); ++n)
  {
    msgReq.m_tuples.u.m_buf[n].m_servo_id = (byte_t)tuples[n].m_nServoId;
    msgReq.m_tuples.u.m_buf[n].m_val      = (ushort_t)tuples[n].m_uVal;
  }
  msgReq.m_tuples.m_count = (size_t)n;

  //
  // Pack request.
  //
  n = BsDynaPackReqSyncWrite(&msgReq, BSPROXY_BUF_BODY(buf), bTrace);

  // check packing return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdReq);

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  hndVConn,
                    msgIdReq, buf, (size_t)n,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  LOGDIAG3("%s: SyncWrite: %u tuples to 0x%02x",
      bsClientAttrGetName(pClient), uCount, uAddr);

  return BS_OK;
}

int bsDynaWrite16	(	BsClient_P	pBsClient,
		BsVConnHnd_T	hndBsVConn,
		int	nServoId,
		uint_t	uAddr,
		ushort_t	huVal,
		uint_t *	pAlarms
	)

Proxied request to write a 16-bit value to a servo's control table.

Parameters

	pClient	client.
	hndVConn	Handle to virtual connection to close.
	nServoId	Servo id.
	uAddr	Control table address.
[in]	huVal	Value to write.
[out]	pAlarms	Current servo alarms, if any.

Definition at line 404 of file bsDynaClient.cxx.

References BsDynaMsgIdReqWrite16, BsDynaMsgIdRspWrite16, BsDynaPackReqWrite16(), BsDynaUnpackRspWrite16(), BsDynaReqWrite16_T::m_addr, BsDynaRspWrite16_T::m_alarms, BsDynaReqWrite16_T::m_servo_id, and BsDynaReqWrite16_T::m_val.

{
  static BsDynaMsgId_T  msgIdReq = BsDynaMsgIdReqWrite16;
  static BsDynaMsgId_T  msgIdRsp = BsDynaMsgIdRspWrite16;

  BsDynaReqWrite16_T    msgReq;                   // response message 
  BsDynaRspWrite16_T    msgRsp;                   // response message 
  byte_t                buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                bTrace;                   // do [not] trace messages
  int                   n;                        // num of bytes/return code

  //
  // Parameter checks.
  //
  BSCLIENT_TRY_EXPR(pClient, BSCLIENT_HAS_VCONN(pClient, hndVConn),
      BS_ECODE_BAD_VAL, "VConn=%d", hndVConn);

  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, hndVConn);

  //
  // Set request message values.
  //
  msgReq.m_servo_id = (byte_t)nServoId;
  msgReq.m_addr     = (byte_t)uAddr;
  msgReq.m_val      = huVal;

  //
  // Pack request.
  //
  n = BsDynaPackReqWrite16(&msgReq, BSPROXY_BUF_BODY(buf), bTrace);

  // check packing return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdReq);

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  hndVConn,
                    msgIdReq, buf, (size_t)n,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  //
  // Unpack response.
  //
  n = BsDynaUnpackRspWrite16(buf, (size_t)n, &msgRsp, bTrace);

  // check unpack return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdRsp);

  //
  // Set return values from response.
  //
  *pAlarms  = (uint_t)msgRsp.m_alarms;

  LOGDIAG3("%s: Write16: 0x%02x <-- 0x%04x.",
      bsClientAttrGetName(pClient), uAddr, huVal);

  return BS_OK;
}

int bsDynaWrite8	(	BsClient_P	pBsClient,
		BsVConnHnd_T	hndBsVConn,
		int	nServoId,
		uint_t	uAddr,
		byte_t	byVal,
		uint_t *	pAlarms
	)

Proxied request to write an 8-bit value to a servo's control table.

Parameters

	pClient	client.
	hndVConn	Handle to virtual connection to close.
	nServoId	Servo id.
	uAddr	Control table address.
[in]	byVal	Value to write.
[out]	pAlarms	Current servo alarms, if any.

Definition at line 335 of file bsDynaClient.cxx.

References BsDynaMsgIdReqWrite8, BsDynaMsgIdRspWrite8, BsDynaPackReqWrite8(), BsDynaUnpackRspWrite8(), BsDynaReqWrite8_T::m_addr, BsDynaRspWrite8_T::m_alarms, BsDynaReqWrite8_T::m_servo_id, and BsDynaReqWrite8_T::m_val.

{
  static BsDynaMsgId_T  msgIdReq = BsDynaMsgIdReqWrite8;
  static BsDynaMsgId_T  msgIdRsp = BsDynaMsgIdRspWrite8;

  BsDynaReqWrite8_T     msgReq;                   // response message 
  BsDynaRspWrite8_T     msgRsp;                   // response message 
  byte_t                buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                bTrace;                   // do [not] trace messages
  int                   n;                        // num of bytes/return code

  //
  // Parameter checks.
  //
  BSCLIENT_TRY_EXPR(pClient, BSCLIENT_HAS_VCONN(pClient, hndVConn),
      BS_ECODE_BAD_VAL, "VConn=%d", hndVConn);

  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, hndVConn);

  //
  // Set request message values.
  //
  msgReq.m_servo_id = (byte_t)nServoId;
  msgReq.m_addr     = (byte_t)uAddr;
  msgReq.m_val      = byVal;

  //
  // Pack request.
  //
  n = BsDynaPackReqWrite8(&msgReq, BSPROXY_BUF_BODY(buf), bTrace);

  // check packing return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdReq);

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  hndVConn,
                    msgIdReq, buf, (size_t)n,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  //
  // Unpack response.
  //
  n = BsDynaUnpackRspWrite8(buf, (size_t)n, &msgRsp, bTrace);

  // check unpack return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdRsp);

  //
  // Set return values from response.
  //
  *pAlarms  = (uint_t)msgRsp.m_alarms;

  LOGDIAG3("%s: Write8: 0x%02x <-- 0x%02x.",
      bsClientAttrGetName(pClient), uAddr, byVal);

  return BS_OK;
}

Variable Documentation

BsClientAppInfo_T bsDynaAppInfo

static

Initial value:

= 
{
  "libbsclient_dyna",
  "The proxied Dynamixel servo chain.",
  "1.1.0",
  "2015.01.09",
  "RoadNarrows LLC",
  "(C) 2012-2015 RoadNarrows LLC. All rights reserved.",
  bsDynaGetMsgName
}

client application information.

Definition at line 74 of file bsDynaClient.cxx.

Referenced by bsDynaOpen().