Deutsch DE
Auf GitHub ansehen

Exp Highs Lows Signal-Strategie

Übersicht

Exp Highs Lows Signal ist ein direkter Port des MetaTrader 5-Expertenberaters Exp_HighsLowsSignal. Die Strategie stützt sich auf einen Musterdetektor, der nach einer konfigurierbaren Anzahl aufeinanderfolgender Kerzen sucht, die höhere Hochs und höhere Tiefs drucken (bullische Sequenz) oder niedrigere Hochs und niedrigere Tiefs (bärische Sequenz). Sobald eine Sequenz gefunden wird, verzögert die Strategie die Reaktion um die konfigurierte Anzahl geschlossener Balken, schließt jede entgegengesetzte Exposition und öffnet optional eine Position in der erkannten Richtung. Schutz-Stops werden in Preisschritten ausgedrückt, um das punktbasierte Money-Management des ursprünglichen Robots nachzubilden.

Strategielogik

Highs/Lows-Sequenzdetektor

  • Der Detektor bewertet jede abgeschlossene Kerze auf dem gewählten Zeitrahmen.
  • Ein bullisches Signal erfordert SequenceLength aufeinanderfolgende Vergleiche, bei denen sowohl das aktuelle Hoch als auch das aktuelle Tief strikt größer als die vorherige Kerze sind.
  • Ein bärisches Signal erfordert SequenceLength aufeinanderfolgende Vergleiche, bei denen sowohl das aktuelle Hoch als auch das aktuelle Tief strikt kleiner als die vorherige Kerze sind.
  • Signale werden eingereiht und nach SignalBarDelay geschlossenen Kerzen freigegeben, was der SignalBar-Einstellung der MQL-Implementierung entspricht.

Einstiegsregeln

  • Long-Eintritte
    • Ausgelöst, wenn eine bullische Sequenz aktiv wird und AllowLongEntry aktiviert ist.
    • Jede bestehende Short-Position wird zuerst geschlossen (wenn AllowShortExit wahr ist), dann wird eine Markt-Kauforder mit Volumen OrderVolume + |Position| gesendet, um Shorts zu decken und die gewünschte Long-Größe zu etablieren.
  • Short-Eintritte
    • Ausgelöst, wenn eine bärische Sequenz aktiv wird und AllowShortEntry aktiviert ist.
    • Jede bestehende Long-Position wird zuerst geschlossen (wenn AllowLongExit wahr ist), dann wird eine Markt-Verkaufsorder mit Volumen OrderVolume + |Position| gesendet, um Longs zu decken und die gewünschte Short-Größe zu etablieren.

Ausstiegsregeln

  • Eine bullische Sequenz fordert immer AllowShortExit an, um offene Shorts zu schließen.
  • Eine bärische Sequenz fordert immer AllowLongExit an, um offene Longs zu schließen.
  • Wenn das relevante Flag deaktiviert ist, bleibt die entgegengesetzte Exposition unberührt, sodass der Benutzer nur in einer Richtung handeln oder den Detektor im „Nur-Alerts"-Modus betreiben kann.

Risikomanagement

  • StopLossTicks und TakeProfitTicks repräsentieren Abstände in Preisschritten (Punkten). Ein Wert von 0 deaktiviert die entsprechende Schutzorder und reproduziert das Verhalten des ursprünglichen EA.
  • StartProtection konvertiert diese Abstände in absolute Preisoffsets, sodass alle Markteintritte automatisch passende Stop-Loss- und Take-Profit-Orders erhalten.

Parameter

  • OrderVolume – Basis-Ordervolumen bei einer neuen Trade-Eröffnung.
  • AllowLongEntry / AllowShortEntry – Schalter, die Long- oder Short-Eintritte bei ihren jeweiligen Signalen aktivieren.
  • AllowLongExit / AllowShortExit – Schalter, die der Strategie erlauben, entgegengesetzte Positionen zu schließen, wenn das Gegentrendssignal erscheint.
  • StopLossTicks / TakeProfitTicks – Schutzabstände in Preisschritten; auf 0 setzen zum Deaktivieren.
  • SequenceLength – Anzahl aufeinanderfolgender Vergleiche zur Qualifizierung einer bullischen oder bärischen Sequenz (entspricht HowManyCandles in MT5).
  • SignalBarDelay – Anzahl geschlossener Kerzen zum Warten vor dem Handeln auf ein Signal (entspricht dem SignalBar-Input).
  • CandleType – Zeitrahmen für den Highs/Lows-Detektor (Standard: 4-Stunden-Kerzen).

