博图V19的DB块，批量导入组态王

最新推荐文章于 2025-03-26 11:28:51 发布
最新推荐文章于 2025-03-26 11:28:51 发布
阅读量2.5k 收藏 27
点赞数 29
分类专栏： DCS 组态王 PLC 文章标签： 组态王 博图 电气自动化 DCS
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qujia121qu/article/details/143415846
版权

最近在使用组态王做一个厂区的DCS项目，plc选用西门子1500系列。一共用了3个1500，5个io站点。整个项目下来，点位大约有5000多个。把这5000多个点位，一个一个导入到组态王，无疑是一个非常非常非常难受的工作，不仅无聊，而且很容易出错。

一、首先，解释一下DB块。DB块是西门子S7系列的PLC，一个非常有特色的功能。大致功能就说允许用户自己定义一个内存区域，如DB1，DB2，DB3.....DB100，等等，每个DB块，可以由用户自定义一些变量或者结构体。

试想一下，当一个PLC控制了好几条产线，如果都把这写变量，全部写到一块，维护起来就比较麻烦，当然写到一块也不是不可以。按车间或者产线，分别写到不同的DB块上，维护起来更方便。下图是博图V19导出的一个DB块内容，PDF文件。可以看到里面DB块基本信息，和结构体定义。

一般情况下， 对同类型的设备控制，比如皮带，风机，等。会使用相同的结构体进行定义，如下图。

 1A-CVS01和1A-CBC02。这两个设备，都是一类型的设备（说白了电机控制都一样），所以两个设备用了相同的结构体定义，不同的是，设备名字不一样，以及结构体内部各个属性对应的内存地质不一样。

他们的控制方式，就是PLC编程是一样的。同时在DCS，就是组态王画面里面，两个设备控制方式也是一样的。这两个结构体怎么才能在DCS画面控制呢？答案就是给这两个结构体在组态王变量里面也定义一下。

二、接下来就是在组态王定义结构体和变量，因为这两个结构体结构一样，所以，只需要在组态王定义一个结构类型。定义两个变量。

结构体定义按下图的步骤。

结构定义完以后，就是定义变量的步骤，先点左侧的变量，再点新建。如下图。变量包含了若干个属性，见下面属性下拉框。每个属性，都需要定义一所在的plc和地址。完整DB5.62.0。表示，DB块5，里面的第62个字节的，第0位。最后一个只有bit类型需要，如果是int，real不需要。

通常情况下，一个厂区，几百个电机到上千个电机，任何设备要运转，都需要电机嘛。当然也不都是同一类型的设备，也会有变频电机，软起电机，也有可以正反转的电机等等，不同的设备类型，控制肯定不一样，那么结构体定义也就不一样。

所以通常一个厂区的控制系统会包含若干个PLC，若干个DB块，十几个结构体定义，成百上千个结构体变量。几千个基本变量。如下图，其中一个DB块已经定义到了3600个字节了，假设一个结构体20个字节，也就是180个结构体定义。1000多个变量定义了。

要给这些变量，一个一个手动编辑到组态王，确实是一个非常庞大的工程，耗时耗力，还非容易出错。所以决定做一个脚本，来简化变量（点位）导入。上一篇写了一个简单的DB块导入功能，见链接DCS项目调试踩坑记录_dcs调试记录表-CSDN博客

这个文章里比较简单，适合单个DB块，并且结构体都是固定死的。并不适合多个DB块，结构体不一样的情况。

三：DB块的pdf直接生成组态王的DB文件。整个过程分为两步，第一步，解析所有pdf文件，循环所有结构体定义，提取出其中不同的结构体定义。就是全部读取，然后给结构相同的去掉。然后给结构体定义文件保存为data.json。如下图。这个文件里面包含所有结构体定义，类型，plc里面变量名称，以及组态王里面变量名称。当然这一步也可以由开发人员自己定义，直接按下面格式编写就行。不过建议先用脚本跑一下，生成基本结构，然后开发人员再根据个人喜欢优化一下。

第二步，读取所有的pdf文件，以及上一步定义的结构文件，循环所有pdf，所有结构体和所有变量。根据上一步定义的结构体自动生成组态王DB文件的结构体定义，如下图，模板页和模板定义页。

然后，把所有结构体变量，按规则生成组态王结构变量，如下图：

最终生成完成以后，会生成一个test.xls文件。组态王工程管理页面，点击导入，即可完成所有变量导入。见下图：

四：代码分享。解析结构体代码如下

import pdfplumber
import os
import json
path='./'

arr=[]  #存储结构体的数组

