English Русский Deutsch 日本語
preview
Desarrollo de un kit de herramientas para el análisis de la acción del precio (Parte 44): Desarrollo de un EA basado en señales de cruce de VWMA en MQL5

Desarrollo de un kit de herramientas para el análisis de la acción del precio (Parte 44): Desarrollo de un EA basado en señales de cruce de VWMA en MQL5

MetaTrader 5 — Ejemplos |
31 4
Christian Benjamin
Christian Benjamin

Introducción

El éxito en el trading depende de la capacidad de distinguir las tendencias significativas de los precios del ruido del mercado. Durante décadas, las medias móviles, como la media móvil simple (SMA) y la media móvil exponencial (EMA), han ayudado a los operadores a suavizar la volatilidad y a aclarar la dirección del mercado. Sin embargo, estos indicadores tradicionales pasan por alto un componente esencial de la evolución de los precios: el volumen de negociación, que a menudo determina la verdadera importancia de una tendencia.

La evolución de la media móvil ponderada por volumen (VWMA) ha solucionado esta limitación al otorgar mayor importancia a los precios asociados a una mayor actividad de negociación. Como resultado, la VWMA ofrece una indicación más clara y fiable del verdadero impulso del mercado y ayuda a los operadores a diferenciar entre movimientos fuertes, respaldados por el volumen, y fluctuaciones débiles, con escasa participación.

Este artículo analiza la aplicación práctica de los cruces de la media móvil ponderada por volumen (VWMA) en el trading algorítmico. En él se presentará el enfoque basado en la VWMA, se explicará su implementación en MQL5, se expondrán los resultados de las pruebas y se resumirán las conclusiones clave tanto para los operadores discrecionales como para los operadores sistemáticos.

Partiendo de estos principios, el asesor experto (EA) de cruces de VWMA incorpora una estrategia de cruces de VWMA combinada con un panel informativo intuitivo integrado en el gráfico. Diseñada para ofrecer claridad y facilidad de uso en cualquier fondo de gráfico, esta herramienta detecta automáticamente los cruces, resalta las señales que permiten actuar y envía alertas oportunas, lo que agiliza tanto la ejecución de operaciones como el seguimiento del mercado.

El siguiente índice resume las secciones de este artículo, cada una de las cuales se analizará en detalle a continuación:


Comprender el concepto de la media móvil ponderada por volumen (VWMA)

A diferencia de muchos indicadores vinculados a un creador conocido, la VWMA surgió de forma orgánica en la comunidad del análisis técnico, a medida que los profesionales buscaban ponderar las medias en función del volumen real del mercado. Se basa en la larga tradición de las medias móviles (que se remonta a las primeras técnicas de suavización de principios del siglo XX) y toma prestadas prácticas institucionales relacionadas con el VWAP, que cuenta con una atribución histórica más clara.

A continuación se enumeran algunas ventajas de la media móvil ponderada por volumen (VWMA) frente a la media móvil simple (SMA) y la media móvil exponencial (EMA)

Ventaja Explicación
Consideración del volumen La VWMA refleja dónde se produjeron la mayoría de las operaciones, no solo dónde variaron los precios.
Mejor confirmación de la tendencia Confirma giros de tendencia o continuaciones genuinos respaldados por el volumen.
Capacidad de respuesta adaptativa Reacciona a los movimientos del mercado con un volumen elevado, al tiempo que filtra el ruido asociado a los movimientos con poco volumen.
Detecta la fuerza de los inversores institucionales Resulta útil para identificar la acumulación o distribución del «dinero inteligente».
La media móvil ponderada por volumen (VWMA) es un indicador técnico que tiene en cuenta tanto el precio como el volumen de negociación para ofrecer una visión más completa de las tendencias del mercado. A diferencia de las medias móviles tradicionales, que solo tienen en cuenta el precio, la VWMA otorga mayor peso a los periodos con mayor actividad de negociación. Se calcula sumando los productos del precio de cierre de cada vela por su volumen correspondiente y dividiendo luego este total entre la suma de los volúmenes del mismo periodo.


Fórmula de la VWMA:

Donde:

  • 𝑃(𝑖) = precio de la vela i (normalmente, el precio de cierre)
  • 𝑉(𝑖) = volumen de negociación de la vela i
  • 𝑛 = número de períodos (por ejemplo, 20)

Supongamos que queremos calcular una media móvil ponderada por volumen (VWMA) de 5 períodos utilizando los siguientes datos:

Vela Precio de cierre Volumen
1 10 100
2 11 200
3 12 150
4 13 300
5 14 250

Ahora calcula:

  • Multiplica cada precio por su volumen:

(10×100) + (11×200) + (12×150) + (13 × 300) + (14 × 250) = 1 000 + 2 200 + 1 800 + 3 900 + 3 500 = 12 400

  • Suma todos los volúmenes:

100 + 200 + 150 + 300 + 250 = 1000

  • Divide el total de (precio × volumen) entre el volumen total:

VWMA = 12 400/1 000 = 12,4

Por lo tanto, para 5 períodos, VWMA = 12,4.

  1. Cuando el precio es superior a la media móvil ponderada por volumen (VWMA), el mercado suele encontrarse en una tendencia alcista respaldada por el volumen.
  2. Cuando el precio es inferior a la media móvil ponderada por volumen (VWMA), esto indica una tendencia bajista respaldada por el volumen.
  3. Una media móvil ponderada por volumen (VWMA) plana o lateral indica una participación débil o una negociación en rango.

A continuación se muestra un fragmento de código conciso que ilustra cómo calcular manualmente la media móvil ponderada por volumen (VWMA) en un asesor experto o indicador de MQL5:

double VWMA(const string symbol, ENUM_TIMEFRAMES timeframe, int period, int shift)
{
   if(period <= 0) return EMPTY_VALUE;
   MqlRates rates[];
   if(CopyRates(symbol, timeframe, shift, period, rates) != period)
      return EMPTY_VALUE;
   double sumPriceVolume = 0, sumVolume = 0;
   for(int i = 0; i < period; i++)
   {
      sumPriceVolume += rates[i].close * rates[i].tick_volume;
      sumVolume += rates[i].tick_volume;
   }
   return (sumVolume == 0) ? EMPTY_VALUE : sumPriceVolume / sumVolume;
}

En este desarrollo, utilizamos tanto una media móvil ponderada por volumen (VWMA) rápida como una lenta para captar las tendencias del mercado a corto y largo plazo, respectivamente.

VWMA rápida

  • Tiene un período más corto (por ejemplo, 10 o 20 barras).
  • Reacciona rápidamente a los cambios recientes en los precios y el volumen.
  • Más sensible a las fluctuaciones del mercado a corto plazo.
  • Resulta útil para detectar tendencias a corto plazo, el impulso o posibles puntos de entrada o salida.

VWMA lenta

  • Tiene un período más largo (por ejemplo, 50 o 60 barras).
  • Reacciona con mayor lentitud a los cambios recientes en los precios y el volumen.
  • Suaviza las pequeñas fluctuaciones y se centra en la tendencia general.
  • Resulta útil para identificar la dirección general del mercado o para filtrar el ruido.

La lógica para generar señales de negociación en este EA se asemeja mucho a la de las estrategias estándar de cruce de medias móviles (MA), en las que se generan señales de compra o venta cuando la VWMA rápida cruza por encima o por debajo de la VWMA lenta.

Señal bajista

Cruce bajista

Las señales de venta se generan cuando la VWMA rápida cruza por debajo de la VWMA lenta.

En concreto, las condiciones para una señal de venta son las siguientes:

  • En la barra anterior, la VWMA rápida se situaba por encima de la VWMA lenta.
  • En la barra actual, la VWMA rápida se ha situado por debajo de la VWMA lenta.

Este «cruce bajista» indica un posible cambio de un impulso alcista a uno bajista, lo que sugiere que podría ser un buen momento para vender.

bool bear = (f_prev > s_prev) && (f_now < s_now);
if(bear /* && other filters */) {
   // Generate sell signal
}

Señal alcista

Las señales de compra (alcistas) se generan cuando la VWMA rápida cruza por encima de la VWMA lenta.

En concreto, las condiciones para una señal de compra son las siguientes:

  • En la barra anterior, la VWMA rápida se encontraba por debajo de la VWMA lenta.
  • En la barra actual, la VWMA rápida se ha situado por encima de la VWMA lenta.

Este «cruce alcista» sugiere un posible cambio de un impulso bajista a uno alcista, lo que indica que podría ser un buen momento para comprar.

bool bull = (f_prev < s_prev) && (f_now > s_now);
if(bull /* && other filters */) {
   // Generate buy signal
}

Ten en cuenta que la media móvil ponderada por volumen (VWMA) no está disponible como indicador estándar integrado en MetaTrader 5. Para utilizar la VWMA en tu EA o indicador, debes implementar el cálculo manualmente utilizando la fórmula presentada anteriormente.


Implementación en MQL5

Para empezar a desarrollar en MQL5, primero asegúrate de tener MetaTrader 5 instalado en tu ordenador. MetaEditor, que es el entorno oficial para escribir y editar código MQL5, se incluye de serie en todas las instalaciones de MetaTrader 5, por lo que no es necesario instalarlo por separado. Una vez que MetaTrader 5 esté listo, abre MetaEditor, ya sea desde el propio terminal de MetaTrader 5 (haciendo clic en el icono de MetaEditor o pulsando F4) o directamente desde el menú de aplicaciones. En MetaEditor, ve a «Archivo» > «Nuevo», selecciona «Asesor experto (plantilla)» y asigna un nombre a tu EA. Una vez completados estos pasos, estarás listo para seguir las instrucciones detalladas que te proporcionaré a continuación para crear tu propio asesor experto de MQL5 desde cero.

