Руководство pine script

Pine Script — скриптовый язык программирования для создания индикаторов и стратегий для платформы TradingView. Разработчики утверждают что большинство встроенных индикаторов написаны также на Pine.

Я также записал несколько видео посвященных как платформе TradingView, так и языку программирования Pine Script. Если формат видео удобнее то все они в плейлисте TradingView + Pine Script.

Скрипты пишутся во встроенном в платформу редакторе, исходные коды также сохраняются на платформе и могут быть как публичными, так и приватными.

Если скрипт публичен, то его исходный код может увидеть любой пользователь TradingView. В одно нажатие этот код может быть скопирован, а затем изменен и оставлен в привате или опубликован после изменения.

Скрипт по сути простыня текста, которая содержит выражения, операторы, определения функций и вызовы функций. Язык простой. Здесь нет ни классов, ни разбиения на файлы/классы и прочее. Полноценная декомпозиция невозможна. Поддержки версий нет. Использовать какие либо IDE нельзя. Доступа из скрипта в консоль в Pine Editor нет, как и инструментов отладки (но сообщения компилятора и ошибки в консоль выводятся).

Результат работы скрипта это либо вывод информации на график (индикатор) или совершение сделок (стратегия).

Важно про обновление Pine Script до версии 5

В конце 2021 года Pine Script обновился до версии 5 и в этом обновлении произошло множество изменений как в синтаксисе, так и в функционале. Старые скрипты продолжат работать если указывать в @version=4. А для обновления под 5 версию нужно внести некоторые изменения в код. Подробно обо всем смотри в этом видео.

Стоимость использования Pine Script

Использование Pine Script бесплатно на всех тарифных планах TradingView. На некоторых тарифах вы можете ограничивать публичность скриптов (вероятно для монетизации ваших скриптов).

Ограничения на скрипты

Так как скрипты выполняются на серверах TradingView, то на скрипты могут накладываться ограничения для того чтобы большие и сложные скрипты излишне не нагружали сервера и не мешали работе скриптов других пользователей.

Ограничения могут коснуться:

• количество баров
• времени исполнения скрипта
• объема потребляемой памяти
• размера скрипта

Например количество баров которые мы можем увидеть ограничено 5000 для пользователей бесплатного тарифа (так написано в документации, но по моим наблюдениям это не всегда так ).

Структура скрипта Pine

Пример скрипта можно увидеть в редакторе Pine если выбрать

Открыть  —

Новый индикатор ( или Новая стратегия )

Например индикатор может выглядеть вот так :

Использование либо

indicator  либо

strategy , либо

library  в скрипте ОБЯЗАТЕЛЬНО.

Отличие indicator или strategy

indicator инициализирует Индикатор, strategy — Стратегию. В PineScript до версии 5 вместо indicator использовалось ключевое слово study.

Индикатор обязан использовать хотя бы одну функцию для вывода информации на график (напр. plot). Стратегия обязана использовать хотя бы одну функцию для совершения сделки (напр. strategy.entry() ).

Стратегия — скрипт предназначенный для совершения сделок. Как в реальном времени так и для тестирования в тестере стратегий TradingView на исторических данных. Стратегия также может что-то выводить на график (например значки о совершенных сделках). Индикатор предназначен для вывода информации на график инструмента и не может совершать сделки, но зато потребляет меньше ресурсов и работает быстрее.

И Стратегия и Индикатор могут создавать Алерты.

Модель работы скриптов Pine

Важно понимать что ваш скрипт выполняется многократно для КАЖДОГО бара начиная с самого старого доступного. При этом индекс “текущего” (самого правого) бара равен 0. По мере работы скрипта он как бы смещается по барам слева направо.

Когда Индикатор достигает текущего, не закрытого ещё бара, то скрипт выполняется каждый тик (при каждом обновлении цены или объема) до тех пор пока бар не закроется. Скрипт выполняется ещё один раз на закрытии бара.

Стратегия по умолчанию считается только по закрытии текущего бара, однако её также можно настроить на пересчет по каждому тику.

Серии

В Pine Script есть важнейший тип данных — Серии. В сериях хранятся например данные баров close, open, high, low и т.д. Серии можно воспринимать как динамический массив. По мере перемещения скрипта по барам серия дополняется значениями.

Серия важнейшее понятие Pine Script. В сериях хранятся все важные данные, серии возвращаются в качестве ответа многих функций технического анализа PineScript. Например ma = ta.sma(close, 14) вернет нам серию значений простой скользящей средней.

Серии могут быть series int, series float, series string. Но серии не могут иметь смешанные типы. В этом серии в PineScript опять напоминают строго типизированные динамические массивы.

С сериями можно совершать некоторые операции. Складывать, вычитать, умножать. В PineScript вы будете постоянно работать с сериями.

Продолжение теории по типам, операндам, операторам возможно будет дополняться в дальнейшем.

Визуализация в PineScript (линии, метки, таблицы)

Визуальный анализ неотъемлемая часть технического анализа. Поэтому в PineScript существует много объектов которые мы можем выводить как в окне графика, так и в окне под графиком. В первую очередь при отрисовки нужно осознать концепцию побарной работы скриптов, о которой я уже упоминал выше. Но более подробно об этом в видео ниже:

Ниже список моих видео посвященных каждому объекту визуализации в PineScript. Я постепенно дополняю этот список снимая новые видео. Все их вы найдете в плейлисте посвященном PineScript на Azzrael Code.

• Линии (line.new) — рисую горизонтальные (но не hline.new) и вертикальные линии
• Метки (label.new) — метки с привязкой к барам
• Заливка фона под баром — как закрасить фон в нужный цвет в зависимости от расчетов
• Заливка произвольной области ограниченной plot или hline

Пересечения цен и линий в PineScript

Часто торговым сигналом является пересечение ценой или индикатором определенного уровня или их взаимное расположение. В PineScript есть простые методы для работы с пересечениями серий — ta.cross, ta.crossunder, ta.crossover. Я подробно рассмотрел их работу в видео:

Alert в Pine Script

Вам может показаться что алерты в TradingView — это банальный инструмент для надоедливых уведомлений, однако это совершенно не так. Благодаря возможности навесить на Alert WebHook, этот инструмент превращается в волшебный мост к вашему брокеру или внешнему инструменту анализа. Мне очень нравятся алерты в TradingView, кроме того что вебхуки доступны только на платных тарифах — это, конечно, печально. Подробнее здесь:

Продолжение следует и сначала все публикуется в видео на канале Azzrael Code! Если интересуешься техническим анализом, Trading View, разными айтишными штуками вокруг инвестиций и трейдинга — ПОДПИСЫВАЙСЯ!

#Трейдинг #Обзоры 

Pine представляет собой скриптовый язык для TradingView. Он позволяет пользователям торговых графиков самостоятельно создавать индикаторы или стратегии. Pine легок и похож на Python, а его задача состоит в том, чтобы позволить писать скрипты с минимальным числом строк кода. Мы узнаем, кому подходит Pine Script, а в каких случаях использовать его не стоит. Познакомимся с альтернативами скриптам от TradingView. Рассмотрим разные примеры использования Pine в новой, 5-й версии: создание SMA, установка стоп-лоссов, заключение сделок и многое другое.

1. 
   Что такое скрипт Pine?
2. 
   Почему я должен использовать скрипт Pine?
3. 
   Почему я не должен использовать скрипт Pine?
4. 
   Какие есть альтернативы использованию скрипта Pine?
5. 
   Как начать работу со скриптом Pine?
6. 1. 
      Первый взгляд на редактор Pine
7. 
   Как узнать цену Apple?
8. 
   Как получить SMA ( 20 ) Apple?
9. 
   Как протестировать кросс-стратегию скользящих средних с помощью Pine Script?
10. 
    Как установить тейк-профит и стоп-лосс?
11. 
    Как запустить сделку с Apple, когда Google движется на 5%?
12. 
    Как модифицировать наши скрипты без кодирования?
13. 
    Как построить сценарий с помощью Pine?
14. 1. 
       График работы рынка Форекс
    2. 
       Нанесение аннотаций
15. 
    Как я могу создать собственный индикатор в скрипте Pine?
16. 
    Последние мысли

Pine Script — это язык программирования, созданный TradingView для тестирования торговых стратегий и создания пользовательских индикаторов.

Скрипт Pine разработан, чтобы быть легким, и в большинстве случаев вы можете достичь своих целей с меньшим количеством строк кода по сравнению с другими языками программирования.