#plc变量名称和组态王变量名称的映射关系，如果不定义这个，会直接使用plc里面的变量名称
varNames={'iinf':'状态字','balm':'报警','disysj':'运行时长','rdianliu_fankui':'电流','rpinlv_fankui':'频率','bstate_run_fw':'正向运行',
          'bstate_run_bw':'反向运行','bstate_fault':'故障','bstate_ready':'备妥','fengjiyunxing':'风机运行','chuchenqirukouyali':'入口压力',
          'panglu':'旁路运行','rm1dianliu_fankui':'M1电流','rm2dianliu_fankui':'M2电流','rrt_pos':'开度','fankuizhuansu':'转速',
          'bstate_open_done':'开到位','bstate_close_done':'关到位','zhengxiangxianwei':'正限位','fanxingxianwei':'负限位',
          'bstate_runz':'正向运行','bstate_runf':'反向运行','bstopallowed':'停止许可',
          'bstart':'启动','bstop':'停止','startallowed':'启动许可','stopallowed':'停止许可','rpinlv_geiding':'手动频率','rpinlv_geiding_a':'自动频率',
          'ma':'模式','breset':'复位','em':'急停','bopen':'手动开','bclose':'手动关','bstop':'手动停','bopen_a':'自动开','bclose_a':'自动关','bstop_a':'自动停',
          'zhengxiangqidong':'正向启动','fanxiangqidong':'反向启动','tingzhi':'停止',
          'bstartz':'正向启动','bstartf':'反向启动','bstartzallowed':'正向启动许可','bstartfallowed':'反向启动许可','wendu1':'温度1','wendu2':'温度2','wendu3':'温度3'
          }
#有时候plc定义变量名称会敲错，这个功能是给敲错的单词转换一下，例如chukou拼写成cukou，这里定义一下'cukou':'chukou'
wordTrans={'chuchanqirukouyali':'chuchenqirukouyali','zhaunsufankui':'fankuizhuansu','zhuansufankui':'fankuizhuansu','bstate_ready_1':'bstate_ready','bstate_fault_1':'bstate_fault'} #有些拼错的，使用这个转换一下



#获取变量在组态王的名称
def getVarName(s):
    if s in varNames.keys():
        return varNames[s]
    return s
#转换名称
def transName(nm):
 
    if nm in wordTrans.keys():
        print(nm+" ===== " +wordTrans[nm])
        return wordTrans[nm]
    return nm


#读取pdf里面的db块号
def getDBNum(pdf):                                  #解析DB块号
    tb=pdf.pages[0].extract_tables()[1]             #获取第一页
    name=tb[2][1]                                   #DB块注释
    dbNum=tb[2][3]                                  #DB块号
    print(name,dbNum)
    return 'DB' +dbNum


#比较两个结构体是否一样
#a1是数组，a2是map
def compStruct(a1,a2) :
    for nm in a1:
       if nm not in a2.keys(): 
           return False
    return True
    
#检查是否有重复的结构体，如果没有就增加上去
def checkStruct(s):
    #print('check struct',s)
    if s=={} :return #无效的结构体
    f = False
    l1=len(s['attrs'])
    for o in arr:
        l2= len ( o['attrs'].keys() )
        if l2!=l1 : continue                #属性数量不一样，直接跳过
        f=compStruct(s['attrs'],o['attrs'])
        if f == True: return                #找到一样的，不用再找了
         
    if f==False :
        arr.append(s)
    return
#----------------------------------------------------------------------------------------------------
def formatStr(s):
    s1=s.replace(' ','').replace('\r','').replace('\n','').lower()
    #print(s,s1)
    return s1
#读取pdf，并解析
def readPDF(fname):
    if fname.find('.pdf')==-1 :
        return
    pdf=pdfplumber.open(fname)
    DB=getDBNum(pdf)
    print("dbname",DB)
    plc=fname.split('_')[0]
    mode='只读'                                     #默认读写模式
    if fname.find("write") !=-1:
        mode='只写'                                 #只写
    ss={}                                           #临时结构体
    for pg in pdf.pages:                            #循环所有页
        data =pg.extract_table()                    #获取表格
        for r in data :                             #循环所有行
            #print(r)
            name=transName(formatStr(r[0]))                    #名称
            type=formatStr(r[1])                              #类型
            add=formatStr(r[2])                               #地址
            remark=formatStr(r[13])                            #备注信息
            # print(name,type,remark)
            if  name=='名称' or name=='w' or name.find('备用')!=-1:            #跳过无用的行
                #print('skip  '+name)
                continue
            #print(name,type)
            if type == 'struct' :                   #如果是Struct ,可能是结构体开头
                checkStruct(ss)                     #添加到结构体
                if name.find('static') ==-1:
                    ss={'name':remark,'DB':DB,'mode':mode,'attrs':{},'plc':plc}
                else:
                    ss={}                           #无效的结构体，直接跳过
                continue                            #结构体开头行

            if name.find('static')==-1 and 'attrs' in ss.keys():                    #如果是一般列，并且有属性
                ss['attrs'][name]={'type':type,'add':add,'name':getVarName(name)}    #添加到属性集合，var是组态王里面的名称
#-----------------------------------------------------------------------------------------------------------------------------------



# 遍历当前目录
for file_name in os.listdir(path):
    # 处理目录中的文件或子目录
    full_path = os.path.join(path, file_name)  # 拼接文件或子目录的完整路径
    if os.path.isfile(full_path):  # 判断是否为文件
        print("文件:", file_name)
        readPDF(file_name)
    elif os.path.isdir(full_path):  # 判断是否为子目录
        print("子目录:", file_name)
print('------------------------------------------------------------')
print(arr)
    
# 打开文件
with open("data.json", "w",encoding="utf-8") as file:
    # 使用json.dump将数据写入文件
    json.dump(arr, file,ensure_ascii=False)

生成组态王DB文件代码如下：

