Usando a API de Dados JSON em seus projetos MQL

MetaTrader 5 — Sistemas de negociação | 3 dezembro 2024, 10:11

375

Sara Sabaghi

Introdução e Contexto

Misturar dados externos pode melhorar a tomada de decisões no trading algorítmico. As APIs permitem a transferência de dados entre diferentes sistemas e ajudam os traders a acessar diferentes fontes de dados, como dados de mercado em tempo real de outros corretores e bancos, acesso a indicadores econômicos, não apenas calendários econômicos, feeds de notícias ou análise de sentimentos sociais, ferramentas de inteligência artificial online, sistemas de previsão online ou qualquer outra coisa que você possa imaginar disponível em serviços API. Neste artigo, mostraremos como usar esta ferramenta da melhor forma.

Usar dados de APIs em Expert Advisors (EA) pode fornecer novos insights sobre o mercado de negociação, ajudando a tomar decisões informadas, criar estratégias de negociação mais dinâmicas e gerenciar riscos de forma mais eficaz. Usando dados de APIs, os traders podem melhorar a precisão dos sinais de negociação usando indicadores técnicos avançados e ferramentas de gráficos sofisticadas. Essa integração amplia as capacidades de plataformas como MetaTrader e oferece acesso a valiosa inteligência de mercado, como processamento de linguagem natural (NLP) para análise de sentimento de mercado e acesso a dados fundamentais e notícias.

Introdução à API Ziwox

Ziwox é um sistema de análise de dados no Forex que contém serviços de API gratuitos. Essa API fornece aos traders dados abrangentes de mercado, incluindo preços, indicadores técnicos, análise de sentimento e dados fundamentais. Ela suporta pares de moedas principais e menores e fornece métricas importantes, como viés fundamental de moeda, previsões baseadas em IA, estatísticas de traders de varejo, relatórios COT, suporte e resistência técnica, sentimento de mercado (risco-on e risco-off), rendimentos de títulos e índice VIX. Esse conjunto de dados rico permite uma análise multifacetada do mercado, combinando insights técnicos, fundamentais e de Sentimento para criar ferramentas revolucionárias.

A parte interessante desses dados é que, além dos dados de preço e técnicos, teremos acesso a dados gerados por inteligência artificial ou analistas reais. Alguns desses dados incluem: análise fundamental para pares de forex por uma equipe de analistas, saídas do sistema NLP (Processamento de Linguagem Natural) como sentimento de notícias do forex, previsões de preços geradas por IA.

A API é fácil de usar, exigindo um simples cadastro para gerar uma chave de API e acessar os dados em formato JSON ou texto. Essa acessibilidade, junto com sua extensa cobertura de dados, torna-a uma ferramenta inestimável para aprimorar estratégias de negociação e desenvolver indicadores personalizados ou sistemas de negociação automatizados.

O que é uma API?

Vamos nos familiarizar um pouco mais: O que é uma API?

APIs são mecanismos que permitem que dois componentes de software se comuniquem entre si usando um conjunto de definições e protocolos. Por exemplo, o sistema de software do serviço meteorológico contém dados climáticos diários. O aplicativo de clima no seu celular "conversa" com esse sistema por meio de uma API e mostra a atualização diária do clima no seu celular.

API significa Interface de Programação de Aplicações. Uma interface pode ser pensada como um contrato de serviço entre dois aplicativos. Esse contrato define como os dois se comunicam, usando solicitações e respostas. A documentação da API contém informações sobre como os desenvolvedores estruturam essas solicitações e respostas.

A arquitetura da API é geralmente descrita em termos de cliente e servidor. O programa que envia a solicitação é chamado de cliente, e o programa que envia a resposta é chamado de servidor. Então, no exemplo do clima, o banco de dados de clima do escritório é o servidor e o aplicativo móvel é o cliente.

Formatos de respostas de API:

Existem vários formatos para as respostas ou troca de dados de uma API. Dependendo do propósito para o qual a API foi criada, com quais outros Aplicações está conectada, o formato pode variar.

Essas respostas podem estar em formato JSON, HTML, TEXT, XML ou CSV.

Para uma breve introdução a esse modelo padrão:

1. JSON: JSON é um formato de intercâmbio de dados leve e legível por humanos, usado em respostas de API devido à sua simplicidade e flexibilidade. Ele representa os dados como pares chave-valor, tornando fácil de analisar e manipular em várias linguagens de programação.

Um exemplo de resposta JSON:

{
"id": 5687,
"source": "oanda",
"symbol": "EURUSD",
"price": "1.08562",
"high": "1.09211",
"low": "1.08154"
}

2. XML: XML ou "eXtensible Markup Language" é outro formato amplamente aceito para representar dados estruturados em respostas de API. Ao contrário do JSON, o XML usa tags para definir estruturas hierárquicas de dados, fornecendo uma representação mais precisa, mas estruturada. É como as tags HTML no design de sites e estruturas web. Enquanto o JSON é preferido por sua simplicidade e legibilidade, o XML permanece relevante em algumas áreas, como sistemas corporativos e integrações legadas.

Exemplo de XML na API de Notícias do Forex Factory:

<event>
<title>German Trade Balance</title>
<country>EUR</country>

</event>

3. Outros formatos: Além de JSON e XML, APIs podem usar outros formatos de resposta, como texto simples, HTML, buffers de protocolo ou arquivos CSV, dependendo dos requisitos específicos de domínio e convenções. Cada formato tem suas próprias vantagens e usos, desde eficiência e desempenho até legibilidade humana e adaptabilidade.

O formato JSON se tornou uma escolha popular no desenvolvimento web devido à sua simplicidade, legibilidade e facilidade de uso. Felizmente, o serviço em questão também usa esse modelo para troca de dados.

Configuração do seu ambiente e desenvolvimento

Para configurar um ambiente em MQL5 para usar APIs JSON, você precisará seguir alguns passos.

MQL5 é uma linguagem de programação para criar robôs de negociação, indicadores técnicos, scripts e bibliotecas de funções para a plataforma de negociação MetaTrader 5.

Aqui está um guia geral sobre como configurar um ambiente para trabalhar com APIs JSON em MQL5:

Entenda o básico de MQL5: Certifique-se de ter um bom entendimento dos conceitos básicos da linguagem de programação MQL5, bem como dos conceitos básicos relacionados à negociação e aos mercados financeiros. Familiarize-se com a documentação MQL4 e Referência MQL5 para entender a sintaxe e as funções da linguagem.
Escolha uma biblioteca JSON: O MQL5 não possui suporte nativo para análise de JSON, então você precisará usar uma biblioteca de terceiros. Você pode encontrar essas bibliotecas em fóruns como a comunidade MQL5 ou no GitHub. JSON Serialization e JSON Parser.
Baixe e instale a biblioteca JSON: Baixe a biblioteca JSON escolhida e siga as instruções de instalação fornecidas pela biblioteca. Isso normalmente envolve colocar o arquivo da biblioteca (mqh ou mq5) na pasta Include da sua instalação MetaTrader.
Inclua a biblioteca no seu código: No início do seu script MQL ou EA (Expert Advisor), inclua a biblioteca JSON usando a diretiva #include:

//Use this type of file include if the file is in MQL include follder
#include <JAson.mqh>

// Use this type of file include If this file is next to your EA file/follder
#include "JAson.mqh"

Faça requisições HTTP: Para interagir com APIs JSON, você precisará fazer requisições HTTP. As opções populares incluem WinHTTP ou WebRequest. Se precisar de outro tipo de uso HTTP, baixe e inclua uma biblioteca HTTP que atenda às suas necessidades.
Salve a resposta HTTP em um arquivo: Como a maioria dessas APIs tem limitações no número de requisições, e você está preocupado com o limite de requisições da API, é melhor salvar os dados solicitados em um arquivo e usar nosso arquivo salvo em vez de fazer requisições repetidas e desnecessárias.
Analise as respostas JSON: Depois de receber uma resposta da API, use a biblioteca JSON para analisar os dados JSON. A sintaxe específica dependerá da biblioteca que você está usando.
Mixagem: Após classificar os dados JSON, você pode agora combinar os dados desejados com seu programa, de acordo com o modelo, estratégia ou tipo.

Exemplo de código de funções API

O MQL5 oferece a função WebRequest para requisições HTTP, permitindo interação com APIs.

Você pode ler mais sobre a documentação de Webrequest > Webrequest e Troca de dados HTTP

Abaixo está um exemplo de código MQL para solicitar dados JSON de um endereço de API usando o método GET:

// Required variables
string cookie=NULL, headers="", apikey="your api key",
value1="value 1", value2="value 2";
char post[],result[];
int res;
string URL   =  "https://www.example.com/API?apikey="+apikey+"&data1=value1&data2="+value2; // Rest API address

ResetLastError(); // Reset ast error
// HTTP request via MQL Webrequest, GET method with apikey, value1, and value2 and 2000 millisecond timeout 
res=WebRequest("GET", URL, cookie, NULL, 2000, post, 0, result, headers);
if(res==-1) // WebRequest error handling
 {
    int error =  GetLastError();
    if(error==4060) Print("Webrequest Error ",error);
    else if(error==5203) Print("HTTP request failed!");
    else Print("Unknow HTTP request error("+string(error)+")! ");
    LastHTTPError=error;
 }
else if (res==200) // The HTTP 200 status response code indicates that the request has succeeded
 {
    Print("HTTP request successful!");

    // Use CharArrayToString to convert HTTP result array to a string
    string HTTP_Result = CharArrayToString(result, 0, 0, CP_UTF8); 
    Print(HTTP_Result);      

 }

Este código envia uma solicitação GET para a URL da API especificada, demonstrando a simplicidade de integrar chamadas de API no MQL4.

Estudo de Caso: Expert Advisor MQL4 bem-sucedido com acesso a dados API

Como usar a API de Dados Ziwox para criar um sistema de negociação automático usando dados fundamentais e previsões de IA em tempo real

Neste artigo, exploraremos como usar a API de Dados Ziwox para construir ferramentas baseadas em dados fundamentais e em tempo real na Linguagem MetaQuotes (MQL). Há muitas informações na API deles, mas escolhemos Previsões de IA para o nosso projeto.

O sistema de previsões de IA no terminal Ziwox, segundo suas informações, é baseado na agregação de dados como notícias, dados do calendário econômico, taxas de juros e suas mudanças, políticas monetárias e econômicas dos bancos centrais, sentimento de mercado, força das moedas forex, dados COT e dados dos traders de varejo. Como resultado, todo o mercado é analisado para que essa previsão possa ser usada como um dado valioso.

Vamos percorrer o processo de obtenção dos dados da API, salvamento dos dados JSON em um arquivo, análise das respostas JSON e uso dessas informações para criar um Expert Advisor automatizado (EA).

Nosso plano é criar um Expert Advisor, usar uma estratégia simples de MA como nosso sinal técnico, e negociar se a previsão de IA estiver na nossa direção como um filtro de IA.

Vamos fazer o nosso melhor.

Passo 1: Cadastro e Geração de uma Chave API

Para começar a usar a API de Dados Ziwox, siga esses passos:

1. Cadastre-se no Terminal Ziwox AQUI

Cadastro no Ziwox

2. Preencha o formulário com suas informações, leia os termos e políticas, aceite-os, clique em "Não sou um robô", depois clique em "Criar uma nova conta".

3. Um e-mail de verificação será enviado para sua caixa de entrada, verifique seu e-mail.

3. Faça login na sua conta aqui, navegue até a página de perfil, aba API aqui, e gere sua chave de API clicando no botão verde Gerar

Gerar API Ziwox

4. Ao gerar uma chave de API, você agora tem acesso aos dados da API Ziwox. Copie a chave de API gerada para usá-la em nosso projeto.

Chave de API Ziwox

Passo 2: Entendendo a Estrutura da API

A estrutura do link da API é a seguinte:

https://ziwox.com/terminal/services/API/V1/fulldata.php?expn=ziwoxuser&apikey={API_KEY}&apitype={REQUEST_TYPE}&pair={PAIR}

API_KEY}: Sua chave de API única do passo anterior
{REQUEST_TYPE}: O formato da resposta, seja JSON ou texto.
{PAIR}: O par forex desejado no formato padrão, sem prefixo ou sufixo, como EURUSD, USDJPY, GBPUSD, XAUUSD, WTI...

Passo 3: Testar sua estrutura de API

Agora queremos verificar a estrutura do link da API e solicitar um exemplo da API Ziwox. Simplesmente, use o link da API do Passo 2, edite os parâmetros com seus próprios parâmetros, abra seu navegador, insira o link da API na barra de endereços e pressione enter.

Se você editar corretamente o link da API, o que teremos na resposta HTTP será algo como isto:

Resposta da API Ziwox

Se a chave da API estiver incorreta, você terá uma resposta de erro como esta:

{
"status": "erro",
"desc": "chave api inválida"
}

Ou se você digitar o nome do ativo incorretamente, pode ver essa resposta:

{
"status": "erro",
"desc": "nome do ativo inválido!!"
}

Passo 4: Implementar uma requisição API HTTP função

