add support for turning rotor without power measurement

(for rotors behind a powered switch or rotor behind a V-Box)
known bug .. the transponder scan loops when a transponder does not lock :/

diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp
index a7f0c70e7e49b149e18af03c2e2d469c4a10c25f..464ef7898f500f8c52bcefc92797ddcc5628878d 100644 (file)
--- a/lib/dvb/frontend.cpp
+++ b/lib/dvb/frontend.cpp
@@ -478,6 +478,28 @@ int eDVBFrontend::readFrontendData(int type)
                                eDebug("FE_READ_SIGNAL_STRENGTH failed (%m)");
                        return strength;
                }
+               case Locked:
+               {
+#if HAVE_DVB_API_VERSION < 3
+                       FrontendStatus status=0;
+#else
+                       fe_status_t status;
+#endif
+                       if ( ioctl(m_fd, FE_READ_STATUS, &status) < 0 && errno != ERANGE )
+                               eDebug("FE_READ_STATUS failed (%m)");
+                       return !!(status&FE_HAS_LOCK);
+               }
+               case Synced:
+               {
+#if HAVE_DVB_API_VERSION < 3
+                       FrontendStatus status=0;
+#else
+                       fe_status_t status;
+#endif
+                       if ( ioctl(m_fd, FE_READ_STATUS, &status) < 0 && errno != ERANGE )
+                               eDebug("FE_READ_STATUS failed (%m)");
+                       return !!(status&FE_HAS_SYNC);
+               }
        }
        return 0;
 }
@@ -532,6 +554,7 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
        int delay=0;
        if ( m_sec_sequence && m_sec_sequence.current() != m_sec_sequence.end() )
        {
+//             eDebug("tuneLoop %d\n", m_sec_sequence.current()->cmd);
                switch (m_sec_sequence.current()->cmd)
                {
                        case eSecCommand::SLEEP:
@@ -586,6 +609,10 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                                setFrontend();
                                ++m_sec_sequence.current();
                                break;
+                       case eSecCommand::START_TUNE_TIMEOUT:
+                               m_timeout->start(5000, 1); // 5 sec timeout. TODO: symbolrate dependent
+                               ++m_sec_sequence.current();
+                               break;
                        case eSecCommand::SET_TIMEOUT:
                                m_timeoutCount = m_sec_sequence.current()++->val;
                                eDebug("[SEC] set timeout %d", m_timeoutCount);
@@ -630,6 +657,31 @@ void eDVBFrontend::tuneLoop()  // called by m_tuneTimer
                                ++m_sec_sequence.current();
                                break;
                        }
+                       case eSecCommand::IF_TUNER_LOCKED_GOTO:
+                       {
+                               eSecCommand::rotor &cmd = m_sec_sequence.current()->measure;
+                               if (readFrontendData(Locked))
+                               {
+                                       eDebug("[SEC] locked step %d ok", cmd.okcount);
+                                       ++cmd.okcount;
+                                       if (cmd.okcount > 12)
+                                       {
+                                               eDebug("ok > 12 .. goto %d\n",m_sec_sequence.current()->steps);
+                                               setSecSequencePos(cmd.steps);
+                                               break;
+                                       }
+                               }
+                               else
+                               {
+                                       eDebug("[SEC] rotor locked step %d failed", cmd.okcount);
+                                       --m_timeoutCount;
+                                       if (!m_timeoutCount && m_retryCount > 0)
+                                               --m_retryCount;
+                                       cmd.okcount=0;
+                               }
+                               ++m_sec_sequence.current();
+                               break;
+                       }
                        case eSecCommand::MEASURE_RUNNING_INPUTPOWER:
                                m_runningInputpower = readInputpower();
                                eDebug("[SEC] runningInputpower is %d", m_runningInputpower);
@@ -741,7 +793,6 @@ void eDVBFrontend::setFrontend()
                perror("FE_SET_FRONTEND failed");
                return;
        }
