SDK Guard 1.0.1
SDK для связи с сетевыми контроллерами Iron logic
ilg_cpp_helpers.h
См. документацию.
1
7#pragma once
8
9#include <chrono>
10#include <exception>
11#include <string>
12#include <vector>
13
14#include "ilguard.h"
15
16namespace ilg {
17
18class CConverter; // forward declaration
19
24class CILGException : public std::exception {
25public:
32
34 virtual const char* what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW;
35
36public:
38};
39
48void ILGCheck(ilg_status nCode);
49
55class CKeyNumber : public ilg_key_number {
56public:
58 CKeyNumber();
59
65 CKeyNumber(const ilg_key_number& other);
66
74 CKeyNumber(uint8_t nEmSeries, uint16_t nEmNumber, uint32_t nFacility = 0);
75
82 CKeyNumber(const uint8_t* pData, size_t nSize);
83
89 const CKeyNumber& operator=(const ilg_key_number& other) {
91 return *this;
92 }
93
95 void Clear();
96
103 void Assign(const uint8_t* pData, size_t nSize);
104};
105
112 friend class CILG;
113 friend class CConverterSearch;
114 friend class CConverter;
115 friend class CController;
116
117public:
119 CILGHandle();
120
127
129 CILGHandle(const CILGHandle&) = delete;
130
136 CILGHandle(CILGHandle&& other);
137
139 virtual ~CILGHandle();
140
142 CILGHandle& operator=(const CILGHandle&) = delete;
143
150
152 operator ilg_handle() const;
153
155 explicit operator bool() const;
156
162 void Swap(CILGHandle& other) noexcept;
163
165 ilg_handle Get() const;
166
171 void Close();
172
178 void Attach(ilg_handle h);
179
186
187protected:
189};
190
196class CAsyncCommand : public CILGHandle {
197public:
200
207
214
216 virtual ~CAsyncCommand();
217
220
225 inline void Cancel();
226
233 inline ilg_status GetStatus() const;
234
243 inline void GetProgress(size_t& nCurrent, size_t& nTotal) const;
244};
245
247 ILGCheck(ilg_command_cancel(m_h));
248}
249
251 ilg_status res;
252 ILGCheck(ilg_command_get_status(m_h, &res));
253 return res;
254}
255
256inline void CAsyncCommand::GetProgress(size_t& nCurrent, size_t& nTotal) const {
257 ILGCheck(ilg_command_get_progress(m_h, &nCurrent, &nTotal));
258}
259
266public:
269
276
283
285 virtual ~CConverterSearch();
286
289
307 void* pUserData = nullptr);
308
327 inline void EnableMessageQueue(bool fEnable = true);
328
340 inline bool GetMessage(ilg_search_msg& nMsg, const void*& pMsgData) const;
341
352 inline void SetOptions(const ilg_search_options& rOptions);
353
361 inline void GetOptions(ilg_search_options& rOptions) const;
362
377 inline void SetListenPorts(const uint16_t* pPorts, size_t nCount);
378
390 void GetListenPorts(std::vector<uint16_t>& oPorts) const;
391
404 inline ilg_status GetListenStatus(uint16_t nTcpPort) const;
405
417 inline void Scan(bool fReset = false);
418
429 inline CAsyncCommand Begin_Scan(bool fReset = false);
430
440 inline size_t GetConverterCount() const;
441
450 inline void GetConverterInfo(size_t nIdx, ilg_converter_info& rInfo) const;
451
465 inline void SetAutoScan(bool fEnable = true, bool fWait = true);
466
477 inline CAsyncCommand Begin_SetAutoScan(bool fEnable);
478
486 inline bool GetAutoScan() const;
487
505 inline int OpenPort(ilg_port_type nPortType, const char* pszPortName,
506 ilg_converter_info* pInfo = nullptr);
507
519 inline CAsyncCommand Begin_OpenPort(ilg_port_type nPortType, const char* pszPortName);
520
530 static inline void End_OpenPort(ilg_handle hCommand, int& PortFD, ilg_converter_info& rInfo);
531
545 inline void ClosePort(ilg_port_type nPortType, const char* pszPortName, int hPort);
546
559 inline CAsyncCommand Begin_ClosePort(ilg_port_type nPortType, const char* pszPortName,
560 int hPortFD);
561
566 inline CConverterSearch Clone() const;
567};
568
570 void* pUserData) {
571 ILGCheck(ilg_search_set_message_callback(m_h, pCallback, pUserData));
572}
573
574inline void CConverterSearch::EnableMessageQueue(bool fEnable) {
575 ILGCheck(ilg_search_enable_message_queue(m_h, (ilg_bool)fEnable));
576}
577
578inline bool CConverterSearch::GetMessage(ilg_search_msg& nMsg, const void*& pMsgData) const {
579 ilg_bool f;
580 ILGCheck(ilg_search_get_message(m_h, &nMsg, &pMsgData, &f));
581 return f;
582}
583
585 ILGCheck(ilg_search_set_options(m_h, &rOptions));
586}
587
589 ILGCheck(ilg_search_get_options(m_h, &rOptions));
590}
591
592inline void CConverterSearch::SetListenPorts(const uint16_t* pPorts, size_t nCount) {
593 ILGCheck(ilg_search_set_listen_ports(m_h, pPorts, nCount));
594}
595
597 ilg_status res;
598 ILGCheck(ilg_search_get_listen_status(m_h, nTcpPort, &res));
599 return res;
600}
601
602inline void CConverterSearch::Scan(bool fReset) {
603 ILGCheck(ilg_search_scan(m_h, (ilg_bool)fReset));
604}
605
607 size_t res;
608 ILGCheck(ilg_search_get_converter_count(m_h, &res));
609 return res;
610}
611
612inline void CConverterSearch::GetConverterInfo(size_t nIdx, ilg_converter_info& rInfo) const {
613 ILGCheck(ilg_search_get_converter_info(m_h, nIdx, &rInfo));
614}
615
616inline void CConverterSearch::SetAutoScan(bool fEnable, bool fWait) {
617 ILGCheck(ilg_search_set_auto_scan(m_h, (ilg_bool)fEnable, (ilg_bool)fWait));
618}
619
620inline bool CConverterSearch::GetAutoScan() const {
621 ilg_bool f;
622 ILGCheck(ilg_search_get_auto_scan(m_h, &f));
623 return static_cast<bool>(f);
624}
625
626inline int CConverterSearch::OpenPort(ilg_port_type nPortType, const char* pszPortName,
627 ilg_converter_info* pInfo) {
628 int fd;
629 ILGCheck(ilg_search_open_port(m_h, nPortType, pszPortName, pInfo, &fd));
630 return fd;
631}
632
633inline void CConverterSearch::ClosePort(ilg_port_type nPortType, const char* pszPortName,
634 int hPort) {
635 ILGCheck(ilg_search_close_port(m_h, nPortType, pszPortName, hPort));
636}
637
639 CAsyncCommand res;
640 ILGCheck(ilg_search_begin_scan(m_h, (ilg_bool)fReset, &res.m_h));
641 return res;
642}
643
645 CAsyncCommand res;
646 ILGCheck(ilg_search_begin_set_auto_scan(m_h, (ilg_bool)fEnable, &res.m_h));
647 return res;
648}
649
651 const char* pszPortName) {
652 CAsyncCommand res;
653 ILGCheck(ilg_search_begin_open_port(m_h, nPortType, pszPortName, &res.m_h));
654 return res;
655}
656
657inline void CConverterSearch::End_OpenPort(ilg_handle hCommand, int& PortFD,
658 ilg_converter_info& rInfo) {
659 ILGCheck(ilg_search_end_open_port(hCommand, &PortFD, &rInfo));
660}
661
663 const char* pszPortName, int hPortFD) {
664 CAsyncCommand res;
665 ILGCheck(ilg_search_begin_close_port(m_h, nPortType, pszPortName, hPortFD, &res.m_h));
666 return res;
667}
668
670 ilg_handle hNewHandle;
671 ILGCheck(ilg_clone_handle(m_h, &hNewHandle));
672 return CConverterSearch(hNewHandle);
673}
674
680class CController : public CILGHandle {
681public:
683 CController();
684
691
697 CController(CController&& other);
698
700 virtual ~CController();
701
704
723 void* pUserData = nullptr);
724
743 inline void EnableMessageQueue(bool fEnable = true);
744
756 inline bool GetMessage(ilg_controller_msg& nMsg, const void*& pMsgData) const;
757
765 inline void SetOptions(const ilg_controller_options& rOptions);
766
774 inline void GetOptions(ilg_controller_options& rOptions);
775
785 inline void Connect(bool fReconnect = false);
786
796 inline CAsyncCommand Begin_Connect(bool fReconnect = false);
797
805 inline void Disconnect();
806
815
824
832 inline void GetControllerInfo(ilg_controller_info& rInfo) const;
833
841 inline void GetConverterInfo(ilg_converter_info& rInfo) const;
842
848 inline CConverter GetConverter() const;
849
857 std::string ReadLines();
858
867
876 static void End_ReadLines(ilg_handle hCommand, std::string& sLines);
877
891 inline void ReadLockTimes(uint8_t nBankN, uint16_t& nOpen, uint16_t& nLet, uint16_t& nMax,
892 bool& fBigTime);
893
903 inline CAsyncCommand Begin_ReadLockTimes(uint8_t nBankN);
904
916 static inline void End_ReadLockTimes(ilg_handle hCommand, uint16_t& nOpen, uint16_t& nLet,
917 uint16_t& nMax, bool& fBigTime);
918
932 inline void WriteLockTimes(uint8_t nBankN, uint16_t nOpen, uint16_t nLet, uint16_t nMax,
933 bool fBigTime);
934
948 inline CAsyncCommand Begin_WriteLockTimes(uint8_t nBankN, uint16_t nOpen, uint16_t nLet,
949 uint16_t nMax, bool fBigTime);
950
961 inline void ReadApbTime(bool& fEnabled, uint16_t& nMinutes);
962
971
981 static inline void End_ReadApbTime(ilg_handle hCommand, bool& fEnabled, uint16_t& nMinutes);
982
993 inline void WriteApbTime(bool fEnabled, uint16_t nMinutes);
994
1005 inline CAsyncCommand Begin_WriteApbTime(bool fEnabled, uint16_t nMinutes);
1006
1021 inline void ReadTimeZones(uint8_t nBankN, size_t nIdx, ilg_time_zone* pBuf, size_t nCount,
1022 size_t* pRead = nullptr);
1023
1035 inline CAsyncCommand Begin_ReadTimeZones(uint8_t nBankN, size_t nIdx, size_t nCount);
1036
1048 static inline void End_ReadTimeZones(ilg_handle hCommand, const ilg_time_zone*& pList,
1049 size_t& nRead);
1050
1065 inline void WriteTimeZones(uint8_t nBankN, size_t nIdx, const ilg_time_zone* pTZs,
1066 size_t nCount, size_t* pWritten = nullptr);
1067
1080 inline CAsyncCommand Begin_WriteTimeZones(uint8_t nBankN, size_t nIdx,
1081 const ilg_time_zone* pTZs, size_t nCount);
1082
1092 static inline void End_WriteTimeZones(ilg_handle hCommand, size_t& nWritten);
1093
1107 inline void ReadModeTimeZones(size_t nIdx, ilg_mode_time_zone* pBuf, size_t nCount);
1108
1120 inline CAsyncCommand Begin_ReadModeTimZones(size_t nIdx, size_t nCount);
1121
1132 static inline void End_ReadModeTimZones(ilg_handle hCommand, const ilg_mode_time_zone*& pList,
1133 size_t& nRead);
1134
1148 inline void WriteModeTimeZones(size_t nIdx, const ilg_mode_time_zone* pTZs, size_t nCount);
1149
1162 inline CAsyncCommand Begin_WriteModeTimeZones(size_t nIdx, const ilg_mode_time_zone* pTZs,
1163 size_t nCount);
1164
1179 inline void ReadKeys(uint8_t nBankN, size_t nIdx, ilg_key* pBuf, size_t nCount,
1180 size_t* pRead = nullptr);
1181
1193 inline CAsyncCommand Begin_ReadKeys(uint8_t nBankN, size_t nIdx, size_t nCount);
1194
1206 static inline void End_ReadKeys(ilg_handle hCommand, const ilg_key*& pList, size_t& nRead);
1207
1226 inline void WriteKeys(uint8_t nBankN, size_t nIdx, const ilg_key* pKeys, size_t nCount,
1227 size_t* pWritten = nullptr, bool fSelected = false);
1228
1243 inline CAsyncCommand Begin_WriteKeys(uint8_t nBankN, size_t nIdx, const ilg_key* pKeys,
1244 size_t nCount, bool fSelected = false);
1245
1255 static inline void End_WriteKeys(ilg_handle hCommand, size_t& nWritten);
1256
1270 inline void EraseKeys(uint8_t nBankN, size_t nIdx, size_t nCount, size_t* pErased = nullptr);
1271
1283 inline CAsyncCommand Begin_EraseKeys(uint8_t nBankN, size_t nIdx, size_t nCount);
1284
1294 static inline void End_EraseKeys(ilg_handle hCommand, size_t& nErased);
1295
1309 inline void EraseKeys2(uint8_t nBankN, const size_t* pIdxs, size_t nCount,
1310 size_t* pErased = nullptr);
1311
1323 inline CAsyncCommand Begin_EraseKeys2(uint8_t nBankN, const size_t* pIdxs, size_t nCount);
1324
1334 static inline void End_EraseKeys2(ilg_handle hCommand, size_t& nErased);
1335
1350 inline ssize_t ReadKeyTopIdx(uint8_t nBankN);
1351
1361 inline CAsyncCommand Begin_ReadKeyTopIdx(uint8_t nBankN);
1362
1372 static inline void End_ReadKeyTopIdx(ilg_handle hCommand, ssize_t& nIdx);
1373
1389 inline void ReadEvents(size_t nIdx, uint64_t* pBuf, size_t nCount, size_t* pRead = nullptr);
1390
1401 inline CAsyncCommand Begin_ReadEvents(size_t nIdx, size_t nCount);
1402
1414 static inline void End_ReadEvents(ilg_handle hCommand, const uint64_t*& pList, size_t& nRead);
1415
1423 inline void WriteEventReadIdx(size_t nIdx);
1424
1436 inline CAsyncCommand Begin_WriteEventReadIdx(size_t nIdx);
1437
1447 inline void ReadRtcParams(ilg_rtc_params& rParams);
1448
1457
1466 static inline void End_ReadRtcParams(ilg_handle hCommand, ilg_rtc_params& rParams);
1467
1475 inline void GetRtcParams(ilg_rtc_params& rParams);
1476
1486 inline void ReadExtAskParams(ilg_extask_params& rParams);
1487
1496
1505 static inline void End_ReadExtAskParams(ilg_handle hCommand, ilg_extask_params& rParams);
1506
1514 inline void GetExtAskParams(ilg_extask_params& rParams);
1515
1524 inline void SyncClock();
1525
1536
1546 inline void SetEmergencyMode(bool fEnable);
1547
1557 inline CAsyncCommand Begin_SetEmergencyMode(bool fEnable);
1558
1569 inline void ReadAntiCovid(uint16_t* pMax8, uint16_t* pCount8);
1570
1579
1589 static inline void End_ReadAntiCovid(ilg_handle hCommand, uint16_t* pMax8, uint16_t* pCount8);
1590
1600 inline void WriteAntiCovid(const uint16_t* pMax8);
1601
1611 inline CAsyncCommand Begin_WriteAntiCovid(const uint16_t* pMax8);
1612
1622 inline void OpenDoor(bool fOut);
1623
1633 inline CAsyncCommand Begin_OpenDoor(bool fOut);
1634
1644 inline void SetFireMode(bool fOn);
1645
1655 inline CAsyncCommand Begin_SetFireMode(bool fOn);
1656
1666 inline void SetSecurityMode(bool fOn);
1667
1677 inline CAsyncCommand Begin_SetSecurityMode(bool fOn);
1678
1688 inline void SetAlarmMode(bool fOn);
1689
1699 inline CAsyncCommand Begin_SetAlarmMode(bool fOn);
1700
1710 inline void SetEcPower(bool fOn);
1711
1721 inline CAsyncCommand Begin_SetEcPower(bool fOn);
1722
1741 inline void ReadFireParams(uint8_t& nSrcMask, uint8_t& nLimitT, uint8_t& nState, uint8_t& nT);
1742
1751
1763 static inline void End_ReadFireParams(ilg_handle hCommand, uint8_t& nSrcMask, uint8_t& nLimitT,
1764 uint8_t& nState, uint8_t& nT);
1765
1778 inline void WriteFireParams(uint8_t nSrcMask, uint8_t nLimitT, uint8_t* pState = nullptr,
1779 uint8_t* pT = nullptr);
1780
1791 inline CAsyncCommand Begin_WriteFireParams(uint8_t nSrcMask, uint8_t nLimitT);
1792
1802 static inline void End_WriteFireParams(ilg_handle hCommand, uint8_t& nState, uint8_t& nT);
1803
1824 inline void ReadSecurityParams(uint8_t& nSrcMask, uint8_t& nTime, uint8_t& nState);
1825
1834
1845 static inline void End_ReadSecurityParams(ilg_handle hCommand, uint8_t& nSrcMask,
1846 uint8_t& nTime, uint8_t& nState);
1847
1859 inline void WriteSecurityParams(uint8_t nSrcMask, uint8_t nTime, uint8_t* pState = nullptr);
1860
1871 inline CAsyncCommand Begin_WriteSecurityParams(uint8_t nSrcMask, uint8_t nTime);
1872
1881 static inline void End_WriteSecurityParams(ilg_handle hCommand, uint8_t& nState);
1882
1906 inline void ReadEcParams(uint8_t& nPowerConfig, uint8_t& nDelay, uint8_t* pState = nullptr);
1907
1916
1927 static inline void End_ReadEcParams(ilg_handle hCommand, uint8_t& nPowerConfig, uint8_t& nDelay,
1928 uint8_t* pState = nullptr);
1929
1939 inline void WriteMode(ilg_controller_mode nMode);
1940
1951
1965 inline ilg_controller_mode ReadMode(uint8_t* pFlags = nullptr);
1966
1975
1985 static inline void End_ReadMode(ilg_handle hCommand, ilg_controller_mode& nMode,
1986 uint8_t* pFlags = nullptr);
1987
1999 inline void WriteConfiguration(const void* pData, size_t nSize);
2000
2011 inline CAsyncCommand Begin_WriteConfiguration(const void* pData, size_t nSize);
2012
2022 void ReadConfiguration(std::vector<uint8_t>& oData);
2023
2032
2041 static void End_ReadConfiguration(ilg_handle hCommand, std::vector<uint8_t>& oData);
2042
2053 inline void SetNetworkAddress(uint8_t nAddress);
2054
2064 inline CAsyncCommand Begin_SetNetworkAddress(uint8_t nAddress);
2065
2076 inline void SetFirmware(const void* pData, size_t nSize);
2077
2088 inline CAsyncCommand Begin_SetFirmware(const void* pData, size_t nSize);
2089
2099 inline ilg_event_type DecodeEventType(const uint64_t& nEvent,
2100 ilg_event_format* pFormat = nullptr);
2101
2113 inline void DecodePassageEvent(const uint64_t& nEvent, ilg_controller_time& rTime,
2114 ilg_direction& nDirection, uint8_t& nKeyBankN, ssize_t& nKeyIdx);
2115
2124 inline void DecodeTimeEvent(const uint64_t& nEvent, ilg_controller_time& rTime);
2125
2137 inline void DecodeControllerModeEvent(const uint64_t& nEvent, ilg_controller_time& rTime,
2138 ilg_controller_mode& nMode, uint8_t& nFlags,
2139 uint8_t& nTrigger);
2140
2151 inline void DecodeStateEvent(const uint64_t& nEvent, ilg_controller_time& rTime,
2152 uint8_t& nFlags, uint8_t& nTrigger);
2153
2162 inline void DecodeKeyNumber(const uint64_t& nEvent, ilg_key_number& rKeyNumber);
2163
2168 inline CController Clone() const;
2169};
2170
2172 void* pUserData) {
2173 ILGCheck(ilg_controller_set_message_callback(m_h, pCallback, pUserData));
2174}
2175
2176inline void CController::EnableMessageQueue(bool fEnable) {
2177 ILGCheck(ilg_controller_enable_message_queue(m_h, static_cast<ilg_bool>(fEnable)));
2178}
2179
2180inline bool CController::GetMessage(ilg_controller_msg& nMsg, const void*& pMsgData) const {
2181 ilg_bool res;
2182 ILGCheck(ilg_controller_get_message(m_h, &nMsg, &pMsgData, &res));
2183 return static_cast<bool>(res);
2184}
2185
2187 ILGCheck(ilg_controller_set_options(m_h, &rOptions));
2188}
2189
2191 ILGCheck(ilg_controller_get_options(m_h, &rOptions));
2192}
2193
2194inline void CController::Connect(bool fReconnect) {
2195 ILGCheck(ilg_controller_connect(m_h, static_cast<ilg_bool>(fReconnect)));
2196}
2197
2199 CAsyncCommand res;
2200 ILGCheck(ilg_controller_begin_connect(m_h, static_cast<ilg_bool>(fReconnect), &res.m_h));
2201 return res;
2202}
2203
2205 ILGCheck(ilg_controller_disconnect(m_h));
2206}
2207
2209 CAsyncCommand res;
2210 ILGCheck(ilg_controller_begin_disconnect(m_h, &res.m_h));
2211 return res;
2212}
2213
2217 return res;
2218}
2219
2221 ILGCheck(ilg_controller_get_info(m_h, &rInfo));
2222}
2223
2225 ILGCheck(ilg_controller_get_converter_info(m_h, &rInfo));
2226}
2227
2229 CAsyncCommand res;
2230 ILGCheck(ilg_controller_begin_read_lines(m_h, &res.m_h));
2231 return res;
2232}
2233
2234inline void CController::ReadLockTimes(uint8_t nBankN, uint16_t& nOpen, uint16_t& nLet,
2235 uint16_t& nMax, bool& fBigTime) {
2236 ilg_bool f;
2237 ILGCheck(ilg_controller_read_lock_times(m_h, nBankN, &nOpen, &nLet, &nMax, &f));
2238 fBigTime = f;
2239}
2240
2242 CAsyncCommand res;
2243 ILGCheck(ilg_controller_begin_read_lock_times(m_h, nBankN, &res.m_h));
2244 return res;
2245}
2246
2247inline void CController::End_ReadLockTimes(ilg_handle hCommand, uint16_t& nOpen, uint16_t& nLet,
2248 uint16_t& nMax, bool& fBigTime) {
2249 ilg_bool f;
2250 ILGCheck(ilg_controller_end_read_lock_times(hCommand, &nOpen, &nLet, &nMax, &f));
2251 fBigTime = f;
2252}
2253
2254inline void CController::WriteLockTimes(uint8_t nBankN, uint16_t nOpen, uint16_t nLet,
2255 uint16_t nMax, bool fBigTime) {
2256 ILGCheck(ilg_controller_write_lock_times(m_h, nBankN, nOpen, nLet, nMax,
2257 static_cast<ilg_bool>(fBigTime)));
2258}
2259
2260inline CAsyncCommand CController::Begin_WriteLockTimes(uint8_t nBankN, uint16_t nOpen,
2261 uint16_t nLet, uint16_t nMax,
2262 bool fBigTime) {
2263 CAsyncCommand res;
2264 ILGCheck(ilg_controller_begin_write_lock_times(m_h, nBankN, nOpen, nLet, nMax,
2265 static_cast<ilg_bool>(fBigTime), &res.m_h));
2266 return res;
2267}
2268
2269inline void CController::ReadApbTime(bool& fEnabled, uint16_t& nMinutes) {
2270 ilg_bool f;
2271 ILGCheck(ilg_controller_read_apb_time(m_h, &f, &nMinutes));
2272 fEnabled = static_cast<bool>(f);
2273}
2274
2276 CAsyncCommand res;
2278 return res;
2279}
2280
2281inline void CController::End_ReadApbTime(ilg_handle hCommand, bool& fEnabled, uint16_t& nMinutes) {
2282 ilg_bool f;
2283 ILGCheck(ilg_controller_end_read_apb_time(hCommand, &f, &nMinutes));
2284 fEnabled = static_cast<bool>(f);
2285}
2286
2287inline void CController::WriteApbTime(bool fEnabled, uint16_t nMinutes) {
2288 ILGCheck(ilg_controller_write_apb_time(m_h, static_cast<ilg_bool>(fEnabled), nMinutes));
2289}
2290
2291inline CAsyncCommand CController::Begin_WriteApbTime(bool fEnabled, uint16_t nMinutes) {
2292 CAsyncCommand res;
2293 ILGCheck(ilg_controller_begin_write_apb_time(m_h, static_cast<ilg_bool>(fEnabled), nMinutes,
2294 &res.m_h));
2295 return res;
2296}
2297
2298inline void CController::ReadTimeZones(uint8_t nBankN, size_t nIdx, ilg_time_zone* pBuf,
2299 size_t nCount, size_t* pRead) {
2300 ILGCheck(ilg_controller_read_time_zones(m_h, nBankN, nIdx, pBuf, nCount, pRead));
2301}
2302
2303inline CAsyncCommand CController::Begin_ReadTimeZones(uint8_t nBankN, size_t nIdx, size_t nCount) {
2304 CAsyncCommand res;
2305 ILGCheck(ilg_controller_begin_read_time_zones(m_h, nBankN, nIdx, nCount, &res.m_h));
2306 return res;
2307}
2308
2309inline void CController::End_ReadTimeZones(ilg_handle hCommand, const ilg_time_zone*& pList,
2310 size_t& nRead) {
2311 ILGCheck(ilg_controller_end_read_time_zones(hCommand, &pList, &nRead));
2312}
2313
2314inline void CController::WriteTimeZones(uint8_t nBankN, size_t nIdx, const ilg_time_zone* pTZs,
2315 size_t nCount, size_t* pWritten) {
2316 ILGCheck(ilg_controller_write_time_zones(m_h, nBankN, nIdx, pTZs, nCount, pWritten));
2317}
2318
2319inline CAsyncCommand CController::Begin_WriteTimeZones(uint8_t nBankN, size_t nIdx,
2320 const ilg_time_zone* pTZs, size_t nCount) {
2321 CAsyncCommand res;
2322 ILGCheck(ilg_controller_begin_write_time_zones(m_h, nBankN, nIdx, pTZs, nCount, &res.m_h));
2323 return res;
2324}
2325
2326inline void CController::End_WriteTimeZones(ilg_handle hCommand, size_t& nWritten) {
2327 ILGCheck(ilg_controller_end_write_time_zones(hCommand, &nWritten));
2328}
2329
2330inline void CController::ReadModeTimeZones(size_t nIdx, ilg_mode_time_zone* pBuf, size_t nCount) {
2331 ILGCheck(ilg_controller_read_mode_time_zones(m_h, nIdx, pBuf, nCount));
2332}
2333
2334inline CAsyncCommand CController::Begin_ReadModeTimZones(size_t nIdx, size_t nCount) {
2335 CAsyncCommand res;
2336 ILGCheck(ilg_controller_begin_read_mode_time_zones(m_h, nIdx, nCount, &res.m_h));
2337 return res;
2338}
2339
2341 size_t& nRead) {
2342 ILGCheck(ilg_controller_end_read_mode_time_zones(hCommand, &pList, &nRead));
2343}
2344
2345inline void CController::WriteModeTimeZones(size_t nIdx, const ilg_mode_time_zone* pTZs,
2346 size_t nCount) {
2347 ILGCheck(ilg_controller_write_mode_time_zones(m_h, nIdx, pTZs, nCount));
2348}
2349
2351 const ilg_mode_time_zone* pTZs,
2352 size_t nCount) {
2353 CAsyncCommand res;
2354 ILGCheck(ilg_controller_begin_write_mode_time_zones(m_h, nIdx, pTZs, nCount, &res.m_h));
2355 return res;
2356}
2357
2358inline void CController::ReadKeys(uint8_t nBankN, size_t nIdx, ilg_key* pBuf, size_t nCount,
2359 size_t* pRead) {
2360 ILGCheck(ilg_controller_read_keys(m_h, nBankN, nIdx, pBuf, nCount, pRead));
2361}
2362
2363inline CAsyncCommand CController::Begin_ReadKeys(uint8_t nBankN, size_t nIdx, size_t nCount) {
2364 CAsyncCommand res;
2365 ILGCheck(ilg_controller_begin_read_keys(m_h, nBankN, nIdx, nCount, &res.m_h));
2366 return res;
2367}
2368
2369inline void CController::End_ReadKeys(ilg_handle hCommand, const ilg_key*& pList, size_t& nRead) {
2370 ILGCheck(ilg_controller_end_read_keys(hCommand, &pList, &nRead));
2371}
2372
2373inline void CController::WriteKeys(uint8_t nBankN, size_t nIdx, const ilg_key* pKeys, size_t nCount,
2374 size_t* pWritten, bool fSelected) {
2375 ILGCheck(ilg_controller_write_keys(m_h, nBankN, nIdx, pKeys, nCount, pWritten,
2376 static_cast<ilg_bool>(fSelected)));
2377}
2378
2379inline CAsyncCommand CController::Begin_WriteKeys(uint8_t nBankN, size_t nIdx, const ilg_key* pKeys,
2380 size_t nCount, bool fSelected) {
2381 CAsyncCommand res;
2382 ILGCheck(ilg_controller_begin_write_keys(m_h, nBankN, nIdx, pKeys, nCount,
2383 static_cast<ilg_bool>(fSelected), &res.m_h));
2384 return res;
2385}
2386
2387inline void CController::End_WriteKeys(ilg_handle hCommand, size_t& nWritten) {
2388 ILGCheck(ilg_controller_end_write_keys(hCommand, &nWritten));
2389}
2390
2391inline void CController::EraseKeys(uint8_t nBankN, size_t nIdx, size_t nCount, size_t* pErased) {
2392 ILGCheck(ilg_controller_erase_keys(m_h, nBankN, nIdx, nCount, pErased));
2393}
2394
2395inline CAsyncCommand CController::Begin_EraseKeys(uint8_t nBankN, size_t nIdx, size_t nCount) {
2396 CAsyncCommand res;
2397 ILGCheck(ilg_controller_begin_erase_keys(m_h, nBankN, nIdx, nCount, &res.m_h));
2398 return res;
2399}
2400
2401inline void CController::End_EraseKeys(ilg_handle hCommand, size_t& nErased) {
2402 ILGCheck(ilg_controller_end_erase_keys(hCommand, &nErased));
2403}
2404
2405inline void CController::EraseKeys2(uint8_t nBankN, const size_t* pIdxs, size_t nCount,
2406 size_t* pErased) {
2407 ILGCheck(ilg_controller_erase_keys2(m_h, nBankN, pIdxs, nCount, pErased));
2408}
2409
2410inline CAsyncCommand CController::Begin_EraseKeys2(uint8_t nBankN, const size_t* pIdxs,
2411 size_t nCount) {
2412 CAsyncCommand res;
2413 ILGCheck(ilg_controller_begin_erase_keys2(m_h, nBankN, pIdxs, nCount, &res.m_h));
2414 return res;
2415}
2416
2417inline void CController::End_EraseKeys2(ilg_handle hCommand, size_t& nErased) {
2418 ILGCheck(ilg_controller_end_erase_keys2(hCommand, &nErased));
2419}
2420
2421inline ssize_t CController::ReadKeyTopIdx(uint8_t nBankN) {
2422 ssize_t res;
2423 ILGCheck(ilg_controller_read_key_top_idx(m_h, nBankN, &res));
2424 return res;
2425}
2426
2428 CAsyncCommand res;
2429 ILGCheck(ilg_controller_begin_read_key_top_idx(m_h, nBankN, &res.m_h));
2430 return res;
2431}
2432
2433inline void CController::End_ReadKeyTopIdx(ilg_handle hCommand, ssize_t& nIdx) {
2434 ILGCheck(ilg_controller_end_read_key_top_idx(hCommand, &nIdx));
2435}
2436
2437inline void CController::ReadEvents(size_t nIdx, uint64_t* pBuf, size_t nCount, size_t* pRead) {
2438 ILGCheck(ilg_controller_read_events(m_h, nIdx, pBuf, nCount, pRead));
2439}
2440
2441inline CAsyncCommand CController::Begin_ReadEvents(size_t nIdx, size_t nCount) {
2442 CAsyncCommand res;
2443 ILGCheck(ilg_controller_begin_read_events(m_h, nIdx, nCount, &res.m_h));
2444 return res;
2445}
2446
2447inline void CController::End_ReadEvents(ilg_handle hCommand, const uint64_t*& pList,
2448 size_t& nRead) {
2449 ILGCheck(ilg_controller_end_read_events(hCommand, &pList, &nRead));
2450}
2451
2452inline void CController::WriteEventReadIdx(size_t nIdx) {
2454}
2455
2457 CAsyncCommand res;
2458 ILGCheck(ilg_controller_begin_write_event_read_idx(m_h, nIdx, &res.m_h));
2459 return res;
2460}
2461
2463 ILGCheck(ilg_controller_read_rtc_params(m_h, &rParams));
2464}
2465
2467 CAsyncCommand res;
2469 return res;
2470}
2471
2473 ILGCheck(ilg_controller_end_read_rtc_params(hCommand, &rParams));
2474}
2475
2477 ILGCheck(ilg_controller_get_rtc_params(m_h, &rParams));
2478}
2479
2481 ILGCheck(ilg_controller_read_extask_params(m_h, &rParams));
2482}
2483
2485 CAsyncCommand res;
2487 return res;
2488}
2489
2491 ILGCheck(ilg_controller_end_read_extask_params(hCommand, &rParams));
2492}
2493
2495 ILGCheck(ilg_controller_get_extask_params(m_h, &rParams));
2496}
2497
2499 ILGCheck(ilg_controller_sync_clock(m_h));
2500}
2501
2503 CAsyncCommand res;
2504 ILGCheck(ilg_controller_begin_sync_clock(m_h, &res.m_h));
2505 return res;
2506}
2507
2508inline void CController::SetEmergencyMode(bool fEnable) {
2509 ILGCheck(ilg_controller_set_emergency_mode(m_h, static_cast<ilg_bool>(fEnable)));
2510}
2511
2513 CAsyncCommand res;
2514 ILGCheck(
2515 ilg_controller_begin_set_emergency_mode(m_h, static_cast<ilg_bool>(fEnable), &res.m_h));
2516 return res;
2517}
2518
2519inline void CController::ReadAntiCovid(uint16_t* pMax8, uint16_t* pCount8) {
2520 ILGCheck(ilg_controller_read_anticovid(m_h, pMax8, pCount8));
2521}
2522
2524 CAsyncCommand res;
2526 return res;
2527}
2528
2529inline void CController::End_ReadAntiCovid(ilg_handle hCommand, uint16_t* pMax8,
2530 uint16_t* pCount8) {
2531 ILGCheck(ilg_controller_end_read_anticovid(hCommand, pMax8, pCount8));
2532}
2533
2534inline void CController::WriteAntiCovid(const uint16_t* pMax8) {
2535 ILGCheck(ilg_controller_write_anticovid(m_h, pMax8));
2536}
2537
2539 CAsyncCommand res;
2540 ILGCheck(ilg_controller_begin_write_anticovid(m_h, pMax8, &res.m_h));
2541 return res;
2542}
2543
2544inline void CController::OpenDoor(bool fOut) {
2545 ILGCheck(ilg_controller_open_door(m_h, static_cast<ilg_bool>(fOut)));
2546}
2547
2549 CAsyncCommand res;
2550 ILGCheck(ilg_controller_begin_open_door(m_h, static_cast<ilg_bool>(fOut), &res.m_h));
2551 return res;
2552}
2553
2554inline void CController::SetFireMode(bool fOn) {
2555 ILGCheck(ilg_controller_set_fire_mode(m_h, static_cast<ilg_bool>(fOn)));
2556}
2557
2559 CAsyncCommand res;
2560 ILGCheck(ilg_controller_begin_set_fire_mode(m_h, static_cast<ilg_bool>(fOn), &res.m_h));
2561 return res;
2562}
2563
2564inline void CController::SetSecurityMode(bool fOn) {
2565 ILGCheck(ilg_controller_set_security_mode(m_h, static_cast<ilg_bool>(fOn)));
2566}
2567
2569 CAsyncCommand res;
2570 ILGCheck(ilg_controller_begin_set_security_mode(m_h, static_cast<ilg_bool>(fOn), &res.m_h));
2571 return res;
2572}
2573
2574inline void CController::SetAlarmMode(bool fOn) {
2575 ILGCheck(ilg_controller_set_alarm_mode(m_h, static_cast<ilg_bool>(fOn)));
2576}
2577
2579 CAsyncCommand res;
2580 ILGCheck(ilg_controller_begin_set_alarm_mode(m_h, static_cast<ilg_bool>(fOn), &res.m_h));
2581 return res;
2582}
2583
2584inline void CController::SetEcPower(bool fOn) {
2585 ILGCheck(ilg_controller_set_ec_power(m_h, static_cast<ilg_bool>(fOn)));
2586}
2587
2589 CAsyncCommand res;
2590 ILGCheck(ilg_controller_begin_set_ec_power(m_h, static_cast<ilg_bool>(fOn), &res.m_h));
2591 return res;
2592}
2593
2594inline void CController::ReadFireParams(uint8_t& nSrcMask, uint8_t& nLimitT, uint8_t& nState,
2595 uint8_t& nT) {
2596 ILGCheck(ilg_controller_read_fire_params(m_h, &nSrcMask, &nLimitT, &nState, &nT));
2597}
2598
2600 CAsyncCommand res;
2602 return res;
2603}
2604
2605inline void CController::End_ReadFireParams(ilg_handle hCommand, uint8_t& nSrcMask,
2606 uint8_t& nLimitT, uint8_t& nState, uint8_t& nT) {
2607 ILGCheck(ilg_controller_end_read_fire_params(hCommand, &nSrcMask, &nLimitT, &nState, &nT));
2608}
2609
2610inline void CController::WriteFireParams(uint8_t nSrcMask, uint8_t nLimitT, uint8_t* pState,
2611 uint8_t* pT) {
2612 ILGCheck(ilg_controller_write_fire_params(m_h, nSrcMask, nLimitT, pState, pT));
2613}
2614
2615inline CAsyncCommand CController::Begin_WriteFireParams(uint8_t nSrcMask, uint8_t nLimitT) {
2616 CAsyncCommand res;
2617 ILGCheck(ilg_controller_begin_write_fire_params(m_h, nSrcMask, nLimitT, &res.m_h));
2618 return res;
2619}
2620
2621inline void CController::End_WriteFireParams(ilg_handle hCommand, uint8_t& nState, uint8_t& nT) {
2622 ILGCheck(ilg_controller_end_write_fire_params(hCommand, &nState, &nT));
2623}
2624
2625inline void CController::ReadSecurityParams(uint8_t& nSrcMask, uint8_t& nTime, uint8_t& nState) {
2626 ILGCheck(ilg_controller_read_security_params(m_h, &nSrcMask, &nTime, &nState));
2627}
2628
2630 CAsyncCommand res;
2632 return res;
2633}
2634
2635inline void CController::End_ReadSecurityParams(ilg_handle hCommand, uint8_t& nSrcMask,
2636 uint8_t& nTime, uint8_t& nState) {
2637 ILGCheck(ilg_controller_end_read_security_params(hCommand, &nSrcMask, &nTime, &nState));
2638}
2639
2640inline void CController::WriteSecurityParams(uint8_t nSrcMask, uint8_t nTime, uint8_t* pState) {
2641 ILGCheck(ilg_controller_write_security_params(m_h, nSrcMask, nTime, pState));
2642}
2643
2644inline CAsyncCommand CController::Begin_WriteSecurityParams(uint8_t nSrcMask, uint8_t nTime) {
2645 CAsyncCommand res;
2646 ILGCheck(ilg_controller_begin_write_security_params(m_h, nSrcMask, nTime, &res.m_h));
2647 return res;
2648}
2649
2650inline void CController::End_WriteSecurityParams(ilg_handle hCommand, uint8_t& nState) {
2651 ILGCheck(ilg_controller_end_write_security_params(hCommand, &nState));
2652}
2653
2654inline void CController::ReadEcParams(uint8_t& nPowerConfig, uint8_t& nDelay, uint8_t* pState) {
2655 ILGCheck(ilg_controller_read_ec_params(m_h, &nPowerConfig, &nDelay, pState));
2656}
2657
2659 CAsyncCommand res;
2661 return res;
2662}
2663
2664inline void CController::End_ReadEcParams(ilg_handle hCommand, uint8_t& nPowerConfig,
2665 uint8_t& nDelay, uint8_t* pState) {
2666 ILGCheck(ilg_controller_end_read_ec_params(hCommand, &nPowerConfig, &nDelay, pState));
2667}
2668
2670 ILGCheck(ilg_controller_write_mode(m_h, nMode));
2671}
2672
2674 CAsyncCommand res;
2675 ILGCheck(ilg_controller_begin_write_mode(m_h, nMode, &res.m_h));
2676 return res;
2677}
2678
2681 ILGCheck(ilg_controller_read_mode(m_h, &res, pFlags));
2682 return res;
2683}
2684
2686 CAsyncCommand res;
2687 ILGCheck(ilg_controller_begin_read_mode(m_h, &res.m_h));
2688 return res;
2689}
2690
2692 uint8_t* pFlags) {
2693 ILGCheck(ilg_controller_end_read_mode(hCommand, &nMode, pFlags));
2694}
2695
2696inline void CController::WriteConfiguration(const void* pData, size_t nSize) {
2697 ILGCheck(ilg_controller_write_configuration(m_h, pData, nSize));
2698}
2699
2700inline CAsyncCommand CController::Begin_WriteConfiguration(const void* pData, size_t nSize) {
2701 CAsyncCommand res;
2702 ILGCheck(ilg_controller_begin_write_configuration(m_h, pData, nSize, &res.m_h));
2703 return res;
2704}
2705
2707 CAsyncCommand res;
2709 return res;
2710}
2711
2712inline void CController::SetNetworkAddress(uint8_t nAddress) {
2713 ILGCheck(ilg_controller_set_network_address(m_h, nAddress));
2714}
2715
2717 CAsyncCommand res;
2718 ILGCheck(ilg_controller_begin_set_network_address(m_h, nAddress, &res.m_h));
2719 return res;
2720}
2721
2722inline void CController::SetFirmware(const void* pData, size_t nSize) {
2723 ILGCheck(ilg_controller_set_firmware(m_h, pData, nSize));
2724}
2725
2726inline CAsyncCommand CController::Begin_SetFirmware(const void* pData, size_t nSize) {
2727 CAsyncCommand res;
2728 ILGCheck(ilg_controller_begin_set_firmware(m_h, pData, nSize, &res.m_h));
2729 return res;
2730}
2731
2732inline ilg_event_type CController::DecodeEventType(const uint64_t& nEvent,
2733 ilg_event_format* pFormat) {
2734 ilg_event_type res;
2735 ILGCheck(ilg_controller_decode_event_type(m_h, nEvent, pFormat, &res));
2736 return res;
2737}
2738
2739inline void CController::DecodePassageEvent(const uint64_t& nEvent, ilg_controller_time& rTime,
2740 ilg_direction& nDirection, uint8_t& nKeyBankN,
2741 ssize_t& nKeyIdx) {
2742 ILGCheck(ilg_controller_decode_passage_event(m_h, nEvent, &rTime, &nDirection, &nKeyBankN,
2743 &nKeyIdx));
2744}
2745
2746inline void CController::DecodeTimeEvent(const uint64_t& nEvent, ilg_controller_time& rTime) {
2747 ILGCheck(ilg_controller_decode_time_event(m_h, nEvent, &rTime));
2748}
2749
2750inline void CController::DecodeControllerModeEvent(const uint64_t& nEvent,
2751 ilg_controller_time& rTime,
2752 ilg_controller_mode& nMode, uint8_t& nFlags,
2753 uint8_t& nTrigger) {
2754 ILGCheck(ilg_controller_decode_controller_mode_event(m_h, nEvent, &rTime, &nMode, &nFlags,
2755 &nTrigger));
2756}
2757
2758inline void CController::DecodeStateEvent(const uint64_t& nEvent, ilg_controller_time& rTime,
2759 uint8_t& nFlags, uint8_t& nTrigger) {
2760 ILGCheck(ilg_controller_decode_state_event(m_h, nEvent, &rTime, &nFlags, &nTrigger));
2761}
2762
2763inline void CController::DecodeKeyNumber(const uint64_t& nEvent, ilg_key_number& rKeyNumber) {
2764 ILGCheck(ilg_controller_decode_key_number(m_h, nEvent, &rKeyNumber));
2765}
2766
2768 ilg_handle hNewHandle;
2769 ILGCheck(ilg_clone_handle(m_h, &hNewHandle));
2770 return CController(hNewHandle);
2771}
2772
2778class CConverter : public CILGHandle {
2779public:
2781 CConverter();
2782
2789
2795 CConverter(CConverter&& other);
2796
2798 virtual ~CConverter();
2799
2802
2818 void* pUserData = nullptr);
2819
2842 inline void EnableMessageQueue(bool fEnable = true);
2843
2855 inline bool GetMessage(ilg_converter_msg& nMsg, const void*& pMsgData) const;
2856
2864 inline void SetOptions(const ilg_converter_options& rOptions);
2865
2873 inline void GetOptions(ilg_converter_options& rOptions) const;
2874
2886 inline void Connect(bool fReconnect = false);
2887
2897 inline CAsyncCommand Begin_Connect(bool fReconnect = false);
2898
2907 inline void Disconnect();
2908
2917
2926
2937 inline void GetConverterInfo(ilg_converter_info& rInfo) const;
2938
2949 inline void ReadLicenseInfo(ilg_license_info& rInfo, bool fForce = false);
2950
2961 inline void ReadLicenseInfo(uint32_t nLicenseN, ilg_license_info& rInfo);
2962
2974 inline CAsyncCommand Begin_ReadLicenseInfo(uint32_t nLicenseN);
2975
2984 static inline void End_ReadLicenseInfo(ilg_handle hCommand, ilg_license_info& rInfo);
2985
3000 inline size_t GetLicenseCount() const;
3001
3012 inline CAsyncCommand Begin_GetLicenseCount() const;
3013
3022 static inline void End_GetLicenseCount(ilg_handle hCommand, size_t& nCount);
3023
3032 inline void GetLicenseInfo(size_t nIdx, ilg_license_info& rInfo) const;
3033
3045 inline void WriteLicense(const void* pData, size_t nSize);
3046
3060 inline void WriteLicense(uint32_t nLicenseN, const void* pData, size_t nSize,
3061 ilg_license_info* pInfo = nullptr);
3062
3076 inline CAsyncCommand Begin_WriteLicense(uint32_t nLicenseN, const void* pData, size_t nSize);
3077
3086 static inline void End_WriteLicense(ilg_handle hCommand, ilg_license_info& rInfo);
3087
3099 inline void ClearLicenses(bool fDisconnect = false);
3100
3113 inline CAsyncCommand Begin_ClearLicenses(bool fDisconnect = false);
3114
3125 inline void Scan(bool fReset = false, bool fForce = false);
3126
3137 inline CAsyncCommand Begin_Scan(bool fReset = false, bool fForce = false);
3138
3146 inline size_t GetControllerCount() const;
3147
3156 inline void GetControllerInfo(size_t nIdx, ilg_controller_info& rInfo) const;
3157
3169 inline void SetAutoScan(bool fEnable = true, bool fWait = false);
3170
3180 inline CAsyncCommand Begin_SetAutoScan(bool fEnable = true);
3181
3189 inline bool GetAutoScan() const;
3190
3201 inline void SetFirmware(const void* pData, size_t nSize);
3202
3213 inline CAsyncCommand Begin_SetFirmware(const void* pData, size_t nSize);
3214
3225 inline CController GetController(ilg_controller_model nModel, int nSn);
3226
3231 inline CConverter Clone() const;
3232};
3233
3235 ilg_handle hNewHandle;
3236 ILGCheck(ilg_controller_get_converter(m_h, &hNewHandle));
3237 return CConverter(hNewHandle);
3238}
3239
3241 void* pUserData) {
3242 ILGCheck(ilg_converter_set_message_callback(m_h, pCallback, pUserData));
3243}
3244
3245inline void CConverter::EnableMessageQueue(bool fEnable) {
3246 ILGCheck(ilg_converter_enable_message_queue(m_h, static_cast<ilg_bool>(fEnable)));
3247}
3248
3249inline bool CConverter::GetMessage(ilg_converter_msg& nMsg, const void*& pMsgData) const {
3250 ilg_bool f;
3251 ILGCheck(ilg_converter_get_message(m_h, &nMsg, &pMsgData, &f));
3252 return f;
3253}
3254
3255inline void CConverter::SetOptions(const ilg_converter_options& rOptions) {
3256 ILGCheck(ilg_converter_set_options(m_h, &rOptions));
3257}
3258
3259inline void CConverter::GetOptions(ilg_converter_options& rOptions) const {
3260 ILGCheck(ilg_converter_get_options(m_h, &rOptions));
3261}
3262
3263inline void CConverter::Connect(bool fReconnect) {
3264 ILGCheck(ilg_converter_connect(m_h, static_cast<ilg_bool>(fReconnect)));
3265}
3266
3268 CAsyncCommand res;
3269 ILGCheck(ilg_converter_begin_connect(m_h, static_cast<ilg_bool>(fReconnect), &res.m_h));
3270 return res;
3271}
3272
3274 ILGCheck(ilg_converter_disconnect(m_h));
3275}
3276
3278 CAsyncCommand res;
3279 ILGCheck(ilg_converter_begin_disconnect(m_h, &res.m_h));
3280 return res;
3281}
3282
3286 return res;
3287}
3288
3290 ILGCheck(ilg_converter_get_info(m_h, &rInfo));
3291}
3292
3293inline void CConverter::ReadLicenseInfo(ilg_license_info& rInfo, bool fForce) {
3294 ILGCheck(
3295 ilg_converter_read_license_info(m_h, &rInfo, ILG_LICENSE_N, static_cast<ilg_bool>(fForce)));
3296}
3297
3298inline void CConverter::ReadLicenseInfo(uint32_t nLicenseN, ilg_license_info& rInfo) {
3299 ILGCheck(ilg_converter_read_license_info(m_h, &rInfo, nLicenseN));
3300}
3301
3303 CAsyncCommand res;
3304 ILGCheck(ilg_converter_begin_read_license_info(m_h, nLicenseN, &res.m_h));
3305 return res;
3306}
3307
3309 ILGCheck(ilg_converter_end_read_license_info(hCommand, &rInfo));
3310}
3311
3312inline size_t CConverter::GetLicenseCount() const {
3313 size_t res = 0;
3314 ILGCheck(ilg_converter_get_license_count(m_h, &res));
3315 return res;
3316}
3317
3319 CAsyncCommand res;
3321 return res;
3322}
3323
3324inline void CConverter::End_GetLicenseCount(ilg_handle hCommand, size_t& nCount) {
3325 ILGCheck(ilg_converter_end_get_license_count(hCommand, &nCount));
3326}
3327
3328inline void CConverter::GetLicenseInfo(size_t nIdx, ilg_license_info& rInfo) const {
3329 ILGCheck(ilg_converter_get_license_info(m_h, nIdx, &rInfo));
3330}
3331
3332inline void CConverter::WriteLicense(const void* pData, size_t nSize) {
3333 ILGCheck(ilg_converter_write_license(m_h, pData, nSize, nullptr));
3334}
3335
3336inline void CConverter::WriteLicense(uint32_t nLicenseN, const void* pData, size_t nSize,
3337 ilg_license_info* pInfo) {
3338 ILGCheck(ilg_converter_write_license(m_h, pData, nSize, pInfo, nLicenseN));
3339}
3340
3341inline CAsyncCommand CConverter::Begin_WriteLicense(uint32_t nLicenseN, const void* pData,
3342 size_t nSize) {
3343 CAsyncCommand res;
3344 ILGCheck(ilg_converter_begin_write_license(m_h, pData, nSize, nLicenseN, &res.m_h));
3345 return res;
3346}
3347
3349 ILGCheck(ilg_converter_end_write_license(hCommand, &rInfo));
3350}
3351
3352inline void CConverter::ClearLicenses(bool fDisconnect) {
3353 ILGCheck(ilg_converter_clear_licenses(m_h, static_cast<ilg_bool>(fDisconnect)));
3354}
3355
3357 CAsyncCommand res;
3358 ILGCheck(ilg_converter_begin_clear_licenses(m_h, static_cast<ilg_bool>(fDisconnect), &res.m_h));
3359 return res;
3360}
3361
3362inline void CConverter::Scan(bool fReset, bool fForce) {
3363 ILGCheck(ilg_converter_scan(m_h, static_cast<ilg_bool>(fReset), static_cast<ilg_bool>(fForce)));
3364}
3365
3366inline CAsyncCommand CConverter::Begin_Scan(bool fReset, bool fForce) {
3367 CAsyncCommand res;
3368 ILGCheck(ilg_converter_begin_scan(m_h, static_cast<ilg_bool>(fReset),
3369 static_cast<ilg_bool>(fForce), &res.m_h));
3370 return res;
3371}
3372
3373inline size_t CConverter::GetControllerCount() const {
3374 size_t res = 0;
3375 ILGCheck(ilg_converter_get_controller_count(m_h, &res));
3376 return res;
3377}
3378
3379inline void CConverter::GetControllerInfo(size_t nIdx, ilg_controller_info& rInfo) const {
3380 ILGCheck(ilg_converter_get_controller_info(m_h, nIdx, &rInfo));
3381}
3382
3383inline void CConverter::SetAutoScan(bool fEnable, bool fWait) {
3384 ILGCheck(ilg_converter_set_auto_scan(m_h, static_cast<ilg_bool>(fEnable),
3385 static_cast<ilg_bool>(fWait)));
3386}
3387
3389 CAsyncCommand res;
3390 ILGCheck(ilg_converter_begin_set_auto_scan(m_h, static_cast<ilg_bool>(fEnable), &res.m_h));
3391 return res;
3392}
3393
3394inline bool CConverter::GetAutoScan() const {
3395 ilg_bool res;
3396 ILGCheck(ilg_converter_get_auto_scan(m_h, &res));
3397 return res;
3398}
3399
3400inline void CConverter::SetFirmware(const void* pData, size_t nSize) {
3401 ILGCheck(ilg_converter_set_firmware(m_h, pData, nSize));
3402}
3403
3404inline CAsyncCommand CConverter::Begin_SetFirmware(const void* pData, size_t nSize) {
3405 CAsyncCommand res;
3406 ILGCheck(ilg_converter_begin_set_firmware(m_h, pData, nSize, &res.m_h));
3407 return res;
3408}
3409
3411 CController res;
3412 ILGCheck(ilg_converter_get_controller(m_h, nModel, nSn, &res.m_h));
3413 return res;
3414}
3415
3417 ilg_handle hNewHandle;
3418 ILGCheck(ilg_clone_handle(m_h, &hNewHandle));
3419 return CConverter(hNewHandle);
3420}
3421
3425class CILG final {
3426public:
3432 CILG(bool fInit = true);
3433
3439 ~CILG();
3440
3442 void Init();
3443
3447 static inline uint32_t GetVersion();
3448
3454 static inline bool CheckVersion();
3455
3461 static inline void SetLogLevel(ilg_log_level nLevel);
3462
3475 static inline void SetLogCallback(ilg_logging_callback pCallback, void* pUserData = nullptr);
3476
3491 inline void SetFilterPortCallback(ilg_filter_port_callback pCallback,
3492 void* pUserData = nullptr);
3493
3501 inline void SetOptions(const ilg_options& rOptions);
3502
3510 inline void GetOptions(ilg_options& rOptions) const;
3511
3524 inline CConverterSearch GetSearch();
3525
3540 inline CConverter GetConverter(ilg_port_type nPortType, const char* pszPortName);
3541
3542protected:
3544 bool m_fInit = false;
3545};
3546
3547inline uint32_t CILG::GetVersion() {
3548 return ilg_get_version();
3549}
3550
3551inline bool CILG::CheckVersion() {
3552 return ilg_check_version();
3553}
3554
3556 ILGCheck(ilg_set_log_level(nLevel));
3557}
3558
3559inline void CILG::SetLogCallback(ilg_logging_callback pCallback, void* pUserData) {
3560 ILGCheck(ilg_set_log_callback(pCallback, pUserData));
3561}
3562
3563inline void CILG::SetFilterPortCallback(ilg_filter_port_callback pCallback, void* pUserData) {
3564 ILGCheck(ilg_set_filter_port_callback(pCallback, pUserData));
3565}
3566
3567inline void CILG::SetOptions(const ilg_options& rOptions) {
3568 ILGCheck(ilg_set_options(&rOptions));
3569}
3570
3571inline void CILG::GetOptions(ilg_options& rOptions) const {
3572 ILGCheck(ilg_get_options(&rOptions));
3573}
3574
3576 CConverterSearch res;
3577 ILGCheck(ilg_get_search(&res.m_h));
3578 return res;
3579}
3580
3581inline CConverter CILG::GetConverter(ilg_port_type nPortType, const char* pszPortName) {
3582 CConverter res;
3583 ILGCheck(ilg_get_converter(nPortType, pszPortName, &res.m_h));
3584 return res;
3585}
3586
3593#define GET_BIT(val, bitN) (bool)((val >> (bitN)) & 1)
3601#define SET_BIT(val, bitN, On) \
3602 { (On) ? ((val) |= (1 << (bitN))) : ((val) &= ~(1 << (bitN))); }
3603
3605inline std::chrono::steady_clock::time_point now() {
3606 return std::chrono::steady_clock::now();
3607}
3608
3614template <class result_t = std::chrono::milliseconds, class clock_t = std::chrono::steady_clock,
3615 class duration_t = std::chrono::milliseconds>
3616inline auto since(std::chrono::time_point<clock_t, duration_t> const& start) {
3617 return std::chrono::duration_cast<result_t>(clock_t::now() - start);
3618}
3619
3621extern const char* kPortTypeNames[ILG_PORT_TYPE_SIZE];
3623extern const char* kConverterModelNames[ILG_CONVERTER_MODEL_SIZE];
3625extern const char* kControllerModelNames[ILG_CONTROLLER_MODEL_SIZE];
3627extern const char* kConverterModeNames[ILG_CONVERTER_MODE_SIZE];
3628
3634std::string SdkVersionToStr(uint32_t nVersion);
3635
3641std::string VersionToStr(uint32_t nVersion);
3642
3648std::string TimeToStr(const int64_t& tTime);
3649
3659std::string KeyNumberToStr(const ilg_key_number& rNumber, uint32_t nKeyFlags, bool fWiegand);
3669bool TryStrToKeyNum(const char* pStr, ilg_key_number* pNumber, uint8_t* pKeyFlags);
3670
3681std::string KeybCodeToStr(const ilg_key_number& rNumber, int nDualIdx = -1, char chError = '_');
3682
3691bool TryParseKeybCodeStr(const char* pStr, ilg_key_number* pNumber);
3692
3693}; // namespace ilg
Класс команды SDK.
Definition: ilg_cpp_helpers.h:196
void Cancel()
Отменяет команду. Устанавливает статус ILG_E_ABORT.
Definition: ilg_cpp_helpers.h:246
ilg_status GetStatus() const
Возвращает состояние команды.
Definition: ilg_cpp_helpers.h:250
virtual ~CAsyncCommand()
Деструктор
Definition: ilg_cpp_helpers.cpp:128
CAsyncCommand()
Конструктор по умолчанию.
Definition: ilg_cpp_helpers.cpp:116
void GetProgress(size_t &nCurrent, size_t &nTotal) const
Возвращает состояние прогресса выполнения команды.
Definition: ilg_cpp_helpers.h:256
CAsyncCommand & operator=(CAsyncCommand &&other)
Оператор перемещения
Definition: ilg_cpp_helpers.cpp:131
Класс контроллера.
Definition: ilg_cpp_helpers.h:680
std::string ReadLines()
Читает информационные строки контроллера.
Definition: ilg_cpp_helpers.cpp:185
void ReadTimeZones(uint8_t nBankN, size_t nIdx, ilg_time_zone *pBuf, size_t nCount, size_t *pRead=nullptr)
Читает временные зоны из контроллера.
Definition: ilg_cpp_helpers.h:2298
CAsyncCommand Begin_WriteSecurityParams(uint8_t nSrcMask, uint8_t nTime)
Запускает асинхронную команду записи параметров режима охраны.
Definition: ilg_cpp_helpers.h:2644
void SetNetworkAddress(uint8_t nAddress)
Устанавливает сетевой адрес контроллеру.
Definition: ilg_cpp_helpers.h:2712
bool GetMessage(ilg_controller_msg &nMsg, const void *&pMsgData) const
Извлекает следующее сообщение из очереди.
Definition: ilg_cpp_helpers.h:2180
static void End_WriteTimeZones(ilg_handle hCommand, size_t &nWritten)
Возвращает результат записи временных зон.
Definition: ilg_cpp_helpers.h:2326
CAsyncCommand Begin_SetEcPower(bool fOn)
Запускает асинхронную команду вкл/выкл питания в режиме Электроконтроль.
Definition: ilg_cpp_helpers.h:2588
void Disconnect()
Отключается от контроллера.
Definition: ilg_cpp_helpers.h:2204
void GetRtcParams(ilg_rtc_params &rParams)
Возвращает результат авто опроса параметров RTC.
Definition: ilg_cpp_helpers.h:2476
CAsyncCommand Begin_WriteMode(ilg_controller_mode nMode)
Запускает асинхронную команду записи режима контроллера.
Definition: ilg_cpp_helpers.h:2673
CAsyncCommand Begin_WriteModeTimeZones(size_t nIdx, const ilg_mode_time_zone *pTZs, size_t nCount)
Запускает асинхронную команду записи временных зон для переключения режима контроллера.
Definition: ilg_cpp_helpers.h:2350
static void End_ReadTimeZones(ilg_handle hCommand, const ilg_time_zone *&pList, size_t &nRead)
Возвращает результат чтения временных зон.
Definition: ilg_cpp_helpers.h:2309
CAsyncCommand Begin_ReadExtAskParams()
Запускает асинхронную команду чтения параметров ExtAsk.
Definition: ilg_cpp_helpers.h:2484
static void End_ReadEcParams(ilg_handle hCommand, uint8_t &nPowerConfig, uint8_t &nDelay, uint8_t *pState=nullptr)
Возвращает результат чтения параметров режима ЭлектроКонтроль.
Definition: ilg_cpp_helpers.h:2664
CAsyncCommand Begin_ReadFireParams()
Запускает асинхронную команду чтения параметров противопожарного режима.
Definition: ilg_cpp_helpers.h:2599
static void End_ReadKeys(ilg_handle hCommand, const ilg_key *&pList, size_t &nRead)
Возвращает результат чтения ключей.
Definition: ilg_cpp_helpers.h:2369
void WriteAntiCovid(const uint16_t *pMax8)
Пишет максимумы AntiCovid.
Definition: ilg_cpp_helpers.h:2534
static void End_EraseKeys(ilg_handle hCommand, size_t &nErased)
Возвращает результат стирания ключей.
Definition: ilg_cpp_helpers.h:2401
static void End_EraseKeys2(ilg_handle hCommand, size_t &nErased)
Возвращает результат стирания ключей в указанных ячейках.
Definition: ilg_cpp_helpers.h:2417
CAsyncCommand Begin_WriteAntiCovid(const uint16_t *pMax8)
Запускает асинхронную команду записи максимумов AntiCovid.
Definition: ilg_cpp_helpers.h:2538
CAsyncCommand Begin_WriteFireParams(uint8_t nSrcMask, uint8_t nLimitT)
Запускает асинхронную команду записи параметров противопожарного режима.
Definition: ilg_cpp_helpers.h:2615
void SetEmergencyMode(bool fEnable)
Вкл/выкл старый режим аварийного открывания дверей.
Definition: ilg_cpp_helpers.h:2508
CAsyncCommand Begin_WriteTimeZones(uint8_t nBankN, size_t nIdx, const ilg_time_zone *pTZs, size_t nCount)
Запускает асинхронную команду записи временных зон.
Definition: ilg_cpp_helpers.h:2319
void WriteEventReadIdx(size_t nIdx)
Пишет позицию указателя чтения событий.
Definition: ilg_cpp_helpers.h:2452
void SetFireMode(bool fOn)
Вкл/выкл противопожарный режим.
Definition: ilg_cpp_helpers.h:2554
void GetOptions(ilg_controller_options &rOptions)
Возвращает параметры контроллера.
Definition: ilg_cpp_helpers.h:2190
void WriteConfiguration(const void *pData, size_t nSize)
Пишет конфигурацию контроллера.
Definition: ilg_cpp_helpers.h:2696
CAsyncCommand Begin_WriteApbTime(bool fEnabled, uint16_t nMinutes)
Запускает асинхронную команду записи времён замка.
Definition: ilg_cpp_helpers.h:2291
CAsyncCommand Begin_WriteConfiguration(const void *pData, size_t nSize)
Запускает асинхронную команду записи конфигурации контроллера.
Definition: ilg_cpp_helpers.h:2700
static void End_ReadLines(ilg_handle hCommand, std::string &sLines)
Возвращает результат чтения инфо строк контроллера.
Definition: ilg_cpp_helpers.cpp:193
CAsyncCommand Begin_ReadLockTimes(uint8_t nBankN)
Запускает асинхронную команду чтения времён замка.
Definition: ilg_cpp_helpers.h:2241
CAsyncCommand Begin_ReadApbTime()
Запускает асинхронную команду чтения времени антипассбэк.
Definition: ilg_cpp_helpers.h:2275
ssize_t ReadKeyTopIdx(uint8_t nBankN)
Читает верхнюю границу ключей.
Definition: ilg_cpp_helpers.h:2421
void SyncClock()
Синхронизирует часы контроллера с часами ПК.
Definition: ilg_cpp_helpers.h:2498
void SetMessageCallback(ilg_controller_message_callback pCallback, void *pUserData=nullptr)
Устанавливает функцию обратного вызова для уведомлений контроллера.
Definition: ilg_cpp_helpers.h:2171
static void End_WriteSecurityParams(ilg_handle hCommand, uint8_t &nState)
Возвращает результат записи параметров режима охраны.
Definition: ilg_cpp_helpers.h:2650
void GetControllerInfo(ilg_controller_info &rInfo) const
Возвращает информацию о контроллере.
Definition: ilg_cpp_helpers.h:2220
CAsyncCommand Begin_ReadLines()
Запускает асинхронную команду чтения инфо строк контроллера.
Definition: ilg_cpp_helpers.h:2228
static void End_WriteKeys(ilg_handle hCommand, size_t &nWritten)
Возвращает результат записи ключей.
Definition: ilg_cpp_helpers.h:2387
CAsyncCommand Begin_ReadSecurityParams()
Запускает асинхронную команду чтения параметров режима охраны.
Definition: ilg_cpp_helpers.h:2629
void WriteMode(ilg_controller_mode nMode)
Пишет режим контроллера.
Definition: ilg_cpp_helpers.h:2669
static void End_ReadModeTimZones(ilg_handle hCommand, const ilg_mode_time_zone *&pList, size_t &nRead)
Возвращает результат чтения временных зон для переключения режима контроллера.
Definition: ilg_cpp_helpers.h:2340
static void End_ReadFireParams(ilg_handle hCommand, uint8_t &nSrcMask, uint8_t &nLimitT, uint8_t &nState, uint8_t &nT)
Возвращает результат чтения параметров противопожарного режима.
Definition: ilg_cpp_helpers.h:2605
void SetSecurityMode(bool fOn)
Вкл/выкл режим охраны.
Definition: ilg_cpp_helpers.h:2564
CAsyncCommand Begin_ReadKeyTopIdx(uint8_t nBankN)
Запускает асинхронную команду чтения верхней границы ключей.
Definition: ilg_cpp_helpers.h:2427
CAsyncCommand Begin_SetNetworkAddress(uint8_t nAddress)
Запускает асинхронную команду установки сетевого адреса.
Definition: ilg_cpp_helpers.h:2716
void ReadKeys(uint8_t nBankN, size_t nIdx, ilg_key *pBuf, size_t nCount, size_t *pRead=nullptr)
Читает ключи из памяти контроллера.
Definition: ilg_cpp_helpers.h:2358
CAsyncCommand Begin_ReadEcParams()
Запускает асинхронную команду чтения параметров режима ЭлектроКонтроль.
Definition: ilg_cpp_helpers.h:2658
void DecodeControllerModeEvent(const uint64_t &nEvent, ilg_controller_time &rTime, ilg_controller_mode &nMode, uint8_t &nFlags, uint8_t &nTrigger)
Декодирует событие переключения режима контроллера.
Definition: ilg_cpp_helpers.h:2750
CAsyncCommand Begin_SetEmergencyMode(bool fEnable)
Запускает асинхронную команду вкл/выкл старого режима аварийного открывания дверей.
Definition: ilg_cpp_helpers.h:2512
void EraseKeys(uint8_t nBankN, size_t nIdx, size_t nCount, size_t *pErased=nullptr)
Стирает ключи в памяти контроллера.
Definition: ilg_cpp_helpers.h:2391
void DecodeTimeEvent(const uint64_t &nEvent, ilg_controller_time &rTime)
Декодирует событие с датой и временем.
Definition: ilg_cpp_helpers.h:2746
void WriteTimeZones(uint8_t nBankN, size_t nIdx, const ilg_time_zone *pTZs, size_t nCount, size_t *pWritten=nullptr)
Пишет временные зоны в контроллер.
Definition: ilg_cpp_helpers.h:2314
CAsyncCommand Begin_ReadKeys(uint8_t nBankN, size_t nIdx, size_t nCount)
Запускает асинхронную команду чтения ключей.
Definition: ilg_cpp_helpers.h:2363
CAsyncCommand Begin_EraseKeys(uint8_t nBankN, size_t nIdx, size_t nCount)
Запускает асинхронную команду стирания ключей.
Definition: ilg_cpp_helpers.h:2395
void Connect(bool fReconnect=false)
Подключается к контроллеру.
Definition: ilg_cpp_helpers.h:2194
CAsyncCommand Begin_ReadModeTimZones(size_t nIdx, size_t nCount)
Запускает асинхронную команду чтения временных зон для переключения режима контроллера.
Definition: ilg_cpp_helpers.h:2334
static void End_ReadRtcParams(ilg_handle hCommand, ilg_rtc_params &rParams)
Возвращает результат чтения параметров RTC.
Definition: ilg_cpp_helpers.h:2472
void SetOptions(const ilg_controller_options &rOptions)
Устанавливает параметры контроллера.
Definition: ilg_cpp_helpers.h:2186
void ReadExtAskParams(ilg_extask_params &rParams)
Читает параметры ExtAsk из контроллера.
Definition: ilg_cpp_helpers.h:2480
void DecodeStateEvent(const uint64_t &nEvent, ilg_controller_time &rTime, uint8_t &nFlags, uint8_t &nTrigger)
Декодирует событие изменения состояния.
Definition: ilg_cpp_helpers.h:2758
void DecodePassageEvent(const uint64_t &nEvent, ilg_controller_time &rTime, ilg_direction &nDirection, uint8_t &nKeyBankN, ssize_t &nKeyIdx)
Декодирует событие прохода.
Definition: ilg_cpp_helpers.h:2739
void ReadAntiCovid(uint16_t *pMax8, uint16_t *pCount8)
Читает параметры AntiCovid.
Definition: ilg_cpp_helpers.h:2519
void ReadFireParams(uint8_t &nSrcMask, uint8_t &nLimitT, uint8_t &nState, uint8_t &nT)
Читает параметры противопожарного режима.
Definition: ilg_cpp_helpers.h:2594
void WriteLockTimes(uint8_t nBankN, uint16_t nOpen, uint16_t nLet, uint16_t nMax, bool fBigTime)
Пишет времена замка в память контроллера.
Definition: ilg_cpp_helpers.h:2254
CController & operator=(CController &&other)
Оператор перемещения
Definition: ilg_cpp_helpers.cpp:180
CAsyncCommand Begin_WriteKeys(uint8_t nBankN, size_t nIdx, const ilg_key *pKeys, size_t nCount, bool fSelected=false)
Запускает асинхронную команду записи ключей.
Definition: ilg_cpp_helpers.h:2379
static void End_WriteFireParams(ilg_handle hCommand, uint8_t &nState, uint8_t &nT)
Возвращает результат записи параметров противопожарного режима.
Definition: ilg_cpp_helpers.h:2621
void WriteSecurityParams(uint8_t nSrcMask, uint8_t nTime, uint8_t *pState=nullptr)
Пишет параметры режима охраны.
Definition: ilg_cpp_helpers.h:2640
ilg_controller_mode ReadMode(uint8_t *pFlags=nullptr)
Читает режим контроллера.
Definition: ilg_cpp_helpers.h:2679
CAsyncCommand Begin_ReadRtcParams()
Запускает асинхронную команду чтения параметров RTC.
Definition: ilg_cpp_helpers.h:2466
void WriteModeTimeZones(size_t nIdx, const ilg_mode_time_zone *pTZs, size_t nCount)
Пишет временные зоны для переключения режима контроллера.
Definition: ilg_cpp_helpers.h:2345
CAsyncCommand Begin_ReadTimeZones(uint8_t nBankN, size_t nIdx, size_t nCount)
Запускает асинхронную команду чтения временных зон.
Definition: ilg_cpp_helpers.h:2303
void WriteKeys(uint8_t nBankN, size_t nIdx, const ilg_key *pKeys, size_t nCount, size_t *pWritten=nullptr, bool fSelected=false)
Пишет ключи в память контроллера.
Definition: ilg_cpp_helpers.h:2373
CAsyncCommand Begin_SyncClock()
Запускает асинхронную команду синхронизации часов контроллера с часами ПК.
Definition: ilg_cpp_helpers.h:2502
CAsyncCommand Begin_EraseKeys2(uint8_t nBankN, const size_t *pIdxs, size_t nCount)
Запускает асинхронную команду стирания ключей в указанных ячейках.
Definition: ilg_cpp_helpers.h:2410
void ReadLockTimes(uint8_t nBankN, uint16_t &nOpen, uint16_t &nLet, uint16_t &nMax, bool &fBigTime)
Читает времена замка из памяти контроллера.
Definition: ilg_cpp_helpers.h:2234
CAsyncCommand Begin_ReadAntiCovid()
Запускает асинхронную команду чтения параметров AntiCovid.
Definition: ilg_cpp_helpers.h:2523
static void End_ReadApbTime(ilg_handle hCommand, bool &fEnabled, uint16_t &nMinutes)
Возвращает результат чтения времени антипассбэк.
Definition: ilg_cpp_helpers.h:2281
virtual ~CController()
Деструктор
Definition: ilg_cpp_helpers.cpp:177
CController Clone() const
Клонирует дескриптор контроллера.
Definition: ilg_cpp_helpers.h:2767
void ReadApbTime(bool &fEnabled, uint16_t &nMinutes)
Читает время антипассбэк из контроллера.
Definition: ilg_cpp_helpers.h:2269
void ReadConfiguration(std::vector< uint8_t > &oData)
Читает конфигурацию контроллера.
Definition: ilg_cpp_helpers.cpp:199
CAsyncCommand Begin_WriteEventReadIdx(size_t nIdx)
Запускает асинхронную команду записи указателя чтения событий.
Definition: ilg_cpp_helpers.h:2456
void ReadSecurityParams(uint8_t &nSrcMask, uint8_t &nTime, uint8_t &nState)
Читает параметры режима охраны.
Definition: ilg_cpp_helpers.h:2625
CAsyncCommand Begin_Disconnect()
Запускает асинхронную команду отключения от контроллера.
Definition: ilg_cpp_helpers.h:2208
CController()
Конструктор по умолчанию.
Definition: ilg_cpp_helpers.cpp:165
void SetAlarmMode(bool fOn)
Вкл/выкл режим тревоги.
Definition: ilg_cpp_helpers.h:2574
void ReadModeTimeZones(size_t nIdx, ilg_mode_time_zone *pBuf, size_t nCount)
Читает временные зоны для переключения режима контроллера.
Definition: ilg_cpp_helpers.h:2330
CAsyncCommand Begin_OpenDoor(bool fOut)
Запускает асинхронную команду открытия двери.
Definition: ilg_cpp_helpers.h:2548
void DecodeKeyNumber(const uint64_t &nEvent, ilg_key_number &rKeyNumber)
Декодирует событие с номером ключа.
Definition: ilg_cpp_helpers.h:2763
static void End_ReadKeyTopIdx(ilg_handle hCommand, ssize_t &nIdx)
Возвращает результат чтения верхней границы ключей.
Definition: ilg_cpp_helpers.h:2433
CConverter GetConverter() const
Создаёт дескриптор конвертера.
Definition: ilg_cpp_helpers.h:3234
ilg_connection_status GetConnectionStatus() const
Возвращает состояние подключения к контроллеру.
Definition: ilg_cpp_helpers.h:2214
static void End_ReadExtAskParams(ilg_handle hCommand, ilg_extask_params &rParams)
Возвращает результат чтения параметров ExtAsk.
Definition: ilg_cpp_helpers.h:2490
ilg_event_type DecodeEventType(const uint64_t &nEvent, ilg_event_format *pFormat=nullptr)
Определяет тип события контроллера и формат записи события.
Definition: ilg_cpp_helpers.h:2732
void WriteApbTime(bool fEnabled, uint16_t nMinutes)
Пишет время антипассбэк в контроллер.
Definition: ilg_cpp_helpers.h:2287
void ReadRtcParams(ilg_rtc_params &rParams)
Читает параметры RTC из контроллера.
Definition: ilg_cpp_helpers.h:2462
void EraseKeys2(uint8_t nBankN, const size_t *pIdxs, size_t nCount, size_t *pErased=nullptr)
Стирает ключи в указанных ячейках.
Definition: ilg_cpp_helpers.h:2405
CAsyncCommand Begin_SetSecurityMode(bool fOn)
Запускает асинхронную команду вкл/выкл режима охраны.
Definition: ilg_cpp_helpers.h:2568
CAsyncCommand Begin_SetAlarmMode(bool fOn)
Запускает асинхронную команду вкл/выкл режима тревоги.
Definition: ilg_cpp_helpers.h:2578
CAsyncCommand Begin_SetFireMode(bool fOn)
Запускает асинхронную команду вкл/выкл противопожарного режима.
Definition: ilg_cpp_helpers.h:2558
CAsyncCommand Begin_SetFirmware(const void *pData, size_t nSize)
Запускает асинхронную команду установки прошивки контроллера.
Definition: ilg_cpp_helpers.h:2726
void GetExtAskParams(ilg_extask_params &rParams)
Возвращает результат авто опроса ExtAsk.
Definition: ilg_cpp_helpers.h:2494
CAsyncCommand Begin_ReadConfiguration()
Запускает асинхронную команду чтения конфигурации контроллера.
Definition: ilg_cpp_helpers.h:2706
static void End_ReadEvents(ilg_handle hCommand, const uint64_t *&pList, size_t &nRead)
Возвращает результат чтения событий.
Definition: ilg_cpp_helpers.h:2447
CAsyncCommand Begin_WriteLockTimes(uint8_t nBankN, uint16_t nOpen, uint16_t nLet, uint16_t nMax, bool fBigTime)
Запускает асинхронную команду записи времён замка.
Definition: ilg_cpp_helpers.h:2260
static void End_ReadConfiguration(ilg_handle hCommand, std::vector< uint8_t > &oData)
Возвращает результат чтения конфигурации контроллера.
Definition: ilg_cpp_helpers.cpp:207
static void End_ReadAntiCovid(ilg_handle hCommand, uint16_t *pMax8, uint16_t *pCount8)
Возвращает результат чтения параметров AntiCovid.
Definition: ilg_cpp_helpers.h:2529
void ReadEcParams(uint8_t &nPowerConfig, uint8_t &nDelay, uint8_t *pState=nullptr)
Читает параметры режима ЭлектроКонтроль.
Definition: ilg_cpp_helpers.h:2654
void ReadEvents(size_t nIdx, uint64_t *pBuf, size_t nCount, size_t *pRead=nullptr)
Читает события из памяти контроллера.
Definition: ilg_cpp_helpers.h:2437
static void End_ReadLockTimes(ilg_handle hCommand, uint16_t &nOpen, uint16_t &nLet, uint16_t &nMax, bool &fBigTime)
Возвращает результат чтения времён замка.
Definition: ilg_cpp_helpers.h:2247
void GetConverterInfo(ilg_converter_info &rInfo) const
Возвращает информацию о конвертере.
Definition: ilg_cpp_helpers.h:2224
void SetFirmware(const void *pData, size_t nSize)
Устанавливает прошивку контроллера.
Definition: ilg_cpp_helpers.h:2722
static void End_ReadSecurityParams(ilg_handle hCommand, uint8_t &nSrcMask, uint8_t &nTime, uint8_t &nState)
Возвращает результат чтения параметров режима охраны.
Definition: ilg_cpp_helpers.h:2635
void SetEcPower(bool fOn)
Вкл/выкл питание в режиме Электроконтроль.
Definition: ilg_cpp_helpers.h:2584
CAsyncCommand Begin_ReadEvents(size_t nIdx, size_t nCount)
Запускает асинхронную команду чтения событий.
Definition: ilg_cpp_helpers.h:2441
CAsyncCommand Begin_ReadMode()
Запускает асинхронную команду чтения режима контроллера.
Definition: ilg_cpp_helpers.h:2685
CAsyncCommand Begin_Connect(bool fReconnect=false)
Запускает асинхронную команду подключения к контроллеру.
Definition: ilg_cpp_helpers.h:2198
static void End_ReadMode(ilg_handle hCommand, ilg_controller_mode &nMode, uint8_t *pFlags=nullptr)
Возвращает результат чтения режима контроллера.
Definition: ilg_cpp_helpers.h:2691
void EnableMessageQueue(bool fEnable=true)
Включает/выключает очередь сообщений.
Definition: ilg_cpp_helpers.h:2176
void WriteFireParams(uint8_t nSrcMask, uint8_t nLimitT, uint8_t *pState=nullptr, uint8_t *pT=nullptr)
Пишет параметры противопожарного режима.
Definition: ilg_cpp_helpers.h:2610
void OpenDoor(bool fOut)
Открывает дверь.
Definition: ilg_cpp_helpers.h:2544
Класс поиска конвертеров.
Definition: ilg_cpp_helpers.h:265
void SetListenPorts(const uint16_t *pPorts, size_t nCount)
Устанавливает список портов для прослушки конвертеров к режиме "Клиент".
Definition: ilg_cpp_helpers.h:592
size_t GetConverterCount() const
Возвращает количество найденных считывателей.
Definition: ilg_cpp_helpers.h:606
void GetConverterInfo(size_t nIdx, ilg_converter_info &rInfo) const
Возвращает информацию о найденном считывателе.
Definition: ilg_cpp_helpers.h:612
CAsyncCommand Begin_Scan(bool fReset=false)
Запускает асинхронную команду поиска считывателей.
Definition: ilg_cpp_helpers.h:638
void GetListenPorts(std::vector< uint16_t > &oPorts) const
Возвращает список портов для прослушки конвертеров к режиме "Клиент".
Definition: ilg_cpp_helpers.cpp:156
bool GetAutoScan() const
Возвращает флаг авто поиска считывателей.
Definition: ilg_cpp_helpers.h:620
void GetOptions(ilg_search_options &rOptions) const
Возвращает параметры поиска считывателей.
Definition: ilg_cpp_helpers.h:588
void SetAutoScan(bool fEnable=true, bool fWait=true)
Включает/выключает авто поиск считывателей.
Definition: ilg_cpp_helpers.h:616
void ClosePort(ilg_port_type nPortType, const char *pszPortName, int hPort)
Закрывает порт
Definition: ilg_cpp_helpers.h:633
CConverterSearch Clone() const
Клонирует дескриптор поиска конвертеров.
Definition: ilg_cpp_helpers.h:669
CAsyncCommand Begin_SetAutoScan(bool fEnable)
Запускает асинхронную команду вкл/выкл режим авто поиска считывателей.
Definition: ilg_cpp_helpers.h:644
CAsyncCommand Begin_ClosePort(ilg_port_type nPortType, const char *pszPortName, int hPortFD)
Запускает асинхронную команду закрытия порта.
Definition: ilg_cpp_helpers.h:662
CAsyncCommand Begin_OpenPort(ilg_port_type nPortType, const char *pszPortName)
Запускает асинхронную команду открытия порта.
Definition: ilg_cpp_helpers.h:650
void SetMessageCallback(ilg_search_message_callback pCallback, void *pUserData=nullptr)
Устанавливает функцию обратного вызова для уведомлений поиска конвертеров.
Definition: ilg_cpp_helpers.h:569
ilg_status GetListenStatus(uint16_t nTcpPort) const
Возвращает состояние Tcp-порта, открытого для прослушки конвертеров в режиме "Клиент".
Definition: ilg_cpp_helpers.h:596
static void End_OpenPort(ilg_handle hCommand, int &PortFD, ilg_converter_info &rInfo)
Возвращает результат открытия порта.
Definition: ilg_cpp_helpers.h:657
void SetOptions(const ilg_search_options &rOptions)
Устанавливает параметры поиска считывателей.
Definition: ilg_cpp_helpers.h:584
virtual ~CConverterSearch()
Деструктор
Definition: ilg_cpp_helpers.cpp:148
void Scan(bool fReset=false)
Ищет считыватели.
Definition: ilg_cpp_helpers.h:602
CConverterSearch()
Конструктор по умолчанию.
Definition: ilg_cpp_helpers.cpp:136
CConverterSearch & operator=(CConverterSearch &&other)
Оператор перемещения
Definition: ilg_cpp_helpers.cpp:151
int OpenPort(ilg_port_type nPortType, const char *pszPortName, ilg_converter_info *pInfo=nullptr)
Открывает порт и возвращает его дескриптор.
Definition: ilg_cpp_helpers.h:626
bool GetMessage(ilg_search_msg &nMsg, const void *&pMsgData) const
Извлекает следующее сообщение из очереди.
Definition: ilg_cpp_helpers.h:578
void EnableMessageQueue(bool fEnable=true)
Включает/выключает очередь сообщений.
Definition: ilg_cpp_helpers.h:574
Класс конвертера.
Definition: ilg_cpp_helpers.h:2778
CAsyncCommand Begin_ClearLicenses(bool fDisconnect=false)
Запускает асинхронную команду удаления всех лицензий.
Definition: ilg_cpp_helpers.h:3356
CAsyncCommand Begin_SetAutoScan(bool fEnable=true)
Запускает асинхронную команду вкл/выкл автоматического сканирования контроллеров.
Definition: ilg_cpp_helpers.h:3388
bool GetAutoScan() const
Возвращает True если авто поиск контроллеров включен.
Definition: ilg_cpp_helpers.h:3394
void ClearLicenses(bool fDisconnect=false)
Удаляет все лицензии.
Definition: ilg_cpp_helpers.h:3352
CConverter Clone() const
Клонирует дескриптор конвертера.
Definition: ilg_cpp_helpers.h:3416
CConverter()
Конструктор по умолчанию.
Definition: ilg_cpp_helpers.cpp:214
bool GetMessage(ilg_converter_msg &nMsg, const void *&pMsgData) const
Извлекает следующее сообщение из очереди.
Definition: ilg_cpp_helpers.h:3249
CController GetController(ilg_controller_model nModel, int nSn)
Возвращает дескриптор подключения к контроллеру.
Definition: ilg_cpp_helpers.h:3410
CAsyncCommand Begin_Disconnect()
Запускает асинхронную команду отключения от конвертера.
Definition: ilg_cpp_helpers.h:3277
void ReadLicenseInfo(ilg_license_info &rInfo, bool fForce=false)
Возвращает информацию о текущей лицензии конвертера.
Definition: ilg_cpp_helpers.h:3293
static void End_WriteLicense(ilg_handle hCommand, ilg_license_info &rInfo)
Возвращает результат установки лицензии в конвертер.
Definition: ilg_cpp_helpers.h:3348
void Scan(bool fReset=false, bool fForce=false)
Ищет контроллеры.
Definition: ilg_cpp_helpers.h:3362
static void End_ReadLicenseInfo(ilg_handle hCommand, ilg_license_info &rInfo)
Возвращает результат запроса инфо о лицензии конвертера.
Definition: ilg_cpp_helpers.h:3308
size_t GetLicenseCount() const
Возвращает количество установленных лицензий.
Definition: ilg_cpp_helpers.h:3312
static void End_GetLicenseCount(ilg_handle hCommand, size_t &nCount)
Возвращает количество установленных лицензий.
Definition: ilg_cpp_helpers.h:3324
void GetControllerInfo(size_t nIdx, ilg_controller_info &rInfo) const
Возвращает инфо о найденном контроллере.
Definition: ilg_cpp_helpers.h:3379
ilg_connection_status GetConnectionStatus() const
Возвращает состояние подключения к конвертеру.
Definition: ilg_cpp_helpers.h:3283
void EnableMessageQueue(bool fEnable=true)
Включает/выключает очередь сообщений.
Definition: ilg_cpp_helpers.h:3245
void Disconnect()
Отключается от конвертера.
Definition: ilg_cpp_helpers.h:3273
void SetOptions(const ilg_converter_options &rOptions)
Устанавливает параметры конвертера.
Definition: ilg_cpp_helpers.h:3255
void SetAutoScan(bool fEnable=true, bool fWait=false)
Вкл/выкл режим авто поиска контроллеров.
Definition: ilg_cpp_helpers.h:3383
void WriteLicense(const void *pData, size_t nSize)
Устанавливает лицензию в конвертер.
Definition: ilg_cpp_helpers.h:3332
void GetConverterInfo(ilg_converter_info &rInfo) const
Возвращает информацию о конвертере.
Definition: ilg_cpp_helpers.h:3289
void Connect(bool fReconnect=false)
Подключается к конвертеру.
Definition: ilg_cpp_helpers.h:3263
CAsyncCommand Begin_WriteLicense(uint32_t nLicenseN, const void *pData, size_t nSize)
Запускает асинхронную команду установки лицензии в конвертер.
Definition: ilg_cpp_helpers.h:3341
void SetFirmware(const void *pData, size_t nSize)
Устанавливает прошивку в конвертер.
Definition: ilg_cpp_helpers.h:3400
CAsyncCommand Begin_Connect(bool fReconnect=false)
Запускает асинхронную команду подключения к конвертеру.
Definition: ilg_cpp_helpers.h:3267
CConverter & operator=(CConverter &&other)
Оператор перемещения
Definition: ilg_cpp_helpers.cpp:229
CAsyncCommand Begin_Scan(bool fReset=false, bool fForce=false)
Запускает асинхронную команду поиска конвертеров.
Definition: ilg_cpp_helpers.h:3366
CAsyncCommand Begin_GetLicenseCount() const
Запускает асинхронную команду получения количества установленных лицензий.
Definition: ilg_cpp_helpers.h:3318
CAsyncCommand Begin_SetFirmware(const void *pData, size_t nSize)
Запускает асинхронную команду установки прошивки конвертера.
Definition: ilg_cpp_helpers.h:3404
size_t GetControllerCount() const
Возвращает количество найденных контроллеров.
Definition: ilg_cpp_helpers.h:3373
void GetLicenseInfo(size_t nIdx, ilg_license_info &rInfo) const
Возвращает инфо о лицензии из списка, полученного методом GetLicenseCount.
Definition: ilg_cpp_helpers.h:3328
CAsyncCommand Begin_ReadLicenseInfo(uint32_t nLicenseN)
Запускает асинхронную команду запроса инфо о лицензии конвертера.
Definition: ilg_cpp_helpers.h:3302
virtual ~CConverter()
Деструктор
Definition: ilg_cpp_helpers.cpp:226
void SetMessageCallback(ilg_converter_message_callback pCallback, void *pUserData=nullptr)
Устанавливает функцию обратного вызова для уведомлений конвертера.
Definition: ilg_cpp_helpers.h:3240
void GetOptions(ilg_converter_options &rOptions) const
Возвращает параметры конвертера.
Definition: ilg_cpp_helpers.h:3259
Класс исключения SDK Guard.
Definition: ilg_cpp_helpers.h:24
CILGException(ilg_status nCode)
Конструктор из кода возврата SDK.
Definition: ilg_cpp_helpers.cpp:10
virtual const char * what() const _GLIBCXX_TXN_SAFE_DYN _GLIBCXX_NOTHROW
Возвращает описание ошибки
Definition: ilg_cpp_helpers.cpp:14
ilg_status m_nCode
Код возврата SDK.
Definition: ilg_cpp_helpers.h:37
Класс дескриптора SDK.
Definition: ilg_cpp_helpers.h:111
CILGHandle & operator=(const CILGHandle &)=delete
Запрещаем копирование этого класса (т.к. он содержит указатель = дескриптор).
void Close()
Закрывает дескриптор SDK.
Definition: ilg_cpp_helpers.cpp:97
ilg_handle Detach()
Отсоединяет дескриптор от этого объекту.
Definition: ilg_cpp_helpers.cpp:110
virtual ~CILGHandle()
Деструктор
Definition: ilg_cpp_helpers.cpp:68
ilg_handle Get() const
Возвращает дескриптор SDK.
Definition: ilg_cpp_helpers.cpp:93
ilg_handle m_h
Дескриптор SDK.
Definition: ilg_cpp_helpers.h:188
CILGHandle()
Конструктор по умолчанию.
Definition: ilg_cpp_helpers.cpp:55
CILGHandle(const CILGHandle &)=delete
Запрещаем копирование этого класса (т.к. он содержит указатель = дескриптор).
void Swap(CILGHandle &other) noexcept
Обменивается значением с другим дескриптором.
Definition: ilg_cpp_helpers.cpp:89
void Attach(ilg_handle h)
Присоединяет дескриптор к этому объекту.
Definition: ilg_cpp_helpers.cpp:104
Класс для инициализации/финализации библиотеки SDK.
Definition: ilg_cpp_helpers.h:3425
void Init()
Definition: ilg_cpp_helpers.cpp:241
void SetOptions(const ilg_options &rOptions)
Устанавливает глобальные настройки библиотеки.
Definition: ilg_cpp_helpers.h:3567
static void SetLogCallback(ilg_logging_callback pCallback, void *pUserData=nullptr)
Устанавливает функцию обратного вызова для лога отладки.
Definition: ilg_cpp_helpers.h:3559
CConverterSearch GetSearch()
Создаёт дескриптор поиска конвертеров.
Definition: ilg_cpp_helpers.h:3575
void SetFilterPortCallback(ilg_filter_port_callback pCallback, void *pUserData=nullptr)
Устанавливает функцию обратного вызова для фильтрации портов при поиске считывателей.
Definition: ilg_cpp_helpers.h:3563
static void SetLogLevel(ilg_log_level nLevel)
Устанавливает уровень лога отладки.
Definition: ilg_cpp_helpers.h:3555
CConverter GetConverter(ilg_port_type nPortType, const char *pszPortName)
Создаёт дескриптор конвертера.
Definition: ilg_cpp_helpers.h:3581
static bool CheckVersion()
Проверяет версию SDK.
Definition: ilg_cpp_helpers.h:3551
CILG(bool fInit=true)
Конструктор по умолчанию
Definition: ilg_cpp_helpers.cpp:234
static uint32_t GetVersion()
Возвращает номер версии библиотеки.
Definition: ilg_cpp_helpers.h:3547
void GetOptions(ilg_options &rOptions) const
Возвращает глобальные настройки библиотеки.
Definition: ilg_cpp_helpers.h:3571
~CILG()
Деструктор
Definition: ilg_cpp_helpers.cpp:248
bool m_fInit
Definition: ilg_cpp_helpers.h:3544
Ключ контроллера.
Definition: ilg_cpp_helpers.h:55
CKeyNumber()
Конструктор по умолчанию
Definition: ilg_cpp_helpers.cpp:23
void Clear()
Definition: ilg_cpp_helpers.cpp:42
void Assign(const uint8_t *pData, size_t nSize)
Устанавливает байты номера ключа.
Definition: ilg_cpp_helpers.cpp:46
const CKeyNumber & operator=(const ilg_key_number &other)
Оператор присвоения номера ilg_key_number.
Definition: ilg_cpp_helpers.h:89
ILG_API ilg_status ILG_CALL ilg_controller_end_erase_keys2(ilg_handle hCommand, size_t *pErased)
Возвращает результат стирания ключей в указанных ячейках.
ILG_API ilg_status ILG_CALL ilg_controller_get_extask_params(ilg_handle hController, ilg_extask_params *pParams)
Возвращает результат авто опроса ExtAsk.
ILG_API ilg_status ILG_CALL ilg_controller_set_message_callback(ilg_handle hController, ilg_controller_message_callback pCallback, void *pUserData=nullptr)
Устанавливает функцию обратного вызова для уведомлений контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_write_lock_times(ilg_handle hController, uint8_t nBankN, uint16_t nOpen, uint16_t nLet, uint16_t nMax, ilg_bool fBigTime)
Пишет времена замка в память контроллера.
ilg_event_format
Definition: ilguard.h:1251
ILG_API ilg_status ILG_CALL ilg_controller_read_key_top_idx(ilg_handle hController, uint8_t nBankN, ssize_t *pIdx)
Читает верхнюю границу ключей.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_lock_times(ilg_handle hController, uint8_t nBankN, ilg_handle *pCommand)
Запускает асинхронную команду чтения времён замка.
ILG_API ilg_status ILG_CALL ilg_controller_write_keys(ilg_handle hController, uint8_t nBankN, size_t nIdx, const ilg_key *pKeys, size_t nCount, size_t *pWritten, ilg_bool fSelected)
Пишет ключи в память контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_end_write_fire_params(ilg_handle hCommand, uint8_t *pState, uint8_t *pT)
Возвращает результат записи параметров противопожарного режима.
ILG_API ilg_status ILG_CALL ilg_controller_begin_disconnect(ilg_handle hController, ilg_handle *pCommand)
Запускает асинхронную команду отключения от контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_extask_params(ilg_handle hController, ilg_handle *pCommand)
Запускает асинхронную команду чтения параметров ExtAsk.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_lines(ilg_handle hController, ilg_handle *pCommand)
Запускает асинхронную команду чтения инфо строк контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_end_read_time_zones(ilg_handle hCommand, const ilg_time_zone **ppList, size_t *pRead)
Возвращает результат чтения временных зон.
ILG_API ilg_status ILG_CALL ilg_controller_write_event_read_idx(ilg_handle hController, size_t nIdx)
Пишет позицию указателя чтения событий.
ILG_API ilg_status ILG_CALL ilg_controller_begin_write_lock_times(ilg_handle hController, uint8_t nBankN, uint16_t nOpen, uint16_t nLet, uint16_t nMax, ilg_bool fBigTime, ilg_handle *pCommand)
Запускает асинхронную команду записи времён замка.
ILG_API ilg_status ILG_CALL ilg_controller_begin_write_event_read_idx(ilg_handle hController, size_t nIdx, ilg_handle *pCommand)
Запускает асинхронную команду записи указателя чтения событий.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_keys(ilg_handle hController, uint8_t nBankN, size_t nIdx, size_t nCount, ilg_handle *pCommand)
Запускает асинхронную команду чтения ключей.
ILG_API ilg_status ILG_CALL ilg_controller_end_read_keys(ilg_handle hCommand, const ilg_key **ppList, size_t *pRead)
Возвращает результат чтения ключей.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_events(ilg_handle hController, size_t nIdx, size_t nCount, ilg_handle *pCommand)
Запускает асинхронную команду чтения событий.
ILG_API ilg_status ILG_CALL ilg_converter_get_controller(ilg_handle hConverter, ilg_controller_model nModel, int nSn, ilg_handle *pController)
Возвращает дескриптор подключения к контроллеру.
ILG_API ilg_status ILG_CALL ilg_controller_begin_write_apb_time(ilg_handle hController, ilg_bool fEnabled, uint16_t nMinutes, ilg_handle *pCommand)
Запускает асинхронную команду записи времён замка.
ILG_API ilg_status ILG_CALL ilg_controller_disconnect(ilg_handle hController)
Отключается от контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_begin_write_configuration(ilg_handle hController, const void *pData, size_t nSize, ilg_handle *pCommand)
Запускает асинхронную команду записи конфигурации контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_set_network_address(ilg_handle hController, uint8_t nAddress)
Устанавливает сетевой адрес контроллеру.
ILG_API ilg_status ILG_CALL ilg_controller_begin_connect(ilg_handle hController, ilg_bool fReconnect, ilg_handle *pCommand)
Запускает асинхронную команду подключения к контроллеру.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_anticovid(ilg_handle hController, ilg_handle *pCommand)
Запускает асинхронную команду чтения параметров AntiCovid.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_key_top_idx(ilg_handle hController, uint8_t nBankN, ilg_handle *pCommand)
Запускает асинхронную команду чтения верхней границы ключей.
ILG_API ilg_status ILG_CALL ilg_controller_begin_write_mode(ilg_handle hController, ilg_controller_mode nMode, ilg_handle *pCommand)
Запускает асинхронную команду записи режима контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_end_read_mode(ilg_handle hCommand, ilg_controller_mode *pMode, uint8_t *pFlags)
Возвращает результат чтения режима контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_begin_write_fire_params(ilg_handle hController, uint8_t nSrcMask, uint8_t nLimitT, ilg_handle *pCommand)
Запускает асинхронную команду записи параметров противопожарного режима.
ILG_API ilg_status ILG_CALL ilg_controller_read_keys(ilg_handle hController, uint8_t nBankN, size_t nIdx, ilg_key *pBuf, size_t nCount, size_t *pRead=nullptr)
Читает ключи из памяти контроллера.
ilg_event_type
Definition: ilguard.h:1183
ILG_API ilg_status ILG_CALL ilg_controller_read_anticovid(ilg_handle hController, uint16_t *pMax8, uint16_t *pCount8)
Читает параметры AntiCovid.
ILG_API ilg_status ILG_CALL ilg_controller_get_info(ilg_handle hController, ilg_controller_info *pInfo)
Возвращает информацию о контроллере.
ILG_API ilg_status ILG_CALL ilg_controller_end_read_security_params(ilg_handle hCommand, uint8_t *pSrcMask, uint8_t *pTime, uint8_t *pState)
Возвращает результат чтения параметров режима охраны.
ILG_API ilg_status ILG_CALL ilg_controller_begin_set_emergency_mode(ilg_handle hController, ilg_bool fEnable, ilg_handle *pCommand)
Запускает асинхронную команду вкл/выкл старого режима аварийного открывания дверей.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_ec_params(ilg_handle hController, ilg_handle *pCommand)
Запускает асинхронную команду чтения параметров режима Электроконтроль.
ILG_API ilg_status ILG_CALL ilg_controller_begin_write_anticovid(ilg_handle hController, const uint16_t *pMax8, ilg_handle *pCommand)
Запускает асинхронную команду записи максимумов AntiCovid.
ILG_API ilg_status ILG_CALL ilg_controller_read_mode(ilg_handle hController, ilg_controller_mode *pMode, uint8_t *pFlags)
Читает режим контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_begin_erase_keys(ilg_handle hController, uint8_t nBankN, size_t nIdx, size_t nCount, ilg_handle *pCommand)
Запускает асинхронную команду стирания ключей.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_mode(ilg_handle hController, ilg_handle *pCommand)
Запускает асинхронную команду чтения режима контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_enable_message_queue(ilg_handle hController, ilg_bool fEnable=ILG_TRUE)
Включает/выключает очередь сообщений.
ILG_API ilg_status ILG_CALL ilg_controller_begin_set_ec_power(ilg_handle hController, ilg_bool fOn, ilg_handle *pCommand)
Запускает асинхронную команду вкл/выкл питания в режиме Электроконтроль.
ilg_controller_msg
Сообщение контроллера.
Definition: ilguard.h:972
ILG_API ilg_status ILG_CALL ilg_controller_read_security_params(ilg_handle hController, uint8_t *pSrcMask, uint8_t *pTime, uint8_t *pState)
Читает параметры режима охраны.
ILG_API ilg_status ILG_CALL ilg_controller_begin_open_door(ilg_handle hController, ilg_bool fOut, ilg_handle *pCommand)
Запускает асинхронную команду открытия двери.
ILG_API ilg_status ILG_CALL ilg_controller_read_lock_times(ilg_handle hController, uint8_t nBankN, uint16_t *pOpen, uint16_t *pLet, uint16_t *pMax, ilg_bool *pBigTime)
Читает времена замка из памяти контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_begin_set_firmware(ilg_handle hController, const void *pData, size_t nSize, ilg_handle *pCommand)
Запускает асинхронную команду установки прошивки контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_connect(ilg_handle hController, ilg_bool fReconnect=ILG_FALSE)
Подключается к контроллеру.
ILG_API ilg_status ILG_CALL ilg_controller_begin_set_fire_mode(ilg_handle hController, ilg_bool fOn, ilg_handle *pCommand)
Запускает асинхронную команду вкл/выкл противопожарного режима.
ILG_API ilg_status ILG_CALL ilg_controller_write_time_zones(ilg_handle hController, uint8_t nBankN, size_t nIdx, const ilg_time_zone *pTZs, size_t nCount, size_t *pWritten)
Пишет временные зоны в контроллер.
ILG_API ilg_status ILG_CALL ilg_controller_read_extask_params(ilg_handle hController, ilg_extask_params *pParams)
Читает параметры ExtAsk из контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_write_mode_time_zones(ilg_handle hController, size_t nIdx, const ilg_mode_time_zone *pTZs, size_t nCount)
Пишет временные зоны для переключения режима контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_get_converter(ilg_handle hController, ilg_handle *pConverter)
Создаёт дескриптор конвертера.
ILG_API ilg_status ILG_CALL ilg_controller_read_time_zones(ilg_handle hController, uint8_t nBankN, size_t nIdx, ilg_time_zone *pBuf, size_t nCount, size_t *pRead)
Читает временные зоны из контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_set_security_mode(ilg_handle hController, ilg_bool fOn)
Вкл/выкл режим охраны.
void(ILG_CALL * ilg_controller_message_callback)(ilg_controller_msg nMsg, const void *pMsgData, void *pUserData)
Тип функции обратного вызова для получения уведомлений от дескриптора контроллера.
Definition: ilguard.h:1013
ILG_API ilg_status ILG_CALL ilg_controller_read_ec_params(ilg_handle hController, uint8_t *pPowerConfig, uint8_t *pDelay, uint8_t *pState)
Читает параметры режима ЭлектроКонтроль.
ILG_API ilg_status ILG_CALL ilg_controller_end_read_mode_time_zones(ilg_handle hCommand, const ilg_mode_time_zone **ppList, size_t *pRead)
Возвращает результат чтения временных зон для переключения режима контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_end_read_apb_time(ilg_handle hCommand, ilg_bool *pEnabled, uint16_t *pMinutes)
Возвращает результат чтения времени антипассбэк.
ILG_API ilg_status ILG_CALL ilg_controller_get_options(ilg_handle hController, ilg_controller_options *pOptions)
Возвращает параметры контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_erase_keys(ilg_handle hController, uint8_t nBankN, size_t nIdx, size_t nCount, size_t *pErased)
Стирает ключи в памяти контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_security_params(ilg_handle hController, ilg_handle *pCommand)
Запускает асинхронную команду чтения параметров режима охраны.
ILG_API ilg_status ILG_CALL ilg_controller_begin_set_network_address(ilg_handle hController, uint8_t nAddress, ilg_handle *pCommand)
Запускает асинхронную команду установки сетевого адреса.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_time_zones(ilg_handle hController, uint8_t nBankN, size_t nIdx, size_t nCount, ilg_handle *pCommand)
Запускает асинхронную команду чтения временных зон.
ILG_API ilg_status ILG_CALL ilg_controller_end_read_events(ilg_handle hCommand, const uint64_t **ppList, size_t *pRead)
Возвращает результат чтения событий.
ILG_API ilg_status ILG_CALL ilg_controller_write_anticovid(ilg_handle hController, const uint16_t *pMax8)
Пишет максимумы AntiCovid.
ILG_API ilg_status ILG_CALL ilg_controller_begin_sync_clock(ilg_handle hController, ilg_handle *pCommand)
Запускает асинхронную команду синхронизации часов контроллера с часами ПК.
ILG_API ilg_status ILG_CALL ilg_controller_set_ec_power(ilg_handle hController, ilg_bool fOn)
Вкл/выкл питание в режиме Электроконтроль.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_mode_time_zones(ilg_handle hController, size_t nIdx, size_t nCount, ilg_handle *pCommand)
Запускает асинхронную команду чтения временных зон для переключения режима контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_sync_clock(ilg_handle hController)
Синхронизирует часы контроллера с часами ПК.
ILG_API ilg_status ILG_CALL ilg_controller_begin_write_security_params(ilg_handle hController, uint8_t nSrcMask, uint8_t nTime, ilg_handle *pCommand)
Запускает асинхронную команду записи параметров режима охраны.
ILG_API ilg_status ILG_CALL ilg_controller_begin_write_keys(ilg_handle hController, uint8_t nBankN, size_t nIdx, const ilg_key *pKeys, size_t nCount, ilg_bool fSelected, ilg_handle *pCommand)
Запускает асинхронную команду записи ключей.
ILG_API ilg_status ILG_CALL ilg_controller_end_read_ec_params(ilg_handle hCommand, uint8_t *pPowerConfig, uint8_t *pDelay, uint8_t *pState)
Возвращает результат чтения параметров режима ЭлектроКонтроль.
ILG_API ilg_status ILG_CALL ilg_controller_end_read_lock_times(ilg_handle hCommand, uint16_t *pOpen, uint16_t *pLet, uint16_t *pMax, ilg_bool *pBigTime)
Возвращает результат чтения времён замка.
ILG_API ilg_status ILG_CALL ilg_controller_end_read_extask_params(ilg_handle hCommand, ilg_extask_params *pParams)
Возвращает результат чтения параметров ExtAsk.
ILG_API ilg_status ILG_CALL ilg_controller_read_rtc_params(ilg_handle hController, ilg_rtc_params *pParams)
Читает параметры RTC из контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_end_read_fire_params(ilg_handle hCommand, uint8_t *pSrcMask, uint8_t *pLimitT, uint8_t *pState, uint8_t *pT)
Возвращает результат чтения параметров противопожарного режима.
ILG_API ilg_status ILG_CALL ilg_controller_erase_keys2(ilg_handle hController, uint8_t nBankN, const size_t *pIdxs, size_t nCount, size_t *pErased)
Стирает ключи в указанных ячейках.
ILG_API ilg_status ILG_CALL ilg_controller_read_fire_params(ilg_handle hController, uint8_t *pSrcMask, uint8_t *pLimitT, uint8_t *pState, uint8_t *pT)
Читает параметры противопожарного режима.
ILG_API ilg_status ILG_CALL ilg_controller_end_write_time_zones(ilg_handle hCommand, size_t *pWritten)
Возвращает результат записи временных зон.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_rtc_params(ilg_handle hController, ilg_handle *pCommand)
Запускает асинхронную команду чтения параметров RTC.
ILG_API ilg_status ILG_CALL ilg_controller_end_write_security_params(ilg_handle hCommand, uint8_t *pState)
Возвращает результат записи параметров режима охраны.
ILG_API ilg_status ILG_CALL ilg_controller_set_options(ilg_handle hController, const ilg_controller_options *pOptions)
Устанавливает параметры контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_end_read_anticovid(ilg_handle hCommand, uint16_t *pMax8, uint16_t *pCount8)
Возвращает результат чтения параметров AntiCovid.
ILG_API ilg_status ILG_CALL ilg_controller_write_apb_time(ilg_handle hController, ilg_bool fEnabled, uint16_t nMinutes)
Пишет время антипассбэк в контроллер.
ILG_API ilg_status ILG_CALL ilg_controller_get_message(ilg_handle hController, ilg_controller_msg *pMsg, const void **pMsgData, ilg_bool *pFound)
Извлекает следующее сообщение из очереди.
ILG_API ilg_status ILG_CALL ilg_controller_write_fire_params(ilg_handle hController, uint8_t nSrcMask, uint8_t nLimitT, uint8_t *pState, uint8_t *pT)
Пишет параметры противопожарного режима.
ILG_API ilg_status ILG_CALL ilg_controller_get_rtc_params(ilg_handle hController, ilg_rtc_params *pParams)
Возвращает результат авто опроса параметров RTC.
ILG_API ilg_status ILG_CALL ilg_controller_begin_erase_keys2(ilg_handle hController, uint8_t nBankN, const size_t *pIdxs, size_t nCount, ilg_handle *pCommand)
Запускает асинхронную команду стирания ключей в указанных ячейках.
ILG_API ilg_status ILG_CALL ilg_controller_end_read_key_top_idx(ilg_handle hCommand, ssize_t *pIdx)
Возвращает результат чтения верхней границы ключей.
ILG_API ilg_status ILG_CALL ilg_controller_begin_write_time_zones(ilg_handle hController, uint8_t nBankN, size_t nIdx, const ilg_time_zone *pTZs, size_t nCount, ilg_handle *pCommand)
Запускает асинхронную команду записи временных зон.
ILG_API ilg_status ILG_CALL ilg_controller_open_door(ilg_handle hController, ilg_bool fOut)
Открывает дверь.
ILG_API ilg_status ILG_CALL ilg_controller_end_write_keys(ilg_handle hCommand, size_t *pWritten)
Возвращает результат записи ключей.
ILG_API ilg_status ILG_CALL ilg_controller_write_security_params(ilg_handle hController, uint8_t nSrcMask, uint8_t nTime, uint8_t *pState)
Пишет параметры режима охраны.
ILG_API ilg_status ILG_CALL ilg_controller_set_alarm_mode(ilg_handle hController, ilg_bool fOn)
Вкл/выкл режим тревоги.
ILG_API ilg_status ILG_CALL ilg_controller_begin_set_security_mode(ilg_handle hController, ilg_bool fOn, ilg_handle *pCommand)
Запускает асинхронную команду вкл/выкл режима охраны.
ILG_API ilg_status ILG_CALL ilg_controller_write_mode(ilg_handle hController, ilg_controller_mode nMode)
Пишет режим контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_configuration(ilg_handle hController, ilg_handle *pCommand)
Запускает асинхронную команду чтения конфигурации контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_begin_set_alarm_mode(ilg_handle hController, ilg_bool fOn, ilg_handle *pCommand)
Запускает асинхронную команду вкл/выкл режима тревоги.
ILG_API ilg_status ILG_CALL ilg_controller_set_emergency_mode(ilg_handle hController, ilg_bool fEnable)
Вкл/выкл старый режим аварийного открывания дверей.
ILG_API ilg_status ILG_CALL ilg_controller_write_configuration(ilg_handle hController, const void *pData, size_t nSize)
Пишет конфигурацию контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_get_converter_info(ilg_handle hController, ilg_converter_info *pInfo)
Возвращает информацию о конвертере.
ILG_API ilg_status ILG_CALL ilg_controller_read_mode_time_zones(ilg_handle hController, size_t nIdx, ilg_mode_time_zone *pBuf, size_t nCount)
Читает временные зоны для переключения режима контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_apb_time(ilg_handle hController, ilg_handle *pCommand)
Запускает асинхронную команду чтения времени антипассбэк.
ILG_API ilg_status ILG_CALL ilg_controller_read_apb_time(ilg_handle hController, ilg_bool *pEnabled, uint16_t *pMinutes)
Читает время антипассбэк из контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_set_fire_mode(ilg_handle hController, ilg_bool fOn)
Вкл/выкл противопожарный режим.
ilg_direction
Definition: ilguard.h:1270
ILG_API ilg_status ILG_CALL ilg_controller_end_read_rtc_params(ilg_handle hCommand, ilg_rtc_params *pParams)
Возвращает результат чтения параметров RTC.
ILG_API ilg_status ILG_CALL ilg_controller_set_firmware(ilg_handle hController, const void *pData, size_t nSize)
Устанавливает прошивку контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_read_events(ilg_handle hController, size_t nIdx, uint64_t *pBuf, size_t nCount, size_t *pRead=nullptr)
Читает события из памяти контроллера.
ILG_API ilg_status ILG_CALL ilg_controller_get_connection_status(ilg_handle hController, ilg_connection_status *pStatus)
Возвращает состояние подключения к контроллеру.
ILG_API ilg_status ILG_CALL ilg_controller_begin_read_fire_params(ilg_handle hController, ilg_handle *pCommand)
Запускает асинхронную команду чтения параметров противопожарного режима.
ILG_API ilg_status ILG_CALL ilg_controller_begin_write_mode_time_zones(ilg_handle hController, size_t nIdx, const ilg_mode_time_zone *pTZs, size_t nCount, ilg_handle *pCommand)
Запускает асинхронную команду записи временных зон для переключения режима контроллера.
ILG_API ilg_status ILG_CALL ilg_converter_begin_set_firmware(ilg_handle hConverter, const void *pData, size_t nSize, ilg_handle *pCommand)
Запускает асинхронную команду установки прошивки конвертера.
ILG_API ilg_status ILG_CALL ilg_converter_clear_licenses(ilg_handle hConverter, ilg_bool fDisconnect=ILG_FALSE)
Удаляет все лицензии.
ILG_API ilg_status ILG_CALL ilg_converter_write_license(ilg_handle hConverter, const void *pData, size_t nSize, ilg_license_info *pInfo=nullptr, uint32_t nLicenseN=ILG_LICENSE_N)
Устанавливает лицензию в конвертер.
ILG_API ilg_status ILG_CALL ilg_converter_get_options(ilg_handle hConverter, ilg_converter_options *pOptions)
Возвращает параметры конвертера.
ILG_API ilg_status ILG_CALL ilg_converter_get_message(ilg_handle hConverter, ilg_converter_msg *pMsg, const void **pMsgData, ilg_bool *pFound)
Извлекает следующее сообщение из очереди.
ILG_API ilg_status ILG_CALL ilg_converter_get_connection_status(ilg_handle hConverter, ilg_connection_status *pStatus)
Возвращает состояние подключения к конвертеру.
ILG_API ilg_status ILG_CALL ilg_converter_connect(ilg_handle hConverter, ilg_bool fReconnect=ILG_FALSE)
Подключается к конвертеру.
ILG_API ilg_status ILG_CALL ilg_converter_end_get_license_count(ilg_handle hCommand, size_t *pCount)
Возвращает количество установленных лицензий.
ILG_API ilg_status ILG_CALL ilg_converter_set_options(ilg_handle hConverter, const ilg_converter_options *pOptions)
Устанавливает параметры конвертера.
ILG_API ilg_status ILG_CALL ilg_converter_get_info(ilg_handle hConverter, ilg_converter_info *pInfo)
Возвращает информацию о конвертере.
ILG_API ilg_status ILG_CALL ilg_converter_get_license_count(ilg_handle hConverter, size_t *pCount)
Возвращает количество установленных лицензий.
ILG_API ilg_status ILG_CALL ilg_converter_begin_connect(ilg_handle hConverter, ilg_bool fReconnect, ilg_handle *pCommand)
Запускает асинхронную команду подключения к конвертеру.
void(ILG_CALL * ilg_converter_message_callback)(ilg_converter_msg nMsg, const void *pMsgData, void *pUserData)
Тип функции обратного вызова для получения уведомлений от дескриптора конвертера.
Definition: ilguard.h:769
ILG_API ilg_status ILG_CALL ilg_converter_begin_write_license(ilg_handle hConverter, const void *pData, size_t nSize, uint32_t nLicenseN, ilg_handle *pCommand)
Запускает асинхронную команду установки лицензии в конвертер.
ILG_API ilg_status ILG_CALL ilg_converter_begin_get_license_count(ilg_handle hConverter, ilg_handle *pCommand)
Запускает асинхронную команду получения количества установленных лицензий.
ILG_API ilg_status ILG_CALL ilg_converter_get_license_info(ilg_handle hConverter, size_t nIdx, ilg_license_info *pInfo)
Возвращает инфо о лицензии из списка, полученного методом ilg_converter_get_license_count.
ILG_API ilg_status ILG_CALL ilg_converter_disconnect(ilg_handle hConverter)
Отключается от конвертера.
ILG_API ilg_status ILG_CALL ilg_converter_set_firmware(ilg_handle hConverter, const void *pData, size_t nSize)
Устанавливает прошивку в конвертер.
ILG_API ilg_status ILG_CALL ilg_converter_enable_message_queue(ilg_handle hConverter, ilg_bool fEnable=ILG_TRUE)
Включает/выключает очередь сообщений.
ILG_API ilg_status ILG_CALL ilg_converter_begin_disconnect(ilg_handle hConverter, ilg_handle *pCommand)
Запускает асинхронную команду отключения от конвертера.
ilg_connection_status
Состояние подключения к конвертеру/контроллеру.
Definition: ilguard.h:669
ILG_API ilg_status ILG_CALL ilg_converter_set_message_callback(ilg_handle hConverter, ilg_converter_message_callback pCallback, void *pUserData=nullptr)
Устанавливает функцию обратного вызова для уведомлений конвертера.
ILG_API ilg_status ILG_CALL ilg_converter_read_license_info(ilg_handle hConverter, ilg_license_info *pInfo, uint32_t nLicenseN=ILG_LICENSE_N, ilg_bool fForce=ILG_FALSE)
Возвращает информацию о лицензии конвертера.
ILG_API ilg_status ILG_CALL ilg_converter_begin_clear_licenses(ilg_handle hConverter, ilg_bool fDisconnect, ilg_handle *pCommand)
Запускает асинхронную команду удаления всех лицензий.
ILG_API ilg_status ILG_CALL ilg_converter_end_write_license(ilg_handle hCommand, ilg_license_info *pInfo)
Возвращает результат установки лицензии в конвертер.
ILG_API ilg_status ILG_CALL ilg_converter_end_read_license_info(ilg_handle hCommand, ilg_license_info *pInfo)
Возвращает результат запроса инфо о лицензии конвертера.
ilg_converter_msg
Сообщение конвертера.
Definition: ilguard.h:728
ILG_API ilg_status ILG_CALL ilg_get_converter(ilg_port_type nPortType, const char *pszPortName, ilg_handle *pConverter)
Создаёт дескриптор конвертера.
ILG_API ilg_status ILG_CALL ilg_converter_begin_read_license_info(ilg_handle hConverter, uint32_t nLicenseN, ilg_handle *pCommand)
Запускает асинхронную команду запроса инфо о лицензии конвертера.
ILG_API ilg_status ILG_CALL ilg_converter_scan(ilg_handle hConverter, ilg_bool fReset=ILG_FALSE, ilg_bool fForce=ILG_FALSE)
Ищет контроллеры.
ILG_API ilg_status ILG_CALL ilg_converter_get_controller_count(ilg_handle hConverter, size_t *pCount)
Возвращает количество найденных контроллеров.
ILG_API ilg_status ILG_CALL ilg_converter_set_auto_scan(ilg_handle hConverter, ilg_bool fEnable=ILG_TRUE, ilg_bool fWait=ILG_FALSE)
Вкл/выкл режим авто поиска контроллеров.
ILG_API ilg_status ILG_CALL ilg_converter_begin_set_auto_scan(ilg_handle hConverter, ilg_bool fEnable, ilg_handle *pCommand)
Запускает асинхронную команду вкл/выкл автоматического сканирования контроллеров.
ILG_API ilg_status ILG_CALL ilg_converter_get_auto_scan(ilg_handle hConverter, ilg_bool *pEnabled)
Возвращает True если авто поиск контроллеров включен.
ILG_API ilg_status ILG_CALL ilg_converter_get_controller_info(ilg_handle hConverter, size_t nIdx, ilg_controller_info *pInfo)
Возвращает инфо о найденном контроллере.
ILG_API ilg_status ILG_CALL ilg_converter_begin_scan(ilg_handle hConverter, ilg_bool fReset, ilg_bool fForce, ilg_handle *pCommand)
Запускает асинхронную команду поиска конвертеров.
ILG_API uint32_t ILG_CALL ilg_get_version()
Возвращает номер версии библиотеки.
void(ILG_CALL * ilg_logging_callback)(ilg_log_level nLevel, const char *pContext, const char *pMessage, void *pUserData)
Тип функции обратного вызова для получения сообщений лога отладки библиотеки.
Definition: ilguard.h:485
ILG_API ilg_status ILG_CALL ilg_set_log_level(ilg_log_level nLevel)
Устанавливает уровень лога отладки.
bool ilg_check_version()
Проверяет версию SDK.
Definition: ilguard.h:1719
ILG_API ilg_status ILG_CALL ilg_get_options(ilg_options *pOptions)
Возвращает глобальные настройки библиотеки.
ilg_status
Коды ошибок.
Definition: ilguard.h:133
ILG_API ilg_status ILG_CALL ilg_set_options(const ilg_options *pOptions)
Устанавливает глобальные настройки библиотеки.
ILG_API ilg_status ILG_CALL ilg_set_log_callback(ilg_logging_callback pCallback, void *pUserData=nullptr)
Устанавливает функцию обратного вызова для лога отладки.
ILG_API ilg_status ILG_CALL ilg_search_get_options(ilg_handle hSearch, ilg_search_options *pOptions)
Возвращает параметры поиска конвертеров.
ILG_API ilg_status ILG_CALL ilg_search_scan(ilg_handle hSearch, ilg_bool fReset=ILG_FALSE)
Ищет конвертеры.
ILG_API ilg_status ILG_CALL ilg_get_search(ilg_handle *pSearch)
Создаёт дескриптор поиска конвертеров.
ILG_API ilg_status ILG_CALL ilg_search_get_message(ilg_handle hSearch, ilg_search_msg *pMsg, const void **pMsgData, ilg_bool *pFound)
Извлекает следующее сообщение из очереди.
ILG_API ilg_status ILG_CALL ilg_search_begin_set_auto_scan(ilg_handle hSearch, ilg_bool fEnable, ilg_handle *pCommand)
Запускает асинхронную команду вкл/выкл режим авто поиска конвертеров.
ILG_API ilg_status ILG_CALL ilg_search_begin_scan(ilg_handle hSearch, ilg_bool fReset, ilg_handle *pCommand)
Запускает асинхронную команду поиска конвертеров.
ILG_API ilg_status ILG_CALL ilg_search_get_converter_count(ilg_handle hSearch, size_t *pCount)
Возвращает количество найденных конвертеров.
ILG_API ilg_status ILG_CALL ilg_search_get_auto_scan(ilg_handle hSearch, ilg_bool *pEnabled)
Возвращает флаг авто поиска конвертеров.
ILG_API ilg_status ILG_CALL ilg_set_filter_port_callback(ilg_filter_port_callback pCallback, void *pUserData=nullptr)
Устанавливает функцию обратного вызова для фильтрации портов при поиске конвертеров.
ILG_API ilg_status ILG_CALL ilg_search_set_listen_ports(ilg_handle hSearch, const uint16_t *pPorts, size_t nCount)
Устанавливает список портов для прослушки конвертеров к режиме "Клиент".
ilg_search_msg
Сообщение поиска конвертеров.
Definition: ilguard.h:570
ILG_API ilg_status ILG_CALL ilg_search_set_message_callback(ilg_handle hSearch, ilg_search_message_callback pCallback, void *pUserData=nullptr)
Устанавливает функцию обратного вызова для уведомлений поиска конвертеров.
ILG_API ilg_status ILG_CALL ilg_search_set_options(ilg_handle hSearch, const ilg_search_options *pOptions)
Устанавливает параметры поиска конвертеров.
void(ILG_CALL * ilg_search_message_callback)(ilg_search_msg nMsg, const void *pMsgData, void *pUserData)
Тип функции обратного вызова для получения уведомлений от дескриптора поиска.
Definition: ilguard.h:616
ILG_API ilg_status ILG_CALL ilg_search_get_converter_info(ilg_handle hSearch, size_t nIdx, ilg_converter_info *pInfo)
Возвращает информацию о найденном конвертере.
ilg_bool(ILG_CALL * ilg_filter_port_callback)(ilg_port_type nPortType, const char *pszPortName, void *pUserData)
Тип функции обратного вызова для фильтрации портов при поиске конвертеров.
Definition: ilguard.h:518
ILG_API ilg_status ILG_CALL ilg_search_set_auto_scan(ilg_handle hSearch, ilg_bool fEnable=ILG_TRUE, ilg_bool fWait=ILG_TRUE)
Включает/выключает авто поиск конвертеров.
ILG_API ilg_status ILG_CALL ilg_search_enable_message_queue(ilg_handle hSearch, ilg_bool fEnable=ILG_TRUE)
Включает/выключает очередь сообщений.
std::chrono::steady_clock::time_point now()
Definition: ilg_cpp_helpers.h:3605
auto since(std::chrono::time_point< clock_t, duration_t > const &start)
Возвращает интервал времени в миллисекундах от времени start до текущего времени.
Definition: ilg_cpp_helpers.h:3616
Заголовочный файл API SDK Guard.
ilg_controller_model
Модель контроллера.
Definition: ilguard.h:382
@ ILG_CONTROLLER_MODEL_SIZE
Definition: ilguard.h:430
ILG_API ilg_status ILG_CALL ilg_search_close_port(ilg_handle hSearch, ilg_port_type nPortType, const char *pszPortName, int hPort)
Закрывает порт.
ILG_API ilg_status ILG_CALL ilg_command_cancel(ilg_handle hCommand)
Отменяет команду. Устанавливает статус ILG_E_ABORT.
@ ILG_CONVERTER_MODE_SIZE
Definition: ilguard.h:360
ILG_API ilg_status ILG_CALL ilg_controller_end_erase_keys(ilg_handle hCommand, size_t *pErased)
Возвращает результат стирания ключей.
ilg_port_type
Definition: ilguard.h:241
@ ILG_PORT_TYPE_SIZE
Definition: ilguard.h:277
ilg_bool
Definition: ilguard.h:123
ILG_API ilg_status ILG_CALL ilg_search_get_listen_status(ilg_handle hSearch, uint16_t nTcpPort, ilg_status *pStatus)
Возвращает состояние Tcp-порта, открытого для прослушки конвертеров в режиме "Клиент".
ilg_controller_mode
Definition: ilguard.h:907
ILG_API ilg_status ILG_CALL ilg_controller_decode_state_event(ilg_handle hController, const uint64_t &nEvent, ilg_controller_time *pTime, uint8_t *pFlags, uint8_t *pTrigger)
Декодирует событие изменения состояния.
ILG_API ilg_status ILG_CALL ilg_controller_decode_controller_mode_event(ilg_handle hController, const uint64_t &nEvent, ilg_controller_time *pTime, ilg_controller_mode *pMode, uint8_t *pFlags, uint8_t *pTrigger)
Декодирует событие переключения режима контроллера.
ILG_API ilg_status ILG_CALL ilg_search_end_open_port(ilg_handle hCommand, int *pPortFD, ilg_converter_info *pInfo)
Возвращает результат открытия порта.
void * ilg_handle
Definition: ilguard.h:120
ILG_API ilg_status ILG_CALL ilg_command_get_status(ilg_handle hCommand, ilg_status *pStatus)
Возвращает состояние команды.
ILG_API ilg_status ILG_CALL ilg_clone_handle(ilg_handle h, ilg_handle *pNewHandle)
Клонирует дескриптор поиска конвертеров, дескриптор конвертера или дескриптор контроллера.
ILG_API ilg_status ILG_CALL ilg_search_open_port(ilg_handle hSearch, ilg_port_type nPortType, const char *pszPortName, ilg_converter_info *pInfo, int *pPort)
Открывает порт и возвращает его дескриптор.
ILG_API ilg_status ILG_CALL ilg_controller_decode_event_type(ilg_handle hController, const uint64_t &nEvent, ilg_event_format *pFormat, ilg_event_type *pType)
Определяет тип события контроллера и формат записи события.
ILG_API ilg_status ILG_CALL ilg_search_begin_close_port(ilg_handle hSearch, ilg_port_type nPortType, const char *pszPortName, int hPortFD, ilg_handle *pCommand)
Запускает асинхронную команду закрытия порта.
ILG_API ilg_status ILG_CALL ilg_controller_decode_key_number(ilg_handle hController, const uint64_t &nEvent, ilg_key_number *pKeyNumber)
Декодирует событие с номером ключа.
ILG_API ilg_status ILG_CALL ilg_controller_decode_passage_event(ilg_handle hController, const uint64_t &nEvent, ilg_controller_time *pTime, ilg_direction *pDirection, uint8_t *pKeyBankN, ssize_t *pKeyIdx)
Декодирует событие прохода.
#define ILG_LICENSE_N
Номер лицензии конвертера для SDK Guard.
Definition: ilguard.h:722
ILG_API ilg_status ILG_CALL ilg_search_begin_open_port(ilg_handle hSearch, ilg_port_type nPortType, const char *pszPortName, ilg_handle *pCommand)
Запускает асинхронную команду открытия порта.
ILG_API ilg_status ILG_CALL ilg_controller_decode_time_event(ilg_handle hController, const uint64_t &nEvent, ilg_controller_time *pTime)
Декодирует событие с датой и временем.
ILG_API ilg_status ILG_CALL ilg_command_get_progress(ilg_handle hCommand, size_t *pCurrent, size_t *pTotal)
Возвращает состояние прогресса выполнения команды.
ilg_log_level
Уровень лога.
Definition: ilguard.h:434
@ ILG_CONVERTER_MODEL_SIZE
Definition: ilguard.h:319
Информация о контроллере.
Definition: ilguard.h:937
Настройки контроллера.
Definition: ilguard.h:1364
Definition: ilguard.h:1323
Информация о конвертере.
Definition: ilguard.h:527
Настройки конвертера.
Definition: ilguard.h:801
Definition: ilguard.h:1337
Номер ключа.
Definition: ilguard.h:1021
uint64_t nData
Номер ключа в формате целого числа.
Definition: ilguard.h:1023
Definition: ilguard.h:1156
Информация о лицензии конвертера.
Definition: ilguard.h:680
Definition: ilguard.h:1088
Настройки библиотеки.
Definition: ilguard.h:493
Definition: ilguard.h:1306
Настройки поиска конвертеров.
Definition: ilguard.h:641
Definition: ilguard.h:1049