Se você teve sucesso no passo 3, agora estamos prontos para implementar uma função para automatizar esta parte. Confira este código:

datetime LastWebRequest = 0; // use this datetime var for limit failed request API

bool GetAPI(string symbolname, string apikey, string filename)

  {
   Print("Get API Update");
   bool NeedToUpdate =   false;

   // Check if the API data file available
   if(FileGetInteger(filename,FILE_EXISTS,true)>=0)
     {
      // Check the latest update time from file modify date time
      if(TimeLocal()-(datetime)FileGetInteger(filename,FILE_MODIFY_DATE,true)>900) // update data every 15 min becasue of API call rate limitation
         NeedToUpdate  = true;
     }
   else
      NeedToUpdate  =  true;


   if(NeedToUpdate && TimeLocal()-LastWebRequest>300)   // retry failed API request every 5 min to avoid firewall IP block
     {
      string   cookie=NULL,headers;
      char     post[],result[];
      int      res;
      string   URL   =  "https://www.ziwox.com/terminal/services/API/V1/fulldata.php?expn=ziwoxuser&apikey="+apikey+"&apitype=json&pair="+symbolname;
      ResetLastError();
      int timeout=5000;
      res=WebRequest("GET", URL, cookie, NULL, timeout, post, 0, result, headers);
      if(res==-1)
        {
         LastWebRequest    =  TimeLocal();
         int error         =  GetLastError();
         if(error==4060)
            Print("API data Webrequest Error ",error, " Check your webrequest on Metatrader Expert option.");
         else  if(error==5203)
               Print("HTTP request for "+symbolname+" Data failed!");
            else
               Print("Unknow HTTP request error("+string(error)+")! "+symbolname+" Data");
         return(false);
        }
      else
         if(res==200)
           {
            LastWebRequest =  TimeLocal();
            string HTTPString = CharArrayToString(result, 0, 0, CP_UTF8);
            Print("HTTP request for "+symbolname+" Data successful!");
            Print(HTTPString);
	    
            if (StringFind(HTTPString,"invalid api key",0)!=-1) {
               Alert("invalid api key");
               return(false);
            }
            // Store the API data into a common folder file
            int filehandle=FileOpen(filename,FILE_READ|FILE_SHARE_READ|FILE_WRITE|FILE_SHARE_WRITE|FILE_BIN|FILE_COMMON);
            if(filehandle!=INVALID_HANDLE)
              {
               FileWriteArray(filehandle,result,0,ArraySize(result));
               FileClose(filehandle);
              }
           }
     }
   return(true);
  }

Esta função recebe uma chave de autenticação da API (apikey), o nome do ativo (symbolname) e o nome de um arquivo (filename) como entradas de sua parte. Ela incorpora "apikey" e "symbolname" na URL para preparar o link da requisição API.

Em seguida, ela usa a função Webrequest para fazer uma requisição HTTP, semelhante ao que você fez no passo anterior, e finalmente obtém uma resposta do servidor e coloca as informações relacionadas em um arquivo com o nome "filename".

Chamamos a função da API assim:

string APIfilename =  symbolname+"_API_Data.json"; // API store file name
string APIKey = "76thfd67a6f867df7"; // Our unic API Key, change it with your API Key
string SymbolRequest = "EURUSD"; // Symbol request, without prefix or suffix
string APIJSON[];
bool APIGET = GetAPI(SymbolRequest, APIKey,  APIfilename);

Passo 5: Analisando Dados JSON

Como você se lembra do Passo 3, os dados recebidos da API contêm um array de dados. Você pode ver a explicação completa desses dados na tabela abaixo.

Nome do Objeto JSON	Tipo de dados	Descrição
Símbolo	string	Retorna o mesmo nome de ativo/símbolo
Último Preço	Número	Último preço do ativo
Dígitos	Número	Dígitos do preço do ativo
Base	string	Nome da moeda base do par
Citação	string	Nome da moeda cotada do par
Tendência Fundamental da Base	string	Tendência fundamental da moeda base ou perspectiva fundamental. Pode ser Altista ou Baixista
Força Fundamental da Base	string	Força da tendência fundamental da moeda base. Pode ser Fraca, Moderada ou Forte
Tendência Fundamental da Citação	string	Tendência fundamental da moeda cotada ou perspectiva fundamental. Pode ser Altista ou Baixista
Força Fundamental da Citação	string	Força da tendência fundamental da moeda cotada. Pode ser Fraca, Moderada ou Forte
Tendência Fundamental	string	Tendência fundamental do ativo, ou perspectiva fundamental de longo prazo dos ativos. Altista ou Baixista
Força Fundamental	string	Força fundamental do ativo. Fraca, Moderada ou Forte
Motor Fundamental	string	Mesmo que a tendência fundamental do ativo, é um número, 50 = Neutro, maior que 50 é Altista e menor que 50 é Baixista
Previsão Altista pela IA	Porcentagem	Previsão de movimento altista do preço do ativo, quanto maior o número, mais Altista
Previsão Baixista pela IA	Porcentagem	Previsão de movimento baixista do preço do ativo, quanto maior o número, mais Baixista
Proporção de Longo do Varejo	Porcentagem	Porcentagem de traders varejistas em posições Longas
Lote Longo do Varejo	Número	Lote de posições Longas dos traders varejistas (volume de ordens)
Posição Longa do Varejo	Número	Número de posições Longas dos traders varejistas
Proporção de Curto do Varejo	Porcentagem	Porcentagem de traders varejistas em posições Curtas
Lote Curto do Varejo	Número	Lote de posições Curtas dos traders varejistas (volume de ordens)
Posição Curta do Varejo	Número	Número de posições Curtas dos traders varejistas
Base COT NET	Número	Posição líquida COT da moeda base
Mudança COT Base	Número	Mudança da posição líquida COT (semanal) da moeda base
COT NET Quote	Número	Posição líquida COT da moeda cotada
Mudança COT Quote	Número	Mudança da posição líquida COT (semanal) da moeda cotada
Mudança do COT Ratio	Número	Mudança da posição líquida dos grandes especuladores, número positivo = Sentimento Longo, número negativo = Sentimento Curto
Sentimento de Risco	string	Sentimento de risco do mercado, pode ser Risk-ON, Risk-OFF ou MIX
Tendência D1	string	Dados técnicos, Tendência Diária, Tendência de Compra ou Venda
RSI D1	Número	Dados do indicador, valor do RSI diário
Estocástico D1	Número	Dados do indicador, valor do Estocástico diário
cci	Números	Valores do indicador CCI e
Sinal CCI	string	Sinal do indicador CCI
Suportes	Números	Níveis de suporte do ativo
Resistência	Números	Níveis de resistência do ativo
Pivô	Números	Pontos/pivôs do ativo
Valor VIX	Número	Valor do índice de volatilidade VIX
Direção do VIX	Número	Direção do sentimento do VIX, para cima = Medo e mercado arriscado, para baixo = mercado ganancioso
Motor de Compra do VIX	Número	Número positivo = mercado ganancioso
Motor de Venda do VIX	Número	Número negativo = mercado de Medo e arriscado
Base do Título	Número	Valor do rendimento do título da moeda base
Mudança do Título Base	Número	Mudança do valor do rendimento do título da moeda base
Título Cotado	Número	Valor do rendimento do título da moeda cotada
Mudança do Título Cotado	Número	Mudança do valor do rendimento do título da moeda cotada
US10Y	Número	Valor do rendimento dos títulos de 10 anos dos Estados UnidosMudança do US10Y
Mudança do US10Y	Número	Mudança do valor do US10Y (semanal)
Motor de Rendimento	Número	Número positivo favorece a base, número negativo favorece a cotada
Permitir Negociar	Booleano	Sugestão do Ziwox, negociar ou parar de negociar
Razão para Parar	String	Se sugerir não negociar, você pode ver o motivo aqui.
Reversão de Risco	Número	Valor da Reversão de Risco para este ativo. Determina o valor PUT/CALL
cesi	Número	Valor CESI
Diferença de Rendimento	Número	Valor do rendimento da moeda base - valor do rendimento da moeda cotada
Posição dos Bancos	Número	Proporção da posição das instituições bancárias
Fundamental Macroeconômico	Número	Valor macroeconômico, um número positivo é um impulsionador altista, um número negativo é um impulsionador baixista para o ativo
Sentimento de Longo Prazo	Número	Sentimento de longo prazo do ativo, baseado em Economia, Política...
Sazonal	Porcentagem	A possibilidade de crescimento ou queda do ativo em termos de dados sazonais

