MQL5.com의 프리랜스 서비스: Convert a MT4 EA to a cTrader cBot

설명

명시

Here is the code that needs to be converted:-

//+------------------------------------------------------------------+

//+ Code generated using FxPro Quant 2.1.4 |

//+------------------------------------------------------------------+

#property strict

#define __STRATEGY_MAGIC 1001000000

#define __SLEEP_AFTER_EXECUTION_FAIL 400

struct InputsStr

{

string _Currency; // Symbol

string _TimeFrame; // TimeFrame

string _Slowing; // Slowing

string _Whole_Number_Input; // Period

string _Grid_Points; // Grid Points

string _SL_Percentage; // SL Percentage

string _RSI_Buy_Limit; // RSI Buy Limit

string _Sell_TP_in_Points; // Sell TP in Points

string _Max_Days; // Max Days

string _Stoc_Buy_Limit; // Stoc Buy Limit

string _Mom_Buy_Limit; // Mom Buy Limit

string _D_Period; // D Period

string _Stoc_Sell_Limit; // Stoc Sell Limit

string _RSI_Sell_Limit; // RSI Sell Limit

string _Mom_Sell_Limit; // Mom Sell Limit

string _Buy_TP_in_Points; // Buy TP in Points

string _Max_Open_Trades; // Max Open Trades

string _Lot_Percentage; // Lot Percentage

};

struct Inputs

{

string _Currency; // Symbol

string _TimeFrame; // TimeFrame

int _Slowing; // Slowing

int _Whole_Number_Input; // Period

int _Grid_Points; // Grid Points

double _SL_Percentage; // SL Percentage

int _RSI_Buy_Limit; // RSI Buy Limit

int _Sell_TP_in_Points; // Sell TP in Points

int _Max_Days; // Max Days

int _Stoc_Buy_Limit; // Stoc Buy Limit

double _Mom_Buy_Limit; // Mom Buy Limit

int _D_Period; // D Period

int _Stoc_Sell_Limit; // Stoc Sell Limit

int _RSI_Sell_Limit; // RSI Sell Limit

double _Mom_Sell_Limit; // Mom Sell Limit

int _Buy_TP_in_Points; // Buy TP in Points

int _Max_Open_Trades; // Max Open Trades

double _Lot_Percentage; // Lot Percentage

};

//Default Input variables

string _Currency ;

int _TimeFrame;

int _Slowing;

int _Whole_Number_Input;

int _Grid_Points ;

double _SL_Percentage ;

int _RSI_Buy_Limit ;

int _Sell_TP_in_Points;

int _Max_Days ;

int _Stoc_Buy_Limit ;

double _Mom_Buy_Limit;

int _D_Period;

int _Stoc_Sell_Limit;

int _RSI_Sell_Limit ;

double _Mom_Sell_Limit;

int _Buy_TP_in_Points;

int _Max_Open_Trades ;

double _Lot_Percentage;

//Global declaration

double _Momentum;

double _Stochastic_3;

double _RSI;

bool _Compare_7;

bool _Compare_10;

bool _Compare_1;

bool _Compare_9;

bool _Compare_11;

double _Arithmetic;

bool _Compare_12;

bool _Compare_2;

Inputs inputsAct[] ;

InputsStr inputs[];

// Global Variables

input string _FileName="MRS14.csv" ; // Input File

input int _GlobalMaxOrders=20;

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

int init()

{

if(ReadCSVFile())

{

if(ArraySize(inputsAct)<=0)

return INIT_FAILED;

}

else

{

return INIT_FAILED ;

}

return(0);

}

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

int start()

