X-Git-Url: https://git.cweiske.de/enigma2.git/blobdiff_plain/d6c68fa2ec0f3c8b6248444a7414942291b571e1..31fb73a15d12559b15f5506622c3902476d3ea0f:/lib/dvb/sec.cpp

diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp
index 58a1b6fa..aeaf5a2a 100644
--- a/lib/dvb/sec.cpp
+++ b/lib/dvb/sec.cpp
@@ -138,22 +138,25 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite
 					if ( di_param.m_committed_cmd < eDVBSatelliteDiseqcParameters::SENDNO )
 						csw = 0xF0 | (csw << 2);
 
-					csw |= band;
+					if (di_param.m_committed_cmd <= eDVBSatelliteDiseqcParameters::SENDNO)
+						csw |= band;
 
 					if ( di_param.m_diseqc_mode == eDVBSatelliteDiseqcParameters::V1_2 )  // ROTOR
 					{
 						rotor=true;
 						if ( curRotorPos == sat.orbital_position )
-							ret=20;
+							ret=20;  // rotor on correct orbpos = prio 20
 						else
-							ret=10;
+							ret=10;  // rotor must turn to correct orbpos = prio 10
 					}
+					else
+						ret = 30;  // no rotor = prio 30
 				}
 				else
+				{
 					csw = band;
-
-				if (!ret)
-					ret=40;
+					ret = 40;  // no diseqc = prio 40
+				}
 
 				if (linked_to != -1)  // check for linked tuners..
 				{
@@ -206,6 +209,60 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite
 //					else
 //						eDebug("OK .. can tune this transponder satpos is correct :)");
 				}
+				if (ret)
+				{
+					static int lofs[] = { 3650000, 5150000, 9750000, 10600000 };
+					int lof = sat.frequency > lnb_param.m_lof_threshold ?
+						lnb_param.m_lof_hi : lnb_param.m_lof_lo;
+					int diff = 0x7FFFFFFF;
+					unsigned int num_lofs = sizeof(lofs) / sizeof(int);
+					int used_band = -1;
+					for (int i=0; i < num_lofs; ++i)
+					{
+						int lof_diff = abs(lof - lofs[i]);
+						if ( lof_diff < diff )
+						{
+							diff = lof_diff;
+							used_band = i;
+						}
+					}
+					if ( used_band != -1 )
+					{
+						if ( diff > 50000 )
+						{
+							eDebug("could not detect used lnb freq range .. disable range check !!!");
+							used_band = -1;
+						}
+					}
+					if ( used_band != -1 )
+					{
+						int range[2];
+						switch(used_band)
+						{
+							case 0:  // s-band
+								range[0] = 2500000;
+								range[1] = 2700000;
+								break;
+							case 1:  // c-band
+								range[0] = 3400000;
+								range[1] = 4200000;
+								break;
+							case 2:  // ku-band low
+								range[0] = 10700000;
+								range[1] = 11750000;
+								break;
+							case 3:  // ku-band high
+								range[0] = 11750000;
+								range[1] = 12750000;
+								break;
+						}
+						// check frequency in range ( +/- 75Mhz )
+						if ( (sat.frequency+75000) < range[0] )
+							ret=0;
+						if ( (sat.frequency-75000) > range[1] )
+							ret=0;
+					}
+				}
 			}
 		}
 	}
@@ -285,6 +342,8 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 			else
 				parm.FREQUENCY = sat.frequency - lnb_param.m_lof_lo;
 
+			parm.FREQUENCY = abs(parm.FREQUENCY);
+
 			if (sat.polarisation == eDVBFrontendParametersSatellite::Polarisation::Horizontal)
 				band |= 2;
 
@@ -351,7 +410,8 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 				if ( di_param.m_committed_cmd < eDVBSatelliteDiseqcParameters::SENDNO )
 					csw = 0xF0 | (csw << 2);
 
-				csw |= band;
+				if (di_param.m_committed_cmd <= eDVBSatelliteDiseqcParameters::SENDNO)
+					csw |= band;
 
 				bool send_csw =
 					(di_param.m_committed_cmd != eDVBSatelliteDiseqcParameters::SENDNO);
