Implementing strategy based on arrow-type indicator code and integrate with Multi strategy

[mavidelisi]

Hello Kenorb

I would like to thank you for the EA31337 source code updates.

I have integrated the Meta Multi Strategy that you published earlier into the system and compiled it successfully right now.
It works without any problems. I have one indicator in my hand and the source code is open. I can give it to you if you want. It has a very simple formula, but
I have not managed to figure out how to create a strategy. Indicators that are already in the system are used. The indicator source code is as follows.

Code:

#property indicator_buffers 4
#property indicator_separate_window

extern int    NumberOfBars    = 100;
extern double SlopeThreshold  = 2.0;
extern int    SlopeMAPeriod   = 7; 
extern int    SlopeATRPeriod  = 50; 

extern color SlopeColor = Gray;
extern color LongColor  = Lime;
extern color ShortColor = Red;

double Slope[];
double Long[];
double Short[];
double Flat[];

int OnInit()
{
   IndicatorShortName(WindowExpertName());

   SetIndexBuffer(0,Slope);
   SetIndexBuffer(1,Long);
   SetIndexBuffer(2,Short);
   SetIndexBuffer(3,Flat);

   SetIndexStyle(0,DRAW_LINE,STYLE_SOLID,1,SlopeColor);  SetIndexLabel(0,"Slope");
   SetIndexStyle(1,DRAW_ARROW,STYLE_SOLID,1,LongColor);  SetIndexLabel(1,"Long");  SetIndexArrow(1,159); 
   SetIndexStyle(2,DRAW_ARROW,STYLE_SOLID,1,ShortColor); SetIndexLabel(2,"Short"); SetIndexArrow(2,159); 
   SetIndexStyle(3,DRAW_ARROW,STYLE_SOLID,1,SlopeColor); SetIndexLabel(3,"Flat");  SetIndexArrow(3,159); 
   
   SetLevelStyle(STYLE_SOLID,1,SlopeColor);
   SetLevelValue(0, SlopeThreshold*0.5);
   SetLevelValue(1,-SlopeThreshold*0.5);

   return(INIT_SUCCEEDED);
}


int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
   int limit=MathMin(NumberOfBars,rates_total-prev_calculated);
   if(limit==rates_total) limit--;

   for(int shift=limit; shift>=0; shift--)
   {
      Slope[shift]=0;
      
      double dblTma,dblPrev;
      double atr=iATR(NULL,Period(),SlopeATRPeriod,shift+10)/10;
      
      if(atr!=0)
      {
         dblTma = iMA(NULL,Period(),SlopeMAPeriod,0,MODE_LWMA,PRICE_CLOSE,shift);
         dblPrev=(iMA(NULL,Period(),SlopeMAPeriod,0,MODE_LWMA,PRICE_CLOSE,shift+1)*231 + iClose(NULL,Period(),shift)*20)/251;
         Slope[shift]=(dblTma-dblPrev)/atr;
      }
      
      Long[shift] =EMPTY_VALUE;
      Short[shift]=EMPTY_VALUE;
      Flat[shift] =EMPTY_VALUE;
     
      if(Slope[shift]> SlopeThreshold*0.5) Long[shift] =Slope[shift]; else
      if(Slope[shift]<-SlopeThreshold*0.5) Short[shift]=Slope[shift]; else
      Flat[shift]=Slope[shift];
   }
   
   return(rates_total);
}

As you can see above, the Moving average and ATR indicator are used. I want to combine it with the Meta Multi strategy and create the startup in my mind.

1 - dblTma = iMA(NULL,Period(),SlopeMAPeriod,0,MODE_LWMA,PRICE_CLOSE,shift); How can I get data from the Moving average indicator for the line.
2 - double atr=iATR(NULL,Period(),SlopeATRPeriod,shift+10)/10; how can I read the data from the ATR indicator for the line. There is already an ATR strategy in the system, but if I want to read the manual, can you give 1-2 examples in coding?
3 - 1. and 2. if the items are successful, I will modify the Meta Multi startup strategy and create the strategy in my mind.
4 - How are the positions closed in the reverse operation when the signal arrives? In other words, when the buy position is open, when the sell signal is received, it should automatically close the buy position and open the sell position.
5 - Can we integrate the indicator mentioned above into the system ? May our other friends also benefit.

