Qualquer pergunta de novato, de modo a não desorganizar o fórum. Profissionais, não passem por aqui. Em nenhum lugar sem você - 6. - página 539
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
Obrigado! Funcionou, eu era feliz quando criança, mas o conselheiro deixou de exibir "novo". Você pode me dizer onde eu errei?
Huh, encontrei o erro, não onde eu estava procurando originalmente. Eu mesmo não consigo lidar com a próxima tarefa.
Favor informar como definir a faixa de desvio - distância do preço em relação ao MA.
Aqui está a parte de entrada
Huh, encontrei o erro, não onde eu estava procurando originalmente. Eu não consigo lidar com a próxima tarefa sozinho.
Você pode me dizer como definir a faixa de desvio - distância do preço em relação ao MA.
Aqui está a parte de entrada
E, portanto, a condição
Precisamos alterar corretamente os dados iniciais no consultor para (1 compra, -1 venda)
//+------------------------------------------------------------------+
//| SimpleBars_rob.mq4 |//| Copyright © 2010, Equipe ENSED |
//| http://www.ensed.org |
//+------------------------------------------------------------------+
#direitos de propriedade intelectual "Copyright © 2010, Equipe ENSED"
#link da propriedade "http://www.ensed.org
externo int SL = 50; // valor de perda stop (em pips)
TP = 150; // Valor do Take Profit (em pontos)
Lotes duplos externos = 0,1; // lote de trabalho (micro lotes - 0,01, mini lotes - 0,1, lotes normais - 1,0)
string externa Order_Comment = "robô"; // comentário que será usado para fazer pedidos
escorregamento interno externo = 5; // nível máximo de escorregamento permitido (em pontos)
número de ordens de magia para o robô (para distinguir negócios "amigáveis")
bool externo Play_Sound = falso; // reprodução de som na abertura: verdadeiro - permitido, falso - proibido
//--------------------------------------------------------------------------------------------------------------------+
//+ configuração dos cronogramas e parâmetros do indicador SimpleBars |
período int externo = 6;
uso de bool externoFechar = verdadeiro;
largura int externa = 3;
//+ ajuste dos prazos e parâmetros do indicador SimpleBars |
//--------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//+ parada de trilha |
UseTrailingTrailing externo = verdadeiro; // parada de trilha on/off
TrailingStop externo int = 50; // tamanho fixo do trailing stop (em pips)
Passo de TrailingStep int externo = 1; // passo de trailing stop (em pontos)
//+ parada de trilha
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| função é executada na inicialização do programa |
init() {
if(GlobalVariableCheck("this_bar "+Symbol()+Period()))
GlobalVariableDel("esta_barra "+Símbolo()+Periodo()));
retornar;
}
//| função, que é executada durante a inicialização do programa |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| função é executada na desinicialização do programa |
void deinit() {
if(GlobalVariableCheck("this_bar "+Symbol()+Period()))
GlobalVariableDel("esta_barra "+Símbolo()+Periodo()));
retornar;
}
//| função, que é executada na desinicialização do programa |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| função de busca de um sinal comercial |
int fsignals() {
sinal duplo = iCustom(NULL, 0, "SimpleBars", período, 0, 1, 4, 0);
retornar(0); // sinal para abrir uma compra
retornar(1); //abrir Sinal de venda
retorno(-1); // sem sinal
} //termine int fsignals()
//| função de busca de um sinal comercial
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| função de rastrear o trabalho do robô na barra dada
bool this_bar() {
se(
(!GlobalVariableCheck("this_bar "+Symbol()+Periodo()))
|| (GlobalVariableGet("this_bar "+Symbol()+Period()!=Time[0])
) {
GlobalVariableSet("esta_barra "+Símbolo()+Periodo(),Tempo[0]);
retorno(falso);
{} else {
retorno(verdadeiro);
} // terminar se (. (!GlobalVariableCheck("this_bar "+Symbol()+Periodo()))
} //termine bool this_bar()
//| função de rastrear o fato do trabalho do robô na barra dada
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| função de busca de ordens deste tipo |
bool find_orders(int magic=-1, int type=-1, string symb="NULL") {
/* retorna verdadeiro se pelo menos uma ordem do tipo dado com o número mágico dado for encontrada pelo símbolo dado */
para (int i=OrdensTotal()-1; i>=0; i--) {
if(!OrderSelect(i,SELECT_BY_POS,MODE_TRADES)) quebrar;
if(((OrderType()===type) ||| (type===-1))
&& ((OrderMagicNumber()==magic) ||| (magic===-1))
&& ((OrderSymbol()==Symbol() |||| (symb==="NONE")))) {
// se uma ordem é encontrada, retornar(true) e sair do laço
retorno(verdadeiro);
pausa;
} //termine if((OrderType()==type) && (OrderMagicNumber()==magic) && (OrderSymbol()==Symbol())
} //terminar para (int i2=OrdensTotal()-1; i2>=0; i2--)
retorno(falso); //retorno falso
} //end bool find_orders(int magic, int type)
//| função de busca de ordens do tipo dado |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| função de cálculo do valor de Stop Loss para pedidos |
double sl(int sl_value, tipo int, double price=0.0, string symb="NONE", int rmode=1) {
//type=0 -> compras de mercado
//type=1 -> vendas de mercado
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)); // para compras
if((type==1) ||| (type===3) ||| (type===5)) return(MarketInfo(symb,MODE_BID)+sl_value*MarketInfo(symb,MODE_POINT)); // para vendas
}
if(rmode===2) {
if((type==0) ||| (type===2) ||| (type===4)) return(MarketInfo(symb,MODE_BID)-sl_value*MarketInfo(symb,MODE_POINT)); // para compra
if((type==1) ||| (type===3) ||| (type===5)) return(MarketInfo(symb,MODE_ASK)+sl_value*MarketInfo(symb,MODE_POINT)); // para venda
}
} //end sl(int sl_value, int type, double price=0.0, string symb="NONE", int rmode=1)
//| função para cálculo do valor de Stop Loss para pedidos |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| função para calcular os valores de Take Profit para pedidos
double tp(int tp_value, int type, double price=0.0, string symb="NONE") {
//type=0 -> market buy
//type=1 -> vendas de mercado
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)); // para compras
if((type==1) ||| (type===3) ||| (type===5)) return(MarketInfo(symb,MODE_BID)-tp_value*MarketInfo(symb,MODE_POINT)); // para vendas
} //terminar duplo tp(int tp_valor, tipo int, preço duplo=0,0, string symb="NONE")
//| função para cálculo do valor de Take Profit para pedidos |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| função de abertura dos pedidos
void open_positions(int signal, double lot, double price=0.0, string symb="NONE") {
//sinal=0 -> sinal para abrir a compra
//sinal=1 -> sinal para abrir venda
/* externo */ int Conta_Of_Trade_Try=5, Pausa_Of_Trade_Try=5;
int i = 0; //variável para o contador de laço
int err = 0;
if(symb==="NONE") symb=Symbol();
if(sinal==0)
price=NormalizeDouble(MarketInfo(symb,MODE_ASK),MarketInfo(symb,MODE_DIGITS)); //open price for buying
if(signal===1)
price=NormalizeDouble(MarketInfo(symb,MODE_BID),MarketInfo(symb,MODE_DIGITS)); // preço aberto para venda
while(i<=Count_Of_Trade_Try) {
A //função para abrir o pedido (embutida). Para a conveniência da percepção, os parâmetros são colocados em linhas diferentes:
int ticket = OrderSend(Symbol(), //symbol
sinal, //tipo de ordem
lote, //volume
preço, // preço aberto
Escorregamento, // nível de requote permitido
sl(SL,sinal), // valor de Stop Loss
tp(TP,sinal), //valor de lucro
Order_Comment, //comentário de ordem
Magic_Number, // número mágico
0, // tempo de expiração (utilizado para pedidos pendentes)
CLR_NONE); //cor da seta exibida na tabela (CLR_NONE - seta não está desenhada)
se(ticket!=-1) // se a abertura foi bem sucedida, desenhe um objeto gráfico e saia do loop
pausa;
err=GetLastError();
if(err!=0) Print("Error: "+Market_Err_To_Str(err));
i++;
Sleep(Pause_Of_Trade_Try*1000); //in em caso de erro, pausa antes de tentar novamente
} //termine while(i<=count)
} //end void open_positions(int signal, double lot, double price=0.0, string symb="NONE")
//| função para abrir pedidos |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------+
//| função de decodificação de códigos de erro |
string Market_Err_To_Str(int err) {
A função /* cobre apenas os códigos de erro das operações comerciais */
switch(err) {
case(0): return("Sem erro");
caso(1): retorno("Nenhum erro, mas o resultado é desconhecido");
caso(2): retorno("Erro geral");
caso(3): retorno("Parâmetros incorretos");
case(4): return("Servidor comercial está ocupado");
case(5): return("Versão antiga do terminal do cliente");
case(6): return("Sem conexão com o servidor comercial");
caso(7): retorno("Não há direitos suficientes");
caso(8): retorno ("Pedidos muito freqüentes");
case(9): return("Invalid operation disrupting server operation");
caso(64): devolução("Conta bloqueada");
caso(65): devolução("Número de conta incorreto");
caso(128): devolução ("O prazo para a transação expirou");
caso(129): devolução("Preço incorreto");
case(130): devolução ("Paradas incorretas");
case(131): return("Volume incorreto");
case(132): retorno ("O mercado está fechado");
caso(133): devolução("Comércio proibido");
case(134): return("Não há dinheiro suficiente para executar a transação");
case(135): devolução ("O preço mudou");
caso(136): devolução("Sem preço");
case(137): return("O corretor está ocupado");
case(138): devolução ("Novos preços");
caso(139): devolução ("O pedido está bloqueado e já está sendo processado");
case(140): devolução("Compra permitida apenas");
case(141): retorno ("Demasiados pedidos");
caso(145): devolução ("Não é permitida a modificação, porque a ordem está muito próxima do mercado");
case(146): return("O subsistema comercial está ocupado");
caso(147): devolução("O uso da data de expiração é proibido pelo corretor");
caso(148): devolução("O número de ordens em aberto e pendentes atingiu o limite estabelecido pelo corretor;)
caso(149): retorno ("Tentativa de abrir uma posição oposta a uma posição existente se o hedging for proibido");
case(150): return("Tentativa de fechar uma posição sobre um símbolo, em contravenção à regra FIFO");
padrão: return("");
} //end switch(err)
} //end string Err_To_Str(int err)
//| função para decodificar códigos de erro |
//+-------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------+
//| Operações de fechamento de transações |||
//+----------------------------------------------------------------------------------------------------+
//| função de fechar um pedido por seu número (bilhete) |
bool close_by_ticket(int c_ticket, int slipage) {
/*
função de fechar um comércio por seu número (bilhete).
Ao fechar uma ordem de mercado, o nível de deslizamento máximo permitido é levado em conta (deslizamento)
*/
/* externo */ int Conta_Of_Trade_Try=5, Pausa_Of_Trade_Try=5;
int i = 0; //variável para o contador de laço
int err = 0;
bool ticket = falso; //variável para o (in)sucesso do fechamento de um comércio
preço duplo = 0,0; // preço para a transação a ser fechada (para ordens de mercado)
if(OrderSelect(c_ticket,SELECT_BY_TICKET,MODE_TRADES)) { //selecionar pedido por bilhete
if(OrderType()==OP_BUY) price = NormalizeDouble(Bid,Digits); // preço de compra
if(OrderType()==OP_SELL) price = NormalizeDouble(Ask,Digits); // preço de venda
for(i=0;i<=Count_Of_Trade_Try;i++) {
se(OrderType()<=1) // se a ordem for de mercado, feche-a, se for uma ordem pendente, apague-a
ticket=OrderClose(OrderTicket(),OrderLots(),price,slipage,CLR_NONE);
senão
ticket=OrderDelete(OrderTicket());
se(bilhete) { // se o fechamento ou exclusão foi bem sucedido - retornar verdadeiro e sair do laço
retorno(verdadeiro);
pausa;
} // terminar se(bilhete)
err=GetLastError();
if(err!=0) Print("Error: "+Market_Err_To_Str(err));
Sleep(Pause_Of_Trade_Try*1000); //in em caso de um erro, pausa antes de tentar novamente
} // terminar para(i=0;i<=Count_Of_Trade_Try;i++)
} // terminar if(OrderSelect(c_ticket,SELECT_BY_TICKET,MODE_TRADES))
retorno(falso); //retorno falso
} //end bool close_by_ticket(int c_ticket)
//| função de fechar um pedido por seu número (bilhete) |
//+----------------------------------------------------------------------------------------------------+
bool cbm(int magic, int slipage, int type) {
/*
Fechar por magia (fechar todas as ordens do tipo dado com o MagicNumber dado)
O deslizamento máximo admissível é levado em conta
A função close_by_ticket é utilizada.
*/
int n = 0;
enquanto (find_orders(magic, type))
para (int i2=OrdensTotal()-1; i2>=0; i2--) {
se (!OrderSelect(i2,SELECT_BY_POS,MODE_TRADES)) quebrar;
if ((OrderType()==type) && (OrderMagicNumber()==magic)) {
close_by_ticket(OrderTicket(), slip;)
n++;
} // terminar se (((OrderType()==OP_BUY) ||| (OrderType()==OP_SELL)) && (OrderMagicNumber()==magic))
} //terminar para (int i2=OrdensTotal()-1; i2>=0; i2--)
if(n>0)
retorno(verdadeiro);
retorno(falso);
} //end bool cbm(int magic, int slipage, int type)
//| Operações de fechamento comercial |
//+-------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| perda da trailing stop |
vazio T_SL() {
se(!UseTrailing) retornar;
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) {
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)
} //termine if(NormalizeDouble(Bid-OrderOpenPrice(),Digits)>NormalizeDouble(TrailingStop*Point,Digits))
} //termine if(OrderType()==OP_BUY)
if(OrderType()==OP_SELL) {
if(NormalizeDouble(OrderOpenPrice()-Ask,Digits)>NormalizeDouble(TrailingStop*Point,Digits)) {
if(NormalizeDouble(OrderStopLoss(),Digitos)>NormalizeDouble(Ask+(TrailingStop+TrailingStep-1)*Ponto,Digitos))
OrderModify(OrderTicket(), OrderOpenPrice(), NormalizeDouble(Ask+TrailingStop*Point,Digitos), OrderTakeProfit(), 0, CLR_NONE)
} //termine if(NormalizeDouble(OrderOpenPrice()-Ask,Digits)>NormalizeDouble(TrailingStop*Point,Digits))
} //termine if(OrderType()==OP_SELL)
} // terminar para(i=0; i<OrdensTotal(); i++)
} //terminar vazio T_SL()
//| perda da trailing stop |
//+-------------------------------------------------------------------------------------------------------------------+
//+-------------------------------------------------------------------------------------------------------------------+
//| função principal |
início nulo() {
int sig = fsignals();
if(!find_orders(Magic_Number)) {
if((sig!=-1)) {
if(!this_bar()) {
open_positions(sig, Lots);
if(Play_Sound)
PlaySound("alert.wav");
}
} //termine if((sig!=-1) && (!this_bar())
{} else {
if(sig==0) {
if(cbm(Magic_Number, Slipage, 1)) {
open_positions(sig, Lots);
if(Play_Sound)
PlaySound("alert.wav");
} // terminar if(cbm(Magic_Number, Slipage, 1))
} // terminar se(sig==0)
if(sig===1) {
if(cbm(Magic_Number, Slipage, 0)) {
open_positions(sig, Lots);
if(Play_Sound)
PlaySound("alert.wav");
} // terminar if(cbm(Magic_Number, Slipage, 0))
} //termine if(sig===1)
T_SL();
} //termine if(!find_orders(Magic_Number) (caso contrário)
retornar;
}
//| função principal |
//+-------------------------------------------------------------------------------------------------------------------+
Olá conhecedores. Ajuda - não está funcionando. Acho que fiquei confuso com a inicialização de variáveis . Minha cabeça está girando, mas não consigo encontrar nenhum erro.
Em vez de abrir posições, o EA deve desenhar setas no preço Klose(0) e, em vez de fechar - uma cruz e imprimir os dados ( fExpiration_func(Expiration), fop_time, cl_time, fop_price, cl_price, ftype) em uma nova linha.
Aqui o estocástico é tomado apenas como exemplo.
Então a questão é como devolver os dois valores. Tentei isto, mas erros
Então a questão é como devolver os dois valores. Tentei isto, mas erros
Então a questão é como devolver os dois valores. Tentei isto, mas erros
Você já tentou usar variáveis? Talvez isso ajude.
Ajude se você não se importar
para ensinar um consultor especializado em comércio pelo indicador
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, "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);}
Comentário
(
"\n Lucro: ", UP,
"\n Lucro: ", DOW
);
Eu tentei ler os valores no comentário, mas eles são sempre estáticos.
Você já tentou usar variáveis? Isso pode ajudar.
Obrigado, funciona.
Ajude se você não se importar
para ensinar um consultor especializado em comércio pelo indicador
BS_Living Now ver #1.mq4 https://www.mql5.com/ru/code/11014#50910