Он не основан на каком-либо конкретном языке, но если вы использовали Python, то быстро разберетесь и заметите сходство.

Код скрипта Pine можно писать в редакторе Pine, который является частью платформы онлайн-графиков TradingView.

Почему я должен использовать скрипт Pine?

Встроенные данные — это одна из важных причин. Тестирование стратегий или создание индикаторов на других языках требует поиска вами собственных данных. Это не только означает, что вам нужно найти место, откуда можно взять данные, но вам также придется отформатировать их определенным образом, и весь этот процесс может занять много времени. TradingView имеет множество готовых данных, доступных всего одной строкой кода.

Простота в освоении — синтаксис скрипта Pine удобочитаем и проще, чем в других языках программирования. Кроме того, вам не нужно тратить много времени на проверку и обработку ошибок, поскольку TradingView позаботится обо всем этом за вас.

Обширная пользовательская база и библиотека. Пользователи TradingView могут публиковать свои индикаторы и стратегии в библиотеке TradingView.

Доступ к открытому исходному коду — отличный способ учиться у других программистов. Кроме того, в некоторых случаях кто-то другой уже написал код для того, что вам нужно.

Почему я не должен использовать скрипт Pine?

Основная причина, по которой вы не захотите использовать скрипт Pine, заключается в том, что вы ограничены вселенной TradingView.

Вот некоторые конкретные ограничения:

Данные. Если TradingView не предлагает нужные вам данные, вам не повезло. Конечно, TradingView имеет очень обширную базу данных. Но если ваша стратегия предполагает торговлю на малоизвестных рынках, данные о ценах могут быть недоступны.

Сервис выходит за рамки данных о ценах. Некоторые стратегии включают экономические или статистические данные. TradingView предлагает некоторые данные (в основном данные Quandl) в этой категории, но в настоящее время они ограничены.

Если вы используете альтернативные данные в своей стратегии, вероятно, будет проще использовать другой язык программирования, который обеспечивает большую гибкость.

Внешние библиотеки. Pine Script не подходит, если вы хотите использовать внешние библиотеки для выполнения таких задач, как машинное обучение. Есть лучшие альтернативы, если ваша стратегия основана на использовании науки о данных или других сторонних библиотек.

Торговля парами – руководство из реальной жизни

Какие есть альтернативы использованию скрипта Pine?

Thinkorswim от TD Ameritrade — эта платформа во многом похожа на Pine Script.

Она использует проприетарный язык thinkScript и хранит данные о ценах в массивах аналогично скрипту Pine. Данные встроены, и платформа предназначена для создания пользовательских индикаторов и стратегий.

Ninjatrader — эта платформа также использует собственный язык, который называется Ninjascript. Язык не является полностью проприетарным, поскольку основан на C#.

Ninjatrader обладает большей гибкостью, поскольку позволяет подключаться к пользовательским потокам данных. Если вы уже знакомы с C#, C или C++, это может оказаться подходящей альтернативой.

Как начать работу со скриптом Pine?

Начать работу со скриптом Pine очень просто, ничего скачивать и устанавливать не нужно.

Если у вас уже есть учетная запись в TradingView, просто перейдите на их страницу.

Если у вас нет учетной записи, перейдите на сайт www.tradingview.com. Оттуда вы увидите окно входа в верхний правый угол.

Существует несколько вариантов регистрации в один клик или использование традиционного метода электронной почты/пароля.

Наличие учетной записи позволяет вам сохранять свои скрипты в облаке TradingView и дает возможность добавлять пользовательские индикаторы на графики.

После регистрации запустите графическую платформу, щелкнув график в меню или перейдя на страницу www.tradingview.com/chart.

Первый взгляд на редактор Pine

В редакторе Pine мы будем создавать наш код. Чтобы запустить его, нажмите Pine Editor в самом низу экрана.

Должен появиться экран, похожий на изображение ниже.

В скрипте Pine вы будете создавать либо индикатор , либо стратегию . Мы подробно обсудим различия в этой статье.

Если вы следите за ходом, экран, на который вы сейчас смотрите, является начальным сценарием по умолчанию для создания индикатора.

Пробежимся по нему строчка за строчкой.

// This source code is subject to the terms of the Mozilla Public License 2.0 at https://mozilla.org/MPL/2.0/

Первая строка — это просто комментарий. Комментарии в скрипте Pine начинаются с двух косых черт.

// © author

Вторая строка также является комментарием, она автоматически заполняется вашим именем пользователя TradingView.

//@version=5

В четвертой строке вы можете предположить, что у нас есть еще один комментарий. Однако эта линия немного отличается.

Это известно как директива компилятора. Это позволяет компилятору узнать, какую версию скрипта Pine мы хотим использовать.

Вы можете отказаться от первых двух строк комментария, если хотите, но директива компилятора требуется во всех скриптах.

indicator("My Script")

Строка 5 является объявлением. Здесь указываете, создаете ли вы индикатор.

Альтернативой является создание стратегии, но мы начнем с индикатора.

Вторая часть строки 5 в кавычках — это имя, которое мы присвоим этому конкретному индикатору. По умолчанию используется Мой сценарий .

plot(close)

Строка 6 содержит команду построения графика. Как вы уже, наверное, догадались, она приказывает TradingView построить график определенной переменной.

В этом случае переменная close будет построена. Это встроенная переменная, которая содержит цену закрытия последнего бара.

Давайте нажмем «Добавить в диаграмму» в правом верхнем углу редактора Pine.

Вам будет предложено сохранить сценарий.

После сохранения ваш график должен получить новое окно, содержащее график цен закрытия с вашего основного графика.

Это окно называется окном данных. На изображении выше это линейная диаграмма, нарисованная синим цветом.

Обратите внимание, что окно данных показывает «Мой сценарий» в верхнем левом углу. Это извлекает все, что введено в строку 5 нашего кода, где мы объявили имя для индикатора.

И вот он, наш первый индикатор, и нам даже не нужно было писать код!

Как узнать цену Apple?

В нашем первом примере мы построили цену закрытия. Скрипт Pine автоматически сделает это для любого открытого графика.

В данном случае у нас был открыт дневной график биткойна.

Но что, если вы хотите получить данные для другого актива? Давайте рассмотрим пример, в котором мы берем цену Apple, даже если у нас нет открытого графика.

Каждый скрипт начинается с нескольких строк, в которых мы устанавливаем директиву компилятора. Мы также указываем, является ли это индикатором или стратегией, которую мы создаем, и присваиваем имя.

//@version=5
indicator("price of Apple")

В данном случае мы создаем индикатор. Название этого индикатора – «цена Apple».

Далее мы должны сообщить Pine Script, что нас интересует актив, отличный от того, что в данный момент отображается на графике.

Для этого мы можем использовать функцию request.security().

request.security()

Приятной особенностью скрипта Pine является то, что справка всегда легко доступна, если вы работаете с синтаксисом, с которым раньше не работали.

Например, мы можем навести курсор на нашу функцию, и она покажет краткое описание.

Для получения более подробной информации вы можете запустить окно справки. Для этого нажмите CTRL, щелкнув функцию на ПК. Или, на Mac, нажмите CMD, нажимая на функцию.

Функция справки разъясняет синтаксис и даже содержит полезные примеры.

request.security("AAPL", "D", close)

Мы использовали синтаксис, аналогичный примеру в приведенном выше фрагменте кода. Первым значением в функции безопасности является тикер, который является AAPL.

Затем мы устанавливаем временные рамки на день. И, наконец, мы сообщили скрипту Pine, что нас интересует цена закрытия.

Мы можем сохранить возврат функции в переменную.

apple_price = request.security("AAPL", "D", close)

Теперь переменная apple_price будет содержать последнее дневное закрытие акций Apple.

Исследования, созданные в скрипте Pine, должны иметь хотя бы один вывод, иначе скрипт выдаст ошибку компилятора.

Давайте построим нашу переменную так, чтобы она удовлетворяла правилу сценария Pine о наличии вывода.

plot(apple_price)

После сохранения и добавления на график наш экран выглядит так.

Теперь у нас есть дневная цена закрытия Apple, отображаемая в окне данных, в то время как в главном окне отображается свечной график биткойнов.

Полный код:

//@version=5
indicator("price of Apple")

apple_price = request.security("AAPL", "D", close)

plot(apple_price)

Как получить SMA ( 20 ) Apple?

Теперь, когда мы можем получить доступ к цене акций Apple, давайте рассмотрим пример получения простой скользящей средней.

Тот же процесс можно использовать для применения любого индикатора.

