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

Bayne  
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  

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  
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  

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  
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
OrderClosePrice - Trade Functions - MQL4 Reference
  • docs.mql4.com
OrderClosePrice - Trade Functions - MQL4 Reference
Bayne  
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
        }}}
Christian  
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 :-)

Grund der Beschwerde: