git.cweiske.de / enigma2.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
dont switch to 18V and measure input current, when slow rotor tuning is selected
[enigma2.git] / lib / dvb / sec.cpp
diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp
index c1caa3801f596f33e3b2d918751ee90c1d21327b..a56dbf0486ff1c2198e60d83af93c3eb1ab57532 100644 (file)
--- a/lib/dvb/sec.cpp
+++ b/lib/dvb/sec.cpp
@@ -371,6 +371,8 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                        bool doSetFrontend = true;
                        bool doSetVoltageToneFrontend = true;
                        bool sendDiSEqC = false;
+                       bool forceChanged = false;
+                       bool needDiSEqCReset = false;
                        long band=0,
                                voltage = iDVBFrontend::voltageOff,
                                tone = iDVBFrontend::toneOff,
@@ -384,7 +386,13 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                curRotorPos = -1,
                                satposDependPtr = -1;
                        iDVBFrontend *sec_fe=&frontend;
+                       eDVBRegisteredFrontend *linked_fe = 0;
                        eDVBSatelliteDiseqcParameters::t_diseqc_mode diseqc_mode = di_param.m_diseqc_mode;
+                       eDVBSatelliteSwitchParameters::t_voltage_mode voltage_mode = sw_param.m_voltage_mode;
+                       bool diseqc13V = voltage_mode == eDVBSatelliteSwitchParameters::HV_13;
+
+                       if (diseqc13V)
+                               voltage_mode = eDVBSatelliteSwitchParameters::HV;
 
                        frontend.getData(eDVBFrontend::SATPOS_DEPENDS_PTR, satposDependPtr);
 
@@ -394,12 +402,20 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                frontend.getData(eDVBFrontend::LINKED_PREV_PTR, linked_prev_ptr);
                                while (linked_prev_ptr != -1)
                                {
-                                       eDVBRegisteredFrontend *linked_fe = (eDVBRegisteredFrontend*) linked_prev_ptr;
+                                       linked_fe = (eDVBRegisteredFrontend*) linked_prev_ptr;
                                        sec_fe = linked_fe->m_frontend;
                                        sec_fe->getData(eDVBFrontend::LINKED_PREV_PTR, (long&)linked_prev_ptr);
                                }
                                if (satposDependPtr != -1)  // we dont need uncommitted switch and rotor cmds on second output of a rotor lnb
                                        diseqc_mode = eDVBSatelliteDiseqcParameters::V1_0;
+                               else {
+                                       // in eDVBFrontend::tuneLoop we call closeFrontend and ->inc_use() in this this condition (to put the kernel frontend thread into idle state)
+                                       // so we must resend all diseqc stuff (voltage is disabled when the frontend is closed)
+                                       int state;
+                                       sec_fe->getState(state);
+                                       if (!linked_fe->m_inuse && state != eDVBFrontend::stateIdle)
+                                               forceChanged = true;
+                               }
                        }
 
                        sec_fe->getData(eDVBFrontend::CSW, lastcsw);
@@ -408,6 +424,9 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                        sec_fe->getData(eDVBFrontend::ROTOR_CMD, lastRotorCmd);
                        sec_fe->getData(eDVBFrontend::ROTOR_POS, curRotorPos);
 
+                       if (lastcsw == lastucsw && lastToneburst == lastucsw && lastucsw == -1)
+                               needDiSEqCReset = true;
+
                        if ( sat.frequency > lnb_param.m_lof_threshold )
                                band |= 1;
 
@@ -423,13 +442,13 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                        if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical))
                                band |= 2;
 
-                       if ( sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::_14V
+                       if ( voltage_mode == eDVBSatelliteSwitchParameters::_14V
                                || ( sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical
-                                       && sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::HV )  )
+                                       && voltage_mode == eDVBSatelliteSwitchParameters::HV )  )
                                voltage = VOLTAGE(13);
-                       else if ( sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::_18V
+                       else if ( voltage_mode == eDVBSatelliteSwitchParameters::_18V
                                || ( !(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical)
-                                       && sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::HV )  )
+                                       && voltage_mode == eDVBSatelliteSwitchParameters::HV )  )
                                voltage = VOLTAGE(18);
                        if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::ON)
                                || ( sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::HILO && (band&1) ) )
@@ -450,15 +469,15 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 
                                bool send_csw =
                                        (di_param.m_committed_cmd != eDVBSatelliteDiseqcParameters::SENDNO);
