641 lines
No EOL
25 KiB
MQL5
641 lines
No EOL
25 KiB
MQL5
//+------------------------------------------------------------------+
|
|
//| RSI_Strategy.mq5 |
|
|
//| Copyright 2025, MetaQuotes Ltd. |
|
|
//| https://www.mql5.com |
|
|
//+------------------------------------------------------------------+
|
|
#property copyright "Copyright 2025, MetaQuotes Ltd."
|
|
#property link "https://www.mql5.com"
|
|
#property version "1.00"
|
|
|
|
#include <Trade\Trade.mqh>
|
|
CTrade trade;
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 输入参数 |
|
|
//+------------------------------------------------------------------+
|
|
input group "=====基本参数======"
|
|
input int MagicNumber = 123456;
|
|
input string OrderComment = "RSI_Strategy";
|
|
|
|
input group "=====马丁参数====="
|
|
input double MartinStartLots = 0.1; // 首次进场手数（基准：10000美元=0.1手）
|
|
input double MartinStepUSD = 3; // 马丁加仓间隔（美金，作为ATR不触发时的回退值）
|
|
input double MartinMultiplier = 1.3; // 马丁加仓倍数
|
|
input double TakeProfitUSD = 3; // 盈利出场（美金）
|
|
input int PriceDigits = 2; // 价格小数位（如XAUUSD有的平台是2，有的是3）
|
|
input int MaxAddCount = 15; // 最大加仓次数
|
|
input bool EnableDynamicLots = true; // 是否启用动态手数（按余额比例），关闭则固定用MartinStartLots
|
|
|
|
input group "=====动态加仓参数====="
|
|
input int ATRPeriod = 2; // ATR周期
|
|
input double ATRThresholdUSD = 0.6; // ATR阈值(美金)
|
|
input double ATRDistanceMultiplier = 1;// ATR加仓距离系数
|
|
|
|
input group "=====EMA加仓风控====="
|
|
input bool EnableEMARisk = false; // 开关：当加仓次数超过阈值后启用EMA风控
|
|
input int EMARiskStartAddCount = 10; // 超过该加仓次数后启用风控
|
|
input int EMARiskPeriod = 50; // EMA周期（默认50）
|
|
|
|
input group "=====指标参数====="
|
|
input double RSIUpperLevel = 85; // RSI超买水平
|
|
input double RSILowerLevel = 25; // RSI超卖水平
|
|
input bool EnableRSIFilter = false; // 是否启用RSI过滤
|
|
input double ADXThreshold = 50; // ADX阈值，大于此值时暂停加仓
|
|
input bool EnableADXFilter = true; // 是否启用ADX过滤功能
|
|
|
|
input group "=====交易方向开关====="
|
|
input bool EnableBuy = true; // 是否允许做多
|
|
input bool EnableSell = true; // 是否允许做空
|
|
|
|
input group "=====时间段控制====="
|
|
input bool EnableTimeControl = false; // 是否时间段控制
|
|
input string TradingHours = "1,2,3,4,5,6,7,8,9,10"; // 允许开仓的时间段（小时），用逗号分割
|
|
|
|
// RSI指标句柄
|
|
int rsiHandle = INVALID_HANDLE;
|
|
|
|
// ADX指标句柄
|
|
int adxHandle = INVALID_HANDLE;
|
|
|
|
// ATR指标句柄
|
|
int atrHandle = INVALID_HANDLE;
|
|
|
|
// EMA12指标句柄
|
|
int ema12Handle = INVALID_HANDLE;
|
|
|
|
// EMA风控指标句柄
|
|
int emaRiskHandle = INVALID_HANDLE;
|
|
|
|
// 记录上一次加仓价和当前加仓手数
|
|
static double lastLongAddPrice = 0;
|
|
static double lastLongAddLots = 0;
|
|
|
|
// 记录上一次空单加仓价和手数
|
|
static double lastShortAddPrice = 0;
|
|
static double lastShortAddLots = 0;
|
|
|
|
// 记录加仓次数
|
|
static int buyAddCount = 0;
|
|
static int sellAddCount = 0;
|
|
|
|
// 记录移动追踪止盈的历史最高/最低价
|
|
static double buyTrailingPrice = 0; // 多单移动追踪止盈位
|
|
static double sellTrailingPrice = 0; // 空单移动追踪止盈位
|
|
|
|
// 获取当前RSI值
|
|
double GetRSI() {
|
|
if(rsiHandle == INVALID_HANDLE)
|
|
rsiHandle = iRSI(_Symbol, _Period, 14, PRICE_CLOSE);
|
|
// 获取当前RSI值
|
|
double rsiArray[1];
|
|
if(CopyBuffer(rsiHandle, 0, 0, 1, rsiArray) <= 0) return 0.0;
|
|
return rsiArray[0];
|
|
|
|
// 获取上一根K线的RSI值
|
|
// double rsiArray[2];
|
|
// if(CopyBuffer(rsiHandle, 0, 1, 2, rsiArray) <= 0) return 0.0;
|
|
// return rsiArray[0];
|
|
}
|
|
|
|
// 获取基于ATR的动态加仓距离（单位：美金）。当ATR>阈值时使用 ATR*系数，否则使用固定MartinStepUSD
|
|
double CalculateDynamicAddDistanceUSD() {
|
|
if(atrHandle == INVALID_HANDLE)
|
|
atrHandle = iATR(_Symbol, _Period, ATRPeriod);
|
|
if(atrHandle != INVALID_HANDLE) {
|
|
double atrArray[1];
|
|
if(CopyBuffer(atrHandle, 0, 0, 1, atrArray) == 1) {
|
|
double atrNow = atrArray[0];
|
|
if(atrNow > ATRThresholdUSD) {
|
|
double distance = atrNow * ATRDistanceMultiplier;
|
|
return NormalizeDouble(distance, 2);
|
|
}
|
|
}
|
|
}
|
|
return NormalizeDouble(MartinStepUSD, 2);
|
|
}
|
|
|
|
// 读取上一根K线的开收盘
|
|
bool GetPrevCandle(double &prevOpen, double &prevClose) {
|
|
double o[1], c[1];
|
|
if(CopyOpen(_Symbol, _Period, 1, 1, o) != 1) return false;
|
|
if(CopyClose(_Symbol, _Period, 1, 1, c) != 1) return false;
|
|
prevOpen = o[0];
|
|
prevClose = c[0];
|
|
return true;
|
|
}
|
|
|
|
// 获取指定周期EMA在上一根K线的值
|
|
bool GetPrevEMA(int period, double &emaPrev) {
|
|
if(emaRiskHandle == INVALID_HANDLE)
|
|
emaRiskHandle = iMA(_Symbol, _Period, period, 0, MODE_EMA, PRICE_CLOSE);
|
|
if(emaRiskHandle == INVALID_HANDLE) return false;
|
|
double emaArr[1];
|
|
if(CopyBuffer(emaRiskHandle, 0, 1, 1, emaArr) != 1) return false;
|
|
emaPrev = emaArr[0];
|
|
return true;
|
|
}
|
|
|
|
// EMA风控：
|
|
// - 多单：上一根K线实体上穿EMA（上一根开盘<EMA 且 收盘>EMA）
|
|
// - 空单：上一根K线实体收在EMA下方（上一根收盘<EMA）
|
|
bool PassesEMARisk(int posType) {
|
|
double prevOpen = 0.0, prevClose = 0.0, emaPrev = 0.0;
|
|
if(!GetPrevCandle(prevOpen, prevClose)) return false;
|
|
if(!GetPrevEMA(EMARiskPeriod, emaPrev)) return false;
|
|
if(posType == POSITION_TYPE_BUY) {
|
|
return (prevOpen < emaPrev && prevClose > emaPrev);
|
|
} else {
|
|
return (prevClose < emaPrev);
|
|
}
|
|
}
|
|
|
|
// 获取当前ADX值
|
|
double GetADX() {
|
|
if(adxHandle == INVALID_HANDLE)
|
|
adxHandle = iADX(_Symbol, _Period, 14);
|
|
// 获取当前ADX值
|
|
double adxArray[1];
|
|
if(CopyBuffer(adxHandle, 0, 0, 1, adxArray) <= 0) return 0.0;
|
|
return adxArray[0];
|
|
}
|
|
|
|
// 获取上根K线收盘价
|
|
double GetPreviousClose() {
|
|
double closeArray[2];
|
|
if(CopyClose(_Symbol, _Period, 1, 2, closeArray) <= 0) return 0.0;
|
|
return closeArray[1]; // 上根K线收盘价
|
|
}
|
|
|
|
// 获取当前EMA12值
|
|
double GetEMA12() {
|
|
if(ema12Handle == INVALID_HANDLE)
|
|
ema12Handle = iMA(_Symbol, _Period, 12, 0, MODE_EMA, PRICE_CLOSE);
|
|
double emaArray[2];
|
|
if(CopyBuffer(ema12Handle, 0, 0, 2, emaArray) <= 0) return 0.0;
|
|
return emaArray[1];
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 检查当前时间是否在允许开仓的时间段内 |
|
|
//+------------------------------------------------------------------+
|
|
bool IsTradingTime() {
|
|
if(!EnableTimeControl) return true;
|
|
|
|
// 获取当前服务器时间
|
|
MqlDateTime dt;
|
|
TimeToStruct(TimeCurrent(), dt);
|
|
int currentHour = dt.hour;
|
|
|
|
// 解析允许的时间段
|
|
string hours[];
|
|
StringSplit(TradingHours, ',', hours);
|
|
for(int i = 0; i < ArraySize(hours); i++) {
|
|
// 去除空格并转换为整数
|
|
string hourStr = hours[i];
|
|
// 去除前后空格
|
|
while(StringLen(hourStr) > 0 && StringGetCharacter(hourStr, 0) == ' ') {
|
|
hourStr = StringSubstr(hourStr, 1);
|
|
}
|
|
while(StringLen(hourStr) > 0 && StringGetCharacter(hourStr, StringLen(hourStr)-1) == ' ') {
|
|
hourStr = StringSubstr(hourStr, 0, StringLen(hourStr)-1);
|
|
}
|
|
|
|
if(hourStr != "") {
|
|
int hour = (int)StringToInteger(hourStr);
|
|
if(hour == currentHour) {
|
|
return true; // 当前时间在允许的时间段内
|
|
}
|
|
}
|
|
}
|
|
|
|
return false; // 当前时间不在允许的时间段内
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 检查是否有指定方向的持仓 |
|
|
//+------------------------------------------------------------------+
|
|
bool HasPosition(int posType) {
|
|
for(int i=0; i<PositionsTotal(); i++) {
|
|
ulong ticket = PositionGetTicket(i);
|
|
if(PositionSelectByTicket(ticket)) {
|
|
if(PositionGetString(POSITION_SYMBOL) == _Symbol &&
|
|
PositionGetInteger(POSITION_MAGIC) == MagicNumber &&
|
|
PositionGetInteger(POSITION_TYPE) == posType) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 获取当前持仓类型 |
|
|
//+------------------------------------------------------------------+
|
|
int GetCurrentPosType() {
|
|
if(HasPosition(POSITION_TYPE_BUY)) return POSITION_TYPE_BUY;
|
|
if(HasPosition(POSITION_TYPE_SELL)) return POSITION_TYPE_SELL;
|
|
return -1;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 开仓函数 |
|
|
//+------------------------------------------------------------------+
|
|
void OpenPosition(int posType, double lots, double price, string comment) {
|
|
trade.SetExpertMagicNumber(MagicNumber);
|
|
bool result = false;
|
|
|
|
if(posType == POSITION_TYPE_BUY) {
|
|
result = trade.Buy(lots, _Symbol, price, 0, 0, comment);
|
|
} else if(posType == POSITION_TYPE_SELL) {
|
|
result = trade.Sell(lots, _Symbol, price, 0, 0, comment);
|
|
}
|
|
|
|
if(result) {
|
|
string direction = (posType == POSITION_TYPE_BUY) ? "多单" : "空单";
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 执行开仓操作（包含开仓、更新变量、打印日志） |
|
|
//+------------------------------------------------------------------+
|
|
void ExecuteOpenPosition(int posType, double rsi, double rsiThreshold, double curPrice) {
|
|
double dynamicLots = GetDynamicLots(posType);
|
|
OpenPosition(posType, dynamicLots, curPrice, OrderComment);
|
|
|
|
// 更新加仓相关变量
|
|
double lastAddPrice = curPrice;
|
|
double lastAddLots = dynamicLots;
|
|
int currentAddCount = 1; // 首次进场算第一次
|
|
|
|
// 写回全局变量
|
|
UpdateGlobalVariables(posType, lastAddPrice, lastAddLots, currentAddCount);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 平仓函数 |
|
|
//+------------------------------------------------------------------+
|
|
void ClosePosition(int posType) {
|
|
for(int i=PositionsTotal()-1; i>=0; i--) {
|
|
ulong ticket = PositionGetTicket(i);
|
|
if(PositionSelectByTicket(ticket)) {
|
|
if(PositionGetString(POSITION_SYMBOL) == _Symbol &&
|
|
PositionGetInteger(POSITION_MAGIC) == MagicNumber &&
|
|
PositionGetInteger(POSITION_TYPE) == posType) {
|
|
if(trade.PositionClose(ticket)) {
|
|
string direction = (posType == POSITION_TYPE_BUY) ? "多单" : "空单";
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 计算指定方向持仓的加权平均价 |
|
|
//+------------------------------------------------------------------+
|
|
double GetAvgPrice(int posType) {
|
|
double totalLots = 0;
|
|
double totalCost = 0;
|
|
for(int i=0; i<PositionsTotal(); i++) {
|
|
ulong ticket = PositionGetTicket(i);
|
|
if(PositionSelectByTicket(ticket)) {
|
|
if(PositionGetString(POSITION_SYMBOL) == _Symbol &&
|
|
PositionGetInteger(POSITION_MAGIC) == MagicNumber &&
|
|
PositionGetInteger(POSITION_TYPE) == posType) {
|
|
double lots = PositionGetDouble(POSITION_VOLUME);
|
|
double price = PositionGetDouble(POSITION_PRICE_OPEN);
|
|
totalLots += lots;
|
|
totalCost += lots * price;
|
|
}
|
|
}
|
|
}
|
|
if(totalLots == 0) return 0;
|
|
return totalCost / totalLots;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 计算指定方向持仓的总手数 |
|
|
//+------------------------------------------------------------------+
|
|
double GetTotalLots(int posType) {
|
|
double totalLots = 0;
|
|
for(int i=0; i<PositionsTotal(); i++) {
|
|
ulong ticket = PositionGetTicket(i);
|
|
if(PositionSelectByTicket(ticket)) {
|
|
if(PositionGetString(POSITION_SYMBOL) == _Symbol &&
|
|
PositionGetInteger(POSITION_MAGIC) == MagicNumber &&
|
|
PositionGetInteger(POSITION_TYPE) == posType) {
|
|
totalLots += PositionGetDouble(POSITION_VOLUME);
|
|
}
|
|
}
|
|
}
|
|
return totalLots;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 检查加仓条件 |
|
|
//+------------------------------------------------------------------+
|
|
bool CheckAddPosition(int posType, double curPrice, double lastAddPrice, double stepDistance, double totalLots, int currentAddCount) {
|
|
if(totalLots <= 0) return false;
|
|
|
|
// 检查时间段是否允许开仓
|
|
if(!IsTradingTime()) {
|
|
Print("当前时间不在允许开仓的时间段内，禁止加仓");
|
|
return false;
|
|
}
|
|
|
|
// 检查最大加仓次数
|
|
if(currentAddCount >= MaxAddCount) {
|
|
string direction = (posType == POSITION_TYPE_BUY) ? "多单" : "空单";
|
|
Print(direction, "已达到最大加仓次数(", currentAddCount, " >= ", MaxAddCount, ")，停止加仓");
|
|
return false;
|
|
}
|
|
|
|
bool shouldAdd = false;
|
|
if(posType == POSITION_TYPE_BUY) {
|
|
shouldAdd = (curPrice <= lastAddPrice - stepDistance * SymbolInfoDouble(_Symbol, SYMBOL_POINT));
|
|
} else {
|
|
shouldAdd = (curPrice >= lastAddPrice + stepDistance * SymbolInfoDouble(_Symbol, SYMBOL_POINT));
|
|
}
|
|
|
|
if(!shouldAdd) return false;
|
|
|
|
// EMA风控：当开启且加仓次数达到阈值后，要求满足指定的K线与EMA关系
|
|
if(EnableEMARisk && currentAddCount >= EMARiskStartAddCount) {
|
|
if(!PassesEMARisk(posType)) {
|
|
string direction2 = (posType == POSITION_TYPE_BUY) ? "多单" : "空单";
|
|
Print(direction2, " EMA风控未通过（AddCount=", currentAddCount, ", 阈值=", EMARiskStartAddCount,
|
|
", EMA", EMARiskPeriod, ")，暂停加仓");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// 检查ADX条件（趋势强度）
|
|
if(EnableADXFilter) {
|
|
double adx = GetADX();
|
|
if(adx > ADXThreshold) {
|
|
string direction = (posType == POSITION_TYPE_BUY) ? "多单" : "空单";
|
|
Print(direction, "ADX值过高(", adx, " > ", ADXThreshold, ")，暂停加仓");
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 写回全局变量 |
|
|
//+------------------------------------------------------------------+
|
|
void UpdateGlobalVariables(int posType, double lastAddPrice, double lastAddLots, int currentAddCount) {
|
|
if(posType == POSITION_TYPE_BUY) {
|
|
lastLongAddPrice = lastAddPrice;
|
|
lastLongAddLots = lastAddLots;
|
|
buyAddCount = currentAddCount;
|
|
} else {
|
|
lastShortAddPrice = lastAddPrice;
|
|
lastShortAddLots = lastAddLots;
|
|
sellAddCount = currentAddCount;
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 检查80%移动追踪止盈条件，达到后全部平仓 |
|
|
//+------------------------------------------------------------------+
|
|
void CheckTrailingTakeProfit(int posType, double currentPrice, double avgPrice) {
|
|
// 检查盈亏平衡价是否有效
|
|
if(avgPrice == 0) {
|
|
return;
|
|
}
|
|
|
|
// 计算80%移动追踪止盈价格
|
|
double trailingPrice = 0;
|
|
if(posType == POSITION_TYPE_BUY) {
|
|
// 多单：当前价格 - (当前价格 - 盈亏平衡价) × 80%
|
|
double profitDistance = currentPrice - avgPrice;
|
|
if(profitDistance <= 0) return; // 没有利润，不检查
|
|
trailingPrice = currentPrice - (profitDistance * 0.3);
|
|
|
|
// 更新多单移动追踪止盈位（取最高值）
|
|
if(trailingPrice > buyTrailingPrice || buyTrailingPrice == 0) {
|
|
buyTrailingPrice = trailingPrice;
|
|
Print("多单移动追踪止盈位更新:", buyTrailingPrice, " 当前价:", currentPrice, " 盈亏平衡价:", avgPrice);
|
|
}
|
|
|
|
// 使用历史最高止盈位进行检查
|
|
trailingPrice = buyTrailingPrice;
|
|
} else {
|
|
// 空单：当前价格 + (盈亏平衡价 - 当前价格) × 80%
|
|
double profitDistance = avgPrice - currentPrice;
|
|
if(profitDistance <= 0) return; // 没有利润，不检查
|
|
trailingPrice = currentPrice + (profitDistance * 0.3);
|
|
|
|
// 更新空单移动追踪止盈位（取最低值）
|
|
if(trailingPrice < sellTrailingPrice || sellTrailingPrice == 0) {
|
|
sellTrailingPrice = trailingPrice;
|
|
Print("空单移动追踪止盈位更新:", sellTrailingPrice, " 当前价:", currentPrice, " 盈亏平衡价:", avgPrice);
|
|
}
|
|
|
|
// 使用历史最低止盈位进行检查
|
|
trailingPrice = sellTrailingPrice;
|
|
}
|
|
|
|
// 规范化价格
|
|
trailingPrice = NormalizeDouble(trailingPrice, _Digits);
|
|
|
|
// 检查是否达到移动追踪止盈条件
|
|
bool shouldClose = false;
|
|
if(posType == POSITION_TYPE_BUY) {
|
|
// 多单：当前价格回撤到移动止盈位以下
|
|
shouldClose = (currentPrice <= trailingPrice);
|
|
} else {
|
|
// 空单：当前价格反弹到移动止盈位以上
|
|
shouldClose = (currentPrice >= trailingPrice);
|
|
}
|
|
|
|
if(shouldClose) {
|
|
Print("达到80%移动追踪止盈条件，", (posType == POSITION_TYPE_BUY) ? "多单" : "空单", " 当前价:", currentPrice, " 移动止盈位:", trailingPrice);
|
|
|
|
// 调用现有的平仓函数
|
|
ClosePosition(posType);
|
|
Print("80%移动追踪止盈平仓完成");
|
|
|
|
// 重置移动追踪止盈位
|
|
if(posType == POSITION_TYPE_BUY) {
|
|
buyTrailingPrice = 0;
|
|
} else {
|
|
sellTrailingPrice = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 入场条件检查函数 |
|
|
//+------------------------------------------------------------------+
|
|
bool CheckEntryFirst(int posType, double rsi, double rsiThreshold, double totalLots) {
|
|
// 1. 检查是否已有持仓
|
|
if(totalLots > 0) return false;
|
|
|
|
// 2. 检查时间段是否允许开仓
|
|
if(!IsTradingTime()) {
|
|
Print("当前时间不在允许开仓的时间段内，禁止开仓");
|
|
return false;
|
|
}
|
|
|
|
// 3. 检查RSI过滤条件
|
|
bool shouldEnter = false;
|
|
if(EnableRSIFilter) {
|
|
shouldEnter = (posType == POSITION_TYPE_BUY) ? (rsi < rsiThreshold) : (rsi > rsiThreshold);
|
|
} else {
|
|
shouldEnter = true; // 不用RSI过滤时，只要没持仓就允许开仓
|
|
}
|
|
|
|
if(!shouldEnter) return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 计算开仓手数：可选动态手数（按余额比例）或固定手数 |
|
|
//+------------------------------------------------------------------+
|
|
double GetDynamicLots(int posType) {
|
|
// 规范化工具
|
|
double minLots = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
|
|
double maxLots = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
|
|
double stepLots = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
|
|
|
|
if(!EnableDynamicLots) {
|
|
// 固定手数模式：直接使用 MartinStartLots，并按交易品种步进规范化
|
|
double fixedLots = MartinStartLots;
|
|
fixedLots = MathMax(minLots, MathMin(maxLots, fixedLots));
|
|
fixedLots = NormalizeDouble(fixedLots / stepLots, 0) * stepLots;
|
|
return fixedLots;
|
|
}
|
|
|
|
// 动态手数模式：当前余额 / 基准余额 * 基准手数
|
|
double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
|
|
double baseBalance = 10000.0; // 基准余额
|
|
double baseLots = MartinStartLots; // 基准手数
|
|
double dynamicLots = (accountBalance / baseBalance) * baseLots;
|
|
|
|
// 规范化手数
|
|
dynamicLots = MathMax(minLots, MathMin(maxLots, dynamicLots));
|
|
dynamicLots = NormalizeDouble(dynamicLots / stepLots, 0) * stepLots;
|
|
return dynamicLots;
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| 马丁策略主逻辑 |
|
|
//+------------------------------------------------------------------+
|
|
void MartinLogic(int posType, double rsi, double rsiThreshold) {
|
|
double curPrice = (posType == POSITION_TYPE_BUY) ?
|
|
SymbolInfoDouble(_Symbol, SYMBOL_ASK) :
|
|
SymbolInfoDouble(_Symbol, SYMBOL_BID);
|
|
double avgPrice = GetAvgPrice(posType);
|
|
double totalLots = GetTotalLots(posType);
|
|
|
|
double lastAddPrice = (posType == POSITION_TYPE_BUY) ? lastLongAddPrice : lastShortAddPrice;
|
|
double lastAddLots = (posType == POSITION_TYPE_BUY) ? lastLongAddLots : lastShortAddLots;
|
|
int currentAddCount = (posType == POSITION_TYPE_BUY) ? buyAddCount : sellAddCount;
|
|
string direction = (posType == POSITION_TYPE_BUY) ? "多单" : "空单";
|
|
|
|
// 计算实际点数（美金转点数），加仓距离采用动态计算
|
|
int multiplier = (PriceDigits == 2) ? 100 : ((PriceDigits == 3) ? 1000 : 1);
|
|
double stepDistanceUSD = CalculateDynamicAddDistanceUSD();
|
|
double stepDistance = stepDistanceUSD * multiplier;
|
|
double tpDistance = TakeProfitUSD * multiplier;
|
|
|
|
// 1. 首次进场
|
|
bool shouldEnter = CheckEntryFirst(posType, rsi, rsiThreshold, totalLots);
|
|
|
|
if(shouldEnter) {
|
|
ExecuteOpenPosition(posType, rsi, rsiThreshold, curPrice);
|
|
return;
|
|
}
|
|
|
|
// 2. 盈利出场
|
|
bool shouldTakeProfit = false;
|
|
if(posType == POSITION_TYPE_BUY) {
|
|
shouldTakeProfit = (totalLots > 0 && curPrice >= avgPrice + tpDistance * SymbolInfoDouble(_Symbol, SYMBOL_POINT));
|
|
} else {
|
|
shouldTakeProfit = (totalLots > 0 && curPrice <= avgPrice - tpDistance * SymbolInfoDouble(_Symbol, SYMBOL_POINT));
|
|
}
|
|
if(shouldTakeProfit) {
|
|
ClosePosition(posType);
|
|
lastAddPrice = 0;
|
|
lastAddLots = 0;
|
|
currentAddCount = 0;
|
|
|
|
// 为所有同方向持仓设置80%追踪止盈TP
|
|
// CheckTrailingTakeProfit(posType, curPrice, avgPrice);
|
|
|
|
// 写回全局变量
|
|
UpdateGlobalVariables(posType, lastAddPrice, lastAddLots, currentAddCount);
|
|
|
|
// 平仓后立即检查是否可以开新的首仓
|
|
bool shouldEnter = CheckEntryFirst(posType, rsi, rsiThreshold, 0); // 传入0因为刚平仓，没有持仓
|
|
if(shouldEnter) {
|
|
ExecuteOpenPosition(posType, rsi, rsiThreshold, curPrice);
|
|
}
|
|
|
|
return;
|
|
}
|
|
// 4. 马丁加仓
|
|
bool shouldAdd = CheckAddPosition(posType, curPrice, lastAddPrice, stepDistance, totalLots, currentAddCount);
|
|
|
|
if(shouldAdd) {
|
|
double nextLots = NormalizeDouble(lastAddLots * MartinMultiplier, 2);
|
|
OpenPosition(posType, nextLots, curPrice, OrderComment);
|
|
lastAddPrice = curPrice;
|
|
lastAddLots = nextLots;
|
|
currentAddCount++; // 增加加仓次数
|
|
Print("马丁加仓", direction, "，价格:", curPrice, " 手数:", nextLots, " 加仓次数:", currentAddCount, "/", MaxAddCount);
|
|
UpdateGlobalVariables(posType, lastAddPrice, lastAddLots, currentAddCount);
|
|
return;
|
|
}
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert tick function |
|
|
//+------------------------------------------------------------------+
|
|
void OnTick() {
|
|
double rsi = GetRSI();
|
|
|
|
// 马丁策略逻辑
|
|
if(EnableBuy)
|
|
MartinLogic(POSITION_TYPE_BUY, rsi, RSILowerLevel); // 多单马丁
|
|
if(EnableSell)
|
|
MartinLogic(POSITION_TYPE_SELL, rsi, RSIUpperLevel); // 空单马丁
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert initialization function |
|
|
//+------------------------------------------------------------------+
|
|
int OnInit() {
|
|
// 打印允许开仓的时间段
|
|
Print("=== RSI策略EA初始化 ===");
|
|
Print("允许开仓的时间段: ", TradingHours);
|
|
Print("最大加仓次数: ", MaxAddCount);
|
|
Print("ADX过滤功能: ", (EnableADXFilter ? "启用" : "禁用"));
|
|
if(EnableADXFilter) {
|
|
Print("ADX过滤阈值: ", ADXThreshold);
|
|
}
|
|
Print("当前服务器时间: ", TimeToString(TimeCurrent(), TIME_DATE|TIME_MINUTES));
|
|
|
|
return(INIT_SUCCEEDED);
|
|
}
|
|
|
|
//+------------------------------------------------------------------+
|
|
//| Expert deinitialization function |
|
|
//+------------------------------------------------------------------+
|
|
void OnDeinit(const int reason) {
|
|
if(rsiHandle != INVALID_HANDLE)
|
|
IndicatorRelease(rsiHandle);
|
|
if(adxHandle != INVALID_HANDLE)
|
|
IndicatorRelease(adxHandle);
|
|
if(ema12Handle != INVALID_HANDLE)
|
|
IndicatorRelease(ema12Handle);
|
|
if(atrHandle != INVALID_HANDLE)
|
|
IndicatorRelease(atrHandle);
|
|
if(emaRiskHandle != INVALID_HANDLE)
|
|
IndicatorRelease(emaRiskHandle);
|
|
} |