574 lines
19 KiB
Plaintext
574 lines
19 KiB
Plaintext
//+------------------------------------------------------------------+
|
|
//| SignalDetector.mqh |
|
|
//| Universal Buffer Reader EA v2.0 |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2025"
|
|
#property link ""
|
|
#property version "1.00"
|
|
#property strict
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| CSignalDetector - Reads indicator buffers and detects signals |
|
|
//+------------------------------------------------------------------+
|
|
class CSignalDetector
|
|
{
|
|
private:
|
|
string m_indicator_name;
|
|
int m_indicator_handle;
|
|
|
|
// Signal buffers
|
|
int m_buy_signal_buffer;
|
|
int m_sell_signal_buffer;
|
|
|
|
// SL/TP buffers (separate for BUY/SELL)
|
|
int m_buy_sl_buffer;
|
|
int m_buy_tp_buffers[];
|
|
int m_sell_sl_buffer;
|
|
int m_sell_tp_buffers[];
|
|
|
|
// ATR settings
|
|
int m_sltp_mode;
|
|
int m_atr_period;
|
|
int m_atr_handle;
|
|
double m_sl_atr_multiplier;
|
|
double m_tp_atr_multiplier;
|
|
int m_min_tp_pips;
|
|
|
|
// Symbol info
|
|
string m_symbol;
|
|
double m_pip_value;
|
|
int m_digits;
|
|
|
|
// Logging
|
|
bool m_enable_debug;
|
|
|
|
public:
|
|
//+------------------------------------------------------------------+
|
|
//| Signal data structure with multiple TPs |
|
|
//+------------------------------------------------------------------+
|
|
struct SignalData
|
|
{
|
|
bool has_signal;
|
|
bool is_buy;
|
|
double signal_price;
|
|
double sl_price;
|
|
double tp_prices[];
|
|
int tp_count;
|
|
bool used_atr_fallback;
|
|
};
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Constructor |
|
|
//+------------------------------------------------------------------+
|
|
CSignalDetector()
|
|
{
|
|
m_indicator_name = "";
|
|
m_indicator_handle = INVALID_HANDLE;
|
|
m_buy_signal_buffer = 0;
|
|
m_sell_signal_buffer = 1;
|
|
m_buy_sl_buffer = 2;
|
|
m_sell_sl_buffer = 6;
|
|
m_sltp_mode = 0;
|
|
m_atr_period = 14;
|
|
m_atr_handle = INVALID_HANDLE;
|
|
m_sl_atr_multiplier = 1.5;
|
|
m_tp_atr_multiplier = 3.0;
|
|
m_min_tp_pips = 300;
|
|
m_symbol = "";
|
|
m_pip_value = 0;
|
|
m_digits = 0;
|
|
m_enable_debug = false;
|
|
|
|
ArrayResize(m_buy_tp_buffers, 0);
|
|
ArrayResize(m_sell_tp_buffers, 0);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Destructor |
|
|
//+------------------------------------------------------------------+
|
|
~CSignalDetector()
|
|
{
|
|
Deinitialize();
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Initialize indicator handles |
|
|
//+------------------------------------------------------------------+
|
|
bool Initialize()
|
|
{
|
|
Print("[SignalDetector] Initializing...");
|
|
|
|
// Initialize custom indicator handle
|
|
if(m_indicator_name != "" && m_indicator_name != "My_Indicator")
|
|
{
|
|
m_indicator_handle = iCustom(m_symbol, PERIOD_CURRENT, m_indicator_name);
|
|
if(m_indicator_handle == INVALID_HANDLE)
|
|
{
|
|
int error = GetLastError();
|
|
Print("[ERROR] Failed to create indicator handle for: ", m_indicator_name,
|
|
" Error code: ", error);
|
|
return false;
|
|
}
|
|
Print("[SignalDetector] Custom indicator handle created: ", m_indicator_name);
|
|
}
|
|
else
|
|
{
|
|
Print("[SignalDetector] Using ATR mode only (no custom indicator)");
|
|
}
|
|
|
|
// Initialize ATR handle
|
|
m_atr_handle = iATR(m_symbol, PERIOD_CURRENT, m_atr_period);
|
|
if(m_atr_handle == INVALID_HANDLE)
|
|
{
|
|
int error = GetLastError();
|
|
Print("[ERROR] Failed to create ATR handle. Error code: ", error);
|
|
return false;
|
|
}
|
|
Print("[SignalDetector] ATR handle created (Period: ", m_atr_period, ")");
|
|
|
|
Print("[SignalDetector] Initialization complete");
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Deinitialize indicator handles |
|
|
//+------------------------------------------------------------------+
|
|
void Deinitialize()
|
|
{
|
|
Print("[SignalDetector] Deinitializing...");
|
|
|
|
if(m_indicator_handle != INVALID_HANDLE)
|
|
{
|
|
IndicatorRelease(m_indicator_handle);
|
|
m_indicator_handle = INVALID_HANDLE;
|
|
Print("[SignalDetector] Custom indicator handle released");
|
|
}
|
|
|
|
if(m_atr_handle != INVALID_HANDLE)
|
|
{
|
|
IndicatorRelease(m_atr_handle);
|
|
m_atr_handle = INVALID_HANDLE;
|
|
Print("[SignalDetector] ATR handle released");
|
|
}
|
|
|
|
ArrayResize(m_buy_tp_buffers, 0);
|
|
ArrayResize(m_sell_tp_buffers, 0);
|
|
|
|
Print("[SignalDetector] Deinitialization complete");
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Set parameters |
|
|
//+------------------------------------------------------------------+
|
|
void SetParameters(
|
|
string indicator_name,
|
|
int buy_signal_buffer, int sell_signal_buffer,
|
|
int buy_sl_buffer, int sell_sl_buffer,
|
|
int sltp_mode, int atr_period,
|
|
double sl_atr_multiplier, double tp_atr_multiplier,
|
|
int min_tp_pips, double pip_value, int digits,
|
|
string symbol,
|
|
bool enable_debug = false
|
|
)
|
|
{
|
|
m_indicator_name = indicator_name;
|
|
m_buy_signal_buffer = buy_signal_buffer;
|
|
m_sell_signal_buffer = sell_signal_buffer;
|
|
m_buy_sl_buffer = buy_sl_buffer;
|
|
m_sell_sl_buffer = sell_sl_buffer;
|
|
m_sltp_mode = sltp_mode;
|
|
m_atr_period = atr_period;
|
|
m_sl_atr_multiplier = sl_atr_multiplier;
|
|
m_tp_atr_multiplier = tp_atr_multiplier;
|
|
m_min_tp_pips = min_tp_pips;
|
|
m_pip_value = pip_value;
|
|
m_digits = digits;
|
|
m_symbol = symbol;
|
|
m_enable_debug = enable_debug;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Set debug mode |
|
|
//+------------------------------------------------------------------+
|
|
void SetDebugMode(bool enable_debug)
|
|
{
|
|
m_enable_debug = enable_debug;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Set TP buffers (can have multiple) |
|
|
//+------------------------------------------------------------------+
|
|
void SetBuyTPBuffers(int &buffers[])
|
|
{
|
|
ArrayCopy(m_buy_tp_buffers, buffers);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Set TP buffers (can have multiple) |
|
|
//+------------------------------------------------------------------+
|
|
void SetSellTPBuffers(int &buffers[])
|
|
{
|
|
ArrayCopy(m_sell_tp_buffers, buffers);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Detect signal from indicator buffers |
|
|
//+------------------------------------------------------------------+
|
|
SignalData DetectSignal(int bar_shift = 1)
|
|
{
|
|
SignalData result;
|
|
result.has_signal = false;
|
|
result.is_buy = false;
|
|
result.signal_price = 0;
|
|
result.sl_price = 0;
|
|
result.tp_count = 0;
|
|
result.used_atr_fallback = false;
|
|
ArrayResize(result.tp_prices, 0);
|
|
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] Detecting signal at bar shift: ", bar_shift);
|
|
}
|
|
|
|
// Read buy/sell signal buffers
|
|
double buy_signal = GetIndicatorBufferValue(m_buy_signal_buffer, bar_shift);
|
|
double sell_signal = GetIndicatorBufferValue(m_sell_signal_buffer, bar_shift);
|
|
|
|
// Determine signal type
|
|
bool has_buy = (buy_signal != EMPTY_VALUE && buy_signal != 0);
|
|
bool has_sell = (sell_signal != EMPTY_VALUE && sell_signal != 0);
|
|
|
|
if(!has_buy && !has_sell)
|
|
{
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] No signal detected");
|
|
}
|
|
return result;
|
|
}
|
|
|
|
// Validate: Both buy and sell signals should not be present
|
|
if(has_buy && has_sell)
|
|
{
|
|
Print("[WARNING] Both BUY and SELL signals detected. Using BUY signal.");
|
|
has_sell = false;
|
|
}
|
|
|
|
result.has_signal = true;
|
|
result.is_buy = has_buy;
|
|
result.signal_price = has_buy ? buy_signal : sell_signal;
|
|
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] ", (has_buy ? "BUY" : "SELL"), " signal detected at: ",
|
|
DoubleToString(result.signal_price, m_digits));
|
|
}
|
|
|
|
// Calculate SL/TP based on mode
|
|
if(m_sltp_mode == 1)
|
|
{
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] Using Mode 1: Indicator SL/TP buffers");
|
|
}
|
|
|
|
// Try indicator buffers first
|
|
double sl_buffer = has_buy ?
|
|
GetIndicatorBufferValue(m_buy_sl_buffer, bar_shift) :
|
|
GetIndicatorBufferValue(m_sell_sl_buffer, bar_shift);
|
|
|
|
if(IsValidPrice(sl_buffer))
|
|
{
|
|
result.sl_price = sl_buffer;
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] SL from indicator: ", DoubleToString(result.sl_price, m_digits));
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] SL buffer empty, will use ATR fallback");
|
|
}
|
|
}
|
|
|
|
// Read TP buffers
|
|
int tp_count;
|
|
if(has_buy)
|
|
tp_count = ArraySize(m_buy_tp_buffers);
|
|
else
|
|
tp_count = ArraySize(m_sell_tp_buffers);
|
|
|
|
if(tp_count > 0)
|
|
{
|
|
ArrayResize(result.tp_prices, tp_count);
|
|
result.tp_count = 0;
|
|
|
|
for(int i = 0; i < tp_count; i++)
|
|
{
|
|
int buffer_index;
|
|
if(has_buy)
|
|
buffer_index = m_buy_tp_buffers[i];
|
|
else
|
|
buffer_index = m_sell_tp_buffers[i];
|
|
|
|
double tp_buffer = GetIndicatorBufferValue(buffer_index, bar_shift);
|
|
if(IsValidPrice(tp_buffer))
|
|
{
|
|
result.tp_prices[result.tp_count] = tp_buffer;
|
|
result.tp_count++;
|
|
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] TP", (i + 1), " from indicator:",
|
|
DoubleToString(tp_buffer, m_digits));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] Using Mode 0: ATR-based SL/TP");
|
|
}
|
|
}
|
|
|
|
// Fall back to ATR if SL/TP not set
|
|
if(result.sl_price == 0 || result.tp_count == 0)
|
|
{
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] SL or TP not set from indicator, using ATR fallback");
|
|
}
|
|
|
|
double atr = GetATRValue(bar_shift);
|
|
if(atr > 0)
|
|
{
|
|
double open_price = SymbolInfoDouble(m_symbol, SYMBOL_BID);
|
|
result.sl_price = CalculateATRSL(has_buy, atr, open_price);
|
|
CalculateATRTPs(has_buy, atr, open_price, result.tp_prices, result.tp_count);
|
|
result.used_atr_fallback = true;
|
|
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] ATR value: ", DoubleToString(atr, m_digits));
|
|
Print("[SignalDetector] SL from ATR: ", DoubleToString(result.sl_price, m_digits));
|
|
for(int i = 0; i < result.tp_count; i++)
|
|
{
|
|
Print("[SignalDetector] TP", (i + 1), " from ATR: ",
|
|
DoubleToString(result.tp_prices[i], m_digits));
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Print("[ERROR] ATR value is 0, cannot calculate SL/TP");
|
|
}
|
|
}
|
|
|
|
// Apply minimum TP
|
|
ApplyMinimumTP(has_buy, result.tp_prices, result.tp_count, result.signal_price);
|
|
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] Signal detection complete. SL: ", DoubleToString(result.sl_price, m_digits),
|
|
", TPs: ", result.tp_count, ", ATR fallback: ", (result.used_atr_fallback ? "Yes" : "No"));
|
|
}
|
|
|
|
return result;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Get ATR value |
|
|
//+------------------------------------------------------------------+
|
|
double GetATRValue(int bar_shift = 1)
|
|
{
|
|
if(m_atr_handle == INVALID_HANDLE)
|
|
{
|
|
Print("[ERROR] ATR handle is invalid");
|
|
return 0;
|
|
}
|
|
|
|
double atr[];
|
|
ArraySetAsSeries(atr, true);
|
|
|
|
int copied = CopyBuffer(m_atr_handle, 0, bar_shift, 1, atr);
|
|
if(copied <= 0)
|
|
{
|
|
int error = GetLastError();
|
|
Print("[ERROR] Failed to copy ATR buffer. Error code: ", error);
|
|
return 0;
|
|
}
|
|
|
|
if(atr[0] <= 0)
|
|
{
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] ATR value is 0 or negative: ", atr[0]);
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
return atr[0];
|
|
}
|
|
|
|
private:
|
|
//+------------------------------------------------------------------+
|
|
//| Get indicator buffer value |
|
|
//+------------------------------------------------------------------+
|
|
double GetIndicatorBufferValue(int buffer_index, int bar_shift)
|
|
{
|
|
if(m_indicator_handle == INVALID_HANDLE)
|
|
{
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] Indicator handle is invalid");
|
|
}
|
|
return EMPTY_VALUE;
|
|
}
|
|
|
|
if(buffer_index < 0)
|
|
{
|
|
Print("[ERROR] Invalid buffer index: ", buffer_index);
|
|
return EMPTY_VALUE;
|
|
}
|
|
|
|
double buffer[];
|
|
ArraySetAsSeries(buffer, true);
|
|
|
|
int copied = CopyBuffer(m_indicator_handle, buffer_index, bar_shift, 1, buffer);
|
|
if(copied <= 0)
|
|
{
|
|
if(m_enable_debug)
|
|
{
|
|
int error = GetLastError();
|
|
Print("[SignalDetector] Failed to copy buffer ", buffer_index,
|
|
". Error code: ", error);
|
|
}
|
|
return EMPTY_VALUE;
|
|
}
|
|
|
|
return buffer[0];
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Calculate ATR-based SL |
|
|
//+------------------------------------------------------------------+
|
|
double CalculateATRSL(bool is_buy, double atr_value, double open_price)
|
|
{
|
|
if(atr_value <= 0) return 0;
|
|
|
|
if(is_buy)
|
|
{
|
|
return NormalizeDouble(open_price - atr_value * m_sl_atr_multiplier, m_digits);
|
|
}
|
|
else
|
|
{
|
|
return NormalizeDouble(open_price + atr_value * m_sl_atr_multiplier, m_digits);
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Calculate ATR-based TPs |
|
|
//+------------------------------------------------------------------+
|
|
void CalculateATRTPs(bool is_buy, double atr_value, double open_price, double &tp_prices[], int &tp_count)
|
|
{
|
|
if(atr_value <= 0) return;
|
|
|
|
// Default to 3 TPs if using ATR
|
|
int num_tps = 3;
|
|
ArrayResize(tp_prices, num_tps);
|
|
tp_count = num_tps;
|
|
|
|
for(int i = 0; i < num_tps; i++)
|
|
{
|
|
double multiplier = m_tp_atr_multiplier * (i + 1);
|
|
|
|
if(is_buy)
|
|
{
|
|
tp_prices[i] = NormalizeDouble(open_price + atr_value * multiplier, m_digits);
|
|
}
|
|
else
|
|
{
|
|
tp_prices[i] = NormalizeDouble(open_price - atr_value * multiplier, m_digits);
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Apply minimum TP to all TPs |
|
|
//+------------------------------------------------------------------+
|
|
void ApplyMinimumTP(bool is_buy, double &tp_prices[], int tp_count, double open_price)
|
|
{
|
|
if(m_min_tp_pips <= 0)
|
|
{
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] Minimum TP disabled (0 pips)");
|
|
}
|
|
return;
|
|
}
|
|
|
|
if(tp_count == 0)
|
|
{
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] No TPs to apply minimum TP");
|
|
}
|
|
return;
|
|
}
|
|
|
|
int adjusted_count = 0;
|
|
|
|
for(int i = 0; i < tp_count; i++)
|
|
{
|
|
if(is_buy)
|
|
{
|
|
double min_tp = NormalizeDouble(open_price + m_min_tp_pips * m_pip_value, m_digits);
|
|
if(tp_prices[i] < min_tp)
|
|
{
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] TP", (i + 1), " adjusted to minimum: ",
|
|
DoubleToString(tp_prices[i], m_digits), " -> ",
|
|
DoubleToString(min_tp, m_digits));
|
|
}
|
|
tp_prices[i] = min_tp;
|
|
adjusted_count++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
double min_tp = NormalizeDouble(open_price - m_min_tp_pips * m_pip_value, m_digits);
|
|
if(tp_prices[i] > min_tp)
|
|
{
|
|
if(m_enable_debug)
|
|
{
|
|
Print("[SignalDetector] TP", (i + 1), " adjusted to minimum: ",
|
|
DoubleToString(tp_prices[i], m_digits), " -> ",
|
|
DoubleToString(min_tp, m_digits));
|
|
}
|
|
tp_prices[i] = min_tp;
|
|
adjusted_count++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(m_enable_debug && adjusted_count > 0)
|
|
{
|
|
Print("[SignalDetector] Minimum TP applied to ", adjusted_count, " TP(s)");
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Check if price is valid |
|
|
//+------------------------------------------------------------------+
|
|
bool IsValidPrice(double price)
|
|
{
|
|
return (price != EMPTY_VALUE && price != 0 && price > 0);
|
|
}
|
|
};
|
|
//+------------------------------------------------------------------+ |