Cara Membuat Forex Trading Otomatis vol2

Cara mengatur Trading Forex otomatis (Bagian 2/2)
Dalam posting sebelumnya, Artikel tentang VPS yang bisa diandalkan untuk trading forex. Setelah Anda sudah memilih Hosting VPS yang tepat, untuk langkah berikutnya. Langkah ini adalah memilih broker yang mengoprasikan Trading Forex Otomatis. Mengapa harus memilih langkah ini? Karena tidak semua broker forex menggunakan platform yang sama. Ada Meta Trader 4, Ninja Trader, Trader virtual (VT), Trading Station, dll ... tetapi tidak semua dapat diatur untuk Trading otomatis. Platform yang memungkinkan Trading otomatis adalah Meta Trader 4 Metaquotes.net

Sekarang kita tahu bahwa platform Sangat penting dalam Trading otomatis. Alasan mengapa Kita memilih Meta Trader 4 yang digunakan oleh hampir 90% dari broker. Para trader banyak yang mengembangkan robot sendiri untuk melakukan trading di MQL, bahasa software yang dikembangkan oleh MetaQuotes khusus untuk trading otomatis dari Meta Trader 4. Robot yang dikembangkan disebut MQL Expert Advisor (EA).

Banyak broker yang menggunakan sistem trading seperti platform Meta Trader 4. Mungkin anda sedang bingun mencari broker yang tepat untuk anda. Ada banyak persyaratan yang harus di lakukan untuk membuat Trading otomatis.

Syarat yang harus dilakukan adalah seperti di bawah ini agar Trading otomatis bisa berkerja :

1) Broker yang akan mengaktifkan menu dalam platform trading otomatis MetaTrader 4. Tidak semua broker menerima trading yang di lakukan oleh robot. Meskipun MetaTrader 4 menyediakan fungsi ini, broker dapat memilih untuk mengaktifkan atau tidak. Karena itu kita harus memastikan bahwa broker memberi izin sebelum menggunakan Expert Advisor(EA).

2) Banyak broker yang tidak menawarkan speed untuk action. Penundaan dalam membuka atau menutup transaksi dapat menyebabkan profit yang sangat kecil, dan menyebabkan masalah untuk E A. Anda bisa melakukan deposit dalam jumlah kecil untuk menguji kecepatan broker.

3) Gunakan fiter harga. Harga data (data tick) akan dikirim melalui broker untuk komputer kita setiap kali ada perubahan di pasar. Beberapa broker tidak menggunakan filter untuk data ini dan tick yang dikirim ke komputer kita bergerak terlalu cepat. Ini dapat menyebabkan masalah baik untuk trading otomatis atau manual.  pergerakan harga seharusnya sedang, untuk mengoptimalkan penggunaan Expert Advisors.

4) Gunakan Account Micro. Katakanlah Anda Sudah memiliki EA yang sangat menguntungkan, kemudian Anda menggunakan EA ini pada account  yang sebenarnya. Tapi Anda tidak tahu persis kemampuan EA ini sebelum digunakan dalam real trading dengan uang sungguhan. Siapapun bisa melakukan pengujian EA di demo account. Yang bisa di katakan adalah bahwa hasilnya tidak akan sama untuk digunakan dalam live Trading dengan uang sungguhan. Mengapa? Karena data (centang) demo account tidak sama dengan real account.  sebaiknya langkah uji coba dalam real account, tetapi  anda tanpa risiko kehilangan banyak uang. Solusinya adalah penggunaan account mikro di mana 1 poin = $ 0,01. Cukup depo sedikit uang di akun  dan menguji EA seberapa akurat di real account.

5) Non Dealing Desk. Ini adalah satu lagi kriteria untuk memilih broker yang baik untuk trading otomatis. Jika broker menawarkan fitur Non Dealing Desk pesanan akan ditangani oleh komputer, sehingga mereka dijalankan dengan sangat cepat. Hal ini tidak mungkin dengan penanganan secara manual oleh operator. Jadi jika broker Anda menyediakan sistem ini, adalah nilai yang plus buat anda.

6) Memungkinkan penggunaan leverage yang tinggi. Jika kita mencoba untuk melakukan Trading dengan sedikit uang, kita harus mempertimbangkan menggunakan leverage yang lebih tinggi. Hal ini untuk mengurangi penyimpanan dan penggunaan margin.

7) menawarkan  banyak sistem pembayaran. Jika anda ingin deposit sedikit uang kita tidak ingin membayar biaya yang berlebihan, bukan? *Saran mencari broker yang memakai banyak sistem pembayaran. karena hal ini mengurangi biaya transaksi.

Ini adalah beberapa persyaratan untuk memilih broker yang mengembangkan sistem trading otomatis. Salah satu forex broker yang menawarkan semua kriteria seperti di sebutkan tadi adalah  LiteForex. Mereka memiliki berbagai jenis account dengan kemampuan untuk menggunakan Expert Advisor dalam Trading otomatis (auto trading) yang sebenarnya. Anda dapat mengecek ini dengan mengunjungi situs webnya LiteForex.com

** Selamat dan sukses menggunakan trading otomatis!!
Sukses buat semua trader indonesia. salam!

Cara Optimalkan Strategi Metatrader

Bagaimana  Cara Mengoptimalkan Strategi Metatrader (Backtest pada Metatrader).

Untuk meningkatkan kinerja EA Anda perlu mengoptimalkan itu dan membuat backtesting dari strateginya. Untuk tujuan ini, gunakan alat yang tepat : Tester Metatrader Strategi.

Menguji strategi Trading Anda dengan bukti tentu penting tetapi membuat backtest, yaitu pada tes lulus pasti cara terbaik untuk menguji strategi mereka dalam jangka panjang. Optimasi adalah fitur yang Anda butuhkan untuk memahami bagaimana untuk menyesuaikan parameter dari EA Anda.

