Qualsiasi domanda da principiante, per non ingombrare il forum. Professionisti, non passate oltre. Da nessuna parte senza di te - 6. - pagina 539
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
Grazie! Ha funzionato, ero felice come un bambino, ma il consulente ha smesso di visualizzare "nuovo". Puoi dirmi dove ho sbagliato?
Huh, ho trovato l'errore, non dove stavo cercando inizialmente. Non posso affrontare il prossimo compito da solo.
Si prega di consigliare come impostare l'intervallo di deviazione - distanza del prezzo dalla MA.
Ecco la parte dell'ingresso
Huh, trovato l'errore, non dove stavo cercando inizialmente. Non posso gestire il prossimo compito da solo.
Puoi dirmi come impostare il range di deviazione - distanza del prezzo dalla MA.
Ecco la parte di ingresso
E di conseguenza la condizione
Dobbiamo cambiare correttamente i dati iniziali nell'advisor in (1 acquisto, -1 vendita)
//+------------------------------------------------------------------+
//| SimpleBars_rob.mq4 |//| Copyright © 2010, ENSED Team |
//| http://www.ensed.org |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2010, ENSED Team"
#proprietà link "http://www.ensed.org"
extern int SL = 50; // valore di stop loss (in pip)
TP = 150; // valore di Take Profit (in punti)
extern double Lots = 0.1; // lotto di lavoro (micro lotti - 0.01, mini lotti - 0.1, lotti normali - 1.0)
extern string Order_Comment = "robot"; // commento che sarà usato per piazzare gli ordini
extern int Slipage = 5; // livello di slittamento massimo consentito (in punti)
extern int int Magic_Number = 777; // numero magico di ordini per il robot (per distinguere gli affari "amichevoli")
extern bool Play_Sound = false; // riproduzione del suono all'apertura: true - permesso, false - vietato
//--------------------------------------------------------------------------------------------------------------------+
//+ impostazione di timeframes e parametri dell'indicatore SimpleBars |
extern int periodo = 6;
extern bool useClose = true;
extern int width = 3;
//+ regolazione dei timeframes e dei parametri dell'indicatore SimpleBars |
//--------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//+ trailing stop |
extern bool UseTrailing = true; // trailing stop on/off
extern int TrailingStop = 50; // dimensione fissa del trailing stop (in pip)
extern int TrailingStep = 1; // passo di trailing stop (in punti)
//+ trailing stop
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| la funzione viene eseguita all'inizializzazione del programma
void init() {
if(GlobalVariableCheck("this_bar "+Symbol()+Period()))
GlobalVariableDel("this_bar "+Symbol()+Period());
ritorno;
}
//| funzione che viene eseguita durante l'inizializzazione del programma
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| la funzione viene eseguita alla deinizializzazione del programma |
void deinit() {
if(GlobalVariableCheck("this_bar "+Symbol()+Period()))
GlobalVariableDel("this_bar "+Symbol()+Period());
ritorno;
}
//| funzione che viene eseguita alla deinizializzazione del programma.
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| funzione di ricerca di un segnale di trading
int fsignals() {
doppio segnale = iCustom(NULL, 0, "SimpleBars", periodo, 0, 1, 4, 0);
return(0); // segnale per aprire un Buy
return(1); //aprire il segnale Sell
return(-1); // nessun segnale
} //end int fsignals()
//| funzione di ricerca di un segnale di trading
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| funzione di tracciamento del lavoro del robot sulla barra data
bool this_bar() {
se(
(!GlobalVariableCheck("this_bar "+Symbol()+Period()))
|| (GlobalVariableGet("this_bar "+Symbol()+Period()!=Time[0])
) {
GlobalVariableSet("this_bar "+Symbol()+Period(),Time[0]);
return(false);
} else {
return(true);
} //end if (. (!GlobalVariableCheck("this_bar "+Symbol()+Period()))
} //end bool this_bar()
//| funzione di monitoraggio del fatto del lavoro del robot sulla barra data
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| funzione di ricerca di ordini di questo tipo
bool find_orders(int magic=-1, int type=-1, string symb="NULL") {
/* restituisce true se almeno un ordine del tipo dato con il numero magico dato è trovato dal simbolo dato */
for (int i=OrdersTotal()-1; i>=0; i--) {
if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES)) break;
if(((OrderType()==type) || (type==-1))
&& ((OrderMagicNumber()==magica) || (magic==-1))
&& ((OrderSymbol()==Symbol() || (symb=="NONE")))) {
//se viene trovato un ordine, return(true) e uscire dal ciclo
return(true);
pausa;
} //end if((OrderType()==type) && (OrderMagicNumber()==magic) && (OrderSymbol()==Symbol())
} //end for (int i2=OrdersTotal()-1; i2>=0; i2--)
return(false); //ritornare false
} //end bool find_orders(int magic, int type)
//| funzione di ricerca di ordini del tipo dato |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| funzione di calcolo del valore di Stop Loss per gli ordini
double sl(int sl_value, int type, double price=0.0, string symb="NONE", int rmode=1) {
//tipo=0 -> acquisti sul mercato
//tipo=1 -> vendite sul mercato
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);
se(rmode==1) {
if((type==0) || (type==2) || (type==4)) return(MarketInfo(symb,MODE_ASK)-sl_value*MarketInfo(symb,MODE_POINT)); //per gli acquisti
if((type==1) || (type==3) || (type==5)) return(MarketInfo(symb,MODE_BID)+sl_value*MarketInfo(symb,MODE_POINT)); //per le vendite
}
se(rmode==2) {
if((type==0) || (type==2) || (type==4)) return(MarketInfo(symb,MODE_BID)-sl_value*MarketInfo(symb,MODE_POINT)); //per comprare
if((type==1) || (type==3) || (type==5)) return(MarketInfo(symb,MODE_ASK)+sl_value*MarketInfo(symb,MODE_POINT)); //per vendere
}
} //end double sl(int sl_value, int type, double price=0.0, string symb="NONE", int rmode=1)
//| funzione per il calcolo del valore di Stop Loss per gli ordini
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| funzione per calcolare i valori di Take Profit per gli ordini
double tp(int tp_value, int type, double price=0.0, string symb="NONE") {
//type=0 -> market buy
//tipo=1 -> vendite sul mercato
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_value<=0) return(0);
if((type==0) || (type==2) || (type==4)) return(price+tp_value*MarketInfo(symb,MODE_POINT)); //per gli acquisti
if((type==1) || (type==3) || (type==5)) return(MarketInfo(symb,MODE_BID)-tp_value*MarketInfo(symb,MODE_POINT)); //per le vendite
} //end double tp(int tp_value, int type, double price=0.0, string symb="NONE")
//| funzione per il calcolo del valore di Take Profit per gli ordini
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| funzione di apertura degli ordini
void open_positions(int signal, double lot, double price=0.0, string symb="NONE") {
//signal=0 -> segnale per aprire l'acquisto
//signal=1 -> segnale per aprire la vendita
/* extern */ int Count_Of_Trade_Try=5, Pause_Of_Trade_Try=5;
int i = 0; //variabile per il contatore del ciclo
int err = 0;
if(symb=="NONE") symb=Symbol();
se(segnale==0)
price=NormalizeDouble(MarketInfo(symb,MODE_ASK),MarketInfo(symb,MODE_DIGITS)); //prezzo aperto per comprare
se(segnale==1)
price=NormalizeDouble(MarketInfo(symb,MODE_BID),MarketInfo(symb,MODE_DIGITS)); //prezzo aperto per la vendita
while(i<=Count_Of_Trade_Try) {
La //funzione di apertura dell'ordine (integrata). Per comodità di percezione, i parametri sono collocati su linee diverse:
int ticket = OrderSend(Symbol(), //symbol
segnale, //tipo di ordine
lotto, //volume
prezzo, //prezzo aperto
Slipage, //livello di requote ammissibile
sl(SL,segnale), // valore di Stop Loss
tp(TP,segnale), //prendere il valore del profitto
Order_Comment, //commento d'ordine
Magic_Number, //numero magico
0, //tempo di scadenza (usato per gli ordini in sospeso)
CLR_NONE); //colore della freccia visualizzata sul grafico (CLR_NONE - la freccia non viene disegnata)
if(ticket!=-1) //se l'apertura ha avuto successo, disegnate un oggetto grafico e uscite dal ciclo
pausa;
err=GetLastError();
if(err!=0) Print("Errore: "+Market_Err_To_Str(err));
i++;
Sleep(Pause_Of_Trade_Try*1000); //in caso di errore, pausa prima di riprovare
} //fine mentre(i<=conteggio)
} //end void open_positions(int signal, double lot, double price=0.0, string symb="NONE")
//| funzione per aprire gli ordini
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------+
//| funzione di decodifica dei codici di errore
stringa Market_Err_To_Str(int err) {
/* la funzione copre solo i codici di errore delle operazioni commerciali */
switch(err) {
caso(0): return("Nessun errore");
caso(1): return("Nessun errore, ma il risultato è sconosciuto");
caso(2): return("Errore generale");
caso(3): return("Parametri errati");
caso(4): return("Il server commerciale è occupato");
caso(5): return("Vecchia versione del terminale client");
caso(6): return("Nessuna connessione al server commerciale");
caso(7): return("Non abbastanza diritti");
caso(8): return("Richieste troppo frequenti");
caso(9): return("Operazione non valida che interrompe il funzionamento del server");
caso(64): return("Account bloccato");
caso(65): return("Numero di conto errato");
caso(128): return("Il termine della transazione è scaduto");
caso(129): return("Prezzo errato");
caso(130): return("Fermate errate");
caso(131): return("Volume errato");
caso(132): return("Il mercato è chiuso");
caso(133): return("Commercio proibito");
caso(134): return("Non ci sono abbastanza soldi per eseguire la transazione");
caso(135): return("Il prezzo è cambiato");
caso(136): return("Nessun prezzo");
caso(137): return("Il broker è occupato");
caso(138): return("Nuovi prezzi");
caso(139): return("L'ordine è bloccato ed è già in elaborazione");
caso(140): return("Acquisto solo permesso");
caso(141): return("Troppe richieste");
caso(145): return("La modifica non è permessa, perché l'ordine è troppo vicino al mercato");
caso(146): return("Il sottosistema commerciale è occupato");
caso(147): return("L'uso della data di scadenza è vietato dal broker");
caso(148): return("Il numero di ordini aperti e pendenti ha raggiunto il limite fissato dal broker;)
caso(149): return("Tentativo di aprire una posizione opposta ad una posizione esistente se la copertura è proibita");
caso(150): return("Tentativo di chiudere una posizione su un simbolo in violazione della regola FIFO");
default: return("");
} //end switch(err)
} //end string Err_To_Str(int err)
//| funzione per decodificare i codici di errore
//+-------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------+
//| Operazioni di chiusura delle transazioni
//+----------------------------------------------------------------------------------------------------+
//| funzione di chiusura di un ordine per il suo numero (ticket) |
bool close_by_ticket(int c_ticket, int slipage) {
/*
funzione di chiusura di un trade per il suo numero (ticket).
Quando si chiude un ordine a mercato, si tiene conto del livello di slippage massimo consentito (slipage)
*/
/* extern */ int Count_Of_Trade_Try=5, Pause_Of_Trade_Try=5;
int i = 0; //variabile per il contatore del ciclo
int err = 0;
bool ticket = false; //variabile per la chiusura (non) riuscita di un trade
double price = 0.0; //prezzo per la transazione da chiudere (per ordini a mercato)
if(OrderSelect(c_ticket,SELECT_BY_TICKET,MODE_TRADES)) { //selezionare l'ordine per biglietto
if(OrderType()==OP_BUY) price = NormalizeDouble(Bid,Digits); //price for buying
if(OrderType()==OP_SELL) price = NormalizeDouble(Ask,Digits); //prezzo di vendita
for(i=0;i<=Count_Of_Trade_Try;i++) {
if(OrderType()<=1) //se l'ordine è un ordine a mercato, chiudilo, se è un ordine in sospeso, cancellalo
ticket=OrderClose(OrderTicket(),OrderLots(),price,slipage,CLR_NONE);
else
ticket=OrderDelete(OrderTicket());
if(ticket) { //se la chiusura o la cancellazione ha avuto successo - restituisce true e esce dal ciclo
return(true);
pausa;
} //end if(ticket)
err=GetLastError();
if(err!=0) Print("Errore: "+Market_Err_To_Str(err));
Sleep(Pause_Of_Trade_Try*1000); //in caso di errore, fare una pausa prima di riprovare
} //end for(i=0;i<=Count_Of_Trade_Try;i++)
} //end if(OrderSelect(c_ticket,SELECT_BY_TICKET,MODE_TRADES))
return(false); //ritornare false
} //end bool close_by_ticket(int c_ticket)
//| funzione di chiusura di un ordine per il suo numero (ticket) |
//+----------------------------------------------------------------------------------------------------+
bool cbm(int magic, int slipage, int type) {
/*
Chiudere per magia (chiudere tutti gli ordini del tipo dato con il MagicNumber dato)
Si tiene conto dello slittamento massimo consentito
Viene usata la funzione close_by_ticket.
*/
int n = 0;
mentre (find_orders(magic, type))
for (int i2=OrdersTotal()-1; i2>=0; i2--) {
if (!OrderSelect(i2,SELECT_BY_POS,MODE_TRADES)) break;
se ((OrderType()==tipo) && (OrderMagicNumber()==magico)) {
close_by_ticket(OrderTicket(), slip;)
n++;
} //end if (((OrderType()==OP_BUY) || (OrderType()==OP_SELL)) && (OrderMagicNumber()==magico))
} //end for (int i2=OrdersTotal()-1; i2>=0; i2--)
se(n>0)
return(true);
return(false);
} //end bool cbm(int magic, int slipage, int type)
//| operazioni di chiusura del commercio
//+-------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| trailing 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))) continua;
if(OrderSymbol() != Symbol() || OrderMagicNumber()!=Magic_Number) continua;
if(OrderType()==OP_BUY) {
se(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) {
se(NormalizeDouble(OrderOpenPrice()-Ask,Digits)>NormalizeDouble(TrailingStop*Point,Digits)) {
se(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()
//| trailing stop loss |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| funzione principale |
void start() {
int sig = fsignals();
if(!find_orders(Magic_Number)) {
se((sig!=-1)) {
if(!this_bar()) {
open_positions(sig, Lots);
if(Play_Sound)
PlaySound("alert.wav");
}
} //end if((sig!=-1) && (!this_bar())
} else {
se(sig==0) {
se(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)
se(sig==1) {
se(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) (altro)
ritorno;
}
//| funzione principale |
//+-------------------------------------------------------------------------------------------------------------------+
Ciao intenditori. Aiuto - non funziona. Penso di essere stato confuso dall'inizializzazione delle variabili . Mi gira la testa, ma non trovo errori.
Invece di aprire posizioni, l'EA dovrebbe disegnare frecce al prezzo Klose(0), e invece di chiudere - una croce e stampare i dati ( fExpiration_func(Expiration), fop_time, cl_time, fop_price, cl_price, ftype) in una nuova riga.
Qui lo stocastico è preso solo come esempio.
Allora la domanda è come restituire i due valori. Provato questo, ma errori
Allora la domanda è come restituire i due valori. Provato questo, ma errori
Allora la domanda è come restituire i due valori. Provato questo, ma errori
Avete provato a usare le variabili? Forse vi aiuterà.
Aiuto se non ti dispiace
per insegnare a un Expert Advisor a fare trading in base all'indicatore
BS_Living Now ver #1.mq4 https://www.mql5.com/ru/code/11014#50910
UP= iCustom(Symbol(),NULL, "Now",BQuant,0,0);
DOW= iCustom(Symbol(),NULL, "Now",BQuant,1,0);
if(DOW){OrderSend(Symbol(), OP_SELL, Lot, Bid, Slip, 0, 0, 0, "Forex-Robots.ru SELL", Magic, 0,Red);}
if(UP ){OrderSend(Symbol(), OP_BUY, Lot, Ask, Slip, 0, 0, 0, "Forex-Robots.ru BUY", Magic, 0,Blue);}
Commento
(
"Un profitto: ", UP,
"Un profitto: ", DOW
);
Ho provato a leggere i valori nel commento ma sono sempre statici.
Avete provato a usare le variabili? Potrebbe aiutare.
Grazie, funziona.
Aiuto se non ti dispiace
per insegnare a un Expert Advisor a fare trading in base all'indicatore
BS_Living Now ver #1.mq4 https://www.mql5.com/ru/code/11014#50910