Currently switching between input.resolution, looking to use Security Function but can't work it out

Viewed 473

Good evening all,

I currently use the below and switch between Daily, Weekly and Monthly using the below function:

dtf = input("D", title = "Time Frame", type = input.resolution)

Is there anyway of turning the below into a function so I could use security() to pick and choose what input.resolution to plot from below "//////OUTPUTS/" in the code.

I have set the below up to work on BTCUSD if you look and test the code.

I would like for example to plot using security() the daily weekly and monthly POC (and various other plots).

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
//@version=4
study("Security Help", overlay = true)

va_percent = input(0.68, title = "Value Area", type = input.float, 
     minval = 0.1, maxval = 1, step = 0.1)
     


offset_val = input(title="Label Offset", type=input.integer, defval=6)


dtf = input("D", title = "Time Frame", type = input.resolution)
resolution = input(1, title = "Resolution", type = input.float)


dOpen = security(syminfo.tickerid, "D", open, lookahead = barmerge.lookahead_on)
plot(dOpen, " dOpen", change(dOpen) ? na : color.blue, offset = 0)
plotshape(dOpen, style=shape.labeldown, location=location.absolute, color=color.blue,  textcolor=color.white, show_last=1, text="dOpen",  offset = offset_val, transp=20, title="dOpen")



is_new_bar(t) => 
    change(time(t)) != 0

round_to_nearest(v, x) => 
    round(v / x) * x


tick_size = max(syminfo.mintick, resolution)

var a = array.new_float(0)

a_min = 0.0, a_min := nz(a_min[1], round_to_nearest(low, tick_size))
a_max = 0.0, a_max := nz(a_max[1], round_to_nearest(high, tick_size))

d_switch = is_new_bar(dtf)

if d_switch
    a_min := low
    a_max := high
    array.clear(a)

// Scaled min max
v_min = int(round_to_nearest(low - a_min, tick_size) / tick_size)
v_max = int(round_to_nearest(high - a_min, tick_size) / tick_size)

// Scaled candle range
ticks = v_max - v_min

vol = volume / (ticks == 0 ? 1 : ticks)

for i = v_min to max(v_max - 1, v_min)
    
    // Insert new low value
    if i < 0
        array.insert(a, i - v_min, vol)
        continue
    
    // Adjust index
    offset = v_min < 0 ? abs(v_min) : 0
    index = int(i + offset)
    
    // Push new high value
    if index >= array.size(a)
        array.push(a, vol)
        continue
    
    // Update existing value
    v = array.get(a, index)
    array.set(a, index, v + vol)

// Array bounds
a_min := min(a_min, round_to_nearest(low, tick_size))
a_max := max(a_max, round_to_nearest(high, tick_size))
a_size = array.size(a)

// { POC

poc_index = -1
poc_prev = -1.0
sum_vol = 0.0

for i = 0 to a_size - 1
    
    poc_current = array.get(a, i)
    sum_vol := sum_vol + poc_current
    
    if poc_current > poc_prev
        poc_prev := poc_current
        poc_index := i

// }

// { VA

va_high_index = poc_index
va_low_index  = poc_index
    
va_vol_cap = sum_vol * va_percent
sum_va_vol = array.get(a, poc_index)

for i = 1 to a_size - 1
    
    above = 0.0
    if va_high_index + 1 < a_size - 1
        above := above + nz(array.get(a, (va_high_index + 1)), 0.0)
    if va_high_index + 2 < a_size - 1
        above := above + nz(array.get(a, (va_high_index + 2)), 0.0)
        
    below = 0.0
    if va_low_index - 1 > 0
        below := below + nz(array.get(a, (va_low_index - 1)), 0.0)
    if va_low_index - 2 > 0
        below := below + nz(array.get(a, (va_low_index - 2)), 0.0)
    
    if above > below
        va_high_index := min(va_high_index + 2, a_size - 1)
        sum_va_vol  := sum_va_vol + above
    else
        va_low_index := max(va_low_index - 2, 0)
        sum_va_vol := sum_va_vol + below
        
    if sum_va_vol >= va_vol_cap or (va_low_index <= 0 and va_high_index >= a_size - 1)
        break

// }

float p_poc = 0.0
float p_va_h = 0.0
float p_va_l = 0.0