Ketepatan strategi metatrader tester selalu menjadi bahan perdebatan. Backtesting ini sebenarnya mampu menciptakan hanya perkiraan perdagangan yang akan benar-benar dieksekusi secara real time. Selain itu, ini tetap satu-satunya alat yang tersedia di pasar dengan cepat menguji strategi rentang waktu yang sangat luas yang mencakup berbagai situasi perdagangan dan Anda perlu belajar bagaimana menggunakannya dengan baik dan benar.

Untuk membuka tester strategi, cukup klik tombol dengan nama yang sama dari toolbar atau pilih dari menu View.

Sebelum membuat backtesting atau mengoptimalkan EA Anda adalah penting untuk memastikan bahwa data historis yang cukup lengkap dan akurat, terutama karena model uji dengan menggunakan '"Event Tick." Dimana data tidak cukup untuk membuat tanda centang (yaitu pergerakan harga minimum) kesalahan cukup akurat dapat terjadi pada grafik dalam Journal of tester strategi atau log yang menggambarkan secara tepat hasil operasioanal backtesting.

Sebagai langkah pertama kita harus menghapus isi dalam "log" yang berisi data historis dari default, untuk menghindari konflik. Folder log adalah di dalam folder root dari instalasi metatrader Anda.

Ada lagi langkah awal yang harus dilakukan sebelum pemuatan data historis. Pilihan  platform metatrader memprediksi bahwa mereka akan dimuat dan diproses sejumlah data default. Hal ini untuk membatasi penggunaan memori yang lain akan menggunakan platform.
Oleh karena itu sebelum impor apapun yang diperlukan untuk mengubah konfigurasi nilai-nilai "Max bar" dan "bar Max dalam grafik" yang dapat diakses melalui menu "tools-> pilihan" tab dan memasukkan grafik dengan menempatkan nilai-nilai maksimum yang mungkin sebagai ditunjukkan pada gambar di bawah.

Tab gambar untuk memperbesar

Pada titik ini Anda dapat membuka History Center dari menu Tools dan klik ganda pada pair mata uang yang Anda ingin melakukan backtesting. Di bawah ini adalah daftar timaframes. Mengklik ganda pada jangka waktu selama satu menit (M1) adalah pengisian data historis untuk periode tersebut. Sejak M1 backtester menggunakan data untuk menghasilkan kutu penting bahwa data dari M1 secara lengkap dan pergi kembali ke periode mana yang ingin memulai untuk melakukan pengujian.
Meskipun History Center, kita diberi kesempatan untuk men-download data historis, adalah bijaksana untuk tidak melakukan tindakan ini, Dan yang sering terjadi adalah untuk memuat data dalam jumlah besar akan memerlukan waktu dan koneksi yang luar biasa.

Cara termudah adalah karena itu untuk mengimpor data secara manual, seperti yang kita lihat pada gambar:

Tab gambar untuk memperbesar

Dan pilih file dengan mengklik browse dan memilih untuk mengimpor data  file yang akan diimpor, seperti terlihat pada gambar di bawah ini:

Tab gambar untuk memperbesar

Data yang Perlu diimpor dapat didownload langsung dan gratis di: http://www.forextester.com/data/datasources.html

Sekarang, kembali ke layar sebelumnya dengan mengklik OK, Anda dapat melihat bagaimana data historis yang dimuat: berikutnya  "database" dan Anda akan melihat bahwa jumlah record jauh lebih tinggi dari jumlah sebelumnya. Jika itu tidak! berarti data tidak dimuat dengan benar.

Tab gambar untuk memperbesar

Sebelum akhirnya akan menguji strategi harus mengurangi jumlah "Max bar di chart" untuk menghindari konsumsi memori yang berlebihan untuk program membangun grafik selama backtesting tersebut.

Tab gambar untuk memperbesar

Jika berencana untuk menggunakan  EA 1M jangka waktu yang berbeda, Anda harus mengkonversi data historis Anda. Operasi ini sangat sederhana dan dicapai dengan menyeret script "periode converter", yang terletak di bawah window "Navigator" di grafik cross yang akan dioperasikan:

Tab gambar untuk memperbesar

Dalam kasus jangka waktu satu jam, dan untuk ini kita tulis di sebelah variabel nilai "60", jika kita ingin menggunakan jangka waktu 4H kita telah tentukan "240" dan seterusnya.
Seperti yang kita lihat di jendela di bawah tab "jurnal" dari konversi "terminal" hasil data .

Optimasi.

Fitur terhutang dari MT4 platform adalah bahwa optimasi gabungan backtesting. Optimasi ini memungkinkan pengujian ribuan kombinasi dari EA yang sama untuk menemukan pengaturan yang paling menguntungkan untuk berbagai grafik, jangka waktu dan tanggal tertentu. Strategi berdasarkan indikator (seperti rata-rata bergerak atau MACD) sebenarnya perlu dioptimalkan untuk keuntungan maksimal. Namun hampir semua Expert Advisor akan mendapatkan keuntungan dari optimasi, bahkan mereka yang mengandalkan Trading untuk mencentang.

Alat optimasi akan memberikan Anda Profit lebih sebagai hasilnya parameter untuk suatu interval waktu, tetapi tidak ada jaminan mutlak bahwa parameter ini tetap menguntungkan di masa depan, karena kondisi pasar sering berubah, sehingga sangat penting untuk membuat EA optimasi baru untuk mendapatkan hasil terbaik.

Untuk mengoptimalkan EA Anda, setelah Anda membuka "Tester Strategi", cukup pilih dari menu drop down, pilih Pair mata uang dan periode, seperti ditunjukkan pada Gambar. Sebagai "model" harus dipilih "Harga Hanya Open" kecuali Anda mengoptimalkan EA yang menggunakan tick data dengan kecil. Untuk memilih tanggal  mengoptimalkan EA harus pilih "Gunakan tanggal" untuk menentukan interval. Sebagai langkah terakhir, pilih kotak centang di sebelah "Optimasi"

Tab gambar untuk memperbesar

