Merancang sistem trading otomatis

Merancang sistem trading otomatis untuk mencapai sukses di forex


Sebelum Anda membuat aplikasi apapun diperlukan tahap desain, Semua ini berlaku untuk berbagai program aplikasi sistem Trading. Berhati-hatilah dalam perencanaan dan penjadwalan Anda yang Benar.

Proses ini akan membantu Anda untuk menyelesaikan masalah Software atau sistem, dalam waktu Real trading  dan akan mengurangi jumlah kesalahan. Jadi mari kita lihat bagaimana pendekatan langkah ini di definisikan sesuai kebutuhan sederhana yang menggunakan tiga sub-tahap.

1. Buat aturan sistem trading Anda

Langkah pertama dalam merancang sebuah sistem Trading adalah hanya untuk mengumpulkan sebuah cara teratur dan disiplin kerja.
yang kedua dimana sistem akan beroperasi. Berikut adalah 4 aturan bahwa setiap sistem trading harus berisi:

•  Mengidentifikasi ketika Anda membuka posisi
•  Mengidentifikasi ketika Anda ingin keluar dari posisi
•  Mengidentifikasi apa yang menghentikan kerugian Anda
•  Identifikasi apa target Anda

Mari kita ambil sebuah contoh untuk masing-masing empat aturan

Buka posisi ketika 30-hari rata-rata bergerak salib di atas rata-rata bergerak 60 hari.
Keluar dari posisi ketika 30-hari rata-rata bergerak kembali di bawah moving average untuk 60 hari.
Tempatkan stop loss pada maksimal 10 pips.
Memiliki 10 pips sebagai target keuntungan.

Dalam sistem ini misalnya akan effett

Pembelian dan penjualan berdasarkan rata-rata bergerak 30 dan 60 hari, sistem secara otomatis akan mengumpulkan keuntungan dan keluar dari posisi tersebut setelah mendapatkan 10 pips, atau akan dirilis pada kerugian jika ia telah kehilangan 10 pips.

2. Mengidentifikasi komponen untuk setiap aturan

Sekarang kita telah membukukan aturan kita, kita perlu mengidentifikasi komponen yang disertakan dalam setiap aturan. Setiap komponen harus mengandung dua elemen: indikator atau studi garis yang digunakan, dan parameter untuk indikator atau mempelajari baris.

Komponen-komponen ini harus dibuat dengan menulis nama untuk pembelajaran, di ikuti oleh parameter dalam tanda kurung. Parameter-parameter dalam kurung mengaitkan nilai yang diberikan untuk indikator atau garis pembelajaran. Kadang-kadang penanda mungkin memiliki lebih dari satu parameter, dalam hal ini hanya dipisahkan dengan koma.

Mari kita lihat beberapa contoh di bawah ini :

MA (25) - adalah rata-rata bergerak sampai 25 hari
RSI (25) - adalah indeks kekuatan relatif sampai 25 hari
MACD (tutup (0), 5,5) - Moving Average Convergence Divergence berdasarkan waktu saat ini, yang cepat dan panjang 5 hari dan lambat 5 hari.

Jika Anda tidak yakin berapa banyak parameter memerlukan indikator tertentu hanya dapat memeriksa Pembukuan atau dokumentasi yang telah anda buat dari platform trading Anda, yang menunjukkan semua indikator dan nilai-nilai yang harus di isi. Kita lihat misalnya nilai-nilai yang diperlukan oleh Markets.com

MACD:

Jadi, melanjutkan contoh dari langkah 1, yang di gunakan adalah :

MA (30) - 30-hari rata-rata bergerak
MA (60) - 60 hari moving average

3. Buat Indikator.

Sekarang kita menambahkan indikator, yaitu algoritma yang mendefinisikan tindakan program akan mengambil tindakan untuk kita, berdasarkan aturan. Setiap tindakan harus dinyatakan dalam format berikut:

Kondisi IF [WHILE] , aksi THEN