-                               bool changed_csw = send_csw && csw != lastcsw;
+                               bool changed_csw = send_csw && (forceChanged || csw != lastcsw);
 
                                bool send_ucsw =
                                        (di_param.m_uncommitted_cmd && diseqc_mode > eDVBSatelliteDiseqcParameters::V1_0);
-                               bool changed_ucsw = send_ucsw && ucsw != lastucsw;
+                               bool changed_ucsw = send_ucsw && (forceChanged || ucsw != lastucsw);
 
                                bool send_burst =
                                        (di_param.m_toneburst_param != eDVBSatelliteDiseqcParameters::NO);
-                               bool changed_burst = send_burst && toneburst != lastToneburst;
+                               bool changed_burst = send_burst && (forceChanged || toneburst != lastToneburst);
 
                                int send_mask = 0; /*
                                        1 must send csw
@@ -583,7 +602,9 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                                sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) );
                                                sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_CONT_TONE]) );
 
-                                               if ( RotorCmd != -1 && RotorCmd != lastRotorCmd )
+                                               if (diseqc13V)
+                                                       vlt = iDVBFrontend::voltage13;
+                                               else if ( RotorCmd != -1 && RotorCmd != lastRotorCmd )
                                                {
                                                        if (rotor_param.m_inputpower_parameters.m_use)
                                                                vlt = VOLTAGE(18);  // in input power mode set 18V for measure input power
@@ -613,6 +634,23 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                                sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_ENABLE_VOLTAGE_BEFORE_SWITCH_CMDS]) );
 
                                                sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_SWITCHPARMS) );
+                                               if (needDiSEqCReset)
+                                               {
+                                                       eDVBDiseqcCommand diseqc;
+                                                       memset(diseqc.data, 0, MAX_DISEQC_LENGTH);
+                                                       diseqc.len = 3;
+                                                       diseqc.data[0] = 0xE0;
+                                                       diseqc.data[1] = 0;
+                                                       diseqc.data[2] = 0;
+                                                       // diseqc reset
+                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
+                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_DISEQC_RESET_CMD]) );
+                                                       diseqc.data[2] = 3;
+                                                       // diseqc peripherial powersupply on
+                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
+                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_DISEQC_PERIPHERIAL_POWERON_CMD]) );
+                                               }
+
                                                for (int seq_repeat = 0; seq_repeat < (di_param.m_seq_repeat?2:1); ++seq_repeat)
                                                {
                                                        if ( send_mask & 4 )
@@ -759,17 +797,22 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                                        bool turn_fast = need_turn_fast(rotor_param.m_inputpower_parameters.m_turning_speed);
                                                        eSecCommand::rotor cmd;
                                                        eSecCommand::pair compare;
-                                                       compare.voltage = VOLTAGE(18);
+                                                       if (turn_fast)
+                                                               compare.voltage = VOLTAGE(18);
+                                                       else
+                                                               compare.voltage = VOLTAGE(13);
                                                        compare.steps = +3;
                                                        sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) );
                                                        sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) );
 // measure idle power values
-                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) );  // wait 150msec after voltage change
-                                                       sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 1) );
-                                                       compare.val = 1;
                                                        compare.steps = -2;
-                                                       sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) );
-                                                       sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) );
+                                                       if (turn_fast) {
+                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) );  // wait 150msec after voltage change
+                                                               sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 1) );
+                                                               compare.val = 1;
+                                                               sec_sequence.push_back( eSecCommand(eSecCommand::IF_MEASURE_IDLE_WAS_NOT_OK_GOTO, compare) );
+                                                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) );
+                                                       }
                                                        sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_VOLTAGE_CHANGE_BEFORE_MEASURE_IDLE_INPUTPOWER]) );  // wait 150msec before measure
                                                        sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 0) );
                                                        compare.val = 0;
@@ -863,8 +906,8 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                csw = band;
                        }
 
-                       if (sendDiSEqC)
-                               sec_sequence.push_front( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeStatic) );
+//                     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);
@@ -892,8 +935,9 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
                                sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
                        }
 
-                       if (sendDiSEqC)
-                               sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeDynamic) );
+//                     if (sendDiSEqC)
+                       sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
+                       sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeDynamic) );
 
                        frontend.setSecSequence(sec_sequence);
 
Clone of git://git.opendreambox.org/git/enigma2.git before dream multimedia removed all the engima2 sources