Expert Advisors

Writing and testing experts trading system has a number of features.
• Before opening a position it is necessary to check if there is any free money at the account. If there
is not enough money at the account the operation of opening a position will end unsuccessfully. And at the
same time, when being tested the FreeMargin value must necessarily be above 1000 because when being
tested one lot price makes 1000.
If FreeMargin < 1000 Then Exit; // no money – exit

• After having opened, closed or changed a position or after having deleted a pending order (i.e.,
after having used any of the following commands: SetOrder, CloseOrder, ModifyOrder or DeleteOrder), it
is recommended to finish the expert program using the Exit instruction, as after completing the operation a
10-seconds-timeout begins which is used for processing trading operations. But for all that, this 10-secondstimeout does not function during the testing (it is possible to process several operations one after another), and, if one does not finish the expert running by executing the Exit instruction after having completed the operation, the testing results can differ from those of the real expert trading.

SetOrder(OP_SELL,Lots,Bid,3,0,Bid-TakeProfit*Point,RED); // execute
Exit; // exit
To prevent a possibility of processing several trade operations with an interval of less than 10 seconds
during the testing it is also possible to check before processing the next operation that no less than 10
seconds have passed after completing the last trade operation.
// check that the current time is more than the time taken for
// completing the last trade operation more than 10 seconds
If CurTime > LastTradeTime + 10 Then Begin
SetOrder(OP_SELL,Lots,Bid,3,0,Bid-TakeProfit*Point,RED); // execute
Exit;
End;

• The admittance for historical data can be obtained using indexing predefined variables Open,
Close, High, Low, and Volume. Index in this case is the number of periods necessary to be counted back.
// if Close at the last bar is less than Close at the bar before last
If Close[1] < Close[2] Then Exit;

• Experts testing in FXDirectDealer trading system supports 4 models.
o OHLC points (Open/High/Low/Close). When testing an expert only Open, High, Low,
Close prices are used. This model of testing is the quickest one. But the results of the testing can differ from
those of the real expert trading.
o Every spread/2 points. When testing an expert the candle development having the
"spread/2"(usually 2) points step is simulated.
o Every 1 point. When testing an expert the candle development having the 1 point step is
simulated. This model of testing is the slowest one. But the results of the testing are identical with those of
the real expert trading (when keeping the 10 seconds interval between completing trading operations).

• When writing and testing an expert, like testing any other program, it is sometimes necessary to
display some additional debugging information. The MQL II language gives a number of opportunities to
display such information.
o The Alert function displays a dialogue box containing data defined by the user.
Alert("Free margin is ", FreeMargin);

o The Comment function shows the data defined by the user in the upper left corner of the
chart. The "\n" char sequence is used for line feed.
Comment("Free margin is ", FreeMargin, "\nEquity is ", Equity);
o The Print function prints data defined by the user in the log file.
Print("Total trades are ", TotalTrades, "; Equity is ", Equity, "; Credit is ", Credit);
o The PrintTrade function prints data of selected trade position in the log-file.
PrintTrade(1);

• When testing an expert the test results are stored in files having ".log" extension in a subdirectory
of the "logs"-directory where you have already installed your FXDirectDealer trading system. When you
often test experts do not forget to delete log files periodically as they can have a size of several megabytes.

• It occurs that it is necessary to perform a large preparatory work before the experts start working.
This work is so large that the expert will close forcedly with the error of loop detected. (It is necessary to note
that the expert runs with each price tick and may not work long). But you can perform the preparatory work,
for example, initialization of any array, in several movements. For example, in this way:
var: cnt(0), initvalue(0);
array: arr[6000](0);
SetLoopCount( 50000 ); // for example only. Illustrates an initialization in 3 times
If initvalue <=6000 Then Begin
print( "beginning from ", initvalue );
For cnt = initvalue To 6000 Begin // initialization loop
arr[cnt] = cnt;
// strongly recommended last instruction in the initialization loop as follow
initvalue = cnt + 1;
End;
print( "stopped with ", initvalue, " –- initialization is complete." );
End
Else print( "initialization is complete" );
If it is necessary to initialize several arrays you should use several variables. For example, "initvalue",
"initvalue2", "initvalue3", etc.