Thank you, I wish you good work.

[kenorb]

1. If you'd like to read value from dblTma, its value needs to be exposed through the external buffer. Same way what you've for Slope[], Long[], Short[] and Flat[]. These array variables are set as buffer via SetIndexBuffer() so they can be accessible from EA for the given index mode.
2. It's the same here. The existing ATR strategy it's using a wrapper class Indi_ATR to communicate with platform builtin ATR indicator (::iATR) to read its buffers. In MT5 platform you can find the source code of ATR in Indicators/Examples directory, where you will find the values are assigned to array variables and using SetIndexBuffer() you're informing platform that this value can be read externally (e.g. in EA). However I don't think you need to read these raw indicator values at the end, since you're calculating different values such as Slope, so it's enough to build the strategy.
3. You really don't need Meta Multi strategy for that, the aim of it is to run multiple strategies in the same timeframe, so using it at this point, it'll only overcomplicate the process of conversion. You've to first convert the indicator into strategy, then it's going to be integrated into EA, and Meta Multi will see it, the same as EA, so it doesn't matter which meta strategies you'll use, or not.
4. By default opposite signals are also closing signals for the their opposite orders. So yes, currently by default when you receive buy position, sell positions are going to closed. It's something that can be override on strategy code level, and in near future, this can be customizable through the signal filter.
5. Sure, I'll look into this and post (in this thread) the step-by-step conversion guide given this example. Once you do it once, should be easy enough to follow.

[mavidelisi]

let me try a little. I hope I can solve it. thanks

[kenorb]

The thing is, this can be implemented in multiple ways, and I'm always looking to generalize solutions, so one way is to use Strategy-Indicator where you can specify in params external file path to indicator, but there is not customization for choose which modes are for sell or buy. Another way is to create Arrows-like strategy (since indicator have short and long buffers), choose which buffers are for buy or sell, then it can work with multiple similar indicators, not just one. I'll look into it as well.
The good start is to clone Strategy-Demo repo as a template, rename the name, add indicator wrapper class (similar to Indi_TMA_True.mqh) and correct the code, that's the quickest route. And I'll check if I can implement more generic strategy Arrows to handle these type of indicators (because this type of buffers usually are designed to plot arrows).

[mavidelisi]

Hi, Kenorb . I figured out how to create my manual strategy. Just how can I close the reverse position. I've scanned all the source code you've written. I also understood all the necessary functions and parameters. I just couldn't figure out how to interfere with the close filters to close the reverse position and add the function. Is it okay if I start with close filters? Will you show me the way? Thanks

[kenorb]

To override default closing signal logic, you can define SignalClose() in your strategy (the arguments should match the same structure), so it'll override the one defined in Strategy. See: https://github.com/EA31337/EA31337-classes/blob/v2.013/Strategy.mqh#L967-L969 (copy from there into your strategy's .mqh file, then remove virtual keyword and write your own logic).

[kenorb]

To implement indicator into strategy, what I did are these steps:

1. I've used Strategy-Demo as a template to create a new Strategy-Arrows repository.

