Hoje eu executo uma estratégia de forma manual que estou estudando um forma de "robotizar" ela.

Durante o leilão de abertura, eu preciso ficar monitorando o preço onde o ativo, no caso o dolar, vai abrir. Dessa forma eu sei qual estratégia eu deverei usar no momento em que ele abrir.

Gostaria de saber se existe alguma forma de pegar esse "preço teórico" (antes da abertura oficial do mercado) através de algumação função da NTSL ?

Utilizando o OPEN eu pego somente no momento em que o mercado abre o primeiro candle e eu gostaria de pegar um pouco antes da abertura para já mostrar qual a estratégia deverá ser utilizada.

Obrigado

Estou tentando criar um indicador de tendência e preciso plotar a média móvel exponencial de 8 períodos do 15 minutos no gráfico de 5 minutos.

Óbvio que o próprio Profit já tem a ferramenta para fazer isso, mas como preciso utilizar um conjunto de médias móveis para serem utilizadas em vários tempos graficos (sem alterar as medias base do 15m), então preciso plotar com código.

Alguma ideia de como fazer isso?

Abs

Mas depois de atualizar, colocar a programação para ordens, e até funcionar, começou a dar erro de compilação de sintaxe.

Parser: O código deve começar com begin
Erro de Sintaxe

Segue o código: 

input
TakeProfitPontos(400); // Valor padrão de 400 pontos para o Take Profit
  StopLossPontos(200); // Valor padrão de 200 pontos para o Stop Loss
  cStopOffsetEmpontos(10);
bGestaoDeRiscoPelaEstrategia(true);
iHorarioInicioAberturaPosicao(0905);
iHorarioFimAberturaPosicao(1630);
iHorarioEncerramentoDaytrade(1645);

VAR
  xEma52,
  xVWAP,
  xOBV,
  xEma52OBV,
  xEma200OBV : float;
  xSelect     : integer;
  nStopPoints : float;
  nTargetPoints : float;
  nContracts : integer;
  bPosicionado: boolean;
  fPrecoStop, fPrecoAlvo, fPrecoStopOffset: float;
  bConfigurouRisco: boolean;

BEGIN
  nStopPoints := StopLossPontos;
  nTargetPoints := TakeProfitPontos;

  begin
    // Cálculo do OBV
    if Close > Close then
      xOBV := xOBV + QuantityVol(false)
    else if Close < Close then
      xOBV := xOBV - QuantityVol(false)
    else
      xOBV := xOBV;
  end;

  // Cálculo dos indicadores
  xEma52    := MediaExp(52, Close);
  xVWAP     := VWAP(1);
  xEma52OBV := MediaExp(52, xOBV);
  xEma200OBV := MediaExp(200, xOBV);

  // Reset da variável de seleção
  xSelect := 0;

  // Condição de Compra (Long)
  if ((Close < xEma52) or (Close < xVWAP) or (xOBV < xEma200OBV))
     and (Close > xEma52)
     and (Close > xVWAP)
     and (Close - xEma52 < 450)
     and (xOBV > xEma52OBV)
     and (xOBV > xEma200OBV) then
  begin
    xSelect := 1;
  end;

  // Condição de Venda (Short)
  if ((Close > xEma52) or (Close > xVWAP) or (xOBV > xEma200OBV))
     and (Close < xEma52)
     and (xEma52 - Close < 450)
     and (Close < xVWAP)
     and (xOBV < xEma52OBV)
     and (xOBV < xEma200OBV) then
  begin
    xSelect := -1;
  end;

