Una estrategia de seguimiento de tendencias de múltiples marcos temporales con una combinación del indicador STOKER y la SMA

Fecha de creación: 2023-12-18 12:19:41 Última modificación: 2023-12-18 12:19:41

Copiar: 0 Número de Visitas: 948

ChaoZhang

Seguir

1621

Seguidores

Una estrategia de seguimiento de tendencias de múltiples marcos temporales con una combinación del indicador STOKER y la SMA

Descripción general

La estrategia utiliza la combinación de los indicadores clásicos de Stokes y los indicadores SMA para lograr una mayor capacidad de seguimiento de tendencias. La idea central de la estrategia es utilizar los indicadores de Stokes para identificar señales de dirección de tendencia, combinar los indicadores SMA para filtrar para mejorar la calidad de la señal, configurar los parámetros del indicador con diferentes modelos de riesgo y ajustar la dinámica de riesgo y ganancias. Además, la estrategia utiliza el juicio de múltiples marcos de tiempo para optimizar la selección de oportunidades de entrada en juego.

Principio de estrategia

La estrategia utiliza el índice de Stokes modificado para reforzar el índice, los parámetros del índice incluyen el ciclo% K, el ciclo de suavización% K y el ciclo de suavización% D, y la sensibilidad del índice se controla mediante la configuración de parámetros.
Los parámetros del indicador SMA incluyen el SMA de punto alto y el SMA de punto bajo, que se utilizan para filtrar la señal, mejorar la calidad de la señal y evitar falsas rupturas.
De acuerdo con las diferentes preferencias de riesgo, las estrategias ofrecen opciones de modelos de bajo riesgo, modelos de riesgo medio y modelos de alto riesgo. Los modelos de riesgo influyen en los parámetros cruzados del índice de Stokes, lo que permite un ajuste dinámico de riesgos y ganancias.
Las estrategias juzgan las señales de posición larga cuando la brecha es en el índice de Stokes y el precio de cierre está por debajo del SMA bajo; juzgan las señales de posición corta cuando la brecha es en el índice de Stokes y el precio de cierre está por encima del SMA alto.
La estrategia de control de riesgo de la operación consiste en la introducción de módulos de juicio en múltiples marcos de tiempo, la verificación de señales en diferentes marcos de tiempo y la selección de los mejores momentos de entrada.

Ventajas estratégicas

El índice de Stokes ha sido modificado para mejorar su sensibilidad y captar rápidamente los cambios en el mercado.
Se ha añadido un mecanismo de filtración de dos vías para el indicador SMA, que permite filtrar eficazmente las señales falsas y mejorar la calidad de la señal.
Ofrece una variedad de modelos de riesgo a elegir, y los usuarios pueden ajustar los parámetros de forma flexible según sus preferencias de riesgo.
Aumentar los módulos de juicio de múltiples marcos de tiempo, optimizar la elección de la hora de entrada y reducir el riesgo de transacción.
La configuración de los parámetros estratégicos es razonable, los indicadores se utilizan de forma natural, el marco general es científicamente riguroso, la estabilidad es buena y la adaptabilidad es fuerte.

Riesgo estratégico

La estrategia en sí no tiene un mecanismo de parada de pérdidas y requiere la configuración manual de los puntos de parada para controlar el riesgo de pérdidas.
Las señales de estrategia son frecuentes y pueden ser excesivamente negociadas, lo que aumenta el costo de las transacciones.
La estrategia es sensible a los parámetros y a la configuración de los modelos de riesgo, y requiere pruebas de optimización para encontrar los mejores parámetros.
El retiro estratégico puede ser grande, no es adecuado para operaciones de posición completa, y requiere un control del tamaño de los fondos de transacción.

El método de respuesta:

Establezca razonablemente la proporción de pérdidas de acuerdo con la volatilidad del mercado para controlar al máximo las pérdidas.
Ajuste adecuadamente los parámetros del índice de Stokes para reducir la frecuencia de la señal. O establezca un parón mínimo para reducir las transacciones innecesarias.
Se recomienda elegir el modo de bajo riesgo predeterminado y ajustar otros parámetros según los datos de la revisión.
Controlar el tamaño de las posiciones, crear posiciones en lotes y reducir el riesgo de una sola operación.

Dirección de optimización de la estrategia

