<< 点击显示目录 >> 主页  PVI通信 > PVI帮助信息 > PVI base system > PVICOM interface > Requests and responses > Access types

每当为一个PVI对象指定读或写请求时，就会指定访问类型。这允许 选择进程数据、属性、 进程对象的状态 和各种服务。

读取请求是通过 PviReadRequest 或PviXReadRequest函数 实现的  。 PviReadResponse 或PviXReadResponse函数用于读取响应数据。写入请求用 PviWriteRequest 或PviXWriteRequest函数  实现 。PviWriteResponse 或PviXWriteResponse函数用于写入响应数据。

一些访问类型由PVI管理器直接执行。其他访问类型则被传递到线路上，在那里进行处理。因此，哪些访问类型可以使用 ，取决于 正在使用的PVI线路 。

所有标准化的访问类型都列在下表中。 对象描述的合适参数代码  显示在 "Par. "栏中。相应的处理对象类型在 "类型 "栏中列出。

Line access types行访问类型

行访问类型是所有数字大于255的访问类型。这些访问类型只在被使用的线路中执行。请求和响应数据只由PVI管理器传递。

行访问类型主要用于Automation Studio和Automation Runtime之间的内部通信。然而，其中一些行访问类型也可以被PVI客户应用程序使用。

下表列出了所有允许在PVI客户应用程序中使用的行访问类型。相应的过程对象类型被列在 "类型 "栏中。

XML string

XML（可扩展标记语言）是一种标准化的标记语言，用于以文本形式描述分层结构的数据。一些PVI访问类型将响应数据作为XML格式的字符串返回。参数组（如列表中的一个条目）然后被结构化为XML元素。这些元素中的各个参数通常被指定为XML属性。

在PVI应用中评估XML响应数据时，必须考虑到以下几点。

•必须使用合适的分析器进行评估。

•来自较新的 AR 版本的 XML 数据可能包含新的 XML 元素或属性。

为了确保兼容性，PVI应用程序必须始终忽略未知的XML元素和属性。

•现有的XML元素和属性也可能被淘汰，如果它们在较新的AR版本中不再具有相关性。

PVI应用程序必须通过实施适当的措施（例如，分配默认值）来考虑这些情况。

•XML属性中的数值可以用十进制（Param="123"）或十六进制格式（Param="0x7b"）指定。

POBJ_ACC_DATA access type

Write access: 写入过程数据。数据首先被写入PVI过程图像中。当使用外部变量时，再转移到PLC中。写入程序的终止与响应数据一起被报告。这也保证了数据已经转移到了PLC中。  然而， 如果  指定了 "h " 对象属性 ，那么响应数据就会在写入PVI过程图像后立即发送给应用程序。因此，应用程序会收到一个更快的写入响应。然而，当收到响应数据时，不能保证数据确实已被写入PLC。

Read access: 激活一个过程数据的读取请求。数据从PLC中读取，并与响应数据一起发送给应用程序。如果过程数据发生变化， 则 与响应数据一起触发一个 POBJ_EVENT_DATA 事件。

POBJ_ACC_STATUS access type

这种访问类型用于读取或设置一个进程对象的状态。这个状态是用一个字符串格式的状态描述来定义的。对这个状态描述的处理是在被使用的行中进行的。这个访问类型支持哪一行，可以在各自的行描述中找到。

Write access:

Read access:

POBJ_ACC_TYPE access type

这种访问类型用于读取或设置过程对象 的属性、 数据格式 和 类型转换 的模式 。这种访问类型与字符串格式的描述一起工作。与 对象描述一样 ，各个参数在字符串中用参数代码进行区分。

该描述可以包括以下参数：

AT, VT, VL, VN, VS, AL, CM.

为了确保与旧版本的PVI（早于V3.0.0）兼容，对于 "简单 "的数组变量（有一个以上数组元素的一维数组，数组索引从0开始，不是派生数据类型）不指定参数VS。为了将一个变量识别为数组变量，除了附加规范'a'外，还必须评估参数VN。以下条件适用。如果VS=...a...或VN > 1，则为数组变量。

Write access: 根据描述字符串中的规格，为过程对象设置对象属性、数据格式和/或类型铸造模式的属性。这些属性既可以单独设置，也可以相互配合。例如，"AT=r "字符串只设置对象属性。其他属性保持不变。