Biasanya kondisi terdiri dari indikator dan parameter yang telah dibuat sebelumnya, sementara saham terdiri dari pembelian atau penjualan. Perhatikan bahwa Saat ditempatkan dalam tanda kurung siku dalam hal ini adalah opsional.

Berikut adalah beberapa contoh dari hal yang terakhir:

BUT IF (30) Crosses Above MA (60) THEN Buy
BUT IF (30) Crosses Below MA (60) WHEN Volume (20,000) THEN Sell
IF EMA (25) Is greater then MA (5) THEN Sell
IF RSI (20) Do The Same For 50 THEN Buy

Kemudian, masih Mengacu pada contoh dari langkah 1 kita bisa menggunakan:

BUT IF (30) Crosses Above MA (60) THEN Buy
BUT IF (30) Crosses Below MA (60) THEN Sell
IF we have a trade 10 pips profit Sell THEN

** selamat merancang trading otomatis anda semoga sukses di forex.
salam buat trader tanah air, sukses milik kita bersama!

Code MQL4 Kerangka Expert Advisor

Kerangka Expert advisor menggunakan 3 Crossing  Komoditi indikator Channel Index (CCI) untuk menentukan posisi pembukaan dan penutupan. Dan indikator sederhana sangat efektif. EA ini juga mampu mengontrol margin dan menghentikan Trading jika Ada margin call. EA ini tidak akan kerja jika bar tidak berubah atau jika setidaknya ada 100 bar pada grafik.

Pada tes sampel dilakukan dengan Kerangka MetaTreader expert advisor memberikan hasil yang baik dengan Cross GBP/ JPY pada daily chart. Ia digunakan sepersepuluh dari banyak standar dan mencapai keuntungan sebesar $ 20,000 untuk $ 10,000 pada account selama setahun, dengan kerugian maksimum pada transaksi sekitar $ 2,000. Selama periode tiga tahun, kinerja sama-sama stabil.

Contoh Code MQL4 sebagai berikut :

#property link      "http://www.lightpatch.com/forex" // User Input
extern double Lots = 0.1;
extern int    TakeProfit=255;
extern int    StopLoss=0;
extern int    Interval=1;
extern int       myCCIs=30;   //  5 days
extern int       myCCIl=150;  // 25 days // Global scope
double barmove0 = 0;
double barmove1 = 0;
int         itv = 0; double Poin;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//|------------------------------------------------------------------| 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
itv=Interval;
return(0);
}
//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
{
return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+ int start()
{ bool      found=false;
bool     rising=false;
bool    falling=false;
bool      cross=false; double slA=0, slB=0, tpA=0, tpB=0;
double p=Poin;

double cCIs;
double cCIm;
double cCIf;

int      cnt=0; // Error checking
if(AccountFreeMargin()<(1000*Lots))        {Print("-----NO MONEY"); return(0);} if(Bars<100)                               {Print("-----NO BARS "); return(0);} if(barmove0==Open[0] && barmove1==Open[1]) {                        return(0);} // bars moved, update current position barmove0=Open[0]; barmove1=Open[1]; // interval (bar) counter // used to pyramid orders during trend itv++;  // since the bar just moved // calculate TP and SL for (B)id and (A)sk tpA=Ask+(p*TakeProfit); slA=Ask-(p*StopLoss); tpB=Bid-(p*TakeProfit); slB=Bid+(p*StopLoss); if (TakeProfit==0) {tpA=0; tpB=0;}            if (StopLoss==0)   {slA=0; slB=0;}             // get CCI based on OPEN cCIs=iCCI(Symbol(),0,125,PRICE_OPEN,0); cCIm=iCCI(Symbol(),0, 25,PRICE_OPEN,0); cCIf=iCCI(Symbol(),0,  5,PRICE_OPEN,0); // is it crossing zero up or down if (cCIm<=0 && cCIs>=0 && cCIf>0) { rising=true; cross=true; Print("Rising  Cross");}
if (cCIm>=0 && cCIs<=0 && cCIf<0) {falling=true; cross=true; Print("Falling Cross");}  // close then open orders based on cross // pyramid below based on itv if (cross) { // Close ALL the open orders  for(cnt=OrdersTotal();cnt>0;cnt--)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderSymbol()==Symbol())
{
if (OrderType()==0) {OrderClose(OrderTicket(),Lots,Bid,3,White);}
if (OrderType()==1) {OrderClose(OrderTicket(),Lots,Ask,3,Red);}
itv=0;
}
}
// Open new order based on direction of cross
if (rising)  OrderSend(Symbol(),OP_BUY,Lots,Ask,3,slA,tpA,"ZZZ100",11123,0,White);
if (falling) OrderSend(Symbol(),OP_SELL,Lots,Bid,3,slB,tpB,"ZZZ100",11321,0,Red);

// clear the interval counter
itv=0;
}