1. Encabezado del archivo y metadatos

//+------------------------------------------------------------------+
//|                                             VWMA CROSSOVER EA.mq5|
//|                               Copyright 2025, Christian Benjamin.|
//|                           https://www.mql5.com/en/users/lynnchris|
//+------------------------------------------------------------------+
#property copyright "https://www.mql5.com/en/users/lynnchris"
#property version   "1.0"
#property strict

Las primeras líneas del archivo fuente contienen tres directivas #property que describen el programa al terminal de MetaTrader 5. La URL de derechos de autor indica la autoría, mientras que la cadena de versión proporciona un número de versión oficial que aparecerá posteriormente en el Navegador del terminal. Por último, #property strict obliga al compilador a aplicar las reglas más recientes del lenguaje. Programar en modo estricto evita muchos atajos heredados, detecta conversiones de tipos ambiguas y, por lo tanto, hace que el código sea más robusto.

2. Parámetros de entrada externos

input ENUM_TIMEFRAMES InpTimeframe = PERIOD_CURRENT;
input uint   FastPeriod  = 20;
input uint   SlowPeriod  = 60;
input uint   SR_LookBack = 50;
input double SR_OffsetPips = 3.0;

input bool   Draw_Arrows = true;
input bool   Send_Alerts = true;
input bool   Show_VWMA_Lines = true;
input int    PlotDepth = 500;

Inmediatamente después del encabezado vienen las variables de entrada: los parámetros públicos que el usuario verá en el cuadro de diálogo de configuración del EA. InpTimeframe define el marco temporal de trabajo; si se deja en PERIOD_CURRENT, el EA simplemente adopta el marco temporal del gráfico en el que se está ejecutando. FastPeriod y SlowPeriod son las ventanas retrospectivas de las dos VWMA que se compararán posteriormente. El siguiente par de parámetros, SR_LookBack y SR_OffsetPips, controla el filtro ligero de soporte y resistencia: el EA analiza las últimas N barras en busca de valores extremos y solo permite una operación cuando el precio los ha rebasado al menos en el número de pips especificado por SR_OffsetPips. Tres indicadores booleanos permiten al operador decidir si desea dibujar flechas, enviar alertas o trazar las líneas de las medias móviles, mientras que PlotDepth limita el número de barras históricas que se muestran en el gráfico para mantener un tiempo de renderizado razonable.

3. Variables globales en tiempo de ejecución

datetime g_last_bar_time = 0;
int      g_last_signal = 0; // 1 = BUY, -1 = SELL, 0 = none
datetime g_last_signal_time = 0;
string   DASH_BASE = "VWMA_DASH_";

Cuatro variables globales conservan el estado del asesor experto (EA) entre ticks. g_last_bar_time almacena la hora de apertura de la vela que ya se ha procesado, de modo que la lógica solo se ejecute una vez por barra. g_last_signal y g_last_signal_time registran la dirección y la marca de tiempo de la alerta más reciente; el panel informativo reutiliza esta información. Por último, DASH_BASE es un prefijo textual que garantiza que cada objeto perteneciente al panel del gráfico tenga un nombre único y fácilmente identificable.

4. La rutina de cálculo de la VWMA

double VWMA(const string sym, ENUM_TIMEFRAMES tf, uint per, int shift)
  {
   if(per == 0)
      return EMPTY_VALUE;
   MqlRates r[];
   if(CopyRates(sym, tf, shift, per, r) != (int)per)
      return EMPTY_VALUE;
   double num = 0, den = 0;
   for(int i = 0; i < (int)per; i++)
     {
      double vol = (double)r[i].tick_volume;
      num += r[i].close * vol;
      den += vol;
     }
   return (den == 0) ? EMPTY_VALUE : num / den;
  }

La función `double VWMA(const string sym, ENUM_TIMEFRAMES tf, uint per, int shift)` constituye el núcleo matemático del programa. Empieza copiando del historial los datos de per velas mediante CopyRates, a partir de la barra situada shift barras antes de la actual. En un bucle sencillo, la función mantiene dos sumas acumuladas: num, la suma de los productos del precio de cierre por el volumen, y den, el volumen total. Al dividir la primera por la segunda se obtiene la media móvil ponderada por volumen canónica.

Si no se pueden obtener los datos de precios o si el denominador resulta ser cero, la función devuelve la constante EMPTY_VALUE de MetaTrader, que las rutinas posteriores tratan como un NaN.

5. Funciones auxiliares de soporte y resistencia

double HighestHigh(const string s, ENUM_TIMEFRAMES tf, uint lb)
  {
   if(lb == 0)
      return EMPTY_VALUE;
   double a[];
   if(CopyHigh(s, tf, 0, lb, a) != (int)lb)
      return EMPTY_VALUE;
   double m = a[0];
   for(uint i = 1; i < lb; i++)
      if(a[i] > m)
         m = a[i];
   return m;
  }

