I will code your EAs and Indicators for no charge

Thanks so much, my friend! I tried searching on Google first of all, but I got the same results. I have the same EA, but it's under a different name, and I can't seem to find a link to the author's contact information. I really love it, but I'd like to add some more functions. I'll try to make something similar. Thanks so much for your help!

I will, thanks. Green pips, mate!

Hello Master,


While changing time frame getting array out of range in VWAP-RSI-Cross,mq5 (111,27).

Could someone please help on this request.


Thanks in advance. God Bless you.

Hello everyone.

In my search for the appropriate step for the Ma indicator (posted earlier), I came across these parameters, which the Artificial intelligence says are the ones I can use.

Testing Considerations
Smaller values (such as 0.236 and 0.382) will be more reactive and can align better with fast crossovers.
Larger values (such as 0.618 and 1.000) will behave more smoothly.

The Ma indicator I use comes with a default value of 0.5.
If any of the scholars on this forum could confirm if what they say is correct, I would be immensely grateful.

Thank you and have a very nice day.

Dear coders and mentors,
i posted 1 request here and it is delted by moderators i think,please dm me to help me please,it is superb project,thanking you .

Change this


to this

Can somebody make the alerts trigger only when both the 1min and 5min timeframes meet the conditions?

That was decompiled. Find the original version and/or hit up the original developer.

Thanks a lot sir. But the source which was downloaded has lot of errors. Could you please help.

please any idea why a regular Auto stoploss EA will not work on a broker platform with a 50pip stop/tp? do such platform require special EA?
only a particular broker its not working but EA is smiley face, if i manually set stop it works
i appreciate any input

The problem is that you either don't have or you didn't update the neccessary libraries:
JB-Indicator.mqh
JB-Array.mqh
which you will find there:
https://github.com/jblanked/MQL-Libr...e/main/Include

If you have the source code, you need those libraries.
If you only had the .ex4 file, you wouldn't need those libraries, because they would alredy have been compiled into the .ex4 file.

You know, if you can't show any messages from the log, or there aren't any messages and there should be messages, then the best solution is to call your broker's client support and ask them.
Also, what is a "regular Auto stoploss EA" ???
If we don't know what method is used to set the auto stoploss, and what method is required by the broker's server, then how can we answer your question?
You provide zero information which could be helpful to solve the problem, you fail to take the basic, logical action (contact your broker), and what do you expect?
A miracle???

thanks so much for your input

Summary of the Trailing Stop Issue in the EA
Issue Description:
I am experiencing an issue with our trailing stop functionality. When a signal is processed, the EA opens orders with a comment that should have the following format:
[GID:1005|TP1:3219.00|SL:3228.00]
However, in some cases, the stop-loss value in the order comment is being modified unexpectedly. For example, instead of “SL:3228.00”, the comment ends up as “SL:322[tp]” (or similar variants), and as a consequence, the trailing stop parser fails to extract a valid numeric stop-loss value. This leads to the trailing stop logic being unable to modify open orders, which is confirmed by messages like:
--> Potential TP Trigger Found! Order #156373580 Comment: [GID:1005|TP1:3219.00|SL:322[tp]] Parse FAILED for closed order #156373580!
Check comment format.
Environment Overview:

1. EA Code (MQL4):
   The Expert Advisor processes signals by reading a file (signals.txt) containing the signal parameters. It then opens orders with a comment that includes the group ID (GID), TP1, and Stop Loss values. When a trailing stop condition is met (for example, an order closes at its take profit), the EA parses the comment to extract the original signal’s stop-loss value. The trailing stop logic calculates a new SL (typically the midpoint between the order’s execution price and the original signal SL) and then applies it to the remaining open orders in that group.
   In our case, the trailing stop code fails because the comment string is malformed (e.g., "SL:322[tp]") due to the unexpected insertion of "[tp]".
2. Queue Manager (Python):
   The queue_manager.py script is responsible for formatting the signal data into a specific string format before appending it to the queue file. The expected format is:
   makefile
   Másolás
   {signal_type}|{symbol}|{entry}|{TP1,TP2,TP3}|{stop_loss}|{lot_size}|GID:{group_id}
   Our testing shows that signals processed by the Python side are output in the correct format (e.g., “Stop loss at 3228”) before being queued.
   However, if any unexpected characters (such as “[tp]”) become part of the stop loss value during input or logging, they can propagate into the final queue message.
3. Signal Parser and Signal Processor (Python):
   These modules parse the raw text signal (from Telegram, for example) and format the data correctly before adding them to the queue. Our logs indicate that the Python code correctly parses a signal like:
   yaml
   Másolás
   SELL XAUUSD ENTRY 3221 Take profit 1 at 3219 Take profit 2 at 3217 Take profit 3 at 3215 Stop loss at 3228
   and produces the expected numeric values.

