Español ES
Ver en GitHub

Estrategia de Cobertura en Cuadrícula Frank Ud

Descripción general

La Estrategia de Cobertura en Cuadrícula Frank Ud es un puerto directo del asesor experto MetaTrader "Frank Ud" a la API de alto nivel de StockSharp. El bot mantiene simultáneamente cestas largas y cortas en el mismo instrumento y luego realiza promediado estilo martingala cuando el precio se aleja contra la cesta activa. Todo el manejo de señales se realiza sobre actualizaciones de mejor bid/ask (Level 1), lo que hace que la estrategia sea adecuada para ejecución de baja latencia o backtesting tick a tick.

Lógica de negociación

  1. Cobertura inicial – cuando no hay posiciones abiertas, la estrategia abre inmediatamente una orden de compra y una de venta de mercado con el mismo volumen. Cada orden recibe un stop-loss y take-profit expresados en pips.
  2. Gestión de stop/take – mientras ambas cestas existen, se respetan sus niveles de protección. Cuando el precio alcanza un nivel de protección se cierra la cesta correspondiente.
  3. Gestión unilateral – cuando solo quedan posiciones de compra o solo de venta, la estrategia:
    • Calcula el precio de entrada promedio ponderado por volumen de la cesta activa.
    • Reasigna el take-profit común al precio promedio ± distancia configurada.
    • Elimina el stop-loss (el EA original se basa puramente en el take-profit a partir de este punto).
  4. Paso de martingala – si el precio se mueve contra la cesta activa en más del paso configurado, la estrategia duplica el multiplicador y abre una nueva orden de mercado. El método auxiliar AdjustVolume mantiene cada orden alineada con el paso de volumen, el mínimo y el máximo del instrumento.
  5. Reinicio del ciclo – una vez que todas las cestas están cerradas, el multiplicador se restablece a 1 y comienza un nuevo ciclo de cobertura.

Parámetros

  • TakeProfitPips – distancia entre el precio promedio de la cesta y el objetivo de take-profit colectivo (predeterminado 12 pips).
  • StopLossPips – distancia del stop de protección usada solo para las primeras órdenes de cobertura (predeterminado 12 pips).
  • StepPips – movimiento adverso requerido antes de añadir la siguiente orden de martingala (predeterminado 16 pips).
  • AutoLot – cuando es true, la estrategia usa LotSize; de lo contrario opera con el volumen mínimo del instrumento.
  • LotSize – tamaño de lote base personalizado usado junto con el multiplicador de martingala cuando AutoLot está activado.

Notas de implementación

  • La conversión usa la API de alto nivel Strategy: las suscripciones Level 1 impulsan la lógica, y el posicionamiento de órdenes se basa en los ayudantes BuyMarket/SellMarket.
  • El seguimiento de posición es interno: la estrategia almacena el precio de entrada y el volumen de cada orden de cesta para poder reproducir las reglas de promediado de MetaTrader originales.
  • El multiplicador (_multiplier) refleja la variable Coefficient del EA y se duplica después de cada orden adicional. Una vez que todas las operaciones están cerradas el multiplicador se reinicia a 1.
  • AdjustVolume emula la función MQL5 LotCheck ajustando los volúmenes solicitados al paso de negociación y a los límites del contrato permitidos.
  • La estrategia requiere una cuenta con habilitación de cobertura, ya que mantiene cestas largas y cortas simultáneamente, igual que el EA fuente.

Archivos

  • CS/FrankUdStrategy.cs – implementación principal de la estrategia con comentarios en inglés explicando cada bloque.
  • README.md – este documento.
  • README_ru.md – traducción al ruso.
  • README_zh.md – traducción al chino simplificado.
using System;
using System.Linq;
using System.Collections.Generic;

using Ecng.Common;
using Ecng.Collections;
using Ecng.Serialization;

using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Hedging grid strategy converted from the Frank Ud MetaTrader expert.
/// Opens a position and adds martingale entries when price moves against the trade.
/// Closes all on take profit from average price.
/// </summary>
public class FrankUdStrategy : Strategy
{
	private readonly StrategyParam<decimal> _takeProfit;
	private readonly StrategyParam<decimal> _stopLoss;
	private readonly StrategyParam<decimal> _stepDistance;
	private readonly StrategyParam<int> _maxEntries;
	private readonly StrategyParam<DataType> _candleType;

	private int _lastSignal;

	public decimal TakeProfit { get => _takeProfit.Value; set => _takeProfit.Value = value; }
	public decimal StopLoss { get => _stopLoss.Value; set => _stopLoss.Value = value; }
	public decimal StepDistance { get => _stepDistance.Value; set => _stepDistance.Value = value; }
	public int MaxEntries { get => _maxEntries.Value; set => _maxEntries.Value = value; }
	public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }

	public FrankUdStrategy()
	{
		_takeProfit = Param(nameof(TakeProfit), 5000m)
			.SetGreaterThanZero()
			.SetDisplay("Take Profit", "Take profit distance from avg price", "Risk");

		_stopLoss = Param(nameof(StopLoss), 5000m)
			.SetGreaterThanZero()
			.SetDisplay("Stop Loss", "Stop loss distance from avg price", "Risk");

		_stepDistance = Param(nameof(StepDistance), 300m)
			.SetGreaterThanZero()
			.SetDisplay("Step Distance", "Price distance for adding martingale entries", "Grid");

		_maxEntries = Param(nameof(MaxEntries), 1)
			.SetGreaterThanZero()
			.SetDisplay("Max Entries", "Maximum martingale entries", "Grid");

		_candleType = Param(nameof(CandleType), TimeSpan.FromHours(1).TimeFrame())
			.SetDisplay("Candle Type", "Candle type for calculations", "General");
	}

	/// <inheritdoc />
	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
		=> [(Security, CandleType)];

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_lastSignal = 0;
	}

	/// <inheritdoc />
	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);

		SubscribeCandles(CandleType)
			.Bind(ProcessCandle)
			.Start();

		StartProtection(
			new Unit(TakeProfit, UnitTypes.Absolute),
			new Unit(StopLoss, UnitTypes.Absolute));
	}

	private void ProcessCandle(ICandleMessage candle)
	{
		if (candle.State != CandleStates.Finished)
			return;

		var bodySize = (candle.ClosePrice - candle.OpenPrice).Abs();
		if (bodySize < StepDistance)
			return;

		var direction = candle.ClosePrice > candle.OpenPrice ? 1 : -1;
		if (direction == _lastSignal)
			return;

		if (direction > 0 && Position <= 0)
		{
			BuyMarket();
			_lastSignal = 1;
		}
		else if (direction < 0 && Position >= 0)
		{
			SellMarket();
			_lastSignal = -1;
		}
	}
}