{

for(int i=0; i<ArraySize(inputsAct); i++)

{

SetSettings(inputsAct[i]._Currency);

//Local declaration

bool _Close_Position_1 = false;

bool _Sell = false;

bool _Buy = false;

bool _Buy_2 = false;

bool _Sell_2 = false;

_Momentum = iMomentum(_Currency,_TimeFrame, _Whole_Number_Input, 0, 0);

_Stochastic_3 = iStochastic(_Currency, _TimeFrame, _Whole_Number_Input, _D_Period, _Slowing, 0, 0, 0, 0);

_RSI = iRSI(_Currency, _TimeFrame, _Whole_Number_Input,0, 0);

_Compare_7 = (_RSI > _RSI_Sell_Limit);

_Compare_10 = (_Momentum > _Mom_Sell_Limit);

_Compare_1 = (_RSI < _RSI_Buy_Limit);

_Compare_9 = (_Momentum < _Mom_Buy_Limit);

_Compare_11 = (Number_of_Open_Trades(1,_Currency) < _Max_Open_Trades);

_Arithmetic = ((_Grid_Points *

(-1)) *

(Number_of_Open_Trades(1,_Currency)));

_Compare_12 = (_Stochastic_3 > _Stoc_Sell_Limit);

_Compare_2 = (_Stochastic_3 < _Stoc_Buy_Limit);

if((__OpenTime(1, _Currency) + 24*60*60 * (_Max_Days) < TimeCurrent()))

{

_Close_Position_1 = __isOpenedPosition(1, _Currency);

if(_Close_Position_1)

{

int ticket = OrderTicket();

int type = OrderType();

double lots = OrderLots();

string sym = OrderSymbol();

_Close_Position_1 = OrderClose(ticket, lots, MarketInfo(sym, MODE_BID) + MarketInfo(sym, MODE_SPREAD) * MarketInfo(sym, MODE_POINT) * (type==1 ? 1:0), 0);

}

if(GetGlobalOrders()>=_GlobalMaxOrders)

return 0 ;

if(((_Compare_7 &&

(_Compare_12 &&

!__selectOrderBySymbol(_Currency))) &&

_Compare_10))

_Sell = Sell(_Currency,1, ((_Lot_Percentage *

(AccountFreeMargin())) /

(100000)), 0, ((AccountFreeMargin() /

((100 /

(_SL_Percentage)))) /

(((_Lot_Percentage *

(AccountFreeMargin())) /

(100000)))), 0, _Sell_TP_in_Points, 5, _Max_Open_Trades, 0, "");

if((((_Compare_2 &&

!__selectOrderBySymbol(_Currency)) &&

_Compare_1) &&

_Compare_9))

_Buy = Buy(_Currency,1, ((_Lot_Percentage *

(AccountFreeMargin())) /

(100000)), 0, ((AccountFreeMargin() /

((100 /

(_SL_Percentage)))) /

(((_Lot_Percentage *

(AccountFreeMargin())) /

(100000)))), 0, _Buy_TP_in_Points, 5, _Max_Open_Trades, 0, "");

if((((((__selectOrderBySymbol(_Currency) &&

((_Arithmetic < 0) &&

(__ProfitPoints(1, _Currency) < _Arithmetic))) &&

_Compare_11) &&

_Compare_2) &&

_Compare_1) &&

_Compare_9))

_Buy_2 = Buy(_Currency,1, ((_Lot_Percentage *

(AccountFreeMargin())) /

(100000)), 0, ((AccountFreeMargin() /

((100 /

(_SL_Percentage)))) /

(((_Lot_Percentage *

(AccountFreeMargin())) /

(100000)))), 0, _Buy_TP_in_Points, 5, _Max_Open_Trades, 0, "");

if((((((__selectOrderBySymbol(_Currency) &&

((_Arithmetic < 0) &&

(__ProfitPoints(1, _Currency) < _Arithmetic))) &&

_Compare_11) &&

_Compare_12) &&

_Compare_7) &&

_Compare_10))

_Sell_2 = Sell(_Currency,1, ((_Lot_Percentage *

(AccountFreeMargin())) /

(100000)), 0, ((AccountFreeMargin() /

((100 /

(_SL_Percentage)))) /

(((_Lot_Percentage *

(AccountFreeMargin())) /

(100000)))), 0, _Sell_TP_in_Points, 5, _Max_Open_Trades, 0, "");

}

return(0);

}

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

bool __selectOrderBySymbol(string symbol)

{

for(int i = 0; i < OrdersTotal(); i++)

{

if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES) && OrderSymbol() == symbol)

return(true);

}

