I will code your EAs and Indicators for no charge

thank you Sir, i have tried this, its not working and it has other functions i dont need,
its not working when i zero them and on default its not working, thank you for your effort to help
please if you can help to make it work i marked most important

Good afternoon.
Please write Expert on the basis of standard terminal indicators AC + AO.
Opening a position when the color matches. Color change feedback.
take + stop.
It is important to work on non-standard charts (Renko, Ranger bars, etc.)
Thank you in advance

this is the correction i was able to make as instructed according to your guide in the updated version, please help me correct the error its showing event handling function not found i dont know what it means and also help me compile it to mt4 and mt5 ea after the correction so that it can be used on both platforms,thanks for your assistance remain blessed because i know u r already blessed

// MACD Expert Advisor with Candlestick Pattern Detection
// Parameters: FastEMA = 21, SlowEMA = 13, SignalSMA = 8
input int FastEMA = 21;
input int SlowEMA = 13;
input int SignalSMA = 8;
input double LotSize = 0.01; // Fixed lot size
input double StopLossPercentage = 0.5; // Stop loss as a percentage of ADR
input double TakeProfitPercentage = 1.0; // Take profit as a percentage of ADR
input int NumberOfTrades = 5; // Number of trades to execute
input int MagicNumber = 123456; // Unique identifier for trades
input string Comment = "MACD EA"; // Comment for trades
input double TrailingStopPips = 20; // Trailing stop in pips
input bool EnableNewsFilter = true; // Enable economic news filter
input int NewsImpactLevel = 2; // Minimum impact level of news to consider
input bool EnableATRFilter = true; // Enable ATR filter
input double ATRMultiplier = 2.0; // ATR multiplier for filtering
input bool EnableCandlestickPattern = true; // Enable candlestick pattern detection
input double MaxRiskPercent = 2.0; // Maximum risk per trade as a percentage of account equity
input int VolatilityPeriod = 14; // Period for calculating market volatility
input double VolatilityThreshold = 0.5; // Minimum volatility level to trade
input int TrendConfirmationPeriod = 20; // Period for confirming the trend
input bool CloseOnReversal = false; // Close trade on market reversal
input string IndicatorNames = ""; // Names of multiple indicators separated by comma
input int MaxTradesPerStrategy = 3; // Maximum number of trades per strategy
input int MaxTotalTrades = 10; // Maximum total number of trades
input bool UseVolatilityFilter = true; // Enable volatility filter
input double MinVolatilityPercent = 0.5; // Minimum volatility level as a percentage of average true range (ATR)
input bool UseTradeExitStrategy = true; // Enable trade exit strategy
input int NewsImpactFilter = 2; // Minimum impact level of news to trade (0 - Low, 1 - Medium, 2 - High)
input bool UseDiversification = true; // Enable diversification of trading strategy
input int MaxTradesPerSymbol = 1; // Maximum number of trades per symbol
// Global variables
double macdBuffer[];
double signalBuffer[];
double histogramBuffer[];
// Candlestick pattern enumeration
enum CandlestickPattern
{
BULLISH_ENGULFING,
BEARISH_ENGULFING,
HAMMER,
HANGING_MAN,
SHOOTING_STAR,
INVERTED_HAMMER,
DOJI,
SPINNING_TOP,
PIERCING_LINE,
THREE_WHITE_SOLDIERS,
THREE_STARS_IN_THE_SOUTH,
DRAGONFLY_DOJI,
THREE_OUTSIDE_UP,
THREE_OUTSIDE_DOWN,
GRAVESTONE_DOJI,
DARK_CLOUD_COVER,
THREE_INSIDE_UP,
THREE_INSIDE_DOWN,
ABANDONED_BABY,
THREE_BLACK_CROWS,
MARUBOZU,
KICKING,
TRI_STAR,
LADDER_BOTTOM,
DOWNSIDE_GAP_THREE_METHODS,
TASUKI_GAP,
MATCHING_LOW,
ENGULFING,
HARAMI,
MORNING_STAR,
EVENING_STAR,
BELT_HOLD,
COUNTER_ATTACK,
SEPARATING_LINES,
DOJI_STAR,
MEETING_LINES,
KICKING_BULL_BEAR,
STALLED_PATTERN,
UNIQUE_THREE_RIVER_BOTTOM,
UPSIDE_GAP_TWO_CROWS,
HANGING_MAN_AT_NECKLINE,
BELT_HOLD_AT_NECKLINE,
UPSIDE_TASUKI_GAP,
TWO_CROWS,
THREE_CROWS,
ADVANCE_BLOCK,
THREE_METHODS,
SIDE_BY_SIDE_WHITE_LINES,
SIDE_BY_SIDE_BLACK_LINES,
HIGH_WAVE,
SPINNING_TOP_DOJI,
UP_GAP_TWO_CROWS,
DOWN_GAP_THREE_METHODS,
TRISTAR_DOJI,
ABANDONED_BABY_DOJI,
TWO_CROWS_DOJI,
THREE_BLACK_CROWS_DOJI,
THREE_INSIDE_UP_DOJI,
THREE_OUTSIDE_DOWN_DOJI,
GRAVESTONE_DOJI_DOJI,
MORNING_DOJI_STAR,
MORNING_STAR_DOJI,
DRAGONFLY_DOJI_DOJI,
EVENING_DOJI_STAR,
EVENING_STAR_DOJI,
SHOOTING_STAR_DOJI,
HARAMI_CROSS,
HARAMI_DOJI,
HANGING_MAN_DOJI,
BELT_HOLD_DOJI,
UPSIDE_GAP_TWO_CROWS_DOJI,
UPSIDE_GAP_TWO_CROWS_DOJI_DOJI,
TRISTAR_DOJI_DOJI,
HARAMI_DOJI_DOJI,
THREE_METHODS_DOJI,
THREE_METHODS_DOJI_DOJI,
THREE_BLACK_CROWS_DOJI_DOJI,
STALLED_PATTERN_DOJI,
ABANDONED_BABY_DOJI_DOJI,
SIDE_BY_SIDE_WHITE_LINES_DOJI,
SPINNING_TOP_DOJI_DOJI,
THREE_CROWS_DOJI,
THREE_INSIDE_DOWN_DOJI,
THREE_INSIDE_UP_DOJI_DOJI,
BELT_HOLD_DOJI_DOJI,
DOWNSIDE_GAP_THREE_METHODS_DOJI,
THREE_OUTSIDE_DOWN_DOJI_DOJI,
THREE_OUTSIDE_UP_DOJI,
SEPARATING_LINES_DOJI,
HIGH_WAVE_DOJI,
ENGULFING_DOJI,
SIDE_BY_SIDE_BLACK_LINES_DOJI,
LADDER_BOTTOM_DOJI,
UNIQUE_THREE_RIVER_BOTTOM_DOJI,
TWO_CROWS_DOJI_DOJI
};
// Function to check if a given value is within a range
bool isWithinRange(double value, double lowerBound, double upperBound)
{
return value >= lowerBound && value <= upperBound;
}
// Function to check for a bullish engulfing pattern
bool isBullishEngulfing(int index)
{
double prevClose = iClose(NULL, 0, index + 1);
double prevOpen = iOpen(NULL, 0, index + 1);
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);

