I will code your EAs and Indicators for no charge

I did much the same with the same results.

I figured you with your excelent searching ability might come up with something more.

I thank you for trying anyway.

Posting again
Respected coders, Please code EA for mt4 and mt5 please
Pair: Nas100
Time: 5 minutes
Indicator used: EMA 8
Buy rule: price/candle is above the EMA. After red candle formed, next candle must be bullish and break the low of bearish candle. We will buy after breakout of bullish candle
Sell rule: price/candle is below the EMA. After bullish candle formed, next candle must be bearish one and break the high of bullish candle. We will sell at the breakout of bearish candle.
Also add position size calculator which calculate risk per trade. 0.5% risk per trade. Thanks
Screenshot attached

Dear Coders,

Is there somebody in this forum who can fix some errors/warnings in the attached EA?
I would appreciate that very much.

With Regards,
Herman

Then I strongly suggest that you learn, beacuse if you don't know such basic things, you also don't what you are dealing with.
And that's like looking into a gun barrel when the gun is loaded, slide lock open, and you are holding the trigger...

There are so many things wrong with this code, I don't even feel like touching it!
Please don't use it!!!
If you coded it, you have got a lot to learn!

Hi dear coders is it posibb6 to develop an Ea based on this
Morning Candle

Identify key levels: The strategy first identifies the high and low of the given time candle like 11:00 AM candle and uses these two levels as key reference levels.

Entry Signals:

• Long signal: When the closing price breaks through the morning high for two consecutive K-lines, a long signal is triggered.

• Short signal: When the closing price falls below the morning low for two consecutive K-lines, a short signal is triggered.

Stop Loss Setting:

• Long Stop Loss: Set at the low of the morning candle.

• Short Stop: Set at the high of the morning candle.

Exit Mechanism:

• Stop loss hit
• Take Profit hit

• Time exit: All positions are automatically closed at difined to control overnight risks.

Trading time limit: The strategy will not open new transactions after defined time to avoid abnormal fluctuations before closing.

Stretergy code

// Define the time variables
var bool morningCandleFound = false
var float morningHigh = na
var float morningLow = na
var bool inTrade = false
var int tradeDirection = 0 // 0: No trade, 1: Buy Call, -1: Buy Put
var bool noNewTrades = false // To prevent new trades after 15:15

// Identify the high and low of the 11:00 morning candle
if (hour == 11 and minute == 0)
morningHigh := high
morningLow := low
morningCandleFound := true

// Plot the high and low of the 11:00 morning candle
plot(morningHigh, title="11:00 morning High", color=color.green, linewidth=2)
plot(morningLow, title="11:00 morning Low", color=color.red, linewidth=2)

// Conditions for Buy Call and Buy Put signals
var bool buyCallCondition = false
var bool buyPutCondition = false

if (morningCandleFound and (hour > 11 or (hour == 11 and minute > 0)) and not noNewTrades)
// Check for Buy Call condition
if (close[1] > morningHigh and close > morningHigh)
if (not inTrade or tradeDirection != 1)
strategy.entry("Buy Call", strategy.long, stop=morningLow)
buyCallCondition := true
inTrade := true
tradeDirection := 1
label.new(bar_index, high, "Buy Call", color=color.green)
alert("Buy Call: Price crossed morning high", alert.freq_once_per_bar_close)
else if (close[1] <= morningHigh)
buyCallCondition := false

// Check for Buy Put condition
if (close[1] < morningLow and close < morningLow)
if (not inTrade or tradeDirection != -1)
strategy.entry("Buy Put", strategy.short, stop=morningHigh)
buyPutCondition := true
inTrade := true
tradeDirection := -1
label.new(bar_index, low, "Buy Put", color=color.red)
alert("Buy Put: Price crossed morning low", alert.freq_once_per_bar_close)
else if (close[1] >= morningLow)
buyPutCondition := false

