MetaTrader 5 / Trading
English Русский 中文 Deutsch 日本語 Português
preview
Aprendiendo a diseñar un sistema de trading con Fibonacci

Aprendiendo a diseñar un sistema de trading con Fibonacci

MetaTrader 5 — Trading | 6 julio 2023, 09:43
1 138 0
Mohamed Abdelmaaboud
Mohamed Abdelmaaboud

Introducción

Bienvenidos a nuevo artículo de nuestra serie dedicada a la creación de sistemas comerciales basados en herramientas analíticas e indicadores técnicos populares. En esta ocasión, analizaremos cómo crear un sistema comercial basado en el indicador Fibonacci Retracement. Probablemente, este sea uno de los indicadores más populares en el trading. Hoy crearemos un sistema comercial que podremos utilizar en el terminal MetaTrader 5. Asimismo, escribiremos un programa en MQL5 utilizando el entorno integrado del MetaEditor. En anteriores ocasiones, ya hemos abarcado con detalle cómo descargar y usar MetaTrader 5 e IDE, a este respecto, podrá leer "Escribiendo el código MQL5 en el MetaEditor" en un artículo anterior.

Qué analizaremos hoy:

Merece la pena señalar que resulta mejor usar Fibonacci en combinación con otras herramientas técnicas, tales como el análisis de tendencias, apoyo y resistencia, etcétera, pues le ayudará a comprender mejor la idea y mejorar sus resultados. También es muy importante probar y optimizar minuciosamente las estrategias antes de operar con ellas para asegurarse de que estas funcionan para usted. Le recomiendo escribir todos los códigos por sí mismo y seguir todos los pasos de los que hablaremos en este artículo. Esta práctica le ayudará a mejorar sus habilidades de programación.

¡Atención! Toda la información del presente artículo se ofrece «tal cual», únicamente con fines ilustrativos, y no supone ningún tipo de recomendación. El artículo no garantiza ningún resultado en absoluto. Todo lo que ponga en práctica usando este artículo como base, lo hará bajo su propia cuenta y riesgo; el autor no garantiza resultado alguno.


Definición de Fibonacci

En esta parte, veremos qué es la herramienta Fibonacci Retracement y cómo se puede utilizar en el gráfico. Fibonacci es una herramienta técnica que se puede usar para encontrar áreas de apoyo o resistencia en un gráfico (estas son las áreas donde esperamos un rebote). Su funcionamiento se basa en la secuencia de Fibonacci, que es una serie numérica matemática. Cada número de esta serie supone la suma de los dos números anteriores. En el gráfico, los niveles de Fibonacci se dibujan como líneas horizontales. Las líneas más populares del gráfico son las del 23,6%, el 38,2%, el 50% y el 61,8%.

Para ver estos niveles en el gráfico, solo tendremos que seleccionar este indicador de la lista de instrumentos técnicos disponibles en MetaTrader 5 y ejecutarlo en el gráfico. Cómo hacerlo paso a paso:

Abra el terminal MetaTrader 5, entre en la pestaña Insertar --> Objetos --> Fibonacci Retracement

Iniciando los niveles de Fibonacci en un gráfico

Después de eso, si se ha formado un retroceso tras una tendencia alcista, construiremos el nivel desde el mínimo hasta el máximo, y viceversa, si se ha formado un retroceso tras una tendencia bajista, construiremos el nivel desde el máximo hasta el mínimo, como en los siguientes ejemplos.

Fibonacci después de una tendencia alcista:

Activación de los niveles de Fibonacci en el gráfico en una tendencia alcista

Fibonacci tras una tendencia bajista:

Activación de los niveles de Fibonacci en el gráfico en una tendencia bajista

Como podemos ver en los ejemplos anteriores, el gráfico muestra una línea de tendencia dibujada entre los dos puntos que representan los valores más alto y más bajo, así como líneas horizontales con niveles 23.6, 38.2, 50 y 61.8. Estos son los niveles en los que podemos esperar una corrección o retroceso después de una tendencia alcista o bajista, es decir, podemos esperar que el precio alcance estos niveles y rebote desde ellos. Gracias a esta característica, los niveles de Fibonacci se pueden usar como niveles de apoyo o resistencia.

Podemos gestionar los niveles a través de la ventana de configuración. Para hacer esto, pulsaremos el botón derecho sobre la herramienta de dibujado o sobre el gráfico. Luego seleccionaremos Objetos del menú y elegiremos los niveles de Fibonacci de la lista. A continuación, se abrirá la ventana siguiente:

Niveles de Fibonacci ventana 1

En la pestaña de configuración general, podremos seleccionar el nombre del objeto y el estilo de visualización: precios, tipo de línea y grosor.

Niveles de Fibonacci ventana 2

Como podemos ver en la figura anterior, la herramienta nos permite personalizar de manera flexible los niveles, así como su apariencia en el gráfico.

Ventana de Fibonacci 3

En la pestaña de parámetros, podremos establecer la fecha, la hora y el valor a partir del cual comenzaremos a construir los niveles, además de la fecha, la hora y los valores en los que finalizará la construcción del objeto de Fibonacci.


Estrategias del indicador de Fibonacci

En esta parte, utilizando estrategias simples como ejemplo, aprenderemos cómo usar los niveles de Fibonacci Retracement. Vamos a analizar dos enfoques. Uno de ellos consistirá en determinar los niveles de Fibonacci según la última vela diaria, mientras que el segundo conllevará establecer el número de velas en cualquier marco temporal y determinar los niveles en función de estas. Luego trabajaremos con otra estrategia, en la que obtendremos una señal de compra o venta basada en un nivel de Fibonacci predeterminado. Veamos con detalle cada una de estas estrategias.

