全部订单
规则
类别中的新订单:
30 - 100 USD
30 - 2000 USD
50 - 200 USD
34 - 36 USD
50 - 200 USD
100 - 300 USD
30+ USD
指定
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 ;
}
//+------------------------------------------------------------------+
反馈
1
等级
项目
50
10%
仲裁
1
0%
/
0%
逾期
8
16%
空闲
2
等级
项目
2
0%
仲裁
3
67%
/
33%
逾期
0
空闲
相似订单
EA with very tight SL / TP
30 - 100 USD
Hi Team We are looking to commission an Expert Advisor (EA) for MetaTrader 5 (MT5) to trade XAUUSD (Gold) . The EA requires tight risk management with a strict $2.00 Stop Loss and a $3.00 to $5.00 Take Profit target. The goal is to achieve a 60%+ Win Rate . Please propose or implement a strategy algorithm capable of meeting the following performance requirements on XAUUSD tick data: Target Performance: $\ge 60\%$ Win
O Trading Ventures
30 - 2000 USD
a trading bot that can open and close trade by its self a stop loss of 1.2 lot size and good tp it should be able to learn trends and learn from its mistakes
Smc
50 - 200 USD
Title: Professional MT5 XAUUSD Multi-Strategy Expert Advisor Developer Needed I am looking for an experienced MQL5 developer to build or improve a fully automated MT5 Expert Advisor for XAUUSD on an Exness hedging account. Requirements: - Five independent trading engines: Rapid, Scalping, Sniper, Trend and Reversal. - Advanced SMC/ICT market structure, liquidity, BOS, CHoCH, order blocks and FVG analysis. - Multiple
Profitable Smart Auto trade EA
30 - 80 USD
Custom MT5 Expert Advisor – Developer Specification 1. Project Objective Develop a fully autonomous, custom MetaTrader 5 Expert Advisor (EA) using native MQL5. The EA must independently analyze financial markets, generate its own trading signals, evaluate opportunities, execute trades, and manage open positions without requiring an external signal provider, another trading bot, or manual intervention. The EA must
نازدك
30+ USD
Specify your Requirements Specification here point by point. Try to describe your requirements briefly and clearly, so that your potential developer is able to correctly assess its complexity and cost, as well as the required execution time. A bad or too generic description will result in your order being ignored, or you will spend a lot of time negotiating the details with each applicant. Remember: It is better to
I am looking for an experienced MQL5 developer to recreate my existing MT5 Expert Advisor (DSTR Novaa). I have the original compiled EX5 file, Vantage MT5 live trading history and original Strategy Tester report. Required Trading Logic: EMA Period: 3. BUY when price crosses below EMA 3. SELL when price crosses above EMA 3. Starting Lot: 0.01 (configurable). Martingale Multiplier: 2.0. Maximum Martingale Cycle: 9
CyberShadow AI
30 - 300 USD
I want a bot that’s trades using smc strategy having stop loss and take profit.I want it to be able to trade with small account I want a disciplined robot but a strong one to I also what it to trade using trend line and locate point of interest
I need an EA for MetaTrader 5 called AI Forex Robot V100. It must trade automatically on EURUSD and GBPUSD, M15 timeframe. Strategy: - Buy when fast EMA crosses above slow EMA and RSI is above 50 - Sell when fast EMA crosses below slow EMA and RSI is below 50 - Only 1 trade at a time - Stop Loss: 50 pips, Take Profit: 100 pips - Lot size: 0.01, with option to change in settings - Must have trailing stop and news
PROJECT: EXISTING MT5 EA MODIFICATION – XAUUSD SLIPPAGE REDUCTION 1. Project Objective I already have a fully developed MT5 Expert Advisor (.mq5 source code). I am looking for an experienced MQL5 developer who can optimize my existing EA to achieve the lowest possible execution slippage on a REAL LIVE trading account. My primary and only objective is to zero slippage. I am not looking for a new trading strategy or
Profitable EA needed
30+ USD
I need an already developed EA with proven ability to grow small accounts for day trading. It can trade any specific instrument like gold, EURUSD or more than one instrument. Any strategy is welcomed, including scalping in lower timeframes A test version is required before concluding the deal or being selected. Only those with ready products apply No fake EAs needed
项目信息
预算
120 - 160 USD
截止日期
从 5 到 10 天