Forex Trading By Expert Advisor (EA)

การเขียนอีเอตรวจสอบแท่งเทียน Hammer

2015-08-15T16:38:00.000+07:00

Hammer คือรูปแบบแท่งเทียนที่บอกถึงสัญญาณการกลับตัวขึ้น (Bullish Reversal) โดยแท่งเทียนจะมีลักษณะคล้ายรูปค้อน เงื่อนไขที่จะทำให้เกิดเป็นแท่งเทียนแฮมเมอร์ก็คือ

1. ตัวแท่งเทียนต้องมีความยาวน้อยกว่าไส้เทียนด้านล่าง 2-3 เท่า

2.ไส้เทียนด้านบนจะต้องมีความยาวน้อยมากถ้าไม่มีเลยจะยึ่งดี

3.ถ้าจะใช้เป็นตัวยืนยันการเข้าออร์เดอร์ต้องเป็น Down Trend ก่อนเกิดแท่งเทียน Hammer

เขียนอีเอตรวจสอบแท่งเทียน Hammer ได้อย่างไร

นำเงื่อนไขการเกิดแท่งเทียน Hammer มาเขียนเป็น Logic

1. fabs(ราคาเปิด - ราคาปิด) * 3 น้อยกว่า ราคาสูงสุด - ราคาต่ำสุด

2.กำหนดความยาวของไส้เทียนด้านบน Max_Upper_Wick = 10;

                - ถ้าราคาเปิดมากกว่าราคาปิด (ราคาสูงสุด - ราคาเปิด) / Point ต้องน้อยกว่าหรือเท่ากับ Max_Upper_Wick
                - ถ้าราคาเปิดน้อยกว่าราคาปิด (ราคาสูงสุด - ราคาปิด) / Point ต้องน้อยกว่าหรือเท่ากับ Max_Upper_Wick
            3.การเช็ค downtrend อาจเช็คจากแท่งเทียนสามแท่งก่อนหน้า Hammer โดยขณะที่เราเช็ครูปแบบแท่งเทียน Hammer นั้นที่แท่งปัจจุบันจะเป็นแท่งที่ 0 แท่งที่เกิด Hammer จะเป็นแท่งที่ 1 ส่วนแท่งถัดไปที่เราจะเช็ค downtrend จะเป็นแท่งที่ 2,3 และ 4 จะได้เงื่อนไขการเช็ค downtrend คือ
                ราคาเปิดแท่งที่2 < ราคาปิดแท่งที่2 และ ราคาเปิดแท่งที่3 < ราคาปิดแท่งที่3 และราคาเปิดแท่งที่4 < ราคาปิดแท่งที่4

การเขียนโค๊ด เพื่อตรวจสอบแท่งเทียน Hammer
1. การตรวจสอบการเกิดแท่งเทียน Hammer จะทำเมื่อเปิดแท่งเทียนแท่งใหม่ คือตรวจสอบแท่งเทียนก่อนหน้า ซึ่งคือตำแหน่งแท่งที่ 1 เพราะแท่งปัจจุบันคือแท่งที่ 0

if(!(fabs(iOpen(Symbol(),TimeFrame,1)-iClose(Symbol(),TimeFrame,1))* 3 < iHigh(Symbol(),TimeFrame,1)-iLow(Symbol(),TimeFrame,1))) { return; }

2. ไส้แท่งเทียนบนต้องไม่เกินที่กำหนด

if((iOpen(Symbol(),TimeFrame,1) > iClose(Symbol(),TimeFrame,1)) if(!((iHigh(Symbol(),TimeFrame,1)-iOpen(Symbol(),TimeFrame,1)) / Point <= Max_Upper_Wick)) { return; } }else if((iOpen(Symbol(),TimeFrame,1) < iClose(Symbol(),TimeFrame,1)) if(!((iHigh(Symbol(),TimeFrame,1)-iClose(Symbol(),TimeFrame,1)) / Point <= Max_Upper_Wick)) { return; } }

3. ตรวจสอบ downtrend

if(!(iOpen(Symbol(),TimeFrame,2) > iClose(Symbol(),TimeFrame,2) && iOpen(Symbol(),TimeFrame,3) > iClose(Symbol(),TimeFrame,3) && iOpen(Symbol(),TimeFrame,4) > iClose(Symbol(),TimeFrame,4))) { return; }

***หากอ่านแล้วรู้สึกว่าบทความเป็นประโยชน์ รบกวนแชร์ให้ด้วยนะครับ เพื่อเป็นกำลังใจในการเขียนบทความต่อไป

Magic Number คืออะไร

2015-08-10T23:19:00.000+07:00

Magic Number คือ

ตัวเลขที่เรากำหนดขึ้นมา จะเป็นเลขอะไรก็ได้เช่น 1111 หรือ 2222 เพื่อใช้เป็นตัวกำหนดค่าของ EA เวลาที่เราใช้คำสั่งในการเปิดออร์เดอร์ เพื่อให้รู้ว่าออร์ที่เปิดนั้นเปิดมาจากคู่เงินไหนหรือไทม์เฟรมไหน ทำให้ง่ายเวลาในการตรวจเช็คเพื่อปิดออร์เดอร์

การเขียน EA ต้องมี Magic Number ไหม

จริงๆแล้วควรมีฟังก์ชั่น Magic Number เพราะในการเทรดเรามีโอกาสที่จะเทรดหลายคู่เงิน หรือหลายไทม์เฟรม ยิ่งคนมีเทคนิคเยอะก็อยากจะเทรดหลายคู่เงินพร้อมกัน ถ้าหากไม่มีฟังก์ชั่นกำหนด Magic Number คงยุ่งน่าดูในการตรวจเช็คเงื่อนไขการปิดออร์เดอร์ แต่สำหรับมือใหม่หัดเขียนอีเออาจจะไม่ต้องกำหนด Magic Number ก็ได้เพื่อลดขั้นตอนการเขียน ซึ่งจะค่อยเพิ่มทีหลังเอาก็ได้

วิธีการกำหนดค่า Magic Number

เราสามารถกำหนดได้จากการใส่ตัวเลขทุกครั้งที่เราเพิ่มอีเอลงในชาร์ท โดยการเขียนโค๊ดตามตัวอย่าง

extern int MagicNumber = 1234;

แต่ถ้าไม่ต้องการกำหนดตัวเลขเองทุกครั้งที่มีการเพิ่มอีเอลงไปในชาร์ทใหม่ ก็ใช้วิธีการเขียนฟังก์ให้อีเอสร้างค่า Magic Number ให้อัตโนมัติก็ถือสะดวกดี ตัวอย่างโค๊ดการใช้งาน Magic Number แบบอัตโนมัติ