float d_poc = 0.0
float d_va_h = 0.0
float d_va_l = 0.0

d_poc  := poc_index * tick_size + a_min
d_va_h := va_high_index * tick_size + a_min
d_va_l := va_low_index  * tick_size + a_min

if is_new_bar(dtf)
    p_poc  := d_poc[1]
    p_va_h := d_va_h[1]
    p_va_l := d_va_l[1]
else
    p_poc  := p_poc[1]
    p_va_h := p_va_h[1]
    p_va_l := p_va_l[1]



//////OUTPUTS


plot(d_poc, color = color.red, title = "dPOC")
plotshape(d_poc, style=shape.labeldown, location=location.absolute, color=color.red,  textcolor=color.white, show_last=1, text="dPOC",  offset = offset_val, transp=20, title="dPOC")

plot(a_max, "dHigh", change(a_max) ? na : color.blue, offset = 0)
plotshape(a_max, style=shape.labeldown, location=location.absolute, color=color.blue,  textcolor=color.white, show_last=1, text="dHigh",  offset = offset_val, transp=20, title="dHigh")

plot(a_min, "dLow", change(a_min) ? na : color.blue, offset = 0)
plotshape(a_min, style=shape.labeldown, location=location.absolute, color=color.blue,  textcolor=color.white, show_last=1, text="dLow",  offset = offset_val, transp=20, title="dLow")

plot_d_va_high = plot(d_va_h, color = color.blue, transp = 60, title = "dVAH")
plotshape(d_va_h, style=shape.labeldown, location=location.absolute, color=color.blue,  textcolor=color.white, show_last=1, text="dVAH",  offset = offset_val, transp=20, title="dVAH")

plot_d_va_low  = plot(d_va_l, color = color.blue, transp = 60, title = "dVAL")
plotshape(d_va_l, style=shape.labeldown, location=location.absolute, color=color.blue,  textcolor=color.white, show_last=1, text="dVAL",  offset = offset_val, transp=20, title="dVAL")



plot(p_poc, " pd_POC", change(p_poc) ? na : color.red, offset = 0)
plotshape(p_poc, style=shape.labeldown, location=location.absolute, color=color.red,  textcolor=color.white, show_last=1, text="pdPOC",  offset = offset_val, transp=20, title="pdPOC")

ccvplot_p_va_h = plot(p_va_h, " pdVAH", change(p_va_h) ? na : color.green, offset = 0)
plotshape(p_va_h, style=shape.labeldown, location=location.absolute, color=color.green, textcolor=color.white, show_last=1, text="pdVAH",  offset = offset_val, transp=20, title="pdVAH")

ccvplot_p_va_l = plot(p_va_l, " pdVAL", change(p_va_l) ? na : color.green, offset = 0)
plotshape(p_va_l, style=shape.labeldown, location=location.absolute, color=color.green, textcolor=color.white, show_last=1, text="pdVAL",  offset = offset_val, transp=20, title="pdVAL")

plot(dOpen, " dOpen", change(dOpen) ? na : color.blue, offset = 0)
plotshape(dOpen, style=shape.labeldown, location=location.absolute, color=color.blue,  textcolor=color.white, show_last=1, text="dOpen",  offset = offset_val, transp=20, title="dOpen")



plot_p_va_h = plot(p_va_h, " pdVAH", change(p_va_h) ? na : color.blue, offset = 0)
plotshape(p_va_h, style=shape.labeldown, location=location.absolute, color=color.blue, textcolor=color.white, show_last=1, text="pdVAH",  offset = offset_val, transp=20, title="pdVAH")

plot_p_va_l = plot(p_va_l, " pdVAL", change(p_va_l) ? na : color.blue, offset = 0)
plotshape(p_va_l, style=shape.labeldown, location=location.absolute, color=color.blue, textcolor=color.white, show_last=1, text="pdVAL",  offset = offset_val, transp=20, title="pdVAL")

################## UPDATE ###############

Below is what I have coded so far and have to reuse the same code and change the input.resolution.

I would be very grateful if anyone can assist with making this into a function.

########Update 01/05/2021 - 1650 UK ####

The ideas I have in mind are:

No.1 To display a monitoring panel like in the below link: https://uk.tradingview.com/script/hyMIeYGK-Initial-Balance-Monitoring-Panel/ enter image description here The monitoring panel would indicate if the dOpen (for several symbols) opens outside of the pdVAL or pdVAL.

