bot do handlu w mql otwiera za dużo pozycji.

Wed, 05 Mar 2025 17:30:37 +0000
witam . Ostatnio trochę się bawię i postanowiłem napisać bota do handlu na giełdzie w MQL. mam problem ponieważ otwiera mi pozycje co 15 min. nie wiem jak to zmienić, próbowałem używać też ia ale bez wiekszego skutku. Czy ktoś jest w stanie pomoć mi rozwiązać problem albo chociaż nakierować gdzie popełniam błąd ?
//+------------------------------------------------------------------+
//|                                               tet4.mq5          |
//|                        Copyright 2023, Your Name                 |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, Your Name"
#property version   "1.05"
#include <Trade\Trade.mqh>
#include <Trade\PositionInfo.mqh>
#include <Trade\OrderInfo.mqh>
#include <Trade\HistoryOrderInfo.mqh>
#include <Trade\DealInfo.mqh>
#include <Object.mqh>
#include <StdLibErr.mqh>

input int      FastMA = 50;          // Fast MA period
input int      SlowMA = 200;         // Slow MA period
input int      MA20Period = 20;      // MA 20 period
input int      RSIPeriod = 14;       // RSI period
input int      ADXPeriod = 14;       // ADX period
input int      MACDFastEMAPeriod = 12; // MACD Fast EMA period
input int      MACDSlowEMAPeriod = 26; // MACD Slow EMA period
input int      MACDSignalSMA = 9;    // MACD Signal SMA period
input double   LotSize = 0.1;        // Lot size
input int      Slippage = 3;          // Slippage
input int      StopLossPips = 30;     // Stop Loss in pips
input int      TakeProfitPips = 30;   // Take Profit in pips
input ulong    MagicNumber = 88888;   // Unique EA identifier
input int      MaxPositions = 1;      // Max number of positions per symbol
input bool     EnableLogging = true;  // Enable logging for debugging

string Symbols[] = {"EURUSD", "GBPUSD", "USDJPY", "USDCHF", "AUDUSD"};
datetime LastBarTime[];

// Structure to store indicators
struct IndicatorHandles {
    int maFastM15;  // Fast MA on M15
    int maSlowM15;  // Slow MA on M15
    int ma20M15;    // 20-period MA on M15
    int rsiM15;     // RSI on M15
    int macdM15;    // MACD on M15
};

// Array to store indicator handles
IndicatorHandles indicators[];

// Trading object
CTrade Trade;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
    Trade.SetDeviationInPoints(Slippage);
    ArrayResize(indicators, ArraySize(Symbols));
    ArrayResize(LastBarTime, ArraySize(Symbols));

    for(int i = 0; i < ArraySize(Symbols); i++)
    {
        string symbol = Symbols[i];
        SymbolSelect(symbol, true);

        // Initialize indicators for M15
        indicators[i].maFastM15 = iMA(symbol, PERIOD_M15, FastMA, 0, MODE_SMA, PRICE_CLOSE);
        indicators[i].maSlowM15 = iMA(symbol, PERIOD_M15, SlowMA, 0, MODE_SMA, PRICE_CLOSE);
        indicators[i].ma20M15 = iMA(symbol, PERIOD_M15, MA20Period, 0, MODE_SMA, PRICE_CLOSE);
        indicators[i].rsiM15 = iRSI(symbol, PERIOD_M15, RSIPeriod, PRICE_CLOSE);
        indicators[i].macdM15 = iMACD(symbol, PERIOD_M15, MACDFastEMAPeriod, MACDSlowEMAPeriod, MACDSignalSMA, PRICE_CLOSE);

        LastBarTime[i] = 0;

        // Check if handles are valid
        if(indicators[i].maFastM15 == INVALID_HANDLE || indicators[i].maSlowM15 == INVALID_HANDLE || 
           indicators[i].ma20M15 == INVALID_HANDLE || indicators[i].rsiM15 == INVALID_HANDLE || 
           indicators[i].macdM15 == INVALID_HANDLE)
        {
            Print("Failed to create indicators for ", symbol);
            return INIT_FAILED;
        }
    }
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
{
    for(int i = 0; i < ArraySize(Symbols); i++)
    {
        string symbol = Symbols[i];
        SymbolSelect(symbol, true);

        // Check for new M15 candle
        if(!IsNewBar(symbol, PERIOD_M15)) continue;

        // Check if there are open positions for this symbol
        if (HasOpenPosition(symbol)) 
        {
            if (EnableLogging) Print("Already open position for ", symbol);
            continue; // If there are open positions, skip opening new ones
        }

        double fastM15 = 0, slowM15 = 0, ma20M15 = 0, rsiM15 = 0, macdM15Main = 0, macdM15Signal = 0;
        if (!GetIndicatorData(i, fastM15, slowM15, ma20M15, rsiM15, macdM15Main, macdM15Signal))
        {
            Print("Failed to get indicator data for ", symbol);
            continue;
        }

        // Check for consensus among indicators
        ENUM_POSITION_TYPE trend = GetConsensusTrend(fastM15, slowM15, ma20M15, rsiM15, macdM15Main, macdM15Signal);
        
        // If there is a valid trend signal, open a new position
        if (trend != WRONG_VALUE)
        {
            OpenPosition(symbol, trend); // Open position based on trend
            if (EnableLogging) Print("Opened position for ", symbol, " with trend: ", trend);
        }
        else
        {
            if (EnableLogging) Print("No clear trend for ", symbol);
        }
    }
}

