Crafting an Ichimoku + SAR Cosmic Trader with MQL5 🌌

Introduction

Picture yourself at the helm of a starship, your navigation console glowing with data as you scan the forex galaxy for clear signals to ride a bullish market wave, like spotting a comet streaking upward. The Ichimoku + SAR EA is your state-of-the-art navigation radar, meticulously engineered to combine two powerhouse indicators: the Ichimoku Cloud and the Parabolic SAR. The Ichimoku Cloud, with its Tenkan-sen, Kijun-sen, and Senkou Span A/B lines, acts like a cosmic map, revealing trend direction and support zones, while the Parabolic SAR pinpoints entry timing, like a beacon guiding your ship through turbulent skies. This EA automates buy trades when conditions align—price above the cloud, Tenkan-sen crossing Kijun-sen, and SAR below the price—executing 0.01-lot trades with a 300-pip stop loss and take profit, like setting a precise course with safety margins.

In this article, I’ll guide you through the code with a continuous, professional narrative that flows like a starry night, weaving each section into a cohesive story that keeps you engaged. I’ll explain every component as if you’re a new crew member learning the ropes, using relatable analogies, clear language, and real-world examples—like capturing a bullish trend on EURUSD—to bring the concepts to life. We’ll explore how the EA initializes indicators, detects signals, executes trades, and ensures reliability, ensuring you grasp not just the “how” but the “why” behind each line of code. With a touch of cosmic charm, this guide will transform the technical into a thrilling expedition, empowering you to harness this EA’s potential. Let’s power up the radar and chart our course through the forex stars!

Strategy Blueprint

Before we dive into the code, let’s map out the EA’s mission, like plotting a star chart for our trading expedition:

• Signal Detection: The EA identifies bullish signals when the price low is above the Ichimoku Cloud (Senkou Span A and B), the Tenkan-sen (9-period) crosses above the Kijun-sen (26-period), and the Parabolic SAR (0.02, 0.2) is below the price low, indicating a strong uptrend.

• Trade Execution: Opens 0.01-lot buy trades at the market ask price with a 300-pip stop loss below and take profit above, ensuring disciplined risk-reward.

• Indicator Setup: Uses Ichimoku (9, 26, 52) for trend and momentum, and SAR (0.02, 0.2) for entry timing, processed on new bars to confirm signals.

• Limitations: Currently buy-only; sell logic could be added for balance.

• Reliability: Includes error handling for indicator data and new-bar checks to prevent overtrading, like a starship’s safety protocols. This strategy is like a cosmic navigation system, automating bullish trades with precision while filtering noise for high-probability entries, making it a robust tool for trend traders.

Code Implementation

Now, let’s step onto the starship’s bridge and explore the MQL5 code that powers this cosmic trader. I’ll guide you through each section like a mission commander, ensuring the narrative flows seamlessly with professional polish and engaging details that keep you captivated. We’ll cover initializing the indicators, detecting bullish signals, executing trades, and cleaning up, using clear explanations and examples—like trading a bullish trend on EURUSD—to make it relatable for beginners. Each step will build on the last, creating a cohesive story that transforms code into a thrilling expedition. Let’s activate the radar and begin our journey!

Step 1: Powering Up the Cosmic Radar—Setting Up Indicators

Our adventure begins by powering up the starship’s navigation systems, initializing the Ichimoku and SAR indicators to scan the market.

//+------------------------------------------------------------------+
//|                                               Ichimoku + SAR.mq5 |
//|      Copyright 2025, Allan Munene Mutiiria.                      |
//|                                   https://t.me/Forex_Algo_Trader |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Allan Munene Mutiiria."
#property link      "https://t.me/Forex_Algo_Trader"
#property version   "1.00"

#include <Trade/Trade.mqh>
CTrade obj_Trade;

int handleIchimoku, handleSAR;

double senkouspan_A[],senkouspan_B[];
double tenkansen[],kijunsen[];
double sar[];

int OnInit(){
   handleIchimoku = iIchimoku(_Symbol,_Period,9,26,52);
   handleSAR = iSAR(_Symbol,_Period,0.02,0.2);
   
   if (handleIchimoku == INVALID_HANDLE){
      Print("ERROR INITIATING ICHIMOKU HANDLE. REVERTING NOW");
      return (INIT_FAILED);
   }
   
   ArraySetAsSeries(senkouspan_A,true);
   ArraySetAsSeries(senkouspan_B,true);
   ArraySetAsSeries(tenkansen,true);
   ArraySetAsSeries(kijunsen,true);
   ArraySetAsSeries(sar,true);
   
   return(INIT_SUCCEEDED);
}

