Jede Anfängerfrage, um das Forum nicht zu überladen. Fachleute, gehen Sie nicht vorbei. Nirgendwo ohne dich - 6. - Seite 539
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
Ich danke Ihnen! Es funktionierte, ich war glücklich wie ein Kind, aber der Berater zeigte nicht mehr "neu" an. Können Sie mir sagen, wo ich einen Fehler gemacht habe?
Aha, ich habe den Fehler gefunden, aber nicht dort, wo ich ursprünglich gesucht habe. Die nächste Aufgabe kann ich selbst nicht bewältigen.
Bitte teilen Sie mir mit, wie ich die Abweichungsspanne - Entfernung des Preises aus dem MA - festlegen kann.
Hier ist der Eingangsteil
Huh, ich habe den Fehler gefunden, aber nicht dort, wo ich ursprünglich gesucht habe. Ich kann die nächste Aufgabe nicht allein bewältigen.
Können Sie mir sagen, wie ich die Abweichungsspanne - den Abstand des Preises vom MA - einstellen kann?
Hier ist der Eingangsteil
Und dementsprechend ist die Bedingung
Wir müssen die Ausgangsdaten im Advisor korrekt in (1 Kauf, -1 Verkauf) ändern
//+------------------------------------------------------------------+
//| SimpleBars_rob.mq4 |//| Copyright © 2010, ENSED Team |
//| http://www.ensed.org |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2010, ENSED Team"
#property link "http://www.ensed.org"
extern int SL = 50; // Stop-Loss-Wert (in Pips)
TP = 150; // Take Profit-Wert (in Punkten)
extern double Lots = 0.1; // Arbeitslos (Mikro-Lose - 0.01, Mini-Lose - 0.1, normale Lose - 1.0)
extern string Order_Comment = "robot"; // Kommentar, der für Bestellungen verwendet wird
extern int Slipage = 5; // maximal zulässige Schlupfhöhe (in Punkten)
extern int int Magic_Number = 777; // magische Anzahl von Aufträgen für den Roboter (um "freundliche" Geschäfte zu unterscheiden)
extern bool Play_Sound = false; // Abspielen von Sound beim Öffnen: true - erlaubt, false - verboten
//--------------------------------------------------------------------------------------------------------------------+
//+ Einrichtung der Zeitrahmen und Parameter des SimpleBars-Indikators |
extern int period = 6;
extern bool useClose = true;
extern int Breite = 3;
//+ Anpassung der Zeitrahmen und Parameter des Indikators SimpleBars |
//--------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//+ Nachlaufender Stopp |
extern bool UseTrailing = true; // Trailing-Stop ein/aus
extern int TrailingStop = 50; // feste Trailing-Stop-Größe (in Pips)
extern int TrailingStep = 1; // Trailing-Stop-Schritt (in Punkten)
//+ Nachlaufender Stopp
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| Die Funktion wird bei der Programminitialisierung ausgeführt.
void init() {
if(GlobalVariableCheck("this_bar "+Symbol()+Periode()))
GlobalVariableLöschen("dieser_Balken "+Symbol()+Periode());
Rückkehr;
}
//| Funktion, die während der Programminitialisierung ausgeführt wird ||.
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| Die Funktion wird bei der Deinitialisierung des Programms ausgeführt.
void deinit() {
if(GlobalVariableCheck("this_bar "+Symbol()+Periode()))
GlobalVariableLöschen("dieser_Balken "+Symbol()+Periode());
Rückkehr;
}
//| Funktion, die bei der Deinitialisierung des Programms ausgeführt wird
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| Funktion der Suche nach einem Handelssignal |
int fsignals() {
double signal = iCustom(NULL, 0, "SimpleBars", period, 0, 1, 4, 0);
return(0); // Signal zum Öffnen eines Kaufs
return(1); //Verkaufssignal öffnen
return(-1); // kein Signal
} //end int fsignals()
//| Funktion der Suche nach einem Handelssignal
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| Funktion zur Verfolgung der Arbeit des Roboters an der angegebenen Stange
bool this_bar() {
wenn(
(!GlobalVariableCheck("this_bar "+Symbol()+Periode()))
|| (GlobalVariableGet("dieser_Balken "+Symbol()+Zeitraum()!=Zeit[0])
) {
GlobalVariableSet("this_bar "+Symbol()+Periode(),Time[0]);
return(false);
} sonst {
return(true);
} //end if (. (!GlobalVariableCheck("this_bar "+Symbol()+Periode()))
} //end bool this_bar()
//| Funktion der Verfolgung der Tatsache, dass der Roboter an der gegebenen Stange arbeitet
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| Funktion der Suche nach Aufträgen dieses Typs |
bool find_orders(int magic=-1, int type=-1, string symb="NULL") {
/* gibt true zurück, wenn mindestens eine Bestellung des angegebenen Typs mit der angegebenen magischen Zahl durch das angegebene Symbol gefunden wird */
for (int i=OrdersTotal()-1; i>=0; i--) {
if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES)) break;
if(((OrderType()==type) || (type==-1))
&& ((OrderMagicNumber()==magic) || (magic==-1))
&& ((OrderSymbol()==Symbol() || (symb=="NONE")))) {
//wenn ein Auftrag gefunden wird, return(true) und die Schleife verlassen
return(true);
Pause;
} //end if((OrderType()==type) && (OrderMagicNumber()==magic) && (OrderSymbol()==Symbol())
} //end for (int i2=OrdersTotal()-1; i2>=0; i2--)
return(false); //return false
} //end bool find_orders(int magic, int type)
//| Funktion der Suche nach Aufträgen des angegebenen Typs |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| Funktion zur Berechnung des Stop-Loss-Wertes für Aufträge |
double sl(int sl_value, int type, double price=0.0, string symb="NONE", int rmode=1) {
//type=0 -> Marktkäufe
//type=1 -> Marktverkäufe
if(symb=="NONE") symb=Symbol();
if(type==0) price=NormalizeDouble(MarketInfo(symb,MODE_ASK),MarketInfo(symb,MODE_DIGITS))
if(type==1) price=NormalizeDouble(MarketInfo(symb,MODE_BID),MarketInfo(symb,MODE_DIGITS));
if(sl_value<=0) return(0);
if(rmode==1) {
if((type==0) || (type==2) || (type==4)) return(MarketInfo(symb,MODE_ASK)-sl_value*MarketInfo(symb,MODE_POINT)); //für Käufe
if((type==1) || (type==3) || (type==5)) return(MarketInfo(symb,MODE_BID)+sl_value*MarketInfo(symb,MODE_POINT)); //für Verkauf
}
if(rmode==2) {
if((type==0) || (type==2) || (type==4)) return(MarketInfo(symb,MODE_BID)-sl_value*MarketInfo(symb,MODE_POINT)); //für Kauf
if((type==1) || (type==3) || (type==5)) return(MarketInfo(symb,MODE_ASK)+sl_value*MarketInfo(symb,MODE_POINT)); //für Verkauf
}
} //end double sl(int sl_value, int type, double price=0.0, string symb="NONE", int rmode=1)
//| Funktion zur Berechnung des Stop-Loss-Wertes für Aufträge |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| Funktion zur Berechnung von Take Profit-Werten für Aufträge
double tp(int tp_value, int type, double price=0.0, string symb="NONE") {
//type=0 -> Marktkauf
//type=1 -> Marktverkäufe
if(symb=="NONE") symb=Symbol();
if(type==0) price=NormalizeDouble(MarketInfo(symb,MODE_ASK),MarketInfo(symb,MODE_DIGITS);
if(type==1) price=NormalizeDouble(MarketInfo(symb,MODE_BID),MarketInfo(symb,MODE_DIGITS));
if(tp_wert<=0) return(0);
if((type==0) || (type==2) || (type==4)) return(price+tp_value*MarketInfo(symb,MODE_POINT)); //für Käufe
if((type==1) || (type==3) || (type==5)) return(MarketInfo(symb,MODE_BID)-tp_value*MarketInfo(symb,MODE_POINT)); //für Verkäufe
} //end double tp(int tp_value, int type, double price=0.0, string symb="NONE")
//| Funktion zur Berechnung des Take Profit Wertes für Aufträge |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| Funktion der Auftragseröffnung
void open_positions(int signal, double lot, double price=0.0, string symb="NONE") {
//signal=0 -> Signal zum Kauf eröffnen
//signal=1 -> Signal zum Öffnen des Verkaufs
/* extern */ int Count_Of_Trade_Try=5, Pause_Of_Trade_Try=5;
int i = 0; //Variable für den Schleifenzähler
int err = 0;
if(symb=="NONE") symb=Symbol();
if(Signal==0)
price=NormalizeDouble(MarketInfo(symb,MODE_ASK),MarketInfo(symb,MODE_DIGITS)); //offener Preis für den Kauf
if(Signal==1)
price=NormalizeDouble(MarketInfo(symb,MODE_BID),MarketInfo(symb,MODE_DIGITS)); //offener Preis für den Verkauf
while(i<=Count_Of_Trade_Try) {
Die //Funktion zum Öffnen des Auftrags (eingebaut). Um die Wahrnehmung zu erleichtern, sind die Parameter in verschiedenen Zeilen untergebracht:
int ticket = OrderSend(Symbol(), //Symbol
Signal, //Auftragsart
Los, //Volumen
Preis, //offener Preis
Slipage, //Ebene der zulässigen Requotes
sl(SL,signal), // Wert des Stop Loss
tp(TP,Signal), //Gewinnwert übernehmen
Bestellung_Comment, //Kommentar zur Bestellung
Magische_Nummer, //magische Nummer
0, //Ablaufzeit (wird für schwebende Aufträge verwendet)
CLR_NONE); //Farbe des im Diagramm angezeigten Pfeils (CLR_NONE - Pfeil wird nicht gezeichnet)
if(ticket!=-1) //wenn die Öffnung erfolgreich war, ein grafisches Objekt zeichnen und die Schleife verlassen
Pause;
err=GetLastError();
if(err!=0) Print("Fehler: "+Market_Err_To_Str(err));
i++;
Sleep(Pause_Of_Trade_Try*1000); //im Falle eines Fehlers, Pause vor erneutem Versuch
} //end while(i<=count)
} //end void open_positions(int signal, double lot, double price=0.0, string symb="NONE")
Funktion zum Eröffnen von Aufträgen //|
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------+
//| Funktion der Dekodierung von Fehlercodes |
string Market_Err_To_Str(int err) {
/* Funktion deckt nur Fehlercodes von Handelsoperationen ab */
switch(err) {
case(0): return("Kein Fehler");
case(1): return("Kein Fehler, aber das Ergebnis ist unbekannt");
case(2): return("Allgemeiner Fehler");
case(3): return("Falsche Parameter");
case(4): return("Der Handelsserver ist beschäftigt");
case(5): return("Alte Version des Client-Terminals");
case(6): return("Keine Verbindung zum Handelsserver");
case(7): return("Nicht genug Rechte");
case(8): return("Zu häufige Anfragen");
case(9): return("Ungültiger Vorgang, der den Serverbetrieb stört");
case(64): return("Konto gesperrt");
case(65): return("Falsche Kontonummer");
case(128): return("Die Frist für die Transaktion ist abgelaufen");
case(129): return("Falscher Preis");
case(130): return("Falsche Haltestellen");
case(131): return("Falsches Volumen");
case(132): return("Der Markt ist geschlossen");
case(133): return("Handel verboten");
case(134): return("Nicht genug Geld, um die Transaktion auszuführen");
case(135): return("Der Preis hat sich geändert");
case(136): return("Kein Preis");
case(137): return("Der Makler ist beschäftigt");
case(138): return("Neue Preise");
case(139): return("Der Auftrag ist blockiert und wird bereits bearbeitet");
case(140): return("Nur Kauf erlaubt");
case(141): return("Zu viele Anfragen");
case(145): return("Die Änderung ist nicht zulässig, da der Auftrag zu nahe am Markt liegt");
case(146): return("Das Handelsteilsystem ist beschäftigt");
case(147): return("Die Verwendung des Verfallsdatums ist vom Broker verboten");
case(148): return("Die Anzahl der offenen und schwebenden Aufträge hat das vom Broker festgelegte Limit erreicht;)
case(149): return("Versuch, eine Gegenposition zu einer bestehenden Position zu eröffnen, wenn Hedging verboten ist");
case(150): return("Versuch, eine Position auf einem Symbol unter Verstoß gegen die FIFO-Regel zu schließen");
Standard: return("");
} //end switch(err)
} //end string Err_To_Str(int err)
//| Funktion zur Dekodierung von Fehlercodes |
//+-------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------+
//| Operationen zum Abschluss von Transaktionen
//+----------------------------------------------------------------------------------------------------+
//| Funktion zum Abschließen eines Auftrags anhand seiner Nummer (Ticket) |
bool close_by_ticket(int c_ticket, int slipage) {
/*
Funktion des Abschlusses eines Geschäfts nach seiner Nummer (Ticket).
Bei der Schließung eines Marktauftrags wird die Höhe der maximal zulässigen Slippage berücksichtigt (Slippage)
*/
/* extern */ int Count_Of_Trade_Try=5, Pause_Of_Trade_Try=5;
int i = 0; //Variable für den Schleifenzähler
int err = 0;
bool ticket = false; //Variable für den (un)erfolgreichen Abschluss eines Geschäfts
double price = 0.0; //Preis für das abzuschließende Geschäft (für Marktaufträge)
if(OrderSelect(c_ticket,SELECT_BY_TICKET,MODE_TRADES)) { //Auswahl der Bestellung nach Ticket
if(OrderType()==OP_BUY) price = NormalizeDouble(Bid,Digits); //Preis für Kauf
if(OrderType()==OP_SELL) price = NormalizeDouble(Ask,Digits); //Preis für Verkauf
for(i=0;i<=Count_Of_Trade_Try;i++) {
if(OrderType()<=1) //wenn es sich um eine Marktorder handelt, wird sie geschlossen, wenn es sich um eine schwebende Order handelt, wird sie gelöscht
ticket=OrderClose(OrderTicket(),OrderLots(),price,slipage,CLR_NONE);
sonst
ticket=OrderDelete(OrderTicket());
if(ticket) { //wenn das Schließen oder Löschen erfolgreich war - true zurückgeben und die Schleife verlassen
return(true);
Pause;
} //end if(ticket)
err=GetLastError();
if(err!=0) Print("Fehler: "+Market_Err_To_Str(err));
Sleep(Pause_Of_Trade_Try*1000); //im Falle eines Fehlers, Pause vor erneutem Versuch
} //end for(i=0;i<=Count_Of_Trade_Try;i++)
} //end if(OrderSelect(c_ticket,SELECT_BY_TICKET,MODE_TRADES))
return(false); //return false
} //end bool close_by_ticket(int c_ticket)
//| Funktion zum Abschließen eines Auftrags anhand seiner Nummer (Ticket) |
//+----------------------------------------------------------------------------------------------------+
bool cbm(int magic, int slipage, int type) {
/*
Close by magic (schließt alle Aufträge des angegebenen Typs mit der angegebenen MagicNumber)
Der maximal zulässige Schlupf wird berücksichtigt
Die Funktion close_by_ticket wird verwendet.
*/
int n = 0;
while (find_orders(magic, type))
for (int i2=OrdersTotal()-1; i2>=0; i2--) {
if (!OrderSelect(i2,SELECT_BY_POS,MODE_TRADES)) break;
if ((OrderType()==type) && (OrderMagicNumber()==magic)) {
close_by_ticket(OrderTicket(), slip;)
n++;
} //end if (((OrderType()==OP_BUY) || (OrderType()==OP_SELL)) && (OrderMagicNumber()==magisch))
} //end for (int i2=OrdersTotal()-1; i2>=0; i2--)
wenn(n>0)
return(true);
return(false);
} //end bool cbm(int magic, int slipage, int type)
Handelsabschlüsse //| Handelsabschlüsse |
//+-------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
Nachlaufender Stop-Loss //|
void T_SL() {
if(!UseTrailing) return;
int i = 0;
for(i=0; i<OrdersTotal(); i++) {
if(!(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))) weiter;
if(OrderSymbol() != Symbol() || OrderMagicNumber()!=Magic_Number) weiter;
if(Auftragsart()==OP_BUY) {
if(NormalizeDouble(Bid-OrderOpenPrice(),Digits)>NormalizeDouble(TrailingStop*Point,Digits)) {
if(NormalizeDouble(OrderStopLoss(),Digits)<NormalizeDouble(Bid-(TrailingStop+TrailingStep-1)*Point,Digits))
OrderModify(OrderTicket(), OrderOpenPrice(), NormalizeDouble(Bid-TrailingStop*Point,Digits), OrderTakeProfit(), 0, CLR_NONE)
} //end if(NormalizeDouble(Bid-OrderOpenPrice(),Digits)>NormalizeDouble(TrailingStop*Point,Digits))
} //end if(OrderType()==OP_BUY)
if(OrderType()==OP_SELL) {
if(NormalizeDouble(OrderOpenPrice()-Ask,Digits)>NormalizeDouble(TrailingStop*Point,Digits)) {
if(NormalizeDouble(OrderStopLoss(),Digits)>NormalizeDouble(Ask+(TrailingStop+TrailingStep-1)*Point,Digits))
OrderModify(OrderTicket(), OrderOpenPrice(), NormalizeDouble(Ask+TrailingStop*Point,Digits), OrderTakeProfit(), 0, CLR_NONE)
} //end if(NormalizeDouble(OrderOpenPrice()-Ask,Digits)>NormalizeDouble(TrailingStop*Point,Digits))
} //end if(OrderType()==OP_SELL)
} //end for(i=0; i<OrdersTotal(); i++)
} //end void T_SL()
Nachlaufender Stop-Loss //|
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| Hauptfunktion |
void start() {
int sig = fsignals();
if(!find_orders(Magic_Number)) {
if((sig!=-1)) {
if(!this_bar()) {
open_positions(sig, Lots);
if(Play_Sound)
PlaySound("alert.wav");
}
} //end if((sig!=-1) && (!this_bar())
} sonst {
if(sig==0) {
if(cbm(Magic_Number, Slipage, 1)) {
open_positions(sig, Lots);
if(Play_Sound)
PlaySound("alert.wav");
} //end if(cbm(Magic_Number, Slipage, 1))
} //end if(sig==0)
if(sig==1) {
if(cbm(Magic_Number, Slipage, 0)) {
open_positions(sig, Lots);
if(Play_Sound)
PlaySound("alert.wav");
} //end if(cbm(Magic_Number, Slipage, 0))
} //end if(sig==1)
T_SL();
} //end if(!find_orders(Magic_Number) (sonst)
Rückkehr;
}
//| Hauptfunktion |
//+-------------------------------------------------------------------------------------------------------------------+
Hallo Kenner. Hilfe - funktioniert nicht. Ich glaube, ich wurde durch die Initialisierung von Variablen verwirrt. Mir schwirrt der Kopf, aber ich kann keine Fehler finden.
Anstatt Positionen zu eröffnen, sollte der EA Pfeile zum Kurs Klose(0) zeichnen und statt zu schließen - ein Kreuz und die Daten ( fExpiration_func(Expiration), fop_time, cl_time, fop_price, cl_price, ftype) in eine neue Zeile schreiben.
Hier wird die Stochastik nur als Beispiel genommen.
Dann stellt sich die Frage, wie die beiden Werte zurückgegeben werden können. Versucht, aber Fehler
Dann stellt sich die Frage, wie die beiden Werte zurückgegeben werden können. Versucht, aber Fehler
Dann stellt sich die Frage, wie die beiden Werte zurückgegeben werden können. Versucht, aber Fehler
Haben Sie versucht, Variablen zu verwenden? Vielleicht hilft es ja.
Hilfe, wenn es Ihnen nichts ausmacht
einem Expert Advisor beizubringen, nach dem Indikator zu handeln
BS_Living Now ver #1.mq4 https://www.mql5.com/ru/code/11014#50910
UP= iCustom(Symbol(),NULL, "Jetzt",BQuant,0,0);
DOW= iCustom(Symbol(),NULL, "Jetzt",BQuant,1,0);
if(DOW){OrderSend(Symbol(), OP_SELL, Lot, Bid, Slip, 0, 0, "Forex-Robots.ru SELL", Magic, 0,Red);}
if(UP ){OrderSend(Symbol(), OP_BUY, Lot, Ask, Slip, 0, 0, "Forex-Robots.ru BUY", Magic, 0,Blue);}
Kommentar
(
"\n Profit: ", UP,
"\n Profit: ", DOW
);
Ich habe versucht, die Werte im Kommentar zu lesen, aber sie sind immer statisch.
Haben Sie versucht, Variablen zu verwenden? Das könnte helfen.
Danke, es funktioniert.
Hilfe, wenn es Ihnen nichts ausmacht
einem Expert Advisor beizubringen, nach dem Indikator zu handeln
BS_Living Now ver #1.mq4 https://www.mql5.com/ru/code/11014#50910