3426 lines
262 KiB
MQL5
3426 lines
262 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| GT - Breakout.mq5 |
|
|
//| Copyright 2022, GESTÃO TRADER |
|
|
//| https://www.gestaotrader.com |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "GESTÃO TRADER"
|
|
#property link "https://www.gestaotrader.com"
|
|
#property version "2.6"
|
|
#property description "Robô Trader Navy Seal"
|
|
#property description "—————————————————————————"
|
|
#property description "GESTÃO TRADER | Xayer L. Xavier"
|
|
#property description "xayerxavier@hotmail.com"
|
|
#property description "Whatsapp (62) 99433-1331"
|
|
#property description " "
|
|
#property description "Estratégia desenvolvida por Xayer L. Xavier"
|
|
#property description "Programação por: Everson Mayer, Hugo Gava | 2022-2023"
|
|
#property icon "\\Images\\Icone_Gestao_Trader.ico"
|
|
//+------------------------------------------------------------------+
|
|
//| INCLUSÔES |
|
|
//+------------------------------------------------------------------+
|
|
#include <Trade\Trade.mqh>
|
|
#include <Trade\Trade.mqh>
|
|
//#include <JAson.mqh>
|
|
|
|
//+------------------------------------------------------------------+
|
|
//+------------------------------------------------------------------+
|
|
//| CONTROLE |
|
|
//| DE |
|
|
//| ACESSO |
|
|
//+------------------------------------------------------------------+
|
|
//+------------------------------------------------------------------+
|
|
|
|
|
|
const int NUMERO_MAXIMO_CONTRATOS = 100;
|
|
const string NOME_NA_CORRETORA = "XAYER LINO XAVIER";
|
|
const long NUMERO_CONTA_REAL = 1;
|
|
const long NUMERO_CONTA_DEMO = 3008889245;
|
|
const int DIA_DO_VENCIMENTO = 30;
|
|
const int MES_DO_VENCIMENTO = 6;
|
|
const int ANO_DO_VENCIMENTO = 2050;
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| OUTRAS CONSTANTES |
|
|
//+------------------------------------------------------------------+
|
|
|
|
string NOME_NUMERO_MAGICO = "NUMERO_MAGICO";
|
|
const int SEGUNDOS_TIMER = 4;
|
|
const string NOME_ROBO = MQLInfoString(MQL_PROGRAM_NAME);
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| ENUM |
|
|
//+------------------------------------------------------------------+
|
|
|
|
enum MODO_CONTA
|
|
{
|
|
|
|
mcNETTING = 0, //Netting
|
|
mcHEDGING = 1, //Hedge
|
|
|
|
};
|
|
|
|
enum FILTRO_MEDIAS
|
|
{
|
|
UmaMedia = 0, // Acima/Abaixo da Média PEQUENA
|
|
DuasMedias = 1, // Acima/Abaixo de DUAS Médias
|
|
TresMedias = 2, // Acima/Abaixo de TRÊS Médias
|
|
SemMedias = 3, // Sem Médias (Gráfico Puro)
|
|
LequeTresMedias = 4, // Leque de TRÊS Médias
|
|
};
|
|
|
|
enum TIPOS_DE_CONTRATO
|
|
{
|
|
MiniIndice = 0, //Mini Indice
|
|
IndiceCheio = 1, // Indice Cheio
|
|
MiniDolar = 2, //Mini Dólar
|
|
DolarCheio = 3, // Dólar Cheio
|
|
OutrosAtivos = 4, //Outros Ativos (ATIVO CORRENTE)
|
|
};
|
|
|
|
|
|
enum TIPOS_DE_POSITIONSIZE
|
|
{
|
|
PorcentagemConta = 0, //Porcentagem do Saldo em Conta
|
|
RFixo = 1, // Valor de R fixo
|
|
LoteFixo = 2, //Lote Fixo
|
|
};
|
|
|
|
enum REAL_OU_BACKTEST
|
|
{
|
|
ContaReal = 0, //Conta REAL
|
|
Backtest = 1, //BackTest
|
|
};
|
|
|
|
enum TRALING_STOP
|
|
{
|
|
Ativa_TralingStop = 0, //Traling Stop ATIVADO
|
|
Desativa_TralingStop = 1, //Traling Stop DESATIVADO
|
|
};
|
|
|
|
enum PORCENTAGEM_DA_CONTA
|
|
{
|
|
PorcentagemConta1_0 = 0, //1.0%
|
|
PorcentagemConta1_5 = 1, //1.5%
|
|
PorcentagemConta2_0 = 2, //2.0%
|
|
PorcentagemConta2_5 = 3, //2.5%
|
|
PorcentagemConta3_0 = 4, //3.0%
|
|
PorcentagemConta4_0 = 5, //4.0%
|
|
PorcentagemConta5_0 = 6, //5.0%
|
|
PorcentagemConta10_0 = 7, //10.0%
|
|
PorcentagemConta15_0 = 8, //15.0%
|
|
PorcentagemConta20_0 = 9, //20.0%
|
|
};
|
|
|
|
enum ROTEAMENTO
|
|
{
|
|
Mini_Indice = 0, //Mini Indice (ATIVO CORRENTE)
|
|
Indice_Cheio = 1, // Indice Cheio (ATIVO CORRENTE)
|
|
Mini_Dolar = 2, //Mini Dólar (ATIVO CORRENTE)
|
|
Dolar_Cheio = 3, // Dólar Cheio (ATIVO CORRENTE)
|
|
OutrosAtivos = 4, //Outros Ativos (ATIVO CORRENTE)
|
|
};
|
|
|
|
enum COMENTARIOS_ROBO
|
|
{
|
|
Sim_MostrarOsComentarios = 0, //Sim, mostrar os comentários/variáveis do robô
|
|
Nao_MostrarOsComentarios = 1, //Não mostrar os comentários/variáveis do robô
|
|
};
|
|
|
|
enum INPUT_ALVO_MIN_ENTRADA
|
|
{
|
|
Alvo_Pela_Minima_Ou_Maxima = 0, // pela Mínima/Máxima
|
|
Alvo_Pela_Entrada = 1, // pela Entrada
|
|
|
|
};
|
|
|
|
enum INPUT_ATR_DIARIO_X_PERIODOS
|
|
{
|
|
Habilitado_Atr_Diario = 0, // Só opera se o ATR Diário de XX períodos for maior que XX pontos
|
|
Desabilitado_Atr_Diario = 1, // Desabilita o filtro do ATR Diário, opera em qq circunstância
|
|
|
|
};
|
|
//+------------------------------------------------------------------+
|
|
//| INPUTS |
|
|
//+------------------------------------------------------------------+
|
|
input group "■■■■■ CONFIGURAÇÕES POSITIONSIZE ↓"
|
|
input TIPOS_DE_POSITIONSIZE inputPorcentagemConta = RFixo; // Escolha modo de Positionsize
|
|
input string ————————————————————— = "———————————————————————————";
|
|
input PORCENTAGEM_DA_CONTA inputPorcentagemConta1_5 = PorcentagemConta1_5; // Porcentagem da conta
|
|
input int valorDoREmReais = 1000; //Valor do R | Risco Financeiro em Reais
|
|
input int quantidadeDeContratosFixo = 3; //Quantidade de contratos fixo
|
|
input group "■■■■■ TIPO DE CONTRATO ↓"
|
|
input TIPOS_DE_CONTRATO inputTipoContrato = MiniIndice; //Pegar Dados Do Seguinte Ativo
|
|
input ROTEAMENTO inputCrossOrder = Mini_Indice; //Rotear Ordens no Seguinte Ativo
|
|
input string inputQualTickerAtivo = ""; //Qual TICKER DO ATIVO? Ex: WINQ23
|
|
input group "■■■■■ TIPO DE CONTA E OPORTUNIDADES NO DIA ↓"
|
|
sinput REAL_OU_BACKTEST inputModoDeMercado = ContaReal; //Conta Real ou Backtest??
|
|
sinput MODO_CONTA inputModoConta = mcHEDGING; //Tipo de Conta
|
|
input ulong VALOR_NUMERO_MAGICO = 1000;
|
|
input int inputMaximoTradesNoDia = 1;
|
|
input group "■■■■■ COMENTÁRIOS E HORÁRIO DE OPERAÇÃO ↓"
|
|
input COMENTARIOS_ROBO inputMostrarComentarios = Sim_MostrarOsComentarios; //Mostrar Comentários na tela?
|
|
sinput string inputHoraInicialAbrirPosicao = "09:05"; //Começa a fazer trade às XX h ?
|
|
sinput string inputHoraLimiteAbrirPosicao = "17:30"; //Hora limite para fazer trade às XX h ?
|
|
sinput string inputHorarioVerao = "17:30"; //Fechar Ordens e Posições às XX:XXh?
|
|
input group "■■■■■ CONFIGURAÇÃO DE MÉDIAS MÓVEIS E ATR ↓"
|
|
input int inputMMPequena = 34; //Média Móvel Pequena
|
|
input int inputMMMedia = 144; //Média Móvel Media
|
|
input int inputMMGrande = 610; //Média Móvel Grande
|
|
input int inputValorATR = 360; //Valor do ATR de 15 Minutos
|
|
input group "■■■■■ LÓGICA ↓"
|
|
input double inputTicksEntrada = 1; //Lançar Ordem a quantos ticks da máxima/mínima?
|
|
input FILTRO_MEDIAS inputFiltroDasMedias = TresMedias; //Filtro de Médias
|
|
input string ash = "----"; //----
|
|
input int inputATRMaximoDia = 90; //Faz Trade até XX% do ATR Diário.
|
|
input int inputPercentualRompimento = 50; //Percentual Rompimento (atr do 15).
|
|
input double inputMultiplicadorDoAlvo = 3.0; //Multiplicador do Alvo (ATR)
|
|
input string asd43 = "----"; //----
|
|
input INPUT_ATR_DIARIO_X_PERIODOS inputAtrDiarioHabilitado = Desabilitado_Atr_Diario; //ATR Diário Maior que XX Pontos?
|
|
input int inputFiltroAtrDiarioXPontos = 1800; //Se ativado o Filtro Acima, o filtro será de XX pontos
|
|
input int inputFiltroAtrDiarioXPeriodos = 5; //Se ativado o Filtro Acima, O ATR será de XX períodos
|
|
input string sdt4 = "----"; //----
|
|
input INPUT_ALVO_MIN_ENTRADA inputAlvoPelaMinMaxOuEntrada = Alvo_Pela_Minima_Ou_Maxima; //O Alvo será calculado Por:
|
|
input TRALING_STOP inputTralingStop = Desativa_TralingStop; //Ativar Traling Stop da MME abaixo?
|
|
input int inputMMTralingStop = 17; //Média Móvel Do Traling Stop, caso Ativado...
|
|
input string a1312 = "----"; //----
|
|
input double multiplicadorStop = 1.0; // Multiplicador Stop em % | colocar 0 na frente = 0.5 == 50%
|
|
input double breakeven_multiplicador = 2.0; //multiplicado ATR Breakeven
|
|
//+------------------------------------------------------------------+
|
|
//| VARIAVEIS GLOBAIS |
|
|
//+------------------------------------------------------------------+
|
|
CTrade trade;
|
|
MqlTick tick;
|
|
|
|
|
|
//--- VARIÁVEIS DO ROBÔ
|
|
double media_movel_pequena = 0;
|
|
double media_movel_media = 0;
|
|
double media_movel_grande = 0;
|
|
double media_movel_tralingstop = 0;
|
|
double atr_stop_15 = 0;
|
|
double atr_diario = 0;
|
|
double atr_diario_filtro_pts = 0;
|
|
|
|
string botao_maxima = "";
|
|
string botao_minima = "";
|
|
double maxima_do_dia = 0;
|
|
double minima_do_dia = 0;
|
|
double valor_do_stop_compra = 0;
|
|
double alvo_compra = 0;
|
|
double valor_do_stop_venda = 0;
|
|
double alvo_venda = 0;
|
|
ulong horario_executou_robo = TimeLocal();
|
|
string comprinha= "";
|
|
string vendinha = "";
|
|
|
|
//---VARIÁVEIS LOOP DE ORDENS E POSIÇÕES -----------------
|
|
bool compradoMercado = false, vendidoMercado = false, compradoPendente = false, vendidoPendente = false;
|
|
bool compradoStop = false;
|
|
bool vendidoStop = false;
|
|
ulong ticketCompradoMercado = 0, ticketVendidoMercado = 0, ticketCompradoPendente = 0, ticketVendidoPendente = 0;
|
|
ulong ticketVendidoStop = 0;
|
|
ulong ticketCompradoStop = 0;
|
|
double quantLotesPosicaoCompra = 0;
|
|
double quantLotesPosicaoVenda = 0;
|
|
double quantLotesOrdensVenda = 0;
|
|
double quantLotesOrdensCompra = 0;
|
|
double quantLotesOrdensStopCompra = 0;
|
|
double quantLotesOrdensStopVenda = 0;
|
|
|
|
uint quantPosicoesCompraExecutadasNoAtivo = 0;
|
|
uint quantPosicoesVendaExecutadasNoAtivo = 0;
|
|
uint quantPosicoesCompraExecutadasGlobal = 0;
|
|
uint quantPosicoesVendaExecutadasGlobal = 0;
|
|
uint quantOrdensCompraAbertasNoAtivo = 0;
|
|
uint quantOrdensVendaAbertasNoAtivo = 0;
|
|
uint quantOrdensCompraAbertasGlobal = 0;
|
|
uint quantOrdensVendaAbertasGlobal = 0;
|
|
|
|
double precoDeCompra = 0;
|
|
double precoDeVenda = 0;
|
|
double precoPendurouOrdemCompra = 0;
|
|
double precoPendurouOrdemVenda = 0;
|
|
double precoPendurouOrdemStopCompra = 0;
|
|
double precoPendurouOrdemStopVenda = 0;
|
|
double maiorOrdemDeCompra = 0;
|
|
double menorOrdemDeVenda = 0;
|
|
double primeiroPrecoOrdemDeVenda = 0;
|
|
bool existem_ordem_entao_nao_pode_monitorar_compra = false;
|
|
bool existem_ordem_entao_nao_pode_monitorar_venda = false;
|
|
bool se_ta_vendido_no_ask_ou_mais = false;
|
|
bool se_ta_comprado_no_bid_ou_menos = false;
|
|
bool enviou_ordem_de_compra = false; //static
|
|
bool enviou_ordem_de_venda = false; //static
|
|
bool ordenStopExiste = false;
|
|
string tipoOrdemAberta = "nada";
|
|
bool verificaHorarioPermitidoAbrirPosicao = false;
|
|
static bool temQueZerarVenda = false;
|
|
static bool temQueZerarCompra = false;
|
|
static int quantos_trades_fez_no_dia = 0;
|
|
bool jaDiminuiuUmaOrdemVenda = true;
|
|
bool jaDiminuiuUmaOrdemCompra = true;
|
|
double quantidadeContratos = 0;
|
|
int minimoDeContratos = 0;
|
|
double valorFinanceiroPorTickMiniIndice = 0.2;
|
|
int valorFinanceiroPorTickIndiceCheio = 5;
|
|
double multiplicadorFinanceiroDoContrato = 0.0;
|
|
double valorStopEmReais = 0;
|
|
string NomeTipoDeContrato = " ";
|
|
double step = 0.0;
|
|
double seraQueAredonda = 0.0;
|
|
bool aredondaPeloTOPO = false;
|
|
bool aredondaPeloFUNDO = false;
|
|
bool podeTreidar = false;
|
|
MqlRates candles5[415]; //para candles do 5 min
|
|
MqlRates candlesDia[2]; //para dia anteriores
|
|
double valorPorcentagemConta1_0 = 0.010; //1.0%
|
|
double valorPorcentagemConta1_5 = 0.015; //1.5%
|
|
double valorPorcentagemConta2_0 = 0.020; //2.0%
|
|
double valorPorcentagemConta2_5 = 0.025; //1.5%
|
|
double valorPorcentagemConta3_0 = 0.03; //3.0%
|
|
double valorPorcentagemConta4_0 = 0.04; //4.0%
|
|
double valorPorcentagemConta5_0 = 0.05; //5.0%
|
|
double valorPorcentagemConta10_0 = 0.10; //10.0%
|
|
double valorPorcentagemConta15_0 = 0.15; //15.0%
|
|
double valorPorcentagemConta20_0 = 0.20; //20.0%
|
|
double valorBalancoDaConta = 0;
|
|
double RPeloBalancoDaConta = 0;
|
|
static double precoDaLinhaATRAlta= 0.0;
|
|
static double precoDaLinhaATRBaixa = 0.0;
|
|
double barra5DeOntemHIGH= 0.0;
|
|
double barra5DeOntemLOW= 0.0;
|
|
datetime primeiroCandle5Horario;
|
|
datetime chaveDiaOntem;
|
|
string roteamento_symbol = "";
|
|
double tickerBase = SymbolInfoDouble(roteamento_symbol, SYMBOL_TRADE_TICK_SIZE); //aqui calcula o valor de 1 tick do mercado/ativo
|
|
int n_ordens_enviadas = 0; // contador proteção envio massivo de ordens
|
|
bool marcou_contagem_trades = false;
|
|
double diferenca_entre_tickers = 0;
|
|
bool not_printou = false;
|
|
|
|
//--------------------------------------------------------
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
ENUM_ACCOUNT_TRADE_MODE tipoConta = (ENUM_ACCOUNT_TRADE_MODE) AccountInfoInteger(ACCOUNT_TRADE_MODE);
|
|
ENUM_ACCOUNT_MARGIN_MODE modoConta = (ENUM_ACCOUNT_MARGIN_MODE) AccountInfoInteger(ACCOUNT_MARGIN_MODE);
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert initialization function |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit()
|
|
{
|
|
|
|
if (inputModoConta == mcHEDGING) trade.SetExpertMagicNumber(VALOR_NUMERO_MAGICO);
|
|
//--- create timer
|
|
EventSetTimer(SEGUNDOS_TIMER);
|
|
SymbolSelect("IND$N",true);
|
|
SymbolSelect("WIN$N",true);
|
|
SymbolSelect(inputQualTickerAtivo,true);
|
|
if(!VerificarInputs())
|
|
ExpertRemove();
|
|
|
|
ControleDeAcesso(NOME_NA_CORRETORA, NUMERO_CONTA_REAL, NUMERO_CONTA_DEMO, NUMERO_MAXIMO_CONTRATOS, DIA_DO_VENCIMENTO, MES_DO_VENCIMENTO, ANO_DO_VENCIMENTO); //chamada de função para controle de acesso ao robô!
|
|
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert deinitialization function |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason)
|
|
{
|
|
//--- destroy timer
|
|
EventKillTimer();
|
|
if (inputTipoContrato == IndiceCheio) SymbolSelect("IND$N",false);
|
|
if (inputTipoContrato == MiniIndice) SymbolSelect("WIN$N",false);
|
|
//SymbolSelect(inputQualTickerAtivo,false);
|
|
RemoverIndicadores();
|
|
|
|
if (inputModoConta == mcHEDGING)
|
|
if (GlobalVariableCheck(NOME_NUMERO_MAGICO)) GlobalVariableDel(NOME_NUMERO_MAGICO); // REMOVER O NúMERO MáGICO
|
|
|
|
}
|
|
|
|
void OnTimer(void)
|
|
{
|
|
if (inputModoConta == mcHEDGING) trade.SetExpertMagicNumber(VALOR_NUMERO_MAGICO);
|
|
|
|
ControleDeAcesso(NOME_NA_CORRETORA, NUMERO_CONTA_REAL, NUMERO_CONTA_DEMO, NUMERO_MAXIMO_CONTRATOS, DIA_DO_VENCIMENTO, MES_DO_VENCIMENTO, ANO_DO_VENCIMENTO); //chamada de função para controle de acesso ao robô!
|
|
CriaLinhaATRMinimoDeAltaEBaixa();
|
|
//Print("HorarioFechamentoPregaoTodasOrdens() = ", HorarioFechamentoPregaoTodasOrdens());
|
|
//Print("HorarioFechamentoPregaoTodasOrdens2() = ", HorarioFechamentoPregaoTodasOrdens2());
|
|
|
|
if (HorarioFechamentoPregaoTodasOrdens2()) {
|
|
|
|
if (!not_printou) {
|
|
Print("Chegou no horário para fechamento de ordens e posições. Caso tenha alguma ordem, será fechada!");
|
|
not_printou = true;
|
|
}
|
|
FecharPosicaoAbertas();
|
|
FecharOrdensPendentesCompraDoAtivo(); // Ever | Que tal remover essa função do final do dia já que coloquei após o almoço né?
|
|
FecharOrdensPendentesVendaDoAtivo();
|
|
FecharOrdensPendentesBuyStopAtivo();
|
|
FecharOrdensPendentesSellStopAtivo();
|
|
}
|
|
|
|
if(HorarioFechamentoPregaoTodasOrdens())
|
|
{
|
|
FecharPosicaoAbertas();
|
|
FecharOrdensPendentesCompraDoAtivo(); // Ever | Que tal remover essa função do final do dia já que coloquei após o almoço né?
|
|
FecharOrdensPendentesVendaDoAtivo();
|
|
FecharOrdensPendentesBuyStopAtivo();
|
|
FecharOrdensPendentesSellStopAtivo();
|
|
}
|
|
|
|
if(VerificarOrdensPosicoes())
|
|
{
|
|
LogicaOperacional();
|
|
FecharPosicoesContaHedge();
|
|
modificarOrdemStopDaPosicaoDeCompra();
|
|
modificarOrdemStopDaPosicaoDeVenda();
|
|
AlvoDaCompra();
|
|
AlvoDaVenda();
|
|
TralingStop();
|
|
ProtecaoContraLooping();
|
|
//ProtecaoEnvioMassivoOrdens();
|
|
|
|
}
|
|
|
|
if (!HorarioPermitidoAbrirPosicao() && verificaHorarioPermitidoAbrirPosicao)
|
|
{
|
|
//Print("Passou do Horário de almoço!");
|
|
verificaHorarioPermitidoAbrirPosicao = false;
|
|
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert tick function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTick()
|
|
{
|
|
CriaLinhaATRMinimoDeAltaEBaixa();
|
|
|
|
if (HorarioFechamentoPregaoTodasOrdens2()) {
|
|
FecharOrdensPendentesBuyStopAtivo();
|
|
FecharOrdensPendentesSellStopAtivo();
|
|
FecharPosicaoAbertas();
|
|
FecharOrdensPendentesCompraDoAtivo(); // Ever | Que tal remover essa função do final do dia já que coloquei após o almoço né?
|
|
FecharOrdensPendentesVendaDoAtivo();
|
|
|
|
}
|
|
|
|
if(HorarioFechamentoPregaoTodasOrdens())
|
|
{
|
|
FecharPosicaoAbertas();
|
|
FecharOrdensPendentesCompraDoAtivo(); // Ever | Que tal remover essa função do final do dia já que coloquei após o almoço né?
|
|
FecharOrdensPendentesVendaDoAtivo();
|
|
FecharOrdensPendentesBuyStopAtivo();
|
|
FecharOrdensPendentesSellStopAtivo();
|
|
}
|
|
|
|
if(VerificarOrdensPosicoes())
|
|
{
|
|
LogicaOperacional();
|
|
FecharPosicoesContaHedge();
|
|
modificarOrdemStopDaPosicaoDeCompra();
|
|
modificarOrdemStopDaPosicaoDeVenda();
|
|
AlvoDaCompra();
|
|
AlvoDaVenda();
|
|
TralingStop();
|
|
ProtecaoContraLooping();
|
|
//ProtecaoEnvioMassivoOrdens();
|
|
|
|
}
|
|
|
|
if (!HorarioPermitidoAbrirPosicao() && verificaHorarioPermitidoAbrirPosicao)
|
|
{
|
|
//Print("Passou do Horário de almoço!");
|
|
verificaHorarioPermitidoAbrirPosicao = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| FUNÇÕES OPERACIONAIS |
|
|
//+------------------------------------------------------------------+
|
|
|
|
//---
|
|
bool LogicaOperacional()
|
|
{
|
|
|
|
if(!SymbolInfoTick(roteamento_symbol,tick))
|
|
{
|
|
Print("ERRO: Dados de ticks não foram copiados corretamente");
|
|
return (false);
|
|
}
|
|
|
|
MediasEAtr();
|
|
|
|
bool filtro_do_atr_diario_em_pontos = true;
|
|
if (inputAtrDiarioHabilitado == Habilitado_Atr_Diario && atr_diario_filtro_pts < inputFiltroAtrDiarioXPontos) {
|
|
filtro_do_atr_diario_em_pontos = false; //marca o filtro como falso
|
|
}
|
|
|
|
|
|
|
|
|
|
//bool se_saiu_leilao = SeAtivoSaiuDoLeilao();
|
|
int desloc_primeira_barra_dia = SeAtivoSaiuDoLeilaoMarcarPrimeiraBarra(); //aqui pega o valor da função para saber quantas barras precisa deslocar para pegar max e minima da primeira barra
|
|
static double maxima_primeira_barra = 0;
|
|
static double minima_primeira_barra = 0;
|
|
|
|
|
|
static bool marcou_primeira_barra = false;
|
|
if(desloc_primeira_barra_dia == 0)
|
|
marcou_primeira_barra = false;
|
|
if(desloc_primeira_barra_dia != 0 && !marcou_primeira_barra)
|
|
{
|
|
maxima_primeira_barra = iHigh(_Symbol,PERIOD_CURRENT,desloc_primeira_barra_dia);
|
|
minima_primeira_barra = iLow(_Symbol,PERIOD_CURRENT,desloc_primeira_barra_dia);
|
|
|
|
precoDaLinhaATRAlta = maxima_primeira_barra + (MathRound(atr_stop_15*inputPercentualRompimento/tickerBase)*tickerBase)/100;
|
|
precoDaLinhaATRBaixa = minima_primeira_barra - (MathRound(atr_stop_15*inputPercentualRompimento/tickerBase)*tickerBase)/100;
|
|
primeiroCandle5Horario = iTime(_Symbol,PERIOD_CURRENT,desloc_primeira_barra_dia);
|
|
|
|
quantos_trades_fez_no_dia = 0;
|
|
marcou_primeira_barra = true;
|
|
}
|
|
|
|
//-- DECLARAR DUAS VARIÁVEIS BOOLEANAS QUE CORRESPONDERAM AOS FILTROS DA MÉDIA
|
|
static bool filtro_uma_media_venda = false;
|
|
static bool filtro_uma_media_compra = false;
|
|
static bool filtro_duas_medias_venda = false;
|
|
static bool filtro_duas_medias_compra = false;
|
|
static bool filtro_tres_medias_venda = false;
|
|
static bool filtro_tres_medias_compra = false;
|
|
static bool filtro_leque_tres_medias_venda = false;
|
|
static bool filtro_leque_tres_medias_compra = false;
|
|
double fechamento_barra_anterior = iClose(_Symbol,PERIOD_CURRENT,1);
|
|
maxima_do_dia = iHigh(_Symbol, PERIOD_D1, 0);
|
|
static double maxima_do_dia_compra = 0;
|
|
minima_do_dia = iLow(_Symbol,PERIOD_D1,0);
|
|
static double minima_do_dia_venda = 0;
|
|
double diferenca_maxima_minima = NormalizeDouble(maxima_do_dia - minima_do_dia, _Digits);
|
|
double percentual_atr_atingido = ((diferenca_maxima_minima*100)/atr_diario);
|
|
bool atingiu_atr_diario = false;
|
|
bool diferenca_tickers_deixa_fazer_trade = true;
|
|
|
|
double precoAtual = NormalizeDouble(tick.last, _Digits);
|
|
double maxima_barra_rompeu = 0; //static
|
|
double minima_barra_rompeu = 0;
|
|
double diferenca_maxima_barra_rompeu = 0;
|
|
double diferenca_minima_barra_rompeu = 0;
|
|
double percentual_barra_rompeu_maxima = 0;
|
|
double percentual_barra_rompeu_minima = 0;
|
|
bool ja_passou_rompimento_minima = false; //Ever | Coloquei no scopo global
|
|
bool ja_passou_rompimento_maxima = false; //static
|
|
//bool enviou_ordem_de_compra = false; //static
|
|
//bool enviou_ordem_de_venda = false; //static
|
|
|
|
if(desloc_primeira_barra_dia == 0)
|
|
{
|
|
|
|
maxima_primeira_barra = 0;
|
|
minima_primeira_barra = 0;
|
|
maxima_barra_rompeu = 0;
|
|
minima_barra_rompeu = 0;
|
|
diferenca_maxima_barra_rompeu = 0;
|
|
diferenca_minima_barra_rompeu = 0;
|
|
percentual_barra_rompeu_maxima = 0;
|
|
percentual_barra_rompeu_minima = 0;
|
|
ja_passou_rompimento_minima = false;
|
|
ja_passou_rompimento_maxima = false;
|
|
enviou_ordem_de_compra = false;
|
|
enviou_ordem_de_venda = false;
|
|
quantos_trades_fez_no_dia = 0;
|
|
marcou_contagem_trades = false;
|
|
maxima_do_dia_compra = 0;
|
|
minima_do_dia_venda = 0;
|
|
|
|
}
|
|
|
|
if(NovoDia())
|
|
{
|
|
enviou_ordem_de_compra = false;
|
|
enviou_ordem_de_venda = false;
|
|
quantos_trades_fez_no_dia = 0;
|
|
not_printou = false;
|
|
|
|
}
|
|
|
|
//CÁLCULO SE ATINGIU ATR DIARIO
|
|
if(percentual_atr_atingido >= inputATRMaximoDia)
|
|
atingiu_atr_diario = true;
|
|
|
|
//SE ATINGIU O ATR DIARIO E TIVER ORDEM START(STOP) ABERTA, ENTAO CANCELA ESSAS ORDENS
|
|
if (atingiu_atr_diario && VerificarOrdensPosicoes() && !compradoMercado && !vendidoMercado) { //se atingiu ATR do DIA e nao tenho posicao aberta
|
|
if (ticketCompradoStop != 0) { //se eu tenho uma ordem stop/start de compra aberta
|
|
FecharOrdensPendentesBuyStopAtivo(); //entao deleto essa ordem
|
|
} else if (ticketVendidoStop != 0) { //se eu tenho uma ordem stop/start de venda aberta
|
|
FecharOrdensPendentesSellStopAtivo(); //entao deleto essa ordem
|
|
}
|
|
}
|
|
|
|
//CÁLCULO PERCENTUAL DO ATR15 QUE ROMPEU A MÍNIMA/MÁXIMA DA PRIMEIRA BARRA DO DIA
|
|
|
|
if(HorarioPermitidoAbrirPosicao() && !ja_passou_rompimento_minima && fechamento_barra_anterior < minima_primeira_barra)
|
|
{
|
|
maxima_barra_rompeu = iHigh(_Symbol, PERIOD_CURRENT, 1);
|
|
minima_barra_rompeu = iLow(_Symbol, PERIOD_CURRENT, 1);
|
|
double fechamento_barra_rompeu = iClose(_Symbol, PERIOD_CURRENT, 1);
|
|
diferenca_minima_barra_rompeu = NormalizeDouble(minima_primeira_barra - fechamento_barra_rompeu, _Digits);
|
|
percentual_barra_rompeu_minima = ((diferenca_minima_barra_rompeu*100)/atr_stop_15);
|
|
ja_passou_rompimento_minima = true;
|
|
|
|
}
|
|
|
|
if(HorarioPermitidoAbrirPosicao() && !ja_passou_rompimento_maxima && (maxima_primeira_barra > 0) && fechamento_barra_anterior > maxima_primeira_barra)
|
|
{
|
|
maxima_barra_rompeu = iHigh(_Symbol, PERIOD_CURRENT, 1);
|
|
minima_barra_rompeu = iLow(_Symbol, PERIOD_CURRENT, 1);
|
|
double fechamento_barra_rompeu = iClose(_Symbol, PERIOD_CURRENT, 1);
|
|
diferenca_maxima_barra_rompeu = NormalizeDouble(fechamento_barra_rompeu - maxima_primeira_barra, _Digits);
|
|
percentual_barra_rompeu_maxima = ((diferenca_maxima_barra_rompeu*100)/atr_stop_15);
|
|
ja_passou_rompimento_maxima = true;
|
|
//---
|
|
verificaHorarioPermitidoAbrirPosicao = true; //Ever | Se o pregão ja começou ativa chave pra zerar operações apenas 1 vez depois que sair do horário de almoço
|
|
}
|
|
|
|
//LÓGICA PIVO COMPRA
|
|
bool valida_pivo_compra = false;
|
|
//if(ja_passou_rompimento_maxima && !compradoMercado)
|
|
if(!compradoMercado) {
|
|
valida_pivo_compra = true;
|
|
}
|
|
|
|
//LÓGICA PIVO VENDA
|
|
bool valida_pivo_venda = false;
|
|
//if(ja_passou_rompimento_minima && !vendidoMercado)
|
|
if(!vendidoMercado) {
|
|
valida_pivo_venda = true;
|
|
}
|
|
|
|
//LÓGICA NOVA PARA NAO DEIXAR O ATIVO FAZER TRADE COM SPREAD GRANDE
|
|
|
|
if (HorarioNoveECinco() && (inputTipoContrato == IndiceCheio || Dolar_Cheio)) {
|
|
double minima_do_dia_do_ticker = iLow(inputQualTickerAtivo,PERIOD_D1,0);
|
|
double maxima_do_dia_do_ticker = iHigh(inputQualTickerAtivo,PERIOD_D1,0);
|
|
diferenca_entre_tickers = MathAbs(minima_do_dia-minima_do_dia_do_ticker);
|
|
if (diferenca_entre_tickers >= (tickerBase*40)) diferenca_tickers_deixa_fazer_trade = false;
|
|
}
|
|
|
|
//LÓGICA DA VENDA PARA UMA MEDIAS
|
|
//Ever | Filtro uma media
|
|
if(fechamento_barra_anterior < media_movel_pequena)
|
|
{
|
|
filtro_uma_media_venda = true;
|
|
}
|
|
else
|
|
{
|
|
filtro_uma_media_venda = false;
|
|
}
|
|
|
|
//LÓGICA DA COMPRA PARA UMA MEDIAS //Ever | Filtro uma media
|
|
if(fechamento_barra_anterior > media_movel_pequena)
|
|
{
|
|
filtro_uma_media_compra = true;
|
|
}
|
|
else
|
|
{
|
|
filtro_uma_media_compra = false;
|
|
}
|
|
|
|
//LÓGICA DA VENDA PARA DUAS MEDIAS
|
|
if((fechamento_barra_anterior < media_movel_pequena) && ((fechamento_barra_anterior < media_movel_media) || (fechamento_barra_anterior < media_movel_grande)))
|
|
{
|
|
filtro_duas_medias_venda = true;
|
|
}
|
|
else
|
|
{
|
|
filtro_duas_medias_venda = false;
|
|
}
|
|
|
|
//LÓGICA DA COMPRA PARA DUAS MEDIAS
|
|
if((fechamento_barra_anterior > media_movel_pequena) && ((fechamento_barra_anterior > media_movel_media) || (fechamento_barra_anterior > media_movel_grande)))
|
|
{
|
|
filtro_duas_medias_compra = true;
|
|
}
|
|
else
|
|
{
|
|
filtro_duas_medias_compra = false;
|
|
}
|
|
|
|
//LÓGICA DA VENDA PARA TRES MEDIAS
|
|
if((fechamento_barra_anterior < media_movel_pequena) && (fechamento_barra_anterior < media_movel_media) && (fechamento_barra_anterior < media_movel_grande))
|
|
{
|
|
filtro_tres_medias_venda = true;
|
|
}
|
|
else
|
|
{
|
|
filtro_tres_medias_venda = false;
|
|
}
|
|
|
|
//LÓGICA DA COMPRA PARA TRES MEDIAS
|
|
if((fechamento_barra_anterior > media_movel_pequena) && (fechamento_barra_anterior > media_movel_media) && (fechamento_barra_anterior > media_movel_grande))
|
|
{
|
|
filtro_tres_medias_compra = true;
|
|
}
|
|
else
|
|
{
|
|
filtro_tres_medias_compra = false;
|
|
}
|
|
|
|
//LÓGICA DA VENDA PARA LEQUE DE TRES MEDIAS
|
|
if((fechamento_barra_anterior < media_movel_pequena) && (media_movel_pequena < media_movel_media) && (media_movel_media < media_movel_grande))
|
|
{
|
|
filtro_leque_tres_medias_venda = true;
|
|
}
|
|
else
|
|
{
|
|
filtro_leque_tres_medias_venda = false;
|
|
}
|
|
|
|
//LÓGICA DA COMPRA PARA LEQUE DE TRES MEDIAS
|
|
if((fechamento_barra_anterior > media_movel_pequena) && (media_movel_pequena > media_movel_media) && (media_movel_media > media_movel_grande))
|
|
{
|
|
filtro_leque_tres_medias_compra = true;
|
|
}
|
|
else
|
|
{
|
|
filtro_leque_tres_medias_compra = false;
|
|
}
|
|
|
|
bool podeComprar = false;
|
|
bool podeVender = false;
|
|
bool podeComprarPivo = false;
|
|
bool podeVenderPivo = false;
|
|
|
|
if(inputFiltroDasMedias == DuasMedias)
|
|
{
|
|
|
|
podeComprar =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_duas_medias_compra) &&
|
|
(!atingiu_atr_diario) &&
|
|
(percentual_barra_rompeu_maxima >= inputPercentualRompimento) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
//(tick.last >= ((maxima_do_dia)-(tickerBase*15))) &&
|
|
(!enviou_ordem_de_compra);
|
|
|
|
podeComprarPivo =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_duas_medias_compra) &&
|
|
(!atingiu_atr_diario) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
(enviou_ordem_de_compra) &&
|
|
(tick.last >= ((maxima_do_dia)-(tickerBase*15))) && // tire menos 50 = ((maxima_do_dia+5)-50))
|
|
(valida_pivo_compra);
|
|
|
|
podeVender =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_duas_medias_venda) &&
|
|
(!atingiu_atr_diario) &&
|
|
(percentual_barra_rompeu_minima >= inputPercentualRompimento) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
//(tick.last <= ((minima_do_dia-tickerBase)+(tickerBase*15))) &&
|
|
(!enviou_ordem_de_venda);
|
|
|
|
podeVenderPivo =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_duas_medias_venda) &&
|
|
(!atingiu_atr_diario) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
(enviou_ordem_de_venda) &&
|
|
(tick.last <= ((minima_do_dia)+(tickerBase*15))) && // ((minima_do_dia-5)+50))
|
|
(valida_pivo_venda);
|
|
}
|
|
|
|
else
|
|
|
|
if(inputFiltroDasMedias == TresMedias)
|
|
{
|
|
|
|
podeComprar =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_tres_medias_compra) &&
|
|
(!atingiu_atr_diario) &&
|
|
(percentual_barra_rompeu_maxima >= inputPercentualRompimento) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
//(tick.last >= ((maxima_do_dia)-(tickerBase*15))) &&
|
|
(!enviou_ordem_de_compra);
|
|
|
|
podeComprarPivo =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_tres_medias_compra) &&
|
|
(!atingiu_atr_diario) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(enviou_ordem_de_compra) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
(tick.last > ((maxima_do_dia)-(tickerBase*15))) && // ((maxima_do_dia+5)-50)) &&
|
|
(valida_pivo_compra);
|
|
|
|
podeVender =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_tres_medias_venda) &&
|
|
(!atingiu_atr_diario) &&
|
|
(percentual_barra_rompeu_minima >= inputPercentualRompimento) && //Mudei de > para menos
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
//(tick.last <= ((minima_do_dia-tickerBase)+(tickerBase*15))) &&
|
|
(!enviou_ordem_de_venda);
|
|
|
|
podeVenderPivo =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_tres_medias_venda) &&
|
|
(!atingiu_atr_diario) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(enviou_ordem_de_venda) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
(tick.last < ((minima_do_dia)+(tickerBase*15))) && // ((minima_do_dia-5)+50))
|
|
(valida_pivo_venda);
|
|
|
|
}
|
|
else
|
|
if(inputFiltroDasMedias == LequeTresMedias)
|
|
{
|
|
|
|
podeComprar =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_leque_tres_medias_compra) &&
|
|
(!atingiu_atr_diario) &&
|
|
(percentual_barra_rompeu_maxima >= inputPercentualRompimento) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
//(tick.last >= ((maxima_do_dia)-(tickerBase*15))) &&
|
|
(!enviou_ordem_de_compra);
|
|
|
|
podeComprarPivo =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_leque_tres_medias_compra) &&
|
|
(!atingiu_atr_diario) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(enviou_ordem_de_compra) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
(tick.last > ((maxima_do_dia)-(tickerBase*15))) && // ((maxima_do_dia+5)-50)) &&
|
|
(valida_pivo_compra);
|
|
|
|
podeVender =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_leque_tres_medias_venda) &&
|
|
(!atingiu_atr_diario) &&
|
|
(percentual_barra_rompeu_minima >= inputPercentualRompimento) && //Mudei de > para menos
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
//(tick.last <= ((minima_do_dia-tickerBase)+(tickerBase*15))) &&
|
|
(!enviou_ordem_de_venda);
|
|
|
|
podeVenderPivo =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_leque_tres_medias_venda) &&
|
|
(!atingiu_atr_diario) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(enviou_ordem_de_venda) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
(tick.last < ((minima_do_dia)+(tickerBase*15))) && // ((minima_do_dia-5)+50))
|
|
(valida_pivo_venda);
|
|
}
|
|
|
|
else
|
|
if(inputFiltroDasMedias == SemMedias)
|
|
{
|
|
|
|
podeComprar =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(!atingiu_atr_diario) &&
|
|
(percentual_barra_rompeu_maxima >= inputPercentualRompimento) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
//(tick.last >= ((maxima_do_dia)-(tickerBase*15))) &&
|
|
(!enviou_ordem_de_compra);
|
|
|
|
podeComprarPivo =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(!atingiu_atr_diario) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(enviou_ordem_de_compra) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
(tick.last >= ((maxima_do_dia+tickerBase)-(tickerBase*15))) &&
|
|
(valida_pivo_compra);
|
|
|
|
podeVender =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(!atingiu_atr_diario) &&
|
|
(percentual_barra_rompeu_minima >= inputPercentualRompimento) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
//(tick.last <= ((minima_do_dia-tickerBase)+(tickerBase*15))) &&
|
|
(!enviou_ordem_de_venda);
|
|
|
|
podeVenderPivo =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(!atingiu_atr_diario) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(enviou_ordem_de_venda) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
(tick.last <= ((minima_do_dia-tickerBase)+(tickerBase*15))) &&
|
|
(valida_pivo_venda);
|
|
}
|
|
|
|
else
|
|
if(inputFiltroDasMedias == UmaMedia)
|
|
{
|
|
|
|
podeComprar =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_uma_media_compra) &&
|
|
(!atingiu_atr_diario) &&
|
|
(percentual_barra_rompeu_maxima >= inputPercentualRompimento) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
//(tick.last >= ((maxima_do_dia+tickerBase)-(tickerBase*15))) &&
|
|
(!enviou_ordem_de_compra);
|
|
|
|
podeComprarPivo =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_uma_media_compra) &&
|
|
(!atingiu_atr_diario) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(enviou_ordem_de_compra) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
(tick.last >= ((maxima_do_dia+tickerBase)-(tickerBase*15))) &&
|
|
(valida_pivo_compra);
|
|
|
|
podeVender =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_uma_media_venda) &&
|
|
(!atingiu_atr_diario) &&
|
|
(percentual_barra_rompeu_minima >= inputPercentualRompimento) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
//(tick.last <= ((minima_do_dia-tickerBase)+(tickerBase*15))) &&
|
|
(!enviou_ordem_de_venda);
|
|
|
|
podeVenderPivo =
|
|
(HorarioPermitidoAbrirPosicao()) &&
|
|
(filtro_uma_media_venda) &&
|
|
(!atingiu_atr_diario) &&
|
|
(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) &&
|
|
(diferenca_tickers_deixa_fazer_trade) &&
|
|
(enviou_ordem_de_venda) &&
|
|
(filtro_do_atr_diario_em_pontos) &&
|
|
(tick.last <= ((minima_do_dia-tickerBase)+(tickerBase*15))) &&
|
|
(valida_pivo_venda);
|
|
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| roteamento da compra |
|
|
//+------------------------------------------------------------------+
|
|
if(inputPorcentagemConta == PorcentagemConta)
|
|
{
|
|
QuantidadeContratosPorPorcentagemDeConta();
|
|
}
|
|
if(inputPorcentagemConta == RFixo)
|
|
{
|
|
QuantidadeContratosDoR();
|
|
}
|
|
if(inputPorcentagemConta == LoteFixo)
|
|
{
|
|
quantidadeContratos = quantidadeDeContratosFixo;
|
|
}
|
|
|
|
//---aqui faz a contagem dos trades no dia e deleta a ordem
|
|
if ((compradoMercado || vendidoMercado) && !marcou_contagem_trades) {
|
|
quantos_trades_fez_no_dia++;
|
|
marcou_contagem_trades = true;
|
|
}
|
|
if (marcou_contagem_trades && (!compradoMercado && !vendidoMercado)) marcou_contagem_trades = false;
|
|
//--------
|
|
//---aqui deleta a ordem stop de compra caso tenha enviado e voltou 100 pontos
|
|
if (compradoStop && vendidoMercado) {
|
|
Print("A ordem Stop de Compra que estava pendurada para tomar posição foi fechada, pois tomou posição de venda");
|
|
FecharOrdensPendentesBuyStopAtivo();
|
|
enviou_ordem_de_compra = false;
|
|
tipoOrdemAberta = "nada";
|
|
ordenStopExiste = false;
|
|
} else if (vendidoStop && compradoMercado) {
|
|
Print("A ordem Stop de Venda que estava pendurada para tomar posição foi fechada, pois tomou posição de compra");
|
|
FecharOrdensPendentesSellStopAtivo();
|
|
enviou_ordem_de_venda = false;
|
|
tipoOrdemAberta = "nada";
|
|
ordenStopExiste = false;
|
|
}
|
|
//--------
|
|
|
|
//--------
|
|
|
|
if((podeComprar || podeComprarPivo) && !compradoMercado && !vendidoMercado && !compradoStop && (quantLotesPosicaoCompra < quantidadeContratos) && podeTreidar)
|
|
{
|
|
ordenStopExiste = true; // Ever | Chave pra validar loop de deletar ordens pendentes longe do preço e não entrar em loop de deletar ordens
|
|
tipoOrdemAberta = "compra";
|
|
bool ok = false;
|
|
double adicionar_ticks = tickerBase*inputTicksEntrada;
|
|
valor_do_stop_compra = ((maxima_do_dia+adicionar_ticks) - (MathRound(atr_stop_15*multiplicadorStop/tickerBase)*tickerBase));
|
|
//alvo_compra = (maxima_do_dia+tickerBase) + (MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase);
|
|
|
|
|
|
ok = trade.BuyStop(quantidadeContratos, maxima_do_dia+adicionar_ticks, roteamento_symbol, valor_do_stop_compra, 0, ORDER_TIME_DAY, DataExpiracao(), NOME_ROBO);
|
|
enviou_ordem_de_compra = true;
|
|
jaDiminuiuUmaOrdemCompra = false; // chave para validar diminuição do contador de trades apenas 1 vez por ordem, quando remover ordem stop no on tick
|
|
n_ordens_enviadas++; //proteção envio massivo de ordens
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
Print("Ordem de COMPRA BuyStop enviada com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO1: COMPRA, BuyStop nao foi enviada");
|
|
}
|
|
}
|
|
else if (VerificarOrdensPosicoes())
|
|
{
|
|
if (VerificarOrdensPosicoes() && !compradoMercado) {
|
|
FecharOrdensPendentesBuyStopAtivo();
|
|
ok = trade.Buy(quantidadeContratos, roteamento_symbol, maxima_do_dia+tickerBase, valor_do_stop_compra, 0, NOME_ROBO);
|
|
Print("O preço pulou o gatilho da compra, então o robô COMPROU A MERCADO");
|
|
enviou_ordem_de_compra = true;
|
|
jaDiminuiuUmaOrdemCompra = false;
|
|
n_ordens_enviadas++;
|
|
}
|
|
}
|
|
|
|
// //CRIA LINHA BREAKEVEN COMPRA
|
|
// datetime barraDaCompra = iTime(_Symbol,PERIOD_CURRENT,0);
|
|
// ObjectCreate(
|
|
// 0, // ID de gráfico
|
|
// "comprinha", // Nome da linha
|
|
// OBJ_HLINE, // Tipo da linha
|
|
// 0, // Sub Window
|
|
// barraDaCompra, // Datetime do objeto
|
|
// maxima_do_dia+adicionar_ticks // Preço
|
|
// );
|
|
// ObjectSetInteger(0,"comprinha",OBJPROP_STYLE,STYLE_DOT);
|
|
// ObjectSetInteger(0,"comprinha",OBJPROP_COLOR,clrRed);
|
|
//
|
|
//
|
|
//
|
|
//
|
|
//
|
|
// if (precoAtual >= maxima_do_dia+adicionar_ticks) {
|
|
// ok = trade.Buy(quantidadeContratos, roteamento_symbol, 0, valor_do_stop_compra, 0, NOME_ROBO);
|
|
// Print("O robô COMPROU A MERCADO - Preço que tentou comprar = " + DoubleToString(maxima_do_dia+adicionar_ticks, _Digits));
|
|
// enviou_ordem_de_compra = true;
|
|
// jaDiminuiuUmaOrdemCompra = false;
|
|
// n_ordens_enviadas++;
|
|
// }
|
|
|
|
|
|
} else {
|
|
|
|
//deletar objeto linha horizontal
|
|
//if( ObjectFind(0,comprinha)>=0 ) ObjectDelete(0,comprinha);
|
|
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| roteamento da venda |
|
|
//+------------------------------------------------------------------+
|
|
|
|
if((podeVender || podeVenderPivo) && !compradoMercado && !vendidoMercado && !vendidoStop && (quantLotesPosicaoVenda < quantidadeContratos) && podeTreidar)
|
|
{
|
|
ordenStopExiste = true; // Ever | Chave pra validar loop de deletar ordens pendentes longe do preço e não entrar em loop de deletar ordens
|
|
tipoOrdemAberta = "venda";
|
|
bool ok = false;
|
|
double adicionar_ticks = tickerBase*inputTicksEntrada;
|
|
valor_do_stop_venda = ((minima_do_dia-adicionar_ticks) + (MathRound(atr_stop_15*multiplicadorStop/tickerBase)*tickerBase));
|
|
//alvo_venda = (minima_do_dia-tickerBase) - (MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase);
|
|
|
|
ok = trade.SellStop(quantidadeContratos, minima_do_dia-adicionar_ticks, roteamento_symbol, valor_do_stop_venda, 0, ORDER_TIME_DAY, DataExpiracao(), NOME_ROBO);
|
|
enviou_ordem_de_venda = true;
|
|
jaDiminuiuUmaOrdemVenda = false; // chave para validar diminuição do contador de trades apenas 1 vez por ordem, quando remover ordem stop no on tick
|
|
n_ordens_enviadas++; //proteção envio massivo de ordens
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
Print("Ordem de VENDA SellStop enviada com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO1: VENDA, SellStop nao foi enviada");
|
|
}
|
|
}
|
|
else if (VerificarOrdensPosicoes())
|
|
{
|
|
if (VerificarOrdensPosicoes() && !vendidoMercado) {
|
|
FecharOrdensPendentesSellStopAtivo();
|
|
ok = trade.Sell(quantidadeContratos, roteamento_symbol, minima_do_dia-tickerBase, valor_do_stop_venda, 0, NOME_ROBO);
|
|
Print("O preço pulou o gatilho da venda, então o robô VENDEU A MERCADO");
|
|
enviou_ordem_de_venda = true;
|
|
jaDiminuiuUmaOrdemVenda = false;
|
|
n_ordens_enviadas++;
|
|
}
|
|
}
|
|
|
|
|
|
// //CRIA LINHA BREAKEVEN VENDA
|
|
// datetime barraDaVenda = iTime(_Symbol,PERIOD_CURRENT,0);
|
|
// ObjectCreate(
|
|
// 0, // ID de gráfico
|
|
// "vendinha", // Nome da linha
|
|
// OBJ_HLINE, // Tipo da linha
|
|
// 0, // Sub Window
|
|
// barraDaVenda, // Datetime do objeto
|
|
// minima_do_dia-adicionar_ticks // Preço
|
|
// );
|
|
// ObjectSetInteger(0,"vendinha",OBJPROP_STYLE,STYLE_DOT);
|
|
// ObjectSetInteger(0,"vendinha",OBJPROP_COLOR,clrRed);
|
|
//
|
|
//
|
|
// if (precoAtual <= minima_do_dia-adicionar_ticks) {
|
|
// ok = trade.Sell(quantidadeContratos, roteamento_symbol, 0, valor_do_stop_venda, 0, NOME_ROBO);
|
|
// Print("O robô VENDEU A MERCADO - Preço que tentou vender = " + DoubleToString(minima_do_dia-adicionar_ticks, _Digits));
|
|
// enviou_ordem_de_venda = true;
|
|
// jaDiminuiuUmaOrdemVenda = false;
|
|
// n_ordens_enviadas++;
|
|
// }
|
|
|
|
|
|
} else {
|
|
|
|
//deletar objeto linha horizontal
|
|
//if( ObjectFind(0,vendinha)>=0 ) ObjectDelete(0,vendinha);
|
|
|
|
}
|
|
|
|
if (inputMostrarComentarios == Sim_MostrarOsComentarios) {
|
|
string string_filtro_atr_diario = "";
|
|
if (inputAtrDiarioHabilitado == Habilitado_Atr_Diario) string_filtro_atr_diario = "\n Filtro Atr Diário em "+ (string)inputFiltroAtrDiarioXPontos + "pts, o ATR Diário está marcando " + DoubleToString(atr_diario_filtro_pts, _Digits) + "pts. Pode fazer trade? = " + (string)filtro_do_atr_diario_em_pontos;
|
|
Comment("marcou_primeira_barra = " + (string)marcou_primeira_barra,
|
|
"\nquantos_trades_fez_no_dia = (" + (string)quantos_trades_fez_no_dia + "/" + (string)inputMaximoTradesNoDia + ")" + " | marcou_contagem_trades = " + (string)marcou_contagem_trades,
|
|
"\ndesloc_primeira_barra_dia = " + (string)desloc_primeira_barra_dia,
|
|
"\nmedia_movel_pequena (" + (string)inputMMPequena + ") = " + DoubleToString(media_movel_pequena, _Digits),
|
|
"\nmedia_movel_media (" + (string)inputMMMedia + ") = " + DoubleToString(media_movel_media, _Digits),
|
|
"\nmedia_movel_grande (" + (string)inputMMGrande + ") = " + DoubleToString(media_movel_grande, _Digits),
|
|
"\natr_stop_15 = " + DoubleToString(atr_stop_15, _Digits),
|
|
"\natr_diario = " + DoubleToString(atr_diario, _Digits),
|
|
"\nmaxima_primeira_barra = " + DoubleToString(maxima_primeira_barra, _Digits),
|
|
"\nminima_primeira_barra = " + DoubleToString(minima_primeira_barra, _Digits),
|
|
"\n",
|
|
"\nfechamento_barra_anterior = " + DoubleToString(fechamento_barra_anterior, _Digits),
|
|
"\nmaxima_do_dia = " + DoubleToString(maxima_do_dia, _Digits),
|
|
"\nminima_do_dia = " + DoubleToString(minima_do_dia, _Digits),
|
|
"\ndiferenca_maxima_minima = " + DoubleToString(diferenca_maxima_minima, _Digits),
|
|
"\npercentual_atr_atingido = " + DoubleToString(percentual_atr_atingido, _Digits) + "% / " + (string)atingiu_atr_diario,
|
|
"\n",
|
|
"\nACCOUNT_BALANCE = " + DoubleToString(AccountInfoDouble(ACCOUNT_BALANCE), _Digits),
|
|
"\nR Pelo Balanco Da Conta = "+ (string)RPeloBalancoDaConta,
|
|
"\nmaxima_barra_rompeu = " + DoubleToString(maxima_barra_rompeu, _Digits),
|
|
"\ndiferenca_maxima_barra_rompeu = " + DoubleToString(diferenca_maxima_barra_rompeu, _Digits),
|
|
"\npercentual_barra_rompeu_maxima = " + DoubleToString(percentual_barra_rompeu_maxima, _Digits),
|
|
"\nminima_barra_rompeu = " + DoubleToString(minima_barra_rompeu, _Digits),
|
|
"\ndiferenca_minima_barra_rompeu = " + DoubleToString(diferenca_minima_barra_rompeu, _Digits),
|
|
"\npercentual_barra_rompeu_minima = " + DoubleToString(percentual_barra_rompeu_minima, _Digits),
|
|
"\n ja_passou_rompimento_maxima = ", ja_passou_rompimento_maxima,
|
|
"\n ja_passou_rompimento_minima = ", ja_passou_rompimento_minima,
|
|
"\nMathRound(atr_stop_15/5)*5) = " + (string)atr_stop_15,
|
|
//"\nPossível Entrada Compra= " + DoubleToString((maxima_do_dia+tickerBase), _Digits),
|
|
//"\nPossível Entrada Venda= " + DoubleToString((minima_do_dia-tickerBase), _Digits),
|
|
"\n ------ " +
|
|
"\nDiferença de ticks = " + DoubleToString(diferenca_entre_tickers, _Digits) + "pts / " + (string)diferenca_tickers_deixa_fazer_trade + " = deixa fazer trade" +
|
|
"\nprecoDeCompra = " + DoubleToString(precoDeCompra, _Digits),
|
|
"\nprecoDeVenda = " + DoubleToString(precoDeVenda, _Digits),
|
|
//"\nprecoDeVenda + 5 = " + DoubleToString(precoDeVenda+(tickerBase*3), _Digits),
|
|
//"\nprecoDeVenda + 5.0 = " + DoubleToString(precoDeVenda+(tickerBase*3), _Digits),
|
|
//"\nstop = " + DoubleToString((maxima_do_dia+1) - atr_stop_15, _Digits),
|
|
"\nBK Compra = " + DoubleToString((precoDeCompra) + (MathRound(atr_stop_15*breakeven_multiplicador/tickerBase)*tickerBase),_Digits),
|
|
"\nBK Venda = " + DoubleToString((precoDeVenda) - (MathRound(breakeven_multiplicador*atr_stop_15/tickerBase)*tickerBase),_Digits),
|
|
"\nAlvo Compra = " + string(MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase) + " pts -> " + DoubleToString(alvo_compra, _Digits),
|
|
"\nAlvo Venda = " + string(MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase) + " pts -> " + DoubleToString(alvo_venda, _Digits),
|
|
"\n ------ " +
|
|
"\nenviou_ordem_de_compra = " + (string)enviou_ordem_de_compra,
|
|
"\nenviou_ordem_de_venda = " + (string)enviou_ordem_de_venda,
|
|
string_filtro_atr_diario +
|
|
// "\nquantos_trades_fez_no_dia = " + (string)quantos_trades_fez_no_dia,
|
|
"\n",
|
|
"\n1 HorarioPermitidoAbrirPosicao= " + (string)HorarioPermitidoAbrirPosicao(),
|
|
"\n2 Filtro_tres_medias_compra= " + (string)(filtro_tres_medias_compra),
|
|
"\n3 !Atingiu_atr_diario= " + (string)!atingiu_atr_diario,
|
|
"\n4 Percentual_barra_rompeu_maxima = " + (string)(percentual_barra_rompeu_maxima >= inputPercentualRompimento),
|
|
"\n5 Enviou Ordem de Compra = " + (string)enviou_ordem_de_compra,
|
|
"\n6 Enviou Ordem de Venda= " + (string)enviou_ordem_de_venda,
|
|
"\n7 CompradoMercado= " + (string)compradoMercado,
|
|
"\n8 VendidoMercado= " + (string)vendidoMercado,
|
|
"\n" +
|
|
"\nquantidadeContratos = " + (string)quantidadeContratos +
|
|
"\n1 HorarioPermitidoAbrirPosicao= " + (string)HorarioPermitidoAbrirPosicao() +
|
|
"\n2 filtro_tres_medias_venda= " + (string)(filtro_tres_medias_venda) +
|
|
"\n3 !Atingiu_atr_diario= " + (string)!atingiu_atr_diario +
|
|
"\n4 percentual_barra_rompeu_minima = " + (string)(percentual_barra_rompeu_minima >= inputPercentualRompimento) + " VALOR percentual_barra_rompeu_minima = " + DoubleToString(percentual_barra_rompeu_minima, _Digits) +
|
|
"\n5 VALOR_NUMERO_MAGICO =" + (string)VALOR_NUMERO_MAGICO +
|
|
"\n6 !Enviou Ordem de Venda= " + (string)!enviou_ordem_de_venda +
|
|
"\n7 !CompradoMercado= " + (string)!compradoMercado +
|
|
"\n8 !VendidoMercado= " + (string)!vendidoMercado +
|
|
"\n9 !vendidoStop " + (string)!vendidoStop +
|
|
"\n10 (quantos_trades_fez_no_dia < inputMaximoTradesNoDia) = " + (string)(quantos_trades_fez_no_dia < inputMaximoTradesNoDia) +
|
|
"\n11 (quantLotesPosicaoVenda < quantidadeContratos) = " + (string)(quantLotesPosicaoVenda < quantidadeContratos) +
|
|
"\n12 podeTreidar = " + (string)podeTreidar
|
|
|
|
|
|
|
|
|
|
);
|
|
}
|
|
|
|
return (true);
|
|
}
|
|
|
|
|
|
|
|
//---
|
|
bool modificarOrdemStopDaPosicaoDeCompra()
|
|
{
|
|
double se_atingir_bk_compra = ((precoDeCompra) + (MathRound(breakeven_multiplicador*atr_stop_15/tickerBase)*tickerBase));
|
|
double precoNovoStopDaPosicaoDeCompra = (precoDeCompra-(tickerBase*2));
|
|
static bool passou_pela_logica_compra = false; // static
|
|
if (!compradoMercado) passou_pela_logica_compra = false;
|
|
|
|
//CRIA LINHA BREAKEVEN COMPRA
|
|
datetime barraDoBreakevenCompra = iTime(_Symbol,PERIOD_CURRENT,0);
|
|
ObjectCreate(
|
|
0, // ID de gráfico
|
|
"breakevenlineCompra1", // Nome da linha
|
|
OBJ_HLINE, // Tipo da linha
|
|
0, // Sub Window
|
|
barraDoBreakevenCompra, // Datetime do objeto
|
|
se_atingir_bk_compra // Preço
|
|
);
|
|
|
|
ObjectSetInteger(0,"breakevenlineCompra1",OBJPROP_STYLE,STYLE_DOT);
|
|
ObjectSetInteger(0,"breakevenlineCompra1",OBJPROP_COLOR,clrBlue);
|
|
|
|
//LÓGICA ORDEM STOP BREAKEVEN
|
|
|
|
if (precoDeCompra != 0)
|
|
{
|
|
if((tick.last >= se_atingir_bk_compra) && !passou_pela_logica_compra)
|
|
{
|
|
passou_pela_logica_compra = true;
|
|
|
|
int positionsTotal = PositionsTotal();
|
|
|
|
for(int i=0; i < positionsTotal && !IsStopped(); i++)
|
|
{
|
|
ulong posTicket = PositionGetTicket(i);
|
|
|
|
if(PositionSelectByTicket(posTicket))
|
|
{
|
|
ulong posMagic = PositionGetInteger(POSITION_MAGIC);
|
|
|
|
string posSymbol = PositionGetString(POSITION_SYMBOL);
|
|
|
|
ENUM_POSITION_TYPE posType = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
|
|
|
|
if(inputModoConta == mcNETTING)
|
|
{
|
|
if(posSymbol == roteamento_symbol)
|
|
{
|
|
if(posType == POSITION_TYPE_BUY)
|
|
{
|
|
bool ok = trade.PositionModify(posTicket, precoNovoStopDaPosicaoDeCompra, 0);
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
Print("AQUIIIII - Ordem de STOP da Posição de Compra foi modificada para o BreakEven COMPRA");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao mofidicar a Ordem Stop para o BreakEven " + roteamento_symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar a modificação da Ordem de STOP da compra do ativo para o BreakEven " + roteamento_symbol);
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(posSymbol == roteamento_symbol && posMagic == VALOR_NUMERO_MAGICO)
|
|
{
|
|
if(posType == POSITION_TYPE_BUY ) //Talvez adicionar ordem BUY STOP
|
|
{
|
|
bool ok = trade.PositionModify(posTicket, precoNovoStopDaPosicaoDeCompra, 0);
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
//modificouOrdemStop = 1;
|
|
Print("Ordem de STOP da Posição de Compra foi modificada para o BreakEven");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao mofidicar a Ordem Stop para o BreakEven " + roteamento_symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar a modificação da Ordem de STOP da compra do ativo para o BreakEven " + roteamento_symbol);
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//---
|
|
bool modificarOrdemStopDaPosicaoDeVenda()
|
|
{
|
|
|
|
double se_atingir_bk = ((precoDeVenda) - (MathRound(breakeven_multiplicador*atr_stop_15/tickerBase)*tickerBase));
|
|
double precoNovoStopDaPosicaoDeVenda = (precoDeVenda+(tickerBase*2));
|
|
static bool passou_pela_logica = false;
|
|
if (!vendidoMercado) passou_pela_logica = false;
|
|
|
|
//CRIA LINHA BREAKEVEN COMPRA
|
|
datetime barraDoBreakevenVenda = iTime(_Symbol,PERIOD_CURRENT,0);
|
|
|
|
ObjectCreate(
|
|
0, // ID de gráfico
|
|
"breakevenlineVenda1", // Nome da linha
|
|
OBJ_HLINE, // Tipo da linha
|
|
0, // Sub Window
|
|
barraDoBreakevenVenda, // Datetime do objeto
|
|
se_atingir_bk // Preço
|
|
);
|
|
|
|
ObjectSetInteger(0,"breakevenlineVenda1",OBJPROP_STYLE,STYLE_DOT);
|
|
ObjectSetInteger(0,"breakevenlineVenda1",OBJPROP_COLOR,clrBlue);
|
|
|
|
//LÓGICA ORDEM STOP BREAKEVEN
|
|
if (precoDeVenda != 0) {
|
|
if((tick.last <= se_atingir_bk) && !passou_pela_logica)
|
|
{
|
|
passou_pela_logica = true;
|
|
|
|
int positionsTotal = PositionsTotal();
|
|
|
|
for(int i=0; i < positionsTotal && !IsStopped(); i++)
|
|
{
|
|
|
|
ulong posTicket = PositionGetTicket(i);
|
|
|
|
if(PositionSelectByTicket(posTicket))
|
|
{
|
|
ulong posMagic = PositionGetInteger(POSITION_MAGIC);
|
|
|
|
string posSymbol = PositionGetString(POSITION_SYMBOL);
|
|
|
|
ENUM_POSITION_TYPE posType = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
|
|
|
|
if(inputModoConta == mcNETTING)
|
|
{
|
|
if(posSymbol == roteamento_symbol)
|
|
{
|
|
if(posType == POSITION_TYPE_SELL ) //Talvez adicionar ordem SELL STOP
|
|
{
|
|
bool ok = trade.PositionModify(posTicket, precoNovoStopDaPosicaoDeVenda, 0);
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
//modificouOrdemStop = 1;
|
|
Print("Ordem de STOP da Posição de Venda foi modificada para o BreakEven");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao mofidicar a Ordem Stop para o BreakEven " + roteamento_symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar a modificação da Ordem de STOP da compra do ativo para o BreakEven " + roteamento_symbol);
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(posSymbol == roteamento_symbol && posMagic == VALOR_NUMERO_MAGICO)
|
|
{
|
|
if(posType == POSITION_TYPE_SELL)
|
|
{
|
|
bool ok = trade.PositionModify(posTicket, precoNovoStopDaPosicaoDeVenda, 0);
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
//modificouOrdemStop = 1;
|
|
Print("Ordem de STOP da Posição de Venda foi modificada para o BreakEven");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao mofidicar a Ordem Stop para o BreakEven " + roteamento_symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar a modificação da Ordem de STOP da compra do ativo para o BreakEven " + roteamento_symbol);
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//---
|
|
//bool FecharPosicoesContaHedge() {
|
|
//
|
|
// //+----------------------------------------------------------------+
|
|
// //| SE TIVER UMA COMPRA E VENDA POSICIONADAS, FECHA UMA PELA OUTRA |
|
|
// //+----------------------------------------------------------------+
|
|
// if (inputModoConta == mcHEDGING) {
|
|
// if (compradoMercado && vendidoMercado && (quantLotesVenda == quantLotesPosicaoVenda)) {
|
|
// bool ok = trade.PositionCloseBy(ticketCompradoMercado, ticketVendidoMercado);
|
|
//
|
|
// if (ok) {
|
|
// if (trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009) {
|
|
// Print("O robô " + NOME_ROBO + " executou a ZERAGEM TOTAL das " + valorTravadoQtdAcoesComprou + " açoes que deveria comprar, do ativo " + _Symbol);
|
|
// } else {
|
|
// Print("ERRO: Retorno inesperado do servidor (trade.PositionCloseBy)");
|
|
//
|
|
// return(false);
|
|
// }
|
|
// } else {
|
|
// Print("ERRO: Erro ao enviar trade.PositionCloseBy");
|
|
//
|
|
// return(false);
|
|
// }
|
|
// }
|
|
// /*
|
|
// else if (compradoMercado && vendidoMercado && (quantLotesVenda > quantLotesPosicaoVenda)) {
|
|
// bool ok = trade.PositionClosePartial(_Symbol, quantLotesPosicaoVenda, 0);
|
|
//
|
|
// if (ok) {
|
|
// if (trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009) {
|
|
// Print("O robô " + NOME_ROBO + " executou a ZERAGEM PARCIAL de " + quantLotesPosicaoVenda + " de " + valorTravadoQtdAcoesComprou + " açoes do ativo " + _Symbol);
|
|
// } else {
|
|
// Print("ERRO: Retorno inesperado do servidor (trade.PositionClosePartial)");
|
|
//
|
|
// return(false);
|
|
// }
|
|
// } else {
|
|
// Print("ERRO: Erro ao enviar trade.PositionClosePartial");
|
|
//
|
|
// return(false);
|
|
// }
|
|
//
|
|
// }
|
|
// */
|
|
// }
|
|
//
|
|
// return true;
|
|
//}
|
|
|
|
//--- Medias Móveis e ATR
|
|
bool MediasEAtr()
|
|
{
|
|
|
|
//---MA
|
|
int MediaMovelPequenaHandler = INVALID_HANDLE;
|
|
int MediaMovelMediaHandler = INVALID_HANDLE;
|
|
int MediaMovelGrandeHandler = INVALID_HANDLE;
|
|
int MediaMovelTralingStopHandler = INVALID_HANDLE;
|
|
int atrHandler = INVALID_HANDLE;
|
|
int atrDiarioHandler = INVALID_HANDLE;
|
|
int atrDiarioFiltroPtsHandler = INVALID_HANDLE;
|
|
|
|
double MediaMovelPequenaBuffer[];
|
|
double MediaMovelMediaBuffer[];
|
|
double MediaMovelGrandeBuffer[];
|
|
double MediaMovelTralingStopBuffer[];
|
|
double atrBuffer[];
|
|
double atrDiarioBuffer[];
|
|
double atrDiarioFiltroPtsBuffer[];
|
|
|
|
ArraySetAsSeries(MediaMovelPequenaBuffer, true);
|
|
ArraySetAsSeries(MediaMovelMediaBuffer, true);
|
|
ArraySetAsSeries(MediaMovelGrandeBuffer, true);
|
|
ArraySetAsSeries(MediaMovelTralingStopBuffer, true);
|
|
ArraySetAsSeries(atrBuffer, true);
|
|
ArraySetAsSeries(atrDiarioBuffer, true);
|
|
ArraySetAsSeries(atrDiarioFiltroPtsBuffer, true);
|
|
|
|
string simbolo_media_grande = "WIN$N";
|
|
string simbolo_media_media = "WIN$N";
|
|
string simbolo_ATR = "WIN$N";
|
|
roteamento_symbol = "";
|
|
|
|
|
|
|
|
if (inputTipoContrato == IndiceCheio) {
|
|
simbolo_media_grande = "IND$N";
|
|
simbolo_media_media = "IND$N";
|
|
simbolo_ATR = "IND$N";
|
|
roteamento_symbol = inputQualTickerAtivo;
|
|
} else if (inputTipoContrato == MiniIndice) {
|
|
simbolo_media_grande = "WIN$N";
|
|
simbolo_media_media = "WIN$N";
|
|
simbolo_ATR = "WIN$N";
|
|
roteamento_symbol = inputQualTickerAtivo;
|
|
} else if (inputTipoContrato == MiniDolar) {
|
|
simbolo_media_grande = "WDO$N";
|
|
simbolo_media_media = "WDO$N";
|
|
simbolo_ATR = "WDO$N";
|
|
roteamento_symbol = inputQualTickerAtivo;
|
|
} else if (inputTipoContrato == DolarCheio) {
|
|
simbolo_media_grande = "DOL$N";
|
|
simbolo_media_media = "DOL$N";
|
|
simbolo_ATR = "DOL$N";
|
|
roteamento_symbol = inputQualTickerAtivo;
|
|
} else {
|
|
simbolo_media_grande = _Symbol;
|
|
simbolo_media_media = _Symbol;
|
|
simbolo_ATR = _Symbol;
|
|
roteamento_symbol = _Symbol;
|
|
}
|
|
|
|
|
|
////---AQUI DEFINE QUAL ATIVO VAI OPERAR
|
|
//if (inputCrossOrder == Mini_Indice) {
|
|
//roteamento_symbol = _Symbol;
|
|
//} else if (inputCrossOrder == Ativa_CrossOrder_Indice) {
|
|
//roteamento_symbol = _Symbol;
|
|
//} else if (inputCrossOrder == Ativa_CrossOrder_Dolar) {
|
|
//roteamento_symbol = _Symbol;
|
|
//}
|
|
|
|
//---
|
|
|
|
MediaMovelPequenaHandler = iMA(_Symbol, PERIOD_CURRENT, inputMMPequena, 0, MODE_EMA, PRICE_CLOSE);
|
|
MediaMovelMediaHandler = iMA(simbolo_media_media, PERIOD_CURRENT, inputMMMedia, 0, MODE_EMA, PRICE_CLOSE);
|
|
MediaMovelGrandeHandler = iMA(simbolo_media_grande, PERIOD_CURRENT, inputMMGrande, 0, MODE_EMA, PRICE_CLOSE);
|
|
MediaMovelTralingStopHandler = iMA(_Symbol, PERIOD_CURRENT, inputMMTralingStop, 0, MODE_EMA, PRICE_CLOSE);
|
|
atrHandler = iATR(simbolo_ATR, PERIOD_M15, inputValorATR);
|
|
atrDiarioHandler = iATR(simbolo_ATR, PERIOD_D1, 20);
|
|
atrDiarioFiltroPtsHandler = iATR(simbolo_ATR, PERIOD_D1, inputFiltroAtrDiarioXPeriodos);
|
|
|
|
if(MediaMovelPequenaHandler != INVALID_HANDLE)
|
|
CopyBuffer(MediaMovelPequenaHandler, 0, 0, 2, MediaMovelPequenaBuffer);
|
|
if(MediaMovelMediaHandler != INVALID_HANDLE)
|
|
CopyBuffer(MediaMovelMediaHandler, 0, 0, 2, MediaMovelMediaBuffer);
|
|
if(MediaMovelGrandeHandler != INVALID_HANDLE)
|
|
CopyBuffer(MediaMovelGrandeHandler, 0, 0, 2, MediaMovelGrandeBuffer);
|
|
if(MediaMovelTralingStopHandler != INVALID_HANDLE)
|
|
CopyBuffer(MediaMovelTralingStopHandler, 0, 0, 2, MediaMovelTralingStopBuffer);
|
|
if(atrHandler != INVALID_HANDLE)
|
|
CopyBuffer(atrHandler, 0, 0, 2, atrBuffer);
|
|
if(atrDiarioHandler != INVALID_HANDLE)
|
|
CopyBuffer(atrDiarioHandler, 0, 0, 2, atrDiarioBuffer);
|
|
if(atrDiarioHandler != INVALID_HANDLE)
|
|
CopyBuffer(atrDiarioFiltroPtsHandler, 0, 0, 5, atrDiarioFiltroPtsBuffer);
|
|
|
|
media_movel_pequena = NormalizeDouble(MediaMovelPequenaBuffer[0], _Digits);
|
|
media_movel_media = NormalizeDouble(MediaMovelMediaBuffer[0], _Digits);
|
|
media_movel_grande = NormalizeDouble(MediaMovelGrandeBuffer[0], _Digits);
|
|
media_movel_tralingstop = NormalizeDouble(MediaMovelTralingStopBuffer[1], _Digits);
|
|
atr_stop_15 = NormalizeDouble(atrBuffer[0], _Digits);
|
|
atr_diario = NormalizeDouble(atrDiarioBuffer[0], _Digits);
|
|
atr_diario_filtro_pts = NormalizeDouble(atrDiarioFiltroPtsBuffer[1], _Digits);
|
|
|
|
|
|
ChartIndicatorAdd(0,0,MediaMovelPequenaHandler);
|
|
ChartIndicatorAdd(0,0,MediaMovelMediaHandler);
|
|
ChartIndicatorAdd(0,0,MediaMovelGrandeHandler);
|
|
|
|
//adicionando e removendo o atr do gráfico
|
|
static bool habilitou_atr = false;
|
|
if (inputAtrDiarioHabilitado == Habilitado_Atr_Diario && !habilitou_atr) {
|
|
ChartIndicatorAdd(0,1,atrDiarioFiltroPtsHandler);
|
|
habilitou_atr = true;
|
|
}
|
|
if (inputAtrDiarioHabilitado == Desabilitado_Atr_Diario && habilitou_atr) {
|
|
habilitou_atr = false;
|
|
RemoverIndicadores();
|
|
}
|
|
|
|
|
|
//DELETAR A MME DO TRALINGSTOP CASO O TRALLINGSTOP SEJA DESATIVADO
|
|
static bool removeu_indicador = false;
|
|
if (inputTralingStop == Ativa_TralingStop) {
|
|
ChartIndicatorAdd(0,0,MediaMovelTralingStopHandler);
|
|
removeu_indicador = false;
|
|
} else if ( (inputTralingStop == Desativa_TralingStop) && !removeu_indicador) {
|
|
RemoverIndicadores();
|
|
removeu_indicador = true;
|
|
}
|
|
|
|
//if (!ChartIndicatorAdd(0,0,MediaMovelPequenaHandler)) Print("Erro ao adicionar a Média de " + inputMMPequena + " no gráfico");
|
|
//if (!ChartIndicatorAdd(0,0,MediaMovelMediaHandler)) Print("Erro ao adicionar a Média de " + inputMMMedia + " no gráfico");
|
|
//if (!ChartIndicatorAdd(0,0,MediaMovelGrandeHandler)) Print("Erro ao adicionar a Média de " + inputMMGrande + " no gráfico");
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
//---
|
|
bool VerificarInputs()
|
|
{
|
|
|
|
Print("NOME_NUMERO_MAGICO = ", NOME_NUMERO_MAGICO);
|
|
Print("VALOR_NUMERO_MAGICO = ", VALOR_NUMERO_MAGICO);
|
|
|
|
if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
|
|
{
|
|
Print("ERRO: Verifique se a negociação automatizada é permitida nas configurações do terminal!");
|
|
return false;
|
|
}
|
|
|
|
if(!MQLInfoInteger(MQL_TRADE_ALLOWED))
|
|
{
|
|
Print("ERRO: A negociação automatizada é proibida nas configurações do Robô!");
|
|
return false;
|
|
}
|
|
|
|
|
|
if(inputModoConta == mcHEDGING)
|
|
{
|
|
if(GlobalVariableCheck(NOME_NUMERO_MAGICO))
|
|
{
|
|
double valor = GlobalVariableGet(NOME_NUMERO_MAGICO);
|
|
//Print("valor = " + valor);
|
|
if(valor != 0 && valor != VALOR_NUMERO_MAGICO)
|
|
{
|
|
//Print("ERRO: Número Mágico incorreto!");
|
|
|
|
//return false;
|
|
}
|
|
|
|
//return true;
|
|
}
|
|
else
|
|
GlobalVariableSet(NOME_NUMERO_MAGICO, VALOR_NUMERO_MAGICO);
|
|
}
|
|
|
|
if(inputModoConta == mcNETTING && modoConta != ACCOUNT_MARGIN_MODE_RETAIL_NETTING)
|
|
{
|
|
Print(modoConta);
|
|
Print("ERRO: Este robô só poderá ser executado em conta !HEDGING!");
|
|
return false;
|
|
}
|
|
|
|
if(inputModoConta == mcHEDGING && modoConta != ACCOUNT_MARGIN_MODE_RETAIL_HEDGING)
|
|
{
|
|
Print(modoConta);
|
|
Print("ERRO: Este robô só poderá ser executado em conta NETTING");
|
|
return false;
|
|
}
|
|
|
|
if (inputQualTickerAtivo == "") {
|
|
Print("ERRO: Defina o ticker que será operado!!");
|
|
return false;
|
|
}
|
|
|
|
//if(inputQuantidadeContratos == 0) // AQUI talvez se colocar os lotes baseado em R pode Travar o robo no replay
|
|
// {
|
|
// Print("ERRO: É obrigatótio informar a Quantidade de Contratos!");
|
|
// return false;
|
|
// }
|
|
|
|
Print("Seja Bem Vindo! Eu sou o escravo da @ Gestão Trader. v2 ");
|
|
Print("Acomode-se e aproveite a viagem. ");
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|
|
//---
|
|
bool RemoverIndicadores()
|
|
{
|
|
int subWindows = (int) ChartGetInteger(0, CHART_WINDOWS_TOTAL);
|
|
|
|
for(int i = subWindows-1; i>=0; i--)
|
|
{
|
|
int inds = ChartIndicatorsTotal(0,i);
|
|
|
|
if(inds >= 1)
|
|
{
|
|
for(int j = inds; j >= 0; j--)
|
|
{
|
|
string indName = ChartIndicatorName(0, i, j);
|
|
|
|
ChartIndicatorDelete(0, i, indName);
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//---
|
|
datetime DataExpiracao()
|
|
{
|
|
MqlRates barraAtuala[];
|
|
|
|
CopyRates(_Symbol, PERIOD_D1, 0, 1, barraAtuala);
|
|
|
|
return barraAtuala[0].time + 86399; //'23:59:59'
|
|
}
|
|
|
|
|
|
//---
|
|
int SeAtivoSaiuDoLeilaoMarcarPrimeiraBarra()
|
|
{
|
|
|
|
static int contagem_de_barras = 0;
|
|
static bool rodei_o_looping = false;
|
|
|
|
static bool virou_alguma_barra_1_minuto = false;
|
|
if(NovoDia() || (contagem_de_barras == 0))
|
|
{
|
|
virou_alguma_barra_1_minuto = false;
|
|
rodei_o_looping = false;
|
|
contagem_de_barras = 0;
|
|
}
|
|
if(NovaBarra1Minuto() && !virou_alguma_barra_1_minuto)
|
|
virou_alguma_barra_1_minuto = true;
|
|
|
|
if(!rodei_o_looping) //para backtestar a funcao com gráfico parado
|
|
{
|
|
//if (virou_alguma_barra_1_minuto && !rodei_o_looping) {
|
|
|
|
datetime hoje = iTime(_Symbol,PERIOD_CURRENT,0);
|
|
MqlDateTime hoje_struct, barra;
|
|
TimeToStruct(hoje,hoje_struct);
|
|
|
|
int dia_hoje = (int)hoje_struct.day;
|
|
int barra_atual = (int)barra.day;
|
|
|
|
for(int i=1; i<200; i++)
|
|
{
|
|
datetime numero_barras_5_minutos = iTime(_Symbol,PERIOD_CURRENT,i);
|
|
MqlDateTime numero_barras_5_minutos_struct;
|
|
TimeToStruct(numero_barras_5_minutos,numero_barras_5_minutos_struct);
|
|
|
|
int dia_da_contagem_barras = (int)numero_barras_5_minutos_struct.day;
|
|
|
|
if(dia_da_contagem_barras == dia_hoje)
|
|
contagem_de_barras++;
|
|
}
|
|
|
|
//Print("contagem_de_barras = ", contagem_de_barras);
|
|
rodei_o_looping = true;
|
|
|
|
}
|
|
|
|
return (contagem_de_barras);
|
|
|
|
}
|
|
|
|
//---
|
|
bool NovaBarra1Minuto()
|
|
{
|
|
static datetime ultimaHora = 0;
|
|
datetime ultimaHoraBarra = (datetime) SeriesInfoInteger(_Symbol, PERIOD_M1, SERIES_LASTBAR_DATE);
|
|
if(ultimaHora == 0)
|
|
{
|
|
ultimaHora = ultimaHoraBarra;
|
|
return false;
|
|
}
|
|
if(ultimaHora != ultimaHoraBarra)
|
|
{
|
|
ultimaHora = ultimaHoraBarra;
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//---
|
|
bool NovoDia()
|
|
{
|
|
static datetime today;
|
|
|
|
if(today != iTime(_Symbol, PERIOD_D1, 0))
|
|
{
|
|
today = iTime(_Symbol, PERIOD_D1, 0);
|
|
|
|
//Print("É um novo dia: ", TimeToString(today));
|
|
|
|
return true;
|
|
}
|
|
else //Print("Não é um novo dia!");
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//---
|
|
bool HorarioPermitidoAbrirPosicao()
|
|
{
|
|
|
|
string horaInicialAbrirPosicao = inputHoraInicialAbrirPosicao; //Aqui Seta o Horário que o robô vai começar a operar
|
|
string horaLimiteComprar = inputHoraLimiteAbrirPosicao; //Aqui Seta o Horário que o robô vai parar de fazer entradas/operar
|
|
|
|
MqlDateTime horaAtual, horarioLimiteAbrirPosicao, horarioInicialAbrirPosicao;
|
|
|
|
TimeToStruct(TimeCurrent(), horaAtual);
|
|
TimeToStruct(StringToTime(horaLimiteComprar), horarioLimiteAbrirPosicao);
|
|
TimeToStruct(StringToTime(horaInicialAbrirPosicao), horarioInicialAbrirPosicao);
|
|
|
|
if((horarioInicialAbrirPosicao.hour == horarioLimiteAbrirPosicao.hour) && (horaAtual.hour == horarioInicialAbrirPosicao.hour) && (horaAtual.min >= horarioInicialAbrirPosicao.min) && (horaAtual.min <= horarioLimiteAbrirPosicao.min))
|
|
return true;
|
|
if((horarioInicialAbrirPosicao.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour == horarioInicialAbrirPosicao.hour) && (horaAtual.min >= horarioInicialAbrirPosicao.min))
|
|
return true;
|
|
if((horarioInicialAbrirPosicao.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour != horarioInicialAbrirPosicao.hour) && (horaAtual.hour > horarioInicialAbrirPosicao.hour) && (horaAtual.hour < horarioLimiteAbrirPosicao.hour))
|
|
return true;
|
|
if((horarioInicialAbrirPosicao.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour == horarioLimiteAbrirPosicao.hour) && (horaAtual.min <= horarioLimiteAbrirPosicao.min))
|
|
return true;
|
|
if(horarioInicialAbrirPosicao.hour > horarioLimiteAbrirPosicao.hour)
|
|
{
|
|
|
|
FecharOrdensPendentesCompraDoAtivo(); // Por ever | Fecha ordens stop pendentes COMPRA após o almoço
|
|
FecharOrdensPendentesVendaDoAtivo(); // Por ever | Fecha ordens stop pendentes COMPRA após o almoço
|
|
|
|
ExpertRemove();
|
|
|
|
Print("ERRO: Os horários fornecidos estão inválidos!");
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//---
|
|
bool HorarioNoveECinco() {
|
|
string horaInicialAbrirPosicao = "09:05"; //Aqui Seta o Horário que o robô vai começar a operar
|
|
string horaLimiteComprar = "17:55"; //Aqui Seta o Horário que o robô vai parar de fazer entradas/operar
|
|
|
|
MqlDateTime horaAtual, horarioLimiteAbrirPosicao, horarioInicialAbrirPosicao;
|
|
|
|
TimeToStruct(TimeCurrent(), horaAtual);
|
|
TimeToStruct(StringToTime(horaLimiteComprar), horarioLimiteAbrirPosicao);
|
|
TimeToStruct(StringToTime(horaInicialAbrirPosicao), horarioInicialAbrirPosicao);
|
|
|
|
if ((horarioInicialAbrirPosicao.hour == horarioLimiteAbrirPosicao.hour) && (horaAtual.hour == horarioInicialAbrirPosicao.hour) && (horaAtual.min >= horarioInicialAbrirPosicao.min) && (horaAtual.min <= horarioLimiteAbrirPosicao.min)) return true;
|
|
if ((horarioInicialAbrirPosicao.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour == horarioInicialAbrirPosicao.hour) && (horaAtual.min >= horarioInicialAbrirPosicao.min)) return true;
|
|
if ((horarioInicialAbrirPosicao.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour != horarioInicialAbrirPosicao.hour) && (horaAtual.hour > horarioInicialAbrirPosicao.hour) && (horaAtual.hour < horarioLimiteAbrirPosicao.hour)) return true;
|
|
if ((horarioInicialAbrirPosicao.hour != horarioLimiteAbrirPosicao.hour) && (horaAtual.hour == horarioLimiteAbrirPosicao.hour) && (horaAtual.min <= horarioLimiteAbrirPosicao.min)) return true;
|
|
|
|
return false;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
|
|
|
|
|
|
//---
|
|
bool HorarioFechamentoPregaoTodasOrdens()
|
|
{
|
|
string hora = inputHorarioVerao;
|
|
|
|
MqlDateTime horaAtual, horarioLimiteFecharOrdem;
|
|
TimeToStruct(TimeCurrent(), horaAtual);
|
|
TimeToStruct(StringToTime(hora), horarioLimiteFecharOrdem);
|
|
|
|
//Print("horarioFechamentoPregao = " + horarioLimiteFecharOrdem.day + "/" + horarioLimiteFecharOrdem.mon + "/" + horarioLimiteFecharOrdem.year + " " + horarioLimiteFecharOrdem.hour + ":" + horarioLimiteFecharOrdem.min);
|
|
|
|
if(horaAtual.hour > horarioLimiteFecharOrdem.hour)
|
|
return true;
|
|
if((horaAtual.hour == horarioLimiteFecharOrdem.hour) && (horaAtual.min >= horarioLimiteFecharOrdem.min))
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool HorarioFechamentoPregaoTodasOrdens2() {
|
|
|
|
|
|
ushort hora1 = StringGetCharacter(inputHorarioVerao,0);
|
|
ushort hora2 = StringGetCharacter(inputHorarioVerao,1);
|
|
ushort min1 = StringGetCharacter(inputHorarioVerao,3);
|
|
ushort min2 = StringGetCharacter(inputHorarioVerao,4);
|
|
string valor_hora1 = ShortToString(hora1);
|
|
string valor_hora2 = ShortToString(hora2);
|
|
string valor_min1 = ShortToString(min1);
|
|
string valor_min2 = ShortToString(min2);
|
|
|
|
uint HoraInicial_ = uint(valor_hora1 + valor_hora2);
|
|
uint MinInicial_ = uint(valor_min1 + valor_min2);
|
|
uint HoraFinal_ = 18;
|
|
uint MinFinal_ = 00;
|
|
|
|
// StringSubstr -> proibido !!! -> torna o backtest extremamente lento !!!
|
|
MqlRates dailyBar[];
|
|
int copied = CopyRates(_Symbol,PERIOD_D1,0,1,dailyBar);
|
|
if(copied==1)
|
|
{
|
|
// datetime dateStart = dailyBar[0].time; // '2019.11.15 00:00:00'
|
|
datetime tempoInicial = dailyBar[0].time + (HoraInicial_*60*60) + (MinInicial_*60);
|
|
datetime tempoFinal = dailyBar[0].time + (HoraFinal_*60*60) + (MinFinal_*60);
|
|
datetime timeNow = TimeCurrent();
|
|
//
|
|
if( timeNow>=tempoInicial && timeNow<tempoFinal )
|
|
{
|
|
return(true);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
return(false);
|
|
}
|
|
//
|
|
return(false);
|
|
|
|
}
|
|
|
|
//---
|
|
bool FecharPosicaoAbertas()
|
|
{
|
|
int positionsTotal = PositionsTotal();
|
|
|
|
for(int i = 0; i < positionsTotal && !IsStopped(); i++)
|
|
{
|
|
ulong posTicket = PositionGetTicket(i);
|
|
|
|
if(PositionSelectByTicket(posTicket))
|
|
{
|
|
ulong posMagic = PositionGetInteger(POSITION_MAGIC);
|
|
|
|
string posSymbol = PositionGetString(POSITION_SYMBOL);
|
|
|
|
ENUM_POSITION_TYPE posType = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
|
|
|
|
// já tenho posição com meu magic number
|
|
//if(posSymbol == _Symbol && posMagic == VALOR_NUMERO_MAGICO) {
|
|
if(inputModoConta == mcNETTING)
|
|
{
|
|
if(posSymbol == roteamento_symbol)
|
|
{
|
|
if(posType == POSITION_TYPE_BUY || posType == POSITION_TYPE_SELL)
|
|
{
|
|
FecharPosicao(posTicket, posType == POSITION_TYPE_BUY ? true : false);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(posSymbol == roteamento_symbol && posMagic == VALOR_NUMERO_MAGICO)
|
|
{
|
|
if(posType == POSITION_TYPE_BUY || posType == POSITION_TYPE_SELL)
|
|
{
|
|
FecharPosicao(posTicket, posType == POSITION_TYPE_BUY ? true : false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
|
|
//---
|
|
bool FecharOrdensPendentesVendaDoAtivo()
|
|
{
|
|
int ordersTotal = OrdersTotal();
|
|
|
|
for(int i=0; i < ordersTotal && !IsStopped(); i++)
|
|
{
|
|
ulong orderTicket = OrderGetTicket(i);
|
|
|
|
if(OrderSelect(orderTicket))
|
|
{
|
|
ulong orderMagic = OrderGetInteger(ORDER_MAGIC);
|
|
|
|
string orderSymbol = OrderGetString(ORDER_SYMBOL);
|
|
|
|
ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
|
|
|
|
if(inputModoConta == mcNETTING)
|
|
{
|
|
if(orderSymbol == roteamento_symbol)
|
|
{
|
|
if(orderType == ORDER_TYPE_SELL_LIMIT || ORDER_TYPE_SELL_STOP ) // Ever adicionou BUY STOP || ORDER_TYPE_SELL_STOP
|
|
{
|
|
bool ok = trade.OrderDelete(orderTicket);
|
|
Print(" Fechou a ordem por FecharOrdensPendentesVendaDoAtivo() ");
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
//Print("Ordem de VENDA PENDENTE excluida com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
|
|
{
|
|
if(orderType == ORDER_TYPE_SELL_LIMIT)
|
|
{
|
|
bool ok = trade.OrderDelete(orderTicket);
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
//Print("Ordem de VENDA PENDENTE excluida com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//---
|
|
bool FecharOrdensPendentesCompraDoAtivo()
|
|
{
|
|
int ordersTotal = OrdersTotal();
|
|
|
|
for(int i=0; i < ordersTotal && !IsStopped(); i++)
|
|
{
|
|
ulong orderTicket = OrderGetTicket(i);
|
|
|
|
if(OrderSelect(orderTicket))
|
|
{
|
|
ulong orderMagic = OrderGetInteger(ORDER_MAGIC);
|
|
|
|
string orderSymbol = OrderGetString(ORDER_SYMBOL);
|
|
|
|
ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
|
|
|
|
if(inputModoConta == mcNETTING)
|
|
{
|
|
if(orderSymbol == roteamento_symbol)
|
|
{
|
|
if(orderType == ORDER_TYPE_BUY_LIMIT || ORDER_TYPE_BUY_STOP ) // Ever adicionou BUY STOP || ORDER_TYPE_BUY_STOP
|
|
{
|
|
bool ok = trade.OrderDelete(orderTicket);
|
|
Print(" Fechou a ordem por FecharOrdensPendentesCompraDoAtivo() ");
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
//Print("Ordem de VENDA PENDENTE excluida com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
|
|
{
|
|
if(orderType == ORDER_TYPE_BUY_LIMIT)
|
|
{
|
|
bool ok = trade.OrderDelete(orderTicket);
|
|
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
//Print("Ordem de VENDA PENDENTE excluida com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//---
|
|
bool FecharOrdensPendentesVendaDoAtivo2()
|
|
{
|
|
int ordersTotal = OrdersTotal();
|
|
|
|
for(int i=0; i < ordersTotal && !IsStopped(); i++)
|
|
{
|
|
ulong orderTicket = OrderGetTicket(i);
|
|
|
|
if(OrderSelect(orderTicket))
|
|
{
|
|
ulong orderMagic = OrderGetInteger(ORDER_MAGIC);
|
|
|
|
string orderSymbol = OrderGetString(ORDER_SYMBOL);
|
|
|
|
ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
|
|
|
|
if(inputModoConta == mcNETTING)
|
|
{
|
|
if(orderSymbol == roteamento_symbol)
|
|
{
|
|
if(orderType == ORDER_TYPE_SELL_LIMIT) // Ever adicionou BUY STOP || ORDER_TYPE_SELL_STOP
|
|
{
|
|
bool ok = trade.OrderDelete(orderTicket);
|
|
Print(" Fechou a ordem por FecharOrdensPendentesVendaDoAtivo2() ");
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
//Print("Ordem de VENDA PENDENTE excluida com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
|
|
{
|
|
if(orderType == ORDER_TYPE_SELL_LIMIT)
|
|
{
|
|
bool ok = trade.OrderDelete(orderTicket);
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
//Print("Ordem de VENDA PENDENTE excluida com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//---
|
|
bool FecharOrdensPendentesCompraDoAtivo2()
|
|
{
|
|
int ordersTotal = OrdersTotal();
|
|
|
|
for(int i=0; i < ordersTotal && !IsStopped(); i++)
|
|
{
|
|
ulong orderTicket = OrderGetTicket(i);
|
|
|
|
if(OrderSelect(orderTicket))
|
|
{
|
|
ulong orderMagic = OrderGetInteger(ORDER_MAGIC);
|
|
|
|
string orderSymbol = OrderGetString(ORDER_SYMBOL);
|
|
|
|
ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
|
|
|
|
if(inputModoConta == mcNETTING)
|
|
{
|
|
if(orderSymbol == roteamento_symbol)
|
|
{
|
|
if(orderType == ORDER_TYPE_BUY_LIMIT) // Ever adicionou BUY STOP || ORDER_TYPE_BUY_STOP
|
|
{
|
|
bool ok = trade.OrderDelete(orderTicket);
|
|
Print(" Fechou a ordem por FecharOrdensPendentesCompraDoAtivo2() ");
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
//Print("Ordem de VENDA PENDENTE excluida com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
|
|
{
|
|
if(orderType == ORDER_TYPE_BUY_LIMIT)
|
|
{
|
|
bool ok = trade.OrderDelete(orderTicket);
|
|
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
//Print("Ordem de VENDA PENDENTE excluida com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem Pendente do ativo" + roteamento_symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar trade.OrderDelete (VENDA PENDENTE)");
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//---
|
|
bool FecharPosicao(ulong ticket, bool compra)
|
|
{
|
|
string sinal = compra ? "COMPRA" : "VENDA";
|
|
|
|
string msgOK = "Ordem de " + sinal + " fechada com sucesso!";
|
|
|
|
string msgErro = "ERRO: Erro ao enviar trade.PositionClose (" + sinal + ")";
|
|
|
|
bool ok = trade.PositionClose(ticket);
|
|
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
Print(msgOK);
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Retorno inesperado do servidor");
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print(msgErro);
|
|
|
|
return(false);
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
//---
|
|
bool FecharOrdensPendentesSellStopAtivo()
|
|
{
|
|
int ordersTotal = OrdersTotal();
|
|
|
|
for(int i=0; i < ordersTotal && !IsStopped(); i++)
|
|
{
|
|
ulong orderTicket = OrderGetTicket(i);
|
|
|
|
if(OrderSelect(orderTicket))
|
|
{
|
|
ulong orderMagic = OrderGetInteger(ORDER_MAGIC);
|
|
|
|
string orderSymbol = OrderGetString(ORDER_SYMBOL);
|
|
|
|
ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
|
|
|
|
if(inputModoConta == mcNETTING)
|
|
{
|
|
if(orderSymbol == roteamento_symbol)
|
|
{
|
|
string comentario = OrderGetString(ORDER_COMMENT);
|
|
if(orderType == ORDER_TYPE_SELL_STOP)
|
|
{
|
|
bool ok = trade.OrderDelete(orderTicket);
|
|
Print(" Fechou a ordem por FecharOrdensPendentesVendaDoAtivo2() ");
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
//Print("Ordem de VENDA PENDENTE excluida com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem SellStop do ativo" + _Symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar trade.SellStop (VENDA STOP)");
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
|
|
{
|
|
string comentario = OrderGetString(ORDER_COMMENT);
|
|
if(orderType == ORDER_TYPE_SELL_STOP)
|
|
{
|
|
bool ok = trade.OrderDelete(orderTicket);
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
Print("Ordem de VENDA STOP excluida com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem SellStop do ativo" + _Symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar trade.SellStop (VENDA STOP)");
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//---
|
|
bool FecharOrdensPendentesBuyStopAtivo()
|
|
{
|
|
int ordersTotal = OrdersTotal();
|
|
|
|
for(int i=0; i < ordersTotal && !IsStopped(); i++)
|
|
{
|
|
ulong orderTicket = OrderGetTicket(i);
|
|
|
|
if(OrderSelect(orderTicket))
|
|
{
|
|
ulong orderMagic = OrderGetInteger(ORDER_MAGIC);
|
|
|
|
string orderSymbol = OrderGetString(ORDER_SYMBOL);
|
|
|
|
ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
|
|
|
|
if(inputModoConta == mcNETTING)
|
|
{
|
|
if(orderSymbol == roteamento_symbol)
|
|
{
|
|
string comentario = OrderGetString(ORDER_COMMENT);
|
|
if(orderType == ORDER_TYPE_BUY_STOP)
|
|
{
|
|
bool ok = trade.OrderDelete(orderTicket);
|
|
Print(" Fechou a ordem por FecharOrdensPendentesCompraDoAtivo2() ");
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
//Print("Ordem de VENDA PENDENTE excluida com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem BuyStop do ativo" + _Symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar trade.BuyStop (COMPRA STOP)");
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
|
|
{
|
|
string comentario = OrderGetString(ORDER_COMMENT);
|
|
if(orderType == ORDER_TYPE_BUY_STOP)
|
|
{
|
|
bool ok = trade.OrderDelete(orderTicket);
|
|
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
Print("Ordem de COMPRA STOP excluida com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("O robô " + NOME_ROBO + " teve um problema ao excluir a Ordem BuyStop do ativo" + _Symbol);
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO: Erro ao enviar trade.BuyStop (COMPRA STOP)");
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//---
|
|
bool VerificarOrdensPosicoes() //modificou algumas coisas do robô original
|
|
{
|
|
|
|
compradoMercado = false;
|
|
vendidoMercado = false;
|
|
compradoPendente = false;
|
|
vendidoPendente = false;
|
|
compradoStop = false;
|
|
vendidoStop = false;
|
|
|
|
ticketCompradoMercado = 0;
|
|
ticketVendidoMercado = 0;
|
|
ticketCompradoPendente = 0;
|
|
ticketVendidoPendente = 0;
|
|
ticketVendidoStop = 0;
|
|
ticketCompradoStop = 0;
|
|
|
|
|
|
quantLotesPosicaoCompra = 0; //é o numero de lotesem posicao de compra
|
|
quantLotesPosicaoVenda = 0; //é o numero de lotes em posicao de venda
|
|
quantLotesOrdensVenda = 0; //é a quantidade de Lotes de Ordens de Venda (pendurada)
|
|
quantLotesOrdensCompra = 0; //é a quantidade de Lotes de Ordens de Compra (pendurada)
|
|
quantPosicoesCompraExecutadasNoAtivo = 0;
|
|
quantPosicoesVendaExecutadasNoAtivo = 0;
|
|
quantPosicoesCompraExecutadasGlobal = 0;
|
|
quantPosicoesVendaExecutadasGlobal = 0;
|
|
quantOrdensCompraAbertasNoAtivo = 0;
|
|
quantOrdensVendaAbertasNoAtivo = 0;
|
|
quantOrdensCompraAbertasGlobal = 0;
|
|
quantOrdensVendaAbertasGlobal = 0;
|
|
|
|
quantLotesOrdensStopCompra = 0;
|
|
quantLotesOrdensStopVenda = 0;
|
|
|
|
|
|
precoDeCompra = 0;
|
|
precoDeVenda = 0;
|
|
precoPendurouOrdemCompra = 0;
|
|
precoPendurouOrdemVenda = 0;
|
|
precoPendurouOrdemStopCompra = 0;
|
|
precoPendurouOrdemStopVenda = 0;
|
|
maiorOrdemDeCompra = 0;
|
|
menorOrdemDeVenda = 0;
|
|
primeiroPrecoOrdemDeVenda = 0;
|
|
existem_ordem_entao_nao_pode_monitorar_compra = false;
|
|
existem_ordem_entao_nao_pode_monitorar_venda = false;
|
|
bool o_loop_so_pode_passar_1x = false;
|
|
//se_ta_vendido_no_ask_ou_mais = false;
|
|
//se_ta_comprado_no_bid_ou_menos = false;
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| LOOP NAS ORDENS - COMPRA/VENDA PENDENTE AINDA NÃO EXECUTADAS |
|
|
//+------------------------------------------------------------------+
|
|
int ordersTotal = OrdersTotal();
|
|
|
|
for(int i=0; i < ordersTotal && !IsStopped(); i++)
|
|
{
|
|
ulong orderTicket = OrderGetTicket(i);
|
|
|
|
if(OrderSelect(orderTicket))
|
|
{
|
|
ulong orderMagic = OrderGetInteger(ORDER_MAGIC);
|
|
|
|
string orderSymbol = OrderGetString(ORDER_SYMBOL);
|
|
|
|
ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
|
|
|
|
if(inputModoConta == mcNETTING)
|
|
{
|
|
|
|
if(orderType == ORDER_TYPE_BUY_LIMIT)
|
|
quantOrdensCompraAbertasGlobal++;
|
|
if(orderType == ORDER_TYPE_SELL_LIMIT)
|
|
quantOrdensVendaAbertasGlobal++;
|
|
|
|
if(orderSymbol == roteamento_symbol)
|
|
{
|
|
if(orderType == ORDER_TYPE_BUY_LIMIT)
|
|
{
|
|
|
|
quantOrdensCompraAbertasNoAtivo++;
|
|
|
|
compradoPendente = true;
|
|
|
|
quantLotesOrdensCompra = (quantLotesOrdensCompra + NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits));
|
|
|
|
ticketCompradoPendente = orderTicket;
|
|
|
|
precoPendurouOrdemCompra = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);
|
|
|
|
if(precoPendurouOrdemCompra > maiorOrdemDeCompra)
|
|
maiorOrdemDeCompra = NormalizeDouble(precoPendurouOrdemCompra, _Digits);
|
|
|
|
}
|
|
|
|
if(orderType == ORDER_TYPE_SELL_LIMIT)
|
|
{
|
|
|
|
quantOrdensVendaAbertasNoAtivo++;
|
|
|
|
vendidoPendente = true;
|
|
|
|
quantLotesOrdensVenda = (quantLotesOrdensVenda + NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits));
|
|
|
|
ticketVendidoPendente = orderTicket;
|
|
|
|
precoPendurouOrdemVenda = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
if((orderMagic == VALOR_NUMERO_MAGICO) && (orderType == ORDER_TYPE_BUY_LIMIT))
|
|
quantOrdensCompraAbertasGlobal++;
|
|
if((orderMagic == VALOR_NUMERO_MAGICO) && (orderType == ORDER_TYPE_SELL_LIMIT))
|
|
quantOrdensVendaAbertasGlobal++;
|
|
|
|
if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
|
|
{
|
|
if(orderType == ORDER_TYPE_BUY_LIMIT)
|
|
{
|
|
|
|
quantOrdensCompraAbertasNoAtivo++;
|
|
|
|
compradoPendente = true;
|
|
|
|
quantLotesOrdensCompra = (quantLotesOrdensCompra + NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits));
|
|
|
|
ticketCompradoPendente = orderTicket;
|
|
|
|
precoPendurouOrdemCompra = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);
|
|
|
|
}
|
|
|
|
if(orderType == ORDER_TYPE_SELL_LIMIT)
|
|
{
|
|
|
|
quantOrdensVendaAbertasNoAtivo++;
|
|
|
|
vendidoPendente = true;
|
|
|
|
quantLotesOrdensVenda = (quantLotesOrdensVenda + NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits));
|
|
|
|
ticketVendidoPendente = orderTicket;
|
|
|
|
precoPendurouOrdemVenda = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);
|
|
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//+---------------------------------------------------------------------------+
|
|
//| LOOP NAS POSIÇÕES - COMPRA/VENDA A MERCADO OU ORDENS QUE FORAM EXECUTADAS |
|
|
//+---------------------------------------------------------------------------+
|
|
int positionsTotal = PositionsTotal();
|
|
|
|
for(int i=0; i < positionsTotal && !IsStopped(); i++)
|
|
{
|
|
ulong posTicket = PositionGetTicket(i);
|
|
|
|
if(PositionSelectByTicket(posTicket))
|
|
{
|
|
ulong posMagic = PositionGetInteger(POSITION_MAGIC);
|
|
|
|
string posSymbol = PositionGetString(POSITION_SYMBOL);
|
|
|
|
ENUM_POSITION_TYPE posType = (ENUM_POSITION_TYPE)PositionGetInteger(POSITION_TYPE);
|
|
|
|
if(inputModoConta == mcNETTING)
|
|
{
|
|
|
|
if(posType == POSITION_TYPE_BUY)
|
|
quantPosicoesCompraExecutadasGlobal++;
|
|
if(posType == POSITION_TYPE_SELL)
|
|
quantPosicoesVendaExecutadasGlobal++;
|
|
|
|
if(posSymbol == roteamento_symbol)
|
|
{
|
|
if(posType == POSITION_TYPE_BUY)
|
|
{
|
|
|
|
quantPosicoesCompraExecutadasNoAtivo++;
|
|
|
|
compradoMercado = true;
|
|
|
|
quantLotesPosicaoCompra = (quantLotesPosicaoCompra + NormalizeDouble(PositionGetDouble(POSITION_VOLUME), _Digits));
|
|
|
|
ticketCompradoMercado = posTicket;
|
|
|
|
precoDeCompra = NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN), 2);
|
|
|
|
//if ((ask_primeira_melhor_oferta_preco - inputCentavosStopar) == precoDeCompra) se_ta_comprado_no_bid_ou_menos = true; //aqui marca se está comprado no preço do BID/melhor oferta de compra
|
|
|
|
}
|
|
|
|
if(posType == POSITION_TYPE_SELL)
|
|
{
|
|
|
|
quantPosicoesVendaExecutadasNoAtivo++;
|
|
|
|
vendidoMercado = true;
|
|
|
|
quantLotesPosicaoVenda = (quantLotesPosicaoVenda + NormalizeDouble(PositionGetDouble(POSITION_VOLUME), _Digits));
|
|
|
|
ticketVendidoMercado = posTicket;
|
|
|
|
precoDeVenda = NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN), 2);
|
|
|
|
//if ((bid_primeira_melhor_oferta_preco + inputCentavosStopar) == precoDeVenda) se_ta_vendido_no_ask_ou_mais = true; //aqui marca se está vendido no preço do ASK/melhor oferta de venda
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if((posMagic == VALOR_NUMERO_MAGICO) && (posType == POSITION_TYPE_BUY))
|
|
quantPosicoesCompraExecutadasGlobal++;
|
|
if((posMagic == VALOR_NUMERO_MAGICO) && (posType == POSITION_TYPE_SELL))
|
|
quantPosicoesVendaExecutadasGlobal++;
|
|
|
|
if(posSymbol == roteamento_symbol && posMagic == VALOR_NUMERO_MAGICO)
|
|
{
|
|
if(posType == POSITION_TYPE_BUY)
|
|
{
|
|
|
|
quantPosicoesCompraExecutadasNoAtivo++;
|
|
|
|
compradoMercado = true;
|
|
|
|
quantLotesPosicaoCompra = (quantLotesPosicaoCompra + NormalizeDouble(PositionGetDouble(POSITION_VOLUME), _Digits));
|
|
|
|
ticketCompradoMercado = posTicket;
|
|
|
|
precoDeCompra = NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN), 2);
|
|
}
|
|
|
|
if(posType == POSITION_TYPE_SELL)
|
|
{
|
|
|
|
quantPosicoesVendaExecutadasNoAtivo++;
|
|
|
|
vendidoMercado = true;
|
|
|
|
quantLotesPosicaoVenda = (quantLotesPosicaoVenda + NormalizeDouble(PositionGetDouble(POSITION_VOLUME), _Digits));
|
|
|
|
ticketVendidoMercado = posTicket;
|
|
|
|
precoDeVenda = NormalizeDouble(PositionGetDouble(POSITION_PRICE_OPEN), 2);
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| LOOP NAS ORDENS - COMPRA/VENDA STOP |
|
|
//+------------------------------------------------------------------+
|
|
int ordersTotalStop = OrdersTotal();
|
|
|
|
for(int i=0; i < ordersTotalStop && !IsStopped(); i++)
|
|
{
|
|
ulong orderTicketStop = OrderGetTicket(i);
|
|
|
|
if(OrderSelect(orderTicketStop))
|
|
{
|
|
ulong orderMagic = OrderGetInteger(ORDER_MAGIC);
|
|
|
|
string orderSymbol = OrderGetString(ORDER_SYMBOL);
|
|
|
|
ENUM_ORDER_TYPE orderType = (ENUM_ORDER_TYPE)OrderGetInteger(ORDER_TYPE);
|
|
|
|
if(inputModoConta == mcNETTING)
|
|
{
|
|
|
|
// if (orderType == ORDER_TYPE_BUY_LIMIT) quantOrdensCompraAbertas++;
|
|
//if (orderType == ORDER_TYPE_SELL_LIMIT) quantOrdensVendaAbertas++;
|
|
|
|
if(orderSymbol == roteamento_symbol)
|
|
{
|
|
if(orderType == ORDER_TYPE_BUY_STOP)
|
|
{
|
|
|
|
quantLotesOrdensStopCompra = NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits);
|
|
|
|
compradoStop = true;
|
|
|
|
precoPendurouOrdemStopCompra = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);
|
|
|
|
ticketCompradoStop = orderTicketStop;
|
|
|
|
}
|
|
|
|
if(orderType == ORDER_TYPE_SELL_STOP)
|
|
{
|
|
|
|
quantLotesOrdensStopVenda = NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits);
|
|
|
|
vendidoStop = true;
|
|
|
|
precoPendurouOrdemStopVenda = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);
|
|
|
|
ticketVendidoStop = orderTicketStop;
|
|
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
|
|
// if (orderType == ORDER_TYPE_BUY_LIMIT) quantOrdensCompraAbertas++;
|
|
//if (orderType == ORDER_TYPE_SELL_LIMIT) quantOrdensVendaAbertas++;
|
|
if(orderSymbol == roteamento_symbol && orderMagic == VALOR_NUMERO_MAGICO)
|
|
{
|
|
if(orderType == ORDER_TYPE_BUY_STOP)
|
|
{
|
|
|
|
quantLotesOrdensStopCompra = NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits);
|
|
|
|
compradoStop = true;
|
|
|
|
precoPendurouOrdemStopCompra = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);
|
|
|
|
ticketCompradoStop = orderTicketStop;
|
|
|
|
}
|
|
|
|
if(orderType == ORDER_TYPE_SELL_STOP)
|
|
{
|
|
|
|
quantLotesOrdensStopVenda = NormalizeDouble(OrderGetDouble(ORDER_VOLUME_CURRENT), _Digits);
|
|
|
|
vendidoStop = true;
|
|
|
|
precoPendurouOrdemStopVenda = NormalizeDouble(OrderGetDouble(ORDER_PRICE_OPEN), _Digits);
|
|
|
|
ticketVendidoStop = orderTicketStop;
|
|
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
|
|
|
|
void QuantidadeContratosDoR()
|
|
{
|
|
|
|
//QUANTIDADE DE CONTRATOS EM R FIXO
|
|
|
|
if(inputCrossOrder == Mini_Indice)
|
|
{
|
|
NomeTipoDeContrato = "Mini Indice";
|
|
multiplicadorFinanceiroDoContrato = valorFinanceiroPorTickMiniIndice;
|
|
minimoDeContratos = 1;
|
|
}
|
|
|
|
if(inputCrossOrder == Indice_Cheio)
|
|
{
|
|
NomeTipoDeContrato = "Indice Cheio";
|
|
multiplicadorFinanceiroDoContrato = valorFinanceiroPorTickIndiceCheio;
|
|
minimoDeContratos = 5;
|
|
}
|
|
|
|
//LIBERA TRADE SE QUANTIDADE DE CONTRATOS FOR MAIOR QUE 1
|
|
if(quantidadeContratos >= minimoDeContratos)
|
|
{
|
|
podeTreidar = true;
|
|
}
|
|
else
|
|
{
|
|
podeTreidar = false;
|
|
}
|
|
|
|
|
|
valorStopEmReais = ((MathRound(atr_stop_15/5))*5) * multiplicadorFinanceiroDoContrato;
|
|
seraQueAredonda = valorDoREmReais/valorStopEmReais - MathFloor(valorDoREmReais/valorStopEmReais);
|
|
|
|
if(seraQueAredonda >= 0.8)
|
|
{
|
|
quantidadeContratos = MathCeil(valorDoREmReais/valorStopEmReais) * minimoDeContratos;
|
|
aredondaPeloTOPO = true;
|
|
}
|
|
else
|
|
{
|
|
quantidadeContratos = MathFloor(valorDoREmReais/valorStopEmReais) * minimoDeContratos;
|
|
aredondaPeloFUNDO = true;
|
|
}
|
|
|
|
// return;
|
|
}
|
|
|
|
|
|
void QuantidadeContratosPorPorcentagemDeConta()
|
|
{
|
|
valorBalancoDaConta = AccountInfoDouble(ACCOUNT_BALANCE);
|
|
|
|
//QUANTIDADE DE CONTRATOS BASEADO EM PORCENTAGEM DE CONTA
|
|
if(inputPorcentagemConta1_5 == PorcentagemConta1_0)
|
|
{
|
|
RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta1_0;
|
|
}
|
|
if(inputPorcentagemConta1_5 == PorcentagemConta1_5)
|
|
{
|
|
RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta1_5;
|
|
}
|
|
if(inputPorcentagemConta1_5 == PorcentagemConta2_0)
|
|
{
|
|
RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta2_0;
|
|
}
|
|
if(inputPorcentagemConta1_5 == PorcentagemConta2_5)
|
|
{
|
|
RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta2_5;
|
|
}
|
|
if(inputPorcentagemConta1_5 == PorcentagemConta3_0)
|
|
{
|
|
RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta3_0;
|
|
}
|
|
if(inputPorcentagemConta1_5 == PorcentagemConta4_0)
|
|
{
|
|
RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta4_0;
|
|
}
|
|
if(inputPorcentagemConta1_5 == PorcentagemConta5_0)
|
|
{
|
|
RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta5_0;
|
|
}
|
|
if(inputPorcentagemConta1_5 == PorcentagemConta10_0)
|
|
{
|
|
RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta10_0;
|
|
}
|
|
if(inputPorcentagemConta1_5 == PorcentagemConta15_0)
|
|
{
|
|
RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta15_0;
|
|
}
|
|
if(inputPorcentagemConta1_5 == PorcentagemConta20_0)
|
|
{
|
|
RPeloBalancoDaConta = valorBalancoDaConta*valorPorcentagemConta20_0;
|
|
}
|
|
|
|
|
|
//CONTINUA LOGICA COMO NA FUNÇÃO DE CALCULO DE R FIXO
|
|
if(inputCrossOrder == Mini_Indice)
|
|
{
|
|
NomeTipoDeContrato = "Mini Indice";
|
|
multiplicadorFinanceiroDoContrato = valorFinanceiroPorTickMiniIndice;
|
|
minimoDeContratos = 1;
|
|
}
|
|
|
|
if(inputCrossOrder == Indice_Cheio)
|
|
{
|
|
NomeTipoDeContrato = "Indice Cheio";
|
|
multiplicadorFinanceiroDoContrato = valorFinanceiroPorTickIndiceCheio;
|
|
minimoDeContratos = 5;
|
|
}
|
|
|
|
//LIBERA TRADE SE QUANTIDADE DE CONTRATOS FOR MAIOR QUE 1
|
|
if(quantidadeContratos >= minimoDeContratos)
|
|
{
|
|
podeTreidar = true;
|
|
}
|
|
else
|
|
{
|
|
podeTreidar = false;
|
|
}
|
|
|
|
valorStopEmReais = ((MathRound(atr_stop_15/tickerBase))*tickerBase) * multiplicadorFinanceiroDoContrato;
|
|
seraQueAredonda = RPeloBalancoDaConta/valorStopEmReais - MathFloor(RPeloBalancoDaConta/valorStopEmReais);
|
|
|
|
if(seraQueAredonda >= 0.8)
|
|
{
|
|
quantidadeContratos = MathCeil(RPeloBalancoDaConta/valorStopEmReais) * minimoDeContratos;
|
|
aredondaPeloTOPO = true;
|
|
}
|
|
else
|
|
{
|
|
quantidadeContratos = MathFloor(RPeloBalancoDaConta/valorStopEmReais) * minimoDeContratos;
|
|
aredondaPeloFUNDO = true;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
//---
|
|
bool TralingStop() {
|
|
|
|
|
|
double fechamento_ultima_barra = iClose(_Symbol,PERIOD_CURRENT,1);
|
|
|
|
//fiz um comentario no traling stop
|
|
|
|
//LÓGICA PARA FECHAR O TRALING STOP DA COMPRA....
|
|
if (compradoMercado && (fechamento_ultima_barra < media_movel_tralingstop) && (inputTralingStop == Ativa_TralingStop)) {
|
|
|
|
FecharPosicaoAbertas();
|
|
|
|
//LÓGICA PARA FECHAR O TRALING STOP DA VENDA....
|
|
} else if (vendidoMercado && (fechamento_ultima_barra > media_movel_tralingstop) && (inputTralingStop == Ativa_TralingStop)) {
|
|
|
|
FecharPosicaoAbertas();
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//---
|
|
bool AlvoDaCompra() {
|
|
|
|
VerificarOrdensPosicoes(); //verifica a situação das ordens
|
|
|
|
if (inputAlvoPelaMinMaxOuEntrada == Alvo_Pela_Entrada) {
|
|
alvo_compra = (precoDeCompra + (MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase));
|
|
} else {
|
|
alvo_compra = (maxima_do_dia + (MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase));
|
|
}
|
|
//Print("alvo_compra = ",alvo_compra);
|
|
static bool enviou_alvo_da_compra = false;
|
|
if (!compradoMercado) {
|
|
enviou_alvo_da_compra = false;
|
|
FecharOrdensPendentesVendaDoAtivo2();
|
|
}
|
|
|
|
//--------marcador de XXs para enfiar o alvo---------
|
|
ulong hora_atual_servidor = TimeCurrent();
|
|
static bool esperou_XXs_para_colocar_alvos = false; //inicialmente a variavel é falsa
|
|
static bool marcou_horario_da_posicao = false; //inicialmente a variavel é falsa, vc nao tem posicao
|
|
static ulong horario_da_posicao = 999999999999;
|
|
int segundos_esperar_para_colocar_ordem_alvo = 30; //espera XX segundos para colocar o alvo
|
|
|
|
if (!marcou_horario_da_posicao && compradoMercado) {
|
|
horario_da_posicao = TimeCurrent(); //marca que tem posicao de compra ou venda
|
|
marcou_horario_da_posicao = true; //sim, agora vc tem posicao
|
|
}
|
|
|
|
if (hora_atual_servidor > (horario_da_posicao+segundos_esperar_para_colocar_ordem_alvo)) { //ora, se tem posicao, entao comeca a conta 30s para, depois, marcar uma variavel positiva para colocar a ordem
|
|
esperou_XXs_para_colocar_alvos = true; //marca a variavel positiva para colocar a ordem
|
|
}
|
|
|
|
if (!compradoMercado) { //se nao tem mais posicao, volta todas as variaveis para a posicao inicial
|
|
marcou_horario_da_posicao = false; //volta a variavel para seu estado original
|
|
esperou_XXs_para_colocar_alvos = false; //volta a variavel para seu estado original
|
|
horario_da_posicao = 999999999999;
|
|
}
|
|
//----------------------------------------------------
|
|
|
|
if (compradoMercado && esperou_XXs_para_colocar_alvos && VerificarOrdensPosicoes() && !vendidoPendente && (quantLotesPosicaoCompra <= quantidadeContratos) && !enviou_alvo_da_compra) {
|
|
bool ok = trade.SellLimit(quantLotesPosicaoCompra, alvo_compra, roteamento_symbol, 0, 0, ORDER_TIME_DAY, DataExpiracao(), NOME_ROBO);
|
|
enviou_alvo_da_compra = true;
|
|
n_ordens_enviadas++; //proteção envio massivo de ordens
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
Print("Alvo da Compra enviado com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO1: Alvo da Compra");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO2: Alvo da Compra");
|
|
}
|
|
}
|
|
|
|
|
|
//SE CHEGOU NO ALVO, FECHA A MERCADO POSIÇÕES REMANESCENTES
|
|
|
|
if (compradoMercado && (quantLotesPosicaoCompra < quantidadeContratos) && (tick.last > (alvo_compra-(tickerBase*10)))) FecharPosicaoAbertas();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//---
|
|
bool AlvoDaVenda() {
|
|
|
|
VerificarOrdensPosicoes(); //verifica a situação das ordens
|
|
|
|
if (inputAlvoPelaMinMaxOuEntrada == Alvo_Pela_Entrada) {
|
|
alvo_venda = (precoDeVenda - (MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase));
|
|
} else {
|
|
alvo_venda = (minima_do_dia - (MathRound(inputMultiplicadorDoAlvo*atr_stop_15/tickerBase)*tickerBase));
|
|
}
|
|
|
|
static bool enviou_alvo_da_venda = false;
|
|
if (!vendidoMercado) {
|
|
enviou_alvo_da_venda = false;
|
|
FecharOrdensPendentesCompraDoAtivo2();
|
|
}
|
|
|
|
//--------marcador de XXs para enfiar o alvo---------
|
|
ulong hora_atual_servidor = TimeCurrent();
|
|
static bool esperou_XXs_para_colocar_alvos = false; //inicialmente a variavel é falsa
|
|
static bool marcou_horario_da_posicao = false; //inicialmente a variavel é falsa, vc nao tem posicao
|
|
static ulong horario_da_posicao = 999999999999;
|
|
int segundos_esperar_para_colocar_ordem_alvo = 30; //espera XX segundos para colocar o alvo
|
|
|
|
if (!marcou_horario_da_posicao && vendidoMercado) {
|
|
horario_da_posicao = TimeCurrent(); //marca que tem posicao de compra ou venda
|
|
marcou_horario_da_posicao = true; //sim, agora vc tem posicao
|
|
}
|
|
|
|
if (hora_atual_servidor > (horario_da_posicao+segundos_esperar_para_colocar_ordem_alvo)) { //ora, se tem posicao, entao comeca a conta 30s para, depois, marcar uma variavel positiva para colocar a ordem
|
|
esperou_XXs_para_colocar_alvos = true; //marca a variavel positiva para colocar a ordem
|
|
}
|
|
|
|
if (!vendidoMercado) { //se nao tem mais posicao, volta todas as variaveis para a posicao inicial
|
|
marcou_horario_da_posicao = false; //volta a variavel para seu estado original
|
|
esperou_XXs_para_colocar_alvos = false; //volta a variavel para seu estado original
|
|
horario_da_posicao = 999999999999;
|
|
}
|
|
//----------------------------------------------------
|
|
|
|
|
|
if (vendidoMercado && esperou_XXs_para_colocar_alvos && VerificarOrdensPosicoes() && !compradoPendente && (quantLotesPosicaoVenda <= quantidadeContratos) && !enviou_alvo_da_venda) {
|
|
bool ok = trade.BuyLimit(quantLotesPosicaoVenda, alvo_venda, roteamento_symbol, 0, 0, ORDER_TIME_DAY, DataExpiracao(), NOME_ROBO);
|
|
enviou_alvo_da_venda = true;
|
|
n_ordens_enviadas++; //proteção envio massivo de ordens
|
|
if(ok)
|
|
{
|
|
if(trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009)
|
|
{
|
|
Print("Alvo da Venda enviado com sucesso!");
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO1: Alvo da Venda");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("ERRO2: Alvo da Venda");
|
|
}
|
|
}
|
|
|
|
//SE CHEGOU NO ALVO, FECHA A MERCADO POSIÇÕES REMANESCENTES
|
|
|
|
if (vendidoMercado && (quantLotesPosicaoVenda < quantidadeContratos) && (tick.last < (alvo_venda+(tickerBase*(tickerBase*2))))) FecharPosicaoAbertas();
|
|
|
|
return true;
|
|
}
|
|
|
|
//---
|
|
bool FecharPosicoesContaHedge() {
|
|
|
|
VerificarOrdensPosicoes(); //verifica a situação das ordens
|
|
//+----------------------------------------------------------------+
|
|
//| SE TIVER UMA COMPRA E VENDA POSICIONADAS, FECHA UMA PELA OUTRA |
|
|
//+----------------------------------------------------------------+
|
|
if (inputModoConta == mcHEDGING) {
|
|
if (compradoMercado && vendidoMercado && (quantLotesPosicaoCompra == quantLotesPosicaoVenda)) {
|
|
double quantidade_que_comprou_ou_vendeu = quantLotesPosicaoCompra;
|
|
bool ok = trade.PositionCloseBy(ticketCompradoMercado, ticketVendidoMercado);
|
|
|
|
if (ok) {
|
|
if (trade.ResultRetcode() == 10008 || trade.ResultRetcode() == 10009) {
|
|
Print("O robô " + NOME_ROBO + " executou a ZERAGEM TOTAL da posição de " + DoubleToString(quantidade_que_comprou_ou_vendeu, _Digits) + " contrato/açoes, do ativo " + _Symbol);
|
|
} else {
|
|
Print("ERRO1: Retorno inesperado do servidor (trade.PositionCloseBy)");
|
|
|
|
return(false);
|
|
}
|
|
} else {
|
|
Print("ERRO2: Erro ao enviar trade.PositionCloseBy");
|
|
|
|
return(false);
|
|
}
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
|
|
|
|
bool ProtecaoContraLooping() {
|
|
|
|
ulong hora_atual = TimeLocal();
|
|
//double posicoesEordensAbertas = NormalizeDouble(quantPosicoesExecutadasGlobal+quantOrdensCompraAbertas, _Digits);
|
|
if (((inputModoDeMercado == ContaReal) || (tipoConta == ACCOUNT_TRADE_MODE_REAL)) && (hora_atual > (horario_executou_robo+30))) {
|
|
if ((quantLotesPosicaoCompra || quantLotesPosicaoVenda) > quantidadeContratos) {
|
|
|
|
Print("MOTIVO 1: APARENTEMENTE O ROBÔ ENTROU EM LOOP NO ATIVO " + roteamento_symbol + " E FOI PARADO.");
|
|
FecharOrdensPendentesCompraDoAtivo();
|
|
FecharOrdensPendentesVendaDoAtivo();
|
|
FecharPosicaoAbertas();
|
|
ExpertRemove();
|
|
|
|
}
|
|
|
|
if ((quantLotesOrdensVenda || quantLotesOrdensCompra) > quantidadeContratos) {
|
|
|
|
Print("MOTIVO 2: APARENTEMENTE O ROBÔ ENTROU EM LOOP NO ATIVO " + roteamento_symbol + " E FOI PARADO, VEJA SE NÃO TOMOU MAIS POSIÇÃO QUE O SETADO NO CAIXA. FAVOR VERIFICAR O QUE HOUVE ANTES DE RODAR DE NOVO");
|
|
FecharOrdensPendentesCompraDoAtivo();
|
|
FecharOrdensPendentesVendaDoAtivo();
|
|
FecharPosicaoAbertas();
|
|
ExpertRemove();
|
|
|
|
}
|
|
|
|
if ((quantLotesOrdensStopCompra || quantLotesOrdensStopVenda) > quantidadeContratos) {
|
|
|
|
Print("MOTIVO 3: APARENTEMENTE O ROBÔ ENTROU EM LOOP NO ATIVO " + roteamento_symbol + " E FOI PARADO, VEJA SE NÃO TOMOU MAIS POSIÇÃO QUE O SETADO NO CAIXA. FAVOR VERIFICAR O QUE HOUVE ANTES DE RODAR DE NOVO");
|
|
FecharOrdensPendentesCompraDoAtivo();
|
|
FecharOrdensPendentesVendaDoAtivo();
|
|
FecharPosicaoAbertas();
|
|
ExpertRemove();
|
|
|
|
}
|
|
|
|
if (quantos_trades_fez_no_dia > 7) {
|
|
|
|
Print("MOTIVO 4: APARENTEMENTE O ROBÔ ENTROU EM LOOP NO ATIVO " + roteamento_symbol + " E FOI PARADO, VEJA SE NÃO TOMOU MAIS POSIÇÃO QUE O SETADO NO CAIXA. FAVOR VERIFICAR O QUE HOUVE ANTES DE RODAR DE NOVO");
|
|
FecharOrdensPendentesCompraDoAtivo();
|
|
FecharOrdensPendentesVendaDoAtivo();
|
|
FecharPosicaoAbertas();
|
|
ExpertRemove();
|
|
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
bool ProtecaoEnvioMassivoOrdens() {
|
|
|
|
if (inputModoDeMercado == Backtest) {
|
|
|
|
int segundos_pausar_robo = 3600;
|
|
int intervalo_segundos = 4;
|
|
int n_maximo_ordens_enviadas_em_x_segundos = 5;
|
|
static ulong hora_que_enviou_a_primeira_ordem = 0;
|
|
static bool marcou_hora_primeira_ordem = false;
|
|
ulong hora_atual_servidor = TimeCurrent();
|
|
|
|
if (n_ordens_enviadas == 1 && !marcou_hora_primeira_ordem) {
|
|
hora_que_enviou_a_primeira_ordem = TimeCurrent();
|
|
marcou_hora_primeira_ordem = true;
|
|
}
|
|
|
|
if (hora_atual_servidor >= (hora_que_enviou_a_primeira_ordem+intervalo_segundos)) {
|
|
n_ordens_enviadas = 0;
|
|
hora_que_enviou_a_primeira_ordem = 0;
|
|
marcou_hora_primeira_ordem = false;
|
|
}
|
|
|
|
if (n_ordens_enviadas >= n_maximo_ordens_enviadas_em_x_segundos) {
|
|
FecharPosicaoAbertas();
|
|
FecharOrdensPendentesCompraDoAtivo();
|
|
FecharOrdensPendentesVendaDoAtivo();
|
|
FecharOrdensPendentesBuyStopAtivo();
|
|
FecharOrdensPendentesSellStopAtivo();
|
|
FecharPosicaoAbertas();
|
|
Print("ROBÔ FECHADO - ENVIO MASSIVO DE ORDENS - ProtecaoEnvioMassivoOrdens()");
|
|
ExpertRemove();
|
|
}
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//void CriaLinhaATRMinimoDeAlta()
|
|
//{
|
|
// //CRIA LINHA ATR MINIMO DE ALTA
|
|
//
|
|
// datetime criaLinhaATRMinimoDeAlta = iTime(_Symbol,PERIOD_CURRENT,0);
|
|
// ObjectCreate(
|
|
// 0, // ID de gráfico
|
|
// "linhaATRMinimoDeAlta", // Nome da linha
|
|
// OBJ_HLINE, // Tipo da linha
|
|
// 0, // Sub Window
|
|
// criaLinhaATRMinimoDeAlta, // Datetime do objeto
|
|
// precoDaLinhaATRAlta // Preço
|
|
// );
|
|
//
|
|
// ObjectSetInteger(0,"linhaATRMinimoDeAlta",OBJPROP_STYLE,STYLE_DOT);
|
|
// ObjectSetInteger(0,"linhaATRMinimoDeAlta",OBJPROP_COLOR,clrGray);
|
|
|
|
|
|
void CriaLinhaATRMinimoDeAltaEBaixa()
|
|
{
|
|
CopyRates(_Symbol,PERIOD_M5,0,114,candles5);
|
|
CopyRates(_Symbol,PERIOD_D1,0,2,candlesDia);
|
|
|
|
for(int i=0; i<114; i++)
|
|
{
|
|
if(TimeToString(candles5[i].time, TIME_DATE) == TimeToString(candlesDia[0].time, TIME_DATE))
|
|
{
|
|
barra5DeOntemHIGH = candles5[i].high;
|
|
barra5DeOntemLOW = candles5[i].low;
|
|
chaveDiaOntem = candlesDia[0].time;
|
|
//CRIA LINHA DE ALTA
|
|
ObjectCreate(0, "linhaHigh", OBJ_TREND,0,primeiroCandle5Horario,precoDaLinhaATRAlta,tick.time,precoDaLinhaATRAlta);
|
|
ObjectSetInteger(0,"linhaHigh", OBJPROP_COLOR,clrYellow);
|
|
ObjectSetInteger(0,"linhaHigh",OBJPROP_STYLE,STYLE_DOT);
|
|
ObjectSetInteger (0, "linhaHigh", OBJPROP_RAY_RIGHT,false);
|
|
|
|
//CRIA LINHA DE BAIXA
|
|
ObjectCreate(0, "linhaLow", OBJ_TREND,0,primeiroCandle5Horario,precoDaLinhaATRBaixa,tick.time,precoDaLinhaATRBaixa);
|
|
ObjectSetInteger(0,"linhaLow", OBJPROP_COLOR,clrYellow);
|
|
ObjectSetInteger (0, "linhaLow", OBJPROP_RAY_RIGHT,false);
|
|
ObjectSetInteger(0,"linhaLow",OBJPROP_STYLE,STYLE_DOT);
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
|
|
bool ControleDeAcesso(string nome_cadastrado, long conta_real_producao, long conta_demo, int numero_maximo_contratos, int dia, int mes, int ano) {
|
|
|
|
|
|
datetime dataAtt = TimeCurrent();
|
|
string data_completa = "";
|
|
long numero_da_conta_real = AccountInfoInteger(ACCOUNT_LOGIN);
|
|
string nome_do_usuario_na_corretora = AccountInfoString(ACCOUNT_NAME);
|
|
string nome_backtest = "Tester";
|
|
|
|
//aqui faz a conversao da data caso o usuário esqueça de digitar um "0" antes....
|
|
if (((dia == 1) || (dia == 2 ) || (dia == 3 ) || (dia == 4) || (dia == 5) || (dia == 6) || (dia == 7) || (dia == 8) || (dia == 9)) && ((mes != 1) && (mes != 2) && (mes != 3) && (mes != 4) && (mes != 5) && (mes != 6) && (mes != 7) && (mes != 8) && (mes != 9))) {
|
|
data_completa = (string)ano + "." + (string)mes + ".0" + (string)dia + " 00:00";
|
|
} else if (((dia != 1) && (dia != 2 ) && (dia != 3 ) && (dia != 4) && (dia != 5) && (dia != 6) && (dia != 7) && (dia != 8) && (dia != 9)) && ((mes == 1) || (mes == 2) || (mes == 3) || (mes == 4) || (mes == 5) || (mes == 6) || (mes == 7) || (mes == 8) || (mes == 9))) {
|
|
data_completa = (string)ano + ".0" + (string)mes + "." + (string)dia + " 00:00";
|
|
} else if (((dia == 1) || (dia == 2 ) || (dia == 3 ) || (dia == 4) || (dia == 5) || (dia == 6) || (dia == 7) || (dia == 8) || (dia == 9)) && ((mes == 1) || (mes == 2) || (mes == 3) || (mes == 4) || (mes == 5) || (mes == 6) || (mes == 7) || (mes == 8) || (mes == 9))) {
|
|
data_completa = (string)ano + ".0" + (string)mes + ".0" + (string)dia + " 00:00";
|
|
} else {
|
|
data_completa = (string)ano + "." + (string)mes + "." + (string)dia + " 00:00";
|
|
}
|
|
|
|
|
|
datetime vencimentoRobo = StringToTime(data_completa);
|
|
//if (tipoConta == ACCOUNT_TRADE_MODE_DEMO) vencimentoRobo = D'2030.01.01 00:00'; //se o robô é conta demo.. entao vence numa data futura bem pra frente.. a pessoa pode usar...
|
|
//Print("Data Atual = ", dataAtt);
|
|
//Print("Data Vencimento Robo = ", vencimentoRobo);
|
|
//Print("A data atual chegou no vencimento? = ", (dataAtt >= vencimentoRobo));
|
|
|
|
if (dataAtt >= vencimentoRobo) {
|
|
Print("Prazo de Validade Vencido, Favor Contactar o Administrador");
|
|
ExpertRemove();
|
|
return false;
|
|
|
|
}
|
|
|
|
if ((nome_cadastrado != "") && (nome_cadastrado != nome_do_usuario_na_corretora) && (nome_backtest != nome_do_usuario_na_corretora)) { //PARA HABILITAR BACKTEST
|
|
//if ((nome_cadastrado != "") && (nome_cadastrado != nome_do_usuario_na_corretora)) { //PARA DESABILITAR BACKTEST
|
|
Print("O nome do usuário na corretora não é o mesmo da licença do robô. Favor contactar o Administrador!");
|
|
Print("O nome do usuário dono da licença é " + NOME_NA_CORRETORA + ", e você quer logar com a conta cujo titular é " + nome_do_usuario_na_corretora + ".");
|
|
Print("----------");
|
|
ExpertRemove();
|
|
return false;
|
|
}
|
|
|
|
//aqui faz o controle pelo numero de contratos...
|
|
if ((tipoConta == ACCOUNT_TRADE_MODE_REAL) && (quantidadeContratos > numero_maximo_contratos)) {
|
|
Print("Você não pode operar " + (string)quantidadeContratos + " contratos, precisamos de liquidez para todo mundo.. Por favor, diminua para até " + (string)numero_maximo_contratos + " contratos.");
|
|
Print("Se estiver utilizando BackTest... FAÇA EM CONTA DEMO!!!.");
|
|
ExpertRemove();
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
//aqui faz o controle pelo numero da conta...
|
|
if ((tipoConta == ACCOUNT_TRADE_MODE_REAL) && (numero_da_conta_real != conta_real_producao)) {
|
|
Print("Essa conta NÃO está habilitada para operar no ambiente real. Contate o pessoal da @ Gestão Trader...");
|
|
Print("Essa conta NÃO está habilitada para operar no ambiente real. Contate o pessoal da @ Gestão Trader...");
|
|
ExpertRemove();
|
|
return false;
|
|
|
|
}
|
|
|
|
//aqui faz o controle pelo numero da conta...
|
|
if ((tipoConta == ACCOUNT_TRADE_MODE_DEMO) && (numero_da_conta_real != conta_demo)) {
|
|
Print("Essa conta NÃO está habilitada para operar. Contate o pessoal da @ Gestão Trader...");
|
|
Print("Essa conta NÃO está habilitada para operar. Contate o pessoal da @ Gestão Trader...");
|
|
ExpertRemove();
|
|
return false;
|
|
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
|