From 7049be52bf2235dfb848b28dcd9aa44eb204771c Mon Sep 17 00:00:00 2001 From: ghost Date: Sat, 22 Nov 2008 12:14:43 +0100 Subject: fix type in bcm4501 snr dB calculation --- lib/dvb/frontend.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'lib/dvb/frontend.cpp') diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp index b0e92d39..a74e65ca 100644 --- a/lib/dvb/frontend.cpp +++ b/lib/dvb/frontend.cpp @@ -728,7 +728,7 @@ int eDVBFrontend::readFrontendData(int type) eDebug("FE_READ_SNR failed (%m)"); if (!strcmp(m_description, "BCM4501 (internal)")) { - unsigned int SDS_SNRE = snr << 16; + float SDS_SNRE = snr << 16; float snr_in_db; if (parm_u_qpsk_fec_inner <= FEC_AUTO) // DVB-S1 / QPSK @@ -748,7 +748,7 @@ int eDVBFrontend::readFrontendData(int type) if (fval1 < 10.0) { fval2 = SNR_COEFF[0]; - for (int i=0; i<6; ++i) + for (int i=1; i<6; ++i) { fval2 *= fval1; fval2 += SNR_COEFF[i]; -- cgit v1.2.3 From 4543185382dbdd51e0e55092fd616ad5fff1eaba Mon Sep 17 00:00:00 2001 From: ghost Date: Wed, 3 Dec 2008 00:35:26 +0100 Subject: frontend.cpp: add SNRdb calculation for Philips TU1216 and Philips CU1216Mk3 --- lib/dvb/frontend.cpp | 34 +++++++++++++++++++++++++++++----- 1 file changed, 29 insertions(+), 5 deletions(-) (limited to 'lib/dvb/frontend.cpp') diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp index a74e65ca..55be6f9c 100644 --- a/lib/dvb/frontend.cpp +++ b/lib/dvb/frontend.cpp @@ -695,6 +695,12 @@ void eDVBFrontend::timeout() #define INRANGE(X,Y,Z) (((X<=Y) && (Y<=Z))||((Z<=Y) && (Y<=X)) ? 1 : 0) +/* unsigned 32 bit division */ +static inline uint32_t fe_udiv(uint32_t a, uint32_t b) +{ + return (a + b / 2) / b; +} + int eDVBFrontend::readFrontendData(int type) { switch(type) @@ -781,7 +787,7 @@ int eDVBFrontend::readFrontendData(int type) snr_in_db = fval1; } #endif - return (int)(snr_in_db * 100.0); + return (int)(snr_in_db * 100); } else if (strstr(m_description, "Alps BSBE1 C01A") || !strcmp(m_description, "Alps -S(STV0288)")) @@ -831,12 +837,30 @@ int eDVBFrontend::readFrontendData(int type) !strcmp(m_description, "Philips -S") || !strcmp(m_description, "LG -S") ) { - float snr_in_db=(snr-39075)/1764.7; - return (int)(snr_in_db * 100.0); + return (int)((snr-39075)/17.647); } else if (!strcmp(m_description, "Alps BSBE2")) { - return (int)((snr >> 7) * 10.0); - } /* else + return (int)((snr >> 7) * 10); + } else if (!strcmp(m_description, "Philips CU1216Mk3")) + { + int mse = (~snr) & 0xFF; + switch (parm_u_qam_modulation) { + case QAM_16: return fe_udiv(1950000, (32 * mse) + 138) + 1000; + case QAM_32: return fe_udiv(2150000, (40 * mse) + 500) + 1350; + case QAM_64: return fe_udiv(2100000, (40 * mse) + 500) + 1250; + case QAM_128: return fe_udiv(1850000, (38 * mse) + 400) + 1380; + case QAM_256: return fe_udiv(1800000, (100 * mse) + 40) + 2030; + default: break; + } + return 0; + } else if (!strcmp(m_description, "Philips TU1216")) + { + snr = 0xFF - (snr & 0xFF); + if (snr != 0) + return (int)(-100 * (log10(snr) - log10(255))); + return 0; + } +/* else eDebug("no SNR dB calculation for frontendtype %s yet", m_description); */ return 0x12345678; } -- cgit v1.2.3 From bd65449944ee0e4aab5acb3da30dd6d4a2b72198 Mon Sep 17 00:00:00 2001 From: ghost Date: Wed, 3 Dec 2008 15:33:47 +0100 Subject: fix Philips Tu1216 snrdb calculcation --- lib/dvb/frontend.cpp | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) (limited to 'lib/dvb/frontend.cpp') diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp index 55be6f9c..b25794f8 100644 --- a/lib/dvb/frontend.cpp +++ b/lib/dvb/frontend.cpp @@ -857,7 +857,7 @@ int eDVBFrontend::readFrontendData(int type) { snr = 0xFF - (snr & 0xFF); if (snr != 0) - return (int)(-100 * (log10(snr) - log10(255))); + return 10 * (int)(-100 * (log10(snr) - log10(255))); return 0; } /* else -- cgit v1.2.3 From a3d5b26f430cf5f35f909d4018887c7a8f13aa66 Mon Sep 17 00:00:00 2001 From: ghost Date: Mon, 8 Dec 2008 14:55:58 +0100 Subject: calculate signalQuality based on snrdb --- lib/dvb/frontend.cpp | 59 ++++++++++++++++++++++++++++------------------------ 1 file changed, 32 insertions(+), 27 deletions(-) (limited to 'lib/dvb/frontend.cpp') diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp index b25794f8..d890c975 100644 --- a/lib/dvb/frontend.cpp +++ b/lib/dvb/frontend.cpp @@ -716,23 +716,15 @@ int eDVBFrontend::readFrontendData(int type) return ber; } case signalQuality: - { - uint16_t snr=0; - if (!m_simulate) - { - if (ioctl(m_fd, FE_READ_SNR, &snr) < 0 && errno != ERANGE) - eDebug("FE_READ_SNR failed (%m)"); - } - return snr; - } case signalQualitydB: /* this will move into the driver */ { + int ret = 0x12345678; uint16_t snr=0; if (m_simulate) return 0; if (ioctl(m_fd, FE_READ_SNR, &snr) < 0 && errno != ERANGE) eDebug("FE_READ_SNR failed (%m)"); - if (!strcmp(m_description, "BCM4501 (internal)")) + else if (!strcmp(m_description, "BCM4501 (internal)")) { float SDS_SNRE = snr << 16; float snr_in_db; @@ -787,15 +779,15 @@ int eDVBFrontend::readFrontendData(int type) snr_in_db = fval1; } #endif - return (int)(snr_in_db * 100); + ret = (int)(snr_in_db * 100); } else if (strstr(m_description, "Alps BSBE1 C01A") || !strcmp(m_description, "Alps -S(STV0288)")) { if (snr == 0) - return 0; + ret = 0; else if (snr == 0xFFFF) // i think this should not happen - return 100*100; + ret = 100*100; else { enum { REALVAL, REGVAL }; @@ -823,46 +815,59 @@ int eDVBFrontend::readFrontendData(int type) else Imin = i; } - return (((regval - CN_lookup[Imin][REGVAL]) + ret = (((regval - CN_lookup[Imin][REGVAL]) * (CN_lookup[Imax][REALVAL] - CN_lookup[Imin][REALVAL]) / (CN_lookup[Imax][REGVAL] - CN_lookup[Imin][REGVAL])) + CN_lookup[Imin][REALVAL]) * 10; } - return 100; + else + ret = 100; } - return 0; } else if (!strcmp(m_description, "Alps BSBE1 702A") || // some frontends with STV0299 !strcmp(m_description, "Alps -S") || !strcmp(m_description, "Philips -S") || !strcmp(m_description, "LG -S") ) { - return (int)((snr-39075)/17.647); + ret = (int)((snr-39075)/17.647); } else if (!strcmp(m_description, "Alps BSBE2")) { - return (int)((snr >> 7) * 10); + ret = (int)((snr >> 7) * 10); } else if (!strcmp(m_description, "Philips CU1216Mk3")) { int mse = (~snr) & 0xFF; switch (parm_u_qam_modulation) { - case QAM_16: return fe_udiv(1950000, (32 * mse) + 138) + 1000; - case QAM_32: return fe_udiv(2150000, (40 * mse) + 500) + 1350; - case QAM_64: return fe_udiv(2100000, (40 * mse) + 500) + 1250; - case QAM_128: return fe_udiv(1850000, (38 * mse) + 400) + 1380; - case QAM_256: return fe_udiv(1800000, (100 * mse) + 40) + 2030; + case QAM_16: ret = fe_udiv(1950000, (32 * mse) + 138) + 1000; break; + case QAM_32: ret = fe_udiv(2150000, (40 * mse) + 500) + 1350; break; + case QAM_64: ret = fe_udiv(2100000, (40 * mse) + 500) + 1250; break; + case QAM_128: ret = fe_udiv(1850000, (38 * mse) + 400) + 1380; break; + case QAM_256: ret = fe_udiv(1800000, (100 * mse) + 40) + 2030; break; default: break; } - return 0; } else if (!strcmp(m_description, "Philips TU1216")) { snr = 0xFF - (snr & 0xFF); if (snr != 0) - return 10 * (int)(-100 * (log10(snr) - log10(255))); - return 0; + ret = 10 * (int)(-100 * (log10(snr) - log10(255))); + } + + if (type == signalQuality) + { + if (ret == 0x12345678) // no snr db calculation avail.. return untouched snr value.. + return snr; + switch(m_type) + { + case feSatellite: // we assume a max of 17.5db here + return ret >= 1750 ? 65536 : ret * 65536 / 1750; + case feCable: // we assume a max of 42db here + return ret >= 4200 ? 65536 : ret * 65536 / 4200; + case feTerrestrial: // we assume a max of 24db here + return ret >= 2400 ? 65536 : ret * 65536 / 2400; + } } /* else eDebug("no SNR dB calculation for frontendtype %s yet", m_description); */ - return 0x12345678; + return ret; } case signalPower: { -- cgit v1.2.3 From 18c98a9e4a08c77fd1e0bfcc7410e9697d19510c Mon Sep 17 00:00:00 2001 From: ghost Date: Mon, 8 Dec 2008 23:22:22 +0100 Subject: small SNRdb correction for latest 4501 firmware --- lib/dvb/frontend.cpp | 5 +++-- 1 file changed, 3 insertions(+), 2 deletions(-) (limited to 'lib/dvb/frontend.cpp') diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp index d890c975..af974c81 100644 --- a/lib/dvb/frontend.cpp +++ b/lib/dvb/frontend.cpp @@ -780,6 +780,7 @@ int eDVBFrontend::readFrontendData(int type) } #endif ret = (int)(snr_in_db * 100); + ret -= 150; // -1.5db for latest bcm4501 firmware.. } else if (strstr(m_description, "Alps BSBE1 C01A") || !strcmp(m_description, "Alps -S(STV0288)")) @@ -857,8 +858,8 @@ int eDVBFrontend::readFrontendData(int type) return snr; switch(m_type) { - case feSatellite: // we assume a max of 17.5db here - return ret >= 1750 ? 65536 : ret * 65536 / 1750; + case feSatellite: // we assume a max of 16.0db here + return ret >= 1600 ? 65536 : ret * 65536 / 1600; case feCable: // we assume a max of 42db here return ret >= 4200 ? 65536 : ret * 65536 / 4200; case feTerrestrial: // we assume a max of 24db here -- cgit v1.2.3 From 0ef515315550e2aede2418565199f9a14c31b04b Mon Sep 17 00:00:00 2001 From: ghost Date: Thu, 11 Dec 2008 16:37:51 +0100 Subject: change snr / snr dB caluculation a bit --- lib/dvb/frontend.cpp | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) (limited to 'lib/dvb/frontend.cpp') diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp index af974c81..f18c3b9e 100644 --- a/lib/dvb/frontend.cpp +++ b/lib/dvb/frontend.cpp @@ -718,6 +718,7 @@ int eDVBFrontend::readFrontendData(int type) case signalQuality: case signalQualitydB: /* this will move into the driver */ { + int sat_max = 1600; // for stv0288 / bsbe2 int ret = 0x12345678; uint16_t snr=0; if (m_simulate) @@ -779,8 +780,8 @@ int eDVBFrontend::readFrontendData(int type) snr_in_db = fval1; } #endif + sat_max = 1750; ret = (int)(snr_in_db * 100); - ret -= 150; // -1.5db for latest bcm4501 firmware.. } else if (strstr(m_description, "Alps BSBE1 C01A") || !strcmp(m_description, "Alps -S(STV0288)")) @@ -830,6 +831,7 @@ int eDVBFrontend::readFrontendData(int type) !strcmp(m_description, "Philips -S") || !strcmp(m_description, "LG -S") ) { + sat_max = 1500; ret = (int)((snr-39075)/17.647); } else if (!strcmp(m_description, "Alps BSBE2")) { @@ -858,8 +860,8 @@ int eDVBFrontend::readFrontendData(int type) return snr; switch(m_type) { - case feSatellite: // we assume a max of 16.0db here - return ret >= 1600 ? 65536 : ret * 65536 / 1600; + case feSatellite: + return ret >= sat_max ? 65536 : ret * 65536 / sat_max; case feCable: // we assume a max of 42db here return ret >= 4200 ? 65536 : ret * 65536 / 4200; case feTerrestrial: // we assume a max of 24db here -- cgit v1.2.3 From 4e74986315be42f5b2e401f201560239777dac05 Mon Sep 17 00:00:00 2001 From: ghost Date: Thu, 11 Dec 2008 22:05:15 +0100 Subject: more debug for dvb api >= v3 --- lib/dvb/frontend.cpp | 15 +++++++++++++++ 1 file changed, 15 insertions(+) (limited to 'lib/dvb/frontend.cpp') diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp index f18c3b9e..284844dc 100644 --- a/lib/dvb/frontend.cpp +++ b/lib/dvb/frontend.cpp @@ -1859,6 +1859,20 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm, res = m_sec->prepare(*this, parm, feparm, 1 << m_slotid, tunetimeout); if (!res) { +#if HAVE_DVB_API_VERSION >= 3 + eDebugNoSimulate("prepare_sat System %d Freq %d Pol %d SR %d INV %d FEC %d orbpos %d system %d modulation %d pilot %d, rolloff %d", + feparm.system, + feparm.frequency, + feparm.polarisation, + feparm.symbol_rate, + feparm.inversion, + feparm.fec, + feparm.orbital_position, + feparm.system, + feparm.modulation, + feparm.pilot, + feparm.rolloff); +#else eDebugNoSimulate("prepare_sat System %d Freq %d Pol %d SR %d INV %d FEC %d orbpos %d", feparm.system, feparm.frequency, @@ -1867,6 +1881,7 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm, feparm.inversion, feparm.fec, feparm.orbital_position); +#endif parm_u_qpsk_symbol_rate = feparm.symbol_rate; switch (feparm.inversion) { -- 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/frontend.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/frontend.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 From 8d85982d460e7cc0eb26f1bf79dc345d12a11858 Mon Sep 17 00:00:00 2001 From: ghost Date: Fri, 30 Jan 2009 15:29:25 +0100 Subject: add check for invalid fec in cable delivery descriptor --- lib/dvb/frontend.cpp | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) (limited to 'lib/dvb/frontend.cpp') diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp index 5fe3799d..e0291ec1 100644 --- a/lib/dvb/frontend.cpp +++ b/lib/dvb/frontend.cpp @@ -192,8 +192,8 @@ void eDVBFrontendParametersCable::set(const CableDeliverySystemDescriptor &descr frequency = descriptor.getFrequency() / 10; symbol_rate = descriptor.getSymbolRate() * 100; fec_inner = descriptor.getFecInner(); - if ( fec_inner == 0xF ) - fec_inner = eDVBFrontendParametersCable::FEC_None; + if ( fec_inner != eDVBFrontendParametersCable::FEC_None && fec_inner > eDVBFrontendParametersCable::FEC_8_9 ) + fec_inner = eDVBFrontendParametersCable::FEC_Auto; modulation = descriptor.getModulation(); if ( modulation > 0x5 ) modulation = eDVBFrontendParametersCable::Modulation_Auto; -- cgit v1.2.3