1404 lines
No EOL
156 KiB
MQL5
1404 lines
No EOL
156 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| IndBruno.mq5 |
|
|
//| Copyright 2022, MetaQuotes Ltd. |
|
|
//| https://www.mql5.com |
|
|
//+------------------------------------------------------------------+
|
|
//+------------------------------------------------------------------+
|
|
//| DIRETIVAS && PRÉ-PROCESSADORES |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2022, MetaQuotes Software Corp."
|
|
#property link "brunoronzani@gmail.com - +55 (48)99933-2600"
|
|
#property version "10.9"
|
|
#property description "TOPOS e FUNDOS, SUPORTES e RESISTÊNCIAS, PULLBACK e DRAWBACK, PULLBACK2 (SECUNDÁRIO), DRAWBACK2 (SECUNDÁRIO), LTA e LTB"
|
|
//---
|
|
#property indicator_chart_window //--- Exibe o indicador na janela do gráfico e, não em janela separada
|
|
//---
|
|
//+------------------------------------------------------------------+
|
|
//| CARACTERÍSTICAS GERAIS DO INDICADOR |
|
|
//+------------------------------------------------------------------+
|
|
//---
|
|
#property indicator_buffers 30 //--- vetor de dados/buffers
|
|
#property indicator_plots 30 //--- plotagens gráficas
|
|
//---
|
|
//--- CARACTERÍSTICAS ESPECÍFICAS - TOPOS
|
|
#property indicator_label1 "Topos"
|
|
//--- plotar Invisível
|
|
#property indicator_type1 DRAW_NONE
|
|
//#property indicator_style1 STYLE_SOLID
|
|
//#property indicator_color1 clrRed
|
|
//#property indicator_width1 1
|
|
//--- CARACTERÍSTICAS ESPECÍFICAS - FUNDOS
|
|
#property indicator_label2 "Fundos"
|
|
#property indicator_type2 DRAW_NONE
|
|
//---
|
|
//--- CARACTERÍSTICAS ESPECÍFICAS - SUPORTES
|
|
#property indicator_label3 "Suportes"
|
|
//---
|
|
//--- CARACTERÍSTICAS ESPECÍFICAS - RESISTÊNCIAS
|
|
#property indicator_label4 "Resistências"
|
|
//---
|
|
//--- CARACTERÍSTICAS ESPECÍFICAS - PULLBACK
|
|
#property indicator_label5 "Pullback"
|
|
//---
|
|
//--- CARACTERÍSTICAS ESPECÍFICAS - DRAWBACK
|
|
#property indicator_label6 "Drawback"
|
|
//---
|
|
//--- CARACTERÍSTICAS ESPECÍFICAS - PULLBACK SECUNDÁRIO
|
|
#property indicator_label7 "Pulback Secundário"
|
|
//---
|
|
//--- CARACTERÍSTICAS ESPECÍFICAS - DRAWBACK SECUNDÁRIO
|
|
#property indicator_label8 "Drawback Secundário"
|
|
//---
|
|
//--- CARACTERÍSTICAS ESPECÍFICAS - LTA - LINHA DE TENDÊNCIA DE ALTA
|
|
#property indicator_label9 "LTA - Linha de Tendência de Alta"
|
|
//---
|
|
//--- CARACTERÍSTICAS ESPECÍFICAS - LTB - LINHA DE TENDÊNCIA DE BAIXA
|
|
#property indicator_label10 "LTB - Linha de Tendência de Baixa"
|
|
//---
|
|
//--- CARACTERÍSTICAS ESPECÍFICAS - MÁXIMA DO PRIMEIRO CANDLE DO DIA
|
|
#property indicator_label11 "Máxima Primeiro Candle"
|
|
//---
|
|
//--- CARACTERÍSTICAS ESPECÍFICAS - MÍNIMA DO PRIMEIRO CANDLE DO DIA
|
|
#property indicator_label12 "Mínima Primeiro Candle"
|
|
//---
|
|
struct base_dados {
|
|
//--- PRIMEIRA BARRA DO DIA
|
|
double highFirstBar; //--- MáXIMA da primeira barra do dia
|
|
double lowFirstBar; //--- MíNIMA da primeira barra do dia
|
|
double distFirstBar; //--- DISTâNCIA entre a máxima e mínima da primeira barra do dia
|
|
double topo; //--- Dados do ÚLTIMO TOPO registrado
|
|
double fundo; //--- Dados do ÚLTIMO FUNDO registrado
|
|
int firstBar; //--- Dados da última "primeira barra do dia" registrada
|
|
bool memFirstBar; //--- Booleana "primeira barra do dia" = true
|
|
//--- TOPOS e FUNDOS
|
|
datetime gatilhoFundoPrecoTFdt; //--- Horário do gatilho de FUNDO --- FUNDOS
|
|
double gatilhoFundoPrecoTF; //--- Preço de gatilho para registro do "último fundo"
|
|
double gatilhoFundoMaxTF; //--- Preço de gatilho para registro da máx do "último fundo"
|
|
bool gatilhoFundoTF; //--- Preço de gatilho que confirma e registra o "último fundo"
|
|
datetime gatilhoTopoPrecoTFdt; //--- Horário do gatilho de TOPO --- TOPOS
|
|
double gatilhoTopoPrecoTF; //--- Preço de gatilho para registro do "último topo"
|
|
double gatilhoTopoMinTF; //--- Preço de gatilho para registro da min do "último topo"
|
|
bool gatilhoTopoTF; //--- Preço de gatilho que confirma e registra o "último topo"
|
|
//--- SUPORTES e RESISTÊNCIAS
|
|
datetime gatilhoFundoPrecoSRdt; //--- Horário do gatilho de SUPORTE --- SUPORTES
|
|
double gatilhoFundoPrecoSR; //--- Preço de gatilho para registro do "último SUPORTE"
|
|
double gatilhoFundoMaxSR; //--- Preço de gatilho para registro da máx do "último SUPORTE"
|
|
bool gatilhoFundoSR; //--- Preço de gatilho que confirma e registra o "último SUPORTE"
|
|
datetime gatilhoTopoPrecoSRdt; //--- Horário do gatilho de RESISTÊNCIA --- RESISTÊNCIAS
|
|
double gatilhoTopoPrecoSR; //--- Preço de gatilho para registro da "última RESISTÊNCIA"
|
|
double gatilhoTopoMinSR; //--- Preço de gatilho para registro da min da "última RESISTÊNCIA"
|
|
bool gatilhoTopoSR; //--- Preço de gatilho que confirma e registra a "última RESISTÊNCIA"
|
|
//--- PULLBACK e DRAWBACK
|
|
datetime gatilhoFundoPrecoPDdt; //--- Horário do gatilho do preço de PULLBACK --- PULLBACK
|
|
double gatilhoFundoPrecoPD; //--- Preço de gatilho para registro do "último PULLBACK"
|
|
double gatilhoFundoMaxPD; //--- Preço de gatilho para registro da máx do "último PULLBACK"
|
|
bool gatilhoFundoPD; //--- Preço de gatilho que confirma e registra o "último PULLBACK"
|
|
datetime gatilhoTopoPrecoPDdt; //--- Horário do gatilho do preço de DRAWBACK --- DRAWBACK
|
|
double gatilhoTopoPrecoPD; //--- Preço de gatilho para registro do "último DRAWBACK"
|
|
double gatilhoTopoMinPD; //--- Preço de gatilho para registro da min do "último DRAWBACK"
|
|
bool gatilhoTopoPD; //--- Preço de gatilho que confirma e registra o "último DRAWBACK"
|
|
double drawback[]; //--- Vetor de DRAWBACK
|
|
double pullback[]; //--- Vetor PULLBACK
|
|
//--- PULLBACK2 (SECUNDÁRIO) e DRAWBACK2 (SECUNDÁRIO)
|
|
datetime gatilhoFundoPrecoPD2dt; //--- Horário do gatilho do preço de PULLBACK2 (SECUNDÁRIO) --- PULLBACK2 (SECUNDÁRIO)
|
|
double gatilhoFundoPrecoPD2; //--- Preço de gatilho para registro do "último PULLBACK2"
|
|
double gatilhoFundoMaxPD2; //--- Preço de gatilho para registro da máx do "último PULLBACK2"
|
|
bool gatilhoFundoPD2; //--- Preço de gatilho que confirma e registra o "último PULLBACK2"
|
|
datetime gatilhoTopoPrecoPD2dt; //--- Horário do gatilho do preço de DRAWBACK2 (SECUNDÁRIO) --- DRAWBACK2 (SECUNDÁRIO)
|
|
double gatilhoTopoPrecoPD2; //--- Preço de gatilho para registro do "último DRAWBACK2"
|
|
double gatilhoTopoMinPD2; //--- Preço de gatilho para registro da min do "último DRAWBACK2"
|
|
bool gatilhoTopoPD2; //--- Preço de gatilho que confirma e registra o "último DRAWBACK2"
|
|
double drawback2[]; //--- Vetor de DRAWBACK
|
|
double pullback2[]; //--- Vetor PULLBACK
|
|
//--- LTA - LINHA DE TENDÊNCIA DE ALTA e LTB - LINHA DE TENDÊNCIA DE BAIXA
|
|
|
|
//double arrayMaxD1[];
|
|
//double arrayMinD1[];
|
|
};
|
|
base_dados setup; //Variável do tipo setup
|
|
//+------------------------------------------------------------------+
|
|
//| INPUTS |
|
|
//+------------------------------------------------------------------+
|
|
input bool InpUseIndVisible = true; //--- Indicadores Visíveis (Sim=true/Não=false) - ainda não está sendo usado no indBruno
|
|
//--- Parâmetro TIMEFRAME para a Coleta dos DADOS
|
|
input ENUM_TIMEFRAMES InpTimeFrameTopoFundo = 0; //--- Time frame TOPOS e FUNDOS - ainda não está sendo usado no indBruno
|
|
input ENUM_TIMEFRAMES InpTimeFrameLTAeLTB = 0; //--- Time frame LTA e LTB - ainda não está sendo usado no indBruno
|
|
//--- parâmetro GERAL de TOPOS e FUNDOS
|
|
input bool InpUseFilterTopoFundo = true; //--- Usar Filtro GERAL TOPOS E FUNDOS (Sim=true/Não=false)
|
|
input double InpFilterTopoFundo = 500.0; //--- Parâmetro GERAL TOPOS E FUNDOS
|
|
input double InputMargemGatilhoTF = 20.0; //--- Margem Gatilho TOPOS E FUNDOS
|
|
//--- Parâmetro Específico de TOPOS e FUNDOS em relação ao 1º Candle - FirstBar
|
|
input bool InpUseFilterTopoFundo1Candle = true; //--- Usar Filtro Específico TOPOS E FUNDOS (Sim=true/Não=false) - FirstBar
|
|
input double InputMaiorQ1CandledoDia = 20.0; //--- Parâmetro ESPECÍFICO 1º TOPO E FUNDO - MAIOR QUE - FirstBar
|
|
input double InputMenorQ1CandledoDia = 300.0; //--- Parâmetro ESPECÍFICO 1º TOPO E FUNDO - MENOR QUE - FirstBar
|
|
//--- Parâmetro Específico de Distância para PullBack e Drawback
|
|
input bool InpUseFilterDistanciaPullBack = true; //--- Usar Distância PullBack (Sim=true/Não=false)
|
|
input string InpFilterDistanciaPullBack = "10|20|30|40|50"; //--- Distância PULLBACK e DRAWBACK em percentuais
|
|
//--- Parâmetro MARGEM de abrangência, em pontos, dos SUPORTES e RESISTÊNCIAS
|
|
input bool InpUseFilterSUPORTEeRESISTENCIA = true; //--- Usar SUPORTEeRESISTENCIA (Sim=true/Não=false)
|
|
input double InputMargemSUPORTEeRESISTENCIA = 0.0; //--- MARGEM de abrangência, dos SUPORTES e RESISTÊNCIAS
|
|
input int InputTotalSUPORTEeRESISTENCIA = 30; //--- Quantidade de dias de coleta dos SUPORTES e RESISTÊNCIAS
|
|
input string InputSymbolSUPORTEeRESISTENCIA = "WIN$N"; //--- "WDO$" para Mini Dólar e "WIN$" para Mini Índice
|
|
input double InputMargemGatilhoSR = 10; //--- Margem Gatilho SUPORTE E RESISTÊNCIA
|
|
//--- Parâmetros LTA e LTB
|
|
input bool InpUseFilterLT = true; //--- Usar LT (Sim=true/Não=false)
|
|
input double InputMinimoAngular = 20.0; //--- Ângulo mínimo PARÂMETRO LTA E LTB
|
|
input int InputQuantidadeLT = 4; //--- Quantidade de LTAs e LTBs podem ser cumuladas no gráfico
|
|
input double InputMargemLT = 10.0; //--- MARGEM de abrangência, das LTAs e LTBs
|
|
//---
|
|
//--- input int InputDiaAnterior = 1; //---
|
|
input int InputDiasAnteriores = 1; //--- ainda não está sendo usado no indBruno
|
|
//---
|
|
//--- input group "###### - Gerenciamento Notificações - ######"
|
|
input bool inpHabMsg = true; //--- Habilitar impressão/print de mensagens
|
|
//---
|
|
//+------------------------------------------------------------------+
|
|
//| Criação de objeto para TF FirstBar, renovação TF, PD e PD2 |
|
|
//+------------------------------------------------------------------+
|
|
//--- Entrada de parâmetros do MAX e MIN da primeira VELA
|
|
input string InpName = "Arrow"; // Nome do sinal
|
|
input int InpDate = 25; // Ponto de ancoragem da data em %
|
|
input int InpPrice = 25; // Ponto de ancoragem do preço em %
|
|
input ENUM_ARROW_ANCHOR InpAnchor = ANCHOR_TOP; // Tipo de ancoragem
|
|
input color InpColor = clrRed; // Cor do sinal
|
|
input ENUM_LINE_STYLE InpStyle = STYLE_DOT; // Estilo da linha da borda
|
|
input int InpWidth = 1; // Tamanho do sinal
|
|
input bool InpBack = false; // Sinal do fundo
|
|
input bool InpSelection = false; // Destaque para mover
|
|
input bool InpHidden = true; // Ocultar na lista de objetos
|
|
input long InpZOrder = 0; // Prioridade para clicar no mouse
|
|
//+------------------------------------------------------------------+
|
|
//| VARIÁVEIS GLOBAIS |
|
|
//+------------------------------------------------------------------+
|
|
//---
|
|
double indBufferTopos[]; //--- ainda não está sendo usado no indBruno
|
|
double indBufferFundos[]; //--- ainda não está sendo usado no indBruno
|
|
double indBufferSuportes[]; //--- ainda não está sendo usado no indBruno
|
|
double indBufferResistencias[]; //--- ainda não está sendo usado no indBruno
|
|
double indBufferPullback[]; //--- ainda não está sendo usado no indBruno
|
|
double indBufferDrawback[]; //--- ainda não está sendo usado no indBruno
|
|
double indBufferPulbackSecundario[]; //--- ainda não está sendo usado no indBruno
|
|
double indBufferDrawbackSecundario[]; //--- ainda não está sendo usado no indBruno
|
|
double indBufferLTA[]; //--- ainda não está sendo usado no indBruno
|
|
double indBufferLTB[]; //--- ainda não está sendo usado no indBruno
|
|
double indBufferMaximaPrimeiroCandle[]; //--- ainda não está sendo usado no indBruno
|
|
double indBufferMinimaPrimeiroCandle[]; //--- ainda não está sendo usado no indBruno
|
|
//---
|
|
MqlRates Rates[];
|
|
//int copiedResistencia = 0;
|
|
//+------------------------------------------------------------------+
|
|
//| DECLARACAO Banco de Dados |
|
|
//+------------------------------------------------------------------+
|
|
int db;
|
|
//+------------------------------------------------------------------+
|
|
//| DECLARACAO impressão de mensagens |
|
|
//+------------------------------------------------------------------+
|
|
string msg;
|
|
//+------------------------------------------------------------------+
|
|
//| FLAGS BOOLEANAS DAS FUNÇÕES ABAIXO |
|
|
//+------------------------------------------------------------------+
|
|
bool flagFCA = false; //--- Flag da Função ClearAll
|
|
bool flagFND = false; //--- Flag da Função NewDay
|
|
bool flagFCB = false; //--- Flag da Função CheckBottomTop
|
|
bool flagFFB = false; //--- Flag da Função FirstBar
|
|
//---
|
|
bool plotObj = false; //--- Armazena o estado inicial como false/falso/inválido //--- ainda não está sendo usado no indBruno
|
|
//+------------------------------------------------------------------+
|
|
//| Custom indicator initialization function |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit() {
|
|
//---
|
|
ArraySetAsSeries(Rates,true); //--- true significa ordem reversa de indexação.
|
|
//--- indicator buffers mapping - a função nativa para esse fim é a SetIndexBuffer
|
|
//--- Buffers do tipo DATA
|
|
SetIndexBuffer(0,indBufferTopos,INDICATOR_DATA); //--- ainda não está sendo usado no indBruno
|
|
SetIndexBuffer(1,indBufferFundos,INDICATOR_DATA); //--- ainda não está sendo usado no indBruno
|
|
SetIndexBuffer(2,indBufferSuportes,INDICATOR_DATA); //--- ainda não está sendo usado no indBruno
|
|
SetIndexBuffer(3,indBufferResistencias,INDICATOR_DATA); //--- ainda não está sendo usado no indBruno
|
|
SetIndexBuffer(4,indBufferPullback,INDICATOR_DATA); //--- ainda não está sendo usado no indBruno
|
|
SetIndexBuffer(5,indBufferDrawback,INDICATOR_DATA); //--- ainda não está sendo usado no indBruno
|
|
SetIndexBuffer(6,indBufferPulbackSecundario,INDICATOR_DATA); //--- ainda não está sendo usado no indBruno
|
|
SetIndexBuffer(7,indBufferDrawbackSecundario,INDICATOR_DATA); //--- ainda não está sendo usado no indBruno
|
|
SetIndexBuffer(8,indBufferLTA,INDICATOR_DATA); //--- ainda não está sendo usado no indBruno
|
|
SetIndexBuffer(9,indBufferLTB,INDICATOR_DATA); //--- ainda não está sendo usado no indBruno
|
|
SetIndexBuffer(10,indBufferMaximaPrimeiroCandle,INDICATOR_DATA); //--- ainda não está sendo usado no indBruno
|
|
SetIndexBuffer(11,indBufferMinimaPrimeiroCandle,INDICATOR_DATA); //--- ainda não está sendo usado no indBruno
|
|
//---
|
|
// EventSetTimer(1); // Comentei, pois, aparentemente, não está sendo usado
|
|
//--- Reset dos arrays de dados do indicador
|
|
ArrayInitialize(indBufferTopos,EMPTY_VALUE); //--- ainda não está sendo usado no indBruno
|
|
ArrayInitialize(indBufferFundos,EMPTY_VALUE); //--- ainda não está sendo usado no indBruno
|
|
ArrayInitialize(indBufferSuportes,EMPTY_VALUE); //--- ainda não está sendo usado no indBruno
|
|
ArrayInitialize(indBufferResistencias,EMPTY_VALUE); //--- ainda não está sendo usado no indBruno
|
|
ArrayInitialize(indBufferPullback,EMPTY_VALUE); //--- ainda não está sendo usado no indBruno
|
|
ArrayInitialize(indBufferDrawback,EMPTY_VALUE); //--- ainda não está sendo usado no indBruno
|
|
ArrayInitialize(indBufferPulbackSecundario,EMPTY_VALUE); //--- ainda não está sendo usado no indBruno
|
|
ArrayInitialize(indBufferDrawbackSecundario,EMPTY_VALUE); //--- ainda não está sendo usado no indBruno
|
|
ArrayInitialize(indBufferLTA,EMPTY_VALUE); //--- ainda não está sendo usado no indBruno
|
|
ArrayInitialize(indBufferLTB,EMPTY_VALUE); //--- ainda não está sendo usado no indBruno
|
|
ArrayInitialize(indBufferMaximaPrimeiroCandle,EMPTY_VALUE); //--- ainda não está sendo usado no indBruno
|
|
ArrayInitialize(indBufferMinimaPrimeiroCandle,EMPTY_VALUE); //--- ainda não está sendo usado no indBruno
|
|
//--- Inicialização bem sucedida.
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Função chamada durante a desinicialização |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason) {
|
|
//--- REMOVE TODOS OS OBJETOS A PARTIR DE UM GRáFICO ESPECíFICO
|
|
//ObjectsDeleteAll(0,InpName,-1,OBJ_ARROW_UP); //--- InpName,-1,OBJ_ARROW_UP
|
|
//ObjectsDeleteAll(0,InpName,-1,OBJ_ARROW_DOWN); //--- InpName,-1,OBJ_ARROW_DOWN
|
|
//ObjectsDeleteAll(0,"suporte",-1,OBJ_HLINE); //--- "suporte",-1,OBJ_HLINE
|
|
//ObjectsDeleteAll(0,"resistencia",-1,OBJ_HLINE); //--- "resistencia",-1,OBJ_HLINE
|
|
//---
|
|
//EventKillTimer(); // Comentei, pois, aparentemente, não está sendo usado
|
|
//---
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Função On Calculate para iteração de Indicador Customizado |
|
|
//+------------------------------------------------------------------+
|
|
int OnCalculate(const int rates_total, //--- Tamanho do array price[] - total de barras no gráfico
|
|
const int prev_calculated, //--- Barras tratadas na chamada anterior
|
|
const datetime & time[], //--- Hora
|
|
const double & open[], //--- Abertura
|
|
const double & high[], //--- Máxima
|
|
const double & low[], //--- Mínima
|
|
const double & close[], //--- Fechamento
|
|
const long & tick_volume[], //--- Volume de Tick
|
|
const long & volume[], //--- Volume Real
|
|
const int & spread[]) { //--- Spread
|
|
//--- ABERTURA DE NOVA VELA
|
|
if(prev_calculated != rates_total && prev_calculated > 0) {
|
|
//--- ESPECIFICAR MOMNETO DE UM NOVO DIA
|
|
string bar1Day = StringSubstr(TimeToString(time[rates_total-3]),8,2); //--- 2022.10.17 - Barra 1 de 3
|
|
string bar2Day = StringSubstr(TimeToString(time[rates_total-2]),8,2); //--- 2022.10.17 - Barra 2 de 3
|
|
string bar3Day = StringSubstr(TimeToString(time[rates_total-1]),8,2); //--- 2022.10.18 - Barra 3 de 3
|
|
if(bar1Day==bar2Day&&bar2Day!=bar3Day) {
|
|
//---
|
|
//flagFCA = false;
|
|
flagFND = false;
|
|
flagFCB = false;
|
|
//---
|
|
//--- ABERTURA DA SEGUNDA VELA/BARRA DO DIA
|
|
} else if(bar1Day!=bar2Day&&bar2Day==bar3Day) {
|
|
//--- Se flagFCA estiver "false", então, chama-se a FuncaoClearAll - função para limpar a estrutura e DB
|
|
if(!flagFCA) FuncaoClearAll(); // if(!flagFCA)
|
|
//--- Se flagFND for "false", então, chama-se a NewDay, para a coleta das informações respectivas
|
|
if(!flagFND) NewDay(rates_total, rates_total - 1, time, open, high, low, close); //if(!flagFND)
|
|
//--- Se CheckBottomTop for "true", então, tem-se a coleta das informações respectivas
|
|
if(CheckBottomTop(rates_total, rates_total - 1, time, open, high, low, close)){
|
|
//---
|
|
// FALTA FAZER A VERIFICAÇÃO DE QUANDO ABRE UM NOVO DIA, DEPOIS DE JÁ TER COLOCADO O INDICADOR NO GRÁFICO
|
|
//---
|
|
}
|
|
//---
|
|
//--- ABERTURA "A PARTIR" DA TERCEIRA VELA DO DIA
|
|
} else if(bar1Day==bar2Day&&bar2Day==bar3Day) {
|
|
//--- Se flagFCA estiver "false", então, chama-se a FuncaoClearAll - função para limpar a estrutura e DB
|
|
if(!flagFCA) FuncaoClearAll(); //
|
|
//--- Se flagFND for "false", então, chama-se a NewDay, para a coleta das informações respectivas
|
|
if(!flagFND) NewDay(rates_total, rates_total - 1, time, open, high, low, close);//
|
|
//--- Se CheckBottomTop for "false"
|
|
if(flagFCB) {
|
|
//--- chama-se a FuncaoFirstBar, para a coleta das informações respectivas
|
|
int firstbar = FuncaoFirstBar(1, rates_total, rates_total-1, time, open, high, low, close);
|
|
msg = StringFormat ("firstbar: %d, time[firstbar] = %s",
|
|
firstbar, TimeToString(time[firstbar],TIME_DATE|TIME_SECONDS));
|
|
FuncaoPrint (msg);
|
|
//---
|
|
for(int i=firstbar;i<rates_total;i++) {
|
|
//---
|
|
if(CheckBottomTop(rates_total, rates_total - 1, time, open, high, low, close)){
|
|
//---
|
|
|
|
//---
|
|
}
|
|
//---
|
|
}
|
|
//---
|
|
flagFCB = true;
|
|
//---
|
|
} else {
|
|
//---
|
|
if(CheckBottomTop(rates_total, rates_total - 1, time, open, high, low, close)){
|
|
//---
|
|
|
|
//---
|
|
}
|
|
//---
|
|
}
|
|
|
|
}
|
|
//novo tick
|
|
} else if(prev_calculated == rates_total) {
|
|
//---
|
|
if(!flagFCA) return(rates_total);
|
|
//---
|
|
if(!flagFND) return(rates_total);
|
|
//---
|
|
if(!flagFCB) return(rates_total);
|
|
//---
|
|
if(CheckBottomTopTick(rates_total, rates_total - 1, time, open, high, low, close)) {
|
|
}
|
|
} //---
|
|
//--- return value of prev_calculated for next call
|
|
return(rates_total);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Função Clear All |
|
|
//+------------------------------------------------------------------+
|
|
void FuncaoClearAll() {
|
|
//--- REMOVE TODOS OS OBJETOS A PARTIR DE UM GRáFICO ESPECíFICO --- CLEAR MEM SETUP AND DBS
|
|
//ObjectsDeleteAll(0,InpName,-1,OBJ_ARROW_UP); //--- InpName,-1,OBJ_ARROW_UP
|
|
//ObjectsDeleteAll(0,InpName,-1,OBJ_ARROW_DOWN); //--- InpName,-1,OBJ_ARROW_DOWN
|
|
//ObjectsDeleteAll(0,"suporte",-1,OBJ_HLINE); //--- "suporte",-1,OBJ_HLINE
|
|
//ObjectsDeleteAll(0,"resistencia",-1,OBJ_HLINE); //--- "resistencia",-1,OBJ_HLINE
|
|
//--- CHAMADA DE UM REDESENHO FORÇADO DE UM GRÁFICO ESPECIFICADO.
|
|
ChartRedraw();
|
|
//--- FLAGs da FuncaoClearAll (flagFCA)
|
|
flagFCA = true;
|
|
//--- RESETAR/ZERAR SETUP
|
|
//--- PRIMEIRA BARRA DO DIA
|
|
setup.highFirstBar = 0;
|
|
setup.lowFirstBar = 0;
|
|
setup.distFirstBar = 0;
|
|
setup.topo = 0;
|
|
setup.fundo = 0;
|
|
setup.firstBar = 0;
|
|
setup.memFirstBar = true;
|
|
//--- TOPOS e FUNDOS
|
|
setup.gatilhoFundoPrecoTFdt = 0;
|
|
setup.gatilhoFundoPrecoTF = 0;
|
|
setup.gatilhoFundoMaxTF = 0;
|
|
setup.gatilhoFundoTF = false;
|
|
setup.gatilhoTopoPrecoTFdt = 0;
|
|
setup.gatilhoTopoPrecoTF = 0;
|
|
setup.gatilhoTopoMinTF = 0;
|
|
setup.gatilhoTopoTF = false;
|
|
//--- SUPORTES e RESISTÊNCIAS
|
|
setup.gatilhoFundoPrecoSRdt = 0;
|
|
setup.gatilhoFundoPrecoSR = 0;
|
|
setup.gatilhoFundoMaxSR = 0;
|
|
setup.gatilhoFundoSR = false;
|
|
setup.gatilhoTopoPrecoSRdt = 0;
|
|
setup.gatilhoTopoPrecoSR = 0;
|
|
setup.gatilhoTopoMinSR = 0;
|
|
setup.gatilhoTopoSR = false;
|
|
//--- PULLBACK e DRAWBACK
|
|
setup.gatilhoFundoPrecoPDdt = 0;
|
|
setup.gatilhoFundoPrecoPD = 0;
|
|
setup.gatilhoFundoMaxPD = 0;
|
|
setup.gatilhoFundoPD = false;
|
|
setup.gatilhoTopoPrecoPDdt = 0;
|
|
setup.gatilhoTopoPrecoPD = 0;
|
|
setup.gatilhoTopoMinPD = 0;
|
|
setup.gatilhoTopoPD = false;
|
|
ArrayFree(setup.drawback);
|
|
ArrayFree(setup.pullback);
|
|
//--- PULLBACK2 (SECUNDÁRIO) e DRAWBACK2 (SECUNDÁRIO)
|
|
setup.gatilhoFundoPrecoPD2dt = 0;
|
|
setup.gatilhoFundoPrecoPD2 = 0;
|
|
setup.gatilhoFundoMaxPD2 = 0;
|
|
setup.gatilhoFundoPD2 = false;
|
|
setup.gatilhoTopoPrecoPD2dt = 0;
|
|
setup.gatilhoTopoPrecoPD2 = 0;
|
|
setup.gatilhoTopoMinPD2 = 0;
|
|
setup.gatilhoTopoPD2 = false;
|
|
ArrayFree(setup.drawback2);
|
|
ArrayFree(setup.pullback2);
|
|
|
|
//--- LTA - LINHA DE TENDÊNCIA DE ALTA e LTB - LINHA DE TENDÊNCIA DE BAIXA
|
|
|
|
//--- Chamada da FUNÇÃO CreateDataBase - tabelas de dados DB
|
|
CreateDataBase();
|
|
//---
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Função New Day |
|
|
//+------------------------------------------------------------------+
|
|
void NewDay(const int rt, //--- Tamanho do array - total de barras no gráfico
|
|
const int k, //--- Barras tratadas na chamada anterior
|
|
const datetime & time[], //--- Hora
|
|
const double & open[], //--- Abertura
|
|
const double & high[], //--- Máxima
|
|
const double & low[], //--- Mínima
|
|
const double & close[]) { //--- Fechamento
|
|
|
|
//--- FLAG da função NewDay atribuída como true/verdadeiro/válido.
|
|
flagFND = true;
|
|
//--- Alimenta a variável firstbar com os elementos da FuncaoFirstBar
|
|
int firstbar = FuncaoFirstBar(1, rt, k, time, open, high, low, close);
|
|
//--- Alimenta a variável do tipo setup.
|
|
setup.highFirstBar = high[firstbar]; //--- com a MáXIMA da primeira vela do dia
|
|
setup.lowFirstBar = low[firstbar]; //--- com a MíNIMA da primeira vela do dia
|
|
setup.distFirstBar = setup.highFirstBar - setup.lowFirstBar; //--- com a diferença entre a máxima e a mínima da primeira vela do dia
|
|
//---
|
|
// pensar no tratamento de erro caso encontra uma vela // com maxima menor do que low, ou seja, setup.distFirstBar < 0;
|
|
|
|
//--- CRIA o NOME do sinal que será plotado no gráfico
|
|
string name = InpName + "_Up_" + string(ulong(time[firstbar]));
|
|
//--- CRIA plotagem de sinal ARROW UP no gráfico
|
|
//if(plotObj) {
|
|
if(!ArrowCreate(0, name, 0, time[firstbar], setup.highFirstBar, ANCHOR_TOP, OBJ_ARROW_UP, InpColor,
|
|
InpStyle, InpWidth, InpBack, InpSelection, InpHidden, InpZOrder)) {
|
|
return;
|
|
}
|
|
name = InpName + "_Down_" + string(ulong(time[firstbar]));
|
|
//--- CRIA plotagem de sinal ARROW DOWN no gráfico
|
|
if(!ArrowCreate(0, name, 0, time[firstbar], setup.lowFirstBar, ANCHOR_BOTTOM, OBJ_ARROW_DOWN,InpColor,
|
|
InpStyle, InpWidth, InpBack, InpSelection, InpHidden, InpZOrder)) {
|
|
//--- FLAG da plotObj atribuída como false/falso/inválido
|
|
//plotObj = false;
|
|
return;
|
|
}
|
|
//}//--- FIM if(plotObj)
|
|
|
|
//--- CHAMADA DE UM REDESENHO FORÇADO DE UM GRÁFICO ESPECIFICADO.
|
|
ChartRedraw();
|
|
//---
|
|
FuncaoSuporteResistencia(close[k-1]); //--- aqui estava k, adicinei k-1 - verificar se está correta a correção
|
|
//---
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| FUNÇÃO ON TIMER |
|
|
//+------------------------------------------------------------------+
|
|
void OnTimer(void) { //--- AINDA NÃO ESTÁ SENDO USADA NO indBruno
|
|
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| FUNÇÃO SUPORTES E RESISTÊNCIAS |
|
|
//+------------------------------------------------------------------+
|
|
void FuncaoSuporteResistencia(double price_ref) {
|
|
//---
|
|
int cont = 0, copiedSuporteResistencia = 0;
|
|
//--- achar o metodo que retorna a quantidade maxima de velas disponiveis (TERMINAL_MAXBARS?)?
|
|
//---
|
|
copiedSuporteResistencia=CopyRates(InputSymbolSUPORTEeRESISTENCIA,PERIOD_D1,1,TERMINAL_MAXBARS,Rates);
|
|
//copiedResistencia=CopyRates(InputSymbolSUPORTEeRESISTENCIA,PERIOD_D1,1,InputTotalSUPORTEeRESISTENCIA,Rates);
|
|
//--- SE A VARIÁVEL "copiedSuporteResistencia" TÊM DADOS
|
|
if(copiedSuporteResistencia>0) {
|
|
//--- ENTÃO, É FEITO O LAÇO DE REPETIÇÃO PARA SUPORTE
|
|
for(int i=0;i<copiedSuporteResistencia;i++) {
|
|
//--- SE COTAÇÃO DAS [i] MÍNIMAS SÃO MENORES DO QUE O PREÇO DE REFERÊNCIA
|
|
if(Rates[i].low < price_ref) {
|
|
//--- INSERE-SE NA TABELA "SUPORTE" OS DADOS DOS SUPORTES - MÍNIMAS DOS DIAS ANTEIRIORES
|
|
if(InsertTable(db,"SUPORTE",Rates[i].low,Rates[i].time,ulong(Rates[i].time))) cont++;
|
|
//--- CRIA O NOME DO OBJETO QUE SERÁ PLOTADO
|
|
string name = "suporte_"+(string)i;
|
|
//--- CRIA UMA LINHA HORIZONTAL DE SUPORTE
|
|
if(!HLineCreate(0,name,0,Rates[i].low,clrRed,InpStyle,InpWidth,InpBack,
|
|
InpSelection,InpHidden,InpZOrder)) {
|
|
return;
|
|
}
|
|
//---
|
|
}
|
|
//--- SE O CONTADOR É MAIOR OU IGUAL AO VALOR DO INPUT, ENTÃO, DEVE PARAR O LAÇO DE REPETIÇÃO PARA ENCONTRAR OS SUPORTES
|
|
if(cont>=InputTotalSUPORTEeRESISTENCIA) break;
|
|
//---
|
|
}
|
|
} else {
|
|
//--- SENÃO, ENVIO DE MENSAGEM DE POSSÍVEL ERRO "copiedSuporteResistencia"
|
|
msg = StringFormat ("%s - Possivel erro! Copied = %d;",
|
|
__FUNCTION__,copiedSuporteResistencia);
|
|
FuncaoPrint(msg);
|
|
//---
|
|
}
|
|
cont = 0;
|
|
//--- SE A VARIÁVEL "copiedSuporteResistencia" TÊM DADOS
|
|
if(copiedSuporteResistencia>0) {
|
|
//--- ENTÃO, É FEITO O LAÇO DE REPETIÇÃO PARA SUPORTE
|
|
for(int i=0;i<copiedSuporteResistencia;i++) {
|
|
//--- SE COTAÇÃO DAS [i] MÁXIMAS SÃO MAIORES DO QUE O PREÇO DE REFERÊNCIA
|
|
if(Rates[i].high > price_ref) {
|
|
//--- INSERE-SE NA TABELA "RESISTENCIA" OS DADOS DAS RESISTÊNCIAS - MÁXIMAS DOS DIAS ANTEIRIORES
|
|
if(InsertTable(db,"RESISTENCIA",Rates[i].high,Rates[i].time,ulong(Rates[i].time))) cont++;
|
|
//--- CRIA O NOME DO OBJETO QUE SERÁ PLOTADO
|
|
string name = "resistencia_"+(string)i;
|
|
//--- CRIA UMA LINHA HORIZONTAL DE RESISTÊNCIA
|
|
if(!HLineCreate(0,name,0,Rates[i].high,clrGreenYellow,InpStyle,InpWidth,InpBack,
|
|
InpSelection,InpHidden,InpZOrder)) {
|
|
return;
|
|
}
|
|
//---
|
|
}
|
|
//--- SE O CONTADOR É MAIOR OU IGUAL AO VALOR DO INPUT, ENTÃO, DEVE PARAR O LAÇO DE REPETIÇÃO - SUPORTES
|
|
if(cont>=InputTotalSUPORTEeRESISTENCIA) break;
|
|
//---
|
|
|
|
}
|
|
} else {
|
|
//--- SENÃO, ENVIO DE MENSAGEM DE POSSÍVEL ERRO "copiedSuporteResistencia"
|
|
msg = StringFormat("%s - Possivel erro! Copied = %d;",
|
|
__FUNCTION__,copiedSuporteResistencia);
|
|
FuncaoPrint(msg);
|
|
//---
|
|
}
|
|
//--- CHAMADA DE UM REDESENHO FORÇADO DE UM GRÁFICO ESPECIFICADO.
|
|
ChartRedraw();
|
|
//---
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| FUNÇÃO PRIMEIRA BARRA DO DIA |
|
|
//+------------------------------------------------------------------+
|
|
int FuncaoFirstBar(int diaAnterior, //--- Dia anterior - para encontrar a primeira barra do dia posterior
|
|
const int rt, //--- Tamanho do array - total de barras no gráfico
|
|
const int k, //--- Barras tratadas na chamada anterior
|
|
const datetime & time[], //--- Hora
|
|
const double & open[], //--- Abertura
|
|
const double & high[], //--- Máxima
|
|
const double & low[], //--- Mínima
|
|
const double & close[]) { //--- Fechamento
|
|
flagFFB = true;
|
|
//---
|
|
/*
|
|
dia 144500 03/10/2022 seg REF
|
|
dia 144499 02/10/2022 dom OBS NAO TEM DADO
|
|
dia 144498 01/10/2022 sab OBS NAO TEM DADO
|
|
dia 144497 30/09/2022 sex
|
|
dia 144496 29/09/2022 qui
|
|
dia 144495 28/09/2022 qua
|
|
dia 144494 27/09/2022 ter objetivo **** primeira vela do dia em questao
|
|
dia 144493 26/09/2022 seg ******* ultima vela do dia anterior
|
|
*/
|
|
//--- INICIA-SE COM AS VARIÁVEIS DESIGNADAS COMO ZERO
|
|
int firstbar = 0, contDay = 0;
|
|
//--- 1º, foi armazenado na variável dayRef, ao dividir time[rt - 1] por 86400 = dias / 2º, normalização do time (milisegundos) para dias = divisão por 86400 = DIA
|
|
ulong dayRef = time[rt - 1] / 86400, dayCont = time[rt - 1] / 86400;
|
|
//--- ENTÃO, É FEITO O LAÇO DE REPETIÇÃO PARA rt-1 (última barra fechada) com indexador decrescente
|
|
for(int i = rt - 1; i >= 1; i--) {
|
|
//--- É atribuído à variável dayRef a informação do Dia de referência
|
|
dayRef = time[i] / 86400;
|
|
//--- Se, o dia de referência é diferente de dayCount
|
|
if (dayRef != dayCont) {
|
|
//--- Será indexado o acréscimo à counDay até que dayCont seja = a dayRef
|
|
contDay++;
|
|
dayCont = dayRef;
|
|
}
|
|
//--- SE contDay FOR MAIOR OU IGUAL AO diaAnterior
|
|
if(contDay >= diaAnterior) {
|
|
//--- É ATRIBUÍDO À VARIÁVEL firstbar O VALOR DE [i] +1, pois se trata da primeira barra do dia
|
|
firstbar = i + 1;
|
|
//--- O operador break finaliza a execução do operador for mais próximo
|
|
break;
|
|
//---
|
|
}
|
|
//--- FIM do for(int i = rt - 1; i >= 1; i--)
|
|
}
|
|
//--- O operador return finaliza a execução da função corrente e retorna o valor da variável firstbar
|
|
return firstbar;
|
|
}
|
|
//+---------------------------------------------------------------------+
|
|
//| FUNÇÃO CheckBottomTopTick - MERCADO ABERTO - PRESENTE - A CADA TICK |
|
|
//+---------------------------------------------------------------------+
|
|
bool CheckBottomTopTick(const int rt, //--- Tamanho do array - total de barras no gráfico
|
|
const int k, //--- Barras tratadas a cada tick
|
|
const datetime & time[], //--- Hora
|
|
const double & open[], //--- Abertura
|
|
const double & high[], //--- Máxima
|
|
const double & low[], //--- Mínima
|
|
const double & close[]) { //--- Fechamento
|
|
//---
|
|
return false;
|
|
//---
|
|
}
|
|
//+---------------------------------------------------------------------+
|
|
//| FUNÇÃO CheckBottomTop - PARA O PASSADO - BARRA FECHADA |
|
|
//+---------------------------------------------------------------------+
|
|
bool CheckBottomTop(const int rt, //--- Tamanho do array - total de barras no gráfico
|
|
const int k, //--- Barras tratadas na chamada anterior
|
|
const datetime & time[], //--- Hora
|
|
const double & open[], //--- Abertura
|
|
const double & high[], //--- Máxima
|
|
const double & low[], //--- Mínima
|
|
const double & close[]) { //--- Fechamento
|
|
|
|
//--- FLAG da Função CheckBottomTop - flagFCB - ATIVADA PARA TRUE
|
|
flagFCB = true;
|
|
//--- Ainda estou olhando pra primeira vela
|
|
if(setup.memFirstBar == true) {
|
|
//--- NÃO TEM FUNDO e NÃO TEM TOPO DEFINIDOS
|
|
if(setup.fundo == 0 && setup.topo == 0) {
|
|
//--- DEFINIU-SE O FUNDO NA MÍNIMA DA 1ª BARRA (VELA ANTERIOR K-1)
|
|
setup.fundo = low[k-1];
|
|
indBufferFundos[k-1] = setup.fundo;
|
|
//--- DEFINIU-SE O TOPO NA MÁXIMA DA 1ª BARRA (VELA ANTERIOR K-1)
|
|
setup.topo = high[k-1];
|
|
//--- ARMAZENA-SE O ÚLTIMO TOPO REGISTRADO, NA TABELA TOPOS.
|
|
InsertTable(db,"TOPOS",high[k-1],time[k-1],ulong(time[k-1]));
|
|
//--- ARMAZENA-SE O ÚLTIMO FUNDO REGISTRADO, NA TABELA FUNDOS.
|
|
InsertTable(db,"FUNDOS",low[k-1],time[k-1],ulong(time[k-1]));
|
|
//--- SE TEM FUNDO DEFINIDO e TOPO DEFINIDO
|
|
} else if(setup.fundo>0 && setup.topo>0) {
|
|
//--- SITUAÇÃO DE RENOVAÇÃO DE TOPO - PRIMEIRA BARRA DO DIA
|
|
//--- RENOVAÇÃO DE TOPO / PRIMEIRA BARRA DO DIA - GATILHO
|
|
if(close[k-2] >= setup.highFirstBar + InputMaiorQ1CandledoDia &&
|
|
high[k-2] >= high[k-1]) {
|
|
//--- ATUALIZAÇÃO DAS MEMÓRIAS DAS VARIÁVEIS DA STRUCT BASE_DADOS
|
|
setup.gatilhoTopoTF = true;
|
|
setup.gatilhoTopoPrecoTF = high[k-2];
|
|
setup.gatilhoTopoMinTF = low[k-2];
|
|
setup.gatilhoTopoPrecoTFdt = time[k-2];
|
|
//--- RENOVAÇÃO DE TOPO / PRIMEIRA BARRA DO DIA - CONFIRMACAO
|
|
} //--- SENÃO, SE GATILHOTF É VÁLIDO/VERDADEIRO E FECHAMENTO DA BARRA ANTERIOR SOMADO AO INPUT FOR MENOR QUE A MÍNIMA DO CANDLE GATILHO
|
|
else if(setup.gatilhoTopoTF &&
|
|
(close[k-1] + InputMargemGatilhoTF <= setup.gatilhoTopoMinTF)) {
|
|
//--- LOGO, NÃO TEM FUNDO VIGENTE, PORTANTO, -1;
|
|
setup.fundo = -1;
|
|
//--- TEM-SE UM NOVO TOPO, IDENTIFICADO PELO PREÇO DA MÁXIMA DO CANDLE GATILHO - SITUAÇÃO DE RENOVAÇÃO DE TOPO
|
|
setup.topo = setup.gatilhoTopoPrecoTF;
|
|
//--- ARMAZENA-SE O ÚLTIMO TOPO REGISTRADO, NA TABELA TOPOS
|
|
InsertTable(db,"TOPOS",setup.gatilhoTopoPrecoTF,setup.gatilhoTopoPrecoTFdt,ulong(setup.gatilhoTopoPrecoTFdt));
|
|
//--- NÃO ESTÁ MAIS "OLHANDO" PARA A PRIMEIRA BARRA DO DIA
|
|
setup.memFirstBar = false;
|
|
//--- CRIA O NOME DO OBJETO QUE SERÁ PLOTADO
|
|
string name = InpName + "_RENOVAÇÃO-TOPO-1BARRA_" + string(ulong(setup.gatilhoTopoPrecoTFdt));
|
|
//--- CRIA sinal ARROW UP no gráfico - NOVO TOPO
|
|
|
|
if(!ArrowCreate(0, name, 0, setup.gatilhoTopoPrecoTFdt, setup.topo, ANCHOR_TOP, OBJ_ARROW_UP, InpColor,
|
|
InpStyle, InpWidth, InpBack, InpSelection, InpHidden, InpZOrder)) {
|
|
//--- ENVIO DE PRINT DE FALHA DE CRIAÇÃO DO OBJETO - PLOTAGEM GRÁFICA
|
|
msg = StringFormat("ArrowCreate Failed %s as %s - Topo atual = %.2f;",
|
|
name,TimeToString(setup.gatilhoTopoPrecoTFdt,TIME_DATE|TIME_SECONDS),setup.topo);
|
|
FuncaoPrint(msg);
|
|
|
|
//---RESETAR/ZERAR GATILHOS
|
|
setup.gatilhoTopoTF = false;
|
|
setup.gatilhoTopoPrecoTF = 0;
|
|
setup.gatilhoTopoMinTF = 0;
|
|
setup.gatilhoTopoPrecoTFdt = 0;
|
|
//--- FIM CRIAÇÃO DE OBJETO E PRINT
|
|
} else
|
|
//--- ENVIO DE PRINT DA RENOVAÇÃO DE TOPO EM RELAÇÃO À PRIMEIRA BARRA DO DIA
|
|
msg = StringFormat("%s - %s - PRIMEIRA VELA - RENOVACAO DE TOPO: Topo atual = %.2f;",
|
|
__FUNCTION__,TimeToString(setup.gatilhoTopoPrecoTFdt,TIME_DATE|TIME_SECONDS),setup.topo);
|
|
FuncaoPrint(msg);
|
|
//---
|
|
//--- FIM SITUAÇÃO DE RENOVAÇÃO DE TOPO - PRIMEIRA BARRA DO DIA
|
|
}
|
|
//--- SITUAÇÃO DE RENOVAÇÃO DE FUNDO - PRIMEIRA BARRA DO DIA
|
|
//--- RENOVAÇÃO DE FUNDO / PRIMEIRA BARRA DO DIA - GATILHO
|
|
else if(close[k-2] <= setup.lowFirstBar - InputMaiorQ1CandledoDia &&
|
|
low[k-2] <= high[k-1]) {
|
|
//--- ATUALIZAÇÃO DAS MEMÓRIAS DAS VARIÁVEIS DA STRUCT BASE_DADOS
|
|
setup.gatilhoFundoTF = true;
|
|
setup.gatilhoFundoPrecoTF = low[k-2];
|
|
setup.gatilhoFundoMaxTF = high[k-2];
|
|
setup.gatilhoFundoPrecoTFdt = time[k-2];
|
|
//--- RENOVAÇÃO DE FUNDO / PRIMEIRA BARRA DO DIA - CONFIRMACAO
|
|
} //--- SENÃO, SE GATILHOTF É VÁLIDO/VERDADEIRO E FECHAMENTO DA BARRA ANTERIOR SUTRAÍDO PELO INPUT FOR MENOR QUE A MáXIMA DO CANDLE GATILHO
|
|
else if(setup.gatilhoFundoTF &&
|
|
(close[k-1] - InputMargemGatilhoTF >= setup.gatilhoFundoMaxTF)) {
|
|
//--- LOGO, NÃO TEM TOPO VIGENTE, PORTANTO, -1;
|
|
setup.topo = -1;
|
|
//--- TEM-SE UM NOVO FUNDO, IDENTIFICADO PELO PREÇO DA MÍNIMA DO CANDLE GATILHO - SITUAÇÃO DE RENOVAÇÃO DE FUNDO
|
|
setup.fundo = setup.gatilhoFundoPrecoTF;
|
|
//--- ARMAZENA-SE O ÚLTIMO FUNDO REGISTRADO, NA TABELA FUNDOS
|
|
InsertTable(db,"FUNDOS",setup.gatilhoFundoPrecoTF,setup.gatilhoFundoPrecoTFdt,ulong(setup.gatilhoFundoPrecoTFdt));
|
|
//--- NÃO ESTÁ MAIS "OLHANDO" PARA A PRIMEIRA BARRA DO DIA
|
|
setup.memFirstBar = false;
|
|
//--- CRIA O NOME DO OBJETO QUE SERÁ PLOTADO
|
|
string name = InpName + "_RENOVAÇÃO-FUNDO-1BARRA_" + string(ulong(setup.gatilhoFundoPrecoTFdt));
|
|
//--- CRIA sinal ARROW DOWN no gráfico - NOVO FUNDO
|
|
if(!ArrowCreate(0, name, 0, setup.gatilhoFundoPrecoTFdt, setup.fundo, ANCHOR_BOTTOM, OBJ_ARROW_DOWN, InpColor,
|
|
InpStyle, InpWidth, InpBack, InpSelection, InpHidden, InpZOrder)) {
|
|
//--- ENVIO DE PRINT DE FALHA DE CRIAÇÃO DO OBJETO - PLOTAGEM GRÁFICA
|
|
msg = StringFormat("ArrowCreate Failed %s as %s - Fundo atual = %.2f;",
|
|
name,TimeToString(setup.gatilhoFundoPrecoTFdt,TIME_DATE|TIME_SECONDS),setup.fundo);
|
|
FuncaoPrint(msg);
|
|
|
|
//---RESETAR/ZERAR GATILHOS
|
|
setup.gatilhoFundoTF = false;
|
|
setup.gatilhoFundoPrecoTF = 0;
|
|
setup.gatilhoFundoMaxTF = 0;
|
|
setup.gatilhoFundoPrecoTFdt = 0;
|
|
//--- FIM CRIAÇÃO DE OBJETO E PRINT
|
|
} else
|
|
//--- ENVIO DE PRINT DA RENOVAÇÃO DE FUNDO EM RELAÇÃO À PRIMEIRA BARRA DO DIA
|
|
msg = StringFormat("%s - %s - PRIMEIRA VELA - RENOVACAO DE FUNDO: Fundo atual = %.2f;",
|
|
__FUNCTION__,TimeToString(setup.gatilhoFundoPrecoTFdt,TIME_DATE|TIME_SECONDS),setup.fundo);
|
|
FuncaoPrint(msg);
|
|
//---
|
|
//--- FIM SITUAÇÃO DE RENOVAÇÃO DE TOPO - PRIMEIRA BARRA DO DIA
|
|
}
|
|
} //--- FIM else if(setup.fundo>0 && setup.topo>0)
|
|
} //--- FIM if(setup.memFirstBar == true)
|
|
//--- NAO estou olhando mais para a primeira vela
|
|
else if(setup.memFirstBar == false) {
|
|
//---
|
|
if(InpUseFilterTopoFundo) {
|
|
//--- EXISTE UM FUNDO DEFINIDO
|
|
if (setup.fundo>0 && setup.topo<0) {
|
|
//--- CRITÉRIOS DE RENOVAÇÃO DE FUNDO - FILTRO TOPO E FUNDO
|
|
//--- SE A MÍNIMA DA PENÚLTIMA VELA (K-2) FOR MENOR OU IGUAL QUE O FUNDO VIGENTE E
|
|
if((low[k-2] <= setup.fundo) &&
|
|
//--- E O FECHAMENTO DA ÚLTIMA VELA (K-1) SUBTRAÍDO PELO InputMargemGatilhoTF FOR MAIOR OU IGUAL QUE ABERTURA E FECHAMENTO DA PENÚLTIMA VELA (K-2)
|
|
(close [k-1] - InputMargemGatilhoTF >= open [k-2] && close [k-1] - InputMargemGatilhoTF >= close [k-2])) {
|
|
//--- TEM-SE UM NOVO FUNDO, IDENTIFICADO PELA MÍNIMA DA PENÚLTIMA BARRA FECHADA (K-2) - SITUAÇÃO DE RENOVAÇÃO DE FUNDO
|
|
setup.fundo = low[k-2];
|
|
//--- ARMAZENA-SE O ÚLTIMO FUNDO REGISTRADO, NA TABELA FUNDOS
|
|
InsertTable(db,"FUNDOS",low[k-2],time[k-2],ulong(time[k-2]));
|
|
//--- CRIA O NOME DO OBJETO QUE SERÁ PLOTADO
|
|
string name = InpName + "_FundoRENOVAÇÃOTF_" + string(ulong(time[k-2]));
|
|
//--- CRIA sinal ARROW DOWN no gráfico - NOVO FUNDO
|
|
if(!ArrowCreate(0, name, 0, time[k-2], setup.fundo, ANCHOR_BOTTOM, OBJ_ARROW_DOWN, InpColor,
|
|
InpStyle, InpWidth, InpBack, InpSelection, InpHidden, InpZOrder)) {
|
|
//--- ENVIO DE PRINT DE FALHA DE CRIAÇÃO DO OBJETO - PLOTAGEM GRÁFICA
|
|
msg = StringFormat("%s - %s - VELAS SEGUINTES TF - RENOVACAO DE FUNDO TF: Fundo atual = %.2f; low = %.2f;",
|
|
__FUNCTION__,TimeToString(time[k-2],TIME_DATE|TIME_SECONDS),setup.fundo,low[k-2]);
|
|
FuncaoPrint(msg);
|
|
|
|
}
|
|
//--- ENVIO DE PRINT DA RENOVAÇÃO DE FUNDO EM RELAÇÃO AO FILTRO TOPO E FUNDO
|
|
msg = StringFormat("%s - %s - PRIMEIRA VELA - RENOVACAO DE FUNDO TF: Fundo atual = %.2f;",
|
|
__FUNCTION__,TimeToString(time[k-2],TIME_DATE|TIME_SECONDS),setup.fundo);
|
|
FuncaoPrint(msg);
|
|
//--- FIM CRIAÇÃO DE OBJETO E PRINT EM RELAÇÃO AO FILTRO TOPO E FUNDO
|
|
//--- critérios/requisitos para inversão de FUNDO para TOPO - GATILHO
|
|
} else if(high[k-1] - setup.fundo >= InpFilterTopoFundo) {
|
|
//---
|
|
setup.gatilhoTopoTF = true;
|
|
setup.gatilhoTopoPrecoTF = high[k-1];
|
|
setup.gatilhoTopoMinTF = low[k-1];
|
|
//--- critérios/requisitos para inversão de FUNDO para TOPO - CONFIRMACAO
|
|
} else if(setup.gatilhoTopoTF &&
|
|
(close[k-1] - InputMargemGatilhoTF <= setup.gatilhoTopoMinTF)) {
|
|
//---
|
|
setup.fundo = -1;
|
|
setup.topo = setup.gatilhoTopoPrecoTF;
|
|
//---
|
|
InsertTable(db,"TOPOS",high[k-1],time[k-1],ulong(time[k-1]));
|
|
//---RESETAR/ZERAR GATILHOS
|
|
setup.gatilhoTopoTF = false;
|
|
setup.gatilhoTopoPrecoTF = 0;
|
|
setup.gatilhoTopoMinTF = 0;
|
|
//---
|
|
}
|
|
} //--- FIM DE "EXISTE UM FUNDO DEFINIDO"
|
|
//---
|
|
//--- EXISTE UM TOPO DEFINIDO
|
|
else if (setup.fundo<0 && setup.topo>0) {
|
|
//--- critérios para renovação de topo
|
|
if(setup.topo < high[k-1]) {
|
|
//---
|
|
setup.topo = high[k-1]; //--- Atualiza o topo
|
|
//---
|
|
InsertTable(db,"TOPOS",high[k-1],time[k-1],ulong(time[k-1]));
|
|
//---
|
|
msg = StringFormat("%s - %s - VELAS SEGUINTES TF - POSSIVEL RENOVACAO DE TOPO: Topo atual = %.2f; high = %.2f;",
|
|
__FUNCTION__,TimeToString(time[k-1],TIME_DATE|TIME_SECONDS),setup.fundo,high[k-1]);
|
|
FuncaoPrint(msg);
|
|
//--- critérios/requisitos para inversão de TOPO para FUNDO - GATILHO
|
|
} else if(setup.topo - low[k-1] >= InpFilterTopoFundo ){
|
|
//---
|
|
setup.gatilhoFundoTF = true;
|
|
setup.gatilhoFundoPrecoTF = low[k-1];
|
|
setup.gatilhoFundoMaxTF = high[k-1];
|
|
setup.gatilhoFundoPrecoTFdt = time[k-1];
|
|
//--- critérios/requisitos para inversão de TOPO para FUNDO - CONFIRMACAO
|
|
} else if(setup.gatilhoFundoTF &&
|
|
(close[k-1] + InputMargemGatilhoTF >= setup.gatilhoFundoMaxTF)) {
|
|
//---
|
|
setup.topo = -1;
|
|
setup.fundo = setup.gatilhoFundoPrecoTF;
|
|
//---
|
|
InsertTable(db,"FUNDOS",low[k-1],time[k-1],ulong(time[k-1]));
|
|
//---RESETAR/ZERAR GATILHOS
|
|
setup.gatilhoFundoTF = false;
|
|
setup.gatilhoFundoPrecoTF = 0;
|
|
setup.gatilhoFundoMaxTF = 0;
|
|
setup.gatilhoFundoPrecoTFdt = 0;
|
|
//---
|
|
}
|
|
} //--- FIM de "EXISTE UM TOPO DEFINIDO"
|
|
} //--- END if(InpUseFilterTopoFundo) {
|
|
//Usar Distância PullBack (Sim=true/Não=false)
|
|
if(InpUseFilterDistanciaPullBack) {
|
|
//---
|
|
double result_dist[]; //--- ************
|
|
string result[]; //--- Um array para obter strings
|
|
string sep = "|"; //--- Um separador como um caractere
|
|
ushort u_sep; //--- O código do caractere separador
|
|
u_sep = StringGetCharacter(sep,0); //--- Obtém o código do separador
|
|
int retorno = StringSplit(InpFilterDistanciaPullBack,u_sep,result);
|
|
//---
|
|
if(ArrayResize(result_dist,retorno)==retorno) {
|
|
//---
|
|
for(int i=0;i<retorno;i++) result_dist[i] = StringToDouble(result[i])/100;
|
|
//---
|
|
} else return false;
|
|
//---
|
|
int total = ArraySize(result_dist);
|
|
//---
|
|
double dist = FuncaoReadDatabase(db,"FUNDOS") - FuncaoReadDatabase(db,"TOPOS");
|
|
//--- existe um fundo definido
|
|
if (setup.fundo>0 && setup.topo<0) {
|
|
//---
|
|
for(int i=0;i<total;i++) {
|
|
//---
|
|
double drawback = setup.fundo + (result_dist[i] * dist);
|
|
//--- critérios para DRAWBACK - GATILHO
|
|
if((high[k-1] >= drawback - InputMargemGatilhoSR) && (high[k-1] <= drawback + InputMargemGatilhoSR)) {
|
|
//---
|
|
setup.gatilhoTopoPD = true;
|
|
setup.gatilhoTopoPrecoPD = high[k-1];
|
|
setup.gatilhoTopoMinPD = low[k-1];
|
|
//--- critérios para DRAWBACK - CONFIRMACAO
|
|
} else if(setup.gatilhoTopoPD && close[k-1] <= setup.gatilhoTopoMinPD - InputMargemGatilhoSR) {//*************************
|
|
//---
|
|
int total_db = ArraySize(setup.drawback);
|
|
if(ArrayResize(setup.drawback,total_db+1)==total_db+1) {
|
|
//---
|
|
setup.drawback[total_db] = setup.gatilhoTopoPrecoPD;
|
|
setup.gatilhoTopoPD = false;
|
|
setup.gatilhoTopoPrecoPD = -1;
|
|
setup.gatilhoTopoMinPD = -1;
|
|
}
|
|
}
|
|
//---
|
|
}//END for(int i=0;i<total;i++) {
|
|
//--- existe um topo definido
|
|
} else if (setup.fundo<0 && setup.topo>0) {
|
|
//---
|
|
for(int i=0;i<total;i++) {
|
|
//---
|
|
double pullback = setup.topo - (result_dist[i] * dist);
|
|
//--- critérios para PULLBACK - GATILHO
|
|
if((low[k-1] <= pullback + InputMargemGatilhoSR) && (low[k-1] >= pullback - InputMargemGatilhoSR)) {
|
|
//---
|
|
setup.gatilhoFundoPD = true;
|
|
setup.gatilhoFundoPrecoPD = low[k-1];
|
|
setup.gatilhoFundoMaxPD = high[k-1];
|
|
//--- critérios para DRAWBACK - CONFIRMACAO
|
|
} else if(setup.gatilhoFundoPD && close[k-1] >= setup.gatilhoFundoMaxPD + InputMargemGatilhoSR) {//*************************
|
|
//---
|
|
int total_db = ArraySize(setup.pullback);
|
|
if(ArrayResize(setup.pullback,total_db+1)==total_db+1) {
|
|
//---
|
|
setup.pullback[total_db] = setup.gatilhoFundoPrecoPD;
|
|
setup.gatilhoFundoPD = false;
|
|
setup.gatilhoFundoPrecoPD = -1;
|
|
setup.gatilhoFundoMaxPD = -1;
|
|
}
|
|
}
|
|
//---
|
|
}//END for(int i=0;i<total;i++) {
|
|
}
|
|
//---
|
|
}//END if(InpUseFilterDistanciaPullBack) {
|
|
//---
|
|
if(InpUseFilterSUPORTEeRESISTENCIA) {
|
|
//--- critérios para renovacao de topos e fundos - SUPORTE e RESISTENCIA
|
|
if (setup.fundo>0 && setup.topo<0) {//--- existe um FUNDO definido
|
|
//--- critérios renovação de FUNDOS - SUPORTE
|
|
//--- criar uma funcao pra fazer um loop dentro do arrayMinD1 pra achar a min mais proxima dos suportes
|
|
|
|
if(setup.fundo >= low[k-1] && FuncaoReadDataBaseRSMaisProximo(db,"SUPORTE",low[k-1]) && !setup.gatilhoFundoSR) {//--- avaliação: tem um FUNDO novo?
|
|
//if(setup.fundo >= low[k-1] && FuncaoRSMaisProximo(low[k-1],arrayMinD1) && !setup.gatilhoFundoSR) {//--- avaliação: tem um FUNDO novo?
|
|
//--- FUNÇÃO - PROVÁVEL FUNDO
|
|
setup.gatilhoFundoSR = true; //--- Gatilho FUNDO que estava no estado "false", foi ativado para "true" - em razão de ser um provável FUNDO
|
|
setup.gatilhoFundoPrecoSR = low[k-1]; //--- Provável novo FUNDO
|
|
setup.gatilhoFundoMaxSR = high[k-1]; //--- Máxima do Provável novo FUNDO - que deverá ser rompida pelo fechamento do candle posterior
|
|
setup.gatilhoFundoPrecoSRdt = time[k-1];
|
|
setup.gatilhoTopoSR = false;
|
|
setup.gatilhoTopoPrecoSR = 0;
|
|
//---
|
|
printf("%s - %s - POSSIVEL RENOVACAO DE FUNDO: Fundo atual = %.2f; low = %.2f;",
|
|
__FUNCTION__,TimeToString(time[k-1],TIME_DATE|TIME_SECONDS),setup.fundo,low[k-1]);
|
|
//---
|
|
// && low[k-1]<=setup.gatilhoFundoPreco//--- InputMargemSUPORTEeRESISTENCIA
|
|
} else if(setup.fundo >= low[k-1] && close[k-1]>setup.gatilhoFundoMaxSR + InputMargemGatilhoSR && setup.gatilhoFundoSR) {
|
|
//--- CONFIRMAçãO DE NOVO FUNDO
|
|
|
|
//--- Atualização do Array de FUNDO
|
|
setup.fundo = setup.gatilhoFundoPrecoSR; //--- Atualização da memória do FUNDO
|
|
//---
|
|
InsertTable(db,"FUNDOS",setup.fundo,setup.gatilhoFundoPrecoSRdt,ulong(setup.gatilhoFundoPrecoSRdt));
|
|
//---
|
|
setup.gatilhoTopoSR = false;
|
|
setup.gatilhoTopoMinSR = 0;
|
|
setup.gatilhoTopoPrecoSR = 0;
|
|
setup.gatilhoTopoPrecoSRdt = 0;
|
|
setup.gatilhoFundoSR = false;
|
|
setup.gatilhoFundoMaxSR = 0;
|
|
setup.gatilhoFundoPrecoSR = 0;
|
|
setup.gatilhoFundoPrecoSRdt = 0;
|
|
//---
|
|
//--- critérios inversao de FUNDO para TOPO - RESISTÊNCIA
|
|
} else if(high[k-1] > setup.fundo &&
|
|
FuncaoReadDataBaseRSMaisProximo(db,"RESISTENCIA",high[k-1]) &&
|
|
!setup.gatilhoTopoSR) {//--- já existe um FUNDO definido
|
|
//} else if(high[k-1] > setup.fundo && FuncaoRSMaisProximo(high[k-1],arrayMaxD1) && !setup.gatilhoTopoSR) {//--- já existe um FUNDO definido
|
|
//--- PROVÁVEL TOPO
|
|
setup.gatilhoTopoSR = true; //--- Gatilho TOPO que estava no estado "false", foi ativado para "true" - em razão de ser um provável TOPO
|
|
setup.gatilhoTopoPrecoSR = high[k-1]; //--- Provável novo TOPO
|
|
setup.gatilhoTopoMinSR = low[k-1]; //--- Mínima do Provável novo TOPO - que deverá ser rompida pelo fechamento do candle posterior
|
|
setup.gatilhoTopoPrecoSRdt = time[k-1];
|
|
setup.gatilhoFundoSR = false;
|
|
setup.gatilhoTopoPrecoSR = 0;
|
|
//--- critérios inversao de FUNDO para TOPO - RESISTÊNCIA
|
|
} else if(high[k-1] > setup.fundo &&
|
|
close[k-1]<setup.gatilhoTopoMinSR - InputMargemGatilhoSR &&
|
|
setup.gatilhoTopoSR) {//--- InputMargemSUPORTEeRESISTENCIA
|
|
//--- CONFIRMAÇÃO DO NOVO TOPO
|
|
setup.topo = setup.gatilhoTopoPrecoSR; //--- Atualização do Array de TOPO
|
|
//--- Atualização da memória do TOPO
|
|
InsertTable(db,"TOPOS",setup.topo,setup.gatilhoTopoPrecoSRdt,ulong(setup.gatilhoTopoPrecoSRdt));
|
|
//---
|
|
setup.fundo = -1; //--- FUNDO passa a ser negativo, em razão de ter confirmação de TOPO
|
|
//---
|
|
setup.gatilhoTopoSR = false;
|
|
setup.gatilhoTopoMinSR = 0;
|
|
setup.gatilhoTopoPrecoSR = 0;
|
|
setup.gatilhoTopoPrecoSRdt = 0;
|
|
setup.gatilhoFundoSR = false;
|
|
setup.gatilhoFundoMaxSR = 0;
|
|
setup.gatilhoFundoPrecoSR = 0;
|
|
setup.gatilhoFundoPrecoSRdt = 0;
|
|
//---
|
|
}
|
|
} else if (setup.fundo<0 && setup.topo>0) {//--- existe um TOPO definido
|
|
//--- critérios renovação de TOPO - RESISTENCIA
|
|
//--- avaliar a possibilidade de renovacao de topo
|
|
|
|
if(high[k-1] >= setup.topo &&
|
|
FuncaoReadDataBaseRSMaisProximo(db,"RESISTENCIA",high[k-1]) &&
|
|
!setup.gatilhoTopoSR) {
|
|
//if(high[k-1] >= setup.topo && FuncaoRSMaisProximo(high[k-1],arrayMaxD1) && !setup.gatilhoTopoSR) {
|
|
//--- FUNÇÃO - PROVÁVEL TOPO
|
|
setup.gatilhoTopoSR = true; //--- Gatilho TOPO que estava no estado "false", foi ativado para "true" - em razão de ser um provável TOPO
|
|
setup.gatilhoTopoMinSR = low[k-1]; //--- Mínima do Provável novo TOPO - que deverá ser rompida pelo fechamento do candle posterior
|
|
setup.gatilhoTopoPrecoSR = high[k-1]; //--- Provável novo TOPO
|
|
setup.gatilhoTopoPrecoSRdt = time[k-1];
|
|
setup.gatilhoFundoSR = false;
|
|
setup.gatilhoFundoMaxSR = 0;
|
|
setup.gatilhoFundoPrecoSR = 0;
|
|
//---
|
|
//--- confirmacao da renovacao de topo
|
|
// && low[k-1]<=setup.gatilhoFundoPreco//--- InputMargemSUPORTEeRESISTENCIA
|
|
} else if(high[k-1] >= setup.topo &&
|
|
close[k-1]<setup.gatilhoTopoMinSR - InputMargemGatilhoSR &&
|
|
setup.gatilhoTopoSR) {
|
|
//--- CONFIRMAçãO DE NOVO TOPO
|
|
//--- Atualização do Array de TOPO
|
|
InsertTable(db,"TOPOS",setup.topo,setup.gatilhoTopoPrecoSRdt,ulong(setup.gatilhoTopoPrecoSRdt));
|
|
//---
|
|
setup.topo = setup.gatilhoTopoPrecoSR; //--- Atualização da memória do TOPO
|
|
//---
|
|
setup.gatilhoTopoSR = false;
|
|
setup.gatilhoTopoMinSR = 0;
|
|
setup.gatilhoTopoPrecoSR = 0;
|
|
setup.gatilhoTopoPrecoSRdt = 0;
|
|
setup.gatilhoFundoSR = false;
|
|
setup.gatilhoFundoMaxSR = 0;
|
|
setup.gatilhoFundoPrecoSR = 0;
|
|
setup.gatilhoFundoPrecoSRdt = 0;
|
|
//--- critérios inversao de TOPO para FUNDO - SUPORTES
|
|
//--- avaliar a possibilidade de inversao
|
|
} else if(low[k-1] < setup.topo &&
|
|
FuncaoReadDataBaseRSMaisProximo(db,"SUPORTE",low[k-1]) &&
|
|
!setup.gatilhoFundoSR) {//já existe um TOPO definido
|
|
//} else if(low[k-1] < setup.topo && FuncaoRSMaisProximo(low[k-1],arrayMinD1) && !setup.gatilhoFundoSR) {//já existe um TOPO definido
|
|
//--- PROVÁVEL FUNDO
|
|
setup.gatilhoTopoSR = false;
|
|
setup.gatilhoTopoMinSR = 0;
|
|
setup.gatilhoTopoPrecoSR = 0;
|
|
setup.gatilhoFundoSR = true; //--- Gatilho FUNDO que estava no estado "false", foi ativado para "true" - em razão de ser um provável FUNDO
|
|
setup.gatilhoFundoMaxSR = high[k-1]; //--- Máxima do Provável novo FUNDO - que deverá ser rompida pelo fechamento do candle posterior
|
|
setup.gatilhoFundoPrecoSR = low[k-1]; //--- Provável novo FUNDO
|
|
setup.gatilhoFundoPrecoSRdt = time[k-1];
|
|
//--- confirmacao da inversao
|
|
} else if(low[k-1] < setup.topo && close[k-1]>setup.gatilhoFundoMaxSR + InputMargemGatilhoSR && setup.gatilhoFundoSR) {//--- InputMargemSUPORTEeRESISTENCIA
|
|
//--- CONFIRMAçãO DE NOVO FUNDO
|
|
setup.fundo = setup.gatilhoFundoPrecoSR; //--- Atualização do Array de FUNDO
|
|
//--- Atualização do Array de FUNDO
|
|
InsertTable(db,"FUNDOS",setup.fundo,setup.gatilhoFundoPrecoSRdt,ulong(setup.gatilhoFundoPrecoSRdt));
|
|
//--- setup.topo = -1; //--- TOPO passa a ser negativo, em razão de ter confirmação de FUNDO
|
|
//---
|
|
setup.gatilhoTopoSR = false;
|
|
setup.gatilhoTopoMinSR = 0;
|
|
setup.gatilhoTopoPrecoSR = 0;
|
|
setup.gatilhoTopoPrecoSRdt = 0;
|
|
setup.gatilhoTopoPrecoSRdt = 0;
|
|
setup.gatilhoFundoSR = false;
|
|
setup.gatilhoFundoMaxSR = 0;
|
|
setup.gatilhoFundoPrecoSR = 0;
|
|
setup.gatilhoFundoPrecoSRdt = 0;
|
|
setup.gatilhoFundoPrecoSRdt = 0;
|
|
//---
|
|
}
|
|
}//--- END else if (setup.fundo??0 && setup.topo??0)
|
|
}//--- END if(InpUseFilterSUPORTEeRESISTENCIA) {
|
|
if(InpUseFilterLT) {//PRICE, UDT
|
|
//--- LTA - último fundo vigente como ponto inicial da LTA
|
|
//--- SELECT PRICE,UDT FROM FUNDOS ORDER BY UDT DESC;
|
|
//--- segundo ponto, é a mínima do Drawback imediatamente posterior ao último fundo vigente
|
|
//--- SELECT PRICE FROM DRAWBACK ORDER BY UDT ASC
|
|
//--- WHERE udtRef > UDT
|
|
//---
|
|
}
|
|
//---
|
|
//---
|
|
}
|
|
return true;
|
|
//---
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| CRIAR SÍMBOLO VISUAL - ARROW UP |
|
|
//+------------------------------------------------------------------+
|
|
bool ArrowCreate(const long chart_ID = 0, // ID do gráfico
|
|
const string name = "Arrow", // nome do sinal
|
|
const int sub_window = 0, // índice da sub-janela
|
|
datetime time = 0, // ponto de ancoragem do tempo
|
|
double price = 0, // ponto de ancoragem do preço
|
|
const ENUM_ARROW_ANCHOR anchor = ANCHOR_BOTTOM, // tipo de ancoragem
|
|
const ENUM_OBJECT obj = OBJ_ARROW_THUMB_UP, // tipo de objetto
|
|
const color clr = clrRed, // cor do sinal
|
|
const ENUM_LINE_STYLE style = STYLE_SOLID, // estilo de linha da borda
|
|
const int width = 1, // tamanho do sinal
|
|
const bool back = false, // no fundo
|
|
const bool selection = true, // destaque para mover
|
|
const bool hidden = true, // ocultar na lista de objetos
|
|
const long z_order = 0) { // prioridade para clicar no mouse
|
|
//--- redefine o valor de erro
|
|
ResetLastError();
|
|
//--- criar o sinal
|
|
if(!ObjectCreate(chart_ID, name, obj, sub_window, time, price)) {
|
|
msg = StringFormat(__FUNCTION__,
|
|
": falha ao criar o sinal \"Arrow\"! Código de erro = ",
|
|
GetLastError());
|
|
FuncaoPrint(msg);
|
|
//---
|
|
return(false);
|
|
}
|
|
//--- tipo de definição de ancoragem
|
|
ObjectSetInteger(chart_ID, name, OBJPROP_ANCHOR, anchor, (long)setup.lowFirstBar);
|
|
//--- definir uma cor de sinal
|
|
ObjectSetInteger(chart_ID, name, OBJPROP_COLOR, clr);
|
|
//--- definir o estilo da linha da borda
|
|
ObjectSetInteger(chart_ID, name, OBJPROP_STYLE, style);
|
|
//--- tamanho da definição do sinal
|
|
ObjectSetInteger(chart_ID, name, OBJPROP_WIDTH, width);
|
|
//--- exibir em primeiro plano (false) ou fundo (true)
|
|
ObjectSetInteger(chart_ID, name, OBJPROP_BACK, back);
|
|
//--- permitir (true) ou desabilitar (false) o modo de movimento do sinal com o mouse
|
|
//--- ao criar um objeto gráfico usando a função ObjectCreate, o objeto não pode ser
|
|
//--- destacado e movimentado por padrão. Dentro deste método, o parâmetro de seleção
|
|
//--- é verdade por padrão, tornando possível destacar e mover o objeto
|
|
ObjectSetInteger(chart_ID, name, OBJPROP_SELECTABLE, selection);
|
|
ObjectSetInteger(chart_ID, name, OBJPROP_SELECTED, selection);
|
|
//--- ocultar (true) ou exibir (false) o nome do objeto gráfico na lista de objeto
|
|
ObjectSetInteger(chart_ID, name, OBJPROP_HIDDEN, hidden);
|
|
//--- definir a prioridade para receber o evento com um clique do mouse no gráfico
|
|
ObjectSetInteger(chart_ID, name, OBJPROP_ZORDER, z_order);
|
|
//--- sucesso na execução
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| LINHA HORIZONTAL |
|
|
//+------------------------------------------------------------------+
|
|
bool HLineCreate(const long chart_ID = 0, // ID DO GRÁFICO
|
|
const string name = "HLine", // Nome da linha
|
|
const int sub_window = 0, // Subjanela index
|
|
double price = 0, // preço da linha
|
|
const color clr = clrRed, // cor da linha
|
|
const ENUM_LINE_STYLE style = STYLE_SOLID, // estilo da linha
|
|
const int width = 1, // largura da linha
|
|
const bool back = false, // fundo
|
|
const bool selection = true, // realçar movimento
|
|
const bool hidden = false, // esconder na lista de objetos
|
|
const long z_order = 0) // prioridade para clique do mouse
|
|
{
|
|
//--- se o preço não está definido, defina-o no atual nível de preço Bid
|
|
if(!price)
|
|
price=SymbolInfoDouble(Symbol(),SYMBOL_BID);
|
|
//--- redefine o valor de erro
|
|
ResetLastError();
|
|
//--- criar um linha horizontal
|
|
if(!ObjectCreate(chart_ID,name,OBJ_HLINE,sub_window,0,price))
|
|
{
|
|
msg = StringFormat(__FUNCTION__,
|
|
": falha ao criar um linha horizontal! Código de erro = ",
|
|
GetLastError());
|
|
FuncaoPrint(msg);
|
|
//---
|
|
return(false);
|
|
}
|
|
//--- definir cor da linha
|
|
ObjectSetInteger(chart_ID,name,OBJPROP_COLOR,clr);
|
|
//--- definir o estilo de exibição da linha
|
|
ObjectSetInteger(chart_ID,name,OBJPROP_STYLE,style);
|
|
//--- definir a largura da linha
|
|
ObjectSetInteger(chart_ID,name,OBJPROP_WIDTH,width);
|
|
//--- exibir em primeiro plano (false) ou fundo (true)
|
|
ObjectSetInteger(chart_ID,name,OBJPROP_BACK,back);
|
|
//--- habilitar (true) ou desabilitar (false) o modo do movimento da seta com o mouse
|
|
//--- ao criar um objeto gráfico usando a função ObjectCreate, o objeto não pode ser
|
|
//--- destacado e movimentado por padrão. Dentro deste método, o parâmetro de seleção
|
|
//--- é verdade por padrão, tornando possível destacar e mover o objeto
|
|
ObjectSetInteger(chart_ID,name,OBJPROP_SELECTABLE,selection);
|
|
ObjectSetInteger(chart_ID,name,OBJPROP_SELECTED,selection);
|
|
//--- ocultar (true) ou exibir (false) o nome do objeto gráfico na lista de objeto
|
|
ObjectSetInteger(chart_ID,name,OBJPROP_HIDDEN,hidden);
|
|
//--- definir a prioridade para receber o evento com um clique do mouse no gráfico
|
|
ObjectSetInteger(chart_ID,name,OBJPROP_ZORDER,z_order);
|
|
//--- sucesso na execução
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
void CreateDataBase() {
|
|
//---
|
|
string filename = "setup_ind_bruno.sqlite";
|
|
//--- criamos ou abrimos um banco de dados na pasta compartilhada do terminal
|
|
db = DatabaseOpen(filename, DATABASE_OPEN_READWRITE | DATABASE_OPEN_CREATE |DATABASE_OPEN_COMMON);
|
|
if(db == INVALID_HANDLE)
|
|
{
|
|
msg = StringFormat("DB: ", filename, " open failed with code ", GetLastError());
|
|
FuncaoPrint(msg);
|
|
//---
|
|
return;
|
|
}
|
|
//--- criamos a tabela SUPORTE
|
|
if(!CreateTable(db,"SUPORTE"))
|
|
{
|
|
DatabaseClose(db);
|
|
return;
|
|
}
|
|
//--- criamos a tabela RESISTENCIA
|
|
if(!CreateTable(db,"RESISTENCIA"))
|
|
{
|
|
DatabaseClose(db);
|
|
return;
|
|
}
|
|
//--- criamos a tabela PULLBACK
|
|
if(!CreateTable(db,"PULLBACK"))
|
|
{
|
|
DatabaseClose(db);
|
|
return;
|
|
}
|
|
//--- criamos a tabela DRAWBACK
|
|
if(!CreateTable(db,"DRAWBACK"))
|
|
{
|
|
DatabaseClose(db);
|
|
return;
|
|
}
|
|
//--- criamos a tabela PULLBACK2 (SECUNDÁRIO)
|
|
if(!CreateTable(db,"PULLBACK2"))
|
|
{
|
|
DatabaseClose(db);
|
|
return;
|
|
}
|
|
//--- criamos a tabela DRAWBACK2 (SECUNDÁRIO)
|
|
if(!CreateTable(db,"DRAWBACK2"))
|
|
{
|
|
DatabaseClose(db);
|
|
return;
|
|
}
|
|
//--- criamos a tabela LTA (LINHA DE TENDÊNCIA DE ALTA)
|
|
if(!CreateTable(db,"LTA"))
|
|
{
|
|
DatabaseClose(db);
|
|
return;
|
|
}
|
|
//--- criamos a tabela LTB (LINHA DE TENDÊNCIA DE BAIXA)
|
|
if(!CreateTable(db,"LTB"))
|
|
{
|
|
DatabaseClose(db);
|
|
return;
|
|
}
|
|
//--- criamos a tabela TOPOS
|
|
if(!CreateTable(db,"TOPOS"))
|
|
{
|
|
DatabaseClose(db);
|
|
return;
|
|
}
|
|
//--- criamos a tabela FUNDOS
|
|
if(!CreateTable(db,"FUNDOS"))
|
|
{
|
|
DatabaseClose(db);
|
|
return;
|
|
}
|
|
}//END CreateDataBase
|
|
//+------------------------------------------------------------------+
|
|
//| Deletes a table with the specified name from the database |
|
|
//+------------------------------------------------------------------+
|
|
bool DeleteTable(int database, string table_name) {
|
|
string query = StringFormat("DROP TABLE %s", table_name);
|
|
ResetLastError();
|
|
if(!DatabaseExecute(database,query)) {
|
|
msg = StringFormat("Failed to drop table %s with code %d;",table_name,GetLastError());
|
|
FuncaoPrint(msg);
|
|
//---
|
|
return(false);
|
|
}
|
|
//--- the table has been successfully deleted
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Cria a tabela database |
|
|
//+------------------------------------------------------------------+
|
|
bool CreateTable(const int database, const string table_name) {
|
|
//--- se a tabela XXXX existir, vamos exclui-la
|
|
string query = "";
|
|
//---
|
|
if(DatabaseTableExists(database, table_name)) {
|
|
//--- excluímos a tabela
|
|
query = StringFormat("DROP TABLE %s",table_name);
|
|
if(!DatabaseExecute(database,query)) {
|
|
//---
|
|
msg = StringFormat("Failed to drop table %s with code %d ",table_name,GetLastError());
|
|
FuncaoPrint(msg);
|
|
//---
|
|
return(false);
|
|
}
|
|
}
|
|
//--- criamos a tabela XXXX
|
|
query = StringFormat("CREATE TABLE %s ("
|
|
"UDT INT PRIMARY KEY NOT NULL,"
|
|
"PRICE REAL NOT NULL);",table_name);
|
|
if(!DatabaseExecute(database,query)) {
|
|
//---
|
|
msg = StringFormat("DB: create table %s failed with code %d ",table_name,GetLastError());
|
|
FuncaoPrint(msg);
|
|
//---
|
|
return(false);
|
|
}
|
|
//--- sucesso
|
|
return(true);
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool InsertTable(const int database, const string table_name, const double value, const datetime dt, const ulong udt) {
|
|
//---
|
|
string query = StringFormat("INSERT INTO %s (UDT,PRICE) VALUES (%d,%5f);",table_name,udt,value);
|
|
//---
|
|
if(!DatabaseExecute(database, query)) {
|
|
//---
|
|
msg = StringFormat("%s insert failed with code %d",table_name,GetLastError());
|
|
FuncaoPrint(msg);
|
|
//---
|
|
return(false);
|
|
}
|
|
//---
|
|
return true;
|
|
//---
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
double FuncaoReadDatabase(int database, const string table_name) {
|
|
//---
|
|
int ret = -2;
|
|
//--- prepare the request
|
|
string request_text=StringFormat("SELECT MAX(UDT), PRICE FROM %s;",table_name);
|
|
int request=DatabasePrepare(database, request_text);
|
|
if(request==INVALID_HANDLE)
|
|
{
|
|
Print("DB: ", database, " request failed with code ", GetLastError());
|
|
DatabaseClose(database);
|
|
return -3;
|
|
}
|
|
while(DatabaseRead(request))
|
|
{
|
|
DatabaseColumnInteger(request, 1, ret);
|
|
}
|
|
//---
|
|
printf("ret: %.2f",ret);
|
|
//--- delete request after use
|
|
DatabaseFinalize(request);
|
|
//--- close database
|
|
return ret;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool FuncaoReadDataBaseRSMaisProximo(int database, const string table_name, double price) {
|
|
//--- prepare the request
|
|
string request_text=StringFormat("SELECT PRICE FROM %s ORDER BY PRICE DESC;",table_name);
|
|
int request=DatabasePrepare(database, request_text);
|
|
double res;
|
|
if(request==INVALID_HANDLE)
|
|
{
|
|
Print("DB: ", database, " request failed with code ", GetLastError());
|
|
DatabaseClose(database);
|
|
return false;
|
|
}
|
|
while(DatabaseRead(request)) {
|
|
//---
|
|
DatabaseColumnDouble(request, 0, res);
|
|
//---
|
|
double dis = MathAbs(price - res);
|
|
if(dis <= InputMargemSUPORTEeRESISTENCIA) {
|
|
//---
|
|
msg = StringFormat("%s - Resistência e/ou Suporte Mais Próximo: Preço atual = %.2f; price = %.2f;",
|
|
__FUNCTION__,price,res,dis);
|
|
FuncaoPrint(msg);
|
|
//--- delete request after use
|
|
DatabaseFinalize(request);
|
|
//---
|
|
return true;
|
|
//---
|
|
}
|
|
//---
|
|
}
|
|
|
|
//--- delete request after use
|
|
DatabaseFinalize(request);
|
|
//--- close database
|
|
return false;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| |
|
|
//+------------------------------------------------------------------+
|
|
bool FuncaoReadDataBaseLT2(int database, ulong udtRef,const string table_name, double priceRef) {
|
|
//--- prepare the request
|
|
string request_text=StringFormat("SELECT PRICE FROM %s ORDER BY UDT ASC;",table_name);
|
|
int request=DatabasePrepare(database, request_text);
|
|
double price = 0;
|
|
ulong udt = 0;
|
|
//---
|
|
if(request==INVALID_HANDLE)
|
|
{
|
|
Print("DB: ", database, " request failed with code ", GetLastError());
|
|
DatabaseClose(database);
|
|
return false;
|
|
}
|
|
while(DatabaseRead(request)) {
|
|
//---
|
|
|
|
DatabaseColumnDouble(request, 0, price);
|
|
DatabaseColumnLong(request, 1, udt);
|
|
//---
|
|
if(udt>udtRef) {
|
|
//---
|
|
break;
|
|
//---
|
|
}
|
|
//---
|
|
}
|
|
|
|
//--- delete request after use
|
|
DatabaseFinalize(request);
|
|
if(price>0 && udt>0){
|
|
//---
|
|
//criar uma variavel/struct global memoria e atualizar com o price
|
|
//criar uma variavel/struct global memoria e atualizar com o time
|
|
//---
|
|
return true;
|
|
|
|
}
|
|
//--- close database
|
|
return false;
|
|
}
|
|
//+------------------------------------------------------------------+
|
|
//| Funcao Print |
|
|
//+------------------------------------------------------------------+
|
|
void FuncaoPrint(string txt) {
|
|
//---
|
|
if(inpHabMsg)
|
|
Print(txt);
|
|
//---
|
|
}
|
|
//--- |