double LowestLow(const string s, ENUM_TIMEFRAMES tf, uint lb)
  {
   if(lb == 0)
      return EMPTY_VALUE;
   double a[];
   if(CopyLow(s, tf, 0, lb, a) != (int)lb)
      return EMPTY_VALUE;
   double m = a[0];
   for(uint i = 1; i < lb; i++)
      if(a[i] < m)
         m = a[i];
   return m;
  }

bool ValidateSR(bool buy, double bid, double ask, double& sup, double& res)
  {
   res = HighestHigh(_Symbol, InpTimeframe, SR_LookBack);
   sup = LowestLow(_Symbol, InpTimeframe, SR_LookBack);
   if(res == EMPTY_VALUE || sup == EMPTY_VALUE)
      return false;
   double off = SR_OffsetPips * _Point;
   return buy ? (bid >= sup + off) : (ask <= res - off);
  }

Dos breves funciones envolventes, HighestHigh y LowestLow, examinan las últimas N barras para encontrar el máximo más alto o el mínimo más bajo, respectivamente, leyendo los arrays de datos sin procesar obtenidos mediante CopyHigh y CopyLow. Sobre estas funciones se apoya ValidateSR, una función booleana que actúa como un filtro de operaciones rudimentario pero eficaz. En primer lugar, llama a las dos funciones envolventes para obtener el máximo reciente (res) y el mínimo reciente (sup). A continuación, suma o resta el desplazamiento en pips especificado por el usuario y, por último, comprueba si el precio de venta o el precio de compra actual ha rebasado esos niveles. En la práctica, esto evita que el EA compre directamente en un nivel de resistencia potencial o venda en un nivel de soporte potencial.

6. Utilidades de gestión de objetos

//+------------------------------------------------------------------+
//| Chart Utilities                                                  |
//+------------------------------------------------------------------+
void SafeDeleteObject(const string name)
  {
   if(ObjectFind(0, name) != -1)
      ObjectDelete(0, name);
  }

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void PlotChartArrow(const string n, datetime t, double price, color clr, int code)
  {
   SafeDeleteObject(n);
   ObjectCreate(0, n, OBJ_ARROW, 0, t, price);
   ObjectSetInteger(0, n, OBJPROP_COLOR, clr);
   ObjectSetInteger(0, n, OBJPROP_ARROWCODE, code);
   ObjectSetInteger(0, n, OBJPROP_WIDTH, 2);
  }

SafeDeleteObject es una línea de código que comprueba primero si existe un objeto gráfico y lo elimina solo si está presente. Este método evita el exceso de entradas en el registro del terminal que se produciría, de otro modo, al intentar eliminar un objeto que ya se ha borrado. PlotChartArrow es una función auxiliar que crea un OBJ_ARROW con un estilo uniforme —color, código de flecha y ancho— en el instante y al precio indicados. Al centralizar las operaciones de eliminación y creación en estas dos funciones auxiliares, el resto del código puede centrarse en la lógica de negociación en lugar de en la gestión de los gráficos.

7. Trazado de polilíneas de medias móviles

void DrawLineVWMA(const string name, int period, color clr, int depth)
  {
   if(!Show_VWMA_Lines)
     {
      SafeDeleteObject(name);
      int total = ObjectsTotal(0);
      for(int i = total - 1; i >= 0; i--)
        {
         string nm = ObjectName(0, i);
         if(StringFind(nm, name + "_seg_") == 0)
            ObjectDelete(0, nm);
        }
      return;
     }
   const int extra = period + 2;
   MqlRates r[];
   if(CopyRates(_Symbol, InpTimeframe, 0, depth + extra, r) < depth + extra)
      return;
   int total = ObjectsTotal(0);
   for(int i = total - 1; i >= 0; i--)
     {
      string nm = ObjectName(0, i);
      if(StringFind(nm, name + "_seg_") == 0)
         ObjectDelete(0, nm);
     }
   for(int i = 0; i < depth - 1; i++)
     {
      double vw1 = VWMA(_Symbol, InpTimeframe, period, i);
      double vw2 = VWMA(_Symbol, InpTimeframe, period, i + 1);
      if(vw1 == EMPTY_VALUE || vw2 == EMPTY_VALUE)
         continue;
      datetime t1 = r[i].time;
      datetime t2 = r[i + 1].time;
      string seg = name + "_seg_" + IntegerToString(i);
      if(ObjectCreate(0, seg, OBJ_TREND, 0, t1, vw1, t2, vw2))
        {
         ObjectSetInteger(0, seg, OBJPROP_COLOR, clr);
         ObjectSetInteger(0, seg, OBJPROP_WIDTH, 1);
         ObjectSetInteger(0, seg, OBJPROP_RAY_RIGHT, false);
        }
     }
  }