// Only pyramid if order already open
found=false;
for(cnt=OrdersTotal();cnt>0;cnt--)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderSymbol()==Symbol())
{
if (OrderType()==0)  //BUY
{
if (itv >= Interval)
{
OrderSend(Symbol(),OP_BUY,Lots,Ask,3,slA,tpA,"ZZZ100",11123,0,White);
itv=0;
}
}
if (OrderType()==1)  //SELL
{
if (itv >= Interval)
{
OrderSend(Symbol(),OP_SELL,Lots,Bid,3,slB,tpB,"ZZZ100",11321,0,Red);
itv=0;
}
}
found=true;
break;
}
}
return(0);
}

**Selamat berexperimen bagi yang memahami bahasa kode MQL4, atau anda memininta bantuan web developer.
Salam sukses buat trader tanah air , profit dan sukses adalah tujuan utama para trader. good job!

Apa Itu Expert Advisor (EA)?

Expert Advisors atau EA Di pasar forex adalah software trading otomatis yang di jalankan pada platform metatrader. Expert Advisors memiliki nama lain di pasar forex, seperti: Forex Robot, EA (di singkat), EA Metatrader 4 (untuk nama dari platform), dan EA MT4 Software Otomatis Forex.

Expert Advisor diprogram menggunakan bahasa pemrograman MQL 4. Robot ini dirancang untuk melakukan  trading forex dalam platform MetaTrader. Expert Advisors  memiliki berbagai tingkat otomatisasi dalam melakukan trading.

Ada EA yang di program akan mengingatkan Anda setiap kali Ia menemukan celah trading ketika mau membuka sebuah posisi, sementara ada yang Membuka dan menutup posisi secara langsung dan otomatis ke account Anda. Strategi-strategi ini mengontrol perdagangan variabel yang berbeda, termasuk penyesuaian otomatis stop loss, berhenti Mengikuti dan mengambil tingkat Profit bagi pemiliknya.

Ada berbagai macam jenis Expert Advisors untuk MetaTrader dan Kebanyakan dari semua Sistem menggunakan strategi yang berbeda untuk masuk dan keluar dari market. Manfaat nyata dari menggunakan software otomatis untuk trading Anda, adalah untuk menghapus elemen emosional yang dimiliki manusia yang bisa menyebabkan kerugian besar setiap kali melakukan trading, termasuk dalam hal gaya trading anda. Trading yang didasarkan pada emosi dan bukan pada perhitungan statistik dapat menyebabkan kerugian serius di Market Forex. Masalah lain yang mampu di pecahkan EA adalah sejumlah besar parameter yang masing-masing dapat di ambil dan mengintegrasikan ketika memutuskan apa yang harus dilakukan. Robot dapat memantau beberapa parameter, dan membuat perhitungan dalam sepersekian detik lebih baik dari kemampuan rata-rata manusia, karena robot memang di rancang hanya untuk tugas-tugas itu.