-       m_timeout->start(5000, 1); // 5 sec timeout. TODO: symbolrate dependent
 }
 
 RESULT eDVBFrontend::getFrontendType(int &t)
@@ -752,10 +803,226 @@ RESULT eDVBFrontend::getFrontendType(int &t)
        return 0;
 }
 
+RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm)
+{
+       int res;
+       if (!m_sec)
+       {
+               eWarning("no SEC module active!");
+               return -ENOENT;
+       }
+       res = m_sec->prepare(*this, parm, feparm, 1 << m_fe);
+       if (!res)
+               eDebug("tuning to %d mhz", parm.frequency/1000);
+       return res;
+}
+
+RESULT eDVBFrontend::prepare_cable(const eDVBFrontendParametersCable &feparm)
+{
+       parm.frequency = feparm.frequency * 1000;
+       parm.u.qam.symbol_rate = feparm.symbol_rate;
+       switch (feparm.modulation)
+       {
+       case eDVBFrontendParametersCable::Modulation::QAM16:
+               parm.u.qam.modulation = QAM_16;
+               break;
+       case eDVBFrontendParametersCable::Modulation::QAM32:
+               parm.u.qam.modulation = QAM_32;
+               break;
+       case eDVBFrontendParametersCable::Modulation::QAM64:
+               parm.u.qam.modulation = QAM_64;
+               break;
+       case eDVBFrontendParametersCable::Modulation::QAM128:
+               parm.u.qam.modulation = QAM_128;
+               break;
+       case eDVBFrontendParametersCable::Modulation::QAM256:
+               parm.u.qam.modulation = QAM_256;
+               break;
+       default:
+       case eDVBFrontendParametersCable::Modulation::Auto:
+               parm.u.qam.modulation = QAM_AUTO;
+               break;
+       }
+       switch (feparm.inversion)
+       {
+       case eDVBFrontendParametersCable::Inversion::On:
+               parm.inversion = INVERSION_ON;
+               break;
+       case eDVBFrontendParametersCable::Inversion::Off:
+               parm.inversion = INVERSION_OFF;
+               break;
+       default:
+       case eDVBFrontendParametersCable::Inversion::Unknown:
+               parm.inversion = INVERSION_AUTO;
+               break;
+       }
+       switch (feparm.fec_inner)
+       {
+       case eDVBFrontendParametersCable::FEC::fNone:
+               parm.u.qam.fec_inner = FEC_NONE;
+               break;
+       case eDVBFrontendParametersCable::FEC::f1_2:
+               parm.u.qam.fec_inner = FEC_1_2;
+               break;
+       case eDVBFrontendParametersCable::FEC::f2_3:
+               parm.u.qam.fec_inner = FEC_2_3;
+               break;
+       case eDVBFrontendParametersCable::FEC::f3_4:
+               parm.u.qam.fec_inner = FEC_3_4;
+               break;
+       case eDVBFrontendParametersCable::FEC::f5_6:
+               parm.u.qam.fec_inner = FEC_5_6;
+               break;
+       case eDVBFrontendParametersCable::FEC::f7_8:
+               parm.u.qam.fec_inner = FEC_7_8;
+               break;
+       case eDVBFrontendParametersCable::FEC::f8_9:
+               parm.u.qam.fec_inner = FEC_8_9;
+               break;
+       default:
+       case eDVBFrontendParametersCable::FEC::fAuto:
+               parm.u.qam.fec_inner = FEC_AUTO;
+               break;
+       }
+       return 0;
+}
+
+RESULT eDVBFrontend::prepare_terrestrial(const eDVBFrontendParametersTerrestrial &feparm)
+{
+       parm.frequency = feparm.frequency;
+
+       switch (feparm.bandwidth)
+       {
+       case eDVBFrontendParametersTerrestrial::Bandwidth::Bw8MHz:
+               parm.u.ofdm.bandwidth = BANDWIDTH_8_MHZ;
+               break;
+       case eDVBFrontendParametersTerrestrial::Bandwidth::Bw7MHz:
+               parm.u.ofdm.bandwidth = BANDWIDTH_7_MHZ;
+               break;
+       case eDVBFrontendParametersTerrestrial::Bandwidth::Bw6MHz:
+               parm.u.ofdm.bandwidth = BANDWIDTH_6_MHZ;
+               break;
+       default:
+       case eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto:
+               parm.u.ofdm.bandwidth = BANDWIDTH_AUTO;
+               break;
+       }
+       switch (feparm.code_rate_LP)
+       {
+       case eDVBFrontendParametersCable::FEC::f1_2:
+               parm.u.ofdm.code_rate_LP = FEC_1_2;
+               break;
+       case eDVBFrontendParametersCable::FEC::f2_3:
+               parm.u.ofdm.code_rate_LP = FEC_2_3;
+               break;
+       case eDVBFrontendParametersCable::FEC::f3_4:
+               parm.u.ofdm.code_rate_LP = FEC_3_4;
+               break;
+       case eDVBFrontendParametersCable::FEC::f5_6:
+               parm.u.ofdm.code_rate_LP = FEC_5_6;
+               break;
+       case eDVBFrontendParametersCable::FEC::f7_8:
+               parm.u.ofdm.code_rate_LP = FEC_7_8;
+               break;
+       default:
+       case eDVBFrontendParametersCable::FEC::fAuto:
+       case eDVBFrontendParametersCable::FEC::fNone:
+               parm.u.ofdm.code_rate_LP = FEC_AUTO;
+               break;
+       }
+       switch (feparm.code_rate_HP)
+       {
+       case eDVBFrontendParametersCable::FEC::f1_2:
+               parm.u.ofdm.code_rate_HP = FEC_1_2;
+               break;
+       case eDVBFrontendParametersCable::FEC::f2_3:
+               parm.u.ofdm.code_rate_HP = FEC_2_3;
+               break;
+       case eDVBFrontendParametersCable::FEC::f3_4:
+               parm.u.ofdm.code_rate_HP = FEC_3_4;
+               break;
+       case eDVBFrontendParametersCable::FEC::f5_6:
+               parm.u.ofdm.code_rate_HP = FEC_5_6;
+               break;
+       case eDVBFrontendParametersCable::FEC::f7_8:
+               parm.u.ofdm.code_rate_HP = FEC_7_8;
+               break;
+       default:
+       case eDVBFrontendParametersCable::FEC::fAuto:
+       case eDVBFrontendParametersCable::FEC::fNone:
+               parm.u.ofdm.code_rate_HP = FEC_AUTO;
+               break;
+       }
+       switch (feparm.modulation)
+       {
+       case eDVBFrontendParametersTerrestrial::Modulation::QPSK:
+               parm.u.ofdm.constellation = QPSK;
+               break;
+       case eDVBFrontendParametersTerrestrial::Modulation::QAM16:
+               parm.u.ofdm.constellation = QAM_16;
+               break;
+       default:
+       case eDVBFrontendParametersTerrestrial::Modulation::Auto:
+               parm.u.ofdm.constellation = QAM_AUTO;
+               break;
+       }
+       switch (feparm.transmission_mode)
+       {
+       case eDVBFrontendParametersTerrestrial::TransmissionMode::TM2k:
+               parm.u.ofdm.transmission_mode = TRANSMISSION_MODE_2K;
+               break;
+       case eDVBFrontendParametersTerrestrial::TransmissionMode::TM8k:
+               parm.u.ofdm.transmission_mode = TRANSMISSION_MODE_8K;
+               break;
+       default:
+       case eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto:
+               parm.u.ofdm.transmission_mode = TRANSMISSION_MODE_AUTO;
+               break;
+       }
+       switch (feparm.guard_interval)
+       {
+               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_32:
+                       parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_32;
+                       break;
+               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_16:
+                       parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_16;
+                       break;
+               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_8:
+                       parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_8;
+                       break;
+               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_4:
+                       parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_4;
+                       break;
+               default:
+               case eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto:
+                       parm.u.ofdm.guard_interval = GUARD_INTERVAL_AUTO;
+                       break;
+       }
+       switch (feparm.hierarchy)
+       {
+               case eDVBFrontendParametersTerrestrial::Hierarchy::H1:
+                       parm.u.ofdm.hierarchy_information = HIERARCHY_1;
+                       break;
+               case eDVBFrontendParametersTerrestrial::Hierarchy::H2:
+                       parm.u.ofdm.hierarchy_information = HIERARCHY_2;
+                       break;
+               case eDVBFrontendParametersTerrestrial::Hierarchy::H4:
+                       parm.u.ofdm.hierarchy_information = HIERARCHY_4;
+                       break;
+               default:
+               case eDVBFrontendParametersTerrestrial::Hierarchy::HAuto:
+                       parm.u.ofdm.hierarchy_information = HIERARCHY_AUTO;
+                       break;
+       }
+       return 0;
+}
+
 RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where)
 {
        eDebug("(%d)tune", m_fe);
 
+       int res=0;
+
        if (m_type == -1)
                return -ENODEV;
 
@@ -767,23 +1034,13 @@ RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where)
        {
        case feSatellite:
        {
-               int res;
                eDVBFrontendParametersSatellite feparm;
                if (where.getDVBS(feparm))
                {
                        eDebug("no dvbs data!");
                        return -EINVAL;
                }
-               if (!m_sec)
-               {
-                       eWarning("no SEC module active!");
-                       return -ENOENT;
-               }
-               
-               res = m_sec->prepare(*this, parm, feparm, 1 << m_fe);
-               if (res)
-                       return res;
-               eDebug("tuning to %d mhz", parm.frequency/1000);
+               res=prepare_sat(feparm);
                break;
        }
        case feCable:
@@ -791,71 +1048,9 @@ RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where)
                eDVBFrontendParametersCable feparm;
                if (where.getDVBC(feparm))
                        return -EINVAL;