Primer enfoque: usamos como base los datos diarios

Sistema simple: Simple FIBO

Según los términos de esta estrategia, obtendremos niveles de corrección de Fibonacci basados ​​en los datos y el estado de la vela diaria. Si la última vela diaria es alcista, construiremos niveles de Fibonacci alcistas desde el mínimo hasta el máximo de la vela, y también obtendremos los valores de precio de cada nivel. Si la última vela diaria es bajista, construiremos niveles de Fibonacci bajistas rojos desde el máximo hasta el mínimo de la vela, y nuevamente obtendremos los valores de precio para cada uno de ellos.

Así, tendremos lo siguiente:

Cierre del último día por encima de la apertura ==> vela alcista

Construimos niveles de Fibonacci verdes, obtenemos los precios de estos niveles.  

Cierre del último día por debajo de la apertura ==> vela bajista

Construimos niveles de Fibonacci rojos, obtenemos los precios de estos niveles.

Señales de Fibonacci:

Esta estrategia generará señales de compra y venta basadas en determinados niveles de Fibonacci alcistas y bajistas. Por ejemplo, establecemos el nivel de Fibonacci alcista en 38,2 y luego obtenemos el precio en este nivel para abrir una operación de compra. Al establecer este nivel para velas bajistas, obtendremos el nivel de precio para entrar en una operación de venta.

Segundo enfoque: usamos como base un array de velas determinadas

Segundo sistema simple: Simple FIBO 2

Con esta estrategia, obtendremos niveles de precios de Fibonacci basados ​​en un array de velas. Para determinar la dirección del mercado (alcista o bajista) a la hora de construir los niveles de Fibonacci correspondientes, usaremos como base un array completo de velas.

Así, tendremos lo siguiente:

Si la apertura de la primera vela del array es más baja que el cierre de la última vela del mismo array, estaremos ante niveles de Fibonacci alcistas y obtendremos el valor de precio correspondiente.

Si la apertura de la primera vela del array es superior al cierre de la última vela del mismo array, trabajaremos con niveles de Fibonacci bajistas y obtendremos el valor de precio correspondiente.

Señales según los niveles de Fibonacci 2: 

Esta estrategia generará señales de entrada comerciales de compra y venta basadas en los niveles de Fibonacci seleccionados, que servirán como nivel de entrada. Si, según las reglas descritas anteriormente, tenemos un Fibonacci alcista, determinaremos el nivel de precio en el que podemos entrar en una operación de compra. Para un Fibonacci bajista, obtendremos el nivel para entrar en una operación de venta.


Esquema de la estrategia de Fibonacci

En esta parte, construiremos los esquemas de desarrollo para escribir el código para las dos estrategias consideradas. Dicho plan/esquema nos permite organizar visualmente el proceso de desarrollo del sistema comercial.

Primer enfoque: usamos como base los datos diarios

Permítanme recordarles que en este enfoque utilizaremos solo la última vela diaria y sus valores de apertura, cierre, máximo y mínimo. Al comparar los precios de apertura y cierre, podremos determinar si nuestra vela es alcista o bajista, y luego, según el tipo de movimiento de esta última vela diaria, construiremos un objeto de Fibonacci y obtendremos las señales.

Sistema simple: Simple FIBO

Esquema del sistema de Fibonacci simple

Señales de Fibonacci:

Esquema de señales de Fibonacci

Segundo enfoque: usamos como base un array de velas determinadas

En este enfoque, trabajaremos con un cierto número de velas en un array. Para ello, determinaremos el precio de apertura de la primera vela y el precio de cierre de la última, así como los valores máximo y mínimo. Al comparar los precios de apertura y cierre, podremos determinar si nuestra vela es alcista o bajista, y nuevamente, según el tipo de movimiento de las velas en este array, construiremos un objeto de Fibonacci y obtendremos las señales.

Segundo sistema simple: Simple FIBO 2

Segundo sistema simple: Simple FIBO 2

Señales de Fibonacci 2

Gráfico de señales de Fibonacci 2

Sistema comercial de Fibonacci

A continuación, veremos cómo podemos implementar todo lo que hemos hablado antes en el sistema comercial. Para ello, crearemos un programa que retornará los niveles de Fibonacci como un comentario en el gráfico. Probaremos ambos enfoques: usando solo la última vela formada del marco temporal diario y eligiendo un cierto número de dichas velas (trabajaremos con un array de valores). También aprenderemos cómo retornar señales de compra y venta basadas en los niveles de Fibonacci según cada uno de estos dos enfoques. Vamos a ver todo con detalle.

Primer enfoque: usamos como base los datos diarios

Sistema simple: Simple FIBO

Como estamos utilizando datos diarios para esta estrategia, deberemos completar los siguientes pasos:

Definiremos el nombre del objeto usando la macrosustitución (#define) para preprocesar el código fuente antes de la compilación.

#define FIB_OBJ "Fibonacci Retracement"

Crearemos una variable entera barsTotal.

int barsTotal;

Después de ello, crearemos en onTick una variable entera para obtener las barras; usaremos la función iBar, que retorna el número de barras históricas disponibles por símbolo. Parámetros de la función:

  • symbol — nombre del símbolo; nosotros tenemos _Symbol, es decir, realizaremos los cálculos según el símbolo del gráfico actual.
  • timeframe — marco temporal para el cálculo. Usaremos el diario, D1.
int bars = iBars(_Symbol, PERIOD_D1);

Generaremos una condición para determinar la vela diaria que se utilizará para el objeto de Fibonacci. El parámetro barTotal no deberá ser igual a bars; lo comprobaremos con el operador (!=). Además, la hora actual deberá ser mayor que la hora de cierre de esta vela diaria. Para hacer esto, usaremos la función TimeCurrent, y StringToTime, que convierte una cadena con un valor temporal en un valor de fecha y hora.

if(barsTotal != bars  && TimeCurrent() > StringToTime("00:05"))

Si se cumple esta condición, el programa hará lo siguiente:

Estableceremos barsTotal en bars.

barsTotal=bars;

Eliminaremos cualquier objeto FIB_OBJ del gráfico utilizando la función ObjectDelete. Parámetros de la función:

  • chart_id — identificador del gráfico, usaremos 0, el gráfico actual. 
  • name — nombre del objeto (FIB_OBJ).
ObjectDelete(0,FIB_OBJ);

Asimismo, crearemos cuatro variables para los valores de precio (apertura, cierre, máximo y mínimo), y las rellenaremos con las funciones iOpen, iClose, iHigh e iLow, que devuelven los valores correspondientes de nuestra barra diaria. Parámetros de la función:

  • symbol — nombre del símbolo; nosotros tenemos _Symbol, es decir, calcularemos el valor del símbolo del gráfico actual.
  • timeframe — marco temporal del gráfico para los cálculos; usaremos el marco temporal diario, PERIOD_D1.
  • start — índice del elemento desde el que comienza la comprobación; no utilizaremos este valor.
      double open = iOpen(_Symbol,PERIOD_D1,1);
      double close = iClose(_Symbol,PERIOD_D1,1);
      double high = iHigh(_Symbol,PERIOD_D1,1);
      double low = iLow(_Symbol,PERIOD_D1,1);

Luego definiremos la hora de inicio y la hora de finalización que usaremos más tarde para dibujar nuestro objeto de Fibonacci. Para ello, utilizaremos la función iTime, que retorna la hora de apertura de la barra. Parámetros de la función:

  • symbol — nombre del símbolo; nosotros tenemos _Symbol, es decir, calcularemos el valor del símbolo del gráfico actual.
  • timeframe — marco temporal del gráfico para los cálculos; usaremos el marco temporal diario, PERIOD_D1.
  • start — índice del elemento desde el que comienza la comprobación; aquí especificaremos 1 para la hora de inicio y 0 para la finalización.

Para la hora de finalización, restaremos 1 del valor retornado, pues ya se encontrará en la hora del nuevo día; esta será la barra diaria actual en el momento que se realicen todos estos cálculos. De hecho, determinaremos la barra anterior.

      datetime startingTime = iTime(_Symbol,PERIOD_D1,1);
      datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1;

Después de ello, estableceremos dos condiciones usando una declaración condicional if-else para dibujar el objeto de Fibonacci.

Si el cierre es mayor que la apertura, esta será una vela alcista y luego haremos lo siguiente.

A continuación, creamos un objeto usando la función ObjectCreate para dibujar el objeto con los símbolos especificados. Parámetros de la función:

  • chart_id — identificador del gráfico, 0 indicará el gráfico actual.
  • name — nombre del objeto utilizado (FIB_OBJ).
  • type — tipo de objeto utilizado, OBJ_FIBO — niveles de fibonacci
  • nwin — índice de la ventana, usaremos 0, la ventana principal del gráfico.
  • time1 — hora del primer punto de anclaje, en nuestro caso, será igual a la hora de inicio.
  • price1 — precio del primer punto de anclaje, aquí comprobaremos el mínimo.
  • timeN=0 — hora del punto de finalización, esta será la hora de finalización.
  • priceN=0 — precio del último punto; usaremos el máximo.

Luego actualizaremos los colores del objeto según la dirección de la barra utilizando ObjectSetInteger y el operador de ciclo for. Parámetros de ObjectSetInteger:

  • chart_id — identificador del gráfico; nosotros lo tenemos en 0, lo que indicará el gráfico actual.
  • name — nombre del objeto que se está utilizando, FIB_OBJ.
  • prop_id — identificador de la propiedad (color), OBJPROP_COLOR.
  • prop_value — valor de la propiedad de color, verde clrGreen.
  • Después usaremos un ciclo for para actualizar continuamente el color del objeto,
y determinaremos los niveles de fibonacci: 23.6 - 38.2 - 50 - 61.8 - 100. Acto seguido, mostraremos un comentario en el gráfico con los valores del último día, de apertura y de cierre. 
      if(close>open)
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
           }
         double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Fib lvl 0% = ",high,"\n",
                 "Fib lvl 23.6% = ",fibRetracLvl1,"\n",
                 "Fib lvl 38.2% = ",fibRetracLvl2,"\n",
                 "Fib lvl 50% = ",fibRetracLvl3,"\n",
                 "Fib lvl 61.8% = ",fibRetracLvl4,"\n",
                 "Fib lvl 100% = ",fibRetracLvl5);
        }

Si estamos tratando con una vela diaria bajista, haremos lo mismo, pero la diferencia será la siguiente:

  • Crearemos el objeto partiendo desde el máximo hasta el mínimo.
  • El color del objeto será rojo.
      else
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
           }
         double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Fib lvl 0% = ",low,"\n",
                 "Fib lvl 23.6% = ",fibRetracLvl1,"\n",
                 "Fib lvl 38.2% = ",fibRetracLvl2,"\n",
                 "Fib lvl 50% = ",fibRetracLvl3,"\n",
                 "Fib lvl 61.8% = ",fibRetracLvl4,"\n",
                 "Fib lvl 100% = ",fibRetracLvl5);
        }

