BRINOVS blocks: Entry filters and restart (20 to 24)

Entry filters answer one question: "Is it OK to buy right now?" Each one gives back a simple yes or no (true or false), or a number you can compare. They never place a trade by themselves. You plug them into an if block so that Purchase only runs when the filter says yes.

A few words first. A tick is one new price from the market. A candle is a bar that sums up the price over a fixed time, for example 60 seconds. A contract is one trade you buy. A contract settles when it ends and the result is known. The journal is the log panel of the Bot Builder, where the bot writes what it is doing.

You find these blocks in the BRINOVS menu, in the folder "Entry filters and restart". Most of them go inside "2. Purchase conditions", in the if above Purchase. The Cooldown block is made for "4. Restart trading conditions", the part that runs after a trade ends, before the bot trades again. Everything here describes what already happened. None of it can tell you what the next tick or candle will do, and none of it makes a win more likely.

Single entry lock

• Kind: BRINOVS custom, block #20
• Type id: bnv_single_entry_lock
• Shape: True/false block
• Where it goes: In an if inside "2. Purchase conditions", above Purchase. Use only one: its settings are saved in one place.
• What it does: Stops one lasting condition from turning into a purchase on every tick. It says yes the first time a signal asks and no once the allowed number of purchases was made for that signal. On the block it reads "Signal still free: one purchase per ...".
• Inputs:
  • one purchase per: [ candle ▾ ] (default), [ tick ▾ ] or [ signal (candle + direction) ▾ ]. This sets what counts as "one signal".
  • candle size (seconds), default 60; timeout (seconds), default 300. Both are numbers of 1 or more.
  • purchases allowed per signal: a whole number from 1 to 100, default 1
  • release: [ when it settles ▾ ] (default), [ at the next candle ▾ ] or [ after the timeout ▾ ]; contract type: pick the contract the Purchase block buys
• Gives back: true while this signal has not been bought yet, false once the allowed number of purchases was made.
• How it works: A signal is the market plus the candle it happens in (or the tick, or the candle plus the contract type you buy). The lock itself is a rule on every purchase, so it also works if you delete the block, and it is remembered after a page refresh. It is let go when the contract settles, at the next candle, or after the timeout, as you chose. Every lock also ends after the timeout, so a lost message can never lock the bot for ever. Market time (the time of the last tick) decides which candle you are in, so a wrong clock on your phone does not matter.
• Example:

┌─ 2. Purchase conditions ───────────────────────────────┐
│ if  < Signal still free: one purchase per [ candle ▾ ] │
│       candle size [ 60 ] seconds                       │
│       purchases allowed per signal [ 1 ]               │
│       release [ when it settles ▾ ]                    │
│       timeout [ 300 ] seconds                          │
│       contract type [ Over ▾ ]                         │
│ then  Purchase [ Over ▾ ]                              │
└────────────────────────────────────────────────────────┘

While the market stays in this 60-second candle, the first check says yes and the bot buys once. Every later check in the same candle says no until the contract settles.

• Good to know:
  • Refusals (the bot stops with a message): no scope chosen; candle size not a whole number of 1 or more; purchases allowed not a whole number from 1 to 100; no release chosen; timeout under 1; per-signal scope with no contract type; or the BRINOVS execution layer is off.
  • A purchase is refused, with a journal message and nothing bought, when the signal was already bought, when no price has arrived yet, or when the saved setting is damaged.
  • It comes preloaded on a fresh Bot Builder, switched off (disabled). Enable it and drag it into the if before Purchase. It says nothing about your chance to win.

Signal confirm

• Kind: BRINOVS custom, block #21
• Type id: bnv_signal_confirm
• Shape: True/false block
• Where it goes: In an if inside "2. Purchase conditions". It can be used more than once.
• What it does: Says yes only after several different candles or ticks in a row all went the same way. This filters out one-off blips. On the block it reads "Confirmed ... times in a row".
• Inputs:
  • Confirmed [ 3 ] times in a row: a whole number from 1 to 100, default 3
  • by: [ closed candles ▾ ] (default) or [ ticks ▾ ]
  • going: [ up ▾ ] (default) or [ down ▾ ]
  • start again when one disagrees: [ yes ▾ ] (default) or [ no (skip it) ▾ ]
• Gives back: true when the count has reached your number, false before that.
• How it works: A closed candle is up when it closed higher than it opened. A tick is up when its price is higher than the tick before. Each candle or tick is counted once, however many times the block is checked. A candle still forming is not counted. With "start again" on, one disagreeing candle or tick (or an unchanged price) sets the count back to 0. With it off, a disagreeing one is skipped and the count stays. The candle size is the one in your Trade parameters, or 60 seconds if none is set.
• Example:

┌─ 2. Purchase conditions ─────────────────────────┐
│ if  < Confirmed [ 3 ] times in a row             │
│       by [ closed candles ▾ ] going [ up ▾ ]     │
│       start again when one disagrees [ yes ▾ ] > │
│ then  Purchase [ Rise ▾ ]                        │
└──────────────────────────────────────────────────┘

The bot buys only after three closed candles in a row each closed higher than they opened. One down candle starts the count again.

• Good to know:
  • Refusals: no candles or ticks chosen; no direction chosen; a number of confirmations that is not a whole number from 1 to 100; candles not available in this bot.
  • If the candles cannot be read, the block says no (never a guess).
  • The count is kept only while the bot is running.
  • It describes what already happened. It does not predict the next candle or tick.

Cooldown

• Kind: BRINOVS custom, block #22
• Type id: bnv_cooldown
• Shape: True/false block
• Where it goes: In an if inside "4. Restart trading conditions", before Trade again.
• What it does: Makes the bot wait after a trade. It says no while the pause is running and yes once trading is allowed again. On the block it reads "Cooldown over: skip ...".
• Inputs:
  • skip: a whole number of 1 or more, default 5
  • unit: [ ticks ▾ ] (default), [ candles ▾ ] or [ seconds ▾ ]
  • after: [ a win ▾ ] (default), [ a loss ▾ ] or [ any trade ▾ ]
• Gives back: true when trading is allowed again, false while the pause runs.
• How it works: The block looks at the latest finished real trade. If there is none, or if it was not the kind you chose (for example a win when you chose "a loss"), there is no pause and it says yes. Otherwise it waits until you have skipped your number of ticks, candles or seconds since that trade ended. Candles are counted as candle changes, using the candle size of your Trade parameters (60 seconds if none is set), so the first one can come sooner than a full candle. Seconds use the market's own time.
• Example:

┌─ 4. Restart trading conditions ─────────────┐
│ if  < Cooldown over: skip [ 5 ] [ ticks ▾ ] │
│       after [ a loss ▾ ] >                  │
│ then  Trade again                           │
└─────────────────────────────────────────────┘

After a losing trade the bot waits for five new ticks before it trades again. After a win it trades again at once.

• Good to know:
  • Refusals: a number that is not a whole number of 1 or more; no unit chosen; no trigger chosen.
  • Pretend (dry run) trades never start a pause.
  • After a page refresh, a pause counted in ticks counts only the ticks seen since the refresh.
  • A pause does not change your chance of winning.

Tick streak

• Kind: BRINOVS custom, block #23
• Type id: bnv_tick_streak
• Shape: True/false block
• Where it goes: In an if inside "2. Purchase conditions".
• What it does: Says yes when the latest ticks form a run of a chosen kind, at least as long as the number you set. A streak is a description of history, not a prediction.
• Inputs:
  • Last [ 3 ] ticks are: a whole number from 2 to 100, default 3
  • kind: [ rising ticks ▾ ] (default), [ falling ticks ▾ ], [ the same digit ▾ ] or [ the same parity ▾ ] (all odd or all even last digits)
  • an unchanged price is: [ a break ▾ ] (default) or [ ignored ▾ ]
• Gives back: true when the run is at least that long. False when too few ticks are known yet.
• How it works: The block counts back from the newest tick. For rising or falling, each step up or each step down counts once, so 3 means three steps in a row. For the same digit or same parity, each tick counts. The digit is read with the market's own number of decimals. An unchanged price either ends a rising or falling run or is skipped, as you chose.
• Example:

┌─ 2. Purchase conditions ─────────────────────────┐
│ if  < Last [ 4 ] ticks are [ the same parity ▾ ] │
│       an unchanged price is [ a break ▾ ] >      │
│ then  Purchase [ Over ▾ ]                        │
└──────────────────────────────────────────────────┘

The bot buys only when the last four ticks all ended in odd digits, or all in even digits.

• Good to know:
  • Refusals: a length that is not a whole number from 2 to 100; no kind chosen; no choice for an unchanged price.
  • While the run goes on, the block keeps saying yes. Add a Single entry lock for one purchase per signal.
  • The companion value block "Tick streak length" (next entry) gives the length of the run itself.

Tick streak length

• Kind: BRINOVS custom, companion of block #23
• Type id: bnv_tick_streak_length
• Shape: Value block (gives a number)
• Where it goes: Anywhere a number is wanted, for example in a comparison inside an if.
• What it does: Tells you how long the current run of ticks is, so you can compare it with a number yourself. A run is a description of history, not a prediction.
• Inputs:
  • Current streak of: [ rising ticks ▾ ] (default), [ falling ticks ▾ ], [ the same digit ▾ ] or [ the same parity ▾ ]
  • an unchanged price is: [ a break ▾ ] (default) or [ ignored ▾ ]