Мы начнем с наших основных объявлений и используем функцию безопасности, которую мы создали в нашем последнем примере.

//@version=5
indicator("Get 20 SMA of Apple")

// Get price of Apple
apple_price = request.security("AAPL", "D", close) // 1 Day

Если вы не хотите получать 20 SMA специально для AAPL, вы можете пропустить определение безопасности и просто использовать встроенную переменную close.

Это позволит получить цену закрытия для любой ценной бумаги, которая отображается в главном окне графика.

В скрипт Pine встроена вспомогательная функция для индикатора SMA. Чтобы получить к нему доступ, мы просто используем функцию ta.sma().

ta.sma(apple_price, 20)

Первый параметр, который нам нужно передать, — это значение цены. В этом случае мы используем цену закрытия для Apple, которую мы сохранили в нашей переменной apple_price.

Второй параметр — длина SMA. Мы ищем 20-периодную SMA.

Наконец, мы назначим данные SMA отдельной переменной, а затем построим ее.

apple_sma = ta.sma(apple_price, 20)

plot(apple_sma)

Простая скользящая средняя для Apple теперь отображается в нашем окне данных.

Скользящие средние обычно наносятся на основной график. Мы можем добиться этого с помощью небольшой модификации нашего кода.

indicator("Get 20 SMA of Apple", overlay=true)

Добавив в overlay=Trueобъявление индикатора, мы можем отображать наши данные непосредственно в главном окне графика, а не в окне данных.

Полный код:

//@version=5
indicator("Get 20 SMA of Apple", overlay=true)

// Get price of Apple
apple_price = request.security("AAPL", "D", close) // 1 Day

// Calculate 20 SMA of Apple
apple_sma = ta.sma(apple_price, 20)

plot(apple_sma)

Как протестировать кросс-стратегию скользящих средних с помощью Pine Script?

Мы прошлись по индикаторам. Давайте посмотрим на стратегии в Pine Script.

В следующем примере мы создадим стратегию пересечения скользящих средних с несколькими дополнительными параметрами. Затем мы проверим стратегию на истории в TradingView.

//@version=5
strategy("My Strategy", overlay=true)

Чтобы создать стратегию, мы заменяем объявление индикатора объявлением стратегии.

// Create Indicator's
shortSMA = ta.sma(close, 10)
longSMA = ta.sma(close, 30)

Первое, что нам нужно сделать, это создать две скользящие средние и присвоить данные переменным.

rsi = ta.rsi(close, 14)

Мы также создадим индикатор RSI, который будет использоваться для подтверждения наших входов и выходов.

Эта стратегия будет работать на основном графике, поэтому нам не нужно использовать здесь функцию security().

Далее мы хотим указать наши условия кроссовера. К счастью, в TradingView уже есть встроенная функция для этого, поэтому нам не нужно кодировать ее вручную.

// Specify crossover conditions
longCondition = ta.crossover(shortSMA, longSMA)
shortCondition = ta.crossunder(shortSMA, longSMA)

У нас есть два условия, первое — когда короткая SMA с периодом 10 пересекает более длинную SMA с периодом 30.

Второе условие является противоположным, поскольку мы использовали функцию crossunder, а не crossover.

Оба эти условия сохраняются в переменных. Поэтому, когда происходит пересечение (crossover или crossunder), эти переменные будут обновлены до True, что является логическим значением.

Мы можем использовать оператор if, чтобы проверить, изменилось ли условие на True, а затем выполнить сделку, если это так.

if (longCondition)
    strategy.entry("long", strategy.long, 100, when = rsi > 50)

Встроенная strategy.entryфункция используется для входа в сделки. Вот параметры, которые передаются в функцию.

1. long — это идентификатор сделки. Мы не будем использовать его в этом примере. Но, если вы планируете закрыть или отменить сделку, это можно сделать с помощью этого идентификатора.
2. Strategy.long — это встроенная переменная, которая сообщает скрипту Pine, что мы хотим открыть длинную позицию.
3. 100 — количество акций, которыми мы хотим торговать
4. when = rsi > 50 — это дополнительный параметр, который указывает скрипту pine выполнять сделку только в том случае, если RSI выше 50.

Синтаксис наших кратких записей будет очень похож на формат.

if (shortCondition)
    strategy.entry("short", strategy.short, 100, when = rsi < 50)

Поскольку мы используем стратегию, нам не нужно ничего строить или задавать выходные данные.

Но мы все равно это сделаем. Было бы неплохо увидеть SMA на графике, чтобы мы могли подтвердить, что сделки имели место, когда они должны были быть.

// Plot Moving Average's to chart
plot(shortSMA)
plot(longSMA, color=color.black)

Если мы сохраним и добавим на график, стратегия запустится и автоматически откроет окно тестера стратегий , в котором будут отображаться некоторые важные статистические данные.

Вот так выглядит наш экран.

По умолчанию открывается новая вкладка с обзорной статистикой по стратегии. Вы можете щелкнуть сводку по эффективности или список сделок, чтобы увидеть другую статистику.

Стратегия будет работать на таймфрейме, который отображается на вашем графике.

Вы можете легко переключаться между различными временными рамками, используя параметры временных рамок в меню в верхней части экрана. Стратегия будет автоматически обновляться в соответствии с выбранным новым таймфреймом.

Полный код:

//@version=5
strategy("My Strategy", overlay=true)

// Create Indicator's
shortSMA = ta.sma(close, 10)
longSMA = ta.sma(close, 30)
rsi = ta.rsi(close, 14)

// Specify crossover conditions
longCondition = ta.crossover(shortSMA, longSMA)
shortCondition = ta.crossunder(shortSMA, longSMA)

// Execute trade if condition is True
if (longCondition)
    strategy.entry("long", strategy.long, 100, when = rsi > 50)

if (shortCondition)
    strategy.entry("short", strategy.short, 100, when = rsi < 50)

// Plot Moving Average's to chart
plot(shortSMA)
plot(longSMA, color=color.black)

Как установить тейк-профит и стоп-лосс?

В нашем последнем примере исполнение сделки определялось пересечением и пересечением скользящих средних.

Мы будем опираться на этот скрипт и установим конкретные стоп-лоссы и тейк-профиты. Мы можем использовать средний истинный диапазон (ATR) для расчета уровней для них.

Индикатор ATR рассчитывает среднее движение за последнее количество указанных баров. Это хороший способ учета изменений волатильности.

Мы уже объявили несколько индикаторов, добавим в список индикатор ATR.

// Create Indicator's
shortSMA = ta.sma(close, 10)
longSMA = ta.sma(close, 30)
rsi = ta.rsi(close, 14)
atr = ta.atr( 14 )

В наших торговых условиях мы можем сделать необходимые расчеты для нашего стоп-лосса и тейк-профита.

if (longCondition)
    stopLoss = low - atr * 2
    takeProfit = high + atr * 2
    strategy.entry("long", strategy.long, 100, when = rsi > 50)
    strategy.exit("exit", "long", stop=stopLoss, limit=takeProfit)

В приведенном выше коде мы рассчитали стоп-лосс, взяв минимум бара во время входа и вычтя средний истинный диапазон, умноженный на два.

Таким образом, если акции двигаются в среднем на 5 долларов за бар, мы устанавливаем тейк-профит на 10 долларов ниже минимума.

Аналогичный расчет делается для тейк-профита.

Наконец, мы указываем условие выхода, используя функцию Strategy.exit(). Вот параметры, которые были переданы.

1. exit — это идентификатор сделки для выхода из сделки.
2. long — это идентификатор, который мы ранее установили при входе в сделку. Это позволит скрипту Pine узнать, из какой позиции мы пытаемся выйти.
3. stop=stopLoss – указываем, что уровень, содержащийся в переменной stopLoss, должен использоваться как стоп-ордер на выход из сделки.
4. limit=takeProfit = мы указываем, что уровень, содержащийся в переменной takeProfit, должен использоваться как лимитный ордер для выхода из сделки.

Синтаксис нашего короткого условия аналогичен, хотя некоторые вычисления немного отличаются.

if (shortCondition)
    stopLoss = high + atr * 2
    takeProfit = low - atr * 2
    strategy.entry("short", strategy.short, 100, when = rsi < 50)
    strategy.exit("exit", "short", stop=stopLoss, limit=takeProfit)

Остальная часть скрипта остается неизменной по сравнению с предыдущим примером. Давайте запустим его и посмотрим, как сработала наша стратегия.