Sebelum menekan tombol "mulai" mungkin tepat untuk menentukan parameter proses EA  yang diakses dengan menekan tombol . Di bawah "input" tab Anda harus memasukkan rentang di mana untuk mencari konfigurasi optimal untuk parameter kita. Kolom "mulai" menunjukkan nilai minimum untuk parameter, sementara kolom "slippage" nilai maksimum. Kolom adalah langkah bukan jumlah yang mendefinisikan algoritma optimasi akan bergerak pada setiap langkah untuk "mulai" untuk "berhenti". Mengklik pada parameter Anda dapat memutuskan apa yang akan dimasukkan dan yang di kecualikan dari optimasi.

Tab gambar untuk memperbesar

Setelah melewati optimasi, menekan tombol start. Setelah waktu yang diperlukan untuk memproses informasi, Anda dapat melihat hasil dengan mengakses tab "Hasil optimasi" yang sesuai dalam window "tester". Jendela ini merangkum semua langkah yang diambil selama proses optimasi, setiap baris menunjukkan langkah optimasi. Di ekstrim kanan adalah input nilai digunakan selama tahap, tetapi nilai-nilai lain menunjukkan, masing-masing, dari kiri ke kanan, keuntungan, trader membuat total, faktor keuntungan, rentang maksimum modal (yang juga menunjukkan risiko) dan kenaikan suku bunga.

Tab gambar untuk memperbesar

Pada titik ini, menganalisis data ini dan data dari grafik optimasi, mudah untuk menentukan adalah parameter yang paling menarik yang dapat digunakan untuk menjalankan backtesting dari EA.

Tab gambar untuk memperbesar

**Selamat mengoptimalkan EA Anda semoga sukses trading yang anda lakukan.
Salam sukses buat trader tanah air

Metatrader Phoenix Forex EA

Phoenix Forex expert advisor(EA) adalah EA yang sangat komplit. Fakta expert advisor menggunakan indikator standar yang berbeda dari platform MetaTrader4, seperti moving average, dan amplop, untuk menentukan titik masuk dan keluar, serta parameter lain dari posisi. Advisor Ini sangat terkini dan memiliki parameter input yang banyak, memelihara data di dalam sistemnya untuk masing-masing dari cross currency 5 yang dapat digunakan untuk trading. Banyaknya indikator dan verifikasi kondisi perdagangan bahwa EA Phoenix adalah sedikit lambat untuk diproses oleh CPU.

Tes dilakukan pada Phoenix MetaTrader expert advisor telah berhasil membuat keuntungan sebesar $ 6,400 di  Cross  GBP / USD dengan jangka waktu 5 menit menggunakan banyak standar untuk setiap posisi terbuka. Pengujian dilakukan selama satu tahun, dan kerugian maksimum ditemukan hanya $ 96. Tes diulang selama 3 tahun dan kinerja yang ditemukan menjadi biasa.

Contoh Kodenya adalah seperti ini:

//+------------------------------------------------------------------+
//|                                             Phoenix_5_6_03.mq4   |
//|                                       Copyright © 2006, Hendrick |
//|                                                                  |
//+------------------------------------------------------------------+ #property copyright "Copyright © 2006, Hendrick." #define MAGICMA_A  20050610
#define MAGICMA_B  20060611 #define MAGICMA01  20050612
#define MAGICMA02  20060613
#define MAGICMA03  20060614 extern string     GeneralSettings         = "===== General Settings ============================";
extern int        PhoenixMode             = 3;
extern double     Lots                    = 1;
extern double     MaximumRisk             = 0.05;
extern int        DecreaseFactor          = 0;
extern bool       MM                      = true;
extern bool       AccountIsMicro          = false; extern bool       PrefSettings            = true; extern int        CloseAfterHours         = 0;
extern int        BreakEvenAfterPips      = 0; extern string     Mode1                   = "====== Phoenix Mode 1 (Classic) ==================";
extern int        TakeProfit              = 0;
extern int        StopLoss                = 0;
extern int        TrailingStop            = 0; extern string     Mode2                   = "====== Phoenix Mode 2 (Second trade)==============";
extern int        Mode2_OpenTrade_2       = 0;
extern int        Mode2_TakeProfit        = 0;
extern int        Mode2_StopLoss          = 0;
extern bool       Mode2_CloseFirstTrade   = false;
extern string     Mode3                   = "====== Phoenix Mode 3 (Three trades at once) =====";
extern int        Mode3_CloseTrade2_3     = 0;
extern int        Mode3_TakeProfit        = 0;
extern int        Mode3_StopLoss          = 0; extern string     Signal1                 = "====== Signal 1 ===================================";
extern bool       UseSignal1              = true;
extern double     Percent                 = 0;
extern int        EnvelopePeriod          = 0; extern string     Signal2                 = "====== Signal 2 ==================================";
extern bool       UseSignal2              = true;
extern int        SMAPeriod               = 0;
extern int        SMA2Bars                = 0; extern string     Signal3                 = "====== Signal 3 ==================================";
extern bool       UseSignal3              = true;
extern int        OSMAFast                = 0;
extern int        OSMASlow                = 0;
extern double     OSMASignal              = 0; extern string     Signal4                 = "====== Signal 4 ==================================";
extern bool       UseSignal4              = true;
extern int        Fast_Period             = 0;
extern int        Fast_Price              = PRICE_OPEN;
extern int        Slow_Period             = 0;
extern int        Slow_Price              = PRICE_OPEN;
extern double     DVBuySell               = 0;
extern double     DVStayOut               = 0; extern string     Signal5                 = "====== Signal 5 =================================";
extern bool       UseSignal5              = true;
extern int        TradeFrom1              = 0;
extern int        TradeUntil1             = 24;
extern int        TradeFrom2              = 0;
extern int        TradeUntil2             = 0;
extern int        TradeFrom3              = 0;
extern int        TradeUntil3             = 0;
extern int        TradeFrom4              = 0;
extern int        TradeUntil4             = 0; double Poin; int init()
{
//Checking for unconvetional Point digits number
if (Point == 0.00001) Poin = 0.0001; //5 digits
else if (Point == 0.001) Poin = 0.01; //3 digits
else Poin = Point; //Normal //+------------------------------------------------------------------+
//| START Preffered Settings                                         |
//+------------------------------------------------------------------+ if(PrefSettings == true)
{
if((Symbol() == "USDJPY") || (Symbol() == "USDJPYm"))
{    
Mode2_OpenTrade_2    = 0;
Mode2_TakeProfit     = 50;
Mode2_StopLoss       = 60; Mode3_CloseTrade2_3  = 30;
Mode3_TakeProfit     = 100;
Mode3_StopLoss       = 55;
Percent              = 0.0032;
EnvelopePeriod       = 2;
TakeProfit           = 42;
StopLoss             = 84;
TrailingStop         = 0;
SMAPeriod            = 2;
SMA2Bars             = 18;
OSMAFast             = 5;
OSMASlow             = 22;
OSMASignal           = 2;
Fast_Period          = 25;
Slow_Period          = 15;
DVBuySell            = 0.0029;
DVStayOut            = 0.024;
} if((Symbol() == "EURJPY") || (Symbol() == "EURJPYm"))
{
Mode2_OpenTrade_2    = 18;
Mode2_TakeProfit     = 70;
Mode2_StopLoss       = 30; Mode3_CloseTrade2_3  = 55;
Mode3_TakeProfit     = 70;
Mode3_StopLoss       = 80; Percent              = 0.007;
EnvelopePeriod       = 2;
TakeProfit           = 42;
StopLoss             = 84;
TrailingStop         = 0;
SMAPeriod            = 4;
SMA2Bars             = 16;
OSMAFast             = 11;
OSMASlow             = 20;
OSMASignal           = 14;
Fast_Period          = 20;
Slow_Period          = 10;
DVBuySell            = 0.0078;
DVStayOut            = 0.026;
} if((Symbol() == "GBPJPY") || (Symbol() == "GBPJPYm"))
{
Mode2_OpenTrade_2    = 2;
Mode2_TakeProfit     = 130;
Mode2_StopLoss       = 80; Mode3_CloseTrade2_3  = 40;
Mode3_TakeProfit     = 90;
Mode3_StopLoss       = 80;
Percent              = 0.0072;
EnvelopePeriod       = 2;
TakeProfit           = 42;
StopLoss             = 84;
TrailingStop         = 0;
SMAPeriod            = 8;
SMA2Bars             = 12;
OSMAFast             = 5;
OSMASlow             = 36;
OSMASignal           = 10;
Fast_Period          = 17;
Slow_Period          = 28;
DVBuySell            = 0.0034;
DVStayOut            = 0.063;
}
if((Symbol() == "USDCHF") || (Symbol() == "USDCHFm"))
{
Mode2_OpenTrade_2    = 10;
Mode2_TakeProfit     = 90;
Mode2_StopLoss       = 65; Mode3_CloseTrade2_3  = 85;
Mode3_TakeProfit     = 130;
Mode3_StopLoss       = 80;
Percent              = 0.0056;
EnvelopePeriod       = 10;
TakeProfit           = 42;
StopLoss             = 84;
TrailingStop         = 0;
SMAPeriod            = 5;
SMA2Bars             = 9;
OSMAFast             = 5;
OSMASlow             = 12;
OSMASignal           = 11;
Fast_Period          = 5;
Slow_Period          = 20;
DVBuySell            = 0.00022;
DVStayOut            = 0.0015;
}
if((Symbol() == "GBPUSD") || (Symbol() == "GBPUSDm"))
{
Mode2_OpenTrade_2    = 5;
Mode2_TakeProfit     = 95;
Mode2_StopLoss       = 90; Mode3_CloseTrade2_3  = 90;
Mode3_TakeProfit     = 110;
Mode3_StopLoss       = 80;
Percent              = 0.0023;
EnvelopePeriod       = 6;
TakeProfit           = 42;
StopLoss             = 84;
TrailingStop         = 0;
SMAPeriod            = 3;
SMA2Bars             = 14;
OSMAFast             = 23;
OSMASlow             = 17;
OSMASignal           = 15;
Fast_Period          = 25;
Slow_Period          = 37;
DVBuySell            = 0.00042;
DVStayOut            = 0.05;
}    
}
return(0);
} //+------------------------------------------------------------------+
//| END Preffered Settings                                           |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| START EA                                                         |
//+------------------------------------------------------------------+ void start()
{
if(Bars<100)
{
Print("bars less than 100");
return(0);
} if(PhoenixMode==1)//Phoenix Classic
{
CheckOpenTrade();    
if(CloseAfterHours != 0)  CheckCloseAfterHours();
if(!StopLoss==0)              CheckTrailingStop();
if(BreakEvenAfterPips != 0)        CheckBreakEven();
}

if(PhoenixMode==2)//Phoenix Second Trade
{
CheckOpenTrade();    
if(CloseAfterHours != 0)  CheckCloseAfterHours();
CheckSecondTrade();
} if(PhoenixMode==3)//Phoenix 123
{
CheckOpenTradeMode123();    
Mode3_MoveSL_Trade_2_3();
Mode3_MoveSL_Trade_3();
if(Mode3_CloseTrade2_3 != 0) CheckCloseTrade23();
}
}
//+------------------------------------------------------------------+
//| END EA                                                           |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| START Function Calculate open positions                          |
//+------------------------------------------------------------------+
int CalculateCurrentOrders(string symbol)
{
int count=0; for(int i=0;i<OrdersTotal();i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
if(OrderSymbol()==Symbol() && (OrderMagicNumber()==MAGICMA_A || OrderMagicNumber()==MAGICMA_B))
{
count++;
}
}
return(count);
}
//+------------------------------------------------------------------+
//| STOP Function Calculate open positions                           |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| START Function Check Open Trade                                  |
//+------------------------------------------------------------------+
int CheckOpenTrade()
{    
int Signal=0, err = 0, total = OrdersTotal(); if(CalculateCurrentOrders(Symbol()) < 1)
{
if(CheckSignal(Signal)==1)
{
if(OrderSend(Symbol(),OP_SELL,LotsOptimized(),Bid,3,Bid+StopLoss*Poin,Bid-TakeProfit*Poin,"FirstTrade",MAGICMA_A,0,Red) < 0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
return(0);
}
if(CheckSignal(Signal)==2)
{
if(OrderSend(Symbol(),OP_BUY,LotsOptimized(),Ask,3,Ask-StopLoss*Poin,Ask+TakeProfit*Poin,"FirstTrade",MAGICMA_A,0,Blue) < 0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
return(0);
}
}
}
//+------------------------------------------------------------------+
//| END Function Check Open Trade                                    |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| START MODE 3 Function Check Open Trade                           |
//+------------------------------------------------------------------+
int CheckOpenTradeMode123()
{
int Signal = 0, err = 0, total = OrdersTotal(), decimalPlaces=1;
if(AccountIsMicro==true) decimalPlaces=2;
double lots123 = NormalizeDouble(LotsOptimized()/3,decimalPlaces); if(lots123 < 0.1 && AccountIsMicro==false) {lots123=0.1;}
if(lots123 < 0.01 && AccountIsMicro==true) {lots123=0.01;} if(Mode3CalculateCurrentOrders(Symbol()) < 1)    
{
if(CheckSignal(Signal)==1)
{
if(OrderSend(Symbol(),OP_SELL,lots123,Bid,3,Bid+Mode3_StopLoss*Poin,Bid-NormalizeDouble(Mode3_TakeProfit/2,0)*Poin,"Mode3_FirstTrade",MAGICMA01,0,Red)<0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
if(OrderSend(Symbol(),OP_SELL,lots123,Bid,3,Bid+Mode3_StopLoss*Poin,Bid-Mode3_TakeProfit*Poin,"Mode3_SecondTrade",MAGICMA02,0,Red)<0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
if(OrderSend(Symbol(),OP_SELL,lots123,Bid,3,Bid+Mode3_StopLoss*Poin,Bid-NormalizeDouble(Mode3_TakeProfit*1.5,0)*Poin,"Mode3_ThirdTrade",MAGICMA03,0,Red)<0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
return(0);
}
if(CheckSignal(Signal)==2)
{
if(OrderSend(Symbol(),OP_BUY,lots123,Ask,3,Ask-Mode3_StopLoss*Poin,Ask+NormalizeDouble(Mode3_TakeProfit/2,0)*Poin,"Mode3_FirstTrade",MAGICMA01,0,Blue)<0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}    
if(OrderSend(Symbol(),OP_BUY,lots123,Ask,3,Ask-Mode3_StopLoss*Poin,Ask+Mode3_TakeProfit*Poin,"Mode3_SecondTrade",MAGICMA02,0,Blue)<0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
if(OrderSend(Symbol(),OP_BUY,lots123,Ask,3,Ask-Mode3_StopLoss*Poin,Ask+NormalizeDouble(Mode3_TakeProfit*1.5,0)*Poin,"Mode3_ThirdTrade",MAGICMA03,0,Blue)<0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
return(0);
}
}
} //+------------------------------------------------------------------+
//| END Function Check Open Trade                                    |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| START Function Check Second Trade                                |
//+------------------------------------------------------------------+ void CheckSecondTrade()
{
int err = 0, total = OrdersTotal(); for(int z = total - 1; z >= 0; z --)
{
if(!OrderSelect( z, SELECT_BY_POS))
{
err = GetLastError();
Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #",err );
continue;
} if(OrderSymbol() != Symbol()) continue; if(OrderMagicNumber() == MAGICMA_B) break;
if(OrderMagicNumber() != MAGICMA_A) continue; if(OrderType() == OP_BUY && (Bid-OrderOpenPrice() > Poin*Mode2_OpenTrade_2))
{  
if(OrderSend(Symbol(),OP_BUY,LotsOptimized(),Ask,3,Ask - Mode2_StopLoss * Poin,Ask + Mode2_TakeProfit * Poin,"Mode2_SecondTrade",MAGICMA_B,0,Blue) < 0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
if(Mode2_CloseFirstTrade==true) {CloseFirstTrade();}
return(0);
} if(OrderType() == OP_SELL && (OrderOpenPrice()-Ask > Poin*Mode2_OpenTrade_2))
{
if(OrderSend(Symbol(),OP_SELL,LotsOptimized(),Bid,3,Bid + Mode2_StopLoss * Poin,Bid - Mode2_TakeProfit*Poin,"Mode2_SecondTrade",MAGICMA_B,0,Red) < 0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
if(Mode2_CloseFirstTrade==true) {CloseFirstTrade();}
return(0);
}
} } //+------------------------------------------------------------------+
//| END Function Check Second Trade                                  |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| START Function Check Close Trade 2 And 3                         |
//+------------------------------------------------------------------+
void CheckCloseTrade23()
{ int err = 0, total = OrdersTotal();
bool CloseTrade=false; for(int z = total - 1; z >= 0; z --)
{
if(!OrderSelect( z, SELECT_BY_POS))
{
err = GetLastError();
Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #",err );
continue;
} if(OrderSymbol() != Symbol()) continue; if(OrderMagicNumber() != MAGICMA01) continue;
if(OrderType() == OP_BUY && (OrderOpenPrice()-Bid > Poin * Mode3_CloseTrade2_3)) {CloseTrade=true;}
if(OrderType() == OP_SELL && (Ask-OrderOpenPrice() > Poin * Mode3_CloseTrade2_3)) {CloseTrade=true;} if(CloseTrade)
{
for(int y = total - 1; y >= 0; y --)
{
if(!OrderSelect( y, SELECT_BY_POS))
{
err = GetLastError();
Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
continue;
}
if(OrderSymbol() != Symbol()) continue; if(OrderMagicNumber() == MAGICMA02 || OrderMagicNumber() == MAGICMA03)
{
if(OrderType() == OP_BUY)
{
if(OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet)<0)
{
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
return(0);
}
if(OrderType() == OP_SELL)
{
if(OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet)<0)
{    
err = GetLastError();
Print("Error Ordersend(",err,"): ");
return(-1);
}
return(0);
}
}
}
}
}
}
//+------------------------------------------------------------------+
//| END Function Check Close Trade 2 And 3                               |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| START Check First Trade Mode3                                         |
//+------------------------------------------------------------------+ void Mode3_MoveSL_Trade_2_3()
{ int err = 0, total = OrdersTotal(), history = HistoryTotal();
bool ChangeStopLoss = false; for(int z = history - 1; z >= 0; z --)
{
if(!OrderSelect( z,SELECT_BY_POS,MODE_HISTORY))
{
err = GetLastError();
Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #",err );
continue;
} if(OrderSymbol() != Symbol()) continue; if(OrderMagicNumber() == MAGICMA03) break;
if(OrderMagicNumber() == MAGICMA02) break;
if(OrderMagicNumber() != MAGICMA01) continue; if(OrderProfit() > 0)
{
ChangeStopLoss=true;
break;
}
}
if(ChangeStopLoss==true)
{
for(int y = total - 1; y >= 0; y --)
{
if(!OrderSelect(y,SELECT_BY_POS))
{
err = GetLastError();
Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
continue;
} if(OrderSymbol() != Symbol()) continue; if(OrderMagicNumber() == MAGICMA02 || OrderMagicNumber() == MAGICMA03)
{
if(OrderType()==OP_BUY)
{
if(OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice(),OrderTakeProfit(),0,GreenYellow)<0)
{
err = GetLastError();
Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
continue;
}
//         return(0);
} if(OrderType()==OP_SELL)
{
if(OrderModify(OrderTicket(),OrderOpenPrice(),OrderOpenPrice(),OrderTakeProfit(),0,GreenYellow)<0)
{
err = GetLastError();
Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
continue;
}
//         return(0);
}
}    
}
}
}
//}
//+------------------------------------------------------------------+
//| END Check First Trade Mode 3                                     |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| START Check Second Trade Mode3                                   |
//+------------------------------------------------------------------+ void Mode3_MoveSL_Trade_3()
{ double NewSLTrade3B,NewSLTrade3S;
int err = 0, total = OrdersTotal(), history = HistoryTotal();
bool ChangeStopLoss = false; for(int z = history - 1; z >= 0; z --)
{
if(!OrderSelect( z,SELECT_BY_POS,MODE_HISTORY))
{
err = GetLastError();
Print("OrderSelect( ", z, ", SELECT_BY_POS ) - Error #",err );
continue;
} if(OrderSymbol() != Symbol()) continue; if(OrderMagicNumber() == MAGICMA03) break;
if(OrderMagicNumber() == MAGICMA01) break;
if(OrderMagicNumber() != MAGICMA02) continue; if(OrderProfit() > 0)
{
for(int y = total - 1; y >= 0; y --)
{
if(!OrderSelect(y,SELECT_BY_POS))
{
err = GetLastError();
Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
continue;
} if(OrderSymbol() != Symbol()) continue; if(OrderMagicNumber() == MAGICMA03)
{
if(OrderType()==OP_BUY)
{
NewSLTrade3B=OrderOpenPrice()+NormalizeDouble(((OrderTakeProfit()-OrderOpenPrice())/2),Digits);
if(OrderModify(OrderTicket(),OrderOpenPrice(),NewSLTrade3B,OrderTakeProfit(),0,GreenYellow)<0)
{
err = GetLastError();
Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
continue;
}
return(0);
} if(OrderType()==OP_SELL)
{
NewSLTrade3S=OrderOpenPrice()-NormalizeDouble(((OrderOpenPrice()-OrderTakeProfit())/2),Digits);
if(OrderModify(OrderTicket(),OrderOpenPrice(),NewSLTrade3S,OrderTakeProfit(),0,GreenYellow)<0)
{
err = GetLastError();
Print("OrderSelect( ", y, ", SELECT_BY_POS ) - Error #",err );
continue;
}
return(0);
}
}    
}
}
}
} //+------------------------------------------------------------------+
//| END Check Second Trade Mode 3                                    |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| START Function Diverge                                           |
//+------------------------------------------------------------------+ double divergence(int F_Period, int S_Period, int F_Price, int S_Price, int mypos)
{
int i;
double maF1, maF2, maS1, maS2; maF2 = iMA(Symbol(), 0, F_Period, 0, MODE_SMA, F_Price, mypos + 1);
maS2 = iMA(Symbol(), 0, S_Period, 0, MODE_SMA, S_Price, mypos + 1); return(maF2-maS2);
} //+------------------------------------------------------------------+
//| END Function Diverge                                             |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| START Function Valid Trade Time                                  |
//+------------------------------------------------------------------+ bool F_ValidTradeTime (int iHour)
{
if(((iHour >= TradeFrom1) && (iHour <= (TradeUntil1-1)))||((iHour>= TradeFrom2) && (iHour <= (TradeUntil2-1)))||((iHour >= TradeFrom3)&& (iHour <= (TradeUntil3-1)))||((iHour >= TradeFrom4) && (iHour <=(TradeUntil4-1))))
{
return (true);
}
else
return (false);
} //+------------------------------------------------------------------+
//| END Function Valid Trade Time                                    |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| START Check Close Trade After x Hours                            |
//+------------------------------------------------------------------+ void CheckCloseAfterHours()
{
int total = OrdersTotal(); for(int cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderType()<=OP_SELL &&
OrderSymbol()==Symbol() &&
OrderMagicNumber()==MAGICMA_A)
{          
if((CurTime()-OrderOpenTime())>(CloseAfterHours*3600) && OrderProfit()<0)
{
OrderClose(OrderTicket(),OrderLots(),Bid,10,Violet);
}
}
}
} //+------------------------------------------------------------------+
//| END Check Close Trade After x Hours                              |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| START Function Check Signals                                     |
//+------------------------------------------------------------------+ //=====================SIGNAL1========================
int CheckSignal(int Signal)
{
Signal=0; bool BuySignal1=false, SellSignal1=false; double HighEnvelope1 = iEnvelopes(NULL,0,EnvelopePeriod,MODE_SMA,0,PRICE_CLOSE,Percent,MODE_UPPER,1);
double LowEnvelope1  = iEnvelopes(NULL,0,EnvelopePeriod,MODE_SMA,0,PRICE_CLOSE,Percent,MODE_LOWER,1);
double CloseBar1     = iClose(NULL,0,1); if(UseSignal1)
{
if(CloseBar1 > HighEnvelope1) {SellSignal1 = true;}
if(CloseBar1 < LowEnvelope1)  {BuySignal1  = true;}
}
else {SellSignal1=true;BuySignal1=true;} //=====================SIGNAL2======================== bool BuySignal2=false, SellSignal2=false; double SMA1=iMA(NULL,0,SMAPeriod,0,MODE_SMA,PRICE_CLOSE,1);
double SMA2=iMA(NULL,0,SMAPeriod,0,MODE_SMA,PRICE_CLOSE,SMA2Bars); if(UseSignal2)
{
if(SMA2-SMA1>0) {BuySignal2  = true;}
if(SMA2-SMA1<0) {SellSignal2 = true;}
}
else {SellSignal2=true;BuySignal2=true;} //=====================SIGNAL3======================== bool BuySignal3=false, SellSignal3=false; double OsMABar2=iOsMA(NULL,0,OSMASlow,OSMAFast,OSMASignal,PRICE_CLOSE,2);
double OsMABar1=iOsMA(NULL,0,OSMASlow,OSMAFast,OSMASignal,PRICE_CLOSE,1); if(UseSignal3)
{
if(OsMABar2 > OsMABar1)  {SellSignal3 = true;}
if(OsMABar2 < OsMABar1)  {BuySignal3  = true;}
}
else {SellSignal3=true;BuySignal3=true;}
//=====================SIGNAL4======================== double diverge;
bool BuySignal4=false,SellSignal4=false;
diverge = divergence(Fast_Period, Slow_Period, Fast_Price, Slow_Price,0); if(UseSignal4)
{
if(diverge >= DVBuySell && diverge <= DVStayOut)
{BuySignal4 = true;}
if(diverge <= (DVBuySell*(-1)) && diverge >= (DVStayOut*(-1)))
{SellSignal4 = true;}
}      
else {SellSignal4=true;BuySignal4=true;}
//=====================SIGNAL5======================= bool BuySignal5=false, SellSignal5=false; if(UseSignal5)
{
int iHour=TimeHour(LocalTime());
int ValidTradeTime = F_ValidTradeTime(iHour);
if(ValidTradeTime==true)
{
BuySignal5=true;
SellSignal5=true;
}
}
else {SellSignal5=true;BuySignal5=true;} if((SellSignal1==true) && (SellSignal2==true) && (SellSignal3==true) && (SellSignal4==true) && (SellSignal5==true)) return(1);
if((BuySignal1==true) && (BuySignal2==true) && (BuySignal3==true) && (BuySignal4==true) && (BuySignal5==true)) return(2);
} //+------------------------------------------------------------------+
//| END Function Check Signals                                       |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| START Calculate optimal lot size                                 |
//+------------------------------------------------------------------+ double LotsOptimized()
{
if(MM==false) return(Lots);
double lot=Lots;
int    orders=HistoryTotal();
int    losses=0;
int    decimalPlaces=1;
if(AccountIsMicro==true) decimalPlaces=2; lot=NormalizeDouble(AccountFreeMargin()*MaximumRisk/1000.0,decimalPlaces);
if(DecreaseFactor>0)
{
for(int i=orders-1;i>=0;i--)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY)==false) { Print("Error in history!"); break; }
if(OrderSymbol()!=Symbol() || OrderType()>OP_SELL) continue;
//----
if(OrderProfit()>0) break;
if(OrderProfit()<0) losses++;
}
if(losses>1) lot=NormalizeDouble(lot-lot*losses/DecreaseFactor,decimalPlaces);
} if(lot<0.1 && AccountIsMicro==false) lot=0.1;
if(lot<0.01 && AccountIsMicro==true) lot=0.01;
if(lot>99) lot=99;
return(lot); }
//+------------------------------------------------------------------+
//| END Calculate optimal lot size                                   |
//+------------------------------------------------------------------+ //+------------------------------------------------------------------+
//| START Function Check TrailingStop                                |
//+------------------------------------------------------------------+
void CheckTrailingStop()
{
for(int i=0;i<OrdersTotal();i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)        break;
if(OrderMagicNumber()!=MAGICMA_A || OrderSymbol()!=Symbol()) continue;
if(OrderType() == OP_BUY)
{
if(((Bid - OrderOpenPrice()) > (Poin * TrailingStop)) && (OrderStopLoss() < (Bid - Poin * TrailingStop)))
OrderModify(
OrderTicket(),
OrderOpenPrice(),
Bid - Poin * TrailingStop,
OrderTakeProfit(),
0,
GreenYellow);
}
if(OrderType() == OP_SELL)
{
if(((OrderOpenPrice() - Ask) > (Poin * TrailingStop)) && (OrderStopLoss() > (Ask + Poin * TrailingStop)))
OrderModify(
OrderTicket(),
OrderOpenPrice(),
Ask + Poin * TrailingStop,
OrderTakeProfit(),
0,
Red);
}          
}
}
//+------------------------------------------------------------------+
//| END Function Check TrailingStop                                  |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Function Check BreakEven                                   |
//+------------------------------------------------------------------+ void CheckBreakEven()
{
for(int i=0;i<OrdersTotal();i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)        break;
if(OrderMagicNumber()!=MAGICMA_A || OrderSymbol()!=Symbol()) continue;
if(OrderType() == OP_BUY)
{
if((Bid-OrderOpenPrice()) > (Poin*BreakEvenAfterPips))
OrderModify(
OrderTicket(),
OrderOpenPrice(),
OrderOpenPrice(),
OrderTakeProfit(),
0,
GreenYellow);
}
if(OrderType() == OP_SELL)
{
if((OrderOpenPrice()-Ask) > (Poin*BreakEvenAfterPips))
OrderModify(
OrderTicket(),
OrderOpenPrice(),
OrderOpenPrice(),
OrderTakeProfit(),
0,
Red);
}          
}
} //+------------------------------------------------------------------+
//| END Function Check BreakEven                                 |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Function Close First Trade                                 |
//+------------------------------------------------------------------+
int CloseFirstTrade()
{
for(int i=0;i<OrdersTotal();i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)        break;
if(OrderMagicNumber()!=MAGICMA_A || OrderSymbol()!=Symbol()) continue;
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet);
return(0);
}
}
//+------------------------------------------------------------------+
//| END Function Close First Trade                                   |
//+------------------------------------------------------------------+
//+------------------------------------------------------------------+
//| START Function Calculate Current Orders Mode 3                   |
//+------------------------------------------------------------------+
int Mode3CalculateCurrentOrders(string symbol)
{
int buys=0,sells=0; for(int i=0;i<OrdersTotal();i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
if(
(OrderSymbol()==Symbol()) &&
((OrderMagicNumber()==MAGICMA01) ||
(OrderMagicNumber()==MAGICMA02) ||
(OrderMagicNumber()==MAGICMA03)))
{
if(OrderType()==OP_BUY)  buys++;
if(OrderType()==OP_SELL) sells++;
}
}
return(buys+sells);
}
//+------------------------------------------------------------------+
//| STOP Function Calculate Current Orders Mode 3                    |
//+------------------------------------------------------------------+