Zusätzliche Hinweise

  • Die Strategie speichert nur die minimale Menge an Kerzengeschichte, die für den Detektor benötigt wird, und hält das Verhalten identisch zum benutzerdefinierten MT5-Indikator.
  • Da alle Order-Verwaltung über StartProtection erfolgt, erhalten Backtests und Live-Trading automatisch passende Stop- und Take-Profit-Orders ohne zusätzlichen Code.
  • Deaktivieren Sie die entsprechenden Allow-Flags, um die Strategie in einen Richtungsfilter oder ein reines Signalisierungswerkzeug umzuwandeln.
  • Es ist keine Python-Übersetzung vorhanden; nur die C#-Version ist in diesem Paket verfügbar.
using System;
using System.Collections.Generic;

using Ecng.Common;

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

namespace StockSharp.Samples.Strategies;

/// <summary>
/// Highs Lows Signal strategy using EMA crossover.
/// Buys when fast EMA crosses above slow EMA, sells on reverse.
/// </summary>
public class ExpHighsLowsSignalStrategy : Strategy
{
	private readonly StrategyParam<int> _fastPeriod;
	private readonly StrategyParam<int> _slowPeriod;
	private readonly StrategyParam<int> _stopLossPoints;
	private readonly StrategyParam<int> _takeProfitPoints;

	private ExponentialMovingAverage _fast;
	private ExponentialMovingAverage _slow;

	private decimal _prevFast;
	private decimal _prevSlow;
	private decimal _entryPrice;
	private int _cooldown;

	public int FastPeriod { get => _fastPeriod.Value; set => _fastPeriod.Value = value; }
	public int SlowPeriod { get => _slowPeriod.Value; set => _slowPeriod.Value = value; }
	public int StopLossPoints { get => _stopLossPoints.Value; set => _stopLossPoints.Value = value; }
	public int TakeProfitPoints { get => _takeProfitPoints.Value; set => _takeProfitPoints.Value = value; }

	public ExpHighsLowsSignalStrategy()
	{
		_fastPeriod = Param(nameof(FastPeriod), 14).SetGreaterThanZero().SetDisplay("Fast Period", "Fast EMA period", "Indicator");
		_slowPeriod = Param(nameof(SlowPeriod), 50).SetGreaterThanZero().SetDisplay("Slow Period", "Slow EMA period", "Indicator");
		_stopLossPoints = Param(nameof(StopLossPoints), 200).SetNotNegative().SetDisplay("Stop Loss", "Stop-loss in price steps", "Risk");
		_takeProfitPoints = Param(nameof(TakeProfitPoints), 400).SetNotNegative().SetDisplay("Take Profit", "Take-profit in price steps", "Risk");
	}

	public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
	{
		yield return (Security, TimeSpan.FromMinutes(5).TimeFrame());
	}

	protected override void OnReseted()
	{
		base.OnReseted();
		_fast = null; _slow = null;
		_prevFast = 0; _prevSlow = 0; _entryPrice = 0; _cooldown = 0;
	}

	protected override void OnStarted2(DateTime time)
	{
		base.OnStarted2(time);
		_fast = new ExponentialMovingAverage { Length = FastPeriod };
		_slow = new ExponentialMovingAverage { Length = SlowPeriod };
		var subscription = SubscribeCandles(TimeSpan.FromMinutes(5).TimeFrame());
		subscription.Bind(_fast, _slow, ProcessCandle);
		subscription.Start();
	}

	private void ProcessCandle(ICandleMessage candle, decimal fastValue, decimal slowValue)
	{
		if (candle.State != CandleStates.Finished) return;
		if (!_fast.IsFormed || !_slow.IsFormed) { _prevFast = fastValue; _prevSlow = slowValue; return; }
		if (_cooldown > 0) { _cooldown--; _prevFast = fastValue; _prevSlow = slowValue; return; }

		var close = candle.ClosePrice;
		var step = Security?.PriceStep ?? 1m;

		if (Position > 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close <= _entryPrice - StopLossPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
			if (TakeProfitPoints > 0 && close >= _entryPrice + TakeProfitPoints * step) { SellMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
		}
		else if (Position < 0 && _entryPrice > 0)
		{
			if (StopLossPoints > 0 && close >= _entryPrice + StopLossPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
			if (TakeProfitPoints > 0 && close <= _entryPrice - TakeProfitPoints * step) { BuyMarket(); _entryPrice = 0; _cooldown = 100; _prevFast = fastValue; _prevSlow = slowValue; return; }
		}

		if (_prevFast <= _prevSlow && fastValue > slowValue && Position <= 0)
		{ if (Position < 0) BuyMarket(); BuyMarket(); _entryPrice = close; _cooldown = 100; }
		else if (_prevFast >= _prevSlow && fastValue < slowValue && Position >= 0)
		{ if (Position > 0) SellMarket(); SellMarket(); _entryPrice = close; _cooldown = 100; }

		_prevFast = fastValue; _prevSlow = slowValue;
	}
}