-               parm.frequency = feparm.frequency * 1000;
-               parm.u.qam.symbol_rate = feparm.symbol_rate;
-               switch (feparm.modulation)
-               {
-               case eDVBFrontendParametersCable::Modulation::QAM16:
-                       parm.u.qam.modulation = QAM_16;
-                       break;
-               case eDVBFrontendParametersCable::Modulation::QAM32:
-                       parm.u.qam.modulation = QAM_32;
-                       break;
-               case eDVBFrontendParametersCable::Modulation::QAM64:
-                       parm.u.qam.modulation = QAM_64;
-                       break;
-               case eDVBFrontendParametersCable::Modulation::QAM128:
-                       parm.u.qam.modulation = QAM_128;
-                       break;
-               case eDVBFrontendParametersCable::Modulation::QAM256:
-                       parm.u.qam.modulation = QAM_256;
-                       break;
-               default:
-               case eDVBFrontendParametersCable::Modulation::Auto:
-                       parm.u.qam.modulation = QAM_AUTO;
-                       break;
-               }
-               switch (feparm.inversion)
-               {
-               case eDVBFrontendParametersCable::Inversion::On:
-                       parm.inversion = INVERSION_ON;
-                       break;
-               case eDVBFrontendParametersCable::Inversion::Off:
-                       parm.inversion = INVERSION_OFF;
-                       break;
-               default:
-               case eDVBFrontendParametersCable::Inversion::Unknown:
-                       parm.inversion = INVERSION_AUTO;
-                       break;
-               }
-               switch (feparm.fec_inner)
-               {
-               case eDVBFrontendParametersCable::FEC::fNone:
-                       parm.u.qam.fec_inner = FEC_NONE;
-                       break;
-               case eDVBFrontendParametersCable::FEC::f1_2:
-                       parm.u.qam.fec_inner = FEC_1_2;
-                       break;
-               case eDVBFrontendParametersCable::FEC::f2_3:
-                       parm.u.qam.fec_inner = FEC_2_3;
-                       break;
-               case eDVBFrontendParametersCable::FEC::f3_4:
-                       parm.u.qam.fec_inner = FEC_3_4;
-                       break;
-               case eDVBFrontendParametersCable::FEC::f5_6:
-                       parm.u.qam.fec_inner = FEC_5_6;
-                       break;
-               case eDVBFrontendParametersCable::FEC::f7_8:
-                       parm.u.qam.fec_inner = FEC_7_8;
-                       break;
-               case eDVBFrontendParametersCable::FEC::f8_9:
-                       parm.u.qam.fec_inner = FEC_8_9;
-                       break;
-               default:
-               case eDVBFrontendParametersCable::FEC::fAuto:
-                       parm.u.qam.fec_inner = FEC_AUTO;
-                       break;
-               }
+               res=prepare_cable(feparm);
+               if (!res)
+                       m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
                break;
        }
        case feTerrestrial:
@@ -866,147 +1061,28 @@ RESULT eDVBFrontend::tune(const iDVBFrontendParameters &where)
                        eDebug("no -T data");
                        return -EINVAL;
                }
-               parm.frequency = feparm.frequency;
-
-               switch (feparm.bandwidth)
-               {
-               case eDVBFrontendParametersTerrestrial::Bandwidth::Bw8MHz:
-                       parm.u.ofdm.bandwidth = BANDWIDTH_8_MHZ;
-                       break;
-               case eDVBFrontendParametersTerrestrial::Bandwidth::Bw7MHz:
-                       parm.u.ofdm.bandwidth = BANDWIDTH_7_MHZ;
-                       break;
-               case eDVBFrontendParametersTerrestrial::Bandwidth::Bw6MHz:
-                       parm.u.ofdm.bandwidth = BANDWIDTH_6_MHZ;
-                       break;
-               default:
-               case eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto:
-                       parm.u.ofdm.bandwidth = BANDWIDTH_AUTO;
-                       break;
-               }
-               switch (feparm.code_rate_LP)
-               {
-               case eDVBFrontendParametersCable::FEC::f1_2:
-                       parm.u.ofdm.code_rate_LP = FEC_1_2;
-                       break;
-               case eDVBFrontendParametersCable::FEC::f2_3:
-                       parm.u.ofdm.code_rate_LP = FEC_2_3;
-                       break;
-               case eDVBFrontendParametersCable::FEC::f3_4:
-                       parm.u.ofdm.code_rate_LP = FEC_3_4;
-                       break;
-               case eDVBFrontendParametersCable::FEC::f5_6:
-                       parm.u.ofdm.code_rate_LP = FEC_5_6;
-                       break;
-               case eDVBFrontendParametersCable::FEC::f7_8:
-                       parm.u.ofdm.code_rate_LP = FEC_7_8;
-                       break;
-               default:
-               case eDVBFrontendParametersCable::FEC::fAuto:
-               case eDVBFrontendParametersCable::FEC::fNone:
-                       parm.u.ofdm.code_rate_LP = FEC_AUTO;
-                       break;
-               }
-               switch (feparm.code_rate_HP)
-               {
-               case eDVBFrontendParametersCable::FEC::f1_2:
-                       parm.u.ofdm.code_rate_HP = FEC_1_2;
-                       break;
-               case eDVBFrontendParametersCable::FEC::f2_3:
-                       parm.u.ofdm.code_rate_HP = FEC_2_3;
-                       break;
-               case eDVBFrontendParametersCable::FEC::f3_4:
-                       parm.u.ofdm.code_rate_HP = FEC_3_4;
-                       break;
-               case eDVBFrontendParametersCable::FEC::f5_6:
-                       parm.u.ofdm.code_rate_HP = FEC_5_6;
-                       break;
-               case eDVBFrontendParametersCable::FEC::f7_8:
-                       parm.u.ofdm.code_rate_HP = FEC_7_8;
-                       break;
-               default:
-               case eDVBFrontendParametersCable::FEC::fAuto:
-               case eDVBFrontendParametersCable::FEC::fNone:
-                       parm.u.ofdm.code_rate_HP = FEC_AUTO;
-                       break;
-               }
-               switch (feparm.modulation)
-               {
-               case eDVBFrontendParametersTerrestrial::Modulation::QPSK:
-                       parm.u.ofdm.constellation = QPSK;
-                       break;
-               case eDVBFrontendParametersTerrestrial::Modulation::QAM16:
-                       parm.u.ofdm.constellation = QAM_16;
-                       break;
-               default:
-               case eDVBFrontendParametersTerrestrial::Modulation::Auto:
-                       parm.u.ofdm.constellation = QAM_AUTO;
-                       break;
-               }
-               switch (feparm.transmission_mode)
-               {
-               case eDVBFrontendParametersTerrestrial::TransmissionMode::TM2k:
-                       parm.u.ofdm.transmission_mode = TRANSMISSION_MODE_2K;
-                       break;
-               case eDVBFrontendParametersTerrestrial::TransmissionMode::TM8k:
-                       parm.u.ofdm.transmission_mode = TRANSMISSION_MODE_8K;
-                       break;
-               default:
-               case eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto:
-                       parm.u.ofdm.transmission_mode = TRANSMISSION_MODE_AUTO;
-                       break;
-               }
-               switch (feparm.guard_interval)
-               {
-                       case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_32:
-                               parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_32;
-                               break;
-                       case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_16:
-                               parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_16;
-                               break;
-                       case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_8:
-                               parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_8;
-                               break;
-                       case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_4:
-                               parm.u.ofdm.guard_interval = GUARD_INTERVAL_1_4;
-                               break;
-                       default:
-                       case eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto:
-                               parm.u.ofdm.guard_interval = GUARD_INTERVAL_AUTO;
-                               break;
-               }
-               switch (feparm.hierarchy)
-               {
-                       case eDVBFrontendParametersTerrestrial::Hierarchy::H1:
-                               parm.u.ofdm.hierarchy_information = HIERARCHY_1;
-                               break;
-                       case eDVBFrontendParametersTerrestrial::Hierarchy::H2:
-                               parm.u.ofdm.hierarchy_information = HIERARCHY_2;
-                               break;
-                       case eDVBFrontendParametersTerrestrial::Hierarchy::H4:
-                               parm.u.ofdm.hierarchy_information = HIERARCHY_4;
-                               break;
-                       default:
-                       case eDVBFrontendParametersTerrestrial::Hierarchy::HAuto:
-                               parm.u.ofdm.hierarchy_information = HIERARCHY_AUTO;
-                               break;
-               }
+               res=prepare_terrestrial(feparm);
+               if (!res)
+                       m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
+               break;
        }
        }
 
