code.vuplus.com Git - vuplus_dvbapp/blob - lib/python/Components/NimManager.py

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