En lugar de crear un indicador independiente con búferes, este asesor experto traza sus medias móviles ponderadas por volumen (VWMA) directamente en el gráfico mediante la función DrawLineVWMA, lo que permite una integración perfecta con la lógica del EA y garantiza que las medias móviles estén siempre sincronizadas con el gráfico y los parámetros. La función comienza comprobando la opción Show_VWMA_Lines; si el usuario desactiva el trazado de las líneas VWMA, realiza inmediatamente una limpieza exhaustiva eliminando todos los objetos utilizados para mostrar la VWMA, identificados por el prefijo de su nombre, y a continuación termina para mantener el gráfico despejado.

Si la opción de trazar líneas está activada, la función solicita un bloque de datos históricos de velas mediante CopyRates, recopilando suficientes barras (en función de la profundidad especificada por el usuario más algunas adicionales para garantizar la precisión del cálculo) para calcular la VWMA en todo el rango visible. Antes de trazar nuevas líneas, vuelve a recorrer todos los objetos del gráfico y elimina cualquier resto de segmentos antiguos de la VWMA, evitando así el desorden y los artefactos gráficos de ejecuciones anteriores. A continuación, la rutina principal de dibujo recorre cada par de barras consecutivas dentro de la profundidad especificada y, para cada par, calcula la VWMA en ambos extremos del segmento; si alguno de los valores de la VWMA no es válido (por ejemplo, por falta de datos), pasa al siguiente par. De lo contrario, crea una línea de tendencia corta de dos puntos (OBJ_TREND) que une estos dos valores de VWMA en sus respectivos momentos y precios, asigna un nombre único a cada segmento para facilitar su posterior eliminación y le aplica el color y el grosor elegidos, asegurándose de que las líneas no se extiendan más allá de sus extremos.

Al repetir este proceso con numerosos pares de barras, la función construye una línea VWMA visualmente continua; este enfoque segmentado resulta a la vez eficiente y eficaz, ya que minimiza el uso de memoria y garantiza actualizaciones rápidas incluso cuando se añaden nuevas barras o se modifican los parámetros. La función está diseñada para un mantenimiento automático fiable; cada vez que se invoca, elimina los segmentos obsoletos y traza otros nuevos basándose en los últimos cálculos de la VWMA, de modo que la representación visual está siempre actualizada y es precisa. En resumen, DrawLineVWMA ofrece un mecanismo práctico y sólido para superponer las VWMA en el gráfico como parte de la salida visual del EA, equilibrando la claridad, la eficiencia y el control del usuario, y elimina la necesidad de un archivo de indicador independiente o de búferes, al tiempo que ofrece al usuario la opción de activar o desactivar las líneas VWMA según desee, manteniendo el gráfico informativo y ordenado.

8. Construcción y mantenimiento del panel informativo

void UpdateDashboard(double fast_vwma, double slow_vwma)
  {
   int corner = 0, x = 12, y = 12;
   int panel_w = 320, panel_h = 130, pill_w = 120, pill_h = 36, gap_y = 12;
   int digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS);
   string prefix = DASH_BASE;
   // ... (creation and property setting for each rectangle and label)
   // See full code for all label/rectangle setup
   string sia = prefix + "SIGN_ARROW";
   if(ObjectFind(0, sia) == -1)
      ObjectCreate(0, sia, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, sia, OBJPROP_CORNER, corner);
   ObjectSetInteger(0, sia, OBJPROP_XDISTANCE, x + pill_w + 130);
   ObjectSetInteger(0, sia, OBJPROP_YDISTANCE, y + (pill_h + gap_y) * 2 + 10);
   ObjectSetInteger(0, sia, OBJPROP_FONTSIZE, 28);
   string txt = "";
   color arrclr = clrGray;
   if(g_last_signal == 1)
     {
      txt = "▲";
      arrclr = clrLime;
     }
   if(g_last_signal == -1)
     {
      txt = "▼";
      arrclr = clrRed;
     }
   ObjectSetInteger(0, sia, OBJPROP_COLOR, arrclr);
   ObjectSetString(0, sia, OBJPROP_TEXT, txt);
  }

UpdateDashboard crea un panel informativo compacto de tres filas en la esquina superior izquierda del gráfico. Un OBJ_RECTANGLE negro constituye el fondo; dentro de él, dos recuadros en forma de cápsula, codificados por colores, muestran los últimos valores de la VWMA rápida y la VWMA lenta, y otro recuadro más ancho situado debajo de ellos muestra la señal de negociación más reciente. Todos los rectángulos y etiquetas llevan un prefijo común, «DASH_BASE», lo que permite su eliminación masiva mediante la función «DeleteDashboardObjects» cuando se descarga el EA. La función selecciona dinámicamente el símbolo de la flecha, su color y la precisión numérica de las lecturas de la VWMA, lo que permite al operador obtener información de un solo vistazo sin tener que consultar las descripciones emergentes ni el registro de la pestaña «Expertos».

9. Ejecución de una señal de trading