• How to assess the beginning of the next bar? (This is necessary to know that the previous bar has
just been formed.) There are several ways:
Variable: prevbars(0);...
If prevbars = Bars Then exit;
prevbars = Bars;
...
This method can sometimes fail when spooling the history. I.e., the number of bars has changed, and the
"previous" bar has not been formed yet. In this case, it is possible to complicate checking the difference
between values being equal to 1.

The next way is based on the fact that the value of Volume is formed on the base of the number of ticks
having come for each bar, and the first tick means that the value of the bar being newly formed the Volume
value is equal to 1:
If Volume > 1 Then exit;
...
This method can fail when price ticks come too intensively. As a matter of fact, the processing of the price
ticks coming is performed in a separate traffic. And if this traffic is occupied during the next tick coming, this
coming tick will not be processed to prevent overloading the computing power! In this case, it is possible to
complicate the checking using storage of the previous Volume value.
The third way is based on the bar opening time:
Variable: prevtime(0);
...
If prevtime = Time Then exit;
prevtime = Time;
...
This method is the most effective. It will work under any conditions.

• An example of working with the file is given below:
vars : handle(0), cnt1(0), cnt2(0), position(0), size(0);
vars : string(""), number(0);
handle = FileOpen( "test", "," );
print( "file size is ", FileSize( handle ) );
size = 0;
while not IsFileEnded( handle ) begin
string = FileReadString( handle );
number = FileReadNumber( handle );
// lines counting
if IsFileLineEnded( handle ) then size = size + 1;
end;
print( "file has ", size, " lines" );
if size < 20 then begin
cnt2 = 0;
for cnt1 = size to 19 begin
FileWrite(handle, "teststring"+cnt1, cnt1+1);
cnt2 = cnt2 + 1;
size = size + 1;
if cnt2 = 5 then break;
end;
print( "there are ", cnt2, " lines added" );
print( "file size is ", FileSize( handle ) );
end;
position = FileSeek( handle, 0, SEEK_SET );
// file reading from begin
for cnt1=1 to size begin
print( FileReadString( handle ), ";", FileReadNumber( handle ) );
If IsFileEnded( handle ) then break;
end;
FileClose(handle);

Here are several explanations to the code. The file will be opened first, then the line-by-line reading should
be performed. It is presumed that the structure of each line of the file consists of one text variable and one
numeric variable. If the number of lines being counted is less than 20 the next portion of 5 lines will be
added.

 Since the pointer of the current position of reading-recording is at the end of the file after the lines have been counted, the recording of the next record will be made to the end of the file, after that the pointer
of the current position will be moved to the end of the file. If the record should be done to the end of the file
immediately after it has been opened it is necessary to use the following function:
position = FileSeek( handle, 0, SEEK_END );
after that the data should be stored in the file.In the second part of the code the reading of records from the file will be conducted from its very beginning.

Step IV:
[You must be registered and logged in to see this image.]
We have written the Expert Advisor – now we are impatient to evaluate it by testing it on historical data. Let's take as an example 15-minute intervals for EUR/USD, approximately 4000 bars.

Let's open EURUSD, M15 chart, attach the MACD Sample Expert Advisor to the chart using the Attach to a chart command (by selecting the MACD Sample line by the mouse pointer in the "Navigator"
window, pressing the right mouse button and selecting the command in the appearing menu).

After that we go the the Expert Advisor settings, where we can change the predefined external variables Lots, Stop Loss, Take Profit, Trailing Stop, as well as the user-defined variables. To allow the Expert Advisor not only to advise, but also to gamble on the trading account in real-time on its own, you need to activate the Allow Live Trading button. We are going to do testing on historical data, though, so we leave the settings unchanged, switch to the Strategy Tester tab, activate the Arrows on the chart tick (to be able to see the arrows on the chart) and start our test with the Start button:
[You must be registered and logged in to see this image.]