return currentOpen < prevOpen && currentClose > prevClose && currentOpen > prevClose && currentClose < prevOpen;
}
// Function to check for a bearish engulfing pattern
bool isBearishEngulfing(int index)
{
double prevClose = iClose(NULL, 0, index + 1);
double prevOpen = iOpen(NULL, 0, index + 1);
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);

return currentOpen > prevOpen && currentClose < prevClose && currentOpen < prevClose && currentClose > prevOpen;
}
// Function to check for a hammer pattern
bool isHammer(int index)
{
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);
double currentHigh = iHigh(NULL, 0, index);
double currentLow = iLow(NULL, 0, index);

double bodySize = MathAbs(currentClose - currentOpen);
double upperShadowSize = currentHigh - MathMax(currentOpen, currentClose);
double lowerShadowSize = MathMin(currentOpen, currentClose) - currentLow;

return bodySize < upperShadowSize && bodySize < lowerShadowSize && currentClose > currentOpen && upperShadowSize >= 2 * bodySize;
}
// Function to check for a hanging man pattern
bool isHangingMan(int index)
{
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);
double currentHigh = iHigh(NULL, 0, index);
double currentLow = iLow(NULL, 0, index);

double bodySize = MathAbs(currentClose - currentOpen);
double upperShadowSize = currentHigh - MathMax(currentOpen, currentClose);
double lowerShadowSize = MathMin(currentOpen, currentClose) - currentLow;