void ExecuteSignal(bool buy, const string cmt)
  {
   g_last_signal = buy ? 1 : -1;
   g_last_signal_time = TimeCurrent();

   // Plot arrow
   if(Draw_Arrows)
     {
      string name = (buy ? "SIGNAL_BUY_" : "SIGNAL_SELL_") + (string)g_last_signal_time;
      color clr = buy ? clrLime : clrRed;
      int code = buy ? 233 : 234;
      double price = buy ? SymbolInfoDouble(_Symbol, SYMBOL_BID) : SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      PlotChartArrow(name, g_last_signal_time, price, clr, code);
     }
   // Alert
   if(Send_Alerts)
     {
      string msg = (buy ? "VWMA SIGNAL BUY " : "VWMA SIGNAL SELL ") + _Symbol + " | " + cmt;
      Alert(msg);
      PlaySound("alert.wav");
     }
   // Update dashboard
   double f = VWMA(_Symbol, InpTimeframe, FastPeriod, 0);
   double s = VWMA(_Symbol, InpTimeframe, SlowPeriod, 0);
   if(f != EMPTY_VALUE && s != EMPTY_VALUE)
      UpdateDashboard(f, s);
  }

Cuando la lógica de la estrategia determina que se ha producido una nueva señal de compra o venta, llama a la función ExecuteSignal, que gestiona todas las acciones relacionadas, salvo la ejecución de operaciones. En primer lugar, actualiza las variables globales para registrar el tipo y la hora de la última señal, lo que garantiza que otros componentes, como los paneles informativos, permanezcan sincronizados. Si se activa la opción de dibujar flechas, la función marca el gráfico en la ubicación de la señal con una flecha de color —verde lima para comprar y roja para vender—, lo que facilita la identificación visual de las señales. Si las alertas están activadas, la función también muestra un mensaje emergente y reproduce un sonido de notificación, lo que proporciona al usuario información inmediata sobre la señal y el símbolo. Por último, actualiza el panel informativo con los últimos valores de la VWMA, de modo que el resumen visual refleje el análisis de mercado más reciente. Es importante señalar que esta función solo genera y muestra señales; no ejecuta ninguna operación, lo que permite que el EA actúe como un generador de señales que podrá ampliarse en el futuro con funciones de negociación automatizada.

10. Manejadores de eventos del ciclo de vida

int OnInit()
  {
   Print("VWMA Crossover Dashboard (signal-only) loaded.");
   g_last_bar_time = 0;
   g_last_signal = 0;
   g_last_signal_time = 0;
   return(INIT_SUCCEEDED);
  }

void OnDeinit(const int reason)
  {
   SafeDeleteObject("VWMA_FAST");
   SafeDeleteObject("VWMA_SLOW");
   int total = ObjectsTotal(0);
   for(int i = total - 1; i >= 0; i--)
     {
      string nm = ObjectName(0, i);
      if(StringFind(nm, "SIGNAL_BUY_") == 0 || StringFind(nm, "SIGNAL_SELL_") == 0)
         ObjectDelete(0, nm);
      if(StringFind(nm, "VWMA_FAST_seg_") == 0 || StringFind(nm, "VWMA_SLOW_seg_") == 0)
         ObjectDelete(0, nm);
     }
   DeleteDashboardObjects();
  }

OnInit se ejecuta una vez cuando el EA se adjunta a un gráfico o se recompila. Pone a cero todas las variables de estado y muestra un mensaje de bienvenida en la consola para que el usuario pueda confirmar que la inicialización se ha realizado correctamente. OnDeinit realiza la tarea contraria: limpia el gráfico eliminando los objetos maestros individuales («VWMA_FAST», «VWMA_SLOW») y, a continuación, recorre todos los objetos restantes del gráfico, eliminando aquellos cuyo nombre comience por «SIGNAL_BUY_», «SIGNAL_SELL_» o los prefijos de segmento que utiliza la herramienta de dibujo de polilíneas. El panel informativo también se elimina para dejar el gráfico exactamente como estaba antes de cargar el EA.

11. El latido: OnTick