Наши выходы работают и отображаются на нашем основном графике вместе с длинными и короткими входами.

Полный код:

//@version=5
strategy("Take profits & stop losses", overlay=true)

// Create Indicator's
shortSMA = ta.sma(close, 10)
longSMA = ta.sma(close, 30)
rsi = ta.rsi(close, 14)
atr = ta.atr( 14 )

// Specify crossover conditions
longCondition = ta.crossover(shortSMA, longSMA)
shortCondition = ta.crossunder(shortSMA, longSMA)

// Execute trade if condition is True
if (longCondition)
    stopLoss = low - atr * 2
    takeProfit = high + atr * 2
    strategy.entry("long", strategy.long, 100, when = rsi > 50)
    strategy.exit("exit", "long", stop=stopLoss, limit=takeProfit)

if (shortCondition)
    stopLoss = high + atr * 2
    takeProfit = low - atr * 2
    strategy.entry("short", strategy.short, 100, when = rsi < 50)
    strategy.exit("exit", "short", stop=stopLoss, limit=takeProfit)

// Plot Moving Average's to chart
plot(shortSMA)
plot(longSMA, color=color.black)

Как запустить сделку с Apple, когда Google движется на 5%?

Мы видели, что функцию безопасности можно использовать для отображения данных по акциям, не отображаемым на экране.

Мы будем использовать его для создания стратегии, которая будет выполнять сделку в Apple, если Google движется более чем на 5%.

Это стратегия возврата к среднему, поэтому, если Google вырастет более чем на 5%, мы продадим Apple. Если Google упадет более чем на 5%, мы сможем купить Apple.

Первое, что мы сделаем, это сохраним ежедневную цену открытия и закрытия Google в переменной.

//@version=5
strategy("Pair Trade: Apple & Google")

google_close = request.security("GOOG", "D", close)
google_open = request.security("GOOG", "D", open)

Затем мы можем выполнить расчет, чтобы определить процентное изменение цены.

price_change = google_close / google_open

Теперь переменная price_change содержит вычисление. Так, например, если Google открылся на уровне 100 долларов и вырос на 5%, чтобы закрыться на уровне 105 долларов, переменная price_change будет равна 105/100, что равно 1,05.

Но если Google открылся на уровне 100 долларов и снизился на 5%, чтобы закрыться на уровне 95 долларов, переменная будет выглядеть как 95/100, что равно 0,95.

Итак, мы знаем, что если Google откажется на 5% или больше, переменная price_change будет равна 0,95 или меньше, и мы хотим открыть длинную позицию. Вот синтаксис для этого.

if price_change < 0.95
    strategy.entry("long", strategy.long, 100)

И синтаксис, чтобы получить короткий, если Google сплачивает более 5%.

if price_change > 1.05
    strategy.entry("short", strategy.short, 100)

Вы могли заметить, что мы не упомянули в коде цену акций Apple. Все, что нам нужно сделать, это открыть график AAPL, и он автоматически узнает, что нужно совершать сделки в Apple.

Наконец, мы построим переменную price_change в окне данных. Это не обязательно, но приятно видеть, и мы можем подтвердить, что сделки выполняются должным образом.

plot(price_change)

И вот результаты нашей стратегии.

Только четыре сделки, так как 5% движения встречаются редко. Нам, вероятно, потребуется увидеть намного больше сделок, чтобы определить, является ли это хорошей стратегией.

Похоже, была проделана хорошая работа, чтобы выбрать этот минимум в марте!

Полный код:

//@version=5
strategy("Pair Trade: Apple & Google")

google_close = request.security("GOOG", "D", close)
google_open = request.security("GOOG", "D", open)

price_change = google_close / google_open

if price_change < 0.95
    strategy.entry("long", strategy.long, 100)

if price_change > 1.05
    strategy.entry("short", strategy.short, 100)

plot(price_change)

Как модифицировать наши скрипты без кодирования?

Отличительной особенностью скрипта Pine является то, что мы можем создавать собственные входные данные, чтобы легко изменять параметры наших стратегий и индикаторов.

Взгляните на стандартный индикатор ATR, предлагаемый в Tradingivew. Обратите внимание, как легко изменить длину и даже цвета на вкладке «Стиль».

Мы можем добиться того же для исследований и стратегий, созданных в скрипте Pine, с помощью функции input().

Вот пример функции ввода, которая позволит пользователю настроить процентное изменение по сравнению с последним примером стратегии.

longTrigger = input(title="% Change for short entries", defval=5)

shortTrigger = input(title="% Change for long entries", defval=5)

Давайте пройдемся по параметрам, которые передаются через функцию input().

1. title — здесь мы указываем текст, который видит пользователь при попытке изменить значение этого конкретного параметра.
2. defval — это значение по умолчанию.

Теперь мы можем получить значения от пользователя. Но они будут вводить значение, такое как 5 (%). Нам нужно преобразовать это в 1,05 для наших операторов if.

longTrigger := 1 - longTrigger/100
shortTrigger := 1 + shortTrigger/100

И нам нужно изменить наши операторы if, чтобы они смотрели на наши вновь созданные переменные на основе пользовательского ввода, а не на ранее жестко закодированных значениях.

if price_change < longTrigger
    strategy.entry("long", strategy.long, 100)

if price_change > shortTrigger
    strategy.entry("short", strategy.short, 100)

Чтобы получить доступ к параметрам ввода, щелкните значок шестеренки рядом с названием вашей стратегии в окне данных.

Пользовательские значения теперь могут быть установлены для процентного изменения, используемого в стратегии.

Существует также окно свойств, которое позволит вам установить пользовательские параметры для других частей стратегии.

И окно стиля для настройки параметров печати.

Полный код:

//@version=5
strategy("Pair Trade: Inputs")

longTrigger = input(title="% Change for short entries", defval=5)
shortTrigger = input(title="% Change for long entries", defval=5)

longTrigger := 1 - longTrigger/100
shortTrigger := 1 + shortTrigger/100

google_close = request.security("GOOG", "D", close)
google_open = request.security("GOOG", "D", open)

price_change = google_close / google_open

if price_change < longTrigger
    strategy.entry("long", strategy.long, 100)

if price_change > shortTrigger
    strategy.entry("short", strategy.short, 100)
    
plot(price_change)

Как построить сценарий с помощью Pine?

До сих пор мы использовали стандартную функцию plot() для вывода определенных элементов на экран. Сценарий Pine имеет несколько других команд, которые мы можем использовать для нашего вывода, и мы рассмотрим некоторые из них.

График работы рынка Форекс

Нужно помнить, когда рынки открываются и закрываются. Это может быть довольно сложно понять трейдерам Forex.

Форекс торгует 24 часа в сутки и 5 дней в неделю. Различные рынки по всему миру открываются и закрываются в течение дня, что влияет на волатильность валюты.

Давайте запрограммируем индикатор, который, взглянув на график, покажет нам, когда ожидается наибольшая занятость на рынках.

Большинство трейдеров Форекс обращают внимание на лондонскую и нью-йоркскую сессии. Мы начнем с указания времени для этих сессий.

//@version=5
indicator("Forex Sessions", overlay=true)

London = time(timeframe.period, "0700-1500")
NY = time(timeframe.period, "1200-2000")

Здесь мы использовали функцию time() для создания периода. В параметрах мы используем 07:00 UTC для времени начала лондонской сессии и 15:00 UTC для времени окончания.

Переменная London теперь будет содержать время бара, если бар попадает между этим периодом. В противном случае он покажет NaN («не»-значение).

Мы можем использовать оператор if, чтобы проверить вывод переменной London.

val = if (na(London))
    1
else
    0

В приведенном выше коде мы используем встроенную функцию na(). Это проверяет, имеет ли переменная значение NaN или нет.

если переменная London возвращает значение NaN, это означает, что бар находится вне лондонских торговых часов.

В этом случае вызываемой переменной val будет присвоено целое число 1. В противном случае переменной будет присвоено значение val0.

Наконец, мы отрисуем только что созданную переменную val.

plot(val)

Вот как выглядит наш график после сохранения и добавления этого индикатора на график.

Это выглядит не слишком хорошо. Он правильно показывает, когда лондонский рынок открыт, но построение этих значений сделало наши свечи неразборчивыми.

Мы могли бы построить его в окне данных, чтобы свечи было лучше видно, но визуализировать открытие и закрытие рынка все равно было бы непросто.

Кроме того, код выглядит не слишком хорошо.

Давайте начнем с использования однострочного оператора if, чтобы немного очистить наш код.

