michi/BDE
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

1st Checking of BD

Browse Source
This commit is contained in:
Michael Rest
2016-10-03 13:32:43 +02:00
parent 3f03b15593
commit ec6883e780
22 changed files with 2632 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
.gitignore vendored
View File

@@ -4,3 +4,4 @@ bde.cfg
*.AppleDouble/
.DS_Store
__pycache__/
*.sqlite

368
DB.py Normal file
View File

@@ -0,0 +1,368 @@
#!/opt/local/bin/python3.0
import sqlite3 as sqlite
#from pysqlite2 import dbapi2 as sqlite
from sys import exit
from datetime import datetime
import os
def logtest (level, msg):
print (msg)
def errlogtest (msg):
print (msg)
def connectdb (dbfile):
"""
Create connection to database
return DB Object
user gets information if failure
"""
print ("Verbindung zu %s herstellen" %dbfile)
try:
db = sqlite.connect (dbfile)
return db
except:
print ("Konnte DB Verbindung nicht herstellen")
exit (1)
class DB:
# Database Stuff
# --------------
def __init__ (self, dbfile, talogfile, log, errlog):
self.db = connectdb (dbfile)
self.talogfile = talogfile
self.log = log
self.errlog = errlog
def executesql (self, dbstring, arguments = ()):
"""
Fuehre den uebergebenen SQL-Befehl aus und liefere ein Cursor-Objekt
zurueck.
"""
try:
cursor = self.db.cursor ()
cursor.execute (dbstring, arguments)
except sqlite.Error as e:
print ("An error occurred:", e.args[0])
raise Warning
except OperationalError: #, msg:
print ("Datenbankausfuehrung fehlgeschlagen. Ausgeloest durch: " + dbstring)
raise Warning
except IntegrityError: #, msg:
print ("Doppelter Eintrag. Ausgeloest durch: " + dbstring)
raise Warning
except ProgrammingError: #, msg:
print ("Fehlerhaftes SQL. Ausgeloest durch: " + dbstring)
raise Warning
except Warning: #, msg:
pass
#Build Transaction Log
if (dbstring.find ('DELETE') >= 0) or\
(dbstring.find ('INSERT') >= 0) or\
(dbstring.find ('UPDATE') >= 0):
file = open (self.talogfile, "a")
dt = datetime.now ()
file.write ("%4d-%02d-%02d %02d:%02d:%02d.%06d: " %(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond))
file.write (dbstring + ";\n")
file.close ()
self.db.commit ()
return cursor
# BDE allgemein
#------------------
def bde (self):
"""
Return all Data of BE
"""
try:
cursor = self.executesql ("SELECT * FROM bde;")
except:
return None
res = cursor.fetchall ()
return res
def addbde (self, data):
"""
Add Processdata
without station information
"""
try:
cursor = self.executesql ("INSERT OR REPLACE INTO bde (dmc, startts, ladungstraeger, seriennr) VALUES ('%(dmc)s', '%(startts)s', '%(ladungstraeger)s', '%(seriennr)s');" % data)
except:
print ("Couldnt insert into BDE")
raise Warning
def checkbde (self, dmc):
"""
"""
try:
cursor = self.executesql ("SELECT dmc FROM bde WHERE dmc = '%s';" % dmc)
except:
print ("Couldnt read from into BDE")
l = len (cursor.fetchall ())
return l
def updatebde (self, dmc, field, value):
"""
Updates BDE information
"""
if self.checkbde (dmc) == 0:
print ('Missing bde entry for DMC %s create empty one' % dmc)
self.addbde ({'dmc' : dmc, 'startts' : '', 'ladungstraeger' : '', 'seriennr' : ''})
try:
cursor = self.executesql ("UPDATE bde SET %s = '%s' WHERE dmc = '%s';" % (field, value, dmc))
except:
print ("Couldnt update BDE")
raise Warning
def addpruefzelle1 (self, data):
"""
Add Processdata 01 - pruefzelle 1
and create BDE data
"""
if len (self.getpruefzelle1 (data['dmc'])):
self.errlog ('PD01 for %s already exists - Overwrite' % data['dmc'])
try:
cursor = self.executesql ("INSERT OR REPLACE INTO pruefzelle1 (dmc, startts, endts, pp01, pp02, pp03, pp04, pp05, pp06, pp07, pp08, pp08, pp09, pp10, pp11, pp12, pp13, pp14, pp15, pp16, pp17, pp18, pp19, pp20, pp21, pp22, pp23, pp24, pp25, pp26, pp27, pp28, pp29, pp30, pp31, pp32, pp33, pp34, pp35, pp36, pp37, pp38, pp39, pp40) VALUES ('%(dmc)s', '%(startts)s', '%(endts)s', '%(pp01)s', '%(pp02)s', '%(pp03)s', '%(pp04)s', '%(pp05)s', '%(pp06)s', '%(pp07)s', '%(pp08)s', '%(pp09)s', '%(pp10)s', '%(pp11)s', '%(pp12)s', '%(pp13)s', '%(pp14)s', '%(pp15)s', '%(pp16)s', '%(pp17)s', '%(pp18)s', '%(pp19)s', '%(pp20)s', '%(pp21)s', '%(pp22)s', '%(pp23)s', '%(pp24)s', '%(pp25)s', '%(pp26)s', '%(pp27)s', '%(pp28)s', '%(pp29)s', '%(pp30)s', '%(pp31)s', '%(pp32)s', '%(pp33)s', '%(pp34)s', '%(pp34)s', '%(pp35)s', '%(pp36)s', '%(pp37)s', '%(pp38)s', '%(pp39)s', '%(pp40)s');" % data)
except:
print ("Couldnt insert PD01 pruefzelle1")
raise Warning
if self.checkbde (data['dmc']) > 0:
self.errlog ('BDE Data for %s already exists - Overwrite' % data['dmc'])
self.addbde (data)
self.updatebde (data['dmc'], 'pruefzelle1', data['bauteilstatus'])
if data['dmc'] == 'n.i.O.':
self.updatebde (data['dmc'], 'endts', data['endts'])
self.updatebde (data['dmc'], 'csv', '')
def getpruefzelle1 (self, dmc):
"""
Get Processdata 01 - prufezelle1
"""
try:
cursor = self.executesql ("SELECT dmc, startts, endts, pp01, pp02, pp03, pp04, pp05, pp06, pp07, pp08, pp08, pp09, pp10, pp11, pp12, pp13, pp14, pp15, pp16, pp17, pp18, pp19, pp20, pp21, pp22, pp23, pp24, pp25, pp26, pp27, pp28, pp29, pp30, pp31, pp32, pp33, pp34, pp35, pp36, pp37, pp38, pp39, pp40 FROM pruefzelle1 WHERE dmc = '%s';" % dmc)
except:
print ("Couldnt get PD06 pruefzelle1")
raise Warning
return cursor.fetchall ()
def deletepruefzelle1 (self, dmc):
"""
Delete Pruefzelle1 info
"""
try:
cursor = self.executesql ("DELETE FROM pruefzelle1 WHERE dmc = '%s';" % (dmc))
except:
print ("Couldnt delete from Pruefzelle1")
raise Warning
def addblindniet (self, data):
"""
Add Processdata 05 - blindniet
and update BDE data
"""
try:
cursor = self.executesql ("INSERT INTO blindniet (dmc, startts, endts, DGBM8status01, DGBM8status02, DGBM8status03, DGBM8status04, NietM8status01, NietM8status02, NietM6status01, NietM6status02, NietM6status03, NietM6status04, NietM6status05, DGBM8M01, DGBM8D01, DGBM8W01, DGBM8T01, DGBM8M02, DGBM8D01, DGBM8W02, DGBM8T02, DGBM8M03, DGBM8D03, DGBM8W03, DGBM8T03, DGBM8M04, DGBM8D04, DGBM8W04, DGBM8T04, NietM8F01, NietM8S01, NietM8F02, NietM8S02, NietM6F01, NietM6S01, NietM6F02, NietM6S02, NietM6F03, NietM6S03, NietM6F04, NietM6S04, NietM6F05, NietM6S05) VALUES ('%(dmc)s', '%(startts)s', '%(endts)s', '%(DGBM8status01)s', '%(DGBM8status02)s', '%(DGBM8status03)s', '%(DGBM8status04)s', '%(NietM8status01)s', '%(NietM8status02)s', '%(NietM6status01)s', '%(NietM6status02)s', '%(NietM6status03)s', '%(NietM6status04)s', '%(NietM6status05)s', '%(DGBM8M01)s', '%(DGBM8D01)s', '%(DGBM8W01)s', '%(DGBM8T01)s', '%(DGBM8M02)s', '%(DGBM8D02)s', '%(DGBM8W02)s', '%(DGBM8T02)s', '%(DGBM8M03)s', '%(DGBM8D03)s', '%(DGBM8W03)s', '%(DGBM8T03)s', '%(DGBM8M04)s', '%(DGBM8D04)s', '%(DGBM8W04)s', '%(DGBM8T04)s', '%(NietM8F01)s', '%(NietM8S01)s', '%(NietM8F02)s', '%(NietM8S02)s', '%(NietM6F01)s', '%(NietM6S01)s', '%(NietM6F02)s', '%(NietM6S02)s', '%(NietM6F03)s', '%(NietM6S03)s', '%(NietM6F04)s', '%(NietM6S04)s', '%(NietM6F05)s', '%(NietM6S05)s');" % data)
except:
print ("Couldnt insert PD05 blindniet")
raise Warning
self.updatebde (data['dmc'], 'blindniet', data['bauteilstatus'])
def deleteblindniet (self, dmc):
"""
Delete Blindniet info
"""
try:
cursor = self.executesql ("DELETE FROM blindniet WHERE dmc = '%s';" % (dmc))
except:
print ("Couldnt delete from blindniet")
raise Warning
def getblindniet (self, dmc):
"""
Get Processdata 05 - blindniet
"""
try:
cursor = self.executesql ("SELECT dmc, startts, endts, DGBM8status01, DGBM8status02, DGBM8status03, DGBM8status04, NietM8status01, NietM8status02, NietM6status01, NietM6status02, NietM6status03, NietM6status04, NietM6status05, DGBM8M01, DGBM8D01, DGBM8W01, DGBM8T01, DGBM8M02, DGBM8D01, DGBM8W02, DGBM8T02, DGBM8M03, DGBM8D03, DGBM8W03, DGBM8T03, DGBM8M04, DGBM8D04, DGBM8W04, DGBM8T04, NietM8F01, NietM8S01, NietM8F02, NietM8S02, NietM6F01, NietM6S01, NietM6F02, NietM6S02, NietM6F03, NietM6S03, NietM6F04, NietM6S04, NietM6F05, NietM6S05 FROM blindniet WHERE dmc = '%s';" % dmc)
except:
print ("Couldnt get PD05 blindniet")
raise Warning
return cursor.fetchone ()
def addbajonettclip (self, data):
"""
Add Processdata 06 - bajonettclip
and update BDE data
"""
if len (self.getbajonettclip (data['dmc'])):
self.errlog ('PD06 for %s already exists - Overwrite' % data['dmc'])
try:
cursor = self.executesql ("INSERT OR REPLACE INTO bajonettclip (dmc, startts, endts, aufnahme, bajostatus01, bajostatus02, bajostatus03, bajostatus04) VALUES ('%(dmc)s', '%(startts)s', '%(endts)s', '%(aufnahme)s', '%(bajostatus01)s', '%(bajostatus02)s', '%(bajostatus03)s', '%(bajostatus04)s');" % data)
except:
print ("Couldnt insert PD06 bajonettclip")
raise Warning
self.updatebde (data['dmc'], 'bajonettclip', data['bauteilstatus'])
def getbajonettclip (self, dmc):
"""
Get Processdata 06 - bajonettclip
"""
try:
cursor = self.executesql ("SELECT dmc, startts, endts, aufnahme, bajostatus01, bajostatus02, bajostatus03, bajostatus04 FROM bajonettclip WHERE dmc = '%s';" % dmc)
except:
print ("Couldnt get PD06 bajonettclip")
raise Warning
return cursor.fetchall ()
def deletebajonettclip (self, dmc):
"""
Delete Bajonettclip info
"""
try:
cursor = self.executesql ("DELETE FROM bajonettclip WHERE dmc = '%s';" % (dmc))
except:
print ("Couldnt delete from bajonettclip")
raise Warning
def addcclip (self, data):
"""
Add Processdata 07 - cclip
and update BDE data
"""
if len (self.getbajonettclip (data['dmc'])):
self.errlog ('PD07 for %s already exists - Overwrite' % data['dmc'])
try:
cursor = self.executesql ("INSERT OR REPLACE INTO cclip (dmc, startts, endts, aufnahme, clipstatus01, clipstatus02, clipstatus03, clipstatus04, clipstatus05, clipstatus06, clipstatus07, clipstatus08, clipstatus09, clipstatus10, clipstatus11, clipstatus12, clipstatus13, clipstatus14, clipstatus15, clipstatus16, clipstatus17, clipstatus18) VALUES ('%(dmc)s', '%(startts)s', '%(endts)s', '%(aufnahme)s', '%(clipstatus01)s', '%(clipstatus02)s', '%(clipstatus03)s', '%(clipstatus04)s', '%(clipstatus05)s', '%(clipstatus06)s', '%(clipstatus07)s', '%(clipstatus08)s', '%(clipstatus09)s', '%(clipstatus10)s', '%(clipstatus11)s', '%(clipstatus12)s', '%(clipstatus13)s', '%(clipstatus14)s', '%(clipstatus15)s', '%(clipstatus16)s', '%(clipstatus17)s', '%(clipstatus18)s');" % data)
except:
print ("Couldnt insert PD07 cclip")
raise Warning
self.updatebde (data['dmc'], 'cclip', data['bauteilstatus'])
def getcclip (self, dmc):
"""
Get Processdata 07 - cclip
"""
try:
cursor = self.executesql ("SELECT dmc, startts, endts, aufnahme, lipstatus01, clipstatus02, clipstatus03, clipstatus04, clipstatus05, clipstatus06, clipstatus07, clipstatus08, clipstatus09, clipstatus10, clipstatus11, clipstatus12, clipstatus13, clipstatus14, clipstatus15, clipstatus16, clipstatus17, clipstatus18WHERE dmc = '%s';" % dmc)
except:
print ("Couldnt get PD07 cclip")
raise Warning
return cursor.fetchall ()
def deletecclip (self, dmc):
"""
Delete CClip info
"""
try:
cursor = self.executesql ("DELETE FROM cclip WHERE dmc = '%s';" % (dmc))
except:
print ("Couldnt delete from cclip")
raise Warning
def addmasseblech (self, data):
"""
Add Processdata 08 - masseblech
and update BDE data
"""
try:
cursor = self.executesql ("INSERT OR REPLACE INTO masseblech (dmc, startts, endts, ausgleichselement, schallisolierung, masseblech, blindniet, kombimutter, fniet, sniet, mmutter, dmutter, wmutter, tmutter) VALUES ('%(dmc)s', '%(startts)s', '%(endts)s', '%(ausgleichselement)s', '%(schallisolierung)s', '%(masseblech)s', '%(blindniet)s', '%(kombimutter)s' , '%(fniet)s', '%(sniet)s', '%(mmutter)s', '%(dmutter)s', '%(wmutter)s', '%(tmutter)s');" % data)
except:
print ("Couldnt insert PD08")
raise Warning
self.updatebde (data['dmc'], 'masseblech', data['bauteilstatus'])
def deletemasseblech (self, dmc):
"""
Delete Masseblech info
"""
try:
cursor = self.executesql ("DELETE FROM masseblech WHERE dmc = '%s';" % (dmc))
except:
print ("Couldnt delete from masseblech")
raise Warning
def addpruefzelle2 (self, data):
"""
Add Processdata 10 - pruefzelle 2
and update BDE data
"""
try:
cursor = self.executesql ("INSERT INTO pruefzelle2 (dmc, startts, endts, pp01, pp02, pp03, pp04, pp05, pp06, pp07, pp08, pp08, pp09, pp10, pp11, pp12, pp13, pp14, pp15, pp16, pp17, pp18, pp19, pp20, pp21, pp22, pp23, pp24, pp25, pp26, pp27, pp28, pp29, pp30, pp31, pp32, pp33, pp34, pp35, pp36, pp37, pp38, pp39, pp40) VALUES ('%(dmc)s', '%(startts)s', '%(endts)s', '%(pp01)s', '%(pp02)s', '%(pp03)s', '%(pp04)s', '%(pp05)s', '%(pp06)s', '%(pp07)s', '%(pp08)s', '%(pp09)s', '%(pp10)s', '%(pp11)s', '%(pp12)s', '%(pp13)s', '%(pp14)s', '%(pp15)s', '%(pp16)s', '%(pp17)s', '%(pp18)s', '%(pp19)s', '%(pp20)s', '%(pp21)s', '%(pp22)s', '%(pp23)s', '%(pp24)s', '%(pp25)s', '%(pp26)s', '%(pp27)s', '%(pp28)s', '%(pp29)s', '%(pp30)s', '%(pp31)s', '%(pp32)s', '%(pp33)s', '%(pp34)s', '%(pp34)s', '%(pp35)s', '%(pp36)s', '%(pp37)s', '%(pp38)s', '%(pp39)s', '%(pp40)s');" % data)
except:
print ("Couldnt insert PD10 pruefzelle2")
raise Warning
self.updatebde (data['dmc'], 'pruefzelle2', data['bauteilstatus'])
def deletepruefzelle2 (self, dmc):
"""
Delete Pruefzelle2 info
"""
try:
cursor = self.executesql ("DELETE FROM pruefzelle2 WHERE dmc = '%s';" % (dmc))
except:
print ("Couldnt delete from Pruefzelle2")
raise Warning
if __name__ == "__main__":
conn = DB ('/opt/data/bde.sqlite', '/tmp/talog.sql', logtest, errlogtest)
from PD01_tel import TEL_PD01
PD01 = TEL_PD01 ()
from PD10_tel import TEL_PD10
PD10 = TEL_PD10 ()
from PD05_tel import TEL_PD05
PD05 = TEL_PD05 ()
conn.addpruefzelle1 (PD01)
#print (conn.getblindniet (PD05['dmc']))
#conn.deleteblindniet (PD05['dmc'])
#conn.addblindniet (PD05)
#conn.deletebajonettclip (PD06['dmc'])
#conn.addbajonettclip (PD06)
#conn.deletecclip (PD07['dmc'])
#conn.addcclip (PD07)
#conn.deletemasseblech (PD08['dmc'])
#conn.addmasseblech (PD08)

