Hedging Grid EA

MQL4 Uzmanlar

İş tamamlandı

Tamamlanma süresi: 7 gün
Geliştirici tarafından geri bildirim
Good client, good business
Müşteri tarafından geri bildirim
Good Job

Şartname

Project Overview: Hedging Grid EA
The goal is to create an MQL4 Expert Advisor that employs a hedging grid strategy. This means it will open both buy and sell trades, often simultaneously, and will add to positions at predefined intervals as the price moves.
Core Strategy:
Grid Trading: The EA places new pending orders (BUYSTOP, SELLSTOP) at a set distance from existing trades.
Hedging: It manages buy and sell trades independently, allowing them to run at the same time.
Lot Sizing: It can use a multiplier (martingale-style) or a fixed increment to increase the lot size for new grid orders.
Profit/Loss Management: It closes trades based on several conditions:
Profit target for a single direction (e.g., close all buys).
Combined profit target for both directions (hedged basket).
A hard stop-loss based on total drawdown.
Dynamic Orders: It uses trailing stops on open positions and can also "trail" its pending orders, adjusting their entry price as the market moves.
Visual Interface: The EA displays key information directly on the chart, including profits, average entry prices, and trading signals.
Part 1: EA Settings (Global extern Variables)
These are the user-configurable inputs. The programmer needs to declare these at the top of the file so they appear in the EA's settings window in MetaTrader.
Order Management:
Magic: int - A unique magic number to distinguish this EA's trades from others.
slippage: int - The maximum allowed slippage in points for order execution.
Allow_BUY, Allow_SELL: bool - Master switches to enable or disable buy and sell trading.
Open_order_on_trend: bool - A setting to control grid order placement logic (either with or against the trend).
Lot Sizing:
Order_lotsize: double - The initial lot size for the first trade in a series.
Multiply_lotsize_by: double - A multiplier for the next lot size (e.g., 1.5 for a martingale strategy).
Increase_lotsize_by: double - A fixed amount to add to the next lot size (used if the multiplier is 1.0).
Round_lotsize_to_decimals: int - The number of decimal places to round the lot size to (e.g., 2 for standard lots).
Grid & Order Spacing:
First_step: int - The distance in points from the current price to place the first pending order.
Distance_between_orders: int - The minimum distance in points between orders in the grid.
Minimum_price_distance: int - The minimum distance from the current price for subsequent pending orders.
Move_step: int - The number of points the price must move before a pending order is trailed (modified).
Stop Loss & Take Profit:
Stoploss, Takeprofit: int - The initial Stop Loss and Take Profit in points for each individual order.
Trailing_type: int - The type of trailing stop to use (0 = disabled). The programmer will need to implement the logic for different types if required.
Trailing_step: int - The step, in points, for the trailing stop.
Minimum_trailing_profit: int - The minimum profit in points an order must have before the trailing stop is activated.
Basket Closing Conditions:
Profit_for_closing_1_direction: double - The profit amount in account currency to close all trades in one direction (e.g., close all buys when their total profit reaches $50).
Profit_for_closing_2_directions: double - The profit amount to close all trades (buys and sells) when the combined profit of the hedged basket reaches this target.
Loss_for_closing: double - A negative dollar amount that triggers the closing of all trades in one direction (e.g., close all buys if their total profit reaches -$100).
Maximum_allowed_loss: double - A negative dollar amount that prevents the EA from opening new trades in a direction.
Close_loss_by_drawdown: double - A profit threshold. If the profit of either side drops below this, the EA switches to its "hedged close" logic.
Auto_calculated_profit: double - A setting to automatically calculate the profit target based on lot size and tick value.
Indicators & Timing:
Opening_1_order_on_indicators: bool - If true, the very first order will only be placed if RSI conditions are met.
Timeframe_indicator: int - The timeframe to use for the RSI calculation.
RSI_Period, Oversold_zone, Overbought_zone: int - Standard RSI settings.
Delete_Orders: bool - Enable/disable the scheduled deletion of all orders.
DeleteHour: int - The server hour (0-23) to delete all orders.
Visuals:
Font_size: int - The font size for text displayed on the chart.
Color_information: color - The color for the informational text.
Part 2: Main Program Structure (OnInit, OnDeinit, OnTick)
int OnInit(): This function runs once when the EA is first attached to a chart. Its purpose is to set up the visual display. The programmer should write code here to create all the necessary text objects (OBJ_LABEL) on the chart for displaying Balance, Equity, Profits, etc.
void OnDeinit(const int reason): This function runs once when the EA is removed from the chart. It should contain a cleanup routine to delete all chart objects created in OnInit().
void OnTick(): This is the heart of the EA, running on every new price tick. The programmer should implement this function exactly as it appears in the refactored code, with the main logic flow calling the 9 helper functions in sequence.
Part 3: Helper Function Implementation
The programmer should create each of the 9 functions called by OnTick.
HandleScheduledOrderDeletion(): Simple function. Check the Delete_Orders setting and the current server hour. If they match DeleteHour, call a function to close/delete all orders.
ProcessOpenOrders(...): This is a critical data-gathering function. It must loop through all orders, filter them by the current symbol and magic number, and then calculate all the key metrics (counts, lots, profits, price points) needed by the other functions.
UpdateAveragePriceObjects(...): This function should first delete the old "SLb" and "SLs" arrows from the chart. Then, if buy or sell orders exist, it should create new arrows (OBJ_ARROW with SYMBOL_RIGHTPRICE) at the calculated averageBuyPrice and averageSellPrice.
ApplyTrailingStops(...): Loop through all open trades. For each trade, calculate the potential new trailing stop loss price. If this new price is better than the current one (higher for buys, lower for sells) and meets the minimum profit condition, modify the order using OrderModify().
ManageProfitAndLossClosing(...): Implement the series of if statements to check the various profit and loss conditions against the targets. If a condition is met, it should call the CloseOrders() function with the correct parameter (1 for buys, -1 for sells, 0 for all).
UpdateTradingSignals(...): This function updates the chart labels ("Char.b", "Char.s") that show if trading is allowed. It uses ObjectSetText() with special Wingdings font characters to display green checkmarks or red crosses.
ManagePendingOrders(...): Implement the logic to place new grid orders. This involves calculating the lot size, determining the entry price based on distance rules and RSI, and checking if there is enough free margin before calling OrderSend().
ModifyPendingOrders(...): Implement the "trailing pending order" logic. Calculate the ideal new price for the existing pending order and compare it to its current price. If the complex shouldModify condition is met, call OrderModify() to update the order's entry price.
UpdateChartInformation(...): Update all the informational text labels on the chart (Balance, Equity, ProfitB, etc.) with the latest values calculated in ProcessOpenOrders.
Part 4: Required Utility Functions
The programmer will also need to create the functions that perform the actual trading actions and calculations.
CloseOrders(int direction): This function will loop through all orders. Based on the direction parameter (1, -1, or 0), it will use OrderClose() on the matching trades.
DeleteOrders(): Similar to CloseOrders, but it will use OrderDelete() for pending orders and OrderClose() for open market orders.
TradingHours(): A function that checks the current server time against user-defined start and end hours to determine if the EA is within its allowed trading session.
CalculateTrailingStop(...): The logic to calculate the trailing stop price. This could be as simple as Bid - Trailing_Stop_Points for a buy order.
UpdateChartLabel(...): A small helper function to make creating and updating the text objects in OnInit and UpdateChartInformation cleaner and less repetitive.