Analysis & Potential Causes:

1. Input Signal Formatting Issue:
   It is possible that the raw signal text (perhaps copied from Telegram) sometimes includes extraneous characters or formatting artifacts (such as “[tp]”)—especially if users inadvertently include extra information or if the mobile client applies formatting. Although the Python parser is designed to handle known formats, unexpected substrings in the "Stop loss" line could lead to a partially parsed value. For instance, if the raw text were “Stop loss at 322[tp]8” instead of “3228”, the Python parser might extract “322” and discard the rest, or the extra characters may be appended later by the EA.
2. EA Comment Construction or Parsing:
   The EA builds the order comment using a concatenation of the signal data (including stop loss). Our EA code does not intentionally add “[tp]” into the comment. Therefore, if the comment string ends up as “SL:322[tp]”, then the source of “[tp]” is likely coming either from the raw signal file or an unintended string manipulation (e.g., a substring extraction error) in the trailing stop parsing function.
   
   
   Conclusion:
   The trailing stop error appears to be due to an unexpected substring (“[tp]”) in the order comment's stop loss field. This prevents the EA’s trailing stop parser from converting the stop loss value to a numeric value, thereby causing the trailing stop modification to fail. The issue is likely related to either user input/formatting or inadequate sanitization of the raw stop loss string.
   
   i will copy the corresponding python files:
   
   
   Inserted Code

   # --- signal_parser.py  ---
    
   import re
    
   def parse_signal(text: str):
       """
       Parses signal text into a dictionary. Handles known formats.
    
       Example Format:
       BUY BTCUSD
       ENTRY 89300.00
       Take profit 1 at 89500.00
       Take profit 2 at 89800.00
       Take profit 3 at 90300.00
       Stop loss at 88600.00
    
       Returns dict with keys:
       signal_type, symbol, entry, take_profits (list), stop_loss
       or None if parsing fails or essential info is missing.
       """
       if not text: return None # Handle empty input
       lines = text.splitlines()
       signal = {}
       tp_found = [False, False, False] # Track found TPs
    
       for line in lines:
           line = line.strip()
           if not line: continue # Skip empty lines
    
           # Signal Type and Symbol (Expects on first non-empty line usually)
           if not signal.get("signal_type"): # Only parse if not already found
                # Match BUY/SELL at the start, followed by symbol
               match_type_symbol = re.match(r'^(BUY|SELL)\s+([\w\.\/\-]+)', line, re.IGNORECASE)
               if match_type_symbol:
                   signal["signal_type"] = match_type_symbol.group(1).upper()
                   signal["symbol"] = match_type_symbol.group(2).upper()
                   continue # Move to next line once type/symbol found
    
           # Entry Price
           if not signal.get("entry"):
               m = re.search(r'ENTRY\s*(?:at)?\s*([\d]+\.?[\d]*)', line, re.IGNORECASE)
               if m:
                   try:
                       signal["entry"] = float(m.group(1))
                       continue
                   except ValueError:
                       print(f"Warning: Invalid number for ENTRY: {m.group(1)}")
    
           # Take Profits
           for i in range(1, 4):
               if not tp_found[i-1]: # Only parse if not already found
                   # Allow variations like "TP1", "Take Profit 1", "Take profit1"
                   tp_pattern = r'(?:TAKE\s*PROFIT|TP)\s*' + str(i) + r'\s*(?:at)?\s*([\d]+\.?[\d]*)'
                   m = re.search(tp_pattern, line, re.IGNORECASE)
                   if m:
                       try:
                           # Initialize take_profits list if first TP is found
                           if "take_profits" not in signal:
                                signal["take_profits"] = [None, None, None]
                           signal["take_profits"][i-1] = float(m.group(1))
                           tp_found[i-1] = True
                           # Found a TP on this line, continue to next line
                           # (avoid accidentally matching SL as TP if format is weird)
                           # Use 'break' if one line can only contain one piece of info
                           # Use 'continue' if one line *might* contain multiple (less likely for signals)
                           continue
                       except ValueError:
                           print(f"Warning: Invalid number for TP{i}: {m.group(1)}")
    
           # Stop Loss
           if not signal.get("stop_loss"):
                # Allow "Stop loss", "Stoploss", "SL"
                sl_pattern = r'(?:STOP\s*LOSS|SL)\s*(?:at)?\s*([\d]+\.?[\d]*)'
                m = re.search(sl_pattern, line, re.IGNORECASE)
                if m:
                    try:
                        signal["stop_loss"] = float(m.group(1))
                        continue
                    except ValueError:
                         print(f"Warning: Invalid number for Stop Loss: {m.group(1)}")
    
       # Final Validation: Check if all essential parts were found
       if ("signal_type" in signal and
           "symbol" in signal and
           "entry" in signal and
           "take_profits" in signal and
           all(tp is not None for tp in signal.get("take_profits", [])) and # Ensure all 3 TPs were found
           "stop_loss" in signal):
           return signal
       else:
           # Log which parts are missing if debugging is needed
           missing = [k for k in ["signal_type", "symbol", "entry", "take_profits", "stop_loss"] if k not in signal or (k == "take_profits" and not all(tp is not None for tp in signal.get("take_profits", [])))]
           print(f"Debug: Signal parsing incomplete. Missing or invalid parts: {missing}. Original text: {text[:100]}...")
           return None

   ------------------------------------------------------------------------------------------------
   
   Inserted Code

   # signal_processor.py
    
   from signal_parser import parse_signal
   from risk_manager import calculate_lot_size
   from queue_manager import add_signal_to_queue
    
   def process_signal(text: str):
       """
       1) parse_signal: kinyeri a paramétereket
       2) lot méret számítása
       3) queue-ba helyezés
       """
       parsed = parse_signal(text)
       if not parsed:
           print(f":warning: Érvénytelen signal formátum: {text}")
           return
    
       # Kinyerjük az adatokat
       signal_type = parsed["signal_type"]
       symbol = parsed["symbol"]
       entry_price = parsed["entry"]
       take_profits = parsed["take_profits"]
       stop_loss = parsed["stop_loss"]
    
       # Lot méret kiszámítása
       lot_size = calculate_lot_size(entry_price, stop_loss)
    
       # Végleges signal_data
       signal_data = {
           "signal_type": signal_type,
           "symbol": symbol,
           "entry": entry_price,
           "take_profits": take_profits,
           "stop_loss": stop_loss,
           "lot_size": lot_size
       }
    
       # Várólistához adás
       add_signal_to_queue(signal_data)
       print(f":white_check_mark: Signal feldolgozva és queue-ba helyezve: {signal_data}")

   ---------------------------------------------------------------------------------
   
   Inserted Code

   # -*- coding: utf-8 -*-
   """
   queue_manager.py
    
   Feladata:
   - A parsed (feldolgozott) signal_data adatait a queue-ba (fájlból) írja (add_signal_to_queue).
   - A queue tartalmát pedig (process_signal_queue) átemeli a signals.txt-be, ha az EA éppen nem használja,
     vagyis ha a signals.txt nem létezik.
    
   Változtatások / Refaktorálás:
   - Részletes docstringek
   - Hibakezelés bővítése
   - Extra log beépítése, ha mégis lenne valami furcsa karakter a kiírt sorokban
   - Minimális formátum-ellenőrzés a queue-ba íráskor
   - Mindkét függvényben robust logolás, traceback, rövid kommentek
   """
   import os
   import time
   import traceback
   import json
   from config import MT4_QUEUE_FILE_PATH, MT4_SIGNAL_FILE_PATH
    
   def add_signal_to_queue(signal_data: dict) -> bool:
       """
       Feladata, hogy a 'signal_data' dict tartalmából elkészítse azt a sort,
       amit a queue-fájlba (MT4_QUEUE_FILE_PATH) fűz hozzá.
       A paraméterekből létrehoz egy 'message' stringet:
         "{signal_type}|{symbol}|{entry}|{tp1,tp2,tp3}|{stop_loss}|{lot_size}|GID:{group_id}"
    
       Kötelező kulcsok a 'signal_data'-ban:
         - signal_type: str (BUY/SELL)
         - symbol: str pl. "XAUUSD"
         - entry: float
         - take_profits: list (>=3 elem), pl. [3219,3217,3215]
         - stop_loss: float
         - lot_size: float
         - group_id: int  (Python generálja)
    
       Visszatér:
         True, ha sikeres
         False, ha hiba történt vagy hiányos adatok
       """
       try:
           # 1) Alap ellenőrzés
           required_keys = ["signal_type", "symbol", "entry", "take_profits",
                            "stop_loss", "lot_size", "group_id"]
           if not all(key in signal_data for key in required_keys):
               print(f":x: [QueueAdd] Hiányzó kulcsok. Van: {list(signal_data.keys())}, Kellene: {required_keys}")
               return False
    
           # 2) TPs ellenőrzés
           tps = signal_data["take_profits"]
           if not isinstance(tps, list) or len(tps) < 3:
               print(f":x: [QueueAdd] Érvénytelen take_profits: {tps}")
               return False
    
           # 3) Sor összerakása
           tp_str = ",".join(str(tp) for tp in tps)
           message = (f"{signal_data['signal_type']}|{signal_data['symbol']}|{signal_data['entry']}|"
                      f"{tp_str}|{signal_data['stop_loss']}|{signal_data['lot_size']}|"
                      f"GID:{signal_data['group_id']}\n")
    
           # 4) I/O művelet: Hozzáfűzés a queue-fájlhoz
           with open(MT4_QUEUE_FILE_PATH, "a", encoding='utf-8') as f:
               f.write(message)
    
           # Logolás
           print(f":white_check_mark: [QueueAdd] Hozzáadva a queue fájlhoz ('{os.path.basename(MT4_QUEUE_FILE_PATH)}'): {message.strip()}")
           return True
    
       except Exception as e:
           print(f":x: [QueueAdd] Végzetes hiba: {e}")
           traceback.print_exc()
           return False
   
    
   def process_signal_queue() -> None:
       """
       Feladata, hogy a queue-fájlból kivesz egy (nem üres) sort,
       és ha a signals.txt nem létezik (vagyis az EA nincs épp busy), akkor
       azt a sort beírja a signals.txt-be, majd kiveszi a queue-fájlból.
    
       További részletek:
       - Ha a queue üres, vagy nincs érvényes sor, kilép
       - Ha a signals.txt már létezik, nem ír bele semmit (EA még dolgozza fel?), kilép
       - Ha van érvényes sor, beírja a signals.txt-be, a queue-ból pedig törli azt a sort
       """
       try:
           # 1) Gyors ellenőrzés: queue létezik-e, van-e benne tartalom
           if not os.path.exists(MT4_QUEUE_FILE_PATH) or os.path.getsize(MT4_QUEUE_FILE_PATH) == 0:
               return  # Nincs semmi a queue-ban
           # 2) signals.txt létezésének ellenőrzése
           if os.path.exists(MT4_SIGNAL_FILE_PATH):
               # Az EA még valószínűleg nem dolgozta fel az előző jelet
               return
    
           lines = []
           next_signal = None
           first_valid_line_index = -1
    
           # 3) Beolvassuk a queue file sorait
           with open(MT4_QUEUE_FILE_PATH, "r", encoding='utf-8') as f:
               lines = f.readlines()
           if not lines:  # semmi nincs benne
               return
    
           # 4) Megkeressük az első nem üres sort
           for i, line in enumerate(lines):
               line_stripped = line.strip()
               if line_stripped:
                   next_signal = line_stripped
                   first_valid_line_index = i
                   break
    
           if next_signal is None:
               # minden sor üres, akkor resetelhetjük a file-t
               if all(not line.strip() for line in lines):
                   open(MT4_QUEUE_FILE_PATH, 'w', encoding='utf-8').close()
               return
    
           # 5) Megpróbáljuk írni a signals.txt-be
           # Ha közben a signals.txt létrejött, azaz az EA (vagy más) is...
           # de a fenti if ezt már lekezelte, feltételezzük, hogy most még nincs signals.txt
           try:
               with open(MT4_SIGNAL_FILE_PATH, "w", encoding='utf-8') as f:
                   f.write(next_signal)
           except IOError as e:
               print(f":x: [Queue->EA] Hiba signals.txt írásnál: {e}")
               return
    
           # 6) Töröljük az első érvényes sort a queue-ból
           try:
               with open(MT4_QUEUE_FILE_PATH, "w", encoding='utf-8') as f:
                   if first_valid_line_index + 1 < len(lines):
                       f.writelines(lines[first_valid_line_index + 1:])
               print(f":outbox_tray: [Queue->EA] Szignál -> EA fájl ('{os.path.basename(MT4_SIGNAL_FILE_PATH)}'): {next_signal}")
           except IOError as e:
               print(f":x: [QueueUpdate] Kritikus hiba a queue frissítésnél: {e}")
               return
    
       except Exception as e:
           print(f":x: [QueueProc] Általános hiba a queue feldolgozásakor: {e}")
           traceback.print_exc()

That's a lot of code and I didn't read all of it. But, the broker sometimes adds [sl], [tp], and a few others things. You should add functionality in your python code to handle those.

Also, it's faster to use a Telegram reader/sender in MQL to process/send Telegram signals instead of python

The "[tp]" and "[sl]" is automatically added to the comment by the broker's server.
So, if you are using the comment to extract data, you need to either search for a specific substring, or add those to the search string.

really no one?

anybody that can do this? i've been trying doing it through AI for days but it doesnt do the job somehow...

You should first write out your conditions specifically. Images rarely help.

the conditions are already coded, you just need to add the 1min and 5min part.....