return bodySize < upperShadowSize && bodySize < lowerShadowSize && currentClose < currentOpen && upperShadowSize >= 2 * bodySize;
}
// Function to check for a shooting star pattern
bool isShootingStar(int index)
{
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);
double currentHigh = iHigh(NULL, 0, index);
double currentLow = iLow(NULL, 0, index);

double bodySize = MathAbs(currentClose - currentOpen);
double upperShadowSize = currentHigh - MathMax(currentOpen, currentClose);
double lowerShadowSize = MathMin(currentOpen, currentClose) - currentLow;

return bodySize < upperShadowSize && bodySize < lowerShadowSize && currentClose < currentOpen && lowerShadowSize >= 2 * bodySize;
}
// Function to check for an inverted hammer pattern
bool isInvertedHammer(int index)
{
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);
double currentHigh = iHigh(NULL, 0, index);
double currentLow = iLow(NULL, 0, index);

double bodySize = MathAbs(currentClose - currentOpen);
double upperShadowSize = currentHigh - MathMax(currentOpen, currentClose);
double lowerShadowSize = MathMin(currentOpen, currentClose) - currentLow;

return bodySize < upperShadowSize && bodySize < lowerShadowSize && currentClose > currentOpen && lowerShadowSize >= 2 * bodySize;
}
// Function to check for a doji pattern
bool isDoji(int index)
{
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);
double currentHigh = iHigh(NULL, 0, index);
double currentLow = iLow(NULL, 0, index);

double bodySize = MathAbs(currentClose - currentOpen);
double totalSize = currentHigh - currentLow;

return bodySize < 0.1 * totalSize;
}
// Function to check for a spinning top pattern
bool isSpinningTop(int index)
{
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);
double currentHigh = iHigh(NULL, 0, index);
double currentLow = iLow(NULL, 0, index);

double bodySize = MathAbs(currentClose - currentOpen);
double totalSize = currentHigh - currentLow;

return bodySize < 0.3 * totalSize;
}
// Function to check for a piercing line pattern
bool isPiercingLine(int index)
{
double prevClose = iClose(NULL, 0, index + 1);
double prevOpen = iOpen(NULL, 0, index + 1);
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);
double currentHigh = iHigh(NULL, 0, index);
double prevLow = iLow(NULL, 0, index + 1);

double bodySize = MathAbs(currentClose - currentOpen);
double totalSize = currentHigh - prevLow;

return currentOpen < prevClose && currentClose > prevOpen && bodySize >= 0.5 * totalSize && bodySize <= totalSize;
}
// Function to check for a three white soldiers pattern
bool isThreeWhiteSoldiers(int index)
{
double prevClose = iClose(NULL, 0, index + 1);
double prevOpen = iOpen(NULL, 0, index + 1);
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);
double currentHigh = iHigh(NULL, 0, index);
double prevLow = iLow(NULL, 0, index + 1);

double bodySize = MathAbs(currentClose - currentOpen);
double totalSize = currentHigh - prevLow;

return currentOpen < prevClose && currentClose > prevOpen && bodySize >= 0.5 * totalSize && bodySize <= totalSize;
}
// Function to check for a three stars in the south pattern
bool isThreeStarsInTheSouth(int index)
{
double prevClose = iClose(NULL, 0, index + 1);
double prevOpen = iOpen(NULL, 0, index + 1);
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);
double currentHigh = iHigh(NULL, 0, index);
double prevLow = iLow(NULL, 0, index + 1);

double bodySize = MathAbs(currentClose - currentOpen);
double totalSize = currentHigh - prevLow;

return currentOpen < prevClose && currentClose > prevOpen && bodySize >= 0.5 * totalSize && bodySize <= totalSize;
}
// Function to check for a dragonfly doji pattern
bool isDragonflyDoji(int index)
{
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);
double currentHigh = iHigh(NULL, 0, index);
double currentLow = iLow(NULL, 0, index);

