• 需求要封装一系列的指令

  
  烦人的指令
• 封装意味着重复，“用另一种方式来表达，以便转接到另外的系统中
• 填写命令表和桩函数名称

static scpi_command_t _scpi_cmds[]=
{
    COM_ITEMs(),

    CMD_ITEM( "*IDN?", _scpi_idn ),

    CMD_ITEM( "SYSTEM:MODE:SWITCH", _scpi_system_mode_switch ),
    CMD_ITEM( "SYSTEM:MODE:READ?", _scpi_system_mode_switch_q ),

    CMD_ITEM( "SCRIPT:RUN", _scpi_script_run ),
    CMD_ITEM( "SCRIPT:RUN:CYCLE", _scpi_script_run_cycle ),
    CMD_ITEM( "SCRIPT:RUN:CYCLE?", _scpi_script_run_cycle_q ),
    CMD_ITEM( "SCRIPT:RUN:CURRCYCLE?", _scpi_script_run_currcycle_q ),
    ...

• 写桩函数

static scpi_result_t _scpi_system_mode_switch( scpi_t * context )

问题来了，桩函数中需要

1. 提取命令关键字
2. 提取命令参数，而且参数有不同的格式
   怎样简化这个过程：

简化命令关键字

1. 命令关键字可以依据函数地址从命令表中搜索

static char * cbToKeyw( scpi_t * context, _scpi_cb pfCb )
{
    scpi_command_t *pCmdList;

    Q_ASSERT( NULL != context );
    Q_ASSERT( NULL != pfCb );

    pCmdList = (scpi_command_t*)context->cmdlist;

    do
    {
        if ( pCmdList->callback == pfCb )
        { return (char*)pCmdList->pattern; }

        if ( pCmdList->pattern == NULL || pCmdList->callback == NULL )
        { return NULL; }

        pCmdList++;

    }while( 1 );

    return NULL;
}

但是在桩函数中需要“重复”函数名称以得到其地址

cbToKeyw( context, _scpi_system_mode_switch )

2. 从当前运行环境中提取完整的输入内容，这样就不再需要函数地址了

context->input_count
context->buffer.position
context->buffer.length
context->buffer.data;

简化桩函数的书写

• 桩函数的两种模式
  • 写
    1. 提取内容
    2. 发送

int ret = _OBJ->write( (byte*)context->buffer.data,\
                            context->buffer.position );\
                            if ( ret != 0 )\
                            { scpi_ret( SCPI_RES_ERR ); }\
                            else\
                            { return SCPI_RES_OK; }

• 读
  1. 提取内容
  2. 发送
  3. 读取

int retLen;\
                            byte *pBuf;\
                            pBuf = _OBJ->recv( retLen );\
                            if ( retLen > 0 )\
                            {\
                                SCPI_ResultText( context, (char*)pBuf);\
                                return SCPI_RES_OK;\
                            }\
                            else\
                            { return SCPI_RES_ERR; }

• 所以用宏来简化函数实现

static scpi_result_t _scpi_system_mode_switch( scpi_t * context )
{
    DEF_LOCAL_VAR();
    transfer_write();
}

static scpi_result_t _scpi_system_mode_switch_q( scpi_t * context )
{
    DEF_LOCAL_VAR();

    transfer_write();

    transfer_recv();
}

• 更进一步，用宏来简化函数

#define make_w_api( api ) static scpi_result_t api( scpi_t * context )\
{\
    DEF_LOCAL_VAR();\
\
    transfer_write();\
\
}

#define make_r_api( api ) static scpi_result_t api( scpi_t * context )\
{\
    DEF_LOCAL_VAR();\
\
    transfer_write();\
\
    transfer_recv();\
}

• 来看一下利用宏的桩函数实现

make_w_api( _scpi_system_mode_switch )
make_r_api( _scpi_system_mode_switch_q )

make_w_api( _scpi_script_run )
make_w_api( _scpi_script_run_cycle )
make_r_api( _scpi_script_run_cycle_q )
make_r_api( _scpi_script_run_currcycle_q )