Bahasa pemrograman MQL-4 adalah sangat fleksibel dan menggunakan semua fungsi bahwa Metatrader 4 platform yang ditawarkan. Semua feed dan statistik yang tersedia pada platform juga tersedia untuk robot sehingga mengintegrasikan Robot ke dalam strategi atau algoritma. Variabel, seperti rata-rata bergerak yang berbeda, relatif indeks stregth, saluran komoditas indeks, dan bahkan kustom indikator Anda sendiri (jika perlu) dapat dilihat dan digunakan (jika perlu) untuk di jadikan EA mengambil keputusan.

Expert Advisors menggunakan indikator teknis yang berbeda, disediakan oleh platform metatrader yang jadi Bahan untuk memeriksa kondisi pasar dan menjalankan keputusan-keputusan trading. Setiap Expert Advisor ini terkait dengan grafik pada platform MetaTrader. mengambil dan memperhitungkan berbagai faktor keputusan di tentukan dalam hitungan detik. Seperti disebutkan sebelumnya, kombinasi dari pengolahan beberapa variabel sekaligus dan tanpa mengunakan emosi dalam trading yang akan mengarah pada persentase Profit yang lebih tinggi dan margin keuntungan yang lebih baik.

Namun, karena dengan adanya  Expert Advisors yang banyak di pasar dan ada beberapa lebih baik dari yang lainnya, tujuan artikel ini adalah untuk membandingkan semua EA yang tersedia di pasar forex dan memberikan informasi yang tepat diperlukan untuk memahami EA mana yang terbaik untuk tujuan sukses trading kita.

** menggali informasi tiada batasnya untuk mencapai sukses dalam bertrading. Salam sukses
buat trader-trader tanah air

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!

Apa Peran VPS dalam Trading Forex

Ini adalah layanan yang membantu para pedagang untuk membuat penyebaran EA mereka pada dedicated server yang akan berjalan 24 jam x 7 hari tanpa gangguan. Terlepas dari komputer trader dan tanpa kerja di PCnya.
Perusahaan-perusahaan yang menawarkan VPS (virtual private server) hosting biasanya memungut $35-115 USD per bulan tergantung pada kualitas layanan yang disediakan. Jadi jika Anda memiliki EA MT4 yang bekerja dengan baik selalu dianjurkan bahwa Anda untuk install unserver VPS sejak EA berjalan pada PC Anda di rumah atau bisnis anda akan tunduk pada masalah yang tak terduga (pemutusan dari jaringan, hw masalah, kesalahan sistem, dan lain-lain).

kita sekarang melihat bagaimana sebuah server VPS dan apa yang digunakan.
tiga elemen utama adalah PC, server dan server trader MT4 VPS. Ia bersama-sama dan saling berkomunikasi melalui Internet.
Trader dapat memeriksa server VPS dan load-nya ke EA baru dan memonitor account trading Anda dengan menghubungkan ke platform MT4 yang ditawarkan oleh broker yang berada pada server VPS.

Melalui  mekanisme kegiatan ini mengharuskan PC trader dihidupkan 24 jam selama 5 hari yang akan terhubung ke Internet. Bahkan, EA diinstal pada server VPS mengirimkan perintah ke MT4 server secara otomatis dan mandiri berkat  VPS  yang memberikan waktu hingga 100% (24/7).

Pada akun trader perlu terhubung ke VPS hanya untuk mengubah strategi dari EA, atau untuk mengontrol kemajuan account mereka.Metatrader 5 menawarkan kesempatan yang sama untuk mengelola account Anda.

Lihat 


http://www.earnforex.com/forex-vps-hosting/
http://www.forexvps.com/

**Anda dapat menemukan daftar VPS metatrader untuk keduanya  linux dan windows.

VPS hosting metatrader 4

Layanan VPS hosting mendapat peran penting dalam dunia trading forex. VPS adalah sebuah server layanan hosting virtual private yang Anda dapat mengakses PC dari mana saja di seluruh penjuru dunia, yang Anda butuhkan adalah koneksi internet.

Para Tarder terbaik menggunakan layanan ini karena menawarkan beberapa keunggulan dibandingkan dengan Trading normal dari rumah yang menggunakan perangkat computer normal.
Hal ini telah menyebabkan banyak layanan VPS didedikasikan khusus untuk forex trading dalam 10 tahun terakhir dan telah digunakan oleh ribuan pengguna.

