Tài nguyên đang được tải lên... tải...

Chiến lược giao dịch xu hướng thích nghi đa chỉ số

Tác giả:ChaoZhang, Ngày: 2023-12-28 17:59:58
Tags:

Tổng quan

Chiến lược giao dịch xu hướng thích nghi đa chỉ số là một chiến lược giao dịch định lượng tích hợp các tín hiệu từ nhiều chỉ số kỹ thuật. Nó có thể tự động xác định hướng xu hướng của thị trường và tạo ra các tín hiệu giao dịch với các cấu hình khác nhau dựa trên các điều kiện thị trường khác nhau.

Chiến lược này kết hợp các chỉ số bao gồm trung bình động, Stoch RSI, WaveTrend v.v. để tạo ra các tín hiệu giao dịch. Ngoài ra, nó chuyển đổi cấu hình tham số của mỗi chỉ số một cách năng động dựa trên đánh giá xu hướng thị trường tổng thể. Điều này cho phép giao dịch thích nghi trong môi trường thị trường khác nhau.

Nhìn chung, chiến lược có khả năng theo dõi xu hướng và thích nghi mạnh mẽ. Nó có thể giảm tần suất giao dịch và nắm bắt lợi nhuận xu hướng một chiều lớn.

Chiến lược logic

Đánh giá xu hướng

Chiến lược này sử dụng một đường trung bình di chuyển biểu thức 300 giai đoạn để xác định hướng xu hướng tổng thể.

Khi giá vượt qua đường EMA, nó sẽ kích hoạt tín hiệu bán ngược để khóa các vị trí mua trước đó. Điều này có thể kiểm soát rủi ro hiệu quả.

Các tín hiệu thương mại

Trong các xu hướng thị trường khác nhau, chiến lược áp dụng các cấu hình tham số khác nhau để tạo ra các tín hiệu giao dịch.

Các tín hiệu giao dịch dưới xu hướng tăng bao gồm:

Trung bình động chéo và vị trí
Các tín hiệu RSI của Stoch
WaveTrend tín hiệu

Các tín hiệu giao dịch dưới xu hướng giảm bao gồm:

Trung bình chuyển động chéo dưới và vị trí
Các tín hiệu RSI của Stoch
WaveTrend tín hiệu

Người dùng có thể bật hoặc vô hiệu hóa các tín hiệu khác nhau từ các chỉ số khác nhau để thực hiện logic giao dịch tùy chỉnh.

Mỗi tín hiệu đóng góp điểm số tín hiệu +1. Khi tổng số điểm đạt ngưỡng được thiết lập bởi người dùng, các tín hiệu giao dịch thực sẽ được kích hoạt.

Lấy lợi nhuận và dừng lỗ

Chiến lược này cung cấp nhiều cách để lấy lợi nhuận và dừng lỗ, bao gồm tỷ lệ phần trăm lấy lợi nhuận, tỷ lệ phần trăm dừng lỗ, phá vỡ giá, v.v. Các tham số này cũng thay đổi năng động dựa trên xu hướng thị trường khác nhau.

Nếu các yêu cầu lợi nhuận không được đáp ứng, chiến lược cũng cung cấp một cách để đóng trực tiếp các vị trí để kiểm soát thời gian nắm giữ và rủi ro.

Phân tích lợi thế

Chiến lược giao dịch xu hướng thích nghi đa chỉ số có những lợi thế sau:

Khả năng xác định xu hướng được cải thiện. Chiến lược sử dụng EMA và các chỉ số khác để xác định xu hướng, tránh bị sai lệch bởi các sự đột phá sai hoặc điều chỉnh ngắn hạn trên thị trường.
Sự linh hoạt lớn. Người dùng có thể bật hoặc vô hiệu hóa các tín hiệu khác nhau từ các chỉ số khác nhau để tùy chỉnh các quy tắc giao dịch của riêng họ.
Khả năng thích nghi mạnh mẽ. Chiến lược có thể tự động xác định các điều kiện thị trường khác nhau và áp dụng các tham số khác nhau để tạo ra các tín hiệu giao dịch mà không cần can thiệp thủ công.
Phương pháp lấy lợi nhuận và dừng lỗ nhiều lần. Chiến lược cung cấp nhiều công cụ lấy lợi nhuận và dừng lỗ để khóa lợi nhuận và kiểm soát rủi ro.
Tỷ lệ giao dịch giảm. Chỉ giao dịch khi xu hướng rõ ràng có thể giảm giao dịch đi lại không cần thiết.

Phân tích rủi ro

Chiến lược giao dịch xu hướng thích nghi đa chỉ số cũng có những rủi ro sau:

Không có điểm chuyển hướng thị trường. Các chiến lược giao dịch xu hướng không thể nắm bắt sự đảo ngược giá trong thời gian và có thể bỏ lỡ cơ hội lợi nhuận ngắn hạn.
Khi giá vượt qua đường EMA để tạo ra tín hiệu nhưng thất bại nhanh chóng, nó sẽ dẫn đến tổn thất.
Rủi ro điều chỉnh tham số: Người dùng cần đủ hiểu biết về ý nghĩa của mỗi tham số để đạt được kết quả backtesting tối ưu.
Rủi ro xác định xu hướng: Chiến lược cũng có thể xác định sai xu hướng trong điều kiện thị trường cực đoan.
Rủi ro thất bại chỉ số: Một số tín hiệu chỉ số cũng có thể hoạt động kém hơn trong các sản phẩm và khung thời gian khác nhau.

Một số rủi ro có thể được giải quyết bằng cách điều chỉnh đúng chiều dài EMA, mở rộng phạm vi dừng lỗ, v.v.

Hướng dẫn tối ưu hóa

Chiến lược cũng có thể được nâng cấp từ các khía cạnh sau:

Thêm mô-đun tối ưu hóa tham số động dựa trên học máy. Vì vậy, các tham số có thể được tự động tối ưu hóa dựa trên những thay đổi thị trường thời gian thực, thay vì các giá trị cố định trước.
Thêm cơ chế bỏ phiếu tập thể mô hình. Kết hợp các đánh giá từ nhiều mô hình và chọn tối ưu như tín hiệu cuối cùng.
Tối ưu hóa cơ chế dừng lỗ. Có thể thử dừng lỗ, di chuyển dừng lỗ để khóa lợi nhuận tốt hơn và kiểm soát rủi ro.
Tùy chỉnh trọng lượng tín hiệu. Cho phép người dùng đặt trọng lượng khác nhau cho các tín hiệu khác nhau thay vì logic 0/1 đơn giản. đạt được sự kết hợp trọng số của tín hiệu chỉ số.

Tóm lại

Chiến lược giao dịch xu hướng thích nghi đa chỉ số tích hợp các phương pháp bao gồm phán đoán xu hướng, hợp nhất của nhiều tín hiệu chỉ số, chuyển đổi tham số động. Là một chiến lược giao dịch định lượng, nó có khả năng thích nghi và tùy biến tuyệt vời. Nó có thể giảm giao dịch không cần thiết trong khi tối đa hóa việc nắm bắt xu hướng đơn phương. Chiến lược là một đại diện xuất sắc của giao dịch định lượng và xứng đáng với nghiên cứu và ứng dụng chuyên sâu.

/*backtest
start: 2022-12-21 00:00:00
end: 2023-12-27 00:00:00
period: 1d
basePeriod: 1h
exchanges: [{"eid":"Futures_Binance","currency":"BTC_USDT"}]
*/

////////////////////////////////////////////////////////////////////////////////
//START▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼

c="███████╗ █████╗  █████╗   ██╗   ██╗ █████╗ ██╗   ██╗ ██████╗ ██╗  ██╗███╗  ██╗"
o="╚════██║██╔══██╗██╔══██╗  ██║   ██║██╔══██╗██║   ██║██╔════╝ ██║  ██║████╗ ██║"
d="  ███╔═╝███████║██║  ╚═╝  ╚██╗ ██╔╝███████║██║   ██║██║  ██╗ ███████║██╔██╗██║"
e="██╔══╝  ██╔══██║██║  ██╗   ╚████╔╝ ██╔══██║██║   ██║██║  ╚██╗██╔══██║██║╚████║"
r="███████╗██║  ██║╚█████╔╝    ╚██╔╝  ██║  ██║╚██████╔╝╚██████╔╝██║  ██║██║ ╚███║"
s="╚══════╝╚═╝  ╚═╝ ╚════╝      ╚═╝   ╚═╝  ╚═╝ ╚═════╝  ╚═════╝ ╚═╝  ╚═╝╚═╝  ╚══╝"

//@version=5
strategy("Instrument-Z", overlay=true, initial_capital=1600, default_qty_type=strategy.percent_of_equity, default_qty_value=90, commission_value=0.075)

//END▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
////////////////////////////////////////////////////////////////////////////////
//BAR COLOR AND EMA AREA▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼

//BAR COLOR
bullCcolor = close > open ? #80cbc4 : na
bearCcolor = close < open ? #ef9a9a : na
bullC = close > open
bearC = close < open
bullE = bullC and bearC[1] and close > open[1] ? color.new(#ffffff, 100) : bullCcolor
bearE = bearC and bullC[1] and close < open[1] ? color.new(#ffffff, 100) : bearCcolor
barcolor(bullE)
barcolor(bearE)

//EMA 1
len1 = 10
ema1 = ta.ema(close, len1)
//EMA 2
len2 = 100
ema2 = ta.ema(close, len2)
//EMA COLORS
emacolor = ema1 > ema2 ? #26a69a : #ef5350
//EMA PLOTS
ema1line = plot(ema1, title="EMA 1", color=color.new(#ffffff, 100), editable=false)
ema2line = plot(ema2, title="EMA 2", color=color.new(#ffffff, 100), editable=false)
fill(ema1line, ema2line, title="EMA Area", color=color.new(emacolor, 90))

//END▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
////////////////////////////////////////////////////////////////////////////////
//INITIAL OPTIONS▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼

src = input.source(defval=close, title="Source", group="SETUP GUIDE AT YouTube.com/c/ZacVaughnYT")
//tfr = input.timeframe("", title="Resolution")
//request.security(syminfo.tickerid, tfr, expression, barmerge.gaps_on)

//POSITIONS
TradeDir = input.string("LONG", title="Trade Direction", options=["LONG", "SHORT"], group="POSITIONS")
TrendTrade = input(false, "Only Trade with Trend", group="POSITIONS")

//UPTREND PROFIT AND LOSS
UTsellProf = input(true, title="Only Sell in Profit", group="UPTREND 🠕 PROFIT & LOSS")
UTminProf = input.float(title="Minimum Profit (%)", defval=3.6, minval=0, maxval=100,  step=.1, group="UPTREND 🠕 PROFIT & LOSS") / 100
UTuseTP = input(true,  title="Use Take Profit", group="UPTREND 🠕 PROFIT & LOSS")
UTTPperc = input.float(title="Take Profit (%)", defval=11.5, minval=0, maxval=1000, step=.1, group="UPTREND 🠕 PROFIT & LOSS") / 100
UTuseSL = input(true,  title="Use Stop Loss", group="UPTREND 🠕 PROFIT & LOSS")
UTSLperc = input.float(title="Stop Loss (%)", defval=-7.5, minval=-50, maxval=0, step=.1, group="UPTREND 🠕 PROFIT & LOSS") / 100
UTuseTE = input(false, title="Use Trade Expiration", group="UPTREND 🠕 PROFIT & LOSS")
UTTEbars = input.int(title="Expire After (bars)", defval=200, minval=1, maxval=10000, group="UPTREND 🠕 PROFIT & LOSS")

//DOWNTREND PROFIT AND LOSS
DTsellProf = input(true, title="Only Sell in Profit", group="DOWNTREND 🠗 PROFIT & LOSS")
DTminProf = input.float(title="Minimum Profit (%)", defval=1, minval=0, maxval=100,  step=.1, group="DOWNTREND 🠗 PROFIT & LOSS") / 100
DTuseTP = input(false,  title="Use Take Profit", group="DOWNTREND 🠗 PROFIT & LOSS")
DTTPperc = input.float(title="Take Profit (%)", defval=15, minval=0, maxval=1000, step=.1, group="DOWNTREND 🠗 PROFIT & LOSS") / 100
DTuseSL = input(true,  title="Use Stop Loss", group="DOWNTREND 🠗 PROFIT & LOSS")
DTSLperc = input.float(title="Stop Loss (%)", defval=-7.4, minval=-50, maxval=0, step=.1, group="DOWNTREND 🠗 PROFIT & LOSS") / 100
DTuseTE = input(false, title="Use Trade Expiration", group="DOWNTREND 🠗 PROFIT & LOSS")
DTTEbars = input.int(title="Expire After (bars)", defval=200, minval=1, maxval=10000, group="DOWNTREND 🠗 PROFIT & LOSS")

//END▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
////////////////////////////////////////////////////////////////////////////////
//TREND MOVING AVERAGE▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼

//TREND MA
ma(source, length, type) =>
     type == "SMA"  ? ta.sma(source, length) :
     type == "EMA"  ? ta.ema(source, length) :
     type == "RMA"  ? ta.rma(source, length) :
     type == "HMA"  ? ta.wma(2*ta.wma(source, length/2)-ta.wma(source, length), math.floor(math.sqrt(length))) :
     type == "WMA"  ? ta.wma(source, length) :
     type == "VWMA" ? ta.vwma(source, length) :
     na
mat_type   = input.string("EMA", "Trend MA", inline="Trend MA", options=["SMA", "EMA", "RMA", "HMA", "WMA", "VWMA"], group="POSITIONS")
mat_length = input.int(300, "", inline="Trend MA", minval=1, step=5, group="POSITIONS")
mat = ma(src, mat_length, mat_type)
matcolor = mat > mat[1] ? #26a69a : #ef5350
matline = plot(mat, color=color.new(matcolor, 50), linewidth=2, title="Trend MA")
matRevS = input(false, title="Sell After Trend Reverses", group="POSITIONS")
matRevSbars = input.int(10, "Sell After (bars)", group="POSITIONS")

//END▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
////////////////////////////////////////////////////////////////////////////////
//CROSSING MOVING AVERAGES▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼

//UPTREND OPTIONS
//Cross
UTUsemaX = input(false, "Moving Average Cross", group="UPTREND 🠕 MOVING AVERAGE SIGNALS")
UTReqmaXscore = UTUsemaX ? 1 : 0
//Position
UTUsemaP = input(true, "Moving Average Position", group="UPTREND 🠕 MOVING AVERAGE SIGNALS")
UTReqmaPscore = UTUsemaP ? 1 : 0
//Histogram
UTUsemaH = input(false, "MA Histogram Reverse", group="UPTREND 🠕 MOVING AVERAGE SIGNALS")
UTReqmaHscore = UTUsemaH ? 1 : 0

//DOWNTREND OPTIONS
//Cross
DTUsemaX = input(false, "Moving Average Cross", group="DOWNTREND 🠗 MOVING AVERAGE SIGNALS")
DTReqmaXscore = DTUsemaX ? 1 : 0
//Position
DTUsemaP = input(true, "Moving Average Position", group="DOWNTREND 🠗 MOVING AVERAGE SIGNALS")
DTReqmaPscore = DTUsemaP ? 1 : 0
//Histogram
DTUsemaH = input(false, "MA Histogram Reverse", group="DOWNTREND 🠗 MOVING AVERAGE SIGNALS")
DTReqmaHscore = DTUsemaH ? 1 : 0

//UPTREND INPUTS
//MA1
UTma1_type   = input.string("RMA", "MA 1", inline="UT MA 1", options=["SMA", "EMA", "RMA", "HMA", "WMA", "VWMA"], group="UPTREND 🠕 MOVING AVERAGE SIGNALS")
UTma1_length = input.int(7, "", inline="UT MA 1", minval=1, group="UPTREND 🠕 MOVING AVERAGE SIGNALS")
UTma1 = ma(src, UTma1_length, UTma1_type)
UTma1Color = mat > mat[1] ? color.new(color.blue, 35) : color.new(color.blue, 100)
UTma1line = plot(UTma1, color=UTma1Color, title="UT MA 1")
//MA2
UTma2_type   = input.string("HMA", "MA 2", inline="UT MA 2", options=["SMA", "EMA", "RMA", "HMA", "WMA", "VWMA"], group="UPTREND 🠕 MOVING AVERAGE SIGNALS")
UTma2_length = input.int(54, "", inline="UT MA 2", minval=1, group="UPTREND 🠕 MOVING AVERAGE SIGNALS")
UTma2 = ma(src, UTma2_length, UTma2_type)
UTma2Color = mat > mat[1] ? color.new(color.purple, 35) : color.new(color.purple, 100)
UTma2line = plot(UTma2, color=UTma2Color, title="UT MA 2")
UTmahist = UTma1 - UTma2

//DOWNTREND INPUTS
//MA1
DTma1_type   = input.string("RMA", "MA 1", inline="DT MA 1", options=["SMA", "EMA", "RMA", "HMA", "WMA", "VWMA"], group="DOWNTREND 🠗 MOVING AVERAGE SIGNALS")
DTma1_length = input.int(7, "", inline="DT MA 1", minval=1, group="DOWNTREND 🠗 MOVING AVERAGE SIGNALS")
DTma1 = ma(src, DTma1_length, DTma1_type)
DTma1Color = mat > mat[1] ? color.new(color.blue, 100) : color.new(color.blue, 35)
DTma1line = plot(DTma1, color=DTma1Color, title="DT MA 1")
//MA2
DTma2_type   = input.string("HMA", "MA 2", inline="DT MA 2", options=["SMA", "EMA", "RMA", "HMA", "WMA", "VWMA"], group="DOWNTREND 🠗 MOVING AVERAGE SIGNALS")
DTma2_length = input.int(54, "", inline="DT MA 2", minval=1, group="DOWNTREND 🠗 MOVING AVERAGE SIGNALS")
DTma2 = ma(src, DTma2_length, DTma2_type)
DTma2Color = mat > mat[1] ? color.new(color.purple, 100) : color.new(color.purple, 35)
DTma2line = plot(DTma2, color=DTma2Color, title="DT MA 2")
DTmahist = DTma1 - DTma2

//UPTREND SIGNALS
UTmaXup = UTUsemaX and UTma1 > UTma2 and UTma1[1] < UTma2[1] ? 1 : 0
UTmaXdn = UTUsemaX and UTma1 < UTma2 and UTma1[1] > UTma2[1] ? 1 : 0
UTmaPup = UTUsemaP and UTma1 > UTma2 ? 1 : 0
UTmaPdn = UTUsemaP and UTma1 < UTma2 ? 1 : 0
UTmaHup = UTUsemaH and UTmahist > UTmahist[1] and UTmahist[1] < UTmahist[2] ? 1 : 0
UTmaHdn = UTUsemaH and UTmahist < UTmahist[1] and UTmahist[1] > UTmahist[2] ? 1 : 0

//DOWNTREND SIGNALS
DTmaXup = DTUsemaX and DTma1 > DTma2 and DTma1[1] < DTma2[1] ? 1 : 0
DTmaXdn = DTUsemaX and DTma1 < DTma2 and DTma1[1] > DTma2[1] ? 1 : 0
DTmaPup = DTUsemaP and DTma1 > DTma2 ? 1 : 0
DTmaPdn = DTUsemaP and DTma1 < DTma2 ? 1 : 0
DTmaHup = DTUsemaH and DTmahist > DTmahist[1] and DTmahist[1] < DTmahist[2] ? 1 : 0
DTmaHdn = DTUsemaH and DTmahist < DTmahist[1] and DTmahist[1] > DTmahist[2] ? 1 : 0

//END▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
////////////////////////////////////////////////////////////////////////////////
//STOCHASTIC RSI▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼

//UPTREND OPTIONS
//Cross
UTUseSrsiX = input(false, "Stoch RSI Cross Signal", group="UPTREND 🠕 STOCH RSI SIGNALS")
UTReqSrsiXscore = UTUseSrsiX ? 1 : 0
//Level
UTUseSrsiL = input(true, "Use Buy/Sell Levels", group="UPTREND 🠕 STOCH RSI SIGNALS")
UTsablevelb = input.int(61, "Buy Below Level", group="UPTREND 🠕 STOCH RSI SIGNALS")
UTsablevels = input.int(13, "Sell Above Level", group="UPTREND 🠕 STOCH RSI SIGNALS")
UTReqSrsiLscore = UTUseSrsiL ? 1 : 0
//Position
UTUseSrsiP = input(false, "Use Stoch RSI Position", group="UPTREND 🠕 STOCH RSI SIGNALS")
UTReqSrsiPscore = UTUseSrsiP ? 1 : 0
//Divergence
UTUseSrsiD = input(false, "Stoch RSI Divergence", group="UPTREND 🠕 STOCH RSI SIGNALS")
UTReqSrsiDscore = UTUseSrsiD ? 1 : 0

//DOWNTREND OPTIONS
//Cross
DTUseSrsiX = input(false, "Stoch RSI Cross Signal", group="DOWNTREND 🠗 STOCH RSI SIGNALS")
DTReqSrsiXscore = DTUseSrsiX ? 1 : 0
//Level
DTUseSrsiL = input(true, "Use Buy/Sell Levels", group="DOWNTREND 🠗 STOCH RSI SIGNALS")
DTsablevelb = input.int(61, "Buy Below Level", group="DOWNTREND 🠗 STOCH RSI SIGNALS")
DTsablevels = input.int(13, "Sell Above Level", group="DOWNTREND 🠗 STOCH RSI SIGNALS")
DTReqSrsiLscore = DTUseSrsiL ? 1 : 0
//Position
DTUseSrsiP = input(false, "Use Stoch RSI Position", group="DOWNTREND 🠗 STOCH RSI SIGNALS")
DTReqSrsiPscore = DTUseSrsiP ? 1 : 0
//Divergence
DTUseSrsiD = input(false, "Stoch RSI Divergence", group="DOWNTREND 🠗 STOCH RSI SIGNALS")
DTReqSrsiDscore = DTUseSrsiD ? 1 : 0

//UPTREND INPUTS
//STOCH RSI
UTlengthRSI = input.int(12, "RSI Length", minval=1, group="UPTREND 🠕 STOCH RSI SIGNALS")
UTlengthStoch = input.int(20, "Stochastic Length", minval=1, group="UPTREND 🠕 STOCH RSI SIGNALS")
UTrsi1 = ta.rsi(src, UTlengthRSI)
UTrk = ta.sma(ta.stoch(UTrsi1, UTrsi1, UTrsi1, UTlengthStoch), 3)
UTrd = ta.sma(UTrk, 3)

//DOWNTREND INPUTS
//STOCH RSI
DTlengthRSI = input.int(12, "RSI Length", minval=1, group="DOWNTREND 🠗 STOCH RSI SIGNALS")
DTlengthStoch = input.int(20, "Stochastic Length", minval=1, group="DOWNTREND 🠗 STOCH RSI SIGNALS")
DTrsi1 = ta.rsi(src, DTlengthRSI)
DTrk = ta.sma(ta.stoch(DTrsi1, DTrsi1, DTrsi1, DTlengthStoch), 3)
DTrd = ta.sma(DTrk, 3)

//UPTREND DIVERGENCE
inRange(cond) =>
	bars = ta.barssince(cond == true)
	5 <= bars and bars <= 60
osc2 = UTrk
//Pivots
plFound2 = na(ta.pivotlow(osc2, 5, 2)) ? false : true
phFound2 = na(ta.pivothigh(osc2, 5, 2)) ? false : true
//Regular Bullish
oscHL2 = osc2[2] > ta.valuewhen(plFound2, osc2[2], 1) and inRange(plFound2[1])
priceLL2 = low[2] < ta.valuewhen(plFound2, low[2], 1)
bullCond2 = priceLL2 and oscHL2 and plFound2
//Hidden Bullish
oscLL2 = osc2[2] < ta.valuewhen(plFound2, osc2[2], 1) and inRange(plFound2[1])
priceHL2 = low[2] > ta.valuewhen(plFound2, low[2], 1)
hiddenBullCond2 = priceHL2 and oscLL2 and plFound2
//Regular Bearish
oscLH2 = osc2[2] < ta.valuewhen(phFound2, osc2[2], 1) and inRange(phFound2[1])
priceHH2 = high[2] > ta.valuewhen(phFound2, high[2], 1)
bearCond2 = priceHH2 and oscLH2 and phFound2
//Hidden Bearish
oscHH2 = osc2[2] > ta.valuewhen(phFound2, osc2[2], 1) and inRange(phFound2[1])
priceLH2 = high[2] < ta.valuewhen(phFound2, high[2], 1)
hiddenBearCond2 = priceLH2 and oscHH2 and phFound2

//DOWNTREND DIVERGENCE
osc3 = DTrk
//Pivots
plFound3 = na(ta.pivotlow(osc3, 5, 2)) ? false : true
phFound3 = na(ta.pivothigh(osc3, 5, 2)) ? false : true
//Regular Bullish
oscHL3 = osc3[2] > ta.valuewhen(plFound3, osc3[2], 1) and inRange(plFound3[1])
priceLL3 = low[2] < ta.valuewhen(plFound3, low[2], 1)
bullCond3 = priceLL3 and oscHL3 and plFound3
//Hidden Bullish
oscLL3 = osc3[2] < ta.valuewhen(plFound3, osc3[2], 1) and inRange(plFound3[1])
priceHL3 = low[2] > ta.valuewhen(plFound3, low[2], 1)
hiddenBullCond3 = priceHL3 and oscLL3 and plFound3
//Regular Bearish
oscLH3 = osc3[2] < ta.valuewhen(phFound3, osc3[2], 1) and inRange(phFound3[1])
priceHH3 = high[2] > ta.valuewhen(phFound3, high[2], 1)
bearCond3 = priceHH3 and oscLH3 and phFound3
//Hidden Bearish
oscHH3 = osc3[2] > ta.valuewhen(phFound3, osc3[2], 1) and inRange(phFound3[1])
priceLH3 = high[2] < ta.valuewhen(phFound3, high[2], 1)
hiddenBearCond3 = priceLH3 and oscHH3 and phFound3

//UPTREND SIGNALS
UTSrsiXup = UTUseSrsiX and UTrk > UTrd and UTrk[1] < UTrd[1] ? 1 : 0
UTSrsiXdn = UTUseSrsiX and UTrk < UTrd and UTrk[1] > UTrd[1] ? 1 : 0
UTSrsiLup = UTUseSrsiL and UTrk < UTsablevelb ? 1 : 0
UTSrsiLdn = UTUseSrsiL and UTrk > UTsablevels ? 1 : 0
UTSrsiPup = UTUseSrsiP and UTrk > UTrd ? 1 : 0
UTSrsiPdn = UTUseSrsiP and UTrk < UTrd ? 1 : 0
UTSrsiDup = UTUseSrsiD and bullCond2 ? 1 : 0
UTSrsiDdn = UTUseSrsiD and bearCond2 ? 1 : 0

//DOWNTREND SIGNALS
DTSrsiXup = DTUseSrsiX and DTrk > DTrd and DTrk[1] < DTrd[1] ? 1 : 0
DTSrsiXdn = DTUseSrsiX and DTrk < DTrd and DTrk[1] > DTrd[1] ? 1 : 0
DTSrsiLup = DTUseSrsiL and DTrk < DTsablevelb ? 1 : 0
DTSrsiLdn = DTUseSrsiL and DTrk > DTsablevels ? 1 : 0
DTSrsiPup = DTUseSrsiP and DTrk > DTrd ? 1 : 0
DTSrsiPdn = DTUseSrsiP and DTrk < DTrd ? 1 : 0
DTSrsiDup = DTUseSrsiD and bullCond3 ? 1 : 0
DTSrsiDdn = DTUseSrsiD and bearCond3 ? 1 : 0

//END▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
////////////////////////////////////////////////////////////////////////////////
//WAVETREND▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼

//UPTREND OPTIONS
//Cross
UTUsewtX = input(false, "WaveTrend Cross", group="UPTREND 🠕 WAVETREND SIGNALS")
UTReqwtXscore = UTUsewtX ? 1 : 0
//Level
UTUsewtL = input(true, "WaveTrend Level", group="UPTREND 🠕 WAVETREND SIGNALS")
UTwablevelb = input.int(82, "Buy Below Level", group="UPTREND 🠕 WAVETREND SIGNALS")
UTwablevels = input.int(15, "Sell Above Level", group="UPTREND 🠕 WAVETREND SIGNALS")
UTReqwtLscore = UTUsewtL ? 1 : 0
//Position
UTUsewtP = input(false, "WaveTrend Position", group="UPTREND 🠕 WAVETREND SIGNALS")
UTReqwtPscore = UTUsewtP ? 1 : 0
//Divergence
UTUsewtD = input(false, "WaveTrend Divergence", group="UPTREND 🠕 WAVETREND SIGNALS")
UTReqwtDscore = UTUsewtD ? 1 : 0

//DOWNTREND OPTIONS
//Cross
DTUsewtX = input(false, "WaveTrend Cross", group="DOWNTREND 🠗 WAVETREND SIGNALS")
DTReqwtXscore = DTUsewtX ? 1 : 0
//Level
DTUsewtL = input(false, "WaveTrend Level", group="DOWNTREND 🠗 WAVETREND SIGNALS")
DTwablevelb = input.int(0, "Buy Below Level", group="DOWNTREND 🠗 WAVETREND SIGNALS")
DTwablevels = input.int(0, "Sell Above Level", group="DOWNTREND 🠗 WAVETREND SIGNALS")
DTReqwtLscore = DTUsewtL ? 1 : 0
//Position
DTUsewtP = input(false, "WaveTrend Position", group="DOWNTREND 🠗 WAVETREND SIGNALS")
DTReqwtPscore = DTUsewtP ? 1 : 0
//Divergence
DTUsewtD = input(false, "WaveTrend Divergence", group="DOWNTREND 🠗 WAVETREND SIGNALS")
DTReqwtDscore = DTUsewtD ? 1 : 0

//UPTREND INPUTS
//WT
UTlenC = input.int(9, title="Channel Length", group="UPTREND 🠕 WAVETREND SIGNALS")
UTlenA = input.int(12, title="Average Length", group="UPTREND 🠕 WAVETREND SIGNALS")
UTap = hlc3 
UTesa = ta.ema(UTap, UTlenC)
UTd1 = ta.ema(math.abs(UTap - UTesa), UTlenC)
UTci = (UTap - UTesa) / (0.015 * UTd1)
UTtci = ta.ema(UTci, UTlenA)
UTwt1 = UTtci
UTwt2 = ta.sma(UTwt1, 4)
UTwthist = UTwt2 - UTwt1

//DOWNTREND INPUTS
//WT
DTlenC = input.int(9, title="Channel Length", group="DOWNTREND 🠗 WAVETREND SIGNALS")
DTlenA = input.int(12, title="Average Length", group="DOWNTREND 🠗 WAVETREND SIGNALS")
DTap = hlc3 
DTesa = ta.ema(DTap, DTlenC)
DTd1 = ta.ema(math.abs(DTap - DTesa), DTlenC)
DTci = (DTap - DTesa) / (0.015 * DTd1)
DTtci = ta.ema(DTci, DTlenA)
DTwt1 = DTtci
DTwt2 = ta.sma(DTwt1, 4)
DTwthist = DTwt2 - DTwt1

//UPTREND DIVERGENCE
osc4 = UTwt1
//Pivots
plFound4 = na(ta.pivotlow(osc4, 5, 2)) ? false : true
phFound4 = na(ta.pivothigh(osc4, 5, 2)) ? false : true
//Regular Bullish
oscHL4 = osc4[2] > ta.valuewhen(plFound4, osc4[2], 1) and inRange(plFound4[1])
priceLL4 = low[2] < ta.valuewhen(plFound4, low[2], 1)
bullCond4 = priceLL4 and oscHL4 and plFound4
//Hidden Bullish
oscLL4 = osc4[2] < ta.valuewhen(plFound4, osc4[2], 1) and inRange(plFound4[1])
priceHL4 = low[2] > ta.valuewhen(plFound4, low[2], 1)
hiddenBullCond4 = priceHL4 and oscLL4 and plFound4
//Regular Bearish
oscLH4 = osc4[2] < ta.valuewhen(phFound4, osc4[2], 1) and inRange(phFound4[1])
priceHH4 = high[2] > ta.valuewhen(phFound4, high[2], 1)
bearCond4 = priceHH4 and oscLH4 and phFound4
//Hidden Bearish
oscHH4 = osc4[2] > ta.valuewhen(phFound4, osc4[2], 1) and inRange(phFound4[1])
priceLH4 = high[2] < ta.valuewhen(phFound4, high[2], 1)
hiddenBearCond4 = priceLH4 and oscHH4 and phFound4

//DOWNTREND DIVERGENCE
osc5 = DTwt1
//Pivots
plFound5 = na(ta.pivotlow(osc5, 5, 2)) ? false : true
phFound5 = na(ta.pivothigh(osc5, 5, 2)) ? false : true
//Regular Bullish
oscHL5 = osc5[2] > ta.valuewhen(plFound5, osc5[2], 1) and inRange(plFound5[1])
priceLL5 = low[2] < ta.valuewhen(plFound5, low[2], 1)
bullCond5 = priceLL5 and oscHL5 and plFound5
//Hidden Bullish
oscLL5 = osc5[2] < ta.valuewhen(plFound5, osc5[2], 1) and inRange(plFound5[1])
priceHL5 = low[2] > ta.valuewhen(plFound5, low[2], 1)
hiddenBullCond5 = priceHL5 and oscLL5 and plFound5
//Regular Bearish
oscLH5 = osc5[2] < ta.valuewhen(phFound5, osc5[2], 1) and inRange(phFound5[1])
priceHH5 = high[2] > ta.valuewhen(phFound5, high[2], 1)
bearCond5 = priceHH5 and oscLH5 and phFound5
//Hidden Bearish
oscHH5 = osc5[2] > ta.valuewhen(phFound5, osc5[2], 1) and inRange(phFound5[1])
priceLH5 = high[2] < ta.valuewhen(phFound5, high[2], 1)
hiddenBearCond5 = priceLH5 and oscHH5 and phFound5

//UPTREND SIGNALS
UTwtXup = UTUsewtX and UTwt1 > UTwt2 and UTwt1[1] < UTwt2[1] and UTwt1 < 0 ? 1 : 0
UTwtXdn = UTUsewtX and UTwt1 < UTwt2 and UTwt1[1] > UTwt2[1] and UTwt1 > 0 ? 1 : 0
UTwtLup = UTUsewtL and UTwt1 < UTwablevelb ? 1 : 0
UTwtLdn = UTUsewtL and UTwt1 > UTwablevels ? 1 : 0
UTwtPup = UTUsewtP and UTwt1 > UTwt2 ? 1 : 0
UTwtPdn = UTUsewtP and UTwt1 < UTwt2 ? 1 : 0
UTwtDup = UTUsewtD and bullCond4 ? 1 : 0
UTwtDdn = UTUsewtD and bearCond4 ? 1 : 0

//DOWNTREND SIGNALS
DTwtXup = DTUsewtX and DTwt1 > DTwt2 and DTwt1[1] < DTwt2[1] and DTwt1 < 0 ? 1 : 0
DTwtXdn = DTUsewtX and DTwt1 < DTwt2 and DTwt1[1] > DTwt2[1] and DTwt1 > 0 ? 1 : 0
DTwtLup = DTUsewtL and DTwt1 < DTwablevelb ? 1 : 0
DTwtLdn = DTUsewtL and DTwt1 > DTwablevels ? 1 : 0
DTwtPup = DTUsewtP and DTwt1 > DTwt2 ? 1 : 0
DTwtPdn = DTUsewtP and DTwt1 < DTwt2 ? 1 : 0
DTwtDup = DTUsewtD and bullCond5 ? 1 : 0
DTwtDdn = DTUsewtD and bearCond5 ? 1 : 0

//END▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
////////////////////////////////////////////////////////////////////////////////
//COLLECT SIGNALS▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼

//UT REQUIRED SCORES
UTReqScore = UTReqmaXscore + UTReqmaPscore + UTReqmaHscore + UTReqSrsiXscore + UTReqSrsiLscore + UTReqSrsiPscore + UTReqSrsiDscore + UTReqwtXscore + UTReqwtLscore + UTReqwtPscore + UTReqwtDscore
//DT REQUIRED SCORES
DTReqScore = DTReqmaXscore + DTReqmaPscore + DTReqmaHscore + DTReqSrsiXscore + DTReqSrsiLscore + DTReqSrsiPscore + DTReqSrsiDscore + DTReqwtXscore + DTReqwtLscore + DTReqwtPscore + DTReqwtDscore

//UT SIGNAL SCORES
UTSigB = UTmaXup + UTmaPup + UTmaHup + UTSrsiXup + UTSrsiLup + UTSrsiPup + UTSrsiDup + UTwtXup + UTwtLup + UTwtPup + UTwtDup
UTSigS = UTmaXdn + UTmaPdn + UTmaHdn + UTSrsiXdn + UTSrsiLdn + UTSrsiPdn + UTSrsiDdn + UTwtXdn + UTwtLdn + UTwtPdn + UTwtDdn
//DT SIGNAL SCORES
DTSigB = DTmaXup + DTmaPup + DTmaHup + DTSrsiXup + DTSrsiLup + DTSrsiPup + DTSrsiDup + DTwtXup + DTwtLup + DTwtPup + DTwtDup
DTSigS = DTmaXdn + DTmaPdn + DTmaHdn + DTSrsiXdn + DTSrsiLdn + DTSrsiPdn + DTSrsiDdn + DTwtXdn + DTwtLdn + DTwtPdn + DTwtDdn

//UT BUY AND SELL
UTNormB = UTSigB == UTReqScore ? 1 : na
UTNormS = UTSigS == UTReqScore ? 1 : na
//DT BUY AND SELL
DTNormB = DTSigB == DTReqScore ? 1 : na
DTNormS = DTSigS == DTReqScore ? 1 : na

//CHECK TREND DIRECTION
UpTrend = mat > mat[1]
BCond = UpTrend ? UTNormB : DTNormB
SCond = UpTrend ? UTNormS : DTNormS

//FINALIZE
LongEntryFinal  = TrendTrade ? BCond and mat > mat[1] : BCond
LongExitFinal   = TrendTrade ? SCond and mat > mat[1] : SCond
ShortEntryFinal = TrendTrade ? SCond and mat < mat[1] : SCond
ShortExitFinal  = TrendTrade ? BCond and mat < mat[1] : BCond

//END▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
////////////////////////////////////////////////////////////////////////////////
//STOP LOSS & TAKE PROFIT▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼

//UT MINIMUM PROFIT
UTmpconvertL = strategy.position_avg_price * (1 + UTminProf)
UTmpconvertS = strategy.position_avg_price * (1 - UTminProf)
UTmpdefineL = TradeDir == "LONG" ? (UTmpconvertL < close and strategy.openprofit > 0) and UTsellProf : na
UTmpdefineS = TradeDir == "SHORT" ? (UTmpconvertS > close and strategy.openprofit > 0) and UTsellProf : na
UTSPL = LongExitFinal and UTmpdefineL
UTSPS = ShortExitFinal and UTmpdefineS
//DT MINIMUM PROFIT
DTmpconvertL = strategy.position_avg_price * (1 + DTminProf)
DTmpconvertS = strategy.position_avg_price * (1 - DTminProf)
DTmpdefineL = TradeDir == "LONG" ? (DTmpconvertL < close and strategy.openprofit > 0) and DTsellProf : na
DTmpdefineS = TradeDir == "SHORT" ? (DTmpconvertS > close and strategy.openprofit > 0) and DTsellProf : na
DTSPL = LongExitFinal and DTmpdefineL
DTSPS = ShortExitFinal and DTmpdefineS
//COLLECT
sellProf = UpTrend ? UTsellProf : DTsellProf
SPL = UpTrend ? UTSPL : DTSPL
SPS = UpTrend ? UTSPS : DTSPS

//UT TAKE PROFIT
UTtpconvertL = strategy.position_avg_price * (1 + UTTPperc)
UTtpconvertS = strategy.position_avg_price * (1 - UTTPperc)
UTTPL = TradeDir == "LONG" ? (UTtpconvertL < close) and UTuseTP : na
UTTPS = TradeDir == "SHORT" ? (UTtpconvertS > close) and UTuseTP : na
//DT TAKE PROFIT
DTtpconvertL = strategy.position_avg_price * (1 + DTTPperc)
DTtpconvertS = strategy.position_avg_price * (1 - DTTPperc)
DTTPL = TradeDir == "LONG" ? (DTtpconvertL < close) and DTuseTP : na
DTTPS = TradeDir == "SHORT" ? (DTtpconvertS > close) and DTuseTP : na
//COLLECT
TPL = UpTrend ? UTTPL : DTTPL
TPS = UpTrend ? UTTPS : DTTPS

//UT STOP LOSS
UTslconvertL = strategy.position_avg_price * (1 + UTSLperc)
UTslconvertS = strategy.position_avg_price * (1 - UTSLperc)
UTSLL = TradeDir == "LONG" ? (UTslconvertL > close) and UTuseSL : na
UTSLS = TradeDir == "SHORT" ? (UTslconvertS < close) and UTuseSL : na
//DT STOP LOSS
DTslconvertL = strategy.position_avg_price * (1 + DTSLperc)
DTslconvertS = strategy.position_avg_price * (1 - DTSLperc)
DTSLL = TradeDir == "LONG" ? (DTslconvertL > close) and DTuseSL : na
DTSLS = TradeDir == "SHORT" ? (DTslconvertS < close) and DTuseSL : na
//COLLECT
SLL = UpTrend ? UTSLL : DTSLL
SLS = UpTrend ? UTSLS : DTSLS

//UT TRADE EXPIRE
entrypos = strategy.opentrades == 1 and strategy.opentrades[1] < 1
UTexpirebars = UTuseTE ? UTTEbars : 1000000
UTTE =  ta.barssince(entrypos) >= UTexpirebars
//DT TRADE EXPIRE
DTexpirebars = DTuseTE ? DTTEbars : 1000000
DTTE =  ta.barssince(entrypos) >= DTexpirebars
//COLLECT
TE = UpTrend ? UTTE : DTTE

//END▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
////////////////////////////////////////////////////////////////////////////////
//PLOTSHAPES▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼

//LONG
plotshape((TradeDir == "LONG") and LongEntryFinal, location=location.belowbar, style=shape.arrowup,   color=color.new(#26a69a, 100), text="⌃", textcolor=#26a69a, size=size.tiny, title="Long BUY Label")
plotshape((TradeDir == "LONG") and LongExitFinal,  location=location.abovebar, style=shape.arrowdown, color=color.new(#ef5350, 100), text="⌄", textcolor=#ef5350, size=size.tiny, title="Long SELL Label")
//SHORT
plotshape((TradeDir == "SHORT") and ShortEntryFinal, location=location.abovebar, style=shape.arrowdown, color=color.new(#ef5350, 100), text="⌄", textcolor=#ef5350, size=size.tiny, title="Short SELL Label")
plotshape((TradeDir == "SHORT") and ShortExitFinal,  location=location.belowbar, style=shape.arrowup,   color=color.new(#26a69a, 100), text="⌃", textcolor=#26a69a, size=size.tiny, title="Short BUY Label")

//END▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
////////////////////////////////////////////////////////////////////////////////
//STRATEGY TRADES▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼

//LONG
if (TradeDir == "LONG") and LongEntryFinal
	strategy.entry("inLong", strategy.long, comment="LEn")
if (TradeDir == "LONG") and sellProf ? SPL : LongExitFinal
	strategy.close("inLong", comment="LEx")

//SHORT
if (TradeDir == "SHORT") and ShortEntryFinal
	strategy.entry("inShort", strategy.short, comment="SEn")
if (TradeDir == "SHORT") and sellProf ? SPS : ShortExitFinal
	strategy.close("inShort", comment="SEx")

//TAKE
if TPL
    strategy.close("inLong", comment="TP")
if TPS
    strategy.close("inShort", comment="TP")
//STOP
if SLL
    strategy.close("inLong", comment="SL")
if SLS
    strategy.close("inShort", comment="SL")
//EXPIRE
if TE
    strategy.close_all(comment="TE")
	
//END▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
////////////////////////////////////////////////////////////////////////////////
//ALERTS▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼▼

useentryalert  = input(defval=true, title="Use ENTRY Alert", group="Custom Alert Messages")
entrystring    = input.string(title="Entry Alert Message", defval="ENTRY", confirm=false, group="Custom Alert Messages")
useexitalert   = input(defval=true, title="Use EXIT Alert", group="Custom Alert Messages")
exitstring     = input.string(title="Exit Alert Message", defval="EXIT", confirm=false, group="Custom Alert Messages")
usetakealert   = input(defval=true, title="Use TAKE Alert", group="Custom Alert Messages")
takestring     = input.string(title="Take Profit Alert Message", defval="TAKE", confirm=false, group="Custom Alert Messages")
usestopalert   = input(defval=true, title="Use STOP Alert", group="Custom Alert Messages")
stopstring     = input.string(title="Stop Loss Alert Message", defval="STOP", confirm=false, group="Custom Alert Messages")
useexpirealert = input(defval=true, title="Use EXPIRE Alert", group="Custom Alert Messages")
expirestring   = input.string(title="Expire Trade Alert Message", defval="EXPIRE", confirm=false, group="Custom Alert Messages")

//LONG
if ((TradeDir == "LONG") and LongEntryFinal) and useentryalert
	alert("{\"message_type\": \"bot\",  \"bot_id\": 7040545,  \"email_token\": \"9b842a1b-9cb4-48ac-9ed4-524c98557e5f\",  \"delay_seconds\": 0}", alert.freq_once_per_bar)
if (TradeDir == "LONG") and (UTsellProf ? SPL : LongExitFinal) and useexitalert
	alert("{\"action\": \"close_at_market_price\",  \"message_type\": \"bot\",  \"bot_id\": 7040545,  \"email_token\": \"9b842a1b-9cb4-48ac-9ed4-524c98557e5f\",  \"delay_seconds\": 0}", alert.freq_once_per_bar)
//SHORT
if ((TradeDir == "SHORT") and ShortEntryFinal) and useentryalert
	alert("{\"action\": \"close_at_market_price\",  \"message_type\": \"bot\",  \"bot_id\": 7040545,  \"email_token\": \"9b842a1b-9cb4-48ac-9ed4-524c98557e5f\",  \"delay_seconds\": 0}", alert.freq_once_per_bar)
if (TradeDir == "SHORT") and (UTsellProf ? SPL : ShortExitFinal) and useexitalert
	alert("{\"action\": \"close_at_market_price\",  \"message_type\": \"bot\",  \"bot_id\": 7040545,  \"email_token\": \"9b842a1b-9cb4-48ac-9ed4-524c98557e5f\",  \"delay_seconds\": 0}", alert.freq_once_per_bar)
//OTHER
if TPL or TPS and usetakealert
    alert("{\"action\": \"close_at_market_price\",  \"message_type\": \"bot\",  \"bot_id\": 7040545,  \"email_token\": \"9b842a1b-9cb4-48ac-9ed4-524c98557e5f\",  \"delay_seconds\": 0}", alert.freq_once_per_bar)
if SLL or SLS and usestopalert
    alert("{\"action\": \"close_at_market_price\",  \"message_type\": \"bot\",  \"bot_id\": 7040545,  \"email_token\": \"9b842a1b-9cb4-48ac-9ed4-524c98557e5f\",  \"delay_seconds\": 0}", alert.freq_once_per_bar)
if TE and useexpirealert
    alert("{\"action\": \"close_at_market_price\",  \"message_type\": \"bot\",  \"bot_id\": 7040545,  \"email_token\": \"9b842a1b-9cb4-48ac-9ed4-524c98557e5f\",  \"delay_seconds\": 0}", alert.freq_once_per_bar)

//END▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲▲
////////////////////////////////////////////////////////////////////////////////

Thêm nữa

2019 FMZ - Tất cả các quyền được bảo lưu