import pdfplumber
import os
import json
from openpyxl import Workbook   #用于写入excel,如果没有需要pip install openpyxl
from openpyxl import load_workbook


#创建组态王结构体声明    
def createStruct(dat):
    print("data length ",len(dat))
    startId=1                                                           #默认从编号1开始
    st1 = wb.create_sheet("模板页")                                         #结构体变量模板
    st2 = wb.create_sheet("模板定义页")
    st1.append(['说明：本页为数据词典中所有模板定义  请不要编辑此行'])
    varId=21                                                      #变量id,21开始
    for o in dat:
        #print(o)
        st1.append(['[模板]','模板ID','模板名称','模板使用记数','注释'])    #结构体行
        st1.append(['',startId,o['name'],-2,''])                               #结构体名称
        st1.append(['','[成员]',	'成员ID','成员名称','成员类型'])         #结构体开始
        id=1                                                                #属性开始
        startId=startId+1
        
        for k in o['attrs'].keys() :
            o['attrs'][k]['varid']=varId       
            tp=o['attrs'][k]['type']                                  #变量id
            varId=varId+1                                               #增加一个
            st1.append(['','',id,o['attrs'][k]['name'],types[tp]])
            id=id+1
    ###下面是输出模板定义地方
    st2.append(['说明：本页为数据词典中所有基本变量  请不要编辑此行'])
    st2.append(['[内存整型]'])
    st2.append(['变量ID','变量名','变量使用记数','变化灵敏度','初始值','最小值','最大值','是否保存值','是否保存参数','报警组','优先级','低低限值','低低报警文本','低限值','低报警文本','高限值','高报警文本','高高限值','高高报警文本','越限死区','报警延时','变化率%','变化率单位','目标值','小偏差','大偏差','偏差死区','扩展域1','扩展域2','历史记录方式(不记录/变化记录/定时记录)','历史记录变化灵敏度','记录间隔(分)','是否生成操作事件','安全区','注释','变量签名属性'])
    #st2.append(['变量ID','变量名','变量使用记数','变化灵敏度','初始值','最小值','最大值','是否保存值','是否保存参数','报警组','优先级','低低限值','低低报警文本','低限值','低报警文本','高限值','高报警文本','高高限值','高高报警文本','越限死区','报警延时','变化率%','变化率单位','目标值','小偏差','大偏差','偏差死区','扩展域1','扩展域2','历史记录方式(不记录/变化记录/定时记录)','历史记录变化灵敏度','记录间隔(分)','是否生成操作事件','安全区','注释','变量签名属性'])
    st2.append([])
    st2.append(['[内存实型]'])
    st2.append(['变量ID','变量名','变量使用记数','变化灵敏度','初始值','最小值','最大值','是否保存值','是否保存参数','报警组','优先级','低低限值','低低报警文本','低限值','低报警文本','高限值','高报警文本','高高限值','高高报警文本','越限死区','报警延时','变化率%','变化率单位','目标值','小偏差','大偏差','偏差死区','扩展域1','扩展域2','历史记录方式(不记录/变化记录/定时记录)','历史记录变化灵敏度','记录间隔(分)','是否生成操作事件','安全区','注释','变量签名属性'])
    st2.append([])
    st2.append(['[内存离散]'])
    st2.append(['变量ID','变量名','变量使用记数','初始值','是否保存值','是否保存参数','报警组','优先级','是否产生报警','报警类型(开/关/变位)','关报警文本','开报警文本','开到关报警文本','关到开报警文本','扩展域1','扩展域2','历史记录方式(不记录/变化记录/定时记录)','记录间隔(分)','是否生成操作事件','安全区','注释','变量签名属性'])
    st2.append([])
    st2.append(['[内存字符串]'])
    st2.append(['变量ID','变量名','变量使用记数','初始字符串(<127字节)','是否保存值','是否保存参数','安全区','注释','变量签名属性'])
    st2.append([])

    st2.append(['[IO整型]'])
    st2.append(['变量ID','变量名','变量使用记数','变化灵敏度','初始值','最小值','最大值','最小原始值','最大原始值','是否保存值','是否保存参数','设备名','寄存器名称','数据类型','读写属性','采集频率(毫秒)','转换方式','高级转换方式','线性表名称','最小累计值','最大累计值','是否允许DDE访问','报警组','优先级','低低限值','低低报警文本','低限值','低报警文本','高限值','高报警文本','高高限值','高高报警文本','越限死区','报警延时','变化率%','变化率单位','目标值','小偏差','大偏差','偏差死区','扩展域1','扩展域2','历史记录方式(不记录/变化记录/定时记录/每次采集记录)','历史记录变化灵敏度','记录间隔(分)','是否生成操作事件','安全区','注释','变量签名属性'])
    for o in dat:
        print(o)
        sname=o['name']
        db=o['DB']+"."

        for k in o['attrs'].keys():
            tp=o['attrs'][k]['type']
            if tp=='dint' :
                name=o['attrs'][k]['name']
                id=o['attrs'][k]['varid']
                add=o['attrs'][k]['add'].split('.')[0]
                add=db+add
                st2.append([id,sname+"."+name,-2,0,0,-10000,999999999,-1000,999999999,'否','否',o['plc'],add,'LONG',o['mode'],1000,'线性','无','','','','否','',1,'','','','','','','','','','','','','','','','','','','不记录','','','否','无','','',144])
                # st2.append([id,	sname+"."+name,0,0,0,-10000,999999999,-10000,999999999,'否','否',o['plc'],add,'LONG',o['mode'],1000,'线性','无','','','','否','',1,'','','','','','','','','','','','','','','','','','','不记录','','','否','无','',144,''])
            if tp=='int' :
                name=o['attrs'][k]['name']
                id=o['attrs'][k]['varid']
                add=o['attrs'][k]['add'].split('.')[0]
                add=db+add
                st2.append([id,sname+"."+name,-2,0,0,-10000,999999999,-1000,999999999,'否','否',o['plc'],add,'SHORT',o['mode'],1000,'线性','无','','','','否','',1,'','','','','','','','','','','','','','','','','','','不记录','','','否','无','','',144])

                #st2.append([id,	sname+"."+name,0,0,0,-10000,999999999,-10000,999999999,'否','否',o['plc'],add,'SHORT',o['mode'],1000,'线性','无','','','','否','',1,'','','','','','','','','','','','','','','','','','','不记录','','','否','无','',144,''])

    st2.append([])
    st2.append(['[IO实型]'])
    st2.append(['变量ID','变量名','变量使用记数','变化灵敏度','初始值','最小值','最大值','最小原始值','最大原始值','是否保存值','是否保存参数','设备名','寄存器名称','数据类型','读写属性','采集频率(毫秒)','转换方式','高级转换方式','线性表名称','最小累计值','最大累计值','是否允许DDE访问','报警组','优先级','低低限值','低低报警文本','低限值','低报警文本','高限值','高报警文本','高高限值','高高报警文本','越限死区','报警延时','变化率%','变化率单位','目标值','小偏差','大偏差','偏差死区','扩展域1','扩展域2','历史记录方式(不记录/变化记录/定时记录/每次采集记录)','历史记录变化灵敏度','记录间隔(分)','是否生成操作事件','安全区','注释','变量签名属性'])

    for o in dat:
        sname=o['name']
        db=o['DB']+"."

        for k in o['attrs'].keys():
            tp=o['attrs'][k]['type']
            if tp=='real' :
                name=o['attrs'][k]['name']
                id=o['attrs'][k]['varid']
                add=o['attrs'][k]['add'].split('.')[0]
                add=db+add
                st2.append([id,sname+"."+name,-2,0,0,-10000,999999999,-1000,999999999,'否','否',o['plc'],add,'FLOAT',o['mode'],1000,'线性','无','','','','否','',1,'','','','','','','','','','','','','','','','','','','不记录','','','否','无','','',144])

                #st2.append([id,	sname+"."+name,0,0,0,-10000,999999999,-10000,999999999,'否','否',o['plc'],add,'FLOAT',o['mode'],1000,'线性','无','','','','否','',1,'','','','','','','','','','','','','','','','','','','不记录','','','否','无','',144,''])
            
    st2.append([])
    st2.append(['[IO离散]'])
    st2.append(['变量ID','变量名','变量使用记数','初始值','是否保存值','是否保存参数','设备名','寄存器名称','数据类型','读写属性','采集频率(毫秒)','是否允许DDE访问','报警组','优先级','是否产生报警','报警类型(开/关/变位)','关报警文本','开报警文本','开到关报警文本','关到开报警文本','扩展域1','扩展域2','历史记录方式(不记录/变化记录/定时记录/每次采集记录)','记录间隔(分)','是否生成操作事件','安全区','注释','变量签名属性'])
    #st2.append(['变量ID','变量名','变量使用记数','初始值','是否保存值','是否保存参数','报警组','优先级','是否产生报警','报警类型(开/关/变位)','关报警文本','开报警文本','开到关报警文本','关到开报警文本','扩展域1','扩展域2','历史记录方式(不记录/变化记录/定时记录)','记录间隔(分)','是否生成操作事件','安全区','注释','变量签名属性'])
    for o in dat:
        sname=o['name']
        db=o['DB']+"."

        for k in o['attrs'].keys():
            tp=o['attrs'][k]['type']
            if tp=='bool' :
                name=o['attrs'][k]['name']
                id=o['attrs'][k]['varid']
                add=db+o['attrs'][k]['add']
                #st2.append([id,sname+"."+name,0,'关','否','否',o['plc'],add,'Bit',o['mode'],1000,'否','',1,'否','','','','','','','','不记录','','否','无','',144,''])
                st2.append([id,sname+"."+name,-2,'关','否','否',o['plc'],add,'Bit',o['mode'],1000,'否','',1,'否','','','','','','','','不记录','','否','无','',144])
    st2.append([])
    st2.append(['[IO字符串]'])
    st2.append(['变量ID','变量名','变量使用记数','初始字符串(<127字节)','是否保存值','是否保存参数','设备名','寄存器名称','数据类型','读写属性','采集频率(毫秒)','是否允许DDE访问','安全区','注释','变量签名属性'])

    st2.append([])

    return varId