Step III:
Let's open the Expert Advisor settings (using a button or a line in the Properties... menu). We are offered a
window in which we have to define the external settings of the working parameters:
[You must be registered and logged in to see this image.]

Let's assemble all the code from the previous section:

defines: MACDOpenLevel(3),MACDCloseLevel(2);

defines: MATrendPeriod(56);

var: MacdCurrent(0),MacdPrevious(0),SignalCurrent(0),SignalPrevious(0);

var: MaCurrent(0),MaPrevious(0);

var: cnt(0);

// initial data checks

// it is important to make sure that the Expert Advisor runs on a normal chart and that

// the user has correctly set the external variables (Lots, StopLoss,

// TakeProfit, TrailingStop)

// in our case we only check the TakeProfit

If Bars<200 or TakeProfit<10 then Exit; // less than 200 bars on the chart

// to simplify and speed up the procedure, we store the necessary

// indicator data in temporary variables

MacdCurrent = iMACD(12,26,9,0,MODE_MAIN);

MacdPrevious = iMACD(12,26,9,1,MODE_MAIN);

SignalCurrent = iMACD(12,26,9,0,MODE_SIGNAL);

SignalPrevious= iMACD(12,26,9,1,MODE_SIGNAL);

MaCurrent = iMA(MATrendPeriod,MODE_EMA,0);

MaPrevious = iMA(MATrendPeriod,MODE_EMA,1);

// now we have to check the status of the trading terminal.

// we are going to see whether there are any previously opened positions or orders.

If TotalTrades<1 then

{

// there are no opened orders

// just to be on the safe side, we make sure we have free funds on our account.

// the "1000" value is taken just as an example, usually it is possible to open 1 lot

If FreeMargin<1000 then Exit; // no money – we exit

// checking for the possibility to take a long position (BUY)

If MacdCurrent<0 and MacdCurrent>SignalCurrent and

MacdPrevious(MACDOpenLevel*Point) and

MaCurrent>MaPrevious then

{

SetOrder(OP_BUY,Lots,Ask,3,0,Ask+TakeProfit*Point,RED); // executing

Exit; // exiting, since after the execution of a trade

// there is a 10-second trading timeout

};

// checking for the possibility of taking a short position (SELL)

If MacdCurrent>0 and MacdCurrent

MacdPrevious>SignalPrevious and MacdCurrent>(MACDOpenLevel*Point) and

MaCurrent

{

SetOrder(OP_SELL,Lots,Bid,3,0,Bid-TakeProfit*Point,RED); // executing

Exit; // exiting

};

// here we completed the check for the possibility of opening new positions.

// no new positions were opened and we simply exit the programme using the Exit command, as

// there is nothing to analyze

Exit;

};

// we come over to an important part of the Expert Advisor – the control of open positions

// it is important to enter the market correctly, but it is even more important to exit it...'

for cnt=1 to TotalTrades