// Lógica de Execução de Ordens
 begin
  if xSelect = 1 then
  begin
   BuyAtMarket;

   if bGestaoDeRiscoPelaEstrategia then
  begin
    //POSIÇÃO COMPRADA
    //Código responsável pela configuração das ordens de stoploss e take profit NA ENTRADA
    fPrecoStop := BuyPrice - StopLossPontos * MinPriceIncrement;
    fPrecoAlvo := BuyPrice + TakeProfitPontos * MinPriceIncrement;
    fPrecoStopOffset := fPrecoStop - cStopOffsetEmpontos * MinPriceIncrement;

    SetStopLoss(fPrecoStop, fPrecoStopOffset);
    SetProfitTarget(fPrecoAlvo);
  end;
  end
  else if xSelect = -1 then
  begin
   SellShortAtMarket;
   if bGestaoDeRiscoPelaEstrategia then
  begin
   //POSIÇÃO VENDIDA
    //Código responsável pela configuração das ordens de stoploss e take profit NA ENTRADA
    fPrecoStop := SellPrice + StopLossPontos * MinPriceIncrement;
    fPrecoAlvo := SellPrice - TakeProfitPontos * MinPriceIncrement;
    fPrecoStopOffset := fPrecoStop + cStopOffsetEmpontos * MinPriceIncrement;

    SetStopLoss(fPrecoStop, fPrecoStopOffset);
    SetProfitTarget(fPrecoAlvo);
  end;
  end;

  // Encerramento Daytrade
  if Time >= iHorarioEncerramentoDaytrade and isPositionOpen then
  begin
    ClosePosition;
  end;
END;
END;

Como corrigir? Já procurei tudo. Em outro código semelhante, inclusive onde esse identifica erro de sintaxe, os erros são outros:

Parser: Tem que ser identificador na declaração de variável
Parser: O código deve começar com begin
Erro de Sintaxe

Segue o codigo (é uma variação para DOL).

INPUT
StopLossPontos(7); // Valor padrão de 7 pontos para o Stop Loss
TakeProfitPontos(21); // Valor padrão de 21 pontos para o Take Profit
cStopOffsetEmpontos(2);
bGestaoDeRiscoPelaEstrategia(true);
iHorarioInicioAberturaPosicao(0905);
iHorarioFimAberturaPosicao(1630);
iHorarioEncerramentoDaytrade(1645);


VAR
  xEma52,
  xVWAP,
  xOBV,
  xEma52OBV,
  xEma200OBV : float;
  xSelect     : integer;
  nStopPoints : float;
  nTargetPoints : float;
  nContracts : integer;
  bPosicionado: boolean;
  fPrecoStop, fPrecoAlvo, fPrecoStopOffset: float;
  bConfigurouRisco: boolean;

BEGIN
  nStopPoints := StopLossPontos;
  nTargetPoints := TakeProfitPontos;
  nContracts := NumContratos;

  begin
    // Cálculo do OBV
    if Close > Close then
      xOBV := xOBV + QuantityVol(false)
    else if Close < Close then
      xOBV := xOBV - QuantityVol(false)
    else
      xOBV := xOBV;
  end;

  // Cálculo dos indicadores
  xEma52   := MediaExp(52, Close);
  xVWAP    := VWAP(1);
  xEma52OBV := MediaExp(52, xOBV);
  xEma200OBV := MediaExp(200, xOBV);

  // Reset da variável de seleção
  xSelect := 0;

  // Condição de Compra (Long)
  if ((Close < xEma52) or (Close < xVWAP) or (xOBV < xEma200OBV))
     and (Close > xEma52)
     and (Close > xVWAP)
     and (Close - xEma52 < 450)
     and (xOBV > xEma52OBV)
     and (xOBV > xEma200OBV) then
  begin
    xSelect := 1;
  end;

  // Condição de Venda (Short)
  if ((Close > xEma52) or (Close > xVWAP) or (xOBV > xEma200OBV))
     and (Close < xEma52)
     and (xEma52 - Close < 450)
     and (Close < xVWAP)
     and (xOBV < xEma52OBV)
     and (xOBV < xEma200OBV) then
  begin
    xSelect := -1;
  end;

  // Lógica de Execução de Ordens
  begin
    if xSelect = 1 then
    begin
      BuyAtMarket(nContracts);
      PrecoCompra := LastTrade; // Armazena o preço de execução da compra
    end
    else if xSelect = -1 then
    begin
      SellShortAtMarket(nContracts);
      PrecoVenda := LastTrade; // Armazena o preço de execução da venda
    end;
  end;

  // Lógica para envio de Stop Loss e Take Profit APÓS a ordem principal ser executada
  if PrecoCompra > 0 then
  begin
    SetStopLoss(nStopPoints);
    SetProfitTarget(nTargetPoints);
    PrecoCompra := 0; // Reseta a variável para não enviar ordens novamente no mesmo candle
  end;

  if PrecoVenda > 0 then
  begin
    SetStopLoss(nStopPoints);
    SetProfitTarget(nTargetPoints);
    PrecoVenda := 0; // Reseta a variável para não enviar ordens novamente no mesmo candle
  end;
