Как открыть пример сделки: используя индикатор RSI, который имеет нижний уровень Period и уровни: 20 и верхний уровень 80, каждый раз, когда перекупленность свечи (нижний уровень) выставляет ордер Buy и закрывается по достижении верхнего уровня, но каждый раз проходит мимо на нижнем уровне уровня перекупленности разместите еще один ордер на покупку, но с приращением в 2,8 раза, пока он не достигнет не более 8 раз, и, наконец, закроет все позиции, когда достигнет верхнего уровня, то же самое произойдет для ордеров на продажу.
Код:
#include <stdlib.mqh>
#include <stderror.mqh>
extern int Top = 80;
extern int Bottom = 20;
extern int Period1 = 10;
int LotDigits; //initialized in OnInit
extern int MagicNumber = 1517688;
extern double MM_Martingale_Start = 0.01; // Start_Lot
double MM_Martingale_ProfitFactor = 1;
extern double MM_Martingale_LossFactor = 2.8;
bool MM_Martingale_RestartProfit = true;
bool MM_Martingale_RestartLoss = false;
int MM_Martingale_RestartLosses = 8;
int MM_Martingale_RestartProfits = 1000;
int MaxSlippage = 3; //adjusted in OnInit
int MaxOpenTrades = 1;
int MaxLongTrades = 1000;
int MaxShortTrades = 1000;
int MaxPendingOrders = 1000;
int MaxLongPendingOrders = 1000;
int MaxShortPendingOrders = 1000;
bool Hedging = false;
int OrderRetry = 5; //# of retries if sending order returns error
int OrderWait = 5; //# of seconds to wait if sending order returns error
double myPoint; //initialized in OnInit
double MM_Size() //martingale / anti-martingale
{
double lots = MM_Martingale_Start; // Start_Lot
double MaxLot = MarketInfo(Symbol(), MODE_MAXLOT); // Maximum permitted amount of a lot
double MinLot = MarketInfo(Symbol(), MODE_MINLOT); // Minimum permitted amount of a lot
if(SelectLastHistoryTrade())
{
double orderprofit = OrderProfit();
double orderlots = OrderLots(); // trade volume
if(orderprofit > 0 && !MM_Martingale_RestartProfit) // If orderprofit is more than 0 and no Martinggale Profit
lots = orderlots * MM_Martingale_ProfitFactor; // then lots is equal to 0.01 * MMartingale profit factor.
else if(orderprofit < 0 && !MM_Martingale_RestartLoss) // and If ordeprofit is less than 0 and no Martiangale_restarloss
lots = orderlots * MM_Martingale_LossFactor; // so then 0.01 * Martingale_LossFactor.
else if(orderprofit == 0)
lots = orderlots;
}
if(ConsecutivePL(false, MM_Martingale_RestartLosses))
lots = MM_Martingale_Start;
if(ConsecutivePL(true, MM_Martingale_RestartProfits))
lots = MM_Martingale_Start;
if(lots > MaxLot) lots = MaxLot;
if(lots < MinLot) lots = MinLot;
return(lots);
}
void myAlert(string type, string message)
{
if(type == "print")
Print(message);
else if(type == "error")
{
Print(type+" | rsi @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
}
else if(type == "order")
{
}
else if(type == "modify")
{
}
}
int TradesCount(int type) //returns # of open trades for order type, current symbol and magic number
{
int result = 0;
int total = OrdersTotal();
for(int i = 0; i < total; i++)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES) == false) continue;
if(OrderMagicNumber() != MagicNumber || OrderSymbol() != Symbol() || OrderType() != type) continue;
result++;
}
return(result);
}
bool SelectLastHistoryTrade()
{
int lastOrder = -1;
int total = OrdersHistoryTotal();
for(int i = total-1; i >= 0; i--)
{
if(!OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) continue;
if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
{
lastOrder = i;
break;
}
}
return(lastOrder >= 0);
}
bool ConsecutivePL(bool profits, int n)
{
int count = 0;
int total = OrdersHistoryTotal();
for(int i = total-1; i >= 0; i--)
{
if(!OrderSelect(i, SELECT_BY_POS, MODE_HISTORY)) continue;
if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumber)
{
double orderprofit = OrderProfit();
if((!profits && orderprofit >= 0) || (profits && orderprofit <= 0))
break;
count++;
}
}
return(count >= n);
}
int myOrderSend(int type, double price, double volume, string ordername) //send order, return ticket ("price" is irrelevant for market orders)
{
if(!IsTradeAllowed()) return(-1);
int ticket = -1;
int retries = 0;
int err = 0;
int long_trades = TradesCount(OP_BUY);
int short_trades = TradesCount(OP_SELL);
int long_pending = TradesCount(OP_BUYLIMIT) + TradesCount(OP_BUYSTOP);
int short_pending = TradesCount(OP_SELLLIMIT) + TradesCount(OP_SELLSTOP);
string ordername_ = ordername;
if(ordername != "")
ordername_ = "("+ordername+")";
//test Hedging
if(!Hedging && ((type % 2 == 0 && short_trades + short_pending > 0) || (type % 2 == 1 && long_trades + long_pending > 0)))
{
myAlert("print", "Order"+ordername_+" not sent, hedging not allowed");
return(-1);
}
//test maximum trades
if((type % 2 == 0 && long_trades >= MaxLongTrades)
|| (type % 2 == 1 && short_trades >= MaxShortTrades)
|| (long_trades + short_trades >= MaxOpenTrades)
|| (type > 1 && type % 2 == 0 && long_pending >= MaxLongPendingOrders)
|| (type > 1 && type % 2 == 1 && short_pending >= MaxShortPendingOrders)
|| (type > 1 && long_pending + short_pending >= MaxPendingOrders)
)
{
myAlert("print", "Order"+ordername_+" not sent, maximum reached");
return(-1);
}
//prepare to send order
while(IsTradeContextBusy()) Sleep(100);
RefreshRates();
if(type == OP_BUY)
price = Ask;
else if(type == OP_SELL)
price = Bid;
else if(price < 0) //invalid price for pending order
{
myAlert("order", "Order"+ordername_+" not sent, invalid price for pending order");
return(-1);
}
int clr = (type % 2 == 1) ? clrRed : clrBlue;
while(ticket < 0 && retries < OrderRetry+1)
{
ticket = OrderSend(Symbol(), type, NormalizeDouble(volume, LotDigits), NormalizeDouble(price, Digits()), MaxSlippage, 0, 0, ordername, MagicNumber, 0, clr);
if(ticket < 0)
{
err = GetLastError();
myAlert("print", "OrderSend"+ordername_+" error #"+IntegerToString(err)+" "+ErrorDescription(err));
Sleep(OrderWait*1000);
}
retries++;
}
if(ticket < 0)
{
myAlert("error", "OrderSend"+ordername_+" failed "+IntegerToString(OrderRetry+1)+" times; error #"+IntegerToString(err)+" "+ErrorDescription(err));
return(-1);
}
string typestr[6] = {"Buy", "Sell", "Buy Limit", "Sell Limit", "Buy Stop", "Sell Stop"};
myAlert("order", "Order sent"+ordername_+": "+typestr[type]+" "+Symbol()+" Magic #"+IntegerToString(MagicNumber));
return(ticket);
}
void myOrderClose(int type, int volumepercent, string ordername) //close open orders for current symbol, magic number and "type" (OP_BUY or OP_SELL)
{
if(!IsTradeAllowed()) return;
if (type > 1)
{
myAlert("error", "Invalid type in myOrderClose");
return;
}
bool success = false;
int err = 0;
string ordername_ = ordername;
if(ordername != "")
ordername_ = "("+ordername+")";
int total = OrdersTotal();
int orderList[][2];
int orderCount = 0;
for(int i = 0; i < total; i++)
{
while(IsTradeContextBusy()) Sleep(100);
if(!OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) continue;
if(OrderMagicNumber() != MagicNumber || OrderSymbol() != Symbol() || OrderType() != type) continue;
orderCount++;
ArrayResize(orderList, orderCount);
orderList[orderCount - 1][0] = OrderOpenTime();
orderList[orderCount - 1][1] = OrderTicket();
}
if(orderCount > 0)
ArraySort(orderList, WHOLE_ARRAY, 0, MODE_ASCEND);
for(i = 0; i < orderCount; i++)
{
if(!OrderSelect(orderList[i][1], SELECT_BY_TICKET, MODE_TRADES)) continue;
while(IsTradeContextBusy()) Sleep(100);
RefreshRates();
double price = (type == OP_SELL) ? Ask : Bid;
double volume = NormalizeDouble(OrderLots()*volumepercent * 1.0 / 100, LotDigits);
if (NormalizeDouble(volume, LotDigits) == 0) continue;
success = OrderClose(OrderTicket(), volume, NormalizeDouble(price, Digits()), MaxSlippage, clrWhite);
if(!success)
{
err = GetLastError();
myAlert("error", "OrderClose"+ordername_+" failed; error #"+IntegerToString(err)+" "+ErrorDescription(err));
}
}
string typestr[6] = {"Buy", "Sell", "Buy Limit", "Sell Limit", "Buy Stop", "Sell Stop"};
if(success) myAlert("order", "Orders closed"+ordername_+": "+typestr[type]+" "+Symbol()+" Magic #"+IntegerToString(MagicNumber));
}
//+------------------------------------------------------------------+
//| Expert initialization function |
//+------------------------------------------------------------------+
int OnInit()
{
//initialize myPoint
myPoint = Point();
if(Digits() == 5 || Digits() == 3)
{
myPoint *= 10;
MaxSlippage *= 10;
}
//initialize LotDigits
double LotStep = MarketInfo(Symbol(), MODE_LOTSTEP);
if(LotStep >= 1) LotDigits = 0;
else if(LotStep >= 0.1) LotDigits = 1;
else if(LotStep >= 0.01) LotDigits = 2;
else LotDigits = 3;
return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
}
//+------------------------------------------------------------------+
//| Expert tick function |
//+------------------------------------------------------------------+
void OnTick()
{
int ticket = -1;
double price;
//Close Long Positions
if(iRSI(NULL, PERIOD_CURRENT, 10, PRICE_CLOSE, 0) < Top && iRSI(NULL, PERIOD_CURRENT, 10, PRICE_CLOSE, 2) > Top //Custom Code
)
{
if(IsTradeAllowed())
myOrderClose(OP_BUY, 100, "");
else //not autotrading => only send alert
myAlert("order", "");
}
//Close Short Positions
if(iRSI(NULL, PERIOD_CURRENT, 10, PRICE_CLOSE, 0) > Bottom && iRSI(NULL, PERIOD_CURRENT, 10, PRICE_CLOSE, 2) < Bottom //Custom Code
)
{
if(IsTradeAllowed())
myOrderClose(OP_SELL, 100, "");
else //not autotrading => only send alert
myAlert("order", "");
}
//Open Buy Order
if(iRSI(NULL, PERIOD_CURRENT, 10, PRICE_CLOSE, 0) > Bottom && iRSI(NULL, PERIOD_CURRENT, 10, PRICE_CLOSE, 2) < Bottom //Custom Code
)
{
RefreshRates();
price = Ask;
if(IsTradeAllowed())
{
ticket = myOrderSend(OP_BUY, price, MM_Size(), "");
if(ticket <= 0) return;
}
else //not autotrading => only send alert
myAlert("order", "");
}
//Open Sell Order
if(iRSI(NULL, PERIOD_CURRENT, 10, PRICE_CLOSE, 0) < Top && iRSI(NULL, PERIOD_CURRENT, 10, PRICE_CLOSE, 2) > Top //Custom Code
)
{
RefreshRates();
price = Bid;
if(IsTradeAllowed())
{
ticket = myOrderSend(OP_SELL, price, MM_Size(), "");
if(ticket <= 0) return;
}
else //not autotrading => only send alert
myAlert("order", "");
}
}
Но я уже решаю вопрос об уровнях RSI TOP и BOTTOM для покупки и продажи сейчас, пытаясь решить, как добавить больше покупок на тот же уровень, например:
Если Свеча закрывается выше уровня покупки 20 и, если повторить, снова покупает, но с большим лотовым множителем в этом случае MM_Martingale_LossFactor X, пока не достигнет не более 8 раз и не закроет все, как только достигнет уровня 80 с тем же логикой c для продажи.