2. After cloning, I've renamed all Demo references to Arrows. I've used these commands:

   rename -v s/Demo/Arrows/ *Demo*.mq? # Rename files
   sed -i'.bak' "s/Demo/Arrows/g;s/demo/arrows/g;s/DEMO/ARROWS/g" Stg* **/*.* .github/workflows/*.yml # Replace Demo to Arrows
   find . -name '*.bak' -type f -delete -print # Removes .bak files
   clang-format -i *.mq? # Reformats code
   git add . # Stage files for git
   pre-commit run -a # Additional validation tests to run
   git commit -m'Renames Demo to Arrows' -a # Commit git changes
   git push origin # Pushed changes to git repo
   

   Note: At this point, the code upon compilation it will point to non-existing indicator, so the next point going to correct that.

3. I've added given indicator, called it ATR_MA_Slope.mq4 and placed it in EA31337-indicators-other repo (dev branch at the time of writing) at Oscillators/Arrows/ location (based on its type).

4. Since I'm using MT5, I've added a wrapper code ATR_MA_Slope.mq5 which can load MQL4 code from it. It's a standard code utilizing EA31337 framework which it's widely used across that EA31337-indicators-other repository. I've copied it from TMA_True.mq5, renamed and replaced name with few adjustments (specific to given indicator) as seen in EA31337/EA31337-indicators-other@710b4f4. This allows to run MQL4 indicator code under MQL5. The conversion can be tricky sometimes, but if you follow the other examples, most of the techniques are already covered. It's actually difficult to make a simple steps out of it, because this depends on the indicator. Usually the aim of the wrapper is to make as little changes to the original code as possible. Although I still had to do some slight changes.

5. In Arrows strategy repo, I've cloned EA31337-indicators-other repo as git submodule, so its indicator is tracked within that repository (so it "knows" which version of indicator to use). EA31337/Strategy-Arrows@8d7b673 (git submodule add --name indicators-other https://github.com/EA31337/EA31337-indicators-other.git indicators-other).

6. I've created Indi_ATR_MA_Slope class (copied mainly from Indi_TMA_True.mqh as starting code), renamed name and added few changes (enums, params, getters and setters specific to indicator, etc.) and integrated it with the new indicator. Indicator classes helps with communication between indicator and strategy, so strategy knows how to retrieve data from it using a simplified code. Here is the change: EA31337/Strategy-Arrows@f558291

   Few extra code comments related to Indi_ATR_MA_Slope.mqh:

   • ENUM_ATR_MA_SLOPE_MODE is enum and its items are corresponding to buffer's indexes set in indicator using SetIndexBuffer(). It's not mandatory, but it helps with readability when accessing indicator values, e.g. _indi[ishift][ATR_MA_SLOPE_LONG], instead of figuring out which index value to use.
   • IndiAtrMaSlopeParams structure defines variables which corresponding to the same indicator inputs (the one with extern). This helps strategy to track internally the values (using getters) and potentially changing its values (setters). In general the struct should introduce the same amount of extern variables set by indicator.
   • IsValidEntry() is the method which determines validity of the individual indicator entry. It depends on the platform and indicator. E.g. for some 0 is a valid value, for some other it's an empty value (meaning it's invalid entry). This helps to detect problems with indicators (low number of bars, calculation issues or other issues) which could result in unpredictable signal behaviour. For example RSI indicator ranges from 0-100, so anything outside of range should be threated as invalid value (so if your signal condition for buy is < 20, you don't want to open it on NULL/0, or sell condition value > 80 when the value is invalid as DBL_MAX). So you need to understand what kind of values your indicator is going to produce in order to write this method correctly. By default NULL (same as 0) and DBL_MAX values are threated as invalid.

7. I've fixed some automatic tests so strategy can be backtested by GitHub action automatically on each change using MT4: EA31337/Strategy-Arrows@3763b7f. Test runs can be found at https://github.com/EA31337/Strategy-Arrows/actions.

8. In summary, these are the changes which were required after renaming Demo strategy: https://github.com/EA31337/Strategy-Arrows/pull/1/files

9. Initial version of strategy is ready for testing, you can clone it with:

   git clone --recursive https://github.com/EA31337/Strategy-Arrows
   

   Note: This also requires cloning https://github.com/EA31337/EA31337-classes (v3.000.1) into MQL's Includes/ directory.

10. Compile .mq4/.mq5 file from the platform's editor and run it.

11. Once strategy is more tested and stable, I'll include it into EA31337-strategies repo. This will allow strategy to be included into Meta Multi strategy which will read the list of strategies and integrated into the main EA code. If you'd like to add it on your own, you'll have to modify enum list of all strategies present and potentially few other changes.

Initially I've tried this condition for signal for buy: _indi[_ishift][(int)ATR_MA_SLOPE_LONG] > 0, and _indi[_ishift][(int)ATR_MA_SLOPE_SHORT] > 0 for sell, however for some reason these long and short values aren't received in MT5 (I'm not sure why, it's something to debug). I'll try to do more improvements at the next convenient time and include it into the next EA release.

The aim of this Arrows strategy is to be generic handler for these type of arrow-type indicators, as I don't want to end up with hundreds of cloned strategies basically doing the same, and using generic strategy the same signal logic can be re-used for other. You can extend it or propose fixes if you like it. Or use as the example to design your own unique strategy.

[mavidelisi]

you have explained it very clearly . Thank you so much. I will test the strategy and get back to you

[mavidelisi]

Hello, Kenorb. Thank you so much for sharing the very valuable source code for us. I think they may have directly tested the source code you shared and touted the robot as bad because they didn't succeed. There is a great intelligence in the robot. and I tried for 6 months to figure it out, and I may have solved almost the entire system. I have successfully integrated the ATR Ma slope indicator into the master source code, which is the latest version, and it is working successfully. You can check it out if you want. I can share with you whether I did right or wrong. I just have a question that's been bothering me. How can I use 60 lwma and 240 lwma values simultaneously at multiple times using the moving average indicator. ? For example, I want to use 240 lwma and 60 lwma on the daily chart, while using 20 ema on the hourly chart. The situation that should be considered here is that when I call the moving average strategy, there are both different periods and different parameters. When I review the source code, the constructor is called 1 time when sending parameters to the moving average indicator. do I need to call more than one constructor for different parameters and different periods. I have created a special vip strategy for myself. i have successfully entered the atr ma slope in it, but for the moving average I can only integrate it for the current time period, but how can I enter different time periods and different parameters into the moving average strategy for the 4-hour and daily chart. Can you give me an example with 1-2 lines of code? Thank you very much

[mavidelisi]

For example, when you want to use m5 and H1 ;
SetParamsByTf(_stg_params, _tf, stg_arrows_m5, stg_arrows_h1); is this how I will use it. where can I debug whether the m5 and h1 periods are working? Is the written code below correct? Some of the code written below has been modified. It works without problems, I just want to use the SetParamsByTf function correctly, the method you gave. Can you check it out for me?

class Stg_Arrows : public Strategy {
 public:
  Stg_Arrows(StgParams &_sparams, TradeParams &_tparams, ChartParams &_cparams, string _name = "")
      : Strategy(_sparams, _tparams, _cparams, _name) {}

  static Stg_Arrows *Init(ENUM_TIMEFRAMES _tf = NULL, EA *_ea = NULL) {
    // Initialize strategy initial values.
    Stg_Arrows_Params_Defaults stg_arrows_defaults;
    StgParams _stg_params(stg_arrows_defaults);
#ifdef __config__
    SetParamsByTf<StgParams>(_stg_params, _tf, stg_arrows_m5, stg_arrows_h1);
    Print("Setby tmieframe config...");
#endif
    // Initialize indicator.
    // Initialize Strategy instance.
    ChartParams _cparams(_tf, _Symbol);
    TradeParams _tparams;
    Strategy *_strat = new Stg_Arrows(_stg_params, _tparams, _cparams, "Arrows");
    return _strat;
  }

  /**
   * Event on strategy's init.
   */
  void OnInit() {
    IndiAtrMaSlopeParams _indi_params(::Arrows_Indi_ATR_MA_Slope_NumberOfBars,
                                      ::Arrows_Indi_ATR_MA_Slope_SlopeThreshold,
                                      ::Arrows_Indi_ATR_MA_Slope_SlopeMAPeriod,
                                      ::Arrows_Indi_ATR_MA_Slope_SlopeATRPeriod, ::Arrows_Indi_ATR_MA_Slope_Shift);
    _indi_params.SetTf(Get<ENUM_TIMEFRAMES>(STRAT_PARAM_TF));
    SetIndicator(new Indi_ATR_MA_Slope(_indi_params));
  }

  /**
   * Check strategy's opening signal.
   */
  bool SignalOpen(ENUM_ORDER_TYPE _cmd, int _method, float _level = 0.0f, int _shift = 0) {
    Indi_ATR_MA_Slope *_indi = GetIndicator();
    int _ishift = _shift + ::Arrows_Indi_ATR_MA_Slope_Shift;  // @fixme: Improve logic.
    bool _result = _indi.GetFlag(INDI_ENTRY_FLAG_IS_VALID, _ishift) && _indi.GetFlag(INDI_ENTRY_FLAG_IS_VALID, _ishift + 1);
    if (!_result) {
      // Returns false when indicator data is not valid.
      return false;
    }
    IndicatorSignal _signals = _indi.GetSignals(4, _shift);
    //double _long = _indi[_ishift][(int)ATR_MA_SLOPE_LONG];
    //double _short = _indi[_ishift][(int)ATR_MA_SLOPE_SHORT];
    switch (_cmd) {
      case ORDER_TYPE_BUY:
        // Buy signal.
        // @fixme
        _result &= _indi[_ishift][(int)ATR_MA_SLOPE_LONG] > 0 && _indi[_ishift][(int)ATR_MA_SLOPE_LONG] != DBL_MAX;
        _result &= _indi.IsIncreasing(1, ATR_MA_SLOPE_LONG, _ishift);
        //_result &= _indi.IsIncByPct(_level / 10, 0, _shift, 2);
        _result &= _method > 0 ? _signals.CheckSignals(_method) : _signals.CheckSignalsAll(-_method);
        break;
      case ORDER_TYPE_SELL:
        // Sell signal.
        // @fixme
        _result &= _indi[_ishift][(int)ATR_MA_SLOPE_SHORT] < 0 && _indi[_ishift][(int)ATR_MA_SLOPE_SHORT] != DBL_MAX;
        _result &= _indi.IsDecreasing(1, ATR_MA_SLOPE_SHORT, _ishift);
        //_result &= _indi.IsDecByPct(_level / 10, 0, _shift, 2);
         _result &= _method > 0 ? _signals.CheckSignals(_method) : _signals.CheckSignalsAll(-_method);
        break;
    }
    return _result;
  }

