Pipsgrowth EX16076 Trend

EX16076 is a smart trend follower that gives you two ways to read momentum on a single chart, then layers additional entries into a basket whose take-profit and stop-loss are calculated from a volume-weighted break-even price rather than the original entry. Both signal modes run on the chart timeframe — the EA declares M5 as its primary working frame and H1 as supported — and the default signal is a moving-average cross.

The two signal paths are selected by an enum input inJnsSignal called "Signal Type." In eTypeCrossMA mode (the default) GetSignal() pulls the last three values of two simple moving averages — inMAPeriodFast defaulting to 14 and inMAPeriodSlow defaulting to 28, both SMA on close — and watches for a fast-line flip relative to the slow line. A sell signal fires when the fast MA is currently above the slow MA and was below it one bar ago, and a buy signal fires when the fast MA is currently below the slow MA and was above it one bar ago. That crossed-bar pattern is a deliberate two-bar confirmation, not a single-bar touch, so the EA is taking the second candle after a cross, not the crossover bar itself. The buy logic in particular looks for fast MA having just slipped under slow, which is the start of a short-term bearish sequence the EA reads as a continuation entry — a small detail that matters when reviewing backtests, because the open of every trade will sit on the bearish side of the cross.

Switch inJnsSignal to eTypeTrend and the engine changes. Now GetSignal() only reads bar index 1, but adds a third handle — gSTOHandle, an iStochastic with K=10, D=3, slowing=3 on low-high. The MA pair is still required, but the cross itself is not — a buy fires when the fast MA is above the slow MA (trend filter) and the previous bar closed as a bullish candle (open below close) and the Stochastic main line is at or below 30. Sell is the mirror. In other words, trend-following with a buy-the-dip entry: the EA waits for the uptrend to pull back into oversold before pulling the trigger. That makes mode 2 materially different from mode 1 — mode 1 is mechanical cross-follow, mode 2 is pullback-in-trend.

Once a signal arrives, OnTick hands it to manageTrading(). If this is the first position in the direction the signal points to, getLotSize() computes the lot as inLotSize * MathPow(inMultiply, layerIndex) — for the first trade that resolves to the base lot of 0.01 by default. validateLot() snaps the result to the symbol's volume step, clamps to min/max, and CheckMoneyForTrade() confirms free margin before openTrade() sends the market order with magic 22216076 and comment Psgrowth.com Expert_16076. If the direction already has a position open, the EA does not place a new trade immediately. Instead it watches for the price to move against the existing position by inJarakLayer pips — 200 pips by default — and only then opens the next layer. For a buy, the trigger is latestBuyPrice − 200 * Point() >= current ask; for a sell, latestSellPrice + 200 * Point() <= current bid. The same getLotSize() formula means the multiplier still controls how much each subsequent layer scales relative to the first — set inMultiply to 1.0 and every layer is the same 0.01 lot; raise it to 1.5 and layer N becomes 0.01 * 1.5^N.

The trades[2] array stores the running state per side: position count (ttlPos), the most recent buy or sell open price (hargaTA, hargaTB), the cumulative notional value (ttlValue), and the cumulative volume (ttlLot). updateDataTrades() rebuilds this on every signal event by scanning PositionsTotal() for positions matching the current symbol and magic number, picking the highest and lowest entry price on each side, and summing the volume-weighted value. That single struct is what makes the basket TP/SL work.

setTPSL() runs unconditionally on every tick — not just on new-bar events — and is where the EA's exit logic lives. It rebuilds the trades array, then for each side calculates the volume-weighted break-even price as ttlValue / ttlLot — that is, the lot-weighted average entry across every layer in the basket. For buys the take-profit is BEP + inTakeProfit * Point() and the stop-loss is BEP − inStopLoss * Point(). For sells the sign flips. inTakeProfit defaults to 500 (50 pips in five-digit notation), and inStopLoss defaults to 0, meaning the basket has a TP but no SL out of the box. The function then iterates every open position matching the magic number and calls modifTPSL() to push the new TP and SL onto any position whose protection is out of date. Because both values are basket-level rather than per-trade, every layer in the basket closes together once price reaches the BEP-based target. Setting inStopLoss to a positive value installs a basket-level stop too.

A small but real risk control: getLotSize() calls getTotalVolume() and refuses to return any lot if the new trade would push the directional exposure above SYMBOL_VOLUME_LIMIT, and CheckMoneyForTrade() rejects the lot if there isn't enough free margin to cover the required margin. So even with martingale multipliers set aggressively, the broker-level volume cap and the account margin cap are still in the loop.

The EA reads as cleanly as any in the PipsGrowth series: header block, three indicator handles created once in OnInit, two-tier signal generation, basket TP/SL via lot-weighted BEP, layered entries at configurable spacing, the standard Trade.mqh trade object plus three retry helpers — TryClose_EX16076, TryClosePartial_EX16076, TryModify_EX16076 — that wrap CTrade with three attempts on requote, timeout, price-off, or price-changed responses. Those helpers are defined in the source but are not currently invoked from OnTick; the live execution path uses raw OrderSend calls in openTrade() and modifTPSL(). The retry code is in place as a safety net a future revision can wire in without re-architecting the trade flow. The EA uses no session filter, no news filter, no OnTester pass, and no daily P&L circuit breaker — all of the trader's discretionary risk controls are therefore expected to live outside the EA.

Because the default SL is 0 and the basket TP is calculated from the lot-weighted average entry, the EA is structurally designed for a let-the-basket-mature use case — open the first position, accumulate layers as the trade moves against you, and close the whole basket at a fixed pips-from-BEP target once price reverses. The default 200-pip spacing and 1.0 multiplier keep the layered exposure small; raising inMultiply to anything above 1.0 quickly turns the EA into a martingale-style averaging system and the trader should treat the basket stop-loss as the primary risk control, not as a safety net.