In questo articolo descriviamo come rilevare un take profit con Tradingview, che può essere un pò complicato. La difficoltà nasce dalla mancanza di una funzione di Tradingview per le notifiche degli ordini (nel momento in cui scriviamo!). Senza le notifiche degli ordini, è difficile implementare tecniche avanzate per la gestione della posizione, come spostare lo stop loss per raggiungere il pareggio. In questo articolo, vediamo una soluzione alternativa che può essere adottata per rilevare quando abbiamo raggiunto un take a profit. Esaminiamo anche alcune limitazioni di questa soluzione in modo da sapere esattamente cosa aspettarsi prima di copiare il codice.
Obiettivo
Il codice riportato in questo articolo implementa una strategia di “spostamento al breakeven”, cioè a pareggio. In altre parole, fisserà due obiettivi di take profit e quindi sposterà il nostro stop loss in pareggio non appena viene raggiunto il primo take profit.
Rilevare un Take Profit con Tradingview
//@version=4
strategy("Take Profit Detection", overlay=true, default_qty_type=strategy.fixed, default_qty_value=2)
tp_perc = input(1, step=0.25, title='Take Profit 1 %')/100
tp2_perc = input(2, step=0.25, title='Take Profit 2 %')/100
sl_perc = input(1, step=0.25, title='Stop Loss %')/100
sma_len = input(200, minval=1, title='SMA Length')
sma1 = sma(close, sma_len)
long_condition = crossover(close, sma1)
short_condition = crossunder(close, sma1)
strategy.entry('Long', strategy.long, when=long_condition)
strategy.entry('Short', strategy.short, when=short_condition)
long_tp_hit = strategy.position_size[1] > 0 and strategy.position_size[0] > 0 and strategy.position_size[1] > strategy.position_size[0]
short_tp_hit = strategy.position_size[1] < 0 and strategy.position_size[0] < 0 and strategy.position_size[1] < strategy.position_size[0]
// Impostazione stop loss e take profit
// ----------------------------------------
float long_sl_level = na
float short_sl_level = na
// float long_tp_level = na
// float short_tp_level = na
// float long_tp2_level = na
// float short_tp2_level = na
long_sl_level := long_condition ? close * (1 - sl_perc) : long_tp_hit ? strategy.position_avg_price : long_sl_level[1]
short_sl_level := short_condition ? close * (1 + sl_perc) : short_tp_hit ? strategy.position_avg_price : short_sl_level[1]
long_tp_level = strategy.position_avg_price * (1 + tp_perc)
long_tp2_level = strategy.position_avg_price * (1 + tp2_perc)
short_tp_level = strategy.position_avg_price * (1 - tp_perc)
short_tp2_level = strategy.position_avg_price * (1 - tp2_perc)
strategy.exit('L-SLTP1', 'Long', stop=long_sl_level, limit=long_tp_level, qty_percent=50)
strategy.exit('L-SLTP2', 'Long', stop=long_sl_level, limit=long_tp2_level, qty_percent=100)
strategy.exit('S-SLTP1', 'Short', stop=short_sl_level, limit=short_tp_level, qty_percent=50)
strategy.exit('S-SLTP2', 'Short', stop=short_sl_level, limit=short_tp2_level, qty_percent=100)
// Take Profit e Stop
plot(strategy.position_size > 0 ? long_sl_level : na, color=color.red, style=plot.style_circles, title="Long Stop")
plot(strategy.position_size < 0 ? short_sl_level : na, color=color.maroon, style=plot.style_circles, title="Short Stop")
plot(strategy.position_size > 0 ? long_tp_level : na, color=color.lime, style=plot.style_circles, title="Long TP")
plot(strategy.position_size > 0 ? long_tp2_level : na, color=color.lime, style=plot.style_circles, title="Long TP2")
plot(strategy.position_size < 0 ? short_tp_level : na, color=color.green, style=plot.style_circles, title="Short TP")
plot(strategy.position_size < 0 ? short_tp2_level : na, color=color.green, style=plot.style_circles, title="Short TP")
alertcondition(long_condition, title='Go Long')
Commento
Prima di descrivere la soluzione alternativa per rilevare un take profit con Tradingview, ci sono un paio di punti da sottolineare. La prima cosa da notare è la dimensione di default della posizione pari a 2 per qualsiasi operazione. Se non specifichiamo il parametro default_qty_value la dimensione sarebbe pari a 1 e usciremo dalla posizione non appena viene raggiunto il primo take profit. Questo può essere evitato impostando default_qty_value pari a 2. Naturalmente, possiamo comunque modificare la dimensione dell’ordine nella scheda delle proprietà se desiderio aumentare le dimensioni.
Successivamente, abbiamo bisogno di una sorta di segnale per entrare in una posizione e dimostrare questa tecnica. A tale scopo abbiamo usato una strategia semplice in modo da non distrarci dall’obiettivo principale. Prevediamo semplicemente di entrare long o short ogni volta che il prezzo incroci rispettivamente al rialzo o ribasso una media mobile a 200 periodi.
Una volta entrati in una posizione, possiamo implementare la soluzione alternativa. Dobbiamo semplicemente monitorare le dimensioni della nostra posizione. Ad esempio, se siamo long e la dimensione della nostra posizione diminuisce ma siamo ancora long dopo che la dimensione della nostra posizione è diminuita, allora possiamo presumere che uno dei take profit sia stato raggiunto. Allo stesso modo, se siamo short e la dimensione della nostra posizione aumenta pur rimanendo short, allora possiamo nuovamente presumere che il nostro take profit short sia stato raggiunto.
Una volta raggiunto il primo take profit, spostiamo il nostro stop loss allo stesso livello della variabile strategy.position_avg_price tramite un operatore condizionale ternario .
Take Profit del 50%
Abbiamo descritto come rilevare un take profit. Tuttavia, questa è solo una parte della soluzione. Dobbiamo anche assicurarci di impostare correttamente i nostri ordini di uscita, altrimenti possiamo finire per uscire completamente dalla posizione quando viene raggiunto il primo take profit.
Il take profit del 50% della dimensione della posizione può essere effettuata usando l’argomento qty_percent all’interno della funzione strategy.exit(). Dobbiamo però fare attenzione alla logica da applicare perchè lo script è eseguito ad ogni nuova barra. Possiamo quindi aggiornare l’ordine su ogni barra ma se stiamo aggiornando gli ordini per il take profit del 50%, prima che il tuo take profit venga raggiunto, l’aggiornamento è il 50% dell’intera posizione. Dopo che il primo take profit è stato raggiunto, la dimensione rimane è effettivamente il 50% e non la dimensione originale, quindi avremo dimensioni insufficienti per il secondo take profit.
Nell’immagine precedente possiamo vedere che la posizione è diminuita di 0,5 invece che 1. Siamo involontariamente rimasti in posizione.
Per risolvere questo caso ci sono un paio di soluzioni. Come prima soluzione Possiamo nascondere le chiamate a strategy.exit() dietro una dichiarazione if, ad esempio dietro long_condition. In questo modo l’ordine viene inviato solamente una volta e non viene aggiornato ad ogni barra. Dobbiamo però assicurarci di aggiornare l’ordine se long_condition è true mentre siamo già in una posizione long! Possiamo farlo controllando se strategy.position_size <=0 prima di inviare gli ordini.
L’alternativa è impostare la seconda parte dell’ordine al 100% e permette di aggiornare l’ordine ad ogni barra. Questo non sembra intuitivo ma, al momento della scrittura, pine-script lo gestisce automaticamente. Se entrambi i take profit sono raggiunti nella stessa barra, non avremo un take off del 150%. Questa seconda soluzione è utile quando prevediamo uno stop complesso che potrebbe essere aggiornato frequentemente.
Limitazioni
Il principale limite di questa soluzione alternativa è la possibilità di entrare e uscire sulla stessa barra se uno dei livelli di take profit è vicino al livello di entrata. Questo può accadere spesso in mercati volatili come le criptovalute, dove si verifica grandi spike di prezzo. Quando entriamo e usciamo nella stessa barra, non possiamo rilevare che la posizione è stata ridotta.
Per carpire questo comportamento dobbiamo ricordarci che lo script viene eseguito ad ogni barra. Ad ogni esecuzione abbiamo un’istantanea dei dati in quel momento dove eseguire calcoli e prendere una decisione di trading. In altre parole immaginiamo che nella barra precedente al nostro ingresso, la dimensione della nostra posizione non sia nulla quindi sulla barra corrente entriamo ma contemporaneamente usciamo da quota parte della posizione. Se ipotizziamo che abbiamo una posizione long, otteniamo che la dimensione della nostra posizione passa da zero a maggiore di zero, cioè è aumentata . Non abbiamo diminuito le nostre dimensioni e siamo rimasti sopra lo zero! Pertanto, il TP non può essere rilevato.
Conclusione
Quindi, come possiamo vedere, la soluzione di cui sopra non è perfetta ma fornisce almeno un’opzione per eseguire alcune tecniche di gestione della posizione più avanzate. Se impostiamo i livelli di take profit a un livello ragionevole per il timeframe/volatilità con cui stiamo lavorando, l’impatto dovrebbe essere minimo.
Codice completo
In questo articolo abbiamo descritto come rilevare un take profit con Tradingview. Per il codice completo riportato in questo articolo, si può consultare il seguente repository di github:
https://github.com/datatrading-info/TradingView