Jenis Metatrader4 Expert Advisors

Berbagai jenis Expert Advisors
Ada banyak jenis Expert Advisors tersedia untuk platform MT4. Dalam artikel ini, di menjelaskan apa yang paling populer. Dalam daftar ini, bukan daftar yang pasti, seperti yang kita lihat setiap tahun di ciptakan puluhan Expert Advisors baru dan strategi baru. Tidak hanya itu, tetapi ada juga perusahaan yang dapat menawarkan layanan penciptaan Expert Advisor berdasarkan permintaan atau ide dari Trader.

Expert Advisor dapat diprogram untuk penggunakan strategi yang berbeda, atau algoritma matematika. Ia mungkin termasuk grid, strategi, strategi lindung nilai, reverse martingale berbasis strategi, strategi tren berikut dan, akhirnya, strategi korelasi. Anda juga dapat mengandalkan berita, pada breakout, pada Broker atau adaptif. Kadang-kadang Expert Advisor bisa menjadi kombinasi strategi ini.

Setelah mencari di antara berbagai Expert Advisor dan dibandingkan strategi mereka, kami melakukan dua jenis klasifikasi. Klasifikasi pertama adalah EA Klasik terhadap Ea lanjutan yang lebih maju. Klasifikasi kedua adalah sebuah divisi yang nyata antara berita, breakout, lindung nilai, broker, dan adaptasi.

