中文 ZH
在 GitHub 上查看

Pipso Range Reversal 策略

该策略是将 MQL5 平台上的 Pipso 智能交易系统移植到 StockSharp。它是一种均值回归模型：在最近高点区间被上破时做空，在最近低点区间被下破时做多，并通过可配置的交易时段过滤信号。

核心思想

  • 基于最近 LookbackPeriod 根已收盘 K 线的最高价和最低价构建 Donchian 风格通道（默认长度 36）。
  • 监控上轨以在向上突破时反向做空，监控下轨以在向下突破时反向做多。
  • 只有当当前 K 线的开始时间处于 StartHour 与 EndHour 定义的交易窗口内时才允许开仓。

交易逻辑

入场条件

  • 做空：当 K 线最高价触及或超过上一周期通道的上轨时，先平掉多头仓位，然后（若交易窗口有效）按市价卖出 OrderVolume 数量。模型将通道上轨视为入场参考价。
  • 做多：当 K 线最低价触及或跌破上一周期通道的下轨时，先平掉空头仓位，然后（若允许交易）按市价买入 OrderVolume 数量，并把通道下轨作为入场参考价。

出场条件

  • 当价格碰到通道的另一侧时立即平仓，这一点完全继承了原版 EA 的处理方式。
  • 同时设置固定距离的保护性止损，距离计算公式为 (channelHigh - channelLow) * (1 + StopRangePercent / 100)；默认 StopRangePercent = 300，因此止损距离等于通道宽度的四倍。
  • 止损根据 K 线极值进行判断：多头在最低价跌破止损时离场，空头在最高价突破止损时离场。

交易时段过滤

  • StartHour 与 EndHour 以交易所时间的小时数表示。如果 StartHour < EndHour，策略只在同一天的该时间区间内交易；如果 StartHour > EndHour，窗口跨越午夜，可用于夜盘（例如 21 点至次日 9 点）。
  • 当两个值相同（StartHour == EndHour）时，策略不会开仓。

参数说明

  • OrderVolume（默认 0.1）— 每次下单的交易数量。
  • LookbackPeriod（默认 36）— 计算通道所用的 K 线数量。
  • StartHour（默认 21）— 交易窗口的开始小时（0–23）。
  • EndHour（默认 9）— 交易窗口的结束小时（0–23）。
  • StopRangePercent（默认 300）— 在通道宽度基础上额外增加的百分比，用于计算止损距离。
  • CandleType（默认 1 小时 K）— 用于运算的时间周期。

指标与数据

  • 使用 StockSharp 提供的 Highest 和 Lowest 指标跟踪通道上下轨。
  • 适用于任何能够提供所选 CandleType 周期连续 K 线数据的交易品种。
  • 原始 EA 依赖图表周期进行决策，可通过调整 CandleType 重现相同环境。

备注

  • 策略基于已收盘 K 线执行逻辑，以减少噪声；实时行情中，入场与止损价格近似于 MQL5 版本在逐笔数据上的表现。
  • 没有设置固定止盈，盈利来自价格回到通道另一侧或由止损保护。
  • 建议根据品种波动性调节交易时段、通道长度和止损倍数。
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>
/// Range-reversal strategy translated from the Pipso MQL5 expert advisor.
/// The system fades breakouts of the recent high/low range during a configurable trading session.
/// </summary>
public class PipsoStrategy : Strategy
{
	private readonly StrategyParam<decimal> _orderVolume;
	private readonly StrategyParam<int> _lookbackPeriod;
	private readonly StrategyParam<int> _startHour;
	private readonly StrategyParam<int> _endHour;
	private readonly StrategyParam<decimal> _stopRangePercent;
	private readonly StrategyParam<DataType> _candleType;

	private Highest _highest = null!;
	private Lowest _lowest = null!;
	private decimal _previousHighest;
	private decimal _previousLowest;
	private bool _isChannelInitialized;

	private decimal? _entryPrice;
	private decimal? _stopPrice;
	private Sides? _entrySide;

	/// <summary>
	/// Trade volume expressed in lots or contracts.
	/// </summary>
	public decimal OrderVolume
	{
		get => _orderVolume.Value;
		set => _orderVolume.Value = value;
	}

	/// <summary>
	/// Number of candles used to compute the high/low channel.
	/// </summary>
	public int LookbackPeriod
	{
		get => _lookbackPeriod.Value;
		set => _lookbackPeriod.Value = value;
	}

	/// <summary>
	/// Hour when the strategy is allowed to start trading.
	/// </summary>
	public int StartHour
	{
		get => _startHour.Value;
		set => _startHour.Value = value;
	}

	/// <summary>
	/// Hour when trading should stop.
	/// </summary>
	public int EndHour
	{
		get => _endHour.Value;
		set => _endHour.Value = value;
	}

	/// <summary>
	/// Multiplier applied to the channel width to compute the stop distance.
	/// </summary>
	public decimal StopRangePercent
	{
		get => _stopRangePercent.Value;
		set => _stopRangePercent.Value = value;
	}