Sebuah layanan hosting Forex dapat meningkatkan keuntungan dalam beberapa cara. Sementara itu, ketika menggunakan layanan VPS tidak perlu khawatir tentang masalah koneksi internet. Bahkan, strategi dibuat pada platform akan terus berjalan pada server VPS terlepas dari mana itu bertempat.
Untuk alasan ini, layanan VPS digunakan oleh semua yang terlibat dalam Forex autotrade ini menggunakan Metatrader atau platform lain yang mendukungnya. Memiliki hosting khusus untuk forex dapat menjalankan Expert Advisor Anda sendiri 24 jam/hari kali 5 hari dalam seminggu.

Bahkan jika seorang trader tidak memiliki akses ke PC dengan koneksi Internet, masalah teknis yang dapat menjadi kekuatan atau koneksi sinyal dengan VPS hosting sistem perdagangan yang terus berjalan, untuk Entry dan Exit menurut posisi stop yang telah ditentukan, sehingga menghindari kerugian besar yang dapat didaftarkan jika platform klien mereka tidak dapat melakukan pemesanan dalam waktu. Jadi ini adalah alasan utama mengapa VPS telah menjadi begitu sangat populer.

Ketika memilih layanan hosting adalah penting untuk memastikan bahwa VPS tersebut kompatibel dengan platform dari broker yang Anda gunakan. Jika Anda menggunakan Metatrader ini hampir tidak pernah masalah karena sebagian besar VPS cenderung untuk penggunaan Metatrader 4.

Ini masih penting dalam memilih layanan hosting, memeriksa dan membandingkan penawaran dari perusahaan yang berbeda. Spesifikasi dapat sangat bervariasi dari satu hosting ke hosting yang lain, Namun poin yang paling penting  menjadi dasar pilihan  adalah:

Layanan data : ia merupakan parameter penting dari keandalan.
Negara: menunjukkan seberapa dekat server dari broker dan kemudian mempengaruhi kecepatan  Order yang ditempatkan.
Opsi Pembayaran : dapat berupa kartu kredit,paypal, dan banyak metode pembayaran untuk semua layanan online.
Harga: penting untuk mengevaluasi bersama dengan kualitas layanan (kualitas bagus tentu sesuai dengan harganya).
Sistem Operasi: Windows normal, tetapi ada orang-orang yang menggunakan sistem Linux.
metatrader sistem terinstal memungkinkan Anda untuk menghindari melakukan banyak setting.
Biaya Bulanan penting untuk mengevaluasi berdasarkan jumlah operasi yang dilakukan.
Masa Percobaan: Jika ditawarkan dapat mempengaruhi pilihan Anda.
Penawaran ready EA : beberapa menyediakan dalam bentuk Free(hadiah)  untuk menginstal atau pra-instal pada platform EA.

Anda bisa mengecek di sini tentang VPS Khusus Forex

** Selamat Menggunakan VPS hosting khusus forex semoga sukses trading anda.
Salam sukses buat trader tanah air

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

Untung Rugi Memakai Metatrader

Keuntungan dan kerugian dari sistem Trading otomatis
Sistem perdagangan adalah seperangkat aturan sederhana bahwa trading dapat digunakan untuk menentukan poin untuk masuk atau keluar dari posisi. Mengembangkan dan menggunakan sistem trading otomatis dapat membantu trader mencapai hasil yang konsisten dan pada saat yang sama membatasi risiko. Dalam situasi yang ideal bagi para trader harus merasa seperti robot, dan mengeksekusi perintah secara sistematis tanpa emosi apapun. Jadi apa kontraindikasi untuk menjalankan robot pada sistem Anda? Jawabannya sederhana: tidak!. Jadi mari kita lihat apa yang Anda butuhkan untuk menciptakan sebuah sistem trading otomatis.

