//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   Print("Signal MQL5 Robot started successfully.");
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   Print("Signal MQL5 Robot stopped.");
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   // Certificando-se de que não há outra posição aberta antes de executar a lógica de sinais
   if (PositionsTotal() == 0) 
   {
      RunSignalLogic();
   }
   else
   {
      Print("Já existe uma ordem aberta. Aguardando.");
   }
  }

//+------------------------------------------------------------------+
//| Signal logic function                                            |
//+------------------------------------------------------------------+
void RunSignalLogic()
  {
   // Capturando os parâmetros do gráfico atual (últimos 3 candles)
   MqlRates prices[];
   ArraySetAsSeries(prices, true); // Inverte a ordem (candle 0 é o mais recente)

   if (CopyRates(Symbol(), Period(), 0, 3, prices) <= 0) 
   {
      Print("Erro ao copiar os preços: ", GetLastError());
      return;
   }

   // Variáveis para os candles atuais e anteriores
   double openPrice0 = prices[1].open;
   double closePrice0 = prices[1].close;
   double highPrice0 = prices[1].high;
   double lowPrice0 = prices[1].low;

   double highPrev = prices[2].high;
   double lowPrev = prices[2].low;
   double closePrev = prices[2].close;

   // Sinal: Nenhum (0), Compra (2), Venda (1)
   int signalType = 0;

   // --- Condições de Compra ---
   bool c0 = openPrice0 > closePrice0; // Candle vermelho
   bool c1 = highPrice0 > highPrev;    // Máxima atual maior que a anterior
   bool c2 = lowPrice0 < lowPrev;      // Mínima atual menor que a anterior
   bool c3 = closePrice0 < lowPrev;    // Fechamento está abaixo da mínima anterior
   if (c0 && c1 && c2 && c3)
      signalType = 2;

   // --- Condições de Venda ---
   c0 = openPrice0 < closePrice0;      // Candle verde
   c1 = lowPrice0 < lowPrev;
   c2 = highPrice0 > highPrev;
   c3 = closePrice0 > highPrev;
   if (c0 && c1 && c2 && c3)
      signalType = 1;

   // Executando o sinal detectado
   if (signalType != 0)
      ExecuteSignal(signalType);
  }

//+------------------------------------------------------------------+
//| Função para executar os sinais detectados                       |
//+------------------------------------------------------------------+
void ExecuteSignal(int signalType)
  {
   MqlTradeRequest request;
   MqlTradeResult result;

   // Valores fixos para lotes, Stop Loss e Take Profit
   double lots = 0.1;
   double slPips = 200 * _Point;
   double tpPips = 400 * _Point;

   double price = 0.0;
   double stopLoss = 0.0;
   double takeProfit = 0.0;

   // Determinando o ponto de entrada (compra/venda)
   if (signalType == 2) // Compra
     {
      price = SymbolInfoDouble(Symbol(), SYMBOL_ASK);
      stopLoss = price - slPips;
      takeProfit = price + tpPips;

      // Preenchendo a estrutura de solicitação
      ZeroMemory(request);
      request.action = TRADE_ACTION_DEAL;
      request.symbol = Symbol();
      request.volume = lots;
      request.price = price;
      request.sl = NormalizeDouble(stopLoss, _Digits);
      request.tp = NormalizeDouble(takeProfit, _Digits);
      request.type = ORDER_TYPE_BUY;
      request.type_filling = ORDER_FILLING_IOC;
      request.deviation = 10;

      // Enviando a ordem
      if (!OrderSend(request, result))
         Print("Erro ao enviar ordem de compra: ", GetLastError());
      else
         Print("Ordem de compra enviada com sucesso!");
     }

   if (signalType == 1) // Venda
     {
      price = SymbolInfoDouble(Symbol(), SYMBOL_BID);
      stopLoss = price + slPips;
      takeProfit = price - tpPips;

      // Preenchendo a estrutura de solicitação
      ZeroMemory(request);
      request.action = TRADE_ACTION_DEAL;
      request.symbol = Symbol();
      request.volume = lots;
      request.price = price;
      request.sl = NormalizeDouble(stopLoss, _Digits);
      request.tp = NormalizeDouble(takeProfit, _Digits);
      request.type = ORDER_TYPE_SELL;
      request.type_filling = ORDER_FILLING_IOC;
      request.deviation = 10;

      // Enviando a ordem
      if (!OrderSend(request, result))
         Print("Erro ao enviar ordem de venda: ", GetLastError());
      else
         Print("Ordem de venda enviada com sucesso!");
     }
  }


  coloque no codigo acima o trailing stop e TP com as mesmas configuraçoes , deacordo com o do codigo abaixo de exemplo: adicione maximo de spread permitido tambem e um TP e SL fixo


//+------------------------------------------------------------------+
//|                                                   Scalping Robot |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.01"

#include <Trade/Trade.mqh>

#define NumNodes 20 // Number of network nodes
CTrade           trade;
CPositionInfo    pos;
COrderInfo       ord;

// Neural Network Parameters
input double Coefficient           = 0.1;
input double LearningRate          = 0.1;

double          Weight[NumNodes];        // Neural network node weights
double          NormalizedInputs[NumNodes];
double          NNOutput            = 0;

//+------------------------------------------------------------------+
//|                                              Inputs and Settings |
//+------------------------------------------------------------------+
input group "*** Trading Inputs ***"
input double LotSize             = 0.01;  // Lot size for trading
input int    Tppoints            = 800;   // Take Profit (10 points = 1 pip)
input int    Slpoints            = 800;   // Stop Loss Points (10 points = 1 pip)
input int    TslTriggerPoints    = 35;    // Points in profit before Trailing SL is activated (10 points = 1 pip)
input int    TslPoints           = 10;    // Trailing Stoploss (10 points = 1 pip)
input ENUM_TIMEFRAMES Timeframe  = PERIOD_CURRENT; // Time frame to run
input int    InpMagic            = 891245; // EA identification no
input string TradeComment        = "Wendel Cassiano";
input int    MaxSpread           = 100;   // Maximum spread allowed (in points)
input int    Slippage            = 50;    // Slippage in points
input int    MaxOrders           = 2;     // Max simultaneous orders

int BarsN            = 5;
int ExpirationBars   = 100;
int OrderDistPoints  = 100;

//+------------------------------------------------------------------+
//| Initialization                                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    trade.SetExpertMagicNumber(InpMagic);
    ChartSetInteger(0, CHART_SHOW_GRID, false);

    // Initialize Neural Network Weights
    for (int i = 0; i < NumNodes; i++)
        Weight[i] = 0.5; // Arbitrary initial weights for the neural network

    return (INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert Tick Function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
    // Apply trailing stop logic
    TrailStop();

    // Check if the new bar is available
    if (!IsNewBar()) return;

    // Check spread
    double spread = (SymbolInfoDouble(_Symbol, SYMBOL_ASK) - SymbolInfoDouble(_Symbol, SYMBOL_BID)) / _Point;
    if (spread > MaxSpread) return;

    // Count active Buy and Sell positions/orders
    int BuyTotal = 0, SellTotal = 0;
    for (int i = PositionsTotal() - 1; i >= 0; i--)
    {
        pos.SelectByIndex(i);
        if (pos.PositionType() == POSITION_TYPE_BUY && pos.Symbol() == _Symbol && pos.Magic() == InpMagic)
            BuyTotal++;
        if (pos.PositionType() == POSITION_TYPE_SELL && pos.Symbol() == _Symbol && pos.Magic() == InpMagic)
            SellTotal++;
    }
    for (int i = OrdersTotal() - 1; i >= 0; i--)
    {
        ord.SelectByIndex(i);
        if (ord.OrderType() == ORDER_TYPE_BUY_STOP && ord.Symbol() == _Symbol && ord.Magic() == InpMagic)
            BuyTotal++;
        if (ord.OrderType() == ORDER_TYPE_SELL_STOP && ord.Symbol() == _Symbol && ord.Magic() == InpMagic)
            SellTotal++;
    }

    // Limit maximum orders
    int TotalOrders = BuyTotal + SellTotal;
    if (TotalOrders >= MaxOrders) return;

    // Neural network prediction
    NormalizingInputs();
    OutputLayerCalculation();

    // Determine Buy and Sell Signals from Neural Network
    bool buySignal = (BuyTotal == 0 && NNOutput > 0);
    bool sellSignal = (SellTotal == 0 && NNOutput < 0);

    if (buySignal)
    {
        double high = findHigh();
        if (high > 0)
            SendBuyOrder(high);
    }
    if (sellSignal)
    {
        double low = findLow();
        if (low > 0)
            SendSellOrder(low);
    }
}

//+------------------------------------------------------------------+
//| Helper Functionality                                             |
//+------------------------------------------------------------------+
double findHigh()
{
    double highestHigh = 0;
    for (int i = 0; i < 200; i++)
    {
        double high = iHigh(_Symbol, Timeframe, i);
        if (i > BarsN && iHighest(_Symbol, Timeframe, MODE_HIGH, BarsN * 2 + 1, i - BarsN) == i)
        {
            if (high > highestHigh) return high;
        }
        highestHigh = MathMax(high, highestHigh);
    }
    return -1;
}

double findLow()
{
    double lowestLow = DBL_MAX;
    for (int i = 0; i < 200; i++)
    {
        double low = iLow(_Symbol, Timeframe, i);
        if (i > BarsN && iLowest(_Symbol, Timeframe, MODE_LOW, BarsN * 2 + 1, i - BarsN) == i)
        {
            if (low < lowestLow) return low;
        }
    }
    return -1;
}

