Архив рубрики: Статьи участников

Модуль сереализации/десереализации и печати таблиц Lua

Автор записи: TGB

Сереализация таблицы Lua (со всеми ее, возможно, многоуровневыми вложенностями и перекрестными ссылками) это представление ее в виде строки. Десереализация это обратная операция – восстановление таблицы из строки.

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

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

--

В модуле реализовано два варианта сереализации/десереализации таблиц Lua:

1) Сереализация/десереализация (функции tbl_to_string и string_to_tbl) таблиц частного вида со следующими ограничениями:

- ключи и поля таблицы только типа : table (простые, не метатаблицы), booleannumberstring;

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

2) Сереализация/десереализация (функции tbl_to_str  и str_to_tb ) таблиц общего вида (при условиях,  детально рассмотренных далее в описании модуля), элементами (ключами и полями) которых могут быть любые Lua-типы (включая метатаблицы и ссылки на functionthread, userdata). Связи между элементами таблиц могут быть произвольными.

Кроме того, в модуле реализована функция печати любых Lua-данных, в том числе произвольных таблиц в удобном для анализа виде (со всеми вложенностями и перекрестными связями, включая метатаблицы, а также ссылки на functionthread, userdata).

----

В представленном скрипте-тесте выполняется сереализация/десереализация глобальной таблицы Lua _G, хранящей стандартные и подключаемые пакеты скрипта, все его переменные без спецификации local и т.д. Там же приведены примеры  сереализации/десереализации более простых таблиц, например:

local t1 = {5, 't1'}

local tbl_str = {1, 2

, { 3, 4, {5}, [t1] = '[t1]' }

, [ { {}, '[8]' } ] = {'Простой пример'}

}

------------------------------------------------------

Смотреть полностью...

Модуль реализации интерфейса обработки событий QUIK с использованием очередей событий

Автор записи: TGB

В существующих (на момент 15.10.21) версиях QUIK, его основной (и единственный) служебный поток обслуживания скриптов пользователя запускает их на выполнение (по команде из меню <Загруженные скрипты>). Этот же служебный поток, транслирует скриптам пользователя события, возникающие в QUIK, запуская все функции обратного вызова (колбеки), всех запущенных на исполнение его скриптов. Таким образом, в каждом работающем скрипте пользователя существует его поток main, а все его колбеки запускаются в отдельном, (единственном) служебном потоке QUIK.
Существуют два вида колбеков:
1) колбеки обслуживающие события фондового рынка;
2) колбеки обслуживающие события, возникающие в созданных пользователем таблицах QIUK.
То, что служебный поток QUIK один обслуживает колбеки всех, запущенных на исполнение скриптов пользователя, является проблемой: если функции колбеков некоторого скрипта выполняются долго, или в них возникают длительные блокировки, то перестают обслуживаться колбеки остальных, работающих скриптов пользователя. Кроме того, в скриптах пользователя необходимо учитывать факт параллелизма выполнения потока main и служебного потока QUIK, выполняющего колбеки. То есть, заниматься, сложным для непрофессионала, параллельным программированием.
Из, всего выше сказанного, можно сделать вывод о том, что: в том виде, как он представлен, в текущий момент времени, интерфейс обработки событий в QLua «сырой» для использования его «широким кругом» пользователей.
Для устранения выше озвученных проблем разработчиком QUIK рекомендуется использовать потокобезопасные очереди для передачи параметров, запус-каемых колбеков, потокам main, в которых должны выполняться функции реакции на такие колбеки (документ «Использование Lua в Рабочем месте QUIK»).
Как это можно реализовать, в удобном и эффективном для пользователя виде, представлено ниже в виде:
1) кода модуля even_handling_module.lua ;
2) шаблона использования этого модуля.
Особенности реализации модуля even_handling_module.lua:
1) код модуля написан на «чистом» QLua;
2) очереди передачи параметров колбеков в скриптах пользователя в его потоки main (в разных скриптах это разные потоки) потокобезопасные и при этом они реализованы без использования синхронизации;
3) при реализации записи/чтения очередей, количество операций (на языке Lua) < 6 и не зависит от текущего размера очередей.
Выше перечисленные особенности реализации модуля even_handling_module.lua обеспечивают минимальное влияние на служебный поток QUIK того, что выполняется в скриптах пользователя, а также удобство использования модуля в скриптах пользователя.
Детальное описание использования модуля even_handling_module.lua приведено в его коде и коде шаблона, описывающего схему обработки событий QUIK.
Для подключения модуля к шаблону его надо сохранить в файле под именем even_handling_module.lua в папку хранения кода запуска QUIK (info.exe).
Коды модуля и скрипта-примера его использования:

Смотреть полностью...

Индикатор экстремум

Автор записи: kalikazandr

Облегченная версия индикатора, определяет локальные макс/мин цены на графике. Надеюсь, индикатор станет полезен для ваших торговых алгоритмов.

жми

в версии quik 8.7 имеется баг с настройками индикатора, проверялось на версии 8.13

Индикатор

--C:/QUIK/LuaIndicators/extr.lua
dofile(getWorkingFolder() .. "\\LuaIndicators\\Include\\myExtr.lua")
Settings = {}
Settings.Name = "*extr"
Settings.nDepth = 3000 --[[для определения стартового бара]]
Settings.nMinHL = 0 --[[минимальное движение цены для определения экстремума]]
Settings.line =
{
 {
 Name = "TRIANGLE_UP",
 Type = TYPE_TRIANGLE_UP,
 Color = RGB(255, 0, 0),
 Width = 4
 },
 {
 Name = "TRIANGLE_DOWN",
 Type = TYPE_TRIANGLE_DOWN,
 Color = RGB(0, 255, 0),
 Width = 4
 }
}
 
function Init()
 extr = myExtr()
 return 2
end
 
local oi, min_hl
function OnCalculate(index)
 
 if index == 1 then
 min_hl = tonumber(Settings.nMinHL)
 
 if min_hl and min_hl &lt;= 0 then min_hl = nil end
 if not min_hl then return message("Индикатору extr нужен параметр nMinHL &gt; 0",3) end
 
 local depth = tonumber(Settings.nDepth) or Size()
 local s = Size() - depth
 oi = s &lt; 1 and 1 or s
 
 extr(oi, min_hl, index)
 end
 --[[считает только что закрывшийся бар, в текущем активном не считает]]
 if not min_hl or index &lt;= oi then return end
 
 extr(oi, min_hl, index)
 oi = index
end

Модуль индикатора

--C:/QUIK/LuaIndicators/Include/myExtr.lua
function myExtr()
   local HH, LL, mH, mL, imH, imL
   local function SetL(oH, oL, oi, min_hl)
      if oH > mH then
         mH, imH = oH, oi
         if not LL then
            if oH - mL >= min_hl then
               LL = mL
               SetValue(imL, 1, LL)
               mL, imL = oL, oi
               HH = nil
            end
         else
            mL, imL = oL, oi
         end
         if HH and oH >= HH then HH = nil end
      end
   end
   local function SetH(oH, oL, oi, min_hl)
      if oL < mL then
         mL, imL = oL, oi
         if not HH then
            if mH - oL >= min_hl then
               HH = mH
               SetValue(imH, 2, HH)
               mH, imH = oH, oi
               LL = nil
            end
         else
            mH, imH = oH, oi
         end
         if LL and oL <= LL then LL = nil end
      end
   end
   return function (oi, min_hl, i)
      if i <= oi then
         mH, mL = H(oi), L(oi)
         imH, imL = oi, oi
         HH, LL = nil, nil
         return
      end
 
      local oH, oL = H(oi), L(oi)
      if imL < imH then
         SetL(oH, oL, oi, min_hl)
         SetH(oH, oL, oi, min_hl)
      else
         SetH(oH, oL, oi, min_hl)
         SetL(oH, oL, oi, min_hl)
      end
   end