当数据格式发生变化时，会触发一个 POBJ_EVENT_DATAFORM 事件。

如果流程对象的数据格式是由行指定的，那么应用程序不能改变它。任何尝试都会被拒绝，错误12039。

Read access: 读取过程对象中设置的对象属性、数据格式和类型铸造模式的属性。

POBJ_ACC_TYPE_INTERN access type

POBJ_ACC_TYPE_INTERN 访问类型读取  一个 PVI 变量的 对象属性和 数据格式的属性 。 与访问类型 POBJ_ACC_TYPE_EXTERN不同，该变量的属性是从 PVI 过程映像中读取的。

该描述可以包括以下参数。

at, vt, vl, ***vn, vs, al, cm, vo。

在读取方向上，访问类型POBJ_ACC_TYPE_INTERN是访问类型 POBJ_ACC_TYPE的扩展 。访问类型POBJ_ACC_TYPE_INTERN可以用来读取以下信息。

对于结构变量，在指定结构元素的数据格式时，可以指定结构元素的名称。

{.<ElementName1>[.<ElementName2>] ... }

Read access: 读取过程对象中设置的对象属性、数据格式和类型铸造模式的属性。

POBJ_ACC_TYPE_EXTERN access type

POBJ_ACC_TYPE_EXTERN访问类型读取  PLC变量的 对象属性和 数据格式的属性  。与访问类型 POBJ_ACC_TYPE 和 POBJ_ACC_TYPE_INTERN 不同，该变量的属性是从 PLC 中读取的。这些属性可能与PVI图像中的变量属性不同。读取请求的处理在  正在使用的PVI行中 进行  。这种访问类型支持哪条线，可以在相应的线描述中找到。

该描述可以包括以下参数。

at, sc, vt, vl, vn, vs, al, sn, tn, vo, ve.

数据格式参数VT、VL、VN、VS和AL是 对象描述中的参数 。所有其他参数是可选的，并且可以与对象描述不同。

与变量对象的对象属性不同，AT的定义如下。

SC参数（范围）用于显示PLC上一个变量的范围。

还可以用变量的数据格式指定更多的信息。

参数SN、TN、VO和VE是对数据格式的可选补充。其条目取决于线路和接入类型。

VS参数只有在存在附加规格的情况下才会给出。一个附加规格由一个规格ID和可选的规格参数组成。VS参数也可以包含几个附加规格（<Spec>）。这些规格总是由'；'（分号）字符分开。规格参数之间以及规格ID之间用","（逗号）分开。

一般语法：

VS=<Spec1>[,<Para1>[,<Para2>[, ... ]]][;<Spec2>[, ... ]]

可以指定以下附加规格：

附加规格 "a"，"v "和 "e "可以被多次输入。附加规格 "a "的每个条目都描述了一个数组维度。第一个条目描述最外层的数组维度；最后一个条目描述最内层的数组维度（例如：var[0.9][0.4]或var[10][5]，二维变量有50个元素=>"VS=a,0,9;a,0,4"）。附加规格 "v "的每个条目都描述了一个派生数据类型。派生数据类型的名称也以同样的顺序列在参数TN中。这个顺序也可以用来将派生数据类型分配给数组维度（例如。Typ1[0...9], Typ2[0...4], 变量由Typ2派生，Typ2由Typ1派生 => "TN=Typ1,Typ2 VS=a,0,9;v;a,0,4;v" ）。

为了确保与旧版本的PVI（早于V3.0.0）兼容，对于 "简单 "的数组变量（有一个以上数组元素的一维数组，数组索引从0开始，不是派生数据类型）不指定参数VS。为了将一个变量识别为数组变量，除了附加规范'a'之外，还必须评估参数VN。以下条件适用。如果VS=...a...或VN > 1，则为数组变量。

通过结构变量，结构元素的名称可以与它们的数据格式描述一起被指定。

{.<ElementName1>[.<ElementName2>] ... }

Read access: 可以读取对象的属性，如对象属性、数据格式、派生数据类型的名称、结构定义的名称以及结构的所有元素。