// Exit conditions
if (inTrade)
if (tradeDirection == 1 and low <= morningLow)
strategy.close("Buy Call")
label.new(bar_index, low, "Exit Call", color=color.red)
alert("Exit Call: Price fell below stop", alert.freq_once_per_bar_close)
buyCallCondition := false
inTrade := false
tradeDirection := 0
if (tradeDirection == -1 and high >= morningHigh)
strategy.close("Buy Put")
label.new(bar_index, high, "Exit Put", color=color.green)
alert("Exit Put: Price rose above stop", alert.freq_once_per_bar_close)
buyPutCondition := false
inTrade := false
tradeDirection := 0

// Close all positions at 15:15 and prevent new trades for the rest of the day
if (hour == 15 and minute == 15)
strategy.close_all()
inTrade := false
tradeDirection := 0
noNewTrades := true
alert("Close All Positions at 15:15", alert.freq_once_per_bar_close)

// Reset noNewTrades at the start of a new day
if (hour == 11 and minute == 0)
noNewTrades := false

Thanks for your reply BestTraderEV.
I dit not coded it but I agree I have a lot to learn.
Herman

hi coder
please code mt4 indicator

below the trdaing view code



Pine Script indicator
Volatility Adjusted Grid [Gann]

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
// @fareidzulkifli
// @version=4

study("Volatility Adjusted Grid [Gann]", shorttitle = "Volatility Adjusted Grid", overlay = true, precision=4)

//-----------------------
// Parameter
//-----------------------
source = close
group = "Style"
typ1 = "Solid", typ2 = "Dashed", typ3 = "Dotted"
ext1 = "Left", ext2 = "None"
alert1 = "Once per Bar", alert2 = "Once per Bar Close"