Dosyalar:

Yanıtlandı

1
Geliştirici 1
Derecelendirme
(283)
Projeler
354
29%
Arabuluculuk
37
27% / 65%
Süresi dolmuş
10
3%
Yüklendi
2
Geliştirici 2
Derecelendirme
(111)
Projeler
183
25%
Arabuluculuk
25
16% / 76%
Süresi dolmuş
16
9%
Serbest
3
Geliştirici 3
Derecelendirme
(17)
Projeler
21
19%
Arabuluculuk
5
40% / 40%
Süresi dolmuş
0
Serbest
4
Geliştirici 4
Derecelendirme
(510)
Projeler
977
74%
Arabuluculuk
27
19% / 67%
Süresi dolmuş
100
10%
Çalışıyor
Yayınlandı: 1 makale, 6 kod
5
Geliştirici 5
Derecelendirme
(98)
Projeler
137
52%
Arabuluculuk
5
40% / 60%
Süresi dolmuş
0
Serbest
6
Geliştirici 6
Derecelendirme
Projeler
0
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
7
Geliştirici 7
Derecelendirme
(68)
Projeler
127
41%
Arabuluculuk
19
47% / 53%
Süresi dolmuş
33
26%
Serbest
8
Geliştirici 8
Derecelendirme
(47)
Projeler
67
37%
Arabuluculuk
5
40% / 40%
Süresi dolmuş
1
1%
Serbest
9
Geliştirici 9
Derecelendirme
(365)
Projeler
507
40%
Arabuluculuk
159
17% / 74%
Süresi dolmuş
99
20%
Yüklendi
10
Geliştirici 10
Derecelendirme
(319)
Projeler
571
35%
Arabuluculuk
83
31% / 45%
Süresi dolmuş
206
36%
Serbest
11
Geliştirici 11
Derecelendirme
(25)
Projeler
31
13%
Arabuluculuk
14
0% / 79%
Süresi dolmuş
9
29%
Serbest
12
Geliştirici 12
Derecelendirme
(16)
Projeler
35
23%
Arabuluculuk
4
0% / 50%
Süresi dolmuş
2
6%
Çalışıyor
13
Geliştirici 13
Derecelendirme
(12)
Projeler
13
23%
Arabuluculuk
7
0% / 71%
Süresi dolmuş
3
23%
Çalışıyor
14
Geliştirici 14
Derecelendirme
(574)
Projeler
945
47%
Arabuluculuk
309
58% / 27%
Süresi dolmuş
125
13%
Serbest
15
Geliştirici 15
Derecelendirme
(78)
Projeler
246
74%
Arabuluculuk
7
100% / 0%
Süresi dolmuş
1
0%
Serbest
Yayınlandı: 1 makale
16
Geliştirici 16
Derecelendirme
(59)
Projeler
92
42%
Arabuluculuk
4
0% / 100%
Süresi dolmuş
3
3%
Çalışıyor
17
Geliştirici 17
Derecelendirme
(14)
Projeler
14
36%
Arabuluculuk
1
0% / 100%
Süresi dolmuş
1
7%
Çalışıyor
18
Geliştirici 18
Derecelendirme
(1)
Projeler
1
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
19
Geliştirici 19
Derecelendirme
(43)
Projeler
66
12%
Arabuluculuk
12
58% / 42%
Süresi dolmuş
1
2%
Serbest
20
Geliştirici 20
Derecelendirme
(8)
Projeler
7
0%
Arabuluculuk
3
0% / 100%
Süresi dolmuş
2
29%
Serbest
21
Geliştirici 21
Derecelendirme
(271)
Projeler
553
50%
Arabuluculuk
57
40% / 37%
Süresi dolmuş
227
41%
Çalışıyor
22
Geliştirici 22
Derecelendirme
(1)
Projeler
2
0%
Arabuluculuk
2
0% / 50%
Süresi dolmuş
0
Serbest
23
Geliştirici 23
Derecelendirme
(10)
Projeler
13
0%
Arabuluculuk
24
0% / 75%
Süresi dolmuş
4
31%
Çalışıyor
24
Geliştirici 24
Derecelendirme
(52)
Projeler
65
40%
Arabuluculuk
15
27% / 60%
Süresi dolmuş
1
2%
Çalışıyor
25
Geliştirici 25
Derecelendirme
(2)
Projeler
2
0%
Arabuluculuk
0
Süresi dolmuş
0
Serbest
Benzer siparişler
Hello! I want to automatically trade on Sierra Charts (IronBeam Brokerage). NQ ($20 per "handle") or MNQ ($2 per point or handle) - futures Broker: IronBeam mostly for the low capital requirement for futures Chart: Sierra Charts I almost exclusively trade a 5-20 bracket with 2 contracts (first contract closes at a +5 and second bracket closes at a +20.) When the +5 is reached, I move my stop from -15 to BE
Let’s use Chart M3. Stochastic 8,3,3. 85/15 trigger for sell stochastic >85, and the reversal move need to engulf the last bar for 1 point. SL over the engulfed bar. Same trigger for buys… Stochastic <15, engulfed bar by 1 point = entrance. SL under the engulfed bar… more details as soon we start to work on it
Scalping EA/straddle 30 - 200 USD
Title: Custom EA: Dynamic Trailing Limit Grid with Volatility/Velocity Filter and Auto SL/TP Description: I am looking for an experienced MQL5 programmer to develop a high-performance, robust Expert Advisor (EA) for MetaTrader 5. The strategy relies on dynamic trailing limit orders that automatically adjust to market price changes, featuring a safety buffer during high-velocity price spikes. The EA must include the
Freelance Task — EA Recovery Layer Hello. I have a ready-made MQL5 EA. The signals, SL/TP and lot calculation should essentially not be touched. I need a recovery system added. I am not a programmer — below is how the robot should behave. What stays Entry only from an EA signal. Stop-loss is not a new signal. Trailing is already built into my EA — recovery does not implement its own trailing. If trailing is disabled
Watcher position 30 - 100 USD
//+------------------------------------------------------------------+ //| synthetic tick generator based on two assets | //+------------------------------------------------------------------+ class CSyntheticTickGenerator { private : string symbol_a; string symbol_b; string synth_name; double ratio; double last_price_a; double
# SNRZ BOT — SESSION PROGRESS LOG Last updated: 2026-09-16 (local late-evening session) ## SAN BOT (new — cloned from SNRZ) - `MQL5\Experts\AutomatedOrderBot_SAN.mq5` / `.ex5` — v1.0, compiled 0 errors/0 warnings - Signal source: custom indicator "SAN" (InpSANName, buy buf 0 / sell buf 1, target bar 1), same SNRZ-style read, MA fallback if missing - Magic number 234567 (separate from SNRZ 123456 so both bots can run
Multi-Asset EA (XAUUSD / FRA40) with Time Filters, High-Impact News Avoidance, Advanced Risk/Lot Sizing, and H1 Breakout Strategy 1. RISK SETTINGS * Max Daily Loss Limit: (bool) Toggle true/false. If true, input double for max loss in currency (e.g., $500). If hit, close all positions and stop trading until next day. * Lot Sizing Mode: Dropdown menu: 1. Fixed Lots (e.g. 0.10); 2. Percentage Risk (%) based on Account
Should be as it but no alarms, also we need to add a deep search so he can see all the preves candles and a memory function so its not slowing down the indicator. for higher time frames daily 4h 1h around 365 days and for lower time frames we do up to 20k bars but both flexible so i can change it later. the memory is important so the indicator is not always recalculating everything when a new candle shows especially
Creating a bot using the Parabolic indicator with a simple interface.. I want a bot that uses the Parabolic SAR indicator only, with these orders attached to it. Boot name : HEMIN .FX Magic number : 000000 …………………………………………………. Trade behavior : regular OR inverse OR only long "buy" OR only short "sell" Timeframe : ………… Period: ……… ………………………………………………….. Lot size : ……………… Break even in points : …
I am looking for an experienced MQL5 EA developer to develop an MT5 EA by the observable trading behaviour from a supplied live XAUUSD trade history . The EA appears to use a simple grid/recovery/hedging strategy with alternating BUY/SELL positions and progressive lot sizes. I need the developer to Develop the EA for MT5 / XAUUSD . Reproduce the observed entry, grid/add-on, recovery/hedging, lot progression and

Proje bilgisi

Bütçe
100 - 150 USD
Son teslim tarihi
to 7 gün