servicemp3.cpp: more simple/flexible streaming detection
[enigma2.git] / lib / python / Components / NimManager.py
1 from Tools.HardwareInfo import HardwareInfo
2 from Tools.BoundFunction import boundFunction
3
4 from config import config, ConfigSubsection, ConfigSelection, ConfigFloat, \
5         ConfigSatlist, ConfigYesNo, ConfigInteger, ConfigSubList, ConfigNothing, \
6         ConfigSubDict, ConfigOnOff, ConfigDateTime
7
8 from enigma import eDVBSatelliteEquipmentControl as secClass, \
9         eDVBSatelliteLNBParameters as lnbParam, \
10         eDVBSatelliteDiseqcParameters as diseqcParam, \
11         eDVBSatelliteSwitchParameters as switchParam, \
12         eDVBSatelliteRotorParameters as rotorParam, \
13         eDVBResourceManager, eDVBDB, eEnv
14
15 from time import localtime, mktime
16 from datetime import datetime
17 from Tools.BoundFunction import boundFunction
18
19 from Tools import Directories
20 import xml.etree.cElementTree
21
22 def getConfigSatlist(orbpos, satlist):
23         default_orbpos = None
24         for x in satlist:
25                 if x[0] == orbpos:
26                         default_orbpos = orbpos
27                         break
28         return ConfigSatlist(satlist, default_orbpos)
29
30 def tryOpen(filename):
31         try:
32                 procFile = open(filename)
33         except IOError:
34                 return None
35         return procFile
36
37 class SecConfigure:
38         def getConfiguredSats(self):
39                 return self.configuredSatellites
40
41         def addSatellite(self, sec, orbpos):
42                 sec.addSatellite(orbpos)
43                 self.configuredSatellites.add(orbpos)
44
45         def addLNBSimple(self, sec, slotid, diseqcmode, toneburstmode = diseqcParam.NO, diseqcpos = diseqcParam.SENDNO, orbpos = 0, longitude = 0, latitude = 0, loDirection = 0, laDirection = 0, turningSpeed = rotorParam.FAST, useInputPower=True, inputPowerDelta=50, fastDiSEqC = False, setVoltageTone = True, diseqc13V = False):
46                 if orbpos is None or orbpos == 3601:
47                         return
48                 #simple defaults
49                 sec.addLNB()
50                 tunermask = 1 << slotid
51                 if self.equal.has_key(slotid):
52                         for slot in self.equal[slotid]:
53                                 tunermask |= (1 << slot)
54                 if self.linked.has_key(slotid):
55                         for slot in self.linked[slotid]:
56                                 tunermask |= (1 << slot)
57                 sec.setLNBSatCR(-1)
58                 sec.setLNBNum(1)
59                 sec.setLNBLOFL(9750000)
60                 sec.setLNBLOFH(10600000)
61                 sec.setLNBThreshold(11700000)
62                 sec.setLNBIncreasedVoltage(lnbParam.OFF)
63                 sec.setRepeats(0)
64                 sec.setFastDiSEqC(fastDiSEqC)
65                 sec.setSeqRepeat(0)
66                 sec.setCommandOrder(0)
67
68                 #user values
69                 sec.setDiSEqCMode(diseqcmode)
70                 sec.setToneburst(toneburstmode)
71                 sec.setCommittedCommand(diseqcpos)
72                 sec.setUncommittedCommand(0) # SENDNO
73                 #print "set orbpos to:" + str(orbpos)
74
75                 if 0 <= diseqcmode < 3:
76                         self.addSatellite(sec, orbpos)
77                         if setVoltageTone:
78                                 if diseqc13V:
79                                         sec.setVoltageMode(switchParam.HV_13)
80                                 else:
81                                         sec.setVoltageMode(switchParam.HV)
82                                 sec.setToneMode(switchParam.HILO)
83                         else:
84                                 sec.setVoltageMode(switchParam._14V)
85                                 sec.setToneMode(switchParam.OFF)
86                 elif (diseqcmode == 3): # diseqc 1.2
87                         if self.satposdepends.has_key(slotid):
88                                 for slot in self.satposdepends[slotid]:
89                                         tunermask |= (1 << slot)
90                         sec.setLatitude(latitude)
91                         sec.setLaDirection(laDirection)
92                         sec.setLongitude(longitude)
93                         sec.setLoDirection(loDirection)
94                         sec.setUseInputpower(useInputPower)
95                         sec.setInputpowerDelta(inputPowerDelta)
96                         sec.setRotorTurningSpeed(turningSpeed)
97
98                         for x in self.NimManager.satList:
99                                 print "Add sat " + str(x[0])
100                                 self.addSatellite(sec, int(x[0]))
101                                 if diseqc13V:
102                                         sec.setVoltageMode(switchParam.HV_13)
103                                 else:
104                                         sec.setVoltageMode(switchParam.HV)
105                                 sec.setToneMode(switchParam.HILO)
106                                 sec.setRotorPosNum(0) # USALS
107                 
108                 sec.setLNBSlotMask(tunermask)
109
110         def setSatposDepends(self, sec, nim1, nim2):
111                 print "tuner", nim1, "depends on satpos of", nim2
112                 sec.setTunerDepends(nim1, nim2)
113                 
114         def linkInternally(self, slotid):
115                 nim = self.NimManager.getNim(slotid)
116                 if nim.internallyConnectableTo is not None:
117                         nim.setInternalLink()
118
119         def linkNIMs(self, sec, nim1, nim2):
120                 print "link tuner", nim1, "to tuner", nim2
121                 if nim2 == (nim1 - 1):
122                         self.linkInternally(nim1)
123                 sec.setTunerLinked(nim1, nim2)
124                 
125         def getRoot(self, slotid, connto):
126                 visited = []
127                 while (self.NimManager.getNimConfig(connto).configMode.value in ("satposdepends", "equal", "loopthrough")):
128                         connto = int(self.NimManager.getNimConfig(connto).connectedTo.value)
129                         if connto in visited: # prevent endless loop
130                                 return slotid
131                         visited.append(connto)
132                 return connto
133
134         def update(self):
135                 sec = secClass.getInstance()
136                 self.configuredSatellites = set()
137                 for slotid in self.NimManager.getNimListOfType("DVB-S"):
138                         if self.NimManager.nimInternallyConnectableTo(slotid) is not None:
139                                 self.NimManager.nimRemoveInternalLink(slotid)
140                 sec.clear() ## this do unlinking NIMs too !!
141                 print "sec config cleared"
142
143                 self.linked = { }
144                 self.satposdepends = { }
145                 self.equal = { }
146
147                 nim_slots = self.NimManager.nim_slots
148
149                 used_nim_slots = [ ]
150
151                 for slot in nim_slots:
152                         if slot.type is not None:
153                                 used_nim_slots.append((slot.slot, slot.description, slot.config.configMode.value != "nothing" and True or False, slot.isCompatible("DVB-S2"), slot.frontend_id is None and -1 or slot.frontend_id))
154                 eDVBResourceManager.getInstance().setFrontendSlotInformations(used_nim_slots)
155
156                 for slot in nim_slots:
157                         x = slot.slot
158                         nim = slot.config
159                         if slot.isCompatible("DVB-S"):
160                                 # save what nim we link to/are equal to/satposdepends to.
161                                 # this is stored in the *value* (not index!) of the config list
162                                 if nim.configMode.value == "equal":
163                                         connto = self.getRoot(x, int(nim.connectedTo.value))
164                                         if not self.equal.has_key(connto):
165                                                 self.equal[connto] = []
166                                         self.equal[connto].append(x)
167                                 elif nim.configMode.value == "loopthrough":
168                                         self.linkNIMs(sec, x, int(nim.connectedTo.value))
169                                         connto = self.getRoot(x, int(nim.connectedTo.value))
170                                         if not self.linked.has_key(connto):
171                                                 self.linked[connto] = []
172                                         self.linked[connto].append(x)
173                                 elif nim.configMode.value == "satposdepends":
174                                         self.setSatposDepends(sec, x, int(nim.connectedTo.value))
175                                         connto = self.getRoot(x, int(nim.connectedTo.value))
176                                         if not self.satposdepends.has_key(connto):
177                                                 self.satposdepends[connto] = []
178                                         self.satposdepends[connto].append(x)
179
180                 for slot in nim_slots:
181                         x = slot.slot
182                         nim = slot.config
183                         hw = HardwareInfo()
184                         if slot.isCompatible("DVB-S"):
185                                 print "slot: " + str(x) + " configmode: " + str(nim.configMode.value)
186                                 if nim.configMode.value in ( "loopthrough", "satposdepends", "nothing" ):
187                                         pass
188                                 else:
189                                         sec.setSlotNotLinked(x)
190                                         if nim.configMode.value == "equal":
191                                                 pass
192                                         elif nim.configMode.value == "simple":          #simple config
193                                                 print "diseqcmode: ", nim.diseqcMode.value
194                                                 if nim.diseqcMode.value == "single":                    #single
195                                                         if nim.simpleSingleSendDiSEqC.value:
196                                                                 self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcA.orbital_position, toneburstmode = diseqcParam.NO, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.AA, diseqc13V = nim.diseqc13V.value)
197                                                         else:
198                                                                 self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcA.orbital_position, toneburstmode = diseqcParam.NO, diseqcmode = diseqcParam.NONE, diseqcpos = diseqcParam.SENDNO, diseqc13V = nim.diseqc13V.value)
199                                                 elif nim.diseqcMode.value == "toneburst_a_b":           #Toneburst A/B
200                                                         self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcA.orbital_position, toneburstmode = diseqcParam.A, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.SENDNO, diseqc13V = nim.diseqc13V.value)
201                                                         self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcB.orbital_position, toneburstmode = diseqcParam.B, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.SENDNO, diseqc13V = nim.diseqc13V.value)
202                                                 elif nim.diseqcMode.value == "diseqc_a_b":              #DiSEqC A/B
203                                                         fastDiSEqC = nim.simpleDiSEqCOnlyOnSatChange.value
204                                                         setVoltageTone = nim.simpleDiSEqCSetVoltageTone.value
205                                                         self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcA.orbital_position, toneburstmode = diseqcParam.NO, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.AA, fastDiSEqC = fastDiSEqC, setVoltageTone = setVoltageTone, diseqc13V = nim.diseqc13V.value)
206                                                         self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcB.orbital_position, toneburstmode = diseqcParam.NO, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.AB, fastDiSEqC = fastDiSEqC, setVoltageTone = setVoltageTone, diseqc13V = nim.diseqc13V.value)
207                                                 elif nim.diseqcMode.value == "diseqc_a_b_c_d":          #DiSEqC A/B/C/D
208                                                         fastDiSEqC = nim.simpleDiSEqCOnlyOnSatChange.value
209                                                         setVoltageTone = nim.simpleDiSEqCSetVoltageTone.value
210                                                         self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcA.orbital_position, toneburstmode = diseqcParam.NO, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.AA, fastDiSEqC = fastDiSEqC, setVoltageTone = setVoltageTone, diseqc13V = nim.diseqc13V.value)
211                                                         self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcB.orbital_position, toneburstmode = diseqcParam.NO, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.AB, fastDiSEqC = fastDiSEqC, setVoltageTone = setVoltageTone, diseqc13V = nim.diseqc13V.value)
212                                                         self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcC.orbital_position, toneburstmode = diseqcParam.NO, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.BA, fastDiSEqC = fastDiSEqC, setVoltageTone = setVoltageTone, diseqc13V = nim.diseqc13V.value)
213                                                         self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcD.orbital_position, toneburstmode = diseqcParam.NO, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.BB, fastDiSEqC = fastDiSEqC, setVoltageTone = setVoltageTone, diseqc13V = nim.diseqc13V.value)
214                                                 elif nim.diseqcMode.value == "positioner":              #Positioner
215                                                         if nim.latitudeOrientation.value == "north":
216                                                                 laValue = rotorParam.NORTH
217                                                         else:
218                                                                 laValue = rotorParam.SOUTH
219                                                         if nim.longitudeOrientation.value == "east":
220                                                                 loValue = rotorParam.EAST
221                                                         else:
222                                                                 loValue = rotorParam.WEST
223                                                         inputPowerDelta=nim.powerThreshold.value
224                                                         useInputPower=False
225                                                         turning_speed=0
226                                                         if nim.powerMeasurement.value:
227                                                                 useInputPower=True
228                                                                 turn_speed_dict = { "fast": rotorParam.FAST, "slow": rotorParam.SLOW }
229                                                                 if turn_speed_dict.has_key(nim.turningSpeed.value):
230                                                                         turning_speed = turn_speed_dict[nim.turningSpeed.value]
231                                                                 else:
232                                                                         beg_time = localtime(nim.fastTurningBegin.value)
233                                                                         end_time = localtime(nim.fastTurningEnd.value)
234                                                                         turning_speed = ((beg_time.tm_hour+1) * 60 + beg_time.tm_min + 1) << 16
235                                                                         turning_speed |= (end_time.tm_hour+1) * 60 + end_time.tm_min + 1
236                                                         self.addLNBSimple(sec, slotid = x, diseqcmode = 3,
237                                                                 longitude = nim.longitude.float,
238                                                                 loDirection = loValue,
239                                                                 latitude = nim.latitude.float,
240                                                                 laDirection = laValue,
241                                                                 turningSpeed = turning_speed,
242                                                                 useInputPower = useInputPower,
243                                                                 inputPowerDelta = inputPowerDelta,
244                                                                 diseqc13V = nim.diseqc13V.value)
245                                         elif nim.configMode.value == "advanced": #advanced config
246                                                 self.updateAdvanced(sec, x)
247                 print "sec config completed"
248
249         def updateAdvanced(self, sec, slotid):
250                 try:
251                         if config.Nims[slotid].advanced.unicableconnected is not None:
252                                 if config.Nims[slotid].advanced.unicableconnected.value == True:
253                                         config.Nims[slotid].advanced.unicableconnectedTo.save_forced = True
254                                         self.linkNIMs(sec, slotid, int(config.Nims[slotid].advanced.unicableconnectedTo.value))
255                                         connto = self.getRoot(slotid, int(config.Nims[slotid].advanced.unicableconnectedTo.value))
256                                         if not self.linked.has_key(connto):
257                                                 self.linked[connto] = []
258                                         self.linked[connto].append(slotid)
259                                 else:
260                                         config.Nims[slotid].advanced.unicableconnectedTo.save_forced = False
261                 except:
262                         pass
263
264                 lnbSat = {}
265                 for x in range(1,37):
266                         lnbSat[x] = []
267
268                 #wildcard for all satellites ( for rotor )
269                 for x in range(3601, 3605):
270                         lnb = int(config.Nims[slotid].advanced.sat[x].lnb.value)
271                         if lnb != 0:
272                                 for x in self.NimManager.satList:
273                                         print "add", x[0], "to", lnb
274                                         lnbSat[lnb].append(x[0])
275
276                 for x in self.NimManager.satList:
277                         lnb = int(config.Nims[slotid].advanced.sat[x[0]].lnb.value)
278                         if lnb != 0:
279                                 print "add", x[0], "to", lnb
280                                 lnbSat[lnb].append(x[0])
281
282                 for x in range(1,37):
283                         if len(lnbSat[x]) > 0:
284                                 currLnb = config.Nims[slotid].advanced.lnb[x]
285                                 sec.addLNB()
286
287                                 if x < 33:
288                                         sec.setLNBNum(x)
289
290                                 tunermask = 1 << slotid
291                                 if self.equal.has_key(slotid):
292                                         for slot in self.equal[slotid]:
293                                                 tunermask |= (1 << slot)
294                                 if self.linked.has_key(slotid):
295                                         for slot in self.linked[slotid]:
296                                                 tunermask |= (1 << slot)
297
298                                 if currLnb.lof.value != "unicable":
299                                         sec.setLNBSatCR(-1)
300
301                                 if currLnb.lof.value == "universal_lnb":
302                                         sec.setLNBLOFL(9750000)
303                                         sec.setLNBLOFH(10600000)
304                                         sec.setLNBThreshold(11700000)
305                                 elif currLnb.lof.value == "unicable":
306                                         def setupUnicable(configManufacturer, ProductDict):
307                                                 manufacturer_name = configManufacturer.value
308                                                 manufacturer = ProductDict[manufacturer_name]
309                                                 product_name = manufacturer.product.value
310                                                 sec.setLNBSatCR(manufacturer.scr[product_name].index)
311                                                 sec.setLNBSatCRvco(manufacturer.vco[product_name][manufacturer.scr[product_name].index].value*1000)
312                                                 sec.setLNBSatCRpositions(manufacturer.positions[product_name][0].value)
313                                                 sec.setLNBLOFL(manufacturer.lofl[product_name][0].value * 1000)
314                                                 sec.setLNBLOFH(manufacturer.lofh[product_name][0].value * 1000)
315                                                 sec.setLNBThreshold(manufacturer.loft[product_name][0].value * 1000)
316                                                 configManufacturer.save_forced = True
317                                                 manufacturer.product.save_forced = True
318                                                 manufacturer.vco[product_name][manufacturer.scr[product_name].index].save_forced = True
319
320                                         if currLnb.unicable.value == "unicable_user":
321 #TODO satpositions for satcruser
322                                                 sec.setLNBLOFL(currLnb.lofl.value * 1000)
323                                                 sec.setLNBLOFH(currLnb.lofh.value * 1000)
324                                                 sec.setLNBThreshold(currLnb.threshold.value * 1000)
325                                                 sec.setLNBSatCR(currLnb.satcruser.index)
326                                                 sec.setLNBSatCRvco(currLnb.satcrvcouser[currLnb.satcruser.index].value*1000)
327                                                 sec.setLNBSatCRpositions(1)     #HACK
328                                         elif currLnb.unicable.value == "unicable_matrix":
329                                                 setupUnicable(currLnb.unicableMatrixManufacturer, currLnb.unicableMatrix)
330                                         elif currLnb.unicable.value == "unicable_lnb":
331                                                 setupUnicable(currLnb.unicableLnbManufacturer, currLnb.unicableLnb)
332                                 elif currLnb.lof.value == "c_band":
333                                         sec.setLNBLOFL(5150000)
334                                         sec.setLNBLOFH(5150000)
335                                         sec.setLNBThreshold(5150000)
336                                 elif currLnb.lof.value == "user_defined":
337                                         sec.setLNBLOFL(currLnb.lofl.value * 1000)
338                                         sec.setLNBLOFH(currLnb.lofh.value * 1000)
339                                         sec.setLNBThreshold(currLnb.threshold.value * 1000)
340
341 #                               if currLnb.output_12v.value == "0V":
342 #                                       pass # nyi in drivers
343 #                               elif currLnb.output_12v.value == "12V":
344 #                                       pass # nyi in drivers
345
346                                 if currLnb.increased_voltage.value:
347                                         sec.setLNBIncreasedVoltage(lnbParam.ON)
348                                 else:
349                                         sec.setLNBIncreasedVoltage(lnbParam.OFF)
350
351                                 dm = currLnb.diseqcMode.value
352                                 if dm == "none":
353                                         sec.setDiSEqCMode(diseqcParam.NONE)
354                                 elif dm == "1_0":
355                                         sec.setDiSEqCMode(diseqcParam.V1_0)
356                                 elif dm == "1_1":
357                                         sec.setDiSEqCMode(diseqcParam.V1_1)
358                                 elif dm == "1_2":
359                                         sec.setDiSEqCMode(diseqcParam.V1_2)
360
361                                         if self.satposdepends.has_key(slotid):
362                                                 for slot in self.satposdepends[slotid]:
363                                                         tunermask |= (1 << slot)
364
365                                 if dm != "none":
366                                         if currLnb.toneburst.value == "none":
367                                                 sec.setToneburst(diseqcParam.NO)
368                                         elif currLnb.toneburst.value == "A":
369                                                 sec.setToneburst(diseqcParam.A)
370                                         elif currLnb.toneburst.value == "B":
371                                                 sec.setToneburst(diseqcParam.B)
372
373                                         # Committed Diseqc Command
374                                         cdc = currLnb.commitedDiseqcCommand.value
375
376                                         c = { "none": diseqcParam.SENDNO,
377                                                 "AA": diseqcParam.AA,
378                                                 "AB": diseqcParam.AB,
379                                                 "BA": diseqcParam.BA,
380                                                 "BB": diseqcParam.BB }
381
382                                         if c.has_key(cdc):
383                                                 sec.setCommittedCommand(c[cdc])
384                                         else:
385                                                 sec.setCommittedCommand(long(cdc))
386
387                                         sec.setFastDiSEqC(currLnb.fastDiseqc.value)
388
389                                         sec.setSeqRepeat(currLnb.sequenceRepeat.value)
390
391                                         if currLnb.diseqcMode.value == "1_0":
392                                                 currCO = currLnb.commandOrder1_0.value
393                                                 sec.setRepeats(0)
394                                         else:
395                                                 currCO = currLnb.commandOrder.value
396
397                                                 udc = int(currLnb.uncommittedDiseqcCommand.value)
398                                                 if udc > 0:
399                                                         sec.setUncommittedCommand(0xF0|(udc-1))
400                                                 else:
401                                                         sec.setUncommittedCommand(0) # SENDNO
402
403                                                 sec.setRepeats({"none": 0, "one": 1, "two": 2, "three": 3}[currLnb.diseqcRepeats.value])
404
405                                         setCommandOrder = False
406
407                                         # 0 "committed, toneburst",
408                                         # 1 "toneburst, committed",
409                                         # 2 "committed, uncommitted, toneburst",
410                                         # 3 "toneburst, committed, uncommitted",
411                                         # 4 "uncommitted, committed, toneburst"
412                                         # 5 "toneburst, uncommitted, commmitted"
413                                         order_map = {"ct": 0, "tc": 1, "cut": 2, "tcu": 3, "uct": 4, "tuc": 5}
414                                         sec.setCommandOrder(order_map[currCO])
415
416                                 if dm == "1_2":
417                                         latitude = currLnb.latitude.float
418                                         sec.setLatitude(latitude)
419                                         longitude = currLnb.longitude.float
420                                         sec.setLongitude(longitude)
421                                         if currLnb.latitudeOrientation.value == "north":
422                                                 sec.setLaDirection(rotorParam.NORTH)
423                                         else:
424                                                 sec.setLaDirection(rotorParam.SOUTH)
425                                         if currLnb.longitudeOrientation.value == "east":
426                                                 sec.setLoDirection(rotorParam.EAST)
427                                         else:
428                                                 sec.setLoDirection(rotorParam.WEST)
429
430                                         if currLnb.powerMeasurement.value:
431                                                 sec.setUseInputpower(True)
432                                                 sec.setInputpowerDelta(currLnb.powerThreshold.value)
433                                                 turn_speed_dict = { "fast": rotorParam.FAST, "slow": rotorParam.SLOW }
434                                                 if turn_speed_dict.has_key(currLnb.turningSpeed.value):
435                                                         turning_speed = turn_speed_dict[currLnb.turningSpeed.value]
436                                                 else:
437                                                         beg_time = localtime(currLnb.fastTurningBegin.value)
438                                                         end_time = localtime(currLnb.fastTurningEnd.value)
439                                                         turning_speed = ((beg_time.tm_hour + 1) * 60 + beg_time.tm_min + 1) << 16
440                                                         turning_speed |= (end_time.tm_hour + 1) * 60 + end_time.tm_min + 1
441                                                 sec.setRotorTurningSpeed(turning_speed)
442                                         else:
443                                                 sec.setUseInputpower(False)
444
445                                 sec.setLNBSlotMask(tunermask)
446
447                                 sec.setLNBPrio(int(currLnb.prio.value))
448
449                                 # finally add the orbital positions
450                                 for y in lnbSat[x]:
451                                         self.addSatellite(sec, y)
452                                         if x > 32:
453                                                 satpos = x > 32 and (3604-(36 - x)) or y
454                                         else:
455                                                 satpos = y
456                                         currSat = config.Nims[slotid].advanced.sat[satpos]
457                                         if currSat.voltage.value == "polarization":
458                                                 if config.Nims[slotid].diseqc13V.value:
459                                                         sec.setVoltageMode(switchParam.HV_13)
460                                                 else:
461                                                         sec.setVoltageMode(switchParam.HV)
462                                         elif currSat.voltage.value == "13V":
463                                                 sec.setVoltageMode(switchParam._14V)
464                                         elif currSat.voltage.value == "18V":
465                                                 sec.setVoltageMode(switchParam._18V)
466
467                                         if currSat.tonemode.value == "band":
468                                                 sec.setToneMode(switchParam.HILO)
469                                         elif currSat.tonemode.value == "on":
470                                                 sec.setToneMode(switchParam.ON)
471                                         elif currSat.tonemode.value == "off":
472                                                 sec.setToneMode(switchParam.OFF)
473                                                 
474                                         if not currSat.usals.value and x < 34:
475                                                 sec.setRotorPosNum(currSat.rotorposition.value)
476                                         else:
477                                                 sec.setRotorPosNum(0) #USALS
478
479         def __init__(self, nimmgr):
480                 self.NimManager = nimmgr
481                 self.configuredSatellites = set()
482                 self.update()
483
484 class NIM(object):
485         def __init__(self, slot, type, description, has_outputs = True, internally_connectable = None, multi_type = {}, frontend_id = None, i2c = None, is_empty = False):
486                 self.slot = slot
487
488                 if type not in ("DVB-S", "DVB-C", "DVB-T", "DVB-S2", None):
489                         print "warning: unknown NIM type %s, not using." % type
490                         type = None
491
492                 self.type = type
493                 self.description = description
494                 self.has_outputs = has_outputs
495                 self.internally_connectable = internally_connectable
496                 self.multi_type = multi_type
497                 self.i2c = i2c
498                 self.frontend_id = frontend_id
499                 self.__is_empty = is_empty
500
501         def isCompatible(self, what):
502                 if not self.isSupported():
503                         return False
504                 compatible = {
505                                 None: (None,),
506                                 "DVB-S": ("DVB-S", None),
507                                 "DVB-C": ("DVB-C", None),
508                                 "DVB-T": ("DVB-T", None),
509                                 "DVB-S2": ("DVB-S", "DVB-S2", None)
510                         }
511                 return what in compatible[self.type]
512         
513         def getType(self):
514                 return self.type
515         
516         def connectableTo(self):
517                 connectable = {
518                                 "DVB-S": ("DVB-S", "DVB-S2"),
519                                 "DVB-C": ("DVB-C",),
520                                 "DVB-T": ("DVB-T",),
521                                 "DVB-S2": ("DVB-S", "DVB-S2")
522                         }
523                 return connectable[self.type]
524
525         def getSlotName(self):
526                 # get a friendly description for a slot name.
527                 # we name them "Tuner A/B/C/...", because that's what's usually written on the back
528                 # of the device.
529                 return _("Tuner ") + chr(ord('A') + self.slot)
530
531         slot_name = property(getSlotName)
532
533         def getSlotID(self):
534                 return chr(ord('A') + self.slot)
535         
536         def getI2C(self):
537                 return self.i2c
538         
539         def hasOutputs(self):
540                 return self.has_outputs
541         
542         def internallyConnectableTo(self):
543                 return self.internally_connectable
544         
545         def setInternalLink(self):
546                 if self.internally_connectable is not None:
547                         print "setting internal link on frontend id", self.frontend_id
548                         open("/proc/stb/frontend/%d/rf_switch" % self.frontend_id, "w").write("internal")
549                 
550         def removeInternalLink(self):
551                 if self.internally_connectable is not None:
552                         print "removing internal link on frontend id", self.frontend_id
553                         open("/proc/stb/frontend/%d/rf_switch" % self.frontend_id, "w").write("external")
554         
555         def isMultiType(self):
556                 return (len(self.multi_type) > 0)
557         
558         def isEmpty(self):
559                 return self.__is_empty
560         
561         # empty tuners are supported!
562         def isSupported(self):
563                 return (self.frontend_id is not None) or self.__is_empty
564         
565         # returns dict {<slotid>: <type>}
566         def getMultiTypeList(self):
567                 return self.multi_type
568
569         slot_id = property(getSlotID)
570
571         def getFriendlyType(self):
572                 return {
573                         "DVB-S": "DVB-S", 
574                         "DVB-T": "DVB-T",
575                         "DVB-S2": "DVB-S2",
576                         "DVB-C": "DVB-C",
577                         None: _("empty")
578                         }[self.type]
579
580         friendly_type = property(getFriendlyType)
581
582         def getFriendlyFullDescription(self):
583                 nim_text = self.slot_name + ": "
584                         
585                 if self.empty:
586                         nim_text += _("(empty)")
587                 elif not self.isSupported():
588                         nim_text += self.description + " (" + _("not supported") + ")"
589                 else:
590                         nim_text += self.description + " (" + self.friendly_type + ")"
591                 
592                 return nim_text
593
594         friendly_full_description = property(getFriendlyFullDescription)
595         config_mode = property(lambda self: config.Nims[self.slot].configMode.value)
596         config = property(lambda self: config.Nims[self.slot])
597         empty = property(lambda self: self.type is None)
598
599 class NimManager:
600         def getConfiguredSats(self):
601                 return self.sec.getConfiguredSats()
602
603         def getTransponders(self, pos):
604                 if self.transponders.has_key(pos):
605                         return self.transponders[pos]
606                 else:
607                         return []
608
609         def getTranspondersCable(self, nim):
610                 nimConfig = config.Nims[nim]
611                 if nimConfig.configMode.value != "nothing" and nimConfig.cable.scan_type.value == "provider":
612                         return self.transponderscable[self.cablesList[nimConfig.cable.scan_provider.index][0]]
613                 return [ ]
614
615         def getTranspondersTerrestrial(self, region):
616                 return self.transpondersterrestrial[region]
617         
618         def getCableDescription(self, nim):
619                 return self.cablesList[config.Nims[nim].scan_provider.index][0]
620
621         def getCableFlags(self, nim):
622                 return self.cablesList[config.Nims[nim].scan_provider.index][1]
623
624         def getTerrestrialDescription(self, nim):
625                 return self.terrestrialsList[config.Nims[nim].terrestrial.index][0]
626
627         def getTerrestrialFlags(self, nim):
628                 return self.terrestrialsList[config.Nims[nim].terrestrial.index][1]
629
630         def getSatDescription(self, pos):
631                 return self.satellites[pos]
632
633         def sortFunc(self, x):
634                 orbpos = x[0]
635                 if orbpos > 1800:
636                         return orbpos - 3600
637                 else:
638                         return orbpos + 1800
639
640         def readTransponders(self):
641                 # read initial networks from file. we only read files which we are interested in,
642                 # which means only these where a compatible tuner exists.
643                 self.satellites = { }
644                 self.transponders = { }
645                 self.transponderscable = { }
646                 self.transpondersterrestrial = { }
647                 db = eDVBDB.getInstance()
648                 if self.hasNimType("DVB-S"):
649                         print "Reading satellites.xml"
650                         db.readSatellites(self.satList, self.satellites, self.transponders)
651                         self.satList.sort(key = self.sortFunc) # sort by orbpos
652                         #print "SATLIST", self.satList
653                         #print "SATS", self.satellites
654                         #print "TRANSPONDERS", self.transponders
655
656                 if self.hasNimType("DVB-C"):
657                         print "Reading cables.xml"
658                         db.readCables(self.cablesList, self.transponderscable)
659 #                       print "CABLIST", self.cablesList
660 #                       print "TRANSPONDERS", self.transponders
661
662                 if self.hasNimType("DVB-T"):
663                         print "Reading terrestrial.xml"
664                         db.readTerrestrials(self.terrestrialsList, self.transpondersterrestrial)
665 #                       print "TERLIST", self.terrestrialsList
666 #                       print "TRANSPONDERS", self.transpondersterrestrial
667
668         def enumerateNIMs(self):
669                 # enum available NIMs. This is currently very dreambox-centric and uses the /proc/bus/nim_sockets interface.
670                 # the result will be stored into nim_slots.
671                 # the content of /proc/bus/nim_sockets looks like:
672                 # NIM Socket 0:
673                 #          Type: DVB-S
674                 #          Name: BCM4501 DVB-S2 NIM (internal)
675                 # NIM Socket 1:
676                 #          Type: DVB-S
677                 #          Name: BCM4501 DVB-S2 NIM (internal)
678                 # NIM Socket 2:
679                 #          Type: DVB-T
680                 #          Name: Philips TU1216
681                 # NIM Socket 3:
682                 #          Type: DVB-S
683                 #          Name: Alps BSBE1 702A
684                 
685                 #
686                 # Type will be either "DVB-S", "DVB-S2", "DVB-T", "DVB-C" or None.
687
688                 # nim_slots is an array which has exactly one entry for each slot, even for empty ones.
689                 self.nim_slots = [ ]
690
691                 nimfile = tryOpen("/proc/bus/nim_sockets")
692
693                 if nimfile is None:
694                         return
695
696                 current_slot = None
697
698                 entries = {}
699                 for line in nimfile.readlines():
700                         if line == "":
701                                 break
702                         if line.strip().startswith("NIM Socket"):
703                                 parts = line.strip().split(" ")
704                                 current_slot = int(parts[2][:-1])
705                                 entries[current_slot] = {}
706                         elif line.strip().startswith("Type:"):
707                                 entries[current_slot]["type"] = str(line.strip()[6:])
708                                 entries[current_slot]["isempty"] = False
709                         elif line.strip().startswith("Name:"):
710                                 entries[current_slot]["name"] = str(line.strip()[6:])
711                                 entries[current_slot]["isempty"] = False
712                         elif line.strip().startswith("Has_Outputs:"):
713                                 input = str(line.strip()[len("Has_Outputs:") + 1:])
714                                 entries[current_slot]["has_outputs"] = (input == "yes")
715                         elif line.strip().startswith("Internally_Connectable:"):
716                                 input = int(line.strip()[len("Internally_Connectable:") + 1:])
717                                 entries[current_slot]["internally_connectable"] = input
718                         elif line.strip().startswith("Frontend_Device:"):
719                                 input = int(line.strip()[len("Frontend_Device:") + 1:])
720                                 entries[current_slot]["frontend_device"] = input
721                         elif  line.strip().startswith("Mode"):
722                                 # "Mode 0: DVB-T" -> ["Mode 0", " DVB-T"]
723                                 split = line.strip().split(":")
724                                 # "Mode 0" -> ["Mode, "0"]
725                                 split2 = split[0].split(" ")
726                                 modes = entries[current_slot].get("multi_type", {})
727                                 modes[split2[1]] = split[1].strip()
728                                 entries[current_slot]["multi_type"] = modes
729                         elif line.strip().startswith("I2C_Device:"):
730                                 input = int(line.strip()[len("I2C_Device:") + 1:])
731                                 entries[current_slot]["i2c"] = input
732                         elif line.strip().startswith("empty"):
733                                 entries[current_slot]["type"] = None
734                                 entries[current_slot]["name"] = _("N/A")
735                                 entries[current_slot]["isempty"] = True
736                 nimfile.close()
737                 
738                 from os import path
739                 
740                 for id, entry in entries.items():
741                         if not (entry.has_key("name") and entry.has_key("type")):
742                                 entry["name"] =  _("N/A")
743                                 entry["type"] = None
744                         if not (entry.has_key("i2c")):
745                                 entry["i2c"] = None
746                         if not (entry.has_key("has_outputs")):
747                                 entry["has_outputs"] = True
748                         if entry.has_key("frontend_device"): # check if internally connectable
749                                 if path.exists("/proc/stb/frontend/%d/rf_switch" % entry["frontend_device"]):
750                                         entry["internally_connectable"] = entry["frontend_device"] - 1
751                                 else:
752                                         entry["internally_connectable"] = None
753                         else:
754                                 entry["frontend_device"] = entry["internally_connectable"] = None
755                         if not (entry.has_key("multi_type")):
756                                 entry["multi_type"] = {}
757                         self.nim_slots.append(NIM(slot = id, description = entry["name"], type = entry["type"], has_outputs = entry["has_outputs"], internally_connectable = entry["internally_connectable"], multi_type = entry["multi_type"], frontend_id = entry["frontend_device"], i2c = entry["i2c"], is_empty = entry["isempty"]))
758
759         def hasNimType(self, chktype):
760                 for slot in self.nim_slots:
761                         if slot.isCompatible(chktype):
762                                 return True
763                         for type in slot.getMultiTypeList().values():
764                                 if chktype == type:
765                                         return True
766                 return False
767         
768         def getNimType(self, slotid):
769                 return self.nim_slots[slotid].type
770         
771         def getNimDescription(self, slotid):
772                 return self.nim_slots[slotid].friendly_full_description
773         
774         def getNimName(self, slotid):
775                 return self.nim_slots[slotid].description
776         
777         def getNim(self, slotid):
778                 return self.nim_slots[slotid]
779         
780         def getI2CDevice(self, slotid):
781                 return self.nim_slots[slotid].getI2C()
782
783         def getNimListOfType(self, type, exception = -1):
784                 # returns a list of indexes for NIMs compatible to the given type, except for 'exception'
785                 list = []
786                 for x in self.nim_slots:
787                         if x.isCompatible(type) and x.slot != exception:
788                                 list.append(x.slot)
789                 return list
790
791         def __init__(self):
792                 self.satList = [ ]
793                 self.cablesList = []
794                 self.terrestrialsList = []
795                 self.enumerateNIMs()
796                 self.readTransponders()
797                 InitNimManager(self)    #init config stuff
798
799         # get a list with the friendly full description
800         def nimList(self):
801                 list = [ ]
802                 for slot in self.nim_slots:
803                         list.append(slot.friendly_full_description)
804                 return list
805         
806         def getSlotCount(self):
807                 return len(self.nim_slots)
808         
809         def hasOutputs(self, slotid):
810                 return self.nim_slots[slotid].hasOutputs()
811         
812         def nimInternallyConnectableTo(self, slotid):
813                 return self.nim_slots[slotid].internallyConnectableTo()
814         
815         def nimRemoveInternalLink(self, slotid):
816                 self.nim_slots[slotid].removeInternalLink()
817         
818         def canConnectTo(self, slotid):
819                 slots = []
820                 if self.nim_slots[slotid].internallyConnectableTo() is not None:
821                         slots.append(self.nim_slots[slotid].internallyConnectableTo())
822                 for type in self.nim_slots[slotid].connectableTo(): 
823                         for slot in self.getNimListOfType(type, exception = slotid):
824                                 if self.hasOutputs(slot):
825                                         slots.append(slot)
826                 # remove nims, that have a conntectedTo reference on
827                 for testnim in slots[:]:
828                         for nim in self.getNimListOfType("DVB-S", slotid):
829                                 nimConfig = self.getNimConfig(nim)
830                                 if nimConfig.content.items.has_key("configMode") and nimConfig.configMode.value == "loopthrough" and int(nimConfig.connectedTo.value) == testnim:
831                                         slots.remove(testnim)
832                                         break 
833                 slots.sort()
834                 
835                 return slots
836         
837         def canEqualTo(self, slotid):
838                 type = self.getNimType(slotid)
839                 if type == "DVB-S2":
840                         type = "DVB-S"
841                 nimList = self.getNimListOfType(type, slotid)
842                 for nim in nimList[:]:
843                         mode = self.getNimConfig(nim)
844                         if mode.configMode.value == "loopthrough" or mode.configMode.value == "satposdepends":
845                                 nimList.remove(nim)
846                 return nimList
847
848         def canDependOn(self, slotid):
849                 type = self.getNimType(slotid)
850                 if type == "DVB-S2":
851                         type = "DVB-S"
852                 nimList = self.getNimListOfType(type, slotid)
853                 positionerList = []
854                 for nim in nimList[:]:
855                         mode = self.getNimConfig(nim)
856                         nimHaveRotor = mode.configMode.value == "simple" and mode.diseqcMode.value == "positioner"
857                         if not nimHaveRotor and mode.configMode.value == "advanced":
858                                 for x in range(3601, 3605):
859                                         lnb = int(mode.advanced.sat[x].lnb.value)
860                                         if lnb != 0:
861                                                 nimHaveRotor = True
862                                                 break
863                                 if not nimHaveRotor:
864                                         for sat in mode.advanced.sat.values():
865                                                 lnb_num = int(sat.lnb.value)
866                                                 diseqcmode = lnb_num and mode.advanced.lnb[lnb_num].diseqcMode.value or ""
867                                                 if diseqcmode == "1_2":
868                                                         nimHaveRotor = True
869                                                         break
870                         if nimHaveRotor:
871                                 alreadyConnected = False
872                                 for testnim in nimList:
873                                         testmode = self.getNimConfig(testnim)
874                                         if testmode.configMode.value == "satposdepends" and int(testmode.connectedTo.value) == int(nim):
875                                                 alreadyConnected = True
876                                                 break
877                                 if not alreadyConnected:
878                                         positionerList.append(nim)
879                 return positionerList
880         
881         def getNimConfig(self, slotid):
882                 return config.Nims[slotid]
883         
884         def getSatName(self, pos):
885                 for sat in self.satList:
886                         if sat[0] == pos:
887                                 return sat[1]
888                 return _("N/A")
889
890         def getSatList(self):
891                 return self.satList
892         
893         # returns True if something is configured to be connected to this nim
894         # if slotid == -1, returns if something is connected to ANY nim
895         def somethingConnected(self, slotid = -1):
896                 if (slotid == -1):
897                         connected = False
898                         for id in range(self.getSlotCount()):
899                                 if self.somethingConnected(id):
900                                         connected = True
901                         return connected
902                 else:
903                         nim = config.Nims[slotid]
904                         configMode = nim.configMode.value
905                 
906                         if self.nim_slots[slotid].isCompatible("DVB-S") or self.nim_slots[slotid].isCompatible("DVB-T") or self.nim_slots[slotid].isCompatible("DVB-C"):
907                                 return not (configMode == "nothing")            
908
909         def getSatListForNim(self, slotid):
910                 list = []
911                 if self.nim_slots[slotid].isCompatible("DVB-S"):
912                         nim = config.Nims[slotid]
913                         #print "slotid:", slotid
914
915                         #print "self.satellites:", self.satList[config.Nims[slotid].diseqcA.index]
916                         #print "diseqcA:", config.Nims[slotid].diseqcA.value
917                         configMode = nim.configMode.value
918
919                         if configMode == "equal":
920                                 slotid = int(nim.connectedTo.value)
921                                 nim = config.Nims[slotid]
922                                 configMode = nim.configMode.value
923                         elif configMode == "loopthrough":
924                                 slotid = self.sec.getRoot(slotid, int(nim.connectedTo.value))
925                                 nim = config.Nims[slotid]
926                                 configMode = nim.configMode.value
927
928                         if configMode == "simple":
929                                 dm = nim.diseqcMode.value
930                                 if dm in ("single", "toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"):
931                                         if nim.diseqcA.orbital_position != 3601:
932                                                 list.append(self.satList[nim.diseqcA.index-1])
933                                 if dm in ("toneburst_a_b", "diseqc_a_b", "diseqc_a_b_c_d"):
934                                         if nim.diseqcB.orbital_position != 3601:
935                                                 list.append(self.satList[nim.diseqcB.index-1])
936                                 if dm == "diseqc_a_b_c_d":
937                                         if nim.diseqcC.orbital_position != 3601:
938                                                 list.append(self.satList[nim.diseqcC.index-1])
939                                         if nim.diseqcD.orbital_position != 3601:
940                                                 list.append(self.satList[nim.diseqcD.index-1])
941                                 if dm == "positioner":
942                                         for x in self.satList:
943                                                 list.append(x)
944                         elif configMode == "advanced":
945                                 for x in range(3601, 3605):
946                                         if int(nim.advanced.sat[x].lnb.value) != 0:
947                                                 for x in self.satList:
948                                                         list.append(x)
949                                 if not list:
950                                         for x in self.satList:
951                                                 if int(nim.advanced.sat[x[0]].lnb.value) != 0:
952                                                         list.append(x)
953                 return list
954
955         def getRotorSatListForNim(self, slotid):
956                 list = []
957                 if self.nim_slots[slotid].isCompatible("DVB-S"):
958                         #print "slotid:", slotid
959                         #print "self.satellites:", self.satList[config.Nims[slotid].diseqcA.value]
960                         #print "diseqcA:", config.Nims[slotid].diseqcA.value
961                         configMode = config.Nims[slotid].configMode.value
962                         if configMode == "simple":
963                                 if config.Nims[slotid].diseqcMode.value == "positioner":
964                                         for x in self.satList:
965                                                 list.append(x)
966                         elif configMode == "advanced":
967                                 nim = config.Nims[slotid]
968                                 for x in range(3601, 3605):
969                                         if int(nim.advanced.sat[x].lnb.value) != 0:
970                                                 for x in self.satList:
971                                                         list.append(x)
972                                 if not list:
973                                         for x in self.satList:
974                                                 lnbnum = int(nim.advanced.sat[x[0]].lnb.value)
975                                                 if lnbnum != 0:
976                                                         lnb = nim.advanced.lnb[lnbnum]
977                                                         if lnb.diseqcMode.value == "1_2":
978                                                                 list.append(x)
979                 return list
980
981 def InitSecParams():
982         config.sec = ConfigSubsection()
983
984         x = ConfigInteger(default=25, limits = (0, 9999))
985         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_AFTER_CONT_TONE_DISABLE_BEFORE_DISEQC, configElement.value))
986         config.sec.delay_after_continuous_tone_disable_before_diseqc = x
987
988         x = ConfigInteger(default=10, limits = (0, 9999))
989         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_AFTER_FINAL_CONT_TONE_CHANGE, configElement.value))
990         config.sec.delay_after_final_continuous_tone_change = x
991
992         x = ConfigInteger(default=10, limits = (0, 9999))
993         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_AFTER_FINAL_VOLTAGE_CHANGE, configElement.value))
994         config.sec.delay_after_final_voltage_change = x
995
996         x = ConfigInteger(default=120, limits = (0, 9999))
997         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_BETWEEN_DISEQC_REPEATS, configElement.value))
998         config.sec.delay_between_diseqc_repeats = x
999
1000         x = ConfigInteger(default=50, limits = (0, 9999))
1001         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_AFTER_LAST_DISEQC_CMD, configElement.value))
1002         config.sec.delay_after_last_diseqc_command = x
1003
1004         x = ConfigInteger(default=50, limits = (0, 9999))
1005         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_AFTER_TONEBURST, configElement.value))
1006         config.sec.delay_after_toneburst = x
1007
1008         x = ConfigInteger(default=20, limits = (0, 9999))
1009         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_SWITCH_CMDS, configElement.value))
1010         config.sec.delay_after_change_voltage_before_switch_command = x
1011
1012         x = ConfigInteger(default=200, limits = (0, 9999))
1013         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_AFTER_ENABLE_VOLTAGE_BEFORE_SWITCH_CMDS, configElement.value))
1014         config.sec.delay_after_enable_voltage_before_switch_command = x
1015
1016         x = ConfigInteger(default=700, limits = (0, 9999))
1017         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_BETWEEN_SWITCH_AND_MOTOR_CMD, configElement.value))
1018         config.sec.delay_between_switch_and_motor_command = x
1019
1020         x = ConfigInteger(default=500, limits = (0, 9999))
1021         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER, configElement.value))
1022         config.sec.delay_after_voltage_change_before_measure_idle_inputpower = x
1023
1024         x = ConfigInteger(default=900, limits = (0, 9999))
1025         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_AFTER_ENABLE_VOLTAGE_BEFORE_MOTOR_CMD, configElement.value))
1026         config.sec.delay_after_enable_voltage_before_motor_command = x
1027
1028         x = ConfigInteger(default=500, limits = (0, 9999))
1029         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_AFTER_MOTOR_STOP_CMD, configElement.value))
1030         config.sec.delay_after_motor_stop_command = x
1031
1032         x = ConfigInteger(default=500, limits = (0, 9999))
1033         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MOTOR_CMD, configElement.value))
1034         config.sec.delay_after_voltage_change_before_motor_command = x
1035
1036         x = ConfigInteger(default=70, limits = (0, 9999))
1037         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_BEFORE_SEQUENCE_REPEAT, configElement.value))
1038         config.sec.delay_before_sequence_repeat = x
1039
1040         x = ConfigInteger(default=360, limits = (0, 9999))
1041         x.addNotifier(lambda configElement: secClass.setParam(secClass.MOTOR_RUNNING_TIMEOUT, configElement.value))
1042         config.sec.motor_running_timeout = x
1043
1044         x = ConfigInteger(default=1, limits = (0, 5))
1045         x.addNotifier(lambda configElement: secClass.setParam(secClass.MOTOR_COMMAND_RETRIES, configElement.value))
1046         config.sec.motor_command_retries = x
1047
1048         x = ConfigInteger(default=50, limits = (0, 9999))
1049         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_AFTER_DISEQC_RESET_CMD, configElement.value))
1050         config.sec.delay_after_diseqc_reset_cmd = x
1051
1052         x = ConfigInteger(default=150, limits = (0, 9999))
1053         x.addNotifier(lambda configElement: secClass.setParam(secClass.DELAY_AFTER_DISEQC_PERIPHERIAL_POWERON_CMD, configElement.value))
1054         config.sec.delay_after_diseqc_peripherial_poweron_cmd = x
1055
1056 # TODO add support for satpos depending nims to advanced nim configuration
1057 # so a second/third/fourth cable from a motorized lnb can used behind a
1058 # diseqc 1.0 / diseqc 1.1 / toneburst switch
1059 # the C(++) part should can handle this
1060 # the configElement should be only visible when diseqc 1.2 is disabled
1061
1062 def InitNimManager(nimmgr):
1063         hw = HardwareInfo()
1064         addNimConfig = False
1065         try:
1066                 config.Nims
1067         except:
1068                 addNimConfig = True
1069
1070         if addNimConfig:
1071                 InitSecParams()
1072                 config.Nims = ConfigSubList()
1073                 for x in range(len(nimmgr.nim_slots)):
1074                         config.Nims.append(ConfigSubsection())
1075
1076         lnb_choices = {
1077                 "universal_lnb": _("Universal LNB"),
1078                 "unicable": _("Unicable"),
1079                 "c_band": _("C-Band"),
1080                 "user_defined": _("User defined")}
1081
1082         lnb_choices_default = "universal_lnb"
1083
1084         unicablelnbproducts = {}
1085         unicablematrixproducts = {}
1086         doc = xml.etree.cElementTree.parse(eEnv.resolve("${datadir}/enigma2/unicable.xml"))
1087         root = doc.getroot()
1088
1089         entry = root.find("lnb")
1090         for manufacturer in entry.getchildren():
1091                 m={}
1092                 for product in manufacturer.getchildren():
1093                         scr=[]
1094                         lscr=("scr1","scr2","scr3","scr4","scr5","scr6","scr7","scr8")
1095                         for i in range(len(lscr)):
1096                                 scr.append(product.get(lscr[i],"0"))
1097                         for i in range(len(lscr)):
1098                                 if scr[len(lscr)-i-1] == "0":
1099                                         scr.pop()
1100                                 else:
1101                                         break;
1102                         lof=[]
1103                         lof.append(int(product.get("positions",1)))
1104                         lof.append(int(product.get("lofl",9750)))
1105                         lof.append(int(product.get("lofh",10600)))
1106                         lof.append(int(product.get("threshold",11700)))
1107                         scr.append(tuple(lof))
1108                         m.update({product.get("name"):tuple(scr)})
1109                 unicablelnbproducts.update({manufacturer.get("name"):m})
1110
1111         entry = root.find("matrix")
1112         for manufacturer in entry.getchildren():
1113                 m={}
1114                 for product in manufacturer.getchildren():
1115                         scr=[]
1116                         lscr=("scr1","scr2","scr3","scr4","scr5","scr6","scr7","scr8")
1117                         for i in range(len(lscr)):
1118                                 scr.append(product.get(lscr[i],"0"))
1119                         for i in range(len(lscr)):
1120                                 if scr[len(lscr)-i-1] == "0":
1121                                         scr.pop()
1122                                 else:
1123                                         break;
1124                         lof=[]
1125                         lof.append(int(product.get("positions",1)))
1126                         lof.append(int(product.get("lofl",9750)))
1127                         lof.append(int(product.get("lofh",10600)))
1128                         lof.append(int(product.get("threshold",11700)))
1129                         scr.append(tuple(lof))
1130                         m.update({product.get("name"):tuple(scr)})
1131                 unicablematrixproducts.update({manufacturer.get("name"):m})
1132
1133         UnicableLnbManufacturers = unicablelnbproducts.keys()
1134         UnicableLnbManufacturers.sort()
1135         UnicableMatrixManufacturers = unicablematrixproducts.keys()
1136         UnicableMatrixManufacturers.sort()
1137
1138         unicable_choices = {
1139                 "unicable_lnb": _("Unicable LNB"),
1140                 "unicable_matrix": _("Unicable Martix"),
1141                 "unicable_user": "Unicable "+_("User defined")}
1142         unicable_choices_default = "unicable_lnb"
1143
1144         advanced_lnb_satcruser_choices = [ ("1", "SatCR 1"), ("2", "SatCR 2"), ("3", "SatCR 3"), ("4", "SatCR 4"),
1145                                         ("5", "SatCR 5"), ("6", "SatCR 6"), ("7", "SatCR 7"), ("8", "SatCR 8")]
1146
1147         prio_list = [ ("-1", _("Auto")) ]
1148         prio_list += [(str(prio), str(prio)) for prio in range(65)+range(14000,14065)+range(19000,19065)]
1149
1150         advanced_lnb_csw_choices = [("none", _("None")), ("AA", _("AA")), ("AB", _("AB")), ("BA", _("BA")), ("BB", _("BB"))]
1151         advanced_lnb_csw_choices += [(str(0xF0|y), "Input " + str(y+1)) for y in range(0, 16)]
1152
1153         advanced_lnb_ucsw_choices = [("0", _("None"))] + [(str(y), "Input " + str(y)) for y in range(1, 17)]
1154
1155         diseqc_mode_choices = [
1156                 ("single", _("Single")), ("toneburst_a_b", _("Toneburst A/B")),
1157                 ("diseqc_a_b", _("DiSEqC A/B")), ("diseqc_a_b_c_d", _("DiSEqC A/B/C/D")),
1158                 ("positioner", _("Positioner"))]
1159
1160         positioner_mode_choices = [("usals", _("USALS")), ("manual", _("manual"))]
1161
1162         diseqc_satlist_choices = [(3601, _('nothing connected'), 1)] + nimmgr.satList
1163         
1164         longitude_orientation_choices = [("east", _("East")), ("west", _("West"))]
1165         latitude_orientation_choices = [("north", _("North")), ("south", _("South"))]
1166         turning_speed_choices = [("fast", _("Fast")), ("slow", _("Slow")), ("fast epoch", _("Fast epoch"))]
1167         
1168         advanced_satlist_choices = nimmgr.satList + [
1169                 (3601, _('All Satellites')+' 1', 1), (3602, _('All Satellites')+' 2', 1),
1170                 (3603, _('All Satellites')+' 3', 1), (3604, _('All Satellites')+' 4', 1)]
1171         advanced_lnb_choices = [("0", "not available")] + [(str(y), "LNB " + str(y)) for y in range(1, 33)]
1172         advanced_voltage_choices = [("polarization", _("Polarization")), ("13V", _("13 V")), ("18V", _("18 V"))]
1173         advanced_tonemode_choices = [("band", _("Band")), ("on", _("On")), ("off", _("Off"))]
1174         advanced_lnb_toneburst_choices = [("none", _("None")), ("A", _("A")), ("B", _("B"))]
1175         advanced_lnb_allsat_diseqcmode_choices = [("1_2", _("1.2"))]
1176         advanced_lnb_diseqcmode_choices = [("none", _("None")), ("1_0", _("1.0")), ("1_1", _("1.1")), ("1_2", _("1.2"))]
1177         advanced_lnb_commandOrder1_0_choices = [("ct", "committed, toneburst"), ("tc", "toneburst, committed")]
1178         advanced_lnb_commandOrder_choices = [
1179                 ("ct", "committed, toneburst"), ("tc", "toneburst, committed"),
1180                 ("cut", "committed, uncommitted, toneburst"), ("tcu", "toneburst, committed, uncommitted"),
1181                 ("uct", "uncommitted, committed, toneburst"), ("tuc", "toneburst, uncommitted, commmitted")]
1182         advanced_lnb_diseqc_repeat_choices = [("none", _("None")), ("one", _("One")), ("two", _("Two")), ("three", _("Three"))]
1183         advanced_lnb_fast_turning_btime = mktime(datetime(1970, 1, 1, 7, 0).timetuple());
1184         advanced_lnb_fast_turning_etime = mktime(datetime(1970, 1, 1, 19, 0).timetuple());
1185
1186         def configLOFChanged(configElement):
1187                 if configElement.value == "unicable":
1188                         x = configElement.slot_id
1189                         lnb = configElement.lnb_id
1190                         nim = config.Nims[x]
1191                         lnbs = nim.advanced.lnb
1192                         section = lnbs[lnb]
1193                         if isinstance(section.unicable, ConfigNothing):
1194                                 if lnb == 1:
1195                                         section.unicable = ConfigSelection(unicable_choices, unicable_choices_default)
1196                                 elif lnb == 2:
1197                                         section.unicable = ConfigSelection(choices = {"unicable_matrix": _("Unicable Martix"),"unicable_user": "Unicable "+_("User defined")}, default = "unicable_matrix")
1198                                 else:
1199                                         section.unicable = ConfigSelection(choices = {"unicable_user": _("User defined")}, default = "unicable_user")
1200
1201                                 def fillUnicableConf(sectionDict, unicableproducts, vco_null_check):
1202                                         for y in unicableproducts:
1203                                                 products = unicableproducts[y].keys()
1204                                                 products.sort()
1205                                                 tmp = ConfigSubsection()
1206                                                 tmp.product = ConfigSelection(choices = products, default = products[0])
1207                                                 tmp.scr = ConfigSubDict()
1208                                                 tmp.vco = ConfigSubDict()
1209                                                 tmp.lofl = ConfigSubDict()
1210                                                 tmp.lofh = ConfigSubDict()
1211                                                 tmp.loft = ConfigSubDict()
1212                                                 tmp.positions = ConfigSubDict()
1213                                                 for z in products:
1214                                                         scrlist = []
1215                                                         vcolist = unicableproducts[y][z]
1216                                                         tmp.vco[z] = ConfigSubList()
1217                                                         for cnt in range(1,1+len(vcolist)-1):
1218                                                                 vcofreq = int(vcolist[cnt-1])
1219                                                                 if vcofreq == 0 and vco_null_check:
1220                                                                         scrlist.append(("%d" %cnt,"SCR %d " %cnt +_("not used")))
1221                                                                 else:
1222                                                                         scrlist.append(("%d" %cnt,"SCR %d" %cnt))
1223                                                                 tmp.vco[z].append(ConfigInteger(default=vcofreq, limits = (vcofreq, vcofreq)))
1224                                                                 tmp.scr[z] = ConfigSelection(choices = scrlist, default = scrlist[0][0])
1225
1226                                                                 positions = int(vcolist[len(vcolist)-1][0])
1227                                                                 tmp.positions[z] = ConfigSubList()
1228                                                                 tmp.positions[z].append(ConfigInteger(default=positions, limits = (positions, positions)))
1229
1230                                                                 lofl = vcolist[len(vcolist)-1][1]
1231                                                                 tmp.lofl[z] = ConfigSubList()
1232                                                                 tmp.lofl[z].append(ConfigInteger(default=lofl, limits = (lofl, lofl)))
1233
1234                                                                 lofh = int(vcolist[len(vcolist)-1][2])
1235                                                                 tmp.lofh[z] = ConfigSubList()
1236                                                                 tmp.lofh[z].append(ConfigInteger(default=lofh, limits = (lofh, lofh)))
1237
1238                                                                 loft = int(vcolist[len(vcolist)-1][3])
1239                                                                 tmp.loft[z] = ConfigSubList()
1240                                                                 tmp.loft[z].append(ConfigInteger(default=loft, limits = (loft, loft)))
1241                                                 sectionDict[y] = tmp
1242
1243                                 if lnb < 3:
1244                                         print "MATRIX"
1245                                         section.unicableMatrix = ConfigSubDict()
1246                                         section.unicableMatrixManufacturer = ConfigSelection(UnicableMatrixManufacturers, UnicableMatrixManufacturers[0])
1247                                         fillUnicableConf(section.unicableMatrix, unicablematrixproducts, True)
1248
1249                                 if lnb < 2:
1250                                         print "LNB"
1251                                         section.unicableLnb = ConfigSubDict()
1252                                         section.unicableLnbManufacturer = ConfigSelection(UnicableLnbManufacturers, UnicableLnbManufacturers[0])
1253                                         fillUnicableConf(section.unicableLnb, unicablelnbproducts, False)
1254
1255 #TODO satpositions for satcruser
1256                                 section.satcruser = ConfigSelection(advanced_lnb_satcruser_choices, default="1")
1257                                 tmp = ConfigSubList()
1258                                 tmp.append(ConfigInteger(default=1284, limits = (950, 2150)))
1259                                 tmp.append(ConfigInteger(default=1400, limits = (950, 2150)))
1260                                 tmp.append(ConfigInteger(default=1516, limits = (950, 2150)))
1261                                 tmp.append(ConfigInteger(default=1632, limits = (950, 2150)))
1262                                 tmp.append(ConfigInteger(default=1748, limits = (950, 2150)))
1263                                 tmp.append(ConfigInteger(default=1864, limits = (950, 2150)))
1264                                 tmp.append(ConfigInteger(default=1980, limits = (950, 2150)))
1265                                 tmp.append(ConfigInteger(default=2096, limits = (950, 2150)))
1266                                 section.satcrvcouser = tmp 
1267
1268                                 nim.advanced.unicableconnected = ConfigYesNo(default=False)
1269                                 nim.advanced.unicableconnectedTo = ConfigSelection([(str(id), nimmgr.getNimDescription(id)) for id in nimmgr.getNimListOfType("DVB-S") if id != x])
1270         
1271         def configDiSEqCModeChanged(configElement):
1272                 section = configElement.section
1273                 if configElement.value == "1_2" and isinstance(section.longitude, ConfigNothing):
1274                         section.longitude = ConfigFloat(default = [5,100], limits = [(0,359),(0,999)])
1275                         section.longitudeOrientation = ConfigSelection(longitude_orientation_choices, "east")
1276                         section.latitude = ConfigFloat(default = [50,767], limits = [(0,359),(0,999)])
1277                         section.latitudeOrientation = ConfigSelection(latitude_orientation_choices, "north")
1278                         section.powerMeasurement = ConfigYesNo(default=True)
1279                         section.powerThreshold = ConfigInteger(default=hw.get_device_name() == "dm7025" and 50 or 15, limits=(0, 100))
1280                         section.turningSpeed = ConfigSelection(turning_speed_choices, "fast")
1281                         section.fastTurningBegin = ConfigDateTime(default=advanced_lnb_fast_turning_btime, formatstring = _("%H:%M"), increment = 600)
1282                         section.fastTurningEnd = ConfigDateTime(default=advanced_lnb_fast_turning_etime, formatstring = _("%H:%M"), increment = 600)
1283
1284         def configLNBChanged(configElement):
1285                 x = configElement.slot_id
1286                 nim = config.Nims[x]
1287                 if isinstance(configElement.value, tuple):
1288                         lnb = int(configElement.value[0])
1289                 else:
1290                         lnb = int(configElement.value)
1291                 lnbs = nim.advanced.lnb
1292                 if lnb and lnb not in lnbs:
1293                         section = lnbs[lnb] = ConfigSubsection()
1294                         section.lofl = ConfigInteger(default=9750, limits = (0, 99999))
1295                         section.lofh = ConfigInteger(default=10600, limits = (0, 99999))
1296                         section.threshold = ConfigInteger(default=11700, limits = (0, 99999))
1297 #                       section.output_12v = ConfigSelection(choices = [("0V", _("0 V")), ("12V", _("12 V"))], default="0V")
1298                         section.increased_voltage = ConfigYesNo(False)
1299                         section.toneburst = ConfigSelection(advanced_lnb_toneburst_choices, "none")
1300                         section.longitude = ConfigNothing()
1301                         if lnb > 32:
1302                                 tmp = ConfigSelection(advanced_lnb_allsat_diseqcmode_choices, "1_2")
1303                                 tmp.section = section
1304                                 configDiSEqCModeChanged(tmp)
1305                         else:
1306                                 tmp = ConfigSelection(advanced_lnb_diseqcmode_choices, "none")
1307                                 tmp.section = section
1308                                 tmp.addNotifier(configDiSEqCModeChanged)
1309                         section.diseqcMode = tmp
1310                         section.commitedDiseqcCommand = ConfigSelection(advanced_lnb_csw_choices)
1311                         section.fastDiseqc = ConfigYesNo(False)
1312                         section.sequenceRepeat = ConfigYesNo(False)
1313                         section.commandOrder1_0 = ConfigSelection(advanced_lnb_commandOrder1_0_choices, "ct")
1314                         section.commandOrder = ConfigSelection(advanced_lnb_commandOrder_choices, "ct")
1315                         section.uncommittedDiseqcCommand = ConfigSelection(advanced_lnb_ucsw_choices)
1316                         section.diseqcRepeats = ConfigSelection(advanced_lnb_diseqc_repeat_choices, "none")
1317                         section.prio = ConfigSelection(prio_list, "-1")
1318                         section.unicable = ConfigNothing()
1319                         tmp = ConfigSelection(lnb_choices, lnb_choices_default)
1320                         tmp.slot_id = x
1321                         tmp.lnb_id = lnb
1322                         tmp.addNotifier(configLOFChanged, initial_call = False)
1323                         section.lof = tmp
1324
1325         def configModeChanged(configMode):
1326                 slot_id = configMode.slot_id
1327                 nim = config.Nims[slot_id]
1328                 if configMode.value == "advanced" and isinstance(nim.advanced, ConfigNothing):
1329                         # advanced config:
1330                         nim.advanced = ConfigSubsection()
1331                         nim.advanced.sat = ConfigSubDict()
1332                         nim.advanced.sats = getConfigSatlist(192, advanced_satlist_choices)
1333                         nim.advanced.lnb = ConfigSubDict()
1334                         nim.advanced.lnb[0] = ConfigNothing()
1335                         for x in nimmgr.satList:
1336                                 tmp = ConfigSubsection()
1337                                 tmp.voltage = ConfigSelection(advanced_voltage_choices, "polarization")
1338                                 tmp.tonemode = ConfigSelection(advanced_tonemode_choices, "band")
1339                                 tmp.usals = ConfigYesNo(True)
1340                                 tmp.rotorposition = ConfigInteger(default=1, limits=(1, 255))
1341                                 lnb = ConfigSelection(advanced_lnb_choices, "0")
1342                                 lnb.slot_id = slot_id
1343                                 lnb.addNotifier(configLNBChanged, initial_call = False)
1344                                 tmp.lnb = lnb
1345                                 nim.advanced.sat[x[0]] = tmp
1346                         for x in range(3601, 3605):
1347                                 tmp = ConfigSubsection()
1348                                 tmp.voltage = ConfigSelection(advanced_voltage_choices, "polarization")
1349                                 tmp.tonemode = ConfigSelection(advanced_tonemode_choices, "band")
1350                                 tmp.usals = ConfigYesNo(default=True)
1351                                 tmp.rotorposition = ConfigInteger(default=1, limits=(1, 255))
1352                                 lnbnum = 33+x-3601
1353                                 lnb = ConfigSelection([("0", "not available"), (str(lnbnum), "LNB %d"%(lnbnum))], "0")
1354                                 lnb.slot_id = slot_id
1355                                 lnb.addNotifier(configLNBChanged, initial_call = False)
1356                                 tmp.lnb = lnb
1357                                 nim.advanced.sat[x] = tmp
1358
1359         def toneAmplitudeChanged(configElement):
1360                 fe_id = configElement.fe_id
1361                 slot_id = configElement.slot_id
1362                 if nimmgr.nim_slots[slot_id].description == 'Alps BSBE2':
1363                         open("/proc/stb/frontend/%d/tone_amplitude" %(fe_id), "w").write(configElement.value)
1364
1365         def tunerTypeChanged(nimmgr, configElement):
1366                 fe_id = configElement.fe_id
1367
1368                 cur_type = int(open("/proc/stb/frontend/%d/mode" % (fe_id), "r").read())
1369                 if cur_type != int(configElement.value):
1370                         print "tunerTypeChanged feid %d from %d to mode %d" % (fe_id, cur_type, int(configElement.value))
1371
1372                         try:
1373                                 oldvalue = open("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", "r").readline()
1374                                 open("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", "w").write("0")
1375                         except:
1376                                 print "[info] no /sys/module/dvb_core/parameters/dvb_shutdown_timeout available"
1377
1378                         frontend = eDVBResourceManager.getInstance().allocateRawChannel(fe_id).getFrontend()
1379                         frontend.closeFrontend()
1380                         open("/proc/stb/frontend/%d/mode" % (fe_id), "w").write(configElement.value)
1381                         frontend.reopenFrontend()
1382                         try:
1383                                 open("/sys/module/dvb_core/parameters/dvb_shutdown_timeout", "w").write(oldvalue)
1384                         except:
1385                                 print "[info] no /sys/module/dvb_core/parameters/dvb_shutdown_timeout available"
1386                         nimmgr.enumerateNIMs()
1387                 else:
1388                         print "tuner type is already already %d" %cur_type
1389
1390         empty_slots = 0
1391         for slot in nimmgr.nim_slots:
1392                 x = slot.slot
1393                 nim = config.Nims[x]
1394                 addMultiType = False
1395                 try:
1396                         nim.multiType
1397                 except:
1398                         addMultiType = True
1399                 if slot.isMultiType() and addMultiType:
1400                         typeList = []
1401                         for id in slot.getMultiTypeList().keys():
1402                                 type = slot.getMultiTypeList()[id]
1403                                 typeList.append((id, type))
1404                         nim.multiType = ConfigSelection(typeList, "0")
1405                         
1406                         nim.multiType.fe_id = x - empty_slots
1407                         nim.multiType.addNotifier(boundFunction(tunerTypeChanged, nimmgr))
1408                 
1409         empty_slots = 0
1410         for slot in nimmgr.nim_slots:
1411                 x = slot.slot
1412                 nim = config.Nims[x]
1413
1414                 if slot.isCompatible("DVB-S"):
1415                         nim.toneAmplitude = ConfigSelection([("11", "340mV"), ("10", "360mV"), ("9", "600mV"), ("8", "700mV"), ("7", "800mV"), ("6", "900mV"), ("5", "1100mV")], "7")
1416                         nim.toneAmplitude.fe_id = x - empty_slots
1417                         nim.toneAmplitude.slot_id = x
1418                         nim.toneAmplitude.addNotifier(toneAmplitudeChanged)
1419                         nim.diseqc13V = ConfigYesNo(False)
1420                         nim.diseqcMode = ConfigSelection(diseqc_mode_choices, "diseqc_a_b")
1421                         nim.connectedTo = ConfigSelection([(str(id), nimmgr.getNimDescription(id)) for id in nimmgr.getNimListOfType("DVB-S") if id != x])
1422                         nim.simpleSingleSendDiSEqC = ConfigYesNo(False)
1423                         nim.simpleDiSEqCSetVoltageTone = ConfigYesNo(True)
1424                         nim.simpleDiSEqCOnlyOnSatChange = ConfigYesNo(False)
1425                         nim.diseqcA = getConfigSatlist(192, diseqc_satlist_choices)
1426                         nim.diseqcB = getConfigSatlist(130, diseqc_satlist_choices)
1427                         nim.diseqcC = ConfigSatlist(list = diseqc_satlist_choices)
1428                         nim.diseqcD = ConfigSatlist(list = diseqc_satlist_choices)
1429                         nim.positionerMode = ConfigSelection(positioner_mode_choices, "usals")
1430                         nim.longitude = ConfigFloat(default=[5,100], limits=[(0,359),(0,999)])
1431                         nim.longitudeOrientation = ConfigSelection(longitude_orientation_choices, "east")
1432                         nim.latitude = ConfigFloat(default=[50,767], limits=[(0,359),(0,999)])
1433                         nim.latitudeOrientation = ConfigSelection(latitude_orientation_choices, "north")
1434                         nim.powerMeasurement = ConfigYesNo(True)
1435                         nim.powerThreshold = ConfigInteger(default=hw.get_device_name() == "dm8000" and 15 or 50, limits=(0, 100))
1436                         nim.turningSpeed = ConfigSelection(turning_speed_choices, "fast")
1437                         btime = datetime(1970, 1, 1, 7, 0);
1438                         nim.fastTurningBegin = ConfigDateTime(default = mktime(btime.timetuple()), formatstring = _("%H:%M"), increment = 900)
1439                         etime = datetime(1970, 1, 1, 19, 0);
1440                         nim.fastTurningEnd = ConfigDateTime(default = mktime(etime.timetuple()), formatstring = _("%H:%M"), increment = 900)
1441                         config_mode_choices = [ ("nothing", _("nothing connected")),
1442                                 ("simple", _("simple")), ("advanced", _("advanced"))]
1443                         if len(nimmgr.getNimListOfType(slot.type, exception = x)) > 0:
1444                                 config_mode_choices.append(("equal", _("equal to")))
1445                                 config_mode_choices.append(("satposdepends", _("second cable of motorized LNB")))
1446                         if len(nimmgr.canConnectTo(x)) > 0:
1447                                 config_mode_choices.append(("loopthrough", _("loopthrough to")))
1448                         nim.advanced = ConfigNothing()
1449                         tmp = ConfigSelection(config_mode_choices, "nothing")
1450                         tmp.slot_id = x
1451                         tmp.addNotifier(configModeChanged, initial_call = False)
1452                         nim.configMode = tmp
1453                 elif slot.isCompatible("DVB-C"):
1454                         nim.configMode = ConfigSelection(
1455                                 choices = {
1456                                         "enabled": _("enabled"),
1457                                         "nothing": _("nothing connected"),
1458                                         },
1459                                 default = "enabled")
1460                         list = [ ]
1461                         n = 0
1462                         for x in nimmgr.cablesList:
1463                                 list.append((str(n), x[0]))
1464                                 n += 1
1465                         nim.cable = ConfigSubsection()
1466                         possible_scan_types = [("bands", _("Frequency bands")), ("steps", _("Frequency steps"))]
1467                         if n:
1468                                 possible_scan_types.append(("provider", _("Provider")))
1469                                 nim.cable.scan_provider = ConfigSelection(default = "0", choices = list)
1470                         nim.cable.scan_type = ConfigSelection(default = "bands", choices = possible_scan_types)
1471                         nim.cable.scan_band_EU_VHF_I = ConfigYesNo(default = True)
1472                         nim.cable.scan_band_EU_MID = ConfigYesNo(default = True)
1473                         nim.cable.scan_band_EU_VHF_III = ConfigYesNo(default = True)
1474                         nim.cable.scan_band_EU_UHF_IV = ConfigYesNo(default = True)
1475                         nim.cable.scan_band_EU_UHF_V = ConfigYesNo(default = True)
1476                         nim.cable.scan_band_EU_SUPER = ConfigYesNo(default = True)
1477                         nim.cable.scan_band_EU_HYPER = ConfigYesNo(default = True)
1478                         nim.cable.scan_band_US_LOW = ConfigYesNo(default = False)
1479                         nim.cable.scan_band_US_MID = ConfigYesNo(default = False)
1480                         nim.cable.scan_band_US_HIGH = ConfigYesNo(default = False)
1481                         nim.cable.scan_band_US_SUPER = ConfigYesNo(default = False)
1482                         nim.cable.scan_band_US_HYPER = ConfigYesNo(default = False)
1483                         nim.cable.scan_frequency_steps = ConfigInteger(default = 1000, limits = (1000, 10000))
1484                         nim.cable.scan_mod_qam16 = ConfigYesNo(default = False)
1485                         nim.cable.scan_mod_qam32 = ConfigYesNo(default = False)
1486                         nim.cable.scan_mod_qam64 = ConfigYesNo(default = True)
1487                         nim.cable.scan_mod_qam128 = ConfigYesNo(default = False)
1488                         nim.cable.scan_mod_qam256 = ConfigYesNo(default = True)
1489                         nim.cable.scan_sr_6900 = ConfigYesNo(default = True)
1490                         nim.cable.scan_sr_6875 = ConfigYesNo(default = True)
1491                         nim.cable.scan_sr_ext1 = ConfigInteger(default = 0, limits = (0, 7230))
1492                         nim.cable.scan_sr_ext2 = ConfigInteger(default = 0, limits = (0, 7230))
1493                 elif slot.isCompatible("DVB-T"):
1494                         nim.configMode = ConfigSelection(
1495                                 choices = {
1496                                         "enabled": _("enabled"),
1497                                         "nothing": _("nothing connected"),
1498                                         },
1499                                 default = "enabled")
1500                         list = []
1501                         n = 0
1502                         for x in nimmgr.terrestrialsList:
1503                                 list.append((str(n), x[0]))
1504                                 n += 1
1505                         nim.terrestrial = ConfigSelection(choices = list)
1506                         nim.terrestrial_5V = ConfigOnOff()
1507                 else:
1508                         empty_slots += 1
1509                         nim.configMode = ConfigSelection(choices = { "nothing": _("disabled") }, default="nothing");
1510                         if slot.type is not None:
1511                                 print "pls add support for this frontend type!", slot.type
1512 #                       assert False
1513
1514         nimmgr.sec = SecConfigure(nimmgr)
1515
1516 nimmanager = NimManager()