Inizia

Cerca negli script per "alert"

AlertoJack AlertoJack v0.1a coded by Bogdan Vaida This indicator was created to provide easily defined alerts on multiple symbols. It's still POC code. Usage: - Add it on any coin, - The chart timeframe will be the timeframe for the alerts; - Configure it with the symbols you want to be alerted on, - Add the prices to be alerted for, - Use Add Alert -> condition AlertoJack -> "Any alert() function call" - Check the Alerts log. Notes: - Alert happens when candle crosses the price. - Because of how Trading View functions, if you modify the indicator settings you'll need to add the alerts again (because an alert uses the code version it was created from). - The alert runs once per current bar's timeframe (e.g. once per minute if you're on the 1m).
Indicatore Pine Script®
di vaidab
2
alertsLibrary "alerts" The library provides options to run alert() calls in loop without worrying about limitations of frequency options. When an alert statement is called within a loop, it will fire just once per bar irrespective of how many iterations allowed when fequency is set to alert.freq_once_per_bar or alert.freq_once_per_bar_close it will fire continuously till it breaks when frequency is set to alert.freq_all The function helps overcome this issue by using varip key array which resets on every bar method alert(message, key)   Enhanced alert which can be used in loops   Namespace types: series string, simple string, input string, const string   Parameters:      message (string) : Alert message to be fired      key (string) : Key to be checked to avoid repetitive alerts   Returns: array containing id of already fired alerts method updateAlertTemplate(this, template)   Updates alert template with given keys and values   Namespace types: map   Parameters:      this (map) : map containing key value pair      template (string) : Alert message template   Returns: updated alert message
Libreria Pine Script®
di Trendoscope
5
Alerts█  OVERVIEW This library is a Pine Script™ programmers tool that provides functions to simplify the creation of compound conditions and alert messages. With these functions, scripts can use comma-separated "string" lists to specify condition groups from arbitrarily large "bool" arrays , offering a convenient way to provide highly flexible alert creation to script users without requiring numerous inputs in the "Settings/Inputs" menu. █  CONCEPTS Compound conditions Compound conditions are essentially groups of two or more conditions, where each required condition must occur to produce a `true` result. Traders often combine conditions, including signals from various indicators, to drive and reinforce trade decisions. Similarly, programmers use compound conditions in logical operations to create scripts that respond dynamically to groups of events. Condition conundrum Providing flexible condition combinations to script users for signals and alerts often poses a significant challenge: input complexity . Conventionally, such flexibility comes at the cost of an extensive list of separate inputs for toggling individual conditions and customizing their properties, often resulting in complicated input menus that are difficult for users to navigate effectively. Furthermore, managing all those inputs usually entails tediously handling many extra variables and logical expressions, making such projects more complex for programmers. Condensing complexity This library introduces a technique using parsed strings to reference groups of elements from "bool" arrays , helping to simplify and streamline the construction of compound conditions and alert messages. With this approach, programmers can provide one or more "string" inputs in their scripts where users can list numbers corresponding to the conditions they want to combine. For example, suppose you have a script that creates alert triggers based on a combination of up to 20 individual conditions, and you want to make inputs for users to choose which conditions to combine. Instead of creating 20 separate checkboxes in the "Settings/Inputs" tab and manually adding associated logic for each one, you can store the conditional values in arrays, make one or more "string" inputs that accept values listing the array item locations (e.g., "1,4,8,11"), and then pass the inputs to these functions to determine the compound conditions formed by the specified groups. This approach condenses the input space, improving navigability and utility. Additionally, it helps provide high-level simplicity to complex conditional code, making it easier to maintain and expand over time. █  CALCULATIONS AND USE This library contains three functions for evaluating compound conditions: `getCompoundConditon()`, `getCompoundConditionsArray()`, and `compoundAlertMessage()`. Each function has two overloads that evaluate compound conditions based on groups of items from one or two "bool" arrays . The sections below explain the functions' calculations and how to use them. Referencing conditions using "string" index lists Each function processes "string" values containing comma-separated lists of numerals representing the indices of the "bool" array items to use in its calculations (e.g., "4, 8, 12"). The functions split each supplied "string" list by its commas, then iterate over those specified indices in the "bool" arrays to determine each group's combined `true` or `false` state. For convenience, the numbers in the "string" lists can represent zero-based indices (where the first item is at index 0) or one-based indices (where the first item is at index 1), depending on the function's `zeroIndex` parameter. For example, an index list of "0, 2, 4" with a `zeroIndex` value of `true` specifies that the condition group uses the first , third , and fifth "bool" values in the array, ignoring all others. If the `zeroIndex` value is `false`, the list "1, 3, 5" also refers to those same elements. Zero-based indexing is convenient for programmers because Pine arrays always use this index format. However, one-based indexing is often more convenient and familiar for script users, especially non-programmers. Evaluating one or many condition groups The `getCompoundCondition()` function evaluates singular condition groups determined by its `indexList` parameter, returning `true` values whenever the specified array elements are `true`. This function is helpful when a script has to evaluate specific groups of conditions and does not require many combinations. In contrast, the `getCompoundConditionsArray()` function can evaluate numerous condition groups, one for each "string" included in its `indexLists` argument. It returns arrays containing `true` or `false` states for each listed group. This function is helpful when a script requires multiple condition combinations in additional calculations or logic. The `compoundAlertMessage()` function is similar to the `getCompoundConditionsArray()` function. It also evaluates a separate compound condition group for each "string" in its `indexLists` array, but it returns "string" values containing the marker (name) of each group with a `true` result. You can use these returned values as the `message` argument in alert() calls, display them in labels and other drawing objects, or even use them in additional calculations and logic. Directional condition pairs The first overload of each function operates on a single `conditions` array, returning values representing one or more compound conditions from groups in that array. These functions are ideal for general-purpose condition groups that may or may not represent direction information. The second overloads accept two arrays representing upward and downward conditions separately: `upConditions` and `downConditions`. These overloads evaluate opposing directional conditions in pairs (e.g., RSI is above/below a level) and return upward and downward condition information separately in a tuple . When using the directional overloads, ensure the `upConditions` and `downConditions` arrays are the same size, with the intended condition pairs at the same indices . For instance, if you have a specific upward RSI condition's value at the first index in the `upConditions` array, include the opposing downward RSI condition's value at that same index in the `downConditions` array. If a condition can apply to both directions (e.g., rising volume), include its value at the same index in both arrays. Group markers To simplify the generation of informative alert messages, the `compoundAlertMessage()` function assigns "string" markers to each condition group, where "marker" refers to the group's name. The `groupMarkers` parameter allows you to assign custom markers to each listed group. If not specified, the function generates default group markers in the format "M", where "M" is short for "Marker" and "" represents the group number starting from 1. For example, the default marker for the first group specified in the `indexLists` array is "M1". The function's returned "string" values contain a comma-separated list with markers for each activated condition group (e.g., "M1, M4"). The function's second overload, which processes directional pairs of conditions, also appends extra characters to the markers to signify the direction. The default for upward groups is "▲" (e.g., "M1▲") and the default for downward ones is "▼" (e.g., "M1▼"). You can customize these appended characters with the `upChar` and `downChar` parameters. Designing customizable alerts We recommend following these primary steps when using this library to design flexible alerts for script users:  1. Create text inputs for users to specify comma-separated lists of conditions with the input.string() or input.text_area() functions, and then collect all the input values in a "string" array . Note that each separate "string" in the array will represent a distinct condition group.  2. Create arrays of "bool" values representing the possible conditions to choose from. If your script will process pairs of upward and downward conditions, ensure the related elements in the arrays align at the same indices.  3. Call `compoundAlertMessage()` using the arrays from steps 1 and 2 as arguments to get the alert message text. If your script will use the text for alerts only, not historical display or calculation purposes, the call is necessary only on realtime bars .  4. Pass the calculated "string" values as the `message` argument in alert() calls. We recommend calling the function only when the "string" is not empty (i.e., `messageText != ""`). To avoid repainting alerts on open bars, use barstate.isconfirmed in the condition to allow alert triggers only on each bar's close .  5. Test the alerts. Open the "Create Alert" dialog box and select "Any alert() function call" in the "Condition" field. It is also helpful to inspect the strings with Pine Logs . NOTE: Because the techniques in this library use lists of numbers to specify conditions, we recommend including a tooltip for the "string" inputs that lists the available numbers and the conditions they represent. This tooltip provides a legend for script users, making it simple to understand and utilize. To create the tooltip, declare a "const string" listing the options and pass it to the `input.*()` call's `tooltip` parameter. See the library's example code for a simple demonstration. █  EXAMPLE CODE This library's example code demonstrates one possible way to offer a selection of compound conditions with "string" inputs and these functions. It uses three input.string() calls, each accepting a comma-separated list representing a distinct condition group. The title of each input represents the default group marker that appears in the label and alert text. The code collects these three input values in a `conditionGroups` array for use with the `compoundAlertMessage()` function. In this code, we created two "bool" arrays to store six arbitrary condition pairs for demonstration:  1. Bar up/down: The bar's close price must be above the open price for upward conditions, and vice versa for downward conditions.  2. Fast EMA above/below slow EMA : The 9-period Exponential Moving Average of close prices must be above the 21-period EMA for upward conditions, and vice versa for downward conditions.  3. Volume above average : The bar's volume must exceed its 20-bar average to activate an upward or downward condition.  4. Volume rising : The volume must exceed that of the previous bar to activate an upward or downward condition.  5. RSI trending up/down : The 14-period Relative Strength Index of close prices must be between 50 and 70 for upward conditions, and between 30 and 50 for downward conditions.  6. High volatility : The 7-period Average True Range (ATR) must be above the 40-period ATR to activate an upward or downward condition. We included a `tooltip` argument for the third input.string() call that displays the condition numbers and titles, where 1 is the first condition number. The `bullConditions` array contains the `true` or `false` states of all individual upward conditions, and the `bearConditions` array contains all downward condition states. For the conditions that filter either direction because they are non-directional, such as "High volatility", both arrays contain the condition's `true` or `false` value at the same index. If you use these conditions alone, they activate upward and downward alert conditions simultaneously. The example code calls `compoundAlertMessage()` using the `bullConditions`, `bearConditions`, and `conditionGroups` arrays to create a tuple of strings containing the directional markers for each activated group. On confirmed bars, it displays non-empty strings in labels and uses them in alert() calls. For the text shown in the labels, we used str.replace_all() to replace commas with newline characters, aligning the markers vertically in the display. Look first. Then leap. █  FUNCTIONS This library exports the following functions: getCompoundCondition(conditions, indexList, minRequired, zeroIndex)   (Overload 1 of 2) Determines a compound condition based on selected elements from a `conditions` array.   Parameters:      conditions (array) : (array) An array containing the possible "bool" values to use in the compound condition.      indexList (string) : (series string) A "string" containing a comma-separated list of whole numbers representing the group of `conditions` elements to use in the compound condition. For example, if the value is `"0, 2, 4"`, and `minRequired` is `na`, the function returns `true` only if the `conditions` elements at index 0, 2, and 4 are all `true`. If the value is an empty "string", the function returns `false`.      minRequired (int) : (series int) Optional. Determines the minimum number of selected conditions required to activate the compound condition. For example, if the value is 2, the function returns `true` if at least two of the specified `conditions` elements are `true`. If the value is `na`, the function returns `true` only if all specified elements are `true`. The default is `na`.      zeroIndex (bool) : (series bool) Optional. Specifies whether the `indexList` represents zero-based array indices. If `true`, a value of "0" in the list represents the first array index. If `false`, a `value` of "1" represents the first index. The default is `true`.   Returns: (bool) `true` if `conditions` elements in the group specified by the `indexList` are `true`, `false` otherwise. getCompoundCondition(upConditions, downConditions, indexList, minRequired, allowUp, allowDown, zeroIndex)   (Overload 2 of 2) Determines upward and downward compound conditions based on selected elements from `upConditions` and `downConditions` arrays.   Parameters:      upConditions (array) : (array) An array containing the possible "bool" values to use in the upward compound condition.      downConditions (array) : (array) An array containing the possible "bool" values to use in the downward compound condition.      indexList (string) : (series string) A "string" containing a comma-separated list of whole numbers representing the `upConditions` and `downConditions` elements to use in the compound conditions. For example, if the value is `"0, 2, 4"` and `minRequired` is `na`, the function returns `true` for the first value only if the `upConditions` elements at index 0, 2, and 4 are all `true`. If the value is an empty "string", the function returns ` `.      minRequired (int) : (series int) Optional. Determines the minimum number of selected conditions required to activate either compound condition. For example, if the value is 2, the function returns `true` for its first value if at least two of the specified `upConditions` elements are `true`. If the value is `na`, the function returns `true` only if all specified elements are `true`. The default is `na`.      allowUp (bool) : (series bool) Optional. Controls whether the function considers upward compound conditions. If `false`, the function ignores the `upConditions` array, and the first item in the returned tuple is `false`. The default is `true`.      allowDown (bool) : (series bool) Optional. Controls whether the function considers downward compound conditions. If `false`, the function ignores the `downConditions` array, and the second item in the returned tuple is `false`. The default is `true`.      zeroIndex (bool) : (series bool) Optional. Specifies whether the `indexList` represents zero-based array indices. If `true`, a value of "0" in the list represents the first array index. If `false`, a value of "1" represents the first index. The default is `true`.   Returns: ( ) A tuple containing two "bool" values representing the upward and downward compound condition states, respectively. getCompoundConditionsArray(conditions, indexLists, zeroIndex)   (Overload 1 of 2) Creates an array of "bool" values representing compound conditions formed by selected elements from a `conditions` array.   Parameters:      conditions (array) : (array) An array containing the possible "bool" values to use in each compound condition.      indexLists (array) : (array) An array of strings containing comma-separated lists of whole numbers representing the `conditions` elements to use in each compound condition. For example, if an item is `"0, 2, 4"`, the corresponding item in the returned array is `true` only if the `conditions` elements at index 0, 2, and 4 are all `true`. If an item is an empty "string", the item in the returned array is `false`.      zeroIndex (bool) : (series bool) Optional. Specifies whether the "string" lists in the `indexLists` represent zero-based array indices. If `true`, a value of "0" in a list represents the first array index. If `false`, a value of "1" represents the first index. The default is `true`.   Returns: (array) An array of "bool" values representing compound condition states for each condition group. An item in the array is `true` only if all the `conditions` elements specified by the corresponding `indexLists` item are `true`. Otherwise, the item is `false`. getCompoundConditionsArray(upConditions, downConditions, indexLists, allowUp, allowDown, zeroIndex)   (Overload 2 of 2) Creates two arrays of "bool" values representing compound upward and downward conditions formed by selected elements from `upConditions` and `downConditions` arrays.   Parameters:      upConditions (array) : (array) An array containing the possible "bool" values to use in each upward compound condition.      downConditions (array) : (array) An array containing the possible "bool" values to use in each downward compound condition.      indexLists (array) : (array) An array of strings containing comma-separated lists of whole numbers representing the `upConditions` and `downConditions` elements to use in each compound condition. For example, if an item is `"0, 2, 4"`, the corresponding item in the first returned array is `true` only if the `upConditions` elements at index 0, 2, and 4 are all `true`. If an item is an empty "string", the items in both returned arrays are `false`.      allowUp (bool) : (series bool) Optional. Controls whether the function considers upward compound conditions. If `false`, the function ignores the `upConditions` array, and all elements in the first returned array are `false`. The default is `true`.      allowDown (bool) : (series bool) Optional. Controls whether the function considers downward compound conditions. If `false`, the function ignores the `downConditions` array, and all elements in the second returned array are `false`. The default is `true`.      zeroIndex (bool) : (series bool) Optional. Specifies whether the "string" lists in the `indexLists` represent zero-based array indices. If `true`, a value of "0" in a list represents the first array index. If `false`, a value of "1" represents the first index. The default is `true`.   Returns: ( ) A tuple containing two "bool" arrays: - The first array contains values representing upward compound condition states determined using the `upConditions`. - The second array contains values representing downward compound condition states determined using the `downConditions`. compoundAlertMessage(conditions, indexLists, zeroIndex, groupMarkers)   (Overload 1 of 2) Creates a "string" message containing a comma-separated list of markers representing active compound conditions formed by specified element groups from a `conditions` array.   Parameters:      conditions (array) : (array) An array containing the possible "bool" values to use in each compound condition.      indexLists (array) : (array) An array of strings containing comma-separated lists of whole numbers representing the `conditions` elements to use in each compound condition. For example, if an item is `"0, 2, 4"`, the corresponding marker for that item appears in the returned "string" only if the `conditions` elements at index 0, 2, and 4 are all `true`.      zeroIndex (bool) : (series bool) Optional. Specifies whether the "string" lists in the `indexLists` represent zero-based array indices. If `true`, a value of "0" in a list represents the first array index. If `false`, a value of "1" represents the first index. The default is `true`.      groupMarkers (array) : (array) Optional. If specified, sets the marker (name) for each condition group specified in the `indexLists` array. If `na`, the function uses the format `"M"` for each group, where "M" is short for "Marker" and `` represents the one-based index for the group (e.g., the marker for the first listed group is "M1"). The default is `na`.   Returns: (string) A "string" containing a list of markers corresponding to each active compound condition. compoundAlertMessage(upConditions, downConditions, indexLists, allowUp, allowDown, zeroIndex, groupMarkers, upChar, downChar)   (Overload 2 of 2) Creates two "string" messages containing comma-separated lists of markers representing active upward and downward compound conditions formed by specified element groups from `upConditions` and `downConditions` arrays.   Parameters:      upConditions (array) An array containing the possible "bool" values to use in each upward compound condition.      downConditions (array) An array containing the possible "bool" values to use in each downward compound condition.      indexLists (array) An array of strings containing comma-separated lists of whole numbers representing the `upConditions` and `downConditions` element groups to use in each compound condition. For example, if an item is `"0, 2, 4"`, the corresponding group marker for that item appears in the first returned "string" only if the `upConditions` elements at index 0, 2, and 4 are all `true`.      allowUp (bool) Optional. Controls whether the function considers upward compound conditions. If `false`, the function ignores the `upConditions` array and returns an empty "string" for the first tuple element. The default is `true`.      allowDown (bool) Optional. Controls whether the function considers downward compound conditions. If `false`, the function ignores the `downConditions` array and returns an empty "string" for the second tuple element. The default is `true`.      zeroIndex (bool) Optional. Specifies whether the "string" lists in the `indexLists` represent zero-based array indices. If `true`, a value of "0" in a list represents the first array index. If `false`, a value of "1" represents the first index. The default is `true`.      groupMarkers (array) Optional. If specified, sets the name (marker) of each condition group specified in the `indexLists` array. If `na`, the function uses the format `"M"` for each group, where "M" is short for "Marker" and `` represents the one-based index for the group (e.g., the marker for the first listed group is "M1"). The default is `na`.      upChar (string) Optional. A "string" appended to all group markers for upward conditions to signify direction. The default is "▲".      downChar (string) Optional. A "string" appended to all group markers for downward conditions to signify direction. The default is "▼".   Returns: ( ): A tuple of "string" values containing lists of markers corresponding to active upward and downward compound conditions, respectively.
Libreria Pine Script®
di PineCoders
2
alert!!!!alerts work over values of plots on the chart. could not find a way to add an alert when a strategy is triggered. so, i created an alert chart that uses the same conditions as the strategy(i published the example strat in my previous script). an alert chart should be mostly zero, but when the strat fires up, the alert = 1, and when the strat fires down, alert = -1. this way it's easy to check the chart for alerts. but, if i'm looking at the cahrt and see the strat's arrows, what's the point? well, the point is that we can add alerts to this chart, to send emails, popup on screen, start screaming, whatever. so that now i don't actually need the chart in screen all the time :) since this alert chart behaves so nice, values = to add an alert is just setting it's value >0.5, or value > -0.5 :) note: aloert is not actually in the script, it has to be added manually using the button. if Pine has a way to add alerts programatically, i couldn't find it
Indicatore Pine Script®
di deimosaffair
3
Alert Sender Library [TradingFinder]Library "AlertSenderLibrary_TradingFinder" 🔵 Introduction The "Alert Sender Library" is a management and production program for "Alert Messages" that enables the creation of unique messages for any type of signal generated by indicators or strategies. These messages include the direction of the signal, symbol, time frame, the date and time the condition was triggered, prices related to the signal, and a personal message from you. To make better and more optimal use of this "library", you should carefully study " Key Features" and "How to Use". 🔵 Key Features Automatic Detection of Appropriate Type : Using two parameters, "AlertType" and "DetectionType", which you must enter at the beginning into the "AlertSender" function, the type of the alert message is determined. For example, if you select one of the "DetectionType"s such as "Order Block Signal", "Signal", and "Setup", your alert type will be chosen based on "Long" and "Short". Whether it's "Long" or "Short" depends on the "AlertType" you have set to either "Bullish" or "Bearish". Automatic Symbol Detection : Whenever you add an alert for a specific symbol, if you want the name of that symbol to be in your message text, you must manually write the name of the symbol in your message. One of the capabilities of the "Alert Sender" is the automatic detection of the symbol and adding it to the message text. Automatic Time Frame Detection : When adding your alert, the "Alert Sender" detects the time frame of the symbol you intend to add the alert for and adds it to the text. This feature is very practical and can prevent traders from making mistakes. For example, a trader might add alerts for a specific symbol using a specific indicator in different time frames, taking the main signal in the 1-hour time frame and only a confirmation signal in the 15-minute time frame. This feature helps to identify in which time frame the signal is set. Detection of Date and Time When the Signal is Triggered : You can have the date and time at the moment the message is sent. This feature has various uses. For example, if you use the Webhook URL feature to send messages to a Telegram channel, there might be issues with alert delivery on your server, causing delays, and you might receive the message when it has lost its validity. With this feature, you can match the sending time of the message from TradingView with the receipt time in your messenger and detect if there is a delay in message delivery. Important : You can also set the Time Zone you wish to receive the date and time based on. Display of "Key Prices" : Key prices can vary based on the type of signals. For example, when the "DetectionType" is in "Order Block Signal" mode, the key prices are the "Distal" and "Proximal" prices. Or if the "DetectionType" is in "Setup" mode, the key prices are "Entry", "Stop Loss", and "Take Profit". Receipt of Personal "Messages" : You can enter your personal message using "input.string" or "input.text_area" in addition to the messages that are automatically created. Beautiful and Functional Display of Messages : The titles of messages sent by "AlertSender" are displayed using related emojis to prevent mistakes due to visual errors, enhancing beauty. 🔵 How to Use 🟣 Familiarity with Function and Parameters AlertSender(Condition, Alert, AlertName, AlertType, DetectionType, SetupData, Frequency, UTC, MoreInfo, Message, o, h, l, c, Entry, TP, SL, Distal, Proximal)  Parameters:   - Condition (bool)   - Alert (string)   - AlertName (string)   - AlertType (string)   - DetectionType (string)   - SetupData (string)   - Frequency (string)   - UTC (string)   - MoreInfo (string)   - Message (string)   - o (float)   - h (float)   - l (float)   - c (float)   - Entry (float)   - TP (float)   - SL (float)   - Distal (float)   - Proximal (float) To add "Alert Sender Library", you must first add the following code to your script. import TFlab/AlertSenderLibrary_TradingFinder/1 🟣 Parameters "Condition" : This parameter is a Boolean. You need to set it based on the condition that, when met (or fired), you want to receive an alert. The output should be either "true" or "false". "Alert" : This parameter accepts one of two inputs, "On" or "Off". If set to "On", the alarm is active; if "Off", the alarm is deactivated. This input is useful when you have numerous alerts in an indicator or strategy and need to activate only a few of them. "Alert" is a string parameter. Alert = input.string('On', 'Alert', , 'If you turn on the Alert, you can receive alerts and notifications after setting the "Alert".', group = 'Alert') "AlertName" : This is a string parameter where you can enter the name you choose for your alert. AlertName = input.string('Order Blocks Finder ', 'Alert Name', group = 'Alert') "AlertType" : The inputs for this parameter are "Bullish" or "Bearish". If the condition selected in the "Condition" parameter is of a bullish bias, you should set this parameter to "Bullish", and if the condition is of a bearish bias, it should be set to "Bearish". "AlertType" is a string parameter. "DetectionType" : This parameter's predefined inputs include "Order Block Signal", "Signal", "Setup", and "Analysis". You may provide other inputs, but some functionalities, like "Key Price", might be lost. "DetectionType" is a string parameter. "SetupData" : If "DetectionType" is set to "Setup", you must specify "SetupData" as either "Basic" or "Full". In "Basic" mode, only the "Entry" price needs to be defined in the function, and "TP" (Take Profit) and "SL" (Stop Loss) can be any number or NA. In "Full" mode, you need to define "Entry", "SL", and "TP". "Setup" is a string parameter. "Frequency" : This string parameter defines the announcement frequency. Choices include: "All" (activates the alert every time the function is called), "Once Per Bar" (activates the alert only on the first call within the bar), and "Once Per Bar Close" (the alert is activated only by a call at the last script execution of the real-time bar upon closing). The default setting is "Once per Bar". Frequency = input.string('Once Per Bar', 'Message Frequency', , 'The triggering frequency. Possible values are: All (all function calls trigger the alert), Once Per Bar (the first function call during the bar triggers the alert), Per Bar Close (the function call triggers the alert only when it occurs during the last script iteration of the real-time bar, when it closes). The default is alert.freq_once_per_bar.', group = 'Alert') "UTC" : With this parameter, you can set the Time Zone for the date and time of the alert's dispatch. "UTC" is a string parameter and can be set as "UTC-4", "UTC+1", "UTC+9", or any other Time Zone. UTC = input.string('UTC', 'Show Alert time by Time Zone', group = 'Alert') "MoreInfo" : This parameter can take one of two inputs, "On" or "Off", which are strings. Additional information, including "Time" and "Key Price", is included. If set to "On", this information is received; if "Off", it is not displayed in the sent message. MoreInfo = input.string('On', 'Display More Info', , group = 'Alert') "Message" : This parameter captures the user's personal message through an input and displays it at the end of the sent message. It is a string input. MessageBull = input.text_area('Long Position', 'Long Signal Message', group = 'Alert') MessageBear = input.text_area('Short Position', 'Short Signal Message', group = 'Alert') "o" (Open Price): A floating-point number representing the opening price of the candle. This input is necessary when the "DetectionType" is set to "Signal". Otherwise, it can be any number or "na". "h" (High Price): A float variable for the highest price of the candle. Required when "DetectionType" is "Signal"; in other cases, any number or "na" is acceptable. "l" (Low Price): A float representing the lowest price of the candle. This field must be filled if "DetectionType" is "Signal". If not, it can be any number or "na". "c" (Close Price): A floating-point variable indicating the closing price of the candle. Needed for "Signal" type detections; otherwise, it can take any value or "na". "Entry" : A float variable indicating the entry price into a trading setup. This is relevant when "DetectionType" is in "Setup" mode. In other scenarios, it can be any number or "na". It denotes the price at which the trade setup is entered. "TP" (Take Profit): A float that is necessary when "DetectionType" is "Setup" and "SetupData" is "Full". Otherwise, it can be any number or "na". It signifies the price target for taking profits in a trading setup. "SL" (Stop Loss): A float required when "DetectionType" is "Setup" and "SetupData" is "Full". It can be any number or "na" in other cases. This value represents the price at which a stop loss is set to limit losses. "Distal" : A float important for "Order Block Signal" detection. It can be any number or "na" if not in use. This variable indicates the price reaching the distal line of an order block. "Proximal" : A float needed for "Order Block Signal" detection mode. It can take any value or "na" otherwise. It marks the price reaching the proximal line of an order block.
Libreria Pine Script®
di TFlab
Alert on Candle CloseAlert on Candle Close is a simple indicator allowing you to set alerts when a candlestick closes. Instructions for use From the chart window, click on "Indicators" and search for "Alert on Candle Close". Click on "Alert on Candle Close" to add the indicator to your chart. Click on the star icon to add it to your favourites to easily access later. Set your chart timeframe to the timeframe you wish to alert on. For example, to create an alert when a 4h candlestick closes, set your chart to the "4h" timeframe. Hover over the "Alert on Candle Close" indicator which has been added to your chart and click the ellipsis "..." icon, then click "Add alert on Alert on Candle Close" or use the keyboard shortcut "Alt+A" from the chart. In the alert pop-up window, make sure "Condition" is set to "Alert on Candle Close" and "Trigger" is set to "Once Per Bar". Optionally, you can set a custom expiry for the alert, give the alert a name and customise the alert message. You can configure notification settings from the "Notifications" tab. Click "Create" and your alert is set up! Each alert is tied to the timeframe and chart it was created on, so you can change the timeframe or asset and create more alerts by repeating the above process. Note : this indicator is only designed to work with time-based chart types, such as Bars, Candles or Heikin Ashi. It will not work for non-time charts such as Renko. FAQs Why do my alerts sometimes not fire as soon as the candle closes? This is a limitation with Pine Script's execution model. Indicators are calculated whenever a price or volume change occurs i.e. when a new trade happens. For illiquid or slow moving markets, there may be some time between when a candle closes and the next trade, leading to a delay in the alert triggering. The alert will trigger on the next tick of data on the chart. Why can't I create more alerts? TradingView has a limit on the number of active technical alerts you can have based on your membership tier. To configure more alerts, consider upgrading your TradingView plan to a higher tier. See a comparison of TradingView plans at www.tradingview.com My alert only fired once, how can I get it to keep working? When configuring the alert in the alert pop-up window, make sure you set "Trigger" to "Once Per Bar" and "Expiration" to "Open-ended alert".
Indicatore Pine Script®
di SimpleTradingTools
3
Alert Intervals and Delays Framework [BigBitsIO]Simply explained, this script, when modified to each specific use case, can allow you to specify that alert conditions are only checked every X seconds (AKA Intervals - as fast as every single second) and that alerts can not occur quicker than the user-specified delay (in seconds) Explained: - This will work on any resolution, but for the best results/fastest alerts a premium plan with 1s resolution will work best. - Be mindful of which alert option you choose when setting up corresponding alerts. On 1s resolution with alerts once per bar you can get alerts up to every second. - The scan for alerts every X seconds will be when the script can scan, by default every 5th second. If you want it to scan on any and all updates, set it to 1 for 1 second - The delay between alerts will just require than that many seconds have passed since the last alert was fired (whether it was an actual alert in TradingView or just as recognized by this script) - To have a custom alert condition met, do your normal indicator logic and check your conditions during the scanning period after the delay has been met, as marked by comments in the code FAQ - Why is this script useful? - Many people do not want to constantly monitor for alerts, and may only want alerts to trigger at certain times, or after certain periods of time - What is an example? - You want a 1min resolution RSI alert, but you don't want to see it every minute, or only once. - By setting your alert to once per bar, or once per minute on a 1min or less resolution chart you can get alerts only every 2min 30sec for example when setting your delay to 150 (seconds) Warning: Since the scan time and alert times on larger resolutions can not be accessed from previous candles when first added to the chart it should be pretty important that you operate on a chart with a smaller resolution than your delay.
Indicatore Pine Script®
di BigBitsIO
6
Alert(), alertcondition() or strategy alerts?Variety of possibilities offered by PineScript, especially thanks to recent additions, created some confusion. Especially one question repeats quite often - which method to use to trigger alerts? I'm posting this to clarify and give some syntax examples. I'll discuss these 3 methods in chronological order, meaning - in the order they were introduced to PineScript. ALERTCONDITION() - it is a function call, which can be used only in study-type script. Since years ago, you could create 2 types of a script: strategy and study. First one enables creating a backtest of a strategy. Second was to develop scripts which didn't require backtesting and could trigger alerts. alertcondition() calls in strategy-type scripts were rejected by Pine compiler. On the other hand compiling study-type scripts rejected all strategy...() calls. That created difficulties, because once you had a nice and backtested strategy, you had to rip it off from all strategy...() function calls to convert your script to study-type so you could produce alerts. Maintenance of two versions of each script was necessary and it was painful. "STRATEGY ALERTS" were introduced because of alertcondition() pains. To create strategy alert, you need to click "Add alert" button inside Strategy Tester (backtester) and only there. Alerts set-up this way are bound with the backtester - whenever backtester triggers an order, which is visible on the chart, alert is also fired. And you can customize alert message using some placeholders like {{strategy.order.contracts}} or {{ticker}}. ALERT() was added last. This is an alerts-triggering function call, which can be run from strategy-type script. Finally it is doable! You can connect it to any event coded in PineScript and generate any alert message you want, thanks to concatenation of strings and wrapping variables into tostring() function. Out of these three alertcondition() is obviously archaic and probably will be discontinued. There is a chance this makes strategy/study distinction not making sense anymore, so I wouldn't be surprised if "studies" are deprecated at some point. But what are the differences between "Strategy alerts" and alert()? "Strategy alerts" seem easier to set-up with just a few clicks and probably easier to understand and verify, because they go in sync with the backtester and on-chart trade markers. It is especially important to understand how they work if you're building strategy based on pending orders (stop and limit) - events in your code might trigger placing pending order, but alert will be triggered only (and when) such order is executed. But "Strategy Alerts" have some limitations - not every variable you'd like to include in alert message is available from PineScript. And maybe you don't need the alert fired when the trade hit a stop-loss or take-profit, because you have already forwarded info about closing conditions in entry alert to your broker/exchange. Alert() was added to PineScript to fill all these gaps. Is allows concatenating any alert message you want, with any variable you want inside it and you can attach alert() function at any event in your PineScript code. For example - when placing orders, crossing variables, exiting trades, but not explicitly at pending orders execution. The Verdict "Strategy Alerts" might seem a better fit - easier to set-up and verify, flexible and they fire only when a trade really happens, not producing unnecessary mess when each pending order is placed. But these advantages are illusionary, because they don't give you the full-control which is needed when trading with real money. Especially when using pending orders. If an alert is fired when price actually hit a stop-order or limit-order level, and even if you are executing such alert within 1 second thanks to a tool like TradingConnector, you might already be late and you are making entry at a market price. Slippage will play a great role here. You need to send ordering alert when logical conditions are met - then it will be executed at the price you want. Even if you need to cancel all the pending orders which were not executed. Because of that I strongly recommend sticking to ALERT() when building your alerts system. Below is an example strategy, showing syntax to manage placing the orders and cancelling them. Yes, this is another spin-off from my TradingView Alerts to MT4 MT5 . As usual, please don't pay attention to backtest results, as this is educational script only. P.S. For the last time - farewell alertcondition(). You served us well.
Strategia Pine Script®
di Peter_O
16
alert reloadedtype: alert creation required time: 5 minutes level: easy Getting alerts for indicators and strats is good to easy the eyes of the charts for a while :) After my first script itroducing how to do alerts here there is an easier, more clear way to create an alert. It's still good to do it the "old way" to understand/debug an alert, but after that you'll want this extra tool for sure. I assume you read my previous post, or understand how alerts are set up on a chart. So, there is this function called alercondition() that does (almost)the whole job for us :) The function does NOT create the alert automatically, what is does is introducing a new option in the alerts popup. While in the v1.0 of my script the alert was triggered checking for the plot value against 0.9 or -0.9, in this example the alertcondition() function just fires the alert by itself. Get the script for yourself, in favourites, copy/paste, whatever. Add it to any chart. Then, open the popup to create an alert(the little clock at the top). There will be a drop menu with the options and "Alert reloaded". This is the title provided in the study() parameter. Choose this one. Now, the second drop menu has the "going UP" and "going DOWN" options. These are the titles from the alertcondition() function. Select one. Make all the aditional choices for the alert you want. Save it. And that's it, the alert will fire when the conditions become true. You can still keep the plot() for graphical reference, but it's now an extra, removing it will not affect the alert, so more space in the chart. Yey!! :)
Indicatore Pine Script®
di deimosaffair
ALERTS :: ALLinDivergence v10.0 Everything you see in this indicator has a designated purpose to ease your trading with predefined ALERTS of high quality. It pulls data from 7 different TimeFrames and it can not be more simpler visual representation of its calculations when applied on chart. When applied on chart, it will colour your chart BARS/CANDLE to the colour PURPLE as that colour is well known colour of Relative Strength Indicator line that indicates overbought or oversold area. RSI is used as a main source of information/data for this indicator. Second reason of colour PURPLE is that it cancels all the noise that default green/red bars have. This indicator also has GREEN/RED colouring of BARS/CANDLES and they appear when something crucial is happening in the market. That something needs to be checked ASAP. This green/red coloured bars are just there to remind you that something can happen and it does not mean that market would actually change direction it is just a "friendly warning" you can use when creating alerts. The best thing about this indicator is those full coloured GREEN/RED LITTLE DOTS. They represent DIVERGENCES emerging and possible actual change of market direction. To be sure, you need to analyse your chart more in depth any way you prefer to get your needed confirmations. To do that, use your strategy that you have been using when trading up until now or even better, use indicator that I made and is called RSI :: ALLinDivergence v 10.0 -> It is a visual representation of ALERT :: ALLinDivergence v 10.0 indicator signals. Very easy to analyse in minutes. HOW TO USE IT? Rule 1. TIMEFRAMES Choose the best TimeFrame for the job. I use: 1min, 2min, 3min, 5min, 8min, 13min, 21min, 34min or 56min (golden ratio). You can also pick a different TF but only to up to 1h TF chart as it does not work well with TF over 1h. Smaller TF is used for SCALPING of DAY TRADING higher TF is used for SWING TRADING. You get the picture? Rule 2
 To ENTER A POSITION 
