代码拉取完成，页面将自动刷新
//+------------------------------------------------------------------+
//| MyAll.mq4|
//+------------------------------------------------------------------+
#property copyright "QQ:741506920"
#property link "QQ:741506920"
#include <stderror.mqh>
#include <stdlib.mqh>
//===================================================================================================================================================
extern string EAName = "MyAll EA";
int MagicNumberBuy = 123456789;
int MagicNumberSell = 987654321;
extern string EA参数设置 = ">>> EA参数设置";
extern bool CheckNewBar = false; // on new bar
bool 显示到图表上 = true; // Show info on chart
bool 显示CDP = false;
bool ShowClock = false; // Show time on chart
bool DrawAveragePrice = true; // Draw average price line
bool 允许买 = true; // Allow buys
bool 允许卖 = true; // Allow sells
//extern ENUM_TIMEFRAMES TimeFrame = PERIOD_H1; //交易周期
int ChaPoint = 100000;
extern string 仓位管理 = ">>> 仓位管理";
extern double 开始手数 = 0.1; // Initial lot size
extern double 加仓额外手数 = 0.1; // Increment lot to add
extern double 最大手数 = 0.1; // Maximum lot size
extern int 最大交易数 = 5;
bool 使用自动手数 = false; // Use Auto-lot ... % deposit
double 自动手数 = 0.05; // Percent - calculate lot size from equity
double 自动手数Increment = 0.03; // Percent of lot to add
extern string 加仓参数设置 = ">>> 加仓参数设置";
extern double PipStep = 1.0; // Step between pips 间隔多少个点加仓
extern double PipStepExponent = 1; // Exponent 每次加仓的间隔的点数与上一单的百分比
extern int 固定止盈点数 = 100; //固定止盈点数
extern int buy固定止损点数 = 1000;
extern int sell固定止损点数 = 1000;
extern string 移动止盈参数设置 = ">>> 移动止盈参数设置";
extern bool 是否分批止盈 = false;
extern bool 是否移动止盈 = true;
extern double TrailStart = 100; // 设置多少个点锁住利润，并且开始执行移动止盈
extern double TrailGap = 50; // 当前价格与新止损点之间的距离
extern double TrailStep = 50; // 在修改交易之前增加新的SL点
int 移动止盈点数 = 1000;
extern string 分批止盈百分比 = ">>> Close order settings";
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
extern double ProfitPersent = 30; // Percent to close(10...50) // percent to close
extern double SecondProfitPersent= 50; // Percent to close previous last order
string 双均线参数设置 = ">>> 双均线，形成均线系统，用于趋势判断";
extern int iMA_Period_5 = 5;
extern int iMA_Period_10 = 10;
string 当前价格与均线的距离 = ">>> 当前价格与均线的距离，用于趋势判断";
double MACD_Down = 0;
double MACD_Up = 0;
extern int iMA_Period = 5;
extern int iMA_OpenDistance = 1;//价格与均线的距离
//---- indicator parameters
string Envelopes指标参数 = ">>> Envelopes指标参数";
int MA_Period=20; //均线周期26比较适合做高抛低吸
int MA_Shift=1; //转换
//extern int MA_Method_m = 2;
//extern int Applied_Price=0;
ENUM_MA_METHOD MA_Method_m = 0; //0:简单平均线 1：指数平均线 2：平滑平均线 3：线形权数
ENUM_APPLIED_PRICE Applied_Price = 0; //0：应用到收盘价,1:开盘价,2:最高价，3：最低价,4:中间价（HL/2）,5:典型价（HLC/3），6：强制平仓价（HLCC/4）
double Deviation=0.25; //偏差百分比%
ENUM_TIMEFRAMES KDownOrUpTimeFrame = PERIOD_H4; //阴线阳线交易周期
//-------------------------------------------------------
//---- input parameters
string Stoch指标参数 = ">>> Stoch指标参数";
bool show_KD_cross = true;
bool show_K_OBOScross = false;
bool show_D_OBOScross = false;
bool SoundON = false;
bool EmailON = false;
int KPeriod = 5;
int DPeriod = 3;
int Slowing = 3;
int MA_Method = 0; // SMA 0, EMA 1, SMMA 2, LWMA 3
int PriceField = 0; // Low/High 0, Close/Close 1
int OverBoughtLevel = 80;
int OverSoldLevel = 20;
//stoch指标参数设置
int K_Period = 5;
int D_Period = 3;
int Stoch_Slowing = 3;
//===================================================================================================================================================
int i = 0;
int TimePrev = 0;
int vDigits;
int OrderSended = 0;
int TotalBuyOrders = 0, TotalSellOrders = 0;
int Lpos, Lpos1, Cpos;
double Spread;
double mPipStep;
double vPoint;
double PriceTarget, AveragePrice, LastBuyPrice, LastSellPrice;
double BuySummLot,SellSummLot,TotalProfitBuy,TotalProfitSell;
double BLot, SLot;
double Cprofit, Lprofit, Lprofit1, PrcCL;
string LastOrderComment = "";
string BComment, SComment;
int TradeSignal = 0;
//===================================================================================================================================================
int init()
{
vPoint = Point;
vDigits = Digits;
TimePrev = Time[0];
Spread = NormalizeDouble(MarketInfo(Symbol(), MODE_SPREAD),vDigits)*vPoint;
int DcD = 1;
if((vDigits == 5)||(vDigits == 3))
DcD = 10;
PipStep *= DcD;
固定止盈点数 *= DcD;
//固定止损点数 *= DcD;
iMA_OpenDistance *= DcD;
移动止盈点数 *= DcD;
if(显示到图表上)
DrawInfo();
return(0);
}
//===================================================================================================================================================
//===================================================================================================================================================
int deinit()
{
ObjectDelete("CurrTime");
ObjectDelete("BuyZeroLevel");
ObjectDelete("BuyAveragePrice");
ObjectDelete("SellZeroLevel");
ObjectDelete("SellAveragePrice");
Comment("QQ:741506920");
return(0);
}
//===================================================================================================================================================
//===================================================================================================================================================
double buystop,sellstop,StopLoss,orderBuySL,orderSellSL;
int start()
{
/*
if (!IsDemo()) {
Alert("你的账号:" + AccountNumber() + " 没有授权交易此EA，请联系开发者QQ：741506920 获取EA认证方可使用。");
return (0);
}
*/
if(显示到图表上)
DrawInfo();
// checking new bar
if(TimePrev == Time[0] && CheckNewBar == true)
return(0);
//Check new bar...first orders of the series only according to new bars
//if (TimePrev == Time[0]) return(0);
TimePrev = Time[0];
TradeSignal = GetSignal();
TotalSellOrders = CountOfOrders(MagicNumberSell);
TotalBuyOrders = CountOfOrders(MagicNumberBuy);
//使用前面那根K线的最高价最多，最低价做空
sellstop = NormalizeDouble(iHigh(NULL,0,1),Digits)*ChaPoint;
buystop = NormalizeDouble(iLow (NULL,0,1),Digits)*ChaPoint;
//if(isUseFloatStopLoss){
StopLoss = NormalizeDouble((sellstop - buystop),Digits);
//}
// New buy series ...
if(TotalBuyOrders == 0 && 允许买 && TradeSignal > 0
//&& TotalSellOrders == 0
)
{
//buy固定止损点数 = StopLoss;
//buy固定止损点数 = 1000;
SendMarketOrder(OP_BUY, 首单持仓手数(), 固定止盈点数, buy固定止损点数, MagicNumberBuy, TimeCurrent() + "|");
//过滤一下频繁在上一个位置止盈之后，再次在同一个位置入场的问题，
//如果做多，在止盈之后，应该让下一次入场的时候，让入场价位在止盈的下方，做空反之。
//SendMarketOrderSL(OP_BUY, 首单持仓手数(), 固定止盈点数, buystop, MagicNumberBuy, TimeCurrent() + "|");
}
// New sell series ...
if(TotalSellOrders == 0 && 允许卖 && TradeSignal < 0
//&& TotalBuyOrders == 0
)
{
//sell固定止损点数 = StopLoss;
//sell固定止损点数 = 1000;
SendMarketOrder(OP_SELL, 首单持仓手数(), 固定止盈点数, sell固定止损点数, MagicNumberSell, TimeCurrent() + "|");
//SendMarketOrderSL(OP_SELL, 首单持仓手数(), 固定止盈点数, sellstop, MagicNumberSell, TimeCurrent() + "|");
}
//做多加码-------------------------------------------------------------------------------------------------------------------------------------------------
// New buy orders
if(TotalBuyOrders > 0 && TotalBuyOrders < 最大交易数
//&& KDownUP == -1
//&& MACD_Signal == 1
//&& rsiaddSignal == 1
//&& rsiSignal == 1
//&& MaBidDiffSignal_240 == -1
//&& StochasticCrossSignal_240 == 1
//&& MaBidDiffSignal == 1
//&& StochasticSignal_多周期共振 == 1
//&& TradeSignal == 1
)
{
OrderSended = -1;
LastBuyPrice = FindLastOrderParameter(MagicNumberBuy, "price");
if(LastBuyPrice - Ask >= GetPipstepForStep(TotalBuyOrders + 1) * vPoint)
{
BLot = GetLotForStep(MagicNumberBuy, TotalBuyOrders);
BComment = StringSubstr(LastOrderComment, 0, StringFind(LastOrderComment, "|", 0)) + "|";
OrderSended = SendMarketOrder(OP_BUY, BLot, 固定止盈点数, buy固定止损点数, MagicNumberBuy, BComment);
}
}
//做空加码-------------------------------------------------------------------------------------------------------------------------------------------------
// New sell orders
if(TotalSellOrders > 0 && TotalSellOrders < 最大交易数
//&& KDownUP == 1
//&& MACD_Signal == -1
//&& rsiaddSignal == -1
//&& rsiSignal == -1
//&& MaBidDiffSignal_240 == 1
//&& StochasticCrossSignal_240 == -1
//&& MaBidDiffSignal == -1
//&& StochasticSignal_多周期共振 == -1
//&& TradeSignal == -1
)
{
OrderSended = -1;
LastSellPrice = FindLastOrderParameter(MagicNumberSell, "price");
if(Bid - LastSellPrice >= GetPipstepForStep(TotalSellOrders + 1) * vPoint)
{
SLot = GetLotForStep(MagicNumberSell, TotalSellOrders);
SComment = StringSubstr(LastOrderComment, 0, StringFind(LastOrderComment, "|", 0)) + "|";
OrderSended = SendMarketOrder(OP_SELL, SLot, 固定止盈点数, sell固定止损点数, MagicNumberSell, SComment);
}
}
//是否分批止盈，默认是整体跟随MACD金叉死叉进行全部平仓
if(是否分批止盈)
{
//持有多个单的时候，判断分批止盈，止盈目标1---止盈目标2
CheckOverlapping();
//检查盈利情况，并画出持仓均价线，止盈目标
//CheckTakeProfit();
}
//检查盈利情况，并画出持仓均价线，止盈目标
CheckTakeProfit();
//检查盈利情况，并画出持仓均价线，止盈目标
//CheckTakeProfit();
if(是否移动止盈)
{
//if ((TotalProfitSell + TotalProfitBuy) > 0){
MoveTakeProfit();
//}
//MoveTakeProfit();
}
return(0);
}
//===================================================================================================================================================
//===================================================================================================================================================
void CheckTakeProfit()
{
//BUY
TotalBuyOrders = CountOfOrders(MagicNumberBuy);
PriceTarget = 0;
AveragePrice = 0;
if(TotalBuyOrders > 0)
{
PriceTarget = FindFirstOrderParameter(MagicNumberBuy, "price") + 固定止盈点数*vPoint;
AveragePrice = CalculateAveragePrice(MagicNumberBuy);
// 新增代码
firstOrderStopLoss = FindFirstOrderParameter(MagicNumberBuy, "stoploss");
for(i = 0; i < OrdersTotal(); i++)
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumberBuy)
if(NormalizeDouble(OrderTakeProfit(),vDigits) != NormalizeDouble(PriceTarget,vDigits))
ModifyTakeProfit(PriceTarget);
}
if(DrawAveragePrice == true)
{
if(AveragePrice == 0)
{
if(ObjectFind("BuyZeroLevel") != -1)
ObjectDelete("BuyZeroLevel");
if(ObjectFind("BuyAveragePrice") != -1)
ObjectDelete("BuyAveragePrice");
}
else
{
if(ObjectFind("BuyZeroLevel") == -1)
{
ObjectCreate("BuyZeroLevel",OBJ_HLINE, 0, 0, AveragePrice);
ObjectSet("BuyZeroLevel", OBJPROP_COLOR, Blue);
ObjectSet("BuyZeroLevel", OBJPROP_STYLE, DRAW_SECTION);
}
else
ObjectSet("BuyZeroLevel", OBJPROP_PRICE1, AveragePrice);
if(ObjectFind("BuyAveragePrice") == -1)
{
ObjectCreate("BuyAveragePrice",OBJ_HLINE, 0, 0, AveragePrice + 固定止盈点数*vPoint);
ObjectSet("BuyAveragePrice", OBJPROP_COLOR, Blue);
ObjectSet("BuyAveragePrice", OBJPROP_STYLE, DRAW_LINE);
}
else
ObjectSet("BuyAveragePrice", OBJPROP_PRICE1, AveragePrice + 固定止盈点数*vPoint);
}
}
//<_BUY
//SELL
PriceTarget = 0;
AveragePrice = 0;
TotalSellOrders = CountOfOrders(MagicNumberSell);
if(TotalSellOrders > 0)
{
PriceTarget = FindFirstOrderParameter(MagicNumberSell, "price") - 固定止盈点数*vPoint;
AveragePrice = CalculateAveragePrice(MagicNumberSell);
// 新增代码
firstOrderStopLoss = FindFirstOrderParameter(MagicNumberSell, "stoploss");
for(i = 0; i < OrdersTotal(); i++)
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumberSell)
if(NormalizeDouble(OrderTakeProfit(),vDigits) != NormalizeDouble(PriceTarget,vDigits))
ModifyTakeProfit(PriceTarget);
}
if(DrawAveragePrice == true)
{
if(AveragePrice == 0)
{
if(ObjectFind("SellZeroLevel") != -1)
ObjectDelete("SellZeroLevel");
if(ObjectFind("SellAveragePrice") != -1)
ObjectDelete("SellAveragePrice");
}
else
{
if(ObjectFind("SellZeroLevel") == -1)
{
ObjectCreate("SellZeroLevel",OBJ_HLINE, 0, 0, AveragePrice);
ObjectSet("SellZeroLevel", OBJPROP_COLOR, Red);
ObjectSet("SellZeroLevel", OBJPROP_STYLE, DRAW_SECTION);
}
else
ObjectSet("SellZeroLevel", OBJPROP_PRICE1, AveragePrice);
if(ObjectFind("SellAveragePrice") == -1)
{
ObjectCreate("SellAveragePrice",OBJ_HLINE, 0, 0, AveragePrice - 固定止盈点数*vPoint);
ObjectSet("SellAveragePrice", OBJPROP_COLOR, Red);
ObjectSet("SellAveragePrice", OBJPROP_STYLE, DRAW_LINE);
}
else
ObjectSet("SellAveragePrice", OBJPROP_PRICE1, AveragePrice - 固定止盈点数*vPoint);
}
}
//<_SELL
}
//===================================================================================================================================================
//===================================================================================================================================================
double CalculateAveragePrice(int mNumber)
{
AveragePrice = 0;
double Count = 0;
for(i = 0; i < OrdersTotal(); i++)
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
if(OrderSymbol() == Symbol() && OrderMagicNumber() == mNumber)
if(OrderType() == OP_BUY || OrderType() == OP_SELL)
{
AveragePrice += OrderOpenPrice() * OrderLots();
Count += OrderLots();
}
if(AveragePrice > 0 && Count > 0)
return(NormalizeDouble(AveragePrice / Count, vDigits));
else
return(0);
}
//===================================================================================================================================================
//获取当前EA的订单数量
int CountOfOrders(int mNumber)
{
int count = 0;
for(i = 0; i < OrdersTotal(); i++)
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
if((OrderSymbol() == Symbol()) && (OrderMagicNumber() == mNumber))
if((OrderType() == OP_SELL) || (OrderType() == OP_BUY))
count++;
return(count);
}
//===================================================================================================================================================
//===================================================================================================================================================
//根据加仓的位置，分配做单仓位
double GetLotForStep(int mNumber, int OrdCount)
{
double CurrLot = 0;
double LastOrderLot = FindLastOrderParameter(mNumber, "lot");
if(使用自动手数 == true)
{
if(LastOrderLot != 0)
{
CurrLot = NormalizeDouble(LastOrderLot + NormalizeDouble(AccountEquity() * 自动手数Increment/10000, 2)*OrdCount, 2);
}
}
else
{
if(LastOrderLot != 0)
{
//CurrLot = NormalizeDouble(LastOrderLot + 加仓额外手数*OrdCount, 2);
CurrLot = NormalizeDouble(LastOrderLot + 加仓额外手数*OrdCount, 2);
}
}
if(CurrLot > 最大手数)
CurrLot = 最大手数;
if(CurrLot < 开始手数)
CurrLot = 开始手数;
if(CurrLot == 0)
CurrLot = 开始手数;
return(CurrLot);
}
//===================================================================================================================================================
//===================================================================================================================================================
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
double 首单持仓手数()
{
double FirstLot = 0;
if(使用自动手数 == true)
{
FirstLot = NormalizeDouble(AccountEquity() * 自动手数/10000, 2);
}
else
{
FirstLot = 开始手数;
}
if(FirstLot > 最大手数)
FirstLot = 最大手数;
if(FirstLot < 开始手数)
FirstLot = 开始手数;
return(FirstLot);
}
//返回第一个单子的相关数据，price，ticket，lot，profit
double FindFirstOrderParameter(int mNumber, string ParamName)
{
int mOrderTicket = 0;
double mOrderPrice = 0;
double mOrderLot = 0;
double mOrderProfit = 0;
double mOrderStopLoss = 0;
int PrevTicket = 0;
int CurrTicket = 0;
for(i = OrdersTotal() - 1; i >= 0; i--)
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
if(OrderSymbol() == Symbol() && OrderMagicNumber() == mNumber)
{
CurrTicket = OrderTicket();
if(CurrTicket < PrevTicket || PrevTicket == 0)
{
PrevTicket = CurrTicket;
mOrderPrice = OrderOpenPrice();
mOrderTicket = OrderTicket();
mOrderLot = OrderLots();
mOrderProfit = OrderProfit() + OrderSwap() + OrderCommission();
mOrderStopLoss = OrderStopLoss();
}
}
if(ParamName == "price"){
return(mOrderPrice);
}
else if(ParamName == "ticket"){
return(mOrderTicket);
}
else if(ParamName == "lot"){
return(mOrderLot);
}
else if(ParamName == "profit"){
return(mOrderProfit);
}
else if(ParamName == "stoploss"){
return(mOrderStopLoss);
}
return(0);
}
//===================================================================================================================================================
//===================================================================================================================================================
//返回最后一个单子的相关数据，price，ticket，lot，profit
double FindLastOrderParameter(int mNumber, string ParamName)
{
int mOrderTicket = 0;
double mOrderPrice = 0;
double mOrderLot = 0;
double mOrderProfit = 0;
int PrevTicket = 0;
int CurrTicket = 0;
for(i = OrdersTotal() - 1; i >= 0; i--)
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
if(OrderSymbol() == Symbol() && OrderMagicNumber() == mNumber)
{
CurrTicket = OrderTicket();
if(CurrTicket > PrevTicket)
{
PrevTicket = CurrTicket;
mOrderPrice = OrderOpenPrice();
mOrderTicket = OrderTicket();
mOrderLot = OrderLots();
mOrderProfit = OrderProfit() + OrderSwap() + OrderCommission();
LastOrderComment = OrderComment();
}
}
if(ParamName == "price")
return(mOrderPrice);
else
if(ParamName == "ticket")
return(mOrderTicket);
else
if(ParamName == "lot")
return(mOrderLot);
else
if(ParamName == "profit")
return(mOrderProfit);
return(0);
}
//===================================================================================================================================================
//===================================================================================================================================================
double GetClosedProfit(int mNumber)
{
double ClosedProfit = 0;
for(i = OrdersHistoryTotal(); i > 0; i--)
if(OrderSelect(i, SELECT_BY_POS, MODE_HISTORY))
if(OrderSymbol() == Symbol() && OrderMagicNumber() == mNumber)
if(StringSubstr(LastOrderComment, 0, StringFind(LastOrderComment, "|", 0)) == StringSubstr(OrderComment(), 0, StringFind(OrderComment(), "|", 0)))
ClosedProfit = ClosedProfit + OrderProfit();
return(ClosedProfit);
}
//===================================================================================================================================================
//===================================================================================================================================================
double firstOrderStopLoss = 0;
bool ModifyTakeProfit(double takeprofit)
{
while(!IsStopped())
{
if(IsTradeContextBusy())
{
Sleep(3000);
continue;
}
if(!IsTradeAllowed())
{
return(False);
}
if(!OrderModify(OrderTicket(), OrderOpenPrice(), NormalizeDouble(firstOrderStopLoss,vDigits), NormalizeDouble(takeprofit,vDigits), 0, Yellow))
{
int Err = GetLastError();
Print("!!! Error(",Err,"): ",ErrorDescription(Err));
return(False);
}
else
{
break;
}
}
return(True);
}
//===================================================================================================================================================
//===================================================================================================================================================
//发送现价买入或者卖出的指令
int SendMarketOrder(int Type, double Lots, int TP, int SL, int Magic, string Cmnt, double OpenPrice = 0, string mSymbol = "")
{
double Price, Take, Stop;
int Ticket, Color, Err;
int ErrorCount = 0;
while(!IsStopped())
{
if(ErrorCount > 5)
return(0);
if(!IsConnected())
{
ErrorCount = ErrorCount + 1;
Print("No connection with server!");
Sleep(1000);
}
if(IsTradeContextBusy())
{
Sleep(3000);
continue;
}
switch(Type)
{
case OP_BUY:
if(mSymbol == "")
Price = NormalizeDouble(Ask, vDigits);
else
Price = NormalizeDouble(MarketInfo(mSymbol, MODE_ASK), vDigits);
Take = IIFd(TP == 0, 0, NormalizeDouble(Price + TP * vPoint, vDigits));
Stop = IIFd(SL == 0, 0, NormalizeDouble(Price - SL * vPoint, vDigits));
Color = Blue;
break;
case OP_SELL:
if(mSymbol == "")
Price = NormalizeDouble(Bid, vDigits);
else
Price = NormalizeDouble(MarketInfo(mSymbol, MODE_BID), vDigits);
Price = NormalizeDouble(Bid, Digits);
Take = IIFd(TP == 0, 0, NormalizeDouble(Price - TP * vPoint, vDigits));
Stop = IIFd(SL == 0, 0, NormalizeDouble(Price + SL * vPoint, vDigits));
Color = Red;
break;
default:
return(-1);
}
if(IsTradeAllowed())
{
if(mSymbol == "")
Ticket = OrderSend(Symbol(), Type, Lots, Price, 2*Spread, Stop, Take, Cmnt, Magic, 0, Color);
else
Ticket = OrderSend(mSymbol, Type, Lots, Price, 2*Spread, Stop, Take, Cmnt, Magic, 0, Color);
if(Ticket < 0)
{
Err = GetLastError();
if(Err == 4 || /* SERVER_BUSY */
Err == 129 || /* INVALID_PRICE */
Err == 135 || /* PRICE_CHANGED */
Err == 137 || /* BROKER_BUSY */
Err == 138 || /* REQUOTE */
Err == 146 || /* TRADE_CONTEXT_BUSY */
Err == 136) /* OFF_QUOTES */
{
Sleep(3000);
continue;
}
else
{
break;
}
}
break;
}
else
{
break;
}
}
return(Ticket);
}
//发送现价买入或者卖出的指令
int SendMarketOrderSL(int Type, double Lots, int TP, int SL, int Magic, string Cmnt, double OpenPrice = 0, string mSymbol = "")
{
double Price, Take, Stop;
int Ticket, Color, Err;
int ErrorCount = 0;
while(!IsStopped())
{
if(ErrorCount > 5)
return(0);
if(!IsConnected())
{
ErrorCount = ErrorCount + 1;
Print("No connection with server!");
Sleep(1000);
}
if(IsTradeContextBusy())
{
Sleep(3000);
continue;
}
switch(Type)
{
case OP_BUY:
if(mSymbol == "")
Price = NormalizeDouble(Ask, vDigits);
else
Price = NormalizeDouble(MarketInfo(mSymbol, MODE_ASK), vDigits);
Take = IIFd(TP == 0, 0, NormalizeDouble(Price + TP * vPoint, vDigits));
//Stop = IIFd(SL == 0, 0, NormalizeDouble(Price - SL * vPoint, vDigits));
Stop = IIFd(SL == 0, 0, NormalizeDouble(SL * vPoint, vDigits));
Color = Blue;
break;
case OP_SELL:
if(mSymbol == "")
Price = NormalizeDouble(Bid, vDigits);
else
Price = NormalizeDouble(MarketInfo(mSymbol, MODE_BID), vDigits);
Price = NormalizeDouble(Bid, Digits);
Take = IIFd(TP == 0, 0, NormalizeDouble(Price - TP * vPoint, vDigits));
//Stop = IIFd(SL == 0, 0, NormalizeDouble(Price + SL * vPoint, vDigits));
Stop = IIFd(SL == 0, 0, NormalizeDouble(SL * vPoint, vDigits));
Color = Red;
break;
default:
return(-1);
}
if(IsTradeAllowed())
{
if(mSymbol == "")
Ticket = OrderSend(Symbol(), Type, Lots, Price, 2*Spread, Stop, Take, Cmnt, Magic, 0, Color);
else
Ticket = OrderSend(mSymbol, Type, Lots, Price, 2*Spread, Stop, Take, Cmnt, Magic, 0, Color);
if(Ticket < 0)
{
Err = GetLastError();
if(Err == 4 || /* SERVER_BUSY */
Err == 129 || /* INVALID_PRICE */
Err == 135 || /* PRICE_CHANGED */
Err == 137 || /* BROKER_BUSY */
Err == 138 || /* REQUOTE */
Err == 146 || /* TRADE_CONTEXT_BUSY */
Err == 136) /* OFF_QUOTES */
{
Sleep(3000);
continue;
}
else
{
break;
}
}
break;
}
else
{
break;
}
}
return(Ticket);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
double IIFd(bool condition, double ifTrue, double ifFalse)
{
if(condition)
return(ifTrue);
else
return(ifFalse);
}
//===================================================================================================================================================
double 最大回撤 = 0;
double 多单最大回撤 = 0;
double 空单最大回撤 = 0;
double 多空之和最大回撤 = 0;
double 最大回撤率 = 0;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void DrawInfo()
{
BuySummLot = 0;
TotalProfitBuy = 0;
BuySummLot = getBuySummLot();
TotalProfitBuy = getTotalProfitBuy();
//double ClosedBuyProfit = GetClosedProfit(MagicNumberBuy);
SellSummLot = 0;
TotalProfitSell = 0;
SellSummLot = getSellSummLot();
TotalProfitSell = getTotalProfitSell();
//double ClosedSellProfit = GetClosedProfit(MagicNumberSell);
//BUY
TotalBuyOrders = CountOfOrders(MagicNumberBuy);
AveragePrice =0;
if(TotalBuyOrders > 0)
{
AveragePrice = CalculateAveragePrice(MagicNumberBuy);
}
else
{
//SELL
TotalSellOrders = CountOfOrders(MagicNumberSell);
if(TotalSellOrders > 0)
{
AveragePrice = CalculateAveragePrice(MagicNumberSell);
}
}
double 余额 = DoubleToStr(AccountBalance(), 2);
if(TotalProfitBuy < 0 && 最大回撤 <= 0 && TotalProfitBuy <= 最大回撤)
{
最大回撤 = TotalProfitBuy ;
最大回撤率 = DoubleToStr(最大回撤/余额*100, 2);
}
if(TotalProfitSell < 0 && 最大回撤 <= 0 && TotalProfitSell <= 最大回撤)
{
最大回撤 = TotalProfitSell ;
最大回撤率 = DoubleToStr(最大回撤/余额*100, 2);
}
/*
if(多单最大回撤<= 0 && 空单最大回撤 <= 0 && (多单最大回撤 + 空单最大回撤) < 多空之和最大回撤
|| 多单最大回撤>= 0 && 空单最大回撤 <= 0 && (多单最大回撤 + 空单最大回撤) < 多空之和最大回撤
|| 多单最大回撤<= 0 && 空单最大回撤 >= 0 && (多单最大回撤 + 空单最大回撤) < 多空之和最大回撤
)
{
多空之和最大回撤 = 多单最大回撤 + 空单最大回撤;
}
最大回撤率 = DoubleToStr(多空之和最大回撤/余额*100, 2);
*/
string signal = "";
if(TradeSignal == -1)
{
signal = "当前趋势偏空头！";
}
else
if(TradeSignal == 1)
{
signal = "当前趋势偏多头！";
}
else
{
signal = "当前暂时无信号！";
}
string comment ="\n"
+ "信号：" + l_text_4
+ "\n"+ "\n"
+ signal
+ "\n"
+ "当前时间: " + TimeToStr(TimeCurrent(), TIME_DATE|TIME_SECONDS)
+ "\n"
+ "--------------------------------------------------------------"
+ "\n"
+ ">>> 做空: " + TotalSellOrders + " 单 ( " + SellSummLot + " 手 ) ==> 利润: " + TotalProfitSell
//+ "\n"+ "\n"
//+ ">>> Profit Taken: "+ClosedSellProfit
+ "\n"
+ "--------------------------------------------------------------"
+ "\n"
+ ">>> 做多: " + TotalBuyOrders + " 单 ( " + BuySummLot + " 手 ) ==> 利润: " + TotalProfitBuy
//+ "\n"+ "\n"
//+ ">>> Profit taken : "+ ClosedBuyProfit
+ "\n"
+ "--------------------------------------------------------------"
+ "\n"
+ ">>> 当前持仓均价： "+ AveragePrice
+ "\n" + "\n"
+ ">>> 最大回撤：" + 最大回撤 +"美元 || 浮亏占余额百分比( "+最大回撤率+" )%"
+ "\n" + "\n"
+ "-------------------- 资金状况 ------------------------------"
+ "\n"+ "\n"
+ "余额: " + DoubleToStr(AccountBalance(), 2)
+ "\n" + "\n"
+ "净值: " + DoubleToStr(AccountEquity(), 2)
+ "\n"+ "\n"
//+ "------------------- 保证金信息 -----------------------------"
//+ "\n"
//+ "可用预付款: " + DoubleToStr(AccountFreeMargin(), 2)
//+ "\n" + "\n"
//+ "已用预付款: " + DoubleToStr(AccountMargin(), 2)
//+ "\n"
+ "--------------------------------------------------------------"
+ "\n";
Comment(comment);
}
//获取当前多单持仓手数
double getBuySummLot()
{
double mBuySummLot = 0;
for(i=OrdersTotal(); i>=0; i--)
{
if(OrderSelect(i,SELECT_BY_POS, MODE_TRADES) && OrderSymbol() == Symbol() && (OrderMagicNumber()==MagicNumberBuy))
{
mBuySummLot += OrderLots();
}
}
return mBuySummLot;
}
//获取当前空单持仓手数
double getSellSummLot()
{
double mSellSummLot = 0;
for(i=OrdersTotal(); i>=0; i--)
{
if(OrderSelect(i,SELECT_BY_POS, MODE_TRADES) && OrderSymbol() == Symbol() && (OrderMagicNumber()==MagicNumberSell))
{
mSellSummLot += OrderLots();
}
}
return mSellSummLot;
}
//获取当前多单获利金额
double getTotalProfitBuy()
{
double mTotalProfitBuy = 0;
for(i=OrdersTotal(); i>=0; i--)
{
if(OrderSelect(i,SELECT_BY_POS, MODE_TRADES) && OrderSymbol() == Symbol() && (OrderMagicNumber()==MagicNumberBuy))
{
mTotalProfitBuy += OrderProfit() + OrderCommission() + OrderSwap();
}
}
return mTotalProfitBuy;
}
//获取当前空单获利金额
double getTotalProfitSell()
{
double mTotalProfitSell = 0;
for(i=OrdersTotal(); i>=0; i--)
{
if(OrderSelect(i,SELECT_BY_POS, MODE_TRADES) && OrderSymbol() == Symbol() && (OrderMagicNumber()==MagicNumberSell))
{
mTotalProfitSell += OrderProfit() + OrderCommission() + OrderSwap();
}
}
return mTotalProfitSell;
}
//===================================================================================================================================================
//===================================================================================================================================================
void ShowCurrentTime()
{
int min,sec;
min = Time[0] + Period()*60 - CurTime();
sec = min%60;
min = (min - min%60)/60;
if(ObjectFind("CurrTime") != 0)
ObjectCreate("CurrTime", OBJ_TEXT, 0, Time[0], Close[0]);
else
ObjectMove("CurrTime", 0, Time[0], Close[0]);
ObjectSetText("CurrTime", "<" + min + ":" + sec, 14, "Verdana", Black);
}
//===================================================================================================================================================
//===================================================================================================================================================
void CheckOverlapping()
{
//BUY--->
TotalBuyOrders = CountOfOrders(MagicNumberBuy);
if(TotalBuyOrders >= 2)
{
Lpos = 0;
Cpos = 0;
Lprofit = 0;
Cprofit = 0;
Lpos = LidingProfitOrder(MagicNumberBuy);
Cpos = CloseProfitOrder(MagicNumberBuy);
if(Lprofit > 0 && Lprofit1 <= 0)
{
if(Lprofit + Cprofit > 0 && (Lprofit + Cprofit)*100/Lprofit > ProfitPersent)
{
Lpos1 = 0;
CloseSelectOrder(MagicNumberBuy);
}
}
else
if(Lprofit > 0 && Lprofit1 > 0)
{
if(Lprofit + Lprofit1 + Cprofit > 0 && (Lprofit + Lprofit1 + Cprofit)*100/(Lprofit + Lprofit1) > SecondProfitPersent)
CloseSelectOrder(MagicNumberBuy);
}
}
//<---BUY
//SELL--->
TotalSellOrders = CountOfOrders(MagicNumberSell);
if(TotalSellOrders >= 2)
{
Lpos = 0;
Cpos = 0;
Lprofit = 0;
Cprofit = 0;
Lpos = LidingProfitOrder(MagicNumberSell);
Cpos = CloseProfitOrder(MagicNumberSell);
if(Lprofit > 0 && Lprofit1 <= 0)
{
if(Lprofit + Cprofit > 0 && (Lprofit + Cprofit)*100/Lprofit > ProfitPersent)
{
Lpos1 = 0;
CloseSelectOrder(MagicNumberSell);
}
}
if(Lprofit > 0 && Lprofit1 > 0)
{
if(Lprofit + Lprofit1 + Cprofit > 0 && (Lprofit + Lprofit1 + Cprofit)*100/(Lprofit + Lprofit1) > SecondProfitPersent)
CloseSelectOrder(MagicNumberSell);
}
}
//<---SELL
}
//======================================== Most profitable order =======================================
int LidingProfitOrder(int mNumber)
{
Lprofit1 = 0;
Lpos1 = 0;
int TotalOrders = CountOfOrders(mNumber);
double profit = 0;
int Pos = 0;
for(i = 0; i < OrdersTotal(); i++)
{
if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
{
if((OrderSymbol() == Symbol()) && (OrderMagicNumber() == mNumber))
{
if(OrderType() == OP_SELL || OrderType() == OP_BUY)
{
profit = OrderProfit();
Pos = OrderTicket();
if(profit > 0 && profit > Lprofit)
{
// Previous value
Lprofit1 = Lprofit;
Lpos1 = Lpos;
// Maximum value
Lprofit = profit;
Lpos = Pos;
}
}
}
}
}
return (Lpos);
}
//======================================== Least Profitable Order =======================================
int CloseProfitOrder(int mNumber)
{
double profit = 0;
int Pos = 0;
for(int trade = OrdersTotal() - 1; trade >= 0; trade--)
{
if(OrderSelect(trade, SELECT_BY_POS, MODE_TRADES))
{
if((OrderSymbol() == Symbol()) && (OrderMagicNumber() == mNumber))
{
if(OrderType() == OP_SELL || OrderType() == OP_BUY)
{
profit = OrderProfit();
Pos = OrderTicket();
if(profit < 0 && profit < Cprofit)
{
Cprofit = profit;
Cpos = Pos;
}
}
}
}
}
return (Cpos);
}
//========================================== Closing Orders ===============================================
int CloseSelectOrder(int mNumber)
{
int error = 0;
int error1 = 0;
int error2 = 0;
int Result = 0;
// ---------------------- Last Order -----------------------
while(error1 == 0)
{
RefreshRates();
i = OrderSelect(Lpos, SELECT_BY_TICKET, MODE_TRADES);
if(i != 1)
{
Print("Error! Not possible to select most profitable order . Operation cancelled.");
return (0);
}
if((OrderSymbol() == Symbol()) && (OrderMagicNumber() == mNumber))
{
if(OrderType() == OP_BUY)
{
error1 = (OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Bid, Digits), Spread, Blue));
if(error1 == 1)
{
Print("Leading Order closed successfully");
Sleep(500);
}
else
{
Print("Error closing leading order, Repeat Operation. ");
}
}
// -----------------------------------------------------
if(OrderType() == OP_SELL)
{
error1 = (OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Ask, Digits), Spread, Red));
if(error1 == 1)
{
Print("Leading Order closed successfully");
Sleep(500);
}
else
{
Print("Error closing leading order, Repeat Operation. ");
}
}
}
}
//---------------------- Previous Last -----------------------
if(Lpos1 != 0)
{
while(error2 == 0)
{
RefreshRates();
i = OrderSelect(Lpos1, SELECT_BY_TICKET, MODE_TRADES);
if(i != 1)
{
Print("Error! Not possible to select previous most profitable order . Operation cancelled.");
return (0);
}
if((OrderSymbol() == Symbol()) && (OrderMagicNumber() == mNumber))
{
if(OrderType() == OP_BUY)
{
error2 = (OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Bid, Digits), Spread, Blue));
if(error2 == 1)
{
Print("Previous leading order closed successfully");
Sleep(500);
}
else
{
Print("Error closing previous leading order, Repeat Operation. ");
}
}
//-----------------------------------------------------
if(OrderType() == OP_SELL)
{
error2 = (OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Ask, Digits), Spread, Red));
if(error2 == 1)
{
Print("Previous leading order closed successfully");
Sleep(500);
}
else
{
Print("Error closing previous leading order, Repeat Operation. ");
}
}
}
}
}
//----------- Selected (Least profitable order ) -----------
while(error == 0)
{
RefreshRates();
i = OrderSelect(Cpos, SELECT_BY_TICKET, MODE_TRADES);
if(i != 1)
{
Print("Error! Not possible to select least profitable order. Operation cancelled");
return (0);
}
if((OrderSymbol() == Symbol()) && (OrderMagicNumber() == mNumber))
{
if(OrderType() == OP_BUY)
{
error = (OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Bid, Digits), Spread, Blue));
if(error == 1)
{
Print("Order closed successfully.");
Sleep(500);
}
}
// --------------------------------------------------
if(OrderType() == OP_SELL)
{
error = (OrderClose(OrderTicket(), OrderLots(), NormalizeDouble(Ask, Digits), Spread, Red));
if(error == 1)
{
Print("Order closed successfully.");
Sleep(500);
}
else
{
Print("Error during Order Close. Repeat operation. ");
}
}
}
}
Result = 1;
return (Result);
}
// added by momods //
//================================================= Calculate Net Profit ===============================================//
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
double NetProfit()
{
double netProfit = 0;
for(int i = OrdersTotal() - 1; i >= 0; i--)
{
OrderSelect(i, SELECT_BY_POS, MODE_TRADES);
if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumberBuy || OrderMagicNumber() == MagicNumberSell)
{
Print("Profit = ",netProfit);
if(OrderType() <= OP_SELL)
{
netProfit += OrderProfit();
}
}
}
return (netProfit);
}
//================================================== Close Orders ===================================================//
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int CloseOrder(int type)
{
for(int cnt = OrdersTotal()-1 ; cnt >= 0; cnt--)
{
OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES);
if(OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumberBuy
|| OrderSymbol() == Symbol() && OrderMagicNumber() == MagicNumberSell)
{
if(type == 0)
{
if(OrderType()==OP_BUY)
{
OrderClose(OrderTicket(),OrderLots(),Bid,2*Spread,Blue);
}
if(OrderType()==OP_SELL)
{
OrderClose(OrderTicket(),OrderLots(),Ask,2*Spread,Red);
}
}
else
if(type == -1)
{
if(OrderType()==OP_BUY)
{
OrderClose(OrderTicket(),OrderLots(),Bid,2*Spread,Blue);
}
}
else
if(type == 1)
{
if(OrderType()==OP_SELL)
{
OrderClose(OrderTicket(),OrderLots(),Ask,2*Spread,Red);
}
}
}
}
return(0);
}
//===================================================================================================================================================
//===================================================================================================================================================
double GetPipstepForStep(int CurrStep)
{
double CurrPipstep = NormalizeDouble(PipStep * MathPow(PipStepExponent,CurrStep), 0);
return(CurrPipstep);
}
//判断首次开单的条件入口======================================================
int MA_Signal_5_10 = 0;
int MA_Signal_5_300 = 0;
int MA_Signal_240 = 0;
int MA_Signal_60 = 0;
int MA_Signal_30 = 0;
int MA_Signal_15 = 0;
int MACD_Signal_240 = 0;
int MACD_Signal_60 = 0;
int MACD_Signal_30 = 0;
int MACD_Signal_15 = 0;
int MACD_Signal = 0;
int MACD加仓 = 0;
int MACD加仓_15 = 0;
int MACD加仓_30 = 0;
int MACD加仓_60 = 0;
int StochasticCrossSignal =0;
int StochasticCrossSignal_1440 = 0;
int StochasticCrossSignal_240 = 0;
int MaBidDiffSignal = 0;
int RsiSignal = 0;
int EnvSignal = 0;
int stochSignal = 0;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int GetSignal()
{
int signal = 0;
//signal = 策略_RSI信号();
//signal = 策略_MACD信号();
//signal = 策略_顺势指标信号();
signal = 策略_Stoch共振信号();
return signal;
}
//===================================================================================================================================================
//===================================================================================================================================================
int StochasticSignal_中线多周期共振 = 0;
int StochasticSignal_短线多周期共振 = 0;
int tempStochasticSignal = 0;
int tempStochasticSignal_240 = 0;
int 策略_Stoch共振信号(){
int All_Signal = 0;
StochasticSignal_中线多周期共振 = getStochasticSignal(PERIOD_D1,PERIOD_H4,PERIOD_H1);
//StochasticSignal_短线多周期共振 = getStochasticSignal(PERIOD_H4,PERIOD_M30,PERIOD_M5);
//MaBidDiffSignal = GetMABidDiffSignal(60);
int tempStochasticSignal = Stochastic_Cross_Signal(1440,true,false,false);
if(tempStochasticSignal != 0 && StochasticCrossSignal != tempStochasticSignal){
StochasticCrossSignal = tempStochasticSignal;
}
if(
//StochasticSignal_中线多周期共振 == 1
//&&
StochasticCrossSignal == 1
//&&
//StochasticSignal_短线多周期共振 == 1
//&& MaBidDiffSignal == -1
){
All_Signal = 1;
//checkCloseOrders(All_Signal);
}else if(
//StochasticSignal_中线多周期共振 == -1
//&&
StochasticCrossSignal == -1
//&&
//StochasticSignal_短线多周期共振 == -1
//&& MaBidDiffSignal == 1
){
All_Signal = -1;
//checkCloseOrders(All_Signal);
}
if(StochasticCrossSignal == 1 || StochasticCrossSignal == -1 ){
checkCloseOrders(StochasticCrossSignal);
}
return All_Signal ;
}
int rsiSignal = 0;
int rsiaddSignal = 0;
int KDownUP;
int MaBidDiffSignal_240;
int 策略_RSI信号()
{
int All_Signal = 0;
/*
int tempMACDSignal = MACD_Signal(0);
if(tempMACDSignal != 0 && MACD_Signal != tempMACDSignal){
MACD_Signal = tempMACDSignal;
}
int tempStochasticSignal = Stochastic_Cross_Signal(0,true,false,false);
if(tempStochasticSignal != 0 && StochasticCrossSignal != tempStochasticSignal){
StochasticCrossSignal = tempStochasticSignal;
}
int temp_MA = MA_DoubleAveraging_Signal(0);
if(temp_MA != 0 && MA_Signal != temp_MA){
MA_Signal = temp_MA;
}
*/
//MaBidDiffSignal = GetMABidDiffSignal(1440);
int tempStochasticSignal_1440 = Stochastic_Cross_Signal(1440,true,false,false);
if(tempStochasticSignal_1440 != 0 && StochasticCrossSignal_1440 != tempStochasticSignal_1440){
StochasticCrossSignal_1440 = tempStochasticSignal_1440;
}
//MaBidDiffSignal_240 = GetMABidDiffSignal(60);
//int tempMACDSignal = MACD_Signal(240);
//if(tempMACDSignal != 0 && MACD_Signal != tempMACDSignal){
// MACD_Signal = tempMACDSignal;
//}
int tempStochasticSignal_240 = Stochastic_Cross_Signal(240,true,false,false);
if(tempStochasticSignal_240 != 0 && StochasticCrossSignal_240 != tempStochasticSignal_240){
StochasticCrossSignal_240 = tempStochasticSignal_240;
}
//KDownUP = isPrevKDownOrUp(KDownOrUpTimeFrame);
/*
int temprsiSignal = RSI_Signal(30,70,60,6);
if(temprsiSignal != 0 && rsiSignal != temprsiSignal){
rsiSignal = temprsiSignal;
}
*/
//rsiSignal = RSI_Signal(30,70,60,6);
//rsiaddSignal = RSI_AddLots_Signal(60,6);
if(
StochasticCrossSignal_1440 == 1
//&&
//MaBidDiffSignal == 1
//&&
//rsiSignal == 1
//&&
//MaBidDiffSignal_240 == -1
//&&
//MACD_Signal == 1
&&
StochasticCrossSignal_240 == 1
//&&
//KDownUP == -1
)
{
All_Signal = 1;
}
else if(
StochasticCrossSignal_1440 == -1
//&&
//MaBidDiffSignal == -1
//&&
//rsiSignal == -1
//&&
//MaBidDiffSignal_240 == 1
//&&
//MACD_Signal == -1
&&
StochasticCrossSignal_240 == -1
//&&
//MaBidDiffSignal_240 == 1
//&&
//KDownUP == 1
)
{
All_Signal = -1;
}
if(StochasticCrossSignal_240 == 1 || StochasticCrossSignal_240 == -1 ){
checkCloseOrders(StochasticCrossSignal_240);
}
/*
if(MaBidDiffSignal == 1 && TotalProfitSell > 0 || MaBidDiffSignal == -1 && TotalProfitBuy > 0){
checkCloseOrders(MaBidDiffSignal);
}
else if ((TotalProfitSell + TotalProfitBuy) > 5){
checkCloseOrders(0);
}
*/
/*
if(MACD_Signal == 1 && MA_Signal_5_10 == 1 || MACD_Signal == -1 && MA_Signal_5_10 == -1 ){
checkCloseOrders(MACD_Signal);
}
if(MACD_Signal == 1 && TotalProfitSell > 0 || MACD_Signal == -1 && TotalProfitBuy > 0){
checkCloseOrders(MACD_Signal);
}
if( (TotalProfitSell + TotalProfitBuy ) > 1){
checkCloseOrders(0);
}
*/
return All_Signal ;
}
int 策略_MACD信号()
{
int All_Signal = 0;
/*
int temprsiSignal = RSI_Signal(30,70,6);
if(temprsiSignal != 0 && rsiSignal != temprsiSignal){
rsiSignal = temprsiSignal;
}
*/
MaBidDiffSignal = GetMABidDiffSignal();
//stochSignal = getStochasticSignal();
rsiaddSignal = RSI_AddLots_Signal(60,6);
rsiSignal = RSI_Signal(30,70,60,6);
if(
//stochSignal == 1
MaBidDiffSignal == 1
&&
rsiaddSignal == 1
)
{
All_Signal = 1;
}
else if(
//stochSignal == -1
MaBidDiffSignal == -1
&&
rsiaddSignal == -1
)
{
All_Signal = -1;
}
if( rsiSignal == 1 || rsiSignal == -1){
checkCloseOrders(rsiSignal);
}
/*
if( TotalSellOrders >0 && TotalBuyOrders >0 && (TotalProfitSell + TotalProfitBuy ) > 10){
checkCloseOrders(0);
}
*/
return All_Signal ;
}
int MA_Signal;
int 策略_顺势指标信号(){
int All_Signal = 0;
int temp_MA = MA_DoubleAveraging_Signal(0);
if(temp_MA != 0 && MA_Signal != temp_MA){
MA_Signal = temp_MA;
}
int tempMACDSignal = MACD_Signal(0);
if(tempMACDSignal != 0 && MACD_Signal != tempMACDSignal){
MACD_Signal = tempMACDSignal;
}
int tempStochasticSignal_1440 = Stochastic_Cross_Signal(0);
if(tempStochasticSignal_1440 != 0 && StochasticCrossSignal_1440 != tempStochasticSignal_1440){
StochasticCrossSignal_1440 = tempStochasticSignal_1440;
}
if(StochasticCrossSignal_1440 == 1 && MACD_Signal == 1 && MA_Signal == 1){
All_Signal = 1;
}else if(StochasticCrossSignal_1440 == -1 && MACD_Signal == -1 && MA_Signal == -1){
All_Signal = -1;
}
/*
else if(MA_Signal== -1 || MA_Signal== 1 )
{
checkCloseOrders(MA_Signal);
}
*/
if(MACD_Signal == 1 && TotalProfitSell > 0 || MACD_Signal == -1 && TotalProfitBuy > 0){
checkCloseOrders(MACD_Signal);
}
return(All_Signal);
}
double K_bule_now = 1,K_bule_previous = 1,D_red_now = 1, D_red_previous = 1 ;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
double prevClose,prevOpen;
//获取前一根K线是阳线还是阴线
int isPrevKDownOrUp(int timeframe){
int OrderSignal = 0;
//获取前一根K线是阳线还是阴线
prevClose = iClose(NULL,timeframe,1);
prevOpen = iOpen (NULL,timeframe,1);
if((prevOpen - prevClose)< 0){
OrderSignal = 1;//代表收阳线
}else if ((prevOpen - prevClose) > 0){
OrderSignal = -1;//代表收阴线
}else{
OrderSignal = 0;//代表收十字星或者没跳空信号
}
return OrderSignal;
}
int eataSignal()
{
int Signal = 0;
//k是蓝色线，D是红色线
double digits = MarketInfo(Symbol(),MODE_DIGITS);
K_bule_now = (double)DoubleToStr(iCustom(Symbol(),0,"eata",0,0),digits);
K_bule_previous = (double)DoubleToStr(iCustom(Symbol(),0,"eata",0,1),digits);
D_red_now = (double)DoubleToStr(iCustom(Symbol(),0,"eata",1,0),digits);
D_red_previous = (double)DoubleToStr(iCustom(Symbol(),0,"eata",1,1),digits);
if((K_bule_now > D_red_now) && (K_bule_previous < D_red_previous))
{
//蓝色线向上穿越红线，形成金叉
Signal = 1;
}
else
if((K_bule_now < D_red_now) && (K_bule_previous > D_red_previous))
{
//红色先向上穿越蓝色线，形成死叉
Signal = -1;
}
return Signal;
}
//根据价格乖离率进行操作
int GetMABidDiffSignal()
{
int Signal = 0;
double iMA_Signal = iMA(Symbol(), 0, iMA_Period, 0, MODE_SMA, PRICE_CLOSE, 0);
int Ma_Bid_Diff = MathAbs(iMA_Signal - Bid)/vPoint;
if(Ma_Bid_Diff > iMA_OpenDistance && Bid > iMA_Signal)
Signal = 1;//价格在均线之上，并且大于设置的距离
if(Ma_Bid_Diff > iMA_OpenDistance && Bid < iMA_Signal)
Signal = -1; //价格在均线之下，并且大于设置的距离
return(Signal);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int GetMABidDiffSignal(int timeframe)
{
int Signal = 0;
double iMA_Signal = iMA(Symbol(), timeframe, iMA_Period, 0, MODE_SMA, PRICE_CLOSE, 0);
int Ma_Bid_Diff = MathAbs(iMA_Signal - Bid)/vPoint;
if(Ma_Bid_Diff > iMA_OpenDistance && Bid > iMA_Signal)
Signal = 1;//价格在均线之上，并且大于设置的距离
if(Ma_Bid_Diff > iMA_OpenDistance && Bid < iMA_Signal)
Signal = -1; //价格在均线之下，并且大于设置的距离
return(Signal);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int getEnvSignal()
{
int Signal = 0;
double iMA_Signal_Sell = (1+Deviation/100)*iMA(Symbol(),0,MA_Period,0,MA_Method_m,Applied_Price,0);
double iMA_Signal_Buy = (1-Deviation/100)*iMA(Symbol(),0,MA_Period,0,MA_Method_m,Applied_Price,0);
//价格进入超买区域，需要做空
int Ma_Bid_Diff_Sell = MathAbs(iMA_Signal_Sell - Bid)/vPoint;
if(Ma_Bid_Diff_Sell > iMA_OpenDistance && Bid > iMA_Signal_Sell)
Signal = -1;//价格在均线之上，并且大于设置的距离
//价格进入超卖区域，需要做多
int Ma_Bid_Diff_Buy = MathAbs(iMA_Signal_Buy - Bid)/vPoint;
if(Ma_Bid_Diff_Buy > iMA_OpenDistance && Bid < iMA_Signal_Buy)
Signal = 1;//价格在均线之下，并且大于设置的距离
return(Signal);
}
//均线金叉或者死叉，信号持续
int MACross(int signal,int a,int b,int zhouqi)
{
int temp = MA_DoubleAveraging_Signal(a,b,zhouqi);
if(temp != 0 && signal != temp)
{
signal = temp;
}
return signal;
}
//双均线金叉死叉判断趋势方向
int MA_DoubleAveraging_Signal(int timeframe)
{
int Signal = 0;
//均线周期5
double iMA_5_Signal_1 = iMA(Symbol(), timeframe, iMA_Period_5, 0, MODE_SMA, PRICE_CLOSE, 1);
double iMA_5_Signal_2 = iMA(Symbol(), timeframe, iMA_Period_5, 0, MODE_SMA, PRICE_CLOSE, 2);
//均线周期10
double iMA_10_Signal_1 = iMA(Symbol(), timeframe, iMA_Period_10, 0, MODE_SMA, PRICE_CLOSE, 1);
double iMA_10_Signal_2 = iMA(Symbol(), timeframe, iMA_Period_10, 0, MODE_SMA, PRICE_CLOSE, 2);
if((iMA_5_Signal_1 > iMA_10_Signal_1) && (iMA_5_Signal_2 < iMA_10_Signal_2))
{
//形成金叉
Signal = 1;
}
else
if((iMA_5_Signal_1 < iMA_10_Signal_1) && (iMA_5_Signal_2 > iMA_10_Signal_2))
{
//形成死叉
Signal = -1;
}
/*
else if((iMA_5_Signal_1 < iMA_10_Signal_1)){
//5日均线在10日均线之下，表示空头
Signal = -1;
}else if(iMA_5_Signal_1 > iMA_10_Signal_1){
//5日均线在10日均线之上，表示多头
Signal = 1;
}
*/
return(Signal);
}
//双均线金叉死叉判断趋势方向
int MA_DoubleAveraging_Signal(int MA_Period_1,int MA_Period_2,int timeframe)
{
int Signal = 0;
//均线周期1
double iMA_5_Signal_1 = iMA(Symbol(), timeframe, MA_Period_1, 0, MODE_SMA, PRICE_CLOSE, 1);
double iMA_5_Signal_2 = iMA(Symbol(), timeframe, MA_Period_1, 0, MODE_SMA, PRICE_CLOSE, 2);
//均线周期2
double iMA_10_Signal_1 = iMA(Symbol(), timeframe, MA_Period_2, 0, MODE_SMA, PRICE_CLOSE, 1);
double iMA_10_Signal_2 = iMA(Symbol(), timeframe, MA_Period_2, 0, MODE_SMA, PRICE_CLOSE, 2);
if((iMA_5_Signal_1 > iMA_10_Signal_1) && (iMA_5_Signal_2 < iMA_10_Signal_2))
{
//形成金叉
Signal = 1;
}
else
if((iMA_5_Signal_1 < iMA_10_Signal_1) && (iMA_5_Signal_2 > iMA_10_Signal_2))
{
//形成死叉
Signal = -1;
}
/*
else if((iMA_5_Signal_1 < iMA_10_Signal_1)){
//5日均线在10日均线之下，表示空头
Signal = -1;
}else if(iMA_5_Signal_1 > iMA_10_Signal_1){
//5日均线在10日均线之上，表示多头
Signal = 1;
}
*/
return(Signal);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int RSI_Signal(int low,int hight,int timeframe,int period)
{
int signal = 0;
double rsi_now = 0;
double rsi_previous = 0;
rsi_now = iRSI(Symbol(),timeframe,period,PRICE_CLOSE,1);
rsi_previous = iRSI(Symbol(),timeframe,period,PRICE_CLOSE,2);
/*
if(rsi_now > hight)
{
//RSI从低位突破高位70，行情进入强势状态，这个时候也极有可能快速下跌，谨慎做多
signal = -1;
}
else if(rsi_now < low)
{
//RSI从高位跌破低位30，行情进入弱势状态，这个时候也极有可能快速反弹，谨慎做空
signal = 1;
}
*/
if(rsi_previous < low && rsi_now > low)
{
//RSI从低位向上突破30，可能有反弹机会
signal = 1;
}
else if(rsi_previous > hight && rsi_now < hight)
{
//RSI从高位向下跌破70，可能有下跌机会
signal = -1;
}
if(rsi_previous < 50 && rsi_now > 50){
//RSI从低位向上突破50，可能有反弹机会
signal = 1;
}else if(rsi_previous > 50 && rsi_now < 50){
//RSI从高位向下跌破50，可能有下跌机会
signal = -1;
}
return signal;
}
int RSI_AddLots_Signal(int timeframe,int period)
{
int signal = 0;
double rsi_now = 0;
double rsi_previous = 0;
rsi_now = iRSI(Symbol(),timeframe,period,PRICE_CLOSE,1);
rsi_previous = iRSI(Symbol(),timeframe,period,PRICE_CLOSE,2);
if(rsi_previous < 70 && rsi_now > 70){
signal = -1;
}else if (rsi_previous < 80 && rsi_now > 80){
signal = -2;//加仓空
}else if (rsi_previous < 90 && rsi_now > 90){
signal = -3;//加仓空
}
else if(rsi_previous > 30 && rsi_now < 30){
signal = 1;
}else if(rsi_previous > 20 && rsi_now < 20){
signal = 2;//加仓多
}else if(rsi_previous > 10 && rsi_now < 10){
signal = 3;//加仓多
}
/*
if(
rsi_previous < 70 && rsi_now > 70
||
rsi_previous < 80 && rsi_now > 80
||rsi_previous < 90 && rsi_now > 90
)
{
//RSI从低位突破高位70，行情进入强势状态，这个时候也极有可能快速下跌，谨慎做多
signal = -1;
}
else if(
rsi_previous > 30 && rsi_now < 30
||
rsi_previous > 20 && rsi_now < 20
||rsi_previous > 10 && rsi_now < 10
)
{
//RSI从高位跌破低位30，行情进入弱势状态，这个时候也极有可能快速反弹，谨慎做空
signal = 1;
}
*/
return signal;
}
//Stochastic交叉信号
int Stochastic_Cross_Signal(int timeframe)
{
int signal = 0;
double fastMAnow, slowMAnow, fastMAprevious, slowMAprevious;
fastMAnow = iStochastic(Symbol(), timeframe, KPeriod, DPeriod, Slowing,MA_Method, PriceField, MODE_MAIN, 1);
fastMAprevious = iStochastic(Symbol(), timeframe, KPeriod, DPeriod, Slowing,MA_Method, PriceField, MODE_MAIN, 2);
slowMAnow = iStochastic(Symbol(), timeframe, KPeriod, DPeriod, Slowing,MA_Method, PriceField, MODE_SIGNAL, 1);
slowMAprevious = iStochastic(Symbol(), timeframe, KPeriod, DPeriod, Slowing,MA_Method, PriceField, MODE_SIGNAL, 2);
if(((show_KD_cross)&&(fastMAnow > slowMAnow) && (fastMAprevious < slowMAprevious))||//只要KD是金叉
((show_K_OBOScross)&&(fastMAnow > OverSoldLevel) && (fastMAprevious < OverSoldLevel))||//K低于20，并且上穿越20
((show_D_OBOScross)&&(slowMAnow > OverSoldLevel) && (slowMAprevious < OverSoldLevel))) //D低于20，并且上穿越20
{
signal = 1;
}
else
if(((show_KD_cross)&&(fastMAnow < slowMAnow) && (fastMAprevious > slowMAprevious))||//只要KD是死叉
((show_K_OBOScross)&&(fastMAnow < OverBoughtLevel) && (fastMAprevious > OverBoughtLevel))||//K高于80，并且下穿越80
((show_D_OBOScross)&&(slowMAnow < OverBoughtLevel) && (slowMAprevious > OverBoughtLevel))) //D高于80，并且下穿越80
{
signal = -1;
}
return(signal);
}
//Stochastic交叉信号
int Stochastic_Cross_Signal(int timeframe,bool m_show_KD_cross,bool m_show_K_OBOScross,bool m_show_D_OBOScross)
{
int signal = 0;
double fastMAnow, slowMAnow, fastMAprevious, slowMAprevious;
fastMAnow = iStochastic(Symbol(), timeframe, KPeriod, DPeriod, Slowing,MA_Method, PriceField, MODE_MAIN, 1);
fastMAprevious = iStochastic(Symbol(), timeframe, KPeriod, DPeriod, Slowing,MA_Method, PriceField, MODE_MAIN, 2);
slowMAnow = iStochastic(Symbol(), timeframe, KPeriod, DPeriod, Slowing,MA_Method, PriceField, MODE_SIGNAL, 1);
slowMAprevious = iStochastic(Symbol(), timeframe, KPeriod, DPeriod, Slowing,MA_Method, PriceField, MODE_SIGNAL, 2);
if(((m_show_KD_cross)&&(fastMAnow > slowMAnow) && (fastMAprevious < slowMAprevious))||//只要KD是金叉
((m_show_K_OBOScross)&&(fastMAnow > OverSoldLevel) && (fastMAprevious < OverSoldLevel))||//K低于20，并且上穿越20
((m_show_D_OBOScross)&&(slowMAnow > OverSoldLevel) && (slowMAprevious < OverSoldLevel))) //D低于20，并且上穿越20
{
signal = 1;
}
else
if(((m_show_KD_cross)&&(fastMAnow < slowMAnow) && (fastMAprevious > slowMAprevious))||//只要KD是死叉
((m_show_K_OBOScross)&&(fastMAnow < OverBoughtLevel) && (fastMAprevious > OverBoughtLevel))||//K高于80，并且下穿越80
((m_show_D_OBOScross)&&(slowMAnow < OverBoughtLevel) && (slowMAprevious > OverBoughtLevel))) //D高于80，并且下穿越80
{
signal = -1;
}
return(signal);
}
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
string l_text_4;
int getStochasticSignal(int timefram_1,int timefram_2,int timefram_3)
{
//stoch指标 短线 H4，M30，M5
double stochastic_H4_Main = iStochastic(NULL, timefram_1, K_Period, D_Period, Stoch_Slowing, MODE_SMA, 0, MODE_MAIN, 0);
double stochastic_H4_Signal = iStochastic(NULL, timefram_1,K_Period, D_Period, Stoch_Slowing, MODE_SMA, 0, MODE_SIGNAL, 0);
double stochastic_M30_Main = iStochastic(NULL, timefram_2,K_Period, D_Period, Stoch_Slowing, MODE_SMA, 0, MODE_MAIN, 0);
double stochastic_M30_Signal = iStochastic(NULL, timefram_2,K_Period, D_Period, Stoch_Slowing, MODE_SMA, 0, MODE_SIGNAL, 0);
double stochastic_M5_Main = iStochastic(NULL, timefram_3, K_Period, D_Period, Stoch_Slowing, MODE_SMA, 0, MODE_MAIN, 0);
double stochastic_M5_Signal = iStochastic(NULL, timefram_3, K_Period, D_Period, Stoch_Slowing, MODE_SMA, 0, MODE_SIGNAL, 0);
//stoch指标 中长线 D1，H4，H1
double stochastic_D1_Main = iStochastic(NULL, timefram_1,K_Period, D_Period, Stoch_Slowing, MODE_SMA, 0, MODE_MAIN, 0);
double stochastic_D1_Signal = iStochastic(NULL, timefram_1,K_Period, D_Period, Stoch_Slowing, MODE_SMA, 0, MODE_SIGNAL, 0);
double stochastic_H1_Main = iStochastic(NULL, timefram_3, K_Period, D_Period, Stoch_Slowing, MODE_SMA, 0, MODE_MAIN, 0);
double stochastic_H1_Signal = iStochastic(NULL, timefram_3, K_Period, D_Period, Stoch_Slowing, MODE_SMA, 0, MODE_SIGNAL, 0);
int signal = 0;
if(stochastic_H4_Main > stochastic_H4_Signal && stochastic_M30_Main >= stochastic_M30_Signal && stochastic_M5_Main > stochastic_M5_Signal)
{
signal = 1;
l_text_4 = "短线强势做多(H4,M30,M5)"+signal;
}
else if(stochastic_H4_Main > stochastic_H4_Signal && stochastic_M30_Main >= stochastic_M30_Signal && stochastic_M5_Main == stochastic_M5_Signal)
{
//这里没运行
//signal = 2;
//l_text_4 = "短线强势做多(H4,M30,M5)"+signal;
}
else if(stochastic_H4_Main > stochastic_H4_Signal && stochastic_M30_Main >= stochastic_M30_Signal && stochastic_M5_Main < stochastic_M5_Signal)
{
signal = 3;
l_text_4 = "短线弱势做多(H4,M30,M5)"+signal;
}
else if(stochastic_H4_Main < stochastic_H4_Signal && stochastic_M30_Main <= stochastic_M30_Signal && stochastic_M5_Main < stochastic_M5_Signal)
{
signal = -1;
l_text_4 = "短线强势做空(H4,M30,M5)"+signal;
}
else if(stochastic_H4_Main < stochastic_H4_Signal && stochastic_M30_Main <= stochastic_M30_Signal && stochastic_M5_Main == stochastic_M5_Signal)
{
//这里没运行
//signal = -2;
//l_text_4 = "短线强势做空(H4,M30,M5)"+signal;
}
//4小时级别，30分钟级别,5分钟级别综合判断
else if(stochastic_H4_Main < stochastic_H4_Signal && stochastic_M30_Main <= stochastic_M30_Signal && stochastic_M5_Main > stochastic_M5_Signal)
{
signal = -3;
l_text_4 = "短线弱势做空(H4,M30,M5)"+signal;
}
//4小时级别，30分钟级别综合判断
else if(stochastic_H4_Main > stochastic_H4_Signal && stochastic_M30_Main < stochastic_M30_Signal)
{
signal = 0;
l_text_4 = "短线观望为主(H4,M30)"+signal;
}
else if(stochastic_H4_Main < stochastic_H4_Signal && stochastic_M30_Main > stochastic_M30_Signal)
{
signal = 0;
l_text_4 = "短线观望为主(H4,M30)"+signal;
}
return signal;
}
//Macd金叉死叉判断趋势方向
int MACD_Signal(int timeframe)
{
if(iMACD(Symbol(),timeframe,12,26,9,PRICE_CLOSE,MODE_MAIN,0) > iMACD(Symbol(),timeframe,12,26,9,PRICE_CLOSE,MODE_SIGNAL,0))
{
return(1);
}
if(iMACD(Symbol(),timeframe,12,26,9,PRICE_CLOSE,MODE_MAIN,0) < iMACD(Symbol(),timeframe,12,26,9,PRICE_CLOSE,MODE_SIGNAL,0))
{
return(-1);
}
return(0);
}
//判断Macd在0以上或者0以下的金叉死叉
int MACD_UPDown_Signal(int timeframe)
{
int signal = 0;
double Main_now, Signal_now, Main_previous, Signal_previous;
Main_now = iMACD(Symbol(),timeframe,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
Main_previous = iMACD(Symbol(),timeframe,12,26,9,PRICE_CLOSE,MODE_MAIN,2);
Signal_now = iMACD(Symbol(),timeframe,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
Signal_previous = iMACD(Symbol(),timeframe,12,26,9,PRICE_CLOSE,MODE_SIGNAL,2);
if((Main_now > Signal_now) && (Main_previous < Signal_previous)
&& Main_now < MACD_Up && Signal_now < MACD_Up && Main_previous < MACD_Up && Signal_previous < MACD_Up)
{
//当前在MACD的0以下进行金叉，这个时候判断要做多
signal = 1;
}
else
if((Main_now < Signal_now) && (Main_previous > Signal_previous)
&& Main_now > MACD_Down && Signal_now > MACD_Down && Main_previous > MACD_Down && Signal_previous > MACD_Down)
{
//当前在MACD的0以上进行死叉，这个时候判断要做空
signal = -1;
}
return(signal);
}
//不区分MACD值在0轴以上还是以下，只要有金叉死叉，就有做多做空信号
int 加仓MACD_UPDown_Signal(int timeframe)
{
int signal = 0;
double Main_now, Signal_now, Main_previous, Signal_previous;
Main_now = iMACD(Symbol(),timeframe,12,26,9,PRICE_CLOSE,MODE_MAIN,1);
Main_previous = iMACD(Symbol(),timeframe,12,26,9,PRICE_CLOSE,MODE_MAIN,2);
Signal_now = iMACD(Symbol(),timeframe,12,26,9,PRICE_CLOSE,MODE_SIGNAL,1);
Signal_previous = iMACD(Symbol(),timeframe,12,26,9,PRICE_CLOSE,MODE_SIGNAL,2);
if((Main_now > Signal_now) && (Main_previous < Signal_previous)
//&& Main_now < 0 && Signal_now < 0 && Main_previous < 0 && Signal_previous < 0
)
{
//当前在MACD的金叉，这个时候判断要做多
signal = 1;
}
else
if((Main_now < Signal_now) && (Main_previous > Signal_previous)
//&& Main_now > 0 && Signal_now > 0 && Main_previous > 0 && Signal_previous > 0
)
{
//当前在MACD的死叉，这个时候判断要做空
signal = -1;
}
return(signal);
}
//如果小周期金叉或者死叉，就对冲一下，如果大周期金叉死叉，代表行情反转，平仓所有反向单子，持有顺势单子。
int duichongOrders(int duichong_signal)
{
TotalBuyOrders = CountOfOrders(MagicNumberBuy);
TotalSellOrders = CountOfOrders(MagicNumberSell);
if(duichong_signal == 1)
{
if(TotalSellOrders > 0 && TotalBuyOrders == 0)
{
// New buy series ...
SendMarketOrder(OP_BUY, 首单持仓手数(), 固定止盈点数, 0, MagicNumberBuy, TimeCurrent() + "|");
}
}
else
if(duichong_signal == -1)
{
//死叉
if(TotalBuyOrders > 0 && TotalSellOrders == 0)
{
// New sell series ...
SendMarketOrder(OP_SELL, 首单持仓手数(), 固定止盈点数, 0, MagicNumberSell, TimeCurrent() + "|");
}
}
}
//根据实际情况止损
int checkCloseOrders(int zhishun_signal)
{
TotalBuyOrders = CountOfOrders(MagicNumberBuy);
TotalSellOrders = CountOfOrders(MagicNumberSell);
if(zhishun_signal == 1)
{
//金叉，如果有空单，就止损所有空单
if(TotalSellOrders > 0)
{
CloseOrder(zhishun_signal);
}
}
else
if(zhishun_signal == -1)
{
//死叉，如果有多单，就止损所有多单
if(TotalBuyOrders > 0)
{
CloseOrder(zhishun_signal);
}
}
else
{
CloseOrder(0);//止损所有单子
}
}
//设置移动止盈功能
void checkMoveTakeProfit(double pips)
{
for(int i=0; i<OrdersTotal(); i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false)
break;
if(OrderSymbol()==Symbol() && OrderMagicNumber()== MagicNumberSell
|| OrderSymbol()==Symbol() && OrderMagicNumber()== MagicNumberBuy)
{
//double movePips = pips * MarketInfo(OrderSymbol(), MODE_POINT);
double movePips = pips * Point;
if(OrderType() == OP_BUY)
{
//RefreshRates();
if(Bid - OrderOpenPrice() > movePips //现价高于开单价+13点
&& (OrderStopLoss() < Bid - movePips || OrderStopLoss() == 0)
)
{
//Print ( "执行移动止盈。Sell --- Bid == "+Bid,"--- movePips == " +movePips+"--- 移动止盈价 == "+(Bid - movePips));
OrderModify(OrderTicket(), OrderOpenPrice(), Bid - movePips, OrderTakeProfit(), Green);
}
}
if(OrderType() == OP_SELL)
{
//RefreshRates();
if(OrderOpenPrice() - Ask > movePips
&& (OrderStopLoss() > Ask + movePips || OrderStopLoss() == 0)
)
{
//Print ( "执行移动止盈。Sell --- Ask == "+Ask,"--- movePips == " +movePips+"--- 移动止盈价"+(Ask + movePips));
OrderModify(OrderTicket(), OrderOpenPrice(), Ask + movePips, OrderTakeProfit(), Tan);
}
}
}
}
}
/*
//设置移动止盈功能
void checkMoveTakeProfit(double pips)
{
for (int i=0; i<OrdersTotal(); i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==false) break;
if(OrderSymbol()==Symbol() && OrderMagicNumber()== MagicNumberSell
|| OrderSymbol()==Symbol() && OrderMagicNumber()== MagicNumberBuy)
{
double movePips = pips * MarketInfo(OrderSymbol(), MODE_POINT);
if ( OrderType() == OP_BUY && Bid - OrderOpenPrice() > movePips //现价高于开单价+13点
//&& (OrderStopLoss() < Bid - movePips || OrderStopLoss() == 0)
)
{
OrderModify(OrderTicket(), OrderOpenPrice(), Bid - movePips, OrderTakeProfit(), Green);
}
if ( OrderType() == OP_SELL && OrderOpenPrice() - Ask > movePips
//&& (OrderStopLoss() > Ask + movePips || OrderStopLoss() == 0)
)
{
OrderModify(OrderTicket(), OrderOpenPrice(), Ask + movePips, OrderTakeProfit(), Tan);
}
}
}
}
*/
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void sendOrder(int orderPos,double orderLot,double orderPrice,double orderSL,double orderTP,int OrderMagic,color orderColor)
{
bool sent; // Added by Capella for the use of OrderSend command, see correction below!
// OrderSend(Symbol(),orderPos,orderLot,orderPrice,3,orderSL,orderTP,"CBS_nEk0",OrderMagic,0,orderColor); // Commented out by Capella
sent = OrderSend(Symbol(),orderPos,orderLot,orderPrice,3,orderSL,orderTP,TimeCurrent() + "|",OrderMagic,0,orderColor); // Added by Capella
}
/*
datetime currtime,prevtime;
bool newTime()
{
currtime=iTime(NULL,TimeFrame,0);
if (prevtime!=currtime)
{
prevtime=currtime;
return true;
}
else {return false;}
}
*/
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
void MoveTakeProfit()
{
TotalBuyOrders = CountOfOrders(MagicNumberBuy);
TotalSellOrders = CountOfOrders(MagicNumberSell);
//if(TotalBuyOrders == 1 || TotalSellOrders == 1)
//{
for(int i=0; i<OrdersTotal(); i++)
{
if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)==true)
{
if(OrderSymbol()==Symbol() && OrderMagicNumber()== MagicNumberSell
|| OrderSymbol()==Symbol() && OrderMagicNumber()== MagicNumberBuy)
{
// Check Trailing
CheckTrail(OrderTicket());
}
}
}
//}
}
// Trail specific order; check to see if StopLoss cand and should be changed
void CheckTrail(int par_ticket)
{
double trstart = TrailStart * Point;
double gap = TrailGap * Point;
double step = TrailStep * Point;
double spread = Ask - Bid;
double openprice = 0;
double oldSL = 0;
double newSL = 0;
bool wasmodified = FALSE;
// If we can select the order that should be trailing
if(OrderSelect(par_ticket, SELECT_BY_TICKET, MODE_TRADES) == TRUE)
{
openprice = OrderOpenPrice();
oldSL = OrderStopLoss();
// Spread is higher than Trailing value, so set Trailing value to spread
if(spread > trstart)
trstart = spread;
// If the order does not have any SL yet
if(oldSL == 0)
{
// If we have matching order type and symbol
if(OrderType() == OP_BUY)
{
// Calculate new SL
newSL = ND(openprice + trstart);
// If the current close price is larger than opening price + TrailingStart
if(Bid > newSL
//+ step
)
{
// Modify the order with a new SL
wasmodified = OrderModify(par_ticket, openprice, newSL, OrderTakeProfit(), 0, Blue);
// If the order could not be modified with a new SL then print out an error message
if(wasmodified == FALSE)
Print("Attempt to trail SL for profitable order# ", par_ticket, " failed! Last error = ", GetLastError(),", OrderType = ", OrderType(),", Bid = ", Bid,", Open price = ", openprice,", OldSL = ", oldSL,", TrailSL = ", newSL);
}
}
// If we have matching order type
if(OrderType() == OP_SELL)
{
// Calculate new SL
newSL = ND(openprice - trstart);
// If the current close price is less than the opening price - TrailingStart - TrailingStep
if(Ask < newSL
//- step
)
{
// Modify the order with a SL
wasmodified = OrderModify(par_ticket, openprice, newSL, OrderTakeProfit(), 0, Blue);
// If the order could not be modified with a new SL then print out an error message
if(wasmodified == FALSE)
Print("Attempt to trail SL for profitable order# ", par_ticket, " failed! Last error = ", GetLastError(),", OrderType = ", OrderType(),", Ask = ", Ask,", Open price = ", openprice,", OldSL = ", oldSL,", TrailSL = ", newSL);
}
}
/*
// If the order has been modified with a StopLoss then print message and call sub for deleting matching pending order
if ( wasmodified > 0 )
{
// Print out message that says that the order is now trailing in profit
Print ( "The order ", string ( par_ticket ), " is trailing SL in profit!" );
}
*/
}
// The order already has a SL, and a check to see if it can be changed
else
{
// If we have matching order type
if(OrderType() == OP_BUY)
{
// Calculate new SL as current closing price - gap
newSL = ND(Bid - gap);
// If the distance between the new SL and the old SL is more than the trailing step
if((newSL - oldSL) > step
&& newSL > openprice + trstart
)
{
// Modify the profit order with a new SL that is current close price less trailing,
wasmodified = OrderModify(par_ticket, openprice, newSL, OrderTakeProfit(), 0, Blue);
// In case the order couiild not be modified then print out error message
if(wasmodified == FALSE)
Print("Modify error. newSl = ", newSL,", oldSl = ", oldSL,", Bid = ", Bid);
}
}
// If we have matching order type and symbol
if(OrderType() == OP_SELL)
{
// Calculate a new SL
newSL = ND(Ask + gap);
// If the distance between the new SL and the old SL is more than the trailing step
if((oldSL - newSL) > gap
&& newSL < openprice - trstart
)
{
// Modify the profit order with a new SL that is current close price plus trailing
wasmodified = OrderModify(par_ticket, openprice, newSL, OrderTakeProfit(), 0, Blue);
// In case the order could not be modified then print out error message
if(wasmodified == FALSE)
Print("Modify error. newSl = ", newSL,", oldSl = ", oldSL,", Ask = ", Ask);
}
}
}
}
}
// Normalize decimals to number of decimals for this currency pair as defined by the broker. Added by Capella
double ND(double par_value)
{
return (NormalizeDouble(par_value, Digits));
}
//===================================================================================================================================================
//+------------------------------------------------------------------+
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。
马建仓 AI 助手