return(false);

}

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

bool __selectOrderByMagic(int magic, string symbol)

{

for(int i = 0; i < OrdersTotal(); i++)

{

if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES) && OrderMagicNumber() == __STRATEGY_MAGIC + magic && OrderSymbol() == symbol)

return(true);

}

return(false);

}

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

datetime __OpenTime(int magic, string symbol)

{

if(!__selectOrderByMagic(magic, symbol))

return(0);

return(OrderOpenTime());

}

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

double __ProfitPoints(int magic, string symbol)

{

if(!__selectOrderByMagic(magic, symbol))

return(0);

if(OrderType() == OP_BUY)

return ((MarketInfo(OrderSymbol(),MODE_BID) - OrderOpenPrice())/MarketInfo(OrderSymbol(),MODE_POINT));

else

if(OrderType() == OP_SELL)

return ((OrderOpenPrice() - (MarketInfo(OrderSymbol(),MODE_ASK)))/MarketInfo(OrderSymbol(),MODE_POINT));

return (0);

}

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

bool __isOpenedPosition(int magic, string symbol)

{

if(!__selectOrderByMagic(magic, symbol))

return(false);

return(OrderType()==OP_BUY || OrderType()==OP_SELL);

}

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

int __Ticket(int magic, string symbol)

{

if(!__selectOrderByMagic(magic, symbol))

return(0);

return(OrderTicket());

}

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

int Number_of_Open_Trades(int MagicIndex, string symbol)

{

int res = 0;

for(int i=OrdersTotal()-1; i>=0; i--)

{

if(!OrderSelect(i, SELECT_BY_POS))

continue;

if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() != symbol)

continue;

res ++;

}

return (res);

}

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

bool Sell(string symbol ,int MagicIndex, double Lots, int StopLossMethod, double StopLossPoints, int TakeProfitMethod, double TakeProfitPoints, int Slippage, int MaxOpenTrades,

int MaxFrequencyMins, string TradeComment)

{

int digits=(int)MarketInfo(symbol,MODE_DIGITS);

double points=MarketInfo(symbol,MODE_POINT);

double bid=MarketInfo(symbol,MODE_BID);

double ask=MarketInfo(symbol,MODE_ASK);

static double pipSize = 0;

if(pipSize == 0)

pipSize = points * (1 + 9 * (digits == 3 || digits == 5));

double sl = 0, tp = 0;

double stopLossPoints = 0, takeProfitPoints = 0;

int numberOfOpenTrades = 0;

for(int i=OrdersTotal()-1; i>=0; i--)

{

if(!OrderSelect(i, SELECT_BY_POS))

continue;

if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() != symbol)

continue;

numberOfOpenTrades ++;

}

if(MaxOpenTrades > 0 && numberOfOpenTrades >= MaxOpenTrades)

return(false);

if(MaxFrequencyMins > 0)

{

int recentSeconds = MaxFrequencyMins * 60;

for(int i=OrdersTotal()-1; i>=0; i--)

{

if(!OrderSelect(i, SELECT_BY_POS))

continue;

if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() !=symbol)

continue;

if(TimeCurrent() - OrderOpenTime() < recentSeconds)

return(false);

}

int hstTotal=OrdersHistoryTotal();

for(int i=hstTotal-1; i>=0; i--)

{

if(!OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))

continue;

if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() != symbol)

continue;

if(TimeCurrent() - OrderOpenTime() < recentSeconds)

return(false);

break;

}

if(Lots < MarketInfo(symbol,MODE_MINLOT))

return(false);

if(AccountFreeMarginCheck(symbol, OP_SELL,Lots) <= 0)

{

Print("Sell order error: insufficient capital");

return(false);

}

if(StopLossPoints > 0)

