def reconnect(self):
""" reconnect """
log.info("reconnect...")
info = ""
if self._lock.locked() == False:
#self.reconnecting = 1
self._lock.acquire()
try:
#self.opc = OpenOPC.open_client(self.host, self.port)
#self.opc.connect(self.provider, self.host)
if self.mode == 'dcom':
self.opc = OpenOPC.client("Graybox.OPC.DAWrapper", self.host)
else:
self.opc = OpenOPC.open_client(self.host, self.port)
info = self.opc.servers()
info = info + self.opc.info()
for group in self.groups:
self.create_group(group, self.groups[group])
#self.reconnecting = 0
except Exception, e:
# release the lock
info = "excetp: %s"%(e.message)
log.error(info)
log.error(traceback.format_exc())
#self.reconnecting = 0
finally:
def connect(self):
print "attempting OPC connection to", self.opc_name
self.opc = OpenOPC.client()
self.opc.connect(self.opc_name, self.opc_host)
props = self.opc.properties(self.points.keys())
print "loaded", len(props), "properties"
points = {}
for point, pid, key, val in props:
name = self.make_path(point)
if not name in points:
points[name] = self.points[point]
if not exclude(key):
points[name]["OpcDA/" + key] = str(val)
# try to make some sense out of the metadata
for name, meta in points.iteritems():
unit = str(meta.get("OpcDA/" + self.unit_tag, "None"))
dtype = meta.get("OpcDA/Item Canonical DataType", None)
if not dtype:
print "no datatype tag in", name
continue
if dtype.startswith("VT_R"):
dtype = "double"
elif dtype.startswith("VT_U") or dtype.startswith("VT_I"):
dtype = "long"
else:
print "skipping", name, "since cannot find data type"
continue
if not self.get_timeseries(name):
self.add_timeseries(name, unit, data_type=dtype)
self.set_metadata(name, points[name])
vals = self.opc.read(self.points.keys(), group="smap-points-group")
def connect(): ''' return 2 connection objects: "opc" and "cursor" ''' # PLC plc='Matrikon.OPC.Simulation.1' try: print "+------------+" print "| | - Connecting to PLC...", opc=OpenOPC.client() opc.connect(plc) print " Success!" except: print "Error connecting to OPC" print "| Connecting |" # MYSQL server='127.0.0.1' user='******' pasw='' dbName='mbr' try: print "| | - Connecting to MySQL...", db=MySQLdb.connect(server,user,pasw,dbName) cursor = db.cursor() print " Success!" except: print "Error connecting to MySQL" print "+------------+" return [opc,cursor]
def connect():
''' return 2 connection objects: "opc" and "cursor" '''
# PLC
plc = 'OMRON.OpenDataServer.1'
try:
print "+------------+"
print "| | - Connecting to PLC...",
opc = OpenOPC.client()
opc.connect(plc)
print " Success!"
except:
print "Error connecting to OPC"
print "| Connecting |"
# MYSQL
server = '127.0.0.1'
user = '******'
pasw = ''
dbName = 'mbr'
try:
print "| | - Connecting to MySQL...",
db = MySQLdb.connect(server, user, pasw, dbName)
cursor = db.cursor()
print " Success!"
except:
print "Error connecting to MySQL"
print "+------------+"
return [opc, cursor]
def subService():
try:
opc = OpenOPC.client()
opc.connect('RSLinx OPC Server')
except:
print "subService OPC Connect exception"
def on_connect(client, userdata, flags, rc):
print("MQTT Connected with result code " + str(rc))
client.subscribe("opcsample/set/#")
def on_message(client, userdata, msg):
topicParse = msg.topic.split("/")
opc.write((topicParse[-2:][0], msg.payload))
print "set: " + topicParse[-2:][0] + ": " + msg.payload
client = mqtt.Client()
client.on_connect = on_connect
client.on_message = on_message
try:
client.username_pw_set("***", "***")
client.connect("***.eercan.com", 1883, 60)
except:
print "subService MQTT Connect exception"
client.loop_forever()
opc.close()
def pubService():
items = [
'[OPC_Sample]Program:MainProgram.OUTPUT1',
'[OPC_Sample]Program:MainProgram.OUTPUT2',
'[OPC_Sample]Program:MainProgram.INPUT'
]
while True:
try:
opc = OpenOPC.client()
opc.connect('RSLinx OPC Server')
opcData = opc.read(items)
except:
print "pubService OPC exception"
else:
msgs = []
for i in opcData:
msgs.append(("opcsample/get/" + i[0] + "/", i[1], 0, False))
try:
publish.multiple(msgs,
hostname="***.eercan.com",
auth={
'username': "******",
'password': "******"
})
except:
print "pubService MQTT exception, sleeping 5 sec"
time.sleep(5)
time.sleep(1)
opc.close()
def connect(self):
print "attempting OPC connection to", self.opc_name
self.opc = OpenOPC.client()
self.opc.connect(self.opc_name, self.opc_host)
props = self.opc.properties(self.points.keys())
print "loaded", len(props), "properties"
points = {}
for point, pid, key, val in props:
name = self.make_path(point)
if not name in points:
points[name] = self.points[point]
if not exclude(key):
points[name]['OpcDA/' + key] = str(val)
# try to make some sense out of the metadata
for name, meta in points.iteritems():
unit = str(meta.get('OpcDA/' + self.unit_tag, 'None'))
dtype = meta.get('OpcDA/Item Canonical DataType', None)
if not dtype:
print "no datatype tag in", name
continue
if dtype.startswith('VT_R'):
dtype = 'double'
elif dtype.startswith('VT_U') or dtype.startswith('VT_I'):
dtype = 'long'
else:
print "skipping", name, "since cannot find data type"
continue
if not self.get_timeseries(name):
self.add_timeseries(name, unit, data_type=dtype)
self.set_metadata(name, points[name])
vals = self.opc.read(self.points.keys(), group="smap-points-group")
def connect(self):
self._lock.acquire()
self._lock.release()
try:
#print self.host
#print self.opc_host
#print self.opc_server
#self.opc = OpenOPC.open_client(self.host, self.port)
if self.mode == 'dcom':
self.opc = OpenOPC.client("Graybox.OPC.DAWrapper", self.host)
else:
self.opc = OpenOPC.open_client(self.host, self.port)
self.opc.connect(self.opc_server, self.opc_host)
#info = self.opc.servers()
#print info
except OPCError, oe:
log.debug( str(oe) )
raise Exception(oe.message)
def connect(self):
""" connect """
self._lock.acquire()
self._lock.release()
try:
#print self.host
#print self.opc_host
#print self.opc_server
#self.opc = OpenOPC.open_client(self.host, self.port)
if self.mode == 'dcom':
self.opc = OpenOPC.client("Graybox.OPC.DAWrapper", self.host)
else:
self.opc = OpenOPC.open_client(self.host, self.port)
self.opc.connect(self.opc_server, self.opc_host)
info = self.opc.servers()
print info
except OPCError, oe:
log.debug(str(oe))
raise Exception(oe.message)
def reconnect(self):
""" reconnect """
log.info("reconnect...")
info = ""
if self._lock.locked() == False:
#self.reconnecting = 1
self._lock.acquire()
try:
#self.opc = OpenOPC.open_client(self.host, self.port)
#self.opc.connect(self.provider, self.host)
if self.mode == 'dcom':
self.opc = OpenOPC.client("Graybox.OPC.DAWrapper",
self.host)
else:
self.opc = OpenOPC.open_client(self.host, self.port)
info = self.opc.servers()
info = info + self.opc.info()
for group in self.groups:
self.create_group(group, self.groups[group])
#self.reconnecting = 0
except Exception, e:
# release the lock
info = "excetp: %s" % (e.message)
log.error(info)
log.error(traceback.format_exc())
#self.reconnecting = 0
finally:
def connect(self):
logger.debug("connect...............")
try:
if conf["Use_Wrapper"] == True:
logger.debug(conf["DAWrapper"])
self.opc_client = OpenOPC.client(conf["DAWrapper"], conf["HOST"])
else:
logger.debug(conf["PROVIDER"])
self.opc_client = OpenOPC.open_client(conf["HOST"], conf["PORT"])
self.opc_client.connect(conf["PROVIDER"], conf["OPC_HOST"])
self.connected = 1
except Exception as ex:
logger.debug(ex)
self.connected = 0
def init(self):
config_filename = 'main.conf'
self.config = ConfigParser.ConfigParser()
file_handle = open(config_filename)
self.config.readfp(file_handle)
self.opc_classname = self.config.get('opc', 'classname')
self.opc_servers = self.config.get('opc', 'servers')
self.opc_host = self.config.get('opc', 'host')
self.logger.info('Opc Class: ' + self.opc_classname)
self.logger.info('Opc Servers: ' + self.opc_servers)
self.logger.info('Opc Host: ' + self.opc_host)
self.preferences = {}
self.preferences['show_root'] = mTools.str_to_bool(
self.config.get('preferences', 'show_root'))
self.opc = OpenOPC.client()
result = self.opc.connect(self.opc_servers, self.opc_host)
#result = False
if result:
self.logger.info('... Successfully connected to OPC server')
return True
else:
self.logger.error('... FAILED to connect to OPC Server')
time.sleep(5)
self.init()
def main():
opc_client = OpenOPC.client(
"Graybox.OPC.DAWrapper",
"127.0.0.1") #OpenOPC.open_client(conf["HOST"], conf["PORT"])
print conf["PROVIDER"]
print conf["OPC_HOST"]
opc_client.connect(conf["PROVIDER"], conf["OPC_HOST"])
#info = opc_client.servers()
#print info
tags = conf["TAGS"] # ["Digi.cool_system.A1", "Digi.cool_system.A11"]
group = conf["GROUP"]
v = opc_client.read(tags=tags, group=group, update=100)
while True:
data = opc_client.read(group=group, update=100)
print data
for item in data:
#update( item )
print item
time.sleep(conf["INTERVAL"])
def connectOPC(self, event):
eventValue = event.get("text").split(',')
nameServer = eventValue[0]
nameTag = eventValue[1]
print(nameServer, nameTag)
con = psycopg2.connect(
"host='localhost' dbname='postgres' user='******' password='******'"
)
cur = con.cursor()
pywintypes.datetime = pywintypes.TimeType
opc = OpenOPC.client()
opc.connect(nameServer)
tag = nameTag
ID = 0
cur.execute(f"delete from orders")
while True:
value = opc.read(tag)
cur.execute(f"INSERT INTO orders VALUES({ID},{value[0]});")
print(value)
con.commit()
sleep(5)
ID += 1
con.close()
def jobWriteOPC(TVpairs,opcserver='OPCManager.DA.XML-DA.Server.DA',client_name=None):
opc = OpenOPC.client(client_name=client_name)
opc.connect(opcserver)
sleep(0.7)
status = opc.write(TVpairs)
sleep(0.7)
opc.close()
return status
def get_opc_info(self,opc_server):
print "Get opc server infomation"
opc = OpenOPC.client()
opc.connect(opc_server)
all = opc.info()
opc.close()
return all
def create_app():
# Funcao responsavel por inicializar a aplicacao REST
app = Flask(__name__)
app.threaded = False
__register_blueprints(app)
app.opc = OpenOPC.client()
return app
def get_opc_info(self, opc_server):
print "Get opc server infomation"
opc = OpenOPC.client()
opc.connect(opc_server)
all = opc.info()
opc.close()
return all
def __init__(self, servername) -> None:
super().__init__()
self.__opc = OpenOPC.client()
try:
self.__opc.connect(servername)
except OpenOPC.OPCError:
self.__opc.close()
print("cannot connect to opc")
raise exception_.OPCError
def OLGA_connect(serverIP='127.0.0.1',modelPrefix='Sim.ServerDemo.'): #Create Data Access Object from OPC server
model = modelPrefix; # turn his into a class
da = OpenOPC.client()
id = 'SPT.OLGAOPCServer.7'
da.connect(id)
time.sleep(1)
#OLGA_restart_time(da,True)
return da
def OPCconnect():
opc = OpenOPC.client()
#opc = OpenOPC.open_client('localhost')
opc = OpenOPC.open_client(wm_global.OpcClientName)
opc.servers()
# opc.connect('KEPware.KEPServerEx.V4')
opc.connect(wm_global.OpcServerName)
return opc
def checkICONICS_Simulator():
opc = OpenOPC.client()
opc.connect(IconicsSim)
j=0
for i in tagset:
print i, ": ", opc[i]
j = j+1
opc.close()
def conexion_OPC():
# Conexion con el servidor del controlador
MPC = Client("opc.tcp://Labo6:16700/") # Creacion objeto OPC-UA
MPC.connect() # Conexion Controlador
MPC.load_type_definitions()
# Conexión con el servidor RTO
RTO = Client("opc.tcp://Labo6:16701/") # Creacion objeto OPC-UA
RTO.connect() # Conexion Controlador
RTO.load_type_definitions()
# Conexion con los demas servidores
SCADA = OpenOPC.client() # Creacion objeto OPC-DA
PID1 = OpenOPC.client() # Creacion objeto OPC-DA
PID2 = OpenOPC.client() # Creacion objeto OPC-DA
SCADA.connect("LecturaOPC.1.0")
PID1.connect("OPC.PID ISA (CreaOPC).1")
PID2.connect("OPC.PID ISA 2 (CreaOPC).1")
return [MPC, SCADA, PID1, PID2, RTO]
def opc_status():
opc = OpenOPC.client() #创建客户端
opc.connect(u'PCAuto.OPCServer', 'localhost') #读取opcserver
lista = ["ZLJ2_ManOn.PV", "ZLJ2_Run.PV", "ZLJ2_ManAuto.PV", "ZLJ3_ManOn.PV", "ZLJ3_Run.PV", "ZLJ3_ManAuto.PV"]
listStatus = []
opcList = opc.read(lista) #读取整个流程参数 0停止和手动 1启动和自动
for line in opcList:
collection = {}
collection[line[0]] = line[1]
listStatus.append(collection)
return jsonify(listStatus) #f返回状态结果集
def readopc(tags):
pywintypes.datetime = pywintypes.TimeType
opc = OpenOPC.client()
opc.connect('Matrikon.OPC.Simulation.1')
try:
data = opc.read(tags, group='Group0', update=1)
except OpenOPC.TimeoutError:
print("TimeoutError occured")
return data
def __init__(self):
pywintypes.datetime = pywintypes.TimeType
self.opc = OpenOPC.client()
if self.opc.servers()[0]:
self.opc.connect(self.opc.servers()[0])
self.server = self.opc.servers()[0]
print('OPC Server Conectado')
print('Servidor: {}'.format(self.opc.servers()[0]))
else:
print('Nenhum servidor encontrado')
def pubService():
opc = OpenOPC.client()
opc.connect('Matrikon.OPC.Simulation.1')
while True:
opcData = opc.read(opc.list('Configured Aliases.testEmir'))
msgs = []
for i in opcData:
alias, item = i[0].split(".")
msgs.append(("/plcNetwork/dev0/get/" + alias + "/" + item + "/",
i[1], 0, False))
publish.multiple(msgs, hostname="###")
time.sleep(0.5)
opc.close()
def _init_OPC(self, opcserver='CoDeSys.OPC.02', opcclientName='OPCClient.GPCSys'):
try:
# opc client instance can not be stored here as this will be run in the main thread during initialisation.
# opc connection will faile later if run from the scheduler job (which will be in an other thread)
opc = OpenOPC.client()
except:
raise ValueError('OPC-Client could not be instantiated')
if opcserver in opc.servers():
self.opcServer = opcserver
try:
opc.connect(self.opcServer)
except:
raise ValueError('OPC-Server: "%s" could not be connected'%(self.opcServer,))
if self.Variables.has_key('OPC_Group'):
opcGrp = self.Variables['OPC_Group']
opcVMap = {}
opcVars = set()
opcServVars = set()
for sti in self.Variables.keys():
if sti in ["OPC_Group",]: continue
stg = lambda vi: ''.join(vi.split('_',2)[:2])
vmapi = dict([(sti+':.'+vi['OPC'],GPC_Stations[stg(vi['OPC'])]+':'+vi['GPC']) for vi in self.Variables[sti]])
opcVMap.update(vmapi)
opcVars.update(vmapi.keys())
opcServVars.update(opc.list(sti+"*", flat=True))
opcVMap.update(dict([reversed(i) for i in opcVMap.items()]))
else:
opcGrp = self.Variables.keys()[0]
opcVars = set([opcGrp+':.'+vi for vi in self.Variables[opcGrp]])
opcServVars = set(opc.list(opcGrp+"*", flat=True))
if opcVars <= opcServVars:
self.opcGrp = opcGrp
self.opcVars = opcVars
self.opcVarsDict = dict()
try: #only if variable mapping available store it
self.opcVMap = opcVMap
self.gpcVars = [opcVMap[vi] for vi in opcVars]
except:
self.gpcVars = self.opcVars
else:
raise ValueError('Not all needed Variables are listed by the OPC Server\n missing: %s' % (opcVars - opcServVars,))
self.opcclientName = opcclientName
self.readLock = False
self.writeLock = False
self.connTrys = 0
self.connMaxTrys = 3 #Could come from config
opc.close()
else:
raise ValueError('OPC Server is not accessible: %s' % opcserver)
def opc_write():
opc = OpenOPC.client() #创建客户端
opc.connect(u'PCAuto.OPCServer', 'localhost') #读取opc
pointName=request.values["pointName"] #获取坐取按钮信息
pointValue=request.values["pointValue"]
opc.write((str(pointName), float(pointValue))) #写入opc值
time.sleep(1)
lista = ["ZLJ2_ManOn.PV", "ZLJ2_Run.PV", "ZLJ2_ManAuto.PV", "ZLJ3_ManOn.PV", "ZLJ3_Run.PV", "ZLJ3_ManAuto.PV"]#控制集
listStatus = []
opcList = opc.read(lista) #读取整个流程参数 0停止和手动 1启动和自动
for line in opcList:
collection = {}
collection[line[0]] = line[1]
listStatus.append(collection)
return jsonify(listStatus) #f返回状态结果集
def get_opc_list(self, opc_server, browe_option):
print "Initial to get all OPC item from ", opc_server
opc = OpenOPC.client()
opc.connect(opc_server)
#all = opc.list()
if browe_option: #Flat == True
all = opc.list('*', flat=True)
print "------------------------"
for t in all:
print t
opc.close()
return all # rerturn all opc server
else:
return all
def _opc_client(self):
"""Create OPC client"""
if system == 'Linux':
self.opc = OpenOPC.open_client(self.opc_server_host,
self.opc_server_port)
self.opc.connect(opc_server=self.opc_server_name)
elif system == 'Windows':
try:
self.opc = OpenOPC.client()
self.opc.connect(opc_server=self.opc_server_name,
opc_host=self.opc_server_host)
except Exception as e:
raise e
self.logger.info('OPC client created successfully')
def get_opc_list(self,opc_server,browe_option):
print "Initial to get all OPC item from ",opc_server
opc = OpenOPC.client()
opc.connect(opc_server)
#all = opc.list()
if browe_option: #Flat == True
all = opc.list('*',flat = True)
print "------------------------"
for t in all:
print t
opc.close()
return all # rerturn all opc server
else:
return all
def __init__(self, conn_cfg, use_alt_host=False):
if use_alt_host:
self.opc_host = conn_cfg["OPC_HOST_ALT"]
else:
self.opc_host = conn_cfg["OPC_HOST"]
self.client = OpenOPC.client(client_name="PyOPC")
self.landmark_path = conn_cfg[
"LANDMARK_PATH"] # Path to known/expected value, for health checks
self.expected_landmark_val = conn_cfg[
"EXPECTED_LANDMARK_VAL"] # Value to compare landmark observation against
self.heartbeat_path = conn_cfg[
"HEARTBEAT_PATH"] # Path to constantly changing value, for health checks
self.landmark = None
self.heartbeats = deque(maxlen=2)
self.aliasing_possible = False # Indicates if heartbeat scan is too slow and could alias signal
self.last_integrity_timestamp = None
def AddItemsCSV(OPCserver, CSVname, taglist):
"""
Connect OPCserver
Extract a value of the value
of the taglist and append them to
liste and to csv
taglist: list with name of all items
liste: list of item value
"""
attach = [] #Initialize attach
try:
opc = OpenOPC.client() #Connection with the OPC Server
opc.connect(OPCserver)
except:
print("No connection to Server")
try:
v = opc.read(tags=taglist) #Reading tags from OPC
str(v)
except:
print("Unable to read tags")
try:
# Create a line with the values from the tag
for i in range(len(v)):
(name, val, qual, time) = v[i]
if val == '':
val = 0
attach.insert(i, val)
attach.insert(0, time)
except:
print('Unable to create a row')
#Writing the line to the CSV file
try:
b = open(CSVname, 'ab')
a = csv.writer(b)
a.writerow(attach)
b.close()
except:
print('Unable to write in CSV')
def jobReadOPC(Tags,opcserver='OPCManager.DA.XML-DA.Server.DA',client_name=None):
opc = OpenOPC.client(client_name=client_name)
opc.connect(opcserver)
sleep(0.7)
opcIn = []
for i in xrange(2):
try:
opcIn = opc.read(Tags,timeout=1000)
break
except OpenOPC.TimeoutError:
print "%s: TimeoutError" % (client_name,)
opc.close()
sleep(1)
opc.connect(opcserver)
sleep(0.7)
opc.close()
return opcIn
def readOPC(self,server,tag_read):
opc = OpenOPC.client()
opc.connect(server)
result = opc.read(tag_read,timeout=7000)
del self.global_list[server]['value'][:] # delete all item
self.global_list[server]['value'] = result
check_time_out = 0
run_proc = True
try:
while run_proc:
# reset tag timeout
if check_time_out > 3:
check_time_out = 0
tag_read = []
del_tag = []
for t in self.global_list[server]['tag']:
time_out = self.global_list[server]['tag'][t]-1
print "Tag %s timeout %s " % (t,time_out)
if time_out > 0 :
self.global_list[server]['tag'][t]=time_out
tag_read.append(t)
else:
del_tag.append(t)
# delete tag from servie
for t in del_tag:
del self.global_list[server]['tag'][t]
#print "OPC thread service update between 2 second \r\n Try to set new value in global_list : ",
#print self.global_list
time.sleep(2)
if len(tag_read)>0:
result = opc.read(tag_read,timeout=7000)
#print result
del self.global_list[server]['value'][:] # delete all item
self.global_list[server]['value'] = result
check_time_out +=1
else:
run_proc = False # exit process
del self.global_list[server] # delete all tag and server
except Exception,err:
print "interrupt exit with thread opc : ",err
def readOPC(self, server, tag_read):
opc = OpenOPC.client()
opc.connect(server)
result = opc.read(tag_read, timeout=7000)
del self.global_list[server]['value'][:] # delete all item
self.global_list[server]['value'] = result
check_time_out = 0
run_proc = True
try:
while run_proc:
# reset tag timeout
if check_time_out > 3:
check_time_out = 0
tag_read = []
del_tag = []
for t in self.global_list[server]['tag']:
time_out = self.global_list[server]['tag'][t] - 1
print "Tag %s timeout %s " % (t, time_out)
if time_out > 0:
self.global_list[server]['tag'][t] = time_out
tag_read.append(t)
else:
del_tag.append(t)
# delete tag from servie
for t in del_tag:
del self.global_list[server]['tag'][t]
#print "OPC thread service update between 2 second \r\n Try to set new value in global_list : ",
#print self.global_list
time.sleep(2)
if len(tag_read) > 0:
result = opc.read(tag_read, timeout=7000)
#print result
del self.global_list[server]['value'][:] # delete all item
self.global_list[server]['value'] = result
check_time_out += 1
else:
run_proc = False # exit process
del self.global_list[server] # delete all tag and server
except Exception, err:
print "interrupt exit with thread opc : ", err
def _connect_OPC(self):
try:
self.opc
except AttributeError:
# opc client instance can now be stored as this is done within the job thread.
# later cals will be issued from the same thread.
try:
self.opc = OpenOPC.client(client_name=self.opcclientName)
except OpenOPC.OPCError as e:
raise ValueError('OpenOPC.OPCError: %s\n Error during OPC client instantiation' % e)
try:
self.opc.info() #This raises an exception if the OPC-Server is not connected.
conn = True
except:
conn = False
if not conn:
self.opc.connect(self.opcServer)
sleep(0.3) #To be sure connection is done on OPC server side.
def connect():
"""
return 2 connection objects: "opc" and "cursor"
"""
# PLC
plc = 'OMRON.OpenDataServer.1'
try:
print("+------------+")
print("- Connecting to PLC...")
opc = OpenOPC.client()
opc.connect(plc)
print(" Success!")
except:
print("Error connecting to OPC")
# MySQL
user = '******'
password = ''
host = '127.0.0.1'
database = 'mbr'
print(" - Connecting to MySQL...")
try:
config = {
'user': user,
'password': password,
'host': host,
'database': database,
'raise_on_warnings': True
}
cnx = mysql.connector.connect(**config)
cursor = cnx.cursor()
print('Success! connection established')
# analise if cursor is defined
assert isinstance(cursor, object)
return [opc, cursor]
except mysql.connector.Error as err:
if err.errno == errorcode.ER_ACCESS_DENIED_ERROR:
print("Something is wrong with your user name or password")
elif err.errno == errorcode.ER_BAD_DB_ERROR:
print("Database does not exist")
else:
print(f'unable to connect to MySQL server on {host}')
def connect(serveurName, taglist):
"""
Connexion serveur OPC
serveurName: name of the OPC server
taglist: list with name of item
return list of item information
"""
try:
# Connexion serveur
opc = OpenOPC.client()
u= opc.connect(serveurName)
# Read item list
v = opc.read(taglist)
# Close socket
opc.close()
except:
print "Error - No connection to OPC server !!!"
return v
def create_client(self):
"""Create a new OpenOPC client instance in the Pyro server"""
opc_obj = OpenOPC.client(opc_class)
opc_obj._open_serv = self
opc_obj._open_self = opc_obj
opc_obj._open_host = opc_gate_host
opc_obj._open_port = opc_gate_port
uri = self._pyroDaemon.register(opc_obj)
opc_obj._open_guid = uri.asString()
self._opc_objects[opc_obj._open_guid] = opc_obj
self._init_times[opc_obj._open_guid] = time.time()
self._last_times[opc_obj._open_guid] = time.time()
servicemanager.LogInfoMsg('\n\nCreate client %s' % opc_obj._open_guid)
return Pyro4.Proxy(uri)
def query_handler(call):
answer = ''
if call.data == '3':
try:
opc1 = OpenOPC.client()
opc1.connect(tagsValue[0])
# tag1 = opc1.list("COM4.TRM_202(adr=104)T_слой_Ср_р-ра.Оперативные параметры")[3]
answer = opc1.read(tagsValue, update=1, include_error=True)
print(answer)
opc1.close()
count = 0
while count < len(tagsValue):
bot.send_message(
call.message.chat.id,
"{0:_^20} {1:>10.2f}".format(tg_lst[tagsValue[count]],
answer[count][1]))
count += 1
except ConnectionError as err:
print(err)
def connect(self, host=None, opc_server=None):
"""
Создание объекта OPC клиента.
@param host: Хост OPC сервера для возможности удаленного подключения (через DCOM) к OPC серверу.
Если не определен, то берется из описания компонента.
@param opc_server: Имя OPC сервера.
Если не определен, то берется из описания компонента.
@return: Объект OPC сервера.
"""
if host is None:
host = self.getHost()
if opc_server is None:
opc_server = self.getOPCServer()
if type(host) not in (None.__class__, str, unicode):
log.error(u'Не корректный тип хоста OPC сервера <%s>' % type(host))
return None
is_local_opc = self.is_localhost(host)
if is_local_opc:
log.info(u'OPC сервер находится локально')
opc = OpenOPC.client()
else:
log.info(u'OPC сервер находится на <%s>' % host)
opc = OpenOPC.open_client(host)
if opc is None:
log.error(u'Не возможно создать объект клиента OPC. Хост <%s>' %
host)
return None
# Список серверов OPC
servers = opc.servers()
if opc_server not in servers:
log.warning(u'Сервер <%s> не найден среди %s' %
(opc_server, servers))
self.disconnect(opc)
return None
# Соедиенение с сервером
opc.connect(opc_server)
return opc
def create_opc_client(self, opc_host=None):
"""
Создание объекта OPC клиента.
@param opc_host: Хост OPC сервера для возможности удаленного подключения (через DCOM) к OPC серверу.
Если не определен, то считается что OPC сервер находится локально.
@return: Объект OPC сервера.
"""
if type(opc_host) not in (None.__class__, str, unicode):
msg = u'Не корректный тип хоста OPC сервера <%s>' % type(opc_host)
log.error(msg)
journal.write_msg(msg)
return None
is_local_opc = (opc_host is None) or (type(opc_host) in (str, unicode) and opc_host.lower().strip() in ('localhost', '127.0.0.1'))
if is_local_opc:
log.info(u'OPC сервер находится локально')
opc = OpenOPC.client()
else:
log.info(u'OPC сервер находится на <%s>' % opc_host)
opc = OpenOPC.open_client(opc_host)
return opc
def create_client(self):
"""Create a new OpenOPC instance in the Pyro server"""
opc_obj = OpenOPC.client(opc_class)
base_obj = Pyro.core.ObjBase()
base_obj.delegateTo(opc_obj)
uri = self.getDaemon().connect(base_obj)
opc_obj._open_serv = self
opc_obj._open_self = base_obj
opc_obj._open_host = self.getDaemon().hostname
opc_obj._open_port = self.getDaemon().port
opc_obj._open_guid = uri.objectID
remote_ip = self.getLocalStorage().caller.addr[0]
try:
remote_name = socket.gethostbyaddr(remote_ip)[0]
self._remote_hosts[uri.objectID] = '%s (%s)' % (remote_ip, remote_name)
except socket.herror:
self._remote_hosts[uri.objectID] = '%s' % (remote_ip)
self._init_times[uri.objectID] = time.time()
self._tx_times[uri.objectID] = time.time()
return Pyro.core.getProxyForURI(uri)
import MySQLdb
# Libraries for time
import time
while True:
try:
# Create a variable for the time
localtime = time.asctime(time.localtime(time.time()))
# Connect to the DB ("host", "username", "password", "db_name")
host = "localhost" # Where the host is (local or internet)
username = "******" # user name to get into the DB
password = "******" # Password to get into the DB
db_name = "prova" # DB name
db = MySQLdb.connect(host, username, password, db_name) # Connect and name it DB
# Create the object cursor to execute the SQL command
cursor = db.cursor()
break
except MySQLdb.Error:
print "Error connectant a la base de dades. Try again!"
# Connect to the OPC server
import OpenOPC # Imports the OpenOPC library
opc = OpenOPC.client() # Opens the client
server = "Matrikon.OPC.Simulation" # Choose the server
opc.connect(server) # Connect to server
def create_instance(self): '''creats OPC client''' self.opc = OpenOPC.client() self.status = 'Created OPC Instance'
=================== """
import sys
from os import path
if __name__ == '__main__':
sys.path[0:0] = ['..',]
from Control.GPCVariablesConfig import EPA_Vars, GPC_SysVars, GPC_StateVars
from ReadWriteDataTest.handleConfig import readConfigJob, readGPCConfig
import ReadWriteDataTest.config as GPCConfig
import OpenOPC
GPCConf = readGPCConfig(path.join('..','ReadWriteDataTest',GPCConfig.GPCConfFile))
OPCServer = GPCConf[0]["Global"]["OPCServer"]
opc = OpenOPC.client()
opc.connect(OPCServer)
#Set the Valves into automatic mode.
# This need sto be done first otherwise some other settings will be ignored.
variables = [('HMI_VanneVM1enAuto_S01',1),
('HMI_VanneVM1enAuto_S02',1),
('HMI_VanneVM1enAuto_S03',1),]
opc.write(variables)
#Set all the other variables that need to have a specific value at startup.
variables = []
for sti in EPA_Vars:
variables.extend([(vi['OPC'],0) for vi in EPA_Vars[sti] if vi['OPC'].endswith('_Index')])
for sti in GPC_SysVars:
def get_opc(self):
print "Get opc server "
opc = OpenOPC.client()
all = opc.servers()
opc.close()
return all
# -*- coding: utf-8 -*-
from __future__ import print_function
import time
from Model import Model
from PlantOPC import PlantOPC
import OpenOPC
import numpy
import matplotlib.pyplot as plt
opc = OpenOPC.client() # Cria o cliente OPC; o servidor é o RSLinx
opc.connect('RSLinx OPC Server') # Essa string não muda; conecta ao RSLinx
init_pos = (opc.read('[CLP_AB]position',update=1)[0])
pC = numpy.array([0.5, 0.6, 0.7, 0.5 + 0.4j, 0.5 - 0.4j])
Ki = 0.183111320328469
Kp = numpy.array([0.007993734748865, 0.009705988539721, -0.004630469582507, -0.000426479250745])
# Kalman Matrices
n = 4
Ak = numpy.matrix([[0.993175847266250, 0.0997676389875316, 0.00447446153612418, 0.000154491807255262],
[-0.266442692060039, 0.989506934720158, 0.0794137333776907, 0.00441443534842949],
[-7.61331011046535, -0.371277877313592, 0.407916221277208, 0.0776985503560236],
[-134.001998512554, -9.45851595845769, -10.6078657460473, 0.377727256243161]])
Bk = numpy.matrix([0.674742463375352, 3.50238796155364, -32.6963528822316, -364.795682866366]).transpose()
Ck = numpy.matrix([1.0, 0.0, 0.0, 0.0])
Q = 0.01 ** 2 * numpy.eye(4)
R = 0.4 ** 2
epsilon = 0.3
Ts = 0.1
def __init__(self):
self.client = OpenOPC.client()
self.client.connect(OPC_SERVER)
def __init__(self):
QtCore.QThread.__init__(self)
self.opc = OpenOPC.client()
self.exiting = False
self.items = []
# Connect to OpenOPC service (Open mode)
if opc_mode == 'open':
try:
opc = OpenOPC.open_client(open_host, open_port)
except:
error_msg = sys.exc_info()[1]
print "Cannot connect to OpenOPC Gateway Service at %s:%s - %s" % (open_host, open_port, error_msg)
exit()
# Dispatch to COM class (DCOM mode)
else:
try:
opc = OpenOPC.client(opc_class, client_name)
except OpenOPC.OPCError, error_msg:
print "Failed to initialize an OPC Automation Class from the search list '%s' - %s" % (opc_class, error_msg)
exit()
# Connect to OPC server
if action not in ['servers'] and not health_only:
try:
opc.connect(opc_server, opc_host)
except OpenOPC.OPCError, error_msg:
if opc_mode == 'open': error_msg = error_msg[0]
print "Connect to OPC server '%s' on '%s' failed - %s" % (opc_server, opc_host, error_msg)
exit()
# Perform requested action...