[kenorb]

You've to enable/uncomment line with __config__ in config/define.h so the code within directives can be activated, then check the definition of SetParamsByTf() in Strategy.mqh. Currently you're passing stg_arrows_m5, stg_arrows_h1 which is different argument list from that function. Then double that these structs (e.g. stg_arrows_m5) are loaded and exist, they're defined and loaded from config/*.h files. The best if you debug the strategy code using MT5, so you can put some breakpoints there and debug/run the code in real-time, in MT4 debugging is more difficult (although it's still possible when you run debug on real data). When you set the breakpoint, you can check the content of _stg_params struct that values changed per timeframe. Alternatively print with Print(_stg_params.ToString());. These settings are to override strategy params, to override indicator values, you've to use the appropriate setters (if available, as there are still some things to add for flexibility).
The aim of framework is to give full flexibility of configurability and allowing to set or override any value of strategy or indicator from the EA code level, so if you're aiming to set some values, but they're not available, let me know about some specific examples what you're trying to do, so I could have some suggestions.

[mavidelisi]

I have already made the config parameter enable. I also checked the Strategy.mqh file.
when I send stg_arrows_m5 and stg_arrows_h1, does it receive one signal at the same time or does it receive a signal separately.
So does it receive signals from both M5 and H1 separately in SetParamsByTf() function ?
What I want to do is to run the indicator or strategy at the same time at different periods, regardless of the timeframe in any period.
We can already modify the default values with the config parameter.
The mt5 platform is not installed on my computer. But I will install it for debug. I was just wondering if you debug the codes in a different way, that's why I asked you. Debugging on Metatrader is very problematic. That's why I can print and see the values using the Print() function. I use visual studio code to make coding easier.
I know that the framework you have provided is very flexible and configurable, so I am creating my own unique strategies and trying different methods.
I realize that I'm tiring you out by asking you a lot of questions; it would be nicer if I had a document of the codes you wrote.
I learn by writing which codes work by studying the codes, and at the same time I study the individual codes.
I understand from your profile that you write high-quality code, that you are a high-quality programmer by reviewing the codes you have written. I have some experience with C/C++. That's why I'm aware that I'm asking detailed questions. Thank you for answering the questions without getting bored.
I can show the strategy I'm trying to do with a single picture. We have already done the strategy for the ATR Ma Slope. There are only 2 values. i need a strategy that will work on both the m5, h1 and h4 timeframe at 60 lwma and 240 lwma. It is necessary to run 3 different periods and 3 different stg_params configurations within the same strategy. If 3 stg_params parameters are sent (stg_arrows_m5, stg_arrows_h1 and stg_arrows_h4), is it a separate signal or does it combine all three and receive one signal at a time. the result of all 3 parameters must be true, or if one of them is false, the result must be false.
I learned to read bufferindex from the indicator.
I learned to pick up signals from inside the indicator.
I learned to write my own unique functions by overriding the virtual functions that you have written.
I have one indicator in my hand. I'm planning to add extra bufferindex in it and make a modified indicator.
The ATR MA Slope I gave you was a simple indicator. There is also an advanced version of this. You can see it in the picture. I didn't know if it would be right if I shared the indicator here. If I may, I can share it here too. I downloaded it from a another forum.If I can manage to run different configurations and different periods in the same strategy, I believe that I can code the strategy I want for the indicator I want now.
The white line you see in the picture is 240 lwma and the red line is 60 lwma. The indicator just below is an advanced version of the ATR MA Slope indicator. It is combined with the Currency Slope. The only thing missing is to close the reverse position. After determining the strategies for him, I will also add his function, which will close the reverse position. The graph you see in the picture is a 4-hour graph. But I will filter it by adding the 5m and h1 graph to it. As you can see, while the strategy is working in different configurations on the 4-hour chart, it also needs to filter the 5m and h1 strategy at the same time. I don't want him to get different signals. When I am working on strategy in different configurations at different periods at the same time, I need to receive a single signal.