-       m_sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
-       m_tuneTimer->start(0,true);
-       m_timeout->stop();
-       m_sec_sequence.current() = m_sec_sequence.begin();
-
-       if (m_state != stateTuning)
+       if (!res)  // prepare ok
        {
-               m_tuning = 1;
-               m_state = stateTuning;
-               m_stateChanged(this);
+               m_tuneTimer->start(0,true);
+               m_timeout->stop();
+               m_sec_sequence.current() = m_sec_sequence.begin();
+
+               if (m_state != stateTuning)
+               {
+                       m_tuning = 1;
+                       m_state = stateTuning;
+                       m_stateChanged(this);
+               }
        }
 
-       return 0;
+       return res;
 }
 
 RESULT eDVBFrontend::connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection)

diff --git a/lib/dvb/frontend.h b/lib/dvb/frontend.h
index 2cccf885dd0c30d6bc5ee1c6cf7fd565f9eb0bde..c28399b4852d1e1031ef082ecfb5c6345fd58b54 100644 (file)
--- a/lib/dvb/frontend.h
+++ b/lib/dvb/frontend.h
@@ -69,6 +69,7 @@ class eDVBFrontend: public iDVBFrontend, public Object
 
        int m_idleInputpower[2];  // 13V .. 18V
        int m_runningInputpower;