42
Navision.py Executable file
View File

@@ -0,0 +1,42 @@
#!/usr/bin/python
import sys, os
sys.path.append (".")
from time import time, strftime, sleep
class pySAP:
def __init__ (self, *dummy, **args):
"""
Initialize a new SAP exporter
"""
self.path = args.get ("path", "/opt/sap/")
self.time = time ()
def log (self, msg):
"""
Print message if in verbose mode.
"""
mins = int (strftime ("%M"))
file = open (self.path + strftime ("%Y_%m_%d_%H_") + '%02d' %(mins), "a")
file.write ( msg )
file.close ()
if __name__ == "__main__":
from pySAP import *
from DB_ERP import DB_ERP
#sapfile = pySAP (path = "/opt/sap/")
sapfile = pySAP (path = "/Users/michi/logtest/")
#conn = DB_ERP ("/opt/data/storage_ERPTrace.db3")
conn = DB_ERP ("/Users/michi/devel/S7ISO/data/storage_ERPTrace.db3")
conn.markinsertionsasunread ()
sapfile.log ('')
for a, c, m, u in conn.getinsertions ():
if c=='':
c = 0
sapfile.log ('%05d;%010d;%s;%s\n' % (int (a), int (c), m, u))
conn.markinsertionsasread ()

162
PD01_tel.py Executable file
View File