	/// <summary>
	/// Candle type used for calculations.
	/// </summary>
	public DataType CandleType
	{
		get => _candleType.Value;
		set => _candleType.Value = value;
	}

	/// <summary>
	/// Initializes strategy parameters.
	/// </summary>
	public PipsoStrategy()
	{
		_orderVolume = Param(nameof(OrderVolume), 1m)
			.SetGreaterThanZero()
			.SetDisplay("Volume", "Order volume per trade", "General");

		_lookbackPeriod = Param(nameof(LookbackPeriod), 36)
			.SetGreaterThanZero()
			.SetDisplay("Lookback Period", "Number of candles used for high/low extremes", "Channel");

		_startHour = Param(nameof(StartHour), 21)
			.SetDisplay("Start Hour", "Session start hour (0-23)", "Session");

		_endHour = Param(nameof(EndHour), 9)
			.SetDisplay("End Hour", "Session end hour (0-23)", "Session");

		_stopRangePercent = Param(nameof(StopRangePercent), 300m)
			.SetGreaterThanZero()
			.SetDisplay("Stop Range %", "Extra percentage of the channel width for stop distance", "Risk");

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

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

	/// <inheritdoc />
	protected override void OnReseted()
	{
		base.OnReseted();
		_previousHighest = 0m;
		_previousLowest = 0m;
		_isChannelInitialized = false;
		ResetTradeState();
	}

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

		Volume = OrderVolume;

		_highest = new Highest { Length = LookbackPeriod };
		_lowest = new Lowest { Length = LookbackPeriod };

		var subscription = SubscribeCandles(CandleType);
		subscription
			.Bind(_highest, _lowest, ProcessCandle)
			.Start();
	}

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

		if (!_highest.IsFormed || !_lowest.IsFormed)
		{
			_previousHighest = highestValue;
			_previousLowest = lowestValue;
			return;
		}

		if (!_isChannelInitialized)
		{
			_previousHighest = highestValue;
			_previousLowest = lowestValue;
			_isChannelInitialized = true;
			return;
		}

		// Indicators are bound via .Bind, no need for IsFormedAndOnlineAndAllowTrading.

		var channelHigh = _previousHighest;
		var channelLow = _previousLowest;

		ManageStopLoss(candle);

		var channelRange = channelHigh - channelLow;
		var breakoutHigh = candle.HighPrice >= channelHigh && channelRange > 0m;
		var breakoutLow = candle.LowPrice <= channelLow && channelRange > 0m;
		var canTrade = IsWithinTradingWindow(candle.OpenTime);

		if (breakoutHigh && Position > 0)
		{
			SellMarket();
			ResetTradeState();
		}

		if (breakoutLow && Position < 0)
		{
			BuyMarket();
			ResetTradeState();
		}

		if (channelRange > 0m)
		{
			var stopDistance = channelRange * (1m + StopRangePercent / 100m);

			if (breakoutHigh && Position == 0 && canTrade)
			{
				SellMarket();
				_entrySide = Sides.Sell;
				_entryPrice = channelHigh;
				_stopPrice = _entryPrice + stopDistance;
			}
			else if (breakoutLow && Position == 0 && canTrade)
			{
				BuyMarket();
				_entrySide = Sides.Buy;
				_entryPrice = channelLow;
				_stopPrice = _entryPrice - stopDistance;
			}
		}

		if (Position == 0)
			ResetTradeState();

		_previousHighest = highestValue;
		_previousLowest = lowestValue;
	}

	private void ManageStopLoss(ICandleMessage candle)
	{
		if (_entrySide is null || _stopPrice is null)
			return;

		if (_entrySide == Sides.Buy)
		{
			if (Position <= 0)
			{
				ResetTradeState();
				return;
			}

			if (candle.LowPrice <= _stopPrice.Value)
			{
				SellMarket();
				ResetTradeState();
			}
		}
		else if (_entrySide == Sides.Sell)
		{
			if (Position >= 0)
			{
				ResetTradeState();
				return;
			}

			if (candle.HighPrice >= _stopPrice.Value)
			{
				BuyMarket();
				ResetTradeState();
			}
		}
	}

	private bool IsWithinTradingWindow(DateTimeOffset time)
	{
		var normalizedStart = ((StartHour % 24) + 24) % 24;
		var normalizedEnd = ((EndHour % 24) + 24) % 24;

		if (normalizedStart == normalizedEnd)
			return false;

		var start = new TimeSpan(normalizedStart, 0, 0);
		var end = new TimeSpan(normalizedEnd, 0, 0);
		var current = time.TimeOfDay;

		return normalizedStart < normalizedEnd
			? current >= start && current <= end
			: current >= start || current <= end;
	}

	private void ResetTradeState()
	{
		_entryPrice = null;
		_stopPrice = null;
		_entrySide = null;
	}
}