+
        int m_timeoutCount; // needed for timeout
        int m_retryCount; // diseqc retry for rotor
        int m_curVoltage;
@@ -85,6 +86,9 @@ public:
 
        RESULT getFrontendType(int &type);
        RESULT tune(const iDVBFrontendParameters &where);
+       RESULT prepare_sat(const eDVBFrontendParametersSatellite &);
+       RESULT prepare_cable(const eDVBFrontendParametersCable &);
+       RESULT prepare_terrestrial(const eDVBFrontendParametersTerrestrial &);
        RESULT connectStateChange(const Slot1<void,iDVBFrontend*> &stateChange, ePtr<eConnection> &connection);
        RESULT getState(int &state);
        RESULT setTone(int tone);
@@ -96,7 +100,7 @@ public:
        RESULT getData(int num, int &data);
        RESULT setData(int num, int val);
 
-       int readFrontendData(int type); // bitErrorRate, signalPower, signalQuality
+       int readFrontendData(int type); // bitErrorRate, signalPower, signalQuality, Locked, Synced
        int isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm);
        int getID() { return m_fe; }
 

diff --git a/lib/dvb/idvb.h b/lib/dvb/idvb.h
index da7ac3b5ca033ded6019feb0abfa0633ac1a7bbc..ada337c8e68e9b4492e15472d811a7f28bda5cc9 100644 (file)
--- a/lib/dvb/idvb.h
+++ b/lib/dvb/idvb.h
@@ -358,7 +358,7 @@ public:
        virtual RESULT setSecSequence(const eSecCommandList &list)=0;
 
        enum {
-               bitErrorRate, signalPower, signalQuality
+               bitErrorRate, signalPower, signalQuality, Locked, Synced
        };
        virtual int readFrontendData(int type)=0;
 
