1278 lines
133 KiB
MQL5
1278 lines
133 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| Atom 2.mq5 |
|
|
//| Copyright 2021, MetaQuotes Ltd. |
|
|
//| https://www.mql5.com |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Rodrigo César Pagani"
|
|
#property link "mailto: rodrigo@pagani.com.br"
|
|
#define VERSION "2.00"
|
|
#property version VERSION
|
|
#define nome_ea "AtomBot "+VERSION+" - "+AccountInfoString(ACCOUNT_COMPANY)
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Definição localização Indicadores |
|
|
//+------------------------------------------------------------------+
|
|
#define LinkKeltner "::Shared Projects\\Atom2\\Indicators\\keltner_channel315.ex5"
|
|
#define LinkVWap "::Shared Projects\\Atom2\\Indicators\\VWap.ex5"
|
|
#define LinkSATL "Shared Projects\\Atom2\\Indicators\\satl.ex5"
|
|
#define LinkFATL "Shared Projects\\Atom2\\Indicators\\fatl.ex5"
|
|
#define LinkMediaMovel "Shared Projects\\Atom2\\Indicators\\CustomIMA.ex5"
|
|
#define LinkAngulo "Shared Projects\\Atom2\\Indicators\\angle_of_averages.ex5"
|
|
#define LinkRegressao "Shared Projects\\Atom2\\Indicators\\Regressao.ex5"
|
|
#define LinkZScore "Shared Projects\\Atom2\\Indicators\\ZScore.ex5"
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| inclusao das classes a serem utilizadas |
|
|
//+------------------------------------------------------------------+
|
|
#resource "\\Shared Projects\\Atom2\\Indicators\\keltner_channel315.ex5"
|
|
#resource "\\Shared Projects\\Atom2\\Indicators\\VWap.ex5"
|
|
#resource "\\Shared Projects\\Atom2\\Indicators\\fatl.ex5"
|
|
#resource "\\Shared Projects\\Atom2\\Indicators\\satl.ex5"
|
|
#resource "\\Shared Projects\\Atom2\\Indicators\\CustomIMA.ex5"
|
|
#resource "\\Shared Projects\\Atom2\\Indicators\\angle_of_averages.ex5"
|
|
#resource "\\Shared Projects\\Atom2\\Indicators\\Regressao.ex5"
|
|
#resource "\\Shared Projects\\Atom2\\Indicators\\ZScore.ex5"
|
|
|
|
#include <AtomBot2\Bot.mqh>
|
|
#include <AtomBot2\Negociacao.mqh>
|
|
#include <AtomBot2\StructEnum.mqh>
|
|
#include <AtomBot2\Financeiro.mqh>
|
|
#include <AtomBot2\FuncoesUteis.mqh>
|
|
#include <AtomBot2\Painel.mqh>
|
|
|
|
CMyBot bot;
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| input genericas do EA |
|
|
//+------------------------------------------------------------------+
|
|
input group "Configurações da Ordem";
|
|
input double ExpertContratos = 1; //Lotes, contratos ou ações
|
|
input long ExpertNumeroMagico = 41; //Número Mágico
|
|
input ENUM_ORDER_TYPE_FILLING ExpertOrderFilling = ORDER_FILLING_FOK; //Tipo de preenchimento da ordem
|
|
input string ExpertComentario = "AtomBot"; //Comentário do EA
|
|
input double ExpertGain = 70; //Take Profit pontos
|
|
input double ExpertLoss = 150; //Stop Loss pontos
|
|
input condicao_ ExpertCompra = condicao_s; //Operar compra
|
|
input condicao_ ExpertVenda = condicao_s; //Operar venda
|
|
condicao_ ExpertDestaqueTPSL = condicao_n; //Destacar linha do Take Profit/Stop Loss/Abertura Posição
|
|
color ExpertCorOP = clrYellow; //Cor para linha Abertura Posição
|
|
color ExpertCorTP = clrDeepSkyBlue; //Cor para linha Take Profit
|
|
color ExpertCorSL = clrRed; //Cor para linha Stop Loss
|
|
//--------------------------------------------------------------------
|
|
input group "Configuração da Hora";
|
|
//input TypeSystem_ ExpertTipoOperacao = TypeSystem1; //Day trade / Swing Trade
|
|
input tipohora_ ExpertTipo_hr = tipo_1; //Tipo de horário
|
|
input string ExpertHoraInicio_hr = "9:30"; //Hora inicio
|
|
input string ExpertIntervalo_Parar_hr = "11:30"; //Intervalo - Parar de Operar (0-Desabilitado)
|
|
input string ExpertIntervalo_Volta_hr = "13:00"; //Intervalo - Voltar Operar (0-Desabilitado)
|
|
input string ExpertHoraFim_hr = "16:30"; //Hora final
|
|
input string ExpertHoraFecha_hr = "17:00"; //Fechar posição/ordens aberta
|
|
//--------------------------------------------------------------------
|
|
input group "Metas Financeiras";
|
|
input condicao_ ExpertGanho_mf = condicao_s; //Ativar meta diária para Ganho
|
|
input double ExpertMetaGanho_mf = 60.0; //Ganho máximo diário em R$
|
|
input condicao_ ExpertPerca_mf = condicao_s; //Ativar meta diária para Perca
|
|
input double ExpertMetaPerda_mf = 980.0; //Perca máxima diária em R$
|
|
input condicao_ ExpertDesativarTerminal = condicao_n; //Encerrar terminal ao atingir meta financeira
|
|
//--------------------------------------------------------------------
|
|
input group "Break Even";
|
|
input condicao_ ExpertBreakeven_be = condicao_s; //Ativar BreakEven
|
|
input double ExpertDistancia_be = 30; //Distância ativar
|
|
input double ExpertProtecao_be = 15; //Pontos a proteger
|
|
//--------------------------------------------------------------------
|
|
input group "Trail Stop";
|
|
input condicao_ ExpertTrailstop_ts = condicao_s; //Ativar Trail Stop
|
|
input double ExpertDistancia_ts = 40; //Distância ativar
|
|
input double ExpertProtecao_ts = 20; //Margem em pontos
|
|
input double ExpressStep_ts = 15; //Step Trail Stop
|
|
//--------------------------------------------------------------------
|
|
input group "Trade System";
|
|
input TradeSystem_ ExpertTradeSystem = TradeSystem1; //Trade System
|
|
//--------------------------------------------------------------------
|
|
//input group "Estratégias de ordem";
|
|
//input condicao_ ExpertPrecoMedio = condicao_s; //Ativar preço médio
|
|
//input int ExpertMaximo_pm = 3; //Máximo de ordens da estratégia
|
|
//input double ExpertFator_pm = 2; //Fator incrementador da estratégia
|
|
//input double ExpertPontos_pm = 115; //Distância em pontos entre ordens
|
|
//--------------------------------------------------------------------
|
|
input group "Configuração do Painel";
|
|
input condicao_ ExpertCriar_pn = condicao_s; //Criar Painel
|
|
input int ExpertXX_pn = 20; //Afastamento Horizontal do Painel
|
|
input int ExpertYY_pn = 20; //Afastamento Vertical do Painel
|
|
input int ExpertLargura_pn = 340; //Largura do Painel
|
|
input int ExpertAltura_pn = 375; //Altura do Painel
|
|
//--------------------------------------------------------------------
|
|
input group "Keltner Channel";
|
|
input condicao_ ExpertAtivarKeltner = condicao_s; //Ativar Keltner Channel
|
|
input int ExpertMM_Keltner = 20; //Período média móvel Keltner
|
|
input int ExpertPeriodo_Keltner = 14; //Período Canal Keltner
|
|
input double ExpertDesvio_Keltner = 1.2; //Desvio Keltner
|
|
input enPrices ExpertCalc_Price = pr_typical; //Preço média móvel
|
|
//--------------------------------------------------------------------
|
|
input group "Linha de Tendência Adaptativa";
|
|
input condicao_ ExpertAtivarFATL = condicao_n; //Ativar Linha de Tendência Adaptativa Rápida(FATL)
|
|
input condicao_ ExpertAtivarSATL = condicao_n; //Ativar Linha de Tendência Adaptativa Lenta(SATL)
|
|
//--------------------------------------------------------------------
|
|
input group "Grau de inclinação da média";
|
|
input condicao_ ExpertAtivarGrau = condicao_s; //Ativar Grau de inclinação
|
|
input int ExpertMAPeriod = 34; //Período Média
|
|
input enumAveragesType ExpertMAType = avgNlma; //Tipo de cálculo
|
|
input enPrices ExpertMAPrice = pr_close; //Preço a usar
|
|
input int ExpertAngleBars = 6; //Barras para angulo
|
|
input double ExpertAngleLevel = 8; //Nivel
|
|
//--------------------------------------------------------------------
|
|
input group "Regressão Linear";
|
|
input condicao_ ExpertAtivarRegressaoLinear = condicao_s; //Ativar Regressão Linear
|
|
input int ExpertRLPeriodo = 20; //Período Médio
|
|
input double ExpertRLDesvio = 2.0; //Coeficiente de Desvio
|
|
//--------------------------------------------------------------------
|
|
input group "Z-Score";
|
|
input condicao_ ExpertAtivarZScore = condicao_s; //Ativar Z-Score
|
|
input int ExpertZSPeriodo = 20; //Período
|
|
input ENUM_APPLIED_PRICE ExpertZSPreco = PRICE_CLOSE; //Preço
|
|
input double ExpertZSDesvio = 2.0; //Coeficiente de Desvio
|
|
//--------------------------------------------------------------------
|
|
input group "Média Móvel Rápida";
|
|
input condicao_ ExpertAtivarMediaRapida = condicao_n; //Ativar Média Móvel Rápida
|
|
input ENUM_APPLIED_PRICE ExpertRapidaPreco = PRICE_CLOSE; //Preço Aplicado para média
|
|
input int ExpertRapidaPeriodo = 7; //Período Média Móvel Rápida
|
|
input ENUM_MA_METHOD ExpertRapidaMetodo = MODE_SMA; //Método Média Rápida
|
|
input color ExpertRapidaCor = clrLightGreen; //Cor Média Rápida
|
|
input ENUM_LINE_STYLE ExpertRapidaEstilo = STYLE_SOLID; //Estilo da linha
|
|
input int ExpertRapidaEspessura = 1; //Espessura da linha
|
|
//--------------------------------------------------------------------
|
|
input group "Média Móvel Lenta";
|
|
input condicao_ ExpertAtivarMediaLenta = condicao_n; //Ativar Média Móvel Lenta
|
|
input ENUM_APPLIED_PRICE ExpertLentaPreco = PRICE_CLOSE; //Preço Aplicado para média
|
|
input int ExpertLentaPeriodo = 21; //Período Média Móvel Rápida
|
|
input ENUM_MA_METHOD ExpertLentaMetodo = MODE_SMA; //Método Média Rápida
|
|
input color ExpertLentaCor = clrRed; //Cor Média Rápida
|
|
input ENUM_LINE_STYLE ExpertLentaEstilo = STYLE_SOLID; //Estilo da linha
|
|
input int ExpertLentaEspessura = 1; //Espessura da linha
|
|
//--------------------------------------------------------------------
|
|
input group "Estocástico";
|
|
input condicao_ ExpertAtivarEstocastico = condicao_n; //Ativar Estocástico
|
|
input int ExpertPeriodo_K = 8; //K-period (número de barras para cálculos)
|
|
input int ExpertPeriodo_D = 3; //D-period (período da primeira suavização)
|
|
input int ExpertSlowing = 3; //Final da suavização
|
|
input ENUM_MA_METHOD ExpertMethod = MODE_SMA; //Tipo de suavização
|
|
input ENUM_STO_PRICE ExpertPrice_Field = STO_LOWHIGH; //Método de cálculo estocástico
|
|
input int ExpertUp = 80; //Linha Superior Estocástico
|
|
input int ExpertDown = 20; //Linha Inferior Estocástico
|
|
//--------------------------------------------------------------------
|
|
input group "VWAP";
|
|
input condicao_ ExpertAtivarVWAP = condicao_n; //Ativar VWAP
|
|
input PRICE_TYPE ExpertPrice_Type = CLOSE_HIGH_LOW; //Valor para Cálculo
|
|
input condicao_ ExpertCalc_Every_Tick = condicao_n; //Calcular cada Tick
|
|
input condicao_ ExpertEnable_Daily = condicao_s; //Habilitar Diário
|
|
condicao_ ExpertShow_Daily_Value = condicao_n; //Mostrar Valor Diário
|
|
input condicao_ ExpertEnable_Weekly = condicao_s; //Habilitar Semanal
|
|
condicao_ ExpertShow_Weekly_Value = condicao_n; //Mostrar Valor Semanal
|
|
input condicao_ ExpertEnable_Monthly = condicao_s; //Habilitar Mensal
|
|
condicao_ ExpertShow_Monthly_Value = condicao_n; //Mostrar Valor Mensal
|
|
//--------------------------------------------------------------------
|
|
input group "Configuração Grupo Telegram";
|
|
input condicao_ ExpertAtivarBotTelegram = condicao_n; //Ativar Bot Telegram
|
|
input string Experttoken = ""; //Token do Grupo
|
|
input long ExpertUsuatioTelegram = 0; //Usuário no Telegram
|
|
|
|
//token ZeusBot 1969425464:AAE5ub30YI5gwq4VGOnCCLesurBF_w5Ss3Q
|
|
//token AtomBot 1964419004:AAGEDQfd4xvPK2NHQi2_i02C4uiKX1J_yLY
|
|
//Usuário para mandar mensagens -546140899
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| variaveis globais para os indicadores |
|
|
//+------------------------------------------------------------------+
|
|
// Keltner Channel
|
|
int Keltner_Handle=0; //Handle
|
|
double Keltner_Up[];
|
|
double Keltner_Middle[];
|
|
double Keltner_Down[];
|
|
|
|
//FATL
|
|
int FATL_Handle=0; //Handle
|
|
double FATL_Buffer[];
|
|
|
|
//SATL
|
|
int SATL_Handle=0; //Handle
|
|
double SATL_Buffer[];
|
|
|
|
//Grau Inclinação da Média
|
|
int Grau_Handle=0; //Handle
|
|
double Grauh_Buffer[];
|
|
double Grauc_Buffer[];
|
|
double Grau_Buffer[];
|
|
|
|
// VWAP
|
|
int VWAP_Handle=0; //Handle
|
|
double VWAP_DIA[];
|
|
double VWAP_SEMANA[];
|
|
double VWAP_MES[];
|
|
|
|
// Stochastic
|
|
int Stochastic_Handle=0; //Handle
|
|
double Stochastic_Buffer[];
|
|
|
|
//--- Médias Móveis
|
|
// RÁPIDA - menor período
|
|
int Rapida_Handle=0; // Handle controlador da média móvel rápida
|
|
double Rapida_Buffer[]; // Buffer para armazenamento dos dados das médias
|
|
|
|
// LENTA - maior período
|
|
int Lenta_Handle=0; // Handle controlador da média móvel lenta
|
|
double Lenta_Buffer[]; // Buffer para armazenamento dos dados das médias
|
|
|
|
// Angulo Média
|
|
int Angulo_Handle=0; // Handle controlador do Angulo da média
|
|
double Angulo_Buffer[]; // Buffer para armazenamento dos dados dos Angulos
|
|
|
|
// Regressão Linear
|
|
int Regressao_Handle=0; // Handle Regressão Linear
|
|
double Regressao_Buffer[]; // Buffer Regressão Linear
|
|
|
|
// Z-Score
|
|
int ZScore_Handle=0; // Handle Z-Score
|
|
double ZScore_Buffer[]; // Buffer Z-Score
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| variaveis globais gerais |
|
|
//+------------------------------------------------------------------+
|
|
MqlRates Precos[]; // variável para armazenar preços
|
|
MqlTick Tick; // variável para armazenar ticks
|
|
string Prefixo = "OBJECT:";
|
|
string MoedaCorrente = " "+(string)AccountInfoString(ACCOUNT_CURRENCY);
|
|
int QtdeBuffer = 4; //Qtde de registros a ser copiado no buffer
|
|
boleta Negociacao;
|
|
financa Financeiro;
|
|
double SL_Anterior = 0.00;
|
|
double TP_Anterior = 0.00;
|
|
double OP_Anterior = 0.00;
|
|
datetime UltimoCandle;
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Initialization function of the expert |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit(){
|
|
RemoveIndicadores();
|
|
|
|
ReiniciarBoleta();
|
|
Negociacao.Desligado=false;
|
|
if(TotalPosicao(Negociacao.Ativo,Negociacao.NumeroMagico)>0)
|
|
RecuperaBoleta();
|
|
|
|
if(!Validacoes())
|
|
return(INIT_FAILED);
|
|
|
|
//--- create timer
|
|
EventSetTimer(4);
|
|
ConfiguraoInicial();
|
|
|
|
AtualizarFinanceiro(Negociacao.Ativo,Negociacao.NumeroMagico);
|
|
|
|
CopyRates(Negociacao.Ativo, Negociacao.Periodo, 0, QtdeBuffer, Precos);
|
|
ArraySetAsSeries(Precos, true);
|
|
|
|
InicializarIndicadores();
|
|
AtualizarIndicadores();
|
|
|
|
|
|
if(ExpertCriar_pn==1){
|
|
CriarPainel(Prefixo, nome_ea, ExpertXX_pn, ExpertYY_pn, ExpertLargura_pn, ExpertAltura_pn);
|
|
AtualizarPainel();
|
|
}
|
|
|
|
if(ExpertAtivarBotTelegram==1){
|
|
bot.Usuario = ExpertUsuatioTelegram;
|
|
bot.Token(Experttoken);
|
|
bot.GetMe();
|
|
}
|
|
|
|
//--- ok
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Deinitialization function of the expert |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason){
|
|
//--- destroy timer
|
|
EventKillTimer();
|
|
MarketBookRelease(Negociacao.Ativo);
|
|
|
|
RemoveIndicadores();
|
|
|
|
DestroiPainel(reason);
|
|
ObjectsDeleteAll(0,Prefixo);
|
|
IndicatorRelease(Keltner_Handle);
|
|
IndicatorRelease(VWAP_Handle);
|
|
IndicatorRelease(FATL_Handle);
|
|
IndicatorRelease(SATL_Handle);
|
|
IndicatorRelease(Stochastic_Handle);
|
|
IndicatorRelease(Rapida_Handle);
|
|
IndicatorRelease(Lenta_Handle);
|
|
IndicatorRelease(Angulo_Handle);
|
|
IndicatorRelease(Regressao_Handle);
|
|
IndicatorRelease(ZScore_Handle);
|
|
|
|
//Motivo do robo ter saido
|
|
Print(GetReasonID(reason));
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| "Tick" event handler function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTick(){
|
|
if(Negociacao.Periodo != _Period)
|
|
Negociacao.Periodo = _Period;
|
|
|
|
// Alimentar com dados variável de tick
|
|
SymbolInfoTick(Negociacao.Ativo,Tick);
|
|
|
|
bool NovaOperacao= (TotalPosicao(Negociacao.Ativo,Negociacao.NumeroMagico)==0);
|
|
bool NovoCandle = CandleNovo(Negociacao.Ativo, Negociacao.Periodo);
|
|
bool MesmoCandle = NegociacaoCandle(Negociacao.Ativo,Negociacao.NumeroMagico);
|
|
|
|
if(NovoCandle){
|
|
UltimoCandle = Tick.time;
|
|
}
|
|
|
|
if(LimiteHorario()){
|
|
ClosePosicao(Negociacao.Ativo,Negociacao.NumeroMagico);
|
|
ReiniciarBoleta();
|
|
}
|
|
|
|
if(NovaOperacao && MercadoAberto() && !MesmoCandle){
|
|
AtualizarIndicadores();
|
|
if(NovoCandle)
|
|
ReiniciarBoleta();
|
|
if(ExpertTradeSystem==1 && NovoCandle)
|
|
RomperKeltner();
|
|
if(ExpertTradeSystem==2)
|
|
TocarKeltner();
|
|
if(ExpertTradeSystem==3 && NovoCandle)
|
|
RetornoKeltner();
|
|
if(ExpertTradeSystem==4)
|
|
TocarKeltnerAcoes();
|
|
if(ExpertTradeSystem==5)
|
|
KeltnerAngulo();
|
|
}
|
|
|
|
if(((ExpertCompra==1 && Negociacao.Tipo=="Comprado") || (ExpertVenda==1 && Negociacao.Tipo=="Vendido"))){
|
|
Stop();
|
|
if(ExpertBreakeven_be==1)
|
|
BreakEven();
|
|
if(ExpertTrailstop_ts==1)
|
|
TrailStop();
|
|
}
|
|
|
|
if(ExpertCriar_pn)
|
|
AtualizarPainel();
|
|
if(ExpertDestaqueTPSL==1 && (Negociacao.StopLoss!=SL_Anterior || Negociacao.TakeProfit!=TP_Anterior || Negociacao.PrecoEntrada!=OP_Anterior)){
|
|
ObjectDelete(0, Prefixo+"PrecoAbertura");
|
|
ObjectDelete(0, Prefixo+"StopLoss");
|
|
ObjectDelete(0, Prefixo+"TakeProfit");
|
|
if((ObjectFind(0,Prefixo+"StopLoss")!=0 || ObjectFind(0,Prefixo+"TakeProfit")!=0 || ObjectFind(0,Prefixo+"PrecoAbertura")!=0) && TotalPosicao(Negociacao.Ativo,Negociacao.NumeroMagico)==1){
|
|
Linha_Horizontal(Prefixo+"PrecoAbertura",Negociacao.PrecoEntrada,1,ExpertCorOP,STYLE_SOLID);
|
|
Linha_Horizontal(Prefixo+"StopLoss",Negociacao.PrecoSL,1,ExpertCorSL,STYLE_SOLID);
|
|
Linha_Horizontal(Prefixo+"TakeProfit",Negociacao.PrecoTP,1,ExpertCorTP,STYLE_SOLID);
|
|
TP_Anterior=Negociacao.PrecoTP;
|
|
SL_Anterior=Negociacao.PrecoSL;
|
|
OP_Anterior=Negociacao.PrecoEntrada;
|
|
}
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| "Trade" event handler function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTrade(){
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| "ChartEvent" event handler function |
|
|
//+------------------------------------------------------------------+
|
|
void OnChartEvent(const int id,
|
|
const long &lparam,
|
|
const double &dparam,
|
|
const string &sparam){
|
|
//--- Move the panel with the mouse
|
|
if(ExpertCriar_pn)
|
|
MovePainel(id, lparam, dparam, sparam);
|
|
|
|
if(id==CHARTEVENT_OBJECT_CLICK){
|
|
if(sparam==Prefixo+"Button1"){
|
|
ClosePosicao(Negociacao.Ativo, Negociacao.NumeroMagico);
|
|
if(TotalPosicao(Negociacao.Ativo, Negociacao.NumeroMagico)==0){
|
|
Print("Posição encerrada com sucesso.");
|
|
ChartRedraw();
|
|
ReiniciarBoleta();
|
|
}
|
|
}
|
|
uint retorno=0;
|
|
if(sparam==Prefixo+"Button2" && MercadoAberto())
|
|
retorno=CompraMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
|
|
if(sparam==Prefixo+"Button3" && MercadoAberto())
|
|
retorno=VendaMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
|
|
if((sparam==Prefixo+"Button3" || sparam==Prefixo+"Button2") && !MercadoAberto())
|
|
Print(StatusBot());
|
|
if(retorno!=0 && retorno!=10008 && retorno!=10009)
|
|
Print("8 - Erro de operação: ", GetRetcodeID(retorno));
|
|
ZeroMemory(retorno);
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| "Timer" event handler function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTimer(){
|
|
//---
|
|
|
|
if(NovoDia(Negociacao.Ativo)){
|
|
UltimoCandle=Tick.time;
|
|
ReiniciarBoleta();
|
|
AtualizarFinanceiro(Negociacao.Ativo,Negociacao.NumeroMagico);
|
|
Print("------------------------------------Novo Dia------------------------------------");
|
|
if(ExpertAtivarBotTelegram==1){
|
|
string Mensagem = "\n---------------------------------------"+"\nBom dia pessoal, começando mais um pregão."+"\nDentro de instantes nosso robô entra em operação."+"\nBora para o gain e boa sorte para nós.";
|
|
bot.EnviaMensagem(ExpertUsuatioTelegram, ExpertComentario+Mensagem);
|
|
}
|
|
}
|
|
|
|
MetaFinanceira();
|
|
if(ExpertCriar_pn){
|
|
AtualizarPainel();
|
|
ChartRedraw();
|
|
}
|
|
|
|
if(ExpertAtivarBotTelegram==1){
|
|
bot.GetUpdates();
|
|
string mensagem=bot.ProcessMessages(ExpertComentario);
|
|
if(mensagem=="/saldo"){
|
|
AtualizarFinanceiro(Negociacao.Ativo,Negociacao.NumeroMagico);
|
|
string resumo = "Resumo financeiro EA\n";
|
|
resumo += "Dia: "+ (string)Financeiro.QtdeGainD1+"/"+(string)Financeiro.QtdeTradeD1+" ("+(string)Porcentagem(Financeiro.QtdeGainD1,Financeiro.QtdeTradeD1)+"%) - R$ "+(string)Financeiro.ResultadoD1+"\n";
|
|
resumo += "Semana: "+(string)Financeiro.QtdeGainW1+"/"+(string)Financeiro.QtdeTradeW1+" ("+(string)Porcentagem(Financeiro.QtdeGainW1,Financeiro.QtdeTradeW1)+"%) - R$ "+(string)Financeiro.ResultadoW1+"\n";
|
|
resumo += "Mês: "+ (string)Financeiro.QtdeGainMN+"/"+(string)Financeiro.QtdeTradeMN+" ("+(string)Porcentagem(Financeiro.QtdeGainMN,Financeiro.QtdeTradeMN)+"%) - R$ "+(string)Financeiro.ResultadoMN+"\n";
|
|
resumo += "Ano: "+ (string)Financeiro.QtdeGainY1+"/"+(string)Financeiro.QtdeTradeY1+" ("+(string)Porcentagem(Financeiro.QtdeGainY1,Financeiro.QtdeTradeY1)+"%) - R$ "+(string)Financeiro.ResultadoY1+"\n";
|
|
bot.SendMessage(ExpertUsuatioTelegram,resumo);
|
|
}
|
|
|
|
if(mensagem=="/zerar"){
|
|
Print("Zerando posições pelo Telegram");
|
|
ClosePosicao(Negociacao.Ativo, Negociacao.NumeroMagico);
|
|
if(TotalPosicao(Negociacao.Ativo, Negociacao.NumeroMagico)==0){
|
|
bot.SendMessage(ExpertUsuatioTelegram,"Posições zeradas com sucesso");
|
|
ReiniciarBoleta();
|
|
}
|
|
}
|
|
if(mensagem=="/ligar"){
|
|
Print("Ligando EA pelo Telegram");
|
|
Negociacao.Desligado = false;
|
|
}
|
|
if(mensagem=="/desligar"){
|
|
Print("Desligando EA pelo Telegram");
|
|
Negociacao.Desligado = true;
|
|
}
|
|
if(mensagem=="/status"){
|
|
bot.SendMessage(ExpertUsuatioTelegram,StatusBot());
|
|
}
|
|
if(mensagem=="/resumo"){
|
|
ResumoNegociacaoTelegram();
|
|
}
|
|
if(mensagem=="/reset"){
|
|
ReiniciarBoleta();
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| TradeTransaction function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTradeTransaction(const MqlTradeTransaction& trans,
|
|
const MqlTradeRequest& request,
|
|
const MqlTradeResult& result){
|
|
//---
|
|
ulong deal_magic =0;
|
|
ENUM_DEAL_ENTRY deal_entry;
|
|
ENUM_DEAL_REASON deal_reason;
|
|
ENUM_DEAL_TYPE deal_type;
|
|
double deal_profit=0;
|
|
|
|
if(trans.type==TRADE_TRANSACTION_DEAL_ADD && trans.symbol==Negociacao.Ativo){
|
|
if(HistoryDealSelect(trans.deal)){
|
|
deal_magic = HistoryDealGetInteger(trans.deal,DEAL_MAGIC);
|
|
deal_entry = (ENUM_DEAL_ENTRY) HistoryDealGetInteger(trans.deal,DEAL_ENTRY);
|
|
deal_reason = (ENUM_DEAL_REASON)HistoryDealGetInteger(trans.deal,DEAL_REASON);
|
|
deal_type = (ENUM_DEAL_TYPE) HistoryDealGetInteger(trans.deal,DEAL_TYPE);
|
|
if(deal_magic==Negociacao.NumeroMagico){
|
|
if(deal_entry==DEAL_ENTRY_IN){
|
|
if(!Negociacao.PosicaoAberta){
|
|
Negociacao.PosicaoAberta = true;
|
|
Negociacao.PrecoEntrada = trans.price;
|
|
Negociacao.Tipo = TipoPosicao(Negociacao.Ativo, Negociacao.NumeroMagico);
|
|
Negociacao.Ticket = PositionGetTicket(PosicaoAtual(Negociacao.Ativo, Negociacao.NumeroMagico));
|
|
Negociacao.TicketOrder = 0;
|
|
Negociacao.TotalOrder = 0;
|
|
Negociacao.TeveOrder = false;
|
|
Negociacao.PrecoUltOrder = Negociacao.PrecoEntrada;
|
|
Negociacao.QtdeUltOrder = 0.00;
|
|
Negociacao.MetaBatida = false;
|
|
Negociacao.Desligado = false;
|
|
Negociacao.FezBreakEven = false;
|
|
Negociacao.FezTrailStop = false;
|
|
Negociacao.PrecoTP = trans.price_tp;
|
|
Negociacao.PrecoSL = trans.price_sl;
|
|
}
|
|
|
|
Print("################### - Nova Operação - ######################");
|
|
ResumoNegociacao();
|
|
if(ExpertAtivarBotTelegram==1)
|
|
ResumoNegociacaoTelegram();
|
|
}
|
|
|
|
if(deal_entry!=DEAL_ENTRY_IN){
|
|
if((ENUM_DEAL_REASON) deal_reason==DEAL_REASON_TP || (ENUM_DEAL_REASON) deal_reason==DEAL_REASON_SL || (ENUM_DEAL_REASON)deal_reason==DEAL_REASON_EXPERT || (ENUM_DEAL_REASON)deal_reason==DEAL_REASON_CLIENT){
|
|
Print("############# Fechando Operação #############");
|
|
ObjectDelete(0, Prefixo+"PrecoAbertura");
|
|
ObjectDelete(0, Prefixo+"StopLoss");
|
|
ObjectDelete(0, Prefixo+"TakeProfit");
|
|
TP_Anterior=0.00;
|
|
SL_Anterior=0.00;
|
|
OP_Anterior=0.00;
|
|
|
|
|
|
ReiniciarBoleta();
|
|
ResumoNegociacao();
|
|
deal_profit= NormalizeDouble(HistoryDealGetDouble(trans.deal,DEAL_PROFIT),2);
|
|
|
|
Financeiro.ResultadoY1+=deal_profit;
|
|
Financeiro.ResultadoD1+=deal_profit;
|
|
Financeiro.ResultadoW1+=deal_profit;
|
|
Financeiro.ResultadoMN+=deal_profit;
|
|
|
|
if(Financeiro.ResultadoD1>Financeiro.ResultadoMaxD1)
|
|
Financeiro.ResultadoMaxD1=Financeiro.ResultadoD1;
|
|
|
|
Financeiro.QtdeTradeY1+=1;
|
|
Financeiro.QtdeTradeD1+=1;
|
|
Financeiro.QtdeTradeW1+=1;
|
|
Financeiro.QtdeTradeMN+=1;
|
|
|
|
if(deal_profit>0){
|
|
Financeiro.QtdeGainY1+=1;
|
|
Financeiro.QtdeGainD1+=1;
|
|
Financeiro.QtdeGainW1+=1;
|
|
Financeiro.QtdeGainMN+=1;
|
|
}
|
|
if(deal_profit<0){
|
|
Financeiro.QtdeLossY1+=1;
|
|
Financeiro.QtdeLossD1+=1;
|
|
Financeiro.QtdeLossW1+=1;
|
|
Financeiro.QtdeLossMN+=1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Validaçãoes |
|
|
//+------------------------------------------------------------------+
|
|
bool Validacoes(){
|
|
if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED)){
|
|
Alert("Verifique se a negociação automatizada é permitida nas configurações do terminal!");
|
|
return(false);
|
|
}else{
|
|
if(!MQLInfoInteger(MQL_TRADE_ALLOWED)){
|
|
Alert("A negociação automatizada é proibida nas configurações do ",__FILE__);
|
|
return(false);
|
|
}
|
|
}
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Configurações Iniciais |
|
|
//+------------------------------------------------------------------+
|
|
void ConfiguraoInicial(){
|
|
//Remove grade do gráfico
|
|
ChartSetInteger(0,CHART_SHOW_GRID, false);
|
|
ChartSetInteger(0,CHART_COLOR_CHART_UP,clrGreen);
|
|
ChartSetInteger(0,CHART_COLOR_CHART_DOWN,clrRed);
|
|
ChartSetInteger(0,CHART_COLOR_CANDLE_BEAR,clrWhite);
|
|
ChartSetInteger(0,CHART_COLOR_CANDLE_BULL,clrWhite);
|
|
ChartSetInteger(0,CHART_AUTOSCROLL,true);
|
|
ChartSetInteger(0,CHART_MODE,CHART_CANDLES);
|
|
ChartSetInteger(0,CHART_SHOW_LAST_LINE,false);
|
|
ChartSetInteger(0,CHART_SHIFT,true);
|
|
if(ExpertDestaqueTPSL==1)
|
|
ChartSetInteger(0,CHART_COLOR_STOP_LEVEL,0,clrNONE);
|
|
else
|
|
ChartSetInteger(0,CHART_COLOR_STOP_LEVEL,0,clrRed);
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Inicializar Indicadores |
|
|
//+------------------------------------------------------------------+
|
|
int InicializarIndicadores(){
|
|
int subwindow;
|
|
if(ExpertAtivarKeltner==1){
|
|
Keltner_Handle = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkKeltner, Negociacao.Periodo, ExpertMM_Keltner, ExpertPeriodo_Keltner, ExpertDesvio_Keltner, ExpertCalc_Price);
|
|
ChartIndicatorAdd(0,0,Keltner_Handle);
|
|
ChartIndicatorAdd(2,0,Keltner_Handle);
|
|
ChartIndicatorAdd(3,0,Keltner_Handle);
|
|
}
|
|
|
|
if(ExpertAtivarVWAP==1){
|
|
VWAP_Handle = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkVWap, "VWAP", ExpertPrice_Type, (ExpertCalc_Every_Tick==1), (ExpertEnable_Daily==1), (ExpertShow_Daily_Value==1), (ExpertEnable_Weekly==1), (ExpertShow_Weekly_Value==1), (ExpertEnable_Monthly==1), (ExpertShow_Monthly_Value==1));
|
|
ChartIndicatorAdd(0,0,VWAP_Handle);
|
|
ChartIndicatorAdd(1,0,VWAP_Handle);
|
|
ChartIndicatorAdd(2,0,VWAP_Handle);
|
|
}
|
|
|
|
if(ExpertAtivarSATL==1){
|
|
SATL_Handle = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkSATL);
|
|
ChartIndicatorAdd(0,0,SATL_Handle);
|
|
}
|
|
|
|
if(ExpertAtivarFATL==1){
|
|
FATL_Handle = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkFATL);
|
|
ChartIndicatorAdd(0,0,FATL_Handle);
|
|
}
|
|
|
|
if(ExpertAtivarMediaRapida==1){
|
|
Rapida_Handle = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkMediaMovel, ExpertRapidaPeriodo, 0, ExpertRapidaMetodo, ExpertRapidaCor, ExpertRapidaEstilo, ExpertRapidaEspessura);
|
|
ChartIndicatorAdd(0,0,Rapida_Handle);
|
|
}
|
|
|
|
if(ExpertAtivarMediaLenta==1){
|
|
Lenta_Handle = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkMediaMovel, ExpertLentaPeriodo, 0, ExpertLentaMetodo, ExpertLentaCor, ExpertLentaEstilo, ExpertLentaEspessura);
|
|
ChartIndicatorAdd(0,0,Lenta_Handle);
|
|
}
|
|
|
|
if(ExpertAtivarEstocastico==1){
|
|
subwindow = (int)ChartGetInteger(0,CHART_WINDOWS_TOTAL);
|
|
Stochastic_Handle= iStochastic(Negociacao.Ativo, Negociacao.Periodo, ExpertPeriodo_K, ExpertPeriodo_D, ExpertSlowing, ExpertMethod, ExpertPrice_Field);
|
|
ChartIndicatorAdd(0,subwindow,Stochastic_Handle);
|
|
}
|
|
|
|
if(ExpertAtivarGrau==1){
|
|
subwindow = (int)ChartGetInteger(0,CHART_WINDOWS_TOTAL);
|
|
Angulo_Handle = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkAngulo, ExpertMAPeriod, ExpertMAType, ExpertMAPrice, ExpertAngleBars, ExpertAngleLevel);
|
|
ChartIndicatorAdd(0,subwindow,Angulo_Handle);
|
|
}
|
|
|
|
if(ExpertAtivarRegressaoLinear==1){
|
|
subwindow = (int)ChartGetInteger(0,CHART_WINDOWS_TOTAL);
|
|
Regressao_Handle = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkRegressao, ExpertRLPeriodo, ExpertRLDesvio);
|
|
ChartIndicatorAdd(0,subwindow,Regressao_Handle);
|
|
}
|
|
|
|
if(ExpertAtivarZScore==1){
|
|
subwindow = (int)ChartGetInteger(0,CHART_WINDOWS_TOTAL);
|
|
ZScore_Handle = iCustom(Negociacao.Ativo, Negociacao.Periodo, LinkZScore, ExpertZSPeriodo, ExpertZSPreco, ExpertZSDesvio);
|
|
ChartIndicatorAdd(0,subwindow,ZScore_Handle);
|
|
}
|
|
|
|
if(Keltner_Handle<0 || VWAP_Handle<0 || SATL_Handle<0 || FATL_Handle<0 || Rapida_Handle<0 || Lenta_Handle<0 || Stochastic_Handle<0 || Angulo_Handle<0 || Regressao_Handle<0 || ZScore_Handle<0){
|
|
Alert("Erro ao tentar criar Handles para o indicador - erro: ",GetLastError(),"!");
|
|
return(INIT_FAILED);
|
|
}
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Atualizar Indicadores |
|
|
//+------------------------------------------------------------------+
|
|
void AtualizarIndicadores(){
|
|
//--- Alimentar Buffers das Velas com dados:
|
|
CopyRates(Negociacao.Ativo,Negociacao.Periodo,0,QtdeBuffer,Precos);
|
|
ArraySetAsSeries(Precos,true);
|
|
|
|
if(ExpertAtivarKeltner==1){
|
|
CopyBuffer(Keltner_Handle, 0, 0, QtdeBuffer, Keltner_Middle);
|
|
CopyBuffer(Keltner_Handle, 2, 0, QtdeBuffer, Keltner_Up);
|
|
CopyBuffer(Keltner_Handle, 3, 0, QtdeBuffer, Keltner_Down);
|
|
// Ordenar o vetor de dados:
|
|
ArraySetAsSeries(Keltner_Middle, true);
|
|
ArraySetAsSeries(Keltner_Up, true);
|
|
ArraySetAsSeries(Keltner_Down, true);
|
|
}
|
|
if(ExpertAtivarVWAP==1){
|
|
CopyBuffer(VWAP_Handle, 0, 0, QtdeBuffer, VWAP_DIA);
|
|
CopyBuffer(VWAP_Handle, 1, 0, QtdeBuffer, VWAP_SEMANA);
|
|
CopyBuffer(VWAP_Handle, 2, 0, QtdeBuffer, VWAP_MES);
|
|
// Ordenar o vetor de dados:
|
|
ArraySetAsSeries(VWAP_DIA, true);
|
|
ArraySetAsSeries(VWAP_SEMANA, true);
|
|
ArraySetAsSeries(VWAP_MES, true);
|
|
}
|
|
if(ExpertAtivarFATL==1){
|
|
CopyBuffer(FATL_Handle, 0, 0, QtdeBuffer, FATL_Buffer);
|
|
ArraySetAsSeries(FATL_Buffer, true);
|
|
}
|
|
if(ExpertAtivarSATL==1){
|
|
CopyBuffer(SATL_Handle, 0, 0, QtdeBuffer, SATL_Buffer);
|
|
ArraySetAsSeries(SATL_Buffer, true);
|
|
}
|
|
if(ExpertAtivarMediaRapida==1){
|
|
CopyBuffer(Rapida_Handle,0,0,QtdeBuffer,Rapida_Buffer);
|
|
ArraySetAsSeries(Rapida_Buffer,true);
|
|
}
|
|
if(ExpertAtivarMediaLenta==1){
|
|
CopyBuffer(Lenta_Handle,0,0,QtdeBuffer,Lenta_Buffer);
|
|
ArraySetAsSeries(Lenta_Buffer,true);
|
|
}
|
|
if(ExpertAtivarEstocastico==1){
|
|
CopyBuffer(Stochastic_Handle,0,0,QtdeBuffer,Stochastic_Buffer);
|
|
ArraySetAsSeries(Stochastic_Buffer,true);
|
|
}
|
|
if(ExpertAtivarGrau==1){
|
|
CopyBuffer(Angulo_Handle,0,0,QtdeBuffer,Angulo_Buffer);
|
|
ArraySetAsSeries(Angulo_Buffer,true);
|
|
}
|
|
if(ExpertAtivarRegressaoLinear==1){
|
|
CopyBuffer(Regressao_Handle,0,0,QtdeBuffer,Regressao_Buffer);
|
|
ArraySetAsSeries(Regressao_Buffer,true);
|
|
}
|
|
if(ExpertAtivarZScore==1){
|
|
CopyBuffer(ZScore_Handle,0,0,QtdeBuffer,ZScore_Buffer);
|
|
ArraySetAsSeries(ZScore_Buffer,true);
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Atualizar Painel |
|
|
//+------------------------------------------------------------------+
|
|
void AtualizarPainel(){
|
|
double Ping = TerminalInfoInteger(TERMINAL_PING_LAST);
|
|
double Latencia=NormalizeDouble(Ping/1000,2);
|
|
d_label1.Text(Hora(TimeTradeServer()));
|
|
d_label2.Text(Data(SymbolInfoInteger(Negociacao.Ativo,SYMBOL_EXPIRATION_TIME)));
|
|
d_label3.Text(Negociacao.Ativo);
|
|
//d_label4.Text(Hora(TimeLocal()));
|
|
d_label4.Text(TimerCandle(UltimoCandle));
|
|
d_label5.Text((string)SymbolInfoInteger(Negociacao.Ativo,SYMBOL_SPREAD));
|
|
d_label6.Text(DoubleToString(Tick.last, _Digits));
|
|
d_label7.Text((string)Financeiro.QtdeGainD1+"/"+(string)Financeiro.QtdeTradeD1+" ("+(string)Porcentagem(Financeiro.QtdeGainD1,Financeiro.QtdeTradeD1)+"%)");
|
|
d_label8.Text((string)Financeiro.QtdeGainW1+"/"+(string)Financeiro.QtdeTradeW1+" ("+(string)Porcentagem(Financeiro.QtdeGainW1,Financeiro.QtdeTradeW1)+"%)");
|
|
d_label9.Text((string)Financeiro.QtdeGainMN+"/"+(string)Financeiro.QtdeTradeMN+" ("+(string)Porcentagem(Financeiro.QtdeGainMN,Financeiro.QtdeTradeMN)+"%)");
|
|
d_label10.Text((string)Financeiro.QtdeGainY1+"/"+(string)Financeiro.QtdeTradeY1+" ("+(string)Porcentagem(Financeiro.QtdeGainY1,Financeiro.QtdeTradeY1)+"%)");
|
|
d_label11.Text(DoubleToString(NormalizeDouble(Financeiro.ResultadoD1, 2),2)+MoedaCorrente);
|
|
d_label12.Text(DoubleToString(NormalizeDouble(Financeiro.ResultadoW1, 2),2)+MoedaCorrente);
|
|
d_label13.Text(DoubleToString(NormalizeDouble(Financeiro.ResultadoMN, 2),2)+MoedaCorrente);
|
|
d_label14.Text(DoubleToString(NormalizeDouble(Financeiro.ResultadoY1, 2),2)+MoedaCorrente);
|
|
d_label15.Text(TipoConta());
|
|
d_label16.Text(DoubleToString(Latencia,2));
|
|
d_label17.Text(DoubleToString(NormalizeDouble(AccountInfoDouble(ACCOUNT_BALANCE),2),2)+MoedaCorrente);
|
|
d_label18.Text(Negociacao.Tipo);
|
|
d_label19.Text("0");
|
|
d_label20.Text("0.00"+MoedaCorrente);
|
|
if(Posicionado(Negociacao.Ativo, Negociacao.NumeroMagico)){
|
|
d_label19.Text((string)PositionGetDouble(POSITION_VOLUME));
|
|
d_label20.Text(DoubleToString(NormalizeDouble(LucroAtual(Negociacao.Ativo, Negociacao.NumeroMagico),2),2)+MoedaCorrente);
|
|
}
|
|
d_label21.Text(StatusBot());
|
|
// ChartRedraw();
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Reiniciar Boleta |
|
|
//+------------------------------------------------------------------+
|
|
void ReiniciarBoleta(){
|
|
ZeroMemory(Negociacao);
|
|
Negociacao.Ativo = _Symbol;
|
|
Negociacao.Periodo = _Period;
|
|
Negociacao.Moeda = " "+(string)AccountInfoString(ACCOUNT_CURRENCY);
|
|
Negociacao.Tipo = TipoPosicao(Negociacao.Ativo, ExpertNumeroMagico);
|
|
Negociacao.NumeroMagico = ExpertNumeroMagico;
|
|
Negociacao.StopLoss = ExpertLoss;
|
|
Negociacao.TakeProfit = ExpertGain;
|
|
Negociacao.TotalOrder = 0;
|
|
Negociacao.PosicaoAberta = false;
|
|
Negociacao.TeveOrder = false;
|
|
Negociacao.MetaBatida = false;
|
|
Negociacao.Desligado = false;
|
|
Negociacao.Encerrado = false;
|
|
Negociacao.FezBreakEven = false;
|
|
Negociacao.FezTrailStop = false;
|
|
Negociacao.Ticket = 0;
|
|
Negociacao.TicketOrder = 0;
|
|
Negociacao.PrecoEntrada = 0.00;
|
|
Negociacao.PrecoTP = 0.00;
|
|
Negociacao.PrecoSL = 0.00;
|
|
Negociacao.PrecoUltOrder = 0.00;
|
|
Negociacao.QtdeUltOrder = 0.00;
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Reiniciar Boleta |
|
|
//+------------------------------------------------------------------+
|
|
void RecuperaBoleta(){
|
|
ZeroMemory(Negociacao);
|
|
Negociacao.Ativo = _Symbol;
|
|
Negociacao.Periodo = _Period;
|
|
Negociacao.Moeda = " "+(string)AccountInfoString(ACCOUNT_CURRENCY);
|
|
Negociacao.Tipo = TipoPosicao(Negociacao.Ativo, ExpertNumeroMagico);
|
|
Negociacao.NumeroMagico = ExpertNumeroMagico;
|
|
Negociacao.StopLoss = ExpertLoss;
|
|
Negociacao.TakeProfit = ExpertGain;
|
|
Negociacao.TotalOrder = TotalOrdem(Negociacao.Ativo, ExpertNumeroMagico);
|
|
Negociacao.PosicaoAberta = TotalPosicao(Negociacao.Ativo, ExpertNumeroMagico)>0;
|
|
Negociacao.TeveOrder = TotalOrdem(Negociacao.Ativo, ExpertNumeroMagico)>0;
|
|
Negociacao.MetaBatida = false;
|
|
Negociacao.Desligado = false;
|
|
Negociacao.Encerrado = false;
|
|
Negociacao.FezBreakEven = false;
|
|
Negociacao.FezTrailStop = false;
|
|
Negociacao.Ticket = PositionGetTicket(PosicaoAtual(Negociacao.Ativo, Negociacao.NumeroMagico));
|
|
Negociacao.PrecoEntrada = PositionGetDouble(POSITION_PRICE_OPEN);
|
|
Negociacao.PrecoTP = PositionGetDouble(POSITION_TP);
|
|
Negociacao.PrecoSL = PositionGetDouble(POSITION_SL);
|
|
uint ultimaOrdem = UltimaOrdem(Negociacao.Ativo, Negociacao.NumeroMagico);
|
|
Negociacao.TicketOrder = OrderGetTicket(ultimaOrdem);
|
|
Negociacao.PrecoUltOrder = OrderGetDouble(ORDER_PRICE_OPEN);
|
|
Negociacao.QtdeUltOrder = OrderGetDouble(ORDER_VOLUME_CURRENT);
|
|
TP_Anterior=ObjectGetDouble(0,Prefixo+"PrecoAbertura",OBJPROP_PRICE,0);
|
|
SL_Anterior=ObjectGetDouble(0,Prefixo+"StopLoss",OBJPROP_PRICE,0);
|
|
OP_Anterior=ObjectGetDouble(0,Prefixo+"TakeProfit",OBJPROP_PRICE,0);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Atualizar Financeiro |
|
|
//+------------------------------------------------------------------+
|
|
void AtualizarFinanceiro(string Ativo, long numeromagioco){
|
|
ZeroMemory(Financeiro);
|
|
string deal_simbol;
|
|
ulong deal_magic = 0;
|
|
ulong ticket = 0;
|
|
ENUM_DEAL_ENTRY deal_entry;
|
|
ENUM_DEAL_REASON deal_reason;
|
|
double deal_profit = 0;
|
|
double lucro_dia = 0;
|
|
long PosicaoAnterior = 0;
|
|
datetime InicioAno = GetTimeFrame(Y1);
|
|
datetime InicioMes = GetTimeFrame(MN1);
|
|
datetime InicioSemana = GetTimeFrame(W1);
|
|
datetime InicioDia = GetTimeFrame(D1);
|
|
|
|
HistorySelect(InicioAno,TimeCurrent());
|
|
int totalHistory = HistoryDealsTotal();
|
|
|
|
for(int i=0;i<totalHistory;i++){
|
|
if((ticket=HistoryDealGetTicket(i))>0){
|
|
deal_magic = HistoryDealGetInteger(ticket,DEAL_MAGIC);
|
|
deal_simbol = HistoryDealGetString(ticket, DEAL_SYMBOL);
|
|
deal_entry = (ENUM_DEAL_ENTRY)HistoryDealGetInteger(ticket,DEAL_ENTRY);
|
|
deal_reason = (ENUM_DEAL_REASON)HistoryDealGetInteger(ticket,DEAL_REASON);
|
|
bool Condicao1 = deal_magic==numeromagioco && deal_simbol==Ativo && deal_entry!=DEAL_ENTRY_IN;
|
|
bool Condicao2 = (ENUM_DEAL_REASON)deal_reason==DEAL_REASON_TP || (ENUM_DEAL_REASON)deal_reason==DEAL_REASON_SL || (ENUM_DEAL_REASON)deal_reason==DEAL_REASON_EXPERT;
|
|
if(Condicao1 && Condicao2){
|
|
deal_profit= NormalizeDouble(HistoryDealGetDouble(ticket,DEAL_PROFIT),2);
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioDia)
|
|
Financeiro.ResultadoD1+=deal_profit;
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioSemana)
|
|
Financeiro.ResultadoW1+=deal_profit;
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioMes)
|
|
Financeiro.ResultadoMN+=deal_profit;
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioAno)
|
|
Financeiro.ResultadoY1+=deal_profit;
|
|
|
|
if(HistoryDealGetInteger(ticket,DEAL_POSITION_ID)!=PosicaoAnterior){
|
|
PosicaoAnterior = HistoryDealGetInteger(ticket,DEAL_POSITION_ID);
|
|
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioDia)
|
|
Financeiro.QtdeTradeD1+=1;
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioSemana)
|
|
Financeiro.QtdeTradeW1+=1;
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioMes)
|
|
Financeiro.QtdeTradeMN+=1;
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioAno)
|
|
Financeiro.QtdeTradeY1+=1;
|
|
|
|
if(deal_profit>0){
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioDia){
|
|
Financeiro.QtdeGainD1+=1;
|
|
lucro_dia+=deal_profit;
|
|
}
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioSemana)
|
|
Financeiro.QtdeGainW1+=1;
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioMes)
|
|
Financeiro.QtdeGainMN+=1;
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioAno)
|
|
Financeiro.QtdeGainY1+=1;
|
|
}
|
|
if(deal_profit<0){
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioDia)
|
|
Financeiro.QtdeLossD1+=1;
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioSemana)
|
|
Financeiro.QtdeLossW1+=1;
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioMes)
|
|
Financeiro.QtdeLossMN+=1;
|
|
if((datetime)HistoryDealGetInteger(ticket,DEAL_TIME)>=InicioAno)
|
|
Financeiro.QtdeLossY1+=1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if((ExpertGanho_mf==1 && Financeiro.ResultadoD1>=ExpertMetaGanho_mf) || (ExpertPerca_mf==1 && Financeiro.ResultadoD1<=(lucro_dia-ExpertMetaPerda_mf)))
|
|
Negociacao.MetaBatida=true;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Meta Financeira |
|
|
//+------------------------------------------------------------------+
|
|
void MetaFinanceira(){
|
|
//-----> Meta Financeira
|
|
if((ExpertGanho_mf==1 && Financeiro.ResultadoD1>=ExpertMetaGanho_mf) || (ExpertPerca_mf==1 && Financeiro.ResultadoD1<=(Financeiro.ResultadoMaxD1-ExpertMetaPerda_mf)))
|
|
Negociacao.MetaBatida=true;
|
|
if(ExpertPerca_mf==1 && (Financeiro.ResultadoD1+LucroAtual(Negociacao.Ativo, Negociacao.NumeroMagico))<=(Financeiro.ResultadoMaxD1-ExpertMetaPerda_mf))
|
|
Negociacao.MetaBatida=true;
|
|
|
|
if((ExpertGanho_mf==1 || ExpertPerca_mf==1) && Negociacao.MetaBatida && !Negociacao.Encerrado){
|
|
Print("Meta Batida R$: "+(string)Financeiro.ResultadoD1+"------"+(string)TimeCurrent()+"--------------------------------------------------");
|
|
Print("Dia: "+(string)Financeiro.QtdeGainD1+"/"+(string)Financeiro.QtdeTradeD1+" Resultado Financeiro: "+(string)Financeiro.ResultadoD1);
|
|
Print("Semana: "+(string)Financeiro.QtdeGainW1+"/"+(string)Financeiro.QtdeTradeW1+" Resultado Financeiro: "+(string)Financeiro.ResultadoW1);
|
|
Print("Mês: "+(string)Financeiro.QtdeGainMN+"/"+(string)Financeiro.QtdeTradeMN+" Resultado Financeiro: "+(string)Financeiro.ResultadoMN);
|
|
Print("Ano: "+(string)Financeiro.QtdeGainY1+"/"+(string)Financeiro.QtdeTradeY1+" Resultado Financeiro: "+(string)Financeiro.ResultadoY1);
|
|
ClosePosicao(Negociacao.Ativo, Negociacao.NumeroMagico);
|
|
ReiniciarBoleta();
|
|
Negociacao.MetaBatida=true;
|
|
Negociacao.Encerrado=true;
|
|
if(ExpertDesativarTerminal==1)
|
|
TerminalClose(0);
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Status do EA |
|
|
//+------------------------------------------------------------------+
|
|
string StatusBot(){
|
|
datetime lastbar_time = (datetime)SeriesInfoInteger(Negociacao.Ativo,PERIOD_M1,SERIES_LASTBAR_DATE);
|
|
bool Aberto = lastbar_time>=StringToTime(ExpertHoraInicio_hr) && lastbar_time<StringToTime(ExpertHoraFim_hr);
|
|
bool MetaFinanceira = Negociacao.MetaBatida;
|
|
bool Conectado = TerminalInfoInteger(TERMINAL_CONNECTED);
|
|
bool Intervalo = true;
|
|
|
|
if(ExpertIntervalo_Volta_hr!="0" && ExpertIntervalo_Parar_hr!="0")
|
|
Intervalo = (lastbar_time<=StringToTime(ExpertIntervalo_Parar_hr) || lastbar_time>=StringToTime(ExpertIntervalo_Volta_hr));
|
|
|
|
if(!Aberto && !Negociacao.Desligado && Conectado)
|
|
return("Fora do horário de operação");
|
|
if(Aberto && Intervalo && !MetaFinanceira && !Negociacao.PosicaoAberta && !Intervalo && !Negociacao.Desligado && Conectado)
|
|
return("Aguardando novo sinal");
|
|
if(Aberto && Intervalo && !MetaFinanceira && Negociacao.PosicaoAberta && !Negociacao.Desligado && Conectado)
|
|
return("Posicionado");
|
|
if(Aberto && !Intervalo && !MetaFinanceira && !Negociacao.PosicaoAberta && !Negociacao.Desligado && Conectado)
|
|
return("Parada para intervalo programado");
|
|
if(MetaFinanceira && !Negociacao.Desligado && Conectado)
|
|
return("Meta financeira atingida");
|
|
if(Negociacao.Desligado && Conectado)
|
|
return("EA desligado pelo Telegram");
|
|
if(!Conectado)
|
|
return("Sem conexão com corretora");
|
|
return("Aguardando novo sinal");
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Atualização Stop Loss / Take Profit |
|
|
//+------------------------------------------------------------------+
|
|
void Stop(){
|
|
if(Negociacao.PosicaoAberta && !Negociacao.FezBreakEven && !Negociacao.FezTrailStop){
|
|
double TakeProfit = 0.00;
|
|
double StopLoss = 0.00;
|
|
if(Negociacao.Tipo=="Comprado"){
|
|
TakeProfit=Negociacao.PrecoEntrada+Negociacao.TakeProfit;
|
|
StopLoss =Negociacao.PrecoEntrada-Negociacao.StopLoss;
|
|
}
|
|
if(Negociacao.Tipo=="Vendido"){
|
|
TakeProfit=Negociacao.PrecoEntrada-Negociacao.TakeProfit;
|
|
StopLoss =Negociacao.PrecoEntrada+Negociacao.StopLoss;
|
|
}
|
|
TakeProfit = NormalizarPreco(Negociacao.Ativo, TakeProfit);
|
|
StopLoss = NormalizarPreco(Negociacao.Ativo, StopLoss);
|
|
|
|
PositionSelectByTicket(Negociacao.Ticket);
|
|
bool Condicao1 = Negociacao.Tipo=="Comprado" || Negociacao.Tipo=="Vendido";
|
|
bool Condicao2 = TakeProfit!=PositionGetDouble(POSITION_TP) || StopLoss!=PositionGetDouble(POSITION_SL);
|
|
bool Condicao3 = TakeProfit!=0 && StopLoss!=0;
|
|
bool Condicao4 = Negociacao.Ticket==PositionGetInteger(POSITION_TICKET);
|
|
|
|
//bool Condicao5 = CheckStopLoss_Takeprofit((ENUM_ORDER_TYPE)PositionGetInteger(POSITION_TYPE), Negociacao.PrecoEntrada, StopLoss, TakeProfit);
|
|
|
|
if(Condicao1 && Condicao2 && Condicao3 && Condicao4){
|
|
uint retorno=0;
|
|
Print("############# Atualizando SL/TP #############");
|
|
retorno = AtualizaTPSL(Negociacao.Ativo, Negociacao.Ticket, NormalizarPreco(Negociacao.Ativo, TakeProfit), NormalizarPreco(Negociacao.Ativo, StopLoss), Negociacao.NumeroMagico);
|
|
if(retorno==10008 || retorno==10009){
|
|
Negociacao.PrecoTP=NormalizarPreco(Negociacao.Ativo, TakeProfit);
|
|
Negociacao.PrecoSL=NormalizarPreco(Negociacao.Ativo, StopLoss);
|
|
Negociacao.PrecoEntrada=PositionGetDouble(POSITION_PRICE_OPEN);
|
|
ResumoNegociacao();
|
|
}else
|
|
if(retorno!=0 && retorno!=10008 && retorno!=10009)
|
|
Print("5 - Erro de operação: ", GetRetcodeID(retorno));
|
|
}
|
|
//https://www.mql5.com/pt/articles/2555 TRADE_RETCODE_NO_CHANGES
|
|
ZeroMemory(TakeProfit);
|
|
ZeroMemory(StopLoss);
|
|
}
|
|
}
|
|
|
|
//https://www.mql5.com/pt/articles/2555 TRADE_RETCODE_NO_CHANGES
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| BreakEven |
|
|
//+------------------------------------------------------------------+
|
|
void BreakEven(){
|
|
if(Negociacao.PosicaoAberta && !Negociacao.FezBreakEven){
|
|
double TakeProfit = 0.00;
|
|
double StopLoss = 0.00;
|
|
if(Negociacao.Tipo=="Comprado" && Tick.last>Negociacao.PrecoEntrada+ExpertDistancia_be){
|
|
TakeProfit=Negociacao.PrecoEntrada+Negociacao.TakeProfit;
|
|
StopLoss =Negociacao.PrecoEntrada+ExpertProtecao_be;
|
|
}
|
|
if(Negociacao.Tipo=="Vendido" && Tick.last<Negociacao.PrecoEntrada-ExpertDistancia_be){
|
|
TakeProfit=Negociacao.PrecoEntrada-Negociacao.TakeProfit;
|
|
StopLoss =Negociacao.PrecoEntrada-ExpertProtecao_be;
|
|
}
|
|
|
|
PositionSelectByTicket(Negociacao.Ticket);
|
|
bool Condicao1 = (Negociacao.Tipo=="Comprado" && StopLoss>Negociacao.PrecoSL) || (Negociacao.Tipo=="Vendido" && StopLoss<Negociacao.PrecoSL);
|
|
bool Condicao2 = TakeProfit!=Negociacao.PrecoTP || StopLoss!=Negociacao.PrecoSL;
|
|
bool Condicao3 = TakeProfit!=0 && StopLoss!=0;
|
|
bool Condicao4 = Negociacao.Ticket==PositionGetInteger(POSITION_TICKET);
|
|
//bool Condicao5 = CheckStopLoss_Takeprofit((ENUM_ORDER_TYPE)PositionGetInteger(POSITION_TYPE), Negociacao.PrecoEntrada, StopLoss, TakeProfit);
|
|
if(Condicao1 && Condicao2 && Condicao3 && Condicao4){
|
|
uint retorno=0;
|
|
Print("############# Break Even #############");
|
|
retorno = AtualizaTPSL(Negociacao.Ativo, Negociacao.Ticket, NormalizarPreco(Negociacao.Ativo, TakeProfit), NormalizarPreco(Negociacao.Ativo, StopLoss), Negociacao.NumeroMagico);
|
|
if(retorno==10008 || retorno==10009){
|
|
Negociacao.FezBreakEven=true;
|
|
Negociacao.PrecoTP=NormalizarPreco(Negociacao.Ativo, TakeProfit);
|
|
Negociacao.PrecoSL=NormalizarPreco(Negociacao.Ativo, StopLoss);
|
|
Negociacao.PrecoEntrada=PositionGetDouble(POSITION_PRICE_OPEN);
|
|
ResumoNegociacao();
|
|
}else
|
|
if(retorno!=0 && retorno!=10008 && retorno!=10009)
|
|
Print("6 - Erro de operação: ", GetRetcodeID(retorno));
|
|
}
|
|
ZeroMemory(TakeProfit);
|
|
ZeroMemory(StopLoss);
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| TrailStop |
|
|
//+------------------------------------------------------------------+
|
|
void TrailStop(){
|
|
if(Negociacao.PosicaoAberta){
|
|
double TakeProfit = 0.00;
|
|
double StopLoss = 0.00;
|
|
if(Negociacao.Tipo=="Comprado" && Tick.last>Negociacao.PrecoEntrada+ExpertDistancia_ts){
|
|
TakeProfit=Negociacao.PrecoEntrada+Negociacao.TakeProfit;
|
|
StopLoss =Tick.last-ExpertProtecao_ts;
|
|
}
|
|
if(Negociacao.Tipo=="Vendido" && Tick.last<Negociacao.PrecoEntrada-ExpertDistancia_ts){
|
|
TakeProfit=Negociacao.PrecoEntrada-Negociacao.TakeProfit;
|
|
StopLoss =Tick.last+ExpertProtecao_ts;
|
|
}
|
|
|
|
PositionSelectByTicket(Negociacao.Ticket);
|
|
bool Condicao1 = (Negociacao.Tipo=="Comprado" && StopLoss>Negociacao.PrecoSL+ExpressStep_ts) || (Negociacao.Tipo=="Vendido" && StopLoss<Negociacao.PrecoSL-ExpressStep_ts);
|
|
bool Condicao2 = TakeProfit!=Negociacao.PrecoTP || StopLoss!=Negociacao.PrecoSL;
|
|
bool Condicao3 = TakeProfit!=0 && StopLoss!=0;
|
|
bool Condicao4 = Negociacao.Ticket==PositionGetInteger(POSITION_TICKET);
|
|
//bool Condicao5 = CheckStopLoss_Takeprofit((ENUM_ORDER_TYPE)PositionGetInteger(POSITION_TYPE), Negociacao.PrecoEntrada, StopLoss, TakeProfit);
|
|
if(Condicao1 && Condicao2 && Condicao3 && Condicao4){
|
|
uint retorno=0;
|
|
Print("############# Trail Stop #############");
|
|
retorno = AtualizaTPSL(Negociacao.Ativo, Negociacao.Ticket, NormalizarPreco(Negociacao.Ativo, TakeProfit), NormalizarPreco(Negociacao.Ativo, StopLoss), Negociacao.NumeroMagico);
|
|
|
|
if(retorno==10008 || retorno==10009){
|
|
Negociacao.FezTrailStop=true;
|
|
Negociacao.PrecoTP=NormalizarPreco(Negociacao.Ativo, TakeProfit);
|
|
Negociacao.PrecoSL=NormalizarPreco(Negociacao.Ativo, StopLoss);
|
|
Negociacao.PrecoEntrada=PositionGetDouble(POSITION_PRICE_OPEN);
|
|
ResumoNegociacao();
|
|
}else
|
|
if(retorno!=0 && retorno!=10008 && retorno!=10009)
|
|
Print("7 - Erro de operação: ", GetRetcodeID(retorno));
|
|
}
|
|
ZeroMemory(TakeProfit);
|
|
ZeroMemory(StopLoss);
|
|
}
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Permição para Operar |
|
|
//+------------------------------------------------------------------+
|
|
bool MercadoAberto(){
|
|
datetime horario=TimeCurrent();
|
|
if(ExpertTipo_hr==0)
|
|
horario=TimeLocal();
|
|
if(ExpertTipo_hr==1)
|
|
horario=(datetime)SeriesInfoInteger(Negociacao.Ativo,PERIOD_M1,SERIES_LASTBAR_DATE);
|
|
|
|
bool Aberto = horario>=StringToTime(ExpertHoraInicio_hr) && horario<StringToTime(ExpertHoraFim_hr) && !Negociacao.MetaBatida && !Negociacao.Desligado;
|
|
bool Intervalo = true;
|
|
if(ExpertIntervalo_Volta_hr!="0" && ExpertIntervalo_Parar_hr!="0")
|
|
Intervalo = (horario<=StringToTime(ExpertIntervalo_Parar_hr) || horario>=StringToTime(ExpertIntervalo_Volta_hr));
|
|
// bool SwingTrade = ExpertTipoOperacao==2 && horario>StringToTime(ExpertHoraInicio_hr) && !Negociacao.Desligado;
|
|
// bool retorn = (Aberto && Intervalo) || SwingTrade;
|
|
|
|
bool retorn = (Aberto && Intervalo);
|
|
return retorn;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Permição para Operar |
|
|
//+------------------------------------------------------------------+
|
|
bool LimiteHorario(){
|
|
datetime horario=TimeCurrent();
|
|
if(ExpertTipo_hr==0)
|
|
horario=TimeLocal();
|
|
if(ExpertTipo_hr==1)
|
|
horario=Precos[0].time;
|
|
return(horario>=StringToTime(ExpertHoraFecha_hr) && Negociacao.PosicaoAberta);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Estratégia de Entrada - Romper Keltner |
|
|
//+------------------------------------------------------------------+
|
|
void RomperKeltner(){
|
|
uint retorno=0;
|
|
|
|
if(Precos[1].close > Keltner_Up[1] && Precos[1].open < Keltner_Up[1] && Precos[1].open > Keltner_Down[1] && Precos[2].close < Keltner_Up[2] && Precos[2].close > Keltner_Down[2] && ExpertCompra==1){
|
|
Print("############# Entrada Compra/Venda #############");
|
|
retorno=CompraMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
|
|
}
|
|
if(Precos[1].close < Keltner_Down[1] && Precos[1].open > Keltner_Down[1] && Precos[1].open < Keltner_Up[1] && Precos[2].close < Keltner_Up[2] && Precos[2].close > Keltner_Down[2] && ExpertVenda==1){
|
|
Print("############# Entrada Compra/Venda #############");
|
|
retorno=VendaMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
|
|
}
|
|
if(retorno!=0 && retorno!=10008 && retorno!=10009)
|
|
Print("1 - Erro de operação: ", GetRetcodeID(retorno));
|
|
ZeroMemory(retorno);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Estratégia de Entrada - Tocar Keltner |
|
|
//+------------------------------------------------------------------+
|
|
void TocarKeltner(){
|
|
uint retorno=0;
|
|
|
|
if(Precos[0].close >= Keltner_Up[0] && Precos[0].open < Keltner_Up[0] && Precos[0].open > Keltner_Down[0] && Precos[1].close < Keltner_Up[1] && Precos[1].close > Keltner_Down[1] && ExpertVenda==1)
|
|
retorno=VendaMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
|
|
|
|
if(Precos[0].close <= Keltner_Down[0] && Precos[0].open > Keltner_Down[0] && Precos[0].open < Keltner_Up[0] && Precos[1].close < Keltner_Up[1] && Precos[1].close > Keltner_Down[1] && ExpertCompra==1)
|
|
retorno=CompraMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
|
|
|
|
if(retorno!=0 && retorno!=10008 && retorno!=10009)
|
|
Print("3 - Erro de operação: ", GetRetcodeID(retorno));
|
|
|
|
ZeroMemory(retorno);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Estratégia de Entrada - Tocar Keltner Ações |
|
|
//+------------------------------------------------------------------+
|
|
void TocarKeltnerAcoes(){
|
|
uint retorno=0;
|
|
|
|
if(Tick.bid >= Keltner_Up[0] && Precos[0].open < Keltner_Up[0] && Precos[0].open > Keltner_Down[0] && Precos[1].close < Keltner_Up[1] && Precos[1].close > Keltner_Down[1] && ExpertVenda==1)
|
|
retorno=VendaMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
|
|
|
|
if(Tick.ask <= Keltner_Down[0] && Precos[0].open > Keltner_Down[0] && Precos[0].open < Keltner_Up[0] && Precos[1].close < Keltner_Up[1] && Precos[1].close > Keltner_Down[1] && ExpertCompra==1)
|
|
retorno=CompraMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
|
|
|
|
if(retorno!=0 && retorno!=10008 && retorno!=10009)
|
|
Print("9 - Erro de operação: ", GetRetcodeID(retorno));
|
|
|
|
ZeroMemory(retorno);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Estratégia de Entrada - Retornar Keltner |
|
|
//+------------------------------------------------------------------+
|
|
void RetornoKeltner(){
|
|
uint retorno= 0;
|
|
if(Precos[2].close>Keltner_Up[2] && Precos[1].close<Keltner_Up[1] && ExpertVenda==1)
|
|
retorno=VendaMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
|
|
|
|
if(Precos[2].close<Keltner_Down[2] && Precos[1].close>Keltner_Down[1] && ExpertCompra==1)
|
|
retorno=CompraMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
|
|
|
|
if(retorno!=0 && retorno!=10008 && retorno!=10009)
|
|
Print("4 - Erro de operação: ", GetRetcodeID(retorno));
|
|
|
|
ZeroMemory(retorno);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Estratégia de Entrada - Keltner/Angulo |
|
|
//+------------------------------------------------------------------+
|
|
void KeltnerAngulo(){
|
|
uint retorno= 0;
|
|
if(ExpertAtivarKeltner==1 && ExpertAtivarGrau==1){
|
|
double AnguloInclinacao=3;
|
|
|
|
bool RomperDown = Tick.last<(Keltner_Down[0]-10) && Precos[2].close<Keltner_Up[2] && Precos[1].close>Keltner_Down[1] && Precos[0].close<Keltner_Down[0] && Angulo_Buffer[0]<-AnguloInclinacao;
|
|
bool RetornoUp = Precos[2].close>Keltner_Up[2] && Precos[1].open>Keltner_Up[1] && Precos[1].close<Keltner_Up[1] && Angulo_Buffer[0]<Angulo_Buffer[1];
|
|
|
|
bool RomperUp = Tick.last>(Keltner_Up[0]+10) && Precos[2].close>Keltner_Down[2] && Precos[1].close<Keltner_Up[1] && Precos[0].close>Keltner_Up[0] && Angulo_Buffer[0]>AnguloInclinacao;
|
|
bool RetornoDown = Precos[2].close<Keltner_Down[2] && Precos[1].open<Keltner_Down[1] && Precos[1].close>Keltner_Down[1] && Angulo_Buffer[0]>Angulo_Buffer[1];
|
|
|
|
|
|
if((RomperDown) && ExpertVenda==1)
|
|
retorno=VendaMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
|
|
|
|
if((RomperUp) && ExpertCompra==1)
|
|
retorno=CompraMercado(Negociacao.Ativo, ExpertContratos, Negociacao.NumeroMagico, ExpertOrderFilling, ExpertComentario);
|
|
|
|
if(retorno!=0 && retorno!=10008 && retorno!=10009)
|
|
Print("10 - Erro de operação: ", GetRetcodeID(retorno));
|
|
}
|
|
ZeroMemory(retorno);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Resumo de como está as variáveis para negociação |
|
|
//+------------------------------------------------------------------+
|
|
void ResumoNegociacao(){
|
|
Print("------------------------------------------------------------------------");
|
|
Print("Horário : ",(string)TimeLocal());
|
|
Print("Nome Ativo : ",Negociacao.Ativo);
|
|
Print("Período : ",EnumToString((ENUM_TIMEFRAMES)Negociacao.Periodo));
|
|
Print("Número Mágico : ",Negociacao.NumeroMagico);
|
|
Print("Tipo Negociação : ",Negociacao.Tipo);
|
|
Print("Moeda : ",Negociacao.Moeda);
|
|
Print("Ticket : ",Negociacao.Ticket);
|
|
Print("Posição Aberta : ",Negociacao.PosicaoAberta);
|
|
Print("Preço Entrada : ",Negociacao.PrecoEntrada);
|
|
Print("Pontos Take Profit: ",Negociacao.TakeProfit);
|
|
Print("Pontos Stop Loss : ",Negociacao.StopLoss);
|
|
Print("Preço Take Profit : ",Negociacao.PrecoTP);
|
|
Print("Preço Stop Loss : ",Negociacao.PrecoSL);
|
|
Print("Total de Ordens : ",Negociacao.TotalOrder);
|
|
Print("Teve Ordens : ",Negociacao.TeveOrder);
|
|
Print("Preço última Ordem: ",Negociacao.PrecoUltOrder);
|
|
Print("Qtde última Ordem : ",Negociacao.QtdeUltOrder);
|
|
Print("Meta Batida : ",Negociacao.MetaBatida);
|
|
Print("Desligado : ",Negociacao.Desligado);
|
|
Print("Fez Break Even : ",Negociacao.FezBreakEven);
|
|
Print("Fez Trail Stop : ",Negociacao.FezTrailStop);
|
|
}
|
|
void ResumoNegociacaoTelegram(){
|
|
string resumo="--------------------------------------\n";
|
|
resumo+="Horário : "+(string)TimeLocal()+"\n";
|
|
resumo+="Nome Ativo : "+(string)Negociacao.Ativo+"\n";
|
|
resumo+="Período : "+EnumToString((ENUM_TIMEFRAMES)Negociacao.Periodo)+"\n";
|
|
resumo+="Número Mágico : "+(string)Negociacao.NumeroMagico+"\n";
|
|
resumo+="Tipo Negociação : "+(string)Negociacao.Tipo+"\n";
|
|
resumo+="Moeda : "+(string)Negociacao.Moeda+"\n";
|
|
resumo+="Ticket : "+(string)Negociacao.Ticket+"\n";
|
|
resumo+="Posição Aberta : "+(string)Negociacao.PosicaoAberta+"\n";
|
|
resumo+="Preço Entrada : "+(string)Negociacao.PrecoEntrada+"\n";
|
|
resumo+="Pontos Take Profit: "+(string)Negociacao.TakeProfit+"\n";
|
|
resumo+="Pontos Stop Loss : "+(string)Negociacao.StopLoss+"\n";
|
|
resumo+="Preço Take Profit : "+(string)Negociacao.PrecoTP+"\n";
|
|
resumo+="Preço Stop Loss : "+(string)Negociacao.PrecoSL+"\n";
|
|
resumo+="Total de Ordens : "+(string)Negociacao.TotalOrder+"\n";
|
|
resumo+="Teve Ordens : "+(string)Negociacao.TeveOrder+"\n";
|
|
resumo+="Preço última Ordem: "+(string)Negociacao.PrecoUltOrder+"\n";
|
|
resumo+="Qtde última Ordem : "+(string)Negociacao.QtdeUltOrder+"\n";
|
|
resumo+="Meta Batida : "+(string)Negociacao.MetaBatida+"\n";
|
|
resumo+="Desligado : "+(string)Negociacao.Desligado+"\n";
|
|
resumo+="Fez Break Even : "+(string)Negociacao.FezBreakEven+"\n";
|
|
resumo+="Fez Trail Stop : "+(string)Negociacao.FezTrailStop+"\n";
|
|
resumo+="Status: "+StatusBot();
|
|
bot.SendMessage(ExpertUsuatioTelegram,resumo);
|
|
}
|
|
//+------------------------------------------------------------------+
|