I sent the picture on attach. Can you make a check?

If you see the indicator at the bottom, the chart is 4 hours, but the daily parameters are working. You will see the treshold value on the right side at the bottom. It has a daily treshold value. You understand why I have to run different periods in the same strategy.

As you can see on the indicator at the bottom of the chart, there are red and green areas. I can also filter this by adding treshold. While the sell signal comes in the red areas, the buy signal comes in the green areas. When there is a buying position, if a sell signal comes, the function that will close the reverse position activates and closes the position. At the same time, candles on the 4-hour chart should be below Moving average 60 and 240 lwma. I am planning to open a position with ATR Ma Slope in the 5m chart. I'm also planning to add an RSI or WPR indicator on the H1 chart, or another filtering, whichever is appropriate. In another forum, there are winners who use the strategy manually.

Thank you.

[kenorb]

So does it receive signals from both M5 and H1 separately in SetParamsByTf() function

Different params are loaded per instance (each StgParams belong to one instance of Strategy). SetParamsByTf() was used more to load different default settings per timeframe. We could think more like splitting the existing input values per timeframe. Let's say you've defined input int RSI_Period=16, the value defined in single place for all timeframes. To avoid defining it for 20 different timeframes, like RSI_Period_M1=20, RSI_Period_M5=18 (which v1 releases actually did this way), you can use SetParamsByTf() to load values from different pre-defined struct per given timeframe. So it does not receive signals separately, it's just one set of pre-defined values to load for the given timeframe per instance. And one instance of Strategy cannot have multiple params. It only make sense when you initialize the same Strategy multiple times, and based on its timeframe, it'll load different values. Not sure if that answer the question.