//+------------------------------------------------------------------+
//| Calculate RSI Value                                              |
//+------------------------------------------------------------------+
double RSIValue(int shift)
{
    int rsiPeriod = 14; // Período padrão do RSI
    double rsi[];       // Array para armazenar os valores do RSI

    // Handle do indicador RSI
    int rsiHandle = iRSI(_Symbol, Timeframe, rsiPeriod, PRICE_CLOSE);

    // Verifique se o handle foi criado corretamente
    if (rsiHandle == INVALID_HANDLE)
    {
        Print("Erro ao criar o indicador RSI!");
        return 0.0;
    }

    // Copiar os valores do RSI para o array a partir do buffer
    if (CopyBuffer(rsiHandle, 0, shift, 1, rsi) <= 0)
    {
        Print("Erro ao copiar os valores do RSI!");
        return 0.0;
    }

    // Liberar recursos do handle do indicador
    IndicatorRelease(rsiHandle);

    // Retornar o valor do RSI desejado
    return rsi[0];
}

//+------------------------------------------------------------------+
//| Neural Network Implementation                                    |
//+------------------------------------------------------------------+
void NormalizingInputs()
{
    double LowerNormRange = -1;
    double UpperNormRange = 1;

    for (int i = 0; i < NumNodes; i++)
    {
        double currentRSI = RSIValue(i); // Obtém o valor do RSI
        NormalizedInputs[i] = (((currentRSI - 0) * (UpperNormRange - LowerNormRange)) / (100 - 0)) + LowerNormRange;
    }
}

void OutputLayerCalculation()
{
    NNOutput = HiddenLayerCalculation(NormalizedInputs, Weight);
}

double HiddenLayerCalculation(double &inputs[], double &Weights[])
{
    double TotalWeightedInputs = 0.0;
    for (int i = 0; i < ArraySize(inputs); i++)
        TotalWeightedInputs += inputs[i] * Weights[i];
    TotalWeightedInputs *= Coefficient;
    return TanHActivationFunction(TotalWeightedInputs);
}

double TanHActivationFunction(double WeightedInputs)
{
    return ((exp(WeightedInputs) - exp(-WeightedInputs)) / (exp(WeightedInputs) + exp(-WeightedInputs)));
}

//+------------------------------------------------------------------+
//| Place Orders                                                     |
//+------------------------------------------------------------------+
void SendBuyOrder(double entry)
{
    double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
    if (ask > entry - OrderDistPoints * _Point) return;

    double tp = entry + Tppoints * _Point;
    double sl = entry - Slpoints * _Point;

    trade.BuyStop(LotSize, entry, _Symbol, sl, tp, ORDER_TIME_SPECIFIED, iTime(_Symbol, Timeframe, 0) + ExpirationBars * PeriodSeconds(Timeframe), Slippage);
}

void SendSellOrder(double entry)
{
    double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
    if (bid < entry + OrderDistPoints * _Point) return;

    double tp = entry - Tppoints * _Point;
    double sl = entry + Slpoints * _Point;

    trade.SellStop(LotSize, entry, _Symbol, sl, tp, ORDER_TIME_SPECIFIED, iTime(_Symbol, Timeframe, 0) + ExpirationBars * PeriodSeconds(Timeframe), Slippage);
}

//+------------------------------------------------------------------+
//| Trailing Stop                                                   |
//+------------------------------------------------------------------+
void TrailStop()
{
    double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
    double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);

    for (int i = PositionsTotal() - 1; i >= 0; i--)
    {
        if (pos.SelectByIndex(i) && pos.Magic() == InpMagic && pos.Symbol() == _Symbol)
        {
            double sl = 0;
            double tp = pos.TakeProfit();
            if (pos.PositionType() == POSITION_TYPE_BUY)
            {
                if (bid - pos.PriceOpen() >= TslTriggerPoints * _Point)
                {
                    sl = bid - TslPoints * _Point;
                    if (sl > pos.StopLoss() || pos.StopLoss() == 0)
                        trade.PositionModify(pos.Ticket(), sl, tp);
                }
            }
            if (pos.PositionType() == POSITION_TYPE_SELL)
            {
                if (pos.PriceOpen() - ask >= TslTriggerPoints * _Point)
                {
                    sl = ask + TslPoints * _Point;
                    if (sl < pos.StopLoss() || pos.StopLoss() == 0)
                        trade.PositionModify(pos.Ticket(), sl, tp);
                }
            }
        }
    }
}

//+------------------------------------------------------------------+
//| Detect New Bar                                                   |
//+------------------------------------------------------------------+
bool IsNewBar()
{
    static datetime previousTime = 0;
    datetime currentTime = iTime(_Symbol, Timeframe, 0);
    if (previousTime != currentTime)
    {
        previousTime = currentTime;
        return true;
    }
    return false;
}