void OnTick()
  {
   // Update dashboard every tick
   double f_now_dash = VWMA(_Symbol, InpTimeframe, FastPeriod, 0);
   double s_now_dash = VWMA(_Symbol, InpTimeframe, SlowPeriod, 0);
   if(f_now_dash != EMPTY_VALUE && s_now_dash != EMPTY_VALUE)
      UpdateDashboard(f_now_dash, s_now_dash);

   datetime cur = iTime(_Symbol, InpTimeframe, 0);
   if(cur == g_last_bar_time)
     {
      DrawLineVWMA("VWMA_FAST", FastPeriod, clrDodgerBlue, PlotDepth);
      DrawLineVWMA("VWMA_SLOW", SlowPeriod, clrOrangeRed, PlotDepth);
      return;
     }
   g_last_bar_time = cur;

   double f_prev = VWMA(_Symbol, InpTimeframe, FastPeriod, 1);
   double s_prev = VWMA(_Symbol, InpTimeframe, SlowPeriod, 1);
   double f_now  = VWMA(_Symbol, InpTimeframe, FastPeriod, 0);
   double s_now  = VWMA(_Symbol, InpTimeframe, SlowPeriod, 0);
   if(f_prev == EMPTY_VALUE || s_prev == EMPTY_VALUE || f_now == EMPTY_VALUE || s_now == EMPTY_VALUE)
      return;

   bool bull = (f_prev < s_prev && f_now > s_now);
   bool bear = (f_prev > s_prev && f_now < s_now);

   double sup, res;
   if(bull && ValidateSR(true, SymbolInfoDouble(_Symbol, SYMBOL_BID), SymbolInfoDouble(_Symbol, SYMBOL_ASK), sup, res))
      ExecuteSignal(true, "VWMA BUY");
   if(bear && ValidateSR(false, SymbolInfoDouble(_Symbol, SYMBOL_BID), SymbolInfoDouble(_Symbol, SYMBOL_ASK), sup, res))
      ExecuteSignal(false, "VWMA SELL");

   DrawLineVWMA("VWMA_FAST", FastPeriod, clrDodgerBlue, PlotDepth);
   DrawLineVWMA("VWMA_SLOW", SlowPeriod, clrOrangeRed, PlotDepth);
  }

Cada tick de mercado recibido activa OnTick, pero la parte del algoritmo que requiere mayor esfuerzo computacional solo se ejecuta una vez por barra. La función comienza actualizando los valores del panel informativo en cada tick, de modo que las cifras se mantengan actualizadas en tiempo real. A continuación, comprueba si la hora de la vela actual, iTime(...,0), difiere de g_last_bar_time; si no es así, solo se vuelven a trazar las líneas de las medias móviles y la función finaliza rápidamente. Cuando se detecta una nueva barra, el EA obtiene los valores de la VWMA rápida y la VWMA lenta tanto para la vela anterior como para la actual. Se identifica un cruce alcista cuando la VWMA rápida pasa de situarse por debajo a situarse por encima de la VWMA lenta; la situación inversa da lugar a un cruce bajista. A continuación, cada operación prevista se procesa a través de ValidateSR; si supera la comprobación de nivel, se llama a ExecuteSignal. Independientemente de si se activa una señal, el método finaliza redibujando ambas polilíneas VWMA para que los elementos visuales permanezcan sincronizados con la vela recién formada.

Una vez que hayas terminado el código de tu EA de MQL5, haz clic en el botón «Compilar» de MetaEditor. Si no hay errores ni advertencias, tu EA está listo para ponerlo en funcionamiento y realizar pruebas. Para evaluar su rendimiento, abre MetaTrader 5, ve a la ventana «Navegador», despliega la sección «Asesores Expertos» y arrastra tu EA a un gráfico para probarlo en una cuenta real o demo. Como alternativa, puedes utilizar el probador de estrategias para realizar una prueba retrospectiva del comportamiento de tu EA con datos históricos.

Paso a paso:

  • Compila tu EA en MetaEditor pulsando el botón «Compilar».
  • Comprueba si hay errores y advertencias. Si no se ha notificado ninguno, el EA está listo.
  • Abre MetaTrader 5, ve al «Navegador» (que suele estar a la izquierda) y busca tu EA en «Expertos».
  • Arrastra y suelta el EA en un gráfico para ejecutarlo en tiempo real o en modo demo.
  • Para analizar el rendimiento histórico, abre el Probador de estrategias (pulsa Ctrl+R o utiliza el menú «Ver»), selecciona tu EA, elige los parámetros e inicia la prueba retrospectiva.


Resultados

A continuación se muestra una ilustración de los resultados de la prueba retrospectiva de nuestra herramienta. Se muestra un panel específico que se actualiza en tiempo real para mostrar los valores actuales de la VWMA rápida y la VWMA lenta a medida que llega cada nuevo tick. En el gráfico, las flechas verdes indican señales de compra, mientras que las rojas marcan señales de venta, lo que proporciona indicaciones visuales claras para cada evento de negociación. En general, observamos una serie de señales positivas, la mayoría de las cuales apuntan a oportunidades de negociación favorables. Aunque hay algunas señales erróneas, son relativamente escasas, lo que demuestra la eficacia potencial de la herramienta a la hora de filtrar el ruido del mercado e identificar tendencias reales.

Backtesting


Conclusión

En conclusión, aunque las medias móviles tradicionales, como la media móvil simple (SMA) y la media móvil exponencial (EMA), siguen siendo herramientas valiosas para el análisis técnico, se centran principalmente en los datos de precios y, en ocasiones, pueden pasar por alto la importancia del volumen de negociación en los movimientos del mercado. El asesor experto (EA) de cruce de VWMA complementa estos enfoques al integrar el volumen en sus cálculos, lo que ofrece una perspectiva más matizada de la acción del precio. Al hacer hincapié tanto en el precio como en el volumen, la herramienta ayuda a los operadores a identificar con mayor eficacia posibles giros de tendencia alcistas y bajistas, especialmente durante los periodos de mayor actividad en el mercado. Esta información adicional puede mejorar la toma de decisiones y aportar más contexto a las señales de trading, lo que convierte al asesor experto (EA) de cruce de VWMA en un complemento útil para el conjunto de herramientas analíticas de cualquier operador.