Berita EA | EA Scalper | Breakout EA | EA Hedge | EA Adaptif

Expert Advisor Berdasarkan Berita : Ini adalah jenis Expert Advisor Hedging Expert Advisor. Expert Advisor berdasarkan berita akan mencoba untuk mengambil keuntungan dari berita terbaru dan peristiwa terbaru yang menyebabkan pergerakan besar dalam Pair mata uang yang berbeda.

Scalper Expert Advisor : dalam skenario banyak, jenis Expert Advisors dibatasi oleh Broker Forex. Ketika digunakan dengan broker yang tidak memungkinkan jenis Trading dapat mengakibatkan penghapusan account Anda. Di sisi lain, biasanya Expert Advisors yang paling menguntungkan. Tujuannya adalah untuk membuat keuntungan kecil segera setelah Ia tersedia berdasarkan tren.

Expert Advisors Breakout : Jenis Expert Advisors transaksi terbuka ketika harga Pair mata uang tertentu melanggar tingkat dukungan atau perlawanan.

Berbasis Hedge Expert Advisor : Kategori ini termasuk semua Expert Advisor yang akan membuka dua posisi yang terpisah dan berlawanan untuk mencoba meminimalkan kerugian dari salah satu dari dua dan memaksimalkan keuntungan pada waktu itu.