extern int MagicNumber = 1234; int OnInit() { MagicNumber = subGenerateMagicNumber(MagicNumber, Symbol(), TimeFrame); return(INIT_SUCCEEDED); } int start() { OrderSend(Symbol(),OP_BUY,Lots,Ask,Slippage, StopLoss, // Stop loss price. TP, // Take profit price. TicketComment,MagicNumber,0,Green); } int subGenerateMagicNumber(int MagicNumber, string symbol, int timeFrame) { int isymbol = 0; if (symbol == "EURUSD") isymbol = 1; else if (symbol == "GBPUSD") isymbol = 2; else if (symbol == "USDJPY") isymbol = 3; else if (symbol == "USDCHF") isymbol = 4; else if (symbol == "AUDUSD") isymbol = 5; else if (symbol == "USDCAD") isymbol = 6; else if (symbol == "EURGBP") isymbol = 7; else if (symbol == "EURJPY") isymbol = 8; else if (symbol == "EURCHF") isymbol = 9; else if (symbol == "EURAUD") isymbol = 10; else if (symbol == "EURCAD") isymbol = 11; else if (symbol == "GBPUSD") isymbol = 12; else if (symbol == "GBPJPY") isymbol = 13; else if (symbol == "GBPCHF") isymbol = 14; else if (symbol == "GBPAUD") isymbol = 15; else if (symbol == "GBPCAD") isymbol = 16; else isymbol = 17; if(isymbol<10 data-blogger-escaped-10="" data-blogger-escaped-agicnumber="" data-blogger-escaped-div="" data-blogger-escaped-isymbol="" data-blogger-escaped-magicnumber="MagicNumber" data-blogger-escaped-return="" data-blogger-escaped-timeframe="" data-blogger-escaped-tringconcatenate="" data-blogger-escaped-trtointeger="">

เวลาเปิดปิดของตลาดการเทรด forex

2013-07-25T01:02:00.002+07:00

         เสน่ห์อย่างหนึ่งของการเทรด Forex ก็คือ เราสามารถเทรดได้ตลอด 24 ชั่วโมงใน 5 วันทำการ คือตั้งแต่ 04:00 ของเช้าวันจันทร์ ถึง 04:00 ของเช้าวันเสาร์ ซึ่งแน่นอนว่ามันเป็นช่วงเวลาที่ยาวนานของสัปดาห์ที่เราๆท่านๆจะสามารถทำเงินได้อย่างจุใจกันเลยทีเดียว

         สำหรับหลายท่านที่เป็นนักเทรดตามข่าว ก็คงหนีไม่พ้นการติดตามช่วงเวลาที่เกิดข่าว และช่วงเวลาที่ตลาดทั้งหลายเปิดทำการ ซึ่งจะเป็นเวลาของการลุ้นระทึกว่าราคาจะวิ่งไปในทิศทางเดียวกันกับที่เราเทรดไว้รึปล่าว
   การรู้เวลาเปิดปิดทำการของตลาดต่างๆ นั้นช่วยให้เราสามารถเขียน EA เพื่อตรวจสอบเงื่อนไขสำหรับท่านที่ต้องการให้ EA ทำงานในช่วงเวลาที่ตลาดใดๆที่จะทำการเทรดยังเปิดทำการ และโอกาสต่อไปคงจะได้อัพเดตโค๊ตตัวอย่างสำหรับการตรวจเช็คเวลาเพื่อให้ EA ทำงานตามช่วงเวลาที่เราตั้งเงื่อนไขไว้
        ขอบคุณสำหรับการติดตาม

What is Forex Trading?

2013-06-04T11:28:00.000+07:00

Forex Tradding ก็คือการซื้อขายแลกเปลี่ยนสกุลเงินจากประเทศที่ต่างกัน โดย Forex เป็นชื่อย่อของการแลกเปลี่ยนเงินตราต่างประเทศ ตัวอย่างเช่น ในยุโรปมีการใช้สกุลเงินสกุลยูโร (EUR) และในประเทศสหรัฐอเมริกามีการใช้สกุลเงินดอลลาร์หสรัฐ (USD) ตัวอย่างของการซื้อขายอัตราแลกเปลี่ยนคือการการซื้อเงินยูโรและขณะเดียวกันจะทำการเขียนเงินดอลลาร์สหรัฐ เพื่อให้ง่ายต่อการเข้าใจและสะดวกในการเรียกจะใช่สัญลักษณ์คือ EUR / USD

ในการลงทุน Forex นั้นมีคู่เงินที่ให้เราซื้อขายหลายคู่เงินเช่น

ยูโร กับ ดอลลาร์สหรัฐ – EUR/ USD

ดอลลาร์สหรัฐ กับ ฟรังก์สวิส – USD / CHF

ปอนด์อังกฤษ กับ ดอลลาร์สหรัฐ – GBP /USD

ดอลลาร์สหรัฐ กับ เยน – USD / JPY

ยูโร กับ ปอนด์อังกฤษ – EUR / GBP

ยูโร กับ ฟรังก์สวิส – EUR / CHF

ยูโร กับ เยน - EUR /JPY

ดอลลาร์สหรัฐ / ดอลลาร์แคนาดา – USD / CAD

นอกจากนี้ยังมีคู่เงินอื่นๆอีกหลายคู่เงิน แต่คู่เงินหลักๆที่นิยมสำหรับนักเทรด Forex คือ EUR /USD, USD / JPY, GBP /USD USD /CHF ซึ่งคู่เงินเหล่านนี้ถือได้ว่าเป็นคู่เงินที่มีความาสำคัญในตลาด Forex

หรับผู้ที่เริ่มต้นศึกษาการเทรด Forex อาจจะมีคำถามว่ามีคู่เงินมากมายในตลาด Forex แล้วเราจะเลือกเทรดคู่เงินไหนดี คำตอบก็คือ EUR / USD เพราะคู่เงินนี้มีค่า Spread ที่ต่ำกว่าคู่เงินอื่นๆ แต่จะเท่าไหร่ไหนก็คงต้องไปดูที่โปรกเกอร์แต่ล่ะเจ้าว่าเจ้าไหนต่ำกว่ากัน

การเขียน EA เพื่อแสดงข้อความบน Chart

2012-09-14T22:32:00.000+07:00

ในการเขียน EA บางครั้งเราจำเป็นต้องแสดงผลของค่าบางค่าที่เราต้องการบน Chart เพื่อให้ง่ายต่อการตรวจสอบผลการทำงานของ EA ว่าทำงานได้ถูกต้องตามเงื่อนไขที่เราตั้งไว้หรือไม่
จากตัวอย่างด้านล่างเป็นการแสดงผลขอกำไร/ขาดทุนของ Order ที่เราเปิดอยู่ ซึ่งจะแสดงหมายเลข Ticket และ Profit ที่เกิดขึ้น

ตัวอย่างการเขียนโค๊ด

int getLastOrderProfit() {
   string name = "strProfit";
   string strDispaly; 
   for(int i=0;i<OrdersTotal();i++){
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true){
         if(OrderSymbol()==Symbol()){
            strDispaly = "Order Ticket "+ OrderTicket()+" Profit: " + DoubleToStr(OrderProfit(),0);
            ObjectCreate(name,OBJ_LABEL,0,0,0);
            ObjectSet(name,OBJPROP_XDISTANCE,5);
            ObjectSet(name,OBJPROP_YDISTANCE,80);
            ObjectSetText(name,strDispaly,14,"Arial",DodgerBlue);
            return(OrderProfit());
         } 
      }    
   }         

}

int start() {
    if(OrdersTotal()>0) {
        getLastOrderProfit();
    }
}

สอนวิธีการเขียน EA เพื่อทำการปิด Order

2012-09-05T13:03:00.000+07:00

ในการเขียน EA เพื่อช่วยในการเทรด Forex แบบอัตโนมัตินั้น การส่งคำสั่งเพื่อปิด Order นั้นถือเป็นส่วนหนึ่งที่มีความสำคัญอีกส่วนหนึ่ง เราต้องทำความเข้าใจถึงแนวคิดและขั้นตอนในการทำงานของการปิด Order เพื่อลดความผิดพลาดที่จะเกิดขึ้น

ทุกครั้งที่มีการเปลี่ยนแปลงราคา Server จะส่งสัญญาณกลับมายัง Client ฟังก์ชั่น start จะทำงาน

int start () {

/* สมมติว่าเราได้วิเคราะห์สัญญาณแล้วปรากฏว่าถึงจุดที่เราจะต้องทำการปิด Order */
/* ทำการเรียกฟังก์ชั่นเพื่อปิด Order จากตัวอย่างจะทำการปิด Order ซึ่งมีการเปิดแบบ BUY */

if(closeOrder(OP_BUY)) {
/* ปิด Order สำเร็จ Order */
} else {
/* ปิด Order ไม่สำเร็จสำเร็จ Order */
}

return(0);
}

เราเขียนฟังก์ชั่นการปิด Order แยกออกมาจากส่วนของฟังก์ชั่น start เพื่อให้ง่ายต่อการแก้ไขแล้วตรวจสอบหากมีการทำงานผิดพลาดเกิดขึ้น จากฟังก์ชั่น closeOrder จะเห็นว่า Input ที่จะป้อนให้แก่ฟังก์ชั่นนี้คือ ลักษณะของฟังก์ชั่นที่เปิดเป็น BUY หรือ SELL ถ้าต้องการปิด Order ที่เปิดเป็น BUY ก็ส่งค่า OP_BUY และถ้าต้องการปิด Order ที่เปิดแบบ SELL ก็ส่ง OP_SELL มาให้ฟังก์ชั่น closeOrder หลังจากที่ประมวลผลเสร็จแล้ว ฟังก์ชั่น closeOrder จะส่งค่าคืนให้กับฟังก์ชั่นที่มีการเรียก closeOrder ซึ่งก็คือฟังก์ชั่น start โดยข้อมูลที่ส่งกลับเป็นชนิดบูลีน ซึ่งถ้าปิด Order สำเร็จจะส่ง true กลับ แต่หากปิด Order ไม่สำเร็จจะส่งค่า false กับ ดังนั้นที่ฟังก์ชั่น start ต้องทำการตรวจสอบค่าผลการทำงานของการปิด Order ว่าสำเร็จหรือไม่

จากตัวอย่างฟังก์ชั่น closeOrder นี้ เป็นการปิด Order แรก Order เดียว

bool closeOrder(int cmd) {
int count_close = 0;
double sp,price;
bool result;
int error;
string XSymbol;
int order_totals;
int i,count;

/* วนลูปเพื่อตรวจสอบ Order */
for(i=0;i<OrdersTotal();i++) {

/* เลือกตรวจสอบเฉพาะ Order ที่กำลังเปิดอยู่ */
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)) {

/* เลือกตรวจสอบเฉพาะคู่เงินที่ตรงกับคู่ที่ EA รันอยู่ */
if(OrderSymbol()==Symbol()) {

/* ตรวจอบว่า Order เปิดแบบตรงกับที่ต้องการปิดรึปล่าว */
if(cmd==OrderType()) {

count = 0;
result=false;

/* วนลูปจนกว่าจะปิด Order ได้ แต่ไม่เกิน 5 ครั้ง */
while ((result == false) && (count < 5)) {

/* เก็บค่าของ Order ที่กำลังตรวจสอบ*/
XSymbol = OrderSymbol();

/* ถ้า Order เปิดแบบ BUY จะอ่านค่าราคา Bid ที่จะปิด */
if(cmd==OP_BUY) price=MarketInfo(XSymbol,MODE_BID);

/* ถ้า Order เปิดแบบ SELL จะอ่านค่าราคา ASK ที่จะปิด */
if(cmd==OP_SELL) price=MarketInfo(XSymbol,MODE_ASK);

sp = GetSlippage(XSymbol);

/* ส่งคำสั่งเพื่อปิด Order */
result=OrderClose(OrderTicket(),OrderLots(),price,sp,CLR_NONE);

/* ถ้าไม่สามารถปิด Order ได้ */
if(!result) {
error=GetLastError();
Print("LastError = ",error," price=",price," Slippage=",sp);
if(error==129 || error==135 || error==146 || error==138) { RefreshRates(); }
/* สามารถปิด Order ได้ */
} else {
/* ส่งค่า true กลับไป */
return (true);
}
count++;
}
/* ไม่สามารถปิด Order ได้ ส่งค่า false กลับ */
return (false);
}
}
}
}
}