#------------------------------------------------------------------------------------------------------


#比较两个结构体是否一样
def compStruct(a1,a2) :
    for nm in a1['attrs']:
       if nm['name'] not in a2['attrs'].keys(): 
           return False
    return True
    
#匹配结构体定义
def getStruct(obj):
    #print('get struct',obj)
    
    if 'attrs' not in obj.keys(): return None
    l1 = len(obj['attrs'])                                      #当前结构体属性数量
    for o in arr:
        l2=len(o['attrs'].keys())                              #目标结构体属性数量
        #print("@@",obj['name'],o['name'],l1,l2)
        if l1!=l2 : continue                                    #数量不匹配直接跳过
        if compStruct(obj,o) :                                 #如果比较成功了
            return o
         
    return None
#--------------------------------------------------------------------
# 解析对象的属性到已经定义的结构名称
# obj 是要转换的对象
# s 是已经定义的结构体
def transStruct(obj,s):
    for o in obj['attrs']:
        o['var']=s['attrs'][o['name']]['name']    #结构体变量名称
    return
#------------------------------------------------------------
#转换特定的名称，防止DB块里面拼写错误
def transName(nm):
    if nm in wordTrans.keys():
        return wordTrans[nm]
    return nm.replace('-','_').replace('#','_')
#----------------------------------------------------------
def formatStr(s):
    s1=s.replace(' ','').replace('\r','').replace('\n','').lower()
    #print(s,s1)
    return s1