Find the best TF that suits your needs. That depends on your trading style (day trading, scalping, swing trading, ect.). To know which TF is the best for you you also need to look for a good quality signals when looking the chart in the past (visual BACKTESTING). Signals from past should yield positive results.
 When you wish to trade certain pair, find the best TF and from there you need to "Create Alert". Choose this indicator when creating alerts and from dropdown menu pick "GREEN" for Divergence BUY/LONG signals or "RED" Divergence SELL/SHORT signals. Then choose "Greater Than" and change the value to "1" (that will set off the alarm), choose how you want to be notified and then name the ALERT so you will know how it is made.

Do not forget to do your work and analyse your market situation best way you can and get needed confirmations before doing anything about it. Rule 3 TO EXIT A POSITION From the same TF as Divergence alerts are made from (Rule 2), you can make alerts that are just a "friendly warning" that something is happening on the market you are in an opened position. Instead of picking GREEN or RED from dropdown menu when creating alerts, you need to pick GREEN BARS or RED BARS and the rest is the same as with rule 2. Rule 4 CONFIRMATIONS Help yourself with any type of analysis you need to get the confirmations you need to enter or exit the position. Use the style you always have up until now. Or find a better one that is quicker and with good yield. There is a great option that can change your way of thinking about trading and it is called RSI :: ALLinDivergence v 10.0 indicator that is used as a visual representation of ALERTS indicator. It takes literally minutes to do whole analysis - remember it uses data from 7 different TimeFrames and it is really good! Just find LowerHighs of RSI curve for SHORT or HigherLows for LONG.
Indicatore Pine Script®
di igorbanker
1
Alert Before Bar Closei.imgur.com Alert Before Bar Close ========================== Example Figure Originality and usefulness This indicator/alert mechanism is unique in two ways. First, it provides alerts before the close of a candlestick, allowing time-based traders to prepare early to determine if the market is about to form a setup. Second, it introduces an observation time mechanism, enabling time-based traders to observe when the market is active, thereby avoiding too many false signals during electronic trading or when trading is light. Detail Regarding the settings (Arrow 1). The first input is to select the candlestick period you want to observe. The second is to notify a few seconds in advance. The third input sets the observation time. For example, if you set "1,2,3,4,5," the alert mechanism will only be activated during the period from 01:00:00 to 05:59:59, consistent with the time zone you set in TradingView. Additionally, I have set it so that the alert will only trigger once per candlestick, so don't worry about repeated alerts. The alert setup is very simple, too. Follow the steps (Arrow 2, 3) to complete the setup. I have tested several periods and successfully received alerts on both mobile and computer. If anyone encounters any issues, feel free to let me know.
Indicatore Pine Script®
di tamiotsiu
2
[ALERTS] ADX and DIThe average directional index (ADX) is a technical analysis metric. Analysts use it to determine the relative strength of a trend, with the direction of the trend either upwards or downwards. The Average Directional Index (ADX) along with the Negative Directional Indicator (-DI) and the Positive Directional Indicator (+DI) are momentum strength indicators that evolved for use in stock trading. Commodities trader J. Welles Wilder pioneered their use. Technical traders who use charting techniques want to know when first spotting a shifting trend how strong that trend is and how likely it is to sustain itself over time. The ADX helps investors determine trend strength as they plan their investment strategies. Confirmation on a chart and other momentum indicators help investors spot trend reversals. But some trends are more potent than others and investors want to better understand the strength of a trend. The ADX identifies a strong positive trend when the ADX is over 25 and a weak trend when the ADX is below 20. Investors can determine directional movement by analyzing the difference between two consecutive low prices and their correlated highs. The movement is +DM when the current high price, less the previous high price, is greater than the previous low price less the current low. The opposite applies in determining the negative or –DI. When analyzing charts, stock price is the single most important variable to follow. ADX and other indicators are supplementary to price movements in providing additional directional information and support. For example, some of the best trends come about from price range consolidation. It is those tugs of war between buying and selling volumes that lead to breakouts and other trading opportunities. The Inventor of the Average Directional Index J. Welles Wilder, Jr. is a former American engineer and real estate developer who went on to revolutionize trading analysis by applying mathematical systems to the world of investing. In addition to developing the ADX, Wilder is also responsible for several other commonly used technical analysis tools including the Average True Range (ATR), the Relative Strength Index (RSI) and the Parabolic SAR. www.investopedia.com This script has alerts and includes the filter for markets with no trend defined. Green Alert --> Long Red Alert --> Short Yellow Area --> Weak trend. ADX below threshold Green candles --> Bullish Market Red Candles --> Bearish Market Orange candles --> No defined trend Enjoy!
Indicatore Pine Script®
di UnknownUnicorn2151907
3
[Alerts] - Moving Average Cross and/or Bbands botThis is the alert script for : We've included the basic alert syntax for Autoview automation. You can learn more about the syntax here: autoview.with.pink and you can watch this video here: www.youtube.com These settings are set, by default, to the lowest contracts allowed by Bitmex (at the time of this posting) to avoid a spam account. You can learn more about Autoview here: autoview.with.pink Get your invite and join us in slack here: slack.with.pink
Indicatore Pine Script®
di CryptoRox
15