From 2dbd18117bf8519ea700c7f87424eaa2e5a794fa Mon Sep 17 00:00:00 2001 From: ghost Date: Tue, 25 Nov 2008 21:15:42 +0100 Subject: add possibility to always switch to 13V before do sec commands --- lib/dvb/sec.cpp | 17 ++++++++++++----- 1 file changed, 12 insertions(+), 5 deletions(-) (limited to 'lib/dvb/sec.cpp') diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp index 2b7f717b..39124b34 100644 --- a/lib/dvb/sec.cpp +++ b/lib/dvb/sec.cpp @@ -388,6 +388,11 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA iDVBFrontend *sec_fe=&frontend; eDVBRegisteredFrontend *linked_fe = 0; eDVBSatelliteDiseqcParameters::t_diseqc_mode diseqc_mode = di_param.m_diseqc_mode; + eDVBSatelliteSwitchParameters::t_voltage_mode voltage_mode = sw_param.m_voltage_mode; + bool diseqc13V = voltage_mode == eDVBSatelliteSwitchParameters::HV_13; + + if (diseqc13V) + voltage_mode = eDVBSatelliteSwitchParameters::HV; frontend.getData(eDVBFrontend::SATPOS_DEPENDS_PTR, satposDependPtr); @@ -437,13 +442,13 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical)) band |= 2; - if ( sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::_14V + if ( voltage_mode == eDVBSatelliteSwitchParameters::_14V || ( sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical - && sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::HV ) ) + && voltage_mode == eDVBSatelliteSwitchParameters::HV ) ) voltage = VOLTAGE(13); - else if ( sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::_18V + else if ( voltage_mode == eDVBSatelliteSwitchParameters::_18V || ( !(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical) - && sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::HV ) ) + && voltage_mode == eDVBSatelliteSwitchParameters::HV ) ) voltage = VOLTAGE(18); if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::ON) || ( sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::HILO && (band&1) ) ) @@ -597,7 +602,9 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) ); sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_CONT_TONE]) ); - if ( RotorCmd != -1 && RotorCmd != lastRotorCmd ) + if (diseqc13V) + vlt = iDVBFrontend::voltage13; + else if ( RotorCmd != -1 && RotorCmd != lastRotorCmd ) { if (rotor_param.m_inputpower_parameters.m_use) vlt = VOLTAGE(18); // in input power mode set 18V for measure input power -- cgit v1.2.3 From 191d68c0c07505af44f15a62fd59ac4216211e89 Mon Sep 17 00:00:00 2001 From: ghost Date: Wed, 3 Dec 2008 18:03:03 +0100 Subject: dont switch to 18V and measure input current, when slow rotor tuning is selected --- lib/dvb/sec.cpp | 17 +++++++++++------ 1 file changed, 11 insertions(+), 6 deletions(-) (limited to 'lib/dvb/sec.cpp') diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp index 39124b34..a56dbf04 100644 --- a/lib/dvb/sec.cpp +++ b/lib/dvb/sec.cpp @@ -797,17 +797,22 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA bool turn_fast = need_turn_fast(rotor_param.m_inputpower_parameters.m_turning_speed); eSecCommand::rotor cmd; eSecCommand::pair compare; - compare.voltage = VOLTAGE(18); + if (turn_fast) + compare.voltage = VOLTAGE(18); + else + compare.voltage = VOLTAGE(13); compare.steps = +3; sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) ); // measure idle power values - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) ); // wait 150msec after voltage change - sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 1) ); - compare.val = 1; compare.steps = -2; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) ); + if (turn_fast) { + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) ); // wait 150msec after voltage change + sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 1) ); + compare.val = 1; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) ); + } sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) ); // wait 150msec before measure sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 0) ); compare.val = 0; -- cgit v1.2.3 From 2ff2e2c4f2a413b36d3eeafee3439ec5df38c59d Mon Sep 17 00:00:00 2001 From: ghost Date: Wed, 3 Dec 2008 20:01:01 +0100 Subject: hopefully finally fix "second cable of motorized LNB" --- lib/dvb/sec.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'lib/dvb/sec.cpp') diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp index a56dbf04..751a5453 100644 --- a/lib/dvb/sec.cpp +++ b/lib/dvb/sec.cpp @@ -283,7 +283,7 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite eSecDebugNoSimulate("ret5 %d", ret); } - if (ret && rotor && curRotorPos != -1 && (direct_connected || satpos_depends_ptr == -1) ) // direct conntected or loopthrough! + if (ret && rotor && curRotorPos != -1) ret -= abs(curRotorPos-sat.orbital_position); eSecDebugNoSimulate("ret6 %d", ret); -- cgit v1.2.3 From b833353b5285a547eb18c079aa860c9ee2765d6e Mon Sep 17 00:00:00 2001 From: ghost Date: Sat, 13 Dec 2008 01:33:05 +0100 Subject: add possibility to set manual lnb priority (only in advanced sat config) range 0..64 to decrease priorities (this is lower as all auto given priorities) range 14000..14064 this is higher than auto given rotor priorities range 19000..19064 this is higher than each auto given priorities --- lib/dvb/sec.cpp | 28 ++++++++++++++++++++++++---- lib/dvb/sec.h | 5 ++++- lib/python/Components/NimManager.py | 10 ++++++++++ lib/python/Screens/Satconfig.py | 1 + 4 files changed, 39 insertions(+), 5 deletions(-) (limited to 'lib/dvb/sec.cpp') diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp index 751a5453..1022b955 100644 --- a/lib/dvb/sec.cpp +++ b/lib/dvb/sec.cpp @@ -140,7 +140,7 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite { bool rotor=false; eDVBSatelliteLNBParameters &lnb_param = m_lnbs[idx]; - if ( lnb_param.slot_mask & slot_id ) // lnb for correct tuner? + if ( lnb_param.m_slot_mask & slot_id ) // lnb for correct tuner? { int ret = 0; eDVBSatelliteDiseqcParameters &di_param = lnb_param.m_diseqc_parameters; @@ -297,6 +297,9 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite ret=0; } + if (ret && lnb_param.m_prio != -1) + ret = lnb_param.m_prio; + eSecDebugNoSimulate("ret %d, score old %d", ret, score); if (ret > score) { @@ -309,7 +312,12 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite } } if (score && satcount) - score -= (satcount-1); + { + if (score > (satcount-1)) + score -= (satcount-1); + else + score = 1; // min score + } if (score && direct_connected) score += 5; // increase score for tuners with direct sat connection eSecDebugNoSimulate("final score %d", score); @@ -963,7 +971,8 @@ RESULT eDVBSatelliteEquipmentControl::clear() for (int i=0; i <= m_lnbidx; ++i) { m_lnbs[i].m_satellites.clear(); - m_lnbs[i].slot_mask = 0; + m_lnbs[i].m_slot_mask = 0; + m_lnbs[i].m_prio = -1; // auto } m_lnbidx=-1; @@ -1021,7 +1030,7 @@ RESULT eDVBSatelliteEquipmentControl::setLNBSlotMask(int slotmask) { eSecDebug("eDVBSatelliteEquipmentControl::setLNBSlotMask(%d)", slotmask); if ( currentLNBValid() ) - m_lnbs[m_lnbidx].slot_mask = slotmask; + m_lnbs[m_lnbidx].m_slot_mask = slotmask; else return -ENOENT; return 0; @@ -1067,6 +1076,17 @@ RESULT eDVBSatelliteEquipmentControl::setLNBIncreasedVoltage(bool onoff) return 0; } +RESULT eDVBSatelliteEquipmentControl::setLNBPrio(int prio) +{ + eSecDebug("eDVBSatelliteEquipmentControl::setLNBPrio(%d)", prio); + if ( currentLNBValid() ) + m_lnbs[m_lnbidx].m_prio = prio; + else + return -ENOENT; + return 0; +} + + /* DiSEqC Specific Parameters */ RESULT eDVBSatelliteEquipmentControl::setDiSEqCMode(int diseqcmode) { diff --git a/lib/dvb/sec.h b/lib/dvb/sec.h index 27dcedd5..2efd0b49 100644 --- a/lib/dvb/sec.h +++ b/lib/dvb/sec.h @@ -231,7 +231,7 @@ public: #ifndef SWIG t_12V_relais_state m_12V_relais_state; // 12V relais output on/off - __u8 slot_mask; // useable by slot ( 1 | 2 | 4...) + int m_slot_mask; // useable by slot ( 1 | 2 | 4...) unsigned int m_lof_hi, // for 2 band universal lnb 10600 Mhz (high band offset frequency) m_lof_lo, // for 2 band universal lnb 9750 Mhz (low band offset frequency) @@ -242,6 +242,8 @@ public: std::map m_satellites; eDVBSatelliteDiseqcParameters m_diseqc_parameters; eDVBSatelliteRotorParameters m_rotor_parameters; + + int m_prio; // to override automatic tuner management ... -1 is Auto #endif }; @@ -304,6 +306,7 @@ public: RESULT setLNBLOFH(int lofh); RESULT setLNBThreshold(int threshold); RESULT setLNBIncreasedVoltage(bool onoff); + RESULT setLNBPrio(int prio); /* DiSEqC Specific Parameters */ RESULT setDiSEqCMode(int diseqcmode); RESULT setToneburst(int toneburst); diff --git a/lib/python/Components/NimManager.py b/lib/python/Components/NimManager.py index edd3bbbb..168962e9 100644 --- a/lib/python/Components/NimManager.py +++ b/lib/python/Components/NimManager.py @@ -381,6 +381,8 @@ class SecConfigure: sec.setLNBSlotMask(tunermask) + sec.setLNBPrio(int(currLnb.prio.value)) + # finally add the orbital positions for y in lnbSat[x]: self.addSatellite(sec, y) @@ -1026,6 +1028,14 @@ def InitNimManager(nimmgr): nim.advanced.lnb[x].fastTurningBegin = ConfigDateTime(default=mktime(btime.timetuple()), formatstring = _("%H:%M"), increment = 600) etime = datetime(1970, 1, 1, 19, 0); nim.advanced.lnb[x].fastTurningEnd = ConfigDateTime(default=mktime(etime.timetuple()), formatstring = _("%H:%M"), increment = 600) + prio_list = [ ("-1", _("Auto")) ] + for prio in range(65): + prio_list.append((str(prio), str(prio))) + for prio in range(14000,14065): + prio_list.append((str(prio), str(prio))) + for prio in range(19000,19065): + prio_list.append((str(prio), str(prio))) + nim.advanced.lnb[x].prio = ConfigSelection(default="-1", choices=prio_list) elif slot.isCompatible("DVB-C"): nim.configMode = ConfigSelection( choices = { diff --git a/lib/python/Screens/Satconfig.py b/lib/python/Screens/Satconfig.py index 6489f28f..5628926f 100644 --- a/lib/python/Screens/Satconfig.py +++ b/lib/python/Screens/Satconfig.py @@ -283,6 +283,7 @@ class NimSetup(Screen, ConfigListScreen): self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold)) # self.list.append(getConfigListEntry(_("12V Output"), currLnb.output_12v)) self.list.append(getConfigListEntry(_("Increased voltage"), currLnb.increased_voltage)) + self.list.append(getConfigListEntry(_("Priority"), currLnb.prio)) def fillAdvancedList(self): self.list = [ ] -- cgit v1.2.3 From 60237210efc3ca21a67cf4058d0e0ae75a4ac60d Mon Sep 17 00:00:00 2001 From: ghost Date: Fri, 19 Dec 2008 21:26:23 +0100 Subject: initialize lnb config --- lib/dvb/sec.cpp | 72 +-------------------------------------------------------- 1 file changed, 1 insertion(+), 71 deletions(-) (limited to 'lib/dvb/sec.cpp') diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp index 1022b955..8812694b 100644 --- a/lib/dvb/sec.cpp +++ b/lib/dvb/sec.cpp @@ -37,81 +37,11 @@ void eDVBSatelliteEquipmentControl::setParam(int param, int value) } eDVBSatelliteEquipmentControl::eDVBSatelliteEquipmentControl(eSmartPtrList &avail_frontends, eSmartPtrList &avail_simulate_frontends) - :m_lnbidx(-1), m_curSat(m_lnbs[0].m_satellites.end()), m_avail_frontends(avail_frontends), m_avail_simulate_frontends(avail_simulate_frontends), m_rotorMoving(false) + :m_lnbidx(sizeof(m_lnbs) / sizeof(eDVBSatelliteLNBParameters)), m_curSat(m_lnbs[0].m_satellites.end()), m_avail_frontends(avail_frontends), m_avail_simulate_frontends(avail_simulate_frontends), m_rotorMoving(false) { if (!instance) instance = this; - clear(); - -// ASTRA - addLNB(); - setLNBSlotMask(3); - setLNBLOFL(9750000); - setLNBThreshold(11700000); - setLNBLOFH(10607000); - setDiSEqCMode(eDVBSatelliteDiseqcParameters::V1_0); - setToneburst(eDVBSatelliteDiseqcParameters::NO); - setRepeats(0); - setCommittedCommand(eDVBSatelliteDiseqcParameters::BB); - setCommandOrder(0); // committed, toneburst - setFastDiSEqC(true); - setSeqRepeat(false); - addSatellite(192); - setVoltageMode(eDVBSatelliteSwitchParameters::HV); - setToneMode(eDVBSatelliteSwitchParameters::HILO); - -// Hotbird - addLNB(); - setLNBSlotMask(3); - setLNBLOFL(9750000); - setLNBThreshold(11700000); - setLNBLOFH(10600000); - setDiSEqCMode(eDVBSatelliteDiseqcParameters::V1_0); - setToneburst(eDVBSatelliteDiseqcParameters::NO); - setRepeats(0); - setCommittedCommand(eDVBSatelliteDiseqcParameters::AB); - setCommandOrder(0); // committed, toneburst - setFastDiSEqC(true); - setSeqRepeat(false); - addSatellite(130); - setVoltageMode(eDVBSatelliteSwitchParameters::HV); - setToneMode(eDVBSatelliteSwitchParameters::HILO); - -// Rotor - addLNB(); - setLNBSlotMask(3); - setLNBLOFL(9750000); - setLNBThreshold(11700000); - setLNBLOFH(10600000); - setDiSEqCMode(eDVBSatelliteDiseqcParameters::V1_2); - setToneburst(eDVBSatelliteDiseqcParameters::NO); - setRepeats(0); - setCommittedCommand(eDVBSatelliteDiseqcParameters::AA); - setCommandOrder(0); // committed, toneburst - setFastDiSEqC(true); - setSeqRepeat(false); - setLaDirection(eDVBSatelliteRotorParameters::NORTH); - setLoDirection(eDVBSatelliteRotorParameters::EAST); - setLatitude(51.017); - setLongitude(8.683); - setUseInputpower(true); - setInputpowerDelta(50); - - addSatellite(235); - setVoltageMode(eDVBSatelliteSwitchParameters::HV); - setToneMode(eDVBSatelliteSwitchParameters::HILO); - setRotorPosNum(0); - - addSatellite(284); - setVoltageMode(eDVBSatelliteSwitchParameters::HV); - setToneMode(eDVBSatelliteSwitchParameters::HILO); - setRotorPosNum(0); - - addSatellite(420); - setVoltageMode(eDVBSatelliteSwitchParameters::HV); - setToneMode(eDVBSatelliteSwitchParameters::HILO); - setRotorPosNum(1); // stored pos 1 } #define eSecDebugNoSimulate(x...) \ -- cgit v1.2.3 From baa574e9f08994953da1110eb16fe7aad63c280f Mon Sep 17 00:00:00 2001 From: ghost Date: Fri, 19 Dec 2008 21:44:57 +0100 Subject: small fix --- lib/dvb/sec.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'lib/dvb/sec.cpp') diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp index 8812694b..da2439f9 100644 --- a/lib/dvb/sec.cpp +++ b/lib/dvb/sec.cpp @@ -37,7 +37,7 @@ void eDVBSatelliteEquipmentControl::setParam(int param, int value) } eDVBSatelliteEquipmentControl::eDVBSatelliteEquipmentControl(eSmartPtrList &avail_frontends, eSmartPtrList &avail_simulate_frontends) - :m_lnbidx(sizeof(m_lnbs) / sizeof(eDVBSatelliteLNBParameters)), m_curSat(m_lnbs[0].m_satellites.end()), m_avail_frontends(avail_frontends), m_avail_simulate_frontends(avail_simulate_frontends), m_rotorMoving(false) + :m_lnbidx((sizeof(m_lnbs) / sizeof(eDVBSatelliteLNBParameters))-1), m_curSat(m_lnbs[0].m_satellites.end()), m_avail_frontends(avail_frontends), m_avail_simulate_frontends(avail_simulate_frontends), m_rotorMoving(false) { if (!instance) instance = this; -- cgit v1.2.3 From a2f2b1a1523b784e70cf3bd9a74b4cc5cfdbb3de Mon Sep 17 00:00:00 2001 From: ghost Date: Mon, 19 Jan 2009 13:24:54 +0100 Subject: add unicable support (thx to adenin) --- lib/dvb/frontend.cpp | 43 ++++ lib/dvb/frontend.h | 4 + lib/dvb/sec.cpp | 378 +++++++++++++++++++++++------------- lib/dvb/sec.h | 24 +++ lib/python/Components/NimManager.py | 183 ++++++++++++++++- lib/python/Screens/Satconfig.py | 76 ++++++-- 6 files changed, 545 insertions(+), 163 deletions(-) (limited to 'lib/dvb/sec.cpp') diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp index 284844dc..aae7bbc2 100644 --- a/lib/dvb/frontend.cpp +++ b/lib/dvb/frontend.cpp @@ -587,6 +587,10 @@ int eDVBFrontend::closeFrontend(bool force) if (m_fd >= 0) { eDebugNoSimulate("close frontend %d", m_dvbid); + if (m_data[SATCR] != -1) + { + turnOffSatCR(m_data[SATCR]); + } setTone(iDVBFrontend::toneOff); setVoltage(iDVBFrontend::voltageOff); m_tuneTimer->stop(); @@ -2552,3 +2556,42 @@ arg_error: "eDVBFrontend::setSlotInfo must get a tuple with first param slotid, second param slot description and third param enabled boolean"); return false; } + +RESULT eDVBFrontend::turnOffSatCR(int satcr) +{ + eSecCommandList sec_sequence; + // check if voltage is disabled + eSecCommand::pair compare; + compare.steps = +9; //nothing to do + compare.voltage = iDVBFrontend::voltageOff; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_NOT_VOLTAGE_GOTO, compare) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage13) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50 ) ); + + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage18_5) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 250) ); + + eDVBDiseqcCommand diseqc; + memset(diseqc.data, 0, MAX_DISEQC_LENGTH); + diseqc.len = 5; + diseqc.data[0] = 0xE0; + diseqc.data[1] = 0x10; + diseqc.data[2] = 0x5A; + diseqc.data[3] = satcr << 5; + diseqc.data[4] = 0x00; + + sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50+20+14*diseqc.len) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage13) ); + setSecSequence(sec_sequence); + return 0; +} + +RESULT eDVBFrontend::ScanSatCR() +{ + setFrontend(); + usleep(20000); + setTone(iDVBFrontend::toneOff); + return 0; +} diff --git a/lib/dvb/frontend.h b/lib/dvb/frontend.h index 6e272aca..81334886 100644 --- a/lib/dvb/frontend.h +++ b/lib/dvb/frontend.h @@ -63,6 +63,7 @@ public: FREQ_OFFSET, // current frequency offset CUR_VOLTAGE, // current voltage CUR_TONE, // current continuous tone + SATCR, // current SatCR NUM_DATA_ENTRIES }; Signal1 m_stateChanged; @@ -142,6 +143,9 @@ public: int closeFrontend(bool force=false); const char *getDescription() const { return m_description; } bool is_simulate() const { return m_simulate; } + + RESULT turnOffSatCR(int satcr); + RESULT ScanSatCR(); }; #endif // SWIG diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp index da2439f9..6f64cf56 100644 --- a/lib/dvb/sec.cpp +++ b/lib/dvb/sec.cpp @@ -305,10 +305,16 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA lnb_param.m_satellites.find(sat.orbital_position); if ( sit != lnb_param.m_satellites.end()) { + eSecCommandList sec_sequence; + + lnb_param.guard_offset = 0; //HACK + + frontend.setData(eDVBFrontend::SATCR, lnb_param.SatCR_idx); + eDVBSatelliteSwitchParameters &sw_param = sit->second; bool doSetFrontend = true; bool doSetVoltageToneFrontend = true; - bool sendDiSEqC = false; + bool forceStaticMode = true; bool forceChanged = false; bool needDiSEqCReset = false; long band=0, @@ -367,35 +373,54 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA if ( sat.frequency > lnb_param.m_lof_threshold ) band |= 1; - - if (band&1) - parm.FREQUENCY = sat.frequency - lnb_param.m_lof_hi; - else - parm.FREQUENCY = sat.frequency - lnb_param.m_lof_lo; - - parm.FREQUENCY = abs(parm.FREQUENCY); - - frontend.setData(eDVBFrontend::FREQ_OFFSET, sat.frequency - parm.FREQUENCY); - if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical)) band |= 2; - if ( voltage_mode == eDVBSatelliteSwitchParameters::_14V - || ( sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical - && voltage_mode == eDVBSatelliteSwitchParameters::HV ) ) - voltage = VOLTAGE(13); - else if ( voltage_mode == eDVBSatelliteSwitchParameters::_18V - || ( !(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical) - && voltage_mode == eDVBSatelliteSwitchParameters::HV ) ) - voltage = VOLTAGE(18); - if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::ON) - || ( sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::HILO && (band&1) ) ) - tone = iDVBFrontend::toneOn; - else if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::OFF) - || ( sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::HILO && !(band&1) ) ) - tone = iDVBFrontend::toneOff; + int lof = (band&1)?lnb_param.m_lof_hi:lnb_param.m_lof_lo; + + int local=0; - eSecCommandList sec_sequence; + + if(lnb_param.SatCR_idx == -1) + { + // calc Frequency + local = abs(sat.frequency + - ((lof - (lof % 1000)) + ((lof % 1000)>500 ? 1000 : 0)) ); //TODO für den Mist mal ein Macro schreiben + parm.FREQUENCY = (local - (local % 125)) + ((local % 125)>62 ? 125 : 0); + frontend.setData(eDVBFrontend::FREQ_OFFSET, sat.frequency - parm.FREQUENCY); + + if ( voltage_mode == eDVBSatelliteSwitchParameters::_14V + || ( sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical + && voltage_mode == eDVBSatelliteSwitchParameters::HV ) ) + voltage = VOLTAGE(13); + else if ( voltage_mode == eDVBSatelliteSwitchParameters::_18V + || ( !(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical) + && voltage_mode == eDVBSatelliteSwitchParameters::HV ) ) + voltage = VOLTAGE(18); + if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::ON) + || ( sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::HILO && (band&1) ) ) + tone = iDVBFrontend::toneOn; + else if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::OFF) + || ( sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::HILO && !(band&1) ) ) + tone = iDVBFrontend::toneOff; + } + else + { + unsigned int tmp = abs(sat.frequency + - ((lof - (lof % 1000)) + ((lof % 1000)>500 ? 1000 : 0)) ) + + lnb_param.SatCRvco + - 1400000 + + lnb_param.guard_offset; + parm.FREQUENCY = (lnb_param.SatCRvco - (tmp % 4000))+((tmp%4000)>2000?4000:0)+lnb_param.guard_offset; + lnb_param.UnicableTuningWord = (((tmp / 4000)+((tmp%4000)>2000?1:0)) + | ((band & 1) ? 0x400 : 0) //HighLow + | ((band & 2) ? 0x800 : 0) //VertHor + | ((lnb_param.LNBNum & 1) ? 0 : 0x1000) //Umschaltung LNB1 LNB2 + | (lnb_param.SatCR_idx << 13)); //Adresse des SatCR + eDebug("[prepare] UnicableTuningWord %#04x",lnb_param.UnicableTuningWord); + eDebug("[prepare] guard_offset %d",lnb_param.guard_offset); + frontend.setData(eDVBFrontend::FREQ_OFFSET, sat.frequency - ((lnb_param.UnicableTuningWord & 0x3FF) *4000 + 1400000 - lnb_param.SatCRvco + lof)); + } if (diseqc_mode >= eDVBSatelliteDiseqcParameters::V1_0) { @@ -668,14 +693,13 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA if (di_param.m_seq_repeat && seq_repeat == 0) sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_BEFORE_SEQUENCE_REPEAT]) ); } - sendDiSEqC = true; } eDebugNoSimulate("RotorCmd %02x, lastRotorCmd %02lx", RotorCmd, lastRotorCmd); if ( RotorCmd != -1 && RotorCmd != lastRotorCmd ) { eSecCommand::pair compare; - if (!send_mask) + if (!send_mask && lnb_param.SatCR_idx == -1) { compare.steps = +3; compare.tone = iDVBFrontend::toneOff; @@ -729,112 +753,113 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA diseqc.data[3] = RotorCmd; diseqc.data[4] = 0x00; } - - if ( rotor_param.m_inputpower_parameters.m_use ) - { // use measure rotor input power to detect rotor state - bool turn_fast = need_turn_fast(rotor_param.m_inputpower_parameters.m_turning_speed); - eSecCommand::rotor cmd; - eSecCommand::pair compare; - if (turn_fast) - compare.voltage = VOLTAGE(18); + if(lnb_param.SatCR_idx == -1) + { + if ( rotor_param.m_inputpower_parameters.m_use ) + { // use measure rotor input power to detect rotor state + bool turn_fast = need_turn_fast(rotor_param.m_inputpower_parameters.m_turning_speed); + eSecCommand::rotor cmd; + eSecCommand::pair compare; + if (turn_fast) + compare.voltage = VOLTAGE(18); + else + compare.voltage = VOLTAGE(13); + compare.steps = +3; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) ); + // measure idle power values + compare.steps = -2; + if (turn_fast) { + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) ); // wait 150msec after voltage change + sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 1) ); + compare.val = 1; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) ); + } + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) ); // wait 150msec before measure + sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 0) ); + compare.val = 0; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) ); + //////////////////////////// + sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_DISEQC_RETRYS, m_params[MOTOR_COMMAND_RETRIES]) ); // 2 retries + sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_ROTORPARMS) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, 40) ); // 2 seconds rotor start timout + // rotor start loop + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) ); // 50msec delay + sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_RUNNING_INPUTPOWER) ); + cmd.direction=1; // check for running rotor + cmd.deltaA=rotor_param.m_inputpower_parameters.m_delta; + cmd.steps=+5; + cmd.okcount=0; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_INPUTPOWER_DELTA_GOTO, cmd ) ); // check if rotor has started + sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +2 ) ); // timeout .. we assume now the rotor is already at the correct position + sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) ); // goto loop start + sec_sequence.push_back( eSecCommand(eSecCommand::IF_NO_MORE_ROTOR_DISEQC_RETRYS_GOTO, turn_fast ? 10 : 9 ) ); // timeout .. we assume now the rotor is already at the correct position + sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -8) ); // goto loop start + //////////////////// + sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_MOVING) ); + if (turn_fast) + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, m_params[MOTOR_RUNNING_TIMEOUT]*20) ); // 2 minutes running timeout + // rotor running loop + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) ); // wait 50msec + sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_RUNNING_INPUTPOWER) ); + cmd.direction=0; // check for stopped rotor + cmd.steps=+3; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_INPUTPOWER_DELTA_GOTO, cmd ) ); + sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +2 ) ); // timeout ? this should never happen + sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) ); // running loop start + ///////////////////// + sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_STOPPED) ); + } else + { // use normal turning mode + doSetVoltageToneFrontend=false; + doSetFrontend=false; + eSecCommand::rotor cmd; + eSecCommand::pair compare; compare.voltage = VOLTAGE(13); - compare.steps = +3; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) ); -// measure idle power values - compare.steps = -2; - if (turn_fast) { - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) ); // wait 150msec after voltage change - sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 1) ); - compare.val = 1; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) ); + compare.steps = +3; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MOTOR_CMD]) ); // wait 150msec after voltage change + + sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_ROTORPARMS) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_MOVING) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) ); + + compare.voltage = voltage; + compare.steps = +3; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // correct final voltage? + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 2000) ); // wait 2 second before set high voltage + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) ); + + compare.tone = tone; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_TONE_GOTO, compare) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, tone) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_CONT_TONE]) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) ); + + cmd.direction=1; // check for running rotor + cmd.deltaA=0; + cmd.steps=+3; + cmd.okcount=0; + sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, m_params[MOTOR_RUNNING_TIMEOUT]*4) ); // 2 minutes running timeout + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 250) ); // 250msec delay + sec_sequence.push_back( eSecCommand(eSecCommand::IF_TUNER_LOCKED_GOTO, cmd ) ); + sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +3 ) ); + sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -3) ); // goto loop start + sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_STOPPED) ); + sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, +3) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) ); + sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) ); } - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) ); // wait 150msec before measure - sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 0) ); - compare.val = 0; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) ); -//////////////////////////// - sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_DISEQC_RETRYS, m_params[MOTOR_COMMAND_RETRIES]) ); // 2 retries - sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_ROTORPARMS) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, 40) ); // 2 seconds rotor start timout -// rotor start loop - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) ); // 50msec delay - sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_RUNNING_INPUTPOWER) ); - cmd.direction=1; // check for running rotor - cmd.deltaA=rotor_param.m_inputpower_parameters.m_delta; - cmd.steps=+5; - cmd.okcount=0; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_INPUTPOWER_DELTA_GOTO, cmd ) ); // check if rotor has started - sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +2 ) ); // timeout .. we assume now the rotor is already at the correct position - sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) ); // goto loop start - sec_sequence.push_back( eSecCommand(eSecCommand::IF_NO_MORE_ROTOR_DISEQC_RETRYS_GOTO, turn_fast ? 10 : 9 ) ); // timeout .. we assume now the rotor is already at the correct position - sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -8) ); // goto loop start -//////////////////// - sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_MOVING) ); - if (turn_fast) - sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, m_params[MOTOR_RUNNING_TIMEOUT]*20) ); // 2 minutes running timeout -// rotor running loop - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) ); // wait 50msec - sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_RUNNING_INPUTPOWER) ); - cmd.direction=0; // check for stopped rotor - cmd.steps=+3; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_INPUTPOWER_DELTA_GOTO, cmd ) ); - sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +2 ) ); // timeout ? this should never happen - sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) ); // running loop start -///////////////////// - sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_STOPPED) ); - } - else - { // use normal turning mode - doSetVoltageToneFrontend=false; - doSetFrontend=false; - eSecCommand::rotor cmd; - eSecCommand::pair compare; - compare.voltage = VOLTAGE(13); - compare.steps = +3; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MOTOR_CMD]) ); // wait 150msec after voltage change - - sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_ROTORPARMS) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_MOVING) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) ); - - compare.voltage = voltage; - compare.steps = +3; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // correct final voltage? - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 2000) ); // wait 2 second before set high voltage - sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) ); - - compare.tone = tone; - sec_sequence.push_back( eSecCommand(eSecCommand::IF_TONE_GOTO, compare) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, tone) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_CONT_TONE]) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) ); - - cmd.direction=1; // check for running rotor - cmd.deltaA=0; - cmd.steps=+3; - cmd.okcount=0; - sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, m_params[MOTOR_RUNNING_TIMEOUT]*4) ); // 2 minutes running timeout - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 250) ); // 250msec delay - sec_sequence.push_back( eSecCommand(eSecCommand::IF_TUNER_LOCKED_GOTO, cmd ) ); - sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +3 ) ); - sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -3) ); // goto loop start - sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_STOPPED) ); - sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, +3) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) ); - sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) ); } sec_fe->setData(eDVBFrontend::NEW_ROTOR_CMD, RotorCmd); sec_fe->setData(eDVBFrontend::NEW_ROTOR_POS, sat.orbital_position); - sendDiSEqC = true; } } } @@ -844,14 +869,11 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA csw = band; } -// if (sendDiSEqC) - sec_sequence.push_front( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeStatic) ); - sec_fe->setData(eDVBFrontend::NEW_CSW, csw); sec_fe->setData(eDVBFrontend::NEW_UCSW, ucsw); sec_fe->setData(eDVBFrontend::NEW_TONEBURST, di_param.m_toneburst_param); - if (doSetVoltageToneFrontend) + if ((doSetVoltageToneFrontend) && (lnb_param.SatCR_idx == -1)) { eSecCommand::pair compare; compare.voltage = voltage; @@ -867,16 +889,45 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_SWITCHPARMS) ); + if(lnb_param.SatCR_idx != -1) + { + // check if voltage is disabled + eSecCommand::pair compare; + compare.steps = +3; + compare.voltage = iDVBFrontend::voltageOff; + sec_sequence.push_back( eSecCommand(eSecCommand::IF_NOT_VOLTAGE_GOTO, compare) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage13) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50 ) ); + + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage18_5) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MOTOR_CMD]) ); // wait 150msec after voltage change + + eDVBDiseqcCommand diseqc; + memset(diseqc.data, 0, MAX_DISEQC_LENGTH); + diseqc.len = 5; + diseqc.data[0] = 0xE0; + diseqc.data[1] = 0x10; + diseqc.data[2] = 0x5A; + diseqc.data[3] = lnb_param.UnicableTuningWord >> 8; + diseqc.data[4] = lnb_param.UnicableTuningWord; + + sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_LAST_DISEQC_CMD]) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage13) ); + } + if (doSetFrontend) { sec_sequence.push_back( eSecCommand(eSecCommand::START_TUNE_TIMEOUT, tunetimeout) ); sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) ); } - -// if (sendDiSEqC) - sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) ); - sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeDynamic) ); - + + if (forceStaticMode) + { + sec_sequence.push_front( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeStatic) ); + sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeDynamic) ); + } frontend.setSecSequence(sec_sequence); return 0; @@ -928,6 +979,7 @@ RESULT eDVBSatelliteEquipmentControl::clear() it->m_frontend->setData(eDVBFrontend::LINKED_NEXT_PTR, -1); it->m_frontend->setData(eDVBFrontend::ROTOR_POS, -1); it->m_frontend->setData(eDVBFrontend::ROTOR_CMD, -1); + it->m_frontend->setData(eDVBFrontend::SATCR, -1); } for (eSmartPtrList::iterator it(m_avail_simulate_frontends.begin()); it != m_avail_simulate_frontends.end(); ++it) @@ -937,6 +989,7 @@ RESULT eDVBSatelliteEquipmentControl::clear() it->m_frontend->setData(eDVBFrontend::LINKED_NEXT_PTR, -1); it->m_frontend->setData(eDVBFrontend::ROTOR_POS, -1); it->m_frontend->setData(eDVBFrontend::ROTOR_CMD, -1); + it->m_frontend->setData(eDVBFrontend::SATCR, -1); } return 0; @@ -1016,6 +1069,17 @@ RESULT eDVBSatelliteEquipmentControl::setLNBPrio(int prio) return 0; } +RESULT eDVBSatelliteEquipmentControl::setLNBNum(int LNBNum) +{ + eSecDebug("eDVBSatelliteEquipmentControl::setLNBNum(%d)", LNBNum); + if(!((LNBNum >= 1) && (LNBNum <= MAX_LNBNUM))) + return -EPERM; + if ( currentLNBValid() ) + m_lnbs[m_lnbidx].LNBNum = LNBNum; + else + return -ENOENT; + return 0; +} /* DiSEqC Specific Parameters */ RESULT eDVBSatelliteEquipmentControl::setDiSEqCMode(int diseqcmode) @@ -1159,6 +1223,46 @@ RESULT eDVBSatelliteEquipmentControl::setInputpowerDelta(int delta) return 0; } +/* Unicable Specific Parameters */ +RESULT eDVBSatelliteEquipmentControl::setLNBSatCR(int SatCR_idx) +{ + eSecDebug("eDVBSatelliteEquipmentControl::setLNBSatCR(%d)", SatCR_idx); + if(!((SatCR_idx >=-1) && (SatCR_idx < MAX_SATCR))) + return -EPERM; + if ( currentLNBValid() ) + m_lnbs[m_lnbidx].SatCR_idx = SatCR_idx; + else + return -ENOENT; + return 0; +} + +RESULT eDVBSatelliteEquipmentControl::setLNBSatCRvco(int SatCRvco) +{ + eSecDebug("eDVBSatelliteEquipmentControl::setLNBSatCRvco(%d)", SatCRvco); + if(!((SatCRvco >= 950*1000) && (SatCRvco <= 2150*1000))) + return -EPERM; + if(!((m_lnbs[m_lnbidx].SatCR_idx >= 0) && (m_lnbs[m_lnbidx].SatCR_idx < MAX_SATCR))) + return -ENOENT; + if ( currentLNBValid() ) + m_lnbs[m_lnbidx].SatCRvco = SatCRvco; + else + return -ENOENT; + return 0; +} +RESULT eDVBSatelliteEquipmentControl::getLNBSatCR() +{ + if ( currentLNBValid() ) + return m_lnbs[m_lnbidx].SatCR_idx; + return -ENOENT; +} + +RESULT eDVBSatelliteEquipmentControl::getLNBSatCRvco() +{ + if ( currentLNBValid() ) + return m_lnbs[m_lnbidx].SatCRvco; + return -ENOENT; +} + /* Satellite Specific Parameters */ RESULT eDVBSatelliteEquipmentControl::addSatellite(int orbital_position) { diff --git a/lib/dvb/sec.h b/lib/dvb/sec.h index 2efd0b49..5bff6bf7 100644 --- a/lib/dvb/sec.h +++ b/lib/dvb/sec.h @@ -245,6 +245,23 @@ public: int m_prio; // to override automatic tuner management ... -1 is Auto #endif +public: +#define guard_offset_min -8000 +#define guard_offset_max 8000 +#define guard_offset_step 8000 +#define MAX_SATCR 8 +#define MAX_LNBNUM 32 + + int SatCR_idx; + unsigned int SatCRvco; + unsigned int UnicableTuningWord; + unsigned int UnicableConfigWord; + int old_frequency; + int old_polarisation; + int old_orbital_position; + int guard_offset_old; + int guard_offset; + int LNBNum; }; class eDVBRegisteredFrontend; @@ -307,6 +324,7 @@ public: RESULT setLNBThreshold(int threshold); RESULT setLNBIncreasedVoltage(bool onoff); RESULT setLNBPrio(int prio); + RESULT setLNBNum(int LNBNum); /* DiSEqC Specific Parameters */ RESULT setDiSEqCMode(int diseqcmode); RESULT setToneburst(int toneburst); @@ -324,6 +342,12 @@ public: RESULT setUseInputpower(bool onoff); RESULT setInputpowerDelta(int delta); // delta between running and stopped rotor RESULT setRotorTurningSpeed(int speed); // set turning speed.. +/* Unicable Specific Parameters */ + RESULT setLNBSatCR(int SatCR_idx); + RESULT setLNBSatCRvco(int SatCRvco); +// RESULT checkGuardOffset(const eDVBFrontendParametersSatellite &sat); + RESULT getLNBSatCR(); + RESULT getLNBSatCRvco(); /* Satellite Specific Parameters */ RESULT addSatellite(int orbital_position); RESULT setVoltageMode(int mode); diff --git a/lib/python/Components/NimManager.py b/lib/python/Components/NimManager.py index 168962e9..1fcbda1a 100644 --- a/lib/python/Components/NimManager.py +++ b/lib/python/Components/NimManager.py @@ -51,6 +51,8 @@ class SecConfigure: elif self.linked.has_key(slotid): for slot in self.linked[slotid]: tunermask |= (1 << slot) + sec.setLNBSatCR(-1) + sec.setLNBNum(1) sec.setLNBLOFL(9750000) sec.setLNBLOFH(10600000) sec.setLNBThreshold(11700000) @@ -255,6 +257,9 @@ class SecConfigure: currLnb = config.Nims[slotid].advanced.lnb[x] sec.addLNB() + if x < 33: + sec.setLNBNum(x) + tunermask = 1 << slotid if self.equal.has_key(slotid): for slot in self.equal[slotid]: @@ -263,10 +268,32 @@ class SecConfigure: for slot in self.linked[slotid]: tunermask |= (1 << slot) + if currLnb.lof.value != "unicable": + sec.setLNBSatCR(-1) + if currLnb.lof.value == "universal_lnb": sec.setLNBLOFL(9750000) sec.setLNBLOFH(10600000) sec.setLNBThreshold(11700000) + elif currLnb.lof.value == "unicable": + sec.setLNBLOFL(9750000) + sec.setLNBLOFH(10600000) + sec.setLNBThreshold(11700000) + if currLnb.unicable.value == "unicable_user": + sec.setLNBSatCR(currLnb.satcruser.index) + sec.setLNBSatCRvco(currLnb.satcrvcouser[currLnb.satcruser.index].value*1000) + elif currLnb.unicable.value == "unicable_matrix": + manufacturer_name = currLnb.unicableMatrixManufacturer.value + manufacturer = currLnb.unicableMatrix[manufacturer_name] + product_name = manufacturer.product.value + sec.setLNBSatCR(manufacturer.scr[product_name].index) + sec.setLNBSatCRvco(manufacturer.vco[product_name][manufacturer.scr[product_name].index].value*1000) + elif currLnb.unicable.value == "unicable_lnb": + manufacturer_name = currLnb.unicableMatrixManufacturer.value + manufacturer = currLnb.unicableMatrix[manufacturer_name] + product_name = manufacturer.product.value + sec.setLNBSatCR(manufacturer.scr[product_name].index) + sec.setLNBSatCRvco(manufacturer.vco[product_name][manufacturer.scr[product_name].index].value*1000) elif currLnb.lof.value == "c_band": sec.setLNBLOFL(5150000) sec.setLNBLOFH(5150000) @@ -892,6 +919,129 @@ def InitNimManager(nimmgr): for x in range(len(nimmgr.nim_slots)): config.Nims.append(ConfigSubsection()) + lnb_choices = { + "universal_lnb": _("Universal LNB"), + "unicable": _("Unicable"), + "c_band": _("C-Band"), + "user_defined": _("User defined")} + lnb_choices_default = "universal_lnb" + + unicablelnbproducts = { + "Humax": {"150 SCR":["1210","1420","1680","2040"]}, + "Inverto": {"IDLP-40UNIQD+S":["1680","1420","2040","1210"]}, + "Kathrein": {"UAS481":["1400","1516","1632","1748"]}, + "Kreiling": {"KR1440":["1680","1420","2040","1210"]}, + "Radix": {"Unicable LNB":["1680","1420","2040","1210"]}, + "Wisi": {"OC 05":["1210","1420","1680","2040"]}} + UnicableLnbManufacturers = unicablelnbproducts.keys() + UnicableLnbManufacturers.sort() + + unicablematrixproducts = { + "Ankaro": { + "UCS 51440":["1400","1632","1284","1516"], + "UCS 51820":["1400","1632","1284","1516","1864","2096","1748","1980"], + "UCS 51840":["1400","1632","1284","1516","1864","2096","1748","1980"], + "UCS 52240":["1400","1632"], + "UCS 52420":["1400","1632","1284","1516"], + "UCS 52440":["1400","1632","1284","1516"], + "UCS 91440":["1400","1632","1284","1516"], + "UCS 91820":["1400","1632","1284","1516","1864","2096","1748","1980"], + "UCS 91840":["1400","1632","1284","1516","1864","2096","1748","1980"], + "UCS 92240":["1400","1632"], + "UCS 92420":["1400","1632","1284","1516"], + "UCS 92440":["1400","1632","1284","1516"]}, + "DCT Delta": { + "SUM518":["1284","1400","1516","1632","1748","1864","1980","2096"], + "SUM918":["1284","1400","1516","1632","1748","1864","1980","2096"], + "SUM928":["1284","1400","1516","1632","1748","1864","1980","2096"]}, + "Inverto": { + "IDLP-UST11O-CUO1O-8PP":["1076","1178","1280","1382","1484","1586","1688","1790"]}, + "Kathrein": { + "EXR501":["1400","1516","1632","1748"], + "EXR551":["1400","1516","1632","1748"], + "EXR552":["1400","1516"]}, + "ROTEK": { + "EKL2/1":["1400","1516"], + "EKL2/1E":["0","0","1632","1748"]}, + "Smart": { + "DPA 51":["1284","1400","1516","1632","1748","1864","1980","2096"]}, + "Technisat": { + "TechniRouter 5/1x8 G":["1284","1400","1516","1632","1748","1864","1980","2096"], + "TechniRouter 5/1x8 K":["1284","1400","1516","1632","1748","1864","1980","2096"], + "TechniRouter 5/2x4 G":["1284","1400","1516","1632"], + "TechniRouter 5/2x4 K":["1284","1400","1516","1632"]}, + "Telstar": { + "SCR 5/1x8 G":["1284","1400","1516","1632","1748","1864","1980","2096"], + "SCR 5/1x8 K":["1284","1400","1516","1632","1748","1864","1980","2096"], + "SCR 5/2x4 G":["1284","1400","1516","1632"], + "SCR 5/2x4 K":["1284","1400","1516","1632"]}} + UnicableMatrixManufacturers = unicablematrixproducts.keys() + UnicableMatrixManufacturers.sort() + + unicable_choices = { + "unicable_lnb": _("Unicable LNB"), + "unicable_matrix": _("Unicable Martix"), + "unicable_user": "Unicable "+_("User defined")} + unicable_choices_default = "unicable_lnb" + + unicableLnb = ConfigSubDict() + for y in unicablelnbproducts: + products = unicablelnbproducts[y].keys() + products.sort() + unicableLnb[y] = ConfigSubsection() + unicableLnb[y].product = ConfigSelection(choices = products, default = products[0]) + unicableLnb[y].scr = ConfigSubDict() + unicableLnb[y].vco = ConfigSubDict() + for z in products: + scrlist = [] + vcolist = unicablelnbproducts[y][z] + unicableLnb[y].vco[z] = ConfigSubList() + for cnt in range(1,1+len(vcolist)): + scrlist.append(("%d" %cnt,"SCR %d" %cnt)) + vcofreq = int(vcolist[cnt-1]) + unicableLnb[y].vco[z].append(ConfigInteger(default=vcofreq, limits = (vcofreq, vcofreq))) + unicableLnb[y].scr[z] = ConfigSelection(choices = scrlist, default = scrlist[0][0]) + + unicableMatrix = ConfigSubDict() + + for y in unicablematrixproducts: + products = unicablematrixproducts[y].keys() + products.sort() + unicableMatrix[y] = ConfigSubsection() + unicableMatrix[y].product = ConfigSelection(choices = products, default = products[0]) + unicableMatrix[y].scr = ConfigSubDict() + unicableMatrix[y].vco = ConfigSubDict() + for z in products: + scrlist = [] + vcolist = unicablematrixproducts[y][z] + unicableMatrix[y].vco[z] = ConfigSubList() + for cnt in range(1,1+len(vcolist)): + vcofreq = int(vcolist[cnt-1]) + if vcofreq == 0: + scrlist.append(("%d" %cnt,"SCR %d " %cnt +_("not used"))) + else: + scrlist.append(("%d" %cnt,"SCR %d" %cnt)) + unicableMatrix[y].vco[z].append(ConfigInteger(default=vcofreq, limits = (vcofreq, vcofreq))) + unicableMatrix[y].scr[z] = ConfigSelection(choices = scrlist, default = scrlist[0][0]) + + satcrvcouser = ConfigSubList() + satcrvcouser.append(ConfigInteger(default=1284, limits = (0, 9999))) + satcrvcouser.append(ConfigInteger(default=1400, limits = (0, 9999))) + satcrvcouser.append(ConfigInteger(default=1516, limits = (0, 9999))) + satcrvcouser.append(ConfigInteger(default=1632, limits = (0, 9999))) + satcrvcouser.append(ConfigInteger(default=1748, limits = (0, 9999))) + satcrvcouser.append(ConfigInteger(default=1864, limits = (0, 9999))) + satcrvcouser.append(ConfigInteger(default=1980, limits = (0, 9999))) + satcrvcouser.append(ConfigInteger(default=2096, limits = (0, 9999))) + + prio_list = [ ("-1", _("Auto")) ] + for prio in range(65): + prio_list.append((str(prio), str(prio))) + for prio in range(14000,14065): + prio_list.append((str(prio), str(prio))) + for prio in range(19000,19065): + prio_list.append((str(prio), str(prio))) + for slot in nimmgr.nim_slots: x = slot.slot nim = config.Nims[x] @@ -990,12 +1140,36 @@ def InitNimManager(nimmgr): nim.advanced.lnb = ConfigSubList() nim.advanced.lnb.append(ConfigNothing()) + + for x in range(1, 37): nim.advanced.lnb.append(ConfigSubsection()) - nim.advanced.lnb[x].lof = ConfigSelection(choices={"universal_lnb": _("Universal LNB"), "c_band": _("C-Band"), "user_defined": _("User defined")}, default="universal_lnb") + nim.advanced.lnb[x].lof = ConfigSelection(choices = lnb_choices, default = lnb_choices_default) + nim.advanced.lnb[x].lofl = ConfigInteger(default=9750, limits = (0, 99999)) nim.advanced.lnb[x].lofh = ConfigInteger(default=10600, limits = (0, 99999)) nim.advanced.lnb[x].threshold = ConfigInteger(default=11700, limits = (0, 99999)) + + nim.advanced.lnb[x].unicable = ConfigSelection(choices = unicable_choices, default = unicable_choices_default) + + nim.advanced.lnb[x].unicableLnb = unicableLnb + nim.advanced.lnb[x].unicableLnbManufacturer = ConfigSelection(choices = UnicableLnbManufacturers, default = UnicableLnbManufacturers[0]) + + nim.advanced.lnb[x].unicableMatrix = unicableMatrix + nim.advanced.lnb[x].unicableMatrixManufacturer = ConfigSelection(choices = UnicableMatrixManufacturers, default = UnicableMatrixManufacturers[0]) + + nim.advanced.lnb[x].satcruser = ConfigSelection(choices=[ + ("1", "SatCR 1"), + ("2", "SatCR 2"), + ("3", "SatCR 3"), + ("4", "SatCR 4"), + ("5", "SatCR 5"), + ("6", "SatCR 6"), + ("7", "SatCR 7"), + ("8", "SatCR 8")], + default="1") + nim.advanced.lnb[x].satcrvcouser = satcrvcouser + # nim.advanced.lnb[x].output_12v = ConfigSelection(choices = [("0V", _("0 V")), ("12V", _("12 V"))], default="0V") nim.advanced.lnb[x].increased_voltage = ConfigYesNo(default=False) nim.advanced.lnb[x].toneburst = ConfigSelection(choices = [("none", _("None")), ("A", _("A")), ("B", _("B"))], default = "none") @@ -1028,13 +1202,6 @@ def InitNimManager(nimmgr): nim.advanced.lnb[x].fastTurningBegin = ConfigDateTime(default=mktime(btime.timetuple()), formatstring = _("%H:%M"), increment = 600) etime = datetime(1970, 1, 1, 19, 0); nim.advanced.lnb[x].fastTurningEnd = ConfigDateTime(default=mktime(etime.timetuple()), formatstring = _("%H:%M"), increment = 600) - prio_list = [ ("-1", _("Auto")) ] - for prio in range(65): - prio_list.append((str(prio), str(prio))) - for prio in range(14000,14065): - prio_list.append((str(prio), str(prio))) - for prio in range(19000,19065): - prio_list.append((str(prio), str(prio))) nim.advanced.lnb[x].prio = ConfigSelection(default="-1", choices=prio_list) elif slot.isCompatible("DVB-C"): nim.configMode = ConfigSelection( diff --git a/lib/python/Screens/Satconfig.py b/lib/python/Screens/Satconfig.py index 320bea84..da6fcc12 100644 --- a/lib/python/Screens/Satconfig.py +++ b/lib/python/Screens/Satconfig.py @@ -87,6 +87,10 @@ class NimSetup(Screen, ConfigListScreen): self.uncommittedDiseqcCommand = None self.cableScanType = None self.have_advanced = False + self.advancedUnicable = None + self.advancedType = None + self.advancedManufacturer = None + self.advancedSCR = None if self.nim.isCompatible("DVB-S"): self.configMode = getConfigListEntry(_("Configuration Mode"), self.nimConfig.configMode) @@ -190,6 +194,7 @@ class NimSetup(Screen, ConfigListScreen): checkList = (self.configMode, self.diseqcModeEntry, self.advancedSatsEntry, \ self.advancedLnbsEntry, self.advancedDiseqcMode, self.advancedUsalsEntry, \ self.advancedLof, self.advancedPowerMeasurement, self.turningSpeed, \ + self.advancedType, self.advancedSCR, self.advancedManufacturer, self.advancedUnicable, \ self.uncommittedDiseqcCommand, self.cableScanType) for x in checkList: if self["config"].getCurrent() == x: @@ -216,19 +221,57 @@ class NimSetup(Screen, ConfigListScreen): if isinstance(currLnb, ConfigNothing): currLnb = None - self.list.append(getConfigListEntry(_("Voltage mode"), Sat.voltage)) - self.list.append(getConfigListEntry(_("Tone mode"), Sat.tonemode)) - if currLnb and currLnb.diseqcMode.value == "1_2": - if lnbnum < 33: - self.advancedUsalsEntry = getConfigListEntry(_("Use usals for this sat"), Sat.usals) - self.list.append(self.advancedUsalsEntry) - if not Sat.usals.value: - self.list.append(getConfigListEntry(_("Stored position"), Sat.rotorposition)) - # LNBs self.advancedLnbsEntry = getConfigListEntry(_("LNB"), Sat.lnb) self.list.append(self.advancedLnbsEntry) + if currLnb: + self.list.append(getConfigListEntry(_("Priority"), currLnb.prio)) + self.advancedLof = getConfigListEntry(_("LOF"), currLnb.lof) + self.list.append(self.advancedLof) + if currLnb.lof.value == "user_defined": + self.list.append(getConfigListEntry(_("LOF/L"), currLnb.lofl)) + self.list.append(getConfigListEntry(_("LOF/H"), currLnb.lofh)) + self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold)) +# self.list.append(getConfigListEntry(_("12V Output"), currLnb.output_12v)) + + if currLnb.lof.value == "unicable": + self.advancedUnicable = getConfigListEntry("Unicable "+_("Configuration Mode"), currLnb.unicable) + self.list.append(self.advancedUnicable) + if currLnb.unicable.value == "unicable_user": + self.advancedSCR = getConfigListEntry(_("Channel"), currLnb.satcruser) + self.list.append(self.advancedSCR) + self.list.append(getConfigListEntry(_("Frequency"), currLnb.satcrvcouser[currLnb.satcruser.index])) + self.list.append(getConfigListEntry(_("LOF/L"), currLnb.lofl)) + self.list.append(getConfigListEntry(_("LOF/H"), currLnb.lofh)) + self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold)) + elif currLnb.unicable.value == "unicable_matrix": + manufacturer_name = currLnb.unicableMatrixManufacturer.value + manufacturer = currLnb.unicableMatrix[manufacturer_name] + product_name = manufacturer.product.value + self.advancedManufacturer = getConfigListEntry(_("Manufacturer"), currLnb.unicableMatrixManufacturer) + self.advancedType = getConfigListEntry(_("Type"), manufacturer.product) + self.advancedSCR = getConfigListEntry(_("Channel"), manufacturer.scr[product_name]) + self.list.append(self.advancedManufacturer) + self.list.append(self.advancedType) + self.list.append(self.advancedSCR) + self.list.append(getConfigListEntry(_("Frequency"), manufacturer.vco[product_name][manufacturer.scr[product_name].index])) + elif currLnb.unicable.value == "unicable_lnb": + manufacturer_name = currLnb.unicableLnbManufacturer.value + manufacturer = currLnb.unicableLnb[manufacturer_name] + product_name = manufacturer.product.value + self.advancedManufacturer = getConfigListEntry(_("Manufacturer"), currLnb.unicableLnbManufacturer) + self.advancedType = getConfigListEntry(_("Type"), manufacturer.product) + self.advancedSCR = getConfigListEntry(_("Channel"), manufacturer.scr[product_name]) + self.list.append(self.advancedManufacturer) + self.list.append(self.advancedType) + self.list.append(self.advancedSCR) + self.list.append(getConfigListEntry(_("Frequency"), manufacturer.vco[product_name][manufacturer.scr[product_name].index])) + else: #kein Unicable + self.list.append(getConfigListEntry(_("Voltage mode"), Sat.voltage)) + self.list.append(getConfigListEntry(_("Increased voltage"), currLnb.increased_voltage)) + self.list.append(getConfigListEntry(_("Tone mode"), Sat.tonemode)) + if lnbnum < 33: self.advancedDiseqcMode = getConfigListEntry(_("DiSEqC mode"), currLnb.diseqcMode) self.list.append(self.advancedDiseqcMode) @@ -275,15 +318,12 @@ class NimSetup(Screen, ConfigListScreen): if currLnb.powerMeasurement.value: currLnb.powerMeasurement.value = False currLnb.powerMeasurement.save() - self.advancedLof = getConfigListEntry(_("LOF"), currLnb.lof) - self.list.append(self.advancedLof) - if currLnb.lof.value == "user_defined": - self.list.append(getConfigListEntry(_("LOF/L"), currLnb.lofl)) - self.list.append(getConfigListEntry(_("LOF/H"), currLnb.lofh)) - self.list.append(getConfigListEntry(_("Threshold"), currLnb.threshold)) -# self.list.append(getConfigListEntry(_("12V Output"), currLnb.output_12v)) - self.list.append(getConfigListEntry(_("Increased voltage"), currLnb.increased_voltage)) - self.list.append(getConfigListEntry(_("Priority"), currLnb.prio)) + self.advancedUsalsEntry = getConfigListEntry(_("Use usals for this sat"), Sat.usals) + self.list.append(self.advancedUsalsEntry) + if not Sat.usals.value: + self.list.append(getConfigListEntry(_("Stored position"), Sat.rotorposition)) + + def fillAdvancedList(self): self.list = [ ] -- cgit v1.2.3 From 4be13de9082e1c79de77db6fa3eeab18a3955715 Mon Sep 17 00:00:00 2001 From: ghost Date: Mon, 19 Jan 2009 21:05:45 +0100 Subject: remove nested structures because of the fact that swig cannot handle this now we no more need the bad duplicate definitions of eDVBFrontendParametersSatellite/Cables/Terrestrial content i.e. eDVBFrontendParametersSatellite.System_DVB_S or eDVBFrontendParametersSatellite.FEC_Auto.... --- lib/dvb/db.cpp | 16 +- lib/dvb/frontend.cpp | 530 ++++++++------------- lib/dvb/frontendparms.h | 124 +++-- lib/dvb/sec.cpp | 20 +- .../SystemPlugins/PositionerSetup/plugin.py | 32 +- .../Plugins/SystemPlugins/Satfinder/plugin.py | 32 +- lib/python/Screens/ScanSetup.py | 343 +++++++------ lib/service/servicedvb.cpp | 177 ++++--- 8 files changed, 577 insertions(+), 697 deletions(-) (limited to 'lib/dvb/sec.cpp') diff --git a/lib/dvb/db.cpp b/lib/dvb/db.cpp index e5a94392..719ff35e 100644 --- a/lib/dvb/db.cpp +++ b/lib/dvb/db.cpp @@ -327,10 +327,10 @@ void eDVBDB::loadServicelist(const char *file) eDVBFrontendParametersSatellite sat; int frequency, symbol_rate, polarisation, fec, orbital_position, inversion, flags=0, - system=eDVBFrontendParametersSatellite::System::DVB_S, - modulation=eDVBFrontendParametersSatellite::Modulation::QPSK, - rolloff=eDVBFrontendParametersSatellite::RollOff::alpha_0_35, - pilot=eDVBFrontendParametersSatellite::Pilot::Unknown; + system=eDVBFrontendParametersSatellite::System_DVB_S, + modulation=eDVBFrontendParametersSatellite::Modulation_QPSK, + rolloff=eDVBFrontendParametersSatellite::RollOff_alpha_0_35, + pilot=eDVBFrontendParametersSatellite::Pilot_Unknown; if (version == 3) sscanf(line+3, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d", &frequency, &symbol_rate, &polarisation, &fec, &orbital_position, &inversion, &system, &modulation, &rolloff, &pilot); else @@ -368,9 +368,9 @@ void eDVBDB::loadServicelist(const char *file) { eDVBFrontendParametersCable cab; int frequency, symbol_rate, - inversion=eDVBFrontendParametersCable::Inversion::Unknown, - modulation=eDVBFrontendParametersCable::Modulation::Auto, - fec_inner=eDVBFrontendParametersCable::FEC::fAuto, + inversion=eDVBFrontendParametersCable::Inversion_Unknown, + modulation=eDVBFrontendParametersCable::Modulation_Auto, + fec_inner=eDVBFrontendParametersCable::FEC_Auto, flags=0; sscanf(line+3, "%d:%d:%d:%d:%d:%d", &frequency, &symbol_rate, &inversion, &modulation, &fec_inner, &flags); cab.frequency = frequency; @@ -495,7 +495,7 @@ void eDVBDB::saveServicelist(const char *file) ch.m_frontendParameters->getFlags(flags); if (!ch.m_frontendParameters->getDVBS(sat)) { - if (sat.system == eDVBFrontendParametersSatellite::System::DVB_S2) + if (sat.system == eDVBFrontendParametersSatellite::System_DVB_S2) { fprintf(f, "\ts %d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d\n", sat.frequency, sat.symbol_rate, diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp index aae7bbc2..5fe3799d 100644 --- a/lib/dvb/frontend.cpp +++ b/lib/dvb/frontend.cpp @@ -1,4 +1,5 @@ #include +#include #include #include // access to python config #include @@ -148,10 +149,10 @@ void eDVBFrontendParametersSatellite::set(const SatelliteDeliverySystemDescripto symbol_rate = descriptor.getSymbolRate() * 100; polarisation = descriptor.getPolarization(); fec = descriptor.getFecInner(); - if ( fec != FEC::fNone && fec > FEC::f9_10 ) - fec = FEC::fAuto; - inversion = Inversion::Unknown; - pilot = Pilot::Unknown; + if ( fec != eDVBFrontendParametersSatellite::FEC_None && fec > eDVBFrontendParametersSatellite::FEC_9_10 ) + fec = eDVBFrontendParametersSatellite::FEC_Auto; + inversion = eDVBFrontendParametersSatellite::Inversion_Unknown; + pilot = eDVBFrontendParametersSatellite::Pilot_Unknown; orbital_position = ((descriptor.getOrbitalPosition() >> 12) & 0xF) * 1000; orbital_position += ((descriptor.getOrbitalPosition() >> 8) & 0xF) * 100; orbital_position += ((descriptor.getOrbitalPosition() >> 4) & 0xF) * 10; @@ -160,13 +161,13 @@ void eDVBFrontendParametersSatellite::set(const SatelliteDeliverySystemDescripto orbital_position = 3600 - orbital_position; system = descriptor.getModulationSystem(); modulation = descriptor.getModulation(); - if (system == System::DVB_S && modulation == Modulation::M8PSK) + if (system == eDVBFrontendParametersSatellite::System_DVB_S && modulation == eDVBFrontendParametersSatellite::Modulation_8PSK) { eDebug("satellite_delivery_descriptor non valid modulation type.. force QPSK"); - modulation=QPSK; + modulation=eDVBFrontendParametersSatellite::Modulation_QPSK; } rolloff = descriptor.getRollOff(); - if (system == System::DVB_S2) + if (system == eDVBFrontendParametersSatellite::System_DVB_S2) { eDebug("SAT DVB-S2 freq %d, %s, pos %d, sr %d, fec %d, modulation %d, rolloff %d", frequency, @@ -192,11 +193,11 @@ void eDVBFrontendParametersCable::set(const CableDeliverySystemDescriptor &descr symbol_rate = descriptor.getSymbolRate() * 100; fec_inner = descriptor.getFecInner(); if ( fec_inner == 0xF ) - fec_inner = FEC::fNone; + fec_inner = eDVBFrontendParametersCable::FEC_None; modulation = descriptor.getModulation(); if ( modulation > 0x5 ) - modulation = Modulation::Auto; - inversion = Inversion::Unknown; + modulation = eDVBFrontendParametersCable::Modulation_Auto; + inversion = eDVBFrontendParametersCable::Inversion_Unknown; eDebug("Cable freq %d, mod %d, sr %d, fec %d", frequency, modulation, symbol_rate, fec_inner); @@ -207,24 +208,24 @@ void eDVBFrontendParametersTerrestrial::set(const TerrestrialDeliverySystemDescr frequency = descriptor.getCentreFrequency() * 10; bandwidth = descriptor.getBandwidth(); if ( bandwidth > 2 ) // 5Mhz forced to auto - bandwidth = Bandwidth::BwAuto; + bandwidth = eDVBFrontendParametersTerrestrial::Bandwidth_Auto; code_rate_HP = descriptor.getCodeRateHpStream(); if (code_rate_HP > 4) - code_rate_HP = FEC::fAuto; + code_rate_HP = eDVBFrontendParametersTerrestrial::FEC_Auto; code_rate_LP = descriptor.getCodeRateLpStream(); if (code_rate_LP > 4) - code_rate_LP = FEC::fAuto; + code_rate_LP = eDVBFrontendParametersTerrestrial::FEC_Auto; transmission_mode = descriptor.getTransmissionMode(); if (transmission_mode > 1) // TM4k forced to auto - transmission_mode = TransmissionMode::TMAuto; + transmission_mode = eDVBFrontendParametersTerrestrial::TransmissionMode_Auto; guard_interval = descriptor.getGuardInterval(); if (guard_interval > 3) - guard_interval = GuardInterval::GI_Auto; + guard_interval = eDVBFrontendParametersTerrestrial::GuardInterval_Auto; hierarchy = descriptor.getHierarchyInformation()&3; modulation = descriptor.getConstellation(); if (modulation > 2) - modulation = Modulation::Auto; - inversion = Inversion::Unknown; + modulation = eDVBFrontendParametersTerrestrial::Modulation_Auto; + inversion = eDVBFrontendParametersTerrestrial::Inversion_Unknown; eDebug("Terr freq %d, bw %d, cr_hp %d, cr_lp %d, tm_mode %d, guard %d, hierarchy %d, const %d", frequency, bandwidth, code_rate_HP, code_rate_LP, transmission_mode, guard_interval, hierarchy, modulation); @@ -316,9 +317,9 @@ RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters diff = 1<<29; else if (sat.polarisation != osat.polarisation) diff = 1<<28; - else if (exact && sat.fec != osat.fec && sat.fec != eDVBFrontendParametersSatellite::FEC::fAuto && osat.fec != eDVBFrontendParametersSatellite::FEC::fAuto) + else if (exact && sat.fec != osat.fec && sat.fec != eDVBFrontendParametersSatellite::FEC_Auto && osat.fec != eDVBFrontendParametersSatellite::FEC_Auto) diff = 1<<27; - else if (exact && sat.modulation != osat.modulation && sat.modulation != eDVBFrontendParametersSatellite::Modulation::Auto && osat.modulation != eDVBFrontendParametersSatellite::Modulation::Auto) + else if (exact && sat.modulation != osat.modulation && sat.modulation != eDVBFrontendParametersSatellite::Modulation_Auto && osat.modulation != eDVBFrontendParametersSatellite::Modulation_Auto) diff = 1<<27; else { @@ -333,10 +334,10 @@ RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters return -2; if (exact && cable.modulation != ocable.modulation - && cable.modulation != eDVBFrontendParametersCable::Modulation::Auto - && ocable.modulation != eDVBFrontendParametersCable::Modulation::Auto) + && cable.modulation != eDVBFrontendParametersCable::Modulation_Auto + && ocable.modulation != eDVBFrontendParametersCable::Modulation_Auto) diff = 1 << 29; - else if (exact && cable.fec_inner != ocable.fec_inner && cable.fec_inner != eDVBFrontendParametersCable::FEC::fAuto && ocable.fec_inner != eDVBFrontendParametersCable::FEC::fAuto) + else if (exact && cable.fec_inner != ocable.fec_inner && cable.fec_inner != eDVBFrontendParametersCable::FEC_Auto && ocable.fec_inner != eDVBFrontendParametersCable::FEC_Auto) diff = 1 << 27; else { @@ -350,32 +351,32 @@ RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters return -2; if (exact && oterrestrial.bandwidth != terrestrial.bandwidth && - oterrestrial.bandwidth != eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto && - terrestrial.bandwidth != eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto) + oterrestrial.bandwidth != eDVBFrontendParametersTerrestrial::Bandwidth_Auto && + terrestrial.bandwidth != eDVBFrontendParametersTerrestrial::Bandwidth_Auto) diff = 1 << 30; else if (exact && oterrestrial.modulation != terrestrial.modulation && - oterrestrial.modulation != eDVBFrontendParametersTerrestrial::Modulation::Auto && - terrestrial.modulation != eDVBFrontendParametersTerrestrial::Modulation::Auto) + oterrestrial.modulation != eDVBFrontendParametersTerrestrial::Modulation_Auto && + terrestrial.modulation != eDVBFrontendParametersTerrestrial::Modulation_Auto) diff = 1 << 30; else if (exact && oterrestrial.transmission_mode != terrestrial.transmission_mode && - oterrestrial.transmission_mode != eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto && - terrestrial.transmission_mode != eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto) + oterrestrial.transmission_mode != eDVBFrontendParametersTerrestrial::TransmissionMode_Auto && + terrestrial.transmission_mode != eDVBFrontendParametersTerrestrial::TransmissionMode_Auto) diff = 1 << 30; else if (exact && oterrestrial.guard_interval != terrestrial.guard_interval && - oterrestrial.guard_interval != eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto && - terrestrial.guard_interval != eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto) + oterrestrial.guard_interval != eDVBFrontendParametersTerrestrial::GuardInterval_Auto && + terrestrial.guard_interval != eDVBFrontendParametersTerrestrial::GuardInterval_Auto) diff = 1 << 30; else if (exact && oterrestrial.hierarchy != terrestrial.hierarchy && - oterrestrial.hierarchy != eDVBFrontendParametersTerrestrial::Hierarchy::HAuto && - terrestrial.hierarchy != eDVBFrontendParametersTerrestrial::Hierarchy::HAuto) + oterrestrial.hierarchy != eDVBFrontendParametersTerrestrial::Hierarchy_Auto && + terrestrial.hierarchy != eDVBFrontendParametersTerrestrial::Hierarchy_Auto) diff = 1 << 30; else if (exact && oterrestrial.code_rate_LP != terrestrial.code_rate_LP && - oterrestrial.code_rate_LP != eDVBFrontendParametersTerrestrial::FEC::fAuto && - terrestrial.code_rate_LP != eDVBFrontendParametersTerrestrial::FEC::fAuto) + oterrestrial.code_rate_LP != eDVBFrontendParametersTerrestrial::FEC_Auto && + terrestrial.code_rate_LP != eDVBFrontendParametersTerrestrial::FEC_Auto) diff = 1 << 30; else if (exact && oterrestrial.code_rate_HP != terrestrial.code_rate_HP && - oterrestrial.code_rate_HP != eDVBFrontendParametersTerrestrial::FEC::fAuto && - terrestrial.code_rate_HP != eDVBFrontendParametersTerrestrial::FEC::fAuto) + oterrestrial.code_rate_HP != eDVBFrontendParametersTerrestrial::FEC_Auto && + terrestrial.code_rate_HP != eDVBFrontendParametersTerrestrial::FEC_Auto) diff = 1 << 30; else diff = abs(terrestrial.frequency - oterrestrial.frequency); @@ -963,120 +964,79 @@ void PutToDict(ePyObject &dict, const char*key, const char *value) void fillDictWithSatelliteData(ePyObject dict, const FRONTENDPARAMETERS &parm, eDVBFrontend *fe) { long freq_offset=0; - const char *tmp=0; + long tmp=0; fe->getData(eDVBFrontend::FREQ_OFFSET, freq_offset); int frequency = parm_frequency + freq_offset; PutToDict(dict, "frequency", frequency); PutToDict(dict, "symbol_rate", parm_u_qpsk_symbol_rate); switch(parm_u_qpsk_fec_inner) { - case FEC_1_2: - tmp = "FEC_1_2"; - break; - case FEC_2_3: - tmp = "FEC_2_3"; - break; - case FEC_3_4: - tmp = "FEC_3_4"; - break; - case FEC_5_6: - tmp = "FEC_5_6"; - break; - case FEC_7_8: - tmp = "FEC_7_8"; - break; - case FEC_NONE: - tmp = "FEC_NONE"; + case FEC_1_2: tmp = eDVBFrontendParametersSatellite::FEC_1_2; break; + case FEC_2_3: tmp = eDVBFrontendParametersSatellite::FEC_2_3; break; + case FEC_3_4: tmp = eDVBFrontendParametersSatellite::FEC_3_4; break; + case FEC_5_6: tmp = eDVBFrontendParametersSatellite::FEC_5_6; break; + case FEC_7_8: tmp = eDVBFrontendParametersSatellite::FEC_7_8; break; + case FEC_NONE: tmp = eDVBFrontendParametersSatellite::FEC_None; break; default: - case FEC_AUTO: - tmp = "FEC_AUTO"; - break; + case FEC_AUTO: tmp = eDVBFrontendParametersSatellite::FEC_Auto; break; #if HAVE_DVB_API_VERSION >=3 - case FEC_S2_8PSK_1_2: - case FEC_S2_QPSK_1_2: - tmp = "FEC_1_2"; - break; + case FEC_S2_8PSK_1_2: + case FEC_S2_QPSK_1_2: tmp = eDVBFrontendParametersSatellite::FEC_1_2; break; case FEC_S2_8PSK_2_3: - case FEC_S2_QPSK_2_3: - tmp = "FEC_2_3"; - break; + case FEC_S2_QPSK_2_3: tmp = eDVBFrontendParametersSatellite::FEC_2_3; break; case FEC_S2_8PSK_3_4: - case FEC_S2_QPSK_3_4: - tmp = "FEC_3_4"; - break; + case FEC_S2_QPSK_3_4: tmp = eDVBFrontendParametersSatellite::FEC_3_4; break; case FEC_S2_8PSK_5_6: - case FEC_S2_QPSK_5_6: - tmp = "FEC_5_6"; - break; + case FEC_S2_QPSK_5_6: tmp = eDVBFrontendParametersSatellite::FEC_5_6; break; case FEC_S2_8PSK_7_8: - case FEC_S2_QPSK_7_8: - tmp = "FEC_7_8"; - break; + case FEC_S2_QPSK_7_8: tmp = eDVBFrontendParametersSatellite::FEC_7_8; break; case FEC_S2_8PSK_8_9: - case FEC_S2_QPSK_8_9: - tmp = "FEC_8_9"; - break; + case FEC_S2_QPSK_8_9: tmp = eDVBFrontendParametersSatellite::FEC_8_9; break; case FEC_S2_8PSK_3_5: - case FEC_S2_QPSK_3_5: - tmp = "FEC_3_5"; - break; + case FEC_S2_QPSK_3_5: tmp = eDVBFrontendParametersSatellite::FEC_3_5; break; case FEC_S2_8PSK_4_5: - case FEC_S2_QPSK_4_5: - tmp = "FEC_4_5"; - break; + case FEC_S2_QPSK_4_5: tmp = eDVBFrontendParametersSatellite::FEC_4_5; break; case FEC_S2_8PSK_9_10: - case FEC_S2_QPSK_9_10: - tmp = "FEC_9_10"; - break; + case FEC_S2_QPSK_9_10: tmp = eDVBFrontendParametersSatellite::FEC_9_10; break; #endif } PutToDict(dict, "fec_inner", tmp); #if HAVE_DVB_API_VERSION >=3 PutToDict(dict, "modulation", - parm_u_qpsk_fec_inner > FEC_S2_QPSK_9_10 ? "8PSK": "QPSK" ); + parm_u_qpsk_fec_inner > FEC_S2_QPSK_9_10 ? + eDVBFrontendParametersSatellite::Modulation_8PSK : + eDVBFrontendParametersSatellite::Modulation_QPSK ); if (parm_u_qpsk_fec_inner > FEC_AUTO) { switch(parm_inversion & 0xc) { default: // unknown rolloff - case 0: // 0.35 - tmp = "ROLLOFF_0_35"; - break; - case 4: // 0.25 - tmp = "ROLLOFF_0_25"; - break; - case 8: // 0.20 - tmp = "ROLLOFF_0_20"; - break; + case 0: tmp = eDVBFrontendParametersSatellite::RollOff_alpha_0_35; break; + case 4: tmp = eDVBFrontendParametersSatellite::RollOff_alpha_0_25; break; + case 8: tmp = eDVBFrontendParametersSatellite::RollOff_alpha_0_20; break; } PutToDict(dict, "rolloff", tmp); switch(parm_inversion & 0x30) { - case 0: // pilot off - tmp = "PILOT_OFF"; - break; - case 0x10: // pilot on - tmp = "PILOT_ON"; - break; - case 0x20: // pilot auto - tmp = "PILOT_AUTO"; - break; + case 0: tmp = eDVBFrontendParametersSatellite::Pilot_Off; break; + case 0x10: tmp = eDVBFrontendParametersSatellite::Pilot_On; break; + case 0x20: tmp = eDVBFrontendParametersSatellite::Pilot_Unknown; break; } PutToDict(dict, "pilot", tmp); - tmp = "DVB-S2"; + tmp = eDVBFrontendParametersSatellite::System_DVB_S2; } else - tmp = "DVB-S"; + tmp = eDVBFrontendParametersSatellite::System_DVB_S; #else - PutToDict(dict, "modulation", "QPSK" ); - tmp = "DVB-S"; + PutToDict(dict, "modulation", eDVBFrontendParametersSatellite::Modulation_QPSK ); + tmp = eDVBFrontendParametersSatellite::System_DVB_S; #endif PutToDict(dict, "system", tmp); } void fillDictWithCableData(ePyObject dict, const FRONTENDPARAMETERS &parm) { - const char *tmp=0; + long tmp=0; #if HAVE_DVB_API_VERSION < 3 PutToDict(dict, "frequency", parm_frequency); #else @@ -1085,196 +1045,102 @@ void fillDictWithCableData(ePyObject dict, const FRONTENDPARAMETERS &parm) PutToDict(dict, "symbol_rate", parm_u_qam_symbol_rate); switch(parm_u_qam_fec_inner) { - case FEC_NONE: - tmp = "FEC_NONE"; - break; - case FEC_1_2: - tmp = "FEC_1_2"; - break; - case FEC_2_3: - tmp = "FEC_2_3"; - break; - case FEC_3_4: - tmp = "FEC_3_4"; - break; - case FEC_5_6: - tmp = "FEC_5_6"; - break; - case FEC_7_8: - tmp = "FEC_7_8"; - break; + case FEC_NONE: tmp = eDVBFrontendParametersCable::FEC_None; break; + case FEC_1_2: tmp = eDVBFrontendParametersCable::FEC_1_2; break; + case FEC_2_3: tmp = eDVBFrontendParametersCable::FEC_2_3; break; + case FEC_3_4: tmp = eDVBFrontendParametersCable::FEC_3_4; break; + case FEC_5_6: tmp = eDVBFrontendParametersCable::FEC_5_6; break; + case FEC_7_8: tmp = eDVBFrontendParametersCable::FEC_7_8; break; #if HAVE_DVB_API_VERSION >= 3 - case FEC_8_9: - tmp = "FEC_8_9"; - break; + case FEC_8_9: tmp = eDVBFrontendParametersCable::FEC_7_8; break; #endif default: - case FEC_AUTO: - tmp = "FEC_AUTO"; - break; + case FEC_AUTO: tmp = eDVBFrontendParametersCable::FEC_Auto; break; } PutToDict(dict, "fec_inner", tmp); switch(parm_u_qam_modulation) { - case QAM_16: - tmp = "QAM_16"; - break; - case QAM_32: - tmp = "QAM_32"; - break; - case QAM_64: - tmp = "QAM_64"; - break; - case QAM_128: - tmp = "QAM_128"; - break; - case QAM_256: - tmp = "QAM_256"; - break; + case QAM_16: tmp = eDVBFrontendParametersCable::Modulation_QAM16; break; + case QAM_32: tmp = eDVBFrontendParametersCable::Modulation_QAM32; break; + case QAM_64: tmp = eDVBFrontendParametersCable::Modulation_QAM64; break; + case QAM_128: tmp = eDVBFrontendParametersCable::Modulation_QAM128; break; + case QAM_256: tmp = eDVBFrontendParametersCable::Modulation_QAM256; break; default: - case QAM_AUTO: - tmp = "QAM_AUTO"; - break; + case QAM_AUTO: tmp = eDVBFrontendParametersCable::Modulation_Auto; break; } PutToDict(dict, "modulation", tmp); } void fillDictWithTerrestrialData(ePyObject dict, const FRONTENDPARAMETERS &parm) { - const char *tmp=0; + long tmp=0; PutToDict(dict, "frequency", parm_frequency); switch (parm_u_ofdm_bandwidth) { - case BANDWIDTH_8_MHZ: - tmp = "BANDWIDTH_8_MHZ"; - break; - case BANDWIDTH_7_MHZ: - tmp = "BANDWIDTH_7_MHZ"; - break; - case BANDWIDTH_6_MHZ: - tmp = "BANDWIDTH_6_MHZ"; - break; + case BANDWIDTH_8_MHZ: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_8MHz; break; + case BANDWIDTH_7_MHZ: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_7MHz; break; + case BANDWIDTH_6_MHZ: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_6MHz; break; default: - case BANDWIDTH_AUTO: - tmp = "BANDWIDTH_AUTO"; - break; + case BANDWIDTH_AUTO: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_Auto; break; } PutToDict(dict, "bandwidth", tmp); switch (parm_u_ofdm_code_rate_LP) { - case FEC_1_2: - tmp = "FEC_1_2"; - break; - case FEC_2_3: - tmp = "FEC_2_3"; - break; - case FEC_3_4: - tmp = "FEC_3_4"; - break; - case FEC_5_6: - tmp = "FEC_5_6"; - break; - case FEC_7_8: - tmp = "FEC_7_8"; - break; + case FEC_1_2: tmp = eDVBFrontendParametersTerrestrial::FEC_1_2; break; + case FEC_2_3: tmp = eDVBFrontendParametersTerrestrial::FEC_2_3; break; + case FEC_3_4: tmp = eDVBFrontendParametersTerrestrial::FEC_3_4; break; + case FEC_5_6: tmp = eDVBFrontendParametersTerrestrial::FEC_5_6; break; + case FEC_7_8: tmp = eDVBFrontendParametersTerrestrial::FEC_7_8; break; default: - case FEC_AUTO: - tmp = "FEC_AUTO"; - break; + case FEC_AUTO: tmp = eDVBFrontendParametersTerrestrial::FEC_Auto; break; } PutToDict(dict, "code_rate_lp", tmp); switch (parm_u_ofdm_code_rate_HP) { - case FEC_1_2: - tmp = "FEC_1_2"; - break; - case FEC_2_3: - tmp = "FEC_2_3"; - break; - case FEC_3_4: - tmp = "FEC_3_4"; - break; - case FEC_5_6: - tmp = "FEC_5_6"; - break; - case FEC_7_8: - tmp = "FEC_7_8"; - break; + case FEC_1_2: tmp = eDVBFrontendParametersTerrestrial::FEC_1_2; break; + case FEC_2_3: tmp = eDVBFrontendParametersTerrestrial::FEC_2_3; break; + case FEC_3_4: tmp = eDVBFrontendParametersTerrestrial::FEC_3_4; break; + case FEC_5_6: tmp = eDVBFrontendParametersTerrestrial::FEC_5_6; break; + case FEC_7_8: tmp = eDVBFrontendParametersTerrestrial::FEC_7_8; break; default: - case FEC_AUTO: - tmp = "FEC_AUTO"; - break; + case FEC_AUTO: tmp = eDVBFrontendParametersTerrestrial::FEC_Auto; break; } PutToDict(dict, "code_rate_hp", tmp); switch (parm_u_ofdm_constellation) { - case QPSK: - tmp = "QPSK"; - break; - case QAM_16: - tmp = "QAM_16"; - break; - case QAM_64: - tmp = "QAM_64"; - break; + case QPSK: tmp = eDVBFrontendParametersTerrestrial::Modulation_QPSK; break; + case QAM_16: tmp = eDVBFrontendParametersTerrestrial::Modulation_QAM16; break; + case QAM_64: tmp = eDVBFrontendParametersTerrestrial::Modulation_QAM64; break; default: - case QAM_AUTO: - tmp = "QAM_AUTO"; - break; + case QAM_AUTO: tmp = eDVBFrontendParametersTerrestrial::Modulation_Auto; break; } PutToDict(dict, "constellation", tmp); switch (parm_u_ofdm_transmission_mode) { - case TRANSMISSION_MODE_2K: - tmp = "TRANSMISSION_MODE_2K"; - break; - case TRANSMISSION_MODE_8K: - tmp = "TRANSMISSION_MODE_8K"; - break; + case TRANSMISSION_MODE_2K: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_2k; break; + case TRANSMISSION_MODE_8K: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_8k; break; default: - case TRANSMISSION_MODE_AUTO: - tmp = "TRANSMISSION_MODE_AUTO"; - break; + case TRANSMISSION_MODE_AUTO: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_Auto; break; } PutToDict(dict, "transmission_mode", tmp); switch (parm_u_ofdm_guard_interval) { - case GUARD_INTERVAL_1_32: - tmp = "GUARD_INTERVAL_1_32"; - break; - case GUARD_INTERVAL_1_16: - tmp = "GUARD_INTERVAL_1_16"; - break; - case GUARD_INTERVAL_1_8: - tmp = "GUARD_INTERVAL_1_8"; - break; - case GUARD_INTERVAL_1_4: - tmp = "GUARD_INTERVAL_1_4"; - break; + case GUARD_INTERVAL_1_32: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_32; break; + case GUARD_INTERVAL_1_16: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_16; break; + case GUARD_INTERVAL_1_8: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_8; break; + case GUARD_INTERVAL_1_4: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_4; break; default: - case GUARD_INTERVAL_AUTO: - tmp = "GUARD_INTERVAL_AUTO"; - break; + case GUARD_INTERVAL_AUTO: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_Auto; break; } PutToDict(dict, "guard_interval", tmp); switch (parm_u_ofdm_hierarchy_information) { - case HIERARCHY_NONE: - tmp = "HIERARCHY_NONE"; - break; - case HIERARCHY_1: - tmp = "HIERARCHY_1"; - break; - case HIERARCHY_2: - tmp = "HIERARCHY_2"; - break; - case HIERARCHY_4: - tmp = "HIERARCHY_4"; - break; + case HIERARCHY_NONE: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_None; break; + case HIERARCHY_1: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_1; break; + case HIERARCHY_2: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_2; break; + case HIERARCHY_4: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_4; break; default: - case HIERARCHY_AUTO: - tmp = "HIERARCHY_AUTO"; - break; + case HIERARCHY_AUTO: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_Auto; break; } PutToDict(dict, "hierarchy_information", tmp); } @@ -1342,20 +1208,18 @@ void eDVBFrontend::getTransponderData(ePyObject dest, bool original) } { const FRONTENDPARAMETERS &parm = original || m_simulate ? this->parm : front; - const char *tmp = "INVERSION_AUTO"; + long tmp = eDVBFrontendParametersSatellite::Inversion_Unknown; switch(parm_inversion & 3) { case INVERSION_ON: - tmp = "INVERSION_ON"; + tmp = eDVBFrontendParametersSatellite::Inversion_On; break; case INVERSION_OFF: - tmp = "INVERSION_OFF"; - break; + tmp = eDVBFrontendParametersSatellite::Inversion_Off; default: break; } - if (tmp) - PutToDict(dest, "inversion", tmp); + PutToDict(dest, "inversion", tmp); switch(m_type) { @@ -1889,41 +1753,41 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm, parm_u_qpsk_symbol_rate = feparm.symbol_rate; switch (feparm.inversion) { - case eDVBFrontendParametersSatellite::Inversion::On: + case eDVBFrontendParametersSatellite::Inversion_On: parm_inversion = INVERSION_ON; break; - case eDVBFrontendParametersSatellite::Inversion::Off: + case eDVBFrontendParametersSatellite::Inversion_Off: parm_inversion = INVERSION_OFF; break; default: - case eDVBFrontendParametersSatellite::Inversion::Unknown: + case eDVBFrontendParametersSatellite::Inversion_Unknown: parm_inversion = INVERSION_AUTO; break; } - if (feparm.system == eDVBFrontendParametersSatellite::System::DVB_S) + if (feparm.system == eDVBFrontendParametersSatellite::System_DVB_S) switch (feparm.fec) { - case eDVBFrontendParametersSatellite::FEC::fNone: + case eDVBFrontendParametersSatellite::FEC_None: parm_u_qpsk_fec_inner = FEC_NONE; break; - case eDVBFrontendParametersSatellite::FEC::f1_2: + case eDVBFrontendParametersSatellite::FEC_1_2: parm_u_qpsk_fec_inner = FEC_1_2; break; - case eDVBFrontendParametersSatellite::FEC::f2_3: + case eDVBFrontendParametersSatellite::FEC_2_3: parm_u_qpsk_fec_inner = FEC_2_3; break; - case eDVBFrontendParametersSatellite::FEC::f3_4: + case eDVBFrontendParametersSatellite::FEC_3_4: parm_u_qpsk_fec_inner = FEC_3_4; break; - case eDVBFrontendParametersSatellite::FEC::f5_6: + case eDVBFrontendParametersSatellite::FEC_5_6: parm_u_qpsk_fec_inner = FEC_5_6; break; - case eDVBFrontendParametersSatellite::FEC::f7_8: + case eDVBFrontendParametersSatellite::FEC_7_8: parm_u_qpsk_fec_inner = FEC_7_8; break; default: eDebugNoSimulate("no valid fec for DVB-S set.. assume auto"); - case eDVBFrontendParametersSatellite::FEC::fAuto: + case eDVBFrontendParametersSatellite::FEC_Auto: parm_u_qpsk_fec_inner = FEC_AUTO; break; } @@ -1932,31 +1796,31 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm, { switch (feparm.fec) { - case eDVBFrontendParametersSatellite::FEC::f1_2: + case eDVBFrontendParametersSatellite::FEC_1_2: parm_u_qpsk_fec_inner = FEC_S2_QPSK_1_2; break; - case eDVBFrontendParametersSatellite::FEC::f2_3: + case eDVBFrontendParametersSatellite::FEC_2_3: parm_u_qpsk_fec_inner = FEC_S2_QPSK_2_3; break; - case eDVBFrontendParametersSatellite::FEC::f3_4: + case eDVBFrontendParametersSatellite::FEC_3_4: parm_u_qpsk_fec_inner = FEC_S2_QPSK_3_4; break; - case eDVBFrontendParametersSatellite::FEC::f3_5: + case eDVBFrontendParametersSatellite::FEC_3_5: parm_u_qpsk_fec_inner = FEC_S2_QPSK_3_5; break; - case eDVBFrontendParametersSatellite::FEC::f4_5: + case eDVBFrontendParametersSatellite::FEC_4_5: parm_u_qpsk_fec_inner = FEC_S2_QPSK_4_5; break; - case eDVBFrontendParametersSatellite::FEC::f5_6: + case eDVBFrontendParametersSatellite::FEC_5_6: parm_u_qpsk_fec_inner = FEC_S2_QPSK_5_6; break; - case eDVBFrontendParametersSatellite::FEC::f7_8: + case eDVBFrontendParametersSatellite::FEC_7_8: parm_u_qpsk_fec_inner = FEC_S2_QPSK_7_8; break; - case eDVBFrontendParametersSatellite::FEC::f8_9: + case eDVBFrontendParametersSatellite::FEC_8_9: parm_u_qpsk_fec_inner = FEC_S2_QPSK_8_9; break; - case eDVBFrontendParametersSatellite::FEC::f9_10: + case eDVBFrontendParametersSatellite::FEC_9_10: parm_u_qpsk_fec_inner = FEC_S2_QPSK_9_10; break; default: @@ -1965,7 +1829,7 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm, } parm_inversion |= (feparm.rolloff << 2); // Hack.. we use bit 2..3 of inversion param for rolloff parm_inversion |= (feparm.pilot << 4); // Hack.. we use bit 4..5 of inversion param for pilot - if (feparm.modulation == eDVBFrontendParametersSatellite::Modulation::M8PSK) { + if (feparm.modulation == eDVBFrontendParametersSatellite::Modulation_8PSK) { parm_u_qpsk_fec_inner = (fe_code_rate_t)((int)parm_u_qpsk_fec_inner+9); // 8PSK fec driver values are decimal 9 bigger } @@ -1992,66 +1856,66 @@ RESULT eDVBFrontend::prepare_cable(const eDVBFrontendParametersCable &feparm) parm_u_qam_symbol_rate = feparm.symbol_rate; switch (feparm.modulation) { - case eDVBFrontendParametersCable::Modulation::QAM16: + case eDVBFrontendParametersCable::Modulation_QAM16: parm_u_qam_modulation = QAM_16; break; - case eDVBFrontendParametersCable::Modulation::QAM32: + case eDVBFrontendParametersCable::Modulation_QAM32: parm_u_qam_modulation = QAM_32; break; - case eDVBFrontendParametersCable::Modulation::QAM64: + case eDVBFrontendParametersCable::Modulation_QAM64: parm_u_qam_modulation = QAM_64; break; - case eDVBFrontendParametersCable::Modulation::QAM128: + case eDVBFrontendParametersCable::Modulation_QAM128: parm_u_qam_modulation = QAM_128; break; - case eDVBFrontendParametersCable::Modulation::QAM256: + case eDVBFrontendParametersCable::Modulation_QAM256: parm_u_qam_modulation = QAM_256; break; default: - case eDVBFrontendParametersCable::Modulation::Auto: + case eDVBFrontendParametersCable::Modulation_Auto: parm_u_qam_modulation = QAM_AUTO; break; } switch (feparm.inversion) { - case eDVBFrontendParametersCable::Inversion::On: + case eDVBFrontendParametersCable::Inversion_On: parm_inversion = INVERSION_ON; break; - case eDVBFrontendParametersCable::Inversion::Off: + case eDVBFrontendParametersCable::Inversion_Off: parm_inversion = INVERSION_OFF; break; default: - case eDVBFrontendParametersCable::Inversion::Unknown: + case eDVBFrontendParametersCable::Inversion_Unknown: parm_inversion = INVERSION_AUTO; break; } switch (feparm.fec_inner) { - case eDVBFrontendParametersCable::FEC::fNone: + case eDVBFrontendParametersCable::FEC_None: parm_u_qam_fec_inner = FEC_NONE; break; - case eDVBFrontendParametersCable::FEC::f1_2: + case eDVBFrontendParametersCable::FEC_1_2: parm_u_qam_fec_inner = FEC_1_2; break; - case eDVBFrontendParametersCable::FEC::f2_3: + case eDVBFrontendParametersCable::FEC_2_3: parm_u_qam_fec_inner = FEC_2_3; break; - case eDVBFrontendParametersCable::FEC::f3_4: + case eDVBFrontendParametersCable::FEC_3_4: parm_u_qam_fec_inner = FEC_3_4; break; - case eDVBFrontendParametersCable::FEC::f5_6: + case eDVBFrontendParametersCable::FEC_5_6: parm_u_qam_fec_inner = FEC_5_6; break; - case eDVBFrontendParametersCable::FEC::f7_8: + case eDVBFrontendParametersCable::FEC_7_8: parm_u_qam_fec_inner = FEC_7_8; break; #if HAVE_DVB_API_VERSION >= 3 - case eDVBFrontendParametersCable::FEC::f8_9: + case eDVBFrontendParametersCable::FEC_8_9: parm_u_qam_fec_inner = FEC_8_9; break; #endif default: - case eDVBFrontendParametersCable::FEC::fAuto: + case eDVBFrontendParametersCable::FEC_Auto: parm_u_qam_fec_inner = FEC_AUTO; break; } @@ -2070,141 +1934,141 @@ RESULT eDVBFrontend::prepare_terrestrial(const eDVBFrontendParametersTerrestrial switch (feparm.bandwidth) { - case eDVBFrontendParametersTerrestrial::Bandwidth::Bw8MHz: + case eDVBFrontendParametersTerrestrial::Bandwidth_8MHz: parm_u_ofdm_bandwidth = BANDWIDTH_8_MHZ; break; - case eDVBFrontendParametersTerrestrial::Bandwidth::Bw7MHz: + case eDVBFrontendParametersTerrestrial::Bandwidth_7MHz: parm_u_ofdm_bandwidth = BANDWIDTH_7_MHZ; break; - case eDVBFrontendParametersTerrestrial::Bandwidth::Bw6MHz: + case eDVBFrontendParametersTerrestrial::Bandwidth_6MHz: parm_u_ofdm_bandwidth = BANDWIDTH_6_MHZ; break; default: - case eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto: + case eDVBFrontendParametersTerrestrial::Bandwidth_Auto: parm_u_ofdm_bandwidth = BANDWIDTH_AUTO; break; } switch (feparm.code_rate_LP) { - case eDVBFrontendParametersTerrestrial::FEC::f1_2: + case eDVBFrontendParametersTerrestrial::FEC_1_2: parm_u_ofdm_code_rate_LP = FEC_1_2; break; - case eDVBFrontendParametersTerrestrial::FEC::f2_3: + case eDVBFrontendParametersTerrestrial::FEC_2_3: parm_u_ofdm_code_rate_LP = FEC_2_3; break; - case eDVBFrontendParametersTerrestrial::FEC::f3_4: + case eDVBFrontendParametersTerrestrial::FEC_3_4: parm_u_ofdm_code_rate_LP = FEC_3_4; break; - case eDVBFrontendParametersTerrestrial::FEC::f5_6: + case eDVBFrontendParametersTerrestrial::FEC_5_6: parm_u_ofdm_code_rate_LP = FEC_5_6; break; - case eDVBFrontendParametersTerrestrial::FEC::f7_8: + case eDVBFrontendParametersTerrestrial::FEC_7_8: parm_u_ofdm_code_rate_LP = FEC_7_8; break; default: - case eDVBFrontendParametersTerrestrial::FEC::fAuto: + case eDVBFrontendParametersTerrestrial::FEC_Auto: parm_u_ofdm_code_rate_LP = FEC_AUTO; break; } switch (feparm.code_rate_HP) { - case eDVBFrontendParametersTerrestrial::FEC::f1_2: + case eDVBFrontendParametersTerrestrial::FEC_1_2: parm_u_ofdm_code_rate_HP = FEC_1_2; break; - case eDVBFrontendParametersTerrestrial::FEC::f2_3: + case eDVBFrontendParametersTerrestrial::FEC_2_3: parm_u_ofdm_code_rate_HP = FEC_2_3; break; - case eDVBFrontendParametersTerrestrial::FEC::f3_4: + case eDVBFrontendParametersTerrestrial::FEC_3_4: parm_u_ofdm_code_rate_HP = FEC_3_4; break; - case eDVBFrontendParametersTerrestrial::FEC::f5_6: + case eDVBFrontendParametersTerrestrial::FEC_5_6: parm_u_ofdm_code_rate_HP = FEC_5_6; break; - case eDVBFrontendParametersTerrestrial::FEC::f7_8: + case eDVBFrontendParametersTerrestrial::FEC_7_8: parm_u_ofdm_code_rate_HP = FEC_7_8; break; default: - case eDVBFrontendParametersTerrestrial::FEC::fAuto: + case eDVBFrontendParametersTerrestrial::FEC_Auto: parm_u_ofdm_code_rate_HP = FEC_AUTO; break; } switch (feparm.modulation) { - case eDVBFrontendParametersTerrestrial::Modulation::QPSK: + case eDVBFrontendParametersTerrestrial::Modulation_QPSK: parm_u_ofdm_constellation = QPSK; break; - case eDVBFrontendParametersTerrestrial::Modulation::QAM16: + case eDVBFrontendParametersTerrestrial::Modulation_QAM16: parm_u_ofdm_constellation = QAM_16; break; - case eDVBFrontendParametersTerrestrial::Modulation::QAM64: + case eDVBFrontendParametersTerrestrial::Modulation_QAM64: parm_u_ofdm_constellation = QAM_64; break; default: - case eDVBFrontendParametersTerrestrial::Modulation::Auto: + case eDVBFrontendParametersTerrestrial::Modulation_Auto: parm_u_ofdm_constellation = QAM_AUTO; break; } switch (feparm.transmission_mode) { - case eDVBFrontendParametersTerrestrial::TransmissionMode::TM2k: + case eDVBFrontendParametersTerrestrial::TransmissionMode_2k: parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_2K; break; - case eDVBFrontendParametersTerrestrial::TransmissionMode::TM8k: + case eDVBFrontendParametersTerrestrial::TransmissionMode_8k: parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_8K; break; default: - case eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto: + case eDVBFrontendParametersTerrestrial::TransmissionMode_Auto: parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_AUTO; break; } switch (feparm.guard_interval) { - case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_32: + case eDVBFrontendParametersTerrestrial::GuardInterval_1_32: parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_32; break; - case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_16: + case eDVBFrontendParametersTerrestrial::GuardInterval_1_16: parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_16; break; - case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_8: + case eDVBFrontendParametersTerrestrial::GuardInterval_1_8: parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_8; break; - case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_4: + case eDVBFrontendParametersTerrestrial::GuardInterval_1_4: parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_4; break; default: - case eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto: + case eDVBFrontendParametersTerrestrial::GuardInterval_Auto: parm_u_ofdm_guard_interval = GUARD_INTERVAL_AUTO; break; } switch (feparm.hierarchy) { - case eDVBFrontendParametersTerrestrial::Hierarchy::HNone: + case eDVBFrontendParametersTerrestrial::Hierarchy_None: parm_u_ofdm_hierarchy_information = HIERARCHY_NONE; break; - case eDVBFrontendParametersTerrestrial::Hierarchy::H1: + case eDVBFrontendParametersTerrestrial::Hierarchy_1: parm_u_ofdm_hierarchy_information = HIERARCHY_1; break; - case eDVBFrontendParametersTerrestrial::Hierarchy::H2: + case eDVBFrontendParametersTerrestrial::Hierarchy_2: parm_u_ofdm_hierarchy_information = HIERARCHY_2; break; - case eDVBFrontendParametersTerrestrial::Hierarchy::H4: + case eDVBFrontendParametersTerrestrial::Hierarchy_4: parm_u_ofdm_hierarchy_information = HIERARCHY_4; break; default: - case eDVBFrontendParametersTerrestrial::Hierarchy::HAuto: + case eDVBFrontendParametersTerrestrial::Hierarchy_Auto: parm_u_ofdm_hierarchy_information = HIERARCHY_AUTO; break; } switch (feparm.inversion) { - case eDVBFrontendParametersTerrestrial::Inversion::On: + case eDVBFrontendParametersTerrestrial::Inversion_On: parm_inversion = INVERSION_ON; break; - case eDVBFrontendParametersTerrestrial::Inversion::Off: + case eDVBFrontendParametersTerrestrial::Inversion_Off: parm_inversion = INVERSION_OFF; break; default: - case eDVBFrontendParametersTerrestrial::Inversion::Unknown: + case eDVBFrontendParametersTerrestrial::Inversion_Unknown: parm_inversion = INVERSION_AUTO; break; } @@ -2514,10 +2378,10 @@ int eDVBFrontend::isCompatibleWith(ePtr &feparm) eDVBFrontendParametersSatellite sat_parm; int ret = feparm->getDVBS(sat_parm); ASSERT(!ret); - if (sat_parm.system == eDVBFrontendParametersSatellite::System::DVB_S2 && !m_can_handle_dvbs2) + if (sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2 && !m_can_handle_dvbs2) return 0; ret = m_sec->canTune(sat_parm, this, 1 << m_slotid); - if (ret > 1 && sat_parm.system == eDVBFrontendParametersSatellite::System::DVB_S && m_can_handle_dvbs2) + if (ret > 1 && sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S && m_can_handle_dvbs2) ret -= 1; return ret; } diff --git a/lib/dvb/frontendparms.h b/lib/dvb/frontendparms.h index 961dfd00..b537963f 100644 --- a/lib/dvb/frontendparms.h +++ b/lib/dvb/frontendparms.h @@ -12,42 +12,35 @@ struct eDVBFrontendParametersSatellite #ifndef SWIG void set(const SatelliteDeliverySystemDescriptor &); #endif - struct Polarisation { - enum { - Horizontal, Vertical, CircularLeft, CircularRight - }; + enum { + Polarisation_Horizontal, Polarisation_Vertical, Polarisation_CircularLeft, Polarisation_CircularRight }; - struct Inversion { - enum { - Off, On, Unknown - }; + + enum { + Inversion_Off, Inversion_On, Inversion_Unknown }; - struct FEC { - enum { - fAuto, f1_2, f2_3, f3_4, f5_6, f7_8, f8_9, f3_5, f4_5, f9_10, fNone=15 - }; + + enum { + FEC_Auto, FEC_1_2, FEC_2_3, FEC_3_4, FEC_5_6, FEC_7_8, FEC_8_9, FEC_3_5, FEC_4_5, FEC_9_10, FEC_None=15 }; - struct System { - enum { - DVB_S, DVB_S2 - }; + + enum { + System_DVB_S, System_DVB_S2 }; - struct Modulation { - enum { - Auto, QPSK, M8PSK, QAM_16 - }; + + enum { + Modulation_Auto, Modulation_QPSK, Modulation_8PSK, Modulation_QAM16 }; + // dvb-s2 - struct RollOff { - enum { - alpha_0_35, alpha_0_25, alpha_0_20 - }; + enum { + RollOff_alpha_0_35, RollOff_alpha_0_25, RollOff_alpha_0_20 }; - struct Pilot { - enum { - Off, On, Unknown - }; + + enum { + Pilot_Off, Pilot_On, Pilot_Unknown }; + bool no_rotor_command_on_tune; unsigned int frequency, symbol_rate; int polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot; @@ -59,21 +52,18 @@ struct eDVBFrontendParametersCable #ifndef SWIG void set(const CableDeliverySystemDescriptor &); #endif - struct Inversion { - enum { - Off, On, Unknown - }; + enum { + Inversion_Off, Inversion_On, Inversion_Unknown }; - struct FEC { - enum { - fAuto, f1_2, f2_3, f3_4, f5_6, f7_8, f8_9, fNone=15 - }; + + enum { + FEC_Auto, FEC_1_2, FEC_2_3, FEC_3_4, FEC_5_6, FEC_7_8, FEC_8_9, FEC_None=15 }; - struct Modulation { - enum { - Auto, QAM16, QAM32, QAM64, QAM128, QAM256 - }; + + enum { + Modulation_Auto, Modulation_QAM16, Modulation_QAM32, Modulation_QAM64, Modulation_QAM128, Modulation_QAM256 }; + unsigned int frequency, symbol_rate; int modulation, inversion, fec_inner; }; @@ -84,42 +74,34 @@ struct eDVBFrontendParametersTerrestrial #ifndef SWIG void set(const TerrestrialDeliverySystemDescriptor &); #endif - struct Bandwidth { - enum { - Bw8MHz, Bw7MHz, Bw6MHz, /*Bw5MHz,*/ BwAuto - }; // Bw5Mhz nyi (compatibilty with enigma1) - }; - struct FEC { - enum { - f1_2, f2_3, f3_4, f5_6, f7_8, fAuto - }; - }; - struct TransmissionMode { - enum { - TM2k, TM8k, /*TM4k,*/ TMAuto - }; // TM4k nyi (compatibility with enigma1) + enum { + Bandwidth_8MHz, Bandwidth_7MHz, Bandwidth_6MHz, /*Bandwidth_5MHz,*/ Bandwidth_Auto + }; // Bw5Mhz nyi (compatibilty with enigma1) + + enum { + FEC_1_2, FEC_2_3, FEC_3_4, FEC_5_6, FEC_7_8, FEC_Auto }; - struct GuardInterval { - enum { - GI_1_32, GI_1_16, GI_1_8, GI_1_4, GI_Auto - }; + + enum { + TransmissionMode_2k, TransmissionMode_8k, /*TransmissionMode_4k,*/ TransmissionMode_Auto + }; // TM4k nyi (compatibility with enigma1) + + enum { + GuardInterval_1_32, GuardInterval_1_16, GuardInterval_1_8, GuardInterval_1_4, GuardInterval_Auto }; - struct Hierarchy { - enum { - HNone, H1, H2, H4, HAuto - }; + + enum { + Hierarchy_None, Hierarchy_1, Hierarchy_2, Hierarchy_4, Hierarchy_Auto }; - struct Modulation { - enum { - QPSK, QAM16, QAM64, Auto - }; + + enum { + Modulation_QPSK, Modulation_QAM16, Modulation_QAM64, Modulation_Auto }; - struct Inversion - { - enum { - Off, On, Unknown - }; + + enum { + Inversion_Off, Inversion_On, Inversion_Unknown }; + unsigned int frequency; int bandwidth; int code_rate_HP, code_rate_LP; diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp index 6f64cf56..ac1a2028 100644 --- a/lib/dvb/sec.cpp +++ b/lib/dvb/sec.cpp @@ -99,7 +99,7 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite if ( sat.frequency > lnb_param.m_lof_threshold ) band |= 1; - if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical)) + if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation_Vertical)) band |= 2; if (di_param.m_diseqc_mode >= eDVBSatelliteDiseqcParameters::V1_0) @@ -373,7 +373,7 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA if ( sat.frequency > lnb_param.m_lof_threshold ) band |= 1; - if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical)) + if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation_Vertical)) band |= 2; int lof = (band&1)?lnb_param.m_lof_hi:lnb_param.m_lof_lo; @@ -390,11 +390,11 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA frontend.setData(eDVBFrontend::FREQ_OFFSET, sat.frequency - parm.FREQUENCY); if ( voltage_mode == eDVBSatelliteSwitchParameters::_14V - || ( sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical + || ( sat.polarisation & eDVBFrontendParametersSatellite::Polarisation_Vertical && voltage_mode == eDVBSatelliteSwitchParameters::HV ) ) voltage = VOLTAGE(13); else if ( voltage_mode == eDVBSatelliteSwitchParameters::_18V - || ( !(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical) + || ( !(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation_Vertical) && voltage_mode == eDVBSatelliteSwitchParameters::HV ) ) voltage = VOLTAGE(18); if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::ON) @@ -936,12 +936,12 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA eDebugNoSimulate("found no useable satellite configuration for %s freq %d%s %s on orbital position (%d)", sat.system ? "DVB-S2" : "DVB-S", sat.frequency, - sat.polarisation == eDVBFrontendParametersSatellite::Polarisation::Horizontal ? "H" : - eDVBFrontendParametersSatellite::Polarisation::Vertical ? "V" : - eDVBFrontendParametersSatellite::Polarisation::CircularLeft ? "CL" : "CR", - sat.modulation == eDVBFrontendParametersSatellite::Modulation::Auto ? "AUTO" : - eDVBFrontendParametersSatellite::Modulation::QPSK ? "QPSK" : - eDVBFrontendParametersSatellite::Modulation::M8PSK ? "8PSK" : "QAM16", + sat.polarisation == eDVBFrontendParametersSatellite::Polarisation_Horizontal ? "H" : + eDVBFrontendParametersSatellite::Polarisation_Vertical ? "V" : + eDVBFrontendParametersSatellite::Polarisation_CircularLeft ? "CL" : "CR", + sat.modulation == eDVBFrontendParametersSatellite::Modulation_Auto ? "AUTO" : + eDVBFrontendParametersSatellite::Modulation_QPSK ? "QPSK" : + eDVBFrontendParametersSatellite::Modulation_8PSK ? "8PSK" : "QAM16", sat.orbital_position ); return -1; } diff --git a/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py b/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py index d3714440..69ef3774 100644 --- a/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py +++ b/lib/python/Plugins/SystemPlugins/PositionerSetup/plugin.py @@ -478,14 +478,14 @@ class TunerScreen(ScanSetup): self.list.append(self.systemEntry) else: # downgrade to dvb-s, in case a -s2 config was active - self.scan_sat.system.value = "dvb-s" + self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency)) self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion)) self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate)) self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization)) - if self.scan_sat.system.value == "dvb-s": + if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec)) - elif self.scan_sat.system.value == "dvb-s2": + elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2: self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2)) self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation) self.list.append(self.modulationEntry) @@ -570,31 +570,21 @@ class TunerScreen(ScanSetup): returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0) satpos = int(tuning.sat.value) if tuning.type.value == "manual_transponder": - if self.scan_sat.system.value == "dvb-s2": + if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2: fec = self.scan_sat.fec_s2.value else: fec = self.scan_sat.fec.value returnvalue = ( self.scan_sat.frequency.value, self.scan_sat.symbolrate.value, - self.scan_sat.polarization.index, - { "auto": 0, - "1_2": 1, - "2_3": 2, - "3_4": 3, - "5_6": 4, - "7_8": 5, - "8_9": 6, - "3_5": 7, - "4_5": 8, - "9_10": 9, - "none": 15 }[fec], - self.scan_sat.inversion.index, + self.scan_sat.polarization.value, + fec, + self.scan_sat.inversion.value, satpos, - self.scan_sat.system.index, - self.scan_sat.modulation.index == 1 and 2 or 1, - self.scan_sat.rolloff.index, - self.scan_sat.pilot.index) + self.scan_sat.system.value, + self.scan_sat.modulation.value, + self.scan_sat.rolloff.value, + self.scan_sat.pilot.value) elif tuning.type.value == "predefined_transponder": transponder = nimmanager.getTransponders(satpos)[tuning.transponder.index] returnvalue = (transponder[1] / 1000, transponder[2] / 1000, diff --git a/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py b/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py index 87dc81e4..8174eb64 100644 --- a/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py +++ b/lib/python/Plugins/SystemPlugins/Satfinder/plugin.py @@ -77,14 +77,14 @@ class Satfinder(ScanSetup): self.list.append(self.systemEntry) else: # downgrade to dvb-s, in case a -s2 config was active - self.scan_sat.system.value = "dvb-s" + self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency)) self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion)) self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate)) self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization)) - if self.scan_sat.system.value == "dvb-s": + if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec)) - elif self.scan_sat.system.value == "dvb-s2": + elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2: self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2)) self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation) self.list.append(self.modulationEntry) @@ -111,31 +111,21 @@ class Satfinder(ScanSetup): returnvalue = (0, 0, 0, 0, 0, 0, 0, 0, 0, 0) satpos = int(self.tuning_sat.value) if self.tuning_type.value == "manual_transponder": - if self.scan_sat.system.value == "dvb-s2": + if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2: fec = self.scan_sat.fec_s2.value else: fec = self.scan_sat.fec.value returnvalue = ( self.scan_sat.frequency.value, self.scan_sat.symbolrate.value, - self.scan_sat.polarization.index, - { "auto": 0, - "1_2": 1, - "2_3": 2, - "3_4": 3, - "5_6": 4, - "7_8": 5, - "8_9": 6, - "3_5": 7, - "4_5": 8, - "9_10": 9, - "none": 15 }[fec], - self.scan_sat.inversion.index, + self.scan_sat.polarization.value, + fec, + self.scan_sat.inversion.value, satpos, - self.scan_sat.system.index, - self.scan_sat.modulation.index == 1 and 2 or 1, - self.scan_sat.rolloff.index, - self.scan_sat.pilot.index) + self.scan_sat.system.value, + self.scan_sat.modulation.value, + self.scan_sat.rolloff.value, + self.scan_sat.pilot.value) self.tune(returnvalue) elif self.tuning_type.value == "predefined_transponder": tps = nimmanager.getTransponders(satpos) diff --git a/lib/python/Screens/ScanSetup.py b/lib/python/Screens/ScanSetup.py index f32904a1..7089074a 100644 --- a/lib/python/Screens/ScanSetup.py +++ b/lib/python/Screens/ScanSetup.py @@ -17,64 +17,17 @@ def buildTerTransponder(frequency, inversion=2, bandwidth = 3, fechigh = 6, feclow = 6, modulation = 2, transmission = 2, guard = 4, hierarchy = 4): - # print "freq", frequency, "inv", inversion, "bw", bandwidth, "fech", fechigh, "fecl", feclow, "mod", modulation, "tm", transmission, "guard", guard, "hierarchy", hierarchy - - # WARNING: normally, enums are working directly. - # Don't copy this (very bad)!! Instead either fix swig (good) or - # move this into a central place. - Bw8MHz = 0 - Bw7MHz = 1 - Bw6MHz = 2 - #Bw5MHz = 3 #not implemented for e1 compatibilty - BwAuto = 3 - - f1_2 = 0 - f2_3 = 1 - f3_4 = 2 - f5_6 = 3 - f7_8 = 4 - fAuto = 5 - - TM2k = 0 - TM8k = 1 - #TM4k = 2 #not implemented for e1 compatibilty - TMAuto = 2 - - GI_1_32 = 0 - GI_1_16 = 1 - GI_1_8 = 2 - GI_1_4 = 3 - GI_Auto = 4 - - HNone = 0 - H1 = 1 - H2 = 2 - H4 = 3 - HAuto = 4 - - QPSK = 0 - QAM16 = 1 - QAM64 = 2 - Auto = 3 - - Off = 0 - On = 1 - Unknown = 2 - parm = eDVBFrontendParametersTerrestrial() - parm.frequency = frequency - - parm.inversion = [Off, On, Unknown][inversion] - parm.bandwidth = [Bw8MHz, Bw7MHz, Bw6MHz, BwAuto][bandwidth] # Bw5MHz unsupported - parm.code_rate_HP = [f1_2, f2_3, f3_4, f5_6, f7_8, fAuto][fechigh] - parm.code_rate_LP = [f1_2, f2_3, f3_4, f5_6, f7_8, fAuto][feclow] - parm.modulation = [QPSK, QAM16, QAM64, Auto][modulation] - parm.transmission_mode = [TM2k, TM8k, TMAuto][transmission] # TM4k unsupported - parm.guard_interval = [GI_1_32, GI_1_16, GI_1_8, GI_1_4, GI_Auto][guard] - parm.hierarchy = [HNone, H1, H2, H4, HAuto][hierarchy] - + parm.inversion = inversion + parm.bandwidth = bandwidth + parm.code_rate_HP = fechigh + parm.code_rate_LP = feclow + parm.modulation = modulation + parm.transmission_mode = transmission + parm.guard_interval = guard + parm.hierarchy = hierarchy return parm def getInitialTransponderList(tlist, pos): @@ -103,7 +56,7 @@ def getInitialCableTransponderList(tlist, nim): parm.symbol_rate = x[2] parm.modulation = x[3] parm.fec_inner = x[4] - parm.inversion = 2 # AUTO + parm.inversion = parm.Inversion_Unknown #print "frequency:", x[1] #print "symbol_rate:", x[2] #print "modulation:", x[3] @@ -178,10 +131,22 @@ class CableTransponderSearchSupport: if len(data): if data[0] == 'OK': print str - qam = { "QAM16" : 1, "QAM32" : 2, "QAM64" : 3, "QAM128" : 4, "QAM256" : 5 } - inv = { "INVERSION_OFF" : 0, "INVERSION_ON" : 1 } - fec = { "FEC_AUTO" : 0, "FEC_1_2" : 1, "FEC_2_3" : 2, "FEC_3_4" : 3, "FEC_5_6": 4, "FEC_7_8" : 5, "FEC_8_9" : 6, "FEC_NONE" : 15 } parm = eDVBFrontendParametersCable() + qam = { "QAM16" : parm.Modulation_QAM16, + "QAM32" : parm.Modulation_QAM32, + "QAM64" : parm.Modulation_QAM64, + "QAM128" : parm.Modulation_QAM128, + "QAM256" : parm.Modulation_QAM256 } + inv = { "INVERSION_OFF" : parm.Inversion_Off, + "INVERSION_ON" : parm.Inversion_On } + fec = { "FEC_AUTO" : parm.FEC_Auto, + "FEC_1_2" : parm.FEC_1_2, + "FEC_2_3" : parm.FEC_2_3, + "FEC_3_4" : parm.FEC_3_4, + "FEC_5_6": parm.FEC_5_6, + "FEC_7_8" : parm.FEC_7_8, + "FEC_8_9" : parm.FEC_8_9, + "FEC_NONE" : parm.FEC_None } parm.frequency = int(data[1]) parm.symbol_rate = int(data[2]) parm.fec_inner = fec[data[3]] @@ -381,15 +346,15 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): self.list.append(self.systemEntry) else: # downgrade to dvb-s, in case a -s2 config was active - self.scan_sat.system.value = "dvb-s" + self.scan_sat.system.value = eDVBFrontendParametersSatellite.System_DVB_S self.list.append(getConfigListEntry(_('Satellite'), self.scan_satselection[index_to_scan])) self.list.append(getConfigListEntry(_('Frequency'), self.scan_sat.frequency)) self.list.append(getConfigListEntry(_('Inversion'), self.scan_sat.inversion)) self.list.append(getConfigListEntry(_('Symbol Rate'), self.scan_sat.symbolrate)) self.list.append(getConfigListEntry(_("Polarity"), self.scan_sat.polarization)) - if self.scan_sat.system.value == "dvb-s": + if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec)) - elif self.scan_sat.system.value == "dvb-s2": + elif self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S2: self.list.append(getConfigListEntry(_("FEC"), self.scan_sat.fec_s2)) self.modulationEntry = getConfigListEntry(_('Modulation'), self.scan_sat.modulation) self.list.append(self.modulationEntry) @@ -447,7 +412,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): if cur == self.typeOfScanEntry or \ cur == self.tunerEntry or \ cur == self.systemEntry or \ - (self.modulationEntry and self.systemEntry[1].value == "dvb-s2" and cur == self.modulationEntry): + (self.modulationEntry and self.systemEntry[1].value == eDVBFrontendParametersSatellite.System_DVB_S2 and cur == self.modulationEntry): self.createSetup() def createConfig(self, frontendData): @@ -481,34 +446,65 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): #("Transmission Mode", frontendData["transmission_mode"], TYPE_TEXT), #("Guard Interval", frontendData["guard_interval"], TYPE_TEXT), #("Hierarchy Inform.", frontendData["hierarchy_information"], TYPE_TEXT), - defaultSat = { "orbpos": 192, "system": "dvb-s", "frequency": 11836, "inversion": "auto", "symbolrate": 27500, "polarization": "horizontal", "fec": "auto", "fec_s2": "9_10", "modulation": "qpsk" } - defaultCab = {"frequency": 466, "inversion": "auto", "modulation": "64qam", "fec": "auto", "symbolrate": 6900} + defaultSat = { + "orbpos": 192, + "system": eDVBFrontendParametersSatellite.System_DVB_S, + "frequency": 11836, + "inversion": eDVBFrontendParametersSatellite.Inversion_Unknown, + "symbolrate": 27500, + "polarization": eDVBFrontendParametersSatellite.Polarisation_Horizontal, + "fec": eDVBFrontendParametersSatellite.FEC_Auto, + "fec_s2": eDVBFrontendParametersSatellite.FEC_9_10, + "modulation": eDVBFrontendParametersSatellite.Modulation_QPSK } + defaultCab = { + "frequency": 466, + "inversion": eDVBFrontendParametersCable.Inversion_Unknown, + "modulation": eDVBFrontendParametersCable.Modulation_QAM64, + "fec": eDVBFrontendParametersCable.FEC_Auto, + "symbolrate": 6900 } + defaultTer = { + "frequency" : 466000, + "inversion" : eDVBFrontendParametersTerrestrial.Inversion_Unknown, + "bandwidth" : eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, + "fechigh" : eDVBFrontendParametersTerrestrial.FEC_Auto, + "feclow" : eDVBFrontendParametersTerrestrial.FEC_Auto, + "modulation" : eDVBFrontendParametersTerrestrial.Modulation_Auto, + "transmission_mode" : eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, + "guard_interval" : eDVBFrontendParametersTerrestrial.GuardInterval_Auto, + "hierarchy": eDVBFrontendParametersTerrestrial.Hierarchy_Auto } + if frontendData is not None: ttype = frontendData.get("tuner_type", "UNKNOWN") if ttype == "DVB-S": - defaultSat["system"] = {"DVB-S": "dvb-s", "DVB-S2": "dvb-s2"}[frontendData.get("system", "DVB-S")] + defaultSat["system"] = frontendData.get("system", eDVBFrontendParametersSatellite.System_DVB_S) defaultSat["frequency"] = frontendData.get("frequency", 0) / 1000 - defaultSat["inversion"] = {"INVERSION_OFF": "off", "INVERSION_ON": "on", "INVERSION_AUTO": "auto"}[frontendData.get("inversion", "INVERSION_AUTO")] + defaultSat["inversion"] = frontendData.get("inversion", eDVBFrontendParametersSatellite.Inversion_Unknown) defaultSat["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000 - defaultSat["polarization"] = {"HORIZONTAL": "horizontal", "VERTICAL": "vertical", "CIRCULAR_LEFT": "circular_left", "CIRCULAR_RIGHT": "circular_right", "UNKNOWN": None}[frontendData.get("polarization", "HORIZONTAL")] - - if frontendData.get("system", "DVB-S") == "DVB-S2": - defaultSat["fec_s2"] = {"FEC_1_2": "1_2", "FEC_2_3": "2_3", "FEC_3_4": "3_4", "FEC_4_5": "4_5", "FEC_5_6": "5_6", "FEC_7_8": "7_8", "FEC_8_9": "8_9", "FEC_9_10": "9_10"} \ - [frontendData.get("fec_inner", "FEC_AUTO")] - defaultSat["rolloff"] = {"ROLLOFF_0_35" : "0_35", "ROLLOFF_0_25" : "0_25", "ROLLOFF_0_20" : "0_20"}[frontendData.get("rolloff", "ROLLOFF_0_35")] - defaultSat["pilot"] = {"PILOT_ON" : "on", "PILOT_OFF" : "off", "PILOT_AUTO" : "auto"}[frontendData.get("pilot", "PILOT_AUTO")] + defaultSat["polarization"] = frontendData.get("polarization", eDVBFrontendParametersSatellite.Polarisation_Horizontal) + if defaultSat["system"] == eDVBFrontendParametersSatellite.System_DVB_S2: + defaultSat["fec_s2"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto) + defaultSat["rolloff"] = frontendData.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35) + defaultSat["pilot"] = frontendData.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown) else: - defaultSat["fec"] = {"FEC_AUTO": "auto", "FEC_1_2": "1_2", "FEC_2_3": "2_3", "FEC_3_4": "3_4", "FEC_5_6": "5_6", "FEC_7_8": "7_8", "FEC_NONE": "none"} \ - [frontendData.get("fec_inner", "FEC_AUTO")] - - defaultSat["modulation"] = {"QPSK": "qpsk", "8PSK": "8psk"}[frontendData.get("modulation", "QPSK")] + defaultSat["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersSatellite.FEC_Auto) + defaultSat["modulation"] = frontendData.get("modulation", eDVBFrontendParametersSatellite.Modulation_QPSK) defaultSat["orbpos"] = frontendData.get("orbital_position", 0) elif ttype == "DVB-C": defaultCab["frequency"] = frontendData.get("frequency", 0) / 1000 defaultCab["symbolrate"] = frontendData.get("symbol_rate", 0) / 1000 - defaultCab["inversion"] = {"INVERSION_OFF": "off", "INVERSION_ON": "on", "INVERSION_AUTO": "auto"}[frontendData.get("inversion", "INVERSION_AUTO")] - defaultCab["fec"] = {"FEC_AUTO": "auto", "FEC_1_2": "1_2", "FEC_2_3": "2_3", "FEC_3_4": "3_4", "FEC_5_6": "5_6", "FEC_7_8": "7_8", "FEC_8_9": "8_9", "FEC_NONE": "none"}[frontendData.get("fec_inner", "FEC_AUTO")] - defaultCab["modulation"] = {"QAM_AUTO": "auto", "QAM_16": "16qam", "QAM_32": "32qam", "QAM_64": "64qam", "QAM_128": "128qam", "QAM_256": "256qam"}[frontendData.get("modulation", "QAM_16")] + defaultCab["inversion"] = frontendData.get("inversion", eDVBFrontendParametersCable.Inversion_Unknown) + defaultCab["fec"] = frontendData.get("fec_inner", eDVBFrontendParametersCable.FEC_Auto) + defaultCab["modulation"] = frontendData.get("modulation", eDVBFrontendParametersCable.Modulation_QAM16) + elif ttype == "DVB-T": + defaultTer["frequency"] = frontendData.get("frequency", 0) + defaultTer["inversion"] = frontendData.get("inversion", eDVBFrontendParametersTerrestrial.Inversion_Unknown) + defaultTer["bandwidth"] = frontendData.get("bandwidth", eDVBFrontendParametersTerrestrial.Bandwidth_7MHz) + defaultTer["fechigh"] = frontendData.get("code_rate_hp", eDVBFrontendParametersTerrestrial.FEC_Auto) + defaultTer["feclow"] = frontendData.get("code_rate_lp", eDVBFrontendParametersTerrestrial.FEC_Auto) + defaultTer["modulation"] = frontendData.get("constellation", eDVBFrontendParametersTerrestrial.Modulation_Auto) + defaultTer["transmission_mode"] = frontendData.get("transmission_mode", eDVBFrontendParametersTerrestrial.TransmissionMode_Auto) + defaultTer["guard_interval"] = frontendData.get("guard_interval", eDVBFrontendParametersTerrestrial.GuardInterval_Auto) + defaultTer["hierarchy"] = frontendData.get("hierarchy_information", eDVBFrontendParametersTerrestrial.Hierarchy_Auto) self.scan_sat = ConfigSubsection() self.scan_cab = ConfigSubsection() @@ -538,36 +534,120 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): self.scan_ber.enabled = False # sat - self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [("dvb-s", _("DVB-S")), ("dvb-s2", _("DVB-S2"))]) + self.scan_sat.system = ConfigSelection(default = defaultSat["system"], choices = [ + (eDVBFrontendParametersSatellite.System_DVB_S, _("DVB-S")), + (eDVBFrontendParametersSatellite.System_DVB_S2, _("DVB-S2"))]) self.scan_sat.frequency = ConfigInteger(default = defaultSat["frequency"], limits = (1, 99999)) - self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))]) + self.scan_sat.inversion = ConfigSelection(default = defaultSat["inversion"], choices = [ + (eDVBFrontendParametersSatellite.Inversion_Off, _("off")), + (eDVBFrontendParametersSatellite.Inversion_On, _("on")), + (eDVBFrontendParametersSatellite.Inversion_Unknown, _("Auto"))]) self.scan_sat.symbolrate = ConfigInteger(default = defaultSat["symbolrate"], limits = (1, 99999)) - self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [("horizontal", _("horizontal")), ("vertical", _("vertical")), ("circular_left", _("circular left")), ("circular_right", _("circular right"))]) - self.scan_sat.fec = ConfigSelection(default = defaultSat["fec"], choices = [("auto", _("Auto")), ("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("none", _("None"))]) - self.scan_sat.fec_s2 = ConfigSelection(default = defaultSat["fec_s2"], choices = [("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("3_5", "3/5"), ("4_5", "4/5"), ("5_6", "5/6"), ("7_8", "7/8"), ("8_9", "8/9"), ("9_10", "9/10")]) - self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [("qpsk", "QPSK"), ("8psk", "8PSK")]) - self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", "0_35"), choices = [("0_35", "0.35"), ("0_25", "0.25"), ("0_20", "0.20")]) - self.scan_sat.pilot = ConfigSelection(default = defaultSat.get("pilot", "auto"), choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))]) + self.scan_sat.polarization = ConfigSelection(default = defaultSat["polarization"], choices = [ + (eDVBFrontendParametersSatellite.Polarisation_Horizontal, _("horizontal")), + (eDVBFrontendParametersSatellite.Polarisation_Vertical, _("vertical")), + (eDVBFrontendParametersSatellite.Polarisation_CircularLeft, _("circular left")), + (eDVBFrontendParametersSatellite.Polarisation_CircularRight, _("circular right"))]) + self.scan_sat.fec = ConfigSelection(default = defaultSat["fec"], choices = [ + (eDVBFrontendParametersSatellite.FEC_Auto, _("Auto")), + (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"), + (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"), + (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"), + (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"), + (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"), + (eDVBFrontendParametersSatellite.FEC_None, _("None"))]) + self.scan_sat.fec_s2 = ConfigSelection(default = defaultSat["fec_s2"], choices = [ + (eDVBFrontendParametersSatellite.FEC_1_2, "1/2"), + (eDVBFrontendParametersSatellite.FEC_2_3, "2/3"), + (eDVBFrontendParametersSatellite.FEC_3_4, "3/4"), + (eDVBFrontendParametersSatellite.FEC_3_5, "3/5"), + (eDVBFrontendParametersSatellite.FEC_4_5, "4/5"), + (eDVBFrontendParametersSatellite.FEC_5_6, "5/6"), + (eDVBFrontendParametersSatellite.FEC_7_8, "7/8"), + (eDVBFrontendParametersSatellite.FEC_8_9, "8/9"), + (eDVBFrontendParametersSatellite.FEC_9_10, "9/10")]) + self.scan_sat.modulation = ConfigSelection(default = defaultSat["modulation"], choices = [ + (eDVBFrontendParametersSatellite.Modulation_QPSK, "QPSK"), + (eDVBFrontendParametersSatellite.Modulation_8PSK, "8PSK")]) + self.scan_sat.rolloff = ConfigSelection(default = defaultSat.get("rolloff", eDVBFrontendParametersSatellite.RollOff_alpha_0_35), choices = [ + (eDVBFrontendParametersSatellite.RollOff_alpha_0_35, "0.35"), + (eDVBFrontendParametersSatellite.RollOff_alpha_0_25, "0.25"), + (eDVBFrontendParametersSatellite.RollOff_alpha_0_20, "0.20")]) + self.scan_sat.pilot = ConfigSelection(default = defaultSat.get("pilot", eDVBFrontendParametersSatellite.Pilot_Unknown), choices = [ + (eDVBFrontendParametersSatellite.Pilot_Off, _("off")), + (eDVBFrontendParametersSatellite.Pilot_On, _("on")), + (eDVBFrontendParametersSatellite.Pilot_Unknown, _("Auto"))]) # cable self.scan_cab.frequency = ConfigInteger(default = defaultCab["frequency"], limits = (50, 999)) - self.scan_cab.inversion = ConfigSelection(default = defaultCab["inversion"], choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))]) - self.scan_cab.modulation = ConfigSelection(default = defaultCab["modulation"], choices = [("16qam", "16-QAM"), ("32qam", "32-QAM"), ("64qam", "64-QAM"), ("128qam", "128-QAM"), ("256qam", "256-QAM")]) - self.scan_cab.fec = ConfigSelection(default = defaultCab["fec"], choices = [("auto", _("Auto")), ("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("8_9", "8/9"), ("none", _("None"))]) + self.scan_cab.inversion = ConfigSelection(default = defaultCab["inversion"], choices = [ + (eDVBFrontendParametersCable.Inversion_Off, _("off")), + (eDVBFrontendParametersCable.Inversion_On, _("on")), + (eDVBFrontendParametersCable.Inversion_Unknown, _("Auto"))]) + self.scan_cab.modulation = ConfigSelection(default = defaultCab["modulation"], choices = [ + (eDVBFrontendParametersCable.Modulation_QAM16, "16-QAM"), + (eDVBFrontendParametersCable.Modulation_QAM32, "32-QAM"), + (eDVBFrontendParametersCable.Modulation_QAM64, "64-QAM"), + (eDVBFrontendParametersCable.Modulation_QAM128, "128-QAM"), + (eDVBFrontendParametersCable.Modulation_QAM256, "256-QAM")]) + self.scan_cab.fec = ConfigSelection(default = defaultCab["fec"], choices = [ + (eDVBFrontendParametersCable.FEC_Auto, _("Auto")), + (eDVBFrontendParametersCable.FEC_1_2, "1/2"), + (eDVBFrontendParametersCable.FEC_2_3, "2/3"), + (eDVBFrontendParametersCable.FEC_3_4, "3/4"), + (eDVBFrontendParametersCable.FEC_5_6, "5/6"), + (eDVBFrontendParametersCable.FEC_7_8, "7/8"), + (eDVBFrontendParametersCable.FEC_8_9, "8/9"), + (eDVBFrontendParametersCable.FEC_None, _("None"))]) self.scan_cab.symbolrate = ConfigInteger(default = defaultCab["symbolrate"], limits = (1, 99999)) # terrestial self.scan_ter.frequency = ConfigInteger(default = 466000, limits = (50000, 999000)) - self.scan_ter.inversion = ConfigSelection(default = "auto", choices = [("off", _("off")), ("on", _("on")), ("auto", _("Auto"))]) + self.scan_ter.inversion = ConfigSelection(default = defaultTer["inversion"], choices = [ + (eDVBFrontendParametersTerrestrial.Inversion_Off, _("off")), + (eDVBFrontendParametersTerrestrial.Inversion_On, _("on")), + (eDVBFrontendParametersTerrestrial.Inversion_Unknown, _("Auto"))]) # WORKAROUND: we can't use BW-auto - self.scan_ter.bandwidth = ConfigSelection(default = "8MHz", choices = [("8MHz", "8MHz"), ("7MHz", "7MHz"), ("6MHz", "6MHz")]) - #, ("auto", _("Auto")))) - self.scan_ter.fechigh = ConfigSelection(default = "auto", choices = [("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("auto", _("Auto"))]) - self.scan_ter.feclow = ConfigSelection(default = "auto", choices = [("1_2", "1/2"), ("2_3", "2/3"), ("3_4", "3/4"), ("5_6", "5/6"), ("7_8", "7/8"), ("auto", _("Auto"))]) - self.scan_ter.modulation = ConfigSelection(default = "auto", choices = [("qpsk", "QPSK"), ("qam16", "QAM16"), ("qam64", "QAM64"), ("auto", _("Auto"))]) - self.scan_ter.transmission = ConfigSelection(default = "auto", choices = [("2k", "2K"), ("8k", "8K"), ("auto", _("Auto"))]) - self.scan_ter.guard = ConfigSelection(default = "auto", choices = [("1_32", "1/32"), ("1_16", "1/16"), ("1_8", "1/8"), ("1_4", "1/4"), ("auto", _("Auto"))]) - self.scan_ter.hierarchy = ConfigSelection(default = "auto", choices = [("none", _("None")), ("1", "1"), ("2", "2"), ("4", "4"), ("auto", _("Auto"))]) + self.scan_ter.bandwidth = ConfigSelection(default = defaultTer["bandwidth"], choices = [ + (eDVBFrontendParametersTerrestrial.Bandwidth_8MHz, "8MHz"), + (eDVBFrontendParametersTerrestrial.Bandwidth_7MHz, "7MHz"), + (eDVBFrontendParametersTerrestrial.Bandwidth_6MHz, "6MHz")]) + #, (eDVBFrontendParametersTerrestrial.Bandwidth_Auto, _("Auto")))) + self.scan_ter.fechigh = ConfigSelection(default = defaultTer["fechigh"], choices = [ + (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"), + (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"), + (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"), + (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"), + (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"), + (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))]) + self.scan_ter.feclow = ConfigSelection(default = defaultTer["feclow"], choices = [ + (eDVBFrontendParametersTerrestrial.FEC_1_2, "1/2"), + (eDVBFrontendParametersTerrestrial.FEC_2_3, "2/3"), + (eDVBFrontendParametersTerrestrial.FEC_3_4, "3/4"), + (eDVBFrontendParametersTerrestrial.FEC_5_6, "5/6"), + (eDVBFrontendParametersTerrestrial.FEC_7_8, "7/8"), + (eDVBFrontendParametersTerrestrial.FEC_Auto, _("Auto"))]) + self.scan_ter.modulation = ConfigSelection(default = defaultTer["modulation"], choices = [ + (eDVBFrontendParametersTerrestrial.Modulation_QPSK, "QPSK"), + (eDVBFrontendParametersTerrestrial.Modulation_QAM16, "QAM16"), + (eDVBFrontendParametersTerrestrial.Modulation_QAM64, "QAM64"), + (eDVBFrontendParametersTerrestrial.Modulation_Auto, _("Auto"))]) + self.scan_ter.transmission = ConfigSelection(default = defaultTer["transmission_mode"], choices = [ + (eDVBFrontendParametersTerrestrial.TransmissionMode_2k, "2K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_8k, "8K"), + (eDVBFrontendParametersTerrestrial.TransmissionMode_Auto, _("Auto"))]) + self.scan_ter.guard = ConfigSelection(default = defaultTer["guard_interval"], choices = [ + (eDVBFrontendParametersTerrestrial.GuardInterval_1_32, "1/32"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_16, "1/16"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_8, "1/8"), + (eDVBFrontendParametersTerrestrial.GuardInterval_1_4, "1/4"), + (eDVBFrontendParametersTerrestrial.GuardInterval_Auto, _("Auto"))]) + self.scan_ter.hierarchy = ConfigSelection(default = defaultTer["hierarchy"], choices = [ + (eDVBFrontendParametersTerrestrial.Hierarchy_None, _("None")), + (eDVBFrontendParametersTerrestrial.Hierarchy_1, "1"), + (eDVBFrontendParametersTerrestrial.Hierarchy_2, "2"), + (eDVBFrontendParametersTerrestrial.Hierarchy_4, "4"), + (eDVBFrontendParametersTerrestrial.Hierarchy_Auto, _("Auto"))]) self.scan_scansat = {} for sat in nimmanager.satList: @@ -594,32 +674,16 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): def updateStatus(self): print "updatestatus" - fecmap = { "auto": 0, - "1_2": 1, - "2_3": 2, - "3_4": 3, - "5_6": 4, - "7_8": 5, - "8_9": 6, - "3_5": 7, - "4_5": 8, - "9_10": 9, - "none": 15 - } - def addSatTransponder(self, tlist, frequency, symbol_rate, polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot): - print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(self.fecmap[fec]) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot) + print "Add Sat: frequ: " + str(frequency) + " symbol: " + str(symbol_rate) + " pol: " + str(polarisation) + " fec: " + str(fec) + " inversion: " + str(inversion) + " modulation: " + str(modulation) + " system: " + str(system) + " rolloff" + str(rolloff) + " pilot" + str(pilot) print "orbpos: " + str(orbital_position) parm = eDVBFrontendParametersSatellite() - if modulation == 1: - parm.modulation = 2 # eDVBFrontendParametersSatellite.Modulation.8PSK - else: - parm.modulation = 1 # eDVBFrontendParametersSatellite.Modulation.QPSK + parm.modulation = modulation parm.system = system parm.frequency = frequency * 1000 parm.symbol_rate = symbol_rate * 1000 parm.polarisation = polarisation - parm.fec = self.fecmap[fec] + parm.fec = fec parm.inversion = inversion parm.orbital_position = orbital_position parm.rolloff = rolloff @@ -632,7 +696,7 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): parm.frequency = frequency * 1000 parm.symbol_rate = symbol_rate * 1000 parm.modulation = modulation - parm.fec = self.fecmap[fec] + parm.fec = fec parm.inversion = inversion tlist.append(parm) @@ -665,21 +729,21 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): # however, the satList itself could be empty. in that case, "index" is 0 (for "None"). if len(nimsats): orbpos = nimsats[selsatidx][0] - if self.scan_sat.system.value == "dvb-s": + if self.scan_sat.system.value == eDVBFrontendParametersSatellite.System_DVB_S: fec = self.scan_sat.fec.value else: fec = self.scan_sat.fec_s2.value print "add sat transponder" self.addSatTransponder(tlist, self.scan_sat.frequency.value, self.scan_sat.symbolrate.value, - self.scan_sat.polarization.index, + self.scan_sat.polarization.value, fec, - self.scan_sat.inversion.index, + self.scan_sat.inversion.value, orbpos, - self.scan_sat.system.index, - self.scan_sat.modulation.index, - self.scan_sat.rolloff.index, - self.scan_sat.pilot.index) + self.scan_sat.system.value, + self.scan_sat.modulation.value, + self.scan_sat.rolloff.value, + self.scan_sat.pilot.value) removeAll = False elif self.scan_type.value == "single_satellite": sat = self.satList[index_to_scan][self.scan_satselection[index_to_scan].index] @@ -693,12 +757,11 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): elif nim.isCompatible("DVB-C"): if self.scan_typecable.value == "single_transponder": - fec = self.scan_cab.fec.value self.addCabTransponder(tlist, self.scan_cab.frequency.value, self.scan_cab.symbolrate.value, - self.scan_cab.modulation.index + 1, - fec, - self.scan_cab.inversion.index) + self.scan_cab.modulation.value, + self.scan_cab.fec.value, + self.scan_cab.inversion.value) removeAll = False elif self.scan_typecable.value == "complete": if config.Nims[index_to_scan].cable.scan_type.value == "provider": @@ -710,14 +773,14 @@ class ScanSetup(ConfigListScreen, Screen, CableTransponderSearchSupport): if self.scan_typeterrestrial.value == "single_transponder": self.addTerTransponder(tlist, self.scan_ter.frequency.value * 1000, - inversion = self.scan_ter.inversion.index, - bandwidth = self.scan_ter.bandwidth.index, - fechigh = self.scan_ter.fechigh.index, - feclow = self.scan_ter.feclow.index, - modulation = self.scan_ter.modulation.index, - transmission = self.scan_ter.transmission.index, - guard = self.scan_ter.guard.index, - hierarchy = self.scan_ter.hierarchy.index) + inversion = self.scan_ter.inversion.value, + bandwidth = self.scan_ter.bandwidth.value, + fechigh = self.scan_ter.fechigh.value, + feclow = self.scan_ter.feclow.value, + modulation = self.scan_ter.modulation.value, + transmission = self.scan_ter.transmission.value, + guard = self.scan_ter.guard.value, + hierarchy = self.scan_ter.hierarchy.value) removeAll = False elif self.scan_typeterrestrial.value == "complete": getInitialTerrestrialTransponderList(tlist, nimmanager.getTerrestrialDescription(index_to_scan)) diff --git a/lib/service/servicedvb.cpp b/lib/service/servicedvb.cpp index dcd7017c..bcf005e4 100644 --- a/lib/service/servicedvb.cpp +++ b/lib/service/servicedvb.cpp @@ -122,64 +122,64 @@ void PutSatelliteDataToDict(ePyObject &dict, eDVBFrontendParametersSatellite &fe PutToDictAsStr(dict, "orbital position", feparm.orbital_position); switch (feparm.inversion) { - case eDVBFrontendParametersSatellite::Inversion::On: tmp="ON"; break; - case eDVBFrontendParametersSatellite::Inversion::Off: tmp="OFF"; break; + case eDVBFrontendParametersSatellite::Inversion_On: tmp="ON"; break; + case eDVBFrontendParametersSatellite::Inversion_Off: tmp="OFF"; break; default: - case eDVBFrontendParametersSatellite::Inversion::Unknown: tmp="AUTO"; break; + case eDVBFrontendParametersSatellite::Inversion_Unknown: tmp="AUTO"; break; } PutToDict(dict, "inversion", tmp); switch (feparm.fec) { - case eDVBFrontendParametersSatellite::FEC::fNone: tmp="NONE"; break; - case eDVBFrontendParametersSatellite::FEC::f1_2: tmp="1/2"; break; - case eDVBFrontendParametersSatellite::FEC::f2_3: tmp="2/3"; break; - case eDVBFrontendParametersSatellite::FEC::f3_4: tmp="3/4"; break; - case eDVBFrontendParametersSatellite::FEC::f5_6: tmp="5/6"; break; - case eDVBFrontendParametersSatellite::FEC::f7_8: tmp="7/8"; break; - case eDVBFrontendParametersSatellite::FEC::f3_5: tmp="3/5"; break; - case eDVBFrontendParametersSatellite::FEC::f4_5: tmp="4/5"; break; - case eDVBFrontendParametersSatellite::FEC::f8_9: tmp="8/9"; break; - case eDVBFrontendParametersSatellite::FEC::f9_10: tmp="9/10"; break; + case eDVBFrontendParametersSatellite::FEC_None: tmp="NONE"; break; + case eDVBFrontendParametersSatellite::FEC_1_2: tmp="1/2"; break; + case eDVBFrontendParametersSatellite::FEC_2_3: tmp="2/3"; break; + case eDVBFrontendParametersSatellite::FEC_3_4: tmp="3/4"; break; + case eDVBFrontendParametersSatellite::FEC_5_6: tmp="5/6"; break; + case eDVBFrontendParametersSatellite::FEC_7_8: tmp="7/8"; break; + case eDVBFrontendParametersSatellite::FEC_3_5: tmp="3/5"; break; + case eDVBFrontendParametersSatellite::FEC_4_5: tmp="4/5"; break; + case eDVBFrontendParametersSatellite::FEC_8_9: tmp="8/9"; break; + case eDVBFrontendParametersSatellite::FEC_9_10: tmp="9/10"; break; default: - case eDVBFrontendParametersSatellite::FEC::fAuto: tmp="AUTO"; break; + case eDVBFrontendParametersSatellite::FEC_Auto: tmp="AUTO"; break; } PutToDict(dict, "fec inner", tmp); switch (feparm.modulation) { - case eDVBFrontendParametersSatellite::Modulation::Auto: tmp="AUTO"; break; - case eDVBFrontendParametersSatellite::Modulation::QPSK: tmp="QPSK"; break; - case eDVBFrontendParametersSatellite::Modulation::M8PSK: tmp="8PSK"; break; - case eDVBFrontendParametersSatellite::Modulation::QAM_16: tmp="QAM16"; break; + case eDVBFrontendParametersSatellite::Modulation_Auto: tmp="AUTO"; break; + case eDVBFrontendParametersSatellite::Modulation_QPSK: tmp="QPSK"; break; + case eDVBFrontendParametersSatellite::Modulation_8PSK: tmp="8PSK"; break; + case eDVBFrontendParametersSatellite::Modulation_QAM16: tmp="QAM16"; break; } PutToDict(dict, "modulation", tmp); switch(feparm.polarisation) { - case eDVBFrontendParametersSatellite::Polarisation::Horizontal: tmp="HORIZONTAL"; break; - case eDVBFrontendParametersSatellite::Polarisation::Vertical: tmp="VERTICAL"; break; - case eDVBFrontendParametersSatellite::Polarisation::CircularLeft: tmp="CIRCULAR LEFT"; break; + case eDVBFrontendParametersSatellite::Polarisation_Horizontal: tmp="HORIZONTAL"; break; + case eDVBFrontendParametersSatellite::Polarisation_Vertical: tmp="VERTICAL"; break; + case eDVBFrontendParametersSatellite::Polarisation_CircularLeft: tmp="CIRCULAR LEFT"; break; default: - case eDVBFrontendParametersSatellite::Polarisation::CircularRight: tmp="CIRCULAR RIGHT"; break; + case eDVBFrontendParametersSatellite::Polarisation_CircularRight: tmp="CIRCULAR RIGHT"; break; } PutToDict(dict, "polarization", tmp); switch(feparm.system) { default: - case eDVBFrontendParametersSatellite::System::DVB_S: tmp="DVB-S"; break; - case eDVBFrontendParametersSatellite::System::DVB_S2: + case eDVBFrontendParametersSatellite::System_DVB_S: tmp="DVB-S"; break; + case eDVBFrontendParametersSatellite::System_DVB_S2: switch(feparm.rolloff) { default: - case eDVBFrontendParametersSatellite::RollOff::alpha_0_35: tmp="0.35"; break; - case eDVBFrontendParametersSatellite::RollOff::alpha_0_25: tmp="0.25"; break; - case eDVBFrontendParametersSatellite::RollOff::alpha_0_20: tmp="0.20"; break; + case eDVBFrontendParametersSatellite::RollOff_alpha_0_35: tmp="0.35"; break; + case eDVBFrontendParametersSatellite::RollOff_alpha_0_25: tmp="0.25"; break; + case eDVBFrontendParametersSatellite::RollOff_alpha_0_20: tmp="0.20"; break; } PutToDict(dict, "roll off", tmp); switch(feparm.pilot) { - case eDVBFrontendParametersSatellite::Pilot::On: tmp="ON"; break; - case eDVBFrontendParametersSatellite::Pilot::Off: tmp="OFF"; break; + case eDVBFrontendParametersSatellite::Pilot_On: tmp="ON"; break; + case eDVBFrontendParametersSatellite::Pilot_Off: tmp="OFF"; break; default: - case eDVBFrontendParametersSatellite::Pilot::Unknown: tmp="AUTO"; break; + case eDVBFrontendParametersSatellite::Pilot_Unknown: tmp="AUTO"; break; } PutToDict(dict, "pilot", tmp); tmp="DVB-S2"; @@ -195,78 +195,78 @@ void PutTerrestrialDataToDict(ePyObject &dict, eDVBFrontendParametersTerrestrial const char *tmp=0; switch (feparm.bandwidth) { - case eDVBFrontendParametersTerrestrial::Bandwidth::Bw8MHz: tmp="8 MHz"; break; - case eDVBFrontendParametersTerrestrial::Bandwidth::Bw7MHz: tmp="7 MHz"; break; - case eDVBFrontendParametersTerrestrial::Bandwidth::Bw6MHz: tmp="6 MHz"; break; + case eDVBFrontendParametersTerrestrial::Bandwidth_8MHz: tmp="8 MHz"; break; + case eDVBFrontendParametersTerrestrial::Bandwidth_7MHz: tmp="7 MHz"; break; + case eDVBFrontendParametersTerrestrial::Bandwidth_6MHz: tmp="6 MHz"; break; default: - case eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto: tmp="AUTO"; break; + case eDVBFrontendParametersTerrestrial::Bandwidth_Auto: tmp="AUTO"; break; } PutToDict(dict, "bandwidth", tmp); switch (feparm.code_rate_LP) { - case eDVBFrontendParametersTerrestrial::FEC::f1_2: tmp="1/2"; break; - case eDVBFrontendParametersTerrestrial::FEC::f2_3: tmp="2/3"; break; - case eDVBFrontendParametersTerrestrial::FEC::f3_4: tmp="3/4"; break; - case eDVBFrontendParametersTerrestrial::FEC::f5_6: tmp="5/6"; break; - case eDVBFrontendParametersTerrestrial::FEC::f7_8: tmp="7/8"; break; + case eDVBFrontendParametersTerrestrial::FEC_1_2: tmp="1/2"; break; + case eDVBFrontendParametersTerrestrial::FEC_2_3: tmp="2/3"; break; + case eDVBFrontendParametersTerrestrial::FEC_3_4: tmp="3/4"; break; + case eDVBFrontendParametersTerrestrial::FEC_5_6: tmp="5/6"; break; + case eDVBFrontendParametersTerrestrial::FEC_7_8: tmp="7/8"; break; default: - case eDVBFrontendParametersTerrestrial::FEC::fAuto: tmp="AUTO"; break; + case eDVBFrontendParametersTerrestrial::FEC_Auto: tmp="AUTO"; break; } PutToDict(dict, "code rate lp", tmp); switch (feparm.code_rate_HP) { - case eDVBFrontendParametersTerrestrial::FEC::f1_2: tmp="1/2"; break; - case eDVBFrontendParametersTerrestrial::FEC::f2_3: tmp="2/3"; break; - case eDVBFrontendParametersTerrestrial::FEC::f3_4: tmp="3/4"; break; - case eDVBFrontendParametersTerrestrial::FEC::f5_6: tmp="5/6"; break; - case eDVBFrontendParametersTerrestrial::FEC::f7_8: tmp="7/8"; break; + case eDVBFrontendParametersTerrestrial::FEC_1_2: tmp="1/2"; break; + case eDVBFrontendParametersTerrestrial::FEC_2_3: tmp="2/3"; break; + case eDVBFrontendParametersTerrestrial::FEC_3_4: tmp="3/4"; break; + case eDVBFrontendParametersTerrestrial::FEC_5_6: tmp="5/6"; break; + case eDVBFrontendParametersTerrestrial::FEC_7_8: tmp="7/8"; break; default: - case eDVBFrontendParametersTerrestrial::FEC::fAuto: tmp="AUTO"; break; + case eDVBFrontendParametersTerrestrial::FEC_Auto: tmp="AUTO"; break; } PutToDict(dict, "code rate hp", tmp); switch (feparm.modulation) { - case eDVBFrontendParametersTerrestrial::Modulation::QPSK: tmp="QPSK"; break; - case eDVBFrontendParametersTerrestrial::Modulation::QAM16: tmp="QAM16"; break; - case eDVBFrontendParametersTerrestrial::Modulation::QAM64: tmp="QAM64"; break; + case eDVBFrontendParametersTerrestrial::Modulation_QPSK: tmp="QPSK"; break; + case eDVBFrontendParametersTerrestrial::Modulation_QAM16: tmp="QAM16"; break; + case eDVBFrontendParametersTerrestrial::Modulation_QAM64: tmp="QAM64"; break; default: - case eDVBFrontendParametersTerrestrial::Modulation::Auto: tmp="AUTO"; break; + case eDVBFrontendParametersTerrestrial::Modulation_Auto: tmp="AUTO"; break; } PutToDict(dict, "constellation", tmp); switch (feparm.transmission_mode) { - case eDVBFrontendParametersTerrestrial::TransmissionMode::TM2k: tmp="2k"; break; - case eDVBFrontendParametersTerrestrial::TransmissionMode::TM8k: tmp="8k"; break; + case eDVBFrontendParametersTerrestrial::TransmissionMode_2k: tmp="2k"; break; + case eDVBFrontendParametersTerrestrial::TransmissionMode_8k: tmp="8k"; break; default: - case eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto: tmp="AUTO"; break; + case eDVBFrontendParametersTerrestrial::TransmissionMode_Auto: tmp="AUTO"; break; } PutToDict(dict, "transmission mode", tmp); switch (feparm.guard_interval) { - case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_32: tmp="1/32"; break; - case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_16: tmp="1/16"; break; - case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_8: tmp="1/8"; break; - case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_4: tmp="1/4"; break; + case eDVBFrontendParametersTerrestrial::GuardInterval_1_32: tmp="1/32"; break; + case eDVBFrontendParametersTerrestrial::GuardInterval_1_16: tmp="1/16"; break; + case eDVBFrontendParametersTerrestrial::GuardInterval_1_8: tmp="1/8"; break; + case eDVBFrontendParametersTerrestrial::GuardInterval_1_4: tmp="1/4"; break; default: - case eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto: tmp="AUTO"; break; + case eDVBFrontendParametersTerrestrial::GuardInterval_Auto: tmp="AUTO"; break; } PutToDict(dict, "guard interval", tmp); switch (feparm.hierarchy) { - case eDVBFrontendParametersTerrestrial::Hierarchy::HNone: tmp="NONE"; break; - case eDVBFrontendParametersTerrestrial::Hierarchy::H1: tmp="1"; break; - case eDVBFrontendParametersTerrestrial::Hierarchy::H2: tmp="2"; break; - case eDVBFrontendParametersTerrestrial::Hierarchy::H4: tmp="4"; break; + case eDVBFrontendParametersTerrestrial::Hierarchy_None: tmp="NONE"; break; + case eDVBFrontendParametersTerrestrial::Hierarchy_1: tmp="1"; break; + case eDVBFrontendParametersTerrestrial::Hierarchy_2: tmp="2"; break; + case eDVBFrontendParametersTerrestrial::Hierarchy_4: tmp="4"; break; default: - case eDVBFrontendParametersTerrestrial::Hierarchy::HAuto: tmp="AUTO"; break; + case eDVBFrontendParametersTerrestrial::Hierarchy_Auto: tmp="AUTO"; break; } PutToDict(dict, "hierarchy", tmp); switch (feparm.inversion) { - case eDVBFrontendParametersSatellite::Inversion::On: tmp="ON"; break; - case eDVBFrontendParametersSatellite::Inversion::Off: tmp="OFF"; break; + case eDVBFrontendParametersSatellite::Inversion_On: tmp="ON"; break; + case eDVBFrontendParametersSatellite::Inversion_Off: tmp="OFF"; break; default: - case eDVBFrontendParametersSatellite::Inversion::Unknown: tmp="AUTO"; break; + case eDVBFrontendParametersSatellite::Inversion_Unknown: tmp="AUTO"; break; } PutToDict(dict, "inversion", tmp); } @@ -279,34 +279,34 @@ void PutCableDataToDict(ePyObject &dict, eDVBFrontendParametersCable &feparm) PutToDictAsStr(dict, "symbolrate", feparm.symbol_rate); switch (feparm.modulation) { - case eDVBFrontendParametersCable::Modulation::QAM16: tmp="QAM16"; break; - case eDVBFrontendParametersCable::Modulation::QAM32: tmp="QAM32"; break; - case eDVBFrontendParametersCable::Modulation::QAM64: tmp="QAM64"; break; - case eDVBFrontendParametersCable::Modulation::QAM128: tmp="QAM128"; break; - case eDVBFrontendParametersCable::Modulation::QAM256: tmp="QAM256"; break; + case eDVBFrontendParametersCable::Modulation_QAM16: tmp="QAM16"; break; + case eDVBFrontendParametersCable::Modulation_QAM32: tmp="QAM32"; break; + case eDVBFrontendParametersCable::Modulation_QAM64: tmp="QAM64"; break; + case eDVBFrontendParametersCable::Modulation_QAM128: tmp="QAM128"; break; + case eDVBFrontendParametersCable::Modulation_QAM256: tmp="QAM256"; break; default: - case eDVBFrontendParametersCable::Modulation::Auto: tmp="AUTO"; break; + case eDVBFrontendParametersCable::Modulation_Auto: tmp="AUTO"; break; } PutToDict(dict, "modulation", tmp); switch (feparm.inversion) { - case eDVBFrontendParametersCable::Inversion::On: tmp="ON"; break; - case eDVBFrontendParametersCable::Inversion::Off: tmp="OFF"; break; + case eDVBFrontendParametersCable::Inversion_On: tmp="ON"; break; + case eDVBFrontendParametersCable::Inversion_Off: tmp="OFF"; break; default: - case eDVBFrontendParametersCable::Inversion::Unknown: tmp="AUTO"; break; + case eDVBFrontendParametersCable::Inversion_Unknown: tmp="AUTO"; break; } PutToDict(dict, "inversion", tmp); switch (feparm.fec_inner) { - case eDVBFrontendParametersCable::FEC::fNone: tmp="NONE"; break; - case eDVBFrontendParametersCable::FEC::f1_2: tmp="1/2"; break; - case eDVBFrontendParametersCable::FEC::f2_3: tmp="2/3"; break; - case eDVBFrontendParametersCable::FEC::f3_4: tmp="3/4"; break; - case eDVBFrontendParametersCable::FEC::f5_6: tmp="5/6"; break; - case eDVBFrontendParametersCable::FEC::f7_8: tmp="7/8"; break; - case eDVBFrontendParametersCable::FEC::f8_9: tmp="8/9"; break; + case eDVBFrontendParametersCable::FEC_None: tmp="NONE"; break; + case eDVBFrontendParametersCable::FEC_1_2: tmp="1/2"; break; + case eDVBFrontendParametersCable::FEC_2_3: tmp="2/3"; break; + case eDVBFrontendParametersCable::FEC_3_4: tmp="3/4"; break; + case eDVBFrontendParametersCable::FEC_5_6: tmp="5/6"; break; + case eDVBFrontendParametersCable::FEC_7_8: tmp="7/8"; break; + case eDVBFrontendParametersCable::FEC_8_9: tmp="8/9"; break; default: - case eDVBFrontendParametersCable::FEC::fAuto: tmp="AUTO"; break; + case eDVBFrontendParametersCable::FEC_Auto: tmp="AUTO"; break; } PutToDict(dict, "fec inner", tmp); } @@ -2028,16 +2028,7 @@ PyObject *eDVBServiceBase::getTransponderData(bool original) if (!feparm->getDVBS(osat)) { PutToDict(ret, "orbital_position", osat.orbital_position); - const char *tmp = "UNKNOWN"; - switch(osat.polarisation) - { - case eDVBFrontendParametersSatellite::Polarisation::Horizontal: tmp="HORIZONTAL"; break; - case eDVBFrontendParametersSatellite::Polarisation::Vertical: tmp="VERTICAL"; break; - case eDVBFrontendParametersSatellite::Polarisation::CircularLeft: tmp="CIRCULAR_LEFT"; break; - case eDVBFrontendParametersSatellite::Polarisation::CircularRight: tmp="CIRCULAR_RIGHT"; break; - default:break; - } - PutToDict(ret, "polarization", tmp); + PutToDict(ret, "polarization", osat.polarisation); } } } -- cgit v1.2.3