end

 

Операционная система разработки многопоточных роботов торговли ценными бумагами в QUIK «OS_Quesha»

Автор записи: TGB

OS_Quesha представляет собой специализированную операционную систему реального времени (с характеристиками, часть из которых будет детально представлены в конце статьи), реализованную в среде QUIK. Она обеспечивает разработку многопоточных торговых роботов для QUIK версий 7…, установленных в Windows 10 (32 , 64 р). С ее помощью могут быть решены сложные задачи эффективного использования многопроцессорности современных ПК с целью повышения скорости обработки данных в роботах, разрабатываемых на языке QLua и C++. OS_Quesha обеспечивает в языке программирования QLua, изначально отсутствующий в нем, параллелизм выполнения его, взаимодействующих между собой, функций в рамках одной его инсталляции. Кроме того, средства OS_Quesha решают и иные существенные задачи, возникающие при разработке торговых роботов, в том числе, обеспечивают устойчивость их функционирования при сбоях аппаратуры и программ.
OS_Quesha запускается в QUIKе в виде обычного QLua-скрипта. При этом, в рамках процесса QUIK, она разворачивается в виде нескольких, эффективно взаимодействующих между собой, потоков, количество которых определяется ее настройками. Ее реализация внутри процесса QUIK обеспечивает тесную интеграцию с ним, а значит высокую скорость взаимодействия с ним, недостижимую при межпроцессорном взаимодействии. Для пользователя OS_Quesha представлена формой диалога, запускаемой в отдельном потоке. Из OS_Quesha доступен весь программный интерфейс QUIK, существующий для скриптов QLua. Наличие работающего шаблона TS_QUIK.lua (в виде исходного кода на языке QLua), демонстрирующего применение средств OS_Quesha и ее компактность, обеспечивают низкий порог вхождения при ее использовании.Смотреть полностью...

Библиотека lua_share: обмен данными между скриптами и приложениями

Автор записи: toxa

ОПИСАНИЕ:
Библиотека предназначена для обмена данными между lua-скриптами, работающими в разных процессах, а так же в
одном процессе, но в разных lua-машинах. Прежде всего, она будет полезна пользователям терминала QUIK.

Комплект состоит из библиотеки lua_share.dll и файла lua_share_boot.lua. Для корректной работы оба файла должны
находиться в одном каталоге. Если файл lua_share_boot.lua отсутствует, то библиотека ведет себя несколько иначе,
но тоже работает, о чем ниже. Для межпроцессного взаимодействия в комплект так же входит IPC-сервер под названием
lua_share_server.exe и lua-скрипт lua_share_server.lua.
Смотреть полностью...

Благодарность

Автор записи: Jon

Уважаемые создатели данного ресурса!

Хочу поблагодарить Вас за данный сайт и ту информацию которая здесь представлена.. С уверенностью могу заявить что это один из самых информативных сайтов по данное теме. В частности по языку Lua и его применению в Quik для создания торговых систем.  Информация,  которая представлена на этом сайте,  в полном объеме отражает тот необходимый минимум для начала изучения вопроса создания мтс. Очень понравились оперативные и профессиональные ответы на вопросы . Удачи Вам!

Отсылка транзакций из С++ без использования Lua кода.

Автор записи: AndreyKrivcov

Доброго времени Суток.

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

ПРЕДУПРЕЖДЕНИЕ:
1) Код НЕ потокобезопасный и по этому требуется использовать разделяемые ресурсы для работы со стеком Луа (если проект многопоточный).

2) Предоставляется "Как Есть" и не несу не какой ответственности за Ваше использование кода

3) Если найдете недочеты или баги, то просьба сообщить тут. (поправим)

Код написан на плюсах и собственно разделен на 2 файла (заголовочный и реализации). Данная обертка функционирует следующим образом:
1) При использовании функций, автоматически формируется массив с полями таблицы. Если вдруг поле менялось дважды то оно просто меняет свое значение в массиве. Так же таблица сама нормализует цены и все прочие... Все команды вынесены в перечисления и по этому удобны для использования.

2) Вызывается функция std::string sentTransaction (Ttransaction &T) - принимающая в себя сформированную таблицу. Данная функция заносит в Луа все необходимые данные, вызывает lua_call и получает в качестве ответа сообщение об ошибке которое возвращает стандартная ф-ция lua_call.

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

Далее пойдет реализация:

Ttransactions.h
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
 
#include <string>
#include<vector>
#include <ctime>
#include <iterator>
#include <windows.h>
 
#define LUA_LIB
#define LUA_BUILD_AS_DLL
 
extern "C" {
#include "Lua/lauxlib.h"
#include "Lua/lua.h"
#include "Lua/luaconf.h"
}
 
 
enum class ExpiryType
{
 GTC = 0,
 TODAY = 1,
 DT = 2
};
struct ExpiryDate
{
 tm DT;
 ExpiryType type;
};
 
struct DB_QueryParams
{
 std::string class_code;
 std::string sec_code;
 std::string account;
};
 
enum class order_Action
{
 NEW_ORDER,//новая заявка
 NEW_NEG_DEAL, //новая заявка на внебиржевую сделку
 NEW_REPO_NEG_DEAL, //новая заявка на сделку РЕПО
 NEW_EXT_REPO_NEG_DEAL, //новая заявка на сделку модифицированного РЕПО (РЕПО-М)
 NEW_STOP_ORDER, //новая стоп-заявка
 KILL_ORDER, //снять заявку
 KILL_NEG_DEAL, //снять заявку на внебиржевую сделку или заявку на сделку РЕПО
 KILL_STOP_ORDER, //снять стоп-заявку
 KILL_ALL_ORDERS, //снять все заявки из торговой системы
 KILL_ALL_STOP_ORDERS, //снять все стоп-заявки
 KILL_ALL_NEG_DEALS, //снять все заявки на внебиржевые сделки и заявки на сделки РЕПО
 KILL_ALL_FUTURES_ORDERS, //снять все заявки на рынке FORTS
 MOVE_ORDERS, //переставить заявки на рынке FORTS
 NEW_QUOTE, //новая безадресная заявка
 KILL_QUOTE, //снять безадресную заявку
 NEW_REPORT, //новая заявка-отчет о подтверждении транзакций в режимах РПС и РЕПО
 SET_FUT_LIMIT, //новое ограничение по фьючерсному счету
};
enum class order_Type
{
 L, //limit
 M //market
};
enum class order_Operation
{
 B, //bue
 S //sell
};
enum class order_Execution_condition
{
 PUT_IN_QUEUE, //поставить в очередь (по умолчанию)
 FILL_OR_KILL, //немедленно или отклонить
 KILL_BALANCE, //снять остаток
};
enum class order_Stop_order_kind
{
 SIMPLE_STOP_ORDER, //стоп-лимит
 CONDITION_PRICE_BY_OTHER_SEC, //с условием по другой бумаге
 WITH_LINKED_LIMIT_ORDER, //со связанной заявкой
 TAKE_PROFIT_STOP_ORDER, //тэйк-профит
 TAKE_PROFIT_AND_STOP_LIMIT_ORDER, //тэйк-профит и стоп-лимит
 ACTIVATED_BY_ORDER_SIMPLE_STOP_ORDER, //стоп-лимит по исполнению заявки
 ACTIVATED_BY_ORDER_TAKE_PROFIT_STOP_ORDER, //тэйк-профит по исполнению заявки
 ACTIVATED_BY_ORDER_TAKE_PROFIT_AND_STOP_LIMIT_ORDER //тэйк-профит и стоп-лимит по исполнению заявки
};
enum class order_Stopprice_condition
{
 less_or_equal,
 more_or_ewual
};
struct order_TimeStruct
{
 int hour;
 int min;
 int sec;
};
enum class order_For_account
{
 OWNOWN, //от своего имени, за свой счет
 OWNCLI, //от своего имени, за счет клиента
 OWNDUP, //от своего имени, за счет доверительного управления
 CLICLI, //от имени клиента, за счет клиента
};
enum class order_Units
{
 PERCENTS, //в процентах (шаг изменения – одна сотая процента)
 PRICE_UNITS // в параметрах цены(шаг изменения равен шагу цены по данному инструменту)
};
enum class order_Mode
{
 _0, //оставить количество в заявках без изменения,
 _1, //изменить количество в заявках на новые,
 _2 //при несовпадении новых количеств с текущим хотя бы в одной заявке, обе заявки снимаются
};
 