Neste estudo de caso/exemplo, gostaríamos de usar a previsão de IA Altista/Baixista. Agora, para projetar essa função, lemos os dados armazenados no arquivo (passo 4) pela biblioteca JSON e extraímos o que precisamos.

A função seria assim:

#include "JAson.mqh"  // include the JSON librery in our project
CJAVal JsonValue;


void JsonDataParse(string filename, string &_APIJSON[])

  {
   bool     UpdateData =   false;
   for (int arraIn=0; arraIn<ArraySize(APIJSON); arraIn++) APIJSON[arraIn]="";


   if(FileGetInteger(filename,FILE_EXISTS,true)>=0)
     {
      int   FileHandle =FileOpen(filename,FILE_READ|FILE_SHARE_READ|FILE_WRITE|FILE_SHARE_WRITE|FILE_BIN|FILE_COMMON);
      char  jsonarray[];
      FileReadArray(FileHandle,jsonarray);
      FileClose(FileHandle);

      JsonValue.Clear();
      JsonValue.Deserialize(CharArrayToString(jsonarray, 0, 0, CP_UTF8));


      _APIJSON[0]   =   JsonValue[0]["Symbol"].ToStr();
      _APIJSON[1]   =   JsonValue[0]["Fundamental Bias"].ToStr();
      _APIJSON[2]   =   JsonValue[0]["Fundamental Power"].ToStr();
      _APIJSON[3]   =   JsonValue[0]["AI Bullish Forecast"].ToStr();
      _APIJSON[4]   =   JsonValue[0]["AI Bearish Forecast"].ToStr();
      _APIJSON[5]   =   JsonValue[0]["Retail Long Ratio"].ToStr();
      _APIJSON[6]   =   JsonValue[0]["Retail Short Ratio"].ToStr();
      _APIJSON[7]   =   JsonValue[0]["Retail Short Lot"].ToStr();
      _APIJSON[8]   =   JsonValue[0]["Retail Short pos"].ToStr();
      _APIJSON[9]   =   JsonValue[0]["Base COT NET"].ToStr();
      _APIJSON[10]  =   JsonValue[0]["Base COT change"].ToStr();
      _APIJSON[11]  =   JsonValue[0]["Quote COT NET"].ToStr();
      _APIJSON[12]  =   JsonValue[0]["Quote COT change"].ToStr();
      _APIJSON[13]  =   JsonValue[0]["COT chng Ratio"].ToStr();
      _APIJSON[14]  =   JsonValue[0]["Risk Sentiment"].ToStr();
     }
  }

E chamamos a função JSON assim:

string APIfilename =  symbolname+"_API_Data.json"; // API store file name
string API_DATA[]; // define an array variable to store API details

JsonDataParse( APIfilename,API_DATA);

Passo 6: Criando uma Estratégia Simples de Cruzamento de Médias Móveis

Usando os dados extraídos, armazenados na variável “APIJSON”, agora podemos criar estratégias de negociação automatizadas e combinar nossa estratégia com um sistema de previsão de IA. Aqui está um exemplo básico de como usar os dados em um EA:

Você pode escolher qualquer estratégia que desejar, mas neste artigo, tentamos escolher uma estratégia simples, porque nosso objetivo aqui é orientá-lo e ensinar como usar uma ferramenta dessas em seus projetos, para que você possa melhorar sua abordagem.

Uma estratégia de Cruzamento de Médias Móveis é uma técnica popular usada pelos traders para identificar possíveis sinais de compra e venda.

Esta estratégia usa duas médias móveis. Uma de curto prazo e uma de longo prazo para determinar a tendência do mercado.

Quando a MA de curto prazo cruza acima da MA de longo prazo, sinaliza uma compra, e quando cruza abaixo, sinaliza uma venda.

Vamos fazer isso:

shortMA  = iMA(Symbol(), 0, shortMAPeriod, 0, MODE_SMA, PRICE_CLOSE, 0);
longMA   = iMA(Symbol(), 0, longMAPeriod, 0, MODE_SMA, PRICE_CLOSE, 0);


// Check for crossover signals
if ( int(APIJSON[3])>=60 ) // if bullish forecast is higher than 60%
   if (shortMA > longMA)   // BUY trend 
   { 
      if (OrdersTotal() == 0) {
         ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, 3, 0, 0, "Buy Order", 0, 0, Green);
         if (ticket < 0) Print("Error opening buy order: ", GetLastError());
      }
   }

if ( int(APIJSON[4])>=60 ) // if bearish forecast is higher than 60%
   if (shortMA < longMA)   // Sell trend
   {
      if (OrdersTotal() == 0) 
      {
         ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, 3, 0, 0, "Sell Order", 0, 0, Red);
         if (ticket < 0) Print("Error opening sell order: ", GetLastError());
      }
   }