Abajo puede ver el código para esta estrategia.

//+------------------------------------------------------------------+
//|                                         Simple Fibo System#2.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define FIB_OBJ "Fibonacci Retracement"
#property script_show_inputs
input double fibRetracLvl = 38.2;
int barsTotal;
//+------------------------------------------------------------------+
void OnTick()
  {

   int bars = iBars(_Symbol, PERIOD_D1);
   if(barsTotal != bars  && TimeCurrent() > StringToTime("00:05"))
     {
      barsTotal=bars;
      ObjectDelete(0,FIB_OBJ);
      double open = iOpen(_Symbol,PERIOD_D1,1);
      double close = iClose(_Symbol,PERIOD_D1,1);
      double closeCandle = iClose(_Symbol,_Period,1);
      double high = iHigh(_Symbol,PERIOD_D1,1);
      double low = iLow(_Symbol,PERIOD_D1,1);
      datetime startingTime = iTime(_Symbol,PERIOD_D1,1);
      datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1;
      if(close>open)
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
           }
         double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits);
         double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Buy Entry Price: ",entryLvl,"\n",
                 "Close: ",closeCandle,"\n");
        }
      else
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
           }
         double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits);
         double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits);
           {
            Comment("Last Day Open = ",open,"\n",
                    "Last Day Close = ",close,"\n",
                    "Sell Entry Price: ",entryLvl,"\n",
                    "Close: ",closeCandle);
           }
        }
     }
  }
//+------------------------------------------------------------------+

A continuación, le mostramos el código completo para crear la estrategia mencionada:

//+------------------------------------------------------------------+
//|                                         Simple Fibo System#1.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define FIB_OBJ "Fibonacci Retracement"
int barsTotal;
//+------------------------------------------------------------------+
void OnTick()
  {
   int bars = iBars(_Symbol, PERIOD_D1);
   if(barsTotal != bars  && TimeCurrent() > StringToTime("00:05"))
     {
      barsTotal=bars;
      ObjectDelete(0,FIB_OBJ);
      double open = iOpen(_Symbol,PERIOD_D1,1);
      double close = iClose(_Symbol,PERIOD_D1,1);
      double high = iHigh(_Symbol,PERIOD_D1,1);
      double low = iLow(_Symbol,PERIOD_D1,1);
      datetime startingTime = iTime(_Symbol,PERIOD_D1,1);
      datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1;
      if(close>open)
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
           }
         double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Fib lvl 0% = ",high,"\n",
                 "Fib lvl 23.6% = ",fibRetracLvl1,"\n",
                 "Fib lvl 38.2% = ",fibRetracLvl2,"\n",
                 "Fib lvl 50% = ",fibRetracLvl3,"\n",
                 "Fib lvl 61.8% = ",fibRetracLvl4,"\n",
                 "Fib lvl 100% = ",fibRetracLvl5);
        }
      else
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
           }
         double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Fib lvl 0% = ",low,"\n",
                 "Fib lvl 23.6% = ",fibRetracLvl1,"\n",
                 "Fib lvl 38.2% = ",fibRetracLvl2,"\n",
                 "Fib lvl 50% = ",fibRetracLvl3,"\n",
                 "Fib lvl 61.8% = ",fibRetracLvl4,"\n",
                 "Fib lvl 100% = ",fibRetracLvl5);
        }
     }
  }
//+------------------------------------------------------------------+

Compilaremos el código del asesor y este aparecerá en la ventana del Navegador en el terminal. A partir de ahí, lo ejecutaremos en el gráfico. A continuación le mostramos un ejemplo de prueba con velas alcistas y bajistas:

Vela diaria alcista:

Sistema Fibonacci Simple - Alcista - Diario

Los niveles de Fibonacci se construirán de menor a mayor, el color será verde, y los niveles de Fibonacci y apertura/cierre se calcularán para el gráfico diario. Esto se muestra en la siguiente captura de pantalla:

Sistema Fibonacci simple - alcista

Entonces, hemos obtenido lo esperado: los niveles de Fibonacci se construyen desde el mínimo hasta el máximo, y se muestran en verde. Además, el gráfico deberá tener un comentario con los siguientes valores:

  • Last day open — coincide con el valor de apertura de la vela diaria en el gráfico
  • Last day open — este es el valor de cierre.
  • Cinco niveles de Fibonacci.

Vela diaria bajista:

Sistema Fibonacci Simple - Bajista - Diario

Ahora los niveles de Fibonacci se dibujan de mayor a menor, el color es rojo y los niveles de Fibonacci y la apertura/cierre se calcularán para el gráfico diario. Esto se muestra en la siguiente captura de pantalla:

Sistema Fibonacci simple - bajista

En la imagen de arriba, vemos que los niveles de Fibonacci se dibujan de mayor a menor, y se muestran en rojo. En el gráfico hay un comentario con los siguientes valores:

  • The last day open — coincide con el valor de apertura de la vela diaria en el gráfico
  • The last day close — este es el valor de cierre.
  • Cinco niveles de Fibonacci.

Señales de Fibonacci:

Para desarrollar este enfoque, crearemos un sistema comercial que pueda retornar señales de compra y venta basadas en los niveles de Fibonacci. A continuación le mostramos el código completo para dicho sistema:

//+------------------------------------------------------------------+
//|                                         Simple Fibo System#2.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define FIB_OBJ "Fibonacci Retracement"
#property script_show_inputs
input double fibRetracLvl = 38.2;
int barsTotal;
//+------------------------------------------------------------------+
void OnTick()
  {

   int bars = iBars(_Symbol, PERIOD_D1);
   if(barsTotal != bars  && TimeCurrent() > StringToTime("00:05"))
     {
      barsTotal=bars;
      ObjectDelete(0,FIB_OBJ);
      double open = iOpen(_Symbol,PERIOD_D1,1);
      double close = iClose(_Symbol,PERIOD_D1,1);
      double closeCandle = iClose(_Symbol,_Period,1);
      double high = iHigh(_Symbol,PERIOD_D1,1);
      double low = iLow(_Symbol,PERIOD_D1,1);
      datetime startingTime = iTime(_Symbol,PERIOD_D1,1);
      datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1;
      if(close>open)
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
           }
         double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits);
         double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits);
         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Buy Entry Price: ",entryLvl);
        }
      else
        {
         ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low);
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
         for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
           {
            ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
           }
         double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits);
         double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits);
         double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits);
         double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits);
         double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits);
         double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits);
           {
            Comment("Last Day Open = ",open,"\n",
                    "Last Day Close = ",close,"\n",
                    "Sell Entry Price: ",entryLvl);
           }
        }
     }
  }
//+------------------------------------------------------------------+

Diferencias en este código:

Hemos añadido propiedades para mostrar la ventana donde el usuario puede introducir el valor. Se trata de #property script_show_inputs que muestra la ventana de propiedades.

#property script_show_inputs

Utilizaremos una variable de entrada para crear double fibRetracLvl con un valor predeterminado de 38,2.

input double fibRetracLvl = 38.2;

Luego definiremos el nivel de entrada según un valor personalizado en caso de tendencia alcista.

double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits);

Definiremos un nivel de entrada basado en un valor personalizado si hay una tendencia bajista.

double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits);

Comentario sobre el gráfico en caso de una tendencia alcista.

         Comment("Last Day Open = ",open,"\n",
                 "Last Day Close = ",close,"\n",
                 "Buy Entry Price: ",entryLvl,"\n",
                 "Close: ",closeCandle,"\n");

Comentario sobre el gráfico en caso de una tendencia bajista.

            Comment("Last Day Open = ",open,"\n",
                    "Last Day Close = ",close,"\n",
                    "Sell Entry Price: ",entryLvl,"\n",
                    "Close: ",closeCandle);

Compilación del código del asesor experto. Después de ello, este aparecerá en la ventana del Navegador en el terminal. A partir de ahí, lo ejecutaremos en el gráfico. A continuación le mostramos un ejemplo de prueba con velas alcistas y bajistas:

Vela diaria alcista:

Señal de Fibonacci - alcista - diaria

Por consiguiente, deberíamos trazar los niveles verdes de Fibonacci comenzando desde el mínimo hasta el máximo en un periodo de 15 minutos; la apertura y el cierre del último día serán los mismos que en el gráfico diario, mientras que el nivel de entrada será el nivel de precios cerca de 38.2. Para el gráfico de 15 minutos, tendremos lo siguiente:

Señal de Fibonacci - alcista - diaria

Entonces, este será un gráfico de 15 minutos en el que tendremos todos los gráficos y los valores necesarios:

  • Last day open — nivel de apertura del gráfico diario.
  • Last day close — cierre.
  • Buy entry price — precio de entrada en el nivel de Fibonacci 38.2.

Vela diaria bajista:

Señal de Fibonacci - alcista - vela diaria

Ahora revisaremos el gráfico de 15 minutos donde necesitamos obtener una señal basada en la estrategia comercial: debería mostrar un nivel de entrada de venta basado en el nivel de Fibonacci 38.2. Vamos a comprobar el gráfico a continuación:

Señal de Fibonacci - bajista

Como podemos ver, en el gráfico anterior, se ha formado una señal con los siguientes valores:

  • Last day open — nivel de apertura del gráfico diario.
  • Last day close — cierre.
  • Sell entry price — precio de entrada en el nivel de Fibonacci 38.2.

Segundo enfoque: usamos como base un array de velas determinadas

Segundo sistema simple: Simple FIBO 2

Dentro de este enfoque, usaremos un número determinado de velas japonesas que se utilizarán para construir los niveles de Fibonacci. Veamos paso a paso cómo hacer esto:

Definición de FIB_OBJ con ayuda de #define.

#define FIB_OBJ "Fibonacci Retracement"

Crearemos variables enteras para los valores máximo y mínimo.

int highestCandle, lowestCandle;

Luego crearemos dos arrays para los máximos y los mínimos,

double high[],low[];

y clasificaremos los datos en los arrays usando la función ArraySetAsSeries. Parámetros de la función:

  • array[] — definimos los arrays creados.
  • flag — establecemos la dirección de indexación en el array, true.
ArraySetAsSeries(high,true);
ArraySetAsSeries(low,true);

Obtenemos los máximos y los mínimos históricos utilizando las funciones CopyHigh y CopyLow. Parámetros de CopyHigh:

  • symbol_name — nombre del símbolo; especificaremos _Symbol para usar el actual.
  • period — periodo de cálculo del indicador; usaremos el periodo actual (_period) 
  • start_pos — estableceremos la posición del inicio del cálculo; especificaremos 0 para comenzar en la vela actual.
  • count — número de datos a copiar; indicaremos 100
  • high_array[] — array de destino; en nuestro caso, es high.

Para CopyLow, los parámetros serán los mismos, pero crearemos el array Low como array de destino.

CopyHigh(_Symbol,_Period,0,100,high);
CopyLow(_Symbol,_Period,0,100,low);

Luego determinaremos los precios de apertura de la primera vela en el array y los precios de cierre de la última vela usando las funciones iOpen e iClose.