na(London) ? 1 : 0

Этот код выполняет ту же функцию, что и предыдущий оператор if. В этом случае нам не нужно использовать переменную val. Разберем синтаксис.

na(London)

Эта часть проверяет, содержит ли переменная London значение NaN.

? 1 : 0

Знак вопроса здесь — это краткая форма оператора if/else.

То, что следует за вопросительным знаком, является важной частью. Здесь два числа, разделенные двоеточием. Число перед двоеточием, в данном случае 1, — это то, что должно быть возвращено в случае, если оператор if верен.

Число после двоеточия, в данном случае 0, возвращается, когда оператор if возвращает false.

Затем мы можем взять весь синтаксис и обернуть его в функцию построения графика, сэкономив усилия на его предварительном сохранении в переменной.

plot(na(London) ? 1 : 0)

Итак, теперь мы превратили оператор if в однострочный фрагмент кода.

Чтобы сделать график более удобным для чтения, мы можем нанести другой цвет фона, если лондонский рынок открыт.

Для этого мы заменяем функцию plot() на функцию bgcolor(). Это позволяет нам изменить цвет фона.

bgcolor(na(London) ? 1 : 0)

Также мы укажем цвет, когда рынок открыт.

bgcolor(na(London) ? na : color.blue)

Наша диаграмма начинает выглядеть намного лучше!

Последнее, что мы сделаем, это добавим код, чтобы увидеть, открыт ли рынок в Нью-Йорке, и установим зеленый фон, если это так.

bgcolor(na( NY ) ? na : color.green)

Вы заметите, что на приведенной ниже диаграмме есть три цвета.

Это связано с тем, что лондонская и нью-йоркская сессии пересекаются, и обычно это самое волатильное время дня.

Теперь мы можем легко увидеть сессии и быстро выделить такие вещи, как максимум, установленный на европейских торгах, или минимум, который был напечатан во время перекрытия.

Полный код:

//@version=5
indicator("Forex Sessions", overlay=true)

Tokyo = time(timeframe.period, "0000-0800")
London = time(timeframe.period, "0700-1500")
NY = time(timeframe.period, "1200-2000")

bgcolor(na(Tokyo) ? na : color.fuchsia)
bgcolor(na(London) ? na : color.blue)
bgcolor(na( NY ) ? na : color.green)

Нанесение аннотаций

Существует несколько вариантов печати аннотаций. Например, вы можете использовать функцию hline() для рисования горизонтального уровня на графике.

Существует функция plotchar(), которая позволяет отображать символы ASCII на графике. Это часто используется для построения заметки сверху или снизу ценового бара.

Другой распространенной функцией построения графиков является plotshape(), которая позволяет отображать различные фигуры. Этот довольно популярен, так как многие люди используют его для построения стрелок вверху или внизу столбцов, чтобы показать сигналы покупки или продажи.

Полный список различных доступных аннотаций см. в разделе Обзор аннотаций в руководстве пользователя скрипта Pine.

Как я могу создать собственный индикатор в скрипте Pine?

Мы собираемся создать мультитаймфреймовый индикатор.

Это основано на стратегии скальпинга, которую я использовал, когда впервые начал торговать. Это стратегия возврата к среднему, которая хорошо работает в начале азиатской сессии на рынках Forex, когда в целом все спокойно.

Стратегия использует полосы Боллинджера на 5-минутном графике и RSI на 1-минутном графике.

Идея состоит в том, чтобы искать расхождение rsi на 1-минутном графике, когда цена достигает верхней или нижней полосы Боллинджера на 5-минутном графике.

Потенциальной целью является средняя линия 5-минутной полосы Боллинджера или нижняя линия 1-минутной полосы Боллинджера.

Изображение выше является примером стратегии. Индикатор сессий Forex, который мы использовали в предыдущем примере, был использован здесь, чтобы показать, когда открыта азиатская сессия.

Эта стратегия лучше всего работает в первой половине сессии, после чего риск прорыва или направленного движения имеет тенденцию к увеличению.

Когда я торговал по этой стратегии, мне приходилось держать открытыми два графика: 1-минутный и 5-минутный.

Но в приведенном выше примере показаны 5-минутные полосы Боллинджера, нарисованные непосредственно на 1-минутном графике. Мы создадим этот индикатор в скрипте Pine.

//@version=5
indicator(title="Higher TF BBands", shorttitle="TF BBands", overlay=true)

Начнем с объявления имени скрипта и указания, что это индикатор. Также можно добавить более короткое название, это имя будет отображаться на диаграммах.

Затем мы устанавливаем некоторые пользовательские входы. Мы можем дублировать большинство входных данных из обычного индикатора полосы Боллинджера (как показано на изображении выше) для нашего пользовательского индикатора.

// Get user input
tf = input(title="BBands Timeframe", defval="5")
len = input(title="Length", defval=20)
stddev = input(title='StdDev', defval=2)

Мы можем создать индикатор полосы Боллинджера из встроенной вспомогательной функции.

[middle, upper, lower] = ta.bb(close, len, stddev)

Эта функция возвращает три значения. Нижняя, средняя и верхняя полоса. Они сохраняются индивидуально в переменные.

Значения должны рассчитываться на другом таймфрейме. Мы можем использовать функцию security(), чтобы указать временной интервал, выбранный пользователем.

Это сохраняется в переменной tf, созданной предыдущим пользовательским вводом.

hbbandsMid = request.security(syminfo.tickerid, tf, middle, barmerge.gaps_on, barmerge.lookahead_off)
hbbandsUpper = request.security(syminfo.tickerid, tf, upper, barmerge.gaps_on, barmerge.lookahead_off)
hbbandsLower = request.security(syminfo.tickerid, tf, lower, barmerge.gaps_on, barmerge.lookahead_off)

Символ тикера остается прежним, поэтому мы использовали значение syminfo.tickerid, которое будет возвращать любой тикер, отображаемый на основном графике.

Вот и все, осталось построить новый индикатор.

plot(hbbandsMid)
plot(hbbandsUpper)
plot(hbbandsLower)

Теперь мы можем видеть полосы Боллинджера на 5-минутном графике, отображаемом на 1-минутном графике.

Входные данные позволяют легко настраивать параметры полос Боллинджера и позволяют этому индикатору работать с любой комбинацией таймфреймов.

Полный код:

//@version=5
indicator(title="Higher TF BBands", shorttitle="TF BBands", overlay=true)

// Get user input
tf = input(title="BBands Timeframe", defval="60")
len = input(title="Length", defval=20)
stddev = input(title='StdDev', defval=2)

[middle, upper, lower] = ta.bb(close, len, stddev)

hbbandsMid = request.security(syminfo.tickerid, tf, middle, barmerge.gaps_on, barmerge.lookahead_off)
hbbandsUpper = request.security(syminfo.tickerid, tf, upper, barmerge.gaps_on, barmerge.lookahead_off)
hbbandsLower = request.security(syminfo.tickerid, tf, lower, barmerge.gaps_on, barmerge.lookahead_off)

plot(hbbandsMid)
plot(hbbandsUpper)
plot(hbbandsLower)

Последние мысли

Если вы следили за примерами, у вас будет хорошее представление о том, на что способен скрипт Pine.

В целом, со скриптом Pine можно многое сделать, хотя у него есть определенные ограничения. Можно очень быстро написать стратегию, как только вы во всем разберетесь.

Оттуда всегда можно взять эту логику и запрограммировать ее на другом языке, если вы хотите использовать ее и сторонние библиотеки.

Функции построения графиков великолепны, а возможность создавать пользовательские индикаторы действительно полезна как для ручных трейдеров, так и для автоматизированных систем.

Полная статистика, предлагаемая для стратегий, также является большим плюсом скрипта Pine.

У TradingView есть несколько ресурсов, если вы хотите продвинуть свои навыки кодирования скриптов Pine на шаг дальше.

Некоторые справочные функции уже обсуждались в этой статье. Кроме того, в редакторе Pine есть опция справки.

Вот еще несколько ресурсов —

1. Руководство по быстрому запуску — здесь приводится пример индикатора и разбивается сценарий построчно.
2. Руководство пользователя Pine Script v5 — Подробное руководство по скрипту Pine.
3. Блог TradingView – объявления о новых функциях, которые часто содержат примеры кода.
4. Библиотека скриптов TradingView — библиотека исследований и стратегий Pine с открытым исходным кодом.

Последний вариант в списке — отличный ресурс, так как обычно другими трейдерами уже разработан нужный вам индикатор или стратегию.