end

Agradeço se der uma luz. Já procurei em todo lugar aqui, IA, etc.

Não consigo nem testar a teoria. 

Obrigado.

estou tentando adicionar essa estrategia no Ninja trader e na hora que compila da os seguintes erros conforme a imagem anexada!

estrategia de fechar operação quando chegar um valor X.

Poderiam me ajudar, não sei nada de programação, codigo gerado na IA

using NinjaTrader.Gui.Tools;
using NinjaTrader.NinjaScript;
using NinjaTrader.NinjaScript.Strategy;
using NinjaTrader.Gui.Tools;
using NinjaTrader.NinjaScript.StrategyGenerator;
using NinjaTrader.Gui.Tools;
using NinjaTrader.Cbi;
using NinjaTrader.Cbi;
using NinjaTrader.NinjaScript.Strategy;

namespace NinjaTrader.NinjaScript.Strategy
{
public class CloseOnTargetProfit : Strategy
{
// Defina o valor do lucro alvo aqui (em dólares)
private double targetProfit = 100.0;

// Variável para armazenar o preço de entrada
private double entryPrice = 0.0;

protected override void OnStartUp()
{
base.OnStartUp();
}

protected override void OnBarUpdate()
{
// Verifica se há uma posição aberta
if (Position.MarketPosition != MarketPosition.Flat)
{
// Calcula o lucro atual
double currentProfit = Position.GetProfitLoss(Close, PerformanceUnit.Currency);

// Verifica se o lucro atual alcançou o alvo
if (currentProfit >= targetProfit)
{
// Fecha a posição com base no tipo de posição (Long ou Short)
if (Position.MarketPosition == MarketPosition.Long)
{
ExitLong("TargetProfitExit");
}
else if (Position.MarketPosition == MarketPosition.Short)
{
ExitShort("TargetProfitExit");
}
}
}
}

// Esta função é chamada quando uma nova posição é aberta
protected override void OnExecution(IExecution execution)
{
base.OnExecution(execution);
// Armazena o preço de entrada ao abrir uma posição
if (execution.Order.OrderState == OrderState.Filled)
{
entryPrice = execution.Order.AvgFillPrice;
}
}
}
}

Desde já agradeço!

Cheguei até esse ponto:

Obrigado.

exemplo: estou no Candle X ele está 1 real 

eu armazeno q ele está 1 real, quando quando acontecer um condição e também o preço passar o preço do Candle x sinalizado lá atrás aí sim faz a entrada..

input
  FastAverage(21);
  SlowAverage(8);
 
var  
  sAvgFast     : Float;
  sAvgSlow     : Float;
  sPrevAvgFast : Float;
  sPrevAvgSlow : Float;
  valorA       :real;
  ValorB       :real;
  amplitude    :real;
  p0, p1, p2, p3, p4, p5,p6,p7,p10, p11, p12, p13, p14, p15,p16,p17   : real;
  contador, contador2      :integer;
  sinal,venda,compra,stopcompra,stopvenda,gaincompra,gainvenda, Cliga, Vliga : integer;
  passe1,passe2 : boolean; 
  
begin
  // Armazena os valores das médias em variáveis de apoio
  sAvgFast     := MediaExp(FastAverage, Close);
  sAvgSlow     := MediaExp(SlowAverage, Close);
  sPrevAvgFast := sAvgFast;
  sPrevAvgSlow := sAvgSlow;
  stopcompra := (p5 - 8 * MinPriceIncrement);
  stopvenda :=  (p10 + 8 * MinPriceIncrement);
  gaincompra := (p2);
  gainvenda := (p13);
  passe1 :=  (sinal=0) or (sinal=2); //testado ok
  passe2 := (sinal=1); //testado ok
   
  if  passe1 and (BuyPosition = 0) and (SellPosition = 0) and (sPrevAvgFast < sPrevAvgSlow) and (sAvgFast > sAvgSlow) then
  BEGIN
    

      ValorA   :=  abs (Lowest(Open, 21));
      ValorB   :=  abs(Highest(close, 8));
      amplitude := abs(ValorB-ValorA) ;
      p0 := valorA + (amplitude * 0);
      p1 := valorA + (amplitude * 0.382);
      p2 := valorA + (amplitude * 0.5);
      p3 := valorA + (amplitude * 0.618);
      p4 := valorA + (amplitude * 1);     //abertura do candle
      p5 := valorB - (amplitude * 1.61);  //stop
      p6 := valorB - (amplitude * 1.69);
      
      cliga:=1;
   
      PaintBar(clVerde);           
    