访问类型POBJ_ACC_TYPE_INTERN（或POBJ_ACC_TYPE）和POBJ_ACC_TYPE_EXTERN也可以返回不同的数据格式。请注意，只有 POBJ_ACC_TYPE_INTERN 访问类型（或 POBJ_ACC_TYPE 或 POBJ_EVENT_DATAFORM 事件）可以描述 PVI 过程映像中过程数据的格式。

POBJ_ACC_UPLOAD and POBJ_ACC_UPLOAD_STM access types

这些访问类型用于从PLC中读取BR模块。  必须使用PVICOM函数 PviReadArgumentRequest 或PviXReadArgumentRequest，因为应用程序还必须在读取请求中定义文件名和模块参数。应用程序会收到上传的确认信息或响应数据的错误信息（PviReadResponse 或PviXReadResponse）。上传总是通过一个PVI模块对象进行调节。PLC上的模块名称是通过过程对象的连接描述来定义的。

模块数据以 POBJ_ACC_UPLOAD 访问类型存储在指定文件中。请注意，当函数被调用时，路径名称中指定的所有目录必须已经存在。路径总是以 PVI 管理器的工作目录为基础。为了通过 PVI 远程连接传输模块数据，必须使用访问类型 POBJ_ACC_UPLOAD_STM。

模块数据以 POBJ_ACC_UPLOAD_STM 的二进制数据形式与响应数据一起传输给应用程序。在这种情况下，模块数据的长度与响应数据的长度相对应。

如果调用字符串中没有定义模块类型（未指定MT参数），那么正在读取的模块数据与PLC上已完成的BR模块相对应。如果调用字符串中定义了模块类型（指定了MT参数），那么有效载荷将从指定的BR模块中提取。然后，正在读取的模块数据只包括BR模块的有效载荷。

POBJ_ACC_UPLOAD的调用字符串的语法：

["]<Filename>["]  [MT=<ModuleType> ...]

或

FN=["]<Filename>["]  [MT=<ModuleType> ...]

带有FN参数项的变体不能与INA2000生产线一起使用。

POBJ_ACC_UPLOAD_STM的调用字符串的语法：

[MT=<ModuleType> ...]

在调用字符串中上传参数:

Example of access type POBJ_ACC_UPLOAD in C:

#include <PviCom.h>
static void WINAPI PviUploadResp (WPARAM wParam, LPARAM lParam)
{
    int ErrCode;
    ErrCode = PviReadResponse (wParam, NULL, 0);
    if (ErrCode != 0)
        printf ("Problem uploading module (PVI Error %d)", ErrCode);
}
void UploadRequ (DWORD hModule, char* szFileName)
{
    int  ErrCode;
    // start PVI upload service:
    ErrCode = PviReadArgumentRequest (hModule, POBJ_ACC_UPLOAD,
                                      szFileName, strlen (szFileName) + 1,
                                      PviUploadResp, SET_PVICALLBACK, 0);
    if (ErrCode != 0)
        printf ("Can't start upload service (PVI Error %d)", ErrCode);
}

Example of access type POBJ_ACC_UPLOAD_STM in C:

#include <PviCom.h>
static void WINAPI PviUploadResp (WPARAM wParam, LPARAM lParam)
{
    DWORD DataLen = 0;
    void* pData = NULL;
    int   ErrCode;
    char  szFilename[256];
    FILE* stream;
    PviGetResponseInfo (wParam, NULL, &DataLen, NULL, 0);
    if (DataLen != 0)
    {
        // create data buffer:
        pData = malloc (DataLen);
        if (pData == NULL)
        {
            printf ("Can't allocate memory");
            DataLen = 0;
        }
    }
    // read module data:
    ErrCode = PviReadResponse (wParam, pData, DataLen);
    if (ErrCode != 0)
        printf ("Problem uploading module (PVI Error %d)", ErrCode);
    else
    {
        // write module data to file:
        sprintf (szFilename, "C:\\List\\Module%u.bin", lParam);
        if ((stream = fopen (szFilename, "wb")) != NULL)
        {
            fwrite (pData, 1, DataLen, stream);
            fclose (stream);
        }
        else
            printf ("Can't create file %s", szFilename);
    }
    if (pData != NULL)
        free (pData);
}
void UploadRequ (DWORD hModule, DWORD ModuleNum)
{
    char* szParam;
    int   ErrCode;
    szParam = "";
    ErrCode = PviReadArgumentRequest (hModule, POBJ_ACC_UPLOAD_STM,
                                      szParam, strlen (szParam) + 1,
                                      PviUploadResp, SET_PVICALLBACK, ModuleNum);
    if (ErrCode != 0)
        printf ("Can't start upload service (PVI Error %d)", ErrCode);
}