{

if(StopLossMethod == 0)

{

sl = NormalizeDouble(bid + StopLossPoints * points, digits);

stopLossPoints = StopLossPoints;

}

else

if(StopLossMethod == 1)

{

sl = NormalizeDouble(bid + StopLossPoints * pipSize, digits);

stopLossPoints = StopLossPoints * (1 + 9 * (digits == 3 || digits == 5));

}

else

{

sl = StopLossPoints;

stopLossPoints = (sl - bid)/points;

}

if(TakeProfitPoints > 0)

{

if(TakeProfitMethod == 0)

{

tp = NormalizeDouble(bid - TakeProfitPoints * points, digits);

takeProfitPoints = TakeProfitPoints;

}

else

if(TakeProfitMethod == 1)

{

tp = NormalizeDouble(bid - TakeProfitPoints * pipSize, digits);

takeProfitPoints = TakeProfitPoints * (1 + 9 * (digits == 3 || digits == 5));

}

else

{

tp = TakeProfitPoints;

takeProfitPoints = (bid - tp)/Point;

}

double stopLevel = MarketInfo(symbol,MODE_STOPLEVEL) + MarketInfo(symbol,MODE_SPREAD);

if((sl > 0 && stopLossPoints <= stopLevel) || (tp > 0 && takeProfitPoints <= stopLevel))

{

Print("Cannot Sell: Stop loss and take profit must be at least "

+ DoubleToStr(MarketInfo(symbol,MODE_STOPLEVEL) + MarketInfo(symbol,MODE_SPREAD),0)

+ " points away from the current price");

return (false);

}

RefreshRates();

int result = OrderSend(symbol, OP_SELL, Lots, bid, Slippage, sl, tp, "FxProQuant" + "(" + WindowExpertName() + ") " + TradeComment,__STRATEGY_MAGIC + MagicIndex);

if(result == -1)

{

Print("Failed to Sell: " + IntegerToString(GetLastError()));

Sleep(__SLEEP_AFTER_EXECUTION_FAIL);

return(false);

}

return(true);

}

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

bool Buy(string symbol ,int MagicIndex, double Lots, int StopLossMethod, double StopLossPoints, int TakeProfitMethod, double TakeProfitPoints, int Slippage, int MaxOpenTrades,

int MaxFrequencyMins, string TradeComment)

{

int digits=(int)MarketInfo(symbol,MODE_DIGITS);

double points=MarketInfo(symbol,MODE_POINT);

double bid=MarketInfo(symbol,MODE_BID);

double ask=MarketInfo(symbol,MODE_ASK);

static double pipSize = 0;

if(pipSize == 0)

pipSize = points * (1 + 9 * (digits == 3 || digits == 5));

double sl = 0, tp = 0;

double stopLossPoints = 0, takeProfitPoints = 0;

int numberOfOpenTrades = 0;

for(int i=OrdersTotal()-1; i>=0; i--)

{

if(!OrderSelect(i, SELECT_BY_POS))

continue;

if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() != symbol)

continue;

numberOfOpenTrades ++;

}

if(MaxOpenTrades > 0 && numberOfOpenTrades >= MaxOpenTrades)

return(false);

if(MaxFrequencyMins > 0)

{

int recentSeconds = MaxFrequencyMins * 60;

for(int i=OrdersTotal()-1; i>=0; i--)

{

if(!OrderSelect(i, SELECT_BY_POS))

continue;

if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() != symbol)

continue;

if(TimeCurrent() - OrderOpenTime() < recentSeconds)

return(false);

}

int hstTotal=OrdersHistoryTotal();

for(int i=hstTotal-1; i>=0; i--)

{

if(!OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))

continue;

if(OrderMagicNumber() != __STRATEGY_MAGIC + MagicIndex || OrderSymbol() !=symbol)

continue;

if(TimeCurrent() - OrderOpenTime() < recentSeconds)

return(false);

break;

}

if(Lots < MarketInfo(symbol,MODE_MINLOT))

return(false);

if(AccountFreeMarginCheck(symbol, OP_SELL,Lots) <= 0)

{

Print("Buy error: insufficient capital");

return(false);

}

if(StopLossPoints > 0)