@@ -0,0 +1,162 @@
#!/usr/bin/python
__author__ = "Michael Rest"
__date__ = "2016/09/01"
__email__ = "mr@mir.systems"
__vrsion__ = "$Revision: 1.1 $"[11:-2]
from telegram import TELEGRAM, TEL_PD01
from telegram import tsdecode
from states import *
from parts import *
def fromstring (data):
"""
Decode the binary representation of a PD_tel from the given
parameter and note the data in the instance of the object.
Parameters:
data: The binary form of the TELEGRAM
"""
tel = TEL_PD01 ()
try:
tel.attrib['nr'] = (data [0] << 8) + data [1]
except:
print ("Debug-Nr", data[0], data[1])
tel.attrib['src'] = data [2:4].decode ()
tel.attrib['dst'] = data [4:6].decode ()
tel.attrib['type'] = data [6:10].decode ()
tel.attrib['dmc'] = (data [10:38]).decode ().rstrip (' \x00')
tel.attrib['startts'] = tsdecode (data [38:52].decode ())
tel.attrib['endts'] = tsdecode (data [52:66].decode ())
tel.attrib['bauteil'] = bauteil.get ((data [66] << 8) + data [67], '')
tel.attrib['Variante'] = variante.get ((data [68] << 8) + data [69], '')
tel.attrib['seriennr'] = '0'
#66-70 Varianten daten
tel.attrib['bauteilstatus'] = bauteilstatus.get (chr (data [70]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
#Fillbyte
tel.attrib['pp01'] = bearbeitungsstatus.get (chr (data [72]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp02'] = bearbeitungsstatus.get (chr (data [73]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp03'] = bearbeitungsstatus.get (chr (data [74]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp04'] = bearbeitungsstatus.get (chr (data [75]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp05'] = bearbeitungsstatus.get (chr (data [76]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp06'] = bearbeitungsstatus.get (chr (data [77]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp07'] = bearbeitungsstatus.get (chr (data [78]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp08'] = bearbeitungsstatus.get (chr (data [79]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp09'] = bearbeitungsstatus.get (chr (data [80]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp10'] = bearbeitungsstatus.get (chr (data [81]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp11'] = bearbeitungsstatus.get (chr (data [82]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp12'] = bearbeitungsstatus.get (chr (data [83]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp13'] = bearbeitungsstatus.get (chr (data [84]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp14'] = bearbeitungsstatus.get (chr (data [85]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp15'] = bearbeitungsstatus.get (chr (data [86]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp16'] = bearbeitungsstatus.get (chr (data [87]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp17'] = bearbeitungsstatus.get (chr (data [88]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp18'] = bearbeitungsstatus.get (chr (data [89]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp19'] = bearbeitungsstatus.get (chr (data [90]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp20'] = bearbeitungsstatus.get (chr (data [91]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp21'] = bearbeitungsstatus.get (chr (data [92]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp22'] = bearbeitungsstatus.get (chr (data [93]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp23'] = bearbeitungsstatus.get (chr (data [94]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp24'] = bearbeitungsstatus.get (chr (data [95]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp25'] = bearbeitungsstatus.get (chr (data [96]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp26'] = bearbeitungsstatus.get (chr (data [97]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp27'] = bearbeitungsstatus.get (chr (data [98]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp28'] = bearbeitungsstatus.get (chr (data [99]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp29'] = bearbeitungsstatus.get (chr (data [100]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp30'] = bearbeitungsstatus.get (chr (data [101]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp31'] = bearbeitungsstatus.get (chr (data [102]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp32'] = bearbeitungsstatus.get (chr (data [103]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp33'] = bearbeitungsstatus.get (chr (data [104]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp34'] = bearbeitungsstatus.get (chr (data [105]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp35'] = bearbeitungsstatus.get (chr (data [106]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp36'] = bearbeitungsstatus.get (chr (data [107]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp37'] = bearbeitungsstatus.get (chr (data [108]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp38'] = bearbeitungsstatus.get (chr (data [109]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp39'] = bearbeitungsstatus.get (chr (data [110]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp40'] = bearbeitungsstatus.get (chr (data [111]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['ladungstraeger'] = data [112:113].decode ()
return tel
class TEL_PD01 (TELEGRAM):
def __init__ (self, nr = 0, src = '01', dst = 'PC', *args, **args2):
TELEGRAM.__init__(self)
self.code = TEL_PD01
self.attrib['nr'] = nr
self.attrib['src'] = src
self.attrib['dst'] = dst
self.attrib['type'] = 'PD01'
self.attrib['startts'] = '2000-01-01 01:01:01'
self.attrib['endts'] = '2000-02-02 02:02:02'
self.attrib['dmc'] = '1234'
self.attrib['ladungstraeger'] = ''
self.attrib['seriennr'] = ''
self.attrib['bauteilstatus'] = 'n.i.O.'
self.attrib['pp01'] = 'n.Bearbeitet'
self.attrib['pp02'] = 'i.O.'
self.attrib['pp03'] = 'n.i.O.'
self.attrib['pp04'] = 'n.Bearbeitet'
self.attrib['pp05'] = 'i.O.'
self.attrib['pp06'] = 'n.i.O.'
self.attrib['pp07'] = 'n.Bearbeitet'
self.attrib['pp08'] = 'i.O.'
self.attrib['pp09'] = 'n.i.O.'
self.attrib['pp10'] = 'n.Bearbeitet'
self.attrib['pp11'] = 'i.O.'
self.attrib['pp12'] = 'n.i.O.'
self.attrib['pp13'] = 'n.Bearbeitet'
self.attrib['pp14'] = 'i.O.'
self.attrib['pp15'] = 'n.i.O.'
self.attrib['pp16'] = 'n.Bearbeitet'
self.attrib['pp17'] = 'i.O.'
self.attrib['pp18'] = 'n.i.O.'
self.attrib['pp19'] = 'n.Bearbeitet'
self.attrib['pp20'] = 'i.O.'
self.attrib['pp21'] = 'n.i.O.'
self.attrib['pp22'] = 'n.Bearbeitet'
self.attrib['pp23'] = 'i.O.'
self.attrib['pp24'] = 'n.i.O.'
self.attrib['pp25'] = 'n.Bearbeitet'
self.attrib['pp26'] = 'i.O.'
self.attrib['pp27'] = 'n.i.O.'
self.attrib['pp28'] = 'n.Bearbeitet'
self.attrib['pp29'] = 'i.O.'
self.attrib['pp30'] = 'n.i.O.'
self.attrib['pp31'] = 'n.Bearbeitet'
self.attrib['pp32'] = 'i.O.'
self.attrib['pp33'] = 'n.i.O.'
self.attrib['pp34'] = 'n.Bearbeitet'
self.attrib['pp35'] = 'i.O.'
self.attrib['pp36'] = 'n.i.O.'
self.attrib['pp37'] = 'n.Bearbeitet'
self.attrib['pp38'] = 'i.O.'
self.attrib['pp39'] = 'n.i.O.'
self.attrib['pp40'] = 'n.Bearbeitet'
self.len = 2220907
return
def identify (self):
"""
This method can be used to identify a TELEGRAM by string.
"""
return "PD01 TELEGRAM"
def __repr__ (self):
"""
Print a representation of the TPDU. Use this method via
`-pair to transfer it over the wire. This will just return
the header data and not the real data!
"""
# Note that the data is not included in the length
return "%c%c%c" % (2, self.code << 4, self.number) + self.data
def __str__ (self):
"""
Return a readable and quite verbose overview of the TPDU instance.
Use this for debugging purposes or if you're just curious.
"""
return "Packet: %s Data: %s" % (self.identify (), repr (self.attrib))

80
PD02_tel.py Executable file
View File

@@ -0,0 +1,80 @@
#!/usr/bin/python
__author__ = "Michael Rest"
__date__ = "2016/09/01"
__email__ = "mr@mir.systems"
__version__ = "$Revision: 1.1 $"[11:-2]
from telegram import TELEGRAM, TEL_PD02
from telegram import tsdecode
from states import *
def fromstring (data):
"""
Decode the binary representation of a PD_tel from the given
parameter and note the data in the instance of the object.
Parameters:
data: The binary form of the TELEGRAM
"""
tel = TEL_PD02 ()
try:
tel.attrib['nr'] = (data [0] << 8) + data [1]
except:
print ("Debug-Nr", data[0], data[1])
tel.attrib['src'] = data [2:4].decode ()
tel.attrib['dst'] = data [4:6].decode ()
tel.attrib['type'] = data [6:10].decode ()
tel.attrib['dmc'] = (data [10:38]).decode ().rstrip (' \x00')
tel.attrib['startts'] = tsdecode (data [38:52].decode ())
tel.attrib['endts'] = tsdecode (data [52:66].decode ())
#66-70 Varianten daten
tel.attrib['bauteilstatus'] = bauteilstatus.get (chr (data [70]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
try:
tel.attrib['aufnahme'] = (data [90] << 8) + data [91]
except:
print ("Debug-aufnahme", data[90], data[91])
return tel
class TEL_PD02 (TELEGRAM):
def __init__ (self, nr = 0, src = '02', dst = 'PC', *args, **args2):
TELEGRAM.__init__(self)
self.code = TEL_PD02
self.attrib['nr'] = nr
self.attrib['src'] = src
self.attrib['dst'] = dst
self.attrib['type'] = 'PD02'
self.attrib['startts'] = '2000-01-01 01:01:01'
self.attrib['endts'] = '2000-02-02 02:02:02'
self.attrib['dmc'] = '1234'
self.attrib['bauteilstatus'] = '0'
self.attrib['aufnahme'] = 0
self.len = 2220907
return
def identify (self):
"""
This method can be used to identify a TELEGRAM by string.
"""
return "PD02 TELEGRAM"
def __repr__ (self):
"""
Print a representation of the TPDU. Use this method via
`-pair to transfer it over the wire. This will just return
the header data and not the real data!
"""
# Note that the data is not included in the length
return "%c%c%c" % (2, self.code << 4, self.number) + self.data
def __str__ (self):
"""
Return a readable and quite verbose overview of the TPDU instance.
Use this for debugging purposes or if you're just curious.
"""
return "Packet: %s Data: %s" % (self.identify (), repr (self.attrib))

250
PD05_tel.py Executable file
View File

@@ -0,0 +1,250 @@
#!/usr/bin/python
__author__ = "Michael Rest"
__date__ = "2016/09/01"
__email__ = "mr@mir.systems"
__version__ = "$Revision: 1.1 $"[11:-2]
from telegram import TELEGRAM, TEL_PD05
from telegram import tsdecode
from states import *
def fromstring (data):
"""
Decode the binary representation of a PD_tel from the given
parameter and note the data in the instance of the object.
Parameters:
data: The binary form of the TELEGRAM
"""
tel = TEL_PD05 ()
try:
tel.attrib['nr'] = (data [0] << 8) + data [1]
except:
print ("Debug-Nr", data[0], data[1])
tel.attrib['src'] = data [2:4].decode ()
tel.attrib['dst'] = data [4:6].decode ()
tel.attrib['type'] = data [6:10].decode ()
tel.attrib['dmc'] = (data [10:38]).decode ().rstrip (' \x00')
tel.attrib['startts'] = tsdecode (data [38:52].decode ())
tel.attrib['endts'] = tsdecode (data [52:66].decode ())
#66-70 Varianten daten
tel.attrib['bauteilstatus'] = bauteilstatus.get (chr (data [70]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['NietM8status01'] = bearbeitungsstatus.get (chr (data [71]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['NietM8status02'] = bearbeitungsstatus.get (chr (data [72]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['DGBM8status01'] = bearbeitungsstatus.get (chr (data [73]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['DGBM8status02'] = bearbeitungsstatus.get (chr (data [74]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['DGBM8status03'] = bearbeitungsstatus.get (chr (data [75]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['DGBM8status04'] = bearbeitungsstatus.get (chr (data [76]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['NietM6status01'] = bearbeitungsstatus.get (chr (data [77]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['NietM6status02'] = bearbeitungsstatus.get (chr (data [78]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['NietM6status03'] = bearbeitungsstatus.get (chr (data [79]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['NietM6status04'] = bearbeitungsstatus.get (chr (data [80]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['NietM6status05'] = bearbeitungsstatus.get (chr (data [81]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
try:
tel.attrib['DGBM8M01'] = (data [90] << 8) + data [91]
except:
print ("Debug-DGBM8M01", data[90], data[91])
try:
tel.attrib['DGBM8D01'] = (data [92] << 8) + data [93]
except:
print ("Debug-DGBM8D01", data[92], data[93])
try:
tel.attrib['DGBM8W01'] = (data [94] << 8) + data [95]
except:
print ("Debug-DGBM8W01", data[94], data[95])
try:
tel.attrib['DGBM8T01'] = (data [96] << 8) + data [97]
except:
print ("Debug-DGBM8T01", data[96], data[97])
try:
tel.attrib['DGBM8M02'] = (data [98] << 8) + data [99]
except:
print ("Debug-DGBM8M02", data[98], data[99])
try:
tel.attrib['DGBM8D02'] = (data [100] << 8) + data [101]
except:
print ("Debug-DGBM8D02", data[100], data[101])
try:
tel.attrib['DGBM8W02'] = (data [102] << 8) + data [103]
except:
print ("Debug-DGBM8W02", data[102], data[103])
try:
tel.attrib['DGBM8T02'] = (data [104] << 8) + data [105]
except:
print ("Debug-DGBM8T02", data[104], data[105])
try:
tel.attrib['DGBM8M03'] = (data [106] << 8) + data [107]
except:
print ("Debug-DGBM8M03", data[106], data[107])
try:
tel.attrib['DGBM8D03'] = (data [108] << 8) + data [109]
except:
print ("Debug-DGBM8D03", data[108], data[109])
try:
tel.attrib['DGBM8W03'] = (data [110] << 8) + data [111]
except:
print ("Debug-DGBM8W03", data[110], data[111])
try:
tel.attrib['DGBM8T03'] = (data [112] << 8) + data [113]
except:
print ("Debug-DGBM8T03", data[112], data[113])
try:
tel.attrib['DGBM8M04'] = (data [114] << 8) + data [115]
except:
print ("Debug-DGBM8M04", data[114], data[115])
try:
tel.attrib['DGBM8D04'] = (data [116] << 8) + data [117]
except:
print ("Debug-DGBM8D04", data[116], data[117])
try:
tel.attrib['DGBM8W04'] = (data [118] << 8) + data [119]
except:
print ("Debug-DGBM8W04", data[118], data[119])
try:
tel.attrib['DGBM8T04'] = (data [120] << 8) + data [121]
except:
print ("Debug-DGBM8T04", data[120], data[121])
try:
tel.attrib['NietM6F01'] = (data [122] << 8) + data [123]
except:
print ("Debug-NietM6F01", data[122], data[123])
try:
tel.attrib['NietM6S01'] = (data [124] << 8) + data [125]
except:
print ("Debug-NietM6S01", data[124], data[125])
try:
tel.attrib['NietM6F02'] = (data [126] << 8) + data [127]
except:
print ("Debug-NietM6F02", data[126], data[127])
try:
tel.attrib['NietM6S02'] = (data [128] << 8) + data [129]
except:
print ("Debug-NietM6S02", data[128], data[129])
try:
tel.attrib['NietM6F03'] = (data [130] << 8) + data [132]
except:
print ("Debug-NietM6F03", data[130], data[132])
try:
tel.attrib['NietM6S03'] = (data [132] << 8) + data [131]
except:
print ("Debug-NietM6S03", data[132], data[131])
try:
tel.attrib['NietM6F04'] = (data [134] << 8) + data [135]
except:
print ("Debug-NietM6F04", data[134], data[135])
try:
tel.attrib['NietM6S04'] = (data [136] << 8) + data [137]
except:
print ("Debug-NietM6S04", data[136], data[137])
try:
tel.attrib['NietM6F05'] = (data [138] << 8) + data [139]
except:
print ("Debug-NietM6F05", data[138], data[139])
try:
tel.attrib['NietM6S05'] = (data [140] << 8) + data [141]
except:
print ("Debug-NietM6S05", data[140], data[141])
try:
tel.attrib['NietM8F01'] = (data [142] << 8) + data [143]
except:
print ("Debug-NietM8F01", data[142], data[143])
try:
tel.attrib['NietM8S01'] = (data [144] << 8) + data [145]
except:
print ("Debug-NietM8S01", data[144], data[145])
try:
tel.attrib['NietM8F02'] = (data [146] << 8) + data [147]
except:
print ("Debug-NietM8F02", data[146], data[147])
try:
tel.attrib['NietM8S02'] = (data [148] << 8) + data [149]
except:
print ("Debug-NietM8S02", data[148], data[149])
return tel
class TEL_PD05 (TELEGRAM):
def __init__ (self, nr = 0, src = '05', dst = 'PC', *args, **args2):
TELEGRAM.__init__(self)
self.code = TEL_PD05
self.attrib['nr'] = nr
self.attrib['src'] = src
self.attrib['dst'] = dst
self.attrib['type'] = 'PD05'
self.attrib['startts'] = '2000-01-01 01:01:01'
self.attrib['endts'] = '2000-02-02 02:02:02'
self.attrib['dmc'] = '1234'
self.attrib['bauteilstatus'] = '0'
self.attrib['NietM8status01'] = '0'
self.attrib['NietM8status02'] = '0'
self.attrib['DGBM8status01'] = '0'
self.attrib['DGBM8status02'] = '0'
self.attrib['DGBM8status03'] = '0'
self.attrib['DGBM8status04'] = '0'
self.attrib['NietM6status01'] = '0'
self.attrib['NietM6status02'] = '0'
self.attrib['NietM6status03'] = '0'
self.attrib['NietM6status04'] = '0'
self.attrib['NietM6status05'] = '0'
self.attrib['DGBM8M01'] = '0'
self.attrib['DGBM8D01'] = '0'
self.attrib['DGBM8W01'] = '0'
self.attrib['DGBM8T01'] = '0'
self.attrib['DGBM8M02'] = '0'
self.attrib['DGBM8D02'] = '0'
self.attrib['DGBM8W02'] = '0'
self.attrib['DGBM8T02'] = '0'
self.attrib['DGBM8M03'] = '0'
self.attrib['DGBM8D03'] = '0'
self.attrib['DGBM8W03'] = '0'
self.attrib['DGBM8T03'] = '0'
self.attrib['DGBM8M04'] = '0'
self.attrib['DGBM8D04'] = '0'
self.attrib['DGBM8W04'] = '0'
self.attrib['DGBM8T04'] = '0'
self.attrib['NietM6F01'] = '0'
self.attrib['NietM6S01'] = '0'
self.attrib['NietM6F02'] = '0'
self.attrib['NietM6S02'] = '0'
self.attrib['NietM6F03'] = '0'
self.attrib['NietM6S03'] = '0'
self.attrib['NietM6F04'] = '0'
self.attrib['NietM6S04'] = '0'
self.attrib['NietM6F05'] = '0'
self.attrib['NietM6S05'] = '0'
self.attrib['NietM8F01'] = '0'
self.attrib['NietM8S01'] = '0'
self.attrib['NietM8F02'] = '0'
self.attrib['NietM8S02'] = '0'
self.len = 2220908
return
def identify (self):
"""
This method can be used to identify a TELEGRAM by string.
"""
return "PD08 TELEGRAM"
def __repr__ (self):
"""
Print a representation of the TPDU. Use this method via
`-pair to transfer it over the wire. This will just return
the header data and not the real data!
"""
# Note that the data is not included in the length
return "%c%c%c" % (2, self.code << 4, self.number) + self.data
def __str__ (self):
"""
Return a readable and quite verbose overview of the TPDU instance.
Use this for debugging purposes or if you're just curious.
"""
return "Packet: %s Data: %s" % (self.identify (), repr (self.attrib))

88
PD06_tel.py Executable file
View File

@@ -0,0 +1,88 @@
#!/usr/bin/python
__author__ = "Michael Rest"
__date__ = "2016/09/01"
__email__ = "mr@mir.systems"
__version__ = "$Revision: 1.1 $"[11:-2]
from telegram import TELEGRAM, TEL_PD06
from telegram import tsdecode
from states import *
def fromstring (data):
"""
Decode the binary representation of a PD_tel from the given
parameter and note the data in the instance of the object.
Parameters:
data: The binary form of the TELEGRAM
"""
tel = TEL_PD06 ()
try:
tel.attrib['nr'] = (data [0] << 8) + data [1]
except:
print ("Debug-Nr", data[0], data[1])
tel.attrib['src'] = data [2:4].decode ()
tel.attrib['dst'] = data [4:6].decode ()
tel.attrib['type'] = data [6:10].decode ()
tel.attrib['dmc'] = (data [10:38]).decode ().rstrip (' \x00')
tel.attrib['startts'] = tsdecode (data [38:52].decode ())
tel.attrib['endts'] = tsdecode (data [52:66].decode ())
#66-70 Varianten daten
tel.attrib['bauteilstatus'] = bauteilstatus.get (chr (data [70]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['bajostatus01'] = bearbeitungsstatus.get (chr (data [71]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['bajostatus02'] = bearbeitungsstatus.get (chr (data [72]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['bajostatus03'] = bearbeitungsstatus.get (chr (data [73]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['bajostatus04'] = bearbeitungsstatus.get (chr (data [74]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
try:
tel.attrib['aufnahme'] = (data [90] << 8) + data [91]
except:
print ("Debug-aufnahme", data[90], data[91])
return tel
class TEL_PD06 (TELEGRAM):
def __init__ (self, nr = 0, src = '06', dst = 'PC', *args, **args2):
TELEGRAM.__init__(self)
self.code = TEL_PD06
self.attrib['nr'] = nr
self.attrib['src'] = src
self.attrib['dst'] = dst
self.attrib['type'] = 'PD06'
self.attrib['startts'] = '2000-01-01 01:01:01'
self.attrib['endts'] = '2000-02-02 02:02:02'
self.attrib['dmc'] = '1234'
self.attrib['bauteilstatus'] = '0'
self.attrib['bajostatus01'] = '0'
self.attrib['bajostatus02'] = '0'
self.attrib['bajostatus03'] = '0'
self.attrib['bajostatus04'] = '0'
self.attrib['aufnahme'] = 0
self.len = 2220907
return
def identify (self):
"""
This method can be used to identify a TELEGRAM by string.
"""
return "PD06 TELEGRAM"
def __repr__ (self):
"""
Print a representation of the TPDU. Use this method via
`-pair to transfer it over the wire. This will just return
the header data and not the real data!
"""
# Note that the data is not included in the length
return "%c%c%c" % (2, self.code << 4, self.number) + self.data
def __str__ (self):
"""
Return a readable and quite verbose overview of the TPDU instance.
Use this for debugging purposes or if you're just curious.
"""
return "Packet: %s Data: %s" % (self.identify (), repr (self.attrib))

116
PD07_tel.py Executable file
View File

@@ -0,0 +1,116 @@
#!/usr/bin/python
__author__ = "Michael Rest"
__date__ = "2016/09/01"
__email__ = "mr@mir.systems"
__version__ = "$Revision: 1.1 $"[11:-2]
from telegram import TELEGRAM, TEL_PD07
from telegram import tsdecode
from states import *
def fromstring (data):
"""
Decode the binary representation of a PD_tel from the given
parameter and note the data in the instance of the object.
Parameters:
data: The binary form of the TELEGRAM
"""
tel = TEL_PD07 ()
try:
tel.attrib['nr'] = (data [0] << 8) + data [1]
except:
print ("Debug-Nr", data[0], data[1])
tel.attrib['src'] = data [2:4].decode ()
tel.attrib['dst'] = data [4:6].decode ()
tel.attrib['type'] = data [6:10].decode ()
tel.attrib['dmc'] = (data [10:38]).decode ().rstrip (' \x00')
tel.attrib['startts'] = tsdecode (data [38:52].decode ())
tel.attrib['endts'] = tsdecode (data [52:66].decode ())
#66-70 Varianten daten
tel.attrib['bauteilstatus'] = bauteilstatus.get (chr (data [70]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus01'] = bearbeitungsstatus.get (chr (data [71]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus02'] = bearbeitungsstatus.get (chr (data [72]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus03'] = bearbeitungsstatus.get (chr (data [73]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus04'] = bearbeitungsstatus.get (chr (data [74]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus05'] = bearbeitungsstatus.get (chr (data [75]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus06'] = bearbeitungsstatus.get (chr (data [76]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus07'] = bearbeitungsstatus.get (chr (data [77]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus08'] = bearbeitungsstatus.get (chr (data [78]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus09'] = bearbeitungsstatus.get (chr (data [79]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus10'] = bearbeitungsstatus.get (chr (data [80]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus11'] = bearbeitungsstatus.get (chr (data [81]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus12'] = bearbeitungsstatus.get (chr (data [82]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus13'] = bearbeitungsstatus.get (chr (data [83]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus14'] = bearbeitungsstatus.get (chr (data [84]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus15'] = bearbeitungsstatus.get (chr (data [85]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus16'] = bearbeitungsstatus.get (chr (data [86]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus17'] = bearbeitungsstatus.get (chr (data [87]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['clipstatus18'] = bearbeitungsstatus.get (chr (data [88]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
try:
tel.attrib['aufnahme'] = (data [90] << 8) + data [91]
except:
print ("Debug-aufnahme", data[90], data[91])
return tel
class TEL_PD07 (TELEGRAM):
def __init__ (self, nr = 0, src = '07', dst = 'PC', *args, **args2):
TELEGRAM.__init__(self)
self.code = TEL_PD07
self.attrib['nr'] = nr
self.attrib['src'] = src
self.attrib['dst'] = dst
self.attrib['type'] = 'PD07'
self.attrib['startts'] = '2000-01-01 01:01:01'
self.attrib['endts'] = '2000-02-02 02:02:02'
self.attrib['dmc'] = '1234'
self.attrib['bauteilstatus'] = '0'
self.attrib['clipstatus01'] = '0'
self.attrib['clipstatus02'] = '0'
self.attrib['clipstatus03'] = '0'
self.attrib['clipstatus04'] = '0'
self.attrib['clipstatus05'] = '0'
self.attrib['clipstatus06'] = '0'
self.attrib['clipstatus07'] = '0'
self.attrib['clipstatus08'] = '0'
self.attrib['clipstatus09'] = '0'
self.attrib['clipstatus10'] = '0'
self.attrib['clipstatus11'] = '0'
self.attrib['clipstatus12'] = '0'
self.attrib['clipstatus13'] = '0'
self.attrib['clipstatus14'] = '0'
self.attrib['clipstatus15'] = '0'
self.attrib['clipstatus16'] = '0'
self.attrib['clipstatus17'] = '0'
self.attrib['clipstatus18'] = '0'
self.attrib['aufnahme'] = 0
self.len = 2220907
return
def identify (self):
"""
This method can be used to identify a TELEGRAM by string.
"""
return "PD07 TELEGRAM"
def __repr__ (self):
"""
Print a representation of the TPDU. Use this method via
`-pair to transfer it over the wire. This will just return
the header data and not the real data!
"""
# Note that the data is not included in the length
return "%c%c%c" % (2, self.code << 4, self.number) + self.data
def __str__ (self):
"""
Return a readable and quite verbose overview of the TPDU instance.
Use this for debugging purposes or if you're just curious.
"""
return "Packet: %s Data: %s" % (self.identify (), repr (self.attrib))

106
PD08_tel.py Executable file
View File

@@ -0,0 +1,106 @@
#!/usr/bin/python
__author__ = "Michael Rest"
__date__ = "2016/09/01"
__email__ = "mr@mir.systems"
__version__ = "$Revision: 1.1 $"[11:-2]
from telegram import TELEGRAM, TEL_PD08
from telegram import tsdecode
from states import *
def fromstring (data):
"""
Decode the binary representation of a PD_tel from the given
parameter and note the data in the instance of the object.
Parameters:
data: The binary form of the TELEGRAM
"""
tel = TEL_PD08 ()
try:
tel.attrib['nr'] = (data [0] << 8) + data [1]
except:
print ("Debug-Nr", data[0], data[1])
tel.attrib['src'] = data [2:4].decode ()
tel.attrib['dst'] = data [4:6].decode ()
tel.attrib['type'] = data [6:10].decode ()
tel.attrib['dmc'] = (data [10:38]).decode ().rstrip (' \x00')
tel.attrib['startts'] = tsdecode (data [38:52].decode ())
tel.attrib['endts'] = tsdecode (data [52:66].decode ())
#66-70 Varianten daten
tel.attrib['bauteilstatus'] = bauteilstatus.get (chr (data [70]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['ausgleichselement'] = bearbeitungsstatus.get (chr (data [71]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['schallisolierung'] = bearbeitungsstatus.get (chr (data [72]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['masseblech'] = bearbeitungsstatus.get (chr (data [73]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['blindniet'] = bearbeitungsstatus.get (chr (data [74]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['kombimutter'] = bearbeitungsstatus.get (chr (data [75]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
try:
tel.attrib['fniet'] = (data [90] << 8) + data [91]
except:
print ("Debug-fniet", data[90], data[91])
try:
tel.attrib['sniet'] = (data [92] << 8) + data [93]
except:
print ("Debug-sniet", data[92], data[93])
try:
tel.attrib['mmutter'] = (data [94] << 8) + data [95]
except:
print ("Debug-mmutter", data[94], data[95])
try:
tel.attrib['dmutter'] = (data [96] << 8) + data [97]
except:
print ("Debug-dmutter", data[96], data[97])
try:
tel.attrib['wmutter'] = (data [98] << 8) + data [99]
except:
print ("Debug-wmutter", data[98], data[99])
try:
tel.attrib['tmutter'] = (data [100] << 8) + data [101]
except:
print ("Debug-tmutter", data[100], data[101])
#tel.attrib['box_nr'] = (ord (data [10]) << 24) + (ord (data [11]) << 16) + (ord (data [12]) << 8) + ord (data [13]) #data [10:14].strip ()
#tel.attrib['location'] = data [14:18]
#tel.attrib['destination'] = (ord (data [18]) << 8) + ord (data [19])
return tel
class TEL_PD08 (TELEGRAM):
def __init__ (self, nr = 0, src = '08', dst = 'PC', *args, **args2):
TELEGRAM.__init__(self)
self.code = TEL_PD08
self.attrib['nr'] = nr
self.attrib['src'] = src
self.attrib['dst'] = dst
self.attrib['type'] = 'PD08'
self.attrib['startts'] = ''
self.attrib['endts'] = ''
self.attrib['dmc'] = ''
self.len = 2220908
return
def identify (self):
"""
This method can be used to identify a TELEGRAM by string.
"""
return "PD08 TELEGRAM"
def __repr__ (self):
"""
Print a representation of the TPDU. Use this method via
`-pair to transfer it over the wire. This will just return
the header data and not the real data!
"""
# Note that the data is not included in the length
return "%c%c%c" % (2, self.code << 4, self.number) + self.data
def __str__ (self):
"""
Return a readable and quite verbose overview of the TPDU instance.
Use this for debugging purposes or if you're just curious.
"""
return "Packet: %s Data: %s" % (self.identify (), repr (self.attrib))

156
PD10_tel.py Executable file
View File

@@ -0,0 +1,156 @@
#!/usr/bin/python
__author__ = "Michael Rest"
__date__ = "2016/09/01"
__email__ = "mr@mir.systems"
__version__ = "$Revision: 1.1 $"[11:-2]
from telegram import TELEGRAM, TEL_PD10
from telegram import tsdecode
from states import *
def fromstring (data):
"""
Decode the binary representation of a PD_tel from the given
parameter and note the data in the instance of the object.
Parameters:
data: The binary form of the TELEGRAM
"""
tel = TEL_PD10 ()
try:
tel.attrib['nr'] = (data [0] << 8) + data [1]
except:
print ("Debug-Nr", data[0], data[1])
tel.attrib['src'] = data [2:4].decode ()
tel.attrib['dst'] = data [4:6].decode ()
tel.attrib['type'] = data [6:10].decode ()
tel.attrib['dmc'] = (data [10:38]).decode ().rstrip (' \x00')
tel.attrib['startts'] = tsdecode (data [38:52].decode ())
tel.attrib['endts'] = tsdecode (data [52:66].decode ())
#66-70 Varianten daten
tel.attrib['bauteilstatus'] = bauteilstatus.get (chr (data [70]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp10'] = bearbeitungsstatus.get (chr (data [71]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp02'] = bearbeitungsstatus.get (chr (data [72]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp03'] = bearbeitungsstatus.get (chr (data [73]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp04'] = bearbeitungsstatus.get (chr (data [74]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp05'] = bearbeitungsstatus.get (chr (data [75]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp06'] = bearbeitungsstatus.get (chr (data [76]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp07'] = bearbeitungsstatus.get (chr (data [77]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp08'] = bearbeitungsstatus.get (chr (data [78]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp09'] = bearbeitungsstatus.get (chr (data [79]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp10'] = bearbeitungsstatus.get (chr (data [80]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp11'] = bearbeitungsstatus.get (chr (data [81]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp12'] = bearbeitungsstatus.get (chr (data [82]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp13'] = bearbeitungsstatus.get (chr (data [83]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp14'] = bearbeitungsstatus.get (chr (data [84]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp15'] = bearbeitungsstatus.get (chr (data [85]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp16'] = bearbeitungsstatus.get (chr (data [86]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp17'] = bearbeitungsstatus.get (chr (data [87]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp18'] = bearbeitungsstatus.get (chr (data [88]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp19'] = bearbeitungsstatus.get (chr (data [89]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp20'] = bearbeitungsstatus.get (chr (data [90]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp21'] = bearbeitungsstatus.get (chr (data [91]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp22'] = bearbeitungsstatus.get (chr (data [92]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp23'] = bearbeitungsstatus.get (chr (data [93]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp24'] = bearbeitungsstatus.get (chr (data [94]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp25'] = bearbeitungsstatus.get (chr (data [95]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp26'] = bearbeitungsstatus.get (chr (data [96]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp27'] = bearbeitungsstatus.get (chr (data [97]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp28'] = bearbeitungsstatus.get (chr (data [98]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp29'] = bearbeitungsstatus.get (chr (data [99]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp30'] = bearbeitungsstatus.get (chr (data [100]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp31'] = bearbeitungsstatus.get (chr (data [101]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp32'] = bearbeitungsstatus.get (chr (data [102]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp33'] = bearbeitungsstatus.get (chr (data [103]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp34'] = bearbeitungsstatus.get (chr (data [104]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp35'] = bearbeitungsstatus.get (chr (data [105]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp36'] = bearbeitungsstatus.get (chr (data [106]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp37'] = bearbeitungsstatus.get (chr (data [107]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp38'] = bearbeitungsstatus.get (chr (data [108]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp39'] = bearbeitungsstatus.get (chr (data [109]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['pp40'] = bearbeitungsstatus.get (chr (data [110]), '') #0 - unbearbeitet; 1 - iO; 2 - niO
tel.attrib['ladungstraeger'] = data [112:113].decode ()
return tel
class TEL_PD10 (TELEGRAM):
def __init__ (self, nr = 0, src = '10', dst = 'PC', *args, **args2):
TELEGRAM.__init__(self)
self.code = TEL_PD10
self.attrib['nr'] = nr
self.attrib['src'] = src
self.attrib['dst'] = dst
self.attrib['type'] = 'PD10'
self.attrib['startts'] = '2000-01-01 01:01:01'
self.attrib['endts'] = '2000-02-02 02:02:02'
self.attrib['dmc'] = '1234'
self.attrib['bauteilstatus'] = '0'
self.attrib['pp01'] = 'test1'
self.attrib['pp02'] = 'test2'
self.attrib['pp03'] = 'test3'
self.attrib['pp04'] = 'test4'
self.attrib['pp05'] = 'test5'
self.attrib['pp06'] = 'test6'
self.attrib['pp07'] = 'test7'
self.attrib['pp08'] = 'test8'
self.attrib['pp09'] = 'test9'
self.attrib['pp10'] = 'test10'
self.attrib['pp11'] = 'test11'
self.attrib['pp12'] = 'test12'
self.attrib['pp13'] = 'test13'
self.attrib['pp14'] = 'test14'
self.attrib['pp15'] = 'test15'
self.attrib['pp16'] = 'test16'
self.attrib['pp17'] = 'test17'
self.attrib['pp18'] = 'test18'
self.attrib['pp19'] = 'test19'
self.attrib['pp20'] = 'test20'
self.attrib['pp21'] = 'test21'
self.attrib['pp22'] = 'test22'
self.attrib['pp23'] = 'test23'
self.attrib['pp24'] = 'test24'
self.attrib['pp25'] = 'test25'
self.attrib['pp26'] = 'test26'
self.attrib['pp27'] = 'test27'
self.attrib['pp28'] = 'test28'
self.attrib['pp29'] = 'test29'
self.attrib['pp30'] = 'test30'
self.attrib['pp31'] = 'test31'
self.attrib['pp32'] = 'test32'
self.attrib['pp33'] = 'test33'
self.attrib['pp34'] = 'test34'
self.attrib['pp35'] = 'test35'
self.attrib['pp36'] = 'test36'
self.attrib['pp37'] = 'test37'
self.attrib['pp38'] = 'test38'
self.attrib['pp39'] = 'test39'
self.attrib['pp40'] = 'test40'
self.attrib['ladungstraeger'] = ''
self.len = 2220907
return
def identify (self):
"""
This method can be used to identify a TELEGRAM by string.
"""
return "PD10 TELEGRAM"
def __repr__ (self):
"""
Print a representation of the TPDU. Use this method via
`-pair to transfer it over the wire. This will just return
the header data and not the real data!
"""
# Note that the data is not included in the length
return "%c%c%c" % (2, self.code << 4, self.number) + self.data
def __str__ (self):
"""
Return a readable and quite verbose overview of the TPDU instance.
Use this for debugging purposes or if you're just curious.
"""
return "Packet: %s Data: %s" % (self.identify (), repr (self.attrib))

76
PD98_tel.py Executable file
View File

@@ -0,0 +1,76 @@
#!/usr/bin/python
__author__ = "Michael Rest"
__date__ = "2016/09/01"
__email__ = "mr@mir.systems"
__version__ = "$Revision: 1.1 $"[11:-2]
from telegram import TELEGRAM, TEL_PD98
from telegram import tsdecode
def fromstring (data):
"""
Decode the binary representation of a PD_tel from the given
parameter and note the data in the instance of the object.
Parameters:
data: The binary form of the TELEGRAM
"""
tel = TEL_PD98 ()
try:
tel.attrib['nr'] = (data [0] << 8) + data [1]
except:
print ("Debug-Nr", data[0], data[1])
tel.attrib['src'] = data [2:4].decode ()
tel.attrib['dst'] = data [4:6].decode ()
tel.attrib['type'] = data [6:10].decode ()
tel.attrib['startts'] = tsdecode (data [10:24].decode ())
tel.attrib['dmcstat'] = chr (data [24]) #25 Fillbyte
tel.attrib['dmc'] = (data [26:54]).decode ().rstrip (' \x00')
#tel.attrib['box_nr'] = (ord (data [10]) << 24) + (ord (data [11]) << 16) + (ord (data [12]) << 8) + ord (data [13]) #data [10:14].strip ()
#tel.attrib['location'] = data [14:18]
#tel.attrib['destination'] = (ord (data [18]) << 8) + ord (data [19])
return tel
class TEL_PD98 (TELEGRAM):
def __init__ (self, nr = 0, src = 'LV', dst = 'TP', *args, **args2):
TELEGRAM.__init__(self)
self.code = TEL_PD98
self.attrib['nr'] = nr
self.attrib['src'] = src
self.attrib['dst'] = dst
self.attrib['type'] = 'PD98'
self.attrib['startts'] = ''
self.attrib['dmcstat'] = 0
self.attrib['dmc'] = ''
self.attrib['box_nr'] = 0
self.attrib['destination'] = 0
self.len = 2220908
return
def identify (self):
"""
This method can be used to identify a TELEGRAM by string.
"""
return "PD98 TELEGRAM"
def __repr__ (self):
"""
Print a representation of the TPDU. Use this method via
`-pair to transfer it over the wire. This will just return
the header data and not the real data!
"""
# Note that the data is not included in the length
return "%c%c%c" % (2, self.code << 4, self.number) + self.data
def __str__ (self):
"""
Return a readable and quite verbose overview of the TPDU instance.
Use this for debugging purposes or if you're just curious.
"""
return "Packet: %s Data: %s" % (self.identify (), repr (self.attrib))

54
STAT.py Executable file
View File

@@ -0,0 +1,54 @@
#! /usr/bin/python
from socket import *
from select import select
import sys
from datetime import datetime
def log (msg):
"""
Print message if in verbose mode.
"""
file = open ("log.txt", "a")
dt = datetime.now ()
file.write ("%4d-%02d-%02d %02d:%02d:%02d.%06d: " %(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond))
file.write (msg + "\n")
file.close ()
if __name__ == "__main__":
s = socket(AF_INET, SOCK_STREAM)
s.setsockopt (SOL_SOCKET, SO_REUSEADDR, 1)
print "got Socket", s
s.bind(("192.168.11.19", 2006))
s.listen (1)
# Select free sockets for transmission
read = [s]
writes = []
bQuit = 0
while 1:
(reads, writes, xlist) = select (read, writes, [], 0.1)
# First write all remaining messages
for conn in writes:
if bQuit:
conn.send ('LVTRSTAT'+ chr (0) + chr (0))
writes = []
bQuit = 0
# Then read all remaining messages from ready sockets
for conn in reads:
print conn
if conn == s:
try:
print "Connected"
c, client = conn.accept ()
read.append (c)
print read
except:
print ("No Connection")
else:
data = conn.recv (16384)
if data:
writes = [conn]
print (data)
bQuit = 1

82
STAT_tel.py Executable file
View File

@@ -0,0 +1,82 @@
#!/usr/bin/python
__author__ = "Michael Rest"
__date__ = "2006/02/15"
__email__ = "michi@rosstein.de"
__version__ = "$Revision: 1.1 $"[11:-2]
from telegram import TELEGRAM, TEL_STAT
# String representation for a DT TPDU
DT_STRING = \
"""\
Length: %d
Number: 0x%02x
Contained Data: %s
"""
def fromstring (data):
"""
Decode the binary representation of a STAT_tel from the given
parameter and note the data in the instance of the object.
Parameters:
data: The binary form of the TELEGRAM
"""
tel = TEL_STAT ()
tel.attrib['nr'] = (ord (data [0]) << 8) + ord (data [1])
tel.attrib['src'] = data [2:4]
tel.attrib['dst'] = data [4:6]
tel.attrib['type'] = data [6:10]
tel.attrib['location'] = data [10:14]
tel.attrib['state'] = data [14:16]
tel.attrib['error'] = data [16:len(data)]
return tel
class TEL_STAT (TELEGRAM):
def __init__ (self, nr = 0, src = 'LV', dst = 'TP', loc = '1000', state='00', error = '0000' , *args, **args2):
TELEGRAM.__init__(self)
self.code = TEL_STAT
self.attrib['nr'] = nr
self.attrib['src'] = src
self.attrib['dst'] = dst
self.attrib['type'] = 'STAT'
self.attrib['location'] = loc
self.attrib['state'] = state
self.attrib['error'] = error
self.__recalclen ()
return
def identify (self):
"""
This method can be used to identify a TELEGRAM by string.
"""
return "STAT TELEGRAM\n"
def __recalclen (self):
"""
Return the length of the TPDU. This function is for
internal use only!
"""
self.len = 2 + 4l
def __repr__ (self):
"""
Print a representation of the TPDU. Use this method via
`-pair to transfer it over the wire. This will just return
the header data and not the real data!
"""
# Note that the data is not included in the length
return "%c%c%c" % (2, self.code << 4, self.number) + self.data
def __str__ (self):
"""
Return a readable and quite verbose overview of the TPDU instance.
Use this for debugging purposes or if you're just curious.
"""
print self.attrib
string = self.identify () #+ DT_STRING % (self.len, self.number, self.data)
return string

60
bde.cfg.tpl Normal file
View File

@@ -0,0 +1,60 @@
[IP Settings]
ipbde = 0.0.0.0
[DB Settings]
dbfile = /opt/data/bde.sqlite
logfile = /opt/data/BDE_talog.sql
[DEBUG]
loglevel = 6
debuglevel = 1
[PD01]
name = Messzelle1
ipsps = 192.168.6.60
[PD02]
name = Entgratzelle1
ipsps = 192.168.6.50
[PD03]
name = Entgratzelle2
ipsps = 192.168.6.150
[PD04]
name = BeladezelleBAZ
ipsps = 192.168.6.160
[PD05]
name = Blindniet
ipsps = 192.168.6.10
[PD06]
name = Bajonettclip
ipsps = 192.168.6.120
[PD07]
name = Metalclip
ipsps = 192.168.6.30
[PD08]
name = Masseblech
ipsps = 192.168.6.40
[PD09]
name = Nacharbeit
ipsps = 192.168.6.100
[PD10]
name = Messzelle2
ipsps = 192.168.6.70
[PD98]
name = Test
ipsps = 192.168.1.150
[PD99]
name = Zentrale
ipsps = 192.168.6.80

510
bde.py Executable file
View File

@@ -0,0 +1,510 @@
#! /usr/bin/python3
#-*- coding: utf-8 -*-
__author__ = "Michael Rest"
__date__ = "1 August 2016"
__email__ = "mr@mir.systems"
__version__ = "$Revision: 1.1 $"[11:-2]
from socket import *
from select import select
import configparser
import sys, os
import pdb
from time import time
from datetime import datetime
import tel_decode
from log import strlog
from DB import DB
from itertools import chain
def doublechar (value):
if len (value) == 1:
return '0' + value
elif len (value) > 2:
return value [len (value) -2: len (value)]
return value
def fillchar (value, l):
if len (value.rstrip()) < l:
_retval = ''
for i in range (0, l - len (value.rstrip())):
_retval += '0'
return _retval + value.rstrip()
return value
class BDEServer ():
def __init__ (self, *dummy, **args):
"""
Initialise a new server object: Open the socket, bind to it
and listen. This will NOT handle incomming connections.
Possible variable parameters are:
port: the port to listen on (default: 102)
address: the address to listen on (default: '' i.e. any)
verbose: if true be anal about anything (default: 0)
"""
self.connections = {}
self.parameter = {}
self.sockets = {}
# Parameter action
self.address = args.get ("address", '')
port = args.get ("port", 2002)
self.verbose = args.get ("verbose", 0)
self.setdebug = args.get ("debug", 0)
_db = args.get ("DB", None)
self.connections['DB'] = DB (_db[0], _db[1], self.log, self.errlog)
#Connectionditcs
self.connections['TCP'] = {}
#Sendqueue
self.connections['Queue'] = []
self.connections['LastBeat'] = 0
self.listener_socket = socket (AF_INET, SOCK_STREAM)
self.listener_socket.setsockopt (SOL_SOCKET, SO_REUSEADDR, 1)
self.sockets[('listener', '%d'%port)] = (self.listener_socket, None)
while 1:
try:
self.listener_socket.bind ((self.address, port))
except error:
self.message (0, "ISOServer Bind Socket error, Started as root?")
sys.exit (0)
else:
break
self.listener_socket.listen (1)
self.sockets[('listener', '%d'%port)] = (self.listener_socket, None)
self.message (1, "Initialized serversocket")
def message (self, level, msg):
"""
Print message if in verbose mode.
"""
if self.verbose >= level:
dt = datetime.now ()
print ("%4d-%02d-%02d %02d:%02d:%02d.%06d: %s" %(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond, msg)),
def log (self, level, msg):
"""
log relevant messages in logfile
and print if loglevel is reached
"""
self.message (level, msg)
file = open ("/var/log/bde/" + os.getcwd().split('/')[-1], "a")
dt = datetime.now ()
file.write ("%4d-%02d-%02d %02d:%02d:%02d.%06d: " %(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond)),
file.write (msg + "\n")
file.close ()
def errlog (self, msg):
"""
Log Errors in seperate logfile too
"""
self.log (0, msg)
file = open ("/var/log/bde/" + os.getcwd().split('/')[-1] + '.err', "a")
dt = datetime.now ()
file.write ("%4d-%02d-%02d %02d:%02d:%02d.%06d: " %(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond)),
file.write (msg + "\n")
file.close ()
def debug (self):
"""
Debuging
"""
if self.setdebug:
pdb.set_trace()
def add_conn (self, stid, name, ipsps, mode = "passive"):
"""
Add a passive connetion from PLC to connections.dict
"""
if mode not in ["passive", "active"]:
print ("Connection mode is not valid")
raise Warning
if stid in self.connections['TCP']:
self.message (1, "Connection " + ipsps + "-" + name + " already exists")
raise Warning
self.message (1, "Connection : " + ipsps + "-" + name + " added " + mode)
#Socket , Counter, Mode, StId, Name
self.connections['TCP'][ipsps] = [None, 0, mode, stid, name]
def dt_handler (self, data, client_id, source = ''):
"""
Handler for data telegrams
"""
_channel = 'TCP'
self.message (3,'DT_handler : data packet from %s with length %d ' % (client_id, len (data)))
#self.message (3,'DT_handler : data packet from %s: %s ' % (client_id, str (data)))
ret_val = tel_decode.decodetelegram (data)
self.message (6,'DT_handler : Decoded from %s' % (str (ret_val)))
teltype = ret_val['type']
if teltype != self.connections[_channel][(client_id)][3]:
print ("Invalid Telegram from this Station")
raise Warning
DB_con = self.connections['DB']
# Do counter checking if a valid telegram arrived
count_old = self.connections[_channel][(client_id)][1]
#if 'nr' in ret_val: FixMe add method to Telegram
if ret_val.has_key('nr'):
count = ret_val['nr']
self.message (2,' DT_handler : Tel. Counter old %d new %d' % (count_old, count))
if (count == count_old) and (count > 0):
self.errlog (' DT_handler : FixMe repeated Tel %d' % (count))
_quit = 0
elif (count == 0) or (count == (count_old % 32767) + 1) or (count == -1):
#Other Telegram received
self.log (3, "DT_handler : Tel Counter valid %d" % (count))
_quit = ret_val['check']
if _quit == 0:
self.message (2,' DT_handler : Telegram specific header check passed ')
#============================================================================================
if (count > 0):
#self.debug()
if teltype == 'PD01':
self.message (3, ' DT_handler : Store Data from PD01 Pruefzelle1')
DB_con.addpruefzelle1 (ret_val)
elif teltype == 'PD05':
self.message (3, ' DT_handler : Store Data from PD05 Blindniet')
DB_con.addblindniet (ret_val)
elif teltype == 'PD06':
self.message (3, ' DT_handler : Store Data from PD06 Bajonettclip')
DB_con.addbajonettclip (ret_val)
elif teltype == 'PD07':
self.message (3, ' DT_handler : Store Data from PD07 CClip')
DB_con.addcclip (ret_val)
elif teltype == 'PD08':
self.message (3, ' DT_handler : Store Data from PD08 Masseblech')
DB_con.addmasseblech (ret_val)
elif teltype == 'PD10':
self.message (3, ' DT_handler : Store Data from PD10 Pruefzelle2')
DB_con.addpruefzelle2 (ret_val)
#============================================================================================
elif (count == 0):
self.message (2, ' DT_handler : Tel counter 0 Synchronisation Tel accept')
#============================================================================================
else:
self.message (2, ' DT_handler : Undefined Telegram or Counter')
_quit = 80
else:
# Countercheck failed negative quit telegram to force synchronisation
self.log (2, ' DT_handler : Tel count FAILED --> Synchronisation')
_quit = 99
if _quit > -1:
# Prepare Quit teltgramm
self.generatequit (count, _channel, client_id, teltype, ret_val ['src'], ret_val ['dst'], _quit)
self.message (5, ' DT_handler : Quit Tel queued:"')
count_old = count
self.connections[_channel][(client_id)][1] = count
else:
self.message (1,'"DT_Handler : unknown Telegram type, no Number')
self.debug ()
def generatequit (self, count, channel, client_id, msgtype, src, dst, quit):
"""
Generate an QUIT telegram and send it
"""
self. message (3, " generatequit : generate Quit Telegram for %s on channel %s, with quit %d" % (msgtype, channel, quit))
_data = chr ((count >> 8) & 0xFF) + chr (count & 0xFF)
_data = bytes ([((count >> 8) & 0xFF)]) + bytes ([(count & 0xFF)])
_data2 = \
doublechar (src) +\
doublechar (dst) +\
msgtype
_data3 = bytes ([0]) + bytes ([quit % 256])
_data = _data + _data2.encode () + _data3
#self.message (6, " generatequit : " + _data)
#self.log ( "generatequit" + _data)
self.queue_add (channel, client_id, msgtype, _data)
return
def queue_add (self, channel, client_id, msgtype, data):
"""
Add a telegram to sendqueue
"""
self.message (3, "Added telegram to sendqueue")
self.connections['Queue'].append ([channel, client_id, msgtype, data])
def listen (self, socket):
"""
Wait for a client to open a connection to our socket.
"""
try:
new_socket, client = socket.accept ()
clientip, port = client
self.message (1, "Server connected by %s port %s" % (clientip, port))
if clientip in self.connections['TCP']:
self.sockets [(clientip, port)]= (new_socket, 'New')
if self.connections['TCP'][clientip][0]:
self.message (1, " Client tried to open an established connection Closing Socket")
oldsock = self.connections['TCP'][clientip][0]
oldsock.close ()
for ip, port in self.sockets:
if self.sockets[(ip, port)][0] == oldsock:
self.message (1, " read delete socket")
del self.sockets[(ip, port)]
break
self.connections['TCP'][clientip][0] = new_socket
self.message (3, "** Checking for active Connections to request")
else:
self.message (1, "Unauthorized connection from %s port %s " % (clientip, port))
except KeyboardInterrupt:
self.message (1,"Interrupted by user")
return
def blocknxmit (self):
"""
Wait for incomming data on any of the open connections, decode it and take
appropriate action and also check for outgoing data and free channels to
transmit it.
"""
# lifebeats
nt = time ()
DB_con = self.connections['DB']
# Send lifebeat every 5s
if nt - self.connections['LastBeat'] > 5:
#self.lifebeat ()
self.connections['LastBeat'] = nt
writecons = []
#Socket , Counter, Mode, StId, Name
#Check for active Connections
for ip in self.connections['TCP']:
if len (ip) != 4 and type (ip) != type (''):
print ("Invalid item in ISO connections")
raise Warning
# Connection Tuple found
socket, counter, mode, stid, name = self.connections['TCP'][ip]
if mode == 'active' and not socket:
#FixMe
print ("No Active Connections yet")
raise Warning
if len (self.connections['Queue']):
channel, client_id, msgtype, data = self.connections['Queue'][0]
if channel == 'TCP':
#conn_name == ISO-Tuple
self.message (3, "blocknxmit - Found to-be-send telegramm on Channel %s to %s" %(channel, client_id))
con = self.connections[channel][client_id][0]
if con:
writecons.append ((con, data, self.connections['TCP'], client_id))
# Select free sockets for transmission
# self.sockets = {(socket, STATE)}
writes = [i[0] for i in writecons]
reads = [self.sockets[i] for i in self.sockets]
(read, writes, xlist) = select ([i[0] for i in reads], writes, [], 0.1)
readcons = [i for i in reads if i[0] in read]
writecons = [i for i in writecons if i[0] in writes]
# First write all remaining messages
for conn, data, channel, client_id in writecons:
self.message (1, "blocknxmit - Write to Socket %s" % str (client_id))
# Loop until we successfuly got the data through
while 1:
try:
#conn.send (data.encode ())
conn.send (data)
except error:
# In case of a failure we'll need a new connection
self.message (1, "blocknxmit - Error on write")
if len (contyp) == 2 and type (contyp) == type (()):
socket, counter, mode = self.connections[c]
if mode == 'active':
print ("hoit")
raise Warning
loc_TSAP, rem_TSAP = contyp
self.makeactiveisoconnection (loc_TSAP, rem_TSAP)
conn = self.connections['ISO'][(loc_TSAP, rem_TSAP)][0]
else:
# Break on success
break
channel, client_id, msgtype, data = self.connections['Queue'][0]
del self.connections['Queue'][0]
# Then read all remaining messages from ready sockets
for conn in readcons:
self.message (1, "blocknxmit - Read from Socket " )
if conn[0] == self.listener_socket:
self.message (3, " blocknxmit - Read on listener socket")
self.listen (conn[0])
else:
self.message (3, " blocknxmit - Read on other socket")
self.read (conn)
# Sweep over DB for empty space in pick every once in a while
DB_con = self.connections['DB']
def read (self, conn):
sock, state = conn
try:
data = sock.recv (32768)
except error:
self.message (1, 'Socket error on read: ')
return
# Bail out if connection closed by client
if not data:
try:
client_ip, client_port = sock.getpeername ()
except:
client_ip, client_port = '0.0.0.0', 0
self.message (1, ' read empty telegramm - client %s %d closed connection - close socket !!!!'% (client_ip, client_port))
if (client_ip, client_port) in self.sockets:
socket, state = self.sockets [(client_ip, client_port)]
self.message (2, ' delete socket')
del self.sockets[(client_ip, client_port)]
for typ in self.connections:
try:
if self.connections[typ][0] == sock:
self.message (2, ' found socket in connection delete Reference %s' % str (typ))
self.connections[typ][0] = None
except:
a = 0
sock.close ()
return
self.message (1," read : Received data packet")
client_id = conn[0].getpeername()[0]
ret_val = self.dt_handler (data, client_id, source = '')
def write (self, loc_TSAP, rem_TSAP, data):
"""
Send Data via ISO Connection
"""
if 'client' in self.connections:
if (loc_TSAP, rem_TSAP) in self.connections['ISO']:
conn_data = self.connections['ISO'][(loc_TSAP, rem_TSAP)]
conn = conn_data[0]
if conn:
if conn_data[1] == "active":
# Loop until we successfuly got the data through
while 1:
try:
conn.send (data)
# In case of a failure we'll need a new connection
except error:
self.makeactiveisoconnection (loc_TSAP, rem_TSAP)
conn = self.connections['ISO'][(loc_TSAP, rem_TSAP)][0]
# Break on success
else:
break
else:
try:
conn.send (data)
except error:
print ("Send Error")
else:
self.message (1,"write: Connection" + loc_TSAP + "-" + rem_TSAP + " not active")
else:
self.message (1,"write: Connection " + loc_TSAP + "-" + rem_TSAP + " doesn't exist")
else:
self.message (1,"write: Client " + " doesn't exist")
def shutdown (self):
"""
Shut down socket and cleanup.
"""
self.socket.close ()
self.message (1,"Server shut down normally")
if __name__ == '__main__':
config = configparser.ConfigParser ()
config.read ('bde.cfg')
IP_BDE = config.get ('IP Settings', 'ipbde')
if not IP_BDE:
print ('No IP for BDE')
sys.exit (0)
print ('BDE configured for IP %s' %IP_BDE)
DBFILE = config.get ('DB Settings', 'dbfile')
if not DBFILE:
print ('No DB file configured')
sys.exit (0)
DBTALOG = config.get ('DB Settings', 'logfile')
if not DBTALOG:
print ('No DB TA Logfile configured')
sys.exit (0)
loglevel = config.getint ('DEBUG', 'loglevel')
if not loglevel:
loglevel = 0
print ('loglevel :%d' %loglevel)
debuglevel = config.getint ('DEBUG', 'debuglevel')
if not debuglevel:
debuglevel = 0
print ('debuglevel :%d' %debuglevel)
server = BDEServer (address = IP_BDE, verbose = loglevel, debug = debuglevel, DB = (DBFILE, DBTALOG) )
for i in chain (range (1, 11), range (98,100)):
IPPLC = config.get ('PD%02d' % i , 'ipsps')
if not IPPLC:
print ('No IP for PD%02d' % i)
else:
CAPPLC = config.get ('PD%02d' % i , 'name')
print ('BDE PD%02d configured for IP %s' %(i, IPPLC))
server.add_conn ('PD%02d' % i, CAPPLC, IPPLC, mode = "passive")
ot = time ()
while 1:
server.blocknxmit ()
server.shutdown ()
sys.exit (0)

56
bde_tst.py Executable file
View File

@@ -0,0 +1,56 @@
#! /usr/bin/python3
from socket import *
from select import select
import sys, os
import pdb
from datetime import datetime
import tel_decode
def log (msg):
"""
Print message if in verbose mode.
"""
file = open ("log.txt", "a")
dt = datetime.now ()
file.write ("%4d-%02d-%02d %02d:%02d:%02d.%06d: " %(dt.year, dt.month, dt.day, dt.hour, dt.minute, dt.second, dt.microsecond))
file.write (msg + "\n")
file.close ()
if __name__ == "__main__":
s = socket(AF_INET, SOCK_STREAM)
s.setsockopt (SOL_SOCKET, SO_REUSEADDR, 1)
print ("got Socket", s)
#s.bind(("192.168.2.2", 2002))
s.bind(("0.0.0.0", 2002))
#s.bind(("192.168.6.254", 2002))
s.listen (1)
# Select free sockets for transmission
read = [s]
writes = []
while 1:
(reads, writes, xlist) = select (read, writes, [], 0.1)
# First write all remaining messages
for conn in writes:
#conn.send ('LEBELVTRAB')
writes = []
# Then read all remaining messages from ready sockets
for conn in reads:
if conn == s:
try:
print ("Connection Request on Listener Socket")
cs, client = conn.accept ()
print ("Client" , client)
read.append (cs)
print ("Read Sockets", read)
except:
print ("No Connection")
else:
data = conn.recv (16384)
if data:
writes = [conn]
print (len (data), data)
telegram = tel_decode.decodetelegram (data)
print (telegram)

222
initdata/dblayout_sqlite.sql Normal file
View File

@@ -0,0 +1,222 @@
-- sqldum : sqlite
--
-- Database : storage
-- ------------------------------------------------------
-- Server version 4.0.24_Debian-10sarge1-log
--
-- Table structure for table bde
--
CREATE TABLE bde (
dmc char(25) UNIQUE,
startts timestamp(14) NOT NULL default '',
endts timestamp(14) NOT NULL default '',
ladungstraeger char(2) NOT NULL default '0',
seriennr char(25) NOT NULL default '',
pruefzelle1 char(25) NOT NULL default 'n.Durchlaufen',
putzzelle char(25) NOT NULL default 'n.Durchlaufen',
blindniet char(25) NOT NULL default 'n.Durchlaufen',
bajonettclip char(25) NOT NULL default 'n.Durchlaufen',
cclip char(25) NOT NULL default 'n.Durchlaufen',
masseblech char(25) NOT NULL default 'n.Durchlaufen',
pruefzelle2 char(25) NOT NULL default 'n.Durchlaufen',
csv integer NOT NULL default 0
);
CREATE TABLE blindniet (
dmc char(25) UNIQUE,
startts timestamp(14) NOT NULL,
endts timestamp(14) NOT NULL,
DGBM8status01 char(25) NOT NULL default '',
DGBM8status02 char(25) NOT NULL default '',
DGBM8status03 char(25) NOT NULL default '',
DGBM8status04 char(25) NOT NULL default '',
NietM8status01 char(25) NOT NULL default '',
NietM8status02 char(25) NOT NULL default '',
NietM6status01 char(25) NOT NULL default '',
NietM6status02 char(25) NOT NULL default '',
NietM6status03 char(25) NOT NULL default '',
NietM6status04 char(25) NOT NULL default '',
NietM6status05 char(25) NOT NULL default '',
DGBM8M01 INTEGER NOT NULL default '0',
DGBM8D01 INTEGER NOT NULL default '0',
DGBM8W01 INTEGER NOT NULL default '0',
DGBM8T01 INTEGER NOT NULL default '0',
DGBM8M02 INTEGER NOT NULL default '0',
DGBM8D02 INTEGER NOT NULL default '0',
DGBM8W02 INTEGER NOT NULL default '0',
DGBM8T02 INTEGER NOT NULL default '0',
DGBM8M03 INTEGER NOT NULL default '0',
DGBM8D03 INTEGER NOT NULL default '0',
DGBM8W03 INTEGER NOT NULL default '0',
DGBM8T03 INTEGER NOT NULL default '0',
DGBM8M04 INTEGER NOT NULL default '0',
DGBM8D04 INTEGER NOT NULL default '0',
DGBM8W04 INTEGER NOT NULL default '0',
DGBM8T04 INTEGER NOT NULL default '0',
NietM8F01 INTEGER NOT NULL default '0',
NietM8S01 INTEGER NOT NULL default '0',
NietM8F02 INTEGER NOT NULL default '0',
NietM8S02 INTEGER NOT NULL default '0',
NietM6F01 INTEGER NOT NULL default '0',
NietM6S01 INTEGER NOT NULL default '0',
NietM6F02 INTEGER NOT NULL default '0',
NietM6S02 INTEGER NOT NULL default '0',
NietM6F03 INTEGER NOT NULL default '0',
NietM6S03 INTEGER NOT NULL default '0',
NietM6F04 INTEGER NOT NULL default '0',
NietM6S04 INTEGER NOT NULL default '0',
NietM6F05 INTEGER NOT NULL default '0',
NietM6S05 INTEGER NOT NULL default '0'
);
CREATE TABLE bajonettclip (
dmc char(25) UNIQUE,
startts timestamp(14) NOT NULL,
endts timestamp(14) NOT NULL,
aufnahme INTEGER NOT NULL default '0',
bajostatus01 char(25) NOT NULL default '',
bajostatus02 char(25) NOT NULL default '',
bajostatus03 char(25) NOT NULL default '',
bajostatus04 char(25) NOT NULL default ''
);
CREATE TABLE cclip (
dmc char(25) UNIQUE,
startts timestamp(14) NOT NULL,
endts timestamp(14) NOT NULL,
aufnahme INTEGER NOT NULL default '0',
clipstatus01 char(25) NOT NULL default '',
clipstatus02 char(25) NOT NULL default '',
clipstatus03 char(25) NOT NULL default '',
clipstatus04 char(25) NOT NULL default '',
clipstatus05 char(25) NOT NULL default '',
clipstatus06 char(25) NOT NULL default '',
clipstatus07 char(25) NOT NULL default '',
clipstatus08 char(25) NOT NULL default '',
clipstatus09 char(25) NOT NULL default '',
clipstatus10 char(25) NOT NULL default '',
clipstatus11 char(25) NOT NULL default '',
clipstatus12 char(25) NOT NULL default '',
clipstatus13 char(25) NOT NULL default '',
clipstatus14 char(25) NOT NULL default '',
clipstatus15 char(25) NOT NULL default '',
clipstatus16 char(25) NOT NULL default '',
clipstatus17 char(25) NOT NULL default '',
clipstatus18 char(25) NOT NULL default ''
);
CREATE TABLE masseblech (
dmc char(25) UNIQUE,
startts timestamp(14) NOT NULL,
endts timestamp(14) NOT NULL,
ausgleichselement char(25) NOT NULL default '',
schallisolierung char(25) NOT NULL default '',
masseblech char(25) NOT NULL default '',
blindniet char(25) NOT NULL default '',
kombimutter char(25) NOT NULL default '',
fniet INTEGER NOT NULL default '0',
sniet INTEGER NOT NULL default '0',
mmutter INTEGER NOT NULL default '0',
dmutter INTEGER NOT NULL default '0',
wmutter INTEGER NOT NULL default '0',
tmutter INTEGER NOT NULL default '0'
);
CREATE TABLE pruefzelle1 (
dmc char(25) UNIQUE,
startts timestamp(14) NOT NULL,
endts timestamp(14) NOT NULL,
pp01 char(25) NOT NULL default '',
pp02 char(25) NOT NULL default '',
pp03 char(25) NOT NULL default '',
pp04 char(25) NOT NULL default '',
pp05 char(25) NOT NULL default '',
pp06 char(25) NOT NULL default '',
pp07 char(25) NOT NULL default '',
pp08 char(25) NOT NULL default '',
pp09 char(25) NOT NULL default '',
pp10 char(25) NOT NULL default '',
pp11 char(25) NOT NULL default '',
pp12 char(25) NOT NULL default '',
pp13 char(25) NOT NULL default '',
pp14 char(25) NOT NULL default '',
pp15 char(25) NOT NULL default '',
pp16 char(25) NOT NULL default '',
pp17 char(25) NOT NULL default '',
pp18 char(25) NOT NULL default '',
pp19 char(25) NOT NULL default '',
pp20 char(25) NOT NULL default '',
pp21 char(25) NOT NULL default '',
pp22 char(25) NOT NULL default '',
pp23 char(25) NOT NULL default '',
pp24 char(25) NOT NULL default '',
pp25 char(25) NOT NULL default '',
pp26 char(25) NOT NULL default '',
pp27 char(25) NOT NULL default '',
pp28 char(25) NOT NULL default '',
pp29 char(25) NOT NULL default '',
pp30 char(25) NOT NULL default '',
pp31 char(25) NOT NULL default '',
pp32 char(25) NOT NULL default '',
pp33 char(25) NOT NULL default '',
pp34 char(25) NOT NULL default '',
pp35 char(25) NOT NULL default '',
pp36 char(25) NOT NULL default '',
pp37 char(25) NOT NULL default '',
pp38 char(25) NOT NULL default '',
pp39 char(25) NOT NULL default '',
pp40 char(25) NOT NULL default ''
);
CREATE TABLE pruefzelle2 (
dmc char(25) UNIQUE,
startts timestamp(14) NOT NULL,
endts timestamp(14) NOT NULL,
pp01 char(25) NOT NULL default '',
pp02 char(25) NOT NULL default '',
pp03 char(25) NOT NULL default '',
pp04 char(25) NOT NULL default '',
pp05 char(25) NOT NULL default '',
pp06 char(25) NOT NULL default '',
pp07 char(25) NOT NULL default '',
pp08 char(25) NOT NULL default '',
pp09 char(25) NOT NULL default '',
pp10 char(25) NOT NULL default '',
pp11 char(25) NOT NULL default '',
pp12 char(25) NOT NULL default '',
pp13 char(25) NOT NULL default '',
pp14 char(25) NOT NULL default '',
pp15 char(25) NOT NULL default '',
pp16 char(25) NOT NULL default '',
pp17 char(25) NOT NULL default '',
pp18 char(25) NOT NULL default '',
pp19 char(25) NOT NULL default '',
pp20 char(25) NOT NULL default '',
pp21 char(25) NOT NULL default '',
pp22 char(25) NOT NULL default '',
pp23 char(25) NOT NULL default '',
pp24 char(25) NOT NULL default '',
pp25 char(25) NOT NULL default '',
pp26 char(25) NOT NULL default '',
pp27 char(25) NOT NULL default '',
pp28 char(25) NOT NULL default '',
pp29 char(25) NOT NULL default '',
pp30 char(25) NOT NULL default '',
pp31 char(25) NOT NULL default '',
pp32 char(25) NOT NULL default '',
pp33 char(25) NOT NULL default '',
pp34 char(25) NOT NULL default '',
pp35 char(25) NOT NULL default '',
pp36 char(25) NOT NULL default '',
pp37 char(25) NOT NULL default '',
pp38 char(25) NOT NULL default '',
pp39 char(25) NOT NULL default '',
pp40 char(25) NOT NULL default ''
);
-- PRIMARY KEY (id, x, y)
-- CREATE UNIQUE INDEX Lockedslots_idcy ON Lockedslots (id, x, y);
-- gewicht decimal(10,0) NOT NULL default '0',

32
log.py Normal file
View File

@@ -0,0 +1,32 @@
from time import time, strftime
loglevel = 7
def log (msg, _level = 3):
"""
Print message if in verbose mode.
"""
if _level <= loglevel:
file = open ("log.txt", "a")
file.write (strftime ("%Y-%m-%d %H:%M:%S "))
file.write (msg + "\n")
file.close ()
def strlog (instr):
"""
Converts String into readable format
"""
oustr = ''
for c in instr:
#if (ord (c) >= 33) & (ord (c) <= 127):
# oustr = oustr + c
#else:
oustr = oustr + " x%2X " %ord(c)
return oustr
def doublechar (i):
"""
build double char val out of int
"""
return chr (i % 256) + chr ((i >> 8) % 256)

14
parts.py Normal file
View File

@@ -0,0 +1,14 @@
bauteil = {1 : 'G11',
2 : 'G32'}
variante = {0 : 'LL-BASIS',
1 : 'RL-BASIS',
2 : 'LL-HUD',
3 : 'RL-HUD'}
artikelnummer = {'G11-LL-BASIS' : '9297644',
'G11-RL-BASIS' : '9297645',
'G11-LL-HUD' : '9297646',
'G11-RL-HUD' : '9297647',
'G32-LL_BASIS' : 'nrG32LLB',
'G32-RL-BASIS' : 'nrG32RLB',
'G32-LL-HUD' : 'nrG32LLH',
'G32-RL-HUD' : 'nrG32RLH'}

6
states.py Normal file
View File

@@ -0,0 +1,6 @@
bauteilstatus = {'0' : 'n.Durchlaufen',
'1' : 'i.O.',
'2' : 'n.i.O.'}
bearbeitungsstatus = {'0' : 'n.Bearbeitet',
'1' : 'i.O.',
'2' : 'n.i.O.'}

69
tel_decode.py Executable file
View File

@@ -0,0 +1,69 @@
#!/usr/bin/python
__author__ = "Michael Rest"
__date__ = "2016/09/01"
__email__ = "mr@mir.systems"
__version__ = "$Revision: 1.1 $"[11:-2]
from telegram import TEL_PD01, TEL_STAT
__all__ = ["decode_packet"]
#Decoder
def decode_PD01 (data):
from PD01_tel import fromstring
return fromstring (data)
def decode_PD02 (data):
from PD02_tel import fromstring
return fromstring (data)
def decode_PD05 (data):
from PD05_tel import fromstring
return fromstring (data)
def decode_PD06 (data):
from PD06_tel import fromstring
return fromstring (data)
def decode_PD07 (data):
from PD07_tel import fromstring
return fromstring (data)
def decode_PD08 (data):
from PD08_tel import fromstring
return fromstring (data)
def decode_PD10 (data):
from PD10_tel import fromstring
return fromstring (data)
def decode_PD98 (data):
from PD98_tel import fromstring
return fromstring (data)
def decode_STAT (data):
from STAT_tel import fromstring
return fromstring (data)
decoderlist = {
b'PD01': decode_PD01,
b'PD02': decode_PD02,
b'PD05': decode_PD05,
b'PD06': decode_PD06,
b'PD07': decode_PD07,
b'PD08': decode_PD08,
b'PD98': decode_PD98,
b'PD10': decode_PD10,
b'STAT': decode_STAT
}
def decodetelegram (data):
teltype = data[6:10]
if teltype in decoderlist:
return decoderlist[teltype](data)
else:
print ("Unhandled telegramtype %s" % teltype)
raise Warning ("Undhandled packettype")
return

82
telegram.py Normal file
View File

@@ -0,0 +1,82 @@
#!/usr/bin/python
__author__ = "Michael Rest"
__date__ = "2016/09/01"
__email__ = "mr@mir.systems"
__version__ = "$Revision: 1.1 $"[11:-2]
# Packet types
TEL_PD01 = 0x1 # Messzelle 1
TEL_PD02 = 0x2 # Entgratzelle 1
TEL_PD03 = 0x3 # Entgratzelle 2
TEL_PD04 = 0x4 # Beladezelle BAZ
TEL_PD05 = 0x5 # Blindniet
TEL_PD06 = 0x6 # Bajonettclips
TEL_PD07 = 0x7 # Metallclips
TEL_PD08 = 0x8 # Masseblech
TEL_PD09 = 0x9 # Nacharbeit
TEL_PD10 = 0xa # Messzelle2
TEL_PD98 = 0xb # TestSPS
TEL_PD99 = 0xc # Zentrale
TEL_SCLS = 0xd #
TEL_STAT = 0xe #
TEL_QUIT = 0xf #
#Helper
def tsdecode (data):
"""
Zeitstempel
"""
return '%s-%s-%s %s:%s:%s' % (data [0:4], data [4:6], data[6:8], data[8:10], data[10:12], data[12:14])
class TELEGRAM:
def __init__ (self):
self.len = 0
self.code = 0
self.attrib = {'src': ' ', 'dst': ' ', 'type': 'NONE', 'check' : 0}
def type (self):
"""
Return type hexadecimal type of the TELEGRAM. This function is
common for all.
"""
return self.code
def __len__ (self):
"""
Return the calcuclated length of the TELEGRAM. The value is
always WITHOUT the coded type, add 1 to it if in doubt.
"""
return self.len
def __getitem__ (self, key):
"""
Return Attrib
"""
return self.attrib[key]
def has_key (self, key):
"""
Check for Key
"""
return key in self.attrib
def __repr__ (self):
"""
Print a representation of the TELEGRAM. Use this method via
`-pair to transfer it over the wire. This will just return
the header data and not the real data!
"""
# Note that the data is not included in the length
return "%c%c" % (2, self.code << 4, self.number)
def __str__ (self):
"""
Return a readable and quite verbose overview of the TPDU instance.
Use this for debugging purposes or if you're just curious.
"""
string = DT_STRING % (self.len, self.number, self.data)
return string