Passo 7: Usando Dados JSON para Filtragem de Sinais

Para melhorar a estratégia de cruzamento de médias móveis, usamos os dados JSON e a razão de previsão de IA da API Ziwox para filtrar os sinais.

Por exemplo, se o cruzamento da MA mostrar uma tendência de compra e se a previsão da IA estiver acima de 50%, sinalizando um movimento altista/para cima, é uma boa ideia entrar em uma compra. Pelo contrário, se a análise técnica (MA) tiver um sinal de venda, venderemos apenas quando os dados analíticos e a previsão estiverem na mesma direção da venda. Dessa forma, o risco de entrada pode ser reduzido e a taxa de acerto pode ser aumentada

Com base na organização dos dados JSON no passo 4, a previsão da IA, a porcentagem altista está no terceiro/terceiro elemento de nosso array e a previsão baixista está no quarto elemento.

O código pode ser assim:

void OnTick()
  {
   if (!APIOK) return;
   double   shortMA, longMA;
   long     ticket = -1;

   if(IsNewCandle())
     {
      shortMA  = iMA(Symbol(), 0, shortMAPeriod, 0, MODE_SMA, PRICE_CLOSE, 0);
      longMA   = iMA(Symbol(), 0, longMAPeriod, 0, MODE_SMA, PRICE_CLOSE, 0);
      
      // Check for crossover signals
      if ( int(APIJSON[3])>=60 ) // if bullish forecast is higher than 60%
         if (shortMA > longMA)   // BUY trend 
         { 
            if (OrdersTotal() == 0) {
               ticket = OrderSend(Symbol(), OP_BUY, Lots, Ask, 3, 0, 0, "Buy Order", 0, 0, Green);
               if (ticket < 0) Print("Error opening buy order: ", GetLastError());
            }
         }
      if ( int(APIJSON[4])>=60 ) // if bearish forecast is higher than 60%
         if (shortMA < longMA)   // Sell trend
         {
            if (OrdersTotal() == 0) 
            {
               ticket = OrderSend(Symbol(), OP_SELL, Lots, Bid, 3, 0, 0, "Sell Order", 0, 0, Red);
               if (ticket < 0) Print("Error opening sell order: ", GetLastError());
            }
         } 
     }
  }

Conclusão

Integrando os dados da API com o MQL4 capacita os traders a criar Expert Advisors mais adaptáveis e baseados em dados. Ao aproveitar informações em tempo real de fontes externas, os traders podem aprimorar suas estratégias e tomar decisões de negociação mais informadas em condições de mercado dinâmicas. Você pode acessar dados além dos preços de mercado brutos. Essa abordagem permite combinar análise técnica e fundamental, aumentando a eficácia de suas estratégias de negociação.

O código final está pronto para ser baixado abaixo.

Estou aqui, pronto para responder a qualquer pergunta, sugestão ou crítica.

Atenciosamente e boas negociações.

Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/14108

Arquivos anexados |

Baixar como ZIP

APIExpert.mq4 (18.77 KB)

JAson.mqh (30.59 KB)

Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.

Últimos Comentários | Ir para discussão (21)

Edgar Akhmadeev | 21 jan. 2025 em 13:18

Ney Borges #:
Se necessário, você pode usar a biblioteca JAson.mqh, que pode ser encontrada no código original do nosso companheiro.

Que maneira horrível de o Google Tradutor funcionar.

Sem a biblioteca JAson, é claro, ele não funcionará.

A biblioteca não está em seu código, ela está aqui, e o autor especificou isso.

Ney Borges | 21 jan. 2025 em 19:24

Sara Sabaghi #:

Sim, eu entendo perfeitamente. Além disso, somos obrigados a usar esse padrão porque quase todos os provedores de dados financeiros usam esse método.

Ney Borges #:
Olá, aqui está, então o que eu pedi é que eu postasse na comunidade mql5 =.

Versão para MQL5 METATRADER 5 Fiz alterações no código para que ele funcionasse no Metatrader 5. As alterações também foram feitas com relação à codificação para obter melhores condições na situação comercial atual. Todas as alterações foram feitas para adaptar o código ao Metatrader 5. Ele é funcional. Basta fazer o download desse arquivo e executá-lo. Se necessário, a biblioteca JAson.mqh, que se encontra no código original do nosso companheiro. Meu nome é Ney Borges. Sou do Brasil, estado de Goiás, cidade de Caldas Novas, no meio da floresta do Brasil. Foi muito difícil aprender sozinho, sem ninguém para ajudar, mas aqui na comunidade eu aprendi muito. Obrigado a vocês.

Versão para MQL5 METATRADER 5 Fiz alterações no código para que ele funcionasse no Metatrader 5. As alterações também foram feitas com relação à codificação para melhores condições na situação comercial atual. Todas as alterações foram feitas para adaptar o código ao Metatrader 5. Ele é funcional. Basta fazer o download desse arquivo e executá-lo. Se necessário, a biblioteca JAson.mqh, que se encontra no código original do nosso companheiro. Meu nome é Ney Borges. Sou do Brasil, estado de Goiás, cidade de Caldas Novas, no meio da floresta do Brasil. Foi muito difícil aprender sozinho, sem ninguém para ajudar, mas aqui na comunidade eu aprendi muito. Obrigado a vocês.

Brasil - Goiás - Caldas Novas - Ney Borges

Fiz algumas correções ao código para funcionar no MQL5 gostaria que uma pessoa gentil verificasse e retornasse, obrigado - Sara Sabaghi

//+------------------------------------------------------------------+
//| Ney Borges versão mql5 de ZIWOX API and Technical Strategy.mq5
//|Copyright 2024, ssabbaghi |
//| https://www.mql5.com/pt/users/ssabbaghi
//+------------------------------------------------------------------+
#property   copyright   "Sara Sabbaghi"
#property   link        "https://www.mql5.com/pt/users/ssabbaghi"
#property   version     "1.0"
#property   strict
#property   description "Especialista com funções de rede para a API do ZIWOX"

// Bibliotecas
#include <JAson.mqh>
CJAVal JsonValue;

// Propriedades do Expert para permitir funções de rede
//#propriedade script_show_inputs
//#property script_show_confirm

//---- parâmetros de entrada
input    string      APIKey         =  "sua Key aqui xxxxxxxx";      // Sua chave de API exclusiva
input    string      SymbolPrefix   =  "";      // Prefixo do símbolo da conta de sua corretora
input    string      SymbolSuffiex  =  "m";      // Sufixo do símbolo da conta de sua corretora
input    int         shortMAPeriod  =  50;      // Período de MA lenta
input    int         longMAPeriod   =  200;     // Período MA rápido
input    double      Lots           =  0.01;    // Volume estático do pedido
input    double      BullishThreshold = 60.0;   // Limite para previsão de alta
input    double      BearishThreshold = 60.0;   // Limite para previsão de baixa
input    int         APICallInterval = 300;     // Intervalo entre chamadas de API em segundos (5 minutos)

