class GenericADC(Device):
''' A generic ADC signal'''
def __init__(self, slave, channel, pdoentry, cycle=""):
self.__super.__init__()
self.slave = slave
self.channel = channel
self.sample = pdoentry.split(" : ")[0]
self.cycle = cycle
self.slave_name = slave.name
assert (self.sample in self.slave.getAllSignals())
def Initialise_FIRST(self):
if self.cycle:
print 'ADC_Ethercat_Sampler("%(slave_name)s",' % self.__dict__ \
+ '%(channel)d,"%(sample)s","%(cycle)s")' % self.__dict__
else:
print 'ADC_Ethercat_Sampler("%(slave_name)s",%(channel)d,"%(sample)s")' \
% self.__dict__
ArgInfo = makeArgInfo(
__init__,
slave=Ident("ethercat slave", EthercatSlave),
channel=Simple("channel id number", int),
pdoentry=Choice("parameter in the form pdo_name.entry_name",
ethercat.pdo_entry_choices),
cycle=Simple("cycle parameter in the form pdo_name.entry_name", str))
class PdoAssignment(Device):
''' An entry to add a PDO in a slave's sync manager'''
def __init__(self, slave, smnumber, pdo_index):
self.__super.__init__()
self.slave = slave
self.smnumber = smnumber
self.slave.assignPdo(smnumber, pdo_index)
ArgInfo = makeArgInfo(__init__,
slave=Ident("ethercat slave", EthercatSlave),
smnumber=Simple("sync manager number", int),
pdo_index=Simple(
"pdo index to include in sync manager", int))
class SdoEntryControl(Device):
def __init__(self, name, parentsdo, asynparameter, description, subindex,
bit_length):
self.__super.__init__()
self.sdoentry = ethercat.SdoEntry(parentsdo.sdo, name, asynparameter,
description, subindex, bit_length)
ArgInfo = makeArgInfo(__init__,
parentsdo=Ident("parent sdo", SdoControl),
name=Simple("sdo entry name", str),
asynparameter=Simple("asyn parameter prefix", str),
description=Simple("sdo entry description", str),
subindex=Simple("sdo entry subindex", int),
bit_length=Simple("sdo entry bit length", int))
class SdoControl(Device):
def __init__(self, name, slave, index):
self.__super.__init__()
self.sdo = ethercat.Sdo(name, slave.name, index)
self.sdoslave = slave
self.sdoslave.assignSdo(self.sdo)
def assignEntry(self, sdoentry):
self.sdo.assignEntry(sdoentry)
ArgInfo = makeArgInfo(__init__,
name=Simple("sdo name", str),
slave=Ident("ethercat slave", EthercatSlave),
index=Simple("sdo index", int))
class EthercatSlave(Device):
''' An EtherCAT slave, usually an entry in a chain '''
Dependencies = (EthercatDevice, )
def __init__(self, master, position, name, type_rev, oversample=0):
self.__super.__init__()
self.master = master
self.chainelem = ethercat.EthercatChainElem(type_rev, position, name,
oversample)
self.name = name
self.master.setSlave(self)
def getAllSignals(self):
if self.chainelem.device == None:
self.master.getDeviceDescriptions()
assert (self.chainelem.device != None)
return self.chainelem.device.getDeviceSignals()
def getTypicalSignals(self):
if self.device == None:
self.master.getDeviceDescriptions()
assert (self.device != None)
return self.device.getTypicalDeviceSignals()
def assignPdo(self, smnumber, pdo_index):
self.chainelem.assignPdo(smnumber, pdo_index)
def assignSdo(self, sdo):
self.chainelem.assignSdo(sdo)
ArgInfo = makeArgInfo(__init__,
master=Ident("master device for slave",
EthercatMaster),
position=Simple(
"slave position in ethercat chain, "
"or serial number of format DCS00001234", str),
type_rev=Choice("Device type and revision",
ethercat.types_choice),
name=Simple("slave's asyn port name", str),
oversample=Simple(
"slave's oversampling rate, e.g. on "
"an EL4702 oversample=100 bus freq 1kHz "
"gives 100kHz samples", int))