#解析PDF
def readPDF(fname):
    if fname.find('.pdf')==-1 :
        return
    plc=fname.split("_")[0]
    pdf=pdfplumber.open(fname)
    DB=getDBNum(pdf)
    print("dbname",DB)                              #结构体名称
    ss={}                                           #临时结构体
    for pg in pdf.pages:                            #循环所有页
        data =pg.extract_table()                    #获取表格
        for r in data :                             #循环所有行
            #print(r)
            name=transName(formatStr(r[0]))                    #名称,转换后的
            type=formatStr(r[1])                               #类型
            add=formatStr(r[2])                               #地址
            remark=r[13][0:35]                            #备注信息
            # print(name,type,remark)
            if name=='名称' or name=='w' or name.find('备用')!=-1:            #跳过无用的行
                #print('skip  '+name)
                continue
            
            #print(name,type)
            if type == 'struct':                    #如果是Struct ,可能是结构体开头
                structDef=getStruct(ss)             #寻找匹配的结构体
                #print("structDef",structDef)
                if  structDef != None :
                    #print(" found struct",ss)
                    transStruct(ss,structDef)       #转换到定义的名称
                    ss['struct']=structDef['name']  #结构体变量名称
                    ss['mode']=structDef['mode']    #读写属性
                    objects.append(ss)              #添加到对象里面
                else :
                    others.append(ss)               #添加到另外一个列表
                if name.find('static')!=-1:         #没有名字的结构体，跳过
                    ss={}
                else :
                    ss={'name':name,'remark':remark,'DB':DB,'plc':plc,'attrs':[]} #重置当前结构体
                continue                            #结构体开头行

            if name.find('static')==-1 and  'attrs' in ss.keys():                #如果存在这个属性，认为是一个合理的结构体
                ss['attrs'].append({'name':name,'type':type,'add':add,'remark':remark}) #增加一个属性
    return                                          #解析PDF结束
