Banki centralne i wielcy gracze: Niewielka zmiana w kodzie reqd
Pokaż wyniki od 1 do 8 z 8

Wątek: Banki centralne i wielcy gracze: Niewielka zmiana w kodzie reqd

  1. #1
    Ostatnio byłem zaintrygowany wątkiem o nazwie Banki Centralne i Gracze Gracze. Podstawowym egy jest kupić lub sprzedać w kierunku pierwszego ruchu 2 pip w cenie w Londynie i Nowym Jorku otwarte. Autor wątku używa bardzo małego SL (2 pipsy), TP 140 i świetnie sobie radzi z egy. EA (patrz kod poniżej) opracowany dla tego egy działa ładnie z wyjątkiem jednej rzeczy. Jak to będzie przesuwać twój przystanek w kierunku BE pip o pip (dopóki nie zostanie osiągnięty BE), jak cena porusza się na Twoją korzyść. Mam problem, nawet jeśli EA postawił mój przystanek BE, wciąż tracę prowizję, którą muszę zapłacić za handel. Czy ktoś może skorygować poniższy kod (pogrubionym drukiem) zmiany niezbędne, aby EA wprowadziło zatrzymanie do BE (x) liczby pipsów, aby pokryć koszt prowizji. dziękuję/ --------------------------------------------- ---------------------
    //| CBBP_EA_v2-0.mq4 |
    //| Zen Leow |
    //| |
    // ----------------------------------------------- -------------------
    #property copyright Zen Leow
    #property link

    #include lt; stdlib.mqhgt;
    #include lt; stderror.mqhgt;
    #define PRIMARY_ORDER 1
    #define SECONDARY_ORDER 2

    extern int EA_MAGIC_NUM = 3947947;
    extern bool IsECN = true;
    extern bool CheckHourOfAttach = true;
    łańcuch zewnętrzny Session1 = London Session;
    extern int SessionOpenHour1 = 8;
    zewnętrzny ciąg Session2 = New York Session;
    extern int SessionOpenHour2 = 13;
    extern int GraceMinutes = 5;
    extern bool Show_Comments = true;
    extern double UserDefinedSpread = 0;

    extern int Slippage = 3;
    extern double Pip_Distance = 2;
    extern int TakeProfit = 140;
    extern int StopLoss = 5;
    extern bool UseJumpingStop = false;
    extern int TrailingStop = 0;
    extern bool Add_Spread_To_StopLoss = false;
    extern bool Use_Spread_Filtering = true;
    extern double Spread_Filter = 1.0;

    extern bool MoneyManagement = true;
    extern double RiskPercent = 0,25;
    extern bool UseEquity = false;
    extern bool Use_BE = true;
    extern double BreakEven_Pips = 5.0;
    extern double FixedLots = 0,1;
    extern double MaxLots = 15,0;
    extern double MinLots = 0,01;
    extern int LotsDecimalAllowed = 2;

    string msg =;
    double CustomSpread = 0;
    int PipFactor = 1;
    bool StartupStatusOK = true;
    int the_StopLoss = 0;
    bool TradeTheSession = true;
    bool Problem z błędem = fałsz;
    int todayOfYear = 0;
    bool SessionIsOn = false;
    double theSessionOpenPrice;
    string latestSession;
    int currentSessionHour;
    bool SessionOpenPriceWritten = false;

    // ----------------------------------------------- -------------------
    //| funkcja inicjalizacji eksperta |
    // ----------------------------------------------- -------------------
    int init ()
    {
    //----
    int currentHour = TimeHour (TimeCurrent ());
    if ((currentHour == SessionOpenHour1 || currentHour == SessionOpenHour2) CheckHourOfAttach)
    {
    Alert (IMPT: nie powinieneś dołączać tego EA podczas sesji Session1 Open hour lub Session2 Open hour);
    StartupStatusOK = false;
    }
    if (okres () gt; PERIOD_H1)
    {
    Alert (ten EA może być dołączony tylko do Wykresów z przedziałem czasu MNIEJ NIŻ 1 godzina);
    StartupStatusOK = false;
    }
    if (MinLots lt; MarketInfo (Symbol (), MODE_MINLOT))
    {
    Alert (Nieprawidłowe miniploty: Minospoty | Wypróbuj: MarketInfo (Symbol (), MODE_MINLOT));
    StartupStatusOK = false;
    }
    if (MaxLots gt; MarketInfo (Symbol (), MODE_MAXLOT))
    {
    Alert (Nieprawidłowe MaxLots: MaxLots | Try: MarketInfo (Symbol (), MODE_MAXLOT));
    StartupStatusOK = false;
    }
    if (SessionOpenHour1 lt; 0 || SessionOpenHour1 gt; 23)
    {
    Alert (Nieprawidłowa godzina otwarcia dla Sesji 1 : SessionOpenHour1);
    StartupStatusOK = false;
    }
    if (SessionOpenHour2 lt; 0 || SessionOpenHour2 gt; 23)
    {
    Alert (Nieprawidłowa godzina otwarcia dla Session2 : SessionOpenHour2);
    StartupStatusOK = false;
    }
    if (MoneyManagement (RiskPercent lt; = 0 || RiskPercent gt; 100))
    {
    Alert (Nieprawidłowy wynik RiskPercent: RiskPercent %);
    StartupStatusOK = false;
    }
    if (StartupStatusOK)
    {
    Alert (CBBP EA załadowany na Symbol () z ważnymi wejściami);
    }
    WriteToLogFile (Początek CBBP EA);

    GetSpread ();

    todayOfYear = DayOfYear ();
    //Wyszukuj ułamkowe pipsy
    jeśli (cyfry == 3 || cyfry == 5)
    {
    PipFactor = 10;
    }
    Slippage = Slippage * PipFactor;
    if (Show_Comments)
    {
    WriteComment ();
    }
    //----
    return (0);
    }

    // ----------------------------------------------- -------------------
    //| ekspercka funkcja deinicjalizacji
    // ----------------------------------------------- -------------------
    int deinit ()
    {
    //----

    //----
    return (0);
    }


    // ----------------------------------------------- -------------------
    //| Funkcje logiczne zarządzania handlem |
    // ----------------------------------------------- -------------------

    bool TradeNotPlacedYet ()
    {
    int total = OrdersTotal ();
    jeśli (łącznie gt; 0)
    {
    for (int cnt = 0; cntlt; total; cnt )
    {
    if (OrderSelect (cnt, SELECT_BY_POS))
    {
    if (OrderSymbol () == Symbol () OrderMagicNumber () == EA_MAGIC_NUM)
    {
    SessionIsOn = false;
    return (false);
    }
    }
    }
    }
    //w przypadku, gdy handel został już otwarty i zamknięty dla tej sesji
    int histotal = OrdersHistoryTotal ();
    if (histotal gt; 0)
    {
    dla (cnt = 0; cntlt; histotal; cnt )
    {
    if (OrderSelect (cnt, SELECT_BY_POS, MODE_HISTORY))
    {
    if (OrderSymbol () == Symbol () OrderMagicNumber () == EA_MAGIC_NUM)
    {
    datetime LatestSessionStart = iTime (NULL, PERIOD_H1,0);
    datetime LatestSessionGrace = LatestSessionStart (GraceMinutes * 60);
    datetime CurrentOrderOpenTime = OrderOpenTime ();
    if (CurrentOrderOpenTime gt; = LatestSessionStart CurrentOrderOpenTime lt; = LatestSessionGrace)
    {
    SessionIsOn = false;
    return (false);
    }
    }
    }
    }
    }
    return (true);
    }

    bool Should_Buy (int SessionOpenIndex)
    {
    if (SessionOpenIndex == -1)
    {
    return (false);
    }
    theSessionOpenPrice = Otwórz [SessionOpenIndex];
    double theSessionCurrentPrice = Zamknij [0];
    if (theSessionCurrentPrice gt; theSessionOpenPrice)
    {
    double lookoutPrice = theSessionOpenPrice (Pip_Distance * Point * PipFactor);
    if (theSessionCurrentPrice gt; = lookoutPrice)
    {
    if (Spread_Still_In_Range ())
    {
    return (true);
    }
    jeszcze
    {
    if (! ProblemLogged)
    {
    string logmsg = Spread jest DoubleToStr (CustomSpread, 1) po przesunięciu ceny DoubleToStr (Pip_Distance, 1) z tej ceny otwarcia sesji. Brak handlu dla tej sesji;
    WriteToLogFile (logmsg);
    ProblemLogged = true;
    TradeTheSession = false;
    }
    }
    }
    }
    return (false);
    }

    bool Should_Sell (int SessionOpenIndex)
    {
    if (SessionOpenIndex == -1)
    {
    return (false);
    }
    theSessionOpenPrice = Otwórz [SessionOpenIndex];
    double theSessionCurrentPrice = Zamknij [0];
    if (theSessionCurrentPrice lt; theSessionOpenPrice)
    {
    double lookoutPrice = theSessionOpenPrice - (Pip_Distance * Point * PipFactor);
    if (theSessionCurrentPrice lt; = lookoutPrice)
    {
    if (Spread_Still_In_Range ())
    {
    return (true);
    }
    jeszcze
    {
    if (! ProblemLogged)
    {
    string logmsg = Spread jest DoubleToStr (CustomSpread, 1) po przesunięciu ceny DoubleToStr (Pip_Distance, 1) z tej ceny otwarcia sesji. Brak handlu dla tej sesji;
    WriteToLogFile (logmsg);
    ProblemLogged = true;
    TradeTheSession = false;
    }
    }
    }
    }
    return (false);
    }

    double PositionSizeToOpen (int StopLossPips)
    {
    double PositionSize;
    podwójne ryzykoDolary;

    if (MoneyManagement StopLossPips gt; 0)
    {
    if (UseEquity)
    {
    riskDollars = (AccountEquity ()100) * RiskPercent;
    }
    jeszcze
    {
    riskDollars = (AccountBalance ()100) * RiskPercent;
    }
    PositionSize = (riskDollarsStopLossPips)(MarketInfo (Symbol (), MODE_TICKVALUE) * PipFactor);
    }

    if (MoneyManagement StopLossPips lt; = 0)
    {
    if (UseEquity)
    {
    PositionSize = ((AccountEquity ()100) * RiskPercent)(MarketInfo (Symbol (), MODE_LOTSIZE)AccountLeverage ());
    }
    jeszcze
    {
    PositionSize = ((AccountBalance ()100) * RiskPercent)(MarketInfo (Symbol (), MODE_LOTSIZE)AccountLeverage ());
    }
    }

    jeśli (! MoneyManagement)
    {
    PositionSize = FixedLots;
    }

    if (PositionSize lt; MinLots)
    {
    PositionSize = MinLots;
    }
    if (PositionSize gt; MaxLots)
    {
    PositionSize = MaxLots;
    }
    PositionSize = NormalizeDouble (PositionSize, LotsDecimalAllowed);
    return (PositionSize);
    }

    bool SendOrders (int BuyOrSell, double LotSize, double PriceToOpen, double Slippage, double SL_Price, double TP_Price, komentarze do ciągów, datetime ExpirationTime)
    {
    int ticket, errorType;

    if (BuyOrSell == OP_BUY)
    {
    if (IsECN)
    {
    Drukuj (Licytacja: Bid Zapytaj: Zapytaj | Otwarcie zamówienia zakupu: Symbol () , KupOrSell , LotSize , PriceToOpen , Slippage , SL_Cena , TP_Cena , komentarze , EA_MAGIC_NUM , ExpirationTime , Zielony) ;
    ticket = OrderSend (Symbol (), BuyOrSell, LotSize, PriceToOpen, Slippage, 0,0, komentarze, EA_MAGIC_NUM, ExpirationTime, Green);
    if (ticketgt; 0)
    {
    if (OrderSelect (bilet, SELECT_BY_TICKET, MODE_TRADES))
    {
    Drukuj (zamówienie BUY zostało otwarte:, OrderOpenPrice ());
    msg = ticket : Kup pozycję otwartą na DoubleToStr (OrderOpenPrice (), cyfry);
    WriteToLogFile (msg);
    if (OrderModify (bilet, OrderOpenPrice (), SL_Price, TP_Price, 0))
    {
    Drukuj (dodano Stop Loss i Take Profit);
    msg = ticket : Stop Loss: DoubleToStr (SL_Price, Digits) i Take Profit DoubleToStr (TP_Price, Digits) dodane;
    WriteToLogFile (msg);
    }
    jeszcze
    {
    errorType = GetLastError ();
    Drukuj (ERROR dodaje Stop Loss i Take Profit -, ErrorDescription (errorType));
    msg = ticket : ERROR add Stop Loss: DoubleToStr (SL_Price, Digits) i Take Profit DoubleToStr (TP_Price, Digits) - ErrorDescription (errorType);
    WriteToLogFile (msg);
    }
    return (true);
    }
    }
    jeszcze
    {
    errorType = GetLastError ();
    Drukuj (błąd podczas otwierania zamówienia KUP:, ErrorDescription (errorType));
    msg = NIE MOŻNA otworzyć pozycji KUP. ErrorDescription (typ błędu);
    WriteToLogFile (msg);
    return (false);
    }
    }
    jeszcze
    {
    Drukuj (Licytacja: Bid Zapytaj: Zapytaj | Otwarcie zamówienia zakupu: Symbol () , KupOrSell , LotSize , PriceToOpen , Slippage , SL_Cena , TP_Cena , komentarze , EA_MAGIC_NUM , ExpirationTime , Zielony) ;
    ticket = OrderSend (Symbol (), BuyOrSell, LotSize, PriceToOpen, Slippage, SL_Price, TP_Price, komentarze, EA_MAGIC_NUM, ExpirationTime, Green);
    if (ticketgt; 0)
    {
    if (OrderSelect (bilet, SELECT_BY_TICKET, MODE_TRADES))
    {
    Drukuj (zamówienie BUY zostało otwarte:, OrderOpenPrice ());
    msg = ticket : Kup pozycję otwartą. ErrorDescription (typ błędu);
    WriteToLogFile (msg);
    return (true);
    }
    }
    jeszcze
    {
    errorType = GetLastError ();
    Drukuj (błąd podczas otwierania zamówienia KUP:, ErrorDescription (errorType));
    msg = NIE MOŻNA otworzyć pozycji KUP. ErrorDescription (typ błędu);
    WriteToLogFile (msg);
    return (false);
    }
    }
    }
    if (BuyOrSell == OP_SELL)
    {
    if (IsECN)
    {
    Drukuj (Licytacja: Bid Zapytaj: Zapytaj | Otwarcie zamówienia sprzedaży: Symbol () , KupOrSell , Lotize , PriceToOpen , Slippage , SL_Cena , TP_Cena , komentarze , EA_MAGIC_NUM , ExpirationTime , Czerwony) ;
    ticket = OrderSend (Symbol (), BuyOrSell, LotSize, PriceToOpen, Slippage, 0,0, komentarze, EA_MAGIC_NUM, ExpirationTime, Red);
    if (ticketgt; 0)
    {
    if (OrderSelect (bilet, SELECT_BY_TICKET, MODE_TRADES))
    {
    Drukuj (rozkaz SELL otwarty:, OrderOpenPrice ());
    msg = ticket : Sprzedaj pozycję otwartą na DoubleToStr (OrderOpenPrice (), Cyfry);
    WriteToLogFile (msg);
    if (OrderModify (bilet, OrderOpenPrice (), SL_Price, TP_Price, 0))
    {
    Drukuj (dodano Stop Loss i Take Profit);
    msg = ticket : Stop Loss: DoubleToStr (SL_Price, Digits) i Take Profit DoubleToStr (TP_Price, Digits) dodane;
    WriteToLogFile (msg);
    }
    jeszcze
    {
    errorType = GetLastError ();
    Drukuj (ERROR dodaje Stop Loss i Take Profit -, ErrorDescription (errorType));
    msg = ticket : ERROR add Stop Loss: DoubleToStr (SL_Price, Digits) i Take Profit DoubleToStr (TP_Price, Digits) - ErrorDescription (errorType);
    WriteToLogFile (msg);
    }
    return (true);
    }
    }
    jeszcze
    {
    errorType = GetLastError ();
    Drukuj (Błąd podczas otwierania polecenia SELL:, ErrorDescription (errorType));
    msg = NIE MOŻNA otworzyć pozycji SELL. ErrorDescription (typ błędu);
    WriteToLogFile (msg);
    return (false);
    }
    }
    jeszcze
    {
    Drukuj (Licytacja: Bid Zapytaj: Zapytaj | Otwarcie zamówienia sprzedaży: Symbol () , KupOrSell , Lotize , PriceToOpen , Slippage , SL_Cena , TP_Cena , komentarze , EA_MAGIC_NUM , ExpirationTime , Czerwony) ;
    ticket = OrderSend (Symbol (), BuyOrSell, LotSize, PriceToOpen, Slippage, SL_Price, TP_Price, komentarze, EA_MAGIC_NUM, ExpirationTime, Red);
    if (ticketgt; 0)
    {
    if (OrderSelect (bilet, SELECT_BY_TICKET, MODE_TRADES))
    {
    Drukuj (otwarte zamówienie sprzedaży:, OrderOpenPrice ());
    msg = ticket : Sprzedaj pozycję otwartą. ErrorDescription (typ błędu);
    WriteToLogFile (msg);
    return (true);
    }
    }
    jeszcze
    {
    errorType = GetLastError ();
    Drukuj (Błąd podczas otwierania polecenia SELL:, ErrorDescription (errorType));
    msg = NIE MOŻNA otworzyć pozycji SELL. ErrorDescription (typ błędu);
    WriteToLogFile (msg);
    return (false);
    }
    }
    }
    }


    bool Spread_Still_In_Range ()
    {
    if (Use_Spread_Filtering CustomSpread gt; Spread_Filter)
    {
    return (false);
    }
    return (true);
    }


    void OpenBuyOrder ()
    {
    RefreshRates ();
    podwójne PriceToOpen, TakeProfitPrice, StopLossPrice, PositionSize;
    PriceToOpen = Zapytaj;
    PriceToOpen = NormalizeDouble (PriceToOpen, Cyfry);
    PositionSize = PositionSizeToOpen (the_StopLoss);
    if (TakeProfit == 0)
    {
    TakeProfitPrice = 0;
    }
    jeszcze
    {
    TakeProfitPrice = PriceToOpen (TakeProfit * Point * PipFactor);
    TakeProfitPrice = NormalizeDouble (TakeProfitPrice, Cyfry);
    }
    if (the_StopLoss == 0)
    {
    StopLossPrice = 0;
    }
    jeszcze
    {
    StopLossPrice = PriceToOpen - (the_StopLoss * Point * PipFactor);
    StopLossPrice = NormalizeDouble (StopLossPrice, Cyfry);
    }
    if (PositionSize lt; MinLots)
    {
    PositionSize = MinLots;
    }
    if (PositionSize gt; MaxLots)
    {
    PositionSize = MaxLots;
    }
    PositionSize = NormalizeDouble (PositionSize, LotsDecimalAllowed);
    string DateNow = TimeDay (TimeCurrent ()) - TimeMonth (TimeCurrent ()) - TimeYear (TimeCurrent ());
    SendOrders (OP_BUY, PositionSize, PriceToOpen, Slippage, StopLossPrice, TakeProfitPrice, CBBP_ DateNow, 0);
    }

    void OpenSellOrder ()
    {
    RefreshRates ();
    podwójne PriceToOpen, TakeProfitPrice, StopLossPrice, PositionSize;
    PriceToOpen = Oferta;
    PriceToOpen = NormalizeDouble (PriceToOpen, Cyfry);
    PositionSize = PositionSizeToOpen (the_StopLoss);
    if (TakeProfit == 0)
    {
    TakeProfitPrice = 0;
    }
    jeszcze
    {
    TakeProfitPrice = PriceToOpen - (TakeProfit * Point * PipFactor);
    TakeProfitPrice = NormalizeDouble (TakeProfitPrice, Cyfry);
    }
    if (the_StopLoss == 0)
    {
    StopLossPrice = 0;
    }
    jeszcze
    {
    StopLossPrice = PriceToOpen (the_StopLoss * Point * PipFactor);
    StopLossPrice = NormalizeDouble (StopLossPrice, Cyfry);
    }

    if (PositionSize lt; MinLots)
    {
    PositionSize = MinLots;
    }
    if (PositionSize gt; MaxLots)
    {
    PositionSize = MaxLots;
    }
    PositionSize = NormalizeDouble (PositionSize, LotsDecimalAllowed);
    string DateNow = TimeDay (TimeCurrent ()) - TimeMonth (TimeCurrent ()) - TimeYear (TimeCurrent ());
    SendOrders (OP_SELL, PositionSize, PriceToOpen, Slippage, StopLossPrice, TakeProfitPrice, DateNow, 0);
    }

    void ManageTrades ()
    {
    double TrailLevel = PipFactor * Point * TrailingStop;
    TrailLevel = NormalizeDouble (TrailLevel, Digits);
    double BE_Level = PipFactor * Point * BreakEven_Pips;
    BE_Level = NormalizeDouble (BE_Level, Digits);
    double TakeProfitPrice, StopLossPrice;
    string logmsg =;
    int ticket, errorType;
    double closeNOWprice = 0;

    int total = OrdersTotal ();
    jeśli (łącznie gt; 0)
    {
    //musi cofać się
    for (int cnt = total-1; cntgt; = 0; cnt--)
    {
    if (OrderSelect (cnt, SELECT_BY_POS))
    {
    if (OrderSymbol () == Symbol () OrderMagicNumber () == EA_MAGIC_NUM)
    {
    if (OrderType () == OP_BUY)
    {
    //W przypadku, gdy Stop Loss i TakeProfit nie zostały dodane. Zróbmy coś tutaj ...
    if (OrderStopLoss () == 0 the_StopLoss! = 0)
    {
    ticket = OrderTicket ();
    //Natychmiast zamknij transakcję, jeśli cena już została przesunięta, zepsuje poziom stop loss
    if (OrderOpenPrice () - Bid gt; = PipFactor * Point * the_StopLoss)
    {
    closeNOWprice = NormalizeDouble (Bid, Cyfry);
    if (OrderClose (ticket, OrderLots (), closeNOWprice, Slippage, Red))
    {
    Drukuj (awaryjne (Stop Loss) zamknięcie zamówienia:, bilet, sukces);
    logmsg = ticket : zamykanie awaryjne (Stop Loss) zakończone powodzeniem !;
    WriteToLogFile (logmsg);
    dalej;
    }
    jeszcze
    {
    errorType = GetLastError ();
    Drukuj (ERROR! Emergency (Stop Loss) zamknięcie zamówienia:, bilet, nie powiodło się! -, ErrorDescription (errorType));
    logmsg = ticket : Emergency (Stop Loss) zamknięcie zamówienia: ticket failed! - ErrorDescription (typ błędu);
    WriteToLogFile (logmsg);
    }
    }
    jeszcze
    {
    //spróbuj teraz ustawić Stop Loss i Take Profit
    StopLossPrice = OrderOpenPrice () - (the_StopLoss * Point * PipFactor);
    StopLossPrice = NormalizeDouble (StopLossPrice, Cyfry);
    TakeProfitPrice = OrderOpenPrice () (TakeProfit * Point * PipFactor);
    TakeProfitPrice = NormalizeDouble (TakeProfitPrice, Cyfry);
    if (OrderModify (ticket, OrderOpenPrice (), StopLossPrice, TakeProfitPrice, 0))
    {
    Drukuj (Stop Loss i Take Profit of order:, ticket, dodane pomyślnie);
    logmsg = ticket : Stop Loss and Take Profit zostały dodane !;
    WriteToLogFile (logmsg);
    }
    jeszcze
    {
    errorType = GetLastError ();
    Drukuj (ERROR! Dodawanie Stop Loss i Take Profit of order:, ticket, failed! -, ErrorDescription (errorType));
    logmsg = ticket : Dodawanie Stop Loss i Take Profit of order: ticket failed! - ErrorDescription (typ błędu);
    WriteToLogFile (logmsg);
    }
    }
    }
    //Podobny do powyższego, z wyjątkiem tego, że rozwiązuje to scenariusz z zamkiem poziomu takeprofit
    if (OrderTakeProfit () == 0 TakeProfit! = 0)
    {
    //Natychmiast zamknij transakcję, jeśli cena już została przesunięta, zepsuje poziom stop loss
    if (Bid-OrderOpenPrice () gt; = PipFactor * Point * TakeProfit)
    {
    ticket = OrderTicket ();
    closeNOWprice = NormalizeDouble (Bid, Cyfry);
    if (OrderClose (ticket, OrderLots (), closeNOWprice, Slippage, Blue))
    {
    Drukuj (Emergency (Take Profit) zamknięcie zamówienia:, bilet, sukces);
    logmsg = ticket : Zamknięcie awaryjne (Take Profit) zakończone sukcesem !;
    WriteToLogFile (logmsg);
    dalej;
    }
    jeszcze
    {
    errorType = GetLastError ();
    Drukuj (ERROR! Emergency (Take Profit) zamknięcie zamówienia:, bilet, nie powiodło się! -, ErrorDescription (errorType));
    logmsg = ticket : Emergency (Take Profit) zamknięcie zamówienia: ticket failed! - ErrorDescription (typ błędu);
    WriteToLogFile (logmsg);
    }
    }
    }

    //Sprawdź, czy Breakeven.
    jeśli (Use_BE)
    {
    if (Bid-OrderStopLoss () gt; PipFactor * Point * BreakEven_Pips)
    {
    if (OrderStopLoss () lt; OrderOpenPrice ())
    {
    StopLossPrice = Stawka - BE_Level;
    StopLossPrice = NormalizeDouble (StopLossPrice, Cyfry);
    if (StopLossPrice gt; OrderOpenPrice ())
    {
    if (OrderModify (OrderTicket (), OrderOpenPrice (), OrderOpenPrice (), OrderTakeProfit (), 0, zielony))
    {
    logmsg = Buy Order OrderTicket () SL osiągnął poziom Breakeven .;
    WriteToLogFile (logmsg);
    }
    }
    jeszcze
    {
    if (OrderModify (OrderTicket (), OrderOpenPrice (), StopLossPrice, OrderTakeProfit (), 0, zielony))
    {
    logmsg = Buy Order OrderTicket () SL w kierunku poziomu rentowności .;
    WriteToLogFile (logmsg);
    }
    }
    }
    }
    }
    //Sprawdź Floating Stop
    if (! UseJumpingStop (TrailingStop! = 0))
    {
    if ((Bid-OrderOpenPrice ()) gt; TrailLevel ((Bid-OrderOpenPrice ()) gt; = BE_Level || OrderStopLoss () gt; = OrderOpenPrice ()))
    {
    if (OrderStopLoss () lt; Bid-TrailLevel)
    {
    StopLossPrice = NormalizeDouble (Bid-TrailLevel, Digits);
    OrderModify (OrderTicket (), OrderOpenPrice (), StopLossPrice, OrderTakeProfit (), 0, zielony);
    }
    }
    }
    //Sprawdź, czy Jumping Stop
    if (UseJumpingStop (TrailingStop! = 0))
    {
    if ((Bid-OrderStopLoss () gt; (TrailLevel * 2)) ((Bid-OrderOpenPrice ()) gt; = BE_Level || OrderStopLoss () gt; = OrderOpenPrice ()))
    {
    if ((OrderStopLoss () TrailLevel) lt; OrderTakeProfit () || OrderTakeProfit () == 0)/Stop loss level nie może być wyższy niż poziom zysku
    {
    StopLossPrice = NormalizeDouble (OrderStopLoss () TrailLevel, Cyfry);
    OrderModify (OrderTicket (), OrderOpenPrice (), StopLossPrice, OrderTakeProfit (), 0, zielony);
    }
    }
    }
    }

    if (OrderType () == OP_SELL)
    {
    //W przypadku, gdy Stop Loss i TakeProfit nie zostały dodane. Zróbmy coś tutaj ...
    if (OrderStopLoss () == 0 the_StopLoss! = 0)
    {
    ticket = OrderTicket ();
    //Natychmiast zamknij transakcję, jeśli cena już została przesunięta, zepsuje poziom stop loss
    if (Ask - OrderOpenPrice () gt; = PipFactor * Point * the_StopLoss)
    {
    closeNOWprice = NormalizeDouble (Ask, Cyfry);
    if (OrderClose (ticket, OrderLots (), closeNOWprice, Slippage, Red))
    {
    Drukuj (awaryjne (Stop Loss) zamknięcie zamówienia:, bilet, sukces);
    logmsg = ticket : zamykanie awaryjne (Stop Loss) zakończone powodzeniem !;
    WriteToLogFile (logmsg);
    dalej;
    }
    jeszcze
    {
    errorType = GetLastError ();
    Drukuj (ERROR! Emergency (Stop Loss) zamknięcie zamówienia:, bilet, nie powiodło się! -, ErrorDescription (errorType));
    logmsg = ticket : Emergency (Stop Loss) zamknięcie zamówienia: ticket failed! - ErrorDescription (typ błędu);
    WriteToLogFile (logmsg);
    }
    }
    jeszcze
    {
    //spróbuj teraz ustawić Stop Loss i Take Profit
    StopLossPrice = OrderOpenPrice () (the_StopLoss * Point * PipFactor);
    StopLossPrice = NormalizeDouble (StopLossPrice, Cyfry);
    TakeProfitPrice = OrderOpenPrice () - (TakeProfit * Point * PipFactor);
    TakeProfitPrice = NormalizeDouble (TakeProfitPrice, Cyfry);
    if (OrderModify (ticket, OrderOpenPrice (), StopLossPrice, TakeProfitPrice, 0))
    {
    Drukuj (Stop Loss i Take Profit of order:, ticket, dodane pomyślnie);
    logmsg = ticket : Stop Loss and Take Profit zostały dodane !;
    WriteToLogFile (logmsg);
    }
    jeszcze
    {
    errorType = GetLastError ();
    Drukuj (ERROR! Dodawanie Stop Loss i Take Profit of order:, ticket, failed! -, ErrorDescription (errorType));
    logmsg = ticket : Dodawanie Stop Loss i Take Profit of order: ticket failed! - ErrorDescription (typ błędu);
    WriteToLogFile (logmsg);
    }
    }
    }
    //Podobny do powyższego, z wyjątkiem tego, że rozwiązuje to scenariusz z zamkiem poziomu takeprofit
    if (OrderTakeProfit () == 0 TakeProfit! = 0)
    {
    //Natychmiast zamknij transakcję, jeśli cena już została przesunięta, zepsuje poziom stop loss
    if (OrderOpenPrice () - Ask gt; = PipFactor * Point * TakeProfit)
    {
    ticket = OrderTicket ();
    closeNOWprice = NormalizeDouble (Ask, Cyfry);
    if (OrderClose (ticket, OrderLots (), closeNOWprice, Slippage, Blue))
    {
    Drukuj (Emergency (Take Profit) zamknięcie zamówienia:, bilet, sukces);
    logmsg = ticket : Zamknięcie awaryjne (Take Profit) zakończone sukcesem !;
    WriteToLogFile (logmsg);
    dalej;
    }
    jeszcze
    {
    errorType = GetLastError ();
    Drukuj (ERROR! Emergency (Take Profit) zamknięcie zamówienia:, bilet, nie powiodło się! -, ErrorDescription (errorType));
    logmsg = ticket : Emergency (Take Profit) zamknięcie zamówienia: ticket failed! - ErrorDescription (typ błędu);
    WriteToLogFile (logmsg);
    }
    }
    }

    //Sprawdź, czy Breakeven
    jeśli (Use_BE)
    {
    if (OrderStopLoss () - Ask gt; PipFactor * Point * BreakEven_Pips)
    {
    if (OrderStopLoss () gt; OrderOpenPrice ())
    {
    StopLossPrice = Zapytaj BE_Level;
    StopLossPrice = NormalizeDouble (StopLossPrice, Cyfry);
    if (StopLossPrice lt; OrderOpenPrice ())
    {
    if (OrderModify (OrderTicket (), OrderOpenPrice (), OrderOpenPrice (), OrderTakeProfit (), 0, zielony))
    {
    logmsg = Sell Order OrderTicket () SL osiągnął poziom Breakeven .;
    WriteToLogFile (logmsg);
    }
    }
    jeszcze
    {
    if (OrderModify (OrderTicket (), OrderOpenPrice (), StopLossPrice, OrderTakeProfit (), 0, zielony))
    {
    logmsg = Sell Order OrderTicket () SL zmierza w kierunku poziomu Breakeven .;
    WriteToLogFile (logmsg);
    }
    }
    }
    }
    }
    //Sprawdź Floating Stop
    if (! UseJumpingStop (TrailingStop! = 0))
    {
    if ((OrderOpenPrice () - Ask) gt; TrailLevel ((OrderOpenPrice () - Ask) gt; = BE_Level || OrderStopLoss () lt; = OrderOpenPrice ()))
    {
    if (OrderStopLoss () gt; Ask TrailLevel)
    {
    StopLossPrice = NormalizeDouble (Ask TrailLevel, Digits);
    OrderModify (OrderTicket (), OrderOpenPrice (), StopLossPrice, OrderTakeProfit (), 0, czerwony);
    }
    }
    }
    //Sprawdź, czy Jumping Stop
    if (UseJumpingStop (TrailingStop! = 0))
    {
    //aktywuj tylko wtedy, gdy pozycja jest zyskiem przez stoploss amt.
    if (((OrderStopLoss () - Ask) gt; (TrailLevel * 2)) ((OrderOpenPrice () - Ask) gt; = BE_Level || OrderStopLoss () lt; = OrderOpenPrice ()))
    {
    if ((OrderStopLoss () - TrailLevel) gt; OrderTakeProfit () || OrderTakeProfit () == 0)/Stop loss level nie może być niższy niż wziąć poziom zysku
    {
    StopLossPrice = NormalizeDouble (OrderStopLoss () - TrailLevel, Digits);
    OrderModify (OrderTicket (), OrderOpenPrice (), StopLossPrice, OrderTakeProfit (), 0, czerwony);
    }
    }
    }
    }
    }
    }
    }
    }
    }

    // ----------------------------------------------- -------------------
    //| Różne funkcje |
    // ----------------------------------------------- -------------------

    void GetSpread ()
    {
    if (UserDefinedSpread lt; = 0)
    {
    CustomSpread = (MarketInfo (Symbol (), MODE_SPREAD))PipFactor;
    }
    jeszcze
    {
    Custom Spread = Spread zdefiniowany przez użytkownika;
    }

    //Czy powinniśmy dodać spread do StopLoss?
    Stop Loss = Stop Loss;
    if (StopLoss gt; 0)
    {
    jeśli (Add_Spread_To_StopLoss)
    {
    Stop Loss = Stop Loss Custom Spread;
    }
    jeszcze
    {
    Stop Loss = Stop Loss;
    }
    }
    }

    void WriteComment ()
    {
    msg =;
    int currentHour = TimeHour (Czas [0]);
    if (SessionOpenHour1 lt; SessionOpenHour2)
    {
    if (currentHour lt; SessionOpenHour2)
    {
    msg = EA czeka na Session2 Open;
    }
    if (currentHour lt; SessionOpenHour1 || currentHour gt; SessionOpenHour2)
    {
    msg = EA czeka na Session1 Open;
    }
    }
    jeszcze
    {
    if (currentHour lt; SessionOpenHour1)
    {
    msg = EA czeka na Session1 Open;
    }
    if (currentHour lt; SessionOpenHour2 || currentHour gt; SessionOpenHour1)
    {
    msg = EA czeka na Session2 Open;
    }
    }
    msg = msg \ Current Time: current Hour : Time Minute (TimeCurrent ());

    if (PipFactor == 10)
    {
    msg = msg \ nPraca z frakcyjnymi pipsami;
    }
    jeszcze
    {
    msg = msg \ nPraca z nie ułamkowymi pipsami;
    }
    //double stoplevel = MarketInfo (Symbol (), MODE_STOPLEVEL)PipFactor;

    if (MoneyManagement the_StopLoss gt; 0)
    {
    msg = msg \ Korzystanie z funkcji zarządzania pieniędzmi zgodnie ze stop loss;
    }
    msg = msg \ Current Spread: DoubleToStr (Custom Spread, 1) pips;
    jeśli (Add_Spread_To_StopLoss the_StopLoss! = 0)
    {
    msg = msg \ nSpread zostanie dodany do Twojego Stop Loss;
    }
    jeszcze
    {
    msg = msg \ nSpread NIE zostanie dodany do Stop Loss;
    }
    if (SessionIsOn)
    {
    msg = msg \ on \ Czas na wymianę latestSession . Szukam wpisu ...;
    msg = msg \ n Cena otwarcia sesji: DoubleToStr (theSessionOpenPrice, Cyfry);
    msg = msg \ nCena bieżąca: DoubleToStr (Close [0], Digits);
    }
    jeszcze
    {
    msg = msg \ n latestSession okno transakcyjne jest zamknięte .;
    }
    Komentarz (msg);
    }

    void WriteToLogFile (wejście łańcuchowe)
    {
    string filename = CBBP- Symbol () - Dzień () - Miesiąc () - Rok () . log;
    int handle = FileOpen (nazwa pliku, FILE_READ | FILE_WRITE);
    if (handlegt; 1)
    {
    prefiks ciągu = Dzień () Miesiąc () Rok () - Godzina () : Minuta () : Sekunda () = gt; ;
    FileSeek (uchwyt, 0, SEEK_END);/przejdź do końca pliku
    FileWrite (uchwyt, prefiks wejście);
    FileClose (uchwyt);
    }
    }
    //Ta metoda jest tworzona w celu odrodzenia nowego pliku na nowy dzień. Pierwsza linia, która ma być napisana, nie jest zapisywana.
    //Użyta tu fikcyjna wiadomość może działać jako bufor, dzięki czemu przydatne informacje nie zostaną pominięte.
    void CreateNewLogFileIfNewDay ()
    {
    if (todayOfYear! = DayOfYear ())
    {
    todayOfYear = DayOfYear ();
    WriteToLogFile (Dummy message);
    }
    }

    bool TimeToTrade ()
    {
    int currentHour = TimeHour (Czas [0]);
    int currentMinute = TimeMinute (TimeCurrent ());
    if ((currentHour == SessionOpenHour1 || currentHour == SessionOpenHour2) currentMinute lt; GraceMinutes)
    {
    return (true);
    }
    return (false);
    }

    int GetSessionOpenCandle ()
    {
    int SessionOpenCandleIndex = -1;
    for (int i = 0; ilt; = GraceMinutes 1; i )
    {
    if (TimeHour (Time [i]) == currentSessionHour TimeMinute (Time [i]) == 0)
    {
    SessionOpenCandleIndex = i;
    złamać;
    }
    }
    return (SessionOpenCandleIndex);
    }

    // ----------------------------------------------- -------------------
    //| funkcja startu eksperta |
    // ----------------------------------------------- -------------------
    int start ()
    {
    //----
    if (! StartupStatusOK)
    {
    Komentarz (Wystąpiły błędy w danych wejściowych EA. Ponownie sprawdź je ponownie.);
    return (0);
    }
    CreateNewLogFileIfNewDay ();
    ManageTrades ();
    GetSpread ();

    if (TimeToTrade ())
    {
    currentSessionHour = TimeHour (czas [0]);
    jeśli (currentSessionHour == SessionOpenHour1)
    {
    latestSession = Session1;
    }
    jeśli (currentSessionHour == SessionOpenHour2)
    {
    latestSession = Session2;
    }
    if (TradeNotPlacedYet () TradeTheSession)
    {
    int SessionOpenIndex = GetSessionOpenCandle ();
    SessionIsOn = true;
    if (! SessionOpenPriceWritten)
    {
    string logmsg = latestSession open at DoubleToStr (Otwórz [SessionOpenIndex], Cyfry);
    Drukuj (logmsg);
    WriteToLogFile (logmsg);
    SessionOpenPriceWritten = true;
    }
    if (Should_Buy (SessionOpenIndex) TradeTheSession)
    {
    OpenBuyOrder ();
    TradeTheSession = false;
    }
    if (Should_Sell (SessionOpenIndex) TradeTheSession)
    {
    OpenSellOrder ();
    TradeTheSession = false;
    }
    }
    jeszcze
    {
    SessionIsOn = false;
    }
    }
    jeszcze
    {
    SessionIsOn = false;
    TradeTheSession = true;
    ProblemLogged = false;
    SessionOpenPriceWritten = false;
    }
    if (Show_Comments)
    {
    WriteComment ();
    }

    //----
    return (0);

  2. #2
    Jestem pewien, że jest ktoś, kto może zobaczyć wartość w tym EA. Jak uzyskać od BE (jak jest) do BE (x) liczbę pestek? Dziękuję Ci

  3. #3
    proszę dołączyć EA do postu - jak zwykle piszę, że składnia jest trochę spieprzona po ponownym załadowaniu do MT4 do edycji.

  4. #4
    Cytat Zamieszczone przez ;
    proszę dołączyć EA do postu - jak zwykle piszę, że składnia jest trochę spieprzona po ponownym załadowaniu do MT4 do edycji.
    Aja, proszę bardzo. dzięki
    https://www.forex-instant.com/tradin...statement.html
    https://www.forex-instant.com/attach...1375101646.mq4

  5. #5
    Czy mówisz o rozprzestrzenianiu? Albo prowizja na szczycie spreadu? Gdyby to był tylko spread, byłoby to dość łatwe, tak myślę? ... BE ((Ask-Bid)Point) * Partie (mogą wymagać dodatkowego nawiasu). W przeciwnym razie musisz dowiedzieć się, w jaki sposób twój broker oblicza dodatkową prowizję i musiałbyś ją poprosić.

  6. #6
    Wersja 3 EA, która wymaga tego wymogu, jest wydana w wątku Central Banks and Big Players. Ten wątek można zamknąć. pozdrowienia, Zen

  7. #7
    Czy masz link? A może możesz tutaj opublikować najnowszą wersję? Nieważne, znalazłem to w tym poście tutaj.

  8. #8
    Cześć Chciałem tylko wiedzieć, czy ten EA ma kod, który ustawia stop, aby złamać nawet po zyskach 2 pipsów. Chciałem mieć tę funkcję, abym mógł ustawić i zapomnieć o zamówieniach po cenie, którą chcę, i po tym, jak osiągną zysk w wysokości 2 pipsów, pozwólcie na wolny handel. Nie jestem programistą, więc nie mam pojęcia, co ten kod oznacza powyżej.

Uprawnienia umieszczania postów

  • Nie możesz zakładać nowych tematów
  • Nie możesz pisać wiadomości
  • Nie możesz dodawać załączników
  • Nie możesz edytować swoich postów
  •  
Używamy cookies
Używamy cookies, aby jak najlepiej dostosować witrynę do Twoich potrzeb. Kontynuowanie przeglądania tej strony, oznacza zgodę na używanie plików cookies. Aby uzyskać więcej informacji zapoznaj się z naszą Polityką Prywatności.