End;
if passe1 then
begin              
Buystop(p1);

end;
if isBought then
 begin
sinal:=1; 

end;
// Verifica se está comprado
if (IsBought) then
begin
 if  (BuyPrice > gaincompra)or (buyprice > p3 ) or ( buyprice > p4) then
  ClosePosition;
 if HasPendingOrders then
  CancelPendingOrders;
end; 
 
//If (BuyPosition = 1) or isBought and ((BuyPrice > gaincompra)or (buyprice > p3 ) or ( buyprice > p4))then
//begin
// ClosePosition;

        //  If hasPendingOrders then
           // CancelPendingOrders;
       // end;
If (BuyPosition = 1) or isBought and  (BuyPrice > stopcompra)then
begin
ClosePosition;
          If hasPendingOrders then
            CancelPendingOrders;
end;



      
      if passe1 then
      begin
    HorizontalLine(p0, clVermelho);
    HorizontalLine(p1, clBLACK); // 1 SEQUENCIA  DE COMPRA
    HorizontalLine(p2, clBLACK); // 2 SEQUENCIA DE COMPRA
    HorizontalLine(p3, clBLACK);//  3 SEQUENCIA DE COMPRA
    HorizontalLine(p4, clVerde);
    HorizontalLine(p5, clVermelho);
    HorizontalLine(p6, clred);
    contador := contador+ 2;
   
end;
      


   if passe2 and (BuyPosition = 0) and (SellPosition = 0)and (sPrevAvgFast > sPrevAvgSlow) and (sAvgFast < sAvgSlow)  then
 begin
   

      ValorA   :=  abs (Lowest(Open, 8));
      ValorB   :=  abs(Highest(close, 21));
      amplitude := abs(ValorB-ValorA) ;
      p15 := valorA + (amplitude * 0);
      p14 := valorA + (amplitude * 0.382);
      p13 := valorA + (amplitude * 0.50);
      p12 := valorA + (amplitude * 0.618);
      p11 := valorA + (amplitude * 1); //abetura do candle
      p10 := valorA + (amplitude * 1.61);                 //stop
      p16 := valorB + (amplitude * 1.69);
      PaintBar(ClRed);    

  
 
End;
if passe2 then
begin              
SellShortStop(p12);

end;
if isSold then
 begin
sinal:=2; 
Venda:=0;
end;

// Verifica se está vendido
if (IsSold) then
begin
 if  (SellPrice < gainVenda) or (sellprice<p14) or (buyprice<p15) then
  ClosePosition;
 if HasPendingOrders then
  CancelPendingOrders;
end;   
//If (SellPosition = 1)or isSold and ((SellPrice < gainVenda) or (sellprice<p14) or (buyprice<p15))  then
//begin
//ClosePosition;

          //If hasPendingOrders then
           // CancelPendingOrders;
       // end;
If (SellPosition = 1)or isSold and (SellPrice < stopvenda) then
begin
 ClosePosition;
          If hasPendingOrders then
            CancelPendingOrders;
end;     
 
  

if passe2 then
 begin
      HorizontalLine(p10, clVermelho);
      HorizontalLine(p11, clVerde);
      HorizontalLine(p12, clBLACK);   // 1 DE VENDA
      HorizontalLine(p13, clBLACK);  // 2 DE VENDA
      HorizontalLine(p14, clBLACK);  // 3 DE VENDA
      HorizontalLine(p15, clVermelho);
      HorizontalLine(p16, clred);
     contador := contador - 2;      
  

end;
end;


     
      

input
  FastAverage(21);
  SlowAverage(8);
  pQtdePeriodosAnaliseVolat(100);
var  
  sAvgFast     : Float;
  sAvgSlow     : Float;
  sPrevAvgFast : Float;
  sPrevAvgSlow : Float;
  valorA    :real;
  ValorB    :real;
  amplitude :real;
   p0, p1, p2, p3, p4, p5,var2,var1 : real;
   contador, contador2 :integer;