{

if(StopLossMethod == 0)

{

sl = NormalizeDouble(ask - StopLossPoints * points, digits);

stopLossPoints = StopLossPoints;

}

else

if(StopLossMethod == 1)

{

sl = NormalizeDouble(ask - StopLossPoints * pipSize, digits);

stopLossPoints = StopLossPoints * (1 + 9 * (digits == 3 || digits == 5));

}

else

{

sl = StopLossPoints;

stopLossPoints = (ask - sl)/Point;

}

if(TakeProfitPoints > 0)

{

if(TakeProfitMethod == 0)

{

tp = NormalizeDouble(ask + TakeProfitPoints * points, digits);

takeProfitPoints = TakeProfitPoints;

}

else

if(TakeProfitMethod == 1)

{

tp = NormalizeDouble(ask + TakeProfitPoints * pipSize, digits);

takeProfitPoints = TakeProfitPoints * (1 + 9 * (digits == 3 || digits == 5));

}

else

{

tp = TakeProfitPoints;

takeProfitPoints = (tp - ask)/Point;

}

double stopLevel = MarketInfo(symbol,MODE_STOPLEVEL) + MarketInfo(symbol,MODE_SPREAD);

if((sl > 0 && stopLossPoints <= stopLevel) || (tp > 0 && takeProfitPoints <= stopLevel))

{

Print("Cannot Buy: Stop loss and take profit must be at least "

+ DoubleToStr(MarketInfo(symbol,MODE_STOPLEVEL) + MarketInfo(symbol,MODE_SPREAD),0)

+ " points away from the current price");

return (false);

}

RefreshRates();

int result = OrderSend(symbol, OP_BUY, Lots, ask, Slippage, sl, tp, "FxProQuant" + "(" + WindowExpertName() + ") " + TradeComment, __STRATEGY_MAGIC + MagicIndex);

if(result == -1)

{

Print("Failed to Buy: " + IntegerToString(GetLastError()));

Sleep(__SLEEP_AFTER_EXECUTION_FAIL);

return(false);

}

return(true);

}

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

bool ReadCSVFile()

{

if(!FileIsExist(_FileName))

return false ;

int handle=FileOpen(_FileName,FILE_CSV|FILE_READ,";") ;

int line=0;

if(handle!=INVALID_HANDLE)

{

while(!FileIsEnding(handle))

{

ArrayResize(inputs,line+1);

inputs[line]._Currency=FileReadString(handle);

inputs[line]._TimeFrame=FileReadString(handle);

inputs[line]._Slowing=FileReadString(handle);

inputs[line]._Whole_Number_Input=FileReadString(handle);

inputs[line]._Grid_Points=FileReadString(handle);

inputs[line]._SL_Percentage=FileReadString(handle);

inputs[line]._RSI_Buy_Limit=FileReadString(handle);

inputs[line]._Sell_TP_in_Points=FileReadString(handle);

inputs[line]._Max_Days=FileReadString(handle);

inputs[line]._Stoc_Buy_Limit=FileReadString(handle);

inputs[line]._Mom_Buy_Limit=FileReadString(handle);

inputs[line]._D_Period=FileReadString(handle);

inputs[line]._Stoc_Sell_Limit=FileReadString(handle);

inputs[line]._RSI_Sell_Limit=FileReadString(handle); ;

inputs[line]._Mom_Sell_Limit=FileReadString(handle);

inputs[line]._Buy_TP_in_Points=FileReadString(handle);

inputs[line]._Max_Open_Trades=FileReadString(handle);

inputs[line]._Lot_Percentage=FileReadString(handle);

line++ ;

}

FileClose(handle);

}

else

{

return false ;

}

ArrayResize(inputsAct,ArraySize(inputs)-1);

for(int i=0; i<ArraySize(inputsAct); i++)

{

inputsAct[i]._Currency=inputs[i+1]._Currency;

inputsAct[i]._TimeFrame=inputs[i+1]._TimeFrame;

inputsAct[i]._Slowing=(int)inputs[i+1]._Slowing;

inputsAct[i]._Whole_Number_Input=(int)inputs[i+1]._Whole_Number_Input;

inputsAct[i]._Grid_Points=(int)inputs[i+1]._Grid_Points;

inputsAct[i]._SL_Percentage=StringToDouble(inputs[i+1]._SL_Percentage);

inputsAct[i]._RSI_Buy_Limit=(int)inputs[i+1]._RSI_Buy_Limit;

inputsAct[i]._Sell_TP_in_Points=(int)inputs[i+1]._Sell_TP_in_Points;

inputsAct[i]._Max_Days=(int)inputs[i+1]._Max_Days;

inputsAct[i]._Stoc_Buy_Limit=(int)inputs[i+1]._Stoc_Buy_Limit;

inputsAct[i]._Mom_Buy_Limit=StringToDouble(inputs[i+1]._Mom_Buy_Limit);

inputsAct[i]._D_Period=(int)inputs[i+1]._D_Period;

inputsAct[i]._Stoc_Sell_Limit=(int)inputs[i+1]._Stoc_Sell_Limit;

inputsAct[i]._RSI_Sell_Limit=(int)inputs[i+1]._RSI_Sell_Limit;

inputsAct[i]._Mom_Sell_Limit=StringToDouble(inputs[i+1]._Mom_Sell_Limit);

inputsAct[i]._Buy_TP_in_Points=(int)inputs[i+1]._Buy_TP_in_Points;

inputsAct[i]._Max_Open_Trades=(int)inputs[i+1]._Max_Open_Trades;

inputsAct[i]._Lot_Percentage=StringToDouble(inputs[i+1]._Lot_Percentage) ;

}

return true ;

}

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

int StringToTimeFrame(string tf)

{

if(tf=="M1")

return PERIOD_M1 ;

else

if(tf=="M5")

return PERIOD_M5 ;

else

if(tf=="M15")

return PERIOD_M15 ;

else

if(tf=="M30")

return PERIOD_M30 ;

else

if(tf=="H1")

return PERIOD_H1 ;

else

if(tf=="H4")

return PERIOD_H4 ;

else

if(tf=="D1")

return PERIOD_D1 ;

else

if(tf=="W1")

return PERIOD_W1 ;

else

if(tf=="MN1")

return PERIOD_MN1 ;

return PERIOD_CURRENT ;

}

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

void SetSettings(string symbol)

{

bool found=false ;

for(int i=0; i<ArraySize(inputsAct); i++)

{

if(inputsAct[i]._Currency==symbol)

{

_Currency=inputsAct[i]._Currency ;

_TimeFrame=StringToTimeFrame(inputsAct[i]._TimeFrame);

_Slowing = inputsAct[i]._Slowing;

_Whole_Number_Input = inputsAct[i]._Whole_Number_Input;

_Grid_Points = inputsAct[i]._Grid_Points;

_SL_Percentage = inputsAct[i]._SL_Percentage;

_RSI_Buy_Limit = inputsAct[i]._RSI_Buy_Limit;

_Sell_TP_in_Points = inputsAct[i]._Sell_TP_in_Points;

_Max_Days = inputsAct[i]._Max_Days;

_Stoc_Buy_Limit = inputsAct[i]._Stoc_Buy_Limit;

_Mom_Buy_Limit = inputsAct[i]._Mom_Buy_Limit;

_D_Period = inputsAct[i]._D_Period;

_Stoc_Sell_Limit = inputsAct[i]._Stoc_Sell_Limit;

_RSI_Sell_Limit = inputsAct[i]._RSI_Sell_Limit;

_Mom_Sell_Limit = inputsAct[i]._Mom_Sell_Limit;

_Buy_TP_in_Points = inputsAct[i]._Buy_TP_in_Points;

_Max_Open_Trades = inputsAct[i]._Max_Open_Trades;

_Lot_Percentage =inputsAct[i]._Lot_Percentage;

found=true ;

break ;

}

else

{

continue ;

}

if(!found)

{

_Currency=symbol;

_TimeFrame=PERIOD_CURRENT ; // Trading TimeFrame

_Slowing = 3; // Slowing

_Whole_Number_Input = 10; // Period

_Grid_Points = 200; // Grid Points

_SL_Percentage = 1; // SL Percentage

_RSI_Buy_Limit = 25; // RSI Buy Limit

_Sell_TP_in_Points = 300; // Sell TP in Points

_Max_Days = 14; // Max Days

_Stoc_Buy_Limit = 15; // Stoc Buy Limit

_Mom_Buy_Limit = 99.5; // Mom Buy Limit

_D_Period = 3; // D Period

_Stoc_Sell_Limit = 85; // Stoc Sell Limit

_RSI_Sell_Limit = 75; // RSI Sell Limit

_Mom_Sell_Limit = 100.5; // Mom Sell Limit

_Buy_TP_in_Points = 300; // Buy TP in Points

_Max_Open_Trades = 6; // Max Open Trades

_Lot_Percentage = 0.5; // Lot Percentage

}

//+------------------------------------------------------------------+

//| |

//+------------------------------------------------------------------+

int GetGlobalOrders()

{

int cnt=0 ;

for(int i=0; i<OrdersTotal(); i++)

{

if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber()==__STRATEGY_MAGIC+1)

cnt ++;

}

return cnt ;

}

//+------------------------------------------------------------------+

파일:

CSV

MRS14_Demo.csv

1.9 Kb

응답함

등급

(38)

프로젝트

10%

중재

0% / 0%

기한 초과

16%

무료

등급

프로젝트

중재

67% / 33%

기한 초과

무료

비슷한 주문

Buy signal: the main MACD line crosses the signal line upwards (macd_current>signal_current && macd_previous<signal_previous). Sell signal: the main MACD line crosses the signal line downwards (macd_current<signal_current && macd_previous>signal_previous). The below figure shows Buy and Sell cases

I need someone that can write me a python and Pine script for a kangaroo tail for forex trading. The kangaroo tail body need to be inside of the previous candlestick body. See attachment for example

I am looking for a professional expert advisor developer to build my BTC EA in MT5. The first thing that I need is screenshot of the work to make sure the developer can Done my project. I need to make sure that the developer fully understood my Strategy and could do it. So the developer should start the job and proof ability to finish the job then we will go ahead to make contract. If you accept my condition

The purpose of the robot is to trade/indicator debugging and statistics and mathematics,the task for the robot is to trade and collecting data on internet and stock trading specific features need trading skills , customer graphics and forex and my particular design is that my robot must have all the of my requirements

This Expert Advisor is designed to detect liquidity-based reversals on the 15-minute timeframe by combining volume spikes , price action (pin bars) , and trend alignment . The goal is to identify exhaustion candles during strong directional moves and enter trades at optimal points using adaptive stop-loss and risk-based lot sizing . 1. Volume Climax Detection Identify bars where volume is at least 1.1× greater than

Create an MQL4 indicator to control live trading of an EA within its specific chart window only. - The indicator should not enable/disable auto trading for all EAs running on the MT4 platform, but only for the EA running in the same chart window as the indicator. - Assume that there is no access to the EA code, therefore the indicator should function independently without having to modify the EA. So, I need to load

Hello Dev Team, am have looking for an experienced Ea programmer who can build any type of EA with his/her expertise or who already have any type of Ea,bot,indicator or HFT, with winning rate of 85% to 95%. Please DO NOT contact or respond if you don’t have or can’t provide any Ea of such request, because I will give you a bad review on lack of understanding of your roles

I need an expert to create a bot used in mt5. I have the strategy ,just wanted it coded with specific SL and Tp and it should be very fast because it's on the 1 minute time-frame. Specially Gbpusd pair .should work with prop firms

I'm looking for an experienced MQL4/MQL5 developer to build an HFT intelligence Expert Advisor with a highly adaptive strategies.If anyone has a ready made HFT EA then we can discuss.The EA has to work on all brokers and has to execute fast with a win rate of 96% to 98%.The system has to be able to (Scalp) and (Trade following trend).The scalping version must place stop orders and trades must be taken on every candle

I'm looking for a trading robot to only take Boom & Crash spikes. The strategy will be defined by the developer. I'm open to any other creation by the developer that would be a profitable EA

프로젝트 정보

예산

120 - 160 USD

개발자에게

108 - 144 USD

기한

에서 5 로 10 일

상세내용의 질
결과 확인의 질
능력과 커뮤니케이션 스킬