double bodySize = MathAbs(currentClose - currentOpen);
double totalSize = currentHigh - currentLow;

return bodySize < 0.1 * totalSize && currentClose == currentHigh && currentOpen == currentLow;
}
// Function to check for a three outside up pattern
bool isThreeOutsideUp(int index)
{
double prevClose = iClose(NULL, 0, index + 1);
double prevOpen = iOpen(NULL, 0, index + 1);
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);

return currentClose > prevClose && currentOpen < prevOpen && currentClose > currentOpen && prevClose > prevOpen;
}
// Function to check for a three outside down pattern
bool isThreeOutsideDown(int index)
{
double prevClose = iClose(NULL, 0, index + 1);
double prevOpen = iOpen(NULL, 0, index + 1);
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);

return currentClose < prevClose && currentOpen > prevOpen && currentClose < currentOpen && prevClose < prevOpen;
}
// Function to check for a gravestone doji pattern
bool isGravestoneDoji(int index)
{
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);
double currentHigh = iHigh(NULL, 0, index);
double currentLow = iLow(NULL, 0, index);

double bodySize = MathAbs(currentClose - currentOpen);
double totalSize = currentHigh - currentLow;

return bodySize < 0.1 * totalSize && currentClose == currentLow && currentOpen == currentHigh;
}
// Function to check for a dark cloud cover pattern
bool isDarkCloudCover(int index)
{
double prevClose = iClose(NULL, 0, index + 1);
double prevOpen = iOpen(NULL, 0, index + 1);
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);
double currentHigh = iHigh(NULL, 0, index);

double bodySize = MathAbs(currentClose - currentOpen);
double totalSize = currentHigh - prevClose;

return currentOpen > prevClose && currentClose < prevOpen && bodySize >= 0.5 * totalSize && bodySize <= totalSize;
}
// Function to check for a three inside up pattern
bool isThreeInsideUp(int index)
{
double prevClose = iClose(NULL, 0, index + 1);
double prevOpen = iOpen(NULL, 0, index + 1);
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);

return currentClose > prevClose && currentOpen < prevOpen && currentClose < currentOpen && prevClose < prevOpen;
}
// Function to check for a three inside down pattern
bool isThreeInsideDown(int index)
{
double prevClose = iClose(NULL, 0, index + 1);
double prevOpen = iOpen(NULL, 0, index + 1);
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);

return currentClose < prevClose && currentOpen > prevOpen && currentClose > currentOpen && prevClose > prevOpen;
}
// Function to check for an abandoned baby pattern
bool isAbandonedBaby(int index)
{
double prevClose = iClose(NULL, 0, index + 1);
double prevOpen = iOpen(NULL, 0, index + 1);
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);
double currentLow = iLow(NULL, 0, index);
double prevHigh = iHigh(NULL, 0, index + 1);

return currentOpen > prevHigh && currentClose < prevClose && currentClose > prevOpen && currentLow < prevClose;
}
// Function to check for a morning star pattern
bool isMorningStar(int index)
{
double prevClose = iClose(NULL, 0, index + 2);
double prevOpen = iOpen(NULL, 0, index + 2);
double currentClose = iClose(NULL, 0, index + 1);
double currentOpen = iOpen(NULL, 0, index + 1);
double currentHigh = iHigh(NULL, 0, index + 1);
double prevLow = iLow(NULL, 0, index + 2);

return currentOpen < prevClose && currentClose > prevClose && currentClose > currentOpen && currentClose > prevOpen && currentOpen > prevLow && currentHigh > prevClose;
}
// Function to check for an evening star pattern
bool isEveningStar(int index)
{
double prevClose = iClose(NULL, 0, index + 2);
double prevOpen = iOpen(NULL, 0, index + 2);
double currentClose = iClose(NULL, 0, index + 1);
double currentOpen = iOpen(NULL, 0, index + 1);
double currentHigh = iHigh(NULL, 0, index + 1);
double prevLow = iLow(NULL, 0, index + 2);

return currentOpen > prevClose && currentClose < prevClose && currentClose < currentOpen && currentClose < prevOpen && currentOpen < prevLow && currentHigh < prevClose;
}
// Function to check for a bullish harami pattern
bool isBullishHarami(int index)
{
double prevClose = iClose(NULL, 0, index + 1);
double prevOpen = iOpen(NULL, 0, index + 1);
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);
double currentHigh = iHigh(NULL, 0, index);
double currentLow = iLow(NULL, 0, index);