#-----------------------------------------------------------------------------------------------------------
#创建结构体变量
def createVar(objs,varId):
    print("struct len ",len(objs))
    startId=1   
    st1=wb.create_sheet("结构变量页")
    st2=wb.create_sheet("基本变量页")
    st1.append(['说明：本页为数据词典中所有结构变量  请不要编辑此行'])
    st2.append(['说明：本页为数据词典中所有基本变量  请不要编辑此行'])
    st2.append(['[内存整型]'])
    st2.append(['变量ID','变量名','变量使用记数','变化灵敏度','初始值','最小值','最大值','是否保存值','是否保存参数','报警组','优先级','低低限值','低低报警文本','低限值','低报警文本','高限值','高报警文本','高高限值','高高报警文本','越限死区','报警延时','变化率%','变化率单位','目标值','小偏差','大偏差','偏差死区','扩展域1','扩展域2','历史记录方式(不记录/变化记录/定时记录)','历史记录变化灵敏度','记录间隔(分)','是否生成操作事件','安全区','注释','变量签名属性'])
    st2.append([''])
    st2.append(['[内存实型]'])
    st2.append(['变量ID','变量名','变量使用记数','变化灵敏度','初始值','最小值','最大值','是否保存值','是否保存参数','报警组','优先级','低低限值','低低报警文本','低限值','低报警文本','高限值','高报警文本','高高限值','高高报警文本','越限死区','报警延时','变化率%','变化率单位','目标值','小偏差','大偏差','偏差死区','扩展域1','扩展域2','历史记录方式(不记录/变化记录/定时记录)','历史记录变化灵敏度','记录间隔(分)','是否生成操作事件','安全区','注释','变量签名属性'])
    st2.append([''])
    st2.append(['[内存离散]'])
    st2.append(['变量ID','变量名','变量使用记数','初始值','是否保存值','是否保存参数','报警组','优先级','是否产生报警','报警类型(开/关/变位)','关报警文本','开报警文本','开到关报警文本','关到开报警文本','扩展域1','扩展域2','历史记录方式(不记录/变化记录/定时记录)','记录间隔(分)','是否生成操作事件','安全区','注释','变量签名属性'])
    st2.append([''])
    st2.append(['[内存字符串]'])
    st2.append(['变量ID','变量名','变量使用记数','初始字符串(<127字节)','是否保存值','是否保存参数','安全区','注释','变量签名属性'])
    st2.append([''])
    for o in objs:                                                                  #循环输出结构体变量页
        m='R'
        if o['mode']=='只写':m="W"
        sname=m+o['name'].upper()
        st1.append(['[结构变量]','变量ID','变量名','变量类型','变量使用记数','注释'])   #列
        st1.append(['',startId,sname,o['struct'],0,o['remark']])                #结构体
        st1.append(['','[成员]','成员名称','成员基本变量ID'])		              #成员变量列
        startId=startId+1
        sname=sname+"."
        for a in o['attrs']:
            a['varid']=varId
            st1.append(['','',sname+a['var'].upper(),varId])		              #成员变量列
            varId=varId+1                                                     #变量id增加1个
    #################################################################
    st2.append(['[IO整型]'])
    st2.append(['变量ID','变量名','变量使用记数','变化灵敏度','初始值','最小值','最大值','是否保存值','是否保存参数','报警组','优先级','低低限值','低低报警文本','低限值','低报警文本','高限值','高报警文本','高高限值','高高报警文本','越限死区','报警延时','变化率%','变化率单位','目标值','小偏差','大偏差','偏差死区','扩展域1','扩展域2','历史记录方式(不记录/变化记录/定时记录)','历史记录变化灵敏度','记录间隔(分)','是否生成操作事件','安全区','注释','变量签名属性'])

    for o in objs:                                                            #循环输出整数
        plc=o['plc']
        DB=o['DB']+"."
        struct=o['struct']
        mode=o['mode']
        m='R'
        if mode=='只写':m="W"
        sname=m+o['name'].upper()+"."
        for  a in o['attrs']:
             if a['type'] == 'int' or a['type']=='dint' :
                add=DB+a['add'].split(".")[0]
                tp='SHORT'
                if a['type']=='dint' : tp='LONG'
                st2.append([a['varid'],sname+a['var'].upper(),0,0,0,-10000,999999999,-10000,999999999,'否','否',plc,add,tp,mode,1000,'线性','无','','','','否','',1,'','','','','','','','','','','','','','','','','','','不记录','','','否','无',a['remark'],144,''])

    st2.append([''])
    #################################################################
    st2.append(['[IO实型]'])
    st2.append(['变量ID','变量名','变量使用记数','变化灵敏度','初始值','最小值','最大值','是否保存值','是否保存参数','报警组','优先级','低低限值','低低报警文本','低限值','低报警文本','高限值','高报警文本','高高限值','高高报警文本','越限死区','报警延时','变化率%','变化率单位','目标值','小偏差','大偏差','偏差死区','扩展域1','扩展域2','历史记录方式(不记录/变化记录/定时记录)','历史记录变化灵敏度','记录间隔(分)','是否生成操作事件','安全区','注释','变量签名属性'])

    for o in objs:                                                            #循环输出整数
        plc=o['plc']
        DB=o['DB']+"."
        struct=o['struct']
        mode=o['mode']
        m='R'
        if mode=='只写':m="W"
        sname=m+o['name'].upper()+"."
        for  a in o['attrs']:
             if a['type'] == 'real':
                add=DB+a['add'].split(".")[0]
                tp='FLOAT'
                st2.append([a['varid'],sname+a['var'].upper(),0,0,0,-10000,999999999,-10000,999999999,'否','否',plc,add,tp,mode,1000,'线性','无','','','','否','',1,'','','','','','','','','','','','','','','','','','','不记录','','','否','无',a['remark'],144,''])
    
    st2.append([''])
    #################################################################
    st2.append(['[IO离散]'])
    st2.append(['变量ID','变量名','变量使用记数','初始字符串(<127字节)','是否保存值','是否保存参数','安全区','注释','变量签名属性'])
    for o in objs:                                                            #循环输出整数
        plc=o['plc']
        DB=o['DB']+"."
        struct=o['struct']
        mode=o['mode']
        m='R'
        if mode=='只写':m="W"
        sname=m+o['name'].upper()+"."
        for  a in o['attrs']:
             if a['type'] == 'bool' :
                add=DB+a['add']     
                st2.append([a['varid'],sname+a['var'].upper(),0,'关','否','否',plc,add,'Bit',mode,1000,'否','',1,'否','','','','','','','','不记录','','否','无',a['remark'],144,''])
    st2.append([''])
    return

#---------------------------------------------------------------

path='./'

arr=[]      #存储定义好的结构体
objects=[]  #所有数据
others=[]   #没有写进去的
wb =Workbook()                              #用于导出excel文件
types={'bool':'离散型','int':'整型','dint':'整型','real':'实型'}

wordTrans={'chuchanqirukouyali':'chuchenqirukouyali','zhaunsufankui':'fankuizhuansu','zhuansufankui':'fankuizhuansu','bstate_ready_1':'bstate_ready','bstate_fault_1':'bstate_fault'} #有些拼错的，使用这个转换一下



