Jede Anfängerfrage, um das Forum nicht zu überladen. Fachleute, gehen Sie nicht vorbei. Nirgendwo ohne dich - 6. - Seite 1096
Sie verpassen Handelsmöglichkeiten:
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Registrierung
Einloggen
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Wenn Sie kein Benutzerkonto haben, registrieren Sie sich
Hallo!
Wie können Sie feststellen, ob eine Position auf TP geschlossen ist? Ich glaube nicht, dass OrderClosePrice()==OrderTakeProfit() die richtige Wahl wäre.
Suchen Sie im Bestellkommentar nach [tp], wenn es eine...
Suchen Sie in den Bestellkommentaren nach [tp], wenn es einen gibt...
Hallo Profi.
helfen, den Fehler im Indikator zu beheben.....
Indikator funktioniert.
Das Signal wird bei Takt 0 ausgelöst.
Wenn jedoch weitere Ticks auf dem aktuellen Balken empfangen werden, wird er erneut ausgelöst und gibt neue Signale.
Ich brauche es, um dieses Signal in einem Kreis an der Stelle des aktuellen Ereignisses Preis, wenn Sell oder Buy - Ereignis auftritt, und keine anderen Ereignisse wurden auf dieser offenen Bar verarbeitet.
Ich möchte neue Signale und Kreise auf diesem Balken vermeiden.
________________________
Ich verstehe, dass Sie sagen werden, das ist Unsinn, das sind falsche Signale usw., aber das ist genau das, was ich brauche.
Ich weiß, dass ich eine Flagge, eine Markierung usw. erstellen sollte, aber ich habe keine Zeit, die Sprache selbst zu lernen.
_________________________
Ich wäre Ihnen sehr dankbar, wenn Sie der angehängten Datei ein solches Kennzeichen hinzufügen und die hinzugefügten Zeilen mit der Farbe..... markieren könnten.
Danke, und ich hoffe, dass jemand antworten wird
Gibt eine Reihe von Fehlern aus, kann aber nicht behoben werden. Was ist hier los?
//+------------------------------------------------------------------+Bitte helfen Sie mir, mit den Nachrichten zu handeln. Ich benötige einen EA, der zwei Hauptfunktionen hat.
Die erste Funktion: Platzierung vonschwebenden Aufträgen mit einem bestimmten TP und SL, zu einem bestimmten Zeitpunkt und auf einem bestimmten Kursniveau.
Die zweite Funktion: die ausstehenden Aufträge parallel zum Preis zu halten. Es bedeutet, sie zusammen mit dem Preis zu verschieben (es ist so lästig, dies manuell zu tun). Zu einem bestimmten Zeitpunkt, im Moment der Veröffentlichung der Nachricht, müssen wir diese Aktion stoppen und abwarten, bis der Kurs einen der Aufträge berührt. Der zweite Auftrag wird unmittelbar danach gelöscht.
Noch einmal:
2 Minuten vor der Veröffentlichung der Nachricht zwei entgegengesetzte Stop-Orders in einem Abstand von 10 Punkten zum Preis platzieren, sofort die Funktion aktivieren, sich parallel zum Preis zu bewegen, 2 Minuten mit dem Preis mitgehen, eine Order läuft vom Preis weg, die zweite holt den Preis ein. Bei der Veröffentlichung von Nachrichten sollten Sie die Funktion der ausstehenden Orderbewegungen deaktivieren und dann auf den Zusammenbruch einer der Orders warten. Der zweite Auftrag wird unmittelbar nach dem Zusammenbruch des ersten gelöscht.
Variable, die in den Eigenschaften eines EAs verändert werden (ungefähr so wie ich es mir vorstelle, ich weiß nicht, wie die Umsetzung in der Realität aussieht)
TP - 600 (standardmäßig)
Trall - 300 (Standard)
SL - 100 (Standard)
Pips - 100 (Standardabstand zum Preis)
Slippage - 100 (Slippage standardmäßig in Pips)
Los - 0,1
Risiko - 10 //Prozent (das ist nicht notwendig, ich werde es später fragen, falls nötig)
TimeNews1On - true (verwenden Sie die Zellen unten, um die Zeit einzugeben, false - der Berater handelt sie nicht)
TimeNewsHour - Stunde (Zeit der Nachrichtenveröffentlichung 1)
TimeNewsMin - Minuten (Zeit der Nachrichtenveröffentlichung 1)
TimeNews2On - falsch (standardmäßig)
TimeNewsHour - Stunden (Zeit für die Veröffentlichung von Nachrichten 2)
TimeNewsMin - Minuten (Zeit der Nachrichtenveröffentlichung 2)
TimeNews3On - falsch
TimeNewsHour - Stunden (Zeit für die Veröffentlichung von Nachrichten 3)
TimeNewsMin - Minuten (Zeit der Nachrichtenveröffentlichung 3)
TimeNews4On - falsch
TimeNewsHour - Stunden (Zeit der Nachrichtenveröffentlichung 4)
TimeNewsMin - Minuten (Zeit der Nachrichtenveröffentlichung 4)
TimeNews5On - falsch
TimeNewsHour - Stunden (Nachrichtenzeit 5)
TimeNewsMin - Minuten (Zeit der Nachrichtenveröffentlichung 5)
Insta, fünfstellig.
Ich tue all dies manuell, es ist zu viel Mühe, und jetzt habe ich keine Zeit, um die Nachrichten zu arbeiten, möchte ich die Expert Advisor am Morgen oder in der Nacht auf Paare, wo es Nachrichten an diesem Tag, so dass sie alle funktionieren wird platzieren.
--------------------------------------
Wenn Sie einen solchen Experten kennen, teilen Sie ihn bitte mit.
Vielen Dank im Voraus!
Gehen wir zurück zu Ihrem Quellcode. Versuchen Sie es so:
int OnInit()
{
if (!GlobalVariableCheck("AllowNewOrders")) GlobalVariableSet("AllowNewOrders",1);
return(INIT_SUCCEED);
}
void OnDeInit()
{
GlobalVariableSet("AllowNewOrders",1);
}
void OnTick()
{
if (CountTrades() == 0) // Die Anzahl der Aufträge muss Null sein
{
if ((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) < PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) > PriceOpenLastHistOrder(OP_SELL))
// Wenn der letzte Handel einen Verlust aufweist, wird derselbe Handel eröffnet, jedoch mit einem größeren Los.
{
GlobalVariableSet("AllowNewOrders", 0);
Typ = TypeLastHistOrder();
if (Typ == OP_BUY) Preis = Ask;
if (Typ == OP_SELL) Preis = Bid;
Lot = NormalizeDouble(LotsLastHistOrder()*Multiplier, 2);
ticket = OrderSend(Symbol(), Typ, Lot, Preis, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (PriceCloseLastHistOrder() == PriceOpenLastHistOrder() && CountHistTrades() > 0)
// wenn der Gewinn des letzten Geschäfts gleich Null ist, wird das gleiche Geschäft eröffnet
{
GlobalVariableSet("AllowNewOrders", 0);
Typ = TypeLastHistOrder();
if (Typ == OP_BUY) Preis = Ask;
if (Typ == OP_SELL) Preis = Bid;
Lot = NormalizeDouble(LotsLastHistOrder(), 2);
ticket = OrderSend(Symbol(), Typ, Lot, Preis, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) > PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) < PriceOpenLastHistOrder(OP_SELL))
|| CountHistTrades() == 0)// Wenn der letzte Handel profitabel ist, wird die Order eröffnet
{
if (GlobalVariableGet("AllowNewOrders") > 0)return;
if (SignalBuy() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic);
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0);
}
if (SignalSell() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic);
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0);
}
}
}
}
Ich habe es nicht überprüft, weil ich nicht verstehe, wie mehrere Kopien eines EA mit einem Gesamtlimit von 1 Auftrag bestimmen, auf welchem Symbol (nach einer profitablen Serie) es besser ist, den Handel zu beginnen?
Bitte helfen Sie, mit den Nachrichten zu handeln. Ich brauche wirklich einen EA, der zwei Hauptfunktionen haben sollte.
Erste Funktion: Platzierung vonschwebenden Aufträgen mit einem bestimmten TP und SL, zu einem bestimmten Zeitpunkt auf einem bestimmten Kursniveau.
Die zweite Funktion: die ausstehenden Aufträge parallel zum Preis zu halten. Es bedeutet, sie zusammen mit dem Preis zu verschieben (es ist so lästig, dies manuell zu tun). Zu einem bestimmten Zeitpunkt, im Moment der Veröffentlichung der Nachricht, müssen wir diese Aktion stoppen und abwarten, bis der Kurs einen der Aufträge berührt. Der zweite Auftrag wird unmittelbar danach gelöscht.
Noch einmal:
2 Minuten vor der Veröffentlichung der Nachricht zwei entgegengesetzte Stop-Orders in einem Abstand von 10 Punkten zum Kurs setzen, sofort die Funktion der Bewegung parallel zum Kurs aktivieren, 2 Minuten mit dem Kurs mitgehen, eine Order läuft vom Kurs weg, die zweite holt den Kurs ein. Bei der Veröffentlichung von Nachrichten sollten Sie die Funktion der ausstehenden Orderbewegungen deaktivieren und dann auf den Zusammenbruch einer der Orders warten. Der zweite wird unmittelbar nach dem Ausfall des ersten gelöscht.
Wenn Sie solche Berater kennen oder ihnen begegnet sind, teilen Sie ihnen bitte mit
Vielen Dank im Voraus!
Ich kann Ihnen den Code für das Lesen von Nachrichten aus einer Datei schicken, er könnte sich als nützlich erweisen. Einmal pro Woche sehen Sie sich den Wirtschaftskalender an und geben die Daten in die Datei folder_with_terminal\MQL4\Files\novosti.txt der Nachrichten ein, die Sie beachten sollten, der Berater kann sogar kurz vor den Nachrichten aktiviert werden (Sie können diesen Berater verwenden, um den Beginn z.B. der amerikanischen Sitzung zu verfolgen - falls es eine starke Bewegung gibt). Ich habe den Handelscode nicht fertiggestellt, weil ich ein paar Mal durch die Nachrichten ernsthaft "betrogen" wurde :)) In der letzten Version wurden sechs Aufträge (3 Kaufstopps + 3 Verkaufsstopps) in unterschiedlichen Abständen mit verschiedenen Take Profits platziert. Wie auch immer, mein Nachrichtencode funktioniert, aber ich muss meinen Handelscode verbessern.
#Eigenschaft streng
input string NewsFilename = "novosti.txt"; // Name der Textdatei mit den Nachrichten
input int MinutesBefore = 5; // Wie viele Minuten vor der Veröffentlichung der Nachricht sollen die Aufträge erteilt werden?
input int MinutesAfter1 = 15; // wie viele Minuten nach der Veröffentlichung der Nachricht die Aufträge der 1.
input int MinutesAfter2 = 30; // wie viele Minuten nach der Veröffentlichung der Nachricht werden die Aufträge der Gruppe 2 entfernt
input int MinutesAfter3 = 30; // wie viele Minuten nach der Veröffentlichung der Nachricht die Aufträge der Gruppe 3 entfernt werden
input int PriceIndent1 = 15; // Einrückung vom Preis in Punkten
input int PriceIndent2 = 5; // Schritt zurück vom vorherigen TakeProfit in Punkten
input int TakeProfit1 = 40; // TakeProfit-Größe für die 1. Gruppe in Punkten
input int TakeProfit2 = 60; // TakeProfit-Größe für die 2. Gruppe in Punkten
input int TakeProfit3 = 100; // TakeProfit-Größe für die 3. Gruppe in Punkten
input int StopLoss = 20; // StopLoss-Größe für alle Aufträge in Punkten
input double Multiplier1 = 1.0; // Koeffizient zum Bestelllos der 2. Gruppe
input double Multiplier2 = 2.0; // Koeffizient zu den Ordnungslosen der 3. Gruppe
input int MaximalRisk = 10; // Maximales Risiko in Prozenten
//====================================================================================================
datetime Times[200]; // LastTime;
Zeichenfolge Symbols[200];
bool NewsPassed[200];
int NewsCount;
//====================================================================================================
int OnInit()
{
// Neue Nachrichten laden
if (!LoadNews()) return(INIT_FAILED);
return(INIT_SUCCEEDED);
}
//====================================================================================================
void OnTick()
{
if (!IsTradeAllowed()) return;
datetime TestTime = iTime(Symbol(), PERIOD_H1, 0);
// Aktualisierung der Nachrichten zu Beginn eines jeden Tages
if (TimeDay(TestTime) != TimeDay(LastTime))
{
LetzteZeit = TestZeit;
if (!LoadNews())
{
Alert("Fehler beim Aktualisieren von Nachrichten!");
Rückkehr;
}
}
//-------------------------------------------------------------------------------------------------
for (int i = 0; i < NewsCount; i++)
{
// Till News Release stellt Aufträge für Durchbruch
if (Times[i] > TimeCurrent() && Times[i] - TimeCurrent() <= MinutesBefore * 60 && !NewsPassed[i])
{
PrintFormat("Die aktuelle Zeit ist %s, es ist Zeit, Währungsaufträge zu setzen - %s", TimeToStr(TimeCurrent(), TIME_DATE|TIME_MINUTES), Symbols[i]);
SetupOrders(Symbols[i];
NewsPassed[i] = true;
}
}
//-------------------------------------------------------------------------------------------------
}
//====================================================================================================
bool LoadNews()
{
int Count, Tick = 0;
string Str, Data[40];
ResetLastError();
if (!FileIsExist(NewsFilename, 0))
{
PrintFormat("Die News-Datei %s existiert nicht.", NewsDateiname);
Print("Die Datei muss sich im Ordner \\MQL4\\Files befinden, im Falle von Tests - im Ordner \\Tester\\Files.");
return(false);
}
int Handle = FileOpen(NewsFilename, FILE_READ|FILE_SHARE_READ|FILE_TXT);
if (Handle != INVALID_HANDLE)
{
while (!FileIsEnding(Handle))
{
Str = FileReadString(Handle);
Count = StringSplit(Str, StringGetChar(" ", 0), Data);
for (int i = 1; i < Count; i = i + 2)
{
Times[Tick] = StringToTime(Data[0] + " + Data[i]);
Symbole[Tick] = Daten[i + 1];
Tick++;
}
}
FileClose(Handle);
NewsCount = Tick;
for (int i = 0; i < NewsCount; i++)
{
if (Zeiten[i] > TimeCurrent()) NewsPassed[i] = false;
sonst NewsPassed[i] = false;
}
PrintFormat("Anzahl der hochgeladenen Nachrichten - %i.", NewsCount);
return(true);
}
PrintFormat("Datei %s kann nicht geöffnet werden. Fehlercode %d.", NewsDateiname, GetLastError());
return(false);
}
//====================================================================================================
void SetupOrders(string Sym)
{
int Ticket, Dig, Count;
double Preis, TP, SL, Los;
datetime KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter1) * 60;
Zeichenfolge SymList[7];
//-------------------------------------------------------------------------------------------------
wenn (Sym == "AUD")
{
SymList[0] = "AUDCAD"; SymList[1] = "AUDCHF"; SymList[2] = "AUDJPY"; SymList[3] = "AUDNZD";
SymList[4] = "AUDUSD"; SymList[5] = "EURAUD"; SymList[6] = "GBPAUD";
}
//-------------------------------------------------------------------------------------------------
wenn (Sym == "CAD")
{
SymList[0] = "AUDCAD"; SymList[1] = "CADCHF"; SymList[2] = "CADJPY"; SymList[3] = "EURCAD";
SymList[4] = "GBPCAD"; SymList[5] = "NZDCAD"; SymList[6] = "USDCAD";
}
//-------------------------------------------------------------------------------------------------
wenn (Sym == "CHF")
{
SymList[0] = "AUDCHF"; SymList[1] = "CADCHF"; SymList[2] = "EURCHF"; SymList[3] = "GBPCHF";
SymList[4] = "CHFJPY"; SymList[5] = "NZDCHF"; SymList[6] = "USDCHF";
}
//-------------------------------------------------------------------------------------------------
wenn (Sym == "EUR")
{
SymList[0] = "EURAUD"; SymList[1] = "EURCAD"; SymList[2] = "EURCHF"; SymList[3] = "EURGBP";
SymList[4] = "EURJPY"; SymList[5] = "EURNZD"; SymList[6] = "EURUSD";
}
//-------------------------------------------------------------------------------------------------
wenn (Sym == "GBP")
{
SymList[0] = "EURGBP"; SymList[1] = "GBPAUD"; SymList[2] = "GBPCAD"; SymList[3] = "GBPCHF";
SymList[4] = "GBPJPY"; SymList[5] = "GBPNZD"; SymList[6] = "GBPUSD";
}
//-------------------------------------------------------------------------------------------------
wenn (Sym == "JPY")
{
SymList[0] = "AUDJPY"; SymList[1] = "CADJPY"; SymList[2] = "CHFJPY"; SymList[3] = "EURJPY";
SymList[4] = "GBPJPY"; SymList[5] = "NZDJPY"; SymList[6] = "USDJPY";
}
//-------------------------------------------------------------------------------------------------
wenn (Sym == "NZD")
{
SymList[0] = "AUDNZD"; SymList[1] = "EURNZD"; SymList[2] = "GBPNZD"; SymList[3] = "NZDCAD";
SymList[4] = "NZDCHF"; SymList[5] = "NZDJPY"; SymList[6] = "NZDUSD";
}
//-------------------------------------------------------------------------------------------------
wenn (Sym == "USD")
{
SymList[0] = "AUSUSD"; SymList[1] = "EURUSD"; SymList[2] = "GBPUSD"; SymList[3] = "NZDUSD";
SymList[4] = "USDCAD"; SymList[5] = "USDCHF"; SymList[6] = "USDJPY";
}
//-------------------------------------------------------------------------------------------------
for (int i = 0; i < 7; i++)
{
Anzahl = 0;
Dig = int(MarketInfo(SymList[i], MODE_DIGITS));
Lot = NormalizeDouble(0.01, 2);
//Kaufen
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter1) * 60;
Preis = NormalizeDouble(MarketInfo(SymList[i], MODE_ASK) + PriceIndent1 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Preis + TakeProfit1 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Preis - StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_BUYSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrLimeGreen);
if (Ticket > 0) Count++; else PrintFormat("Fehler beim Erstellen der Order %i, Symbol %s, Preis %f, Take %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Preis, TP, SL, Lot);
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter2) * 60;
Preis = NormalizeDouble(TP + PriceIndent2 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Preis + TakeProfit2 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Preis - StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_BUYSTOP, Lot * Multiplier1, Price, 5, SL, TP, NULL, 0, KeepAlive, clrLimeGreen);
if (Ticket > 0) Count++; else PrintFormat("Fehler beim Erstellen der Order %i, Symbol %s, Preis %f, Take %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Preis, TP, SL, Lot*Multiplier1);
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter3) * 60;
Preis = NormalizeDouble(TP + PriceIndent2 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Preis + TakeProfit2 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Preis - StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_BUYSTOP, Lot*Multiplier2, Price, 5, SL, TP, NULL, 0, KeepAlive, clrLimeGreen);
if (Ticket > 0) Count++; else PrintFormat("Fehler beim Erstellen der Order %i, Symbol %s, Preis %f, Take %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Price, TP, SL, Lot*Multiplier2);
// Verkaufen
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter1) * 60;
Preis = NormalizeDouble(MarketInfo(SymList[i], MODE_BID) - PriceIndent1 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Preis - TakeProfit1 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Preis + StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_SELLSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrOrangeRed);
if (Ticket > 0) Count++; else PrintFormat("Fehler beim Erstellen der Order %i, Symbol %s, Preis %f, Take %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Preis, TP, SL, Lot);
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter2) * 60;
Preis = NormalizeDouble(TP - PriceIndent2 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Preis - TakeProfit2 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Preis + StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_SELLSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrOrangeRed);
if (Ticket > 0) Count++; else PrintFormat("Fehler beim Erstellen der Order %i, Symbol %s, Preis %f, Take %f, Stop %f, Lot %f.", GetLastError(), SymList[i], Preis, TP, SL, Lot*Multiplier1);
KeepAlive = TimeCurrent() + (MinutesBefore + MinutesAfter3) * 60;
Preis = NormalizeDouble(TP - PriceIndent2 / pow(10, Dig-1), Dig);
TP = NormalizeDouble(Preis - TakeProfit3 / pow(10, Dig-1), Dig);
SL = NormalizeDouble(Preis + StopLoss / pow(10, Dig-1), Dig);
Ticket = OrderSend(SymList[i], OP_SELLSTOP, Lot, Price, 5, SL, TP, NULL, 0, KeepAlive, clrOrangeRed);
PrintFormat("Es liegen %i Aufträge für das Symbol %s vor", SymList[i], Count);0 }
}
Die Nachrichtendatei sieht wie folgt aus:
15.09.2016 01:45 NZD 04:30 AUD 10:30 CHF 14:00 GBP 15:30 USD
16.09.2016 15:30 USD 17:00 USD
und so weiter...
Gehen wir zurück zu Ihrem Quellcode. Versuchen Sie es so:
int OnInit()
{
if (!GlobalVariableCheck("AllowNewOrders")) GlobalVariableSet("AllowNewOrders",1);
return(INIT_SUCCEED);
}
void OnDeInit()
{
GlobalVariableSet("AllowNewOrders",1);
}
void OnTick()
{
if (CountTrades() == 0) // Die Anzahl der Aufträge muss Null sein
{
if ((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) < PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) > PriceOpenLastHistOrder(OP_SELL))
// Wenn der letzte Handel einen Verlust aufweist, wird derselbe Handel eröffnet, jedoch mit einem größeren Los.
{
GlobalVariableSet("AllowNewOrders", 0);
Typ = TypeLastHistOrder();
if (Typ == OP_BUY) Preis = Ask;
if (Typ == OP_SELL) Preis = Bid;
Lot = NormalizeDouble(LotsLastHistOrder()*Multiplier, 2);
ticket = OrderSend(Symbol(), Typ, Lot, Preis, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (PriceCloseLastHistOrder() == PriceOpenLastHistOrder() && CountHistTrades() > 0)
// wenn der Gewinn des letzten Geschäfts gleich Null ist, wird das gleiche Geschäft eröffnet
{
GlobalVariableSet("AllowNewOrders", 0);
Typ = TypeLastHistOrder();
if (Typ == OP_BUY) Preis = Ask;
if (Typ == OP_SELL) Preis = Bid;
Lot = NormalizeDouble(LotsLastHistOrder(), 2);
ticket = OrderSend(Symbol(), Typ, Lot, Preis, Slippage, 0, 0, IntegerToString(Exp), Magic);
}
if (((TypeLastHistOrder() == OP_BUY && PriceCloseLastHistOrder(OP_BUY) > PriceOpenLastHistOrder(OP_BUY))
|| (TypeLastHistOrder() == OP_SELL && PriceCloseLastHistOrder(OP_SELL) < PriceOpenLastHistOrder(OP_SELL))
|| CountHistTrades() == 0)// Wenn der letzte Handel profitabel ist, wird die Order eröffnet
{
if (GlobalVariableGet("AllowNewOrders") > 0)return;
if (SignalBuy() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, Slippage, 0, 0, IntegerToString(Exp), Magic);
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0);
}
if (SignalSell() && MaxOpenOrders > OrdersTotal())
{
ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, Slippage, 0, 0, IntegerToString(Exp), Magic);
if (ticket>0) GlobalVariableSet("AllowNewOrders", 0);
}
}
}
}
Ich habe es nicht überprüft, weil ich nicht verstehe, wie mehrere Kopien eines EA mit einem Gesamtlimit von 1 Order erkennen, bei welchem Symbol (nach einer profitablen Serie) es besser ist, den Handel zu beginnen?
Alexander, der Bot muss die angegebene Anzahl von Kerzen in jedem Symbol in einer Richtung abwarten und dann eine Serie starten, d.h. bei welchem Symbol diese Bedingung zuerst für dieses Symbol ausgelöst wird und den ersten Handel eröffnen. Gleichzeitig sollten Sie die Eröffnung einer Serie für andere Symbole so lange verbieten, bis die erste Serie mit Gewinn abgeschlossen ist.
Der letzte Code, den Sie angegeben haben, ist ein Schritt nach vorn - er öffnet überhaupt kein Geschäft (d.h. das Verbot ist aktiv). Ich habe überhaupt nicht verstanden, warum nicht. Im Anhang finden Sie einen Screenshot des Protokolls.
Vielleicht ist es an der Zeit zu lernen, wie man einen Code einfügt!