Sistem trading otomatis diciptakan dengan mengubah aturan kode sistem trading Anda bahwa komputer Anda dapat mengerti. Komputer kemudian "menjalankan" aturan-aturan ini melalui software trading, yang menetapkan untuk mencari usaha yang mematuhi aturan yang telah ditetapkan. Ditemukan respon pasar terhadap aturan ini, sistem tempat pesanan pada broker anda.

Tapi kita melihat secara lebih rinci apa sistem perangkat lunak ini yang mendukung trading otomatis.

Ada banyak fakta  program trading  yang mendukung sistem perdagangan otomatis. Beberapa operasi secara otomatis akan menghasilkan dan menetap di broker anda. Lainnya hanya menemukan operasi mungkin yang sesuai dengan kriteria mereka, tetapi untuk melakukan pemesanan akan membutuhkan intervensi dari trader secara pribadi. Selain itu, program trading otomatis sering meminta Anda untuk menggunakan broker tertentu yang mendukung fitur tertentu.

Jadi apa keuntungan dan kerugian mereka jika memakai sistem ini?

Sistem otomatis(metatrader) dapat menyebabkan banyak manfaat, tetapi jelas ada juga downsides. Lagi pula, jika seseorang memiliki sistem perdagangan yang secara otomatis berhasil membuat Profit setiap kali Anda membuka posisi maka dia benar-benar menemukan penemuan abad ini!

Keuntungan:

• Sebuah sistem trading otomatis dari emosinya dan bahkan "kotor" karya Trading, yang memungkinkan orang untuk fokus pada peningkatan strategi mereka dan aturan untuk pengelolaan portofolio.
• Setelah Anda mengembangkan biaya yang efektif, tidak perlu untuk melakukan pekerjaan lebih lanjut sampai sistem bekerja , atau sampai kondisi pasar tidak memerlukan perubahan.

Kekurangan:

• Jika sistem ini tidak benar dibuat dan diuji, maka kerugian yang sangat besar dapat terjadi dengan cepat atau nol sukses.
• Kadang-kadang tidak mungkin untuk menyusun aturan-aturan tertentu, sehingga sangat sulit untuk mengembangkan sistem trading otomatis.

** Tapi semuanya tergantung kepada anda, dimana ada akan memulai sukses!?

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                    |
//+------------------------------------------------------------------+

Instal EA di Platform MetaTrader4

Cara menginstal EA di Platform MetaTrader4
Beberapa robot Trading untuk Metatrader 4 termasuk paket instalasi otomatis. Lainnya memerlukan instalasi manual, terutama yang gratis. Instal bot masih sangat sederhana, hanya perlu bahwa semua file ditempatkan dalam folder yang benar di komputer Anda



Tahap Instalasi robot trading:

1. Download Expert Advisor. Anda dapat mendownload file tersebut langsung ke posisi yang benar tetapi pertama Anda harus memastikan bahwa itu adalah file zip. Jika ya, Anda harus terlebih dahulu meng-unzip file dan menempatkan mereka dalam posisi yang tepat.
2. Windows Vista dan Windows 7 memiliki dukungan yang diperlukan untuk unzip file tanpa bantuan software lain. Namun, jika Anda masih menggunakan XP, 2000 atau versi windows lain Anda mungkin perlu men-download program gratis seperti "iZip".
3. Setelah download selesai Anda akan perlu untuk memasukkan "E A" Anda dalam program MetaTrader 4. Jika Anda memiliki live account atau demo account, Anda harus membuat satu sebelum melanjutkan.
4. Salin file dari E A. Ini adalah ekstensi file Atau ex4.. Mq4 (copy file, bukan folder). Untuk menyalinnya untuk memilihnya dengan Ctrl + c atau klik kanan + copy.
5. File pada My Computer dan mencari ikon hard drive Anda (biasanya C :). Begitu menemukan file program folder atau program. Setelah masuk Anda akan menemukan folder yang disebut MetaTrader atau sesuatu seperti nama mungkin?  tergantung pada broker yang menyediakan itu. Setelah Anda menemukan folder, membukanya dan konfirmasi.
6. Untuk menyelesaikan instalasi hanya copy file ke konfirmasi dengan mengklik kanan pada mouse dan melakukan "paste". Jika tab keluar windows yang meminta Anda  izin untuk meng-copy, dan setuju untuk file tersebut akan diinstal.
7.setelah install selesai restart komputeranda. Setelah restart program akan memeriksa "EA" untuk melihat apakah EA sudah terinstal. Anda dapat memeriksa dengan  ke View -> Navigator. Jika instalasi berhasil nama dan ikon akan ditampilkan.