{

if OrderValue(cnt,VAL_TYPE)<=OP_SELL and // is this an open position? OP_BUY or OP_SELL

OrderValue(cnt,VAL_SYMBOL)=Symbol then // does the instrument match?

{

If OrderValue(cnt,VAL_TYPE)=OP_BUY then // long position opened

{

// we check – maybe, it's already time to close it?

If MacdCurrent>0 and MacdCurrent

MacdPrevious>SignalPrevious and MacdCurrent>(MACDCloseLevel*Point) then

{

CloseOrder(OrderValue(cnt,VAL_TICKET),OrderValue(cnt,VAL_LOTS),Bid,3,Violet);

Exit; // exiting

};

// we check – maybe, we already may or it's already time to set a trailing stop?

If TrailingStop>0 then // the user has put a trailing stop in his settings

{ // so, we set out to check it

If (Bid-OrderValue(cnt,VAL_OPENPRICE))>(Point*TrailingStop) then

{

If OrderValue(cnt,VAL_STOPLOSS)<(Bid-Point*TrailingStop) then

{

ModifyOrder(OrderValue(cnt,VAL_TICKET),OrderValue(cnt,VAL_OPENPRICE),

Bid-Point*TrailingStop,OrderValue(cnt,VAL_TAKEPROFIT),Red);

Exit;

};

};

};

}

else // otherwise it is a short position

{

// we check – maybe, it's already time to close it?

If MacdCurrent<0 and MacdCurrent>SignalCurrent and

MacdPrevious(MACDCloseLevel*Point) then

{

CloseOrder(OrderValue(cnt,VAL_TICKET),OrderValue(cnt,VAL_LOTS),Ask,3,Violet);

Exit; // exiting

};

// we check – maybe, we already may or it's already time to set a trailing stop?

If TrailingStop>0 then // the user has put a trailing stop in his settings

{

// so, we set out to check it

If(OrderValue(cnt,VAL_OPENPRICE)-Ask)>(Point*TrailingStop) then

{

If OrderValue(cnt,VAL_STOPLOSS)=0 or

OrderValue(cnt,VAL_STOPLOSS)>(Ask+Point*TrailingStop) then

{

ModifyOrder(OrderValue(cnt,VAL_TICKET),OrderValue(cnt,VAL_OPENPRICE),

Ask+Point*TrailingStop,OrderValue(cnt,VAL_TAKEPROFIT),Red);

Exit;

};

};

};

};

};

};

// the end.




To complete setting up the Expert Advisor we need only to specify the values of the external variables Lots
= 1, Stop Loss (S/L) = 0 (not used), Take Profit (T/P) = 120 (appropriate for one-hour intervals), Trailing
Stop (T/S) = 30. Of course, you can set your own values. Press the Verify button and, if there isn't any error
message (by the way, you can copy the text from the above programme printout against the grey
background right into the MetaEditor), press the Save button to save the Expert Advisor.

Let's take a look at the description given below:

1. Initial data checks
- check the chart, number of bars on the chart
– check the values of external variables: Lots, S/L, T/P, T/S

2. Setting the internal variables for quick data access


3. Checking the trading terminal – is it void? If yes, then:
- checks: availability of funds on the account etc...
- is it possible to take a long position (BUY)?
» open a long position and exit
– is it possible to take a short position (SELL)?
» open a short position and exit
– exiting the Expert Advisor...

4. Control of the positions previously opened in the cycle
- if it is a long position
» should it be closed?
» should the trailing stop be reset?
– if it is a short position
» should it be closed?
» should the trailing stop be reset?
It turned out to be relatively simple, with only 4 main blocks.
Now let's try to generate pieces of code step by step for each section of the structural scheme:

1. Initial data checks
This piece of code usually migrates from one Expert Advisor to another with minor changes – it is a
practically standard block of checks:

If Bars<200 Then Exit; // the chart has less than 200 bars – exit

If TakeProfit<10 Then Exit; // wrong takeprofit parameters

2. Setting the internal variables for quick data access
In the programme code it is very often necessary to access the indicator values or handle the
computed values. To simplify the coding and speed up the access, the data is initially nested within
the internal variables.

MacdCurrent=iMACD(12,26,9,0,MODE_MAIN); // MACD value on the current bar

MacdPrevious=iMACD(12,26,9,1,MODE_MAIN); // MACD value on the previous bar

SignalCurrent=iMACD(12,26,9,0,MODE_SIGNAL); // Signal Line value on the current bar

SignalPrevious=iMACD(12,26,9,1,MODE_SIGNAL);// Signal Line value on the previous bar

MaCurrent=iMA(MATrendPeriod,MODE_EMA,0); // moving average value on the current bar

MaPrevious=iMA(MATrendPeriod,MODE_EMA,1); // moving average value on the previous bar

Now, instead of the monstrous notation of iMACD(12,26,9,MODE_MAIN,0) we can simply write in the
program text MacdCurrent. All the variables used by the Expert Advisor will have to be preliminarily
described, according to the MetaQuotes Language II description. Therefore we insert the description of
these variables at the beginning of the programme:

var: MacdCurrent(0), MacdPrevious(0), SignalCurrent(0), SignalPrevious(0);
var: MaCurrent(0), MaPrevious(0);

MetaQuotes Language II also introduces the concept of additional user-defined variables which may be set
from outside the programme, without any interference with the source source text of the Expert Advisor
programme. This feature allows added flexibility. Variable MATrendPeriod is a user-defined variable of this
very type. So, we insert the description of this variable in the beginning of the programme.
defines: MATrendPeriod(56);

3. Checking the trading terminal – is it void? If yes, then:
In our Expert Advisor we only use the current positions and don't handle the delayed orders.
orders:

If TotalTrades < 1 then // no opened orders identified {

o Checks: availability of funds on the account etc...
Before analyzing the market situation it is advisable to check the status of your account to make
sure that there are free funds for opening a position.
If FreeMargin < 1000 then Exit; // no funds – exit

o is it possible to take a long position (BUY)?
Condition of entry into the long position: MACD is below zero, goes upwards and is crossed by the
Signal Line going downwards. This is how we describe it in MQL II (note that we operate on the
indicator values which were previously saved in the variables):

If MacdCurrent < 0 and MacdCurrent > SignalCurrent and

MacdPrevious < SignalPrevious and // a cross-section exists

Abs(MacdCurrent) > (MACDOpenLevel*Point) and // the indicator plotted a decent 'hillock'

MaCurrent > MaPrevious then // 'bull' trend

{

SetOrder(OP_BUY,Lots,Ask,3,0,Ask+TakeProfit*Point,RED); // executing

Exit; // exiting, since after the execution of a trade

// there is a 10-second trading timeout

};

Above we mentioned the method of additional monitoring of the size of the plotted 'hillocks'.
MACDOpenLevel variable is a user-defined variable which may be changed without interfering with the
programme text, to ensure greater flexibility. In the beginning of the programme we insert a
description of this variable (as well as the description of the variable used below).

defines: MACDOpenLevel(3), MACDCloseLevel(2);
o is it possible to take a short position (SELL)?

Condition of entry of a short position: MACD is above zero, goes downwards and is crossed by the
Signal Line going upwards. The notation is as follows:



If MacdCurrent > 0 and MacdCurrent < SignalCurrent and

MacdPrevious > SignalPrevious and MacdCurrent > (MACDOpenLevel*Point) and

MaCurrent < MaPrevious then

{

SetOrder(OP_SELL,Lots,Bid,3,0,Bid-TakeProfit*Point,RED); // executing

Exit; // exiting

};

Exit; // no new positions opened – just exit

4. Control of the positions previously opened in the cycle
for cnt=1 to TotalTrades

