def timeTestforReadWrite():
'''
testing the time to read and write to the PLC
'''
from pylogix import PLC
import time
DiamondElements = PLC('192.168.1.10') #AB PLC IP Address
count = 0
targetCycleCount = 1000
startTime = time.time()
"""
read the bool, write its opposite value, read it again.
"""
while True:
returnedValue = DiamondElements.Read('IO_NEEDED_HERE')
print('Currently read value of ' + returnedValue.TagName + ': ' +
str(returnedValue.Value))
if returnedValue.Value == True:
boolToWrite = 0
else:
boolToWrite = 1
DiamondElements.Write('IO_NEEDED_HERE', boolToWrite)
newReturnedValue = DiamondElements.Read('IO_NEEDED_HERE')
print('New value after writing: ' + str(newReturnedValue.Value))
if count >= targetCycleCount:
break
count += 1
EndTime = time.time()
totalTime = EndTime - startTime
print(f"{totalTime:.4f} seconds with {targetCycleCount} read/write cycles")
def ReadOutWord():
comm = PLC()
comm.IPAddress = '169.254.215.82'
value = comm.Read('OutWord')
lbl3 = Label(window,
text="OutWord|Value",
bg="white",
fg="Black",
bd=2,
relief="solid",
width=15,
height=2)
lbl3.place(x=410, y=20)
lbl4 = Label(window,
text=value,
bg="Black",
fg="lime",
bd=3,
relief="raised",
width=15,
height=5)
lbl4.place(x=410, y=60)
window.after(550, ReadOutWord)
return
def ReadSEQCount():
comm = PLC()
comm.IPAddress = '169.254.215.82'
valueseqcount = comm.Read('SEQCount')
lbl6 = Label(window,
text="Sequence Count",
bg="white",
fg="Black",
bd=2,
relief="solid",
width=15,
height=2)
lbl6.place(x=540, y=180)
lbl7 = Label(window,
text=valueseqcount,
bg="Black",
fg="lime",
bd=3,
relief="raised",
width=15,
height=5)
lbl7.place(x=540, y=220)
window.after(550, ReadSEQCount)
return
'''
Read a list of tags at once
Reading lists and arrays is much more efficient than
reading them individually. You can create a list of tags
and pass it to .Read() to read them all in one packet.
The values returned will be in the same order as the tags
you passed to Read()
NOTE: Packets have a ~500 byte limit, so you have to be cautions
about not exceeding that or the read will fail. It's a little
difficult to predict how many bytes your reads will take up becuase
the send packet will depend on the length of the tag name and the
reply will depened on the data type. Strings are a lot longer than
DINT's for example.
I'll usually read no more than 5 strings at once, or 10 DINT's)
'''
from pylogix import PLC
tag_list = ['Zone1ASpeed', 'Zone1BSpeed', 'Zone2ASpeed', 'Zone2BSpeed', 'Zone3ASpeed', 'Zone3BSpeed',
'Zone4ASpeed', 'ZOne4BSpeed', 'Zone1Case', 'Zone2Case']
with PLC() as comm:
comm = PLC()
comm.IPAddress = '192.168.1.9'
value = comm.Read(tag_list)
print(value)
def get_tag(tag, ipAddress, slot):
comm = PLC(ipAddress, slot)
regularTags = []
arrayTags = dict()
results = []
readArray = False
arrayElementCount = 0
showBoolAsOneZero = False
if tag.startswith('[') and tag.endswith(']'): # array of mixed tags
tags = (tag[1:-1].replace(' ', '')).split(';')
for t in tags:
if not t == '':
if t.endswith(
'}') and '{' in t: # 1 or 2 or 3 dimensional array tag
try:
arrayElementCount = int(t[t.index('{') +
1:t.index('}')])
readArray = True
t = t[:t.index('{')]
arrayTags.update({t: arrayElementCount})
except:
pass
else:
regularTags.append(t)
if len(regularTags) > 0:
ret = comm.Read(regularTags)
if ret[0].Value is None:
comm.Close()
return jsonify(ret[0].Status)
for i in range(0, len(ret)):
if showBoolAsOneZero and (str(ret[i].Value) == 'True'
or str(ret[i].Value) == 'False'):
results.append({
"tagName":
str(ret[i].TagName),
"value":
1 if str(ret[i].Value) == 'True' else 0,
"status":
str(ret[i].Status)
})
else:
results.append({
"tagName": str(ret[i].TagName),
"value": str(ret[i].Value),
"status": str(ret[i].Status)
})
if len(arrayTags) > 0:
for tag in arrayTags:
ret = comm.Read(tag, arrayTags[tag])
if ret.Value is None:
comm.Close()
return jsonify(ret.Status)
if showBoolAsOneZero and (str(ret.Value[0]) == 'True'
or str(ret.Value[0]) == 'False'):
newBoolArray = []
for val in range(0, len(ret.Value)):
newBoolArray.append(1 if str(ret.Value[val]) ==
'True' else 0)
results.append({
"tagName": ret.TagName,
"value": newBoolArray,
"status": ret.Status
})
else:
results.append({
"tagName": ret.TagName,
"value": ret.Value,
"status": ret.Status
})
comm.Close()
if len(regularTags) > 0 or len(arrayTags) > 0:
return jsonify({'tags': results})
else:
return jsonify('Not a valid tag!')
else:
if tag.endswith('}') and '{' in tag: # 1 or 2 or 3 dimensional array
try:
arrayElementCount = int(tag[tag.index('{') + 1:tag.index('}')])
readArray = True
tag = tag[:tag.index('{')]
except:
pass
else:
pass
if readArray and arrayElementCount > 0:
ret = comm.Read(tag, arrayElementCount)
if ret.Value is None:
comm.Close()
return jsonify(ret.Status)
if showBoolAsOneZero and (str(ret.Value[0]) == 'True'
or str(ret.Value[0]) == 'False'):
newBoolArray = []
for val in range(0, len(ret.Value)):
newBoolArray.append(1 if str(ret.Value[val]) ==
'True' else 0)
results.append({
"tagName": ret.TagName,
"value": newBoolArray,
"status": ret.Status
})
else:
results.append({
"tagName": ret.TagName,
"value": ret.Value,
"status": ret.Status
})
else:
ret = comm.Read(tag)
if ret.Value is None:
comm.Close()
return jsonify(ret.Status)
if showBoolAsOneZero and (str(ret.Value) == 'True'
or str(ret.Value) == 'False'):
results.append({
"tagName": ret.TagName,
"value": 1 if str(ret.Value) == 'True' else 0,
"status": ret.Status
})
else:
results.append({
"tagName": ret.TagName,
"value": ret.Value,
"status": ret.Status
})
comm.Close()
return jsonify({'tag': results})
'''
the following import is only necessary because eip.py is not in this directory
'''
import sys
sys.path.append('..')
'''
Read an array of values
I have a tag called "LargeArray", which is DINT[10000]
We can read as many of them as we'd like, which makes
reading arrays the most efficient way to read data.
Read will handle multi-packet replies.
We're going to pass Read() the tag and the number
to read.
'''
from pylogix import PLC
with PLC() as comm:
comm = PLC()
comm.IPAddress = '192.168.1.9'
ret = comm.Read('LargeArray[0]', 500)
print(ret.value)
class CondorSkill(MycroftSkill):
# The constructor of the skill, which calls Mycroft Skill's constructor
def __init__(self):
super(CondorSkill, self).__init__(name="CondorSkill")
self.myKeywords = []
# self.client = '' # mqtt.Client()
# Initialize settings values
self.client = mqtt.Client(self.id_generator())
#self.MQTT_Enabled = False
#self.settings["MQTT_Enabled"] = False
#self.broker_address = "192.168.0.43"
#self.settings["broker_address"] = "" #self.broker_address
#self.broker_port = 1883
#self.settings["broker_port"] = "" # self.broker_port
#self.settings["plc_address"] = "" # '142.156.204.41'
#self.plcOutTagName = "StartRobot"
#self.settings["plc_out_tag_name"] = "" # self.plcOutTagName
#self.plcInTagName = "RobotStarted"
#self.settings["plc_in_tag_name"] = "" # self.plcInTagName
#self.cardRequestFreq = 2
#self.settings["card_request_interval"] = 2
self.comm = PLC()
self._is_setup = False
self.io_pins = []
self.notifier_bool = True
# This method loads the files needed for the skill's functioning, and
# creates and registers each intent that the skill uses
def initialize(self):
self.io_pins = [
3, 5, 7, 29, 31, 26, 24, 21, 19, 23, 32, 33, 8, 10, 36, 11, 12, 35,
38, 40, 15, 16, 18, 22, 37, 13
]
GPIO.setmode(GPIO.BOARD)
self.load_data_files(dirname(__file__))
# Check and then monitor for credential changes
self.settings.set_changed_callback(self.on_websettings_changed)
self.on_websettings_changed()
self.add_event('recognizer_loop:wakeword',
self.handle_listen) # should be "utterance"
self.add_event('recognizer_loop:utterance',
self.handle_utterances) # should be "utterances"
self.add_event('speak', self.handle_speak) # should be "utterance"
def on_websettings_changed(self): # called when updating mycroft home page
#if not self._is_setup:
self.MQTT_Enabled = self.settings.get(
"MQTT_Enabled", False) # used to enable / disable mqtt
self.broker_address = self.settings.get("broker_address",
"192.168.0.43")
self.broker_port = self.settings.get("broker_port", 1883)
self.comm.IPAddress = self.settings.get(
"plc_address", '142.156.204.41') # PLC Address
self.plcOutTagName = self.settings.get("plc_out_tag_name",
"StartRobot")
self.plcInTagName = self.settings.get("plc_in_tag_name",
"RobotStarted")
self.cardRequestFreq = self.settings.get("card_request_interval", 2)
self._is_setup = True
LOG.info("Websettings Changed! " + str(self.MQTT_Enabled) + ", " +
self.broker_address + ", " + str(self.broker_port))
def id_generator(self,
size=6,
chars=string.ascii_uppercase + string.digits):
return ''.join(random.choice(chars) for _ in range(size))
@intent_handler(
IntentBuilder("GPIOIntent").require("GpioKeyword").one_of(
"OnKeyword", "OffKeyword").build())
def handle_gpio_intent(self, message):
str_limits = []
str_remainder = str(message.utterance_remainder())
if (str_remainder.find('for') != -1) or (str_remainder.find('four') !=
-1):
str_limits = [4]
else:
str_limits = re.findall('\d+', str_remainder)
if str_limits:
gpio_request = int(str_limits[0])
if (gpio_request > 1) and (gpio_request < 28):
pin_index = gpio_request - 2
board_pin = self.io_pins[pin_index]
LOG.info('The pin number requested was: ' + str(board_pin))
if "OnKeyword" in message.data:
self.gpio_on(board_pin, gpio_request)
if "OffKeyword" in message.data:
self.gpio_off(board_pin, gpio_request)
else:
self.speak_dialog("error",
data={"result": str(gpio_request)},
wait=True)
else:
self.speak('No GPIO Pin was specified')
@intent_handler(
IntentBuilder("WikiIntent").require("TellKeyword").require(
"AboutKeyword").require("ConestogaKeyword").build())
def handle_wiki_intent(self, message):
LOG.info('Condor.ai was asked: ' + message.data.get('utterance'))
str_remainder = str(message.utterance_remainder())
self.speak_dialog("about", wait=True)
self.card_conversation()
@intent_handler(
IntentBuilder("AcademicIntent").require("WhatKeyword").require(
"AcademicKeyword").optionally("ConestogaKeyword").build())
def handle_academic_intent(self, message):
LOG.info('Condor.ai was asked: ' + message.data.get('utterance'))
str_remainder = str(message.utterance_remainder())
self.speak_dialog("academic1", wait=True)
self.speak_dialog("academic2", wait=True)
self.card_conversation()
# @intent_handler(IntentBuilder("CampusIntent").require("WhereKeyword").
# require("CampusKeyword").optionally("ConestogaKeyword").build())
@intent_handler(
IntentBuilder("CampusIntent").require("WhereKeyword").optionally(
"CampusKeyword").require("ConestogaKeyword").build())
def handle_campus_intent(self, message):
LOG.info('Condor.ai was asked: ' + message.data.get('utterance'))
str_remainder = str(message.utterance_remainder())
self.speak_dialog("campus_intro", wait=True)
self.speak_dialog("campus", wait=True)
self.card_conversation()
@intent_handler(
IntentBuilder("SetStackLightIntent").require("SetKeyword").require(
"StackLightKeyword").require("ColorKeyword").build())
def handle_set_stack_light_intent(self, message):
LOG.info('Condor.ai was asked: ' + message.data.get('utterance'))
color_kw = message.data.get("ColorKeyword")
self.speak_dialog("set_stacklight",
data={"result": str(color_kw)},
wait=True)
@intent_handler(
IntentBuilder("RobotStartIntent").require("BusinessKeyword").require(
"CardKeyword").optionally("ConestogaKeyword").build())
def handle_robot_start_intent(self, message):
LOG.info('Condor.ai was asked: ' + message.data.get('utterance'))
str_remainder = str(message.utterance_remainder())
self.start_robot()
@intent_handler(
IntentBuilder("CardConversationIntent").require(
"BusinessCardContextKeyword").one_of('YesKeyword',
'NoKeyword').build())
def handle_card_conversation_intent(self, message):
LOG.info('Condor.ai was asked: ' + message.data.get('utterance'))
str_remainder = str(message.utterance_remainder())
self.set_context('BusinessCardContextKeyword', '')
if "YesKeyword" in message.data:
self.start_robot()
else:
self.speak_dialog("no_card", wait=False)
def card_conversation(self):
low_number = 1
high_number = self.cardRequestFreq
my_number = random.randint(low_number, high_number)
LOG.info('Card Request Context ID: ' + str(my_number) + '/' +
str(high_number))
if my_number == high_number:
self.set_context('BusinessCardContextKeyword',
'SetBusinessCardContext')
self.speak_dialog("ask_card", wait=True, expect_response=True)
def gpio_on(self, board_number, gpio_request_number):
GPIO.setup(board_number, GPIO.OUT, initial=0)
GPIO.output(board_number, True)
LOG.info('Turning On GPIO Number: ' + str(gpio_request_number))
self.speak_dialog("on",
data={"result": str(gpio_request_number)},
wait=True)
def gpio_off(self, board_number, gpio_request_number):
GPIO.setup(board_number, GPIO.OUT, initial=0)
GPIO.output(board_number, False)
LOG.info('Turning Off GPIO Number: ' + str(gpio_request_number))
self.speak_dialog("off",
data={"result": str(gpio_request_number)},
wait=True)
def get_card(self, program_select):
GPIO.setup(program_select, GPIO.OUT, initial=0)
GPIO.output(program_select, True)
def start_robot(self):
LOG.info(self.comm.IPAddress)
self.write_plc("StartRobot", 1)
LOG.info('PLC Output Should be On')
self.speak_dialog("retrieve_card", wait=False)
sleep(1)
self.write_plc(self.plcOutTagName, 0)
LOG.info('PLC Output Should be Off')
inTag = self.comm.Read(self.plcInTagName)
while inTag.value == 0:
inTag = self.comm.Read(self.plcInTagName)
LOG.info('Checking Robot Complete Status: ' + str(inTag.value))
if inTag.value == 1:
self.speak_dialog("card_delivered", wait=False)
else:
sleep(1)
def write_plc(self, myTagName, myTagValue):
LOG.info('Writing: ' + myTagName + ' A value of: ' + str(myTagValue))
self.comm.Write(myTagName, myTagValue)
self.comm.Close()
# listening event used for kodi notifications
def handle_listen(self, message):
voice_payload = message.data.get('utterance')
if self.notifier_bool:
try:
LOG.info(voice_payload)
except Exception as e:
LOG.error(e)
self.on_websettings_changed()
# utterance event used for notifications ***This is what the user says***
def handle_utterances(self, message):
voice_payload = str(message.data.get('utterances')[0])
if self.notifier_bool:
try:
LOG.info(voice_payload)
self.send_MQTT("Mycroft/Student", voice_payload)
except Exception as e:
LOG.error(e)
self.on_websettings_changed()
# mycroft speaking event used for notificatons ***This is what mycroft says***
def handle_speak(self, message):
voice_payload = message.data.get('utterance')
if self.notifier_bool:
try:
LOG.info(voice_payload)
self.send_MQTT("Mycroft/AI", voice_payload)
#self.card_conversation()
except Exception as e:
LOG.error(e)
self.on_websettings_changed()
def send_MQTT(self, myTopic, myMessage):
if self.MQTT_Enabled:
LOG.info("MQTT: " + myTopic + ", " + myMessage)
myID = self.id_generator()
#LOG.info("MyID: " + str(myID))
#self.client = mqtt.Client(myID)
#self.client.connect(self.broker_address, self.broker_port) # connect to broker
#self.client.publish(myTopic, myMessage) # publish
#self.client.disconnect()
LOG.info("address: " + self.broker_address + ", Port: " +
str(self.broker_port))
publish.single(myTopic, myMessage, hostname=self.broker_address)
else:
LOG.info(
"MQTT has been disabled in the websettings at https://home.mycroft.ai"
)
def stop(self):
pass
import sys
sys.path.append('..')
'''
Read a little faster by providing the data type
up front
This only really makes sense to do if you have to
read a lot of unique tags. Typically, when you read a
tag, it has to fetch the data type first. This only
happens the first time you read a uniuqe tag name. Once
we have read a tag, we remember the type.
If you have, for example, 1000 tags to read and they are
all unique, you would have have to fetch the data type,
then the value, which is quite a bit of overhead.
If you pass the data type up front, it will skip that
initial read...
'''
from pylogix import PLC
with PLC() as comm:
comm = PLC()
comm.IPAddress = '192.168.1.9'
tags = [
'BaseINT', ['BaseDINT', 196], ('BaseBOOL', 193), ['BaseSTRING', 160]
]
ret = comm.Read(tags)
for r in ret:
print(r.value)
'''
the following import is only necessary because eip is not in this directory
'''
import sys
sys.path.append('..')
'''
The simplest example of reading a tag from a PLC
NOTE: You only need to call .Close() after you are done exchanging
data with the PLC. If you were going to read in a loop or read
more tags, you wouldn't want to call .Close() every time.
'''
from pylogix import PLC
comm = PLC()
comm.IPAddress = '192.168.1.9'
ret = comm.Read('CurrentScreen')
print(ret.Value)
comm.Close()
'''
the following import is only necessary because eip.py is not in this directory
'''
import sys
sys.path.append('..')
'''
Read a program scoped tag
I have a program named "MiscHMI" in my main task.
In MiscHMI, the tag I'm reading will be TimeArray[0]
You have to specify that the tag will be program scoped
by appending the tag name with "Program" and the beginning,
then add the program name, finally the tag name. So our
example will look like this:
Program:MiscHMI.TimeArray[0]
'''
from pylogix import PLC
with PLC() as comm:
comm = PLC()
comm.IPAddress = '192.168.1.9'
value = comm.Read('Program:MiscHMI.TimeArray[0]')
print(value)
'''
the following import is only necessary because eip.py is not in this directory
'''
import sys
sys.path.append('..')
'''
A simple single read using a with statement.
One advantage of using a with statement is that
you don't have to call .Close() when you are done,
this is handled automatically.
'''
from pylogix import PLC
with PLC() as comm:
comm = PLC()
comm.IPAddress = '192.168.1.9'
value = comm.Read('CurrentScreen')
print(value)
'''
the following import is only necessary because eip is not in this directory
'''
import sys
sys.path.append('..')
'''
The simplest example of reading a tag from a PLC
NOTE: You only need to call .Close() after you are done exchanging
data with the PLC. If you were going to read in a loop or read
more tags, you wouldn't want to call .Close() every time.
'''
from pylogix import PLC
comm = PLC()
comm.IPAddress = '192.168.111.249'
comm.ProcessorSlot = 3
value = comm.Read('Dest_IP')
print(value)
comm.Close()
def ReadConditions():
comm = PLC()
comm.IPAddress = '169.254.215.82'
ECR = comm.Read('indicate.0') #!Estop Control Relay PLC
MCR = comm.Read('indicate.1') #Master Control Relay PLC
SCR = comm.Read('indicate.2') #!Sequence Control Relay PLC
SSR = comm.Read('indicate.3') #Sequence Stop Relay PLC
SPR = comm.Read('indicate.4') #Sequence Pause Relay PLC
SRR = comm.Read('indicate.5') #Sequence Resume Relay PLC
window.after(2000, ReadConditions)
if ECR == True:
lbl18 = Label(window,
text="EStop On",
fg="yellow",
bg="red",
bd=2,
relief="raised",
width=12,
height=2)
lbl18.place(x=31, y=150)
elif ECR == False:
lbl18 = Label(window,
text="No_EStop",
fg="red",
bg="yellow",
bd=2,
relief="flat",
width=12,
height=2)
lbl18.place(x=31, y=150)
if MCR == True:
lbl19 = Label(window,
text="Master On",
fg="White",
bg="Firebrick4",
bd=2,
relief="raised",
width=12,
height=2)
lbl19.place(x=161, y=150)
elif MCR == False:
lbl19 = Label(window,
text="Master Off",
fg="Firebrick4",
bg="white",
bd=2,
relief="flat",
width=12,
height=2)
lbl19.place(x=161, y=150)
if SCR == True:
lbl20 = Label(window,
text="Seq On",
fg="White",
bg="Green",
bd=2,
relief="raised",
width=12,
height=2)
lbl20.place(x=291, y=400)
elif SCR == False:
lbl20 = Label(window,
text="Seq Off",
fg="Green",
bg="white",
bd=2,
relief="flat",
width=12,
height=2)
lbl20.place(x=291, y=400)
if SSR == True:
lbl21 = Label(window,
text="Seq Off",
fg="White",
bg="Red",
bd=2,
relief="raised",
width=12,
height=2)
lbl21.place(x=291, y=440)
elif SSR == False:
lbl21 = Label(window,
text="Seq On",
fg="Red",
bg="white",
bd=2,
relief="flat",
width=12,
height=2)
lbl21.place(x=291, y=440)
if SPR == True:
lbl22 = Label(window,
text="Paused",
fg="White",
bg="Navy",
bd=2,
relief="raised",
width=12,
height=2)
lbl22.place(x=291, y=480)
elif SPR == False:
lbl22 = Label(window,
text="Resumed",
fg="Navy",
bg="White",
bd=2,
relief="flat",
width=12,
height=2)
lbl22.place(x=291, y=480)
if SRR == True:
lbl23 = Label(window,
text="Resumed",
fg="White",
bg="Olive Drab",
bd=2,
relief="raised",
width=12,
height=2)
lbl23.place(x=291, y=520)
elif SRR == False:
lbl23 = Label(window,
text="Paused",
fg="Olive Drab",
bg="White",
bd=2,
relief="flat",
width=12,
height=2)
lbl23.place(x=291, y=520)
return
from pylogix import PLC
# Setup the PLC object with initial parameters
# Change to your plc ip address, and slot, default is 0, shown for clarity
comm = PLC('192.168.1.207', 0)
# Read returns Response class (.TagName, .Value, .Status)
ret = comm.Read('bool_01')
print(ret.TagName, ret.Value, ret.Status)
# Close Open Connection to the PLC
comm.Close()
from pylogix import PLC
# Setup the PLC object with initial parameters
# Change to your plc ip address, and slot, default is 0, shown for clarity
comm = PLC('192.168.1.207', 0)
# Read returns Response class (.TagName, .Value, .Status)
ret = comm.Read('Program:MainProgram.bool_01')
print(ret.TagName, ret.Value, ret.Status)
# Close Open Connection to the PLC
comm.Close()
Read a list of tags at once
Reading lists and arrays is much more efficient than
reading them individually. You can create a list of tags
and pass it to .Read() to read them all in one packet.
The values returned will be in the same order as the tags
you passed to Read()
NOTE: Packets have a ~500 byte limit, so you have to be cautions
about not exceeding that or the read will fail. It's a little
difficult to predict how many bytes your reads will take up becuase
the send packet will depend on the length of the tag name and the
reply will depened on the data type. Strings are a lot longer than
DINT's for example.
I'll usually read no more than 5 strings at once, or 10 DINT's)
'''
from pylogix import PLC
tag_list = [
'Zone1ASpeed', 'Zone1BSpeed', 'Zone2ASpeed', 'Zone2BSpeed', 'Zone3ASpeed',
'Zone3BSpeed', 'Zone4ASpeed', 'ZOne4BSpeed', 'Zone1Case', 'Zone2Case'
]
with PLC() as comm:
comm = PLC()
comm.IPAddress = '192.168.1.9'
ret = comm.Read(tag_list)
for r in ret:
print(r.Value)
'''
the following import is only necessary because eip.py is not in this directory
'''
import sys
sys.path.append('..')
'''
Read an array of values
I have a tag called "LargeArray", which is DINT[10000]
We can read as many of them as we'd like, which makes
reading arrays the most efficient way to read data.
Read will handle multi-packet replies.
We're going to pass Read() the tag and the number
to read.
'''
from pylogix import PLC
with PLC() as comm:
comm = PLC()
comm.IPAddress = '192.168.1.9'
values = comm.Read('LargeArray[0]', 500)
print(values)
'''
the following import is only necessary because eip.py is not in this directory
'''
import sys
sys.path.append('..')
'''
Read a little faster by providing the data type
up front
This only really makes sense to do if you have to
read a lot of unique tags. Typically, when you read a
tag, it has to fetch the data type first. This only
happens the first time you read a uniuqe tag name. Once
we have read a tag, we remember the type.
If you have, for example, 1000 tags to read and they are
all unique, you would have have to fetch the data type,
then the value, which is quite a bit of overhead.
If you pass the data type up front, it will skip that
initial read...
'''
from pylogix import PLC
with PLC() as comm:
comm = PLC()
comm.IPAddress = '192.168.1.9'
value = comm.Read('CurrentScreen', datatype=196)
print(value)
fileName = 'Node06'
data0 = 'Timestamp,S1, S2,S3,S4,S5,S6,S7,S8,S9,S10,S11,S12,S13,S14,S15,S21,S22,S23,S24,S25,S26,S27,S28,S29,S30,S31,S32,S33,S34,S35,S41,S42,S43,S44,S45,S46,S47,S48,S49,S50,S51,S52,S53,S54,S55\n'
# open the file as write mode
# data = ''.join(data2)
# data = ''.join(map(str, data0))
while loop_PLC:
try:
Time_now = datetime.now()
second = Time_now.strftime("%S")
if (second >= "30" and second <= "30"):
T1 = comm1.Read('Real1')
T1_data = str(T1).split(' ')
print(T1_data[1])
S1 = T1_data[1]
T2 = comm1.Read('Real2')
T2_data = str(T2).split(' ')
print(T2_data[1])
S2 = T2_data[1]
T3 = comm1.Read('Real3')
T3_data = str(T3).split(' ')
print(T3_data[1])
S3 = T3_data[1]
T4 = comm1.Read('Real4')
T4_data = str(T4).split(' ')
print(T4_data[1])
S4 = T4_data[1]