We start by activating the radar with the #property header, proudly declaring the EA as a creation by Allan in 2025, with a Telegram link for support, like engraving your starship’s mission badge. The "OnInit()" function is our launch sequence, where we flip the switches to prepare the EA for action. It includes "Trade/Trade.mqh" to enable trading via "obj_Trade", setting the stage for trade execution.

We define handles ("handleIchimoku", "handleSAR") and arrays ("senkouspan_A[]", "tenkansen[]", "sar[]") to store indicator data, like installing sensors on your ship. The "iIchimoku()" function initializes the Ichimoku Cloud with parameters 9 (Tenkan-sen), 26 (Kijun-sen), and 52 (Senkou Span), while "iSAR()" sets up the Parabolic SAR with step 0.02 and maximum 0.2, like tuning your radar for trend and timing signals. If "handleIchimoku" fails ("INVALID_HANDLE"), we log an error with "Print()" and abort with "INIT_FAILED", ensuring reliability, like a diagnostic check before launch.

The arrays are set as time series with "ArraySetAsSeries()", aligning data from newest to oldest, like organizing your starship’s sensor logs. Returning INIT_SUCCEEDED signals, “Radar’s powered up, ready to scan!” This setup primes the EA to track Ichimoku and SAR signals, like a starship ready to navigate the forex galaxy.

Step 2: Scanning the Starfield—Loading Indicator Data

With the radar online, we scan the market by loading Ichimoku and SAR data, like pulling up a star map to identify bullish signals.

void OnTick(){
   if (CopyBuffer(handleIchimoku,2,0,3,senkouspan_A) < 3){
      Print("FAILED TO GET THE SPAN A DATA FOR ANALYSIS. REVERTING");
      return;
   }
   if (CopyBuffer(handleIchimoku,3,0,3,senkouspan_B) < 3){return;}
   if (CopyBuffer(handleIchimoku,0,0,3,tenkansen) < 3){return;}
   if (CopyBuffer(handleIchimoku,1,0,3,kijunsen) < 3){return;}
   if (CopyBuffer(handleSAR,0,0,3,sar) < 3){return;}

We move to the navigation deck, where the "OnTick()" function runs every price tick, like your ship’s sensors constantly scanning the market. The first task is to load indicator data using "CopyBuffer()", pulling 3 bars of data (current and two prior) into arrays for analysis, like downloading the latest starfield coordinates.

For Ichimoku, we load:

• Senkou Span A ("senkouspan_A[]", buffer 2) and B ("senkouspan_B[]", buffer 3), defining the cloud’s boundaries.

• Tenkan-sen ("tenkansen[]", buffer 0, 9-period) and Kijun-sen ("kijunsen[]", buffer 1, 26-period), tracking momentum.

For SAR, we load "sar[]" (buffer 0, 0.02 step, 0.2 max), marking potential entry points. Each "CopyBuffer()" call checks for success, returning if fewer than 3 bars are loaded and logging errors (e.g., “FAILED TO GET THE SPAN A DATA”), like your ship’s diagnostics flagging a sensor glitch. This ensures we have reliable data, like a clear star map, before proceeding to signal detection, setting the stage for our next mission phase.

Step 3: Plotting the Course—Detecting Bullish Signals

With data loaded, we analyze it to detect bullish signals, like spotting a comet signaling a market surge.

void OnTick(){
   // ... (data loading)
   int currBars = iBars(_Symbol,_Period);
   static int prevBars = currBars;
   if (prevBars==currBars) return;
   prevBars = currBars;
   
   double low1 = iLow(_Symbol,_Period,1);
   double high1 = iHigh(_Symbol,_Period,1);
   
   double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_ASK),_Digits);
   double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol,SYMBOL_BID),_Digits);
   
   if (low1 > senkouspan_A[1] && low1 > senkouspan_B[1] &&
      tenkansen[0] > kijunsen[0] && tenkansen[1] < kijunsen[1] &&
      sar[0] < low1){
      Print("BUY SIGNAL");
      obj_Trade.Buy(0.01,_Symbol,Ask,Ask-300*_Point,Ask+300*_Point);
   }
}