No.2 To display the outputs (plots) for different timeframes (currently I update the settings from Daily to Weekly/12 hour/6 hour/4hour. I have tried to replicate it in this link below: https://uk.tradingview.com/script/CYyx8unI-Mini-CCVs/

Also the below picture is the same indictor used 3 times to plot daily/weekly/monthly plots: (The below picture is a bit busy but I would only chose to use certain information). enter image description here

1 Answers

Monitoring panel coded for previous day VAH/VAL for multiple symbols.

enter image description here

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/
//@version=4
study("Security Help v1.0", overlay = false)

is_new_bar(t) => 
    change(time(t)) != 0

round_to_nearest(v, x) => 
    round(v / x) * x


show_ccv = input(true, title = "First check if CCV is in play", type = input.bool)
Outer = input(title="Outer Precentage", type=input.integer, defval=25, minval=0, maxval=100)
Inner = input(title="Inner Precentage", type=input.integer, defval=25, minval=0, maxval=100)



VACALC () =>

    va_percent = input(0.68, title = "Value Area", type = input.float, minval = 0.1, maxval = 1, step = 0.1)
     

    dtf = input("D", title = "Time Frame", type = input.resolution)
    resolution = input(1, title = "Resolution", type = input.float)


//    is_new_bar(t) => 
//        change(time(t)) != 0

//    round_to_nearest(v, x) => 
//        round(v / x) * x


    tick_size = max(syminfo.mintick, resolution)

    var a = array.new_float(0)

    a_min = 0.0, a_min := nz(a_min[1], round_to_nearest(low, tick_size))
    a_max = 0.0, a_max := nz(a_max[1], round_to_nearest(high, tick_size))

    d_switch = is_new_bar(dtf)

    if d_switch
        a_min := low
        a_max := high
        array.clear(a)

    // Scaled min max
    v_min = int(round_to_nearest(low - a_min, tick_size) / tick_size)
    v_max = int(round_to_nearest(high - a_min, tick_size) / tick_size)

    // Scaled candle range
    ticks = v_max - v_min

    vol = volume / (ticks == 0 ? 1 : ticks)

    for i = v_min to max(v_max - 1, v_min)
    
        // Insert new low value
        if i < 0
            array.insert(a, i - v_min, vol)
            continue
    
        // Adjust index
        offset = v_min < 0 ? abs(v_min) : 0
        index = int(i + offset)
    
        // Push new high value
        if index >= array.size(a)
            array.push(a, vol)
            continue
    
        // Update existing value
        v = array.get(a, index)
        array.set(a, index, v + vol)

    // Array bounds
    a_min := min(a_min, round_to_nearest(low, tick_size))
    a_max := max(a_max, round_to_nearest(high, tick_size))
    a_size = array.size(a)

    // { POC

    poc_index = -1
    poc_prev = -1.0
    sum_vol = 0.0

    for i = 0 to a_size - 1
    
        poc_current = array.get(a, i)
        sum_vol := sum_vol + poc_current
    
        if poc_current > poc_prev
            poc_prev := poc_current
            poc_index := i

// }

// { VA

    va_high_index = poc_index
    va_low_index  = poc_index
    
    va_vol_cap = sum_vol * va_percent
    sum_va_vol = array.get(a, poc_index)

    for i = 1 to a_size - 1
    
        above = 0.0
        if va_high_index + 1 < a_size - 1
            above := above + nz(array.get(a, (va_high_index + 1)), 0.0)
        if va_high_index + 2 < a_size - 1
            above := above + nz(array.get(a, (va_high_index + 2)), 0.0)
        
        below = 0.0
        if va_low_index - 1 > 0
            below := below + nz(array.get(a, (va_low_index - 1)), 0.0)
        if va_low_index - 2 > 0
            below := below + nz(array.get(a, (va_low_index - 2)), 0.0)
    
        if above > below
            va_high_index := min(va_high_index + 2, a_size - 1)
            sum_va_vol  := sum_va_vol + above
        else
            va_low_index := max(va_low_index - 2, 0)
            sum_va_vol := sum_va_vol + below
        
        if sum_va_vol >= va_vol_cap or (va_low_index <= 0 and va_high_index >= a_size - 1)
            break

// }
    float p_va_h = 0.0
    float p_va_l = 0.0

    float d_va_h = 0.0
    float d_va_l = 0.0

    d_va_h := va_high_index * tick_size + a_min
    d_va_l := va_low_index  * tick_size + a_min

    if is_new_bar(dtf)
        p_va_h := d_va_h[1]
        p_va_l := d_va_l[1]
    else
        p_va_h := p_va_h[1]
        p_va_l := p_va_l[1]


    pvah_  = p_va_h
    pval_  = p_va_l

    [pval_, pvah_]


///////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
Symbol01 = input(title = "Symbol Selection", defval="BYBIT:BTCUSD")
Symbol02 = input(title = "Symbol Selection", defval="BINANCE:BTCUSDT")
Symbol03 = input(title = "Symbol Selection", defval="BINANCE:ETHUSDT")
Symbol04 = input(title = "Symbol Selection", defval="BINANCE:LTCUSDT")
Symbol05 = input(title = "Symbol Selection", defval="BINANCE:MKRUSDT")
Symbol06 = input(title = "Symbol Selection", defval="BINANCE:YFIIUSDT")
Symbol07 = input(title = "Symbol Selection", defval="BINANCE:PAXGUSDT")
Symbol08 = input(title = "Symbol Selection", defval="BINANCE:COMPUSDT")


[pval_, pvah_] = VACALC ()

Sym01_pvah = security(Symbol01, timeframe.period, pvah_)
Sym01_pval = security(Symbol01, timeframe.period, pval_)


Sym01_Range = Sym01_pvah - Sym01_pval
Sym01_PercentageRange = Sym01_Range/100

Sym01_pd25VAHUp = Sym01_pvah+(Sym01_PercentageRange*Outer)
Sym01_pd25VAHDown = Sym01_pvah-(Sym01_PercentageRange*Inner)
Sym01_pd25VALUp = Sym01_pval+(Sym01_PercentageRange*Inner)
Sym01_pd25VALDown = Sym01_pval-(Sym01_PercentageRange*Outer)

Sym01_dOpen = security(Symbol01, "D", open, lookahead = barmerge.lookahead_on)

Sym01_ccv_color =  show_ccv ?
     (Sym01_dOpen < Sym01_pd25VAHUp) and (Sym01_dOpen > Sym01_pd25VAHDown) ? color.green :
     (Sym01_dOpen < Sym01_pd25VALUp) and (Sym01_dOpen > Sym01_pd25VALDown) ? color.green :
     color.red :
     na
Sym01_ccv_fill_color = Sym01_ccv_color

//////////////////////////////////////////////////////////////
Sym02_pvah = security(Symbol02, timeframe.period, pvah_)
Sym02_pval = security(Symbol02, timeframe.period, pval_)

Sym02_Range = Sym02_pvah - Sym02_pval
Sym02_PercentageRange = Sym02_Range/100

Sym02_pd25VAHUp = Sym02_pvah+(Sym02_PercentageRange*Outer)
Sym02_pd25VAHDown = Sym02_pvah-(Sym02_PercentageRange*Inner)
Sym02_pd25VALUp = Sym02_pval+(Sym02_PercentageRange*Inner)
Sym02_pd25VALDown = Sym02_pval-(Sym02_PercentageRange*Outer)

Sym02_dOpen = security(Symbol02, "D", open, lookahead = barmerge.lookahead_on)

Sym02_ccv_color =  show_ccv ?
     (Sym02_dOpen < Sym02_pd25VAHUp) and (Sym02_dOpen > Sym02_pd25VAHDown) ? color.green :
     (Sym02_dOpen < Sym02_pd25VALUp) and (Sym02_dOpen > Sym02_pd25VALDown) ? color.green :
     color.red :
     na
Sym02_ccv_fill_color = Sym02_ccv_color


///////////////////////////////////////////////////////////////
Sym03_pvah = security(Symbol03, timeframe.period, pvah_)
Sym03_pval = security(Symbol03, timeframe.period, pval_)

Sym03_Range = Sym03_pvah - Sym03_pval
Sym03_PercentageRange = Sym03_Range/100

Sym03_pd25VAHUp = Sym03_pvah+(Sym03_PercentageRange*Outer)
Sym03_pd25VAHDown = Sym03_pvah-(Sym03_PercentageRange*Inner)
Sym03_pd25VALUp = Sym03_pval+(Sym03_PercentageRange*Inner)
Sym03_pd25VALDown = Sym03_pval-(Sym03_PercentageRange*Outer)

Sym03_dOpen = security(Symbol03, "D", open, lookahead = barmerge.lookahead_on)

Sym03_ccv_color =  show_ccv ?
     (Sym03_dOpen < Sym03_pd25VAHUp) and (Sym03_dOpen > Sym03_pd25VAHDown) ? color.green :
     (Sym03_dOpen < Sym03_pd25VALUp) and (Sym03_dOpen > Sym03_pd25VALDown) ? color.green :
     color.red :
     na
Sym03_ccv_fill_color = Sym03_ccv_color

////////////////////////////////////////////////////////////////
Sym04_pvah = security(Symbol04, timeframe.period, pvah_)
Sym04_pval = security(Symbol04, timeframe.period, pval_)

Sym04_Range = Sym04_pvah - Sym04_pval
Sym04_PercentageRange = Sym04_Range/100

Sym04_pd25VAHUp = Sym04_pvah+(Sym04_PercentageRange*Outer)
Sym04_pd25VAHDown = Sym04_pvah-(Sym04_PercentageRange*Inner)
Sym04_pd25VALUp = Sym04_pval+(Sym04_PercentageRange*Inner)
Sym04_pd25VALDown = Sym04_pval-(Sym04_PercentageRange*Outer)

Sym04_dOpen = security(Symbol04, "D", open, lookahead = barmerge.lookahead_on)

Sym04_ccv_color =  show_ccv ?
     (Sym04_dOpen < Sym04_pd25VAHUp) and (Sym04_dOpen > Sym04_pd25VAHDown) ? color.green :
     (Sym04_dOpen < Sym04_pd25VALUp) and (Sym04_dOpen > Sym04_pd25VALDown) ? color.green :
     color.red :
     na
Sym04_ccv_fill_color = Sym04_ccv_color

////////////////////////////////////////////////////////////////
Sym05_pvah = security(Symbol05, timeframe.period, pvah_)
Sym05_pval = security(Symbol05, timeframe.period, pval_)

Sym05_Range = Sym05_pvah - Sym05_pval
Sym05_PercentageRange = Sym05_Range/100

Sym05_pd25VAHUp = Sym05_pvah+(Sym05_PercentageRange*Outer)
Sym05_pd25VAHDown = Sym05_pvah-(Sym05_PercentageRange*Inner)
Sym05_pd25VALUp = Sym05_pval+(Sym05_PercentageRange*Inner)
Sym05_pd25VALDown = Sym05_pval-(Sym05_PercentageRange*Outer)

Sym05_dOpen = security(Symbol05, "D", open, lookahead = barmerge.lookahead_on)

Sym05_ccv_color =  show_ccv ?
     (Sym05_dOpen < Sym05_pd25VAHUp) and (Sym05_dOpen > Sym05_pd25VAHDown) ? color.green :
     (Sym05_dOpen < Sym05_pd25VALUp) and (Sym05_dOpen > Sym05_pd25VALDown) ? color.green :
     color.red :
     na
Sym05_ccv_fill_color = Sym05_ccv_color

////////////////////////////////////////////////////////////////
Sym06_pvah = security(Symbol06, timeframe.period, pvah_)
Sym06_pval = security(Symbol06, timeframe.period, pval_)

Sym06_Range = Sym06_pvah - Sym06_pval
Sym06_PercentageRange = Sym06_Range/100

Sym06_pd25VAHUp = Sym06_pvah+(Sym06_PercentageRange*Outer)
Sym06_pd25VAHDown = Sym06_pvah-(Sym06_PercentageRange*Inner)
Sym06_pd25VALUp = Sym06_pval+(Sym06_PercentageRange*Inner)
Sym06_pd25VALDown = Sym06_pval-(Sym06_PercentageRange*Outer)

Sym06_dOpen = security(Symbol06, "D", open, lookahead = barmerge.lookahead_on)

Sym06_ccv_color =  show_ccv ?
     (Sym06_dOpen < Sym06_pd25VAHUp) and (Sym06_dOpen > Sym06_pd25VAHDown) ? color.green :
     (Sym06_dOpen < Sym06_pd25VALUp) and (Sym06_dOpen > Sym06_pd25VALDown) ? color.green :
     color.red :
     na
Sym06_ccv_fill_color = Sym06_ccv_color

////////////////////////////////////////////////////////////////
Sym07_pvah = security(Symbol07, timeframe.period, pvah_)
Sym07_pval = security(Symbol07, timeframe.period, pval_)

Sym07_Range = Sym07_pvah - Sym07_pval
Sym07_PercentageRange = Sym07_Range/100

Sym07_pd25VAHUp = Sym07_pvah+(Sym07_PercentageRange*Outer)
Sym07_pd25VAHDown = Sym07_pvah-(Sym07_PercentageRange*Inner)
Sym07_pd25VALUp = Sym07_pval+(Sym07_PercentageRange*Inner)
Sym07_pd25VALDown = Sym07_pval-(Sym07_PercentageRange*Outer)

Sym07_dOpen = security(Symbol07, "D", open, lookahead = barmerge.lookahead_on)

Sym07_ccv_color =  show_ccv ?
     (Sym07_dOpen < Sym07_pd25VAHUp) and (Sym07_dOpen > Sym07_pd25VAHDown) ? color.green :
     (Sym07_dOpen < Sym07_pd25VALUp) and (Sym07_dOpen > Sym07_pd25VALDown) ? color.green :
     color.red :
     na
Sym07_ccv_fill_color = Sym07_ccv_color


////////////////////////////////////////////////////////////////
Sym08_pvah = security(Symbol08, timeframe.period, pvah_)
Sym08_pval = security(Symbol08, timeframe.period, pval_)

Sym08_Range = Sym08_pvah - Sym08_pval
Sym08_PercentageRange = Sym08_Range/100

Sym08_pd25VAHUp = Sym08_pvah+(Sym08_PercentageRange*Outer)
Sym08_pd25VAHDown = Sym08_pvah-(Sym08_PercentageRange*Inner)
Sym08_pd25VALUp = Sym08_pval+(Sym08_PercentageRange*Inner)
Sym08_pd25VALDown = Sym08_pval-(Sym08_PercentageRange*Outer)

Sym08_dOpen = security(Symbol08, "D", open, lookahead = barmerge.lookahead_on)

Sym08_ccv_color =  show_ccv ?
     (Sym08_dOpen < Sym08_pd25VAHUp) and (Sym08_dOpen > Sym08_pd25VAHDown) ? color.green :
     (Sym08_dOpen < Sym08_pd25VALUp) and (Sym08_dOpen > Sym08_pd25VALDown) ? color.green :
     color.red :
     na
Sym08_ccv_fill_color = Sym08_ccv_color






//plot(color_Sym01_pvah)
//plot(color_Sym01_pval)

//plot(color_Sym02_pvah)
//plot(color_Sym02_pval)

//plot(color_Sym03_pvah)
//plot(color_Sym03_pval)

//plot(color_Sym04_pvah)
//plot(color_Sym04_pval)


color_Sym01 = security(Symbol01, timeframe.period, Sym01_ccv_fill_color)
color_Sym02 = security(Symbol02, timeframe.period, Sym02_ccv_fill_color)
color_Sym03 = security(Symbol03, timeframe.period, Sym03_ccv_fill_color)
color_Sym04 = security(Symbol04, timeframe.period, Sym04_ccv_fill_color)
color_Sym05 = security(Symbol05, timeframe.period, Sym05_ccv_fill_color)
color_Sym06 = security(Symbol06, timeframe.period, Sym06_ccv_fill_color)
color_Sym07 = security(Symbol07, timeframe.period, Sym07_ccv_fill_color)
color_Sym08 = security(Symbol08, timeframe.period, Sym08_ccv_fill_color)

// === Allocate Strategies to Lines ===
Sym01_bar = 8
Sym02_bar = 7
Sym03_bar = 6
Sym04_bar = 5
Sym05_bar = 4
Sym06_bar = 3
Sym07_bar = 2
Sym08_bar = 1

// === Plot Signals per Strategy ===
plot(Sym01_bar, title="BYBIT:BTCUSD", color = color_Sym01, transp = 0, style = plot.style_columns)
plot(Sym02_bar, title="BINANCE:BTCUSDT", color = color_Sym02, transp = 0, style = plot.style_columns)
plot(Sym03_bar, title="BINANCE:ETHUSDT", color = color_Sym03, transp = 0, style = plot.style_columns)
plot(Sym04_bar, title="BINANCE:LTCUSDT", color = color_Sym04, transp = 0, style = plot.style_columns)
plot(Sym05_bar, title="BINANCE:MKRUSDT", color = color_Sym05, transp = 0, style = plot.style_columns)
plot(Sym06_bar, title="BINANCE:YFIIUSDT", color = color_Sym06, transp = 0, style = plot.style_columns)
plot(Sym07_bar, title="BINANCE:PAXGUSDT", color = color_Sym07, transp = 0, style = plot.style_columns)
plot(Sym08_bar, title="BINANCE:COMPUSDT", color = color_Sym08, transp = 0, style = plot.style_columns)


// === Plot Background lines ===
line0 = hline(0, title="Line 0", linestyle=hline.style_dotted, editable = false)
line1 = hline(1, title="Line 1", linestyle=hline.style_dotted, editable = false)
line2 = hline(2, title="Line 2", linestyle=hline.style_dotted, editable = false)
line3 = hline(3, title="Line 3", linestyle=hline.style_dotted, editable = false)
line4 = hline(4, title="Line 4", linestyle=hline.style_dotted, editable = false)
line5 = hline(5, title="Line 5", linestyle=hline.style_dotted, editable = false)
line6 = hline(6, title="Line 6", linestyle=hline.style_dotted, editable = false)
line7 = hline(7, title="Line 7", linestyle=hline.style_dotted, editable = false)

// === Plot Labels ===
chper = time - time[1]
chper := change(chper) > 0 ? chper[1] : chper

var label l_Sym01 = na, var label l_Sym02 = na, var label l_Sym03 = na, var label l_Sym04 = na, var label l_Sym05 = na, var label l_Sym06 = na, var label l_Sym07 = na, var label l_Sym08 = na
label.delete(l_Sym01), label.delete(l_Sym02), label.delete(l_Sym03), label.delete(l_Sym04), label.delete(l_Sym05), label.delete(l_Sym06), label.delete(l_Sym07), label.delete(l_Sym08)

l_Sym01 := label.new(x = time + chper * 20, y = Sym01_bar-1, text = "BYBIT:BTCUSD",   textcolor=color.white, style=label.style_none, xloc = xloc.bar_time, yloc=yloc.price, size=size.small)
l_Sym02 := label.new(x = time + chper * 20, y = Sym02_bar-1, text = "BINANCE:BTCUSDT",   textcolor=color.white, style=label.style_none, xloc = xloc.bar_time, yloc=yloc.price, size=size.small)
l_Sym03 := label.new(x = time + chper * 20, y = Sym03_bar-1, text = "BINANCE:ETHUSDT",   textcolor=color.white, style=label.style_none, xloc = xloc.bar_time, yloc=yloc.price, size=size.small)
l_Sym04 := label.new(x = time + chper * 20, y = Sym04_bar-1, text = "BINANCE:LTCUSDT",   textcolor=color.white, style=label.style_none, xloc = xloc.bar_time, yloc=yloc.price, size=size.small)
l_Sym05 := label.new(x = time + chper * 20, y = Sym05_bar-1, text = "BINANCE:MKRUSDT",   textcolor=color.white, style=label.style_none, xloc = xloc.bar_time, yloc=yloc.price, size=size.small)
l_Sym06 := label.new(x = time + chper * 20, y = Sym06_bar-1, text = "BINANCE:YFIIUSDT",   textcolor=color.white, style=label.style_none, xloc = xloc.bar_time, yloc=yloc.price, size=size.small)
l_Sym07 := label.new(x = time + chper * 20, y = Sym07_bar-1, text = "BINANCE:PAXGUSDT",   textcolor=color.white, style=label.style_none, xloc = xloc.bar_time, yloc=yloc.price, size=size.small)
l_Sym08 := label.new(x = time + chper * 20, y = Sym08_bar-1, text = "BINANCE:COMPUSDT",   textcolor=color.white, style=label.style_none, xloc = xloc.bar_time, yloc=yloc.price, size=size.small)
Related