@@ -372,7 +372,7 @@ public:
 class iDVBSatelliteEquipmentControl: public iObject
 {
 public:
-       virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat, int frontend_id)=0;
+       virtual RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, const eDVBFrontendParametersSatellite &sat, int frontend_id)=0;
        virtual int canTune(const eDVBFrontendParametersSatellite &feparm, iDVBFrontend *fe, int frontend_id)=0;
        virtual void setRotorMoving(bool)=0;
 };

diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp
index aeaf5a2ae33c34470164882dded478b380820e20..4d6558da3335127f46b30ced5901f7ac4aa3ebb9 100644 (file)
--- a/lib/dvb/sec.cpp
+++ b/lib/dvb/sec.cpp
@@ -271,7 +271,7 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite
 
 #define VOLTAGE(x) (lnb_param.m_increased_voltage ? iDVBFrontend::voltage##x##_5 : iDVBFrontend::voltage##x)
 
-RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat, int frontend_id)
+RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, const eDVBFrontendParametersSatellite &sat, int frontend_id)
 {
        bool linked=false;
        bool depend_satpos_mode=false;
@@ -289,7 +289,7 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                if ( sit != lnb_param.m_satellites.end())
                {
                        eDVBSatelliteSwitchParameters &sw_param = sit->second;
-
+                       bool doSetVoltageToneFrontend = true;
                        int band=0,
                                linked_to=-1, // linked tuner
                                satpos_depends_to=-1,
@@ -554,8 +554,12 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                        sec_sequence.push_back( eSecCommand(eSecCommand::IF_NOT_VOLTAGE_GOTO, compare) );
 
                                        if ( RotorCmd != -1 && RotorCmd != lastRotorCmd )
-                                               // TODO .. add handling for turning rotor without measure inputpower
-                                               compare.voltage = VOLTAGE(18);
+                                       {
+                                               if (rotor_param.m_inputpower_parameters.m_use)
+                                                       compare.voltage = VOLTAGE(18);  // in input power mode turn rotor always with 18V (fast)
+                                               else
+                                                       compare.voltage = VOLTAGE(13);  // in normal mode start turning with 13V
+                                       }
                                        else
                                                compare.voltage = voltage;
 
@@ -652,8 +656,11 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                        // else we set voltage after all diseqc stuff..
                                        sec_sequence.push_back( eSecCommand(eSecCommand::IF_NOT_VOLTAGE_GOTO, compare) );
 
-                                       // TODO .. add handling for turning rotor without measure inputpower
-                                       sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) );
+                                       if (rotor_param.m_inputpower_parameters.m_use)
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) ); // in normal mode start turning with 13V
+                                       else
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) ); // turn always with 18V
+
                                        // voltage was disabled..so we wait a longer time ..
                                        sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 500) );
                                        sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, +7) );  // no need to send stop rotor cmd