ฟังก์ชั่น GetSlippage ใช้คำนวนหาค่าความต่างของราคา ask กับ bid ว่าต่างกันกี่จุด

double GetSlippage(string XSymbol) {

/* อ่านค่า ราคา Bid */
double bid = MarketInfo(XSymbol,MODE_BID);

/* อ่านค่าราคา Ask */
double ask = MarketInfo(XSymbol,MODE_ASK);

/* อ่านค่า point */
double point = MarketInfo(XSymbol,MODE_POINT);

return((ask-bid)/point);
}

มาถึงตอนนี้ก็จะได้ฟังก์ชั่นเปิดและปิด Order แล้ว ที่เหลือก็จะเป็นการใส่เทคนิคในการตรวจสอบสัญญาณซื้อขาย ซึ่งขึ้นอยู่กับแต่ละคนว่าจะใช้เครื่องมือไหน ขอบคุณสำหรับการติดตามครับ

ตัวอย่างการเขียน EA เพื่อเปิด Order โดยครอบคลุมทั้ง BUY และ SELL

2012-09-02T01:54:00.001+07:00

การเขียนโปรแกรมที่ดีควรเขียนแยกการทำงานออกเป็นส่วนๆหรือที่เรียกว่าฟังก์ชั่น เพื่อให้ง่ายต่อการวิเคราะห์ในการหาข้อผิดพลาดจากการทำงานของโปรแกรม การเขียน EA ก็เหมือนกัน ถ้าเราเขียนโดยแยกออกเป็นฟังก์ชั่นก็จะทำให้ง่ายต่อการแก้ไขปรับปรุง ในกรณีที่เราต้องการปรับเปลี่ยนเทคนิคในการเทรด
มาดูฟังก์ชั่นในการเปิด Order ซึ่งเป็นฟังก์ชั่นหลักฟังก์ชั่นหนี่งของ EA ก็ว่าได้ เพราะถ้าฟังก์ชั่นนี้ทำงานผิดพลาดนั่นหมายถึงหายนะกำลังมาเยือน เพราะฉะนั้นต้องมั่นใจว่าฟังก์ชั่นนี้จะไม่ทำงานผิดพลาด ไม่ว่าสถานการณ์ของตลาดจะผันผวนก็ตาม

