Mehrere technische Indikatoren für die Echtzeiterkennung von Goldveränderungen und Risikomanagementstrategien
MA EMA ATR STC HEIKIN ASHI CHANDELIER EXIT supertrend RMA VWMA WMA HMA
ianzeng123
Strategieübersicht
Die Multiple Technical Indicators Gold Instant Change Detection and Risk Management Strategy ist ein Gold-Trading-System, das auf dem 1-Minuten-Heikin Ashi-Chart basiert und mehrere technische Indikatoren als Handelssignale und Bestätigungswerkzeuge kombiniert. Die Strategie verwendet hauptsächlich den Niedergangsausgang (Chandelier Exit) als leitenden Indikator und kombiniert optional Indikatoren wie den EMA-Filter, den Supertrend (SuperTrend) und die Schaff-Trend-Zyklus (Schaff Trend Cycle) als Bestätigungswerkzeuge. Die Strategie verwendet eine flexible Stop-Loss-Methode und bietet eine intuitive Handelstabelle, die es dem Händler ermöglicht, die Handelsstatus in Echtzeit zu überwachen.
Strategieprinzip
Die Strategie basiert auf einem mehrschichtigen Signal-Bestätigungssystem, dessen Kernlogik lautet:
Herstellung von SignalenDie Strategie basiert auf dem “Chandelier Exit” als Leitindikator. Der “Chandelier Exit” ist ein Trendverfolgungsindikator, der das ATR (Average True Range) multipliziert, um die Stop-Loss-Position zu bestimmen und Mehrkopf- und Leerkopfsignale zu erzeugen.
Bestätigung des FiltersDie Strategie erlaubt den Händlern, mehrere Bestätigungsindikatoren selektiv zu aktivieren:
- EMA-Filter: Die Preise müssen über der angegebenen EMA-Linie liegen (Mehrkopf) oder darunter (Leerkopf)
- Supertrend (SuperTrend): muss mit der Richtung des vorherrschenden Signals übereinstimmen
- Schaff-Trend-Zyklus ((STC): Bedarf höher als die obere Grenze ((Mehrköpfe) oder niedriger als die untere Grenze ((Leerköpfe))
Signal-AuslaufmechanismusDie Strategie implementiert eine Signal-Auslauffunktion, die die Anzahl der Tons, die für ein Signal gültig sind, einstellt, um den Handel auf einem alten Signal zu verhindern.
Logik der TransaktionsdurchführungWenn alle gewählten Bedingungen erfüllt sind, erzeugt die Strategie ein Einstiegssignal und setzt automatisch einen Stop-Stop-Loss mit einer festen Punktzahl ein.
Optimierung der DatenverarbeitungStrategie: Einsatz der EMA- und SMA-Funktionen für die Konditionsmusterung sowie eines speziellen Bereichsfilters, um die Berechnungs-Effizienz der technischen Kennzahlen zu verbessern.
VisualisierungDie Handelstabelle zeigt den Status der einzelnen Indikatoren an und markiert die Handelssignale und die Stop-Loss-Positionen auf den Diagrammen.
Strategische Vorteile
MehrfachbestätigungDurch die Bestätigung mehrerer Indikatoren wird die Falschmeldung deutlich reduziert und die Handelsgenauigkeit erhöht. Die Handelssignale sind zuverlässiger, wenn mehrere Indikatoren gemeinsam eine Richtung bestätigen.
Flexible KomponentenDer Benutzer kann die verschiedenen Bestätigungsindikatoren frei aktivieren oder deaktivieren, um die Strategie nach den unterschiedlichen Marktbedingungen anzupassen.
Genaues RisikomanagementStrategie: Die Strategie erlaubt dem Benutzer, eine bestimmte Anzahl von Stop-Loss-Punkten einzurichten, um die Risikobeträge für jeden Handel genau zu kontrollieren.
SignalüberschreitungDie Strategie vermeidet den Handel mit veralteten Signalen und reduziert das Risiko von Verzögerungen durch die Einstellung der Gültigkeitsdauer der Signale.
Hochvisualisierte HandelsinterfaceDie Handelsanzeige zeigt den Zustand aller Indikatoren und hilft den Händlern, die Marktbedingungen schnell zu beurteilen.
Optimierung für den GoldmarktDie Strategie wurde optimiert, um die Eigenschaften des Goldmarktes zu berücksichtigen.
Anpassungsfähigkeit des HochfrequenzhandelsDie 1-minütige Zeitspanne ermöglicht es der Strategie, kurzfristige Kursschwankungen zu erfassen und ist für Intraday-Händler geeignet.
Strategisches Risiko
ÜberhändlerrisikenDie Lösung besteht darin, die Anzahl der Bestätigungsindikatoren anzupassen oder die Signalfilterbedingungen zu erhöhen.
Auswirkungen von MarktlärmEs wird empfohlen, in Zeiten hoher Volatilität mit Vorsicht zu handeln oder Trends in Verbindung mit längeren Zeiten zu bestätigen.
Rückstand bei der Überlagerung von IndikatorenMehrfache Kennzahlen-Bestätigung reduziert die Falschmeldungen, erhöht aber auch die Verzögerung des Systems und kann zu verpassten Gewinnchancen führen. Es kann in Erwägung gezogen werden, die Anzahl der Bestätigungskennzahlen zu reduzieren, um die Reaktionsgeschwindigkeit zu verbessern.
Die Grenzen des Fixed Stop LossesDie Stop-Loss-Werte werden nicht berücksichtigt, wenn die Marktvolatilität sich ändert. Die Stop-Loss-Werte können zu kurz und zu weit sein. Es wird empfohlen, die Stop-Loss-Werte an die aktuelle ATR-Dynamik anzupassen.
Besondere Risiken auf dem GoldmarktGoldmarkt wird von einer Vielzahl von makroökonomischen Faktoren beeinflusst, darunter Inflation, Zentralbankpolitik und Geopolitik, die in der reinen technischen Analyse möglicherweise nicht berücksichtigt werden. Es wird empfohlen, diese Faktoren in Kombination mit der fundamentalen Analyse zu verwenden.
Abhängigkeit von LeitindikatorenStrategie: Übermäßige Abhängigkeit von Rentabilitäts-Exporten als dominierender Indikator, der in den Zonenmärkten schlecht abschneiden kann. Es wird empfohlen, die Option für mehrere dominierende Indikatoren zu erweitern.
Richtung der Strategieoptimierung
Hauptindikatoren für die DiversifizierungDie derzeitige Strategie unterstützt nur die Erweiterung der Exporte als Leitindikator. Es können mehrere Leitindikatoroptionen wie Brinband, MACD oder Adaptive Moving Averages erweitert werden, um sich an unterschiedliche Marktbedingungen anzupassen.
Dynamische StoppschlägeEs ist möglich, dass die Anzahl der Stop-Losses an den Fixpunkten in ATR-basierten, dynamischen Stop-Losses umgewandelt wird, um besser auf Veränderungen in der Marktvolatilität reagieren zu können.
sl_value = atr(14) * 1.5Anstelle einer festen Punktzahl.Zeit-Filter-IntegrationDie Erhöhung der Filterzeit für den Handel und die Vermeidung von Zeiten mit geringer Liquidität oder wichtigen Pressemitteilungen verringert die Gefahr von Ausrutschen und unerwarteten Preisschwankungen.
Volumenanalyse hinzufügenDie Integration von Traffic Indicators kann die Intensität von Preisbewegungen verifizieren und die Signalqualität verbessern. Zum Beispiel wird ein Durchbruchsignal nur bestätigt, wenn der Traffic steigt.
Maschinelle LernoptimierungEinführung eines Algorithmus für maschinelles Lernen, der die Gewichte der einzelnen Indikatoren dynamisch anpasst und die Strategieparameter an die jüngste Marktentwicklung anpasst.
Eintritts- und AusstiegsmechanismenDie Einführung von Schüttel- und Ausstiegsmechanismen verringert das Zeitrisiko eines einzelnen Einstiegs- und Ausstiegspunktes, beispielsweise durch dreifache Ein- und Dreifache Auslagerung.
Bestätigung mehrerer ZeiträumeEs wird empfohlen, Positionen nur in Richtung des hohen Zeitzyklustrends zu eröffnen, um das Risiko eines nachteiligen Handels zu verringern.
Analyse der Relevanz der IndikatorenAnalysieren Sie die Korrelation zwischen den gewählten Kennzahlen und vermeiden Sie die Verwendung von hochkorrelativen Kennzahlen als Bestätigung, was zu einer Mehrfachbestätigung von Falschmeldungen führen kann.
Zusammenfassen
Die Multi-Technik-Indikator-Gold-Strategie ist ein komplexes Handelssystem für kurzfristige Händler, das durch die Integration mehrerer technischer Indikatoren zuverlässigere Handelssignale liefert. Die Kernvorteile der Strategie liegen in ihrer flexiblen Indikator-Bestätigungsmechanik und ihrer intuitiven visuellen Oberfläche, die es Händlern ermöglicht, die Strategieparameter an die Marktlage anzupassen. Die Benutzer müssen jedoch auf die Risiken achten, die dem Handel mit niedrigen Zeitzyklen verbunden sind, einschließlich übermäßiger Handel und Markträusch.
Die Strategie kann durch die Umsetzung der empfohlenen Optimierungsmaßnahmen, insbesondere der dynamischen Stop-Loss-Strategie, der Bestätigung von mehreren Zeiträumen und der Diversifizierung der dominanten Indikatoren, ihre Anpassungsfähigkeit und Stabilität weiter verbessern. Für Day-Trader und Gold-Liebhaber des Short-Line-Handels bietet die Strategie einen Rahmen für die technische Analyse, der jedoch in Kombination mit den Prinzipien der Kapitalverwaltung und dem grundlegenden Verständnis des Marktes verwendet werden sollte, um optimale Wirkung zu erzielen.
Letztendlich hängt der Erfolg des Handels nicht nur von der Strategie selbst ab, sondern auch vom Verständnis und der korrekten Ausführung der Strategie durch den Händler. Die kontinuierliche Rückmeldung, Optimierung und Anpassung der Strategie ist der Schlüssel zu langfristigen stabilen Handelsergebnissen.
/*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)