| //+------------------------------------------------------------------+
|
| //| SignalGenerator.mqh |
|
| //| Copyright 2025, EscapeEA |
|
| //| https://www.escapeea.com |
|
| //+------------------------------------------------------------------+
|
| #property copyright "Copyright 2025, EscapeEA"
|
| #property link "https://www.escapeea.com"
|
| #property version "1.00"
|
| #property strict
|
|
|
| #include <Arrays\ArrayObj.mqh>
|
| #include <Indicators\Trend.mqh>
|
| #include <Indicators\Oscilators.mqh>
|
|
|
| // Forward declarations
|
| class CSymbolInfo;
|
|
|
| //+------------------------------------------------------------------+
|
| //| Signal types and enums |
|
| //+------------------------------------------------------------------+
|
| enum ENUM_SIGNAL_TYPE {
|
| SIGNAL_TYPE_NONE = 0, // No signal
|
| SIGNAL_TYPE_BUY = 1, // Buy signal
|
| SIGNAL_TYPE_SELL = -1, // Sell signal
|
| SIGNAL_TYPE_CLOSE = 2 // Close position signal
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Signal structure to hold signal details |
|
| //+------------------------------------------------------------------+
|
| struct SSignal {
|
| ENUM_SIGNAL_TYPE type; // Signal type
|
| double price; // Entry price
|
| double sl; // Stop loss
|
| double tp; // Take profit
|
| double strength; // Signal strength (0.0 to 1.0)
|
| string comment; // Signal comment/description
|
| datetime time; // Signal time
|
|
|
| // Default constructor
|
| SSignal() {
|
| type = SIGNAL_TYPE_NONE;
|
| price = 0.0;
|
| sl = 0.0;
|
| tp = 0.0;
|
| strength = 0.0;
|
| comment = "";
|
| time = 0;
|
| }
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Signal Generator class |
|
| //+------------------------------------------------------------------+
|
| class CSignalGenerator {
|
| private:
|
| // Indicators
|
| CiMA m_ma; // Moving Average
|
| CiMA m_maFast; // Fast Moving Average
|
| CiMA m_maSlow; // Slow Moving Average
|
| CiATR m_atr; // Average True Range
|
|
|
| // Configuration
|
| int m_maPeriod; // MA Period
|
| int m_maFastPeriod; // Fast MA Period
|
| int m_maSlowPeriod; // Slow MA Period
|
| int m_atrPeriod; // ATR Period
|
| double m_atrMultiplier; // ATR Multiplier for SL/TP
|
|
|
| // State
|
| bool m_initialized; // Initialization flag
|
| CSymbolInfo *m_symbol; // Symbol info
|
|
|
| // Private methods
|
| bool InitializeIndicators();
|
| double CalculateATRMultiplier() const;
|
|
|
| public:
|
| // Constructor/Destructor
|
| CSignalGenerator();
|
| ~CSignalGenerator();
|
|
|
| // Initialization
|
| bool Initialize(CSymbolInfo *symbol,
|
| int maPeriod,
|
| int maFastPeriod,
|
| int maSlowPeriod,
|
| int atrPeriod,
|
| double atrMultiplier);
|
|
|
| // Signal generation
|
| bool GenerateSignal(SSignal &signal);
|
|
|
| // Getters
|
| bool IsInitialized() const { return m_initialized; }
|
|
|
| // Utility
|
| static string SignalTypeToString(ENUM_SIGNAL_TYPE type);
|
| };
|
|
|
| //+------------------------------------------------------------------+
|
| //| Constructor |
|
| //+------------------------------------------------------------------+
|
| CSignalGenerator::CSignalGenerator() :
|
| m_initialized(false),
|
| m_symbol(NULL),
|
| m_maPeriod(0),
|
| m_maFastPeriod(0),
|
| m_maSlowPeriod(0),
|
| m_atrPeriod(0),
|
| m_atrMultiplier(0.0)
|
| {
|
| // Initialize member variables in the initialization list
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Destructor |
|
| //+------------------------------------------------------------------+
|
| CSignalGenerator::~CSignalGenerator() {
|
| // Cleanup if needed
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Initialize the signal generator |
|
| //+------------------------------------------------------------------+
|
| bool CSignalGenerator::Initialize(CSymbolInfo *symbol,
|
| int maPeriod,
|
| int maFastPeriod,
|
| int maSlowPeriod,
|
| int atrPeriod,
|
| double atrMultiplier) {
|
| // Validate inputs
|
| if(symbol == NULL) {
|
| Print("Error: Invalid symbol pointer");
|
| return false;
|
| }
|
|
|
| if(maPeriod <= 0 || maFastPeriod <= 0 || maSlowPeriod <= 0 || atrPeriod <= 0 || atrMultiplier <= 0) {
|
| Print("Error: Invalid parameters");
|
| return false;
|
| }
|
|
|
| // Store parameters
|
| m_symbol = symbol;
|
| m_maPeriod = maPeriod;
|
| m_maFastPeriod = maFastPeriod;
|
| m_maSlowPeriod = maSlowPeriod;
|
| m_atrPeriod = atrPeriod;
|
| m_atrMultiplier = atrMultiplier;
|
|
|
| // Initialize indicators
|
| if(!InitializeIndicators()) {
|
| Print("Failed to initialize indicators");
|
| return false;
|
| }
|
|
|
| m_initialized = true;
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Initialize technical indicators |
|
| //+------------------------------------------------------------------+
|
| bool CSignalGenerator::InitializeIndicators() {
|
| // Initialize MA
|
| if(!m_ma.Create(m_symbol.Name(), PERIOD_CURRENT, m_maPeriod, 0, MODE_SMA, PRICE_CLOSE)) {
|
| Print("Failed to create MA indicator");
|
| return false;
|
| }
|
|
|
| // Initialize Fast MA
|
| if(!m_maFast.Create(m_symbol.Name(), PERIOD_CURRENT, m_maFastPeriod, 0, MODE_SMA, PRICE_CLOSE)) {
|
| Print("Failed to create Fast MA indicator");
|
| return false;
|
| }
|
|
|
| // Initialize Slow MA
|
| if(!m_maSlow.Create(m_symbol.Name(), PERIOD_CURRENT, m_maSlowPeriod, 0, MODE_SMA, PRICE_CLOSE)) {
|
| Print("Failed to create Slow MA indicator");
|
| return false;
|
| }
|
|
|
| // Initialize ATR
|
| if(!m_atr.Create(m_symbol.Name(), PERIOD_CURRENT, m_atrPeriod)) {
|
| Print("Failed to create ATR indicator");
|
| return false;
|
| }
|
|
|
| return true;
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Generate trading signal |
|
| //+------------------------------------------------------------------+
|
| bool CSignalGenerator::GenerateSignal(SSignal &signal) {
|
| // Reset signal
|
| signal = SSignal();
|
|
|
| // Check initialization
|
| if(!m_initialized || m_symbol == NULL) {
|
| Print("Signal generator not properly initialized");
|
| return false;
|
| }
|
|
|
| // Update indicators
|
| if(m_ma.CalculateRates() == 0 ||
|
| m_maFast.CalculateRates() == 0 ||
|
| m_maSlow.CalculateRates() == 0 ||
|
| m_atr.CalculateRates() == 0) {
|
| Print("Failed to calculate indicator values");
|
| return false;
|
| }
|
|
|
| // Get current values
|
| double ma[3], maFast[3], maSlow[3];
|
|
|
| if(m_ma.GetData(0, 3, 0, ma) != 3 ||
|
| m_maFast.GetData(0, 3, 0, maFast) != 3 ||
|
| m_maSlow.GetData(0, 3, 0, maSlow) != 3) {
|
| Print("Failed to get indicator data");
|
| return false;
|
| }
|
|
|
| // Get ATR value for volatility
|
| double atr[1];
|
| if(m_atr.GetData(0, 1, 0, atr) != 1) {
|
| Print("Failed to get ATR data");
|
| return false;
|
| }
|
|
|
| // Simple crossover strategy
|
| if(maFast[0] > maSlow[0] && maFast[1] <= maSlow[1]) {
|
| // Bullish crossover
|
| signal.type = SIGNAL_TYPE_BUY;
|
| signal.price = m_symbol.Ask();
|
| signal.sl = signal.price - (atr[0] * m_atrMultiplier);
|
| signal.tp = signal.price + (2 * atr[0] * m_atrMultiplier); // 1:2 risk-reward
|
| signal.strength = 0.7; // Example strength
|
| signal.comment = "Bullish MA Crossover";
|
| }
|
| else if(maFast[0] < maSlow[0] && maFast[1] >= maSlow[1]) {
|
| // Bearish crossover
|
| signal.type = SIGNAL_TYPE_SELL;
|
| signal.price = m_symbol.Bid();
|
| signal.sl = signal.price + (atr[0] * m_atrMultiplier);
|
| signal.tp = signal.price - (2 * atr[0] * m_atrMultiplier); // 1:2 risk-reward
|
| signal.strength = 0.7; // Example strength
|
| signal.comment = "Bearish MA Crossover";
|
| }
|
|
|
| signal.time = TimeCurrent();
|
| return (signal.type != SIGNAL_TYPE_NONE);
|
| }
|
|
|
| //+------------------------------------------------------------------+
|
| //| Convert signal type to string |
|
| //+------------------------------------------------------------------+
|
| string CSignalGenerator::SignalTypeToString(ENUM_SIGNAL_TYPE type) {
|
| switch(type) {
|
| case SIGNAL_TYPE_BUY: return "BUY";
|
| case SIGNAL_TYPE_SELL: return "SELL";
|
| case SIGNAL_TYPE_CLOSE: return "CLOSE";
|
| default: return "NONE";
|
| }
|
| }
|