@@ -393,7 +453,10 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 				}
 				if (changed_csw) 
 				{
-					if ( di_param.m_use_fast && (lastcsw & 0xF0) && ((csw / 4) == (lastcsw / 4)) )
+					if ( di_param.m_use_fast
+						&& di_param.m_committed_cmd < eDVBSatelliteDiseqcParameters::SENDNO
+						&& (lastcsw & 0xF0)
+						&& ((csw / 4) == (lastcsw / 4)) )
 						eDebug("dont send committed cmd (fast diseqc)");
 					else
 					{
@@ -415,93 +478,8 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 				eDebug("");
 #endif
 
-				if ( send_mask )
-				{
-					sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) );
-					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, 50) );
-				}
-
-				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) );
-					}
-
-					int loops=0;
-
-					if ( send_mask & 1 )
-						++loops;
-					if ( send_mask & 2 )
-						++loops;
-
-					for ( int i=0; i < di_param.m_repeats; ++i )
-						loops *= 2;
-
-					for ( int i = 0; i < loops;)  // fill commands...
-					{
-						eDVBDiseqcCommand diseqc;
-						diseqc.len = 4;
-						diseqc.data[0] = i ? 0xE1 : 0xE0;
-						diseqc.data[1] = 0x10;
-						if ( (send_mask & 2) && (di_param.m_command_order & 4) )
-						{
-							diseqc.data[2] = 0x39;
-							diseqc.data[3] = ucsw;
-						}
-						else if ( send_mask & 1 )
-						{
-							diseqc.data[2] = 0x38;
-							diseqc.data[3] = csw;
-						}
-						else
-						{
-							diseqc.data[2] = 0x00;
-							diseqc.data[3] = 0x00;
-						}
-						sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
-
-						i++;
-						if ( i < loops )
-						{
-							int cmd=0;
-							if (diseqc.data[2] == 0x38 && (send_mask & 2))
-								cmd=0x39;
-							else if (diseqc.data[2] == 0x39 && (send_mask & 1))
-								cmd=0x38;
-							if (cmd)
-							{
-								static int delay = (120 - 54) / 2;  // 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;
-								sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
-								++i;
-								if ( i < loops )
-									sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, delay ) );
-								else
-									sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
-							}
-							else  // delay 120msek when no command is in repeat gap
-								sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 120) );
-						}
-						else
-							sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
-					}
-
-					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) );
-					}
-				}
-
+				int RotorCmd=-1;
+				bool useGotoXX = false;
 				if ( di_param.m_diseqc_mode == eDVBSatelliteDiseqcParameters::V1_2 )
 				{
 					if (depend_satpos_mode || linked)
@@ -509,9 +487,6 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 						frontend.setData(6, sat.orbital_position);
 					else
 					{
-						int RotorCmd=0;
-						bool useGotoXX = false;
-
 						if (sw_param.m_rotorPosNum) // we have stored rotor pos?
 							RotorCmd=sw_param.m_rotorPosNum;
 						else  // we must calc gotoxx cmd
@@ -556,7 +531,7 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 									RotorCmd |= 0xD000;
 								}
 								else					// west
-								{          
+								{
 									int tmp=(int)round( fabs( 360 - satHourAngle ) * 10.0 );
 									RotorCmd = (tmp/10)*0x10 + gotoXTable[ tmp % 10 ];
 									RotorCmd |= 0xE000;
@@ -564,93 +539,215 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 							}
 							eDebug("RotorCmd = %04x", RotorCmd);
 						}
-						if ( RotorCmd != lastRotorCmd )
+					}
+				}
+
+				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.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 ( RotorCmd != -1 && RotorCmd != lastRotorCmd )
+						// TODO .. add handling for turning rotor without measure inputpower
+						compare.voltage = VOLTAGE(18);
+					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) );
+
+					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) );
+						}
+
+						int loops=0;
+
+						if ( send_mask & 1 )
+							++loops;
+						if ( send_mask & 2 )
+							++loops;
+
+						for ( int i=0; i < di_param.m_repeats; ++i )
+						loops *= 2;
+
+						for ( int i = 0; i < loops;)  // fill commands...
 						{
-							if ( send_mask )
+							eDVBDiseqcCommand diseqc;
+							diseqc.len = 4;
+							diseqc.data[0] = i ? 0xE1 : 0xE0;
+							diseqc.data[1] = 0x10;
+							if ( (send_mask & 2) && (di_param.m_command_order & 4) )
 							{
-								// override first voltage change
-								*(++(++sec_sequence.begin()))=eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13));
-								// wait 1 second after first switch diseqc command
-								sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 1000) );
+								diseqc.data[2] = 0x39;
+								diseqc.data[3] = ucsw;
 							}
-							else  // no other diseqc commands before
+							else if ( send_mask & 1 )
 							{
-								sec_sequence.push_back( eSecCommand(eSecCommand::SET_TONE, iDVBFrontend::toneOff) );
-								sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 15) );  // wait 15msec after tone change
-								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(13)) );
-								sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );  // wait 50msec after voltage change
+								diseqc.data[2] = 0x38;
+								diseqc.data[3] = csw;
 							}
-
-							eDVBDiseqcCommand diseqc;
-							diseqc.data[0] = 0xE0;
-							diseqc.data[1] = 0x31;		// positioner
-							if ( useGotoXX )
+							else
 							{
-								diseqc.len = 5;
-								diseqc.data[2] = 0x6E;	// drive to angular position
-								diseqc.data[3] = ((RotorCmd & 0xFF00) / 0x100);
-								diseqc.data[4] = RotorCmd & 0xFF;
+								diseqc.data[2] = 0x00;
+								diseqc.data[3] = 0x00;
 							}
-							else
+							sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
+
+							i++;
+							if ( i < loops )
 							{
-								diseqc.len = 4;
-								diseqc.data[2] = 0x6B;	// goto stored sat position
-								diseqc.data[3] = RotorCmd;
-								diseqc.data[4] = 0x00;
+								int cmd=0;
+								if (diseqc.data[2] == 0x38 && (send_mask & 2))
+									cmd=0x39;
+								else if (diseqc.data[2] == 0x39 && (send_mask & 1))
+									cmd=0x38;
+								if (cmd)
+								{
+									static int delay = (120 - 54) / 2;  // 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;
+									sec_sequence.push_back( eSecCommand(eSecCommand::SEND_DISEQC, diseqc) );
+									++i;
+									if ( i < loops )
+										sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, delay ) );
+									else
+										sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
+								}
+								else  // delay 120msek when no command is in repeat gap
+									sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 120) );
 							}
+							else
+								sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );
+						}
 
-							if ( rotor_param.m_inputpower_parameters.m_use )
-							{ // use measure rotor input power to detect rotor state
-								eSecCommand::rotor 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) );
+						}
+					}
+				}
+
+				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, +7) );  // no need to send stop rotor cmd
+
+					if (send_mask)
+						sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 750) ); // wait 750ms after send switch cmd
+					else
+						sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, +1) );
+
+					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 300msec after send rotor stop cmd
+					sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 300) );
+
+					diseqc.data[0] = 0xE0;
+					diseqc.data[1] = 0x31;		// positioner
+					if ( useGotoXX )
+					{
+						diseqc.len = 5;
+						diseqc.data[2] = 0x6E;	// drive to angular position
+						diseqc.data[3] = ((RotorCmd & 0xFF00) / 0x100);
+						diseqc.data[4] = RotorCmd & 0xFF;
+					}
+					else
+					{
+						diseqc.len = 4;
+						diseqc.data[2] = 0x6B;	// goto stored sat position
+						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
+						eSecCommand::rotor cmd;
+						eSecCommand::pair compare;
+						compare.voltage = VOLTAGE(18);
+						compare.steps = +2;
+						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::IF_IDLE_INPUTPOWER_AVAIL_GOTO, +8) ); // already measured?
-								sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );  // wait 50msec after voltage change
-								sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 0) );
-								sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) );
-								sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 100) );  // wait 100msec before measure
-								sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 1) );
-								sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(13)) ); // back to lower voltage
-								sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 50) );  // wait 50msec
+						sec_sequence.push_back( eSecCommand(eSecCommand::SLEEP, 200) );  // wait 200msec after voltage change
+						sec_sequence.push_back( eSecCommand(eSecCommand::MEASURE_IDLE_INPUTPOWER, 1) );
+						compare.voltage = 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::MEASURE_IDLE_INPUTPOWER, 0) );
+						compare.voltage = 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::SLEEP, 50) );  // wait 50msec after voltage change
-								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::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::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=+3;
-								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, +9 ) );  // 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::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, +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_TIMEOUT, 2400) );  // 2 minutes running timeout
-								sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) );
+						sec_sequence.push_back( eSecCommand(eSecCommand::SET_TIMEOUT, 2400) );  // 2 minutes running timeout
+						sec_sequence.push_back( eSecCommand(eSecCommand::SET_VOLTAGE, VOLTAGE(18)) );
 // 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, +3 ) );  // timeout ? this should never happen
-								sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) );  // running loop start
+						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, +3 ) );  // timeout ? this should never happen
+						sec_sequence.push_back( eSecCommand(eSecCommand::GOTO, -4) );  // running loop start
 /////////////////////
-								sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) );
-								sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeDynamic) );
-								frontend.setData(3, RotorCmd);
-								frontend.setData(4, sat.orbital_position);
-							}
-							else
-								eFatal("rotor turning without inputpowermeasure not implemented yet");
-						}
+						sec_sequence.push_back( eSecCommand(eSecCommand::UPDATE_CURRENT_ROTORPARAMS) );
+						sec_sequence.push_back( eSecCommand(eSecCommand::SET_POWER_LIMITING_MODE, eSecCommand::modeDynamic) );
+						frontend.setData(3, RotorCmd);
+						frontend.setData(4, sat.orbital_position);
 					}
+					else
+						eFatal("rotor turning without inputpowermeasure not implemented yet");
 				}
 			}
 			else