change ConfigDummy to ConfigNothing
[enigma2.git] / lib / python / Components / NimManager.py
1 from config import config, ConfigSubsection, ConfigSelection, ConfigFloat, ConfigSatlist, ConfigYesNo, ConfigInteger, ConfigSubList, ConfigNothing, ConfigSubDict
2
3 from enigma import eDVBSatelliteEquipmentControl, \
4         eDVBSatelliteLNBParameters as lnbParam, \
5         eDVBSatelliteDiseqcParameters as diseqcParam, \
6         eDVBSatelliteSwitchParameters as switchParam, \
7         eDVBSatelliteRotorParameters as rotorParam
8
9 import xml.dom.minidom
10 from xml.dom import EMPTY_NAMESPACE
11 from skin import elementsWithTag
12 from Tools import XMLTools
13
14 from xml.sax import make_parser
15 from xml.sax.handler import ContentHandler
16
17 from Tools.BoundFunction import boundFunction
18
19 def tryOpen(filename):
20         try:
21                 procFile = open(filename)
22         except IOError:
23                 return ""
24         return procFile
25
26 class SecConfigure:
27         def addLNBSimple(self, sec, slotid, diseqcmode, toneburstmode = 0, diseqcpos = 0, orbpos = 0, longitude = 0, latitude = 0, loDirection = 0, laDirection = 0):
28                 #simple defaults
29                 sec.addLNB()
30                 tunermask = 1 << slotid
31                 if self.equal.has_key(slotid):
32                         tunermask |= (1 << self.equal[slotid])
33                 elif self.linked.has_key(slotid):
34                         tunermask |= (1 << self.linked[slotid])
35                 sec.setLNBTunerMask(tunermask)
36                 sec.setLNBLOFL(9750000)
37                 sec.setLNBLOFH(10600000)
38                 sec.setLNBThreshold(11700000)
39                 sec.setLNBIncreasedVoltage(lnbParam.OFF)
40                 sec.setRepeats(0)
41                 sec.setFastDiSEqC(0)
42                 sec.setSeqRepeat(0)
43                 sec.setVoltageMode(switchParam.HV)
44                 sec.setToneMode(switchParam.HILO)
45                 sec.setCommandOrder(0)
46
47                 #user values
48                 sec.setDiSEqCMode(diseqcmode)
49                 sec.setToneburst(toneburstmode)
50                 sec.setCommittedCommand(diseqcpos)
51                 #print "set orbpos to:" + str(orbpos)
52
53                 if (0 <= diseqcmode < 3):
54                         sec.addSatellite(orbpos)
55                         self.satList.append(orbpos)
56                 elif (diseqcmode == 3): # diseqc 1.2
57                         if self.satposdepends.has_key(slotid):
58                                 tunermask |= (1 << self.satposdepends[slotid])
59                                 sec.setLNBTunerMask(tunermask)
60                         sec.setLatitude(latitude)
61                         sec.setLaDirection(laDirection)
62                         sec.setLongitude(longitude)
63                         sec.setLoDirection(loDirection)
64                         sec.setUseInputpower(True)
65                         sec.setInputpowerDelta(50)
66
67                         for x in self.NimManager.satList:
68                                 print "Add sat " + str(x[0])
69                                 sec.addSatellite(int(x[0]))
70                                 sec.setVoltageMode(0)
71                                 sec.setToneMode(0)
72                                 sec.setRotorPosNum(0) # USALS
73                                 self.satList.append(int(x[0]))
74
75         def setSatposDepends(self, sec, nim1, nim2):
76                 print "tuner", nim1, "depends on satpos of", nim2
77                 sec.setTunerDepends(nim1, nim2)
78
79         def linkNIMs(self, sec, nim1, nim2):
80                 print "link tuner", nim1, "to tuner", nim2
81                 sec.setTunerLinked(nim1, nim2)
82
83         def getSatList(self):
84                 return self.satList
85
86         def update(self):
87                 sec = eDVBSatelliteEquipmentControl.getInstance()
88                 sec.clear() ## this do unlinking NIMs too !!
89                 print "sec config cleared"
90                 self.satList = []
91
92                 self.linked = { }
93                 self.satposdepends = { }
94                 self.equal = { }
95                 for slot in self.NimManager.nimslots:
96                         x = slot.slotid
97                         nim = config.Nims[x]
98                         if slot.nimType == self.NimManager.nimType["DVB-S"]:
99                                 if nim.configMode.value == "equal":
100                                         self.equal[nim.equalTo.value]=x
101                                 if nim.configMode.value == "loopthrough":
102                                         self.linkNIMs(sec, x, nim.linkedTo.value)
103                                         self.linked[nim.linkedTo.value]=x
104                                 elif nim.configMode.value == "satposdepends":
105                                         self.setSatposDepends(sec, x, nim.satposDependsTo.index)
106                                         self.satposdepends[nim.satposDependsTo.value]=x
107
108                 for slot in self.NimManager.nimslots:
109                         x = slot.slotid
110                         nim = config.Nims[x]
111                         if slot.nimType == self.NimManager.nimType["DVB-S"]:
112                                 print "slot: " + str(x) + " configmode: " + str(nim.configMode.value)
113                                 print "diseqcmode: ", nim.configMode.value
114                                 if nim.configMode.value in [ "loopthrough", "satposdepends", "equal", "nothing" ]:
115                                         pass
116                                 elif nim.configMode.value == "simple":          #simple config
117                                         if nim.diseqcMode.value == "single":                    #single
118                                                 self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcA.orbital_position, toneburstmode = diseqcParam.NO, diseqcmode = diseqcParam.NONE, diseqcpos = diseqcParam.SENDNO)
119                                         elif nim.diseqcMode.value == "toneburst_a_b":           #Toneburst A/B
120                                                 self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcA.orbital_position, toneburstmode = diseqcParam.A, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.SENDNO)
121                                                 self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcB.orbital_position, toneburstmode = diseqcParam.B, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.SENDNO)
122                                         elif nim.diseqcMode.value == "diseqc_a_b":              #DiSEqC A/B
123                                                 self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcA.orbital_position, toneburstmode = diseqcParam.NO, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.AA)
124                                                 self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcB.orbital_position, toneburstmode = diseqcParam.NO, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.AB)
125                                         elif nim.diseqcMode.value == "diseqc_a_b_c_d":          #DiSEqC A/B/C/D
126                                                 self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcA.orbital_position, toneburstmode = diseqcParam.NO, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.AA)
127                                                 self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcB.orbital_position, toneburstmode = diseqcParam.NO, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.AB)
128                                                 self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcC.orbital_position, toneburstmode = diseqcParam.NO, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.BA)
129                                                 self.addLNBSimple(sec, slotid = x, orbpos = nim.diseqcD.orbital_position, toneburstmode = diseqcParam.NO, diseqcmode = diseqcParam.V1_0, diseqcpos = diseqcParam.BB)
130                                         elif nim.diseqcMode.value == "positioner":              #Positioner
131                                                 if nim.latitudeOrientation.value == "north":
132                                                         laValue = rotorParam.NORTH
133                                                 else:
134                                                         laValue = rotorParam.SOUTH
135                                                 if nim.longitudeOrientation.value == "east":
136                                                         loValue = rotorParam.EAST
137                                                 else:
138                                                         loValue = rotorParam.WEST
139                                                 self.addLNBSimple(sec, slotid = x, diseqcmode = 3,
140                                                         longitude = nim.longitude.float,
141                                                         loDirection = loValue,
142                                                         latitude = nim.latitude.float,
143                                                         laDirection = laValue)
144                                 elif nim.configMode.value == "advanced": #advanced config
145                                         self.updateAdvanced(sec, x)
146                 print "sec config completed"
147
148         def updateAdvanced(self, sec, slotid):
149                 lnbSat = {}
150                 for x in range(1,33):
151                         lnbSat[x] = []
152                 for x in self.NimManager.satList:
153                         lnb = int(config.Nims[slotid].advanced.sat[x[0]].lnb.value)
154                         if lnb != 0:
155                                 print "add", x[0], "to", lnb
156                                 lnbSat[lnb].append(x[0])
157                 for x in range(1,33):
158                         if len(lnbSat[x]) > 0:
159                                 currLnb = config.Nims[slotid].advanced.lnb[x]
160                                 sec.addLNB()
161
162                                 tunermask = 1 << slotid
163                                 if self.equal.has_key(slotid):
164                                         tunermask |= (1 << self.equal[slotid])
165                                 elif self.linked.has_key(slotid):
166                                         tunermask |= (1 << self.linked[slotid])
167
168                                 if currLnb.lof.value == "universal_lnb":
169                                         sec.setLNBLOFL(9750000)
170                                         sec.setLNBLOFH(10600000)
171                                         sec.setLNBThreshold(11700000)
172                                 elif currLnb.lof.value == "c_band":
173                                         sec.setLNBLOFL(5150000)
174                                         sec.setLNBLOFH(5150000)
175                                         sec.setLNBThreshold(5150000)
176                                 elif currLnb.lof.value == "user_defined":
177                                         sec.setLNBLOFL(currLnb.lofl.value * 1000)
178                                         sec.setLNBLOFH(currLnb.lofh.value * 1000)
179                                         sec.setLNBThreshold(currLnb.threshold.value * 1000)
180                                         
181                                 if currLnb.output_12v.value == "0V":
182                                         pass # nyi in drivers
183                                 elif currLnb.output_12v.value == "12V":
184                                         pass # nyi in drivers
185                                         
186                                 if currLnb.increased_voltage.value:
187                                         sec.setLNBIncreasedVoltage(lnbParam.ON)
188                                 else:
189                                         sec.setLNBIncreasedVoltage(lnbParam.OFF)
190                                 
191                                 dm = currLnb.diseqcMode.value 
192                                 if dm == "none":
193                                         sec.setDiSEqCMode(diseqcParam.NONE)
194                                 elif dm == "1_0":
195                                         sec.setDiSEqCMode(diseqcParam.V1_0)
196                                 elif dm == "1_1":
197                                         sec.setDiSEqCMode(diseqcParam.V1_1)
198                                 elif dm == "1_2":
199                                         sec.setDiSEqCMode(diseqcParam.V1_2)
200
201                                         if self.satposdepends.has_key(slotid):  # only useable with rotors
202                                                 tunermask |= (1 << self.satposdepends[slotid])
203
204                                 if dm != "none":
205                                         if currLnb.toneburst.value == "none":
206                                                 sec.setToneburst(diseqcParam.NO)
207                                         elif currLnb.toneburst.value == "A":
208                                                 sec.setToneburst(diseqcParam.A)
209                                         elif currLnb.toneburst.value == "B":
210                                                 sec.setToneburst(diseqcParam.B)
211                                         
212                                         # Committed Diseqc Command
213                                         cdc = currLnb.commitedDiseqcCommand.value
214                                         
215                                         c = { "none": diseqcParam.SENDNO,
216                                                 "AA": diseqcParam.AA,
217                                                 "AB": diseqcParam.AB,
218                                                 "BA": diseqcParam.BA,
219                                                 "BB": diseqcParam.BB }
220
221                                         if c.has_key(cdc):
222                                                 sec.setCommittedCommand(c[cdc])
223                                         else:
224                                                 sec.setCommittedCommand(long(cdc))
225
226                                         sec.setFastDiSEqC(currLnb.fastDiseqc.value)
227                                                 
228                                         sec.setSeqRepeat(currLnb.sequenceRepeat.value)
229                                                 
230                                         if currLnb.diseqcMode.value == "1_0":
231                                                 currCO = currLnb.commandOrder1_0.value
232                                         else:
233                                                 currCO = currLnb.commandOrder.value
234
235                                                 udc = int(currLnb.uncommittedDiseqcCommand.value)
236                                                 if udc > 0:
237                                                         sec.setUncommittedCommand(0xF0|(udc-1))
238                                                 else:
239                                                         sec.setUncommittedCommand(0) # SENDNO
240
241                                                 sec.setRepeats({"none": 0, "one": 1, "two": 2, "three": 3}[currLnb.diseqcRepeats.value])
242
243                                         setCommandOrder = False
244                                         
245                                         # 0 "committed, toneburst", 
246                                         # 1 "toneburst, committed", 
247                                         # 2 "committed, uncommitted, toneburst",
248                                         # 3 "toneburst, committed, uncommitted",
249                                         # 4 "uncommitted, committed, toneburst"
250                                         # 5 "toneburst, uncommitted, commmitted"
251                                         order_map = {"ct": 0, "tc": 1, "cut": 2, "tcu": 3, "uct": 4, "tuc": 5}
252                                         sec.setCommandOrder(order_map[currCO])
253
254                                 if dm == "1_2":
255                                         latitude = currLnb.latitude.float
256                                         sec.setLatitude(latitude)
257                                         longitude = currLnb.longitude.float
258                                         sec.setLongitude(longitude)
259                                         if currLnb.latitudeOrientation.value == "north":
260                                                 sec.setLaDirection(rotorParam.NORTH)
261                                         else:
262                                                 sec.setLaDirection(rotorParam.SOUTH)
263                                         if currLnb.longitudeOrientation.value == "east":
264                                                 sec.setLoDirection(rotorParam.EAST)
265                                         else:
266                                                 sec.setLoDirection(rotorParam.WEST)
267                                                 
268                                 if currLnb.powerMeasurement.value:
269                                         sec.setUseInputpower(True)
270                                         sec.setInputpowerDelta(currLnb.powerThreshold.value)
271                                 else:
272                                         sec.setUseInputpower(False)
273
274                                 sec.setLNBTunerMask(tunermask)
275
276                                 # finally add the orbital positions
277                                 for y in lnbSat[x]:
278                                         sec.addSatellite(y)
279                                         currSat = config.Nims[slotid].advanced.sat[y]
280
281                                         if currSat.voltage.value == "polarization":
282                                                 sec.setVoltageMode(switchParam.HV)
283                                         elif currSat.voltage.value == "13V":
284                                                 sec.setVoltageMode(switchParam._14V)
285                                         elif currSat.voltage.value == "18V":
286                                                 sec.setVoltageMode(switchParam._18V)
287                                                 
288                                         if currSat.tonemode == "band":
289                                                 sec.setToneMode(switchParam.HILO)
290                                         elif currSat.tonemode == "on":
291                                                 sec.setToneMode(switchParam.ON)
292                                         elif currSat.tonemode == "off":
293                                                 sec.setToneMode(switchParam.OFF)
294                                                 
295                                         if not currSat.usals.value:
296                                                 sec.setRotorPosNum(currSat.rotorposition.value)
297                                         else:
298                                                 sec.setRotorPosNum(0) #USALS
299
300         def __init__(self, nimmgr):
301                 self.NimManager = nimmgr
302                 self.update()
303
304 class nimSlot:
305         def __init__(self, slotid, nimtype, name):
306                 self.slotid = slotid
307                 self.nimType = nimtype
308                 self.name = name
309
310 class NimManager:
311         class parseSats(ContentHandler):
312                 def __init__(self, satList, satellites, transponders):
313                         self.isPointsElement, self.isReboundsElement = 0, 0
314                         self.satList = satList
315                         self.satellites = satellites
316                         self.transponders = transponders
317         
318                 def startElement(self, name, attrs):
319                         if (name == "sat"):
320                                 #print "found sat " + attrs.get('name',"") + " " + str(attrs.get('position',""))
321                                 tpos = int(attrs.get('position',""))
322                                 if tpos < 0:
323                                         tpos = 3600 + tpos
324                                 tname = attrs.get('name',"").encode("UTF-8")
325                                 self.satellites[tpos] = tname
326                                 self.satList.append( (tpos, tname) )
327                                 self.parsedSat = int(tpos)
328                         elif (name == "transponder"):
329                                 modulation = int(attrs.get('modulation',"1")) # QPSK default
330                                 system = int(attrs.get('system',"0")) # DVB-S default
331                                 freq = int(attrs.get('frequency',""))
332                                 sr = int(attrs.get('symbol_rate',""))
333                                 pol = int(attrs.get('polarization',""))
334                                 fec = int(attrs.get('fec_inner',"0")) # AUTO default
335                                 if self.parsedSat in self.transponders:
336                                         pass
337                                 else:
338                                         self.transponders[self.parsedSat] = [ ]
339
340                                 self.transponders[self.parsedSat].append((0, freq, sr, pol, fec, system, modulation))
341
342         class parseCables(ContentHandler):
343                 def __init__(self, cablesList, transponders):
344                         self.isPointsElement, self.isReboundsElement = 0, 0
345                         self.cablesList = cablesList
346                         self.transponders = transponders
347         
348                 def startElement(self, name, attrs):
349                         if (name == "cable"):
350                                 #print "found sat " + attrs.get('name',"") + " " + str(attrs.get('position',""))
351                                 tname = attrs.get('name',"").encode("UTF-8")
352                                 self.cablesList.append(str(tname))
353                                 self.parsedCab = str(tname)
354                         elif (name == "transponder"):
355                                 freq = int(attrs.get('frequency',""))
356                                 sr = int(attrs.get('symbol_rate',""))
357                                 mod = int(attrs.get('modulation',"3")) # QAM64 default
358                                 fec = int(attrs.get('fec_inner',"0")) # AUTO default
359                                 if self.parsedCab in self.transponders:
360                                         pass
361                                 else:
362                                         self.transponders[self.parsedCab] = [ ]
363                                 self.transponders[self.parsedCab].append((1, freq, sr, mod, fec))
364
365         class parseTerrestrials(ContentHandler):
366                 def __init__(self, terrestrialsList, transponders):
367                         self.isPointsElement, self.isReboundsElement = 0, 0
368                         self.terrestrialsList = terrestrialsList
369                         self.transponders = transponders
370         
371                 def startElement(self, name, attrs):
372                         if (name == "terrestrial"):
373                                 #print "found sat " + attrs.get('name',"") + " " + str(attrs.get('position',""))
374                                 tname = attrs.get('name',"").encode("UTF-8")
375                                 tflags = attrs.get('flags',"")
376                                 self.terrestrialsList.append((tname, tflags))
377                                 self.parsedTer = str(tname)
378                         elif (name == "transponder"):
379                                 # TODO finish this!
380                                 freq = int(attrs.get('centre_frequency',""))
381                                 bw = int(attrs.get('bandwidth',"3")) # AUTO
382                                 const = int(attrs.get('constellation',"1")) # AUTO
383                                 crh = int(attrs.get('code_rate_hp',"5")) # AUTO
384                                 if crh > 5: # our terrestrial.xml is buggy... 6 for AUTO
385                                         crh = 5
386                                 crl = int(attrs.get('code_rate_lp',"5")) # AUTO
387                                 if crl > 5: # our terrestrial.xml is buggy... 6 for AUTO
388                                         crl = 5
389                                 guard = int(attrs.get('guard_interval',"4")) # AUTO
390                                 transm = int(attrs.get('transmission_mode',"2")) # AUTO
391                                 hierarchy = int(attrs.get('hierarchy_information',"4")) # AUTO
392                                 inv = int(attrs.get('inversion',"2")) # AUTO
393                                 if self.parsedTer in self.transponders:
394                                         pass
395                                 else:
396                                         self.transponders[self.parsedTer] = [ ]
397
398                                 self.transponders[self.parsedTer].append((2, freq, bw, const, crh, crl, guard, transm, hierarchy, inv))
399
400         def getTransponders(self, pos):
401                 if self.transponders.has_key(pos):
402                         return self.transponders[pos]
403                 else:
404                         return []
405
406         def getTranspondersCable(self, cable):
407                 return self.transponderscable[cable]
408
409         def getTranspondersTerrestrial(self, region):
410                 return self.transpondersterrestrial[region]
411         
412         def getCableDescription(self, nim):
413                 return self.cablesList[config.Nims[nim].cable.value]
414
415         def getTerrestrialDescription(self, nim):
416                 return self.terrestrialsList[config.Nims[nim].terrestrial.value][0]
417
418         def getTerrestrialFlags(self, nim):
419                 return self.terrestrialsList[config.Nims[nim].terrestrial.value][1]
420
421         def getConfiguredSats(self):
422                 return self.sec.getSatList()
423
424         def getSatDescription(self, pos):
425                 return self.satellites[pos]
426
427         def readSatsfromFile(self):
428                 self.satellites = { }
429                 self.transponders = { }
430                 self.transponderscable = { }
431                 self.transpondersterrestrial = { }              
432                 
433                 parser = make_parser()
434                 if (self.hasNimType(self.nimType["DVB-S"])):
435                         print "Reading satellites.xml"
436                         satHandler = self.parseSats(self.satList, self.satellites, self.transponders)
437                         parser.setContentHandler(satHandler)
438                         parser.parse('/etc/tuxbox/satellites.xml')
439                 if (self.hasNimType(self.nimType["DVB-C"])):
440                         print "Reading cables.xml"
441                         cabHandler = self.parseCables(self.cablesList, self.transponderscable)
442                         parser.setContentHandler(cabHandler)
443                         parser.parse('/etc/tuxbox/cables.xml')
444
445                 if (self.hasNimType(self.nimType["DVB-T"])):
446                         print "Reading terrestrial.xml"
447                         terHandler = self.parseTerrestrials(self.terrestrialsList, self.transpondersterrestrial)
448                         parser.setContentHandler(terHandler)
449                         parser.parse('/etc/tuxbox/terrestrial.xml')
450                 
451         def parseProc(self):
452                 self.nimTypes = {}
453                 self.nimNames = {}              
454                 self.nimSocketCount = 0
455                 nimfile = tryOpen("/proc/bus/nim_sockets")
456
457                 if nimfile == "":
458                                 return self.nimType["empty/unknown"]
459                         
460                 lastsocket = -1
461
462                 while 1:                
463                         line = nimfile.readline()
464                         if line == "":
465                                 break
466                         if line.strip().startswith("NIM Socket"):
467                                 parts = line.strip().split(" ")
468                                 id = int(parts[2][:1])
469                                 lastsocket = int(id)
470                                 self.nimSocketCount += 1
471                         elif line.strip().startswith("Type:"):
472                                 self.nimTypes[lastsocket] = str(line.strip()[6:])
473                                 #self.nimTypes[lastsocket] = str("DVB-T")
474                         elif line.strip().startswith("Name:"):
475                                 self.nimNames[lastsocket] = str(line.strip()[6:])
476                         elif line.strip().startswith("empty"):
477                                 self.nimNames[lastsocket] = _("N/A")
478                                 self.nimTypes[lastsocket] = "empty/unknown"
479
480                 nimfile.close()
481
482         def getNimType(self, slotID):
483                 if slotID >= self.nimCount:
484                         return self.nimType["empty/unknown"]
485                 else:   
486                         return self.nimType[self.nimTypes[slotID]]
487                         
488         def getNimTypeName(self, slotID):
489                 if slotID >= self.nimCount:
490                         return "empty/unknown"
491                 else:   
492                         return self.nimTypes[slotID]
493                 
494         def getNimName(self, slotID):
495                 return self.nimNames[slotID]
496
497         def getNimSocketCount(self):
498                 return self.nimSocketCount
499         
500         def hasNimType(self, chktype):
501                 for id, type in self.nimTypes.items():
502                         if (chktype == self.nimType[str(type)]):
503                                 return True
504                 return False
505         
506         def getNimListOfType(self, type, exception = -1):
507                 list = []
508                 for x in self.nimslots:
509                         if ((x.nimType == type) and (x.slotid != exception)):
510                                 list.append(x.slotid)
511                 return list
512
513         def getConfigPrefix(self, slotid):
514                 return "config.Nim" + ("A","B","C","D")[slotid] + "."
515                         
516         def __init__(self):
517                 #use as enum
518                 self.nimType = {                "empty/unknown": -1,
519                                                                                                 "DVB-S": 0,
520                                                                                                 "DVB-C": 1,
521                                                                                                 "DVB-T": 2}
522                 self.satList = [ ]
523                 self.cablesList = []
524                 self.terrestrialsList = []
525                                                                                                 
526                 self.parseProc()
527
528                 self.readSatsfromFile()                                                 
529                 
530                 self.nimCount = self.getNimSocketCount()
531                 
532                 self.nimslots = [ ]
533                 x = 0
534                 while x < self.nimCount:
535                         tType = self.getNimType(x)
536                         tName = self.getNimName(x)
537                         tNim = nimSlot(x, tType, tName)
538                         self.nimslots.append(tNim)
539                         x += 1
540                 
541                 InitNimManager(self)    #init config stuff
542
543         def nimList(self):
544                 list = [ ]
545                 for slot in self.nimslots:
546                         nimText = _("Socket ") + ("A", "B", "C", "D")[slot.slotid] + ": "
547                         if slot.nimType == -1:
548                                 nimText += _("empty/unknown")
549                         else:
550                                 nimText += slot.name + " ("     
551                                 nimText += ("DVB-S", "DVB-C", "DVB-T")[slot.nimType] + ")"
552                         list.append((nimText, slot))
553                 return list
554
555         def getNimConfigMode(self, slotid):
556                 return config.Nims[slotid].configMode.value
557         
558         def getSatList(self):
559                 return self.satList
560
561         def getSatListForNim(self, slotid):
562                 list = []
563                 if (self.getNimType(slotid) == self.nimType["DVB-S"]):
564                         #print "slotid:", slotid
565                         
566                         #print "self.satellites:", self.satList[config.Nims[slotid].diseqcA.value]
567                         #print "diseqcA:", config.Nims[slotid].diseqcA.value
568                         configMode = config.Nims[slotid].configMode.value
569
570                         if configMode == "equal":
571                                 slotid=0 #FIXME add handling for more than two tuners !!!
572                                 configMode = config.Nims[slotid].configMode.value
573
574                         if configMode == "simple":
575                                 dm = config.Nims[slotid].diseqcMode.value
576                                 if dm in ["single", "toneburst", "diseqc_a_b", "diseqc_a_b_c_d"]:
577                                         list.append(self.satList[config.Nims[slotid].diseqcA.index])
578                                 if dm in ["toneburst", "diseqc_a_b", "diseqc_a_b_c_d"]:
579                                         list.append(self.satList[config.Nims[slotid].diseqcB.index])
580                                 if dm == "diseqc_a_b_c_d":
581                                         list.append(self.satList[config.Nims[slotid].diseqcC.index])
582                                         list.append(self.satList[config.Nims[slotid].diseqcD.index])
583                                 if dm == "positioner":
584                                         for x in self.satList:
585                                                 list.append(x)
586                         elif configMode == "advanced":
587                                 for x in self.satList:
588                                         if int(config.Nims[slotid].advanced.sat[x[0]].lnb.value) != 0:
589                                                 list.append(x)
590
591                 return list
592
593         def getRotorSatListForNim(self, slotid):
594                 list = []
595                 if (self.getNimType(slotid) == self.nimType["DVB-S"]):
596                         #print "slotid:", slotid
597
598                         #print "self.satellites:", self.satList[config.Nims[slotid].diseqcA.value]
599                         #print "diseqcA:", config.Nims[slotid].diseqcA.value
600                         configMode = config.Nims[slotid].configMode.value
601                         if configMode == "simple":
602                                 if config.Nims[slotid].diseqcMode.value == "positioner":
603                                         for x in self.satList:
604                                                 list.append(x)
605                         elif configMode == "advanced":
606                                 for x in self.satList:
607                                         nim = config.Nims[slotid]
608                                         lnbnum = int(nim.advanced.sat[x[0]].lnb.value)
609                                         if lnbnum != 0:
610                                                 lnb = nim.advanced.lnb[lnbnum]
611                                                 if lnb.diseqcMode.value == "diseqc_a_b_c_d":
612                                                         list.append(x)
613                 return list
614
615         def nimDiseqcModeChanged(self, slotid, mode):
616                 #print "nimDiseqcModeChanged set to " + str(mode)
617                 pass
618         def nimPortAChanged(self, slotid, val):
619                 #print "nimDiseqcA set to " + str(slotid) + " val:" + str(val)
620                 pass
621         def nimPortBChanged(self, slotid, val):
622                 #print "nimDiseqcA set to " + str(slotid) + " val:" + str(val)
623                 #print "nimDiseqcB set to " + str(val)
624                 pass
625         def nimPortCChanged(self, slotid, val):
626                 #print "nimDiseqcC set to " + str(val)
627                 pass
628         def nimPortDChanged(self, slotid, val):
629                 #print "nimDiseqcD set to " + str(val)
630                 pass
631
632 def InitNimManager(nimmgr):
633         config.Nims = ConfigSubList()
634         for x in range(nimmgr.nimCount):
635                 config.Nims.append(ConfigSubsection())
636                 
637 #       def nimConfigModeChanged(slotid, configElement):
638 #               nimmgr.nimConfigModeChanged(slotid, configElement.value)
639         def nimDiseqcModeChanged(slotid, configElement):
640                 nimmgr.nimDiseqcModeChanged(slotid, configElement.value)
641                 
642         def nimPortAChanged(slotid, configElement):
643                 nimmgr.nimPortAChanged(slotid, configElement.value)
644         def nimPortBChanged(slotid, configElement):
645                 nimmgr.nimPortBChanged(slotid, configElement.value)
646         def nimPortCChanged(slotid, configElement):
647                 nimmgr.nimPortCChanged(slotid, configElement.value)
648         def nimPortDChanged(slotid, configElement):
649                 nimmgr.nimPortDChanged(slotid, configElement.value)
650
651         for slot in nimmgr.nimslots:
652                 x = slot.slotid
653                 cname = nimmgr.getConfigPrefix(x)
654                 nim = config.Nims[x]
655                 
656                 if slot.nimType == nimmgr.nimType["DVB-S"]:
657                         if slot.slotid == 0:
658                                 nim.configMode = ConfigSelection(
659                                         choices = {
660                                                 "simple": _("simple"),
661                                                 "advanced": _("advanced")},
662                                         default = "simple")
663                         else:
664
665                                 nim.configMode = ConfigSelection(
666                                         choices = {
667                                                 "equal": _("equal to Socket A"),
668                                                 "looptrough": _("loopthrough to socket A"),
669                                                 "nothing": _("nothing connected"),
670                                                 "satposdepends": _("second cable of motorized LNB"),
671                                                 "simple": _("simple"),
672                                                 "advanced": _("advanced")},
673                                         default = "looptrough")
674
675                         #important - check if just the 2nd one is LT only and the first one is DVB-S
676                         if nim.configMode.value in ["loopthrough", "satposdepends", "equal"]:
677                                 if x == 0: # first one can never be linked to anything
678                                         # reset to simple
679                                         nim.configMode.value = "simple"
680                                         nim.configMode.save()
681                                 else:
682                                         #FIXME: make it better
683                                         for y in nimmgr.nimslots:
684                                                 if y.slotid == 0:
685                                                         if y.nimType != nimmgr.nimType["DVB-S"]:
686                                                                 # reset to simple
687                                                                 nim.configMode.value = "simple"
688                                                                 nim.configMode.save()
689
690                         nim.diseqcMode = ConfigSelection(
691                                 choices = [
692                                         ("single", _("Single")),
693                                         ("toneburst_a_b", _("Toneburst A/B")),
694                                         ("diseqc_a_b", _("DiSEqC A/B")),
695                                         ("diseqc_a_b_c_d", _("DiSEqC A/B/C/D")),
696                                         ("positioner", _("Positioner"))],
697                                 default = "diseqc_a_b")
698                         nim.diseqcA = ConfigSatlist(default = 192, list = nimmgr.satList)
699                         nim.diseqcB = ConfigSatlist(default = 130, list = nimmgr.satList)
700                         nim.diseqcC = ConfigSatlist(list = nimmgr.satList)
701                         nim.diseqcD = ConfigSatlist(list = nimmgr.satList)
702                         nim.positionerMode = ConfigSelection(
703                                 choices = [
704                                         ("usals", _("USALS")),
705                                         ("manual", _("manual"))],
706                                 default = "usals")
707                         nim.longitude = ConfigFloat(default=[5,100], limits=[(0,359),(0,999)])
708                         nim.longitudeOrientation = ConfigSelection(choices={"east": _("East"), "west": _("West")}, default = "east")
709                         nim.latitude = ConfigFloat(default=[50,767], limits=[(0,359),(0,999)])
710                         nim.latitudeOrientation = ConfigSelection(choices={"north": _("North"), "south": _("South")}, default="north")
711                         satNimList = nimmgr.getNimListOfType(nimmgr.nimType["DVB-S"], slot.slotid)
712                         satNimListNames = {}
713                         for x in satNimList:
714                                 satNimListNames["Slot_" + ("A", "B", "C", "D")[x] + "_" + nimmgr.getNimName(x)] = _("Slot ") + ("A", "B", "C", "D")[x] + ": " + nimmgr.getNimName(x)
715                         if len(satNimListNames):
716                                 nim.equalTo = ConfigSelection(choices = satNimListNames)
717                                 nim.linkedTo = ConfigSelection(choices = satNimListNames)
718                                 nim.satposDependsTo = ConfigSelection(choices = satNimListNames)
719                         
720                         #perhaps the instance of the slot is more useful?
721 #                       nim.configMode.addNotifier(boundFunction(nimConfigModeChanged,x))
722                         nim.diseqcMode.addNotifier(boundFunction(nimDiseqcModeChanged,x))
723                         nim.diseqcA.addNotifier(boundFunction(nimPortAChanged,int(x)))
724                         nim.diseqcB.addNotifier(boundFunction(nimPortBChanged,x))
725                         nim.diseqcC.addNotifier(boundFunction(nimPortCChanged,x))
726                         nim.diseqcD.addNotifier(boundFunction(nimPortDChanged,x))
727                         
728                         # advanced config:
729                         nim.advanced = ConfigSubsection()
730                         nim.advanced.sats = ConfigSatlist(default = 192, list = nimmgr.satList)
731                         nim.advanced.sat = ConfigSubDict()
732                         lnbs = [("0", "not available")]
733                         for y in range(1, 33):
734                                 lnbs.append((str(y), "LNB " + str(y)))
735
736                         for x in nimmgr.satList:
737                                 nim.advanced.sat[x[0]] = ConfigSubsection()
738                                 nim.advanced.sat[x[0]].voltage = ConfigSelection(choices={"polarization": _("Polarization"), "13V": _("13 V"), "18V": _("18 V")}, default = "polarization")
739                                 nim.advanced.sat[x[0]].tonemode = ConfigSelection(choices={"band": _("Band"), "on": _("On"), "off": _("Off")}, default = "band")
740                                 nim.advanced.sat[x[0]].usals = ConfigYesNo(default=True)
741                                 nim.advanced.sat[x[0]].rotorposition = ConfigInteger(default=1, limits=(1, 255))
742                                 nim.advanced.sat[x[0]].lnb = ConfigSelection(choices = lnbs)
743
744                         csw = [("none", _("None")), ("AA", _("AA")), ("AB", _("AB")), ("BA", _("BA")), ("BB", _("BB"))]
745                         for y in range(0, 16):
746                                 csw.append((str(0xF0|y), "Input " + str(y+1)))
747                         
748                         ucsw = [("0", _("None"))]
749                         for y in range(1, 17):
750                                 ucsw.append((str(y), "Input " + str(y)))
751                         
752                         nim.advanced.lnb = ConfigSubList()
753                         nim.advanced.lnb.append(ConfigNothing())
754                         for x in range(1, 33):
755                                 nim.advanced.lnb.append(ConfigSubsection())
756                                 nim.advanced.lnb[x].lof = ConfigSelection(choices={"universal_lnb": _("Universal LNB"), "c_band": _("C-Band"), "user_defined": _("User defined")}, default="universal_lnb")
757                                 nim.advanced.lnb[x].lofl = ConfigInteger(default=9750, limits = (0, 99999))
758                                 nim.advanced.lnb[x].lofh = ConfigInteger(default=10600, limits = (0, 99999))
759                                 nim.advanced.lnb[x].threshold = ConfigInteger(default=11700, limits = (0, 99999))
760                                 nim.advanced.lnb[x].output_12v = ConfigSelection(choices = [("0V", _("0 V")), ("12V", _("12 V"))], default="0V")
761                                 nim.advanced.lnb[x].increased_voltage = ConfigYesNo(default=False)
762                                 nim.advanced.lnb[x].toneburst = ConfigSelection(choices = [("none", _("None")), ("A", _("A")), ("B", _("B"))], default = "none")
763                                 nim.advanced.lnb[x].diseqcMode = ConfigSelection(choices = [("none", _("None")), ("1_0", _("1.0")), ("1_1", _("1.1")), ("1_2", _("1.2"))], default = "none")
764                                 nim.advanced.lnb[x].commitedDiseqcCommand = ConfigSelection(choices = csw)
765                                 nim.advanced.lnb[x].fastDiseqc = ConfigYesNo(default=False)
766                                 nim.advanced.lnb[x].sequenceRepeat = ConfigYesNo(default=False)
767                                 nim.advanced.lnb[x].commandOrder1_0 = ConfigSelection(choices = [("ct", "committed, toneburst"), ("tc", "toneburst, committed")], default = "ct")
768                                 nim.advanced.lnb[x].commandOrder = ConfigSelection(choices = [
769                                                 ("ct", "committed, toneburst"), 
770                                                 ("tc", "toneburst, committed"), 
771                                                 ("cut", "committed, uncommitted, toneburst"), 
772                                                 ("tcu", "toneburst, committed, uncommitted"), 
773                                                 ("uct", "uncommitted, committed, toneburst"), 
774                                                 ("tuc", "toneburst, uncommitted, commmitted")],
775                                                 default="ct")
776                                 nim.advanced.lnb[x].uncommittedDiseqcCommand = ConfigSelection(choices = ucsw)
777                                 nim.advanced.lnb[x].diseqcRepeats = ConfigSelection(choices = [("none", _("None")), ("one", _("One")), ("two", _("Two")), ("three", _("Three"))], default = "none")
778                                 nim.advanced.lnb[x].longitude = ConfigFloat(default = [5,100], limits = [(0,359),(0,999)])
779                                 nim.advanced.lnb[x].longitudeOrientation = ConfigSelection(choices = [("east", _("East")), ("west", _("West"))], default = "east")
780                                 nim.advanced.lnb[x].latitude = ConfigFloat(default = [50,767], limits = [(0,359),(0,999)])
781                                 nim.advanced.lnb[x].latitudeOrientation = ConfigSelection(choices = [("north", _("North")), ("south", _("South"))], default = "north")
782                                 nim.advanced.lnb[x].powerMeasurement = ConfigYesNo(default=True)
783                                 nim.advanced.lnb[x].powerThreshold = ConfigInteger(default=50, limits=(0, 100))
784
785                 elif slot.nimType == nimmgr.nimType["DVB-C"]:
786                         nim.cable = ConfigSelection(choices = nimmgr.cablesList)
787                 elif slot.nimType == nimmgr.nimType["DVB-T"]:
788                         list = []
789                         for x in nimmgr.terrestrialsList:
790                                 list.append(x[0])
791                         nim.terrestrial = ConfigSelection(choices = list)
792                         nim.terrestrial_5V = ConfigOnOff()
793                 else:
794                         print "pls add support for this frontend type!"         
795 #                       assert False
796
797         nimmgr.sec = SecConfigure(nimmgr)
798
799
800 nimmanager = NimManager()