POBJ_ACC_DOWNLOAD and POBJ_ACC_DOWNLOAD_STM access types

这些访问类型用于向PLC写入BR模块。为了执行下载程序，  必须使用PVICOM函数 PviWriteRequest 或PviXWriteRequest。应用程序要么收到下载的确认，要么收到响应数据的错误（PviWriteResponse 或PviXWriteResponse）。下载总是通过一个PVI CPU对象进行调节。

模块数据以 POBJ_ACC_DOWNLOAD 访问类型从指定文件读取。路径总是以 PVI 管理器的工作目录为基础。为了通过PVI远程连接传输模块数据，必须使用访问类型POBJ_ACC_UPLOAD_STM。

应用程序必须使用 POBJ_ACC_DOWNLOAD_STM 来传输模块数据和请求数据。为此必须创建一个数据块。这个数据块需要包括调用字符串和二进制模块数据，并且必须传输请求函数（PviWriteRequest 或 PviXWriteRequest）。数据块的大小以字节为单位，由调用字符串的长度+二进制模块数据的大小+1计算。ASCII格式的调用字符串（字符长度为1字节）必须始终位于数据块的开头，并以二进制0（空）结束。二进制模块数据必须在空字节之后开始。如果不需要调用字符串，那么应该在数据块中指定一个空字符串。

如果调用字符串中没有定义模块类型（未指定MT参数），那么模块数据需要包括一个完成的BR模块。如果调用字符串中定义了模块类型（指定了MT参数），那么模块数据将被视为来自BR模块的有效载荷。然后PVI从这个有效载荷和模块类型信息中生成一个完成的BR模块，并将其传送给PLC。

POBJ_ACC_DOWNLOAD的调用字符串的语法。

["]<Filename>["]  [LD=<MemoryType>]  [IM=<InstallationMode>]   [MT=<ModuleType> MN=<ModuleName> ...]

or

FN=["]<Filename>["]  [LD=<MemoryType>]  [IM=<InstallationMode>]   [MT=<ModuleType> MN=<ModuleName> ...]

带有FN参数项的变体不能与INA2000 line一起使用。

POBJ_ACC_DOWNLOAD_STM的调用字符串的语法。

[LD=<MemoryType>]  [IM=<InstallationMode>]   [MT=<ModuleType> MN=<ModuleName> ...]

在调用字符串中下载参数：

C语言中访问类型POBJ_ACC_DOWNLOAD的例子：

#include <PviCom.h>
static void WINAPI PviDownloadResp (WPARAM wParam, LPARAM lParam)
{
    int ErrCode;
    ErrCode = PviWriteResponse (wParam);
    if (ErrCode != 0)
        printf ("Problem downloading module (PVI Error %d)", ErrCode);
}
void DownloadRequ (DWORD hCpu, char* szFileName)
{
    char szParam[256];
    int  ErrCode;
    // start PVI download service:
    sprintf (szParam, "%s LD=Rom", szFileName);
    ErrCode = PviWriteRequest (hCpu, POBJ_ACC_DOWNLOAD,
                               szParam, strlen (szParam) + 1,
                               PviDownloadResp , SET_PVICALLBACK, 0);
    if (ErrCode != 0)
        printf ("Can't start download service (PVI Error %d)", ErrCode);
}

C语言中访问类型POBJ_ACC_DOWNLOAD_STM的例子：