string   OBJPREFIX      =  "ZXAPI",
         SymbolRequest  =  "",
         APIJSON[];
bool     APIOK          =  false;
datetime LastAPICallTime = 0; // Armazena o tempo da última chamada à API

//+------------------------------------------------------------------+
//| Função para testar a conexão HTTP|
//+------------------------------------------------------------------+
bool TestHTTPConnection()
{
   string cookie=NULL,headers;
   char post[],result[];
   string url="https://www.ziwox.com";
   
   ResetLastError();
   int timeout=5000; 
   
   int res=WebRequest("GET",url,cookie,NULL,timeout,post,0,result,headers);
   
   if(res==-1)
   { 
      int error=GetLastError();
      string msg = "Falha ao conectar, erro "+IntegerToString(error);
      
      // Se houver erro de permissão, mostra mensagem específica
      if(error==4014)
         msg = "Adicione "+url+" em Ferramentas -> Opções -> Expert Advisors -> Permitir WebRequest";
         
      Print("DEBUG: ", msg);
      return(false);
   }
   
   Print("DEBUG: Conexão HTTP testada com sucesso");
   return(true);
}

//+------------------------------------------------------------------+
//| função de inicialização de especialista|
//+------------------------------------------------------------------+
int OnInit()
{
   Print("=== Iniciando Expert Advisor ===");
   
   // Verifica configurações básicas
   if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
   {
      Print("AVISO: Negociação Algorítmica não é permitida");
      // Continua mesmo assim
   }
   
   if(!TerminalInfoInteger(TERMINAL_CONNECTED))
   {
      Print("AVISO: O terminal não está conectado à Internet");
      // Continua mesmo assim
   }
   
   // Configuração do EA
   EventSetTimer(30);
   ArrayResize(APIJSON, 15);
   SymbolRequest = PureSymbol(Symbol(), SymbolSuffiex, SymbolPrefix);
   
   // Prepara e mostra a URL que será usada
   string cleanSymbol = SymbolRequest;
   StringReplace(cleanSymbol, "m", "");
   string apiUrl = StringFormat("https://www.ziwox.com/terminal/services/API/V1/fulldata.php?expn=ziwoxuser&amp;apikey=%s&apitype=json&pair=%s", 
                              APIKey, cleanSymbol);
   
   Print("URL configurada: ", apiUrl);
   Print("IMPORTANTE: Adicione a URL https://www.ziwox.com em:");
   Print("Ferramentas -> Opções -> Expert Advisors -> Permitir WebRequest");
   
   Comment("Iniciando EA...\n",
           "URL que será usada:\n",
           apiUrl,
           "\n\nIMPORTANTE: Configure a URL nas opções do Expert Advisor");
   
   // Testa conexão HTTP, mas não falha se der erro
   if(!TestHTTPConnection())
   {
      Print("AVISO: O teste de conexão HTTP falhou");
      Print("O EA continua tentando se conectar...");
      // Continua mesmo assim
   }
   
   Print("=== Inicialização concluída ===");
   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Função de desinicialização de especialista|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   Comment("");
   ObjectsDeleteAll(0);
}

//+------------------------------------------------------------------+
//| Função OnTick() do tique do especialista|
//+------------------------------------------------------------------+
void OnTick()
{
   if (!APIOK) return;
   
   double shortMA, longMA;
   MqlTradeRequest request = {};
   MqlTradeResult result = {};
   
   if (IsNewCandle())
   {
      shortMA = iMA(Symbol(),PERIOD_CURRENT, shortMAPeriod, 0, MODE_SMA, PRICE_CLOSE);
      longMA = iMA(Symbol(),PERIOD_CURRENT, longMAPeriod, 0, MODE_SMA, PRICE_CLOSE);

      // Analisando dados JSON para decisões de negociação
      double aiBullishForecast = StringToDouble(APIJSON[3]); // Previsão de alta
      double aiBearishForecast = StringToDouble(APIJSON[4]); // Previsão de baixa

      // Verificação de sinais de crossover
      if (aiBullishForecast >= BullishThreshold && shortMA > longMA) // Se a previsão de alta for maior que o limite
      {
         if (OrdersTotal() == 0) {
            request.action = TRADE_ACTION_DEAL;
            request.symbol = _Symbol;
            request.volume = Lots;
            request.type = ORDER_TYPE_BUY;
            request.price = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
            request.deviation = 3;
            request.magic = 123456;
            request.comment = "Buy Order";
            request.type_filling = ORDER_FILLING_FOK;
            
            if(!OrderSend(request, result))
               Print("Error opening buy order: ", GetLastError());
         }
      }
      if (aiBearishForecast >= BearishThreshold && shortMA < longMA) // Se a previsão de baixa for maior que o limite
      {
         if (OrdersTotal() == 0) {
            request.action = TRADE_ACTION_DEAL;
            request.symbol = _Symbol;
            request.volume = Lots;
            request.type = ORDER_TYPE_SELL;
            request.price = SymbolInfoDouble(_Symbol, SYMBOL_BID);
            request.deviation = 3;
            request.magic = 123456;
            request.comment = "Sell Order";
            request.type_filling = ORDER_FILLING_FOK;
            
            if(!OrderSend(request, result))
               Print("Error opening sell order: ", GetLastError());
         }
      }
   }
}

//+------------------------------------------------------------------+
//| Função para verificar se a URL está permitida
//+------------------------------------------------------------------+
bool IsURLAllowed()
{
   string url = "https://www.ziwox.com";
   string cookie=NULL, headers;
   char post[], result[];
   ResetLastError();
   
   int res = WebRequest("GET", url, cookie, NULL, 5000, post, 0, result, headers);
   
   if(res == -1)
   {
      int error = GetLastError();
      if(error == 4014)
      {
         Comment("ATENÇÃO: URL não permitida",
                 "1. Vá em Ferramentas -> Opções -> Expert Advisors\n",
                 "2. Marque 'Permitir WebRequest para as URLs listadas abaixo'\n",
                 "3. Adicione a URL: ", url, "\n",
                 "4. Clique em OK");
         return false;
      }
   }
   return true;
}

