机械境

int16_t getsnapshot()
{
    edna_tag_t  *tag;
    int32_t     index;
    int32_t     *buff_size;
    int16_t     counter;
    int32_t		ret;
    int8_t      log_tag[MAX_BUFF_SIZE];
    int8_t	szValue[EDNA_LEN];
    int32_t ptTime;

    int8_t szmS[EDNA_LEN];
    uint16_t pusStatus;
    int8_t szStatus[EDNA_LEN];
    int8_t szDesc[EDNA_DESC_LEN];
    int8_t szUnits[EDNA_LEN];

    strncpy(log_tag, "getsnapshot", MAX_BUFF_SIZE);
    // init parameters
    // ....

    for (index = 0; index < ptbl_data->point_size; index++, tag++)
    {
        // other stuff
        // ...

        if (tag->flag == E_EMPTY_TAG) continue;

        // tests the string, validating it as a fully qualified eDNA point name
        if (DNAGoodPointFormat(tag->name) == 0)
        {
            tag->flag = INVALID;
            continue;
        }

        // check point name is exist
        if (!DoesIdExist(tag->name))
        {
            tag->flag = NOT_EXIST;
            continue;
        }

        // retrieves the value, time and status in their raw formats
        ret = DNAGetRTFull(tag->name, &tag->value, szValue, EDNA_LEN, &ptTime, tag->ts,
                          EDNA_LEN, &pusStatus, szStatus, EDNA_LEN, szDesc,
                          EDNA_DESC_LEN, szUnits, EDNA_LEN);

#if 0

        ret = DNAGetHSFull(tag->name, &tag->value, szValue, EDNA_LEN, &ptTime, tag->ts,
                           EDNA_LEN, &tag->ms, szmS, EDNA_LEN, &pusStatus, szStatus,
                           EDNA_LEN, szDesc, EDNA_DESC_LEN, szUnits, EDNA_LEN);
#endif


        tag->flag = (ret == 0) ? NORMAL : OFFLINE;
    }

    return TRUE;
}

error_t connect_pi(server_info_t *server)
{
    int32_t result;
    int32_t valid;
    int8_t  version[SERVER_FIELD_SIZE];
    int8_t  log_tag[MAX_BUFF_SIZE];
    int8_t  pro_name[SERVER_FIELD_SIZE];

    valid = PIREAD;

    strncpy(log_tag, "connect pi", MAX_BUFF_SIZE);

    if (piut_isconnected() == 0)
    {
        //  retrieves the version number of the PI-API.
        if (piut_getapiversion(version, sizeof(version)) == 0)
        {
            ftrace_log(log_tag, "PI-API version %s", version);
        }

        if (server->misc3 == NULL || strlen(server->misc3) == 0)
        {
            strncpy(pro_name, "pi_snap", SERVER_FIELD_SIZE);
        }
        else
        {
            strncpy(pro_name, server->misc3, SERVER_FIELD_SIZE);
        }

        // sets the active PI Server node where the data for the subsequent
        // PI-API calls will be resolved
        result = piut_setservernode(server->server_ip);

        if (result)
        {
            ftrace_log(log_tag, "piut_setservernode: can not connect to %s", server->server_ip);
            return E_CONNECT_FAILED;
        }

        if (server->usr_name != NULL && strlen(server->usr_name) > 0)
        {
            // establishes a user's access to PI System data based on a login to a configured user database
            result = piut_login(server->usr_name, server->usr_pwd, &valid);

            if (result == 0)
            {
                ftrace_log(log_tag, "piut_login: connect to %s successful, valid=%d", server->server_ip, valid);
                return E_SUCCESS;
            }

            ferror_log(log_tag, "piut_login: connect to %s failed, ret=%d", server->server_ip, result);
        }

        //sets the global process name to the passed string
        piut_setprocname(pro_name);
        result = piut_connect(server->server_ip);

        if (result)
        {
            ferror_log(log_tag, "piut_connect: connect to %s failed, ret=%d", server->server_ip, result);
            return E_CONNECT_FAILED;
        }
    }

    return E_SUCCESS;
}

static int16_t init_pi_tag(pi_tag_t *tag)
{
    int32_t result;
    int8_t  log_tag[MAX_BUFF_SIZE];
    strncpy(log_tag, "init_pi_tag", MAX_BUFF_SIZE);

    // gets the point number for the given tagname
    result = pipt_findpoint(tag->name, &tag->point_id);

    if (result)
    {
        ftrace_log(log_tag, "fetch point[%s] id failed.", tag->name);
        tag->stat = NOT_EXIST;
        return FALSE;
    }

    // gets the data type code for the passed point number
    result = pipt_pointtypex(tag->point_id, &tag->pt_typex);

    if (result)
    {
        ftrace_log(log_tag, "fetch point[%s] typex failed.", tag->name);
        tag->stat = INVALID;
        return FALSE;
    }

    // gets the display digits attribute for the passed point number
    result = pipt_displaydigits(tag->point_id, &tag->display_prec);

    if (result)
    {
        ftrace_log(log_tag, "fetch point[%s] display digits failed.", tag->name);
        tag->display_prec = -5;
    }

    tag->stat = NORMAL;
    tag->rval = (float64_t) 0.0;
    tag->istat = 0;
    tag->ival = 0;
    tag->flag = 0;

    ftrace_log(log_tag, "name:%s, id:%d, dis_prec: %d,type: %d", tag->name, tag->point_id, tag->display_prec, (int32_t)tag->pt_typex);

    switch (tag->pt_typex)
    {
    case PI_Type_PIstring:
    case PI_Type_blob:
    case PI_Type_PItimestamp:
        if (tag->bsize == 0)
        {
            /* Skip allocation if a subsequent run. */
            if ((tag->bval = (void *)malloc(BVALUE_BUFF)) == NULL)
            {
                error_log(log_tag, "malloc bval failed.");
                destory();
                return E_MALLOC_FAILED;
            }
        }

        tag->bsize = (tag->bsize > BVALUE_BUFF - 1) ? tag->bsize : BVALUE_BUFF - 1;
        memset(tag->bval, 0, (size_t)(tag->bsize + 1));
        break;

    case PI_Type_int16:
    case PI_Type_int32:
        tag->bsize = 0;
        break;

    case PI_Type_digital:
        tag->bsize = 0;
        break;

    default:/* floats, PI2 */
        tag->bsize = 0;
        break;
    } /* End switch */

    return TRUE;
}

int16_t getsnapshot()
{
    // init parameters etc.
    // ...

    for (index = 0; index < ptbl_data->point_size; index++, tag++)
    {
        // check server connection etc
        // ...
        tag->rval = 0;
        tag->istat = 0;

        result = pisn_getsnapshot(tag->point_id, &tag->rval, &tag->istat, &tag->time);

        if (result == 0)
        {
            ftrace_log(log_tag, "%s[0x%p] pisn_getsnapshot, rval=%f,ival=%d,time=%d", tag->name, tag, tag->rval, tag->istat, tag->time);
        }
        else if (result == -1)
        {
            tag->stat = NOT_EXIST;
            ftrace_log(log_tag, "%s pisn_getsnapshot not exist, result=%d.", tag->name, result);
        }
        else
        {
            tag->stat = INVALID;
            ftrace_log(log_tag, "%s pisn_getsnapshot failed, result=%d.", tag->name, result);
        }
    }

    return TRUE;
}