double openCandle = iOpen(_Symbol,_Period,100);
double closeCandle = iClose(_Symbol,_Period,1);

Después determinaremos los valores máximos y mínimos en los arrays High y Low creados usando para ello las funciones ArrayMaximum y ArrayMinimum. Parámetros de la función:

  • array[] — array, high para los máximos y low para los mínimos.
  • start=0 — índice del elemento a partir del cual comenzará la comprobación; utilizaremos 0.
  • count— número de elementos a comprobar; en nuestro caso, será igual a 100 o WHOLE_ARRAY.
highestCandle=ArrayMaximum(high,0,100);
lowestCandle=ArrayMinimum(low,0,100);

A continuación, crearemos un array de precios usando la función MqlRates para almacenar información sobre precios y clasificar los datos en este array usando la función ArraySetAsSeries.

MqlRates pArray[];
ArraySetAsSeries(pArray,true);

Luego obtendremos los datos históricos de MqlRates usando la función CopyRates. Parámetros de la función:

  • symbol_name — nombre del símbolo para el cálculo del indicador, _Symbol, símbolo actual.
  • timeframe — marco temporal a calcular, _Period indicará el marco temporal actual del gráfico.
  • start_pos — posición de inicio del cálculo del indicador; estableceremos 0 para realizar el cálculo desde la posición actual
  • count — número de datos a copiar, Bars.
  • rates_array[] — array al que copiaremos los datos, pArray
int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray);

A continuación, determinaremos dateTime y los precios del nivel cero y el nivel 100 utilizando ObjectGetInteger y ObjectGetDouble

datetime dTlvl0 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,0);
double PriceFibLvl00 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,0);
datetime dTlvl1 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,1);
double PriceFibLvl0 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,1);

Además, estableceremos las condiciones de tendencia alcista y bajista utilizando la declaración if-else.

En el caso de una tendencia alcista (CloseCandle es mayor que openCandle) los siguientes pasos serían:

  • Eliminaremos el objeto FIBO construido previamente usando ObjectDelete.
  • Crearemos un nuevo objeto FIBO, comenzando desde el mínimo y terminando con el máximo del array, usando para ello ObjectCreate.
  • Actualizaremos los colores del objeto FIBO: cambiaremos a verde usando ObjectSetInteger y un ciclo for para continuar actualizando según la tendencia.
  • Determinaremos el rango de precios, obteniendo la diferencia entre el máximo y el mínimo.
  • Determinaremos los niveles de FIBO: 23.6 - 38.2 - 50 - 61.8.
  • Mostraremos un comentario en el gráfico con los niveles Array Open, Array Close y FIBO.
   if(closeCandle>openCandle)
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[lowestCandle].low,pArray[0].time,pArray[highestCandle].high);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
        }
      double pRange =  PriceFibLvl0 - PriceFibLvl00;
      double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 - pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 - pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble (PriceFibLvl0 - pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 - pRange * 61.8/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Fib lvl 0% = ",PriceFibLvl0,"\n",
              "Fib lvl 23.6% = ",PriceFibLvl1,"\n",
              "Fib lvl 38.2% = ",PriceFibLvl2,"\n",
              "Fib lvl 50% = ",PriceFibLvl3,"\n",
              "Fib lvl 61.8% = ",PriceFibLvl4,"\n",
              "Fib lvl 100% = ",PriceFibLvl00);
     }

En el caso de una tendencia bajista (CloseCandle es menor que openCandle), los pasos serían:

  • Eliminaremos el objeto FIBO construido previamente usando ObjectDelete.
  • Crearemos un nuevo objeto FIBO, comenzando desde el máximo y terminando con el mínimo del array, usando ObjectCreate.
  • Actualizaremos los colores del objeto FIBO: cambiaremos a rojo usando ObjectSetInteger y un ciclo for para continuar actualizando según la tendencia.
  • Determinaremos el rango de precios, obteniendo la diferencia entre el mínimo y el máximo.
  • Determinaremos los niveles de FIBO: 23.6 - 38.2 - 50 - 61.8.
  • Mostraremos un comentario en el gráfico con los niveles Array Open, Array Close y FIBO.
   else
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[highestCandle].high,pArray[0].time,pArray[lowestCandle].low);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
        }
      double pRange =  PriceFibLvl00 - PriceFibLvl0;
      double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 + pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 + pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 + pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble (PriceFibLvl0 + pRange * 61.8/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Fib lvl 0% = ",PriceFibLvl0,"\n",
              "Fib lvl 23.6% = ",PriceFibLvl1,"\n",
              "Fib lvl 38.2% = ",PriceFibLvl2,"\n",
              "Fib lvl 50% = ",PriceFibLvl3,"\n",
              "Fib lvl 61.8% = ",PriceFibLvl4,"\n",
              "Fib lvl 100% = ",PriceFibLvl00);
     }

A continuación le mostramos el código completo:

//+------------------------------------------------------------------+
//|                                         Simple Fibo System 2.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define FIB_OBJ "Fibonacci Retracement"
//+------------------------------------------------------------------+
void OnTick()
  {
   int highestCandle, lowestCandle;
   double high[],low[];
   ArraySetAsSeries(high,true);
   ArraySetAsSeries(low,true);
   CopyHigh(_Symbol,_Period,0,100,high);
   CopyLow(_Symbol,_Period,0,100,low);
   double openCandle = iOpen(_Symbol,_Period,100);
   double closeCandle = iClose(_Symbol,_Period,1);
   highestCandle=ArrayMaximum(high,0,100);
   lowestCandle=ArrayMinimum(low,0,100);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray);
   datetime dTlvl0 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,0);
   double PriceFibLvl00 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,0);
   datetime dTlvl1 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,1);
   double PriceFibLvl0 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,1);
   if(closeCandle>openCandle)
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[lowestCandle].low,pArray[0].time,pArray[highestCandle].high);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
        }
      double pRange =  PriceFibLvl0 - PriceFibLvl00;
      double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 - pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 - pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble (PriceFibLvl0 - pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 - pRange * 61.8/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Fib lvl 0% = ",PriceFibLvl0,"\n",
              "Fib lvl 23.6% = ",PriceFibLvl1,"\n",
              "Fib lvl 38.2% = ",PriceFibLvl2,"\n",
              "Fib lvl 50% = ",PriceFibLvl3,"\n",
              "Fib lvl 61.8% = ",PriceFibLvl4,"\n",
              "Fib lvl 100% = ",PriceFibLvl00);
     }
   else
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[highestCandle].high,pArray[0].time,pArray[lowestCandle].low);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
        }
      double pRange =  PriceFibLvl00 - PriceFibLvl0;
      double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 + pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 + pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 + pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble (PriceFibLvl0 + pRange * 61.8/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Fib lvl 0% = ",PriceFibLvl0,"\n",
              "Fib lvl 23.6% = ",PriceFibLvl1,"\n",
              "Fib lvl 38.2% = ",PriceFibLvl2,"\n",
              "Fib lvl 50% = ",PriceFibLvl3,"\n",
              "Fib lvl 61.8% = ",PriceFibLvl4,"\n",
              "Fib lvl 100% = ",PriceFibLvl00);
     }
  }
//+------------------------------------------------------------------+

Luego compilaremos el código y lo ejecutaremos desde el Navegador en el gráfico. El asesor generará señales. A continuación le mostramos ejemplos de señales de prueba.

En el caso de un array alcista:

Sistema simple Fibonacci 2 - alcista

Entonces, en el gráfico anterior, hemos trazado los niveles de Fibonacci verdes, mostrando además un comentario con los siguientes valores en la esquina superior izquierda del gráfico:

  • Array open — valor de apertura en el array.
  • Array close — valor de cierre en el array.
  • Niveles de Fibonacci: 0, 23.6, 38.2, 50, 61.8, 100.

En el caso de un array bajista:

Sistema simple Fibonacci 2 - bajista

Aquí hemos dibujado los niveles rojos de Fibonacci y mostrado un comentario con los siguientes valores en la esquina superior izquierda del gráfico:

  • Array open — valor de apertura en el array.
  • Array close — valor de cierre en el array.
  • Niveles de Fibonacci: 0, 23.6, 38.2, 50, 61.8, 100.

Señales de Fibonacci 2

Ahora, basándonos en el segundo enfoque, crearemos un sistema comercial que retornará señales de compra y venta basadas en los niveles de Fibonacci. El código completo de un sistema comercial así tendrá el aspecto que sigue:

//+------------------------------------------------------------------+
//|                                               Fibo Signals 2.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
#define FIB_OBJ "Fibonacci Retracement"
#property script_show_inputs
input double fibRetracLvl = 38.2;
//+------------------------------------------------------------------+
void OnTick()
  {
   int highestCandle, lowestCandle;
   double high[],low[];
   ArraySetAsSeries(high,true);
   ArraySetAsSeries(low,true);
   CopyHigh(_Symbol,_Period,0,100,high);
   CopyLow(_Symbol,_Period,0,100,low);
   double openCandle = iOpen(_Symbol,_Period,100);
   double closeCandle = iClose(_Symbol,_Period,1);
   highestCandle=ArrayMaximum(high,0,100);
   lowestCandle=ArrayMinimum(low,0,100);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray);
   datetime dTlvl0 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,0);
   double PriceFibLvl00 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,0);
   datetime dTlvl1 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,1);
   double PriceFibLvl0 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,1);
   if
   (closeCandle>openCandle)
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[lowestCandle].low,pArray[0].time,pArray[highestCandle].high);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen);
        }
      double pRange =  PriceFibLvl0 - PriceFibLvl00;
      double PriceFibLvl1 = NormalizeDouble(PriceFibLvl0 - pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble(PriceFibLvl0 - pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 - pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 - pRange * 61.8/100,_Digits);
      double entryLvl = NormalizeDouble(PriceFibLvl0 - pRange * fibRetracLvl/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Buy Entry Price: ",entryLvl);
     }
   else
     {
      ObjectDelete(_Symbol, "Fibonacci Retracement");
      ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time,
                   pArray[highestCandle].high,pArray[0].time,pArray[lowestCandle].low);
      ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed);
      for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++)
        {
         ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed);
        }
      double pRange =  PriceFibLvl00 - PriceFibLvl0;
      double PriceFibLvl1 = NormalizeDouble(PriceFibLvl0 + pRange * 23.6/100,_Digits);
      double PriceFibLvl2 = NormalizeDouble(PriceFibLvl0 + pRange * 38.2/100,_Digits);
      double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 + pRange * 50/100,_Digits);
      double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 + pRange * 61.8/100,_Digits);
      double entryLvl = NormalizeDouble(PriceFibLvl0 + pRange * fibRetracLvl/100,_Digits);
      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Sell Entry Price: ",entryLvl);
     }
  }
//+------------------------------------------------------------------+

Diferencias en este código:

Aquí hemos añadido la propiedad #property script_show_inputs, que muestra la ventana con propiedades. Usando una variable de entrada, crearemos fibRetracLvl de tipo double, por ejemplo, con un valor predeterminado de 38.2.