#include <PviCom.h>
static void WINAPI PviDownloadResp (WPARAM wParam, LPARAM lParam)
{
    int ErrCode;
    ErrCode = PviWriteResponse (wParam);
    if (ErrCode != 0)
        printf ("Problem downloading module (PVI Error %d)", ErrCode);
}
void DownloadRequ (DWORD hCpu, char* szModuleName)
{
    char  szFilename[256];
    FILE* stream;
    long  FileLen;
    char  szParam[256];
    long  ParamLen;
    void* pRequData;
    int   ErrCode;
    // open file:
    sprintf (szFilename, "C:\\List\\%s.bin", szModuleName);
    if ((stream = fopen (szFilename, "rb")) != NULL)
    {
        // get file length:
        fseek (stream, 0, SEEK_END);
        FileLen = ftell (stream);
        // PVI download parameter:
        sprintf (szParam, "MT=BRT MN=%s LD=DRam", szModuleName);
        ParamLen = strlen (szParam) + 1;
        // create request data buffer:
        pRequData = malloc (ParamLen + FileLen);
        if (pRequData != NULL)
        {
            // prepare request data buffer:
            memcpy (pRequData, szParam, ParamLen);
            fseek (stream, 0, SEEK_SET);
            FileLen = fread ((BYTE*) pRequData + ParamLen, 1, FileLen, stream);
            // start PVI download service:
            ErrCode = PviWriteRequest (hCpu, POBJ_ACC_DOWNLOAD_STM,
                                       pRequData, ParamLen + FileLen,
                                       PviDownloadResp , SET_PVICALLBACK, 0);
            if (ErrCode != 0)
                printf ("Can't start download service (PVI Error %d)", ErrCode);
            free (pRequData);
        }
        else
           printf ("Can't allocate memory");
        fclose (stream);
    }
    else
        printf ("Can't open file %s", szFilename);
}

POBJ_ACC_MOD_DATA access type

这种访问类型可用于从BR日志数据模块中读取有效载荷数据，或向BR日志数据模块中写入一个条目。

Read access:

读取访问是通过PVICOM函数 PviReadArgumentRequest 或PviXReadArgumentRequest 启动的  。在调用字符串中指定的参数定义了要读取的日志数据。如果只能用默认参数进行读取访问，  也可以使用 PVICOM函数 PviReadRequest 。应用程序要么收到请求的日志数据，要么收到一个错误的响应数据（PviReadResponse 或PviXReadResponse）。

BR日志数据模块中的每个日志条目都有一个唯一的识别号（ID）。每一个新的日志条目，识别号都会增加一个。一旦数字计数器超限，识别号又从零开始。如果用识别号来找出差异，需要考虑到这个条件。

日志条目可以从某个识别号开始读取，也可以从最后一个（最新的）日志条目开始。也可以用 POBJ_ACC_STATUS 访问类型或 POBJ_EVENT_STATUS 事件类型来确定一个BR日志数据模块的最新日志条目的标识号 。

调用字符串的语法。

[DN=<Number>] [ID=<Identification>]

调用字符串中的参数。

响应字符串的语法。

响应数据由单个ASCII字符串组成。每个字符串都以一个空字符（"\0 "字符）结束。下一个字符串在空字符之后直接开始。

<AccessInformation> \0 <LogEntry1> \0 <LogEntry2> \0 ... \0 <LogEntryN> \0

第一个字符串包含一般的访问信息。

每个读取的日志条目都有三个字符串（<LogEntry>）。(<Information>)字符串包含关于日志条目的一般信息。接下来是信息文本的字符串(<ASCIILogData>)，然后是十六进制格式的二进制日志数据的字符串(<BinaryLogData>)。如果没有ASCII或二进制日志数据，那么就会列出一个空字符串（只有空字符）。

在响应数据中，第一个日志条目（<LogEntry1>）始终是读取的日志条目中最新的一个.

<Information> \0 <ASCIILogData> \0 <BinaryLogData>

信息字符串中的参数:

Write access:

通过PVICOM函数 PviWriteRequest 或PviXWriteRequest启动写访问  。每次写入时，都有一个条目被写入PLC的BR日志数据模块。

调用字符串的语法。

TXT=["]<Text>["] [LEV=<Level>] [E=<ErrorCode>]

调用字符串中的参数。

不可能写入二进制数据。

C语言中访问类型为POBJ_ACC_MOD_DATA的读取示例。