{

if OrderValue(cnt,VAL_TYPE)<=OP_SELL and // is it an open position?

OrderValue(cnt,VAL_SYMBOL)=Symbol then // position from "our" chart?

{

Cnt is the cycle variable which is to be described at the beginning of the programme as follows:

var: Cnt(0);

o if it is a long position:

If OrderValue(cnt,VAL_TYPE)=OP_BUY then // long position opened




{

•  Should it be closed?
  

Condition for exiting a long position: MACD is crossed by its Signal Line, MACD being above zero,
going downwards and being crossed by the Signal Line going upwards.

If MacdCurrent > 0 and MacdCurrent < SignalCurrent and
MacdPrevious > SignalPrevious and MacdCurrent > (MACDCloseLevel*Point) then
{
CloseOrder(OrderValue(cnt,VAL_TICKET),OrderValue(cnt,VAL_LOTS),Bid,3,Violet); Exit; // exit
};

•  should the trailing stop be reset?
  

We set the trailing stop only in case the position already has a profit exceeding the trailing stop
level in points, and in case the new level of the stop is better than the previous.
If TrailingStop > 0 then // if trailing stops are used

{

If (Bid-OrderValue(cnt,VAL_OPENPRICE))>(Point*TrailingStop) then
{

If OrderValue(cnt,VAL_STOPLOSS)<(Bid-Point*TrailingStop) then

{

ModifyOrder(OrderValue(cnt,VAL_TICKET),OrderValue(cnt,VAL_OPENPRICE),

Bid-Point*TrailingStop,OrderValue(cnt,VAL_TAKEPROFIT),Red);

Exit

};

};

};

o if it is a short position:

else // otherwise it is a short position

{

•  should it be closed?
  

Condition for exiting a short position: MACD is crossed by its Signal Line, MACD being below zero,
going upwards and being crossed by the Signal Line going downwards.
If MacdCurrent<0 and MacdCurrent>SignalCurrent and
MacdPrevious(MACDCloseLevel*Point) then
{ \ CloseOrder(OrderValue(cnt,VAL_TICKET),OrderValue(cnt,VAL_LOTS),Ask,3,Violet);
Exit; // exit };

•  should the trailing stop be reset?
  

We set the trailing stop only in case the position already has a profit exceeding the trailing stop
level in points, and in case the new level of the stop is better than the previous.
If TrailingStop>0 then // the user has put a trailing stop in his settings
{ // so, we set out to check it

If (OrderValue(cnt,VAL_OPENPRICE)-Ask)>(Point*TrailingStop) then

{

If OrderValue(cnt,VAL_STOPLOSS)=0 or

OrderValue(cnt,VAL_STOPLOSS)>(Ask+Point*TrailingStop) then

{

ModifyOrder(OrderValue(cnt,VAL_TICKET),OrderValue(cnt,VAL_OPENPRICE),

Ask+Point*TrailingStop,OrderValue(cnt,VAL_TAKEPROFIT),Red)

Exit;




};

};

};
// end. Closing all the curly bracket which remain open

};

};

};
So, following this step-by-step procedure, we have written our Expert Advisor...

Let's try to create an Expert Advisor running on the standard MACD indicator, with the profit-taking
capability, supporting trailing stops and using most safeguards for secure operation. In the example given
below the trade is done by opening and controlling a single position.

Trading principles:
• Long (BUY) entry – MACD indicator is below zero, goes upwards and is crossed by the "Signal
Line" going downwards.
[You must be registered and logged in to see this image.]
• Short (SELL) entry – MACD indicator is above zero, goes downwards and is crossed by the
"Signal Line" going upwards.
[You must be registered and logged in to see this image.]
• Long exit – by execution of the take profit limit, by execution of the trailing stop or when MACD
crosses its "Signal Line" (MACD is above zero, goes downwards and is crossed by the "Signal Line" going
upwards).
• Short exit – by execution of the take profit limit, by execution of the trailing stop or when MACD
crosses its "Signal Line" (MACD is below zero, goes upwards and is crossed by the "Signal Line" going
downwards).

Important note: to exclude insignificant changes of the MACD indicator (small 'hillocks' on the chart) from our analysis, we introduce an additional measure of controlling the size of the plotted 'hillocks' as follows: the indicator size should be at least 5 units of the minimum price (5*Point, which for USD/CHF = 0.0005 and for USD/JPY = 0.05).
[You must be registered and logged in to see this image.]

Step I: Writing the Expert Advisor description
[You must be registered and logged in to see this image.]
Point the mouse pointer on the Expert Advisors section of the "Navigator" window, press the right button of the mouse and select "Create a new Expert" command in the appearing menu. The "Initializing Wisard" of the Expert Advisor will ask you to enter certain data. In the appearing window we write the name (Name) of the
Expert Advisor – "MACD Sample", the author (Author) – indicate your name, the link (Link) – a link to your website, in the notes (Notes) – "Test example of an MACD-based Expert Advisor".

Step II: Creating the primary structure of the programme
Code of the test Expert Advisor will only occupy several pages, but even such volume is often difficult to
grasp, especially in view of the fact that we are not professional programmers – otherwise we wouldn't need this description at all, right?