/* ฟังก์ชั่นนี้จะทำงานเมื่อมีสัญญาณมาจากฝั่ง Server */
int start(){

/* เมื่อเราตรวจสอบราคาด้วยอินดิเคเตอร์ใดๆแล้ว แล้วถึงจุดที่ต้องการเปิด Order */
/* ยกตัวอย่าง ถ้าต้องการเปิด ORDER BUY และ Lotsize เท่ากับ 1
openOrder(OP_BUY,1);

/* ยกตัวอย่าง ถ้าต้องการเปิด ORDER SELL และ Lotsize เท่ากับ 1
openOrder(OP_SELL,1);

return(0);
}

/* ฟังก์ชั่นสำหรับเปิด Order
bool openOrder(int cmd,double lot,double tp=0.0) {
int ticket,count;
int error;
double price;
count = 0;
ticket = -1;

/* วนลูปเพื่อส่งคำสั่งซื้อจนกว่าจะเปิด Order ได้ แต่ไม่เกิน 5 ครั้ง */
while((ticket<0) && (count < 5)){ /* ถ้าเป็นคำสั่ง BUY ให้ซื้อที่ Ask */ if(cmd==OP_BUY) price=Ask; /* ถ้าเป็นคำสั่ง SELL ให้ซื้อที่ Bid */ else price=Bid; /* ถ้าเป็นคำสั่ง BUY */ if(cmd==OP_BUY){ ticket=OrderSend(Symbol(),OP_BUY,lot,price,3,0.0,tp,NULL,255,0,CLR_NONE); /* ตรวจสอบว่าเปิด Order สำเร็จรึปล่าว */ if(ticket<0){ error = GetLastError(); Print("Error:Send Buy Order LastError = ",error," price=",price); /* ถ้า error code เกี่ยวกับราคาที่เปลี่ยนไปจากราคาที่ต้องการให้อ่านค่าใหม่ */ if(error==129 || error==135 || error==146 || error==138){ RefreshRates(); } }else{ /* ได้รับค่า ticket แสดงว่าเปิด Order สำเร็จ */ return (true); } /* ถ้าเป็นคำสั่ง SELL */ }else { ticket=OrderSend(Symbol(),OP_SELL,lot,price,3,0.0,tp,NULL,255,0,CLR_NONE); if(ticket<0 ){ error = GetLastError(); Print("Error:Send Sell Order LastError = ",error," price=",price); if(error==129 || error==135 || error==146 || error==138){ RefreshRates(); } }else { /* เปิด Order สำเร็จ */ return (true); } } /* เปิด Order ไม่สำเร็จกับไปเปิดใหม่ */ count++; } /* ไม่สามารถเปิด Order ได้ */ return (false); }

พยายามคิดการทำงานออกมาให้เป็นส่วนๆ แต่ละส่วนทำงานแยกขาดออกจากกัน จะทำให้เราได้ฟังก์ชั่นที่สามารถนำเอาไปใช้ทำงานร่วมกับ EA ตัวอื่นได้ ขอให้สนุกับการเขียน EA ครับ

สิ่งสำคัญที่ไม่ควรมองข้ามในการเขียน EA

2012-08-29T18:29:00.000+07:00

             สิ่งที่เราคาดหวังจาก Expert Advisor (EA) นั้น นอกจากการความาสามารถในการกำไรให้เราแล้วนั้น สิ่งหนึ่งที่เราต้องการก็คือ การทำงานที่ถูกต้องโดยไม่เกิดข้อผิดพลาด ซึ่งหลังจากที่เราเขียน EA เสร็จแล้วเราจะต้องทำการทดสอบด้วย Strategy Tester เพื่อให้แน่ใจว่าการทำงานของ EA นั้นสามารถทำงานได้ตรงตามที่เราคาดหวังไว้ ซึ่งการทดสอบ EA วิธีการนี้เป็นเพียงการทดสอบขั้นต้นเท่านั้น เพราะในสภาวะของการใช้งานจริงจะมีปัญจัยที่จะสารมารถที่ทำให้เกิดความผิดพลาดหรือการการงานผิดเพี้ยนจากหลักการที่กำหนดให้ตัว EA คือ ในสถานะการณ์ที่มีความผันผวน เมื่อมีการส่งคำสั่งซื้อ (BUY) หรือส่งคำสั่งขาย (SELL) เราอาจจะไม่สามารถซื้อหรือขายได้ในราคาที่เราต้องการ เพราะในขณะที่เราส่งคำสั่งซื้อ/ขายไปนั้น ราคาได้มีการเปลี่ยน ยกตัวอย่างการส่งคำสั่งซื้อ


         ticket=OrderSend(Symbol(),OP_BUY,lot,price,3,0.0,tp,NULL,255,0,CLR_NONE);

จะเห็นว่าตรงตำแหน่งของเลข 3 คือ จำนวนจุดที่ยอมรับได้เมื่อราคาเปลี่ยนไป เช่น ต้องการซื้อที่ราคา 1.5000 แต่เมื่อส่งคำสั่งไปราคาเปลี่ยนไปเป็น 1.5002 อย่างนี้ฝั่งโปรกเกอร์จะประมวลผลให้ แต่ถ้าราคากระโดดไปเป็น 1.5010 ซึ่งสามารถเกิดขึ้นได้ในช่วงที่มีข่าว อย่างนี้เราจะไม่สามารถซื้อได้ในราคาที่ EA เราคำนวณจุดซื้อไว้ได้ ซึ่งถือจะว่า EA ทำงานผิดพลาด และถ้าแย่ไปกว่านั้น ถ้าเราเขียน EA ให้ส่งคำสั่งซื้อไปจนกว่าจะสามารถซื้อได้ นี่แหละที่จะทำให้มีโอกาสล้างพอร์ตได้ เพราะฉะนั้นการจะเขียนอีเอต้องสนใจในทุกรายละเอียด ต้องทดสอบด้วย Strategy Tester เพื่อดูการทำงานว่ามีส่วนไหนทำงานผิดพลาดรึปล่าว เมื่อแน่ใจว่าทำงานตรงตามที่ต้องการแล้ว ให้ทำการรัน EA ด้วยบัญชี Demo ประมาณ 1 เดือน เพื่อดูว่าเทคนิคที่เราใช้นั้นสามารถทำเงินได้จริงๆ และเพื่อเป็นการทดสอบการทำงาน EA ในสถานการณ์จริงด้วย ถ้าผลการทำงานเป็นที่น่าพอใจเราค่อยนำ EA ไปใช้กับบัญชีเงินจริง

        สำหรับท่านที่ต้องการเรียนรู้เกี่ยวกับการเขีนยโค๊ด รบกวนรอหน่อยนะครับ จะพยายามอัพเดตให้เร็วที่สุด ขอบคุณสำหรับการติดตามครับ