//+------------------------------------------------------------------+
//| Determine consensus trend                                       |
//+------------------------------------------------------------------+
ENUM_POSITION_TYPE GetConsensusTrend(double fastM15, double slowM15, double ma20M15, double rsiM15, double macdM15Main, double macdM15Signal)
{
    int bullishCount = 0;
    int bearishCount = 0;

    // Check MA crossovers on M15
    if (fastM15 > slowM15) bullishCount++;
    if (fastM15 < slowM15) bearishCount++;

    // Check RSI on M15
    if (rsiM15 > 50) bullishCount++;
    if (rsiM15 < 50) bearishCount++;

    // Check MACD on M15
    if (macdM15Main > macdM15Signal) bullishCount++;
    if (macdM15Main < macdM15Signal) bearishCount++;

    // Determine trend based on consensus
    if (bullishCount > bearishCount && bullishCount >= 2) // At least 2 indicators agree
    {
        if (EnableLogging) Print("Consensus trend for pair: BUY");
        return POSITION_TYPE_BUY;
    }
    else if (bearishCount > bullishCount && bearishCount >= 2) // At least 2 indicators agree
    {
        if (EnableLogging) Print("Consensus trend for pair: SELL");
        return POSITION_TYPE_SELL;
    }

    return WRONG_VALUE; // No clear consensus
}

//+------------------------------------------------------------------+
//| Check for new bar                                               |
//+------------------------------------------------------------------+
bool IsNewBar(string symbol, ENUM_TIMEFRAMES timeframe)
{
    datetime currentTime[];
    if(CopyTime(symbol, timeframe, 0, 1, currentTime) != 1) return false;

    int index = FindSymbolIndex(symbol);
    if(index == -1) return false;

    if(currentTime[0] != LastBarTime[index])
    {
        LastBarTime[index] = currentTime[0];
        return true;
    }
    return false;
}

//+------------------------------------------------------------------+
//| Find the index of the symbol in the Symbols array               |
//+------------------------------------------------------------------+
int FindSymbolIndex(string symbol)
{
    for(int i = 0; i < ArraySize(Symbols); i++)
    {
        if(Symbols[i] == symbol)
            return i;
    }
    return -1; // Not found
}

//+------------------------------------------------------------------+
//| Manage positions                                                |
//+------------------------------------------------------------------+
void ManagePositions(string symbol, ENUM_POSITION_TYPE trend)
{
    // Check if there are open positions for this symbol
    if (HasOpenPosition(symbol)) 
    {
        if (EnableLogging) Print("Cannot open position on ", symbol, " - Position already open");
        return; // If there are open positions, do not open a new one
    }

    // Open a new position if the trend is consistent and there are no open positions
    if (trend != WRONG_VALUE && CountOpenPositions(symbol) < MaxPositions)
    {
        OpenPosition(symbol, trend);
    }
    else
    {
        if (EnableLogging) Print("Cannot open position on ", symbol, " - Trend: ", trend);
    }
}

//+------------------------------------------------------------------+
//| Check for existing position                                      |
//+------------------------------------------------------------------+
bool HasOpenPosition(string symbol)
{
    for(int i = PositionsTotal() - 1; i >= 0; i--)
    {
        ulong ticket = PositionGetTicket(i);
        if(ticket > 0 && 
           PositionGetString(POSITION_SYMBOL) == symbol &&
           PositionGetInteger(POSITION_MAGIC) == MagicNumber)
            return true;
    }
    return false;
}

