add unicable support (thx to adenin)

diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp
index 284844dc4323c9774207fa6786312a84824cb35b..aae7bbc2d58f239d66459c83c417476f0367a8c2 100644 (file)
--- 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_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();
                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;
 }
                "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 6e272aca852574a3f8bd2fb7fc40f79f2641b64f..8133488641d57e96a97e5153aa907227a2764b2c 100644 (file)
--- 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
                FREQ_OFFSET,          // current frequency offset
                CUR_VOLTAGE,          // current voltage
                CUR_TONE,             // current continuous tone

+               SATCR,                // current SatCR

                NUM_DATA_ENTRIES
        };
        Signal1<void,iDVBFrontend*> m_stateChanged;
                NUM_DATA_ENTRIES
        };
        Signal1<void,iDVBFrontend*> 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; }
        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
 };
 
 #endif // SWIG

diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp
index da2439f990f322001d405ab33db15c82f59d3fa1..6f64cf56425588837460c7d057da69aa9849d42c 100644 (file)
--- 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())
                {
                        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;
                        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,
                        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 ( 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 (!(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)
                        {
 
                        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]) );
                                                }
                                                        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;
                                        }
 
                                        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;
                                                {
                                                        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;
                                                }
                                                        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
                                                        else

+                                                       {  // use normal turning mode
+                                                               doSetVoltageToneFrontend=false;
+                                                               doSetFrontend=false;
+                                                               eSecCommand::rotor cmd;
+                                                               eSecCommand::pair compare;

                                                                compare.voltage = VOLTAGE(13);
                                                                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);
                                                }
                                                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;
                        }
 
                                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);
 
                        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;
                        {
                                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) );
 
 
                        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 (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;
                        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::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<eDVBRegisteredFrontend>::iterator it(m_avail_simulate_frontends.begin()); it != m_avail_simulate_frontends.end(); ++it)
        }
 
        for (eSmartPtrList<eDVBRegisteredFrontend>::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::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;
        }
 
        return 0;


@@ -1016,6 +1069,17 @@ RESULT eDVBSatelliteEquipmentControl::setLNBPrio(int prio)
        return 0;
 }
 
        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)
 
 /* DiSEqC Specific Parameters */
 RESULT eDVBSatelliteEquipmentControl::setDiSEqCMode(int diseqcmode)


@@ -1159,6 +1223,46 @@ RESULT eDVBSatelliteEquipmentControl::setInputpowerDelta(int delta)
        return 0;
 }
 
        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)
 {
 /* Satellite Specific Parameters */
 RESULT eDVBSatelliteEquipmentControl::addSatellite(int orbital_position)
 {

diff --git a/lib/dvb/sec.h b/lib/dvb/sec.h
index 2efd0b4985462b2179ade6b750d3b73a899d6c4f..5bff6bf71111e65b0ad2285f328794664e50c41e 100644 (file)
--- 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
 
        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;
 };
 
 class eDVBRegisteredFrontend;


@@ -307,6 +324,7 @@ public:
        RESULT setLNBThreshold(int threshold);
        RESULT setLNBIncreasedVoltage(bool onoff);
        RESULT setLNBPrio(int prio);
        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);
 /* 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..
        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);
 /* 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 168962e97e395585b0005989a6fbe7a5f4b79e3d..1fcbda1ac333f31bb602c6bf836f3e8e74a356a3 100644 (file)
--- 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)
                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)
                sec.setLNBLOFL(9750000)
                sec.setLNBLOFH(10600000)
                sec.setLNBThreshold(11700000)


@@ -255,6 +257,9 @@ class SecConfigure:
                                currLnb = config.Nims[slotid].advanced.lnb[x]
                                sec.addLNB()
 
                                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]:
                                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)
 
                                        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)
                                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)
                                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())
 
        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]
        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())
 
                        nim.advanced.lnb = ConfigSubList()
                        nim.advanced.lnb.append(ConfigNothing())

+                       
+

                        for x in range(1, 37):
                                nim.advanced.lnb.append(ConfigSubsection())
                        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].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")
 #                              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)
                                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(
                                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 320bea8444a671704b0850a5fe52d56c1a763908..da6fcc123ea63726cdff2368d7a7706e1098aa5a 100644 (file)
--- 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.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)
 
                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, \
                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:
                        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
 
                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)
                # LNBs
                self.advancedLnbsEntry = getConfigListEntry(_("LNB"), Sat.lnb)
                self.list.append(self.advancedLnbsEntry)

+

                if currLnb:
                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)
                        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()
                                                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 = [ ]
 
        def fillAdvancedList(self):
                self.list = [ ]