#include <PviCom.h>
//////////////////////////
// Parse PVI Parameter: //
//////////////////////////
static bool GetNextParam (const char** pszDesc,
                          char* szKeywordBf, int KeywordBfLen,
                          char* szParamBf,   int ParamBfLen)
{
    const char* szDesc = *pszDesc;
    char  EndChr = ' ';
    // skip space characters:
    while (*szDesc == ' ')
        szDesc++;
    // copy keyword:
    while (isalpha (*szDesc))
        if (--KeywordBfLen > 0)
            *(szKeywordBf++) = (char) toupper (*(szDesc++));
        else
            szDesc++;
    *szKeywordBf = '\0';
    if (*szDesc == PVICHR_ASSIGN)
    {
        // skip space characters:
        while (*(++szDesc) == ' ');
        // test parameter spezification:
        if (*szDesc == PVICHR_PARAM)
        {
            szDesc++;
            EndChr = PVICHR_PARAM;
        }
        // copy parameter:
        while ((*szDesc != '\0') && (*szDesc != EndChr))
            if (--ParamBfLen > 0)
                *(szParamBf++) = *(szDesc++);
            else
                szDesc++;
        *szParamBf = '\0';
        if (*szDesc == PVICHR_PARAM)
            szDesc++;
        *pszDesc = szDesc;
        return (TRUE);
    }
    *pszDesc = szDesc;
    return (FALSE);
}
bool FindParam (const char* szDesc,
                const char* szKeyword,
                char* szParamBf, int ParamBfLen)
{
    char szKeywordBf[16];
    while (GetNextParam (&szDesc, szKeywordBf, 16, szParamBf, ParamBfLen))
        if (strcmp (szKeywordBf, szKeyword) == 0)
            return (TRUE);
    return (FALSE);
}
////////////////////////////////
// Read logging informations: //
////////////////////////////////
typedef struct
{
    bool  bValid;
    DWORD Level;
    DWORD Error;
    char  Task[32+1];
    char  Text[80+1];
} T_LOGDATA;
static HANDLE hReadLogEvent;
// PVI callback function:
static void WINAPI ReadLogProc (WPARAM wParam, LPARAM lParam,
                                LPVOID pData, DWORD DataLen,
                                T_RESPONSE_INFO* pInfo)
{
    const char* szDesc = (const char*) pData;
    T_LOGDATA* pLogData = (T_LOGDATA*) lParam;
    char szParamBf[256];
    int Entries = 0;
    if (DataLen > 0)
        if (FindParam (szDesc, KWDESC_DATACNT, szParamBf, sizeof (szParamBf)))
            Entries = strtol (szParamBf, NULL, 10);
    while (Entries-- > 0)
    {
        // parse informations (string 1):
        szDesc += (strlen (szDesc) + 1);
        if (! FindParam (szDesc, "LEV", szParamBf, sizeof (szParamBf)))
            pLogData->Level = 0;
        else
            pLogData->Level = strtoul (szParamBf, NULL, 10);
        if (! FindParam (szDesc, "E", szParamBf, sizeof (szParamBf)))
            pLogData->Error = 0;
        else
            pLogData->Error = strtoul (szParamBf, NULL, 10);
        if (! FindParam (szDesc, "TN", pLogData->Task, sizeof (pLogData->Task)))
            strcpy (pLogData->Task, "???");
        // copy ASCII data (string 2):
        szDesc += (strlen (szDesc) + 1);
        strncpy (pLogData->Text, szDesc, (sizeof (pLogData->Text)-1));
        pLogData->Text[sizeof (pLogData->Text)-1] = '\0';
        // skip binary data (string 3):
        szDesc += (strlen (szDesc) + 1);
        pLogData->bValid = TRUE;
        pLogData++;
    }
    SetEvent (hReadLogEvent);
}
// Read logging informations from module object:
void ReadLog (DWORD LinkId,        // PVI module object handle
              T_LOGDATA* pLogData, // pointer to data buffer
              DWORD ReadCnt)       // entries to read
{
    char szArgParam[32];
    int i;
    // reset data buffer:
    for (i = 0; (i < ReadCnt); i++)
        pLogData[i].bValid = FALSE;
    hReadLogEvent = CreateEvent (NULL, FALSE, FALSE, NULL);
    sprintf (szArgParam, "%s=%u", KWDESC_DATACNT, ReadCnt);
    // request read service:
    if (PviReadArgumentRequest (LinkId, POBJ_ACC_MOD_DATA,
                                szArgParam, strlen (szArgParam), ReadLogProc,
                                SET_PVICALLBACK_DATA, (LPARAM) pLogData) == 0)
        WaitForSingleObject (hReadLogEvent, INFINITE);
    CloseHandle (hReadLogEvent);
}