Adaptive Expert Advisor: Kategori ini termasuk bagian dari jenis baru penasehat ahli. Ini generasi kedua Expert Advisors jauh lebih adaptif terhadap lingkungannya dan dapat bereaksi terhadap berbagai situasi dan tren.Kebanyakan dari sistem ini didasarkan pada jaringan , Yang memungkinkan ia untuk berpikir hampir seperti manusia.

EA Klasik | EA Lanjutan

Expert Advisor Classic: Expert Advisor ini berusaha untuk perdagangan rebound dari harga pada garis-garis support dan resistance, selain inversi. Ini akan membuka posisi ketika akan ada konfigurasi yang menyediakan probabilitas tinggi pembalikan atau koreksi. Banyak dari penasihat ahli berhenti mengunakan, sebuah fitur yang memungkinkan Anda untuk menjamin keuntungan. Ia juga dapat predefine berbagai kondisi untuk memantau pasar mencari pembalikan dan kemudian menutup posisi segera, bila diperlukan.

Expert Advisor Lanjutan : ini berkaitan Trading Expert Advisor  adalah beberapa pair pada saat yang sama dan sekaligus memantau kerangka waktu yang berbeda. Fitur unik ini memungkinkan Anda untuk memiliki berbagai pilihan ketika memilih tren yang biasanya akan membutuhkan jam jika Anda harus melakukannya secara manual.