#include <lib/dvb/sec.h>
#include <lib/dvb/rotor_calc.h>
+#include <set>
+
#if HAVE_DVB_API_VERSION < 3
-#define INVERSION Inversion
#define FREQUENCY Frequency
-#define FEC_INNER FEC_inner
-#define SYMBOLRATE SymbolRate
#else
-#define INVERSION inversion
#define FREQUENCY frequency
-#define FEC_INNER fec_inner
-#define SYMBOLRATE symbol_rate
#endif
#include <lib/base/eerror.h>
eDVBSatelliteEquipmentControl *eDVBSatelliteEquipmentControl::instance;
+int eDVBSatelliteEquipmentControl::m_params[MAX_PARAMS];
+/*
+ defaults are set in python lib/python/Components/NimManager.py
+ in InitSecParams function via setParam call
+*/
+
+void eDVBSatelliteEquipmentControl::setParam(int param, int value)
+{
+ if (param >= 0 && param < MAX_PARAMS)
+ m_params[param]=value;
+}
+
eDVBSatelliteEquipmentControl::eDVBSatelliteEquipmentControl(eSmartPtrList<eDVBRegisteredFrontend> &avail_frontends)
:m_lnbidx(-1), m_curSat(m_lnbs[0].m_satellites.end()), m_avail_frontends(avail_frontends), m_rotorMoving(false)
{
addLNB();
setLNBTunerMask(3);
setLNBLOFL(9750000);
- setLNBThreshold(11750000);
+ setLNBThreshold(11700000);
setLNBLOFH(10607000);
setDiSEqCMode(eDVBSatelliteDiseqcParameters::V1_0);
setToneburst(eDVBSatelliteDiseqcParameters::NO);
addLNB();
setLNBTunerMask(3);
setLNBLOFL(9750000);
- setLNBThreshold(11750000);
+ setLNBThreshold(11700000);
setLNBLOFH(10600000);
setDiSEqCMode(eDVBSatelliteDiseqcParameters::V1_0);
setToneburst(eDVBSatelliteDiseqcParameters::NO);
addLNB();
setLNBTunerMask(3);
setLNBLOFL(9750000);
- setLNBThreshold(11750000);
+ setLNBThreshold(11700000);
setLNBLOFH(10600000);
setDiSEqCMode(eDVBSatelliteDiseqcParameters::V1_2);
setToneburst(eDVBSatelliteDiseqcParameters::NO);
setRotorPosNum(1); // stored pos 1
}
+static void checkLinkedParams(int direction, int &linked_ptr, int &ret, const eDVBFrontendParametersSatellite &sat, int csw, int ucsw, int toneburst, bool diseqc, bool rotor)
+{
+ eDVBRegisteredFrontend *linked_fe = (eDVBRegisteredFrontend*) linked_ptr;
+ int oRotorPos = -1;
+ linked_fe->m_frontend->getData(eDVBFrontend::ROTOR_POS, oRotorPos);
+ if (linked_fe->m_inuse)
+ {
+ int ocsw = -1,
+ oucsw = -1,
+ oToneburst = -1;
+ linked_fe->m_frontend->getData(eDVBFrontend::CSW, ocsw);
+ linked_fe->m_frontend->getData(eDVBFrontend::UCSW, oucsw);
+ linked_fe->m_frontend->getData(eDVBFrontend::TONEBURST, oToneburst);
+#if 0
+ eDebug("compare csw %02x == lcsw %02x",
+ csw, ocsw);
+ if ( diseqc )
+ eDebug("compare ucsw %02x == lucsw %02x\ncompare toneburst %02x == oToneburst %02x",
+ ucsw, oucsw, toneburst, oToneburst);
+ if ( rotor )
+ eDebug("compare pos %d == current pos %d",
+ sat.orbital_position, oRotorPos);
+#endif
+ if ( (csw != ocsw) ||
+ ( diseqc && (ucsw != oucsw || toneburst != oToneburst) ) ||
+ ( rotor && oRotorPos != sat.orbital_position ) )
+ {
+// eDebug("can not tune this transponder with linked tuner in use!!");
+ ret=0;
+ }
+// else
+// eDebug("OK .. can tune this transponder with linked tuner in use :)");
+ }
+ else if (rotor && oRotorPos != -1)
+ {
+ ret -= abs(oRotorPos-sat.orbital_position);
+// eDebug("decrement rotor pos for linked tuner!!");
+ }
+ linked_fe->m_frontend->getData(direction, linked_ptr);
+}
+
int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite &sat, iDVBFrontend *fe, int frontend_id )
{
- int ret=0;
+ int ret=0, satcount=0;
for (int idx=0; idx <= m_lnbidx; ++idx )
{
+ bool rotor=false;
eDVBSatelliteLNBParameters &lnb_param = m_lnbs[idx];
if ( lnb_param.tuner_mask & frontend_id ) // lnb for correct tuner?
{
eDVBSatelliteDiseqcParameters &di_param = lnb_param.m_diseqc_parameters;
+ satcount += lnb_param.m_satellites.size();
+
std::map<int, eDVBSatelliteSwitchParameters>::iterator sit =
lnb_param.m_satellites.find(sat.orbital_position);
if ( sit != lnb_param.m_satellites.end())
{
int band=0,
- linked_to=-1, // linked tuner
- satpos_depends_to=-1,
+ linked_prev_ptr=-1,
+ linked_next_ptr=-1,
+ satpos_depends_ptr=-1,
csw = di_param.m_committed_cmd,
ucsw = di_param.m_uncommitted_cmd,
toneburst = di_param.m_toneburst_param,
curRotorPos;
- fe->getData(6, curRotorPos);
- fe->getData(7, linked_to);
- fe->getData(8, satpos_depends_to);
+ fe->getData(eDVBFrontend::ROTOR_POS, curRotorPos);
+ fe->getData(eDVBFrontend::LINKED_PREV_PTR, linked_prev_ptr);
+ fe->getData(eDVBFrontend::LINKED_NEXT_PTR, linked_next_ptr);
+ fe->getData(eDVBFrontend::SATPOS_DEPENDS_PTR, satpos_depends_ptr);
if ( sat.frequency > lnb_param.m_lof_threshold )
band |= 1;
- if (sat.polarisation == eDVBFrontendParametersSatellite::Polarisation::Horizontal)
+ if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical))
band |= 2;
- bool rotor=false;
bool diseqc=false;
if (di_param.m_diseqc_mode >= eDVBSatelliteDiseqcParameters::V1_0)
csw |= band;
if ( di_param.m_diseqc_mode == eDVBSatelliteDiseqcParameters::V1_2 ) // ROTOR
- {
- rotor=true;
- if ( curRotorPos == sat.orbital_position )
- ret=20; // rotor on correct orbpos = prio 20
- else
- ret=10; // rotor must turn to correct orbpos = prio 10
- }
- else
- ret = 30; // no rotor = prio 30
+ rotor = true;
+
+ ret=10000;
+ if (rotor && curRotorPos != -1)
+ ret -= abs(curRotorPos-sat.orbital_position);
}
else
{
csw = band;
- ret = 40; // no diseqc = prio 40
+ ret = 15000;
}
- if (linked_to != -1) // check for linked tuners..
- {
- eDVBRegisteredFrontend *linked_fe = (eDVBRegisteredFrontend*) linked_to;
- if (linked_fe->m_inuse)
+ while (ret && linked_prev_ptr != -1) // check for linked tuners..
+ checkLinkedParams(eDVBFrontend::LINKED_PREV_PTR, linked_prev_ptr, ret, sat, csw, ucsw, toneburst, diseqc, rotor);
+
+ while (ret && linked_next_ptr != -1) // check for linked tuners..
+ checkLinkedParams(eDVBFrontend::LINKED_NEXT_PTR, linked_next_ptr, ret, sat, csw, ucsw, toneburst, diseqc, rotor);
+
+ if (ret)
+ if (satpos_depends_ptr != -1)
{
- int ocsw = -1,
- oucsw = -1,
- oToneburst = -1,
- oRotorPos = -1;
- linked_fe->m_frontend->getData(0, ocsw);
- linked_fe->m_frontend->getData(1, oucsw);
- linked_fe->m_frontend->getData(2, oToneburst);
- linked_fe->m_frontend->getData(6, oRotorPos);
-#if 0
- eDebug("compare csw %02x == lcsw %02x",
- csw, ocsw);
- if ( diseqc )
- eDebug("compare ucsw %02x == lucsw %02x\ncompare toneburst %02x == oToneburst %02x",
- ucsw, oucsw, toneburst, oToneburst);
- if ( rotor )
- eDebug("compare pos %d == current pos %d",
- sat.orbital_position, oRotorPos);
-#endif
- if ( (csw != ocsw) ||
- ( diseqc && (ucsw != oucsw || toneburst != oToneburst) ) ||
- ( rotor && oRotorPos != sat.orbital_position ) )
+ eDVBRegisteredFrontend *satpos_depends_to_fe = (eDVBRegisteredFrontend*) satpos_depends_ptr;
+ if ( satpos_depends_to_fe->m_inuse )
{
-// eDebug("can not tune this transponder with linked tuner in use!!");
- ret=0;
+ int oRotorPos = -1;
+ satpos_depends_to_fe->m_frontend->getData(eDVBFrontend::ROTOR_POS, oRotorPos);
+ if (!rotor || oRotorPos != sat.orbital_position)
+ {
+// eDebug("can not tune this transponder ... rotor on other tuner is positioned to %d", oRotorPos);
+ ret=0;
+ }
}
// else
-// eDebug("OK .. can tune this transponder with linked tuner in use :)");
+// eDebug("OK .. can tune this transponder satpos is correct :)");
}
- }
- if (satpos_depends_to != -1) // check for linked tuners..
+ if (ret)
{
- eDVBRegisteredFrontend *satpos_depends_to_fe = (eDVBRegisteredFrontend*) satpos_depends_to;
- if ( satpos_depends_to_fe->m_inuse )
+ int lof = sat.frequency > lnb_param.m_lof_threshold ?
+ lnb_param.m_lof_hi : lnb_param.m_lof_lo;
+ int tuner_freq = abs(sat.frequency - lof);
+// eDebug("tuner freq %d", tuner_freq);
+ if (tuner_freq < 900000 || tuner_freq > 2200000)
{
- int oRotorPos = -1;
- satpos_depends_to_fe->m_frontend->getData(6, oRotorPos);
- if (!rotor || oRotorPos != sat.orbital_position)
- {
-// eDebug("can not tune this transponder ... rotor on other tuner is positioned to %d", oRotorPos);
- ret=0;
- }
+ ret=0;
+// eDebug("Transponder not tuneable with this lnb... %d Khz out of tuner range",
+// tuner_freq);
}
-// else
-// eDebug("OK .. can tune this transponder satpos is correct :)");
}
}
}
}
+ if (ret && satcount)
+ ret -= (satcount-1);
return ret;
}
#define VOLTAGE(x) (lnb_param.m_increased_voltage ? iDVBFrontend::voltage##x##_5 : iDVBFrontend::voltage##x)
-RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat, int frontend_id)
+RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, const eDVBFrontendParametersSatellite &sat, int frontend_id)
{
bool linked=false;
bool depend_satpos_mode=false;
if ( sit != lnb_param.m_satellites.end())
{
eDVBSatelliteSwitchParameters &sw_param = sit->second;
-
+ bool doSetVoltageToneFrontend = true;
+ bool doSetFrontend = true;
int band=0,
- linked_to=-1, // linked tuner
- satpos_depends_to=-1,
+ linked_prev_ptr=-1, // linked tuner
+ linked_next_ptr=-1, // linked tuner
+ satpos_depends_ptr=-1,
voltage = iDVBFrontend::voltageOff,
tone = iDVBFrontend::toneOff,
csw = di_param.m_committed_cmd,
lastRotorCmd = -1,
curRotorPos = -1;
- frontend.getData(0, lastcsw);
- frontend.getData(1, lastucsw);
- frontend.getData(2, lastToneburst);
- frontend.getData(5, lastRotorCmd);
- frontend.getData(6, curRotorPos);
- frontend.getData(7, linked_to);
- frontend.getData(8, satpos_depends_to);
+ frontend.getData(eDVBFrontend::CSW, lastcsw);
+ frontend.getData(eDVBFrontend::UCSW, lastucsw);
+ frontend.getData(eDVBFrontend::TONEBURST, lastToneburst);
+ frontend.getData(eDVBFrontend::ROTOR_CMD, lastRotorCmd);
+ frontend.getData(eDVBFrontend::ROTOR_POS, curRotorPos);
+ frontend.getData(eDVBFrontend::LINKED_PREV_PTR, linked_prev_ptr);
+ frontend.getData(eDVBFrontend::LINKED_NEXT_PTR, linked_next_ptr);
+ frontend.getData(eDVBFrontend::SATPOS_DEPENDS_PTR, satpos_depends_ptr);
- if (linked_to != -1)
+ while (linked_prev_ptr != -1) // check for linked tuners..
{
- eDVBRegisteredFrontend *linked_fe = (eDVBRegisteredFrontend*) linked_to;
+ eDVBRegisteredFrontend *linked_fe = (eDVBRegisteredFrontend*) linked_prev_ptr;
if (linked_fe->m_inuse)
{
eDebug("[SEC] frontend is linked with another and the other one is in use.. so we dont do SEC!!");
linked=true;
+ break;
}
+ linked_fe->m_frontend->getData(eDVBFrontend::LINKED_PREV_PTR, linked_prev_ptr);
}
- if (satpos_depends_to != -1)
+ if (!linked)
+ while (linked_next_ptr != -1) // check for linked tuners..
+ {
+ eDVBRegisteredFrontend *linked_fe = (eDVBRegisteredFrontend*) linked_next_ptr;
+ if (linked_fe->m_inuse)
+ {
+ eDebug("[SEC] frontend is linked with another and the other one is in use.. so we dont do SEC!!");
+ linked=true;
+ break;
+ }
+ linked_fe->m_frontend->getData(eDVBFrontend::LINKED_NEXT_PTR, linked_next_ptr);
+ }
+
+ if (satpos_depends_ptr != -1)
{
- eDVBRegisteredFrontend *satpos_fe = (eDVBRegisteredFrontend*) satpos_depends_to;
+ eDVBRegisteredFrontend *satpos_fe = (eDVBRegisteredFrontend*) satpos_depends_ptr;
if (satpos_fe->m_inuse)
{
if ( di_param.m_diseqc_mode != eDVBSatelliteDiseqcParameters::V1_2 )
parm.FREQUENCY = abs(parm.FREQUENCY);
- if (sat.polarisation == eDVBFrontendParametersSatellite::Polarisation::Horizontal)
- band |= 2;
+ frontend.setData(eDVBFrontend::FREQ_OFFSET, sat.frequency - parm.FREQUENCY);
- switch (sat.inversion)
- {
- case eDVBFrontendParametersCable::Inversion::On:
- parm.INVERSION = INVERSION_ON;
- break;
- case eDVBFrontendParametersCable::Inversion::Off:
- parm.INVERSION = INVERSION_OFF;
- break;
- default:
- case eDVBFrontendParametersCable::Inversion::Unknown:
- parm.INVERSION = INVERSION_AUTO;
- break;
- }
-
- switch (sat.fec)
- {
- default:
- case eDVBFrontendParametersSatellite::FEC::fNone:
- eDebug("no fec set.. assume auto");
- case eDVBFrontendParametersSatellite::FEC::fAuto:
- parm.u.qpsk.FEC_INNER = FEC_AUTO;
- break;
- case eDVBFrontendParametersSatellite::FEC::f1_2:
- parm.u.qpsk.FEC_INNER = FEC_1_2;
- break;
- case eDVBFrontendParametersSatellite::FEC::f2_3:
- parm.u.qpsk.FEC_INNER = FEC_2_3;
- break;
- case eDVBFrontendParametersSatellite::FEC::f3_4:
- parm.u.qpsk.FEC_INNER = FEC_3_4;
- break;
- case eDVBFrontendParametersSatellite::FEC::f5_6:
- parm.u.qpsk.FEC_INNER = FEC_5_6;
- break;
- case eDVBFrontendParametersSatellite::FEC::f7_8:
- parm.u.qpsk.FEC_INNER = FEC_7_8;
- break;
- }
-
- parm.u.qpsk.SYMBOLRATE = sat.symbol_rate;
+ if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical))
+ band |= 2;
if ( sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::_14V
- || ( sat.polarisation == eDVBFrontendParametersSatellite::Polarisation::Vertical
+ || ( sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical
&& sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::HV ) )
voltage = VOLTAGE(13);
else if ( sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::_18V
- || ( sat.polarisation == eDVBFrontendParametersSatellite::Polarisation::Horizontal
+ || ( !(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical)
&& sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::HV ) )
voltage = VOLTAGE(18);
if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::ON)
int RotorCmd=-1;
bool useGotoXX = false;
- if ( di_param.m_diseqc_mode == eDVBSatelliteDiseqcParameters::V1_2 )
+ if ( di_param.m_diseqc_mode == eDVBSatelliteDiseqcParameters::V1_2
+ && !sat.no_rotor_command_on_tune )
{
if (depend_satpos_mode || linked)
// in this both modes we dont really turn the rotor.... but in canTune we need the satpos
- frontend.setData(6, sat.orbital_position);
+ frontend.setData(eDVBFrontend::ROTOR_POS, sat.orbital_position);
else
{
if (sw_param.m_rotorPosNum) // we have stored rotor pos?
RotorCmd = (tmp/10)*0x10 + gotoXTable[ tmp % 10 ];
RotorCmd |= 0xD000;
}
- else // west
+ else // west
{
int tmp=(int)round( fabs( 360 - satHourAngle ) * 10.0 );
RotorCmd = (tmp/10)*0x10 + gotoXTable[ tmp % 10 ];
if ( send_mask )
{
- sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) );
- sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 15) );
eSecCommand::pair compare;
+ compare.steps = +3;
+ compare.tone = iDVBFrontend::toneOff;
+ sec_sequence.push_back( eSecCommand(eSecCommand::IF_TONE_GOTO, compare) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_CONT_TONE]) );
compare.voltage = iDVBFrontend::voltageOff;
- compare.steps = +4;
+ compare.steps = +3;
// the next is a check if voltage is switched off.. then we first set a voltage :)
// else we set voltage after all diseqc stuff..
sec_sequence.push_back( eSecCommand(eSecCommand::IF_NOT_VOLTAGE_GOTO, compare) );
if ( RotorCmd != -1 && RotorCmd != lastRotorCmd )
- // TODO .. add handling for turning rotor without measure inputpower
- compare.voltage = VOLTAGE(18);
+ {
+ if (rotor_param.m_inputpower_parameters.m_use)
+ compare.voltage = VOLTAGE(18); // in input power mode set 18V for measure input power
+ else
+ compare.voltage = VOLTAGE(13); // in normal mode start turning with 13V
+ }
else
compare.voltage = voltage;
- // voltage already correct ?
- sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) );
- compare.steps = +3;
sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, compare.voltage) );
- // voltage was disabled..so we wait a longer time .. for normal switches 200ms should be enough
- sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 200) );
+
+ // voltage was disabled..so we wait a longer time .. for normal switches 250ms should be enough
+ sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_ENABLE_VOLTAGE_BEFORE_SWITCH_CMDS]) );
for (int seq_repeat = 0; seq_repeat < (di_param.m_seq_repeat?2:1); ++seq_repeat)
{
if ( send_mask & 4 )
{
sec_sequence.push_back( eSecCommand(eSecCommand::SEND_TONEBURST, di_param.m_toneburst_param) );
- sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_TONEBURST]) );
}
int loops=0;
if ( send_mask & 2 )
++loops;
- for ( int i=0; i < di_param.m_repeats; ++i )
- loops *= 2;
+ loops <<= di_param.m_repeats;
for ( int i = 0; i < loops;) // fill commands...
{
diseqc.data[2] = 0x38;
diseqc.data[3] = csw;
}
- else
+ else // no committed command confed.. so send uncommitted..
{
- diseqc.data[2] = 0x00;
- diseqc.data[3] = 0x00;
+ diseqc.data[2] = 0x39;
+ diseqc.data[3] = ucsw;
}
sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
cmd=0x39;
else if (diseqc.data[2] == 0x39 && (send_mask & 1))
cmd=0x38;
+ int tmp = m_params[DELAY_BETWEEN_DISEQC_REPEATS];
if (cmd)
{
- static int delay = (120 - 54) / 2; // standard says 100msek between two repeated commands
+ int delay = di_param.m_repeats ? (tmp - 54) / 2 : tmp; // standard says 100msek between two repeated commands
sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, delay) );
diseqc.data[2]=cmd;
diseqc.data[3]=(cmd==0x38) ? csw : ucsw;
if ( i < loops )
sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, delay ) );
else
- sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_LAST_DISEQC_CMD]) );
}
else // delay 120msek when no command is in repeat gap
- sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 120) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, tmp) );
}
else
- sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_LAST_DISEQC_CMD]) );
}
if ( send_mask & 8 ) // toneburst at end of sequence
{
sec_sequence.push_back( eSecCommand(eSecCommand::SEND_TONEBURST, di_param.m_toneburst_param) );
- sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_TONEBURST]) );
}
}
}
if ( RotorCmd != -1 && RotorCmd != lastRotorCmd )
{
eSecCommand::pair compare;
- compare.voltage = iDVBFrontend::voltageOff;
- compare.steps = +4;
- // the next is a check if voltage is switched off.. then we first set a voltage :)
- // else we set voltage after all diseqc stuff..
- sec_sequence.push_back( eSecCommand(eSecCommand::IF_NOT_VOLTAGE_GOTO, compare) );
-
- // TODO .. add handling for turning rotor without measure inputpower
- sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) );
- // voltage was disabled..so we wait a longer time ..
- sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 500) );
- sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, +4) ); // no need to send stop rotor cmd
-
- eDVBDiseqcCommand diseqc;
- if ( !send_mask ) // no switch changed.. so we send first the rotor stop command
+ if (!send_mask)
{
- diseqc.len = 3;
- diseqc.data[0] = 0xE0;
- diseqc.data[1] = 0x31; // positioner
- diseqc.data[2] = 0x60; // stop
- sec_sequence.push_back( eSecCommand(eSecCommand::IF_ROTORPOS_VALID_GOTO, +3) );
- sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
- // wait 300msec after send rotor stop cmd
- sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 300) );
+ compare.steps = +3;
+ compare.tone = iDVBFrontend::toneOff;
+ sec_sequence.push_back( eSecCommand(eSecCommand::IF_TONE_GOTO, compare) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_CONT_TONE]) );
+
+ compare.voltage = iDVBFrontend::voltageOff;
+ compare.steps = +4;
+ // the next is a check if voltage is switched off.. then we first set a voltage :)
+ // else we set voltage after all diseqc stuff..
+ sec_sequence.push_back( eSecCommand(eSecCommand::IF_NOT_VOLTAGE_GOTO, compare) );
+
+ if (rotor_param.m_inputpower_parameters.m_use)
+ sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) ); // set 18V for measure input power
+ else
+ sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) ); // in normal mode start turning with 13V
+
+ sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_ENABLE_VOLTAGE_BEFORE_MOTOR_CMD]) ); // wait 750ms when voltage was disabled
+ sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, +9) ); // no need to send stop rotor cmd and recheck voltage
}
else
- {
- // wait 500msec after switching to rotor
- sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 500) );
- sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, +2) );
- sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, +1) );
- }
+ sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_BETWEEN_SWITCH_AND_MOTOR_CMD]) ); // wait 700ms when diseqc changed
+
+ eDVBDiseqcCommand diseqc;
+ diseqc.len = 3;
+ diseqc.data[0] = 0xE0;
+ diseqc.data[1] = 0x31; // positioner
+ diseqc.data[2] = 0x60; // stop
+ sec_sequence.push_back( eSecCommand(eSecCommand::IF_ROTORPOS_VALID_GOTO, +5) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
+ // wait 150msec after send rotor stop cmd
+ sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_MOTOR_STOP_CMD]) );
diseqc.data[0] = 0xE0;
diseqc.data[1] = 0x31; // positioner
eSecCommand::rotor cmd;
eSecCommand::pair compare;
compare.voltage = VOLTAGE(18);
- compare.steps = +2;
+ 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, 200) ); // wait 200msec after voltage change
+ 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.voltage = 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)) );
- sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 200) ); // wait 200msec before measure
+ 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.voltage = 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_POWER_LIMITING_MODE, eSecCommand::modeStatic) );
- sec_sequence.push_back( eSecCommand(eSecCommand::SET_ROTOR_DISEQC_RETRYS, 2) ); // 2 retries
+ 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
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, +9 ) ); // timeout .. we assume now the rotor is already at the correct position
+ sec_sequence.push_back( eSecCommand(eSecCommand::IF_NO_MORE_ROTOR_DISEQC_RETRYS_GOTO, +10 ) ); // 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_TIMEOUT, 2400) ); // 2 minutes running timeout
sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeDynamic) );
+ 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;
+ cmd.steps=+4;
sec_sequence.push_back( eSecCommand(eSecCommand::IF_INPUTPOWER_DELTA_GOTO, cmd ) );
- sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +3 ) ); // timeout ? this should never happen
+ sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +4 ) ); // timeout ? this should never happen
sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) ); // running loop start
/////////////////////
- sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) );
sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeDynamic) );
- frontend.setData(3, RotorCmd);
- frontend.setData(4, sat.orbital_position);
+ sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) );
}
else
- eFatal("rotor turning without inputpowermeasure not implemented yet");
+ { // 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::SET_POWER_LIMITING_MODE, eSecCommand::modeStatic) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::INVALIDATE_CURRENT_ROTORPARMS) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
+
+ compare.voltage = voltage;
+ compare.steps = +3;
+ sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // correct final voltage?
+ sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 2000) ); // wait 2 second before set high voltage
+ sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) );
+
+ 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_POWER_LIMITING_MODE, eSecCommand::modeDynamic) );
+ }
+ frontend.setData(eDVBFrontend::NEW_ROTOR_CMD, RotorCmd);
+ frontend.setData(eDVBFrontend::NEW_ROTOR_POS, sat.orbital_position);
}
}
else
csw = band;
- frontend.setData(0, csw);
- frontend.setData(1, ucsw);
- frontend.setData(2, di_param.m_toneburst_param);
+ frontend.setData(eDVBFrontend::CSW, csw);
+ frontend.setData(eDVBFrontend::UCSW, ucsw);
+ frontend.setData(eDVBFrontend::TONEBURST, di_param.m_toneburst_param);
- if ( linked )
- return 0;
-
- eSecCommand::pair compare;
- compare.voltage = voltage;
- compare.steps = +3;
- sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // voltage already correct ?
- sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) );
- sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 10) );
-
- sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, tone) );
- sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 15) );
+ if (!linked && doSetVoltageToneFrontend)
+ {
+ eSecCommand::pair compare;
+ compare.voltage = voltage;
+ compare.steps = +3;
+ sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // voltage already correct ?
+ sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, m_params[DELAY_AFTER_FINAL_VOLTAGE_CHANGE]) );
+ 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]) );
+ }
+ if (doSetFrontend)
+ {
+ sec_sequence.push_back( eSecCommand(eSecCommand::START_TUNE_TIMEOUT) );
+ sec_sequence.push_back( eSecCommand(eSecCommand::SET_FRONTEND) );
+ }
frontend.setSecSequence(sec_sequence);
return 0;
RESULT eDVBSatelliteEquipmentControl::clear()
{
- for (int i=0; i < m_lnbidx; ++i)
+ for (int i=0; i <= m_lnbidx; ++i)
{
m_lnbs[i].m_satellites.clear();
m_lnbs[i].tuner_mask = 0;
// clear linked tuner configuration
for (eSmartPtrList<eDVBRegisteredFrontend>::iterator it(m_avail_frontends.begin()); it != m_avail_frontends.end(); ++it)
- it->m_frontend->setData(7, -1);
-
- return 0;
-}
-
-// helper function for setTunerLinked and setTunerDepends
-RESULT eDVBSatelliteEquipmentControl::setDependencyPointers( int tu1, int tu2, int dest_data_byte )
-{
- if (tu1 == tu2)
- return -1;
-
- eDVBRegisteredFrontend *p1=NULL, *p2=NULL;
-
- int cnt=0;
- for (eSmartPtrList<eDVBRegisteredFrontend>::iterator it(m_avail_frontends.begin()); it != m_avail_frontends.end(); ++it, ++cnt)
{
- if (cnt == tu1)
- p1 = *it;
- else if (cnt == tu2)
- p2 = *it;
+ it->m_frontend->setData(eDVBFrontend::SATPOS_DEPENDS_PTR, -1);
+ it->m_frontend->setData(eDVBFrontend::LINKED_PREV_PTR, -1);
+ it->m_frontend->setData(eDVBFrontend::LINKED_NEXT_PTR, -1);
}
- if (p1 && p2)
- {
- p1->m_frontend->setData(dest_data_byte, (int)p2); // this is evil..
- p2->m_frontend->setData(dest_data_byte, (int)p1);
- return 0;
- }
- return -1;
+
+ return 0;
}
/* LNB Specific Parameters */
RESULT eDVBSatelliteEquipmentControl::addLNB()
{
- if ( m_lnbidx < (int)(sizeof(m_lnbs) / sizeof(eDVBSatelliteLNBParameters)))
+ if ( (m_lnbidx+1) < (int)(sizeof(m_lnbs) / sizeof(eDVBSatelliteLNBParameters)))
m_curSat=m_lnbs[++m_lnbidx].m_satellites.end();
else
{
return 0;
}
+struct sat_compare
+{
+ int orb_pos, lofl, lofh;
+ sat_compare(int o, int lofl, int lofh)
+ :orb_pos(o), lofl(lofl), lofh(lofh)
+ {}
+ sat_compare(const sat_compare &x)
+ :orb_pos(x.orb_pos), lofl(x.lofl), lofh(x.lofh)
+ {}
+ bool operator < (const sat_compare & cmp) const
+ {
+ if (orb_pos == cmp.orb_pos)
+ {
+ if ( abs(lofl-cmp.lofl) < 200000 )
+ {
+ if (abs(lofh-cmp.lofh) < 200000)
+ return false;
+ return lofh<cmp.lofh;
+ }
+ return lofl<cmp.lofl;
+ }
+ return orb_pos < cmp.orb_pos;
+ }
+};
+
+PyObject *eDVBSatelliteEquipmentControl::get_exclusive_satellites(int tu1, int tu2)
+{
+ ePyObject ret;
+
+ if (tu1 != tu2)
+ {
+ eDVBRegisteredFrontend *p1=NULL, *p2=NULL;
+ int cnt=0;
+ for (eSmartPtrList<eDVBRegisteredFrontend>::iterator it(m_avail_frontends.begin()); it != m_avail_frontends.end(); ++it, ++cnt)
+ {
+ if (cnt == tu1)
+ p1 = *it;
+ else if (cnt == tu2)
+ p2 = *it;
+ }
+
+ if (p1 && p2)
+ {
+ // check for linked tuners
+
+ do
+ {
+ int tmp;
+ p1->m_frontend->getData(eDVBFrontend::LINKED_PREV_PTR, tmp);
+ if (tmp != -1)
+ p1 = (eDVBRegisteredFrontend*)tmp;
+ else
+ break;
+ }
+ while (true);
+
+ do
+ {
+ int tmp;
+ p2->m_frontend->getData(eDVBFrontend::LINKED_PREV_PTR, tmp);
+ if (tmp != -1)
+ p2 = (eDVBRegisteredFrontend*)tmp;
+ else
+ break;
+ }
+ while (true);
+
+ if (p1 != p2)
+ {
+ int tmp1=-1;
+ int tmp2=-1;
+ // check for rotor dependency
+ p1->m_frontend->getData(eDVBFrontend::SATPOS_DEPENDS_PTR, tmp1);
+ if (tmp1 != -1)
+ p1 = (eDVBRegisteredFrontend*)tmp1;
+ p2->m_frontend->getData(eDVBFrontend::SATPOS_DEPENDS_PTR, tmp2);
+ if (tmp2 != -1)
+ p2 = (eDVBRegisteredFrontend*)tmp2;
+ if (p1 != p2)
+ {
+ int tu1_mask = 1 << p1->m_frontend->getID(),
+ tu2_mask = 1 << p2->m_frontend->getID();
+ std::set<sat_compare> tu1sats, tu2sats;
+ std::list<sat_compare> tu1difference, tu2difference;
+ std::insert_iterator<std::list<sat_compare> > insert1(tu1difference, tu1difference.begin()),
+ insert2(tu2difference, tu2difference.begin());
+ for (int idx=0; idx <= m_lnbidx; ++idx )
+ {
+ eDVBSatelliteLNBParameters &lnb_param = m_lnbs[idx];
+ for (std::map<int, eDVBSatelliteSwitchParameters>::iterator sit(lnb_param.m_satellites.begin());
+ sit != lnb_param.m_satellites.end(); ++sit)
+ {
+ if ( lnb_param.tuner_mask & tu1_mask )
+ tu1sats.insert(sat_compare(sit->first, lnb_param.m_lof_lo, lnb_param.m_lof_hi));
+ if ( lnb_param.tuner_mask & tu2_mask )
+ tu2sats.insert(sat_compare(sit->first, lnb_param.m_lof_lo, lnb_param.m_lof_hi));
+ }
+ }
+ std::set_difference(tu1sats.begin(), tu1sats.end(),
+ tu2sats.begin(), tu2sats.end(),
+ insert1);
+ std::set_difference(tu2sats.begin(), tu2sats.end(),
+ tu1sats.begin(), tu1sats.end(),
+ insert2);
+ if (!tu1sats.empty() || !tu2sats.empty())
+ {
+ int idx=0;
+ ret = PyList_New(2+tu1difference.size()+tu2difference.size());
+
+ PyList_SET_ITEM(ret, idx++, PyInt_FromLong(tu1difference.size()));
+ for(std::list<sat_compare>::iterator it(tu1difference.begin()); it != tu1difference.end(); ++it)
+ PyList_SET_ITEM(ret, idx++, PyInt_FromLong(it->orb_pos));
+
+ PyList_SET_ITEM(ret, idx++, PyInt_FromLong(tu2difference.size()));
+ for(std::list<sat_compare>::iterator it(tu2difference.begin()); it != tu2difference.end(); ++it)
+ PyList_SET_ITEM(ret, idx++, PyInt_FromLong(it->orb_pos));
+ }
+ }
+ }
+ }
+ }
+ if (!ret)
+ {
+ ret = PyList_New(2);
+ PyList_SET_ITEM(ret, 0, PyInt_FromLong(0));
+ PyList_SET_ITEM(ret, 1, PyInt_FromLong(0));
+ }
+ return ret;
+}
+
RESULT eDVBSatelliteEquipmentControl::setTunerLinked(int tu1, int tu2)
{
- return setDependencyPointers(tu1, tu2, 7);
+ if (tu1 != tu2)
+ {
+ eDVBRegisteredFrontend *p1=NULL, *p2=NULL;
+
+ int cnt=0;
+ for (eSmartPtrList<eDVBRegisteredFrontend>::iterator it(m_avail_frontends.begin()); it != m_avail_frontends.end(); ++it, ++cnt)
+ {
+ if (cnt == tu1)
+ p1 = *it;
+ else if (cnt == tu2)
+ p2 = *it;
+ }
+ if (p1 && p2)
+ {
+ p1->m_frontend->setData(eDVBFrontend::LINKED_PREV_PTR, (int)p2);
+ p2->m_frontend->setData(eDVBFrontend::LINKED_NEXT_PTR, (int)p1);
+ return 0;
+ }
+ }
+ return -1;
}
RESULT eDVBSatelliteEquipmentControl::setTunerDepends(int tu1, int tu2)
{
- return setDependencyPointers(tu1, tu2, 8);
+ if (tu1 == tu2)
+ return -1;
+
+ eDVBRegisteredFrontend *p1=NULL, *p2=NULL;
+
+ int cnt=0;
+ for (eSmartPtrList<eDVBRegisteredFrontend>::iterator it(m_avail_frontends.begin()); it != m_avail_frontends.end(); ++it, ++cnt)
+ {
+ if (cnt == tu1)
+ p1 = *it;
+ else if (cnt == tu2)
+ p2 = *it;
+ }
+ if (p1 && p2)
+ {
+ p1->m_frontend->setData(eDVBFrontend::SATPOS_DEPENDS_PTR, (int)p2);
+ p2->m_frontend->setData(eDVBFrontend::SATPOS_DEPENDS_PTR, (int)p1);
+ return 0;
+ }
+ return -1;
}
bool eDVBSatelliteEquipmentControl::isRotorMoving()
git.cweiske.de / enigma2.git / blobdiff