1190 lines
No EOL
99 KiB
MQL5
1190 lines
No EOL
99 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| SuperCharlie_Aldridge_Dev_v0.mq5|
|
|
//| HEDGING HORN CAPITAL |
|
|
//| https://www.hhcapital.com.br |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "HEDGING HORN CAPITAL"
|
|
#property link "https://www.hhcapítal.com.br"
|
|
#property version "DEV_v0"
|
|
#property description "INDICE"
|
|
//INDICE
|
|
|
|
|
|
//+===================================================================================================================================================================================+
|
|
//| 1 - SESSAO DE CABECALHO / ADMISSAO
|
|
//+===================================================================================================================================================================================+
|
|
//+------------------------------------------------------------------+
|
|
//| 1.1 - IMPORTACOES |
|
|
//+------------------------------------------------------------------+
|
|
//--- Importacoes
|
|
#include <Expert/Expert.mqh>
|
|
#include <Trade/Trade.mqh>
|
|
#include <Trade/SymbolInfo.mqh>
|
|
#include "MarketBook.mqh"
|
|
#include <Math/Stat/Poisson.mqh>
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 1.2 - ENTRADAS DE USUARIO |
|
|
//+------------------------------------------------------------------+
|
|
//+------------------------------------------------------------------+
|
|
//| 1.2.1 - INPUTS DE GERENCIAMENTO DE INVENTARIO |
|
|
//+------------------------------------------------------------------+
|
|
input group "Gerenciamento de Inventário--------------------------------------------------------------------------------------------------"
|
|
input int inventario = 10; //Inventario máximo q {1}[1, +inf[
|
|
input int loteEnvio = 1; //Quantidade por ordem η {1}[1, +inf[
|
|
input double premioOperacao = 3; //Premio por trade liquido ρ {0.64}[0.0, 1.0[
|
|
input double custoOperacao = 2; //Custo por operacao ζ {1.86}[0.0, 2.0[
|
|
input double tickMin = 5; //Tick minimo do ativo Δ {0.5}[0.01, +inf[
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 1.2.2 - INPUTS DE GERENCIAMENTO DE OPERACOES |
|
|
//+------------------------------------------------------------------+
|
|
input group "Gerenciamento de Operacões---------------------------------------------------------------------------------------------------"
|
|
input ushort horaInicial = 545; //Horário inicial 09:05 -> Τ0 em minutos {600}[600, 985]
|
|
input ushort horaFinal = 980; //Horário final 16:20 -> ΤF em minutos {700}[600, 985]
|
|
input ushort horaEncerramento = 985; //Horário limite de after 16:25 -> ΤP em minutos {705}[600, 990]
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 1.2.3 - INPUTS DE GERENCIAMENTO DE RISCOS |
|
|
//+------------------------------------------------------------------+
|
|
input group "Gerenciamento de Riscos------------------------------------------------------------------------------------------------------"
|
|
input double alvoFinanceiro = 1000.0; //3º Order Risk M.: Alvo financeiro no dia sup(Χ)
|
|
input double stopFinanceiro = -1000.0; //3º Order Risk M.: Stop financeiro no dia inf(Χ)
|
|
|
|
/*
|
|
input group "Análise Quant - Tendência----------------------------------------------------------------------------------------------------"
|
|
input double pesoAlpha = 0.5; //Peso de alpha α {0.5}[0.00, 1.00[ passo = 0.1
|
|
input double pesoBeta = 0.0; //Peso de beta β {0.0}[0.00, 1.00[ passo = 0.1
|
|
input double pesoGama = 0.1; //Peso de gama γ {0.1}[0.00, 1.00[ passo = 0.1
|
|
input double pesoEpsilon = 0.0; //Peso de epsilon ε {0.0}[0.00, 1.00[ passo = 0.1
|
|
input double pesoIota = 1.0; //Peso de iota i {1.0}[0.00, 1.00[ passo = 0.1
|
|
input double thresholdResistencia = 3.0; //Threshold de resistencia γ {3.0}[0.0, 3.0[ passo = 0.5
|
|
input double qtdBigPlayer = 8; //Tamanho de big player i {8}[2, 20] passo = 2
|
|
input double pontoCorteSoma = 0.5; //Ponto de corte da soma Σm {0.5}[0.0, 1.0] passo = 0.1
|
|
input int fatorMultTend1 = 1; //Fator multiplicativo da tendencia fτ1 {1}[0, 10[
|
|
input int fatorMultTend2 = 2; //Fator multiplicativo da tendencia fτ2 {2}[0, 10[
|
|
input int fatorMultTend3 = 3; //Fator multiplicativo da tendencia fτ3 {3}[0, 10[
|
|
input int fatorMultTend4 = 4; //Fator multiplicativo da tendencia fτ4 {4}[0, 10[
|
|
input int fatorMultTend5 = 5; //Fator multiplicativo da tendencia fτ5 {5}[0, 10[
|
|
input int fatorMultTend6 = 6; //Fator multiplicativo da tendencia fτ6 {6}[0, 10[
|
|
*/
|
|
|
|
/*
|
|
input group "Análise Quant - Volatilidade-------------------------------------------------------------------------------------------------"
|
|
//input double fatorLinVol = 1.5; //Fator linear de log vol σ [1.0, 2.0[
|
|
input double pontoCorteDesvio = 0.0; //Ponto de corte do desvio padrao σm {0.0}[0.0, 1.0] passo = 0.1
|
|
input int fatorMultDesvio0 = 0; //Fator multiplicativo do desvio fσ0 {0}[0, 5[
|
|
input int fatorMultDesvio1 = 1; //Fator multiplicativo do desvio fσ1 {1}[0, 5[
|
|
input int fatorMultDesvio2 = 2; //Fator multiplicativo do desvio fσ2 {2}[0, 5[
|
|
input int fatorMultDesvio3 = 3; //Fator multiplicativo do desvio fσ3 {3}[0, 5[
|
|
*/
|
|
|
|
/*
|
|
//+------------------------------------------------------------------+
|
|
//| 1.2.5 - INPUTS DE ANALISE DE PROBABILIDADES |
|
|
//+------------------------------------------------------------------+
|
|
input group "Análise de Probabilidades - Fill Rates---------------------------------------------------------------------------------------"
|
|
input int posicaoFila = 350; //Tamanho médio de fila κ {300}[100, 1000[
|
|
//input double limite_prob_C = 0.80; //Limite inferior de Fill Rate Λc {0.8}[0.00, 1.00]
|
|
//double limite_prob_V = limite_prob_C; //Limite inferior de Fill Rate Λv {0.8}[0.00, 1.00]
|
|
input double fatorCancelamento = 1.0; //Fator de cancelamento χ (1 = 0% de cancelamento/0.9 = 10% de cancelamento)
|
|
*/
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 1.3 - VARIAVEIS GLOBAIS |
|
|
//+------------------------------------------------------------------+
|
|
//+------------------------------------------------------------------+
|
|
//| 1.3.1 - VARIAVEIS FINANCEIRAS |
|
|
//+------------------------------------------------------------------+
|
|
double midPrice = 0.0;
|
|
double buyPrice = 0.0;
|
|
double sellPrice = 0.0;
|
|
double stopBuyPrice = 0.0;
|
|
double stopSellPrice = 0.0;
|
|
double spreadBuy = 0.0;
|
|
double spreadSell = 0.0;
|
|
double stopBuySpread = 0.0;
|
|
double stopSellSpread = 0.0;
|
|
double qtdBuy = 0.0;
|
|
double qtdSell = 0.0;
|
|
double qtdCompraEnviada = 0.0;
|
|
double qtdVendaEnviada = 0.0;
|
|
double qtdCompraFilada = 0.0;
|
|
double qtdVendaFilada = 0.0;
|
|
double saldoInicialDia = 0.0;
|
|
double saldoFinalDia = 0.0;
|
|
double diferencaSaldo = 0.0;
|
|
int spreadTotal = 0;
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 1.3.2 - VARIAVEIS QUANTITATIVAS |
|
|
//+------------------------------------------------------------------+
|
|
int iBid[4], iAsk[4];
|
|
double desvioPadrao = 0.0;
|
|
double alpha = 0.0;
|
|
double epsilon = 0.0;
|
|
double soma = 0.0;
|
|
double soma0 = 0.0;
|
|
double soma1 = 0.0;
|
|
double soma2 = 0.0;
|
|
double filaMediaBuy = 0.0;
|
|
double filaMediaSell = 0.0;
|
|
int medianaLambdaAsk = 0;
|
|
int medianaLambdaBid = 0;
|
|
double MA[];
|
|
double handlerMA;
|
|
int q = 0;
|
|
|
|
// "Gerenciamento de Riscos------------------------------------------------------------------------------------------------------"
|
|
double limiteSupDesvio = 500; //2º Order Risk M.: Limite sup de volatilidade σ {1.5}[0.00, 1.00[
|
|
double limiteInfDesvio = 0.00; //2º Order Risk M.: Limite inf de volatilidade σ [0.00, 0.005[
|
|
double limiteInfTend1 = 0.00; //2º Order Risk M.: Limite inf de var da media Δμ [0.00, 1.00[ passo = 0.1
|
|
double limiteSupTend1 = limiteInfTend1 + 100; //2º Order Risk M.: Limite sup de variacao da media movel Δμ [0.00, 1.00[ passo = 0.1
|
|
double fatorBaseStop = 10; //1º Order Risk M.: Stop base ω {5}[2, 10[
|
|
double fatorMultStop = 1.0; //1º Order Risk M.: Fator mult de log stop fω {1.0}[1.0, 10.0[
|
|
double constLinStop = 5.3; //1º Order Risk M.: Constante de log vol stop cω {5.3}
|
|
int sleepTime = 0; //T de sleep para pós-stop em ms {0}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 1.3.3 - VARIAVEIS DE ANALISE QUANTITATIVA |
|
|
//+------------------------------------------------------------------+
|
|
// "Análise Quant - Intervalos---------------------------------------------------------------------------------------------------"
|
|
//int intervalo_temporal_resistencia = 100; //T resistencia γ temporal em segundos {100} [1, 100[
|
|
//int intervalo_lambda_temporal = 10; //T lambda λ temporal em segundos {10}[1, 10[ passo = 1
|
|
//int tempoTrade = 90; //T de trade N temporal em segundos {90}[0, 100[
|
|
int intervalo_desvio = 500; //Ticks da volatilidade σ atemporal {500}[1, 500[
|
|
double periodoMA = 10; //Ticks da media movel μ atemporal {10}[2, 20[ passo = 1
|
|
//input int intervalo_resistencia = 3000; //Ticks para resistencias γ atemporal {3000} [2, 3000[
|
|
int intervalo_lambda = 50; //Ticks lambda λ atemporal {50}[10, 100[
|
|
int k = 1; //Variavel k do modelo Stoikov {1}
|
|
double gama = 0.5; //Variavel gama y Aversao a risco {0.5} [0, 1]
|
|
double t = 0.5; //Variavel representando o tempo do dia {0.5} [0, 1]
|
|
double sigma = 10; //Variavel sigma {10}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 1.3.4 - VARIAVEIS OPERACIONAIS |
|
|
//+------------------------------------------------------------------+
|
|
int magic = 12345;
|
|
MqlDateTime horario;
|
|
MqlDateTime horario_inicio,
|
|
horario_final,
|
|
horario_encerramento,
|
|
horario_atual,
|
|
horario_comprado,
|
|
horario_compra;
|
|
ushort horarioAtual;
|
|
datetime horaAtual;
|
|
int diaAtual = 0;
|
|
CSymbolInfo simbolo;
|
|
CExpert extExpert;
|
|
CMarketBook Book(_Symbol);
|
|
CTrade negocio;
|
|
MqlBookInfo ArrayBook[];
|
|
MqlTick ArrayTick[];
|
|
MqlTradeRequest request;
|
|
MqlTradeResult result;
|
|
MqlTradeTransaction transaction;
|
|
MqlTradeCheckResult check_result;
|
|
string handlerNormalizeDoubleSize;
|
|
int normalizeDoubleSize;
|
|
|
|
struct CustomMqlTick
|
|
{
|
|
int idTick;
|
|
string tipoEvento;
|
|
datetime timestamp;
|
|
int flag;
|
|
double last;
|
|
int volume;
|
|
double bid0;
|
|
double ask0;
|
|
int vb0;
|
|
int va0;
|
|
int bid1;
|
|
int ask1;
|
|
int vb1;
|
|
int va1;
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 1.3.5 - VARIAVEIS DE LOG E FEEDBACK |
|
|
//+------------------------------------------------------------------+
|
|
int arqResultados = 0;
|
|
int idResultados = 0;
|
|
string headerRes = "ID_RESULTADO,TIMESTAMP,BID,PRECO_COMPRA,MIDPRICE,PRECO_VENDA,ASK,DESVIO,SOMA,ALPHA,EPSILON,RES_BRUTO,RES_LIQ,K_C,K_V,LAMBDA_C,LAMBDA_V,FILL_C,FILL_V,TRADES,ACERTOS,ERROS";
|
|
|
|
//+===================================================================================================================================================================================+
|
|
//| 2 - SESSAO DE INICIALIZACAO/ATUALIZACAO / IGNICAO
|
|
//+===================================================================================================================================================================================+
|
|
//+------------------------------------------------------------------+
|
|
//| 2.1 - FUNCAO DE INICIALIZACAO DO ROBO |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit()
|
|
{
|
|
saldoInicialDia = AccountInfoDouble(ACCOUNT_BALANCE);
|
|
TimeToStruct(TimeCurrent(), horario_atual);
|
|
diaAtual = horario_atual.day;
|
|
//Inicializa o Market Book
|
|
if(!MarketBookAdd(_Symbol)) Print("Falha para inicializar o book");
|
|
|
|
//Inicializa o ArrayTick
|
|
if(CopyTicks(Symbol(),ArrayTick,COPY_TICKS_TRADE,0,intervalo_lambda) != -1) ArraySetAsSeries(ArrayTick,true);
|
|
else Print("Falha para inicializar o ArrayTicks");
|
|
|
|
handlerNormalizeDoubleSize = DoubleToString(tickMin);
|
|
handlerNormalizeDoubleSize = StringReplace(handlerNormalizeDoubleSize,".","");
|
|
normalizeDoubleSize = (StringLen(handlerNormalizeDoubleSize))-1;
|
|
|
|
handlerMA = iMA(_Symbol,PERIOD_M1,periodoMA,0,MODE_EMA,PRICE_OPEN);
|
|
ArraySetAsSeries(MA, true);
|
|
CopyBuffer(handlerMA,0,0,1,MA);
|
|
|
|
Print("TAMANHO DO NORMALIZE DOUBLE: ",normalizeDoubleSize);
|
|
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 2.2 - FUNCAO EVENTO TICK / CORACAO |
|
|
//+------------------------------------------------------------------+
|
|
void OnTick()
|
|
{
|
|
//Atualiza os ticks e variaveis
|
|
AtualizaVariaveis();
|
|
|
|
handlerMA = iMA(_Symbol,PERIOD_M1,periodoMA,0,MODE_EMA,PRICE_OPEN);
|
|
CopyBuffer(handlerMA,0,0,2,MA);
|
|
//Chamar o motor
|
|
if(VerificaHorarioOrdens()) FazTrades();
|
|
else if(VerificaHorarioFechamento())
|
|
{
|
|
FechaPosicao();
|
|
CancelaOrdensAbertas();
|
|
}
|
|
else return;
|
|
|
|
return;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 2.3 - FUNCAO EVENTO BOOK |
|
|
//+------------------------------------------------------------------+
|
|
void OnBookEvent(const string &symbol)
|
|
{
|
|
|
|
if(MarketBookGet(_Symbol, ArrayBook))
|
|
{
|
|
iBid[0] = Book.InfoGetInteger(MBOOK_BEST_BID_INDEX);
|
|
iAsk[0] = Book.InfoGetInteger(MBOOK_BEST_ASK_INDEX);
|
|
iBid[1] = iBid[0] + 1;
|
|
iAsk[1] = iAsk[0] - 1;
|
|
iBid[2] = iBid[0] + 2;
|
|
iAsk[2] = iAsk[0] - 2;
|
|
}
|
|
else
|
|
{
|
|
// Print("Falha ao obter o Book");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 2.4 - FUNCAO EVENTO TRADE |
|
|
//+------------------------------------------------------------------+
|
|
void OnTrade()
|
|
{
|
|
static int previous_open_positions = 0;
|
|
int current_open_positions = PositionsTotal();
|
|
double last_trade_profit = 0.0;
|
|
|
|
if(current_open_positions < previous_open_positions) // a position just got closed:
|
|
{
|
|
previous_open_positions = current_open_positions;
|
|
HistorySelect(TimeCurrent()-300, TimeCurrent()); // 5 minutes ago
|
|
int All_Deals = HistoryDealsTotal();
|
|
if(All_Deals < 1) Print("Some nasty shit error has occurred :s");
|
|
// last deal (should be an DEAL_ENTRY_OUT type):
|
|
ulong temp_Ticket = HistoryDealGetTicket(All_Deals-1);
|
|
// here check some validity factors of the position-closing deal
|
|
// (symbol, position ID, even MagicNumber if you care...)
|
|
last_trade_profit = HistoryDealGetDouble(temp_Ticket , DEAL_PROFIT);
|
|
if(last_trade_profit < 0) Sleep(sleepTime);
|
|
// Print("Last Trade Profit : ", DoubleToString(last_trade_profit));
|
|
}
|
|
else if(current_open_positions > previous_open_positions) // a position just got opened:
|
|
previous_open_positions = current_open_positions;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 2.5 - FUNCAO DE DESLIGAMENTO |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason)
|
|
{
|
|
//Fecha os arquivos de log
|
|
// FileClose(arqResultados);
|
|
// Print("Fechou arquivos de log.");
|
|
Print("OUTPUT PATH=",TerminalInfoString(TERMINAL_DATA_PATH));
|
|
|
|
//Falha na desinicializacao
|
|
printf("Deinit reason: %d", reason);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 2.6 - FUNCAO QUE ATUALIZA AS VARIAVEIS IMPORTANTES |
|
|
//+------------------------------------------------------------------+
|
|
void AtualizaVariaveis()
|
|
{
|
|
//Atualiza o book e ticks
|
|
if(!simbolo.RefreshRates()) return;
|
|
|
|
if(MarketBookGet(_Symbol, ArrayBook))
|
|
{
|
|
//Atualiza os indices do topo do book
|
|
iBid[0] = Book.InfoGetInteger(MBOOK_BEST_BID_INDEX);
|
|
iAsk[0] = Book.InfoGetInteger(MBOOK_BEST_ASK_INDEX);
|
|
iBid[1] = iBid[0] + 1;
|
|
iAsk[1] = iAsk[0] - 1;
|
|
iBid[2] = iBid[0] + 2;
|
|
iAsk[2] = iAsk[0] - 2;
|
|
}
|
|
else
|
|
{
|
|
// Print("Falha ao atualizar o Book");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//+===================================================================================================================================================================================+
|
|
//| 3 - SESSAO DE LOGICA / MOTOR
|
|
//+===================================================================================================================================================================================+
|
|
//+------------------------------------------------------------------+
|
|
//| 3.1 - FUNCAO QUE FAZ NEGOCIACOES |
|
|
//+------------------------------------------------------------------+
|
|
void FazTrades()
|
|
{
|
|
//Verifica os limites de compra e venda
|
|
if(VerificaLimites()==0)
|
|
{
|
|
//Verifica se atingiu os riscos de VaR (3a camada de riscos} ou volatilidade (2a camada de riscos)
|
|
if(VerificaRiscos()==true)
|
|
{
|
|
//Verifica a projecao instantanea de preco, preenche os precos e stops (1a camada de riscos)
|
|
if(VerificaPreco()==0)
|
|
{
|
|
if(buyPrice > ArrayTick[0].bid)
|
|
{
|
|
// CompraMercado(stopBuyPrice, loteEnvio);
|
|
}
|
|
else
|
|
{
|
|
CompraLimite(buyPrice, stopBuyPrice, loteEnvio);
|
|
}
|
|
|
|
if(sellPrice < ArrayTick[0].ask)
|
|
{
|
|
// VendaMercado(stopSellPrice, loteEnvio);
|
|
}
|
|
else
|
|
{
|
|
VendaLimite(sellPrice, stopSellPrice, loteEnvio);
|
|
}
|
|
|
|
//Imprime na tela o feedback dos indicadores
|
|
Comment("SpreadTotal = " + (sellPrice - buyPrice) + "\n" +
|
|
"MidPrice = " + midPrice + "\n" +
|
|
"SellPrice = " + sellPrice + "\n" +
|
|
"BuyPrice = " + buyPrice + "\n" +
|
|
"SpreadSell = " + spreadSell + "\n" +
|
|
"SpreadBuy = " + spreadBuy + "\n" +
|
|
"StopSellSpead = " + stopSellSpread + "\n" +
|
|
"StopBuySpread = " + stopBuySpread + "\n" +
|
|
"DesvioPadrao = " + NormalizeDouble(desvioPadrao,normalizeDoubleSize) + "\n"
|
|
"Tendencia = " + NormalizeDouble(soma,normalizeDoubleSize));
|
|
|
|
//Sleep(1000);
|
|
//Grava os resultados de trade no log
|
|
// idResultados += 1;
|
|
// TimeCurrent(horario);
|
|
// horaAtual = StructToTime(horario);
|
|
// FileWrite(arqResultados,idResultados + "," + horario.year+"."+horario.mon+"."+horario.day+" "+horario.hour+":"+horario.min+":"+horario.sec + "," + ArrayTick[0].bid + "," + buyPrice + "," + midPrice + "," + sellPrice + "," + ArrayTick[0].ask + "," + desvioPadrao + "," + soma + "," + alpha + "," + epsilon + "," + resultadoHom + "," + resultadoLiqHom + "," + posicaoFilaCompraHom + "," + posicaoFilaVendaHom + "," + lambda_C + "," + lambda_V + "," + probC + "," + probV + "," + tradesHom + "," + acertosHom + "," + errosHom);
|
|
}
|
|
}
|
|
else{}
|
|
}
|
|
//se estiver com uma ordem aberta desparidade de compra ou venda
|
|
else if(VerificaLimites() == 1)
|
|
{
|
|
if(OrdensCompraLimitadasAbertas() > OrdensVendaLimitadasAbertas())
|
|
{
|
|
CancelaOrdemAbertaCompra();
|
|
}
|
|
else
|
|
{
|
|
CancelaOrdemAbertaVenda();
|
|
}
|
|
}
|
|
//se não tiver limites de compra e venda
|
|
else if(VerificaLimites() == 2)
|
|
{
|
|
//Verifica se tiver ordem de compra aberta
|
|
if((OrdensCompraLimitadasAbertas() == 1) || (OrdensVendaLimitadasAbertas() == 1))
|
|
{
|
|
//Verifica se precisa modificar ordens
|
|
if(VerificaModificaOrdens() == 0)
|
|
{
|
|
// CalculaSpreadBuy();
|
|
// CalculaSpreadSell();
|
|
}
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
//+===================================================================================================================================================================================+
|
|
//| 4.1 - SESSAO DE HORARIOS / CRONOMETRO
|
|
//+===================================================================================================================================================================================+
|
|
//+------------------------------------------------------------------+
|
|
//| 4.1.1 - FUNCAO DE ATUALIZAR HORARIO DE PREGAO |
|
|
//+------------------------------------------------------------------+
|
|
bool VerificaHorarioOrdens()
|
|
{
|
|
TimeToStruct(TimeCurrent(), horario_atual);
|
|
ushort horarioAtual = horario_atual.hour * 60 + horario_atual.min;
|
|
|
|
if((horarioAtual > horaInicial)&&(horarioAtual < horaEncerramento))
|
|
{
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 4.1.2 - FUNCAO DE ATUALIZAR HORARIO DE FECHAMENTO |
|
|
//+------------------------------------------------------------------+
|
|
bool VerificaHorarioFechamento()
|
|
{
|
|
if(horarioAtual > horaFinal)
|
|
{
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
|
|
//+===================================================================================================================================================================================+
|
|
//| 4.2 - SESSAO DE LIMITES / FREIO MOTOR
|
|
//+===================================================================================================================================================================================+
|
|
//+------------------------------------------------------------------+
|
|
//| 4.2.1 - FUNCAO QUE VERIFICA OS LIMITES DE COMPRA E VENDA |
|
|
//+------------------------------------------------------------------+
|
|
int VerificaLimites()
|
|
{
|
|
if(VerificaLimiteCompra() != VerificaLimiteVenda())
|
|
{
|
|
return 1;
|
|
}
|
|
else if ((VerificaLimiteCompra() == 0) && (VerificaLimiteVenda() == 0))
|
|
{
|
|
return 2;
|
|
}
|
|
else
|
|
{
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 4.2.2 - FUNCAO QUE VERIFICA LIMITE DE ORDENS DE COMPRA |
|
|
//+------------------------------------------------------------------+
|
|
int VerificaLimiteCompra()
|
|
{
|
|
int limite_Compra = inventario/loteEnvio;
|
|
|
|
limite_Compra = limite_Compra - OrdensCompraLimitadasAbertas() - PosicoesCompraAbertas();
|
|
|
|
if(limite_Compra > 0) return 1;
|
|
else return 0;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 4.2.3 - FUNCAO QUE VERIFICA LIMITE DE ORDENS VENDA |
|
|
//+------------------------------------------------------------------+
|
|
int VerificaLimiteVenda()
|
|
{
|
|
int limite_Venda = inventario/loteEnvio;
|
|
|
|
limite_Venda = limite_Venda - OrdensVendaLimitadasAbertas() - PosicoesVendaAbertas();
|
|
|
|
if(limite_Venda > 0) return 1;
|
|
else return 0;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 4.2.4 - FUNCAO QUE VERIFICA LIMITE EM VOLUME DE ORDENS DE COMPRA |
|
|
//+------------------------------------------------------------------+
|
|
int VerificaLimiteVolumeCompra()
|
|
{
|
|
int limite = loteEnvio;
|
|
int returnCode = 1;
|
|
|
|
if(qtdCompraEnviada == 0) return 0;
|
|
if(qtdCompraEnviada == limite) return 1;
|
|
|
|
return returnCode;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 4.2.5 - FUNCAO QUE VERIFICA LIMITE EM VOLUME DE ORDENS VENDA |
|
|
//+------------------------------------------------------------------+
|
|
int VerificaLimiteVolumeVenda()
|
|
{
|
|
int limite = loteEnvio;
|
|
int returnCode = 1;
|
|
|
|
if(qtdVendaEnviada == 0) return 0;
|
|
if(qtdVendaEnviada == limite) return 1;
|
|
|
|
return returnCode;
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------+
|
|
//| 4.2.6 - FUNCAO DE CALCULO DO NUMERO DE ORDENS COMPRA LIMITADAS ABERTAS |
|
|
//+--------------------------------------------------------------------------+
|
|
int OrdensCompraLimitadasAbertas()
|
|
{
|
|
int ordens = 0;
|
|
|
|
//Percorre todas as ordens
|
|
for(int i=OrdersTotal()-1; i>=0; i--)
|
|
{
|
|
ulong ticket = OrderGetTicket(i);
|
|
string symbol = OrderGetString(ORDER_SYMBOL);
|
|
ulong magicEA = OrderGetInteger(ORDER_MAGIC);
|
|
|
|
//Verifica para cada ordem, se eh do simbolo corrente e do mesmo robo
|
|
if((symbol == _Symbol) && (magicEA == magic))
|
|
{
|
|
//Verifica se a ordem eh do tipo buy limit
|
|
if(OrderGetInteger(ORDER_TYPE) == ORDER_TYPE_BUY_LIMIT)
|
|
{
|
|
ordens = ordens + 1;
|
|
qtdCompraEnviada = OrderGetDouble(ORDER_VOLUME_INITIAL);
|
|
qtdCompraFilada = qtdCompraEnviada - OrderGetDouble(ORDER_VOLUME_CURRENT);
|
|
}
|
|
}
|
|
}
|
|
|
|
return ordens;
|
|
}
|
|
|
|
//+--------------------------------------------------------------------------+
|
|
//| 4.2.7 - FUNCAO DE CALCULO DO NUMERO DE ORDENS VENDA LIMITADAS ABERTAS |
|
|
//+--------------------------------------------------------------------------+
|
|
int OrdensVendaLimitadasAbertas()
|
|
{
|
|
int ordens = 0;
|
|
|
|
//Percorre todas as ordens
|
|
for(int i=OrdersTotal()-1; i>=0; i--)
|
|
{
|
|
ulong ticket = OrderGetTicket(i);
|
|
string symbol = OrderGetString(ORDER_SYMBOL);
|
|
ulong magicEA = OrderGetInteger(ORDER_MAGIC);
|
|
|
|
//Verifica para cada ordem, se eh do simbolo corrente e do mesmo robo
|
|
if((symbol == _Symbol) && (magicEA == magic))
|
|
{
|
|
//Verifica se a ordem eh do tipo sell limit
|
|
if(OrderGetInteger(ORDER_TYPE) == ORDER_TYPE_SELL_LIMIT)
|
|
{
|
|
ordens = ordens + 1;
|
|
qtdVendaEnviada = OrderGetDouble(ORDER_VOLUME_INITIAL);
|
|
qtdVendaFilada = qtdVendaEnviada - OrderGetDouble(ORDER_VOLUME_CURRENT);
|
|
}
|
|
}
|
|
}
|
|
|
|
return ordens;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 4.2.* - FUNCAO DE CALCULO DO q |
|
|
//+------------------------------------------------------------------+
|
|
void AtualizaQuantidade()
|
|
{
|
|
q = 0;
|
|
|
|
q = PosicoesCompraAbertas() - PosicoesVendaAbertas();
|
|
|
|
return;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 4.2.8 - FUNCAO DE VERIFICACAO DE POSICAO DE COMPRA |
|
|
//+------------------------------------------------------------------+
|
|
int PosicoesCompraAbertas()
|
|
{
|
|
int positions = 0;
|
|
|
|
//Percorre todas as posicoes
|
|
for(int i=PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
ulong ticket = PositionGetTicket(i);
|
|
string symbol = PositionGetString(POSITION_SYMBOL);
|
|
ulong magicEA = PositionGetInteger(POSITION_MAGIC);
|
|
|
|
//Verifica para cada posicao, se eh do simbolo corrente e do mesmo robo
|
|
if((symbol == _Symbol) && (magicEA == magic))
|
|
{
|
|
//Verifica se a posicao eh do tipo buy
|
|
if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
|
|
{
|
|
positions = positions + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return positions;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 4.2.9 - FUNCAO DE VERIFICACAO DE POSICAO DE VENDAS |
|
|
//+------------------------------------------------------------------+
|
|
int PosicoesVendaAbertas()
|
|
{
|
|
int positions = 0;
|
|
|
|
//Percorre todas as posicoes
|
|
for(int i = PositionsTotal()-1; i>=0; i--)
|
|
{
|
|
ulong ticket = PositionGetTicket(i);
|
|
string symbol = PositionGetString(POSITION_SYMBOL);
|
|
ulong magicEA = PositionGetInteger(POSITION_MAGIC);
|
|
|
|
//Verifica para cada posicao, se eh do simbolo corrente e do mesmo robo
|
|
if((symbol == _Symbol) && (magicEA == magic))
|
|
{
|
|
//Verifica se a posicao eh do tipo sell
|
|
if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
|
|
{
|
|
positions = positions + 1;
|
|
}
|
|
}
|
|
}
|
|
|
|
return positions;
|
|
}
|
|
|
|
//+---------------------------------------------------------------------------+
|
|
//| 4.2.10 - FUNCAO QUE VERIFICA A NECESSIDADE DE MODIFICAR ORDENS ENVIADAS |
|
|
//+---------------------------------------------------------------------------+
|
|
int VerificaModificaOrdens()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
//+===================================================================================================================================================================================+
|
|
//| 4.3 - SESSAO DE RISCOS DE MERCADO/PORTFOLIO / FREIO DE MAO
|
|
//+===================================================================================================================================================================================+
|
|
//+------------------------------------------------------------------+
|
|
//| 4.3.1 - FUNCAO QUE VERIFICA OS RISCOS DE MERCADO |
|
|
//+------------------------------------------------------------------+
|
|
bool VerificaRiscos()
|
|
{
|
|
const int n = intervalo_desvio;
|
|
double precos[];
|
|
double diferencaMA = 0.0;
|
|
ArrayResize(precos, n);
|
|
GetPrecosPassados(precos);
|
|
desvioPadrao = MathStandardDeviation(precos);
|
|
diferencaMA = MA[0] - MA[1];
|
|
|
|
saldoFinalDia = AccountInfoDouble(ACCOUNT_BALANCE);
|
|
|
|
if(diaAtual == horario_atual.day)
|
|
{
|
|
diferencaSaldo = saldoFinalDia - saldoInicialDia;
|
|
}
|
|
else
|
|
{
|
|
Print("Dia anterior: ",diaAtual," Resultado: ", diferencaSaldo);
|
|
diaAtual += 1;
|
|
saldoInicialDia = AccountInfoDouble(ACCOUNT_BALANCE);
|
|
diferencaSaldo = 0.0;
|
|
}
|
|
|
|
if(diferencaMA < 0) diferencaMA = -1*diferencaMA;
|
|
|
|
//Verifica se atingiu o 5% VAR - 3º Order Risk Management
|
|
if((diferencaSaldo < alvoFinanceiro) && (diferencaSaldo > stopFinanceiro))
|
|
{
|
|
//Verifica se atingiu o volatility cutouts - 2º Order Risk Management
|
|
if((desvioPadrao >= limiteInfDesvio) && (desvioPadrao <= limiteSupDesvio))
|
|
{
|
|
//Verifica se atingiu o trends cutouts - 2º Order Risk Management
|
|
if((diferencaMA >= limiteInfTend1) && (diferencaMA <= limiteSupTend1))
|
|
{
|
|
return true;
|
|
}
|
|
else return false;
|
|
}
|
|
else return false;
|
|
}
|
|
else return false;
|
|
}
|
|
|
|
//+===================================================================================================================================================================================+
|
|
//| 5 - SESSAO DE PRECOS / DIRECAO
|
|
//+===================================================================================================================================================================================+
|
|
//+------------------------------------------------------------------+
|
|
//| 5.1 - FUNCAO QUE VERIFICA O PRECO NAQUELE INSTANTE |
|
|
//+------------------------------------------------------------------+
|
|
int VerificaPreco()
|
|
{
|
|
//Define os spreads das ordens
|
|
const int n = intervalo_desvio;
|
|
double precos[];
|
|
double diferencaMA = 0.0;
|
|
ArrayResize(precos, n);
|
|
GetPrecosPassados(precos);
|
|
desvioPadrao = MathStandardDeviation(precos);
|
|
AtualizaQuantidade();
|
|
// double t = 0.0;
|
|
|
|
// t = (double)(horaEncerramento - horarioAtual)/(double)(horaEncerramento - horaInicial);
|
|
// midPrice = ArrayTick[0].last - q*gama*pow(desvioPadrao,2)*(horaEncerramento - horarioAtual);
|
|
midPrice = ArrayTick[0].last - q*gama*pow(sigma,2)*(t);
|
|
|
|
spreadBuy = (CalculaSpreadTotal() * tickMin) /2;
|
|
spreadSell = (CalculaSpreadTotal() * tickMin) /2;
|
|
stopBuySpread = CalculaStopBuy();
|
|
stopSellSpread = CalculaStopSell();
|
|
// Print("Last: ", ArrayTick[0].last, " Reservation price: ", midPrice, " SpreadTotal: ", CalculaSpreadTotal());
|
|
|
|
//Preenche os precos de envio das ordens
|
|
buyPrice = MathRound(midPrice - spreadBuy - 0.1);
|
|
sellPrice = MathRound(midPrice + spreadSell + 0.1);
|
|
stopBuyPrice = buyPrice + stopBuySpread;
|
|
stopSellPrice = sellPrice + stopSellSpread;
|
|
|
|
return 0;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 5.* - FUNCAO QUE CALCULA SPREAD TOTAL |
|
|
//+------------------------------------------------------------------+
|
|
int CalculaSpreadTotal()
|
|
{
|
|
spreadTotal = 0;
|
|
double f1 = 0.0;
|
|
double f2 = 0.0;
|
|
double div = 0.0;
|
|
// double t = 0.0;
|
|
|
|
// t = (double)(horaEncerramento - horarioAtual)/(double)(horaEncerramento - horaInicial);
|
|
// spreadTotal = (gama * pow(desvioPadrao,2) * (horaEncerramento - horarioAtual)) + ((2/(double)gama) * log1p(1+((double)gama/(double)k)));
|
|
f1 = (gama * pow(sigma,2) * t);
|
|
div = (double)gama/(double)k;
|
|
f2 = (2/(double)gama) * log1p(div);
|
|
spreadTotal = f1 + f2;
|
|
|
|
// Print("f1: ", f1, " f2: ", f2, " div: ", div);
|
|
|
|
return spreadTotal;
|
|
}
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 5.4 - FUNCAO QUE CALCULA SPREAD DE STOP DE COMPRA |
|
|
//+------------------------------------------------------------------+
|
|
double CalculaStopBuy()
|
|
{
|
|
const int n = intervalo_desvio;
|
|
double precos[];
|
|
ArrayResize(precos, n);
|
|
double delta = - fatorBaseStop * tickMin;
|
|
double volatilidade = 0.0;
|
|
double spread = 0.0;
|
|
|
|
GetPrecosPassados(precos);
|
|
desvioPadrao = MathStandardDeviation(precos);
|
|
volatilidade = - ((MathLog1p(desvioPadrao * fatorMultStop) + constLinStop) * tickMin);
|
|
volatilidade = NormalizeDouble(volatilidade,0);
|
|
|
|
spread = delta;
|
|
|
|
return spread;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 5.5 - FUNCAO QUE CALCULA SPREAD DE STOP DE VENDA |
|
|
//+------------------------------------------------------------------+
|
|
double CalculaStopSell()
|
|
{
|
|
const int n = intervalo_desvio;
|
|
double precos[];
|
|
ArrayResize(precos, n);
|
|
double delta = fatorBaseStop * tickMin;
|
|
double tendencia = 0.0;
|
|
double volatilidade = 0.0;
|
|
double spread = 0.0;
|
|
|
|
GetPrecosPassados(precos);
|
|
desvioPadrao = MathStandardDeviation(precos);
|
|
volatilidade = ((MathLog1p(desvioPadrao * fatorMultStop) + constLinStop) * tickMin);
|
|
volatilidade = NormalizeDouble(volatilidade,0);
|
|
|
|
spread = delta;
|
|
|
|
return spread;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 5.6 - FUNCAO QUE CALCULA A MEDIA DE PRECOS |
|
|
//+------------------------------------------------------------------+
|
|
void GetPrecosPassados(double &precos[])
|
|
{
|
|
if(CopyTicks(Symbol(),ArrayTick,COPY_TICKS_TRADE,0,intervalo_desvio) != -1)
|
|
{
|
|
ArraySetAsSeries(ArrayTick,true);
|
|
for(int i=0;i<ArraySize(ArrayTick);i++)
|
|
{
|
|
precos[i] = ArrayTick[i].last;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("Falha ao obter o ArrayTick, falha para GetPrecosPassados");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//+===================================================================================================================================================================================+
|
|
//| 8 - SESSAO DE OPERACOES E EXECUCOES / ESCAPAMENTO
|
|
//+===================================================================================================================================================================================+
|
|
//+------------------------------------------------------------------+
|
|
//| 8.1 - FUNCAO DE COMPRA LIMITADA |
|
|
//+------------------------------------------------------------------+
|
|
void CompraLimite(double precoEnvio, double precoStop, double qtd)
|
|
{
|
|
//Limpar informacoes das estruturas
|
|
ZeroMemory(request);
|
|
ZeroMemory(result);
|
|
ZeroMemory(check_result);
|
|
|
|
request.magic = magic;
|
|
request.symbol = _Symbol;
|
|
request.action = TRADE_ACTION_PENDING;
|
|
request.type = ORDER_TYPE_BUY_LIMIT;
|
|
request.type_filling = ORDER_FILLING_RETURN;
|
|
request.type_time = ORDER_TIME_DAY;
|
|
request.volume = qtd;
|
|
request.price = simbolo.NormalizePrice(precoEnvio);
|
|
// request.price = NormalizeDouble(precoEnvio,normalizeDoubleSize);
|
|
request.deviation = 0;
|
|
// request.sl = NormalizeDouble(precoStop,normalizeDoubleSize);
|
|
request.sl = simbolo.NormalizePrice(precoStop);
|
|
// request.stoplimit = tickMin;
|
|
// request.tp = precoAlvo;
|
|
request.comment = "Compra Limitada";
|
|
|
|
// Print("Tipo: Compra Limitada", "/ Preco: ", NormalizeDouble(precoEnvio,normalizeDoubleSize),"/ Preco Stop: ", NormalizeDouble(precoStop,normalizeDoubleSize), "/ QTD: ", qtd);
|
|
|
|
ResetLastError();
|
|
|
|
if(!OrderCheck(request, check_result))
|
|
{
|
|
PrintFormat("Erro em OrderCheck: %d", GetLastError());
|
|
PrintFormat("Codigo de retorno: %d", check_result.retcode);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if(!OrderSend(request, result))
|
|
{
|
|
PrintFormat("Erro em OrderSend: %d", GetLastError());
|
|
PrintFormat("Codigo de retorno: %d", result.retcode);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
Print("Ordem enviada com sucesso");
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 8.2 - FUNCAO DE VENDA LIMITADA |
|
|
//+------------------------------------------------------------------+
|
|
void VendaLimite(double precoEnvio, double precoStop, double qtd)
|
|
{
|
|
//Limpar informacoes das estruturas
|
|
ZeroMemory(request);
|
|
ZeroMemory(result);
|
|
ZeroMemory(check_result);
|
|
|
|
request.magic = magic;
|
|
request.symbol = _Symbol;
|
|
request.action = TRADE_ACTION_PENDING;
|
|
request.type = ORDER_TYPE_SELL_LIMIT;
|
|
request.type_filling = ORDER_FILLING_RETURN;
|
|
request.type_time = ORDER_TIME_DAY;
|
|
request.volume = qtd;
|
|
request.price = simbolo.NormalizePrice(precoEnvio);
|
|
// request.price = NormalizeDouble(precoEnvio,normalizeDoubleSize);
|
|
request.deviation = 0;
|
|
// request.sl = NormalizeDouble(precoStop,normalizeDoubleSize);
|
|
request.sl = simbolo.NormalizePrice(precoStop);
|
|
// request.stoplimit = tickMin;
|
|
// request.tp = precoAlvo;
|
|
request.comment = "Venda Limitada";
|
|
|
|
// Print("Tipo: Venda Limitada", "/ Preco: ", NormalizeDouble(precoEnvio,normalizeDoubleSize),"/ Preco Stop: ", NormalizeDouble(precoStop,normalizeDoubleSize), "/ QTD: ", qtd);
|
|
|
|
ResetLastError();
|
|
|
|
if(!OrderCheck(request, check_result))
|
|
{
|
|
PrintFormat("Erro em OrderCheck: %d", GetLastError());
|
|
PrintFormat("Codigo de retorno: %d", check_result.retcode);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if(!OrderSend(request, result))
|
|
{
|
|
PrintFormat("Erro em OrderSend: %d", GetLastError());
|
|
PrintFormat("Codigo de retorno: %d", result.retcode);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
Print("Ordem enviada com sucesso");
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 8.3 - FUNCAO DE COMPRA A MERCADO |
|
|
//+------------------------------------------------------------------+
|
|
void CompraMercado(double precoStop, double qtd)
|
|
{
|
|
//Limpar informacoes das estruturas
|
|
ZeroMemory(request);
|
|
ZeroMemory(result);
|
|
ZeroMemory(check_result);
|
|
|
|
request.magic = magic;
|
|
request.symbol = _Symbol;
|
|
request.action = TRADE_ACTION_DEAL;
|
|
request.type = ORDER_TYPE_BUY;
|
|
request.type_filling = ORDER_FILLING_RETURN;
|
|
request.type_time = ORDER_TIME_DAY;
|
|
request.volume = qtd;
|
|
request.sl = NormalizeDouble(precoStop,normalizeDoubleSize);
|
|
// request.stoplimit = tickMin;
|
|
// request.tp = NormalizeDouble(precoAlvo,2);
|
|
request.comment = "Compra Mercado";
|
|
|
|
// Print("Tipo: Compra Mercado", "/ Preco Stop: ", NormalizeDouble(precoStop,normalizeDoubleSize), "/ QTD: ", qtd);
|
|
|
|
ResetLastError();
|
|
|
|
if(!OrderCheck(request, check_result))
|
|
{
|
|
PrintFormat("Erro em OrderCheck: %d", GetLastError());
|
|
PrintFormat("Codigo de retorno: %d", check_result.retcode);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if(!OrderSend(request, result))
|
|
{
|
|
PrintFormat("Erro em OrderSend: %d", GetLastError());
|
|
PrintFormat("Codigo de retorno: %d", result.retcode);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
Print("Ordem enviada com sucesso");
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 8.4 - FUNCAO DE VENDA A MERCADO |
|
|
//+------------------------------------------------------------------+
|
|
void VendaMercado(double precoStop, double qtd)
|
|
{
|
|
//Limpar informacoes das estruturas
|
|
ZeroMemory(request);
|
|
ZeroMemory(result);
|
|
ZeroMemory(check_result);
|
|
|
|
request.magic = magic;
|
|
request.symbol = _Symbol;
|
|
request.action = TRADE_ACTION_DEAL;
|
|
request.type = ORDER_TYPE_SELL;
|
|
request.type_filling = ORDER_FILLING_RETURN;
|
|
request.type_time = ORDER_TIME_DAY;
|
|
request.volume = qtd;
|
|
request.sl = NormalizeDouble(precoStop,normalizeDoubleSize);
|
|
// request.stoplimit = tickMin;
|
|
// request.tp = NormalizeDouble(precoAlvo,2);
|
|
request.comment = "Venda Mercado";
|
|
|
|
// Print("Tipo: Venda Mercado", "/ Preco Stop: ",NormalizeDouble(precoStop,normalizeDoubleSize), "/ QTD: ", qtd);
|
|
|
|
ResetLastError();
|
|
|
|
if(!OrderCheck(request, check_result))
|
|
{
|
|
PrintFormat("Erro em OrderCheck: %d", GetLastError());
|
|
PrintFormat("Codigo de retorno: %d", check_result.retcode);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
if(!OrderSend(request, result))
|
|
{
|
|
PrintFormat("Erro em OrderSend: %d", GetLastError());
|
|
PrintFormat("Codigo de retorno: %d", result.retcode);
|
|
return;
|
|
}
|
|
else
|
|
{
|
|
Print("Ordem enviada com sucesso");
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 8.5 - FUNCAO QUE MODIFICA ORDEM ENVIADA |
|
|
//+------------------------------------------------------------------+
|
|
int ModificaOrdem()
|
|
{
|
|
return 0;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 8.6 - FUNCAO DE CANCELAMENTO DE ORDENS PENDENTES |
|
|
//+------------------------------------------------------------------+
|
|
void CancelaOrdensAbertas()
|
|
{
|
|
ulong ticket = 0;
|
|
for(int i=OrdersTotal()-1;i>=0;i--){
|
|
ulong ticket = OrderGetTicket(i);
|
|
negocio.OrderDelete(ticket);
|
|
Print("Cancelou ordem aberta");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 8.7 - FUNCAO DE FECHAMENTO DE ORDENS EXECUTADAS |
|
|
//+------------------------------------------------------------------+
|
|
void FechaTrade()
|
|
{
|
|
double qtd = loteEnvio;
|
|
|
|
if(!PositionSelect(_Symbol))
|
|
return;
|
|
long tipoPosicao = PositionGetInteger(POSITION_TYPE);
|
|
|
|
if(tipoPosicao == POSITION_TYPE_BUY)
|
|
{
|
|
negocio.Sell(qtd, NULL, 0, 0, 0, "Saida por fechamento Trade");
|
|
}
|
|
else if(tipoPosicao==POSITION_TYPE_SELL)
|
|
{
|
|
negocio.Buy(qtd, NULL, 0, 0, 0, "Saida por fechamento Trade");
|
|
}
|
|
return;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 8.8 - FUNCAO DE FECHAMENTO DE TODAS AS POSICOES |
|
|
//+------------------------------------------------------------------+
|
|
void FechaPosicao()
|
|
{
|
|
double qtd = loteEnvio;
|
|
|
|
if(!PositionSelect(_Symbol))
|
|
return;
|
|
long tipoPosicao = PositionGetInteger(POSITION_TYPE);
|
|
|
|
if(tipoPosicao == POSITION_TYPE_BUY)
|
|
{
|
|
negocio.Sell(qtd, NULL, 0, 0, 0, "Saida por fechamento do dia");
|
|
}
|
|
else if(tipoPosicao==POSITION_TYPE_SELL)
|
|
{
|
|
negocio.Buy(qtd, NULL, 0, 0, 0, "Saida por fechamento do dia");
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 8.9 - FUNCAO DE CANCELAMENTO DE ORDEM PENDENTE DE COMPRA |
|
|
//+------------------------------------------------------------------+
|
|
void CancelaOrdemAbertaCompra()
|
|
{
|
|
//Percorre todas as ordens
|
|
for(int i=OrdersTotal()-1; i>=0; i--)
|
|
{
|
|
ulong ticket = OrderGetTicket(i);
|
|
string symbol = OrderGetString(ORDER_SYMBOL);
|
|
ulong magicEA = OrderGetInteger(ORDER_MAGIC);
|
|
|
|
//Verifica para cada ordem, se eh do simbolo corrente e do mesmo robo
|
|
if((symbol == _Symbol) && (magicEA == magic))
|
|
{
|
|
//Verifica se a ordem eh do tipo buy limit
|
|
if(OrderGetInteger(ORDER_TYPE) == ORDER_TYPE_BUY_LIMIT)
|
|
{
|
|
negocio.OrderDelete(ticket);
|
|
Print("Cancelou ordem aberta de compra");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 8.9 - FUNCAO DE CANCELAMENTO DE ORDEM PENDENTE DE VENDA |
|
|
//+------------------------------------------------------------------+
|
|
void CancelaOrdemAbertaVenda()
|
|
{
|
|
//Percorre todas as ordens
|
|
for(int i=OrdersTotal()-1; i>=0; i--)
|
|
{
|
|
ulong ticket = OrderGetTicket(i);
|
|
string symbol = OrderGetString(ORDER_SYMBOL);
|
|
ulong magicEA = OrderGetInteger(ORDER_MAGIC);
|
|
|
|
//Verifica para cada ordem, se eh do simbolo corrente e do mesmo robo
|
|
if((symbol == _Symbol) && (magicEA == magic))
|
|
{
|
|
//Verifica se a ordem eh do tipo sell limit
|
|
if(OrderGetInteger(ORDER_TYPE) == ORDER_TYPE_SELL_LIMIT)
|
|
{
|
|
negocio.OrderDelete(ticket);
|
|
Print("Cancelou ordem aberta de venda");
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return;
|
|
}
|
|
|
|
//+===================================================================================================================================================================================+
|
|
//| FIM DO PROGRAMA
|
|
//+===================================================================================================================================================================================+ |