เตือนสำหรับนักเทรด Forex ทั้งมือใหม่และมือเก่า

2012-08-22T21:21:00.002+07:00

อันตราย!!

             การเทรด Forex ก็เหมือนกับการเล่นหุ้นซึ่งจะมีปัจจัยต่างๆเข้ามาทำให้ค่าเงินเกิดการผันผวน ดังนั้นต้องคอยติดตามข่าวเศรษฐกิจของทั่วโลกอย่างใกล้ชิดนะครับ ไม่อย่างนั้นอาจทำให้ท่านทั้งหลายล้างพอร์ตได้
             สำหรับนักเทรดท่านใดที่ใช้อีเอในการช่วยเทรด ของเตือนนิดหนึ่งนะครับว่า อีเอจะทำงานได้ดีในสถานนะการปรกติเท่านั้น เพราะหลักการในการเขียนอีเอมันมาจากสถิติย้อนหลัง การทำสอบกับข้อมูลย้อนหลังโดยเราไม่สามารถรู้ได้เลยว่าอนาคตจะเกิดเหตุการณ์ อะไรขึ้น เพราะฉะนั้นต้องคอยติดตามข่าวควบคู่กันไปด้วยจึงจะให้เราสามารถแก้ไข สถานการณ์ได้ทันท่วงที
              ผมไม่ได้บอกว่าการเทรดด้วยอีเอไม่ดีนะครับ ผมว่ามันดีมากๆหากอีเอนั้นมาจากเทคนิคของคนที่เทรดเก่ง และจะต้องเขียนด้วยคนที่เขียนโปรแกรมเก่งด้วย ซึ่งผมเชื่อว่าต้องมีคนอยากได้อีเอแบบนี้แน่ๆ และสุดท้ายคือ ผู้ใช้อีเอต้องรู้จักวิธีใช้ เข้าใจสถานการณ์โลกว่าอยู่ในสถานการณ์ไหน รับรองอยู่ในวงการนี้ได้อย่างสบาย
       โชคดีกับการเทรดครับ...

รู้สักนิดก่อนเขียน EA - ราคาการซื้อและขายของ BUY กับ SELL

2012-05-10T12:39:00.000+07:00

สิ่งหนึ่งที่ผู้เขียน EA หรือแม้แต่ผู้เทรด Forex ต้องทำความเข้าใจเกี่ยวกับการเปิด Order ก็คือ ต้องรู้ว่า

Order Buy ซื้อที่ราคา Ask ขายที่ราคา Bid

Order Sell ซื้อที่ราคา Bid ขายที่ราคา Ask

แล้วอย่างไง ??