struct Ttransaction
{
public:
 Ttransaction(lua_State *L, DB_QueryParams params);
 Ttransaction(const Ttransaction &other);
 ~Ttransaction();
 
 void classcode();
 void seccode();
 void classcode(std::string param);
 void seccode(std::string param);
 void action(order_Action param);
 void firm_ID(std::string param);
 void account();
 void account(std::string param);
 void client_code(std::string param); // 20 symb - max
 void type(order_Type param);
 void market_maker_order(bool param);
 void operation(order_Operation param);
 void execution_condition(order_Execution_condition param);
 void quantity(int param);
 void repovalue(double param);
 void start_discount(double param);
 void lower_discount(double param);
 void upper_discount(double param);
 void price(double param);
 void stopprice(double param);
 void stop_order_kind(order_Stop_order_kind param);
 void stopprice_classcode(std::string param);
 void stopprice_seccode(std::string param);
 void stopprice_condition(order_Stopprice_condition param);
 void linked_order_price(double param);
 void expiry_date(ExpiryDate param);
 void stopprice2(double param);
 void market_stop_limit(bool param);
 void market_take_profit(bool param);
 void is_active_in_time(bool param);
 void active_from_time(order_TimeStruct param);
 void active_to_time(order_TimeStruct param);
 void partner(std::string param);
 void order_key(long param);
 void stop_order_key(long param);
 int trans_id();
 void trans_id(int param);
 void settle_code(std::string param);
 void price2(double param);
 void repoterm(std::string param);
 void reporate(double param);
 void block_securities(bool param);
 void refundrate(double param);
 void comment(std::string param);
 void large_trade(bool param);
 void curr_code(std::string param);
 void for_account(order_For_account param);
 void settle_date(tm param);
 void kill_if_linked_order_partly_field(bool param);
 void offset(double param, order_Units units);
 void spread(double param, order_Units units);
 void base_order_key(long param);
 void use_base_order_balance(bool param);
 void activate_if_base_order_partly_fielled(bool param);
 void base_contract(std::string param);
 void mode(order_Mode param);
 void first_order_number(long param);
 void first_order_new_quantity(int param);
 void first_order_new_price(double param);
 void second_order_number(long param);
 void second_order_new_quantity(int param);
 void second_order_new_price(double param);
 void kill_active_orders(bool param);
 void neg_trade_operation(order_Operation param);
 void neg_trade_number(std::string param);
 void volumemn(std::string param);
 void volumepl(std::string param);
 void kfl(double param);
 void kgo(double param);
 void use_kgo(bool param);
 void check_limits(bool param);
 void matchref(std::string param);
 void correction(bool param);
 
 //void reset_Table(int args_num);
 void reset_Table(DB_QueryParams params);
 
private:
 struct param_value
 {
 std::string fieldName;
 std::string arg;
 };
 
 lua_State *L;
 int scale;
 double price_step;
 std::vector<param_value> param_keeper;
 DB_QueryParams params;
 
 friend std::string sendTransaction(Ttransaction& T);
 
 std::string get_correctPrice(double price);
 void add_or_replace_field(std::string fieldName, std::string arg); // проверяет есть ли в fieldRows, если есть то заменяет, если нет то добовляет новое и добавляет в fieldRows
};

Теперь реализация данного заголовочного файла:

Ttransaction.cpp
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
#include "Ttransaction.h"
//=================================================================================================================================================================================
//	Ttransaction
//=================================================================================================================================================================================
 
void Ttransaction::offset(double param, order_Units units)
{
	std::string data_param, data_units;
	if (units == order_Units::PRICE_UNITS)
	{
		data_param = get_correctPrice(param);
		data_units = "PRICE_UNITS";
	}
	else
	{
		data_param = std::to_string(param);
		data_units = "PERCENTS";
	}
	add_or_replace_field("OFFSET", data_param);
	add_or_replace_field("OFFSET_UNITS", data_units);
}
 
void Ttransaction::spread(double param, order_Units units)
{
	std::string data_param, data_units;
	if (units == order_Units::PRICE_UNITS)
	{
		data_param = get_correctPrice(param);
		data_units = "PRICE_UNITS";
	}
	else
	{
		data_param = std::to_string(param);
		data_units = "PERCENTS";
	}
	add_or_replace_field("SPREAD", data_param);
	add_or_replace_field("SPREAD_UNITS", data_units);
}
 
void Ttransaction::base_order_key(long param)
{
	add_or_replace_field("BASE_ORDER_KEY", std::to_string(param));
}
 
void Ttransaction::use_base_order_balance(bool param)
{
	add_or_replace_field("USE_BASE_ORDER_BALANCE", (param ? "YES" : "NO"));
}
 
void Ttransaction::activate_if_base_order_partly_fielled(bool param)
{
	add_or_replace_field("ACTIVATE_IF_BASE_ORDER_PARTLY_FILLED", (param ? "YES" : "NO"));
}
 
void Ttransaction::base_contract(std::string param)
{
	add_or_replace_field("BASE_CONTRACT", param);
}
 
void Ttransaction::mode(order_Mode param)
{
	std::string data;
	switch (param)
	{
	case order_Mode::_0: data = "0"; break;
	case order_Mode::_1: data = "1"; break;
	case order_Mode::_2: data = "2";  break;
	default: data = ""; break;
	}
 
	add_or_replace_field("MODE", data);
}
 
void Ttransaction::first_order_number(long param)
{
	add_or_replace_field("FIRST_ORDER_NUMBER", std::to_string(param));
}
 
void Ttransaction::first_order_new_quantity(int param)
{
	if (param < 0) param = -param;
	add_or_replace_field("FIRST_ORDER_NEW_QUANTITY", std::to_string(param));
}
 
void Ttransaction::first_order_new_price(double param)
{
	add_or_replace_field("FIRST_ORDER_NEW_PRICE", get_correctPrice(param));
}
 
void Ttransaction::second_order_number(long param)
{
	add_or_replace_field("SECOND_ORDER_NUMBER", std::to_string(param));
}
 
void Ttransaction::second_order_new_quantity(int param)
{
	if (param < 0) param = -param;
	add_or_replace_field("SECOND_ORDER_NEW_QUANTITY", std::to_string(param));
}
 
void Ttransaction::second_order_new_price(double param)
{
	add_or_replace_field("SECOND_ORDER_NEW_PRICE", std::to_string(param));
}
 
void Ttransaction::kill_active_orders(bool param)
{
	add_or_replace_field("KILL_ACTIVE_ORDERS", (param ? "YES" : "NO"));
}
 