#property script_show_inputs
input double fibRetracLvl = 38.2;

Luego determinaremos el nivel de entrada según el valor especificado por el usuario. En el caso de una tendencia alcista:

double entryLvl = NormalizeDouble(PriceFibLvl0 - pRange * fibRetracLvl/100,_Digits);

Definiremos un nivel de entrada basado en un valor personalizado si hay una tendencia bajista.

double entryLvl = NormalizeDouble(PriceFibLvl0 + pRange * fibRetracLvl/100,_Digits);

Comentario para Fibonacci alcista.

      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Buy Entry Price: ",entryLvl);

Comentario para Fibonacci bajista.

      Comment("Array Open: ",openCandle,"\n",
              "Array Close: ",closeCandle,"\n",
              "Sell Entry Price: ",entryLvl);

Luego compilaremos el código del asesor y este aparecerá en la ventana del navegador en el terminal, desde donde lo iniciaremos en el gráfico. A continuación le mostramos ejemplos de arrays alcistas y bajistas.

Array alcista:

Señal de Fibonacci 2 - alcista - diaria

En el gráfico de arriba, hemos dibujado los niveles de Fibonacci verdes de menor a mayor, y en el gráfico aparece un comentario con los siguientes valores:

  • Array open — valor de apertura en el array.
  • Array close — valor de cierre en el array.
  • Buy entry price — precio para entrar en una posición de compra en Fibonacci 38.2.

En el caso de un array bajista:

Señal de Fibonacci 2 - bajista

En el gráfico tenemos niveles de Fibonacci rojos de máximo a mínimo, además de un comentario con los siguientes valores:

  • Array open — valor de apertura en el array.
  • Array close — valor de cierre en el array.
  • Sell entry price — precio para entrar en una operación de venta en el nivel Fibonacci 38.2.


Conclusión

Bien, hoy hemos aprendido cómo crear un sistema comercial simple basado en los niveles de Fibonacci usando MQL5. Este sistema comercial se ha diseñado para operar en el terminal comercial MetaTrader 5. Antes de crear las estrategias, hemos examinado con detalle el instrumento técnico de Fibonacci y aprendido a usarlo en MetaTrader 5.

Además, hemos presentado dos enfoques para generar los niveles de Fibonacci, uno usando los datos diarios y el otro usando un array de velas japonesas en cualquier marco temporal para generar niveles de entrada de compra o venta basados ​​en los niveles de Fibonacci. Como en todos los artículos anteriores, insistimos en la gran importancia de poner a prueba cuidadosamente todos los nuevos conocimientos antes de aplicarlos a una cuenta real, para asegurarse así de que se adaptan a su estilo y comprensión del trading. Al fin y al cabo, lo que funciona para otros no tiene por qué funcionar para usted. Además, no olvides que el objetivo principal de las estrategias es ilustrativo.

Esperamos que este artículo lo ayude a mejorar un poco su comercio y le ofrezca nuevas ideas. ¡Le deseo un comercio rentable! Si le ha gustado este artículo y le ha resultado útil, lea los artículos anteriores de la misma serie para aprender a desarrollar sistemas comerciales basados en diferentes indicadores técnicos populares. Ya hemos analizado Stochastic, RSI, Bollinger Bands, Moving Averages, Envelopes, MACD, ADX y otros indicadores.

Traducción del inglés realizada por MetaQuotes Ltd.
Artículo original: https://www.mql5.com/en/articles/12301

Archivos adjuntos |
Descargar ZIP
Simple_Fibo_System.mq5 (3.56 KB)
Fibo_Signals.mq5 (3.37 KB)
Simple_Fibo_System_2.mq5 (4.06 KB)
Fibo_Signals_2.mq5 (3.79 KB)
Advertencia: todos los derechos de estos materiales pertenecen a MetaQuotes Ltd. Queda totalmente prohibido el copiado total o parcial.

Otros artículos del autor

Pasar a la discusión en el foro de los operadores
Indicadores basados ​​en la clase CCanvas: Rellenando canales con transparencia Indicadores basados ​​en la clase CCanvas: Rellenando canales con transparencia
En este artículo, analizaremos métodos utilizados para crear indicadores personalizados que se dibujan con la ayuda de la clase CCanvas de la Biblioteca estándar, y también consideraremos las propiedades de los gráficos para transformar coordenadas. Prestaremos especial atención a los indicadores que rellenan de transparencia el área entre las dos líneas.
Desarrollo de un sistema de repetición — Simulación de mercado (Parte 04): Haciendo ajustes (II) Desarrollo de un sistema de repetición — Simulación de mercado (Parte 04): Haciendo ajustes (II)
Vamos continuar con el desarrollo del sistema y el control. Sin una forma de controlar el servicio, se complica avanzar y mejorar el sistema.
Desarrollo de un sistema de repetición — Simulación de mercado (Parte 05): Vistas previas Desarrollo de un sistema de repetición — Simulación de mercado (Parte 05): Vistas previas
Hemos logrado desarrollar una forma de ejecutar la repetición de mercado de manera bastante realista y aceptable. Ahora, vamos a continuar con nuestro proyecto y agregar datos para mejorar el comportamiento de la repetición.
Algoritmos de optimización de la población: Algoritmo de siembra y crecimiento de árboles (Saplings Sowing and Growing up — SSG) Algoritmos de optimización de la población: Algoritmo de siembra y crecimiento de árboles (Saplings Sowing and Growing up — SSG)
El algoritmo de siembra y crecimiento de árboles (SSG) está inspirado en uno de los organismos más resistentes del planeta, que es un ejemplo notable de supervivencia en una amplia variedad de condiciones.