double bodySize = MathAbs(currentClose - currentOpen);
double prevBodySize = MathAbs(prevClose - prevOpen);

return currentClose > currentOpen && currentOpen > prevClose && currentClose < prevOpen && bodySize < prevBodySize && currentHigh > prevOpen && currentLow < prevClose;
}
// Function to check for a bearish harami pattern
bool isBearishHarami(int index)
{
double prevClose = iClose(NULL, 0, index + 1);
double prevOpen = iOpen(NULL, 0, index + 1);
double currentClose = iClose(NULL, 0, index);
double currentOpen = iOpen(NULL, 0, index);
double currentHigh = iHigh(NULL, 0, index);
double currentLow = iLow(NULL, 0, index);

double bodySize = MathAbs(currentClose - currentOpen);
double prevBodySize = MathAbs(prevClose - prevOpen);

return currentOpen > currentClose && currentClose > prevOpen && currentOpen < prevClose && bodySize < prevBodySize && currentHigh > prevClose && currentLow < prevOpen;
}

Hey,

I found this EA and would like to know if it's possible to have orders executed based on standard Fibonacci Retracement Levels instead of the yellow trigger line which can be only defined by a fixed distance.

EA: https://www.forexfactory.com/thread/...robot-by-steve

The new logic behind this is supposed to be that orders are then executed on x fibonnaci retracement level as soon as price broke one end of the range.

BUY order example

1.) Range = 00:00 - 00:15
2.) Price breaks the low of the range at x time after 00:15
3.) Plot a Fib based on this range
4.) Price reverses back to x Fib level = BUY

SELL order example

1.) Range = 00:00 - 00:15
2.) Price breaks the high of the range at x time after 00:15
3.) Plot a Fib based on this range
4.) Price reverses back to x Fib level = SELL

Words are not enough to thank you sir. I am really really grateful for all your work sir. God bless you and God continue to bless you and your love once.

Let me use this opportunity to say thank you and God continue to bless all great coder.
BestTraderEv, BlueRain, CJA, Hanover, Jblanked, Jeanlouie, Tintep, Zbig, and all the amazing Coders,
We appreciate you all.

Thank you all great coders.

Hi Coders,

is anybody so kind to add an MovAvg on this VolumeColor Indicator?

VolumeMA as reference.

Thanks alot.
Greetings Thorsten

""

#property indicator_chart_window
#property indicator_buffers 2
#property indicator_color1 Blue
#property indicator_color2 Blue
extern int StartHour=0;
extern int EndHour=22;
extern int FontSize=0;
extern color TextColor=Silver;
double UpperCh[], LowerCh[];
int init()
{
IndicatorDigits(Digits);
SetIndexStyle(0,DRAW_LINE);
SetIndexBuffer(0,UpperCh);
SetIndexStyle(1,DRAW_LINE);
SetIndexBuffer(1,LowerCh);
return(0);
}
int deinit()
{
ObjectsDeleteAll();
return(0);
}

