EMP BWEC

Dieser Eintrag beschäftigt sich mit der automatisierten Steuerung der Klimakammer “TempEvent T 340/40/5”. Die folgende Anleitung wurde als vorbereitenden Schritt für die Kalibrierung von flachen Pt100-Temperatursensoren, die im elektromagnetischen Rückwärtskalorimeter verwendet werden, erarbeitet. Die Theorie dazu kann hier nachgelesen werden. Diese Anleitung verlangt die Installation des Python Pakets “calibration”, das hier zu finden ist

sudo apt install update
sudo apt install software-properties-common
sudo add-apt-repository ppa:deadsnakes/ppa
sudo apt install python3.8
sudo apt install python3-pip
pip3 install wheel
pip3 install setuptools
pip3 install twine
cd ~
cd <path to calibration/setup.py>
python3 setup.py bdist_wheel
pip3 install <path to .whl file>
cd ~
sudo chmod 666 /dev/ttyUSB0

1. Die flachen Sensoren und Referenzsensoren zeichnen sich durch mehrere Merkmale aus, die ALLE bekannt sein müssen, aber leicht herauszufinden sind:
   1. die ID, die an jedem Kabel gekennzeichnet ist
   2. die Position, an der gemessen wird. Die Positionen der Referenzsensoren wird sich allerdings selten ändern. Die Positionen der flachen Sensoren bestimmt sich durch den Mittelpunkt der Wicklungsfläche des Platindrahtes.
   3. Das Koordinatensystem kann man sich legen wie man will, bis jetzt war es immer in Einheiten von Millimetern. Steht man vor dem Submodul ist der Koordinatenursprung an der hinteren unteren rechten Ecke der Alveole. Es handelt sich um ein linkshändigen Koordinatensystem.
   4. der Channel, an dem der Sensor angeschlossen ist
   5. die Kassette, auf der sich der Channel befindet
   6. das digitale Multimeter (AGILENT=1, KEYSIGHT=2), an das die Kassette angeschlossen ist
   7. die Zugehörigkeit der Sensoren zu ihren Submodulen
2. Am Terminal der Klimakammer wird “Tau-und Kondensschutz” eingestellt
3. Am Terminal der Klimakammer wird das Prüfgut auf den Sensor gestellt, der mit einem blau/gelben Kabel einsam mit der Kammer verbunden ist. Es gibt drei Wahlmöglichkeiten für das Prüfgut. Dass man das korrekte Prüfgut eingestellt hat, kann man überprüfen, indem man zuvor erwähnten Sensor in der Hand hält und am Display der Klimakammer beobachtet, ob sich die Temperatur ändert.

nachdem alle Merkmale notiert worden sind, kann der Datenaufnahmealgorithmus beginnen. In einem Python3 wird nach der Installation das Paket folgendermaßen importiert.

from calibration.Datenaufnahme import *

Danach müssen von verschiedenen Klassen Instanzen erstellt werden:

• Sensor
• Plateau
• Submodule
• Run

• Sensor() bekommt folgende Parameter übergeben:
  1. die *eindeutige* ID, die auf dem Kabel zu finden ist
  2. 'sent' oder 'flat' für Referenzsensoren oder flache Sensoren
  3. die Zahl 1 oder 2 für AGILENT oder KEYSIGHT
  4. die Kassette: [1,2]
  5. den Channel: [1,2,3,4,5,6,7,8,9,10]
  6. die Position in form einer Liste, z.B: [256,106,91]
• Plateau() bekommt folgende Parameter übergeben:
  1. einen String, der eindeutig und in aufsteigender Reihenfolge vorkommen solle, z.B: “01”
  2. die Temperatur in °C als float oder int
  3. die Zeit in Sekunden, die für das Erreichen der Temperatur aufgewendet werden soll als float oder int,
• Submodule() bekommt folgende Parameter übergeben:
  1. einen String, der eindeutig das Submodul beschreibt
  2. eine Liste der Sensor-Instanzen (Referenzsensoren) die zum Submodul gehören
  3. eine Liste der Sensor-Instanzen (flache Sensoren) die zum Submodul gehören

• Run() bekommt folgende Parameter übergeben:
  1. eine natürliche Zahl, mit der die Verzeichnisse für die Datenaufnahme erstellt werden
  2. eine liste, die ALLE Sensor-Instanzen enthält
  3. eine liste, die ALLE Plateau-Instanzen enthält, in der gewünschten Reihenfolge der Temperaturanfahrten
  4. eine liste, die ALLE Submodule-Instanzen enthält

All diese Klassen besitzen zudem den Parameter 'information'. Es wird dringend empfohlen, diesen zu benutzen, um alle Informationen, die nicht als Parameter übergeben wurden, zu dokumentieren. Die Datenaufnahme wird gestartet, indem von der Instanz von Run() die Methode run(sudo = True) aufgerufen wird.