สมมติว่าเรามี Order Buy อยู่ในมือและราคาปัจุบันอยู่ที่ 1.6100 และเราคิดว่าเราจะเขียน EA เพื่อ Modify Order นี้เพื่อตั้ง TP (Target Profit) ให้ Order นี้ปิดที่ราคา 1.6150 ซึ่ง Order นี้เป็น Order Buy ราคา 1.6150 จึงเป็นราคา Ask แต่เราต้องปิดที่ราคา Bid เพราะฉะนั้น ราคาที่จะทำให้ Order นี้ปิดก็คือ 1.6150 + Spread (ค่า Spread คือค่าความต่างระหว่างราคา Ask กับ ราคา Bid ซึ่งค่า Spread นี้จะมีความต่างไม่เท่ากันขึ้นอยู่กับคูเงินที่เราเทรด และขึ้นอยู่กับโปรกเกอร์หรือลักษณะของบัญชีที่เราเปิด แต่ในการเขียน EA เพื่อคำนวณหาค่านี้จะเขียนเหมือนกันคือ Ask -Bid


          double TP;
bool result;
          TP = 1.6150 + (Ask-Bid);
          result=OrderModify(OrderTicket(),OrderOpenPrice(),0,TP.0,0,CLR_NONE);

ตัวฟังก์ชั่นเต็มผมจะยังไม่พูดถึงนะครับ บทความนี้ต้องการให้เข้าใจเรื่องของราคาตรงนี้ก่อน

จากตัวอย่างด้านบน สมมติว่าเป็นราคาของคู่เงิน GBP/USD และ Ask - Bid = 0.0003

TP = 1.6150 + 0.0003;
TP = 1.6153; นี่ืคือราคาที่ปิด Order แต่ราคาตลาดจะเป็น 1.6156 งงปล่าวเนี่ย
เอาเป็นว่า ถ้าเป็น Order Buy จะปิดที่ ราคาที่เราอยากให้ปิด + (Ask - Bid)

ส่วน Order Sell ก็เป็นส่วนกลับของ ซึ่งจะเปิดที่ ราคาที่เราอยากให้ปิด - (Ask - Bid)

ไม่มีอะไรยาก แค่เรายังไม่รู้ ของให้สนุกกับการเรียนรู้แล้วเราก็จะรู้เอง
ขอบคุณสำหรับการติดตาม

เขียน EA ตรวจสอบ Candlestick Pattern

2011-05-22T19:59:00.001+07:00

The Bearish Engulfing pattern

รูปแบบของ Bearish Engulfing คือ รุปแบบที่เป็นสัญญาณของการกลับตัวจากภาวะตลาดกระทิง(Up Trend) ไปสู่ภาวะตลาดหมี(Down Trend) จะเกิดแท่งเทียนทึบ(หมายเลข1)ครอบ แท่งเทียนโปร่ง(หมายเลข2) โดยที่ราคาเปิดและราคาปิดของแท่งเทียนโปร่งจะต้องอยู่ระหว่างราคาเปิดและราคาปิดของแท่งเทียนทึบ ดูภาพประกอบเพื่อความเข้าใจ
ก่อนที่เราจะทำการเขียน EA เพื่อตรวจสอบว่า รูปแบบของกราฟแท่งเทียนที่เกิดขึ้นนั้น ใช่รูปแบบของ Bearish Engulfing Pattern รึปล่าวนั้น เราต้องทำการกำหนดเงื่อนไขของรูปแบบนี้ก่อนด้วยภาษาพูดและค่อยแปลงให้เป็นภาษา MQL

เงื่อนไขของ Bearish Engulfing Pattern

เราจะทำการตรวจสอบเมื่อเกิดแท่งเทียนแท่งใหม่ ใช้รูปประกอบ คือเมื่อเกิดแท่งเทียนหมายเลข 0
ราคาเปิดของแท่งเทียนหมายเลข1 ต้องมากกว่าราคาปิดของแท่งเทียนหมายเลข1 ใช้เพื่อตรวจสอบว่าเป็นแท่งเทียนทึบ
ราคาเปิดของแท่งเที่ยนหมายเลข2 ต้องน้อยกว่าราคาปิดของแท่งเทียนหมายเลข2 ใช้ตรวจสอบว่าเป็นแท่งเทียนโปร่ง
ราคาเปิดของแท่งเทียนหมายเลข2 ต้องมากกว่าราคาปิดของแท่งเทียนหมายเลข1 และ ราคาปิดของแท่งเทียนหมายเลข2 ต้องน้อยกว่าราคาเปิดของแท่งเทียนหมายเลข1 ใช้เพื่อตรวจสอบว่าเป็น Bearish Engulfing Pattern
ราคาเปิดของแท่งเทียนหมายเลข3 ต้องน้อยกว่าราคาปิดของแท่งเทียนหมายเลข3 ใช้ตรวจสอบว่าเป็นแท่งเทียนโปร่ง
ส่วนต่างของราคาปิดกับราคาเปิดของแท่งเทียนหมายเลข3 ต้องมากกว่า ส่วนต่างของราคาปิดกับราคาเปิดของแท่งเทียนหมายเลข2 ใช้เพื่อเป็นการยืนยันว่าเป็น Up Trend
ทุกเงื่อนไขเป็นจริงก็ให้ทำการเปิด Order Sell

หลังจากได้สัญญาณจากกราฟแล้ว ถ้าใครต้องการจะรอสัญญาณจาก Indicator ตัวอื่นเป็นตัวยืนยันก็สามารถทำได้ครับ แล้วแต่เทคนิคของแต่ละคน

ลงมือเขียน Code

/* กำหนด Timeframe = 5 นาที */ int TF = PERIOD_M5; /* กำหนดตัวแปรเพื่อใช้เก็บค่าของจำนวน Bar ใน Chart */ int pbl_Bars=0; int start() { /* ในครั้งแรกที่เริ่มรัน EA เราจะยังไม่ทำการตรวจสอบ Candlestick Parttern */ if(pbl_Bars==0) { //เก็บค่าจำนวนของ Bar ที่มีใน Chart pbl_Bars = Bars; //กำหนด Bar ที่จะทำการตรวจสอบ pbl_Bars++; //ออกจากฟังก์ชั้น return (0); } /* 1. เราจะทำการตรวจสอบเมื่อเกิดแท่งเทียนแท่งใหม่ */ if(pbl_Bars==Bars) { /* แยกเป็นฟังก์ชั่นย่อย ถ้าตรวจสอบแล้วว่าเป็น Bearish Engulfing Pattern จะคืนค่ากลับมาเป็น true */ if(isBearish_Engulfing()) { /* 7.ทุกเงื่อนไขเป็นจริงก็ให้ทำการเปิด Order Sell */ /* OpenOrder เป็นฟังก์ชันย่อย ใช้ในการเปิด Order */ OpenOrder(OP_SELL); } /* เมื่อเข้ามาตรวจสอบแล้ว ถ้ายังไม่เปลี่ยนเป็นแท่งใหม่ก็จะไม่เข้ามาอีก */ pbl_Bars--; } return (0); } bool isBearish_Engulfing() { /* 2.ราคาเปิดของแท่งเทียนหมายเลข1 ต้องมากกว่าราคาปิดของแท่งเทียนหมายเลข1 */ if(!(iOpen(Symbol(),TF,1) > iClose(Symbol(),TF,1))) { /* ถ้าไม่ต้องตามเงื่อนไขทีี่ 2 ก็ออกจากฟังก์ชัน */ return (false); } /* 3.ราคาเปิดของแท่งเที่ยนหมายเลข2 ต้องน้อยกว่าราคาปิดของแท่งเทียนหมายเลข2 */ if(!(iOpen(Symbol(),TF,2) < iClose(Symbol(),TF,2))) { /* ถ้าไม่ต้องตามเงื่อนไขทีี่ 3 ก็ออกจากฟังก์ชัน */ return (false); } /* 4.ราคาเปิดของแท่งเทียนหมายเลข2 ต้องมากกว่าราคาปิดของแท่งเทียนหมายเลข1 และ ราคาปิดของแท่งเทียนหมายเลข2 ต้องน้อยกว่าราคาเปิดของแท่งเทียนหมายเลข1 */ if(!((iOpen(Symbol(),TF,2) > iClose(Symbol(),TF,1)) && (iClose(Symbol(),TF,2) < iOpen(Symbol(),TF,1)))) { /* ถ้าไม่ต้องตามเงื่อนไขทีี่ 4 ก็ออกจากฟังก์ชัน */ return (false); } /* 5.ราคาเปิดของแท่งเทียนหมายเลข3 ต้องน้อยกว่าราคาปิดของแท่งเทียนหมายเลข3 */ if(!((iOpen(Symbol(),TF,3) < iClose(Symbol(),TF,3))) { /* ถ้าไม่ต้องตามเงื่อนไขทีี่ 5 ก็ออกจากฟังก์ชัน */ return (false); } /* 6.ส่วนต่างของราคาปิดกับราคาเปิดของแท่งเทียนหมายเลข3 ต้องมากกว่า ส่วนต่างของราคาปิดกับราคาเปิดของแท่งเทียนหมายเลข2 */ if(! ((iClose(Symbol(),TF,3) - iOpen(Symbol(),TF,3)) > (iClose(Symbol(),TF,2) - iOpen(Symbol(),TF,2)))) { /* ถ้าไม่ต้องตามเงื่อนไขทีี่ 6 ก็ออกจากฟังก์ชัน */ return (false); } /* เข้าเงื่อนไขของ Bearish Engulfing Pattern */ return (true); } bool OpenOrder(int cmd) { /* คำสั่งในการเปิด Order จะมาอัพเดตทีหลังครับ }

Candlestick Pattern ยังมีอีกหลายรูปแบบ แล้วผมจะมาเขียนต่อในคราวหน้าครับ อย่างงัยก็คอยติดตามด้วยนะครับ ถ้าว่างเมื่อไหร่จะมาเขียนให้ผู้ที่สนใจเรียนรู้การเรียน EA ได้ใช้เป็นแนวทางในการเขียนต่อไปครับ...

เริ่มต้นเขียน EA จะซื้อ-ขายต้องเขียนอย่างไร

2011-05-14T06:41:00.000+07:00

สำหรับมือใหม่อาจจะมองภาพของการทำงานของ Expert Advisor (EA) ไม่ออกว่ามันเริ่มต้นการทำงานของโค๊ดที่เราเขียนอย่างไร ผมขออธิบายคร่าว ๆ ก่อน เพื่อใช้เป็นพื้นฐานก่อนที่เราจะเริ่มเขียนคำสั่งซื้อ (Buy) และ ขาย (Sell)
ถ้าเราสร้างไฟล์ EA ขึ้นมาใหม่เราจะเห็นว่ามีฟังก์ที่สร้างมาให้อัตโนมัติ มาดูกันนะครับว่ามีอะไรบ้างแล้วแต่ละส่วนมีไว้ทำอะไร

/* ส่วนนี้เป็นการประกาศฟังก์ชัน ชื่อฟังก์ชันคือ init */
/* int (integer - เลขจำนวนเต็ม) หน้าชื่อฟังก์ชั่น คือชนิดของค่าที่ส่งกลับคืน หลังจากทำงานในฟังก์ชันนี้แล้ว */
int init () {

/* ฟังก์ชันนี้เป็นฟังก์ชั่นหลักของ EA ซึ่งจะทำงานเมื่อเริ่มต้น EA ครั้งแรก */
/* ถ้าเรามีตัวแปรไหนที่ต้องการให้มีการกำหนดค่าก่อนที่จะเริ่มการทำงานของ EA เราก็สามารถมากำหนดในฟังก์ชันนี้ได้ */

/* ส่งค่า 0 กลับคืน */
return(0);
}

/* ฟังก์ชันนี้ชื่อ deinit คืนค่ากลับเป็น int พอมองออกรึยังครับ */
int deinit () {

/* ฟังก์ชั่นจะทำงานอัตโนมัติเหมือนฟังก์ชั่น init แต่ต่างกันตรงที่จะทำงานตอนที่เราปิด EA ครับ */
/* ซึ่งเราจะใช้ฟังก์ชันนี้เพื่อเขียนคำสั่งลบสิ่งที่เราสร้างตอนที่ EA ทำงาน */
/* ส่งค่า 0 กลับคืน */
return(0);
}

/* ตามชื่อฟังก์ชันแหละครับ เมื่อเราเริ่มรัน EA หลังจากที่ทำงานฟังก์ชัน init เสร็จแล้ว ก็จะมาทำฟังก์ชันนี้ต่อ */
int start () {

/* ความรู้ในการเทรดที่เรามี เราจะเปลี่ยนมันให้เป็นโค๊ตแล้วเขียนมันให้ทำงานอัตโนมัติที่ตรงนี้แหละครับ */
/* จะทำให้ได้กำไรหรือว่าขาดทุนนั้นนอกจากมีกลยุทธ์ที่ดีแล้วก็ต้องอาศัยการเขียนโค๊ดที่มีประสิทธิภาพด้วย ถึงจะทำให้เราบรรลุวัตถุประสงค์ที่ตั้งไว้นะครับ ถ้าความคิดดีแต่เขียนโค๊ตไม่ดีก็อาจทำให้ขาดทุนได้หรือถึงขั้นล้างพอร์ตได้ครับ */
/* แต่ว่าหลังจากที่เรา EA เสร็จ อย่างน้อยเราก็ต้องทดสอบก่อนว่ามันสามารถทำงานได้ตามที่เราเขียน แล้วค่อยนำไปใช้งานจริง */
/* มาเริ่มกันเลยดีกว่าครับ */
/* ก่อนที่เราจะส่งคำสั่งซื้อขาย หรือว่าเปิด Order เราก็ต้องการวิเคราะห์ด้วยเครื่องมือต่าง ๆ ตามความถนัดของแต่และคน อาจจะใช้ RSI MA MACD STOCHASTICหรืออื่นๆ อีกมากมาย ซึ่งเราจะมาศึกษาวิธีการเขียนโค๊ตเพื่อ นำค่าจากเครื่องมือต่างๆ เหล่านี้ มาใช้ในการกำหนดเป็นเงื่อนไขซื้อขาย หรือปิด order */
/* แต่ตอนนี้ผมอยากให้เข้าใจคำสั่งในการซื้อขายก่อนครับ ซึงหลังจาก วิเคราะห์สัญญาณแล้ววก็ทำการเปิด Order ด้วยคำสั่งOrderSend */
int ticket = OrderSend(Symbol(),OP_BUY,1.0,Ask,3,0,0,"EA Comment",255,0,CLR_NONE);

/* การส่งคำสั่งด้วยฟังก์ชั่นก์ OrderSend เมื่อฟังก์ชั้นนี้ทำงานเสร็จก็จะส่งค่ากลับมาเป็นชนิด int เราจึงประกาศตัวแปรชื่อ ticket เป็นชนิด int เพื่อรับค่าจากฟังก์ OrderSend */
/* ซึ่ง Parameter ที่ต้องส่งเข้าไปในฟังก์ชั่น OrderSend ได้แก่ */
/* Symbol() เป็นฟังก์ที่ใช้บอกชื่อคู่เงินที่เรากำลังจะเทรด */
/* OP_BUY เพื่อบอกว่าเราต้องการจะเปิด Order ซื้อ ถ้าเราจะเปิด Order ขายก็กำหนดเป็น OP_SELL */
/* 1.0 เป็นค่าของ Lot Size ที่เราจะเทรด ซึ่งค่านี้สามารถปรับเปลี่ยนตามความต้องการของผู้เทรด ซึ่งต่อไปเราจะเขียนเป็นตัวแปร แล้วสามารถรับค่าจากผู้เทรดได้ */
/* Ask ในการเปิดแบบ BUY เราต้องซื้อที่ราคา Ask ถ้าเปิดแบบ SELL ขายเราต้องซื้อที่ราคา Bid */
/* 3 หมายถึง slippage ก็คือราคาที่เรายอมให้มีเปลี่ยนแปลงได้สูงสุดกี่จุด จากราค่าขณะที่ส่งคำสั่งจนถึงเวลาที่ Server ประมวลผล */
/* 0 ตัวแรกหมายถึงจุด Stop Loss ถ้าใส่ 0 คือไม่กำหนด แต่ในการเทรดการเปิด Order ควรกำหนดจุด Stop Loss ด้วย ซึ่งวิธีการคำนวนจุด Stop Loss จะมาพูดในบทความต่อไป */
/* 0 ตัวที่สองคือค่าจุดเป้าหมายของกำไร ซึ่งเมื่อราคามาถึงจุดนี้ก็จะทำการปิด Order ให้อัตโนมัติ ถ้าใส่ 0 คือไม่ได้กำหนด ซึ่งผู้เทรดสามารถเขียนเงื่อนไขขึ้นมาเพื่อทำการส่งคำสั่งปิด Order เองได้จะกล่าวในบทความถัดไป */
/* "EA Comment" เป็นคอมเมนท์ ที่เราตั้งเพื่อความเข้าใจของเราเอง */
/* 255 เป็นตัวเลขที่ใช้ระบุหมายเลขคำสั่ง ที่เราเข้าใจเอง */
/* 0 เป็นการกำหนดระยะเวลาในการยกเลิก Order ใช้สำหรับคำสั่งที่ Pending เท่านั้น */
/* CLR_NONE เป็นการกำหนดสีของลูกศรเวลาเปิด Order ถ้าไม่ให้มีลูกศรก็หนดเป็น CLR_NONE */

/* ถ้าการส่งคำสั่งสำเร็จไม่มี Error เกิดขึ้น ตัวแปร ticket ก็จะได้รับค่าหมายเลข ticket จาก Server */

/* จบการทำงานคืนค่า 0 กลับไป หลังจากนั้นจะเข้ามาทำฟังก์ชันนี้อีกเมื่อมีการส่งข้อมูลมาจากโบรกเกอร์ของเรา */
/* ซึ่งถ้าตรงกลับช่วงที่ตลาดปิด เสาร์-อาทิตย์ หลายคนอาจสงสัยว่าเขียน EA เสร็จแล้ว ทดสอบรัน ปรากฏว่าไม่เห็นมีอะไรเกิดขึ้นเลย ไม่ต้องสงสัยแแล้วนะครับ */
return(0);
}

ก่อนจบบทความนี้ ผมอยากจะพูดถึงความรู้สึกในการทำบล็อกนี้สักเล็กน้อย คือจากการที่ผมดูสถิติการเข้ามาชมบล๊อกนี้ มันทำให้ผมรู้สึกมีกำลังใจและอยากจะทำบทความต่อๆไป คิดว่ามันน่าจะเป็นประโยชน์กันคนที่อยากหาความรู้เพิ่มเติม และก็หวังเป็นอย่างยิ่งว่าผู้ที่เข้ามาอ่านบทความเหล่านี้แล้ว จะรู้สึกพอใจและอยากติดตามบทความต่อๆไป ซึ่งหากมีผู้สนใจมันก็จะเป็นแรงผลักดันให้เกิดบทความต่อๆไปครับ ขอขอบคุณที่ร่วมติดตามครับ

EA เขียนด้วยภาษาอะไร ?

2011-04-27T10:03:00.000+07:00
MetaQuotes Language 4 (MQL4) เป็นภาษาที่ถูกสร้างขึ้นมาเพื่อใช้สำหรับเขียนโปรแกรมที่ใช้การเทรด ช่วยให้เราสร้างและจัดการการซื้อขายโดยอัตโนมัติด้วยตัวเอง ซึ่งในการเขียนเจ้า EA นี้สามารถทำการเขียนใน MT4 ที่เราใช้เทรดนั่นเอง โดยเลือกไปที่เมนู Tool->MeataQuotes Language Editor

   จากนั้นเริ่มเขียน EA ได้เลย

   เมื่อเขียนเสร็จแล้วก็ทำการ Compile โดยไปที่เมนู File->Compile ตอนนี้ EA ที่เราเขียนก็พร้อมที่จะนำไปใช้งานแล้ว

ทำอย่างไรจึงจะไม่เสียเงินจาก Forex?

2011-04-26T23:13:00.001+07:00
- เริ่มต้นกับ Mini Account และ Mini lot
   ผู้เริ่มต้นเทรด Forex จะต้องก้าวผ่านความรู้สึกที่ท้าทาย ในการเริ่มเทรดครั้งแรกไปให้ได้ แต่สิ่งสำคัญที่สุดก็คือ ไม่มีใครอยากสูญเสียเงินที่ลงทุน การผ่านพ้นประสบการณ์ครั้งแรกไปอย่างปลอดภัยหรือมีความสูญเสียน้อยที่สุดถือว่าเป็นเรื่องที่ดี การเริ่มต้นกับ mini account และ mini lot จึงน่าจะช่วยลดแรงกดดันได้

- ต้องเทรดอย่างเป็นระบบ
   ไม่เพียงแต่ต้องเป็นระบบเท่านั้น แต่สิ่งหนึ่งที่จะยับยั้งไม่ให้เกิดการตีความผิดซ้ำซ้อน ทั้งการเข้าและออก คือ หลีกเลี่ยงระบบที่เรียกว่า การหยั่งรู้โดยสัญชาติญาณ หรือการกระทำโดยสามัญสำนึก หรือใช้ตัดสินใจตามสถานการณ์
   ระบบที่ดีที่สุดมันเกิดขึ้นมาด้วยตัวของคุณเอง อาจจะต้องใช้เวลาในการสร้างหลายเดือน แต่ถ้าสมบูรณ์แบบแล้ว มันก็จะเพิ่มความเชื่อมั่นในการเทรดให้แก่คุณได้

- เรียนรู้ที่จะหยุด
   การสามารถรักษาเงินที่ลงทุนไปได้นั้นถือว่าเป็นสิ่งที่สำคัญยิ่ง หยุดเมื่อเท่าทุนถือว่าเป็นสิ่งที่ดีนั่นหมายความว่าคุณไม่ได้สูญเสียอะไร เมื่อเรียนรู้ที่หยุดได้ คุณก็จะสามารถเป็น นักลงทุน ได้

- เทรดระหว่างที่ตลาดตื่นตัว
   แม้ว่าตลาด Forex จะเปิดและสามารถาเทรดได้ตลอด 24 ชั่วโมง แต่เวลาที่ตลาดตื่นตัวมากที่สุดคือ 3 am EST ถึง 5 am EST ควรหลีกเลี่ยงการเทรดเวลาอื่น คุณอาจได้รับเงินไม่มากแต่จะมีโอกาสสูญเสียได้มากกว่า

- หลีกเลี่ยงการเทรดระหว่างเวลาข่าว
   ตรวจสอบปฏิทินข่าว และหลีกเลี่ยงชั่วโมงที่มีข่าว หลีกเลี่ยงการเทรด 20 นาทีก่อนข่าว และหลังจากข่าว 20 นาที การเทรดจากข่าวเป็นสิ่งหนึ่งที่มีความเสี่ยงอย่างมาก ให้มองว่ามีโอกาสเสียมากกว่าได้เสมอ

- ไม่เทรดมากเกินไป
   ไม่ทำการเทรดมากจนเกินไป ห้ามละเลยการเทรด หากสภาวะตลาดไม่สู่ดี ต้องหยุดเทรด

- ฝึกฝน เรียนรู้ และปรับปรุง
   ศึกษาค้นคว้าอย่างต่อเนื่อง เรียนรู้และปรับปรุงระบบการทำงานของเรา สร้างระเบียบวินัยและหลีกเลี่ยงจากความเสี่ยง ที่สำคัญที่สุดคือ ห้ามคิดว่าเป็นเวลาเลิกงาน เป้าหมายของเราอยู่สูงมาก มันจะเป็นแรงผลักดันทำให้คุณได้รับเงินจากการเทรดได้เร็วกว่าปกติ

ใช้เวลาของคุณเรียนรู้ และทดสอบ
ขอให้ทุกคนโชคดี

Forex Leverage

2011-04-26T12:18:00.000+07:00

Leverage คืออะไร

   คือ อัตราเงินที่คุณสามารถลงทุนได้ต่อ $1 ที่คุณลงทุนไปจริงๆ ตัวอย่างเช่น   ถ้าคุณลงทุน $100 แล้ว Leverage ของคุณคือ 1:100 คุณก็สามารถที่จะทำกำไรด้วยเงิน $10,000 ซึ่งทำให้ใช้เงินในการลงทุนน้อยแต่สามารถทำกำไรได้มากและยังมีความเสี่ยงต่ำอีกด้วย

   อย่างไรก็ตาม นี่ก็เป็นดาบสองคมเช่นกันหากไม่มีการบริหารความเสี่ยงที่ดีพอ ก็อาจนำไปสู่ความสูญเสียได้มากเช่นกัน นักลงทุนที่ดีจะทำการเทรดแค่ 1-5 % ของเงินลงทุนทั้งหมด