code.vuplus.com Git - vuplus_dvbapp/blob - lib/dvb/sec.cpp

   1 #include <config.h>
   2 #include <lib/dvb/sec.h>
   3 #include <lib/dvb/rotor_calc.h>
   4
   5 #if HAVE_DVB_API_VERSION < 3
   6 #define INVERSION Inversion
   7 #define FREQUENCY Frequency
   8 #define FEC_INNER FEC_inner
   9 #define SYMBOLRATE SymbolRate
  10 #else
  11 #define INVERSION inversion
  12 #define FREQUENCY frequency
  13 #define FEC_INNER fec_inner
  14 #define SYMBOLRATE symbol_rate
  15 #endif
  16 #include <lib/base/eerror.h>
  17
  18 DEFINE_REF(eDVBSatelliteEquipmentControl);
  19
  20 eDVBSatelliteEquipmentControl::eDVBSatelliteEquipmentControl()
  21         :m_lnbidx(-1), m_curSat(m_lnbs[0].m_satellites.end())
  22 {
  23         clear();
  24
  25 #undef ROTOR
  26
  27 // ASTRA
  28         addLNB();
  29         setLNBTunerMask(1);
  30         setLNBLOFL(9750000);
  31         setLNBThreshold(11750000);
  32 #ifdef ROTOR
  33         setLNBLOFH(10600000);
  34         setDiSEqCMode(eDVBSatelliteDiseqcParameters::V1_2);
  35 #else
  36         setLNBLOFH(10607000);
  37         setDiSEqCMode(eDVBSatelliteDiseqcParameters::V1_0);
  38 #endif
  39         setToneburst(eDVBSatelliteDiseqcParameters::NO);
  40         setRepeats(0);
  41 #ifdef ROTOR
  42         setCommittedCommand(eDVBSatelliteDiseqcParameters::AA);
  43 #else
  44         setCommittedCommand(eDVBSatelliteDiseqcParameters::BB);
  45 #endif
  46         setCommandOrder(0); // committed, toneburst
  47         setFastDiSEqC(true);
  48 #ifdef ROTOR
  49         setLongitude(8.683);
  50         setLatitude(51.017);
  51         setLoDirection(eDVBSatelliteRotorParameters::EAST);
  52         setLaDirection(eDVBSatelliteRotorParameters::NORTH);
  53         setUseInputpower(true);
  54         setInputpowerDelta(50);
  55 #endif
  56         addSatellite(192);
  57         setVoltageMode(eDVBSatelliteSwitchParameters::HV);
  58         setToneMode(eDVBSatelliteSwitchParameters::HILO);
  59 #ifdef ROTOR
  60         setRotorPosNum(0); // use gotoXX
  61 #else
  62 // HOTBIRD
  63         addLNB();
  64         setLNBTunerMask(1);
  65         setLNBLOFL(9750000);
  66         setLNBLOFH(10600000);
  67         setLNBThreshold(11750000);
  68         setDiSEqCMode(eDVBSatelliteDiseqcParameters::V1_0);
  69         setToneburst(eDVBSatelliteDiseqcParameters::NO);
  70         setRepeats(0);
  71         setCommittedCommand(eDVBSatelliteDiseqcParameters::AB);
  72         setCommandOrder(0); // committed, toneburst
  73         setFastDiSEqC(true);
  74 #endif
  75         addSatellite(130);
  76         setVoltageMode(eDVBSatelliteSwitchParameters::HV);
  77         setToneMode(eDVBSatelliteSwitchParameters::HILO);
  78 #ifdef ROTOR
  79         setRotorPosNum(0); // use gotoXX
  80 #endif
  81 }
  82
  83 RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPARAMETERS &parm, eDVBFrontendParametersSatellite &sat)
  84 {
  85         for (int idx=0; idx <= m_lnbidx; ++idx )
  86         {
  87                 eDVBSatelliteLNBParameters &lnb_param = m_lnbs[idx];
  88                 eDVBSatelliteDiseqcParameters &di_param = lnb_param.m_diseqc_parameters;
  89                 eDVBSatelliteRotorParameters &rotor_param = lnb_param.m_rotor_parameters;
  90
  91                 std::map<int, eDVBSatelliteSwitchParameters>::iterator sit =
  92                         lnb_param.m_satellites.find(sat.orbital_position);
  93                 if ( sit != lnb_param.m_satellites.end())
  94                 {
  95                         eDVBSatelliteSwitchParameters &sw_param = sit->second;
  96
  97                         int hi=0,
  98                                 voltage = iDVBFrontend::voltageOff,
  99                                 tone = iDVBFrontend::toneOff,
 100                                 csw = di_param.m_committed_cmd,
 101                                 ucsw = di_param.m_uncommitted_cmd,
 102                                 toneburst = di_param.m_toneburst_param,
 103                                 lastcsw = -1,
 104                                 lastucsw = -1,
 105                                 lastToneburst = -1,
 106                                 lastRotorCmd = -1,
 107                                 curRotorPos = -1;
 108
 109                         frontend.getData(0, lastcsw);
 110                         frontend.getData(1, lastucsw);
 111                         frontend.getData(2, lastToneburst);
 112                         frontend.getData(5, lastRotorCmd);
 113                         frontend.getData(6, curRotorPos);
 114
 115                         if ( sat.frequency > lnb_param.m_lof_threshold )
 116                                 hi = 1;
 117
 118                         if (hi)
 119                                 parm.FREQUENCY = sat.frequency - lnb_param.m_lof_hi;
 120                         else
 121                                 parm.FREQUENCY = sat.frequency - lnb_param.m_lof_lo;
 122
 123                         parm.INVERSION = (!sat.inversion) ? INVERSION_ON : INVERSION_OFF;
 124
 125                         switch (sat.fec)
 126                         {
 127                                 default:
 128                                 case eDVBFrontendParametersSatellite::FEC::fNone:
 129                                         eDebug("no fec set.. assume auto");
 130                                 case eDVBFrontendParametersSatellite::FEC::fAuto:
 131                                         parm.u.qpsk.FEC_INNER = FEC_AUTO;
 132                                         break;
 133                                 case eDVBFrontendParametersSatellite::FEC::f1_2:
 134                                         parm.u.qpsk.FEC_INNER = FEC_1_2;
 135                                         break;
 136                                 case eDVBFrontendParametersSatellite::FEC::f2_3:
 137                                         parm.u.qpsk.FEC_INNER = FEC_2_3;
 138                                         break;
 139                                 case eDVBFrontendParametersSatellite::FEC::f3_4:
 140                                         parm.u.qpsk.FEC_INNER = FEC_3_4;
 141                                         break;
 142                                 case eDVBFrontendParametersSatellite::FEC::f5_6:
 143                                         parm.u.qpsk.FEC_INNER = FEC_5_6;
 144                                         break;
 145                                 case eDVBFrontendParametersSatellite::FEC::f7_8:
 146                                         parm.u.qpsk.FEC_INNER = FEC_7_8;
 147                                         break;
 148                         }
 149
 150                         parm.u.qpsk.SYMBOLRATE = sat.symbol_rate;
 151
 152                         if ( sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::_14V
 153                                 || ( sat.polarisation == eDVBFrontendParametersSatellite::Polarisation::Vertical
 154                                         && sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::HV )  )
 155                                 voltage = iDVBFrontend::voltage13;
 156                         else if ( sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::_18V
 157                                 || ( sat.polarisation == eDVBFrontendParametersSatellite::Polarisation::Horizontal
 158                                         && sw_param.m_voltage_mode == eDVBSatelliteSwitchParameters::HV )  )
 159                                 voltage = iDVBFrontend::voltage18;
 160
 161                         if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::ON)
 162                                 || ( sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::HILO && hi ) )
 163                                 tone = iDVBFrontend::toneOn;
 164                         else if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::OFF)
 165                                 || ( sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::HILO && !hi ) )
 166                                 tone = iDVBFrontend::toneOff;
 167
 168                         eSecCommandList sec_sequence;
 169
 170                         if (di_param.m_diseqc_mode >= eDVBSatelliteDiseqcParameters::V1_0)
 171                         {
 172                                 if ( di_param.m_committed_cmd < eDVBSatelliteDiseqcParameters::SENDNO )
 173                                 {
 174                                         csw = 0xF0 | (csw << 2);
 175                                         if (hi)
 176                                                 csw |= 1;
 177                                         if (sat.polarisation == eDVBFrontendParametersSatellite::Polarisation::Horizontal)
 178                                                 csw |= 2;
 179                                 }
 180
 181                                 bool send_csw =
 182                                         (di_param.m_committed_cmd != eDVBSatelliteDiseqcParameters::SENDNO);
 183                                 bool changed_csw = send_csw && csw != lastcsw;
 184
 185                                 bool send_ucsw =
 186                                         (di_param.m_uncommitted_cmd && di_param.m_diseqc_mode > eDVBSatelliteDiseqcParameters::V1_0);
 187                                 bool changed_ucsw = send_ucsw && ucsw != lastucsw;
 188
 189                                 bool send_burst =
 190                                         (di_param.m_toneburst_param != eDVBSatelliteDiseqcParameters::NO);
 191                                 bool changed_burst = send_burst && toneburst != lastToneburst;
 192
 193                                 bool send_diseqc = changed_ucsw;
 194                                 if (!send_diseqc)
 195                                         send_diseqc = changed_burst && (send_ucsw || send_csw);
 196                                 if (!send_diseqc)
 197                                 {
 198                                         send_diseqc = changed_csw;
 199                                         if ( send_diseqc && di_param.m_use_fast && (csw & 0xF0) && (lastcsw & 0xF0) && ((csw / 4) == (lastcsw / 4)) )
 200                                                 send_diseqc = false;
 201                                 }
 202
 203                                 if ( send_diseqc || changed_burst )
 204                                 {
 205                                         sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) );
 206                                         eSecCommand::pair compare;
 207                                         compare.voltage = voltage;
 208                                         compare.steps = +3;
 209                                         sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // voltage already correct ?
 210                                         sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) );
 211                                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
 212                                 }
 213
 214                                 if ( di_param.m_command_order & 1 && // toneburst at begin of sequence
 215                                         changed_burst && di_param.m_toneburst_param != eDVBSatelliteDiseqcParameters::NO )
 216                                 {
 217                                         sec_sequence.push_back( eSecCommand(eSecCommand::SEND_TONEBURST, di_param.m_toneburst_param) );
 218                                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
 219                                         frontend.setData(2, di_param.m_toneburst_param);
 220                                 }
 221
 222                                 if ( send_diseqc )
 223                                 {
 224                                         int loops=0;
 225
 226                                         if ( send_csw )
 227                                                 ++loops;
 228                                         if ( send_ucsw )
 229                                                 ++loops;
 230
 231                                         for ( int i=0; i < di_param.m_repeats; ++i )
 232                                                 loops *= 2;
 233
 234                                         for ( int i = 0; i < loops;)  // fill commands...
 235                                         {
 236                                                 eDVBDiseqcCommand diseqc;
 237                                                 diseqc.len = 4;
 238                                                 diseqc.data[0] = i ? 0xE1 : 0xE0;
 239                                                 diseqc.data[1] = 0x10;
 240
 241                                                 if ( !send_csw || (send_ucsw && (di_param.m_command_order & 4) ) )
 242                                                 {
 243                                                         diseqc.data[2] = 0x39;
 244                                                         diseqc.data[3] = ucsw;
 245                                                 }
 246                                                 else
 247                                                 {
 248                                                         diseqc.data[2] = 0x38;
 249                                                         diseqc.data[3] = csw;
 250                                                 }
 251                                                 sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
 252
 253                                                 i++;
 254                                                 if ( i < loops )
 255                                                 {
 256                                                         int cmd=0;
 257                                                         if (diseqc.data[2] == 0x38 && send_ucsw)
 258                                                                 cmd=0x39;
 259                                                         else if (diseqc.data[2] == 0x39 && send_csw)
 260                                                                 cmd=0x38;
 261                                                         if (cmd)
 262                                                         {
 263                                                                 static int delay = (120 - 54) / 2;  // standard says 100msek between two repeated commands
 264                                                                 sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, delay) );
 265                                                                 diseqc.data[2]=cmd;
 266                                                                 diseqc.data[3]=(cmd==0x38) ? csw : ucsw;
 267                                                                 sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
 268                                                                 ++i;
 269                                                                 if ( i < loops )
 270                                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, delay ) );
 271                                                                 else
 272                                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
 273                                                         }
 274                                                         else  // delay 120msek when no command is in repeat gap
 275                                                                 sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 120) );
 276                                                 }
 277                                                 else
 278                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
 279
 280                                                 frontend.setData(0, csw);
 281                                                 frontend.setData(1, ucsw);
 282                                         }
 283                                 }
 284
 285                                 if ( !(di_param.m_command_order & 1) && // toneburst at end of sequence
 286                                         (changed_burst || send_diseqc) && di_param.m_toneburst_param != eDVBSatelliteDiseqcParameters::NO )
 287                                 {
 288                                         sec_sequence.push_back( eSecCommand(eSecCommand::SEND_TONEBURST, di_param.m_toneburst_param) );
 289                                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
 290                                         frontend.setData(2, di_param.m_toneburst_param);
 291                                 }
 292
 293                                 if ( di_param.m_diseqc_mode == eDVBSatelliteDiseqcParameters::V1_2 )
 294                                 {
 295                                         int RotorCmd=0;
 296                                         bool useGotoXX = false;
 297
 298                                         if (sw_param.m_rotorPosNum) // we have stored rotor pos?
 299                                                 RotorCmd=sw_param.m_rotorPosNum;
 300                                         else  // we must calc gotoxx cmd
 301                                         {
 302                                                 eDebug("Entry for %d,%d° not in Rotor Table found... i try gotoXX°", sat.orbital_position / 10, sat.orbital_position % 10 );
 303                                                 useGotoXX = true;
 304
 305                                                 int satDir = sat.orbital_position < 0 ?
 306                                                         eDVBSatelliteRotorParameters::WEST :
 307                                                         eDVBSatelliteRotorParameters::EAST;
 308
 309                                                 double  SatLon = abs(sat.orbital_position)/10.00,
 310                                                                 SiteLat = rotor_param.m_gotoxx_parameters.m_latitude,
 311                                                                 SiteLon = rotor_param.m_gotoxx_parameters.m_longitude;
 312
 313                                                 if ( rotor_param.m_gotoxx_parameters.m_la_direction == eDVBSatelliteRotorParameters::SOUTH )
 314                                                         SiteLat = -SiteLat;
 315
 316                                                 if ( rotor_param.m_gotoxx_parameters.m_lo_direction == eDVBSatelliteRotorParameters::WEST )
 317                                                         SiteLon = 360 - SiteLon;
 318
 319                                                 if (satDir == eDVBSatelliteRotorParameters::WEST )
 320                                                         SatLon = 360 - SatLon;
 321
 322                                                 eDebug("siteLatitude = %lf, siteLongitude = %lf, %lf degrees", SiteLat, SiteLon, SatLon );
 323                                                 double satHourAngle =
 324                                                         calcSatHourangle( SatLon, SiteLat, SiteLon );
 325                                                 eDebug("PolarmountHourAngle=%lf", satHourAngle );
 326
 327                                                 static int gotoXTable[10] =
 328                                                         { 0x00, 0x02, 0x03, 0x05, 0x06, 0x08, 0x0A, 0x0B, 0x0D, 0x0E };
 329
 330                                                 if (SiteLat >= 0) // Northern Hemisphere
 331                                                 {
 332                                                         int tmp=(int)round( fabs( 180 - satHourAngle ) * 10.0 );
 333                                                         RotorCmd = (tmp/10)*0x10 + gotoXTable[ tmp % 10 ];
 334
 335                                                         if (satHourAngle < 180) // the east
 336                                                                 RotorCmd |= 0xE000;
 337                                                         else                                    // west
 338                                                                 RotorCmd |= 0xD000;
 339                                                 }
 340                                                 else // Southern Hemisphere
 341                                                 {
 342                                                         if (satHourAngle < 180) // the east
 343                                                         {
 344                                                                 int tmp=(int)round( fabs( satHourAngle ) * 10.0 );
 345                                                                 RotorCmd = (tmp/10)*0x10 + gotoXTable[ tmp % 10 ];
 346                                                                 RotorCmd |= 0xD000;
 347                                                         }
 348                                                         else                                    // west
 349                                                         {
 350                                                                 int tmp=(int)round( fabs( 360 - satHourAngle ) * 10.0 );
 351                                                                 RotorCmd = (tmp/10)*0x10 + gotoXTable[ tmp % 10 ];
 352                                                                 RotorCmd |= 0xE000;
 353                                                         }
 354                                                 }
 355                                                 eDebug("RotorCmd = %04x", RotorCmd);
 356                                         }
 357                                         if ( RotorCmd != lastRotorCmd )
 358                                         {
 359                                                 if ( changed_burst || send_diseqc )
 360                                                 {
 361                                                         // override first voltage change
 362                                                         *(++(++sec_sequence.begin()))=eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage13);
 363                                                         // wait 1 second after first switch diseqc command
 364                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 1000) );
 365                                                 }
 366                                                 else  // no other diseqc commands before
 367                                                 {
 368                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) );
 369                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 15) );  // wait 50msec after voltage change
 370                                                         eSecCommand::pair compare;
 371                                                         compare.voltage = voltage;
 372                                                         compare.steps = +3;
 373                                                         sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // voltage already correct ?
 374                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage13) );
 375                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );  // wait 50msec after voltage change
 376                                                 }
 377
 378                                                 eDVBDiseqcCommand diseqc;
 379                                                 diseqc.data[0] = 0xE0;
 380                                                 diseqc.data[1] = 0x31;          // positioner
 381                                                 if ( useGotoXX )
 382                                                 {
 383                                                         diseqc.len = 5;
 384                                                         diseqc.data[2] = 0x6E;  // drive to angular position
 385                                                         diseqc.data[3] = ((RotorCmd & 0xFF00) / 0x100);
 386                                                         diseqc.data[4] = RotorCmd & 0xFF;
 387                                                 }
 388                                                 else
 389                                                 {
 390                                                         diseqc.len = 4;
 391                                                         diseqc.data[2] = 0x6B;  // goto stored sat position
 392                                                         diseqc.data[3] = RotorCmd;
 393                                                 }
 394
 395                                                 if ( rotor_param.m_inputpower_parameters.m_use )
 396                                                 { // use measure rotor input power to detect rotor state
 397                                                         eSecCommand::rotor cmd;
 398 // measure idle power values
 399                                                         sec_sequence.push_back( eSecCommand(eSecCommand::IF_IDLE_INPUTPOWER_AVAIL_GOTO, +8) ); // already measured?
 400                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );  // wait 50msec after voltage change
 401                                                         sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 0) );
 402                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage18) );
 403                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 100) );  // wait 100msec before measure
 404                                                         sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 1) );
 405                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage13) ); // back to lower voltage
 406                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );  // wait 50msec
 407 ////////////////////////////
 408                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeStatic) );
 409                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );  // wait 50msec after voltage change
 410                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
 411                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, 40) );  // 2 seconds rotor start timout
 412 // rotor start loop
 413                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );  // 50msec delay
 414                                                         sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_RUNNING_INPUTPOWER) );
 415                                                         cmd.direction=1;  // check for running rotor
 416                                                         cmd.deltaA=rotor_param.m_inputpower_parameters.m_delta;
 417                                                         cmd.steps=+3;
 418                                                         cmd.okcount=0;
 419                                                         sec_sequence.push_back( eSecCommand(eSecCommand::IF_INPUTPOWER_DELTA_GOTO, cmd ) );  // check if rotor has started
 420                                                         sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +11 ) );  // timeout ?
 421                                                         sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) );  // goto loop start
 422 ////////////////////
 423                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, 2400) );  // 2 minutes running timeout
 424                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, iDVBFrontend::voltage18) );
 425                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeDynamic) );
 426 // rotor running loop
 427                                                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );  // wait 50msec
 428                                                         sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_RUNNING_INPUTPOWER) );
 429                                                         cmd.direction=0;  // check for stopped rotor
 430                                                         cmd.steps=+3;
 431                                                         sec_sequence.push_back( eSecCommand(eSecCommand::IF_INPUTPOWER_DELTA_GOTO, cmd ) );
 432                                                         sec_sequence.push_back( eSecCommand(eSecCommand::IF_TIMEOUT_GOTO, +3 ) );  // timeout ?
 433                                                         sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) );  // running loop start
 434 /////////////////////
 435                                                         sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) );
 436                                                         frontend.setData(3, RotorCmd);
 437                                                         frontend.setData(4, sat.orbital_position);
 438                                                 }
 439                                                 else
 440                                                         eFatal("rotor turning without inputpowermeasure not implemented yet");
 441                                         }
 442                                 }
 443                         }
 444
 445                         eSecCommand::pair compare;
 446                         compare.voltage = voltage;
 447                         compare.steps = +3;
 448                         sec_sequence.push_back( eSecCommand(eSecCommand::IF_VOLTAGE_GOTO, compare) ); // voltage already correct ?
 449                         sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, voltage) );
 450                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 10) );
 451
 452                         sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, tone) );
 453                         sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 15) );
 454
 455                         frontend.setSecSequence(sec_sequence);
 456
 457                         return 0;
 458                 }
 459         }
 460
 461         eDebug("not found satellite configuration for orbital position (%d)", sat.orbital_position );
 462
 463         return -1;
 464 }
 465
 466 RESULT eDVBSatelliteEquipmentControl::clear()
 467 {
 468         for (int i=0; i < m_lnbidx; ++i)
 469         {
 470                 m_lnbs[i].m_satellites.clear();
 471                 m_lnbs[i].tuner_mask = 0;
 472         }
 473         m_lnbidx=-1;
 474         return 0;
 475 }
 476
 477 /* LNB Specific Parameters */
 478 RESULT eDVBSatelliteEquipmentControl::addLNB()
 479 {
 480         if ( m_lnbidx < (int)(sizeof(m_lnbs) / sizeof(eDVBSatelliteLNBParameters)))
 481                 m_curSat=m_lnbs[++m_lnbidx].m_satellites.end();
 482         else
 483         {
 484                 eDebug("no more LNB free... cnt is %d", m_lnbidx);
 485                 return -ENOSPC;
 486         }
 487         return 0;
 488 }
 489
 490 RESULT eDVBSatelliteEquipmentControl::setLNBTunerMask(int tunermask)
 491 {
 492         if ( currentLNBValid() )
 493                 m_lnbs[m_lnbidx].tuner_mask = tunermask;
 494         else
 495                 return -ENOENT;
 496         return 0;
 497 }
 498
 499 RESULT eDVBSatelliteEquipmentControl::setLNBLOFL(int lofl)
 500 {
 501         if ( currentLNBValid() )
 502                 m_lnbs[m_lnbidx].m_lof_lo = lofl;
 503         else
 504                 return -ENOENT;
 505         return 0;
 506 }
 507
 508 RESULT eDVBSatelliteEquipmentControl::setLNBLOFH(int lofh)
 509 {
 510         if ( currentLNBValid() )
 511                 m_lnbs[m_lnbidx].m_lof_hi = lofh;
 512         else
 513                 return -ENOENT;
 514         return 0;
 515 }
 516
 517 RESULT eDVBSatelliteEquipmentControl::setLNBThreshold(int threshold)
 518 {
 519         if ( currentLNBValid() )
 520                 m_lnbs[m_lnbidx].m_lof_threshold = threshold;
 521         else
 522                 return -ENOENT;
 523         return 0;
 524 }
 525
 526 RESULT eDVBSatelliteEquipmentControl::setLNBIncreasedVoltage(bool onoff)
 527 {
 528         if ( currentLNBValid() )
 529                 m_lnbs[m_lnbidx].m_increased_voltage = onoff;
 530         else
 531                 return -ENOENT;
 532         return 0;
 533 }
 534
 535 /* DiSEqC Specific Parameters */
 536 RESULT eDVBSatelliteEquipmentControl::setDiSEqCMode(int diseqcmode)
 537 {
 538         if ( currentLNBValid() )
 539                 m_lnbs[m_lnbidx].m_diseqc_parameters.m_diseqc_mode = (eDVBSatelliteDiseqcParameters::t_diseqc_mode)diseqcmode;
 540         else
 541                 return -ENOENT;
 542         return 0;
 543 }
 544
 545 RESULT eDVBSatelliteEquipmentControl::setToneburst(int toneburst)
 546 {
 547         if ( currentLNBValid() )
 548                 m_lnbs[m_lnbidx].m_diseqc_parameters.m_toneburst_param = (eDVBSatelliteDiseqcParameters::t_toneburst_param)toneburst;
 549         else
 550                 return -ENOENT;
 551         return 0;
 552 }
 553
 554 RESULT eDVBSatelliteEquipmentControl::setRepeats(int repeats)
 555 {
 556         if ( currentLNBValid() )
 557                 m_lnbs[m_lnbidx].m_diseqc_parameters.m_repeats=repeats;
 558         else
 559                 return -ENOENT;
 560         return 0;
 561 }
 562
 563 RESULT eDVBSatelliteEquipmentControl::setCommittedCommand(int command)
 564 {
 565         if ( currentLNBValid() )
 566                 m_lnbs[m_lnbidx].m_diseqc_parameters.m_committed_cmd=command;
 567         else
 568                 return -ENOENT;
 569         return 0;
 570 }
 571
 572 RESULT eDVBSatelliteEquipmentControl::setUncommittedCommand(int command)
 573 {
 574         if ( currentLNBValid() )
 575                 m_lnbs[m_lnbidx].m_diseqc_parameters.m_uncommitted_cmd = command;
 576         else
 577                 return -ENOENT;
 578         return 0;
 579 }
 580
 581 RESULT eDVBSatelliteEquipmentControl::setCommandOrder(int order)
 582 {
 583         if ( currentLNBValid() )
 584                 m_lnbs[m_lnbidx].m_diseqc_parameters.m_command_order=order;
 585         else
 586                 return -ENOENT;
 587         return 0;
 588 }
 589
 590 RESULT eDVBSatelliteEquipmentControl::setFastDiSEqC(bool onoff)
 591 {
 592         if ( currentLNBValid() )
 593                 m_lnbs[m_lnbidx].m_diseqc_parameters.m_use_fast=onoff;
 594         else
 595                 return -ENOENT;
 596         return 0;
 597 }
 598
 599 /* Rotor Specific Parameters */
 600 RESULT eDVBSatelliteEquipmentControl::setLongitude(float longitude)
 601 {
 602         if ( currentLNBValid() )
 603                 m_lnbs[m_lnbidx].m_rotor_parameters.m_gotoxx_parameters.m_longitude=longitude;
 604         else
 605                 return -ENOENT;
 606         return 0;
 607 }
 608
 609 RESULT eDVBSatelliteEquipmentControl::setLatitude(float latitude)
 610 {
 611         if ( currentLNBValid() )
 612                 m_lnbs[m_lnbidx].m_rotor_parameters.m_gotoxx_parameters.m_latitude=latitude;
 613         else
 614                 return -ENOENT;
 615         return 0;
 616 }
 617
 618 RESULT eDVBSatelliteEquipmentControl::setLoDirection(int direction)
 619 {
 620         if ( currentLNBValid() )
 621                 m_lnbs[m_lnbidx].m_rotor_parameters.m_gotoxx_parameters.m_lo_direction=direction;
 622         else
 623                 return -ENOENT;
 624         return 0;
 625 }
 626
 627 RESULT eDVBSatelliteEquipmentControl::setLaDirection(int direction)
 628 {
 629         if ( currentLNBValid() )
 630                 m_lnbs[m_lnbidx].m_rotor_parameters.m_gotoxx_parameters.m_la_direction=direction;
 631         else
 632                 return -ENOENT;
 633         return 0;
 634 }
 635
 636 RESULT eDVBSatelliteEquipmentControl::setUseInputpower(bool onoff)
 637 {
 638         if ( currentLNBValid() )
 639                 m_lnbs[m_lnbidx].m_rotor_parameters.m_inputpower_parameters.m_use=onoff;
 640         else
 641                 return -ENOENT;
 642         return 0;
 643 }
 644
 645 RESULT eDVBSatelliteEquipmentControl::setInputpowerDelta(int delta)
 646 {
 647         if ( currentLNBValid() )
 648                 m_lnbs[m_lnbidx].m_rotor_parameters.m_inputpower_parameters.m_delta=delta;
 649         else
 650                 return -ENOENT;
 651         return 0;
 652 }
 653
 654 /* Satellite Specific Parameters */
 655 RESULT eDVBSatelliteEquipmentControl::addSatellite(int orbital_position)
 656 {
 657         if ( currentLNBValid() )
 658         {
 659                 std::map<int, eDVBSatelliteSwitchParameters>::iterator it =
 660                         m_lnbs[m_lnbidx].m_satellites.find(orbital_position);
 661                 if ( it == m_lnbs[m_lnbidx].m_satellites.end() )
 662                 {
 663                         std::pair<std::map<int, eDVBSatelliteSwitchParameters>::iterator, bool > ret =
 664                                 m_lnbs[m_lnbidx].m_satellites.insert(
 665                                         std::pair<int, eDVBSatelliteSwitchParameters>(orbital_position, eDVBSatelliteSwitchParameters())
 666                                 );
 667                         if ( ret.second )
 668                                 m_curSat = ret.first;
 669                         else
 670                                 return -ENOMEM;
 671                 }
 672                 else
 673                         return -EEXIST;
 674         }
 675         else
 676                 return -ENOENT;
 677         return 0;
 678 }
 679
 680 RESULT eDVBSatelliteEquipmentControl::setVoltageMode(int mode)
 681 {
 682         if ( currentLNBValid() && m_curSat != m_lnbs[m_lnbidx].m_satellites.end() )
 683                 m_curSat->second.m_voltage_mode = (eDVBSatelliteSwitchParameters::t_voltage_mode)mode;
 684         else
 685                 return -ENOENT;
 686         return 0;
 687
 688 }
 689
 690 RESULT eDVBSatelliteEquipmentControl::setToneMode(int mode)
 691 {
 692         if ( currentLNBValid() )
 693         {
 694                 if ( m_curSat != m_lnbs[m_lnbidx].m_satellites.end() )
 695                         m_curSat->second.m_22khz_signal = (eDVBSatelliteSwitchParameters::t_22khz_signal)mode;
 696                 else
 697                         return -EPERM;
 698         }
 699         else
 700                 return -ENOENT;
 701         return 0;
 702 }
 703
 704 RESULT eDVBSatelliteEquipmentControl::setRotorPosNum(int rotor_pos_num)
 705 {
 706         if ( currentLNBValid() )
 707         {
 708                 if ( m_curSat != m_lnbs[m_lnbidx].m_satellites.end() )
 709                         m_curSat->second.m_rotorPosNum=rotor_pos_num;
 710                 else
 711                         return -EPERM;
 712         }
 713         else
 714                 return -ENOENT;
 715         return 0;
 716 }