Cara Aktifkan metatrader /Robot forex

Cara Aktifkan E A cukup mudah. Untuk melakukan hal ini cukup pergi ke menu Tools dan pilih Options - Advisors> username dan pilih kotak "mengaktifkan expert advisor" dan "memungkinkan live trading". Jika EA Anda menyertakan file. DLL Anda juga pilih "memungkinkan Anda untuk mengimpor DLL." Jika expert advisor Anda termasuk layar atau pengguna eksternal Anda juga harus memilih "memungkinkan impor penguna eksternal."

Gunakan Tester Strategi Metatrader

Pernahkah Anda ingin menguji fungsi atau strategi sebelum Anda menggunakannya secara live? Untuk melakukan ini, Anda dapat menggunakan "strategi test" dengan memilih View -> Strategi Tester dari menu dan melakukan langkah-langkah berikut:

1. Pilih  EA Anda untuk menguji.
2. Pilih parameter dari AE (sifat tombol).
3. Pilih Pair(pasangan) mata uang yang akan diuji (dari daftar simbol).
4. Pilih jangka waktu dari data yang akan digunakan (dari periode daftar).
5. Pilih template Anda gunakan dari daftar template, menghitung bahwa setiap tick adalah yang paling akurat tetapi juga lebih lambat sementara pada titik kontrol lebih cepat, namun kurang akurat.
6. Optimasi ini digunakan untuk memilih set parameter optimal untuk EA.
7. Layar ini digunakan untuk memungkinkan pengguna untuk mengikuti posisi open dan closed oleh EA.
8. "Gunakan Tanggal" digunakan untuk memilih jangka tes, jika masa uji tidak ditentukan, tester akan secara otomatis memberlakukan semua tanggal yang tersedia.

Hasil pengujian dapat dilihat sebagai spreadsheet, grafik atau laporan, disajikan dengan informasi cara yang berbeda diperoleh.

selamat mencoba

Contoh Tampilan Expert Advisor MACD EA

Contoh MACD expert advisor adalah ahli penasihat, sampel terkenal dibuat oleh Software MetaQuotes untuk Melaksanakan strategi MACD berbasis sangat sederhana perdagangan Forex. MACD (Moving Average Convergence / Divergence) adalah salah satu indikator perdagangan dasar keuangan, "yang hadir dalam setiap platform MetaTrader.

Versi Contoh MACD telah dioptimalkan secara khusus untuk GBP / USD grafik H4.  EA Ini menggunakan Crossing dari 4 indikator MACD dan 2 indikator moving average determinates ke arah posisi depan. Contoh MACD menggunakan stop-loss order untuk membuntuti PERUSAHAAN. Itu sebabnya ia memiliki persentase yang sangat tinggi dari pesanan menguntungkan. Tapi EA ini Harus selalu aktif untuk berhenti dari posisi kalah dalam waktu singkat.

Pengujian Sampel MACD MetaTrader expert advisor Menunjukkan beberapa hasil yang menarik. pada GBP / USD grafik H4  dengan 0,3 Oder standar. Hasilnya tentang keuntungan sekitar $ 4,450 $ 1,030 penarikan maksimum dalam satu tahun. Memeriksa pada masa tahun tiga

Apakah tidak masalah untuk mengungkapkan  EA ini:
Contoh Tampilan  MACD EA