Now, we’re in the command center, where "OnTick()" orchestrates the mission. To avoid overtrading, it checks for new bars with "iBars()", "currBars", and "prevBars", processing only when a new candle forms, like scanning at regular intervals. It grabs the latest bar’s low and high ("iLow()", "iHigh()") and current ask/bid prices ("SymbolInfoDouble()", "NormalizeDouble()") for signal validation and trading.

The buy signal requires three conditions:

1. The price low is above the Ichimoku Cloud ("low1 > senkouspan_A[1] && low1 > senkouspan_B[1]"), indicating a bullish trend, like flying above a cosmic fog.

2. Tenkan-sen crosses above Kijun-sen ("tenkansen[0] > kijunsen[0] && tenkansen[1] < kijunsen[1]"), confirming momentum, like a comet gaining speed.

3. SAR is below the price low ("sar[0] < low1"), signaling an upward move, like a beacon below your ship.

If met, the EA logs “BUY SIGNAL” with "Print()" and opens a 0.01-lot buy with "obj_Trade.Buy()", setting a 300-pip stop loss ("Ask-300*_Point") and take profit ("Ask+300*_Point"). For example, on EURUSD H1, if the low at 1.2005 is above the cloud (Senkou Span A at 1.1990, B at 1.1985), Tenkan-sen crosses Kijun-sen at 1.2000, and SAR is at 1.1995, the EA buys at 1.2008 (ask), with stop loss at 1.1708 and take profit at 1.2308. This is like launching your starship on a confirmed bullish course, ready to ride the trend.

Step 4: Docking the Starship—Cleaning Up and Enhancing

As our mission concludes, we prepare to dock the starship, ensuring the radar system shuts down cleanly and planning future upgrades.

void OnDeinit(const int reason){
}

In the docking bay, the "OnDeinit()" function is our final stop, but it’s empty, like leaving your starship’s sensors active. This means no cleanup occurs, potentially leaving indicator handles in memory. To tidy up, you could add "IndicatorRelease()" for "handleIchimoku" and "handleSAR", and "ArrayFree()" for arrays, like powering down your radar:

IndicatorRelease(handleIchimoku);
IndicatorRelease(handleSAR);
ArrayFree(senkouspan_A);
ArrayFree(senkouspan_B);
ArrayFree(tenkansen);
ArrayFree(kijunsen);
ArrayFree(sar);

For now, the empty "OnDeinit()" keeps things simple, ready for your next voyage. This lightweight approach focuses on trading, but cleanup would enhance professionalism, like docking your ship neatly.

Why This EA’s a Cosmic Legend (and Keeps You Engaged!)

The Ichimoku + SAR EA is a trend-trading legend, automating bullish trades with the precision of a cosmic navigation system, blending Ichimoku’s trend filter with SAR’s timing. Its clear signals, fixed risk-reward (300-pip SL/TP), and new-bar checks make it reliable, with room for enhancements like sell logic or dynamic sizing. Picture catching a bullish trend on EURUSD at 1.2008, riding it to 1.2308 for 300 pips—pure cosmic gold! Beginners will love the simplicity, while pros can refine its robust framework, making it a must-have for trend traders seeking automation.

Putting It All Together

To launch this EA:

1. Open MetaEditor in MetaTrader 5, like stepping onto your starship’s bridge.

2. Copy the code, compile with F5, and check for errors—no commander wants a glitchy radar!

3. Drop the EA on your chart, enable AutoTrading, and watch it open 0.01-lot buy trades based on Ichimoku and SAR signals.

4. Monitor logs (e.g., “BUY SIGNAL”) to track your mission, like reviewing starship data.

5. Test on a demo account first—real pips deserve a practice voyage!

Conclusion

We’ve crafted an Ichimoku + SAR Cosmic Trader that automates bullish trend trading with stellar precision, guided by the Ichimoku Cloud and Parabolic SAR. This MQL5 code is your navigation radar, brought to life with a seamless, professional narrative that flows like a galactic journey, packed with clear explanations and vibrant examples to ignite your trading passion. Whether you’re a novice navigator or a seasoned starfarer, this EA empowers you to conquer market trends like a pro. Ready to explore further? Check our video guide on the website for a front-row seat to this cosmic mission. Now, go chart those bullish stars! 🌌

Disclaimer: Trading is like navigating a galaxy—thrilling but risky. Losses can exceed deposits. Test strategies on a demo account before going live.