@@ -741,13 +748,46 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                                sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +3 ) );  // 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_POWER_LIMITING_MODE, eSecCommand::modeDynamic) );
-                                               frontend.setData(3, RotorCmd);
-                                               frontend.setData(4, sat.orbital_position);
                                        }
                                        else
-                                               eFatal("rotor turning without inputpowermeasure not implemented yet");
+                                       {  // use normal turning mode
+                                               doSetVoltageToneFrontend=false;
+                                               eSecCommand::rotor cmd;
+                                               eSecCommand::pair compare;
+                                               compare.voltage = VOLTAGE(13);
+                                               compare.steps = +2;
+                                               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, 200) );  // wait 200msec after voltage change
+
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeStatic) );
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_ROTORPARMS) );
+                                               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) );
+
+                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, 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, 480) );  // 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_POWER_LIMITING_MODE, eSecCommand::modeDynamic) );
+                                       frontend.setData(3, RotorCmd);
+                                       frontend.setData(4, sat.orbital_position);
                                }
                        }
                        else
@@ -760,15 +800,21 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                        if ( linked )
                                return 0;
 
-                       eSecCommand::pair compare;
-                       compare.voltage = voltage;
-                       compare.steps = +3;
-                       sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // voltage already correct ?
-                       sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) );
-                       sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 10) );
-
-                       sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, tone) );
-                       sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 15) );
+                       if (doSetVoltageToneFrontend)
+                       {
+                               eSecCommand::pair compare;
+                               compare.voltage = voltage;
+                               compare.steps = +3;
+                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // voltage already correct ?
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) );
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 10) );
+
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, tone) );
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 15) );
+
+                               sec_sequence.push_back( eSecCommand(eSecCommand::START_TUNE_TIMEOUT) );
+                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
+                       }
 
                        frontend.setSecSequence(sec_sequence);
 

diff --git a/lib/dvb/sec.h b/lib/dvb/sec.h
index ac18f3c66116d7cd8ce04456389a29778725f836..d86d96eaba184d9b7002805edd372168eff159bb 100644 (file)
--- a/lib/dvb/sec.h
+++ b/lib/dvb/sec.h
@@ -19,7 +19,9 @@ public:
                MEASURE_IDLE_INPUTPOWER, MEASURE_RUNNING_INPUTPOWER,
                IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, IF_INPUTPOWER_DELTA_GOTO,
                UPDATE_CURRENT_ROTORPARAMS, INVALIDATE_CURRENT_ROTORPARMS,
-               IF_ROTORPOS_VALID_GOTO
+               IF_ROTORPOS_VALID_GOTO,
+               IF_TUNER_LOCKED_GOTO,
+               START_TUNE_TIMEOUT
        };
        int cmd;
        struct rotor
@@ -250,7 +252,7 @@ public:
 #ifndef SWIG
        eDVBSatelliteEquipmentControl(eSmartPtrList<eDVBRegisteredFrontend> &avail_frontends);
        DECLARE_REF(eDVBSatelliteEquipmentControl);
-       RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat, int frontend_id);
+       RESULT prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, const eDVBFrontendParametersSatellite &sat, int frontend_id);
        int canTune(const eDVBFrontendParametersSatellite &feparm, iDVBFrontend *, int frontend_id);
        bool currentLNBValid() { return m_lnbidx > -1 && m_lnbidx < (int)(sizeof(m_lnbs) / sizeof(eDVBSatelliteLNBParameters)); }
 #endif