maxline = input(15, title = "No. of S&R Lines", minval=1, maxval=20, tooltip = "No. of each S & R\n20 means 20 Resistance and 20 Support")
atr_size = input(1.5, title = "Range Size", minval=.1, maxval=10., step=0.1, tooltip = "Smaller Number indicates tighter range\nMin Val=0.1\nMax Val = 10.0")
disp_rguide = input(true, title = "Range Guide", tooltip = "Display Range Size guide to find next bigger/smaller range at bottom left of the chart")
in_ext = input(ext1, title = "Line Extension", group = group, options=[ext1, ext2])
c_style = input(typ1, title = "Cardinal Cross Style", group = group, options=[typ1, typ2, typ3])
o_style = input(typ3, title = "Ordinal Cross Style", group = group, options=[typ1, typ2, typ3])
g_col = input(color.new(#606060, 35), title = "Line Color", group = group)
alert_typ = input(alert2, title = "Alert Frequency", group = "Alert", options=[alert1, alert2])

//-----------------------
var cardinal = c_style == typ1 ? line.style_solid : c_style == typ2 ? line.style_dashed : line.style_dotted
var ordinal = o_style == typ1 ? line.style_solid : o_style == typ2 ? line.style_dashed : line.style_dotted
var ext_type = in_ext == ext1 ? extend.left : extend.none

//-----------------------
// Generate Gann Square of 9 Sequence
//-----------------------
var table_size = 1200
var gann_table = array.new_float()
var val = 1
var increment = 1
var diag_check = 3

if(barstate.isfirst)
array.push(gann_table, 1)

for cnt = 0 to table_size-1
val := val+increment
array.push(gann_table, val)

if(val==pow(diag_check,2))
increment += 1
diag_check += 2

//-----------------------
// Funtions
//-----------------------
get_mult(_val, adj)=>
float initial = 0.00001
float res = initial
float check = na

int cnt_run = 0
for i = 0 to 12
check := adj * (initial * pow(10., i))
cnt_run := cnt_run+1
if(_val < check)
res := 100.0/(initial * pow(10., i))
break

[res, cnt_run]

get_idx(_src)=>
int idx = array.indexof(gann_table, _src)
float tmp = 0
int res = na, int r_idx = na, int s_idx = na

// if src==gann
if(idx!=-1)
r_idx := idx+1

// if src != gann
if(idx==-1)
for cnt = 0 to (array.size(gann_table)-1)

tmp := array.get(gann_table, cnt)
if(tmp>_src and not r_idx)
r_idx := cnt
if(r_idx)
break

res := r_idx

f_line(_yloc, _idx)=>
line.new(
x1 = bar_index-50, x2 = bar_index+10, xloc=xloc.bar_index,
y1 = _yloc, y2 = _yloc,
style = _idx%2==1 ? cardinal : ordinal,
extend = ext_type,
color = g_col)

f_label(_txt, _yloc) =>
label.new(
x = bar_index+10, xloc = xloc.bar_index,
y = _yloc,
text = _txt,
color = #00000000,
textcolor = g_col,
size = size.normal,
style = label.style_label_left,
textalign = text.align_left)

//-----------------------
// Main Calculation
//-----------------------
varip int r_loc = na // Keep index of SnR levels array
varip int s_loc = na
varip float r1 = na // Temporary placeholder to check the range size
varip float s1 = na
varip r_list = array.new_float() // Array to keep SnR level intrabar //workaround as varip cant be use with line array
varip s_list = array.new_float()
var g_line = array.new_line() // Array for drawing SnR Lines
var g_lbl = array.new_label() // Array for drawing SnR Price Labels
varip float curr_size = na
varip float prev_size = na
varip int run_num = 0 // Keep track no of execution of main calculation since it may go up to 1000+ iterations per run
varip int count_run = 0 // Keep track no of execution of main calculation since it may go up to 1000+ iterations per run

//-----------------------
float atr = sma(tr, 30)
int lookback = max(min(bar_index, 20), 1)
float range = na
float range2 = (highest(high, lookback) - lowest(low, lookback)) // Alternative when atr not available
float mult = na
float src = na
float min_range = atr[1] * atr_size

//-----------------------
if(barstate.isnew) // reset on newbar
run_num := 0
count_run := 0
r_loc := na, r1 := na
s_loc := na, s1 := na
curr_size := na
prev_size := na
array.clear(r_list)
array.clear(s_list)

if(barstate.islast and run_num == 0)
run_num += 1

for i = 0.0 to 4.5 by 0.5 //10 iterations max
for j = 1 to 10 //10 iterations max
range := atr * (j*3)
[_mul,_run] = get_mult(nz(range, range2), (5-i)) //12 iterations max
mult := _mul
src := floor(source*mult)

r_loc := get_idx(src)
s_loc := r_loc-1
r1 := round_to_mintick(array.get(gann_table, r_loc)/mult)
s1 := round_to_mintick(array.get(gann_table, s_loc)/mult)
count_run := count_run + 1 //+ _run
curr_size := r1-s1

if(curr_size >= min_range) //break loop if found
break

prev_size := curr_size

if(curr_size >= min_range) //break loop if found
break

for i=0 to maxline-1
float r_val = r_loc + i < 0 or r_loc + i > table_size-1 ? na : round_to_mintick(array.get(gann_table, r_loc + i)/mult)
float s_val = s_loc - i < 0 or s_loc - i > table_size-1 ? na : round_to_mintick(array.get(gann_table, s_loc - i)/mult)

if(r_val)
array.push(r_list, r_val)

if(s_val)
array.push(s_list, s_val)

//-----------------------
// S/R Drawing
//-----------------------
float _temp = na
int r_size = array.size(r_list)
int s_size = array.size(s_list)

if(barstate.islast)
if(array.size(g_line) > 0)
for z = 0 to array.size(g_line)-1
oldline = array.shift(g_line)
line.delete(oldline)

if(array.size(g_lbl) > 0)
for z = 0 to array.size(g_lbl)-1
oldlbl = array.shift(g_lbl)
label.delete(oldlbl)

if(r_size>0)
for i=0 to r_size-1
_temp := array.get(r_list, i)
array.push(g_line, f_line(_temp, r_loc+i))
array.push(g_lbl, f_label("("+tostring(_temp, format.mintick)+")", _temp))

if(s_size>0)
for i=0 to s_size-1
_temp := array.get(s_list, i)
array.push(g_line, f_line(_temp, s_loc-i))
array.push(g_lbl, f_label("("+tostring(_temp, format.mintick)+")", _temp))

//-----------------------
// Alert
//-----------------------

alertup = (crossover(close, r1) or (close[1] < close and close==r1))
alertdn = (crossunder(close, s1) or (close[1] > close and close==s1))

string alerttxt = na

if(alertup)
alerttxt :="Cross Above "+ tostring(r1, format.mintick)
if(alertdn)
alerttxt :="Cross Below " + tostring(s1, format.mintick)

var alert_freq = alert_typ==alert1 ? alert.freq_once_per_bar : alert.freq_once_per_bar_close

if(alertup or alertdn)
alert(alerttxt, alert_freq)

//-----------------------
// Table for Range Guideline
//-----------------------
var PTable = table.new(position = position.bottom_left, columns = 2, rows = 2)
prv_range = prev_size/atr[1] > 0.1 ? tostring(prev_size/atr[1], "0.00") : "Not Available"
nxt_range = curr_size/atr[1] < 10 and count_run < 80 ? tostring(curr_size/atr[1], "0.00") : "Not Available"

if(barstate.islast and disp_rguide)
table.cell(PTable, 0, 0, text="Previous Range: ", text_color=g_col, text_halign=text.align_left, text_size=size.small)
table.cell(PTable, 1, 0, text="< " + prv_range, text_color=g_col, text_halign=text.align_left, text_size=size.small)
table.cell(PTable, 0, 1, text="Next Range: ", text_color=g_col, text_halign=text.align_left, text_size=size.small)
table.cell(PTable, 1, 1, text="> " + nxt_range, text_color=g_col, text_halign=text.align_left, text_size=size.small)

I fixed the compiler warnings and errors, but there are more issues that need to be addressed.

Also:
https://www.mql5.com/en/market/produ...ource=External

Another:

Use the "code" option when pasting code or supply the source file (you can use .txt for Pinescript)

Or, in the simplest option, just paste the link to TradingView:
https://www.tradingview.com/script/W...ted-Grid-Gann/

Would a brilliant coder be willing to modify this indicator? This would be nice tool for visual analysis.
In advance I send many thank yous!

BestTraderEv,

I know this is in the wrong forum, but the question is specific to you. What would 2 deviations of the 200 EMA be?
Thank you for your response when time allows. Your help & views are most appreciated.

Thank you Tony for the link.
Though this is not the one I'm looking for.

please i have been searching i cant find on NET, maybe such EA exist, or maybe i dont know the right word. all i see is trailing when in profit
is there an EA that have option to trail only when current trade is negative, or start trailing when a current trade running is minus xxx the account
just as if Breakeven EA is working in reverse, is it possible to reverse BE function to the negative side?

Sure, you just need to adjust the EA.
This will probably work if you input a negative value for trailing.
Can't say for sure if I don't have the EA source code.
I don't know if the EA has some positive value to start trailing?
If it does, you can try setting it to a negative value.

Good Day Everyone.
I have tried to code pivot however, I know little about coding but I have tried, I kindly request to be assisted on these matters.

1. I would like my pivot to have comments on support and resistance.

2. I would like it only to display resistance areas only when the market is bullish and only shows support areas when it's bearish.
3. I would like it to have a comment ontop which will state the bullish or bearish trend.

Thank you in advance.

Please see the attached sources file.

As far as PivotPoints, we don't need to reinvent the wheel:
MT4:
https://www.forexfactory.com/thread/...indicator-ever
MT5:
https://www.mql5.com/en/code/95
https://forex-station.com/attach/file/3470585

As far as your requests for trend filters, you need to define what you mean by "bullish trend" and what you mean by "bearish trend".
How will the code know when the market is bullish, and when the market is bearish?

IOW, you are asking for a very specific modification of PivotPoints, but you didn't define according to what should the indicator recognise the trend.
And, if anyone had that Holy Grail, we would already know about it.
It would be on every news all around the world.

Also, how will the code know what will be resistance, and what will be support?
Every PivotPoint can be support or resistance, or even both.
And we will never know until after the fact...

There is one idea here:
https://www.forexstrategiesresources...rading-system/