//+------------------------------------------------------------------+
//| Função OnTimer especializada|
//+------------------------------------------------------------------+
void OnTimer()
{
   // Verifica se a URL está permitida antes de fazer a chamada
   if(!IsURLAllowed())
   {
      Print("DEBUG: URL não está permitida. Aguardando configuração...");
      return;
   }

   if (TimeCurrent() - LastAPICallTime >= APICallInterval)
   {
      string APIfilename = SymbolRequest + "_API_Data.json";
      
      // Prepara a URL para mostrar no comentário
      string cleanSymbol = SymbolRequest;
      StringReplace(cleanSymbol, "m", "");
      string apiUrl = StringFormat("https://www.ziwox.com/terminal/services/API/V1/fulldata.php?expn=ziwoxuser&amp;apikey=%s&apitype=json&pair=%s", 
                                 APIKey, cleanSymbol);
      
      // Mostra que está fazendo a chamada
      Comment("Fazendo chamada à API...\n",
              "URL: ", apiUrl,
              "\n\nAguarde...");
      
      APIOK = GetAPI(SymbolRequest, APIKey, APIfilename);
      
      if (APIOK) {
         JsonDataParse(APIfilename, APIJSON);
         Comment("=== API OK ===\n",
                 "URL: ", apiUrl, "\n",
                 "Última atualização: ", TimeToString(TimeCurrent(), TIME_DATE|TIME_SECONDS), "\n",
                 "\nDados recebidos:",
                 "\nSymbol: ", APIJSON[0],
                 "\nÚltimo Preço: ", APIJSON[1],
                 "\nViés Fundamental: ", APIJSON[2],
                 "\nPrevisão de Alta: ", APIJSON[3], "%",
                 "\nPrevisão de Baixa: ", APIJSON[4], "%",
                 "\nPosições Compradas: ", APIJSON[5],
                 "\nPosições Vendidas: ", APIJSON[6],
                 "\nTendência D1: ", APIJSON[7],
                 "\nRSI D1: ", APIJSON[8],
                 "\nPermitido Operar: ", APIJSON[9]
                 );
      } else {
         Comment("=== FALHA NA API ===\n",
                 "URL tentada: ", apiUrl, "\n",
                 "Hora: ", TimeToString(TimeCurrent(), TIME_DATE|TIME_SECONDS), "\n",
                 "\nVerifique:",
                 "\n1. Se a URL for permitida em Ferramentas -> Opções -> Expert Advisors -> WebRequest",
                 "\n2. Se sua conexão com a Internet estiver funcionando",
                 "\n3. Se o símbolo estiver correto"
                 );
      }

      LastAPICallTime = TimeCurrent();
   }
}

//+------------------------------------------------------------------+
//| Função para verificar se é um novo candle
//+------------------------------------------------------------------+
bool IsNewCandle()
{
   static datetime lastCandleTime = 0;
   datetime currentCandleTime = iTime(Symbol(), 0, 0);
   if (currentCandleTime != lastCandleTime)
   {
      lastCandleTime = currentCandleTime;
      return true;
   }
   return false;
}

//+------------------------------------------------------------------+
//| Função de símbolo puro|
//+------------------------------------------------------------------+
string PureSymbol(string symbol, string suffiex, string prefix)
{
   string puresymbol = symbol;
   if (prefix != "" || suffiex != "")
   {
      StringReplace(puresymbol, suffiex, "");
      StringReplace(puresymbol, prefix, "");
   }
   return puresymbol;
}

//+------------------------------------------------------------------+
//| Função para verificar a configuração do WebRequest
//+------------------------------------------------------------------+
bool CheckWebRequestSettings()
{
   if(!TerminalInfoInteger(TERMINAL_DLLS_ALLOWED))
   {
      Print("ERRO: DLLs não são permitidas!");
      return false;
   }
   
   if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED))
   {
      Print("ERRO: Negociação Algorítmica não é permitida!");
      return false;
   }
   
   if(!MQLInfoInteger(MQL_DLLS_ALLOWED))
   {
      Print("ERRO: DLLs não são permitidas para este Expert!");
      return false;
   }
   
   return true;
}

//+------------------------------------------------------------------+
//| Função para verificar a conexão com o servidor
//+------------------------------------------------------------------+
bool CheckServerConnection()
{
   int socket = SocketCreate();
   
   if(socket != INVALID_HANDLE)
   {
      // Tenta se conectar ao servidor da ZIWOX (porta 80 para HTTP)
      if(SocketConnect(socket, "www.ziwox.com", 80, 1000))
      {
         Print("DEBUG: Conexão com servidor testada com sucesso");
         // Verifica se está realmente conectado
         if(SocketIsConnected(socket))
         {
            SocketClose(socket);
            return true;
         }
      }
      else
      {
         Print("DEBUG: Falha ao conectar com o servidor: ", GetLastError());
      }
      SocketClose(socket);
   }
   else
   {
      Print("DEBUG: Falha ao criar socket: ", GetLastError());
   }
   return false;
}

//+------------------------------------------------------------------+
//| Função para obter dados da API|
//+------------------------------------------------------------------+
bool GetAPI(string symbolname, string apikey, string filename)
{
   if(!TestHTTPConnection())
   {
      Print("DEBUG: Falha no teste de conexão HTTP");
      return false;
   }

   string headers = "Content-Type: application/json\r\nAccept: application/json\r\n";
   char post[], result[];
   string cookie=NULL;
   int res;
   
   // Remover o sufixo 'm' do símbolo para a API
   string cleanSymbol = symbolname;
   StringReplace(cleanSymbol, "m", "");
   
   string URL = "https://www.ziwox.com/terminal/services/API/V1/fulldata.php";
   string params = StringFormat("?expn=ziwoxuser&apikey=%s&apitype=json&pair=%s", 
                              apikey, cleanSymbol);
   
   Print("DEBUG: Preparando requisição...");
   Print("DEBUG: URL completa: ", URL + params);
   
   URL = URL + params;
   
   string body = StringFormat("{\"apikey\":\"%s\",\"pair\":\"%s\"}", apikey, cleanSymbol);
   StringToCharArray(body, post, 0, WHOLE_ARRAY, CP_UTF8);
   
   Print("DEBUG: Corpo da requisição: ", body);
   
   // Tenta fazer a requisição
   Print("DEBUG: Iniciando WebRequest...");
   res = WebRequest("GET", URL, cookie, NULL, 5000, post, 0, result, headers);
   Print("DEBUG: Código de resposta WebRequest: ", res);
   
   if(res == -1)
   {
      int error = GetLastError();
      Print("DEBUG: GetLastError retornou: ", error);
      return false;
   }
   
   if(res != 200)
   {
      Print("DEBUG: Resposta HTTP diferente de 200: ", res);
      return false;
   }
   
   string response = CharArrayToString(result, 0, WHOLE_ARRAY, CP_UTF8);
   
   // Remover uma tag <pre> da resposta
   StringReplace(response, "<pre>", "");
   StringReplace(response, "</pre>", "");
   
   Print("DEBUG: Resposta recebida (primeiros 500 caracteres): ", StringSubstr(response, 0, 500));
   Print("DEBUG: Tamanho total da resposta: ", StringLen(response));
   
   if(StringFind(response, "invalid api key") >= 0)
   {
      Print("DEBUG: Chave de API inválida encontrada na resposta");
      Alert("Invalid API key");
      return false;
   }
   
   // Tenta salvar a resposta
   Print("DEBUG: Tentando salvar resposta no arquivo: ", filename);
   int filehandle = FileOpen(filename, FILE_WRITE|FILE_BIN|FILE_COMMON);
   if(filehandle != INVALID_HANDLE)
   {
      // Converte a resposta para array de caracteres
      char responseArray[];
      StringToCharArray(response, responseArray, 0, StringLen(response));
      
      // Salva no arquivo
      FileWriteArray(filehandle, responseArray);
      FileClose(filehandle);
      Print("DEBUG: Arquivo salvo com sucesso");
      return true;
   }
   
   Print("DEBUG: Falha ao salvar arquivo");
   return false;
}