Lee mis otros artículos.

Nota: Este artículo y el asesor experto (EA) de cruce de VWMA se ofrecen con fines educativos, con el objetivo de ayudarte a profundizar en tu comprensión del análisis técnico y del trading basado en señales. El EA actúa como generador de señales; no ejecuta operaciones de forma automática, por lo que tú mantienes el control total sobre tus decisiones de trading. Te animamos a que pruebes la herramienta, realices pruebas retrospectivas exhaustivas y ajustes los parámetros de entrada para adaptarlos a tu estrategia personal y a tus preferencias de mercado. Utiliza las señales como un elemento valioso de tu análisis y valídalas siempre con tu propio criterio. Con unas pruebas minuciosas y una personalización bien pensada, esta herramienta puede convertirse en una valiosa incorporación a tu conjunto de herramientas de trading.

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

Archivos adjuntos |
Wilson Malinda
Wilson Malinda | 9 oct 2025 en 15:50
Acabo de probarlo y hace ya cinco días que no aparece la señal para el XAUSD. ¿Por qué no aparece la señal?
Christian Benjamin
Christian Benjamin | 9 oct 2025 en 16:53
Wilson Malinda #:
Acabo de probar esto y la señal lleva ya 5 días sin aparecer para el XAUSD. ¿Por qué no aparece la señal?
No te entiendo, ¿te refieres al backtesting o qué? Esta herramienta se ha publicado hoy mismo, así que, ¿cómo es posible que ya lleve cinco días?
smartchartfx
smartchartfx | 17 oct 2025 en 12:15
Una configuración interesante. Ese cruce de la media móvil ponderada de Volkswagen (VWMA) se ve claro. Me gusta cómo combinas el volumen con la confirmación de la tendencia, en lugar de basarte únicamente en el movimiento del precio. Tengo curiosidad por ver cómo se comporta en marcos temporales más cortos, sobre todo durante sesiones volátiles.
beetle2008
beetle2008 | 27 oct 2025 en 07:41
Me parece genial cómo has combinado las medias móviles ponderadas por volumen con la evolución del precio para detectar cambios de tendencia. El panel del gráfico tiene un aspecto muy limpio y es fácil de seguir. Hay mucho margen para experimentar con esta idea. Gracias por compartirla con todos.
Tablas en el paradigma MVC en MQL5: Columnas de tabla personalizables y ordenables Tablas en el paradigma MVC en MQL5: Columnas de tabla personalizables y ordenables
En este artículo implementaremos el ajuste del ancho de las columnas de una tabla mediante el cursor del ratón y la ordenación de la tabla según los datos de las columnas, y añadiremos una nueva clase para simplificar la creación de tablas a partir de cualquier conjunto de datos.
Modelos matemáticos en las estrategias de rejilla Modelos matemáticos en las estrategias de rejilla
En este artículo analizaremos la aplicación de las matemáticas a las estrategias de rejilla. Además, analizaremos los principios básicos de funcionamiento de la estrategia, así como sus ventajas e inconvenientes. Usted aprenderá a crear una rejilla de trading, a establecer los parámetros óptimos y a gestionar los riesgos de forma eficaz.
Redes neuronales en el trading: Percepción adaptativa de la dinámica del mercado (Codificador) Redes neuronales en el trading: Percepción adaptativa de la dinámica del mercado (Codificador)
En este artículo se presenta la arquitectura integral del codificador STE-FlowNet, que combina memoria de pila, procesamiento recurrente y un mecanismo de correlación para extraer dependencias ocultas del mercado. Se muestra cómo estos módulos se integran secuencialmente en una cadena de cálculo única, capaz de realizar un análisis multifacético de series temporales.
Superando las limitaciones del aprendizaje automático (Parte 6): Validación cruzada de memoria efectiva Superando las limitaciones del aprendizaje automático (Parte 6): Validación cruzada de memoria efectiva
En este análisis, comparamos el enfoque clásico de la validación cruzada de series temporales con alternativas modernas que cuestionan sus supuestos fundamentales. Así, pondremos de manifiesto los principales puntos ciegos del método tradicional, especialmente su incapacidad para tener en cuenta la evolución de las condiciones del mercado. Para subsanar estas carencias, presentamos la «validación cruzada de memoria efectiva» (EMCV), un enfoque que tiene en cuenta el ámbito de aplicación y que pone en tela de juicio la creencia arraigada de que disponer de más datos históricos siempre mejora el rendimiento.