What I want to do is to run the indicator or strategy at the same time at different periods, regardless of the timeframe in any period.

In v2 releases of framework, each instance of strategy is tied/focused per each timeframe, although it's not really a fixed rule, because you can still call built-in chart functions related to any timeframe. Strategy class is just an abstract of layer which theoretically shouldn't know know anything about market and its "knowledge" rely on indicators, and based on the indicator values making the market decision. When Strategy decides it's time to open a trade, it's using Trade instance which is like an access gateway to the current broker's account to trade. And when you've position open, it's really not tied to any timeframe, it's just a price. Timeframe assignment of strategy is just for organization purposes. To access chart in Strategy code, you can still access any timeframe through built-in functions, so it's up to you. The same with indicators, you can initialize any indicator from any timeframe within the same Strategy, it's up to you (to have Strategy on M5, but load indicators from H1 or H2, Strategy doesn't validate or care, it just "sees" data which can analyse). In v3 releases, chart is going to be indicator as well, so strategy can access market data through indicator called chart of the given timeframe producing OHLC values (this will also allow multiple instances of chart, but you don't need it at this point).

asking you a lot of questions

If you think some questions can belong to separate threads with clear set of problems, would be great, for organization purposes and to help others to find the relevant topics.

would be nicer if I had a document of the codes you wrote

