Deutsch DE
Auf GitHub ansehen

Awesome-Osc-Trader-Strategie

Die Strategie repliziert den MetaTrader-Expert "Awesome Osc Trader", indem sie Bollinger-Bandbreite, einen Stochastic-Filter und eine normalisierte Awesome-Oscillator-Momentumprüfung kombiniert. Long-Trades werden eröffnet, wenn der Oszillator von einem negativen Extrem ansteigt, während Stochastic den überverkauften Bereich verlässt und die Marktvolatilität innerhalb einer konfigurierbaren Bandbreite bleibt. Shorts verlangen die gespiegelten Bedingungen. Ein konfigurierbares Handelsfenster beschränkt neue Orders auf bestimmte Stunden, und offene Positionen können bei Gegensignalen nur dann zwangsweise geschlossen werden, wenn der schwebende Gewinn zum gewählten Filter passt.

Einzelheiten

  • Einstiegskriterien:
    • Der Bollinger-Band-Spread, in Pips umgerechnet, muss zwischen BollingerSpreadLowerLimit und BollingerSpreadUpperLimit bleiben.
    • Die Stochastic-Hauptlinie liegt für Longs über StochLower oder für Shorts unter StochUpper.
    • Der normalisierte Awesome Oscillator hat mindestens vier aufeinanderfolgende Bars auf der Gegenseite von null gezeigt und dreht mit Stärke über AoStrengthLimit zurück in Richtung null.
    • Die aktuelle Zeit liegt innerhalb des durch EntryHour und OpenHours definierten Handelsfensters.
  • Long/Short: handelt beide Richtungen.
  • Ausstiegskriterien:
    • Optionaler früher Ausstieg, wenn ein Gegensignal erscheint oder der Oszillator null kreuzt, gesteuert durch CloseTrade und ProfitTypeClTrd.
    • Schutz-Stop-Loss-, Take-Profit- und Trailing-Stop-Distanzen in Pips.
  • Stops: fester Stop, Take-Profit und optionaler Trailing Stop, verwaltet über StartProtection.
  • Standardwerte:
    • BollingerPeriod = 20, BollingerSigma = 2
    • BollingerSpreadLowerLimit = 55, BollingerSpreadUpperLimit = 380
    • PeriodFast = 3, PeriodSlow = 32
    • AoStrengthLimit = 0.13
    • StochK = 8, StochD = 3, StochSlow = 3
    • StochLower = 18, StochUpper = 76
    • EntryHour = 0, OpenHours = 16
    • Lots = 0.01, TakeProfit = 200, StopLoss = 80, TrailingStop = 40
    • CloseTrade = true, ProfitTypeClTrd = 1 (nur profitable Positionen schließen)
  • Filter:
    • Kategorie: Momentum mit Volatilitätsfilter
    • Richtung: Long und Short
    • Indikatoren: Bollinger Bands, Stochastic Oscillator, Awesome Oscillator
    • Stops: Ja (fest und trailing)
    • Komplexität: Mittel
    • Zeitrahmen: Für H1 konzipiert, funktioniert aber mit jeder Kerzenserie
    • Saisonalität: Handelsstundenfenster
    • Neuronale Netze: Nein
    • Divergenz: Nein
    • Risikolevel: Moderat
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;

public class AwesomeOscTraderStrategy : 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 AwesomeOscTraderStrategy()
	{
		_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;
	}
}