• Gives back: a whole number: how many in a row, counting back from the latest tick. 0 when there is none.
• How it works: It counts exactly like the Tick streak block does: steps up or steps down for rising and falling, ticks for the same digit or the same parity.
• Example:

┌─ 2. Purchase conditions ────────────────────────────────┐
│ if  < ( Current streak of [ rising ticks ▾ ]            │
│         an unchanged price is [ a break ▾ ] ) ≥ [ 4 ] > │
│ then  Purchase [ Rise ▾ ]                               │
└─────────────────────────────────────────────────────────┘

The bot buys only when the price has gone up at least four steps in a row.

• Good to know:
  • Refusals: no kind chosen; no choice for an unchanged price.
  • It describes the ticks that already happened. It does not predict the next tick.

Tick momentum

• Kind: BRINOVS custom, block #24
• Type id: bnv_tick_momentum
• Shape: Value block (gives a number, or one of the words UP, DOWN, NEUTRAL)
• Where it goes: Anywhere a number is wanted, for example in a comparison inside an if in "2. Purchase conditions".
• What it does: Describes the last ticks of the market: how many of the price moves went up or down, or how big a move is. It does not say what comes next.
• Inputs:
  • Tick momentum over the last [ 20 ] ticks: a whole number from 5 to 200, default 20
  • measure: [ % of moves rising ▾ ] (default), [ % of moves falling ▾ ], [ average size of a move ▾ ] or [ direction class (UP / DOWN / NEUTRAL) ▾ ]
• Gives back: a percentage, an average move (in price units), or the word UP, DOWN or NEUTRAL. With too few ticks, or ticks missing inside the window, the number blocks give "not a number" and the class gives UNKNOWN.
• How it works: It takes the price moves between the last ticks. The two percentages are shares of all moves in the window; a move with no change counts in neither. The average size drops the biggest and the smallest tenth of the moves, so one jump cannot decide it. The class is UP when rising moves beat falling moves by at least 20 points (for example 60 against 40), DOWN the other way round, otherwise NEUTRAL.
• Example:

┌─ 2. Purchase conditions ─────────────────────────────┐
│ if  < ( Tick momentum over the last [ 20 ] ticks     │
│         measure [ % of moves rising ▾ ] ) ≥ [ 60 ] > │
│ then  Purchase [ Rise ▾ ]                            │
└──────────────────────────────────────────────────────┘

The bot buys when at least 60 percent of the last 20 moves went up. This only counts the past.

• Good to know:
  • Refusals: no measure chosen; a window that is not a whole number from 5 to 200.
  • When there is no answer the journal says why: too few ticks, or a gap in the price feed. It is never a guess.
  • Ticks are not trading volume.

Last digits match

• Kind: BRINOVS custom, extra block (no catalogue number)
• Type id: bnv_last_digits_match
• Shape: True/false block
• Where it goes: In an if inside "2. Purchase conditions".
• What it does: Says yes when the last ticks end in the digits you wrote. You write patterns of last digits, such as "4 then 5". It describes the past only.
• Inputs:
  • digits: each one is [ any ▾ ] or 0 to 9. A fresh block shows 4, 5, 5, 4.
  • joins between digits: [ then ▾ ] (the digits come one after the other) or [ or ▾ ] (start another pattern)
  • the - and + buttons remove or add a digit (from 2 up to 12)
• Gives back: true when the end of the tick list fits one of your patterns. False when too few ticks are known yet.
• How it works: Read from left to right. The oldest digit is first, the last digit is the newest tick. "then" binds tighter than "or", so "4 then 5 or 5 then 4" means the last two digits are 4, 5 or they are 5, 4. "any" matches every digit. Digits are read with the market's own number of decimals.
• Example:

┌─ 2. Purchase conditions ───────────────────┐
│ if  < Last digits match                    │
│       [ 4 ▾ ]                              │
│       [ then ▾ ] [ 5 ▾ ]                   │
│       [ or ▾ ] [ 5 ▾ ]                     │
│       [ then ▾ ] [ 4 ▾ ]   [-] [+] >       │
│ then  Purchase [ Differs ▾ ]               │
└────────────────────────────────────────────┘

The bot buys when the last two digits are 4 then 5, or 5 then 4.

• Good to know:
  • Refusals: no pattern written; a pattern with more than 12 digits; a digit that is not 0 to 9 or "any".
  • While the latest digits stay the same it keeps saying yes. Add a Single entry lock if you want one purchase per signal.