Skip to content

Instantly share code, notes, and snippets.

@pklaus

pklaus/pyYASDI.py

Created March 19, 2014 16:52
Show Gist options
  • Save pklaus/9646059 to your computer and use it in GitHub Desktop.
Save pklaus/9646059 to your computer and use it in GitHub Desktop.
Download ZIP
Raw
pyYASDI.py
about = """
Titel: pyYASDI
Autor: Sebastian Schulte
Version: 1.0.0
Datum: 18.3.07 / 18.3.07 / 18.3.07
Datei: pyYASDI.py
+ SMA YASDI Library Wrapper fuer Python Scripting Language v1"""
import yasdiwrapper
class pyYASDI:
"""pyYASDI - ermoeglicht bequeme SMANet bedienung"""
def __init__(self,driver=0,debug=0,max_devices=1):
"""Konstruktor
Parameter:
driver = 0 0 = 1.Driver in der yasdi.ini
debug = 1/0 1 = an oder 0 = aus
max_devices = 1 maximale Geraete die zu suchen sind"""
self.max_devices = max_devices
self.debug = debug
self.driver = driver
self.DeviceList = []
self.YasdiMaster = yasdiwrapper.YasdiMaster()
self.Yasdi = yasdiwrapper.Yasdi()
self.YasdiMaster.yasdiMasterInitialize()
self.DriverName = self.goOnline(self.driver)
if self.DriverName == 0: self.die()
result = self.detectDevices(self.max_devices)
self.load_devices()
def msg(self,msg,error=0):
"""msg Methode fuer Debug ausgaben etc.
Parameter:
msg = Die Nachricht die ausgegeben / gespeichert werden soll
error = 0 error = 0 Status error = 1 Fehlermeldung"""
if error == 0:
if self.debug: print ":> %s"%(msg)
elif error == 1:
if self.debug: print ":> Error: %s"%(msg)
def quit(self):
"""Beendet den Yasdi-Master und gibt die Resourcen wieder frei"""
self.YasdiMaster.yasdiMasterShutdown()
def die(self):
"""Beendet den Yasdi-Master aufgrund eines Fehlers"""
self.msg("gestorben",1)
self.quit()
def goOnline(self,driver):
"""Sorgt dafuer das eine Schnittstelle eingeschaltet wird
Parameter:
driver 0 = 1. Schnittstelle in yasdi.ini usw.
Ergebnis:
0 bei Fehler oder z.B.
COM1 Wenn die erste serielle Schnittstelle geladen wurde"""
anzdriver = self.Yasdi.yasdiGetDriver()
if anzdriver == 0:
self.msg("konnte Schnittstelle nicht laden",1)
return anzdriver
else:
self.Yasdi.yasdiSetDriverOnline(driver)
DriverName = self.Yasdi.yasdiGetDriverName(driver)
self.msg("Schnittstelle %s bereit"%(DriverName))
return DriverName
def detectDevices(self,max_devices):
"""Geraeteerkennung
Parameter:
max_devices max. Geraete die gesucht werden sollen
Ergebnis:
0 wenn nicht alle Geraete gefunden wurden
1 wenn alle Geraete gefunden wurden"""
result = self.YasdiMaster.DoMasterCmdEx(max_devices)
if result == -1:
self.msg("konnte nicht alle %s Geraete finden"%(self.max_devices),1)
return 0
elif not result:
self.msg("konnte alle Geraete finden",0)
return 1
def get_masterstatus(self):
"""Gibt den Status des Masters zurueck, per return und print
Ergebnis:
1 = Initialzustand der Maschine
2 = Geraeteerfassung
3 = festlegen der Netzadressen
4 = Abfrage der Kanallisten
5 = Master-Kommando bearbeitung
6 = Kanaele lesen (Spot oder Parameter)
7 = Kanaele schreiben (nur Parameter)"""
result = self.YasdiMaster.GetMasterStateIndex()
self.msg("Yasdi-Master Status: %s"%(result),0)
return result
def reset(self):
"""Setzt den Yasdi-Master in den Initialisierungszustand zurueck"""
self.quit()
self.__init__(self.driver,self.debug,self.max_devices)
def load_devices(self):
"""Laed die gefunden Geraete per Unterklasse Device"""
self.devicehandleslist = self.YasdiMaster.GetDeviceHandles()
for i in self.devicehandleslist:
if i != 0:
self.DeviceList.append(Device(handle=i,master=self.YasdiMaster,debug=self.debug))
def get_devices(self):
"""Gibt die geladenen Geraete wieder zurueck
Ergebnis:
Device-Klasse eines jeden Geraetes"""
return self.DeviceList
class Device:
"""DeviceKlasse mit den moeglichen Eigenschaften und Methoden eines Geraetes (Wechselrichter und SunnyBC etc.)"""
def __init__(self,handle,master,debug=0):
"""Konstruktor
Parameter:
handle = Geraetehandle
master = Masterklasse
debug = 0 Es werden bei 1 die DebugMsgs zurueckgegeben"""
self.handle = handle
self.master = master
self.debug = debug
self.channels = []
result = self.update_all(nochannels=0)
self.name = result[0]
self.sn = result[1]
self.type = result[2]
def msg(self,msg,error=0):
"""msg Methode fuer Debug ausgaben etc.
Parameter:
msg = Die Nachricht die ausgegeben / gespeichert werden soll
error = 0 error = 0 Status error = 1 Fehlermeldung"""
if error == 0:
if self.debug: print ":> %s"%(msg)
elif error == 1:
if self.debug: print ":> Error: %s"%(msg)
def update_name(self):
"""Aktualisiert den Geraetenamen und gibt ihn zurueck"""
result = self.master.GetDeviceName(self.handle)
self.msg("Geraetename %s"%(result),0)
return result
def update_sn(self):
"""Aktualisiert die GeraeteSN und gibt sie zurueck"""
result = self.master.GetDeviceSN(self.handle)
self.msg("GeraeteSN %s"%(result),0)
return result
def update_type(self):
"""Aktualisiert den Geraetetypen und gibt ihn zurueck"""
result = self.master.GetDeviceType(self.handle)
self.msg("Geraetetyp %s"%(result),0)
return result
def update_channels(self):
"""Aktualisiert die Kanaele des Geraetes und gibt die KanalHandles zurueck"""
result = self.master.GetChannelHandles(handle=self.handle,parameter_channel=0)
for i in result:
if i != 0:
self.channels.append(Channel(channel_handle=i,device_handle=self.handle,parameter_channel=0,master=self.master))
self.msg("Geraetespotchannel %s"%(i),0)
result = self.master.GetChannelHandles(handle=self.handle,parameter_channel=1)
for i in result:
if i != 0:
self.channels.append(Channel(channel_handle=i,device_handle=self.handle,parameter_channel=1,master=self.master))
self.msg("Geraeteparameterchannel %s"%(i),0)
return self.channels
def update_all(self,noname=0,nosn=0,notype=0,nochannels=0):
"""Aktualisiert alles, das komplette Geraet
Parameter:
noname = 0 Namen des Geraetes nicht aktualisieren
nosn = 0 SN des Geraetes nicht aktualisieren
notype = 0 Typen des Geraetes nicht aktualisieren
nochannels = 0 Kanaele des Geraetes nicht aktualisieren
Ergebnis:
Tupel (name,sn,type,channels)"""
name = 0
sn = 0
typ = 0
channels = 0
if not noname: name = self.update_name()
if not nosn: sn = self.update_sn()
if not notype: typ = self.update_type() # type nicht erlaubt weil wegen Schluesselwort
if not nochannels: channels = self.update_channels()
return (name,sn,typ,channels)
def get_name(self):
"""Gibt den GeraeteNamen zurueck"""
return self.name
def get_sn(self):
"""Gibt die GeraeteSN zurueck"""
return self.sn
def get_type(self):
"""Gibt den GeraeteTyp zurueck"""
return self.type
def get_channels(self):
"""Gibt die GeraeteKanaele zurueck"""
return self.channels
def get_formatted(self):
"""Formatierte Ausgabe des Geraetes, die Kanaele werden ink. Value einzeln aktualisiert"""
print "Formatierter Bericht fuer Geraet %s:"%(self.get_name())
for i in self.channels:
name = i.update_name()
value = i.update_value()
unit = i.update_unit()
if value == -3: self.msg("Channeltimeout fuer %s"%(i),1)
else: print "%s = %s%s"%(name,value[0],unit)
class Channel:
"""Konstruktor
Parameter:
channel_handle HandleNummer dieses Kanals
device_handle GeraeteNummer dieses Kanals
parameter_channel 0 = Spotwertkanal 1 = Parameterkanal
max_channel_age = 60 max. Alter eines Spotwertkanals"""
def __init__(self,channel_handle,device_handle,parameter_channel,master,max_channel_age=60):
self.channel_handle = channel_handle
self.device_handle = device_handle
self.max_channel_age = max_channel_age
self.master = master
self.name = ""
self.statustext = [] #Entweder Liste mit Statustexten oder wenn es keine fuer diesen Channel gibt | -1 wenn Kanalhandle ungueltig
self.unit = ""
self.range = 0
self.value = [0,"",0] #(Wert,WertText,Timestamp)
self.timestamp = 0
def msg(self,msg,error=0):
"""msg Methode fuer Debug ausgaben etc.
Parameter:
msg = Die Nachricht die ausgegeben / gespeichert werden soll
error = 0 error = 0 Status error = 1 Fehlermeldung"""
if error == 0:
if self.debug: print ":> %s"%(msg)
elif error == 1:
if self.debug: print ":> Error: %s"%(msg)
def update_statustext(self):
"""Ruft alle Statustexte zu einem Kanal ab und gibt sie als Liste zurueck"""
result = self.master.GetChannelStatTextCnt(self.channel_handle)
if not result:
self.statustext = 0
if result == -1:
self.msg("Kanalhandle %s ungueltig fur Device %s"%(self.channel_handle,self.device_handle),1)
self.statustext = -1
else:
for i in range(1,result):
self.statustext.append(self.master.GetChannelStatText(self.channel_handle,i))
return self.statustext
def update_value(self):
"""Kanalwert aktualisieren, diese Methode braucht einige Sekunden. Gibt den Wert zurueck"""
result = self.master.GetChannelValue(self.channel_handle,self.device_handle,0)
if result == -3: return result
else:
channeltimestamp = self.update_timestamp()
self.value[0] = result[0]
self.value[1] = result[1]
self.value[2] = channeltimestamp
return result
def update_timestamp(self):
"""Aktualisiert den Zeitstempel des Kanals und gibt ihn zurueck"""
result = self.master.GetChannelValueTimeStamp(self.channel_handle)
self.timestamp = result
return result
def update_range(self):
"""Aktualisiert den Kanalbereich und gibt ihn als Tupel zurueck"""
result = self.master.GetChannelValRange(self.channel_handle)
self.range = result
return result
def update_name(self):
"""Aktualisiert den Namen des Kanals und gibt ihn zurueck"""
result = self.master.GetChannelName(self.channel_handle)
self.name = result
return result
def update_unit(self):
"""Aktualisiert den Einheit (kWh) des Kanals und gibt ihn zurueck"""
result = self.master.GetChannelUnit(self.channel_handle)
self.unit = result
return result
def update_all(self,noname=0,nounit=0,nostatustext=0,novalue=1,norange=0):
"""Aktualisiert alles, den kompletten Kanal
Parameter:
noname = 0 Namen des Kanals nicht aktualisieren
nounit = 0 Einheit des Kanals nicht aktualisieren
nostatustext = 0 Statustext des Kanals nicht aktualisieren
novalue = 1 Wert des Kanals nicht aktualisieren
norange = 0 Wertebereich des Kanals nicht aktualisieren
Ergebnis:
Tupel (name,unit,statustext,value,range)"""
statustext = []
value = (0,"",0)
valrange = ()
unit = ""
name = ""
if not noname: name = self.update_name()
if not nounit: unit = self.update_unit()
if not nostatustext: statustext = self.update_statustext()
if not novalue: value = self.update_value()
if not norange: valrange = self.update_range() # range nicht erlaubt weil wegen Schluesselwort
return (name,unit,statustext,value,valrange)
def get_name(self):
"""Gibt den KanalNamen zurueck"""
return self.name
def get_unit(self):
"""Gibt die KanalEinheit zurueck"""
return self.unit
def get_statustext(self):
"""Gibt den KanalStatustext zurueck"""
return self.statustext
def get_value(self):
"""Gibt den KanalWert zurueck"""
return self.value
def get_range(self):
"""Gibt den KanalWerteBereicht zurueck"""
return self.range
if __name__ == "__main__":
#main = pyYASDI()
pass
Raw
yasdiwrapper.py
about = """
Titel: yasdiwrapper
Autor: Sebastian Schulte
Version: 1.0.0
Datum: 18.3.07 / 18.3.07 / 18.3.07
Datei: yasdiwrapper.py
+ SMA YASDI Library Wrapper fuer Python Scripting Language v1"""
import ctypes,array #ctypes laed die Libs in Python, array (BuildIn) fuer C Arrays
class YasdiMaster:
def __init__(self,
ini_file="./yasdi.ini",
yasdiMaster_lib="yasdimaster.dll",
iDeviceHandleCount=50,
iChannelHandleCount=142,
DeviceNameBuffer=30,
DeviceTypeBuffer=30,
ValText=15,
ChannelName=30,
cChanUnit=10,
status_text_buffer=30):
"""Konstruktor
Parameter:
ini_file = "./yasdi.ini" |erwartet Pfad zur ini Datei (mit Schnittstelleninformationen etc.)
yasdiMaster_lib = "yasdimaster.dll" |erwartet Pfad zur yasdimaster Lib
iDeviceHandleCount = 50 |Anzahl der max. zu erfassenden Geraete
iChannelHandleCount = 142 |Anzahl der max. zu erfassenden Kanaele
DeviceNameBuffer = 30 |Anzahl der max. Namenslaenge eines Geraetes
DeviceTypeBuffer = 30 |Anzahl der max. Namenslaenge eines Geraetetypes
ValText = 15 |Anzahl der max. Namenslaenge eines Textes der zu einem Kanal gehoert
ChannelName = 30 |Anzahl der max. Namenslaenge eines Kanalnamens
cChanUnit = 10 |Anzahl der max. Namenslaenge einer Kanaleinheit (z.B. kWp)
status_text_buffer = 30 |Anzahl der max. Nameslaenge eines Statustextes zu einem Kanal"""
self.ini_file = ini_file
self.yasdiMaster_lib = yasdiMaster_lib
self.DriverCount = ctypes.c_ulong()
self.pDriverCount = ctypes.pointer(self.DriverCount)
self.iDeviceHandleCount = iDeviceHandleCount
self.DeviceHandles = array.array("L",[0]*self.iDeviceHandleCount)
self.iChannelHandleCount = iChannelHandleCount
self.ChannelHandles = array.array("L",[0]*self.iChannelHandleCount)
self.DeviceNameBuffer = " "*DeviceNameBuffer
self.DeviceTypeBuffer = " "*DeviceTypeBuffer
self.SNBuffer = ctypes.c_ulong()
self.pSNBuffer = ctypes.pointer(self.SNBuffer)
self.dDevHandle = ctypes.c_ulong()
self.pdDevHandle = ctypes.pointer(self.dDevHandle)
self.ChannelName = " "*ChannelName
self.dblValue = ctypes.c_double(0)
self.pdblValue = ctypes.pointer(self.dblValue)
self.ValText = " "*ValText
self.cChanUnit = " "*cChanUnit
self.status_text_buffer = " "*status_text_buffer
self.ChanType = ctypes.c_ushort()
self.pChanType = ctypes.pointer(self.ChanType)
self.ChanIndex = ctypes.c_int()
self.pChanIndex = ctypes.pointer(self.ChanIndex)
self.range_min = ctypes.c_double()
self.prange_min = ctypes.pointer(self.range_min)
self.range_max = ctypes.c_double()
self.prange_max = ctypes.pointer(self.range_max)
self.yasdiMaster = ctypes.cdll.LoadLibrary(self.yasdiMaster_lib)
def yasdiMasterInitialize(self):
"""Initialisiert die yasdiMaster Lib, diese Mathode muss zuerst aufgerufen werden."""
self.yasdiMaster._yasdiMasterInitialize(self.ini_file,self.pDriverCount)
def yasdiMasterShutdown(self):
"""Beendet die yasdiMaster Lib, diese Methode gibt alle Resourcen wieder frei."""
self.yasdiMaster._yasdiMasterShutdown()
def yasdiReset(self):
"""Setzt die yasdiMaster Lib wiedr in den Ursprungszustend... wie nach yasdiMasterInitialize"""
self.yasdiMaster._yasdiReset()
def GetDeviceHandles(self):
"""Gibt alle GeraeteHandles zurueck (typ: Liste)"""
self.yasdiMaster._GetDeviceHandles(self.DeviceHandles.buffer_info()[0],
self.iDeviceHandleCount)
return self.DeviceHandles.tolist()
def GetDeviceName(self,handle):
"""Gibt zu dem GeraeteHandle den Geraetenamen als String zurueck
Parameter:
handle = Geraetehandle"""
self.yasdiMaster._GetDeviceName(handle,self.DeviceNameBuffer,len(self.DeviceNameBuffer))
return self.DeviceNameBuffer.replace("\x00","").rstrip()
def GetDeviceSN(self,handle):
"""Gibt zu dem GeraeteHandle die Seriennummer zurueck, fuehrende Nullen werden entfernt da das Ergebnis numerisch ist
Parameter:
handle = Geraetehandle"""
self.yasdiMaster._GetDeviceSN(handle,self.pSNBuffer)
return int(self.SNBuffer.value)
def GetDeviceType(self,handle):
"""Gibt zu dem GeraeteHandle den Typ (z.B. SunBC-38) zrueck
Parameter:
handle = Geraetehandle"""
result = self.yasdiMaster._GetDeviceType(handle,self.DeviceTypeBuffer,len(self.DeviceTypeBuffer))
if result == -1:
return result
else:
return self.DeviceTypeBuffer.replace("\x00","").rstrip()
def GetChannelHandles(self,handle,parameter_channel=0):
"""Gibt die ChannelHandles zurueck.
handle = erwartet das entsprechende Handle des Geraetes
parameter_channel = 0 -> Spotwerte| 1 -> Parameterwerte"""
if parameter_channel == 1:
wChanType = ctypes.c_ushort(0x040f)
elif parameter_channel == 0:
wChanType = ctypes.c_ushort(0x090f)
else:
return -1
bChanIndex = ctypes.c_byte(0)
self.yasdiMaster._GetChannelHandles(handle,
self.ChannelHandles.buffer_info()[0],
self.iChannelHandleCount,
wChanType,
bChanIndex)
return self.ChannelHandles.tolist()
def FindChannelName(self,name):
"""Gibt zu einen Kanalnamen den Wert und das Handle zurueck
Parameter:
name = Kanalnamen"""
channel_value = self.yasdiMaster._FindChannelName(self.pdDevHandle,name)
if channel_value == 0:
return channel_value
else:
return (channel_value,self.dDevHandle.value)
def GetChannelName(self,handle):
"""Gibt den ChannelNamen zurueck. -1 bei Misserfolg
Parameter:
handle = erwartet den entsprechenden Handle des Channels"""
result = self.yasdiMaster._GetChannelName(handle,self.ChannelName,len(self.ChannelName))
if result == -1:
return result
else:
return self.ChannelName.replace("\x00","").rstrip().lstrip()
def GetChannelValue(self,channel_handle,device_handle,max_val_age=0):
"""Gibt den Wert einen Channels zu einem Device zurueck.
Parameter:
channel_handle = erwartet einen KanalHandle (Parameter oder Spot)
device_handle = erwartet eine DeviceHandle
max_val_age = maximales Alter in Sekunden, die YASDI Lib wartet darauf (!!)| Std. sind 10Sekunden
Rueckgabe:
Tupel: (Wert,wenn vorhanden Text)
-1: Kanalhandle falsch
-2: YASDI Status ShutDown
-3: Timeout
-4: Unbekannter Fehler; Kanalwert ungueltig"""
result = self.yasdiMaster._GetChannelValue(channel_handle,
device_handle,
self.pdblValue,
self.ValText,
len(self.ValText),
max_val_age)
if result == 0:
return (self.dblValue.value,self.ValText.replace("\x00","").rstrip().lstrip())
else:
return result
def GetChannelValueTimeStamp(self,handle):
"""Sekunden der Epoche, wenn Rueckgabe Null dann ist das Handle ungueltig
Parameter:
handle = Kanalhandle"""
timestamp = self.yasdiMaster._GetChannelValueTimeStamp(handle)
return timestamp
def GetChannelUnit(self,handle):
"""Gibt die Einheit eines Kanals zurueck. z.B. [Pac]=kW
Parameter:
handle = Kanalhandle"""
self.yasdiMaster._GetChannelUnit(handle,self.cChanUnit,len(self.cChanUnit))
return self.cChanUnit.replace("\x00","").rstrip().lstrip()
def GetMasterStateIndex(self):
"""Gibt den Status des yasdiMasters zurueck:
1 = Initialzustand der Maschine
2 = Geraeteerfassung
3 = festlegen der Netzadressen
4 = Abfrage der Kanallisten
5 = Master-Kommando bearbeitung
6 = Kanaele lesen (Spot oder Parameter)
7 = Kanaele schreiben (nur Parameter)"""
result = self.yasdiMaster._GetMasterStateIndex()
return result
def SetChannelValue(self,channel_handle,device_handle,value):
result = self.yasdiMaster._SetChannelValue(channel_handle,device_handle,value)
return result
def GetChannelStatTextCnt(self,handle):
"""Gibt die Anzahl der Statustechte des Kanals zurueck
Parameter:
handle = Kanalhandle"""
result = self.yasdiMaster._GetChannelStatTextCnt(handle)
return result
def GetChannelStatText(self,handle,index,):
"""Gibt den Statustext des Kanals zurueck
Parameter:
handle = Kanalhandle
index = Index des Statustextes, beginnend bei 0"""
result = self.yasdiMaster._GetChannelStatText(handle,index,self.status_text_buffer,len(self.status_text_buffer))
if not result:
return self.status_text_buffer.replace("\x00","").rstrip().lstrip()
else:
return result
def GetChannelMask(self,handle):
"""Gibt die ChannelMast zurueck, d.h. ob die Kanaele Spot oder Parameterkanaele sind
Parameter: Kanalhandle"""
result = self.yasdiMaster._GetChannelMask(handle,self.pChanType,self.pChanIndex)
return (self.ChanType.value,self.ChanIndex.value)
def DoMasterCmdEx(self,device_handle_count,cmd="detection",param1=None,param2=None):
"""Sendet Kommandos an den YASDI-Master. In YASDI 1.3 gibt es nur das Cmd "detection"
Parameter:
device_handle_count = Anzahl der zu suchenden Geraete
cmd = "detection" , das einzige Cmd ist voreingestellt und sucht nach Geraeten
param1 = None k.a.
param2 = None k.a.
Ergebnis:
0 = OK
-1 = es wurden nicht alle Geraete erreicht"""
result = self.yasdiMaster._yasdiDoMasterCmdEx(cmd,device_handle_count,param1,param2)
return result
def GetChannelValRange(self,handle):
"""Gibt den Bereich des Kanals zurueck. z.B. Kanal 82 (DA_Messintervall von 0 - 240)
Parameter:
handle = Kanalhandle
Ergebnis:
Python Tupel(min,max) bei OK
-1: Kanalhandle ist ungueltig
-2: Zeiger fuer Ergebnis ungueltig (sollte durch den yasdiwrapper nicht vorkommen)
-3: wenn es keinen extra Wertebereich gibt
"""
result = self.yasdiMaster._GetChannelValRange(handle,self.prange_min,self.prange_max)
if not result:
return (self.range_min.value,self.range_max.value)
else:
return result
class Yasdi:
"""YASDI Wrapper fuer Python"""
def __init__(self,yasdi_lib="yasdi.dll",maxDriverIDs=10,DriverNameBuffer=30):
"""Konstruktor
Parameter:
yasdi_lib = "yasdi.dll" |erwartet Pfad zur yasdi Lib
maxDriverIDs = 10 |Anzahl der max. moegleichen Schnittstellen
DriverNameBuffer = 30 |Anzahl der max.Namenslaenge des Schnittstellennamens"""
self.maxDriverIDs = maxDriverIDs
self.DriverIDArray = array.array("L",[0]*self.maxDriverIDs)
self.DriverNameBuffer = " "*DriverNameBuffer
self.yasdi = ctypes.cdll.LoadLibrary(yasdi_lib)
def yasdiGetDriver(self):
"""Gibt die Anzahl zur verfuegung stehender Schnittstellen zurueck"""
result = self.yasdi._yasdiGetDriver(self.DriverIDArray.buffer_info()[0],self.maxDriverIDs)
return result
def yasdiGetDriverName(self,driverID):
"""Gibt den Namen eine Schnittstelle zurueck, zum Beispiel: COM1 oder /drv/ttyS0 etc.
Parameter:
driverID = erwartet Schnittstellnummer (z.B. 0)"""
self.yasdi._yasdiGetDriverName(driverID,self.DriverNameBuffer,len(self.DriverNameBuffer))
return self.DriverNameBuffer.replace("\x00","").rstrip().lstrip()
def yasdiSetDriverOnline(self,driverID):
"""Setzt eine Schnittstelle(driver) online, Achtung: unter Linux muss die Schnittstelle freigegeben werden!
Parameter:
driverID = Nummer der Schnittstelle (Com1 = 0 etc.)
Rueckgabe:
0: bei Erfolg
1: bei Fehler"""
result = self.yasdi._yasdiSetDriverOnline(driverID)
return result
def yasdiSetDriverOffline(self,driverID):
"""Gibt die Schnittstelle wieder Frei
Parameter:
driverID = erwartet Schnittstellnummer (z.B. 0)"""
self.yasdi._yasdiSetDriverOffline(driverID)
if __name__ == "__main__":
print about
Master = YasdiMaster()
Slave = Yasdi()
Master.yasdiMasterInitialize()
print "hole Driver(>0) :",Slave.yasdiGetDriver()
print "setze Driver Online(1):",Slave.yasdiSetDriverOnline(6)
print "Geraete erfassen(0) :",Master.DoMasterCmdEx(1) #ein Geraet erfassen
print Master.GetChannelValue(2,1)
Master.yasdiMasterShutdown()
raw_input("Eingabe")
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment