MetaTrader5
Lazy Bot MT5: Dein täglicher Trading-Assistent für MetaTrader 5
Willkommen in der Welt des automatisierten Tradings! Heute stelle ich dir den Lazy Bot MT5 vor, einen cleveren EA (Expert Advisor), der dir hilft, die täglichen Ausbrüche auf dem Markt zu nutzen.
1. Input-Parameter
EASettings: "---------------------------------------------"
Magic Number: 123456
Bot Name: "LazyBot_V1"
Lots: 0.01
Stoploss (in Pips): 5.0
Distanz von [H], [L] zu OP_Preis (in Pips): 0
Maximale Slippage: 3 Pips
Maximaler Spread (in Pips): 0 (0 = schwankend)
Trading-Zeiten:
Erlaubte Trading-Zeiten: Ja
Startstunde: 7
Endstunde: 22
Risikomanagement:
Volumen Prozent zulassen: Nein
Risikoprozent des Kontos (%): 1
2. Lokale Variableninitialisierung
// Lokale Parameter
datetime last;
int totalBars;
int Pips2Points; // Slippage 3 Pips
double Pips2Double; // Stoploss 15 Pips
double slippage;
double acSpread;
string strComment = "";
3. Hauptcode
Der Lazy Bot löscht alle alten Aufträge und sucht den höchsten und niedrigsten Wert der vorherigen Tageskerze. Daraufhin werden zwei ausstehende Aufträge gesetzt: BUY_STOP und SELL_STOP. (Es gibt kein TakeProfit).
a) Expert-Initialisierungsfunktion
int OnInit()
{
// 3 oder 5 Ziffern Erkennung
if (_Digits % 2 == 1)
{
Pips2Double = _Point * 10;
Pips2Points = 10;
slippage = 10 * Inpuser_SLippage;
}
else
{
Pips2Double = _Point;
Pips2Points = 1;
slippage = Inpuser_SLippage;
}
if (!m_symbol.Name(Symbol()))
return (INIT_FAILED);
RefreshRates();
m_trade.SetExpertMagicNumber(InpMagicNumber);
m_trade.SetMarginMode();
m_trade.SetTypeFillingBySymbol(m_symbol.Name());
m_trade.SetDeviationInPoints(slippage);
return (INIT_SUCCEEDED);
}
b) Expert-Tick-Funktion
void OnTick()
{
if (TerminalInfoInteger(TERMINAL_TRADE_ALLOWED) == false)
{
Comment("LazyBot\nTrade nicht erlaubt.");
return;
}
// Handelszeit ermitteln
MqlDateTime timeLocal;
MqlDateTime timeServer;
TimeLocal(timeLocal);
TimeCurrent(timeServer);
// Feiertage ignorieren
if (timeServer.day_of_week == 0 || timeServer.day_of_week == 6)
return;
int hourLocal = timeLocal.hour;
int hourCurrent = timeServer.hour;
acSpread = SymbolInfoInteger(_Symbol, SYMBOL_SPREAD);
strComment = "\nLokale Stunde ist = " + hourLocal;
strComment += "\nAktuelle Stunde ist = " + hourCurrent;
strComment += "\nSpread ist = " + (string)acSpread;
strComment += "\nGesamtbalken ist = " + (string)totalBars;
Comment(strComment);
// Trailing überprüfen
TrailingSL();
if (last != iTime(m_symbol.Name(), PERIOD_D1, 0))
{
if (isTradingTime)
{
if (hourCurrent >= InpStartHour)
{
DeleteOldOrds();
OpenOrder();
last = iTime(m_symbol.Name(), PERIOD_D1, 0);
}
}
else
{
DeleteOldOrds();
OpenOrder();
last = iTime(m_symbol.Name(), PERIOD_D1, 0);
}
}
}
3.1 Signal berechnen und Aufträge senden
void OpenOrder()
{
double TP_Buy = 0, TP_Sell = 0;
double SL_Buy = 0, SL_Sell = 0;
// Maximale Spread überprüfen
if (InpMax_spread != 0)
{
if (acSpread > InpMax_spread)
{
Print(__FUNCTION__, " > aktueller Spread ist größer als der zulässige Spread!...");
return;
}
}
double Bar1High = m_symbol.NormalizePrice(iHigh(m_symbol.Name(), PERIOD_D1, 1));
double Bar1Low = m_symbol.NormalizePrice(iLow(m_symbol.Name(), PERIOD_D1, 1));
// Lots berechnen
double lot1 = CalculateVolume();
double OpenPrice = m_symbol.NormalizePrice(Bar1High + InpAddPrice_pip * Pips2Double);
// Für BUY_STOP --------------------------------
SL_Buy = m_symbol.NormalizePrice(OpenPrice - Inpuser_SL * Pips2Double);
totalBars = iBars(m_symbol.Name(), PERIOD_D1);
string comment = InpBotName + ";" + m_symbol.Name() + ";" + totalBars;
if (CheckVolumeValue(lot1) && CheckOrderForFREEZE_LEVEL(ORDER_TYPE_BUY_STOP, OpenPrice) && CheckMoneyForTrade(m_symbol.Name(), lot1, ORDER_TYPE_BUY) && CheckStopLoss(OpenPrice, SL_Buy))
{
if (!m_trade.BuyStop(lot1, OpenPrice, m_symbol.Name(), SL_Buy, TP_Buy, ORDER_TIME_GTC, 0, comment))
Print(__FUNCTION__, "--> Buy Fehler");
}
// Für SELL_STOP --------------------------------
OpenPrice = m_symbol.NormalizePrice(Bar1Low - InpAddPrice_pip * Pips2Double);
SL_Sell = m_symbol.NormalizePrice(OpenPrice + Inpuser_SL * Pips2Double);
if (CheckVolumeValue(lot1) && CheckOrderForFREEZE_LEVEL(ORDER_TYPE_SELL_STOP, OpenPrice) && CheckMoneyForTrade(m_symbol.Name(), lot1, ORDER_TYPE_SELL) && CheckStopLoss(OpenPrice, SL_Sell))
{
if (!m_trade.SellStop(lot1, OpenPrice, m_symbol.Name(), SL_Sell, TP_Sell, ORDER_TIME_GTC, 0, comment))
Print(__FUNCTION__, "--> Sell Fehler");
}
}
3.2 Neuen Tag: Alle alten Aufträge löschen
void DeleteOldOrds()
{
string sep = ";";
ushort u_sep;
string result[];
for (int i = OrdersTotal() - 1; i >= 0; i--)
{
if (m_order.SelectByIndex(i))
{
u_sep = StringGetCharacter(sep, 0);
string Ordcomment = m_order.Comment();
int k = StringSplit(Ordcomment, u_sep, result);
if (k > 2)
{
string sym = m_symbol.Name();
if ((m_order.Magic() == InpMagicNumber) && (sym == result[1]))
{
m_trade.OrderDelete(m_order.Ticket());
}
}
}
}
}
3.3 Trailing StopLoss
Die EA hat die Funktion "Trailing StopLoss", die sich jedes Mal ändert, wenn der Preis steigt und somit den Gewinn erhöht.
void TrailingSL()
{
double SL_in_Pip = 0;
for (int i = PositionsTotal() - 1; i >= 0; i--)
{
if (m_position.SelectByIndex(i))
{
if ((m_position.Magic() == InpMagicNumber) && (m_position.Symbol() == m_symbol.Name()))
{
double order_stoploss1 = m_position.StopLoss();
// Für Kaufauftrag
if (m_position.PositionType() == POSITION_TYPE_BUY)
{
SL_in_Pip = NormalizeDouble((Bid - order_stoploss1), _Digits) / Pips2Double;
if (SL_in_Pip > Inpuser_SL)
{
order_stoploss1 = NormalizeDouble(Bid - (Inpuser_SL * Pips2Double), _Digits);
m_trade.PositionModify(m_position.Ticket(), order_stoploss1, m_position.TakeProfit());
}
}
// Für Verkaufsauftrag
if (m_position.PositionType() == POSITION_TYPE_SELL)
{
SL_in_Pip = NormalizeDouble((m_position.StopLoss() - Ask), _Digits) / Pips2Double;
if (SL_in_Pip > Inpuser_SL)
{
order_stoploss1 = NormalizeDouble(Ask + (Inpuser_SL * Pips2Double), _Digits);
m_trade.PositionModify(m_position.Ticket(), order_stoploss1, m_position.TakeProfit());
}
}
}
}
}
}
3.4 Volumenwert überprüfen
bool CheckVolumeValue(double volume)
{
double min_volume = m_symbol.LotsMin();
double max_volume = m_symbol.LotsMax();
double volume_step = m_symbol.LotsStep();
if (volume < min_volume || volume > max_volume)
{
return (false);
}
int ratio = (int)MathRound(volume / volume_step);
if (MathAbs(ratio * volume_step - volume) > 0.0000001)
{
return (false);
}
return (true);
}
3.5 Freeze Level überprüfen
bool CheckOrderForFREEZE_LEVEL(ENUM_ORDER_TYPE type, double price)
{
int freeze_level = (int)SymbolInfoInteger(_Symbol, SYMBOL_TRADE_FREEZE_LEVEL);
bool check = false;
switch (type)
{
case ORDER_TYPE_BUY_STOP:
check = ((price - Ask) > freeze_level * _Point);
return (check);
case ORDER_TYPE_SELL_STOP:
check = ((Bid - price) > freeze_level * _Point);
return (check);
}
return false;
}
3.6 Geld für den Handel überprüfen
bool CheckMoneyForTrade(string symb, double lots, ENUM_ORDER_TYPE type)
{
MqlTick mqltick;
SymbolInfoTick(symb, mqltick);
double price = mqltick.ask;
if (type == ORDER_TYPE_SELL)
price = mqltick.bid;
double margin, free_margin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
if (!OrderCalcMargin(type, symb, lots, price, margin))
{
Print("Error in ", __FUNCTION__, " code=", GetLastError());
return (false);
}
if (margin > free_margin)
{
Print("Nicht genug Geld für ", EnumToString(type), " ", lots, " ", symb, " Error code=", GetLastError());
return (false);
}
return (true);
}
3.7 Stoploss überprüfen
bool CheckStopLoss(double price, double SL)
{
int stops_level = (int)SymbolInfoInteger(m_symbol.Name(), SYMBOL_TRADE_STOPS_LEVEL);
if (stops_level != 0)
{
PrintFormat("SYMBOL_TRADE_STOPS_LEVEL=%d: StopLoss und TakeProfit müssen nicht näher als %d Punkte vom Schlusskurs sein", stops_level, stops_level);
}
return MathAbs(price - SL) > (stops_level * m_symbol.Point());
}
Hier sind auch einige nützliche Videos über MQL4 und MQL5:
Video MQL4:
Video MQL5:
2022.12.14
