Immer wenn90% des TP erreicht-> SL nachziehen & TP Erhöhen

Bayne 2018.11.03 16:40

Was ich machen will (im mt4) steht oben:

der Obere Abschnitt ist die erstellung der Orders SL's & TP's fürs erste

Der Untere Abschnitt behandelt das eigentliche Problem:

Mein Problem ist, dass direkt alle Takeprofits im millisekundentakt eingesetzt werden & Das Signal nicht richtig als der Wertebereich erkannt wird als der er geschrieben wurde.

++ Extra, Da die SL geschichte hier auch nicht zu klappen scheint: Hat vllt jemand nh idee Wie ich den SL um X% unter dem Alten TP setzen kann

Also erstmal hier der ungefähre voraufbau: (darunter dann das kurze Problemabteil)

//vorher:
extern double SL_prozent=0.4 , TP_prozent= 0.4, SL_konstante=0.06,SL_konstante2=0.06;
extern double TP_prozent2 =0.5,TP_prozent3 =0.55,TP_prozent4 =0.6,TP_prozent5 =0.7,TP_prozent6 =0.8;

bool siglong = OrderClosePrice()>= (OrderOpenPrice() + (OrderTakeProfit()-OrderOpenPrice()))*0.90;
bool sigshort = OrderClosePrice()<= (OrderOpenPrice() - (OrderOpenPrice()-OrderTakeProfit()))*0.90;

  void OnTick(){

double MAlanghandle =iMA (NULL,0,MA_langperiode,0, MODE_SMA, PRICE_CLOSE,1);
double MAlangVorperiode =iMA(NULL,0,MA_langperiode,0, MODE_SMA, PRICE_CLOSE,2);
double MAkurzhandle =iMA(NULL ,0,MA_kurzperiode,0, MODE_SMA, PRICE_CLOSE,1);
double MAkurzVorperiode =iMA (NULL ,0,MA_kurzperiode,0, MODE_SMA, PRICE_CLOSE,2);

//---------------------------------------------------------------------------
 //Long

   if (LongOrder<=0 && MAkurzhandle>MAlanghandle && Bid>=MAkurzhandle){
   LongOrder = OrderSend(Symbol(),OP_BUY,Lot,Bid,10,0,0,"einfach Long",MagicNummer,0,Green);
   LongOrder++;}
 
   //Short
   
   if (ShortOrder<=0 && MAkurzhandle<MAlanghandle && Ask<=MAkurzhandle){
   ShortOrder = OrderSend(Symbol(),OP_SELL,Lot,Ask,10,0,0,"einfach Short",MagicNummer,0,Green);
   ShortOrder++;}
   
//---------------------------------------------------------------------------
//SL für LongOrder setzen
if (OrderSelect(LongOrder,SELECT_BY_TICKET) == true)
   {if (OrderCloseTime()==0 && OrderStopLoss()==false)//Order noch nicht geschlossen & SL nochnicht gesetzt
      {
     StopLossLong = NormalizeDouble(OrderOpenPrice()/(1+(SL_prozent/100)),Digits);
     SL_Setzen = OrderModify(OrderTicket(),OrderOpenPrice(),StopLossLong,OrderTakeProfit(),0,Yellow);
      }
   }
 //SL für ShortOrder setzen
if (OrderSelect(ShortOrder,SELECT_BY_TICKET) == true)
   {if (OrderCloseTime()==0 && OrderStopLoss()==false) //Order noch nicht geschlossen & SL nochnicht gesetzt
      {
     StopLossShort=NormalizeDouble(OrderOpenPrice()*(1+(SL_prozent/100)),Digits);
      SL_Setzen=OrderModify(OrderTicket(),OrderOpenPrice(),StopLossShort,OrderTakeProfit(),0,Yellow);
      }
   }
//TP für LongOrder Setzen
if (OrderSelect(LongOrder,SELECT_BY_TICKET) == true)
   {
   if (OrderCloseTime()==0 && OrderTakeProfit()==false) //Order noch nicht geschlossen & TP nochnicht gesetzt
      {
    TakeProfitLong=NormalizeDouble(OrderOpenPrice()*(1+(TP_prozent/100)),Digits);
    TP_Setzen=OrderModify(OrderTicket(), OrderOpenPrice(),OrderStopLoss(),TakeProfitLong,0,Orange);
      }}
   }}
//TP für ShortOrder setzen
if (OrderSelect(ShortOrder,SELECT_BY_TICKET) == true)
   {
   if (OrderCloseTime()==0 && OrderTakeProfit()==false) //Order noch nicht geschlossen & TP nochnicht gesetzt
      {
     TakeProfitShort=NormalizeDouble(OrderOpenPrice()/(1+(TP_prozent/100)),Digits);
     TP_Setzen=OrderModify(OrderTicket(), OrderOpenPrice(),OrderStopLoss(),TakeProfitShort,0,Orange);
      }
      }


//TP erhöhen wenn 90% & Sl auf -0.1 unter altem TP setzen

if (OrderSelect(LongOrder,SELECT_BY_TICKET) == true && OrderClosePrice()>=siglong && OrderCloseTime()==0)//Order noch nicht geschlossen & sig ausgelöst
      {
          
double TakeProfitLong2=NormalizeDouble(OrderOpenPrice()*(1+(TP_prozent2/100)),Digits);
double StopLossLong2 = NormalizeDouble(OrderOpenPrice()*(1+(TP_prozent-SL_konstante/100)),Digits);
double TakeProfitLong3=NormalizeDouble(OrderOpenPrice()*(1+(TP_prozent3/100)),Digits);
double StopLossLong3 = NormalizeDouble(OrderOpenPrice()*(1+(TP_prozent2-SL_konstante2/100)),Digits);
double TakeProfitLong4=NormalizeDouble(OrderOpenPrice()*(1+(TP_prozent4/100)),Digits);
double StopLossLong4 = NormalizeDouble(OrderOpenPrice()*(1+(TP_prozent3-SL_konstante2/100)),Digits);
double TakeProfitLong5=NormalizeDouble(OrderOpenPrice()*(1+(TP_prozent5/100)),Digits);
 double StopLossLong5 = NormalizeDouble(OrderOpenPrice()*(1+(TP_prozent4-SL_konstante2/100)),Digits);
 
  if (siglong && OrderTakeProfit()==TakeProfitLong && TakeProfitLong2>OrderTakeProfit()){
          TP_Setzen=OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),TakeProfitLong2,0,Orange);
          SL_Setzen2 = OrderModify(OrderTicket(),OrderOpenPrice(),StopLossLong2,OrderTakeProfit(),0,Yellow);
          RefreshRates();
            }/*
    else if (siglong==true && TakeProfitLong2==OrderTakeProfit() && TakeProfitLong3>OrderTakeProfit()){//TP3
          TP_Setzen=OrderModify(OrderTicket(), OrderOpenPrice(),OrderStopLoss(),TakeProfitLong3,0,Orange);
          SL_Setzen2 = OrderModify(OrderTicket(),OrderOpenPrice(),StopLossLong3,OrderTakeProfit(),0,Yellow);
          RefreshRates();
            }
    else if (siglong==true && TakeProfitLong3==OrderTakeProfit() && TakeProfitLong4>OrderTakeProfit()){//TP4
          TP_Setzen=OrderModify(OrderTicket(), OrderOpenPrice(),OrderStopLoss(),TakeProfitLong4,0,Orange);
          SL_Setzen2 = OrderModify(OrderTicket(),OrderOpenPrice(),StopLossLong4,OrderTakeProfit(),0,Yellow);
          RefreshRates();
            }        
     else if (siglong==true && TakeProfitLong4==OrderTakeProfit() && TakeProfitLong5>OrderTakeProfit()){//TP5
          TP_Setzen=OrderModify(OrderTicket(), OrderOpenPrice(),OrderStopLoss(),TakeProfitLong5,0,Orange); 
            SL_Setzen2 = OrderModify(OrderTicket(),OrderOpenPrice(),StopLossLong5,OrderTakeProfit(),0,Yellow);
            RefreshRates();
            }  */
    }
     
if (OrderSelect(ShortOrder,SELECT_BY_TICKET) == true && sigshort==true && OrderCloseTime()==0)
      {
      
      double TakeProfitShort2=NormalizeDouble(OrderOpenPrice()/(1+(TP_prozent2/100)),Digits);           
     double StopLossShort2=NormalizeDouble(OrderOpenPrice()/(1+((TP_prozent-SL_konstante)/100)),Digits);
     double TakeProfitShort3=NormalizeDouble(OrderOpenPrice()/(1+(TP_prozent3/100)),Digits);
     double StopLossShort3=NormalizeDouble(OrderOpenPrice()/(1+((TP_prozent2-SL_konstante2)/100)),Digits);
     double TakeProfitShort4=NormalizeDouble(OrderOpenPrice()/(1+(TP_prozent4/100)),Digits);
     double StopLossShort4=NormalizeDouble(OrderOpenPrice()/(1+((TP_prozent3-SL_konstante2)/100)),Digits);
     double TakeProfitShort5=NormalizeDouble(OrderOpenPrice()/(1+(TP_prozent5/100)),Digits);
      double StopLossShort5=NormalizeDouble(OrderOpenPrice()/(1+((TP_prozent4-SL_konstante2)/100)),Digits);
    
     if (TakeProfitShort==OrderTakeProfit() && TakeProfitShort2<OrderTakeProfit()){
         TP_Setzen2=OrderModify(OrderTicket(), OrderOpenPrice(),OrderStopLoss(),TakeProfitShort2,0,Orange);
         SL_Setzen2=OrderModify(OrderTicket(),OrderOpenPrice(),StopLossShort2,OrderTakeProfit(),0,Yellow);
         RefreshRates();
         }/*
      else if (sigshort==true && TakeProfitShort2==OrderTakeProfit() && TakeProfitShort3<OrderTakeProfit()){
         TP_Setzen2=OrderModify(OrderTicket(), OrderOpenPrice(),OrderStopLoss(),TakeProfitShort3,0,Orange);
         SL_Setzen2=OrderModify(OrderTicket(),OrderOpenPrice(),StopLossShort3,OrderTakeProfit(),0,Yellow);
         RefreshRates();
         }
        else if (sigshort==true && TakeProfitShort3==OrderTakeProfit() && TakeProfitShort4<OrderTakeProfit()){
         TP_Setzen2=OrderModify(OrderTicket(), OrderOpenPrice(),OrderStopLoss(),TakeProfitShort4,0,Orange);
         SL_Setzen2=OrderModify(OrderTicket(),OrderOpenPrice(),StopLossShort4,OrderTakeProfit(),0,Yellow);
         RefreshRates();
         }
         else if (sigshort==true && TakeProfitShort4==OrderTakeProfit() && TakeProfitShort5<OrderTakeProfit()){
         TP_Setzen2=OrderModify(OrderTicket(), OrderOpenPrice(),OrderStopLoss(),TakeProfitShort5,0,Orange);
         SL_Setzen2=OrderModify(OrderTicket(),OrderOpenPrice(),StopLossShort5,OrderTakeProfit(),0,Yellow);
         RefreshRates();
         }*/

Carl Schreiber 2018.11.03 18:19 #1

Verwende doch eine Schrittweite (step):

(Kaufposition nicht geprüft..):

..
double Step = _Point*20.0;
..
if ( OrderClosePrice() > OrderStopLoss()+Step ) {
        if( !OrderModify( ..,OrderStopLoss()+Step, .. ) ) { // error... }
}

oder von TP:

..
double Step = _Point*20.0,
       Dist = _Point*200.0;
..
if ( OrderTakeProfit() - Dist > OrderStopLoss()+Step ) {
        if( !OrderModify( ..,OrderStopLoss()+Step, .. ) ) { // error... }

Bayne 2018.11.03 22:48 #2

Carl Schreiber:

Verwende doch eine Schrittweite (step):

(Kaufposition nicht geprüft..):

oder von TP:

@Carl SchreiberVerstehe deinen Vorschlag folgendermaßen:

Wenn der "Kurs" mehr als 20 Points über dem SL liegt -> SL erhöhen

Oder was willst du mit dem !OrderModyfiy ausdrücken? So etwa:


      if (OrderSelect(LongOrder,SELECT_BY_TICKET) == true && OrderCloseTime()==0 && OrderClosePrice() > OrderStopLoss()+Step) {

        OrderModify( OrderTicket(),OrderOpenPrice(),OrderStopLoss()+Step,OrderTakeProfit(),0,Yellow)

        if( !OrderModify( OrderTicket(),OrderOpenPrice(),OrderStopLoss()+Step,OrderTakeProfit(),0,Yellow) ) {GetLastError();Print("SL konnte nicht nachgesetzt werden")}

Wenn 200 Punkte unter dem jetigen Takeprofit kleiner ist als 20 Punkte über dem StoppLoss -> TP erhöhen

//        
if (OrderSelect(LongOrder,SELECT_BY_TICKET) == true && OrderCloseTime()==0 && (OrderTakeProfit() - Dist < OrderStopLoss()+Step )) {

OrderModify( OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit+Step(),0,Yellow)

        if( !OrderModify( OrderTicket(), OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit()+Step,0,Yellow) ) {GetLastError(); Print("TP2 konnte nicht gesetzt werden")}

Ist das So richtig?

Für Short Orders würde dass dann in etwa So aussehen

if (OrderSelect(ShortOrder,SELECT_BY_TICKET) == true && OrderCloseTime()==0 && (OrderClosePrice() < OrderStopLoss()-Step)) {
        OrderModify( OrderTicket(),OrderOpenPrice(),OrderStopLoss()-Step,OrderTakeProfit(),0,Yellow)
        
        if( !OrderModify( OrderTicket(),OrderOpenPrice(),OrderStopLoss()-Step,OrderTakeProfit(),0,Yellow) ) {GetLastError();Print("SL konnte nicht nachgesetzt werden")}
        }
if (OrderSelect(ShortOrder,SELECT_BY_TICKET) == true && OrderCloseTime()==0 &&  (OrderTakeProfit() + Dist > OrderStopLoss()-Step )) {
        OrderModify( OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit-Step(),0,Yellow)
        
        if( !OrderModify( OrderTicket(), OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit()-Step,0,Yellow) ) {GetLastError(); Print("TP2 konnte nicht gesetzt werden")}
        }

Bayne 2018.11.04 01:41 #3

Aber noch Viel Wichtiger (zur anfangsfrage):

Es geht darum->Warum funktioniert dieser Code nicht:

bool siglong = OrderClosePrice()>= (OrderOpenPrice() + (OrderTakeProfit()-OrderOpenPrice()))*0.90;
bool sigshort = OrderClosePrice()<= (OrderOpenPrice() - (OrderOpenPrice()-OrderTakeProfit()))*0.90;

Christian 2018.11.04 10:16 #4

Bayne:

Aber noch Viel Wichtiger (zur anfangsfrage):

Es geht darum->Warum funktioniert dieser Code nicht:

Du kannst kein Rechenergebniss( double) einem bool zuweisen.

https://docs.mql4.com/trading/ordercloseprice

https://docs.mql4.com/basis/types/integer/boolconst

Gruß

OrderClosePrice - Trade Functions - MQL4 Reference

docs.mql4.com

OrderClosePrice - Trade Functions - MQL4 Reference

Bayne 2018.11.04 13:46 #5

Christian:

Du kannst kein Rechenergebniss( double) einem bool zuweisen.

https://docs.mql4.com/trading/ordercloseprice

https://docs.mql4.com/basis/types/integer/boolconst

Gruß

Was kann ich stattdessen machen um diese Grenze klarzustellen ? (Das ganze etwa direkt inder BedingungsKlammer ohne deklaration nennen?)

Andere Sache: das Signal wird nun doch erkannt (Ask anstatt OrderClosePrice), aber es werden unendlich viele TPs direkt hintereinander gesetzt... Was tun?

bool siglong = (OrderTakeProfit()-OrderOpenPrice())*0.95 <= Ask - OrderOpenPrice(),
if (OrderSelect(LongOrder,SELECT_BY_TICKET) == true && OrderCloseTime()==0)
   {
   
   if (siglong=false){Comment("KeinSig");return;}
    else if (siglong=true){
  
    if (OrderTakeProfit()>0.1000) { //Klarstellen, vorher ein TP da war
    
        TP_Setzen = OrderModify( OrderTicket(),OrderOpenPrice(),OrderStopLoss(),OrderTakeProfit()+StepLongTP,0,Yellow); //StepLongTP beträgt in diesem Fall 210*_Points
        }}}

Von der Theorie zur Multi-Timeframe-Indikatoren Styler im MetaTrader 5-Handelsterminal

Christian 2018.11.04 14:01 #6

Bayne:

Andere Sache: das Signal wird nun doch erkannt (Ask anstatt OrderClosePrice), aber es werden unendlich viele TPs direkt hintereinander gesetzt... Was tun?

Falsch , du hast aus der Rechenoperation ( XXX XXX + XXX XXX)

einen Vergleich gemacht ( XXX XXX <= XXX XXX )

Das Ergebniss kannst du einem bool zuweisen. Es kommt ja immer ein true oder false raus.

Dir fehlen Grundlagen ..... -> nochmal C++ Videos reinziehn ...Wetter passt :-)

MT 5 Fehler beim [Archiv c 17.03.2008] Humor EA - Problem mit

Christian 2018.11.04 14:21 #7

Noch was ...um Programmfehler zu finden nutzt man den Debugger.

Jeden neuen Fehler im Forum zu ergründen geht auf dauer schief.

Also los, breakpoint vor der Funktion die Ärger macht setzen und dann Schritt für Schritt in JEDE Variable schauen .

Dann siehst du warum er zu viel OrderModifys macht.

Gruß

Trade wird eröffnet sobald Hilfe mein Expert funktioniert Fragen von Anfängern MQL5

Neuer Kommentar