//|                                       http://www.metaquotes.net/ | extern double TakeProfit = 30;
extern double Lots = 0.3;
extern double TrailingStop = 60;
extern double StopLoss = 0;
extern double MACDOpenLevel=3;
extern double MACDCloseLevel=2;
extern double MATrendPeriod=24; //+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
{
double MacdCurrent, MacdPrevious, SignalCurrent;
double SignalPrevious, MaCurrent, MaPrevious;
int cnt, ticket, total;
// initial data checks
// it is important to make sure that the expert works with a normal
// chart and the user did not make any mistakes setting external
// variables (Lots, StopLoss, TakeProfit,
// TrailingStop) in our case, we check TakeProfit
// on a chart of less than 100 bars
if(Bars<100)
{
Print("bars less than 100");
return(0);
}
if(TakeProfit<10)
{
Print("TakeProfit less than 10");
return(0);  // check TakeProfit
}
// to simplify the coding and speed up access
// data are put into internal variables
MacdCurrent=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,0);
MacdPrevious=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
SignalCurrent=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,0);
SignalPrevious=iMACD(NULL,0,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
MaCurrent=iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,0);
MaPrevious=iMA(NULL,0,MATrendPeriod,0,MODE_EMA,PRICE_CLOSE,1); double SL;
total=OrdersTotal();
if(total<1)
{
// no opened orders identified
if(AccountFreeMargin()<(1000*Lots))
{
Print("We have no money. Free Margin = ", AccountFreeMargin());
return(0);
}
// check for long position (BUY) possibility
if(MacdCurrent<0 && MacdCurrent>SignalCurrent && MacdPrevious<SignalPrevious &&
MathAbs(MacdCurrent)>(MACDOpenLevel*Point) && MaCurrent>MaPrevious)
{
SL = 0;
if (StopLoss > 0) SL = Ask - StopLoss * Point;
ticket=OrderSend(Symbol(),OP_BUY,Lots,Ask,3,SL,Ask+TakeProfit*Point,"macd sample",16384,0,Green);
if(ticket>0)
{
if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES)) Print("BUY order opened : ",OrderOpenPrice());
}
else Print("Error opening BUY order : ",GetLastError());
return(0);
}
// check for short position (SELL) possibility
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDOpenLevel*Point) && MaCurrent<MaPrevious)
{
SL = 0;
if (StopLoss > 0) SL = Bid + StopLoss * Point;
ticket=OrderSend(Symbol(),OP_SELL,Lots,Bid,3,0,Bid-TakeProfit*Point,"macd sample",16384,0,Red);
if(ticket>0)
{
if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES)) Print("SELL order opened : ",OrderOpenPrice());
}
else Print("Error opening SELL order : ",GetLastError());
return(0);
}
return(0);
}
// it is important to enter the market correctly,
// but it is more important to exit it correctly...  
for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderType()<=OP_SELL &&   // check for opened position
OrderSymbol()==Symbol())  // check for symbol
{
if(OrderType()==OP_BUY)   // long position is opened
{
// should it be closed?
if(MacdCurrent>0 && MacdCurrent<SignalCurrent && MacdPrevious>SignalPrevious &&
MacdCurrent>(MACDCloseLevel*Point))
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
return(0); // exit
}
// check for trailing stop
if(TrailingStop>0)
{                
if(Bid-OrderOpenPrice()>Point*TrailingStop)
{
if(OrderStopLoss()<Bid-Point*TrailingStop)
{
OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,OrderTakeProfit(),0,Green);
return(0);
}
}
}
}
else // go to short position
{
// should it be closed?
if(MacdCurrent<0 && MacdCurrent>SignalCurrent &&
MacdPrevious<SignalPrevious && MathAbs(MacdCurrent)>(MACDCloseLevel*Point))
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
return(0); // exit
}
// check for trailing stop
if(TrailingStop>0)
{                
if((OrderOpenPrice()-Ask)>(Point*TrailingStop))
{
if((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0))
{
OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red);
return(0);
}
}
}
}
}
}
return(0);
}
// the end.