//+------------------------------------------------------------------+
//| Count open positions                                            |
//+------------------------------------------------------------------+
int CountOpenPositions(string symbol)
{
    int count = 0;
    for(int i = PositionsTotal() - 1; i >= 0; i--)
    {
        ulong ticket = PositionGetTicket(i);
        if(ticket > 0 && PositionGetString(POSITION_SYMBOL) == symbol && PositionGetInteger(POSITION_MAGIC) == MagicNumber)
            count++;
    }
    return count;
}

//+------------------------------------------------------------------+
//| Open new position                                              |
//+------------------------------------------------------------------+
void OpenPosition(string symbol, ENUM_POSITION_TYPE trend)
{
    double price = trend == POSITION_TYPE_BUY ? SymbolInfoDouble(symbol, SYMBOL_ASK) : SymbolInfoDouble(symbol, SYMBOL_BID);
    double sl = CalculateSL(symbol, trend, price);
    double tp = CalculateTP(symbol, trend, price);

    if(trend == POSITION_TYPE_BUY)
    {
        if(Trade.Buy(LotSize, symbol, price, sl, tp, NULL))
        {
            if (EnableLogging) Print("Opened BUY position for ", symbol);
        }
        else
        {
            Print("Failed to open BUY position for ", symbol);
        }
    }
    else
    {
        if(Trade.Sell(LotSize, symbol, price, sl, tp, NULL))
        {
            if (EnableLogging) Print("Opened SELL position for ", symbol);
        }
        else
        {
            Print("Failed to open SELL position for ", symbol);
        }
    }
}

//+------------------------------------------------------------------+
//| Calculate Stop Loss                                             |
//+------------------------------------------------------------------+
double CalculateSL(string symbol, ENUM_POSITION_TYPE trend, double entryPrice)
{
    double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
    double slDistance = StopLossPips * 10 * point; // 30 pips

    return trend == POSITION_TYPE_BUY ? entryPrice - slDistance : entryPrice + slDistance;
}

//+------------------------------------------------------------------+
//| Calculate Take Profit                                           |
//+------------------------------------------------------------------+
double CalculateTP(string symbol, ENUM_POSITION_TYPE trend, double entryPrice)
{
    double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
    double tpDistance = TakeProfitPips * 10 * point; // 30 pips

    return trend == POSITION_TYPE_BUY ? entryPrice + tpDistance : entryPrice - tpDistance;
}

//+------------------------------------------------------------------+
//| Get indicator data                                             |
//+------------------------------------------------------------------+
bool GetIndicatorData(int index, double &fastM15, double &slowM15, double &ma20M15, double &rsiM15, double &macdM15Main, double &macdM15Signal)
{
    double fastM15Buffer[], slowM15Buffer[], ma20M15Buffer[], rsiM15Buffer[], macdM15Buffer[], macdM15SignalBuffer[];

    if(CopyBuffer(indicators[index].maFastM15, 0, 0, 1, fastM15Buffer) != 1 ||
       CopyBuffer(indicators[index].maSlowM15, 0, 0, 1, slowM15Buffer) != 1 ||
       CopyBuffer(indicators[index].ma20M15, 0, 0, 1, ma20M15Buffer) != 1 ||
       CopyBuffer(indicators[index].rsiM15, 0, 0, 1, rsiM15Buffer) != 1 ||
       CopyBuffer(indicators[index].macdM15, 0, 0, 1, macdM15Buffer) != 1 ||
       CopyBuffer(indicators[index].macdM15, 1, 0, 1, macdM15SignalBuffer) != 1)
    {
        return false;
    }

    fastM15 = fastM15Buffer[0];
    slowM15 = slowM15Buffer[0];
    ma20M15 = ma20M15Buffer[0];
    rsiM15 = rsiM15Buffer[0];
    macdM15Main = macdM15Buffer[0];
    macdM15Signal = macdM15SignalBuffer[0];

    return true;
}

//+------------------------------------------------------------------+
MQL - opisanie alertów aby wyswietłały się tylko raz

Wed, 27 Dec 2017 19:14:03 +0000
Nie wiem czy ktoś tutaj się tym zajmuję ale potrzebuję pomocy przy oprogramowaniu alertów. Nie wiem jak to zrobić aby wyświetlały się tylko podczas zamknięcia danej świecy a nie przez cały czas kiedy świeca się tworzy. Jeżeli ktoś bawi się w tym języku i chciałby pomóc będę wdzięczny.
Forum Pasja Informatyki - Najnowsze z tagiem mql

bot do handlu w mql otwiera za dużo pozycji.

MQL - opisanie alertów aby wyswietłały się tylko raz