begin
  // Armazena os valores das médias em variáveis de apoio
  sAvgFast     := MediaExp(FastAverage, Close);
  sAvgSlow     := MediaExp(SlowAverage, Close);
  sPrevAvgFast := sAvgFast;
  sPrevAvgSlow := sAvgSlow;
  var2 := p3-4 * MinPriceIncrement;
  var1 := p3+4 * MinPriceIncrement;
  if  (BuyPosition = 0) and (SellPosition = 0) and (sPrevAvgFast < sPrevAvgSlow) and (sAvgFast > sAvgSlow) and (contador=0) then
  BEGIN
       
      ValorA   :=  abs(LOW);
      ValorB   :=  abs(HIGH);
      amplitude := abs(ValorB-ValorA) ;
      p0 := valorA + (amplitude * 0);
      p1 := valorA + (amplitude * 0.382);
      p2 := valorA + (amplitude * 0.5);
      p3 := valorA + (amplitude * 0.618);
      p4 := valorA + (amplitude * 1);     //abertura do candle
      p5 := valorB - (amplitude * 1.61);                      //stop
               
 /////////////////////////////              
BuyStop(p2);
PaintBar(clVerde);
 end;
if isBought then
 begin
   
SellToCoverLimit(p3); 
SellToCoverStop(p5 - 8 * MinPriceIncrement,buyposition);

end;
//FECHAMENTO
//FIM ORDEM DE COMPRA ACIMA E CODIÇÃO DE FECHAMENTO ABAIXO SE CRUZAR MEDIAS.


         if (BuyPosition=1)and(SellPosition=0) and (sPrevAvgFast > sPrevAvgSlow) and (sAvgFast < sAvgSlow) then
              BEGIN
      ClosePosition;
      PaintBar(clblue);
       If (hasPendingOrders) then
          CancelPendingOrders;
              end;
 ////////////////////////////////////
      
      if contador=0 then
      begin
      HorizontalLine(p0, clVermelho);
      HorizontalLine(p1, clVerdeClaro);
      HorizontalLine(p2, clVerdeClaro);
      HorizontalLine(p3, clVerdeClaro);
      HorizontalLine(p4, clVerde);
      HorizontalLine(p5, clVermelho);

      contador := contador+ 2;
   
end;
      


   if  (BuyPosition = 0) and (SellPosition = 0)and (sPrevAvgFast > sPrevAvgSlow) and (sAvgFast < sAvgSlow) and (contador=2)  then
 begin
      
      ValorA   :=  abs(LOW);
      ValorB   :=  abs(HIGH);
      amplitude := abs(ValorB-ValorA) ;
      p5 := valorA + (amplitude * 0);
      p4 := valorA + (amplitude * 0.382);
      p3 := valorA + (amplitude * 0.5);
      p2 := valorA + (amplitude * 0.618);
      p1 := valorA + (amplitude * 1); //abetura do candle
      p0 := valorA + (amplitude * 1.61);                 //stop

   //////////////////////////////////////// 

  SellShortStop(p2);
      PaintBar(ClRed);
    end;
      if IsSold then
  begin
   BuyToCoverLimit(p3); 
   BuyToCoverStop(p0 + 8 * MinPriceIncrement,sellposition);
  
   end;
   //FIM DA ORDE DE VENDA
   //FIM ORDEM DE VENDA ACIMA E CODIÇÃO DE FECHAMENTO ABAIXO SE CRUZAR MEDIAS.
          if (BuyPosition=0)and(SellPosition=1) AND (sPrevAvgFast < sPrevAvgSlow) and (sAvgFast > sAvgSlow) then
   BEGIN

      ClosePosition;
      PaintBar(clblue);
      If (hasPendingOrders) then
          CancelPendingOrders;
             end;  
 ////////////////////////////////////////////////
 if (contador=2)  then
 begin
       HorizontalLine(p0, clVermelho);
       HorizontalLine(p1, clVerde);
       HorizontalLine(p2, clVerdeClaro);
       HorizontalLine(p3, clVerdeClaro);
       HorizontalLine(p4, clVerdeClaro);
       HorizontalLine(p5, clVermelho);
     
      contador := contador - 2;      


end;
end;
end;