int start()
{
if(Bars<=3) return(0);
int ExtCountedBars=IndicatorCounted();
if (ExtCountedBars<0) return(-1);
int pos=Bars-2;
if(ExtCountedBars>2) pos=Bars-ExtCountedBars-1;
while(pos>0)
{
datetime EndTime=StrToTime(TimeToStr(Time[pos],TIME_DATE)+" "+DoubleToStr(EndHour,0)+":00");
if (Time[pos]>=EndTime && Time[pos+1]<EndTime)
{
double MaxPrice=High[pos];
double MinPrice=Low[pos];
datetime StartTime=StrToTime(TimeToStr(Time[pos],TIME_DATE)+" "+DoubleToStr(StartHour,0)+":00");
if (StartHour>EndHour) StartTime=StartTime-86400;
int pos_=pos;
while (pos_<Bars && Time[pos_]>=StartTime)
{
MinPrice=MathMin(MinPrice, Low[pos_]);
MaxPrice=MathMax(MaxPrice, High[pos_]);
pos_++;
}
int i;
for (i=pos_-1;i>=pos;i--)
{
UpperCh[i]=MaxPrice;
LowerCh[i]=MinPrice;
}
if (pos!=pos_-1)
{
string ObjName="ChannelSizeLabel "+TimeToStr(Time[pos],TIME_DATE);
string LabelText=""+DoubleToStr((MaxPrice-MinPrice)/Point,0);
if (ObjectFind(ObjName)==-1)
{
ObjectCreate(ObjName, OBJ_TEXT, 0, Time[pos], MinPrice);
}
else
{
ObjectSet(ObjName,OBJPROP_PRICE1,MinPrice);
}
ObjectSetText(ObjName, LabelText, FontSize, "Times New Roman", TextColor);
}
}
else
{
UpperCh[pos]=EMPTY_VALUE;
LowerCh[pos]=EMPTY_VALUE;
}
pos--;
}
return(0);
}

""
Could some one guide me to fix it?
The purpose of indicator is to draw horizontal trend lines at the high and low of Yesterday's Daily chart data. Next it displays High and Low Horizontal lines inside 15 minutes, 30 minutes and 1 hour time frame. It works fine in real time.

Problem: There is a bug inside the code.
Due to this reason, the indicator automatically deletes all kinds of vertical and horizontal trendlines, drawn manually by a human hand after a few minutes time.

Find the line where objects are being deleted, the line/function will probably include those words, and look up the documentation for that function and to see how to delete only certain objects you want to delete. Also when posting long bits of code, click on the </> button and paste within that.

I have no idea about it, that is why I asked for help!

Hello coders,

Any one can help convert the Daily_Open_line-Mod-X to Colsing time? Now instead of Open Price, I want Closing Price.

Thanks

Hi everyone
Can anyone of you write me a program that shows Current running equity on the chart.

You can choose any of the following and any TF High, Low or Close with this indicator :

This is quite a good one :
Margin Level, Margin, Free Margin, Equity, Balance & Account Profit
Choose font color, size, position etc. vertical or horizontal

Hey guys,

I've been testing an indicator recently called the XO indicator and it has potential, the thing is I've noticed that when using the XO indicator on different brokers the signals (dots) that it gives are not always the same and in many instances the dots are not there, or are painted on different bars, which in turn leads to having different results between various brokers. Is there any way to make the indicator have the same signals (dots) between the different brokers so its more consistent? My coding knowledge is limited and I did first try checking out the code myself, but I could not find a reason why. Any help is appreciated thank you.

Hi Guys,

I need help to fix the bug in my ea coding.
The MT4 Strategy Tester runs pretty good most of time, but when it comes to a specific signal, it will open around 5-8 trades in the same candle.
(Same time same entry)

I try so many different way to fix it, but it looks like the issue getting worst after the new try.

I even place the new SMA50 cross to reset the trigger, but it only work toward to the next signal, not the current candle.
Can someone help me to find out the solution?

Thanks

You're trying to limit something to once per candle, so simplest way is to save the current candle time of the buy or sell trade, and only take new trades if the current candle time is not equal to the last time a buy or sell trade was made, don't have to worry about resetting signals with this or that.

edit - for trading operations, it may be more useful to just not open a new trade, if a current trade of that type is open. This is to prevent new trades being made on new candles, where the entry conditions are still met and the first opened trade is still running.

sound a good idea. let me give a try. so i dont need reset signal, i just need to make sure candle time be monitor at trade entry. correct?

also, the new question that come out is how can i make signal trigger at the order of the cross.
for example, my current entry signal is price cross sma8, bb center, sma50, then open trade at sto k d move above 80
instead in the reality, trade will only open when price cross all three and sto k d move above 80 in the same time.
should i make time lapse range or something??

by using && coding, it will consider happen in same time. how can i improve the signal??

thx.

Is it possible to share the mq4 file as well please.

Also I am getting zero divide in error while clicking crude oil. Please help me fix this issue.

Objects Delete All