//+------------------------------------------------------------------+
//| Função para analisar dados JSON|
//+------------------------------------------------------------------+
void JsonDataParse(string filename, string &_APIJSON[])
{
   for (int arraIn = 0; arraIn < ArraySize(APIJSON); arraIn++) 
      APIJSON[arraIn] = "";

   if (FileGetInteger(filename, FILE_EXISTS, true) >= 0)
   {
      int FileHandle = FileOpen(filename, FILE_READ|FILE_BIN|FILE_COMMON);
      if(FileHandle != INVALID_HANDLE)
      {
         char jsonarray[];
         FileReadArray(FileHandle, jsonarray);
         FileClose(FileHandle);

         JsonValue.Clear();
         string jsonString = CharArrayToString(jsonarray, 0, WHOLE_ARRAY, CP_UTF8);
         Print("JSON Recebido: ", jsonString); // Depurar
         
         if(JsonValue.Deserialize(jsonString))
         {
            _APIJSON[0] = JsonValue[0]["Symbol"].ToStr();
            _APIJSON[1] = JsonValue[0]["Last Price"].ToStr();
            _APIJSON[2] = JsonValue[0]["Base Fundamental Bias"].ToStr();
            _APIJSON[3] = JsonValue[0]["AI Bullish Forecast"].ToStr();
            _APIJSON[4] = JsonValue[0]["AI Bearish Forecast"].ToStr();
            _APIJSON[5] = JsonValue[0]["Retail Long Ratio"].ToStr();
            _APIJSON[6] = JsonValue[0]["Retail Short Ratio"].ToStr();
            _APIJSON[7] = JsonValue[0]["D1 Trend"].ToStr();
            _APIJSON[8] = JsonValue[0]["D1 RSI"].ToStr();
            _APIJSON[9] = JsonValue[0]["Allow To Trade"].ToStr();
            
            Print("Dados processados:");
            Print("Symbol: ", _APIJSON[0]);
            Print("Last Price: ", _APIJSON[1]);

Sara Sabaghi | 21 jan. 2025 em 20:33

Ney Borges #:

Fiz algumas correções ao código para funcionar no MQL5 gostaria que uma pessoa gentil verificasse e retornasse, obrigado - Sara Sabaghi

Olá, cara

Obrigado por compartilhar seu código. Sim, eu o testei. Ele funciona bem

API de dados Forex da Ziwox

fxsaber | 22 jan. 2025 em 15:58

Nikolai Semko #:

Mudou para binário. O tamanho dos mesmos dados agora é de 1,2 Mb. A análise das matrizes de estruturas necessárias agora leva 5 milissegundos.

Isso é um pouco demais para você. Aqui são necessários 12 ms, mas os dados são de 80 Mb.

Nikolai Semko | 22 jan. 2025 em 16:55

fxsaber #:

Isso é um pouco demais. São 12 ms aqui, mas os dados são de 80 Mb.

Não, tudo é o mais otimizado possível com a análise. O fato é que a estrutura de dados no servidor é muito ruim, o que não pude influenciar. A saída da análise é de 5 matrizes de estruturas, e a entrada (no binário) é de 2 matrizes de estruturas. Ou seja, 3 matrizes de estruturas estão aninhadas em elementos de 2 matrizes de estruturas. É por isso que tive de copiar elemento por elemento. A única coisa sobre a qual menti foi o fato de ter mudado de JSON de 20 Mb para um binário de 2,2 Mb em vez de 1,2 Mb.

Desenvolvendo um EA multimoeda (Parte 18): Automação da seleção de grupos considerando o período forward

Continuaremos automatizando etapas que anteriormente realizávamos manualmente. Desta vez, voltaremos à automação da segunda etapa, ou seja, a escolha do grupo ideal de instâncias individuais de estratégias de negociação, complementada pela capacidade de considerar os resultados dessas instâncias no período forward.

Técnicas do MQL5 Wizard que você deve conhecer (Parte 26): Médias Móveis e o Exponente de Hurst

O Exponente de Hurst é uma medida de quanto uma série temporal se autocorrela ao longo do tempo. Entende-se que ele captura as propriedades de longo prazo de uma série temporal e, portanto, tem um peso significativo na análise de séries temporais, mesmo fora do contexto econômico/financeiro. No entanto, focamos em seu potencial benefício para os traders ao analisar como essa métrica poderia ser combinada com médias móveis para construir um sinal potencialmente robusto.

Técnicas do MQL5 Wizard que você deve conhecer (Parte 27): Médias Móveis e o Ângulo de Ataque

O Ângulo de Ataque é uma métrica frequentemente citada, cuja inclinação é entendida como tendo uma forte correlação com a força de uma tendência predominante. Vamos analisar como ele é comumente usado e compreendido e examinar se há mudanças que poderiam ser introduzidas na forma como é medido, para benefício de um sistema de negociação que o utilize.

Usando o Algoritmo de Aprendizado de Máquina PatchTST para Prever a Ação do Preço nas Próximas 24 Horas

Neste artigo, aplicamos um algoritmo relativamente complexo de rede neural chamado PatchTST, lançado em 2023, para prever a ação do preço nas próximas 24 horas. Usaremos o repositório oficial, faremos algumas modificações, treinaremos um modelo para EURUSD e o aplicaremos para fazer previsões futuras, tanto em Python quanto em MQL5.