void Ttransaction::neg_trade_operation(order_Operation param)
{
	std::string data;
	switch (param)
	{
	case order_Operation::B: data = "B"; break;
	case order_Operation::S: data = "S"; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("NEG_TRADE_OPERATION", data);
}
 
void Ttransaction::neg_trade_number(std::string param)
{
	add_or_replace_field("NEG_TRADE_NUMBER", param);
}
 
void Ttransaction::volumemn(std::string param)
{
	add_or_replace_field("VOLUMEMN", param);
}
 
void Ttransaction::volumepl(std::string param)
{
	add_or_replace_field("VOLUMEPL", param);
}
 
void Ttransaction::kfl(double param)
{
	add_or_replace_field("KFL", std::to_string(param));
}
 
void Ttransaction::kgo(double param)
{
	add_or_replace_field("KGO", std::to_string(param));
}
 
void Ttransaction::use_kgo(bool param)
{
	add_or_replace_field("USE_KGO", (param ? "Y" : "N"));
}
 
void Ttransaction::check_limits(bool param)
{
	add_or_replace_field("CHECK_LIMITS", (param ? "YES" : "NO"));
}
 
void Ttransaction::matchref(std::string param)
{
	add_or_replace_field("MATCHREF", param);
}
 
void Ttransaction::correction(bool param)
{
	add_or_replace_field("CORRECTION", (param ? "Y" : "N"));
}
 
std::string Ttransaction::get_correctPrice(double price)
{
	price = round(price / price_step)*price_step;
	std::string data = std::to_string(price);
	std::string ans;
	bool is_next_step = false;
	std::string to_add;
 
	int _dot = -1;
	for (int i = 0; i < (int)data.size(); i++)
	{
		if(data.at(i) == '.' || data.at(i) == ',')
		{
			if (!is_next_step)
				is_next_step = true;
			continue;
		}
 
		if (is_next_step)
		{
			if (scale > 0)
				to_add.push_back(data.at(i));
			else
				break;
		}
		else
			ans.push_back(data.at(i));
	}
 
	if (scale > 0)
	{
		int to_add_size = to_add.size();
		ans.push_back('.');
		for (size_t i = 0; i < scale; i++)
		{
			if (i < to_add_size && to_add_size >0)
				ans.push_back(to_add.at(i));
			else
				ans.push_back('0');
		}
	}
	return ans;
}
 
void Ttransaction::add_or_replace_field(std::string fieldName, std::string arg)
{
	if (arg.compare("") != 0)
	{
		bool insert = true;
		for (size_t i = 0; i < param_keeper.size(); i++)
		{
			if (param_keeper[i].fieldName.compare(fieldName) == 0)
			{
				param_keeper[i].arg = arg;
				insert = false;
			}
		}
		if (insert)
		{
			param_value S;
			S.fieldName = fieldName;
			S.arg = arg;
			param_keeper.push_back(S);
		}
	}
}
 
Ttransaction::Ttransaction(lua_State * L, DB_QueryParams params)
{
	this->L = L;
 
	reset_Table(params);
}
 
Ttransaction::~Ttransaction()
{
}
 
void Ttransaction::classcode()
{
	add_or_replace_field("CLASSCODE", params.class_code);
}
 
void Ttransaction::seccode()
{
	add_or_replace_field("SECCODE", params.sec_code);
}
 
void Ttransaction::classcode(std::string param)
{
	add_or_replace_field("CLASSCODE", param);
}
 
void Ttransaction::seccode(std::string param)
{
	add_or_replace_field("SECCODE", param);
}
 
void Ttransaction::action(order_Action param)
{
	std::string data;
 
	switch (param)
	{
	case order_Action::NEW_ORDER: data = "NEW_ORDER"; break;
	case order_Action::NEW_NEG_DEAL: data = "NEW_NEG_DEAL"; break;
	case order_Action::NEW_REPO_NEG_DEAL: data = "NEW_REPO_NEG_DEAL"; break;
	case order_Action::NEW_EXT_REPO_NEG_DEAL: data = "NEW_EXT_REPO_NEG_DEAL"; break;
	case order_Action::NEW_STOP_ORDER: data = "NEW_STOP_ORDER"; break;
	case order_Action::KILL_ORDER: data = "KILL_ORDER"; break;
	case order_Action::KILL_NEG_DEAL: data = "KILL_NEG_DEAL"; break;
	case order_Action::KILL_STOP_ORDER: data = "KILL_STOP_ORDER"; break;
	case order_Action::KILL_ALL_ORDERS: data = "KILL_ALL_ORDERS"; break;
	case order_Action::KILL_ALL_STOP_ORDERS: data = "KILL_ALL_STOP_ORDERS"; break;
	case order_Action::KILL_ALL_NEG_DEALS: data = "KILL_ALL_NEG_DEALS"; break;
	case order_Action::KILL_ALL_FUTURES_ORDERS: data = "KILL_ALL_FUTURES_ORDERS"; break;
	case order_Action::MOVE_ORDERS: data = "MOVE_ORDERS"; break;
	case order_Action::NEW_QUOTE: data = "NEW_QUOTE"; break;
	case order_Action::KILL_QUOTE: data = "KILL_QUOTE"; break;
	case order_Action::NEW_REPORT: data = "NEW_REPORT"; break;
	case order_Action::SET_FUT_LIMIT: data = "SET_FUT_LIMIT"; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("ACTION", data);
}
 
void Ttransaction::firm_ID(std::string param)
{
	add_or_replace_field("FIRM_ID", param);
}
 
void Ttransaction::account()
{
	add_or_replace_field("ACCOUNT", params.account);
}
 
void Ttransaction::account(std::string param)
{
	add_or_replace_field("ACCOUNT", param);
}
 
void Ttransaction::client_code(std::string param)
{
	add_or_replace_field("CLIENT_CODE", param);
}
 
void Ttransaction::type(order_Type param)
{
	std::string data;
 
	switch (param)
	{
	case order_Type::L: data = "L"; break;
	case order_Type::M: data = "M"; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("TYPE", data);
}
 
void Ttransaction::market_maker_order(bool param)
{
	add_or_replace_field("MARKET_MAKER_ORDER", (param ? "YES" : "NO"));
}
 
void Ttransaction::operation(order_Operation param)
{
	std::string data;
	switch (param)
	{
	case order_Operation::B: data = "B"; break;
	case order_Operation::S: data = "S"; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("OPERATION", data);
}
 
void Ttransaction::execution_condition(order_Execution_condition param)
{
	std::string data;
	switch (param)
	{
	case order_Execution_condition::PUT_IN_QUEUE: data = "PUT_IN_QUEUE"; break;
	case order_Execution_condition::FILL_OR_KILL: data = "FILL_OR_KILL"; break;
	case order_Execution_condition::KILL_BALANCE: data = "KILL_BALANCE"; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("EXECUTION_CONDITION", data);
}
 
void Ttransaction::quantity(int param)
{
	if (param < 0) param = -param;
	add_or_replace_field("QUANTITY", std::to_string(param));
}
 
void Ttransaction::repovalue(double param)
{
	add_or_replace_field("REPOVALUE", std::to_string(param));
}
 
void Ttransaction::start_discount(double param)
{
	add_or_replace_field("START_DISCOUNT", std::to_string(param));
}
 
void Ttransaction::lower_discount(double param)
{
	add_or_replace_field("LOWER_DISCOUNT", std::to_string(param));
}
 
void Ttransaction::upper_discount(double param)
{
	add_or_replace_field("UPPER_DISCOUNT", std::to_string(param));
}
 
void Ttransaction::price(double param)
{
	add_or_replace_field("PRICE", get_correctPrice(param));
}
 
void Ttransaction::stopprice(double param)
{
	add_or_replace_field("STOPPRICE", get_correctPrice(param));
}
 
void Ttransaction::stop_order_kind(order_Stop_order_kind param)
{
	std::string data;
	switch (param)
	{
	case order_Stop_order_kind::SIMPLE_STOP_ORDER: data = "SIMPLE_STOP_ORDER"; break;
	case order_Stop_order_kind::CONDITION_PRICE_BY_OTHER_SEC: data = "CONDITION_PRICE_BY_OTHER_SEC"; break;
	case order_Stop_order_kind::WITH_LINKED_LIMIT_ORDER: data = "WITH_LINKED_LIMIT_ORDER"; break;
	case order_Stop_order_kind::TAKE_PROFIT_STOP_ORDER: data = "TAKE_PROFIT_STOP_ORDER"; break;
	case order_Stop_order_kind::TAKE_PROFIT_AND_STOP_LIMIT_ORDER: data = "TAKE_PROFIT_AND_STOP_LIMIT_ORDER"; break;
	case order_Stop_order_kind::ACTIVATED_BY_ORDER_SIMPLE_STOP_ORDER: data = "ACTIVATED_BY_ORDER_SIMPLE_STOP_ORDER"; break;
	case order_Stop_order_kind::ACTIVATED_BY_ORDER_TAKE_PROFIT_STOP_ORDER: data = "ACTIVATED_BY_ORDER_TAKE_PROFIT_STOP_ORDER"; break;
	case order_Stop_order_kind::ACTIVATED_BY_ORDER_TAKE_PROFIT_AND_STOP_LIMIT_ORDER: data = "ACTIVATED_BY_ORDER_TAKE_PROFIT_AND_STOP_LIMIT_ORDER"; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("STOP_ORDER_KIND", data);
}
 
void Ttransaction::stopprice_classcode(std::string param)
{
	add_or_replace_field("STOPPRICE_CLASSCODE", param);
}
 
void Ttransaction::stopprice_seccode(std::string param)
{
	add_or_replace_field("STOPPRICE_SECCODE", param);
}
 
void Ttransaction::stopprice_condition(order_Stopprice_condition param)
{
	std::string data;
	switch (param)
	{
	case order_Stopprice_condition::less_or_equal: data = "<="; break;
	case order_Stopprice_condition::more_or_ewual: data = ">="; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("STOPPRICE_CONDITION", data);
}
 
void Ttransaction::linked_order_price(double param)
{
	add_or_replace_field("LINKED_ORDER_PRICE", get_correctPrice(param));
}
 
void Ttransaction::expiry_date(ExpiryDate param)
{
	bool add = true;
	std::string data;
	switch (param.type)
	{
	case ExpiryType::GTC: data = "GTC"; break;
	case ExpiryType::TODAY: data = "TODAY"; break;
	default:
	{
		char DT[100];
		if (std::strftime(DT, sizeof(DT), "%Y%m%d", &param.DT))
			data = DT;
		else
			add = false;
	}
	break;
	}
 
	if (add)
		add_or_replace_field("EXPIRY_DATE", data);
}
 
void Ttransaction::stopprice2(double param)
{
	add_or_replace_field("STOPPRICE2", get_correctPrice(param));
}
 
void Ttransaction::market_stop_limit(bool param)
{
	add_or_replace_field("MARKET_STOP_LIMIT", (param ? "YES" : "NO"));
}
 
void Ttransaction::market_take_profit(bool param)
{
	add_or_replace_field("MARKET_TAKE_PROFIT", (param ? "YES" : "NO"));
}
 
void Ttransaction::is_active_in_time(bool param)
{
	add_or_replace_field("IS_ACTIVE_IN_TIME", (param ? "YES" : "NO"));
}
 
void Ttransaction::active_from_time(order_TimeStruct param)
{
	auto get_num = [](double num)
	{
		return (num < 10 ? "0" + std::to_string(num) : std::to_string(num));
	};
	std::string data = get_num(param.hour) + get_num(param.min) + get_num(param.sec);
 
	add_or_replace_field("ACTIVE_FROM_TIME", data);
}
 
void Ttransaction::active_to_time(order_TimeStruct param)
{
	auto get_num = [](double num)
	{
		return (num < 10 ? "0" + std::to_string(num) : std::to_string(num));
	};
	std::string data = get_num(param.hour) + get_num(param.min) + get_num(param.sec);
 
	add_or_replace_field("ACTIVE_TO_TIME", data);
}
 
void Ttransaction::partner(std::string param)
{
	add_or_replace_field("PARTNER", param);
}
 
void Ttransaction::order_key(long param)
{
	add_or_replace_field("ORDER_KEY", std::to_string(param));
}
 
void Ttransaction::stop_order_key(long param)
{
	add_or_replace_field("STOP_ORDER_KEY", std::to_string(param));
}
 
int Ttransaction::trans_id()
{
	srand((unsigned int)time(NULL)); //seeding for the first time only!
	int num = (1 + rand() % ((2147483647 + 1) - 1));
 
	add_or_replace_field("TRANS_ID", std::to_string(num));
	return num;
}
 
void Ttransaction::trans_id(int param)
{
	if (param < 0) param = abs(param);
	add_or_replace_field("TRANS_ID", std::to_string(param));
}
 
void Ttransaction::settle_code(std::string param)
{
	add_or_replace_field("SETTLE_CODE", param);
}
 
void Ttransaction::price2(double param)
{
	add_or_replace_field("PRICE2", get_correctPrice(param));
}
 
void Ttransaction::repoterm(std::string param)
{
	add_or_replace_field("REPOTERM", param);
}
 
void Ttransaction::reporate(double param)
{
	add_or_replace_field("REPORATE", std::to_string(param));
}
 
void Ttransaction::block_securities(bool param)
{
	add_or_replace_field("BLOCK_SECURITIES", (param ? "YES" : "NO"));
}
 
void Ttransaction::refundrate(double param)
{
	add_or_replace_field("REFUNDRATE", std::to_string(param));
}
 
void Ttransaction::comment(std::string param)
{
	add_or_replace_field("COMMENT", param);
}
 
void Ttransaction::large_trade(bool param)
{
	add_or_replace_field("LARGE_TRADE", (param ? "YES" : "NO"));
}
 
void Ttransaction::curr_code(std::string param)
{
	add_or_replace_field("CURR_CODE", param);
}
 
void Ttransaction::for_account(order_For_account param)
{
	std::string data;
	switch (param)
	{
	case order_For_account::OWNOWN: data = "OWNOWN"; break;
	case order_For_account::OWNCLI: data = "OWNCLI"; break;
	case order_For_account::OWNDUP: data = "OWNDUP"; break;
	case order_For_account::CLICLI: data = "CLICLI"; break;
	default: data = ""; break;
	}
 
	add_or_replace_field("FOR_ACCOUNT", data);
}
 
void Ttransaction::settle_date(tm param)
{
	char DT[100];
	if (std::strftime(DT, sizeof(DT), "%Y%m%d", &param))
	{
		add_or_replace_field("SETTLE_DATE", DT);
	}
}
 
void Ttransaction::kill_if_linked_order_partly_field(bool param)
{
	add_or_replace_field("KILL_IF_LINKED_ORDER_PARTLY_FILLED", (param ? "YES" : "NO"));
}
 
std::string sendTransaction(Ttransaction & T)
{
 
	std::string ans;
 
	int length = (int)T.param_keeper.size();
 
	lua_settop(T.L, 0);
	lua_getglobal(T.L, "sendTransaction"); // 1 -2
	lua_createtable(T.L, 0, length);
 
	for (int i = 0; i < length; i++)
	{
		lua_pushfstring(T.L, T.param_keeper[i].arg.c_str());
		lua_setfield(T.L, -2, T.param_keeper[i].fieldName.c_str());
	}
 
	lua_call(T.L, 1, 1);
 
	if (lua_isnil(T.L, -1) || lua_tostring(T.L, -1) == "")
		ans = "";
	else
		ans = lua_tostring(T.L, -1);
 
	return ans;
}
 
void Ttransaction::reset_Table(DB_QueryParams params)
{
	lua_settop(L, 0);
 
	this->params = params;
	if (param_keeper.size() > 0)
		param_keeper.clear();
 
	lua_getglobal(L, "getSecurityInfo");
	lua_pushfstring(L, params.class_code.c_str());
	lua_pushfstring(L, params.sec_code.c_str());
 
	lua_call(L, 2, 1);
	lua_getfield(L, -1, "scale");
	scale = (int)lua_tonumber(L, -1);
 
	lua_settop(L, 0);
 
	lua_getglobal(L, "getParamEx");
	lua_pushfstring(L, params.class_code.c_str());
	lua_pushfstring(L, params.sec_code.c_str());
	lua_pushfstring(L, "SEC_PRICE_STEP");
 
	lua_call(L, 3, 1);
	lua_getfield(L, -1, "param_value");
	price_step = lua_tonumber(L, -1);
}
 
Ttransaction::Ttransaction(const Ttransaction & other)
{
	this->L = other.L;
	this->scale = other.scale;
	this->price_step = other.price_step;
	this->params = other.params;
 
	this->param_keeper.reserve(other.param_keeper.size());
	std::copy(other.param_keeper.begin(), other.param_keeper.end(), std::back_inserter(this->param_keeper));
}

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

Пример использования таблицы транзакций

C++:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
#include "Ttransaction.h"
 
BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
 return TRUE;
}
 
void msg_ToQuik(lua_State *L, std::string msg, int num)
{
 lua_settop(L, 0);
 
 lua_getglobal(L, "message");
 lua_pushfstring(L, msg.c_str());
 lua_pushnumber(L, num);
 lua_call(L, 2, 0);
}
 
void market_order(lua_State *L, DB_QueryParams params, order_Operation operation, double borderPrice, int qty)
{
 Ttransaction T(L, params);
 
 T.trans_id();
 T.account();
 T.classcode();
 T.seccode();
 T.action(order_Action::NEW_ORDER);
 T.type(borderPrice == 0 ? order_Type::M : order_Type::L);
 T.operation(operation);
 T.price(borderPrice);
 T.quantity(qty);
 
 std::string res = sendTransaction(T);
 if (res.compare("") != 0)
 {
 msg_ToQuik(L, res, 3);
 }
 
}
 
int _main(lua_State *L)
{
 
 DB_QueryParams params;
 params.account = "NL0011100043";
 params.class_code = "QJSIM";
 params.sec_code = "ROSN";
 
 market_order(L, params, order_Operation::S, 313.15, 1);
 
 return 0;
}
 
static struct luaL_reg ls_lib[] = {
 { NULL, NULL }
};
extern "C" LUALIB_API int luaopen_Project2(lua_State *L)
{
 
 lua_pushcfunction(L, _main);
 lua_setglobal(L, "main");
 
 return 0;
}

Lua:

1
require("ProjectName"); 

 

Обмен данными между DLL (C/C++) и приложением QT Creator (C++)

Автор записи: NewDracon

Для начала объясню, почему я выбрал для связки с QUIK'ом именно QT и зачем нужен этот "велосипед". Дело в том, что захотелось побольше графических возможностей, а если использовать Visual Studio С++ (а не C#), то готовых компонентов для "рисования" графиков практически нет. А C# или java в сравнению с QT С++ будут уступать в скорости, которая  необходима для тестирования стратегий. (Последнее спорно, но, по моему мнению, все же C++ "ближе" к процессорному языку, и код тестов QT в будущем можно будет перенести на unix)

И тут начались грабли... Если заходил со стороны прямой компиляции LUA для QT, не хотел подключаться QUIK (написанный на MVSC). Затем я попробовал создать DLL на MVSC и подключиться динамически к ней из QT, но export'ы DLL просто не виделась в QT. И тут я наткнулся на замечательную статью Обмен данными между DLL (C/C++) и приложением C# посредством Memory Mapped File (MMF). Ниже привожу мою адаптацию данной статьи на QT Ctreator. При этом использовалась среда Visual Studio 2017 С++ для написания DLL и среда QT Creator 5.3 с компилятором MinGW 4.8.

Смотреть полностью...

Таблица "Портфель" в QUIKе

Автор записи: ram555

Представляю таблицу для портфельных инвестиций.  Цвет строки меняется если Прибыль%<>5%. Обновление каждые 5 сек. Показаны только бумаги с лимитом Т0, для недопущения дублирования. Если хотите, чтоб были бумаги только с лимитом Т2, замените в двух местах «limitKind<1» на «limitKind>1»

Для её создания необходимо:
1. Создать файл «tablePortfolio.txt» в папке «C:\QUIK\Scripts». Если папки нет, создать её.
2. Скопировать туда код скрипта
3. Сохранить, выбрав кодировку «ANSI», иначе вместо русских букв могут быть кракозябры.
4. Сменить расширение файла с ".txt" на ".lua"
5. Запустить скрипт командой Сервисы-> Lua  скрипты-> Добавить (выбрать файл tablePortfolio.lua) -> Запустить

Код скрипта
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
IsRun = true
class_code="TQBR"
 
function main()
   -- Получает доступный id для создания
   t_id = AllocTable()
 
   -- добавить столбцы
   AddColumn(t_id, 1, "Бумага",       true, QTABLE_STRING_TYPE, 20)
   AddColumn(t_id, 2, "Кол-во",       true, QTABLE_INT_TYPE,     7)
   AddColumn(t_id, 3, "Цена покупки", true, QTABLE_DOUBLE_TYPE, 14)
   AddColumn(t_id, 4, "Цена текущая", true, QTABLE_DOUBLE_TYPE,   14)
   AddColumn(t_id, 5, "Прибыль, р",   true, QTABLE_DOUBLE_TYPE,   14)
   AddColumn(t_id, 6, "Прибыль, %",   true, QTABLE_DOUBLE_TYPE, 14)
   t = CreateWindow(t_id)
 
   for iRow=1, getNumberOf("depo_limits")-1, 1 do
      rowInPortfolioTable = getItem("depo_limits", iRow) -- получить текущую строку из таблицы "Лимиты по бумагам"
      qtyBoughtLots  = tonumber(rowInPortfolioTable.currentbal)
      limitKind = rowInPortfolioTable.limit_kind
      if qtyBoughtLots>0 and limitKind<1 then
         InsertRow(t_id, iRow)-- добавить новую строку вниз таблицы
      end
   end
   local rows, columns = GetTableSize (t_id)
   InsertRow(t_id, rows+1) -- добавить новую строку вниз таблицы для "Итого"
 
   SetWindowCaption(t_id, "Портфель: прибыли и убытки    © ramirzaev@mail.ru")
 
   -- исполнять цикл, пока пользователь не остановит скрипт или не закроет окно таблицы
   while IsRun do
      if IsWindowClosed(t_id)==true then
         IsRun=false
      end
 
      local currentPrice=0
      local qtyBoughtLots=0
      local profitAbs = 0
      local profitPerc = 0
      local currentSecCode= ""
      local fullNameOfInstrument = ""
      local limitKind = 0
      local rowInPortfolioTable = {}    -- строка из таблицы "Лимиты по бумагам"
      local tableInstrument = {}    -- данные "Таблицы текущих торгов"
      local iRowInOutTable = 1
	  local totalInvest = 0
	  local totalPortfolio = 0
	  local totalProfit = 0
	  local totalPercent = 0
 
      for iRow=0, getNumberOf("depo_limits")-1, 1 do
         rowInPortfolioTable = getItem("depo_limits", iRow) -- получить текущую строку из таблицы "Лимиты по бумагам"
 
         qtyBoughtLots  = tonumber(rowInPortfolioTable.currentbal)
 
         limitKind = rowInPortfolioTable.limit_kind
 
         if qtyBoughtLots>0 and limitKind<1    then      -- если кол-во лотов >0 и тип лимита T0
            currentSecCode = rowInPortfolioTable.sec_code
            fullNameOfInstrument =  tostring(getParamEx(class_code, currentSecCode, "SHORTNAME").param_image or "0") --"LONGNAME"
            avgPrice       = tonumber(rowInPortfolioTable.awg_position_price)
            currentPrice = GetAskPrice(currentSecCode)
            profitAbs = (currentPrice-avgPrice)*qtyBoughtLots
            profitPerc    = 100*currentPrice/avgPrice   - 100
 
			totalInvest = totalInvest + avgPrice*qtyBoughtLots
			totalPortfolio = totalPortfolio + currentPrice*qtyBoughtLots
 
            SetCell(t_id, iRowInOutTable, 1, fullNameOfInstrument) -- "Бумага"
            SetCell(t_id, iRowInOutTable, 2, tostring(qtyBoughtLots)) -- "Кол-во"RemoveZero(tostring(qtyBoughtLots)))
            SetCell(t_id, iRowInOutTable, 3, tostring( math_round(avgPrice, 3) ))  -- tostring(avgPrice))   -- "Цена покупки"
            SetCell(t_id, iRowInOutTable, 4, RemoveZero(tostring(currentPrice)))   -- "Цена текущая"
            SetCell(t_id, iRowInOutTable, 5, tostring( math_round( profitAbs, 0)) ) -- "Прибыль, р"
            SetCell(t_id, iRowInOutTable, 6, tostring(math_round(profitPerc, 1)) .."%") -- "Прибыль, %"
 
            if profitPerc >5 then       -- окрашиваем
               ColourRowInGreen(iRowInOutTable)
            elseif profitPerc<-5 then
               ColourRowInRed(iRowInOutTable)
            else
               ColourRowInYellow(iRowInOutTable)
            end
            iRowInOutTable = iRowInOutTable+1
         end
      end
      totalProfit = totalPortfolio - totalInvest
      totalPercent   = 100*totalProfit/totalInvest
	  SetCell(t_id, iRowInOutTable, 1, "Итого")
      SetCell(t_id, iRowInOutTable, 3, tostring( math_round(totalInvest, 0) ))
      SetCell(t_id, iRowInOutTable, 4, tostring( math_round(totalPortfolio, 0)))
      SetCell(t_id, iRowInOutTable, 5, tostring( math_round( totalProfit, 0)) )
      SetCell(t_id, iRowInOutTable, 6, tostring(math_round(totalPercent, 1)) .."%")
 
	  if profitPerc >5 then       -- окрашиваем
               ColourRowInGreen(iRowInOutTable)
            elseif profitPerc<-5 then
               ColourRowInRed(iRowInOutTable)
            else
               ColourRowInYellow(iRowInOutTable)
            end
            iRowInOutTable = iRowInOutTable+1
      sleep(5000) -- пауза 5 сек.
      end
   --message("script table portfolio finished")
end
 
 
function ColourRowInRed(num_row)
   SetColor(t_id, num_row, QTABLE_NO_INDEX, RGB(255,150,150), RGB(0,0,0), RGB(255,150,150), RGB(0,0,0))
end
function ColourRowInYellow(num_row)
   SetColor(t_id, num_row, QTABLE_NO_INDEX, RGB(255,255,200), RGB(0,0,0), RGB(255,255,200), RGB(0,0,0))
end
function ColourRowInGreen(num_row)
   SetColor(t_id, num_row, QTABLE_NO_INDEX, RGB(150,255,150), RGB(0,0,0), RGB(150,255,150), RGB(0,0,0))
end
function GetAskPrice(inp_Sec_Code )
   local ask = tostring(getParamEx(class_code, inp_Sec_Code, "OFFER").param_value or 0)
   return ask
end
-- Округляет число до указанной точности
function math_round (num, idp)
   local mult = 10^(idp or 0)
   return math.floor(num * mult + 0.5) / mult
end
-- удаление точки и нулей после нее
function RemoveZero(str)
   while (string.sub(str,-1) == "0" and str ~= "0") do
      str = string.sub(str,1,-2)
   end
   if (string.sub(str,-1) == ".") then
      str = string.sub(str,1,-2)
   end
   return str
end
function OnStop()
   DestroyTable(t_id)
   IsRun = false
end

ПОСТАНОВКА И СНЯТИЕ STOP-ОРДЕРА В QLUA(LUA)

Автор записи: ram555

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

Самая распространенная ошибка начинающего программиста отправка в SendTransaction в STOP_ORDER_KEY  trans_id стоп-ордера

Робот выставляет стоп-заявку на покупку по определенной цене, затем через 2 секунды снимает её.

Также в коде имеются следующие фишки:

  • Запись удобочитаемого лог-файла.  Записи с интервалом <=1 сек. группируются в пул. Между пулами - пустая строка. После остановки скрипта в файл добавляется двойная линия.
  • Функция преобразования числа в строку с удалением точки и нулей правее нее для отправки этой строки в SendTransaction
  • Функция, возвращающая Entry или Exit в зависимости от trans_id принадлежности транзакций к входу или выходу
Код скрипта
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
--/*НАСТРАИВАЕМЫЕ ПАРАМЕТРЫ*/
NAME_OF_STRATEGY = 'Str1_' -- НАЗВАНИЕ СТРАТЕГИИ (не более 9 символов!)
CLASS_CODE = "QJSIM" -- Код класса SPBFUT
SEC_CODE = "SBER" -- Код бумаги SiZ6 SiH7, SiM7, SiU7
ACCOUNT = "NL0011100043" -- Идентификатор счета SPBFUT00355
CLIENT_CODE = NAME_OF_STRATEGY..SEC_CODE -- "Код клиента"
QTY_LOTS = "1" -- Кол-во торгуемых лотов
FILE_LOG_NAME = "C:\\TRADING\\QUIK Junior\\Scripts\\Log.txt" -- ИМЯ ЛОГ-ФАЙЛА
 
--/*РАБОЧИЕ ПЕРЕМЕННЫЕ РОБОТА (менять не нужно)*/
g_price_step = 0 -- ШАГ ЦЕНЫ ИНСТРУМЕНТА
g_trans_id_entry = 110001 -- Задает начальный номер ID транзакций на вход
g_trans_id_exit = 220001 -- Задает начальный номер ID транзакций на выход
g_arrTransId_entry = {} -- массив ID транзакций на вход
g_arrTransId_exit = {} -- массив ID транзакций на выход
g_transId_del_order = "1234" -- ID ордера на удаление заявки (не меняется)
g_transId_del_stopOrder = "6789" -- ID ордера на удаление стоп заявки (не меняется)
g_currentPosition = 0 -- в позиции? сколько лотов и какое направление
g_IsTrallingStop = false -- выставлен ли трейлинг стоп на сервере
g_stopOrderEntry_num= "" -- номер стоп-заявки на вход в системе, по которому её можно снять
g_stopOrderExit_num = "" -- номер стоп-заявки на выход в системе, по которому её можно снять
g_order_num = "" -- номер заявки в системе, по которому её можно снять
g_oldTrade_num = "" -- номер предыдущей обработанной сделки
g_previous_time = os.time() -- помещение в переменную времени сервера в формате HHMMSS
isRun = true -- Флаг поддержания работы бесконечного цикла в main
 
function OnInit()
   -- Получает ШАГ ЦЕНЫ ИНСТРУМЕНТА
    g_price_step = getParamEx(CLASS_CODE, SEC_CODE, "SEC_PRICE_STEP").param_value
 
    f = io.open(FILE_LOG_NAME, "a+") -- открывает файл
    myLog("Initialization finished")
end
function main()
   g_trans_id_exit = g_trans_id_exit + 1
   g_arrTransId_exit[#g_arrTransId_exit+1] = g_trans_id_exit
 
   SendStopOrder("131.9", QTY_LOTS, "B", g_trans_id_exit) -- Отправить стоп ордер
   sleep(2000)                                            -- через 2 секунды
   DeleteStopOrder(g_stopOrderExit_num)                   -- удалить стоп-ордер
 
   while isRun do
      sleep(5000) -- обрабатываем цикл с задержкой 5сек.
   end
end
 
-- функция вызывается терминалом ТЕРМИНАЛОМ QUIK при остановке скрипта
function OnStop()
   myLog("Script Stoped")
   f:close() -- Закрывает файл
   isRun = false
end
 
function SendStopOrder(stopPrice, quantity, operation, trans_id)
   local offset=50 -- отступ для гарантированного исполнения ордера по рынку (в кол-ве шагов цены)
   local price
   local direction
 
   if operation=="B" then
      price = stopPrice + g_price_step*offset
      direction = "5" -- Направленность стоп-цены. «5» - больше или равно
   else
      price = stopPrice - g_price_step*offset
      direction = "4" -- Направленность стоп-цены. «4» - меньше или равно
   end
   --message("stopPrice"..stopPrice)
   --Пошлем стоп заявку
   local Transaction = {
                       ['ACTION'] = "NEW_STOP_ORDER",
                       ['PRICE'] = tostring(price),
                       ['EXPIRY_DATE'] = "TODAY",--"GTC", -- на учебном серве только стоп-заявки с истечением сегодня, потом поменять на GTC
                       ['STOPPRICE'] = tostring(stopPrice),
                       ['STOP_ORDER_KIND'] = "SIMPLE_STOP_ORDER",
                       ['TRANS_ID'] = removeZero(tostring(trans_id)),
                       ['CLASSCODE'] = CLASS_CODE,
                       ['SECCODE'] = SEC_CODE,
                       ['ACCOUNT'] = ACCOUNT,
                       ['CLIENT_CODE'] = CLIENT_CODE, -- Комментарий к транзакции, который будет виден в транзакциях, заявках и сделках
                       ['TYPE'] = "L",
                       ['OPERATION'] = tostring(operation),
                       ['CONDITION'] = direction, -- Направленность стоп-цены. Возможные значения: «4» - меньше или равно, «5» – больше или равно
                       ['QUANTITY'] = tostring(math.abs(quantity))
                       }
   local res = sendTransaction(Transaction)
   if string.len(res) ~= 0 then
      message('Error: '..res, 3)
      myLog("SendStopOrder(): Error "..res)
   else
      myLog("SendStopOrder(): "..EntryOrExit(trans_id).."; trans_id="..trans_id)
   end
end
 
function DeleteStopOrder(stopOrder_num)
   local Transaction = {
                       ['ACTION'] = "KILL_STOP_ORDER",
                       ['CLASSCODE'] = CLASS_CODE,
                       ['SECCODE'] = SEC_CODE,
                       ['ACCOUNT'] = ACCOUNT,
                       ['CLIENT_CODE'] = CLIENT_CODE,
                       ['TYPE'] = "L",
                       ['STOP_ORDER_KIND'] = "SIMPLE_STOP_ORDER",
                       ['TRANS_ID'] = g_transId_del_order, -- ID УДАЛЯЮЩЕЙ транзакции
                       ['STOP_ORDER_KEY'] = tostring(stopOrder_num)
                       }
 
   local res = sendTransaction(Transaction)
   if string.len(res) ~= 0 then
      message('Error: '..res, 3)
      myLog("DeleteStopOrder(): fail "..res)
   else
      myLog("DeleteStopOrder(): "..stopOrder_num.." success ")
   end
end
-- создан/изменен/сработал стоп-ордер
function OnStopOrder(stopOrder)
   -- Если не относится к роботу, выходит из функции
   if stopOrder.brokerref:find(CLIENT_CODE) == nil then return end
 
   local string state="_" -- состояние заявки
   --бит 0 (0x1) Заявка активна, иначе не активна
   if bit.band(stopOrder.flags,0x1)==0x1 then
      state="стоп-заявка создана"
      if EntryOrExit(stopOrder.trans_id) == "Entry" then
         g_stopOrderEntry_num = stopOrder.order_num
      end
      if EntryOrExit(stopOrder.trans_id) == "Exit" then
         g_stopOrderExit_num = stopOrder.order_num
      end
   end
   if bit.band(stopOrder.flags,0x2)==0x1 or stopOrder.flags==26 then
      state="стоп-заявка снята"
   end
   if bit.band(stopOrder.flags,0x2)==0x0 and bit.band(stopOrder.flags,0x1)==0x0 then
      state="стоп-ордер исполнен"
   end
   if bit.band(stopOrder.flags,0x400)==0x1 then
      state="стоп-заявка сработала, но была отвергнута торговой системой"
   end
   if bit.band(stopOrder.flags,0x800)==0x1 then
      state="стоп-заявка сработала, но не прошла контроль лимитов"
   end
   if state=="_" then
      state="Набор битовых флагов="..tostring(stopOrder.flags)
   end
   myLog("OnStopOrder(): sec_code="..stopOrder.sec_code.."; "..EntryOrExit(stopOrder.trans_id)..";\t"..state..
         "; condition_price="..stopOrder.condition_price.."; transID="..stopOrder.trans_id.."; order_num="..stopOrder.order_num )
end
------------------------- Сервисные функции--------------------
-- функция записывает в лог строчку с временем и датой
function myLog(str)
   if f==nil then return end
 
   local current_time=os.time()--tonumber(timeformat(getInfoParam("SERVERTIME"))) -- помещене в переменную времени сервера в формате HHMMSS
   if (current_time-g_previous_time)>1 then -- если текущая запись произошла позже 1 секунды, чем предыдущая
      f:write("\n") -- добавляем пустую строку для удобства чтения
   end
   g_previous_time = current_time
 
   f:write(os.date().."; ".. str .. ";\n")
 
   if str:find("Script Stoped") ~= nil then
      f:write("======================================================================================================================\n\n")
      f:write("======================================================================================================================\n")
   end
   f:flush() -- Сохраняет изменения в файле
end
-- удаление точки и нулей после нее
function removeZero(str)
   while (string.sub(str,-1) == "0" and str ~= "0") do
      str = string.sub(str,1,-2)
   end
   if (string.sub(str,-1) == ".") then
      str = string.sub(str,1,-2)
   end
   return str
end
-- Возвращает Entry или Exit в зависимости от trans_id
function EntryOrExit(trans_id)
   if isArrayContain(g_arrTransId_entry, trans_id) then
      return "Entry"
   elseif isArrayContain(g_arrTransId_exit, trans_id) then
      return "Exit"
   elseif trans_id==g_transId_del_order then
      return "DeleteOrder"
   elseif trans_id==g_transId_del_stopOrder then
      return "DeleteStopOrder"
   else
      return "NoId"
   end
end
 
function isArrayContain(array, value)
   if #array < 1 then return end
      for i=1, #array do
         if array[i]==value then
         return true
      end
   end
   return false
end

В итоге получается текстовый  лог-файл, удобный для чтения человеком, с которого можно считать данные программой (например на  C#) и подбить статистику

Log.txt

01/17/17 19:34:56; Initialization finished;
01/17/17 19:34:56; SendStopOrder(): Exit; trans_id=220002;
01/17/17 19:34:56; OnStopOrder(): sec_code=SBER; Exit; стоп-заявка создана; condition_price=131.9; transID=220002; order_num=7902164;

01/17/17 19:34:58; DeleteStopOrder(): 7902164 success ;
01/17/17 19:34:58; OnStopOrder(): sec_code=SBER; Exit; стоп-заявка снята; condition_price=131.9; transID=220002; order_num=7902164;

01/17/17 19:35:01; Script Stoped;
======================================================================================================================

======================================================================================================================

Если у Вас появились какие-то вопросы, задайте их в комментариях под статьей !!!