Prueba exhaustiva de los parámetros del índice de Stokes y el índice SMA para encontrar la combinación óptima de parámetros.
Aumentar el número de marcos de tiempo múltiple, enriquecer las bases de juicio y optimizar la selección de la hora de ingreso.
La introducción de una combinación de indicadores de stop loss como el stop loss ATR, que puede rastrear dinámicamente los puntos de stop loss, reduce el riesgo.
Construir mecanismos de filtración y confirmación de las señales de indicadores, como el aumento de la determinación de los indicadores de volumen de transacciones, para evitar la captura.
El módulo de gestión de posiciones permite ajustar las posiciones de forma proactiva en función de las condiciones del mercado, lo que reduce el riesgo de transacciones individuales.

Resumir

La estrategia utiliza las ventajas de los indicadores de Stokes y SMA para lograr un efecto de seguimiento de tendencias más fuerte. El marco de la estrategia es razonable, los indicadores se usan de forma natural, se recupera la naturaleza de los indicadores mediante el control de los parámetros y el modelo de riesgo, se optimiza la estabilidad de la estrategia. El módulo de juicio de múltiples marcos de tiempo también mejora la adaptabilidad de la estrategia, que puede ajustarse según las diferentes variedades y períodos.

Código Fuente de la Estrategia

/*backtest
start: 2023-11-17 00:00:00
end: 2023-12-17 00:00:00
period: 1h
basePeriod: 15m
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

//►►►► Description ►►►►
//1. The Original Pine Script
//- Stochastic
//- SMA
//1.1 Concepts
//- Stochastic crossover and crossunder with range 80/20 or 70/30 or 50/50 from your risk you can adjust it from config
//- Confirm Signal by SMA High and Low Original Range is 50 or you can adjust by your self in config Setting
//1.2 Condition
//- Buy Condition = Stochastic crossover Sto Signal Line and SMA Filter <= 20 or 30 or 50 from your risk
//- Sell Condition = Stochastic crossunder Sto Signal Line and SMA Filter >= 80 or 70 or 50 from your risk
//1.3 Idea For Trading
//- Trend Runing If you use "Trend" Mode is Martingale Your Position Until You Have a Profit
//- Scalping You Can Adjust TP for Little Profit and Increase Your Winrate

//►►►► Strategy results ►►►►
// ►► Use an account size ►►
// - For Newbie i recommend try to use 50$ you can test in MT4 Or MT5 Start With 50$ Leverage : 1000
// - For Some User Have a Exp. Trading : 500$ you can use martingale for help your trading
// - For Expert User : 5000$ or 5000$ (Cent) you can use martingale for help your trading
// ►► realistic commission AND slippage ►►
// - Some Broker Not Have a commission for Gold and Forex.
// - slippage : default i'm Setting is 350 point, (it's mean 35 pip) it's average or your account is ECN or Zero Spread You can Set = 0
// ►► Size For Trading ►►
// - This strategy is Start From 0.01 lot and use martingale for next position
// - This not perfect strategy. it's have equity drawdown. just try and test your config you like.
// ►► Sample size Dataset Trading ►►
// - This Strategy Recommend For Long-Term Trading Becuase It's Have Martingale Help Your Next Position

//►►►► strategy's default Properties ►►►►
// - From Default Setting : Slippage or Spread Set = 0 (Becuase I don't know your account spread) you can set in Properties
// ** Some Broeker Are 2 Digits or 3 Digit You Must Set By Your Self (like 35 point or 350 point from your account spread)
// - From Default Setting : commission = 0 (Becuase I don't know your account commission) you can set in Properties
// ** Some Broeker Are not commission for forex and gold

//@version=5
var int slippage = 0
strategy("X48 - DayLight Hunter | Strategy | V.01.03", overlay=true)

var int hedge_mode = 0
var int sto_buy = 0
var int sto_sell = 0

Trade_Mode = input.string(defval = "Trend", title = "⚖️ Mode For Trade [Oneway / Hedge / ⭐Trend]", options = ["Oneway", "Hedge", "Trend"], group = "=== Mode Trade [Recommend Mode is ⭐Trend and ⭐Low Risk] ===", tooltip = "Oneway = Switching Position Type With Signal\nHedge Mode = Not Switching Position Type Unitl TP or SL")
Risk_Mode = input.string(defval = "Low Risk", title = "⚖️ Risk Signal Mode [⭐Low / Medium / High]", options = ["Low Risk", "Medium Risk", "High Risk"], group = "=== Mode Trade [Recommend Mode is ⭐Trend and ⭐Low Risk] ===", tooltip = "[[Signal Form Stochastic]]\nLow Risk is >= 80 and <= 20\nMedium Risk is >= 70 and <= 30\nHigh Risk is >= 50 and <=50")

if Trade_Mode == "Oneway"
    hedge_mode := 0
else if Trade_Mode == "Hedge"
    hedge_mode := 1
else if Trade_Mode == "Trend"
    hedge_mode := 2

if Risk_Mode == "Low Risk"
    sto_buy := 20
    sto_sell := 80
else if Risk_Mode == "Medium Risk"
    sto_buy := 30
    sto_sell := 70
else if Risk_Mode == "High Risk"
    sto_buy := 50
    sto_sell := 50

periodK = input.int(15, title="%K Length", minval=1, group = "Stochastic Setting", inline = "Sto0")
smoothK = input.int(3, title="%K Smoothing", minval=1, group = "Stochastic Setting", inline = "Sto0")
periodD = input.int(3, title="%D Smoothing", minval=1, group = "Stochastic Setting", inline = "Sto0")

GRSMA = "=== 🧮 SMA Filter Mode ==="
SMA_Mode = input.bool(defval = true, title = "🧮 SMA High and Low Filter Mode", group = GRSMA, tooltip = "Sell Signal With Open >= SMA High\nBuy Signal With Close <= SMA Low")
SMA_High = input.int(defval = 50, title = "SMA High", group = GRSMA, inline = "SMA1")
SMA_Low = input.int(defval = 50, title = "SMA Low", group = GRSMA, inline = "SMA1")

k = ta.sma(ta.stoch(close, high, low, periodK), smoothK)
d = ta.sma(k, periodD)
high_line = ta.sma(high, SMA_High)
low_line = ta.sma(low, SMA_Low)
plot(SMA_Mode ? high_line : na, "H-Line", color = color.yellow, linewidth = 2)
plot(SMA_Mode ? low_line : na, "L-Line", color = color.blue, linewidth = 2)

entrybuyprice = strategy.position_avg_price

var bool longcondition = na
var bool shortcondition = na

if SMA_Mode == true
    longcondition := ta.crossover(k,d) and d <= sto_buy and close < low_line and open < low_line// or ta.crossover(k, 20)// and close <= low_line
    shortcondition := ta.crossunder(k,d) and d >= sto_sell and close > high_line and open > high_line// or ta.crossunder(k, 80)// and close >= high_line
else
    longcondition := ta.crossover(k,d) and d <= sto_buy
    shortcondition := ta.crossunder(k,d) and d >= sto_sell
//longcondition_double = ta.crossover(d,20) and close < low_line// and strategy.position_size > 0
//shortcondition_double = ta.crossunder(d,80) and close > high_line// and strategy.position_size < 0

//=============== TAKE PROFIT and STOP LOSS by % =================

tpsl(percent) =>
    strategy.position_avg_price * percent / 100 / syminfo.mintick
GR4 = "=====🆘🆘🆘 TAKE PROFIT & STOP LOSS BY [%] 🆘🆘🆘====="
mode= input.bool(title="🆘 Take Profit & Stop Loss By Percent (%)", defval=true, group=GR4, tooltip = "Take Profit & Stop Loss by % Change\n0 = Disable")
tp_l = tpsl(input.float(0, title='🆘 TP [LONG] % >> [OneWay Only]', group=GR4, tooltip = "0 = Disable"))
tp_s = tpsl(input.float(0, title='🆘 TP [SHORT] % >> [OneWay Only]', group=GR4, tooltip = "0 = Disable"))
sl = tpsl(input.float(0, title='🆘 Stop Loss % [All Mode / 1st Position]', group=GR4, tooltip = "0 = Disable"))
tp_pnl = input.float(defval = 1, title = "🆘 TakeProfit by PNL ($) eg. (0.1 = 0.1$)", group = GR4, tooltip = "All Mode TP by PNL")
spread_size = input.float(defval = 0.350, title = "🆘 Spread Point Size(Eg. 35 Point or 350 Point From Your Broker Digits)", tooltip = "Spread Point Form Your Broker \nEg. 1920.124 - 1920.135 or 1920.12 - 1920.13\nPlease Check From Your Broker", group = GR4)

GR5 = "===💮💮💮 Hedge / Martingale Mode 💮💮💮==="
//hedge_mode = input.bool(defval = true, title = "⚖️ Hedge / Martingale Mode", group = GR5)
hedge_point = input.int(defval = 500, title = "💯 Hedge Point Range / Martingale Range", group = GR5, tooltip = "After Entry Last Position And Current Price More Than Point Range Are Open New Hedge Position")
hedge_gale = input.float(defval = 2.0, title = "✳️ Martingale For Hedge Multiply [default = 2]", tooltip = "Martingale For Multiply Hedge Order", group = GR5)
hedge_point_size = hedge_point/100

calcStopLossPrice(OffsetPts) =>
    if strategy.position_size > 0
        strategy.position_avg_price - OffsetPts * syminfo.mintick
    else if strategy.position_size < 0
        strategy.position_avg_price + OffsetPts * syminfo.mintick
    else
        na

calcStopLossL_AlertPrice(OffsetPts) =>
    strategy.position_avg_price - OffsetPts * syminfo.mintick
calcStopLossS_AlertPrice(OffsetPts) =>
    strategy.position_avg_price + OffsetPts * syminfo.mintick

calcTakeProfitPrice(OffsetPts) =>
    if strategy.position_size > 0
        strategy.position_avg_price + OffsetPts * syminfo.mintick
    else if strategy.position_size < 0
        strategy.position_avg_price - OffsetPts * syminfo.mintick
    else
        na

calcTakeProfitL_AlertPrice(OffsetPts) =>
    strategy.position_avg_price + OffsetPts * syminfo.mintick
calcTakeProfitS_AlertPrice(OffsetPts) =>
    strategy.position_avg_price - OffsetPts * syminfo.mintick

var stoploss = 0.
var stoploss_l = 0.
var stoploss_s = 0.
var takeprofit = 0.
var takeprofit_l = 0.
var takeprofit_s = 0.
var takeprofit_ll = 0.
var takeprofit_ss = 0.

if mode == true
    if (strategy.position_size > 0)
        if sl > 0
            stoploss := calcStopLossPrice(sl)
            stoploss_l := stoploss
        else if sl <= 0
            stoploss := na
        if tp_l > 0
            takeprofit := tp_l
            takeprofit_ll := close + ((close/100)*tp_l)
            //takeprofit_s := na
        else if tp_l <= 0
            takeprofit := na
    if (strategy.position_size < 0)
        if sl > 0
            stoploss := calcStopLossPrice(sl)
            stoploss_s := stoploss
        else if sl <= 0
            stoploss := na
        if tp_s > 0
            takeprofit := tp_s
            takeprofit_ss := close - ((close/100)*tp_s)
            //takeprofit_l := na
        else if tp_s <= 0
            takeprofit := na
    else if strategy.position_size == 0
        stoploss := na
        takeprofit := na
        //takeprofit_l := calcTakeProfitL_AlertPrice(tp_l)
        //takeprofit_s := calcTakeProfitS_AlertPrice(tp_s)
        //stoploss_l := calcStopLossL_AlertPrice(sl)
        //stoploss_s := calcStopLossS_AlertPrice(sl)

//////////// INPUT BACKTEST RANGE ////////////////////////////////////////////////////
var string BTR1         = '════════⌚⌚ INPUT BACKTEST TIME RANGE ⌚⌚════════'
i_startTime             = input(defval = timestamp("01 Jan 1945 00:00 +0000"), title = "Start", inline="timestart", group=BTR1, tooltip = 'Start Backtest YYYY/MM/DD')
i_endTime               = input(defval = timestamp("01 Jan 2074 23:59 +0000"), title = "End", inline="timeend", group=BTR1, tooltip = 'End Backtest YYYY/MM/DD')
//////////////// Strategy Alert For X4815162342 BOT //////////////////////
Text_Alert_Future = '{{strategy.order.alert_message}}'
copy_Fu = input( defval= Text_Alert_Future ,    title="Alert Message for BOT", inline = '00'  ,group = '═ Bot Setting ═ \n >> If You Dont Use Bot Just Pass It' ,tooltip = 'Alert For X48-BOT > Copy and Paste To Alert Function')
TimeFrame_input = input(defval= 'Input Your TimeFrame [1m, 15m, 1h, 4h, 1d ,1w]' ,    title="TimeFrame Text Alert", inline = '01'  ,group = '═ Bot Setting ═ \n >> If You Dont Use Bot Just Pass It', tooltip = "[1m, 15m, 1h, 4h, 1d ,1w]")
string Alert_EntryL = '🪙 Asset : {{ticker}} \n💱 Status : {{strategy.market_position}}\n🕛 TimeFrame : '+str.tostring(TimeFrame_input)+'\n💸 Price : {{strategy.order.price}} $\n✅ TP : '+str.tostring(takeprofit_ll)+' $\n❌ SL : '+str.tostring(stoploss_l)+' $\n⏰ Time : {{timenow}}'
string Alert_EntryS = '🪙 Asset : {{ticker}} \n💱 Status : {{strategy.market_position}}\n🕛 TimeFrame : '+str.tostring(TimeFrame_input)+'\n💸 Price : {{strategy.order.price}} $\n✅ TP : '+str.tostring(takeprofit_ss)+' $\n❌ SL : '+str.tostring(stoploss_s)+' $\n⏰ Time : {{timenow}}'
string Alert_TPSL = '🪙 Asset : {{ticker}}\n🕛 TimeFrame : '+str.tostring(TimeFrame_input)+'\n💹 {{strategy.order.comment}}\n💸 Price : {{strategy.order.price}} $\n⏰ Time : {{timenow}}'

if true
    if (longcondition and strategy.position_size == 0) or (longcondition and strategy.position_size < 0 and hedge_mode == 0)
        strategy.entry("Long", strategy.long, comment = "🌙", alert_message = Alert_EntryL)
    //if longcondition_double
    //    //strategy.cancel_all()
    //    strategy.entry("Long2", strategy.long, comment = "🌙🌙")
    //    //strategy.exit("Exit",'Long', qty_percent = 100 , profit = takeprofit, stop = stoploss, comment_profit = "TP💚L", comment_loss = "SL💚L")
    if (shortcondition and strategy.position_size == 0) or (shortcondition and strategy.position_size > 0 and hedge_mode == 0)
        strategy.entry("Short", strategy.short, comment = "👻", alert_message = Alert_EntryS)
        //strategy.exit("Exit",'Short', qty_percent = 100, profit = takeprofit, stop = stoploss, comment_profit = "TP❤️️S", comment_loss = "SL❤️️S")
    //if shortcondition_double
    //    //strategy.cancel_all()
    //    strategy.entry("Short2", strategy.short, comment = "👻👻")

if strategy.position_size > 0 and strategy.opentrades >= 1 and hedge_mode == 1
    entrypricel = strategy.opentrades.entry_price(strategy.opentrades - 1)
    callpointsize =  entrypricel - close
    lastsize = strategy.position_size
    if callpointsize >= hedge_point_size and longcondition
        strategy.order("Long2", strategy.long, qty = lastsize * hedge_gale, comment = "🌙⌛", alert_message = Alert_EntryL)
    if shortcondition
        strategy.order("Short2", strategy.short, qty = lastsize * hedge_gale, comment = "👻⌛", alert_message = Alert_EntryS)

else if strategy.position_size < 0 and strategy.opentrades >= 1 and hedge_mode == 1
    entryprices = strategy.opentrades.entry_price(strategy.opentrades - 1)
    callpointsize = (entryprices - close)* -1
    lastsize = (strategy.position_size) * -1
    if callpointsize >= hedge_point_size and shortcondition
        strategy.order("Short2", strategy.short, qty = lastsize * hedge_gale, comment = "👻⌛", alert_message = Alert_EntryS)
    if longcondition
        strategy.order("Long2", strategy.long, qty = lastsize * hedge_gale, comment = "🌙⌛", alert_message = Alert_EntryL)

if strategy.position_size > 0 and strategy.opentrades >= 1 and hedge_mode == 2
    entrypricel = strategy.opentrades.entry_price(strategy.opentrades - 1)
    callpointsize =  entrypricel - close
    lastsize = strategy.position_size
    if callpointsize >= hedge_point_size and longcondition
        strategy.order("Long2", strategy.long, qty = lastsize * hedge_gale, comment = "🌙⌛", alert_message = Alert_EntryL)

else if strategy.position_size < 0 and strategy.opentrades >= 1 and hedge_mode == 2
    entryprices = strategy.opentrades.entry_price(strategy.opentrades - 1)
    callpointsize = (entryprices - close)* -1
    lastsize = (strategy.position_size) * -1
    if callpointsize >= hedge_point_size and shortcondition
        strategy.order("Short2", strategy.short, qty = lastsize * hedge_gale, comment = "👻⌛", alert_message = Alert_EntryS)

last_price_l = (strategy.opentrades.entry_price(strategy.opentrades - 1) + (strategy.opentrades.entry_price(strategy.opentrades - 1)/100) * takeprofit) + spread_size
last_price_s = (strategy.opentrades.entry_price(strategy.opentrades - 1) - (strategy.opentrades.entry_price(strategy.opentrades - 1)/100) * takeprofit) - spread_size 
current_price = request.security(syminfo.tickerid, "1", close)
current_pricel = request.security(syminfo.tickerid, "1", close) + spread_size
current_prices = request.security(syminfo.tickerid, "1", close) - spread_size
//if mode == true
if strategy.position_size > 0 and strategy.openprofit >= tp_pnl and mode == true and hedge_mode == 1
    lastsize = strategy.position_size
    lastprofitorder = strategy.openprofit
    //if lastprofitorder >= 0.07
    //strategy.close('Long', qty = lastsize, comment = "TP💚L", alert_message = Alert_TPSL, immediately = true)
    strategy.cancel_all()
    strategy.close_all(comment = "TP💚PNL", alert_message = Alert_TPSL, immediately = true)
    //strategy.close_all(comment = "TP💚LH", alert_message = Alert_TPSL)
    //strategy.exit("Exit",'Long2', qty_percent = 100, profit = last_price_l, stop = stoploss, comment_profit = "TP💚LH", comment_loss = "SL💚LH", alert_message = Alert_TPSL)
    //strategy.exit("Exit",'Long', qty_percent = 100, profit = last_price_l, stop = stoploss, comment_profit = "TP💚L", comment_loss = "SL💚L", alert_message = Alert_TPSL)
else if strategy.position_size > 0 and strategy.openprofit < tp_pnl and mode == true and hedge_mode == 1
    strategy.exit("Exit",'Long', qty_percent = 100, stop = stoploss, comment_loss = "SL💚%L", alert_message = Alert_TPSL)

if strategy.position_size > 0 and strategy.openprofit >= tp_pnl and mode == true and hedge_mode == 2
    lastsize = strategy.position_size
    lastprofitorder = strategy.openprofit
    //if lastprofitorder >= 0.07
    //strategy.close('Long', qty = lastsize, comment = "TP💚L", alert_message = Alert_TPSL, immediately = true)
    strategy.cancel_all()
    strategy.close_all(comment = "TP💚PNL", alert_message = Alert_TPSL, immediately = true)
    //strategy.close_all(comment = "TP💚LH", alert_message = Alert_TPSL)
    //strategy.exit("Exit",'Long2', qty_percent = 100, profit = last_price_l, stop = stoploss, comment_profit = "TP💚LH", comment_loss = "SL💚LH", alert_message = Alert_TPSL)
    //strategy.exit("Exit",'Long', qty_percent = 100, profit = last_price_l, stop = stoploss, comment_profit = "TP💚L", comment_loss = "SL💚L", alert_message = Alert_TPSL)
else if strategy.position_size > 0 and strategy.openprofit < tp_pnl and mode == true and hedge_mode == 2
    strategy.exit("Exit",'Long', qty_percent = 100, stop = stoploss, comment_loss = "SL💚%L", alert_message = Alert_TPSL)

if strategy.position_size > 0 and mode == true and hedge_mode == 0
    //strategy.close_all(comment = "TP💚LH", alert_message = Alert_TPSL, immediately = true)
    strategy.exit("Exit",'Long', qty_percent = 100, profit = takeprofit, stop = stoploss, comment_profit = "TP💚%L", comment_loss = "SL💚%L", alert_message = Alert_TPSL)
    //strategy.exit("Exit",'Long', qty_percent = 100, profit = takeprofit, stop = stoploss, comment_profit = "TP💚LL", comment_loss = "SL💚L", alert_message = Alert_TPSL)

if strategy.position_size < 0 and strategy.openprofit >= tp_pnl and mode == true and hedge_mode == 1
    lastsize = (strategy.position_size) * -1
    lastprofitorder = strategy.openprofit
    //if lastprofitorder >= 0.07
    //strategy.close('Short', qty = lastsize, comment = "TP❤️️S", alert_message = Alert_TPSL, immediately = true)
    strategy.cancel_all()
    strategy.close_all(comment = "TP❤️️PNL", alert_message = Alert_TPSL, immediately = true)
    //strategy.close_all(comment = "TP❤️️SH", alert_message = Alert_TPSL)
    //strategy.exit("Exit",'Short2', qty_percent = 100, profit = last_price_s, stop = stoploss, comment_profit = "TP❤️️SH", comment_loss = "SL❤️️SH", alert_message = Alert_TPSL)
    //strategy.exit("Exit",'Short', qty_percent = 100, profit = last_price_s, stop = stoploss, comment_profit = "TP❤️️S", comment_loss = "SL❤️️S", alert_message = Alert_TPSL)
else if strategy.position_size < 0 and strategy.openprofit < tp_pnl and mode == true and hedge_mode == 1
    strategy.exit("Exit",'Short', qty_percent = 100, stop = stoploss, comment_loss = "SL❤️️%S", alert_message = Alert_TPSL)
if strategy.position_size < 0 and mode == true and hedge_mode == 0
    //strategy.close_all(comment = "TP❤️️SH", alert_message = Alert_TPSL, immediately = true)
    strategy.exit("Exit",'Short', qty_percent = 100, profit = takeprofit, stop = stoploss, comment_profit = "TP❤️️%S", comment_loss = "SL❤️️%S", alert_message = Alert_TPSL)
    //strategy.exit("Exit",'Short', qty_percent = 100, profit = takeprofit, stop = stoploss, comment_profit = "TP❤️️S", comment_loss = "SL❤️️S", alert_message = Alert_TPSL)

if strategy.position_size < 0 and strategy.openprofit >= tp_pnl and mode == true and hedge_mode == 2
    lastsize = (strategy.position_size) * -1
    lastprofitorder = strategy.openprofit
    //if lastprofitorder >= 0.07
    //strategy.close('Short', qty = lastsize, comment = "TP❤️️S", alert_message = Alert_TPSL, immediately = true)
    strategy.cancel_all()
    strategy.close_all(comment = "TP❤️️PNL", alert_message = Alert_TPSL, immediately = true)
    //strategy.close_all(comment = "TP❤️️SH", alert_message = Alert_TPSL)
    //strategy.exit("Exit",'Short2', qty_percent = 100, profit = last_price_s, stop = stoploss, comment_profit = "TP❤️️SH", comment_loss = "SL❤️️SH", alert_message = Alert_TPSL)
    //strategy.exit("Exit",'Short', qty_percent = 100, profit = last_price_s, stop = stoploss, comment_profit = "TP❤️️S", comment_loss = "SL❤️️S", alert_message = Alert_TPSL)
else if strategy.position_size < 0 and strategy.openprofit < tp_pnl and mode == true and hedge_mode == 2
    strategy.exit("Exit",'Short', qty_percent = 100, stop = stoploss, comment_loss = "SL❤️️%S", alert_message = Alert_TPSL)


//else if strategy.position_size < 0 and strategy.opentrades > 1
//    lastsize = (strategy.position_size) * -1
//    lastprofitorder = strategy.openprofit
//    if lastprofitorder >= 0.07
//        strategy.close_all(comment = "TP❤️️SS", alert_message = Alert_TPSL)

//===================== เรียกใช้  library =========================
import X4815162342/X48_LibaryStrategyStatus/2 as fuLi 
//แสดงผล Backtest

show_Net = input.bool(true,'Monitor Profit&Loss', inline = 'Lnet', group = '= PNL MONITOR SETTING =')
position_ = input.string('bottom_center','Position', options = ['top_right','middle_right','bottom_right','top_center','middle_center','bottom_center','middle_left','bottom_left'] , inline = 'Lnet')
size_i = input.string('auto','size', options = ['auto','tiny','small','normal'] , inline = 'Lnet') 
color_Net = input.color(color.blue,"" , inline = 'Lnet')
// fuLi.NetProfit_Show(show_Net , position_ , size_i,  color_Net )

Forums

PINE Language FAQ Summary MyLanguage Web3 About Us

Product

Robot Strategy Node Platforms Tickets

API

Syntax guide User guide Trading api Blockchain Indicator