A Estratégia Alexav SpeedUp M1 é uma versão direta do MetaTrader 4 consultor especialista "Alexav_SpeedUp_M1". Ele avalia os corpos das velas intradiárias concluídas e reage imediatamente às ordens de mercado sempre que o corpo da vela excede um limite configurável. Após uma entrada, a estratégia emula o gerenciamento de risco no estilo MetaTrader, anexando ordens de stop-loss, take-profit e trailing stop à posição aberta.
A conversão depende do StockSharp API de alto nível. As velas são consumidas por meio de SubscribeCandles, as informações de preço para rastreamento são recebidas dos dados de nível 1 e os pedidos de proteção são feitos com ajudantes padrão BuyStop, SellStop, BuyLimit e SellLimit. Não são necessários cálculos manuais de indicadores.
Geração de sinal
Cada vela finalizada no período configurado é inspecionada.
Quando a vela fecha acima de sua abertura em mais de Body Threshold, a estratégia abre (ou reverte para) uma posição longa no mercado.
Quando a vela fecha abaixo de sua abertura em mais do que o mesmo limite, a estratégia abre (ou reverte para) uma posição curta no mercado.
A exposição existente na direção oposta é fechada automaticamente aumentando o volume da ordem de mercado, reproduzindo fielmente o comportamento do consultor especialista original.
Gerenciamento de pedidos
Stop-loss inicial: Assim que o volume da posição aumenta, uma ordem de stop de proteção é registrada pelo preço de entrada menos (para posições compradas) ou mais (para posições vendidas) o número de pontos configurado.
Take Profit: Uma ordem com limite correspondente é colocada na direção da negociação na distância especificada por Take Profit (pontos).
Trailing stop: as atualizações de oferta/venda de nível 1 monitoram o lucro atual. Quando o lucro não realizado excede a distância de fuga, o stop de proteção é movido em direção ao preço, mantendo o gap configurado sem nunca recuar.
Todas as ordens de proteção são canceladas sempre que a posição retorna à estabilidade.
A conversão mantém a lógica intencionalmente simples: nenhum filtro, indicador ou controle de risco adicional é adicionado além do que estava presente na implementação do MQL.
Parâmetros
Nome
Descrição
Tamanho do lote
Volume base de negociação (em lotes) utilizado para cada ordem de mercado. Ao inverter uma posição existente, o volume necessário é adicionado automaticamente.
Take Profit (pontos)
Distância do preço de entrada ao nível de lucro medido em MetaTrader pontos (convertido usando a etapa de preço do título).
Parada inicial (pontos)
Distância do preço de entrada ao stop de proteção inicial expressa em pontos.
Trailing Stop (pontos)
A distância final é mantida após o preço se mover a favor da posição. Um valor zero desativa a lógica final.
Limiar Corporal
Diferença absoluta mínima entre o fechamento e a abertura da vela necessária para acionar uma nova negociação.
Tipo de vela
Série de velas (período de tempo) usada para avaliação de sinal. O padrão corresponde ao gráfico original de um minuto.
Notas de uso
Certifique-se de que a segurança forneça um PriceStep válido. Quando indisponível, a estratégia volta a interpretar as distâncias dos pontos como compensações de preços brutos.
A lógica de trailing stop requer dados de nível 1 (melhor oferta/venda). Quando apenas os dados da vela estão disponíveis, a funcionalidade de rastreamento permanece inativa.
A estratégia foi projetada para operação intradiária e reflete o comportamento de uma negociação por vela aplicado pelo especialista MQL original por meio de seus contadores internos.
using System;
using System.Collections.Generic;
using StockSharp.Algo.Indicators;
using StockSharp.Algo.Strategies;
using StockSharp.BusinessEntities;
using StockSharp.Messages;
namespace StockSharp.Samples.Strategies;
/// <summary>
/// Alexav SpeedUp M1 Body strategy.
/// Trades based on large candle body breakouts.
/// Buys after a large bullish candle, sells after a large bearish candle.
/// Uses ATR to define "large" body threshold.
/// </summary>
public class AlexavSpeedUpM1BodyBreakStrategy : Strategy
{
private readonly StrategyParam<int> _atrPeriod;
private readonly StrategyParam<decimal> _bodyMultiplier;
private readonly StrategyParam<DataType> _candleType;
public int AtrPeriod { get => _atrPeriod.Value; set => _atrPeriod.Value = value; }
public decimal BodyMultiplier { get => _bodyMultiplier.Value; set => _bodyMultiplier.Value = value; }
public DataType CandleType { get => _candleType.Value; set => _candleType.Value = value; }
public AlexavSpeedUpM1BodyBreakStrategy()
{
_atrPeriod = Param(nameof(AtrPeriod), 14)
.SetDisplay("ATR Period", "ATR period for body threshold", "Indicators");
_bodyMultiplier = Param(nameof(BodyMultiplier), 1.0m)
.SetDisplay("Body Multiplier", "Body must exceed ATR * multiplier", "Indicators");
_candleType = Param(nameof(CandleType), TimeSpan.FromHours(4).TimeFrame())
.SetDisplay("Candle Type", "Candle timeframe", "General");
}
/// <inheritdoc />
public override IEnumerable<(Security sec, DataType dt)> GetWorkingSecurities()
{
return [(Security, CandleType)];
}
/// <inheritdoc />
protected override void OnReseted()
{
base.OnReseted();
}
protected override void OnStarted2(DateTime time)
{
base.OnStarted2(time);
var atr = new AverageTrueRange { Length = AtrPeriod };
var subscription = SubscribeCandles(CandleType);
subscription
.Bind(atr, ProcessCandle)
.Start();
}
private void ProcessCandle(ICandleMessage candle, decimal atrValue)
{
if (candle.State != CandleStates.Finished)
return;
var body = candle.ClosePrice - candle.OpenPrice;
var absBody = Math.Abs(body);
var threshold = atrValue * BodyMultiplier;
if (absBody < threshold)
return;
// Large bullish candle - buy
if (body > 0 && Position <= 0)
{
if (Position < 0)
BuyMarket();
BuyMarket();
}
// Large bearish candle - sell
else if (body < 0 && Position >= 0)
{
if (Position > 0)
SellMarket();
SellMarket();
}
}
}
import clr
clr.AddReference("StockSharp.Messages")
clr.AddReference("StockSharp.Algo")
clr.AddReference("StockSharp.Algo.Indicators")
clr.AddReference("StockSharp.Algo.Strategies")
from System import TimeSpan, Math
from StockSharp.Messages import DataType, CandleStates
from StockSharp.Algo.Indicators import AverageTrueRange
from StockSharp.Algo.Strategies import Strategy
class alexav_speed_up_m1_body_break_strategy(Strategy):
"""Alexav SpeedUp M1 Body strategy.
Trades based on large candle body breakouts.
Buys after a large bullish candle, sells after a large bearish candle.
Uses ATR to define large body threshold."""
def __init__(self):
super(alexav_speed_up_m1_body_break_strategy, self).__init__()
self._atr_period = self.Param("AtrPeriod", 14) \
.SetDisplay("ATR Period", "ATR period for body threshold", "Indicators")
self._body_multiplier = self.Param("BodyMultiplier", 1.0) \
.SetDisplay("Body Multiplier", "Body must exceed ATR * multiplier", "Indicators")
self._candle_type = self.Param("CandleType", DataType.TimeFrame(TimeSpan.FromHours(4))) \
.SetDisplay("Candle Type", "Candle timeframe", "General")
@property
def CandleType(self):
return self._candle_type.Value
@CandleType.setter
def CandleType(self, value):
self._candle_type.Value = value
@property
def AtrPeriod(self):
return self._atr_period.Value
@property
def BodyMultiplier(self):
return self._body_multiplier.Value
def OnReseted(self):
super(alexav_speed_up_m1_body_break_strategy, self).OnReseted()
def OnStarted2(self, time):
super(alexav_speed_up_m1_body_break_strategy, self).OnStarted2(time)
atr = AverageTrueRange()
atr.Length = self.AtrPeriod
subscription = self.SubscribeCandles(self.CandleType)
subscription.Bind(atr, self._process_candle).Start()
def _process_candle(self, candle, atr_value):
if candle.State != CandleStates.Finished:
return
close = float(candle.ClosePrice)
open_price = float(candle.OpenPrice)
body = close - open_price
abs_body = abs(body)
atr_val = float(atr_value)
threshold = atr_val * float(self.BodyMultiplier)
if abs_body < threshold:
return
# Large bullish candle - buy
if body > 0 and self.Position <= 0:
if self.Position < 0:
self.BuyMarket()
self.BuyMarket()
# Large bearish candle - sell
elif body < 0 and self.Position >= 0:
if self.Position > 0:
self.SellMarket()
self.SellMarket()
def CreateClone(self):
return alexav_speed_up_m1_body_break_strategy()