Múltiples indicadores técnicos para la detección de cambios en el oro en tiempo real y estrategias de gestión de riesgos
MA EMA ATR STC HEIKIN ASHI CHANDELIER EXIT supertrend RMA VWMA WMA HMA
ianzeng123
Descripción general de la estrategia
La estrategia de detección de cambios instantáneos en el oro y gestión de riesgos de los indicadores técnicos múltiples es un sistema de negociación de oro basado en el gráfico Heikin Ashi de 1 minuto que combina varios indicadores técnicos como señales de negociación y herramientas de confirmación. La estrategia utiliza principalmente la salida de Candelier como indicador principal y, opcionalmente, combina indicadores como el filtro EMA, la tendencia súper, la tendencia súper y el ciclo de tendencia Schaff como herramientas de confirmación. La estrategia utiliza un mecanismo de parada y pérdida flexible y proporciona un instrumental de negociación visual que permite a los operadores monitorear el estado de las operaciones en tiempo real.
Principio de estrategia
La estrategia se basa en un sistema de confirmación de señales de varios niveles, cuya lógica central es la siguiente:
Generación de señales de indicadores dominantesLa estrategia utiliza la salida de Candelier como indicador principal. La salida de Candelier es un indicador de seguimiento de tendencias que utiliza el ATR (rango real promedio) multiplicado para determinar la posición de parada y generar señales de más y menos.
Filtrado de indicadores confirmadosLa estrategia permite al comerciante activar selectivamente varios indicadores de confirmación:
- Filtro EMA: el precio debe estar por encima de la línea EMA indicada (en la parte superior) o por debajo (en la parte inferior)
- Supertrend: Necesidad de coincidir con la dirección de la señal dominante
- Ciclo de tendencia de Schaff (STC): necesita estar por encima de la línea superior (Multiple) o por debajo de la línea inferior (Blanco)
Mecanismo de caducidad de señal: La estrategia ha implementado la función de caducidad de la señal, que permite configurar el número de tokens válidos en la señal, evitando el comercio en la señal antigua.
Logía de ejecución de transacciones: Cuando se cumplen todas las condiciones seleccionadas, la estrategia genera una señal de entrada y establece automáticamente un stop loss de un número fijo de puntos.
Optimización del procesamiento de datos: El uso estratégico de las funciones de muestreo condicional EMA y SMA, junto con un filtro de rango dedicado, mejora la eficiencia de cálculo de los indicadores técnicos.
Sistema de visualización: Dispone de un panel de instrumentos de negociación que muestra el estado de los indicadores y marca en el gráfico las posiciones de las señales de negociación y de los stop-loss.
Ventajas estratégicas
Mecanismo de confirmación múltiple: Confirmación de múltiples indicadores reduce significativamente las señales falsas y mejora la precisión de las operaciones. Cuando varios indicadores confirman conjuntamente una dirección, las señales de negociación son más confiables.
Una combinación flexible de indicadores: El usuario tiene la libertad de activar o desactivar varios indicadores de confirmación y personalizar el rendimiento de la estrategia en función de las diferentes condiciones del mercado.
La gestión de riesgos precisa: La estrategia permite al usuario establecer un número específico de puntos de parada y pérdida, lo que permite un control preciso del riesgo y la rentabilidad de cada operación.
Control de la caducidad de la señalLa estrategia de evitar el comercio de señales caducadas, reduciendo el riesgo de retraso, mediante la fijación de la duración de la señal.
Interfaz de transacciones de alta visibilidadEl indicador de negociación muestra de forma intuitiva el estado de todos los indicadores, ayudando a los operadores a evaluar rápidamente las condiciones del mercado.
Optimización para el mercado del oro: La estrategia se ha optimizado para las características del mercado del oro, especialmente teniendo en cuenta la conversión de puntos (un punto = 0,1 dólares).
Adaptabilidad de las transacciones de alta frecuenciaEl ciclo de tiempo de 1 minuto permite a la estrategia capturar las fluctuaciones de precios a corto plazo y es adecuado para los operadores diarios.
Riesgo estratégico
El riesgo de sobrecomercializaciónEl ciclo de 1 minuto puede generar demasiadas señales de transacción, lo que aumenta los costos de transacción y el exceso de transacciones. La solución es ajustar la cantidad de indicadores de confirmación o aumentar las condiciones de filtración de la señal.
El impacto del ruido en el mercado: Los períodos de tiempo bajos son más susceptibles a la interferencia del ruido del mercado, lo que genera falsas señales. Se recomienda usar con precaución durante los períodos de alta volatilidad, o en combinación con la confirmación de tendencias en períodos más largos.
El retraso en la acumulación de indicadores: La confirmación de múltiples indicadores, aunque reduce las señales falsas, también aumenta la latencia del sistema, lo que puede causar la pérdida de algunas oportunidades de ganancias. Se puede considerar reducir la cantidad de indicadores de confirmación para mejorar la velocidad de respuesta.
Limitaciones de la pérdida fija de frenadoLos puntos fijos no tienen en cuenta los cambios en la volatilidad del mercado. En períodos de alta volatilidad, los puntos fijos pueden estar demasiado cerca y los períodos bajos demasiado lejos. Se recomienda ajustar el valor de los puntos fijos de acuerdo con la dinámica actual del ATR.
Riesgos especiales en el mercado del oroEl mercado del oro está influenciado por una serie de factores macroeconómicos, incluidos los datos de inflación, la política del banco central, la geopolítica, etc. El análisis técnico puro puede ignorar estos efectos. Se recomienda su uso en combinación con el análisis fundamental.
Dependencia del indicador dominante: La estrategia depende en exceso de las exportaciones de Taiwán como indicador dominante, que puede tener un mal desempeño en los mercados interbancarios. Se recomienda agregar la opción de elegir varios indicadores dominantes.
Dirección de optimización de la estrategia
Indicadores clave para la diversificaciónLa estrategia actual solo admite exportaciones en alza como indicador dominante, y puede ampliarse para admitir opciones de indicadores dominantes como el Brin Belt, el MACD o el Moving Average Adaptable, entre otros, para adaptarse a diferentes entornos de mercado.
Dinámica paralización de pérdidas: Cambiar el stop loss de punto fijo por el stop loss dinámico basado en ATR, para adaptarse mejor a los cambios en la volatilidad del mercado. Por ejemplo, se puede usar
sl_value = atr(14) * 1.5En lugar de puntos fijos.Integración del filtro de tiempoAumentar los filtros de tiempo de negociación, evitando los momentos de baja liquidez o los momentos importantes de los comunicados de prensa, puede reducir el riesgo de deslizamientos y fluctuaciones inesperadas de los precios.
Añadir análisis de volumenLos indicadores de volumen de transacción integrados pueden verificar la intensidad de los movimientos de precios y mejorar la calidad de la señal. Por ejemplo, la señal de ruptura solo se confirma cuando el volumen de transacción aumenta.
Mejoras en el aprendizaje automáticoIntroducción de algoritmos de aprendizaje automático para ajustar dinámicamente el peso de los indicadores según los parámetros de la estrategia de adaptación al rendimiento del mercado reciente.
Mecanismo de entrada y salida por lotesImplementación de mecanismos de entrada y salida por lotes para reducir el riesgo de tiempo de un solo punto de entrada y salida, por ejemplo, la creación de una bodega en tres etapas y la liquidación en tres etapas.
Confirmación de varios períodos de tiempoConfirmación de la tendencia de incrementar los períodos de tiempo más altos: abre posiciones sólo en la dirección de la tendencia de los períodos de tiempo más altos, reduciendo el riesgo de negociación en contra.
Análisis de la correlación de los indicadores: analizar la correlación entre los indicadores seleccionados y evitar el uso de indicadores altamente correlacionados como confirmación, lo que puede conducir a la confirmación múltiple de falsedades.
Resumir
La estrategia de detección de cambios inmediatos y gestión de riesgos de los indicadores técnicos múltiples de oro es un sistema de negociación complejo dirigido a los operadores a corto plazo que ofrece una señal de negociación más confiable mediante la integración de varios indicadores técnicos. La ventaja central de la estrategia reside en su mecanismo de confirmación de indicadores flexibles y su interfaz visual intuitiva, que permite al comerciante ajustar los parámetros de la estrategia en función de las condiciones del mercado.
La estrategia puede mejorar aún más su adaptabilidad y robustez mediante la implementación de las medidas de optimización recomendadas, en particular, el stop loss dinámico, la confirmación de múltiples períodos de tiempo y la diversificación de los indicadores dominantes. Para los comerciantes de día y los aficionados al comercio de oro en línea corta, esta estrategia ofrece un marco de análisis técnico, pero debe combinarse con los principios de gestión de fondos y la comprensión básica del mercado para obtener el mejor efecto.
En última instancia, el éxito de la negociación depende no sólo de la estrategia en sí, sino también de la comprensión y ejecución correcta de la estrategia por parte del comerciante. La retroalimentación, optimización y adaptación continua de la estrategia es clave para lograr resultados de negociación estables a largo plazo.
/*backtest
start: 2024-03-05 00:00:00
end: 2025-03-03 08:00:00
period: 1d
basePeriod: 1d
exchanges: [{"eid":"Futures_Binance","currency":"ETH_USDT"}]
*/
//@version=5
strategy("1 Min Gold Heikin Ashi Strategy", overlay=true, max_bars_back=500)
// Adjustable TP & SL in Pips
tp_pips = input.int(50, title="Take Profit (Pips)")
sl_pips = input.int(30, title="Stop Loss (Pips)")
// Convert pips to price value for XAUUSD (1 pip = 0.1 in Gold)
tp_value = tp_pips * 0.1
sl_value = sl_pips * 0.1
// Fixed components
justcontinue = bool(true)
ma(_source, _length, _type) =>
switch _type
"SMA" => ta.sma (_source, _length)
"EMA" => ta.ema (_source, _length)
"RMA" => ta.rma (_source, _length)
"WMA" => ta.wma (_source, _length)
"VWMA" => ta.vwma(_source, _length)
alarm(_osc, _message) =>
alert(syminfo.ticker + ' ' + _osc + ' : ' + _message + ', price (' + str.tostring(close, format.mintick) + ')')
// Conditional Sampling EMA Function
Cond_EMA(x, cond, n) =>
var val = array.new_float(0)
var ema_val = array.new_float(1)
if cond
array.push(val, x)
if array.size(val) > 1
array.remove(val, 0)
if na(array.get(ema_val, 0))
array.fill(ema_val, array.get(val, 0))
array.set(ema_val, 0, (array.get(val, 0) - array.get(ema_val, 0)) * (2 / (n + 1)) + array.get(ema_val, 0))
EMA = array.get(ema_val, 0)
EMA
// Conditional Sampling SMA Function
Cond_SMA(x, cond, n) =>
var vals = array.new_float(0)
if cond
array.push(vals, x)
if array.size(vals) > n
array.remove(vals, 0)
SMA = array.avg(vals)
SMA
// Standard Deviation Function
Stdev(x, n) =>
math.sqrt(Cond_SMA(math.pow(x, 2), 1, n) - math.pow(Cond_SMA(x, 1, n), 2))
// Range Size Function
rng_size(x, scale, qty, n) =>
ATR = Cond_EMA(ta.tr(true), 1, n)
AC = Cond_EMA(math.abs(x - x[1]), 1, n)
SD = Stdev(x, n)
rng_size = scale == 'Pips' ? qty * 0.0001 : scale == 'Points' ? qty * syminfo.pointvalue : scale == '% of Price' ? close * qty / 100 : scale == 'ATR' ? qty * ATR : scale == 'Average Change' ? qty * AC : scale == 'Standard Deviation' ? qty * SD : scale == 'Ticks' ? qty * syminfo.mintick : qty
rng_size
// Two Type Range Filter Function
rng_filt(h, l, rng_, n, type, smooth, sn, av_rf, av_n) =>
rng_smooth = Cond_EMA(rng_, 1, sn)
r = smooth ? rng_smooth : rng_
var rfilt = array.new_float(2, (h + l) / 2)
array.set(rfilt, 1, array.get(rfilt, 0))
if type == 'Type 1'
if h - r > array.get(rfilt, 1)
array.set(rfilt, 0, h - r)
if l + r < array.get(rfilt, 1)
array.set(rfilt, 0, l + r)
if type == 'Type 2'
if h >= array.get(rfilt, 1) + r
array.set(rfilt, 0, array.get(rfilt, 1) + math.floor(math.abs(h - array.get(rfilt, 1)) / r) * r)
if l <= array.get(rfilt, 1) - r
array.set(rfilt, 0, array.get(rfilt, 1) - math.floor(math.abs(l - array.get(rfilt, 1)) / r) * r)
rng_filt1 = array.get(rfilt, 0)
hi_band1 = rng_filt1 + r
lo_band1 = rng_filt1 - r
rng_filt2 = Cond_EMA(rng_filt1, rng_filt1 != rng_filt1[1], av_n)
hi_band2 = Cond_EMA(hi_band1, rng_filt1 != rng_filt1[1], av_n)
lo_band2 = Cond_EMA(lo_band1, rng_filt1 != rng_filt1[1], av_n)
rng_filt = av_rf ? rng_filt2 : rng_filt1
hi_band = av_rf ? hi_band2 : hi_band1
lo_band = av_rf ? lo_band2 : lo_band1
[hi_band, lo_band, rng_filt]
// Moving Average Function
ma_function(source, length, type) =>
if type == 'RMA'
ta.rma(source, length)
else if type == 'SMA'
ta.sma(source, length)
else if type == 'EMA'
ta.ema(source, length)
else if type == 'WMA'
ta.wma(source, length)
else if type == 'HMA'
if (length < 2)
ta.hma(source, 2)
else
ta.hma(source, length)
else
ta.vwma(source, length)
// Get Table Size
table_size(s) =>
switch s
"Auto" => size.auto
"Huge" => size.huge
"Large" => size.large
"Normal" => size.normal
"Small" => size.small
=> size.tiny
// Confirmation Setup
confirmation_counter = array.new_string(0)
confirmation_val = array.new_string(0)
confirmation_val_short = array.new_string(0)
pushConfirmation(respect, label, longCondition, shortCondition) =>
if respect
array.push(confirmation_counter, label)
array.push(confirmation_val, longCondition ? "✔️" : "❌")
array.push(confirmation_val_short, shortCondition ? "✔️" : "❌")
leadinglongcond = bool(na)
leadingshortcond = bool(na)
longCond = bool(na)
shortCond = bool(na)
longCondition = bool(na)
shortCondition = bool(na)
// Indicator Setup Inputs
setup_group = "████████ Indicator Setup ████████"
signalexpiry = input.int(defval=3, title='Signal Expiry Candle Count', group=setup_group, inline='expiry', tooltip="Number of candles to wait for all indicators to confirm a signal. Default is 3.")
alternatesignal = input.bool(true, "Alternate Signal", group=setup_group, inline='alternate')
showsignal = input.bool(true, "Show Long/Short Signal", group=setup_group, inline='showsignal', tooltip="Option to turn on/off the Long/Short signal shown on the chart.")
showdashboard = input.bool(true, "Show Dashboard", group=setup_group, inline='dashboard')
string i_tab1Ypos = input.string('bottom', 'Dashboard Position', group=setup_group, inline='dashboard2', options=['top', 'middle', 'bottom'])
string i_tab1Xpos = input.string('right', '', inline='dashboard2', group=setup_group, options=['left', 'center', 'right'])
in_dashboardtab_size = input.string(title="Dashboard Size", defval="Normal", options=["Auto", "Huge", "Large", "Normal", "Small", "Tiny"], group=setup_group, inline="dashboard3")
// Confirmation Indicator Settings
confirmation_group = "████████ Confirmation Indicators (filter) ████████"
respectce = input.bool(false, "Chandelier Exit", group=confirmation_group, inline='ce')
respectema = input.bool(false, "EMA Filter", group=confirmation_group, inline='respectema')
respectemaperiod = input.int(defval=200, minval=1, title='', group=confirmation_group, inline='respectema', tooltip="EMA filter for confirmation.")
respectst = input.bool(false, "SuperTrend", group=confirmation_group, inline='st')
respectstc = input.bool(false, "Schaff Trend Cycle (STC)", group=confirmation_group, inline='stc')
// Switchboard Indicators
switchboard_group = "████ Switch Board (Turn On/Off Overlay Indicators) ████"
switch_ema = input.bool(false, "EMA", group=switchboard_group, inline='Switch1')
switch_supertrend = input.bool(false, "Supertrend", group=switchboard_group, inline='Switch2')
switch_stc = input.bool(false, "STC", group=switchboard_group, inline='Switch3')
// ----------------------------------------
// 4. Indicator Code
// Chandelier Exit
////////////////////////////////////////////////
////// Chandelier Exit
///////////////////////////////////////////////
ChandelierE = "██████████ Chandelier Exit ██████████"
ce_length = input.int(title='ATR Period', defval=22, group=ChandelierE)
ce_mult = input.float(title='ATR Multiplier', step=0.1, defval=3.0, group=ChandelierE)
showLabels = input.bool(title='Show Buy/Sell Labels?', defval=true, group=ChandelierE)
useClose = input.bool(title='Use Close Price for Extremums?', defval=true, group=ChandelierE)
highlightState = input.bool(title='Highlight State?', defval=true, group=ChandelierE)
ce_atr = ce_mult * ta.atr(ce_length)
longStop = (useClose ? ta.highest(close, ce_length) : ta.highest(ce_length)) - ce_atr
longStopPrev = nz(longStop[1], longStop)
longStop := close[1] > longStopPrev ? math.max(longStop, longStopPrev) : longStop
shortStop = (useClose ? ta.lowest(close, ce_length) : ta.lowest(ce_length)) + ce_atr
shortStopPrev = nz(shortStop[1], shortStop)
shortStop := close[1] < shortStopPrev ? math.min(shortStop, shortStopPrev) : shortStop
var int dir = 1
dir := close > shortStopPrev ? 1 : close < longStopPrev ? -1 : dir
ce_long = dir == 1
ce_short = dir == -1
// EMA Filter
////////////////////////////////////////////////////////////////////////////
//////////// EMA Filter
////////////////////////////////////////////////////////////////////////////
respectemavalue = ta.ema(close, respectemaperiod)
isaboverespectema = close > respectemavalue
isbelowrespectema = close < respectemavalue
// SuperTrend Calculation
////////////////////////////////
///// SuperTrend
//////////////////////////////
sp_group = "██████████ SuperTrend ██████████"
Periods = input.int(title='ATR Period', defval=10, group=sp_group)
stsrc = input.source(hl2, title='Source', group=sp_group)
Multiplier = input.float(title='ATR Multiplier', step=0.1, defval=3.0, group=sp_group)
changeATR = input.bool(title='Change ATR Calculation Method?', defval=true, group=sp_group)
statr2 = ta.sma(ta.tr, Periods)
statr = changeATR ? ta.atr(Periods) : statr2
stup = stsrc - Multiplier * statr
up1 = nz(stup[1], stup)
stup := close[1] > up1 ? math.max(stup, up1) : stup
dn = stsrc + Multiplier * statr
dn1 = nz(dn[1], dn)
dn := close[1] < dn1 ? math.min(dn, dn1) : dn
sttrend = 1
sttrend := nz(sttrend[1], sttrend)
sttrend := sttrend == -1 and close > dn1 ? 1 : sttrend == 1 and close < up1 ? -1 : sttrend
stbuySignal = sttrend == 1 and sttrend[1] == -1
stsellSignal = sttrend == -1 and sttrend[1] == 1
isstup = bool(na)
isstdown = bool(na)
isstup := sttrend == 1
isstdown := sttrend != 1
// Schaff Trend Cycle (STC)
/////////////////////////
/// STC overlay signal
/////////////////////////
stc_group = "██████████ Schaff Trend Cycle (STC) ██████████"
fastLength = input.int(title='MACD Fast Length', defval=23, group=stc_group)
slowLength = input.int(title='MACD Slow Length', defval=50, group=stc_group)
cycleLength = input.int(title='Cycle Length', defval=10, group=stc_group)
d1Length = input.int(title='1st %D Length', defval=3, group=stc_group)
d2Length = input.int(title='2nd %D Length', defval=3, group=stc_group)
srcstc = input.source(title='Source', defval=close, group=stc_group)
upper = input.int(title='Upper Band', defval=75, group=stc_group)
lower = input.int(title='Lower Band', defval=25, group=stc_group)
v_show_last = input.int(2000, "Plotting Length", group=stc_group)
macd = ta.ema(srcstc, fastLength) - ta.ema(srcstc, slowLength)
k = nz(fixnan(ta.stoch(macd, macd, macd, cycleLength)))
d = ta.ema(k, d1Length)
kd = nz(fixnan(ta.stoch(d, d, d, cycleLength)))
stc = ta.ema(kd, d2Length)
stc := math.max(math.min(stc, 100), 0)
stcColor1 = stc > stc[1] ? color.green : color.red
stcColor2 = stc > upper ? color.green : stc <= lower ? color.red : color.orange
upperCrossover = ta.crossover(stc, upper)
upperCrossunder = ta.crossunder(stc, upper)
lowerCrossover = ta.crossover(stc, lower)
lowerCrossunder = ta.crossunder(stc, lower)
stcup = stc >= upper
stcdown = stc <= lower
// ----------------------------------------
// 5. Switchboard Code
// Additional code for EMA from Switchboard
/////////////////////////////////////////////////////////////////////////
// EMA Selection
/////////////////////////////////////////////////////////////////////////
ma_group= "██████████ MAs Line ██████████"
len1bool = input.bool(true, '', group=ma_group, inline='len1')
len1 = input.int(5, title='MA 1', group=ma_group, inline='len1')
string ma_1_type = input.string(defval='EMA', title='Type', options=['RMA', 'SMA', 'EMA', 'WMA', 'HMA', 'VWMA'], inline='len1', group=ma_group)
color ma_1_colour = input.color(color.rgb(254, 234, 74, 0), '', inline='len1', group=ma_group)
len2bool = input.bool(true, '', group=ma_group, inline='len2')
len2 = input.int(13, minval=1, title='MA 2', group=ma_group, inline='len2')
string ma_2_type = input.string(defval='EMA', title='Type', options=['RMA', 'SMA', 'EMA', 'WMA', 'HMA', 'VWMA'], inline='len2', group=ma_group)
color ma_2_colour = input.color(color.rgb(253, 84, 87, 0), '', inline='len2', group=ma_group)
len3bool = input.bool(false, '', group=ma_group, inline='len3')
len3 = input.int(20, minval=1, title='MA 3', group=ma_group, inline='len3')
string ma_3_type = input.string(defval='EMA', title='Type', options=['RMA', 'SMA', 'EMA', 'WMA', 'HMA', 'VWMA'], inline='len3', group=ma_group)
color ma_3_colour = input.color(color.new(color.aqua, 0), '', inline='len3', group=ma_group)
len4bool = input.bool(true, '', group=ma_group, inline='len4')
len4 = input.int(50, minval=1, title='MA 4', group=ma_group, inline='len4')
string ma_4_type = input.string(defval='EMA', title='Type', options=['RMA', 'SMA', 'EMA', 'WMA', 'HMA', 'VWMA'], inline='len4', group=ma_group)
color ma_4_colour = input.color(color.new(color.blue, 0), '', inline='len4', group=ma_group)
len5bool = input.bool(true, '', group=ma_group, inline='len5')
len5 = input.int(200, minval=1, title='MA 5', group=ma_group, inline='len5')
string ma_5_type = input.string(defval='EMA', title='Type', options=['RMA', 'SMA', 'EMA', 'WMA', 'HMA', 'VWMA'], inline='len5', group=ma_group)
color ma_5_colour = input.color(color.new(color.white, 0), '', inline='len5', group=ma_group)
// Request Security for MA calculations
ema1 = request.security(syminfo.tickerid, timeframe.period, ma_function(close, len1, ma_1_type))
ema2 = request.security(syminfo.tickerid, timeframe.period, ma_function(close, len2, ma_2_type))
ema3 = request.security(syminfo.tickerid, timeframe.period, ma_function(close, len3, ma_3_type))
ema4 = request.security(syminfo.tickerid, timeframe.period, ma_function(close, len4, ma_4_type))
ema5 = request.security(syminfo.tickerid, timeframe.period, ma_function(close, len5, ma_5_type))
// Plot the Moving Averages
plot(len1bool and switch_ema ? ema1 : na, color=ma_1_colour, linewidth=2, title='MA 1')
plot(len2bool and switch_ema ? ema2 : na, color=ma_2_colour, linewidth=2, title='MA 2')
plot(len3bool and switch_ema ? ema3 : na, color=ma_3_colour, linewidth=2, title='MA 3')
plot(len4bool and switch_ema ? ema4 : na, color=ma_4_colour, linewidth=2, title='MA 4')
plot(len5bool and switch_ema ? ema5 : na, color=ma_5_colour, linewidth=2, title='MA 5')
// Additional code for SuperTrend from switchboard
///////////////////////////////////////////////////
// SuperTrend - Switchboard
///////////////////////////////////////////////////
upPlot = plot(sttrend == 1 and switch_supertrend ? stup : na, title='Up Trend', style=plot.style_linebr, linewidth=2, color=color.new(color.green, 0))
plotshape(stbuySignal and switch_supertrend ? stup : na, title='UpTrend Begins', location=location.absolute, style=shape.circle, size=size.tiny, color=color.new(color.green, 0))
dnPlot = plot(sttrend != 1 and switch_supertrend ? dn : na, title='Down Trend', style=plot.style_linebr, linewidth=2, color=color.new(color.red, 0))
plotshape(stsellSignal and switch_supertrend ? dn : na, title='DownTrend Begins', location=location.absolute, style=shape.circle, size=size.tiny, color=color.new(color.red, 0))
// Additional code for Schaff Trend Cycle (STC) from switchboard
/////////////////////////////////////////////
// Schaff Trend Cycle (STC) - Switchboard
/////////////////////////////////////////////
plotshape(stcdown and switch_stc ? true : na, style=shape.circle, location=location.top, show_last=v_show_last, color=color.new(color.red, 0), title='STC Sell')
plotshape(stcup and switch_stc ? true : na, style=shape.circle, location=location.top, show_last=v_show_last, color=color.new(color.green, 0), title='STC Buy')
// ----------------------------------------
// 6. Declare and Initialize 'leadingindicator'
leadingindicator = input.string(title="Leading Indicator", defval="Chandelier Exit",
options=["Chandelier Exit"], group="████████ Main Indicator (signal) ████████")
// 6. Leading Indicator Logic
if leadingindicator == 'Chandelier Exit'
leadinglongcond := ce_long
leadingshortcond := ce_short
// ----------------------------------------
// 7. Confirmation Indicator Logic
longCond := leadinglongcond
shortCond := leadingshortcond
longCond := longCond and (respectce ? ce_long : justcontinue)
shortCond := shortCond and (respectce ? ce_short : justcontinue)
longCond := longCond and (respectema ? isaboverespectema : justcontinue)
shortCond := shortCond and (respectema ? isbelowrespectema : justcontinue)
longCond := longCond and (respectst ? isstup : justcontinue)
shortCond := shortCond and (respectst ? isstdown : justcontinue)
longCond := longCond and (respectstc ? stcup : justcontinue)
// ----------------------------------------
// 7. Confirmation Indicator Logic
longCond := leadinglongcond
shortCond := leadingshortcond
longCond := longCond and (respectce ? ce_long : justcontinue)
shortCond := shortCond and (respectce ? ce_short : justcontinue)
longCond := longCond and (respectema ? isaboverespectema : justcontinue)
shortCond := shortCond and (respectema ? isbelowrespectema : justcontinue)
longCond := longCond and (respectst ? isstup : justcontinue)
shortCond := shortCond and (respectst ? isstdown : justcontinue)
longCond := longCond and (respectstc ? stcup : justcontinue)
shortCond := shortCond and (respectstc ? stcdown : justcontinue)
// ----------------------------------------
// 8. Function to Update Dashboard Label
pushConfirmation(respectce, "Chandelier Exit", ce_long, ce_short)
pushConfirmation(respectema, "EMA", isaboverespectema, isbelowrespectema)
pushConfirmation(respectst, "SuperTrend", isstup, isstdown)
pushConfirmation(respectstc, "Schaff Trend Cycle", stcup, stcdown)
// ----------------------------------------
// 9. Final Part (Dashboard Table and Signal Plotting)
leadingstatus = leadinglongcond ? "✔️" : "❌"
leadingstatus_short = leadingshortcond ? "✔️" : "❌"
rowcount = int(na)
if array.size(confirmation_counter) == 0
rowcount := 5
else
rowcount := array.size(confirmation_counter) + 4
// Signal Expiry Logic
var int leadinglong_count = 0
var int leadinglong_count2 = 0
var int leadingshort_count = 0
var int leadingshort_count2 = 0
if leadinglongcond
leadinglong_count := leadinglong_count + 1
leadinglong_count2 := leadinglong_count
for i = 1 to 100
if leadinglongcond[i]
leadinglong_count := leadinglong_count + 1
leadinglong_count2 := leadinglong_count
else
leadinglong_count := 0
break
if leadingshortcond
leadingshort_count := leadingshort_count + 1
leadingshort_count2 := leadingshort_count
for i = 1 to 100
if leadingshortcond[i]
leadingshort_count := leadingshort_count + 1
leadingshort_count2 := leadingshort_count
else
leadingshort_count := 0
break
// Expiry Condition
CondIni = 0
// If expiry option is used
longcond_withexpiry = longCond and leadinglong_count2 <= signalexpiry
shortcond_withexpiry = shortCond and leadingshort_count2 <= signalexpiry
// Without expiry
longCondition := longcond_withexpiry and CondIni[1] == -1
shortCondition := shortcond_withexpiry and CondIni[1] == 1
if alternatesignal
longCondition := longcond_withexpiry and CondIni[1] == -1
shortCondition := shortcond_withexpiry and CondIni[1] == 1
else
longCondition := longcond_withexpiry
shortCondition := shortcond_withexpiry
CondIni := longcond_withexpiry ? 1 : shortcond_withexpiry ? -1 : CondIni[1]
// Check if expiry count is crossed
is_expiry_count_crossed_long = leadinglong_count2 >= signalexpiry
is_expiry_count_crossed_short = leadingshort_count2 >= signalexpiry
// Plot signals on chart
plotshape(showsignal ? (longCondition[1] ? false : longCondition) : na, title='Buy Signal', text='long', textcolor=color.new(color.white, 0), style=shape.labelup, size=size.tiny, location=location.belowbar, color=color.new(color.green, 0))
plotshape(showsignal ? (shortCondition[1] ? false : shortCondition) : na, title='Sell Signal', text='short', textcolor=color.new(color.white, 0), style=shape.labeldown, size=size.tiny, location=location.abovebar, color=color.new(color.red, 0))
// Alerts
alertcondition(longCondition, title='Buy Alert', message='BUY')
alertcondition(shortCondition, title='Sell Alert', message='SELL')
alertcondition(longCondition or shortCondition, title='Buy or Sell Alert', message="Buy or Sell Alert")
/// ----------------------------------------
// 10. Strategy Execution - Entries & Exits
// Use already declared TP & SL values (from the start of the script)
// Long Entry Conditions
if longCondition
strategy.entry("Long", strategy.long)
strategy.exit("TakeProfit_Long", from_entry="Long", limit=close + tp_value, stop=close - sl_value)
// Short Entry Conditions
if shortCondition
strategy.entry("Short", strategy.short)
strategy.exit("TakeProfit_Short", from_entry="Short", limit=close - tp_value, stop=close + sl_value)