Это также хороший источник идей для создания собственных индикаторов или стратегий.

Если вы хотите попробовать некоторые из примеров, загрузите весь код одним щелчком мыши на GitHub. Просто нажмите зеленую кнопку и выберите «Загрузить zip». Код будет в текстовых файлах, которые можно скопировать в редактор Pine Tradingview.

Читать оригинал руководства от Algotrading101

Рекомендуем к прочтению:

Лучшие индикаторы TradingView 2022

Лучшие альтернативы TradingView

Мы выбираем 🔥

Новости криптовалют
→

Краткое руководство

Скрипт, написанный на языке Pine, состоит из функций и переменных. Функции содержат инструкции, которые описывают необходимые вычисления. Переменные сохраняют значения, использованные или созданные во время этих вычислений.

Скрипт должен содержать аннотацию study (индикатор) или strategy (стратегия), которая определяет имя и другие свойства  скрипта. Тело сценария содержит функции и переменные, необходимые для вычисления результатов, которые будут отображаться на графике с помощью функции plot или какой-либо другой функции, которая отображает выходные данные скрипта.

Пример скрипта Pine

Давайте посмотрим на реализацию индикатора MACD в Pine:

//@version=4
study("MACD")
fast = 12, slow = 26
fastMA = ema(close, fast)
slowMA = ema(close, slow)
macd = fastMA - slowMA
signal = sma(macd, 9)
plot(macd, color=color.blue)
plot(signal, color=color.orange)

Это комментарий, содержащий описание версии компилятора, которая сообщает компилятору, что скрипт будет использовать 4-ую версию языка Pine.

Определяет имя скрипта, который будет отображаться на графике как «MACD».

fast = 12, slow = 26

Определяет две целочисленные переменные с названиями: fast и slow.

fastMA = ema(close, fast)

Определяет переменную fastMA, содержащую результат расчета EMA (Exponential Moving Average, экспоненциальное скользящее среднее) с длиной, равной fast (12), для close, т.е. цены закрытия свечей.

slowMA = ema(close, slow)

Определяет переменную slowMA, содержащую результат вычисления EMA с длиной, равной slow (26), для close.

macd = fastMA - slowMA

Определяет переменную macd как разницу между двумя EMA.

signal = sma(macd, 9)

Определяет переменную signal как сглаженное значение macd, с использованием алгоритма SMA (Simple Moving Average, простое скользящее среднее) с длинной 9.

plot(macd, color=color.blue)

Вызывает функцию plot для вывода переменной macd,отображая линией синего цвета.

plot(signal, color=color.orange)

Вызывает plot функцию для вывода переменной signal, отображая линией оранжевого цвета.

После добавления скрипта «MACD» на график вы увидите следующее:

Pine содержит множество встроенных функций для самых популярных индикаторов (SMA, EMA, WMA и т.д.). Вы также можете определить свои пользовательские функции. 

Индикаторы и стратегии

Pine стратегии используются для запуска бэк-тестов. В дополнение к обычным скриптовым вычислениям они также содержат strategy.***** вызовы для создания заявок (ордеров) на покупку и продажу. Они могут отображать информацию на графиках, но не могут быть использованы для создания оповещений.

Pine индикаторы, как и в предыдущем примере, также содержат расчеты и могут отображать информацию на графиках, но не могут использоваться при тестировании на истории. Индикаторы, содержащие alertcondition вызовы, могут использоваться для создания оповещений с помощью диалогового окна «Создать оповещение TradingView». 

Модель исполнения скриптов Pine

Скрипт Pine не похож на многие обычные программы, которые выполняются один раз, а затем останавливаются. В среде выполнения Pine скрипт выполняется как скрытый цикл, где он выполняется один раз на каждом историческом изменении. Когда выполнение достигает последней свечи в реальном времени, скрипт будет выполняться каждый раз, когда обнаруживается изменение цены или объема, затем последний раз, когда свеча реального времени закрывается и становится исторической свечой.

По умолчанию стратегии Pine выполняются только один раз при закрытии свечи в реальном времени, но их также можно настроить чтобы они выполнялись при каждом изменении цены, как это делают индикаторы. 

Серии

Основной тип данных, используемый в сценариях Pine, называется series (серия). Это непрерывный список значений, который тянется во времени от текущей свечи и где существует одно значение для каждой свечи. Хотя эта структура может напоминать многим о массиве, ряд Pine совершенно другой, и мышление в терминах массивов будет вредно для понимания этой ключевой концепции Pine. 

Понимание сценариев

Если вы собираетесь написать сценарий Pine любой разумной сложности, то хорошее понимание как модели выполнения Pine, так и серии важно для понимания того, как работают сценарии Pine. Если вы никогда раньше не работали с данными, организованными в серии, вам понадобится практика, чтобы заставить их работать на вас. Когда вы ознакомитесь с фундаментальными концепциями Pine, вы обнаружите, что, комбинируя использование рядов с нашими встроенными функциями, разработанными для эффективной обработки информации в сериях, можно достичь многого за несколько строк кода Pine.

Редактор Pine

В Pine Editor вы будете работать над своими сценариями. Чтобы открыть его, нажмите на вкладку Pine Editor в нижней части графика TradingView. Это откроет окно редактора. Мы создадим наш первый рабочий скрипт Pine. Начните с вызова выпадающего меню «Новый» в правом верхнем углу редактора и выберите «Пустой скрипт индикатора». Затем скопируйте предыдущий пример сценария, выделите весь код, уже находящийся в редакторе, и замените его примером сценария. Нажмите «Сохранить», выберите имя и нажмите «Добавить на график». Индикатор MACD появится в отдельной панели под графиком.

Здесь же вы можете изменить код скрипта. Например, измените последнюю строку color.orange на color.fuchsia. При сохранении скрипта изменение будет отражено на панели индикатора. Ваш первый скрипт Pine запущен!

Что дальше?

Эта документация содержит многочисленные примеры кода, используемого для иллюстрации того, как функции, переменные и операторы используются в Pine. Пройдя через это, вы сможете изучить основы Pine и изучить примеры сценариев.

Самый быстрый способ выучить язык программирования — прочитать ключевые понятия и опробовать их на реальном коде. Как мы только что сделали, скопируйте примеры этой документации в редактор и поиграйте с ними. Проводите исследования! Вы ничего не испортите.

Также вы найдете примеры скриптов Pine в выпадающем меню редактора Новый и в обширной публичной библиотеке скриптов TradingView, которая содержит тысячи скриптов Pine с открытым исходным кодом. Наслаждайтесь и добро пожаловать в Pine!

In this pine script tutorial I’ll be showing you how to get started with TradingView scripting for technical analysis and trading strategy development. We will start by looking at how pine script works and a simple example. From there we will move on to inputs and indicators before creating a complete trading strategy using pine script. Finally we will look at how to backtest, execute and publish pine script indicators and strategies.

1. Developing Pine Script Trading Strategies [Video]
2. How Pine Script Works On TradingView
3. Your First Pine Script Overlay
4. Pine Script Basics
5. Pine Script Built In Functions
6. Creating A Pine Script Trading Strategy
7. Backtesting Pine Script Strategies
8. How & Why Publish TradingView Pine Scripts
9. Trade Execution & Strategy Deployment

Developing Pine Script Trading Strategies

Note that Pinescript v4 was used in the video, now Pinescript v5 has been released I’ve updated the code in the article below with the main difference being namespacing i.e. sma becomes ta.sma

How Pine Script Works On TradingView

Pine script is the native coding language of TradingView. It’s used widely for technical analysis and algo trading strategy development.

Pine script is quite similar to Python in it’s format and layout. Developers familiar with Python or any other scripting language shouldn’t have much difficulty getting up to speed. There are some important considerations that need to be addressed before we get started.

Pine script executes once for each candle of a chart on what is known as series data. The code that you write is executed once for each data point in the series data. There might be a thousand data points (1 data point = 1 candle) on a standard chart and the code will iterate over itself each time. So when you call the plot(close) function in pine script it draws a line at the close price for each data point.

When you change the timeframe on the chart the data changes and the indicator or strategy will change completely. A 30 minute moving average is very different to a 30 day moving average and this is normally set on the chart not within the script itself.

There are two types of pine script formats indicators and strategies. Indicators are used for technical analysis to draw lines and patterns on charts. Strategies are used to develop and back test trading strategies. An indicator might be used by a trader looking to better understand the current price movements of a particular asset. A strategy might be developed to take advantage of a particular market movement or opportunity.