from calibration.Datenaufnahme import *
S001 = Sensor("S001", "sent", 1, 1, 1, position=[253, 106, 91])
S002 = Sensor("S002", "sent", 1, 1, 2, position=[253, 106, 13])
S003 = Sensor("S003", "sent", 1, 1, 3, position=[253, -6, 91])
S004 = Sensor("S004", "sent", 1, 1, 4, position=[253, -6, 13])
S005 = Sensor("S005", "sent", 1, 1, 5, position=[62, 106, 91])
S006 = Sensor("S006", "sent", 1, 1, 6, position=[62, 106, 13])
S007 = Sensor("S007", "sent", 1, 1, 7, position=[62, -6, 91])
S008 = Sensor("S008", "sent", 1, 1, 8, position=[62, -6, 13])
S009 = Sensor("S009", "sent", 1, 1, 9, position=[154, 105, 49])
S010 = Sensor("S010", "sent", 1, 1, 10, position=[154, -4, 49])
P001 = Sensor("P001", "core", 2, 1, 1, position=[106, 1, 13])
P002 = Sensor("P002", "core", 2, 1, 2, position=[232, 63, 25])
P003 = Sensor("P003", "core", 2, 1, 3, position=[106, 38, 75])
P004 = Sensor("P004", "core", 2, 1, 4, position=[232, 99, 87])
 
S011 = Sensor("S011", "sent", 1, 2, 1, position=[253, 106, 91])
S012 = Sensor("S012", "sent", 1, 2, 2, position=[253, 106, 13])
S013 = Sensor("S013", "sent", 1, 2, 3, position=[253, -6, 91])
S014 = Sensor("S014", "sent", 1, 2, 4, position=[253, -6, 13])
S015 = Sensor("S015", "sent", 1, 2, 5, position=[62, 106, 91])
S016 = Sensor("S016", "sent", 1, 2, 6, position=[62, 106, 13])
S017 = Sensor("S017", "sent", 1, 2, 7, position=[62, -6, 91])
S018 = Sensor("S018", "sent", 1, 2, 8, position=[62, -6, 13])
S019 = Sensor("S019", "sent", 1, 2, 9, position=[154, 105, 49])
S020 = Sensor("S020", "sent", 1, 2, 10, position=[154, -4, 49])
P005 = Sensor("P005", "core", 2, 1, 5, position=[106, 1, 13])
P006 = Sensor("P006", "core", 2, 1, 6, position=[232, 63, 25])
P007 = Sensor("P007", "core", 2, 1, 7, position=[106, 38, 75])
P008 = Sensor("P008", "core", 2, 1, 8, position=[232, 99, 87])
 
S021 = Sensor("S021", "sent", 1, 3, 1, position=[253, 106, 91])
S022 = Sensor("S022", "sent", 1, 3, 2, position=[253, 106, 13])
S023 = Sensor("S023", "sent", 1, 3, 3, position=[253, -6, 91])
S024 = Sensor("S024", "sent", 1, 3, 4, position=[253, -6, 13])
S025 = Sensor("S025", "sent", 1, 3, 5, position=[62, 106, 91])
S026 = Sensor("S026", "sent", 1, 3, 6, position=[62, 106, 13])
S027 = Sensor("S027", "sent", 1, 3, 7, position=[62, -6, 91])
S028 = Sensor("S028", "sent", 1, 3, 8, position=[62, -6, 13])
S029 = Sensor("S029", "sent", 1, 3, 9, position=[154, 105, 49])
S030 = Sensor("S030", "sent", 1, 3, 10, position=[154, -4, 49])
P009 = Sensor("P009", "core", 2, 1, 9, position=[106, 1, 13])
P010 = Sensor("P010", "core", 2, 1, 10, position=[232, 63, 25])
P011 = Sensor("P011", "core", 2, 2, 11, position=[106, 38, 75])
P012 = Sensor("P012", "core", 2, 2, 12, position=[232, 99, 87])
 
 
sentinelsS1 = [S001, S002, S003, S004, S005, S006, S007, S008, S009, S010]
flatsS1 = [P001, P002, P003, P004]
 
sentinelsS2 = [S011, S012, S013, S014, S015, S016, S017, S018, S019, S020]
flatsS2 = [P001, P002, P003, P004]
 
sentinelsS3 = [S021, S022, S023, S024, S025, S026, S027, S028, S029, S030]
flatsS3 = [P001, P002, P003, P004]
 
 
pl_stay = 4.5*3600
PL_01 = Plateau("01", -5, stay=pl_stay)
PL_02 = Plateau("02", -10, stay=pl_stay)
PL_03 = Plateau("03", -15, stay=pl_stay)
PL_04 = Plateau("04", -20, stay=pl_stay)
PL_05 = Plateau("05", -25, stay=pl_stay)
PL_06 = Plateau("06", -30, stay=pl_stay)
PL_07 = Plateau("07", -25, stay=pl_stay)
PL_08 = Plateau("08", -20, stay=pl_stay)
PL_09 = Plateau("09", -15, stay=pl_stay)
PL_10 = Plateau("10", -10, stay=pl_stay)
PL_11 = Plateau("11", -5, stay=pl_stay)
 
 
plateaulist = [PL_01, PL_02, PL_03, PL_04, PL_05,
               PL_06, PL_07, PL_08, PL_09, PL_10, PL_11]
 
sensorlist = [*sentinelsS1, *flatsS1,
              *sentinelsS2, *flatsS2,
              *sentinelsS3, *flatsS3]
 
submodulelist = [
    Submodule('001', sentinelsS1, flatsS1),
    Submodule('002', sentinelsS2, flatsS2),
    Submodule('003', sentinelsS3, flatsS3),
]
 
 
R = Run(125, sensorlist=sensorlist, plateaulist=plateaulist, N=10, submodulelist=submodulelist,
        information='hier sollten wichtige Informationen stehen')
R.run(sudo=True)

Nachdem das Skript startet, werden laufend die Widerstände der übergebenen Temperatursensoren aufgezeichnet und in entsprechende Dateien geschrieben.