def test_initialization(self):
with self.assertRaises(TypeError):
pyads.Connection()
with self.assertRaises(AttributeError):
pyads.Connection(None, None)
def test_initialization(self):
# type: () -> None
"""Test init process."""
with self.assertRaises(TypeError):
pyads.Connection()
with self.assertRaises(TypeError):
pyads.Connection(None, None)
def run(self):
""" Executed automatically when the thread starts. """
# Create and open a connection.
plc = pyads.Connection(AMS_NET_ID, AMS_NET_PORT)
plc.open()
@plc.notification(pyads.PLCTYPE_BOOL)
def callback(handle, name, timestamp, value):
""" Executed when the variable changes its state. """
data = {'name': name, 'value': value}
self.notification_signal.emit(data) # send data
# Create device notifications.
attr = pyads.NotificationAttrib(1)
plc.add_device_notification('MAIN.qCyl1toMinus', attr, callback)
plc.add_device_notification('MAIN.qCyl1toPlus', attr, callback)
plc.add_device_notification('MAIN.qCyl2toMinus', attr, callback)
plc.add_device_notification('MAIN.qCyl2toPlus', attr, callback)
plc.add_device_notification('MAIN.qCyl3toMinus', attr, callback)
plc.add_device_notification('MAIN.qCyl3toPlus', attr, callback)
plc.add_device_notification('MAIN.qCyl4toMinus', attr, callback)
plc.add_device_notification('MAIN.qCyl4toPlus', attr, callback)
plc.add_device_notification('MAIN.qMot1start', attr, callback)
plc.add_device_notification('MAIN.qMot2start', attr, callback)
plc.add_device_notification('MAIN.qMot3start', attr, callback)
plc.add_device_notification('MAIN.qMot4start', attr, callback)
def thread_plc():
global plot_new_data
remote_ip = '192.168.20.157'
remote_ads = '192.168.30.202.1.1'
plc = pyads.Connection(remote_ads, pyads.PORT_TC3PLC1, remote_ip)
plc.open()
symbols_list = plc.get_all_symbols()
plc.close()
while True:
if not plot_new_data:
plc.open()
namespace = "KrogstrupMBE2.temperatureController[4].znTuner"
time_vector_temp = plc.read_by_name(
namespace + ".FFT_IN", pyads.PLCTYPE_REAL * (1024 * 2))
fft_vector_temp = plc.read_by_name(namespace + ".FFT_OUT",
pyads.PLCTYPE_REAL * (1024 * 2))
plc.close()
time_vector[1] = format_complex_array(time_vector_temp)
fft_plc_vector[1] = format_complex_array(fft_vector_temp)
time_vector[0] = np.arange(0, time_duration, 1 / Fs)
fft_plc_vector[0] = np.linspace(0,
Fs,
len(fft_plc_vector[1]),
endpoint=False)
fft_vector[1] = fft_nonRecursive.dif_fft4(time_vector[1])
fft_vector[0] = np.linspace(0,
Fs,
len(fft_vector[1]),
endpoint=False)
plot_new_data = True
else:
time.sleep(0.1)
pass
def setUp(self):
# type: () -> None
"""Establish connection to the testserver."""
self.test_server.request_history = []
self.plc = pyads.Connection(TEST_SERVER_AMS_NET_ID,
TEST_SERVER_AMS_PORT,
TEST_SERVER_IP_ADDRESS)
def setUp(self):
# Clear request history before each test
self.test_server.request_history = []
self.test_server.handler.reset()
self.plc = pyads.Connection(TEST_SERVER_AMS_NET_ID,
TEST_SERVER_AMS_PORT,
TEST_SERVER_IP_ADDRESS)
def test_methods_with_closed_port(self):
# type: () -> None
"""Test pyads.Connection methods with no open port."""
with self.plc:
adr = self.plc.get_local_address()
self.assertIsNotNone(adr)
plc = pyads.Connection("127.0.0.1.1.1", 851)
self.assertIsNone(plc.get_local_address())
self.assertIsNone(plc.read_state())
self.assertIsNone(plc.read_device_info())
self.assertIsNone(plc.read_write(1, 2, pyads.PLCTYPE_INT, 1, pyads.PLCTYPE_INT))
self.assertIsNone(plc.read(1, 2, pyads.PLCTYPE_INT))
self.assertIsNone(plc.read_by_name("hello", pyads.PLCTYPE_INT))
self.assertIsNone(plc.get_handle("hello"))
self.assertIsNone(
plc.read_structure_by_name(
"hello", (("", pyads.PLCTYPE_BOOL, 1), ("", pyads.PLCTYPE_BOOL, 1))
)
)
self.assertIsNone(
plc.add_device_notification(
"test", pyads.NotificationAttrib(4), lambda x: x
)
)
def test_no_ip_address(self):
"""
Autogenerate IP-address from AMS net id if no ip address is given
on initialization.
"""
plc = pyads.Connection(TEST_SERVER_AMS_NET_ID, TEST_SERVER_AMS_PORT)
self.assertEqual(TEST_SERVER_IP_ADDRESS, plc.ip_address)
def conn_open(self):
"""Open a connection with the TwinCAT message router."""
try:
self.conn = pyads.Connection(self.net_id, self.net_port)
self.conn.open()
except pyads.pyads_ex.ADSError as err:
print(err)
else:
self.textconn.setText("Yhteys: Auki")
def __init__(self, thermocouples_count) -> None:
super().__init__()
self.twincat_info = TwinCatConnectionInfo.from_twincat_config()
self.plc = pyads.Connection(self.twincat_info.ams_net_id,
pyads.PORT_SPECIALTASK1)
self.thermocouples_count = thermocouples_count
self.status_datatype = pyads.PLCTYPE_USINT
self.value_datatype = pyads.PLCTYPE_UINT
self.channel_size = 3
def setup(hass, config):
"""Set up the ADS component."""
import pyads
conf = config[DOMAIN]
# get ads connection parameters from config
net_id = conf.get(CONF_DEVICE)
ip_address = conf.get(CONF_IP_ADDRESS)
port = conf.get(CONF_PORT)
# create a new ads connection
client = pyads.Connection(net_id, port, ip_address)
# add some constants to AdsHub
AdsHub.ADS_TYPEMAP = {
ADSTYPE_BOOL: pyads.PLCTYPE_BOOL,
ADSTYPE_BYTE: pyads.PLCTYPE_BYTE,
ADSTYPE_INT: pyads.PLCTYPE_INT,
ADSTYPE_UINT: pyads.PLCTYPE_UINT,
}
AdsHub.PLCTYPE_BOOL = pyads.PLCTYPE_BOOL
AdsHub.PLCTYPE_BYTE = pyads.PLCTYPE_BYTE
AdsHub.PLCTYPE_INT = pyads.PLCTYPE_INT
AdsHub.PLCTYPE_UINT = pyads.PLCTYPE_UINT
AdsHub.ADSError = pyads.ADSError
# connect to ads client and try to connect
try:
ads = AdsHub(client)
except pyads.pyads.ADSError:
_LOGGER.error('Could not connect to ADS host (netid=%s, port=%s)',
net_id, port)
return False
# add ads hub to hass data collection, listen to shutdown
hass.data[DATA_ADS] = ads
hass.bus.listen(EVENT_HOMEASSISTANT_STOP, ads.shutdown)
def handle_write_data_by_name(call):
"""Write a value to the connected ADS device."""
ads_var = call.data.get(CONF_ADS_VAR)
ads_type = call.data.get(CONF_ADS_TYPE)
value = call.data.get(CONF_ADS_VALUE)
try:
ads.write_by_name(ads_var, value, ads.ADS_TYPEMAP[ads_type])
except pyads.ADSError as err:
_LOGGER.error(err)
hass.services.register(DOMAIN,
SERVICE_WRITE_DATA_BY_NAME,
handle_write_data_by_name,
schema=SCHEMA_SERVICE_WRITE_DATA_BY_NAME)
return True
def connect_to_plc():
#import pyads
# connect to plc and open connection
#plc = pyads.Connection("192.9.66.203.1.1", 851) # my twincat
plc = pyads.Connection("192.9.45.134.1.1", 851) # lab twincat
print("Connecting..")
plc.open()
print("Connected!")
plc.read_device_info()
return plc
def test_decorated_device_notification(self):
plc = pyads.Connection(TEST_SERVER_AMS_NET_ID, TEST_SERVER_AMS_PORT)
@plc.notification(pyads.PLCTYPE_INT)
def callback(handle, name, timestamp, value):
print (handle, name, timestamp, value)
with plc:
plc.add_device_notification("a", pyads.NotificationAttrib(20), callback)
plc.write_by_name("a", 1, pyads.PLCTYPE_INT)
def __init__(self, ip_address, ams_id, port):
self.running = True
self.ip_address = ip_address
self.ams_id = ams_id
self.port = port
self.symbols = {}
self.ads = pyads.Connection(ams_id, port, ip_address=ip_address)
self.queue = queue.Queue()
self.thread = threading.Thread(target=self._thread, daemon=True)
self.thread.start()
self.poll_threads = {}
def __init__(self, config):
self.config = config
self.plc = pyads.Connection(config['PLC_ID'], 851)
self.lcr = bkp891.connect(config['LCR_SERIAL'])
self.queue = Queue()
self.worker = MeasurementWorker(self.queue, self.start_measure)
self.callback = self.plc.notification(pyads.PLCTYPE_BOOL)(
self._callback)
logger.debug("Bridge created")
def test_context(self):
handler = BasicHandler()
test_server = AdsTestServer(handler=handler, logging=False)
with test_server:
time.sleep(0.1) # Give server a moment to spin up
plc = pyads.Connection(TEST_SERVER_AMS_NET_ID,
TEST_SERVER_AMS_PORT)
with plc:
byte = plc.read(12345, 1000, pyads.PLCTYPE_BYTE)
self.assertEqual(byte, 0)
time.sleep(0.1) # Give server a moment to spin down
def __init__(self,
ams_net_id: str,
ams_net_port: str,
plc_ip_address=None,
callback=None):
self.notification_handles = []
self.cb = callback
try:
print("Connecting to plc...")
self.plc = pyads.Connection(ams_net_id, ams_net_port,
plc_ip_address)
self.plc.open()
except pyads.ADSError as e:
print("Ads Error: ", e)
def setUp(self):
# type: () -> None
"""Establish connection to the test server."""
# Clear test server and handler
self.test_server.request_history = []
self.handler.reset()
# Create PLC variable that is added by default
self.test_var = PLCVariable("TestDouble",
ads_type=constants.ADST_REAL64,
symbol_type="LREAL")
self.test_var.comment = "Some variable of type double"
self.handler.add_variable(self.test_var)
self.plc = pyads.Connection(TEST_SERVER_AMS_NET_ID,
TEST_SERVER_AMS_PORT,
TEST_SERVER_IP_ADDRESS)
def setup(hass: HomeAssistant, config: ConfigType) -> bool:
"""Set up the ADS component."""
conf = config[DOMAIN]
net_id = conf[CONF_DEVICE]
ip_address = conf.get(CONF_IP_ADDRESS)
port = conf[CONF_PORT]
client = pyads.Connection(net_id, port, ip_address)
try:
ads = AdsHub(client)
except pyads.ADSError:
_LOGGER.error(
"Could not connect to ADS host (netid=%s, ip=%s, port=%s)",
net_id,
ip_address,
port,
)
return False
hass.data[DATA_ADS] = ads
hass.bus.listen(EVENT_HOMEASSISTANT_STOP, ads.shutdown)
def handle_write_data_by_name(call: ServiceCall) -> None:
"""Write a value to the connected ADS device."""
ads_var = call.data[CONF_ADS_VAR]
ads_type = call.data[CONF_ADS_TYPE]
value = call.data[CONF_ADS_VALUE]
try:
ads.write_by_name(ads_var, value, ADS_TYPEMAP[ads_type])
except pyads.ADSError as err:
_LOGGER.error(err)
hass.services.register(
DOMAIN,
SERVICE_WRITE_DATA_BY_NAME,
handle_write_data_by_name,
schema=SCHEMA_SERVICE_WRITE_DATA_BY_NAME,
)
return True
async def initializeADS(request):
global PLC
if request.body_exists:
data = await request.read()
data = json.loads(data.decode("utf-8"))
AMSNetID = data["target"]
if AMSNetID != None:
PLC = pyads.Connection(AMSNetID, 851)
PLC.open()
return web.json_response(
{
"target": AMSNetID,
"description": "Service initialized"
},
status=200)
else:
return web.json_response({"description": "Wrong init information"},
status=400)
def check_connection_with_twincat(self):
""" Check the connection with the TwinCAT message router. """
try:
self.connection = pyads.Connection(AMS_NET_ID, AMS_NET_PORT)
self.connection.open()
self.state = self.connection.read_state(
) # (adsState, deviceState)
except pyads.pyads_ex.ADSError as error:
# No connection.
self.connection.close()
self.open_messagebox_critical(error) # open a popup window
else:
if self.state[0] == 5:
# Successfull connection.
self.open_messagebox_information()
self.start_threading()
self.create_mover_instances()
else:
# Wrong port.
self.connection.close()
self.open_messagebox_critical('Wrong port number.')
def connect(self) -> bool:
""" Connect driver.
: returns: True if connection stablished False if not
"""
# Create connection
try:
import pyads
self._connection = pyads.Connection(self.net_id, self.port)
self._connection.open()
except Exception as e:
self.sendDebugInfo(
f"Connection with {self.net_id} cannot be stablished.")
return False
# Check connection status.
state = self._connection.read_state()
if state[0] == 5:
return True
else:
self.sendDebugInfo(f"Driver not connected, ADS state = {state[0]}")
return False
def __init__(self, config):
self.config = config
self.is_error = False
try:
self._plc = pyads.Connection(config['PLC_ID'], 851)
except pyads.ADSError as e:
logger.exception(e)
self.is_error = True
exit(1)
self.queue = queue.Queue()
try:
self._t = SeleniumWorker(self.queue, config)
except ValueError as e:
self.handle_error('Error during setup. Check the logs.', e)
exit(1)
self.callback = self._plc.notification(pyads.PLCTYPE_BOOL)(
self._callback)
def connect(self):
import pyads
self.contr_sys = pyads.Connection(self.ads_id, self.ads_port)
self.contr_sys.open()
def setup(hass, config):
"""Set up the ADS component."""
conf = config[DOMAIN]
net_id = conf.get(CONF_DEVICE)
ip_address = conf.get(CONF_IP_ADDRESS)
port = conf.get(CONF_PORT)
client = pyads.Connection(net_id, port, ip_address)
AdsHub.ADS_TYPEMAP = {
ADSTYPE_BOOL: pyads.PLCTYPE_BOOL,
ADSTYPE_BYTE: pyads.PLCTYPE_BYTE,
ADSTYPE_DINT: pyads.PLCTYPE_DINT,
ADSTYPE_INT: pyads.PLCTYPE_INT,
ADSTYPE_UDINT: pyads.PLCTYPE_UDINT,
ADSTYPE_UINT: pyads.PLCTYPE_UINT,
}
AdsHub.ADSError = pyads.ADSError
AdsHub.PLCTYPE_BOOL = pyads.PLCTYPE_BOOL
AdsHub.PLCTYPE_BYTE = pyads.PLCTYPE_BYTE
AdsHub.PLCTYPE_DINT = pyads.PLCTYPE_DINT
AdsHub.PLCTYPE_INT = pyads.PLCTYPE_INT
AdsHub.PLCTYPE_UDINT = pyads.PLCTYPE_UDINT
AdsHub.PLCTYPE_UINT = pyads.PLCTYPE_UINT
try:
ads = AdsHub(client)
except pyads.ADSError:
_LOGGER.error(
"Could not connect to ADS host (netid=%s, ip=%s, port=%s)",
net_id,
ip_address,
port,
)
return False
hass.data[DATA_ADS] = ads
hass.bus.listen(EVENT_HOMEASSISTANT_STOP, ads.shutdown)
def handle_write_data_by_name(call):
"""Write a value to the connected ADS device."""
ads_var = call.data.get(CONF_ADS_VAR)
ads_type = call.data.get(CONF_ADS_TYPE)
value = call.data.get(CONF_ADS_VALUE)
try:
ads.write_by_name(ads_var, value, ads.ADS_TYPEMAP[ads_type])
except pyads.ADSError as err:
_LOGGER.error(err)
hass.services.register(
DOMAIN,
SERVICE_WRITE_DATA_BY_NAME,
handle_write_data_by_name,
schema=SCHEMA_SERVICE_WRITE_DATA_BY_NAME,
)
return True
class Plc():
__plc = pyads.Connection('127.0.0.1.1.1', 851) #local connection
def __init__(self):
pass
def prepare(self):
'''opens connection'''
self.__plc.open()
def close(self):
''' closes connection'''
self.__plc.close()
def __writeValue(self,variable):
if self.__plc.is_open:
#Writes
self.__plc.write_by_name(variable.name,variable.writeValue, variable.datatype)
variable.isDirty = False
def __readValue(self, variable):
if self.__plc.is_open:
#reads
return self.__plc.read_by_name(variable.name, variable.datatype)
def __updateValues(self, variable):
if self.__plc.is_open:
newValue = self.__readValue(variable)
variable.updateValue(newValue)
def blockWriteValues(self, varList):
if self.__plc.is_open:
#for loop through list with variable entries
for x in varList:
#checks if there are unsaved changes
if varList[x].isDirty:
self.__writeValue(varList[x])
def blockUpdateValues(self, varList):
if self.__plc.is_open:
#for loop through list with variable entries
for x in varList:
self.__updateValues(varList[x])
import pyads
from time import sleep
plc = pyads.Connection('5.46.12.154.1.1',pyads.PORT_TC3PLC1)
plc.open()
print('open')
sleep(1)
print(plc.read_state())
# input('Enter to continue..')
################################################################
# Setup symbols
DRIVETIME :float = 2
WAITTIME :float = 0.5
################################################################
# Horizontal Axis
hEnable = plc.get_symbol('HAVL.enable')
hForward = plc.get_symbol('HAVL.forward')
hBackward = plc.get_symbol('HAVL.backwards')
hResetError = plc.get_symbol('HAVL.resetError')
################################################################
# Rotational Axis
rEnable = plc.get_symbol('RAVL.enable')
rForward = plc.get_symbol('RAVL.forward')
rBackward = plc.get_symbol('RAVL.backwards')
rResetError = plc.get_symbol('RAVL.resetError')
################################################################
# Testing symbols
hEnable.write(False)
hForward.write(False)
hBackward.write(False)
PLC_IP = '141.33.59.208'
USERNAME = '******'
PASSWORD = '******'
ROUTE_NAME = '141.33.59.7'
HOSTNAME = '141.33.59.7'
PLC_AMS_ID = '5.34.116.124.1.1'
pyads.add_route_to_plc(SENDER_AMS,
HOSTNAME,
PLC_IP,
USERNAME,
PASSWORD,
route_name=ROUTE_NAME)
adsport = pyads.PORT_TC3PLC1
print('using port {}'.format(adsport))
plc = pyads.Connection(PLC_AMS_ID, adsport, PLC_IP)
plc.set_timeout(3000)
print('Connecting ...')
plc.open()
print('Connected')
print(plc.read_device_info())
print(plc.read_state())
q = plc.read_by_name('MAIN.Dust5.Q', pyads.PLCTYPE_BOOL)
print(q)
plc.write_by_name('MAIN.Dust5.PV', 8192, pyads.PLCTYPE_WORD)
# plc.read_by_name('global.bool_value', pyads.PLCTYPE_BOOL)
cv = plc.read_by_name('MAIN.Dust5.CV', pyads.PLCTYPE_WORD)
print(cv)
print('Closing ...')
plc.close()
print('Closed')
#%%
import pyads
#%%
plc = pyads.Connection('127.0.0.1.1.1', pyads.PORT_TC3PLC1)
plc.open()
#%%
state = plc.read_state()
print("state: {}".format(state))
#%%
i = plc.read_by_name('POU_LD.INPUT')
print("i: {}".format(i))
#%%
i = not i
print("i: {}".format(i))
plc.write_by_name('POU_LD.INPUT', i)
#%%
plc.close()
import pyads
import os
# clear the screen
os.system('cls')
# title
print("PYADS Quick Demo")
print("-------------------")
# connection
plc = pyads.Connection('127.0.0.1.1.1', 851)
plc.open()
# read test
readResult = plc.read_by_name('global.bool_value', pyads.PLCTYPE_BOOL)
print('global.bool_value = ' + str(readResult))
# read and write true test
plc.write_by_name('global.bool_value', True, pyads.PLCTYPE_BOOL)
readResult = plc.read_by_name('global.bool_value', pyads.PLCTYPE_BOOL)
print('global.bool_value = ' + str(readResult))
plc.close()