The free version of TradingView allows you to have up to 3 indicators on a chart at any one time. There are paid versions available as well. The Pro version allows up to 5 indicators @ $15/month and the Pro+ version up to 10 indicators @ $30/month. The paid versions also have a lot of additional features.

Check the TradingView | Go Pro Page for details on the split-screen/alerts/features and current prices.

Your First Pine Script Overlay

Let’s look at some example code for an indicator to get stuck in.

//@version=5
indicator('First Pine Script', overlay=true)
fast = ta.sma(close, 24)
slow = ta.sma(close, 200)
plot(fast, color=color.new(color.blue, 0))
plot(slow, color=color.new(color.yellow, 0))

• The first line declares we are using the latest version 4 of pine script.
• The study function declares it’s an indicator, gives it a name and sets it to overlay rather than add a separate window at the bottom of the chart.
• We then set two variables using the built in sma() function (simple moving average). We set the fast variable to a moving average with a period of 24 and the slow variable to a period of 200. This will look back and calculate the average of the last 24 and 200 closing prices for each data point.
• Finally we use the plot() function to print these on to the chart with different colours.

Try opening up the pine editor, adding this in and then clicking “add to chart”. You should see two lines printed on your chart for the moving averages.

Pine Script Basics

This is half introduction, half cheat sheet to get up to speed as quickly as possible before we go through some more in depth examples. It assumes some basic programming knowledge in other languages.

Pine script at it’s core just takes in time series data, passes that data through functions and outputs it as a strategy or indicator.

Functions can either be user specified or fortunately pine script comes with the vast majority of functions you’ll likely need built in. To get the simple moving average for the last 14 bar closes you can use:
sma1 = ta.sma(close,14)

Data sources or inputs are in the series format and generally available for:
open, high, low, close, volume, time

You can access the previous value in a series using the format:
close[-1]

UPDATE 10th April 2021
Pine script has introduced a new function to allow for variables to be stored between candles. You can now use varip to keep running counts and retain data across each execution or candle:
varip int count = 0

Most indicators will be customisable without digging into the code. This is done by adjusting the inputs using the little cog next to the indicator name (hover mouse over towards the top left of the chart). The code for setting variables based on inputs looks like this:
myInput1 = input(title=”Click To Turn Off”, type=input.bool, defval=true)
myInput2 = input(title=”Chance Of Success(%)”, type=input.float, defval=1, minval=1, step=0.1)
myInput3 = input(title=”Choose An Option”, defval=”A”, options=[“A”, “B”, “C”])

As default pine script will execute at the close of every candle as opposed to on each tick or price movement. To change this set the following:
calc_on_every_tick=true

Alerts can be used to send a notification or to send trades to an external API. Paid plans come with server-side alerts which can be setup to send out a message without needing to be logged in.
alert(“Wake Up”, alert.freq_once_per_bar_close)

The following data types are available:
int = integer or whole number
float = number with decimal point
bool = boolean (true or false)
color = a standard color which we use a RGBA (red, green,blue,alpha) hex format similar to CSS #FF003399
string = a line of text
line = a line on a chart
hline = a horizontal line on a chart
plot = a line or diagram on a chart
array = a data format like [“a”,”b”,”c”]

Standard operators include:
+ – * / % < <= >= > == != not and or

These can be used in statements which use a double space indented layout:
if close >= open
doSomething()

Statements can be combined and used in line. This is useful when adding filters and you want to check multiple attributes before executing a trade:
FilterOK = false
Filter1 = close > open
Filter2 = rising(volume,1)
FilterOK := Filter1 and Filter2

You can plot a line by specifying the price and any options
plot(priceVariable, color=color.yellow)

You can place a shape on a chart using the plotShape() function:
plotshape(true, style=shape.flag, color=test ? color.green : color.red)

Shapes available are:
shape.xcross, shape.cross, shape.circle, shape.triangleup, shape.triangledown, shape.flag, shape.arrowup, shape.arrowdown, shape.square, shape.diamond, shape.labelup, shape.labeldown

If you want to access or round then you’ll often want to use the current tick size for the data set which is stored in:
syminfo.mintick

Pine Script Built In Functions

Pine scripts built in functions are great and make testing and developing strategies quicker and more efficient. There are hundreds of built in functions but these are the ones I find most useful when developing strategies.

Standard Built In Functions

These are standard functions that you’ll be using a lot to when developing in pine script. For the most part you pass in data and a resulting value is passed back.

five = sqrt(25)

Time Series Built In Functions

These are slightly different functions that you can use to pass in series data such as the daily close or high and a data length or look back period to calculate a moving average or some other value based on that data.

topPriceExample = highest(close,5)

Creating A Pine Script Trading Strategy

OK now everyone is up to speed let’s get started with create a basic moving average cross over strategy.

//@version=5
strategy('Pine Script Tutorial Example Strategy 1', overlay=true, initial_capital=1000, default_qty_value=100, default_qty_type=strategy.percent_of_equity)
fastEMA = ta.ema(close, 24)
slowEMA = ta.ema(close, 200)
goLongCondition1 = ta.crossover(fastEMA, slowEMA)
timePeriod = time >= timestamp(syminfo.timezone, 2020, 12, 15, 0, 0)
notInTrade = strategy.position_size <= 0
if goLongCondition1 and timePeriod and notInTrade
    stopLoss = low * 0.97
    takeProfit = high * 1.12
    strategy.entry('long', strategy.long)
    strategy.exit('exit', 'long', stop=stopLoss, limit=takeProfit)
plot(fastEMA, color=color.new(color.blue, 0))
plot(slowEMA, color=color.new(color.yellow, 0))

• So we start by setting the pine script version and a name for our strategy and setting overlay=true to put any drawings on top of the chart. Note that we use the strategy function instead of the study function to define a strategy.
• We set the initial capital to $1000 and default quantity to 100% of capital for backtesting within this strategy() function.
• We then move on to calculate a fast (24 candle) and slow (200 candle) exponential moving average. This is going to be using the hourly time frame so we have an average 24hr price and a average 200hr price.
• The goLongCondition1 variable is set to true or false depending if there is a cross over of the fast and slow moving averages
• This is a trend following strategy so I only want to test it from the start of the most recent bull run. We set the sinceBullRun variable to true if the date is later than the 15th December 2020
• We set notInTrade to true if we are not currently in a trade using the strategy.position_size built in variable
• if goLongCondition1, timePeriod and notInTrade are all true, we continue to the indented code
• A stop loss is set to 3% below the hourly low, a take profit is set to 12% above the daily high
• strategy.entry is used to take out a long position effectively purchasing the underlying asset.
• strategy.exit is used to set the previously declared stopLoss and takeProfit levels
• Finally we will plot the fastEMA and slowEMA values on the chart so we can better visualise what the strategy is doing.

Backtesting Pine Script Strategies

So how does this simple moving average cross over strategy perform? When lambo? To find out we use TradingView’s StrategyTest application.

Go in to TradingView and search for asset BTCUSD, set the time frame to 1 hour, copy and paste the strategy from the previous example, click “Add To Chart”, then go into the StrategyTest tab and you should be presented with something like this:

As you can see this is performing quite well. We have a net profit of 35% which is not to be sniffed at. However when you compare it to a buy and hold strategy which returns over 50% it’s starting to look less optimal.

Using the chart you can see that there’s large sections of this bull run where we don’t have exposure and it’s taking out positions at points where we are getting stopped out quite frequently.

So what can we do to improve this strategy?

The first thing I would do is get it to execute trades whenever we are above the slow moving average rather than rely on a specific cross over point. We effectively want to be long when Bitcoin is trending up and then sell at the first signs of trouble but without getting stopped out so frequently that the strategy gets chopped to pieces.

I would also add a second condition to both the entry and exit. We want the market momentum to be in our favour whenever executing a trade and we don’t want to exit a position if it’s already turned and trending back up. One simple trick I’ve found works quite effectively for this is comparing the simple moving average with the exponential moving average for the same period. The exponential moving average puts more weight on recent data so when compared to the sma which is just the mean, it will therefore show the most recent market direction.

The other thing I’d modify is the stop-loss, to use average true range rather than a fixed percentage which will be more dynamic in volatile conditions. Let’s take a look at what this modified code looks like:

//@version=5
strategy('Pine Script Tutorial Example Strategy 2', overlay=true, shorttitle='PSTES2', initial_capital=1000, default_qty_value=100, default_qty_type=strategy.percent_of_equity, commission_value=0.025)
fastPeriod = input(title='Fast MA', defval=24)
slowPeriod = input(title='Slow MA', defval=200)
fastEMA = ta.ema(close, fastPeriod)
fastSMA = ta.sma(close, fastPeriod)
slowEMA = ta.ema(close, slowPeriod)
atr = ta.atr(14)
goLongCondition1 = fastEMA > fastSMA
goLongCondition2 = fastEMA > slowEMA
exitCondition1 = fastEMA < fastSMA
exitCondition2 = close < slowEMA
inTrade = strategy.position_size > 0
notInTrade = strategy.position_size <= 0
timePeriod = time >= timestamp(syminfo.timezone, 2020, 12, 15, 0, 0)
if timePeriod and goLongCondition1 and goLongCondition2 and notInTrade
    strategy.entry('long', strategy.long, when=notInTrade)
    stopLoss = close - atr * 3
    strategy.exit('exit', 'long', stop=stopLoss)
if exitCondition1 and exitCondition2 and inTrade
    strategy.close(id='long')
plot(fastEMA, color=color.new(color.blue, 0))
plot(slowEMA, color=color.new(color.yellow, 0))
bgcolor(notInTrade ? color.red : color.green, transp=90)

• I’ve also added a commission value of 0.025 in the strategy set up at the top to allow for trading fees.
• I’ve added customisable fastPeriod, slowPeriod values for the moving averages using the input() function.
• And I’ve changed the background colour in the last line to display red or green depending on if we are in a trade or not.

Copy and paste this into TradingView with the 1HR BTCUSD chart and it will look something like this:

This is much more like how I would want to trade this market moving forwards. You can see from the green and red backgrounds that we are capturing the majority of the upwards momentum and avoiding some of the down trends. But more importantly it closes the position early enough so that if there was a big crash we wouldn’t lose the farm.

The return is 194% which is just slightly above a buy and hold strategy. I’d expect in production it would be roughly equal or even below a buy and hold strategy if the market continues rising. This is because the algo has been shaped, to a certain extent, by past data.

The Sharpe ratio however is improved because the risk adjusted returns on this type of strategy has improved. This strategy gives you exposure to Bitcoin gains in a trending market and gets you out before any major market crashes, where were you in 2017-18?! 😒. There’s a lot of value in capturing gains while avoiding major downturns which fitted moving average strategies aim to realise.

As soon as the market dips beyond the 200hr moving average line the position is closed preserving capital. This is exactly what I want during the mid to later stages of a parabolic bull market. If the market stopped trending up and started moving sideways for a significant amount of time this strategy would get destroyed. You’d be effectively buying high and selling low, a mean reversion strategy would be much more appropriate in that type of market conditions. In fast trending markets though this provides a simple but effective, risk-averse, trend following trading strategy.

Here are some more example code snippets that can be used to filter trades and develop strategies.

// Open Trade Filters
openCondition1 = (ta.rsi(close,14) > 40)
openCondition2 = ((strategy.closedtrades - strategy.closedtrades[24]) < 1)

// Exit Conditions
exitCondition1 = ta.ema(close, 50) < ta.ema(close, 200)
exitCondition2 = close < close[1] * 0.95
if exitCondition1 or exitCondition2
    strategy.close(id='long')

// Smoothing
smoothed = close + 0.5 * (close[1] - close)

// Adaptive Colors
line_color = color.green
if close < close[1]
    line_color := color.red
    line_color
plot(close, color=line_color)
bgcolor(line_color, transp=90)

How & Why Publish TradingView Pine Scripts

To publish a script publicly it needs to be original, useful and it needs a good description to let other traders understand what it is. This is an except from the TradingView documentation:

“Your script’s description is your opportunity to explain to the community how it is original and can be useful. If your description does not allow TradingView moderators to understand how your script is original and potentially useful, it will be moderated.”

My moving average script wouldn’t be approved because there are already a million and one other scripts just like it in the public library. This brings me to an important point about expectations for public work.

If someone has a low time frame delta neutral strategy that is consistently profitable they aren’t going to publish it, they aren’t going to sell it and they aren’t going to need your money to execute it. Things like that do exist but they are rare, extremely hard to create, don’t last forever and are highly profitable.

If someone had a strategy that makes just 5% a day consistently they could generate a return of $50 billion from an initial investment of $1000 in a year. This is obviously unrealistic and what’s more unrealistic is that they’ll sell you this strategy for just $19/month.

Having said that there are some very smart developers who publish open source algorithms. I think there is value in reviewing others work and then incorporating their ideas and methods in your own strategies and algos.

The collaboration and industry acknowledgement aspect is why many algorithms which could be successful in specific market conditions are published. There is a community of traders who use TradingView regularly and publishing original work which adds value can be beneficial to the developer and the community.

If you would like to publish your work you can click on the “Publish Script” tab within pine editor which will bring up the following interface:

Trade Execution & Strategy Deployment

TradingView has a broker panel where you can connect your account directly to one of the following brokers:

• Oanda
• TradeStation
• Gemini
• Capital.com
• FXCM
• Saxo

TradingView is great for visualising and developing trading strategies but for execution, in my opinion, we need something more robust. If the markets get busy and TradingView goes down we need our strategies to still execute.

For this reason I’d recommend migrating pine script over to either NodeJS or Python and executing via official exchange/broker API’s. Production code can be executed on a dedicated server (with a fallback server if volume permits it) to provide complete control over the process.

On a high timeframe strategy where execution efficiency doesn’t matter too much then it could well be possible to work with one of the brokers above but most quant traders will run their own bots and this is the approach I’d recommend.

If I wanted to execute the strategy discussed above I wouldn’t actually want all my funds on an exchange account buying and selling spot BTC. I would probably flip the strategy so that it opened a short position on a perpetual futures trading contract whenever the price fell below the 200hr moving average and other filters were met.

This would in effect hedge my current long position with a leveraged trade so that I’d only need to keep a reduced amount of capital on exchange for collateral. The rest of my funds could be held in a cold storage wallet and trade them only to balance out the position by closing the perp and selling spot at a later date.

So for example if my cryptocurrency portfolio had 1BTC and 20ETH in it I’d add 5 ETH and 0.25 BTC to an exchange like FTX to use as collateral. I’d then use an API to execute a leveraged short position for 1BTC and 20ETH whenever the strategy dictated.

This is what the code for something like that would look like:-

const request = require('request');
const crypto = require('crypto');
const ftx = require('lib/exchanges/ftx.js');

const account = {
  apiKey: `abc123`,
  apiSecret: `abc345`,
  subAccount: `HEDGE1`,
  inTrade: false,
}

const calculateSMA = (arr, range=false) => {
  if (!range) range = arr.length;
  let sum = 0;
  if (range > arr.length) range = arr.length;
  for (let ii = arr.length - range; ii < arr.length; ii++){
    sum += arr[ii];
  }
  return sum / range;
}

const calculateEMA = (arr,range=false) => {
  if (!range) range = arr.length;
  const yma = arr.reduce((p,n,i) => i ? p.concat(2*n/(range+1) + p[p.length-1]*(range-1)/(range+1)) : p, [arr[0]]);
  return yma[yma.length-1];
}

const checkStrategy = async () => {
  const res1Promise = fetch(`https://ftx.com/api/markets/BTC-PERP/candles?resolution=3600&limit=200`).catch(err => utils.errorLog(err));
  const res1 = await res1Promise;
  const ftxCandles = await res1.json().catch(err => utils.errorLog(err));
  const priceArray = [];
  ftxCandles.result.forEach((min,i) => {
    priceArray.push(min.close);
  });
  const fastEMA = calculateEMA(priceArray.slice(-24));
  const fastSMA = calculateSMA(priceArray.slice(-24));
  const slowEMA = calculateEMA(priceArray.slice(-200));
  const hedgeCondition1 = (fastEMA < fastSMA);
  const hedgeCondition2 = (fastEMA < slowEMA);
  if (hedgeCondition1 && hedgeCondition2 && account.inTrade === false) {
    account.inTrade = true;
    ftx.Order('SELL', 'BTC-PERP', 1, fastEMA * 0.95, account);
    // Send an alarm notification and do logic to confirm trade went through
  }
}

setInterval(() => {
  checkStrategy();
}, 60000);

This is untested and nowhere near production ready but it provides a couple of useful JavaScript functions for calculating simple and exponential moving averages. It also shows how you can grab live data from an exchange and use this to make trading decisions.

In production I would have infrastructure like this set up.

Check the TradingView | Go Pro Page