def getDBNum(pdf):                                  #解析DB块号
    tb=pdf.pages[0].extract_tables()[1]             #获取第一页
    name=tb[2][1]                                   #DB块注释
    dbNum=tb[2][3]                                  #DB块号
    print(name,dbNum)
    return 'DB' +dbNum
 
# 打开JSON文件
with open('data.json', 'r',encoding='utf-8') as f:
    # 读取文件内容
    arr = json.load(f)
    
# 创建结构体定义
varId=createStruct(arr)


# 遍历当前目录
for file_name in os.listdir(path):
    # 处理目录中的文件或子目录
    full_path = os.path.join(path, file_name)  # 拼接文件或子目录的完整路径
    if os.path.isfile(full_path):  # 判断是否为文件
        print("文件:", file_name)
        readPDF(file_name)
        #print(objects)
    elif os.path.isdir(full_path):  # 判断是否为子目录
        print("子目录:", file_name)
#创建变量定义
createVar(objects,varId)
wb.save('test.xls')  

print(others)

西门子博途数据块（DB块）快速导入导出
RXXW_Dor的博客
11-17 1万+
有些人可能会想用查表法计算CRC校验码， 查表法效率和速度都很高，但是空间换时间，让你用几秒钟时间，把一张完整的表存入博途里，就算了你单身20年的手速估计也完成不了，想要几秒钟完成也不是不可以，就是导入别人的源文件，拿来主义当然块，继续上图： 已经导出的源文件.. 我们可以随便找个文本编辑器打开这个源文件，看看文件内容： 博途里的每一个数据块其实都是在一个大的结构变量里的,下面直接上图看看数据块是怎么导出导入的： ...
DB块中变量导入到wincc中
01-10
### DB块中变量导入到WinCC中的详细指南 在工业自动化领域，西门子的Step 7和WinCC是两款非常重要的软件工具。Step 7主要用于编程和配置PLC（可编程逻辑控制器），而WinCC则是一种人机界面（HMI）系统，用于监控和...
组态王变量批量导入工具
qq_42249276的博客
07-26 1410
组态王虽然可以用 Excel 导入，但是对格式有严格要求，如果直接编辑，非常容易出错,此软件可以解决这个痛点.
博图DB块中的变量导入MCGS昆仑通态触摸屏
tomcat_ww的博客
08-18 1万+
8，打开MCGS触摸屏选择你的设备，会弹出新的对话框，再进行选择“点击按钮设置”，点击标签导入对话框的“预览”按钮，找到你要添加的DB块变量(块号出错误的可以看一下“DB块文件导入说明”)2，找到防护安全——连接机制——允许来自远程对象的PUT/GET通讯访问√。9，有些可能会出现“连接变量”一栏空白，这个需要你手动添加一下。3，找到你要导入触摸屏里的DB块变量，鼠标右键——属性。6找到要添加的DB块鼠标右键——从块生成源——仅所选块。7，保存后出现(对应的DB块名称).db文件。
博图PLC程序的两种导入导出方法
最新发布
dsq75315的博客
03-26 2747
摘要：介绍两种博图PLC程序导入导出方法
组态王变量导入导出补丁
01-24
组态王7.5SP2建立结构变量后，导出修改会导致组态王运行崩溃，使用本补丁替换C盘安装目录文件后即可正常，组态王官方出版请放心使用
博图V17 DB块 导入 昆仑通态屏
AutoYoung2021的博客
03-15 7631
选择对应DB块后鼠标右击，选择 从块生成源→仅所选块。弹出对话框后，选择文件的保存路径和文件的命名，文件的命名必须遵循图片所示的规则。（1）查看DB块的属性，必须是“非优化的块访问”。记住DB块的编号（每个DB块编号唯一）（3）打开mcgsPro组态软件准备导入。边记录，一边学习，初学者日记。
S7中UDT、DB块如何导入博途V17教程
qq_40859404的博客
01-11 4429
S7的UDT、DB导入博途教材
昆仑通态触摸屏和博图DB块导入
qq_54233653的博客
07-08 1759
选择对应DB块后鼠标右击，选择 从块生成源→仅所选块。弹出对话框后，选择文件的保存路径和文件的命名，文件的命名必须遵循图片所示的规则。1.查看DB块的属性，必须是“非优化的块访问”。记住DB块的编号（每个DB块编号唯一）3.打开mcgsPro组态软件准备导入。
博图V19水处理项目实例1500PLC程序
11-03
博图V19作为西门子PLC的编程软件，提供了一个强大的平台，用于创建、测试和部署控制逻辑。 针对水处理项目，PLC需要控制的环节包括但不限于原水的抽取、沉淀、过滤、消毒、分配等多个过程。每一个环节都需要精确的...
博图V19支持包，支持伺服 esp200
12-03
博图V19支持包是西门子公司发布的一款针对其自动化产品TIA Portal V19版本的升级支持软件包。该支持包的主要功能是提供固件更新服务，特别是针对伺服控制产品的ESP200系列，确保设备能够运行在最新的固件版本上，...
组态王下拉式组合框.zip_areax8y_spokenimj_下拉式组合框_组态王_组态王tagname.db
07-14
组态王下拉式组合框使用样例，包含了使用的说明，以及控件存放位置，可以直接运行
组态王与SQL连接.zip_KRK_sql server_组态王_组态王tagname.db_连接
07-13
组态王和SQL server 连接，能进行数据库连接，数据库数据查询，数据库数据插入等等
组态王数据库-读-写-查询
05-23
密码1 简单的组态读取数写数据库的小案例啊啊啊啊啊啊
博图塔灯的功能块
11-26
博图塔灯的功能块，便于处理塔灯等的应用。。
TIA博途中使用DB数据块的快照功能实现数据传递的具体方法.docx
11-06
TIA博途中使用DB数据块的快照功能实现数据传递的具体方法
MCGS昆仑通态触摸屏导入博途自定义数据类型和DB块变量的具体方法演示.docx
06-05
本文将详细介绍如何在MCGS中导入博途中的自定义数据类型和DB块变量，以实现两者之间的高效通信。 首先，我们需要在TIA博途中创建一个新的项目。在项目中定义所需的自定义数据类型，这是为了满足特定控制任务的需要...
优化的 DB 块和标准 DB 块有哪些区别_DB块_between_salty5w_优化DB块_
09-30
在数据库管理领域，DB（Database）块是存储数据的基本单元，它们构成了数据库的物理结构。在Oracle数据库系统中，DB块的设计对数据库性能有着至关重要的影响。本文将深入探讨优化的DB块与标准DB块之间的差异，以帮助...
【scl】博图程序的导入和导出
热门推荐
weixin_67913271的博客
02-19 2万+
本篇文章主要写一下关于博图文件的导入和导出，具体要怎么样才能将写好的程序或者块移植到其他地方，下面我们一起来看！一、程序块的导入和导出程序块包含FC块，FB块；注意：需要是SCL语言编写的程序块才可以导出源文件！导出步骤： 找到要导出的程序块---->右键单击----->选择从块生成源---->可以选着一个块或关联块---->将文件保存---->保存后可以在另一个项目导入（也可以发送给其他人）
博图v19
03-25
<think>好的，用户想了解博图V19的相关信息，包括软件版本、功能介绍和下载方式。首先，我需要确认博图V19的全称是西门子的TIA Portal V19，全称是Totally Integrated Automation Portal。接下来，用户可能想知道版本的具体更新内容，比如新增的功能或改进的部分。然后，关于功能介绍，需要涵盖工程效率提升、硬件支持扩展、软件功能增强、数字化集成以及安全功能等方面。下载方式方面，用户可能需要官方途径的信息，比如官网或授权经销商，同时提醒用户注意版权和系统兼容性问题。另外，用户可能还关心安装步骤，但根据引用内容，安装过程需要管理员权限，但详细步骤可能需要参考官方文档。需要确保回答结构清晰，分点列出，并且符合用户的中文需求。最后，生成的相关问题要围绕版本区别、硬件支持、系统要求、更新内容以及兼容性展开，帮助用户进一步了解。</think>### 博图 TIA Portal V19 相关信息 #### 一、软件版本与核心特性 1. **版本定位** 博图 V19（TIA Portal V19）是西门子工业自动化软件平台的迭代版本，属于中短期支持版本（STS），适用于需要平衡稳定性和新功能的用户。其核心升级包括： - 工程效率优化：项目模板支持多设备批量配置，缩短开发周期[^1] - 硬件支持扩展：新增对SIMATIC S7-1500系列新型CPU模块（如CPU 1516-3 PN/DP）的支持 - 软件功能增强：STEP 7 Professional V19 新增数据类型自动校验功能 2. **版本对比** | 特性 | V18 | V19 | |---------------------|-------------------|-----------------------| | 硬件支持 | S7-1200 V4.5 | S7-1200 V4.6 | | 工程模板 | 单设备模板 | 多设备协同模板 | | 安全功能 | 基础访问控制 | 增强型数字证书管理 | #### 二、核心功能模块 1. **STEP 7 Professional** - 新增基于AI的代码冲突检测工具 - 支持Profinet设备拓扑自动校验 - 增强型在线诊断功能（带时间戳的报警记录） 2. **WinCC Professional** - 面板设备支持4K分辨率显示 - 新增工业大数据分析模块（需配合MindSphere使用） - HMI模板库增加20+行业专用模板 3. **StartDrive** - 新增驱动参数云同步功能 - 支持SINAMICS G120X系列变频器一键配置 - 驱动故障树分析（FTA）工具升级[^1] #### 三、系统要求与兼容性 1. **硬件配置** - 最低配置：Intel i5-6500/16GB RAM/500GB SSD - 推荐配置：Intel i7-10700/32GB RAM/1TB NVMe SSD - 图形卡需支持DirectX 11（建议NVIDIA Quadro P2200） 2. **操作系统支持** | Windows版本 | 支持状态 | |--------------------|-------------------| | Windows 10 20H2 | 完全支持 | | Windows 11 21H2 | 有限支持（需补丁）| | Windows Server 2019| 企业版专用 | #### 四、获取途径 1. **官方渠道** - 西门子工业支持中心（需有效服务合同） - 授权经销商提供的媒体套件 2. **技术资源** - 西门子工业支持文档库包含超过200个V19专用技术手册 - 官方提供V18到V19的项目迁移工具（需单独下载）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值