The code evolves constantly, so it's difficult to document it. I wanted to generate automatic API docs as per GH-423, but I didn't have time. Currently the documentation is within the code. There is amount of code for the next releases, but needs to be integrated and tested. I think once code is more finalized in terms of architecture, then we can focus on documentation, there are still so many things to implement.

I have some experience with C/C+

In v3 releases, we're trying to make the code compatible with C++, this allows running code outside of the platform.

I need a strategy that will work on both the m5, h1 and h4 timeframe at 60 lwma and 240 lwma.

There is nothing stopping you to initialize indicators on strategy's OnInit() for different timeframes. Strategy just "sees" indicator values, so it doesn't care which timeframe they're running on.

It is necessary to run 3 different periods and 3 different stg_params configurations within the same strategy

You don't need multiple stg_params for multi timeframe indicators. stg_params is more to store general strategy and filter settings, nothing to do with indicators or timeframe. It got tf, but it's just for the point of reference.

If 3 stg_params parameters are sent (stg_arrows_m5, stg_arrows_h1 and stg_arrows_h4), is it a separate signal or does it combine all three and receive one signal at a time. the result of all 3 parameters must be true, or if one of them is false, the result must be false.

It loads one of the params into stg_params (which is one per strategy instance). You shouldn't worry about it much, because you can write your logic in SignalOpen(), and use whatever settings you need. You can also set all filters to 0, and implement extra filters on your own in this method. But this all depends what you're trying to achieve.

I didn't know if it would be right if I shared the indicator here.

You can post it either at https://github.com/EA31337/EA31337-indicators-other/discussions (other=3rd party) or https://github.com/EA31337/EA31337-indicators/discussions (general repo for all kind of indicators), I can include it into the codebase. It would be great to have different variety of indicators.

When I am working on strategy in different configurations at different periods at the same time, I need to receive a single signal.

In general Strategy should produce the signals based on analysis of indicator values. Then EA once receives the signal from strategy, to process it into the position via Trade instance.

I sent the picture on attach. Can you make a check?

Looks fine.
My only comment is, as already mentioned, you should leave indicators to handle different timeframes, and strategy is just to manage and read these indicators' values.

Hope that helps.

[mavidelisi]

I understood everything clearly
Thank you for answering the questions I asked.