ਨੈਨੋਟਿਕ NanoLib C++ ਪ੍ਰੋਗਰਾਮਿੰਗ ਯੂਜ਼ਰ ਮੈਨੂਅਲ

NanoLib ਲਾਇਬ੍ਰੇਰੀ ਨੈਨੋਟੈਕ ਕੰਟਰੋਲਰਾਂ ਲਈ ਪ੍ਰੋਗਰਾਮਿੰਗ ਕੰਟਰੋਲ ਸਾਫਟਵੇਅਰ ਲਈ ਤਿਆਰ ਕੀਤੀ ਗਈ ਹੈ। ਇਹ ਨਿਯੰਤਰਣ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੇ ਵਿਕਾਸ ਦੀ ਸਹੂਲਤ ਲਈ ਇੱਕ ਉਪਭੋਗਤਾ ਇੰਟਰਫੇਸ, ਕੋਰ ਕਾਰਜਸ਼ੀਲਤਾਵਾਂ, ਅਤੇ ਸੰਚਾਰ ਲਾਇਬ੍ਰੇਰੀਆਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

ਉਤਪਾਦ ਵਰਤੋਂ ਨਿਰਦੇਸ਼

ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ:
- ਯਕੀਨੀ ਬਣਾਓ ਕਿ ਤੁਹਾਡਾ ਸਿਸਟਮ ਮੈਨੂਅਲ ਵਿੱਚ ਦਰਸਾਏ ਹਾਰਡਵੇਅਰ ਲੋੜਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦਾ ਹੈ। ਇਸ ਉਤਪਾਦ ਦੇ ਉਦੇਸ਼ ਵਾਲੇ ਦਰਸ਼ਕਾਂ ਵਿੱਚ ਨੈਨੋਟੈਕ ਕੰਟਰੋਲਰਾਂ ਲਈ ਨਿਯੰਤਰਣ ਸਾਫਟਵੇਅਰ ਬਣਾਉਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰਨ ਵਾਲੇ ਡਿਵੈਲਪਰ ਸ਼ਾਮਲ ਹਨ।

ਸ਼ੁਰੂ ਕਰਨਾ:
- NanoLib ਦੀ ਵਰਤੋਂ ਸ਼ੁਰੂ ਕਰਨ ਲਈ, ਇਹਨਾਂ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ:
- ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ NanoLib ਨੂੰ ਆਯਾਤ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰੋ।
- ਲੋੜ ਅਨੁਸਾਰ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਸੈਟਿੰਗਾਂ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰੋ।
- NanoLib ਕਾਰਜਕੁਸ਼ਲਤਾਵਾਂ ਨੂੰ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਆਪਣਾ ਪ੍ਰੋਜੈਕਟ ਬਣਾਓ।
ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣਾ:
- ਤੁਸੀਂ ਵਿੰਡੋਜ਼ ਅਤੇ ਲੀਨਕਸ ਦੋਵਾਂ ਵਾਤਾਵਰਣਾਂ ਲਈ ਪ੍ਰੋਜੈਕਟ ਬਣਾ ਸਕਦੇ ਹੋ। ਹਰੇਕ ਪਲੇਟਫਾਰਮ ਲਈ ਮੈਨੂਅਲ ਵਿੱਚ ਦਿੱਤੀਆਂ ਖਾਸ ਹਿਦਾਇਤਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ।
ਸ਼੍ਰੇਣੀਆਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ:
- ਪ੍ਰੋਗਰਾਮਿੰਗ ਕੰਟਰੋਲ ਸੌਫਟਵੇਅਰ ਲਈ NanoLib ਵਿੱਚ ਉਪਲਬਧ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਬਾਰੇ ਵਿਸਤ੍ਰਿਤ ਗਾਈਡ ਲਈ ਉਪਭੋਗਤਾ ਮੈਨੂਅਲ ਵੇਖੋ।

ਅਕਸਰ ਪੁੱਛੇ ਜਾਂਦੇ ਸਵਾਲ

ਸਵਾਲ: NanoLib ਦਾ ਮਕਸਦ ਕੀ ਹੈ?
- A: NanoLib ਨੈਨੋਟੈਕ ਕੰਟਰੋਲਰਾਂ ਲਈ ਪ੍ਰੋਗਰਾਮਿੰਗ ਨਿਯੰਤਰਣ ਸੌਫਟਵੇਅਰ ਲਈ ਇੱਕ ਲਾਇਬ੍ਰੇਰੀ ਹੈ, ਜ਼ਰੂਰੀ ਕਾਰਜਕੁਸ਼ਲਤਾਵਾਂ ਅਤੇ ਸੰਚਾਰ ਸਮਰੱਥਾ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।
ਸਵਾਲ: ਮੈਂ NanoLib ਨਾਲ ਕਿਵੇਂ ਸ਼ੁਰੂਆਤ ਕਰ ਸਕਦਾ ਹਾਂ?
- A: ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ NanoLib ਨੂੰ ਆਯਾਤ ਕਰਕੇ, ਪ੍ਰੋਜੈਕਟ ਸੈਟਿੰਗਾਂ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਕੇ, ਅਤੇ NanoLib ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਬਣਾਉਣ ਦੁਆਰਾ ਸ਼ੁਰੂ ਕਰੋ।

View Fullscreen

ਉਪਭੋਗਤਾ ਮੈਨੂਅਲ NanoLib
C++

ਉਤਪਾਦ ਸੰਸਕਰਣ 1.3.0 ਨਾਲ ਵੈਧ

ਉਪਭੋਗਤਾ ਮੈਨੂਅਲ ਸੰਸਕਰਣ: 1.4.2

ਦਸਤਾਵੇਜ਼ ਉਦੇਸ਼ ਅਤੇ ਸੰਮੇਲਨ

ਇਹ ਦਸਤਾਵੇਜ਼ NanoLib ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਸੈੱਟਅੱਪ ਅਤੇ ਵਰਤੋਂ ਦਾ ਵਰਣਨ ਕਰਦਾ ਹੈ ਅਤੇ ਨੈਨੋਟੈਕ ਕੰਟਰੋਲਰਾਂ ਲਈ ਤੁਹਾਡੇ ਆਪਣੇ ਨਿਯੰਤਰਣ ਸੌਫਟਵੇਅਰ ਨੂੰ ਪ੍ਰੋਗਰਾਮ ਕਰਨ ਲਈ ਸਾਰੀਆਂ ਕਲਾਸਾਂ ਅਤੇ ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ ਰੱਖਦਾ ਹੈ। ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਟਾਈਪਫੇਸਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ:
ਰੇਖਾਂਕਿਤ ਟੈਕਸਟ ਇੱਕ ਕਰਾਸ ਸੰਦਰਭ ਜਾਂ ਹਾਈਪਰਲਿੰਕ ਦੀ ਨਿਸ਼ਾਨਦੇਹੀ ਕਰਦਾ ਹੈ।
Example 1: NanoLibAccessor 'ਤੇ ਸਹੀ ਨਿਰਦੇਸ਼ਾਂ ਲਈ, ਸੈੱਟਅੱਪ ਦੇਖੋ। ਸਾਬਕਾampਕਦਮ 2: Ixxat ਡਰਾਈਵਰ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ ਅਤੇ CAN-to-USB ਅਡਾਪਟਰ ਨੂੰ ਕਨੈਕਟ ਕਰੋ। ਇਟਾਲਿਕ ਟੈਕਸਟ ਦਾ ਅਰਥ ਹੈ: ਇਹ ਇੱਕ ਨਾਮੀ ਵਸਤੂ ਹੈ, ਇੱਕ ਮੀਨੂ ਮਾਰਗ / ਆਈਟਮ, ਇੱਕ ਟੈਬ / file ਨਾਮ ਜਾਂ (ਜੇਕਰ ਜ਼ਰੂਰੀ ਹੋਵੇ) ਵਿਦੇਸ਼ੀ ਭਾਸ਼ਾ ਦਾ ਸਮੀਕਰਨ।
Example 1: ਚੁਣੋ File > ਨਵਾਂ > ਖਾਲੀ ਦਸਤਾਵੇਜ਼। ਟੂਲ ਟੈਬ ਖੋਲ੍ਹੋ ਅਤੇ ਟਿੱਪਣੀ ਚੁਣੋ। ਸਾਬਕਾample 2: ਇਹ ਦਸਤਾਵੇਜ਼ ਉਪਭੋਗਤਾਵਾਂ (= Nutzer; usuario; utente; utilisateur; utente ਆਦਿ) ਨੂੰ ਇਸ ਤੋਂ ਵੰਡਦਾ ਹੈ:
- ਥਰਡ-ਪਾਰਟੀ ਯੂਜ਼ਰ (= ਡ੍ਰਿਟਨਟਜ਼ਰ; tercero usuario; terceiro utente; tiers utilisateur; terzo utente ਆਦਿ)। - ਅੰਤਮ ਉਪਭੋਗਤਾ (= ਐਂਡਨਟਜ਼ਰ; ਯੂਜ਼ਰਿਓ ਫਾਈਨਲ; ਯੂਟੇਂਟ ਫਾਈਨਲ; ਯੂਟੀਲੀਸੇਟਰ ਫਾਈਨਲ; ਯੂਟੇਂਟ ਫਾਈਨਲ ਆਦਿ)।
ਕੋਰੀਅਰ ਕੋਡ ਬਲਾਕ ਜਾਂ ਪ੍ਰੋਗਰਾਮਿੰਗ ਕਮਾਂਡਾਂ ਨੂੰ ਚਿੰਨ੍ਹਿਤ ਕਰਦਾ ਹੈ। ਸਾਬਕਾample 1: Bash ਰਾਹੀਂ, ਸ਼ੇਅਰ ਕੀਤੀਆਂ ਵਸਤੂਆਂ ਦੀ ਨਕਲ ਕਰਨ ਲਈ ਸੂਡੋ ਮੇਕ ਇੰਸਟਾਲ ਕਰੋ; ਫਿਰ ldconfig ਨੂੰ ਕਾਲ ਕਰੋ। ਸਾਬਕਾample 2: NanoLib ਵਿੱਚ ਲਾਗਿੰਗ ਪੱਧਰ ਨੂੰ ਬਦਲਣ ਲਈ ਹੇਠਾਂ ਦਿੱਤੇ NanoLibAccessor ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ:
// ***** C++ ਵੇਰੀਐਂਟ *****
void setLoggingLevel(LogLevel Level);
ਬੋਲਡ ਟੈਕਸਟ ਨਾਜ਼ੁਕ ਮਹੱਤਤਾ ਵਾਲੇ ਵਿਅਕਤੀਗਤ ਸ਼ਬਦਾਂ 'ਤੇ ਜ਼ੋਰ ਦਿੰਦਾ ਹੈ। ਵਿਕਲਪਕ ਤੌਰ 'ਤੇ, ਬਰੈਕਟ ਕੀਤੇ ਵਿਸਮਿਕ ਚਿੰਨ੍ਹ ਨਾਜ਼ੁਕ(!) ਮਹੱਤਤਾ 'ਤੇ ਜ਼ੋਰ ਦਿੰਦੇ ਹਨ।
Example 1: ਆਪਣੇ ਆਪ ਨੂੰ, ਦੂਜਿਆਂ ਨੂੰ ਅਤੇ ਆਪਣੇ ਉਪਕਰਣਾਂ ਦੀ ਰੱਖਿਆ ਕਰੋ। ਸਾਡੇ ਆਮ ਸੁਰੱਖਿਆ ਨੋਟਸ ਦੀ ਪਾਲਣਾ ਕਰੋ ਜੋ ਆਮ ਤੌਰ 'ਤੇ ਸਾਰੇ Nanotec ਉਤਪਾਦਾਂ 'ਤੇ ਲਾਗੂ ਹੁੰਦੇ ਹਨ।
Exampਕਦਮ 2: ਤੁਹਾਡੀ ਆਪਣੀ ਸੁਰੱਖਿਆ ਲਈ, ਖਾਸ ਸੁਰੱਖਿਆ ਨੋਟਸ ਦੀ ਵੀ ਪਾਲਣਾ ਕਰੋ ਜੋ ਇਸ ਖਾਸ ਉਤਪਾਦ 'ਤੇ ਲਾਗੂ ਹੁੰਦੇ ਹਨ। ਸਹਿ-ਕਲਿੱਕ ਕਰਨ ਦੀ ਕਿਰਿਆ ਦਾ ਅਰਥ ਹੈ ਇੱਕ ਸੰਦਰਭ ਮੀਨੂ ਆਦਿ ਨੂੰ ਖੋਲ੍ਹਣ ਲਈ ਸੈਕੰਡਰੀ ਮਾਊਸ ਕੁੰਜੀ ਰਾਹੀਂ ਇੱਕ ਕਲਿੱਕ।
Example 1: ਉੱਤੇ ਸਹਿ-ਕਲਿੱਕ ਕਰੋ file, ਨਾਮ ਬਦਲੋ ਚੁਣੋ, ਅਤੇ ਨਾਮ ਬਦਲੋ file. ਸਾਬਕਾample 2: ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ, 'ਤੇ ਸਹਿ-ਕਲਿੱਕ ਕਰੋ file ਅਤੇ ਗੁਣ ਚੁਣੋ.

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਤੁਸੀਂ ਸ਼ੁਰੂ ਕਰੋ

ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਤੁਸੀਂ NanoLib ਦੀ ਵਰਤੋਂ ਸ਼ੁਰੂ ਕਰੋ, ਆਪਣੇ ਪੀਸੀ ਨੂੰ ਤਿਆਰ ਕਰੋ ਅਤੇ ਆਪਣੇ ਆਪ ਨੂੰ ਉਦੇਸ਼ਿਤ ਵਰਤੋਂ ਅਤੇ ਲਾਇਬ੍ਰੇਰੀ ਦੀਆਂ ਸੀਮਾਵਾਂ ਬਾਰੇ ਸੂਚਿਤ ਕਰੋ।
2.1 ਸਿਸਟਮ ਅਤੇ ਹਾਰਡਵੇਅਰ ਲੋੜਾਂ

ਨੋਟਿਸ 32-ਬਿੱਟ ਓਪਰੇਸ਼ਨ ਜਾਂ ਬੰਦ ਕੀਤੇ ਸਿਸਟਮ ਤੋਂ ਖਰਾਬੀ! ਇੱਕ 64-ਬਿੱਟ ਸਿਸਟਮ ਦੀ ਵਰਤੋਂ ਕਰੋ, ਅਤੇ ਲਗਾਤਾਰ ਬਣਾਈ ਰੱਖੋ। OEM ਬੰਦ ਕਰਨ ਅਤੇ ~ ਹਦਾਇਤਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ।

NanoLib 1.3.0 CANopen, Modbus RTU (ਵਰਚੁਅਲ com ਪੋਰਟ ਤੇ USB ਵੀ), Modbus TCP, EtherCat, ਅਤੇ Profinet ਦੇ ਨਾਲ ਸਾਰੇ ਨੈਨੋਟੈਕ ਉਤਪਾਦਾਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ। ਪੁਰਾਣੇ NanoLibs ਲਈ: ਛਾਪ ਵਿੱਚ ਚੇਂਜਲੌਗ ਵੇਖੋ। ਸਿਰਫ਼ ਤੁਹਾਡੇ ਜੋਖਮ 'ਤੇ: ਵਿਰਾਸਤ-ਸਿਸਟਮ ਦੀ ਵਰਤੋਂ। ਨੋਟ: ਜੇਕਰ ਤੁਹਾਨੂੰ FTDI-ਅਧਾਰਿਤ USB ਅਡਾਪਟਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਸਮੇਂ ਸਮੱਸਿਆਵਾਂ ਦਾ ਸਾਹਮਣਾ ਕਰਨਾ ਪੈਂਦਾ ਹੈ ਤਾਂ ਜਿੰਨਾ ਸੰਭਵ ਹੋ ਸਕੇ ਲੇਟੈਂਸੀ ਨੂੰ ਘੱਟ ਤੋਂ ਘੱਟ ਸੈੱਟ ਕਰਨ ਲਈ ਵੈਧ OEM ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ।

ਲੋੜਾਂ (64-ਬਿੱਟ ਸਿਸਟਮ ਲਾਜ਼ਮੀ)
ਵਿੰਡੋਜ਼ 10 ਜਾਂ 11 ਡਬਲਯੂ/ ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ 2019 ਸੰਸਕਰਣ 16.8 ਜਾਂ ਬਾਅਦ ਵਾਲਾ ਅਤੇ ਵਿੰਡੋਜ਼ SDK 10.0.20348.0 (ਵਰਜਨ 2104) ਜਾਂ ਬਾਅਦ ਵਾਲਾ
C++ ਮੁੜ ਵੰਡਣਯੋਗ 2017 ਜਾਂ ਉੱਚੇ CANopen: Ixxat VCI ਜਾਂ PCAN ਬੇਸਿਕ ਡਰਾਈਵਰ (ਵਿਕਲਪਿਕ) EtherCat ਮੋਡੀਊਲ / Profinet DCP: Npcap ਜਾਂ WinPcap RESTful ਮੋਡੀਊਲ: Npcap, WinPcap, ਜਾਂ ਪ੍ਰਬੰਧਕ ਦੀ ਇਜਾਜ਼ਤ
ਈਥਰਨੈੱਟ ਬੂਟਲੋਡਰਾਂ ਨਾਲ ਸੰਚਾਰ ਕਰੋ
Linux w/ Ubuntu 20.04 LTS ਤੋਂ 24 (ਸਾਰੇ x64 ਅਤੇ arm64)
ਕਰਨਲ ਸਿਰਲੇਖ ਅਤੇ libpopt-dev ਪੈਕੇਟ Profinet DCP: CAP_NET_ADMIN ਅਤੇ CAP_NET_RAW ਯੋਗਤਾ-
ties CANopen: Ixxat ECI ਡਰਾਈਵਰ ਜਾਂ ਪੀਕ PCAN-USB ਅਡਾਪਟਰ ਈਥਰਕੈਟ: CAP_NET_ADMIN, CAP_NET_RAW ਅਤੇ
CAP_SYS_NICE ਯੋਗਤਾਵਾਂ ਆਰਾਮਦਾਇਕ: CAP_NET_ADMIN Eth- ਨਾਲ ਸੰਚਾਰ ਕਰਨ ਦੀ ਯੋਗਤਾ
ernet ਬੂਟਲੋਡਰ (ਇਹ ਵੀ ਸਿਫਾਰਸ਼ ਕੀਤੀ ਜਾਂਦੀ ਹੈ: CAP_NET_RAW)

ਭਾਸ਼ਾ, ਫੀਲਡਬੱਸ ਅਡਾਪਟਰ, ਕੇਬਲ
C++ GCC 7 ਜਾਂ ਉੱਚਾ (ਲੀਨਕਸ)
ਈਥਰਨੈੱਟ: ਈਥਰਨੈੱਟ ਕੇਬਲ VCP / USB ਹੱਬ: ਹੁਣ ਯੂਨੀਫਾਰਮ USB USB ਮਾਸ ਸਟੋਰੇਜ: USB ਕੇਬਲ REST: ਈਥਰਨੈੱਟ ਕੇਬਲ CANopen: Ixxat USB-to-CAN V2; ਨਾ-
notec ZK-USB-CAN-1, ਪੀਕ PCANUSB ਅਡਾਪਟਰ arm64 'ਤੇ Ubuntu ਲਈ Ixxat ਸਮਰਥਨ ਨਹੀਂ
Modbus RTU: Nanotec ZK-USB-RS485-1 ਜਾਂ ਬਰਾਬਰ ਅਡਾਪਟਰ; ਵਰਚੁਅਲ com ਪੋਰਟ (VCP) 'ਤੇ USB ਕੇਬਲ
Modbus TCP: ਉਤਪਾਦ ਡੇਟਾਸ਼ੀਟ ਦੇ ਅਨੁਸਾਰ ਈਥਰਨੈੱਟ ਕੇਬਲ

2.2 ਨਿਯਤ ਵਰਤੋਂ ਅਤੇ ਦਰਸ਼ਕ
NanoLib ਇੱਕ ਪ੍ਰੋਗ੍ਰਾਮ ਲਾਇਬ੍ਰੇਰੀ ਅਤੇ ਸਾਫਟਵੇਅਰ ਕੰਪੋਨੈਂਟ ਹੈ ਜੋ ਕਿ ਉਦਯੋਗਿਕ ਐਪਲੀਕੇਸ਼ਨਾਂ ਦੀ ਇੱਕ ਵਿਸ਼ਾਲ ਸ਼੍ਰੇਣੀ ਵਿੱਚ Nanotec ਨਿਯੰਤਰਕਾਂ ਦੇ ਸੰਚਾਲਨ ਅਤੇ ਸੰਚਾਰ ਲਈ ਹੈ ਅਤੇ ਕੇਵਲ ਨਿਪੁੰਨ ਪ੍ਰੋਗਰਾਮਰਾਂ ਲਈ।
ਰੀਅਲ-ਟਾਈਮ ਅਸਮਰੱਥ ਹਾਰਡਵੇਅਰ (ਪੀਸੀ) ਅਤੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਕਾਰਨ, NanoLib ਉਹਨਾਂ ਐਪਲੀਕੇਸ਼ਨਾਂ ਵਿੱਚ ਵਰਤੋਂ ਲਈ ਨਹੀਂ ਹੈ ਜਿਨ੍ਹਾਂ ਨੂੰ ਸਮਕਾਲੀ ਮਲਟੀ-ਐਕਸਿਸ ਅੰਦੋਲਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਜਾਂ ਆਮ ਤੌਰ 'ਤੇ ਸਮਾਂ-ਸੰਵੇਦਨਸ਼ੀਲ ਹੁੰਦੇ ਹਨ।
ਕਿਸੇ ਵੀ ਸਥਿਤੀ ਵਿੱਚ ਤੁਸੀਂ NanoLib ਨੂੰ ਇੱਕ ਉਤਪਾਦ ਜਾਂ ਸਿਸਟਮ ਵਿੱਚ ਸੁਰੱਖਿਆ ਹਿੱਸੇ ਵਜੋਂ ਜੋੜ ਨਹੀਂ ਸਕਦੇ। ਅੰਤਮ ਉਪਭੋਗਤਾਵਾਂ ਨੂੰ ਡਿਲੀਵਰੀ ਕਰਨ 'ਤੇ, ਤੁਹਾਨੂੰ ਨੈਨੋਟੈਕ-ਨਿਰਮਿਤ ਕੰਪੋਨੈਂਟ ਦੇ ਨਾਲ ਹਰੇਕ ਉਤਪਾਦ ਲਈ ਸੁਰੱਖਿਅਤ ਵਰਤੋਂ ਅਤੇ ਸੁਰੱਖਿਅਤ ਸੰਚਾਲਨ ਲਈ ਸੰਬੰਧਿਤ ਚੇਤਾਵਨੀ ਨੋਟਿਸ ਅਤੇ ਨਿਰਦੇਸ਼ ਸ਼ਾਮਲ ਕਰਨੇ ਚਾਹੀਦੇ ਹਨ। ਤੁਹਾਨੂੰ ਨੈਨੋਟੈਕ ਦੁਆਰਾ ਜਾਰੀ ਕੀਤੇ ਸਾਰੇ ਚੇਤਾਵਨੀ ਨੋਟਿਸਾਂ ਨੂੰ ਅੰਤਮ ਉਪਭੋਗਤਾ ਨੂੰ ਪਾਸ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ।
2.3 ਡਿਲੀਵਰੀ ਅਤੇ ਵਾਰੰਟੀ ਦਾ ਦਾਇਰਾ
NanoLib ਸਾਡੇ ਡਾਊਨਲੋਡ ਤੋਂ ਇੱਕ *.zip ਫੋਲਡਰ ਦੇ ਰੂਪ ਵਿੱਚ ਆਉਂਦਾ ਹੈ webEMEA / APAC ਜਾਂ ਅਮਰੀਕਾ ਲਈ ਸਾਈਟ। ਸੈੱਟਅੱਪ ਤੋਂ ਪਹਿਲਾਂ ਆਪਣੇ ਡਾਉਨਲੋਡ ਨੂੰ ਸਹੀ ਢੰਗ ਨਾਲ ਸਟੋਰ ਅਤੇ ਅਨਜ਼ਿਪ ਕਰੋ। NanoLib ਪੈਕੇਜ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ:

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

2 ਸ਼ੁਰੂ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ

ਸਰੋਤ ਕੋਡ (API) ਵਜੋਂ ਇੰਟਰਫੇਸ ਸਿਰਲੇਖ

ਬਾਈਨਰੀ ਫਾਰਮੈਟ ਵਿੱਚ ਲਾਇਬ੍ਰੇਰੀਆਂ ਵਜੋਂ ਕੋਰ ਫੰਕਸ਼ਨ: ਨੈਨੋ-

ਲਾਇਬ੍ਰੇਰੀਆਂ ਜੋ ਸੰਚਾਰ ਦੀ ਸਹੂਲਤ ਦਿੰਦੀਆਂ ਹਨ: nanolibm_ lib.dll

[yourfieldbus].dll ਆਦਿ।

Example ਪ੍ਰੋਜੈਕਟ: ਸਾਬਕਾample.sln (ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ

ਪ੍ਰੋਜੈਕਟ) ਅਤੇ ਸਾਬਕਾample.cpp (ਮੁੱਖ file)

ਵਾਰੰਟੀ ਦੇ ਦਾਇਰੇ ਲਈ, ਕਿਰਪਾ ਕਰਕੇ a) EMEA / APAC ਜਾਂ ਅਮਰੀਕਾ ਲਈ ਸਾਡੇ ਨਿਯਮ ਅਤੇ ਸ਼ਰਤਾਂ ਅਤੇ b) ਲਾਇਸੰਸ ਦੀਆਂ ਸਾਰੀਆਂ ਸ਼ਰਤਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ। ਨੋਟ: ਨੈਨੋਟੈਕ ਤੀਜੀ-ਧਿਰ ਦੇ ਉਪਕਰਣਾਂ ਦੀ ਨੁਕਸਦਾਰ ਜਾਂ ਅਣਉਚਿਤ ਗੁਣਵੱਤਾ, ਹੈਂਡਲਿੰਗ, ਸਥਾਪਨਾ, ਸੰਚਾਲਨ, ਵਰਤੋਂ ਅਤੇ ਰੱਖ-ਰਖਾਅ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਨਹੀਂ ਹੈ! ਉਚਿਤ ਸੁਰੱਖਿਆ ਲਈ, ਹਮੇਸ਼ਾ ਵੈਧ OEM ਨਿਰਦੇਸ਼ਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

ਨੈਨੋਲਿਬ ਆਰਕੀਟੈਕਚਰ

NanoLib ਦਾ ਮਾਡਿਊਲਰ ਸਾਫਟਵੇਅਰ ਢਾਂਚਾ ਤੁਹਾਨੂੰ ਸਖਤੀ ਨਾਲ ਪੂਰਵ-ਨਿਰਮਿਤ ਕੋਰ ਦੇ ਆਲੇ-ਦੁਆਲੇ ਸੁਤੰਤਰ ਤੌਰ 'ਤੇ ਅਨੁਕੂਲਿਤ ਮੋਟਰ ਕੰਟਰੋਲਰ / ਫੀਲਡਬੱਸ ਫੰਕਸ਼ਨਾਂ ਦਾ ਪ੍ਰਬੰਧ ਕਰਨ ਦਿੰਦਾ ਹੈ। NanoLib ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਮੋਡੀਊਲ ਸ਼ਾਮਲ ਹਨ:

ਯੂਜ਼ਰ ਇੰਟਰਫੇਸ (API)

NanoLib ਕੋਰ

ਇੰਟਰਫੇਸ ਅਤੇ ਸਹਾਇਕ ਕਲਾਸਾਂ ਕਿਹੜੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਜੋ

ਸੰਚਾਰ ਲਾਇਬ੍ਰੇਰੀਆਂ ਫੀਲਡਬੱਸ-ਵਿਸ਼ੇਸ਼ ਲਾਇਬ੍ਰੇਰੀਆਂ ਜੋ

NanoLib ਵਿਚਕਾਰ API ਕਾਰਜਸ਼ੀਲਤਾ ਡੂ ਇੰਟਰਫੇਸ ਨੂੰ ਲਾਗੂ ਕਰਨ ਲਈ ਤੁਹਾਡੇ ਕੰਟਰੋਲਰ ਤੱਕ ਪਹੁੰਚ ਕਰੋ

OD (ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ)

ਬੱਸ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨਾਲ ਗੱਲਬਾਤ ਕਰੋ।

ਕੋਰ ਅਤੇ ਬੱਸ ਹਾਰਡਵੇਅਰ।

NanoLib ਕੋਰ ਫੰਕ 'ਤੇ ਅਧਾਰਤ-

ਕੌਮੀਅਤਾਂ

3.1 ਯੂਜ਼ਰ ਇੰਟਰਫੇਸ

ਯੂਜ਼ਰ ਇੰਟਰਫੇਸ ਵਿੱਚ ਹੈਡਰ ਇੰਟਰਫੇਸ ਹੁੰਦਾ ਹੈ files ਤੁਸੀਂ ਕੰਟਰੋਲਰ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਐਕਸੈਸ ਕਰਨ ਲਈ ਵਰਤ ਸਕਦੇ ਹੋ। ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦੇ ਸੰਦਰਭ ਵਿੱਚ ਵਰਣਿਤ ਉਪਭੋਗਤਾ ਇੰਟਰਫੇਸ ਕਲਾਸਾਂ ਤੁਹਾਨੂੰ ਇਹ ਕਰਨ ਦੀ ਇਜਾਜ਼ਤ ਦਿੰਦੀਆਂ ਹਨ:
ਹਾਰਡਵੇਅਰ (ਫੀਲਡਬੱਸ ਅਡਾਪਟਰ) ਅਤੇ ਕੰਟਰੋਲਰ ਡਿਵਾਈਸ ਦੋਵਾਂ ਨਾਲ ਜੁੜੋ। ਕੰਟਰੋਲਰ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਪੜ੍ਹਨ/ਲਿਖਣ ਲਈ, ਡਿਵਾਈਸ ਦੇ OD ਤੱਕ ਪਹੁੰਚ ਕਰੋ।

3.2 ਨੈਨੋਲਿਬ ਕੋਰ

NanoLib ਕੋਰ ਆਯਾਤ ਲਾਇਬ੍ਰੇਰੀ nanolib.lib ਦੇ ਨਾਲ ਆਉਂਦਾ ਹੈ। ਇਹ ਉਪਭੋਗਤਾ ਇੰਟਰਫੇਸ ਕਾਰਜਕੁਸ਼ਲਤਾ ਨੂੰ ਲਾਗੂ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸਦੇ ਲਈ ਜ਼ਿੰਮੇਵਾਰ ਹੈ:
ਸੰਚਾਰ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਲੋਡ ਕਰਨਾ ਅਤੇ ਪ੍ਰਬੰਧਨ ਕਰਨਾ। NanoLibAccessor ਵਿੱਚ ਉਪਭੋਗਤਾ ਇੰਟਰਫੇਸ ਕਾਰਜਕੁਸ਼ਲਤਾਵਾਂ ਪ੍ਰਦਾਨ ਕਰਨਾ। ਇਹ ਸੰਚਾਰ ਪ੍ਰਵੇਸ਼ ਪੁਆਇੰਟ ਡੀ-
ਨੈਨੋਲਿਬ ਕੋਰ ਅਤੇ ਕਮਿਊਨੀਕੇਸ਼ਨ ਲਾਇਬ੍ਰੇਰੀਆਂ 'ਤੇ ਚਲਾਏ ਜਾ ਸਕਣ ਵਾਲੇ ਓਪਰੇਸ਼ਨਾਂ ਦਾ ਇੱਕ ਸੈੱਟ ਜੁਰਮਾਨਾ ਕਰਦਾ ਹੈ।

3.3 ਸੰਚਾਰ ਲਾਇਬ੍ਰੇਰੀਆਂ

nanotec.services.nanolib.dll (ਤੁਹਾਡੇ ਵਿਕਲਪਿਕ ਪਲੱਗ ਅਤੇ ਡਰਾਈਵ ਸਟੂਡੀਓ ਲਈ ਉਪਯੋਗੀ) ਤੋਂ ਇਲਾਵਾ, NanoLib ਹੇਠ ਲਿਖੀਆਂ ਸੰਚਾਰ ਲਾਇਬ੍ਰੇਰੀਆਂ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦਾ ਹੈ:

nanolibm_canopen.dll nanolibm_modbus.dll

nanolibm_ethercat.dll nanolibm_restful-api.dll

nanolibm_usbmmsc.dll nanolibm_profinet.dll

ਸਾਰੀਆਂ ਲਾਇਬ੍ਰੇਰੀਆਂ ਕੋਰ ਅਤੇ ਕੰਟਰੋਲਰ ਦੇ ਵਿਚਕਾਰ ਇੱਕ ਹਾਰਡਵੇਅਰ ਐਬਸਟਰੈਕਸ਼ਨ ਲੇਅਰ ਰੱਖਦੀਆਂ ਹਨ। ਕੋਰ ਉਹਨਾਂ ਨੂੰ ਮਨੋਨੀਤ ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ ਤੋਂ ਸਟਾਰਟਅੱਪ ਤੇ ਲੋਡ ਕਰਦਾ ਹੈ ਅਤੇ ਸੰਬੰਧਿਤ ਪ੍ਰੋਟੋਕੋਲ ਦੁਆਰਾ ਕੰਟਰੋਲਰ ਨਾਲ ਸੰਚਾਰ ਸਥਾਪਤ ਕਰਨ ਲਈ ਉਹਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

ਸ਼ੁਰੂ ਕਰਨਾ

ਪੜ੍ਹੋ ਕਿ ਤੁਹਾਡੇ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਲਈ NanoLib ਨੂੰ ਕਿਵੇਂ ਸੈਟ ਅਪ ਕਰਨਾ ਹੈ ਅਤੇ ਲੋੜ ਅਨੁਸਾਰ ਹਾਰਡਵੇਅਰ ਨੂੰ ਕਿਵੇਂ ਕਨੈਕਟ ਕਰਨਾ ਹੈ।
4.1 ਆਪਣੇ ਸਿਸਟਮ ਨੂੰ ਤਿਆਰ ਕਰੋ
ਅਡਾਪਟਰ ਡਰਾਈਵਰਾਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਤੋਂ ਪਹਿਲਾਂ, ਪਹਿਲਾਂ ਆਪਣੇ ਪੀਸੀ ਨੂੰ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਦੇ ਨਾਲ ਤਿਆਰ ਕਰੋ। ਆਪਣੇ Windows OS ਦੇ ਨਾਲ PC ਨੂੰ ਤਿਆਰ ਕਰਨ ਲਈ, C++ ਐਕਸਟੈਂਸ਼ਨਾਂ ਨਾਲ MS ਵਿਜ਼ੁਅਲ ਸਟੂਡੀਓ ਸਥਾਪਿਤ ਕਰੋ। ਲੀਨਕਸ ਬੈਸ਼ ਦੁਆਰਾ ਮੇਕ ਅਤੇ ਜੀਸੀਸੀ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਲਈ, sudo apt install build-essentials ਨੂੰ ਕਾਲ ਕਰੋ। ਫਿਰ NanoLib ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲੀ ਐਪਲੀਕੇਸ਼ਨ ਲਈ CAP_NET_ADMIN, CAP_NET_RAW, ਅਤੇ CAP_SYS_NICE ਸਮਰੱਥਾਵਾਂ ਨੂੰ ਸਮਰੱਥ ਬਣਾਓ: 1. sudo setcap 'cap_net_admin,cap_net_raw,cap_sys_nice+eip' ਨੂੰ ਕਾਲ ਕਰੋ।
ਨਾਮ>. 2. ਤਦ ਹੀ, ਆਪਣੇ ਅਡਾਪਟਰ ਡਰਾਈਵਰਾਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ।
4.2 ਵਿੰਡੋਜ਼ ਲਈ Ixxat ਅਡਾਪਟਰ ਡਰਾਈਵਰ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ
ਸਿਰਫ਼ ਡਰਾਇਵਰ ਇੰਸਟਾਲੇਸ਼ਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ Ixxat ਦੇ USB-to-CAN V2 ਅਡਾਪਟਰ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। USB ਡਰਾਈਵ ਦੇ ਉਤਪਾਦ ਮੈਨੂਅਲ ਨੂੰ ਪੜ੍ਹੋ, ਇਹ ਜਾਣਨ ਲਈ ਕਿ ਕੀ/ਕਿਵੇਂ ਵਰਚੁਅਲ ਕੰਪੋਰਟ (VCP) ਨੂੰ ਕਿਰਿਆਸ਼ੀਲ ਕਰਨਾ ਹੈ। 1. ਤੋਂ ਵਿੰਡੋਜ਼ ਲਈ Ixxat ਦੇ VCI 4 ਡਰਾਈਵਰ ਨੂੰ ਡਾਊਨਲੋਡ ਅਤੇ ਸਥਾਪਿਤ ਕਰੋ www.ixxat.com. 2. Ixxat ਦੇ USB-to-CAN V2 ਕੰਪੈਕਟ ਅਡਾਪਟਰ ਨੂੰ USB ਰਾਹੀਂ PC ਨਾਲ ਕਨੈਕਟ ਕਰੋ। 3. ਡਿਵਾਈਸ ਮੈਨੇਜਰ ਦੁਆਰਾ: ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਡ੍ਰਾਈਵਰ ਅਤੇ ਅਡਾਪਟਰ ਦੋਵੇਂ ਸਹੀ ਢੰਗ ਨਾਲ ਸਥਾਪਿਤ/ਪਛਾਣੇ ਗਏ ਹਨ।
4.3 ਵਿੰਡੋਜ਼ ਲਈ ਪੀਕ ਅਡਾਪਟਰ ਡਰਾਈਵਰ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ
ਸਿਰਫ਼ ਡਰਾਇਵਰ ਇੰਸਟਾਲੇਸ਼ਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਪੀਕ ਦੇ PCAN-USB ਅਡਾਪਟਰ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। USB ਡਰਾਈਵ ਦੇ ਉਤਪਾਦ ਮੈਨੂਅਲ ਨੂੰ ਪੜ੍ਹੋ, ਇਹ ਜਾਣਨ ਲਈ ਕਿ ਕੀ/ਕਿਵੇਂ ਵਰਚੁਅਲ ਕੰਪੋਰਟ (VCP) ਨੂੰ ਕਿਰਿਆਸ਼ੀਲ ਕਰਨਾ ਹੈ। 1. ਵਿੰਡੋਜ਼ ਡਿਵਾਈਸ ਡਰਾਈਵਰ ਸੈਟਅਪ (= ਇੰਸਟਾਲੇਸ਼ਨ ਪੈਕੇਜ w/ ਡਿਵਾਈਸ ਡਰਾਈਵਰ, ਟੂਲਸ, ਅਤੇ
APIs) ਤੋਂ http://www.peak-system.com. 2. ਪੀਕ ਦੇ PCAN-USB ਅਡਾਪਟਰ ਨੂੰ USB ਰਾਹੀਂ PC ਨਾਲ ਕਨੈਕਟ ਕਰੋ। 3. ਡਿਵਾਈਸ ਮੈਨੇਜਰ ਦੁਆਰਾ: ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਡ੍ਰਾਈਵਰ ਅਤੇ ਅਡਾਪਟਰ ਦੋਵੇਂ ਸਹੀ ਢੰਗ ਨਾਲ ਸਥਾਪਿਤ/ਪਛਾਣੇ ਗਏ ਹਨ।
4.4 ਲੀਨਕਸ ਲਈ Ixxat ਅਡਾਪਟਰ ਡਰਾਈਵਰ ਇੰਸਟਾਲ ਕਰੋ
ਸਿਰਫ਼ ਡਰਾਇਵਰ ਇੰਸਟਾਲੇਸ਼ਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ Ixxat ਦੇ USB-to-CAN V2 ਅਡਾਪਟਰ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਨੋਟ: ਹੋਰ ਸਮਰਥਿਤ ਅਡਾਪਟਰਾਂ ਨੂੰ sudo chmod +777/dev/ttyACM* (* ਡਿਵਾਈਸ ਨੰਬਰ) ਦੁਆਰਾ ਤੁਹਾਡੀਆਂ ਇਜਾਜ਼ਤਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। USB ਡਰਾਈਵ ਦੇ ਉਤਪਾਦ ਮੈਨੂਅਲ ਨੂੰ ਪੜ੍ਹੋ, ਇਹ ਜਾਣਨ ਲਈ ਕਿ ਕੀ/ਕਿਵੇਂ ਵਰਚੁਅਲ ਕੰਪੋਰਟ (VCP) ਨੂੰ ਕਿਰਿਆਸ਼ੀਲ ਕਰਨਾ ਹੈ। 1. ECI ਡਰਾਈਵਰ ਅਤੇ ਡੈਮੋ ਐਪਲੀਕੇਸ਼ਨ ਲਈ ਲੋੜੀਂਦੇ ਸੌਫਟਵੇਅਰ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ:
sudo apt-get update apt-get install libusb-1.0-0-dev libusb-0.1-4 libc6 libstdc++6 libgcc1 ਬਿਲਡਸੈਂਸ਼ੀਅਲ
2. www.ixxat.com ਤੋਂ ECI-for-Linux ਡਰਾਈਵਰ ਡਾਊਨਲੋਡ ਕਰੋ। ਇਸਨੂੰ ਇਸ ਰਾਹੀਂ ਅਨਜ਼ਿਪ ਕਰੋ:
eci_driver_linux_amd64.zip ਨੂੰ ਅਨਜ਼ਿਪ ਕਰੋ
3. ਦੁਆਰਾ ਡਰਾਈਵਰ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ:
cd /EciLinux_amd/src/KernelModule sudo make install-usb
4. ਡੈਮੋ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਕੰਪਾਇਲ ਅਤੇ ਸ਼ੁਰੂ ਕਰਕੇ ਸਫਲ ਡਰਾਈਵਰ ਇੰਸਟਾਲੇਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰੋ:
cd /EciLinux_amd/src/EciDemos/ sudo ਮੇਕ cd /EciLinux_amd/bin/release/ ./LinuxEciDemo

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

4 ਸ਼ੁਰੂ ਕਰਨਾ
4.5 ਲੀਨਕਸ ਲਈ ਪੀਕ ਅਡਾਪਟਰ ਡਰਾਈਵਰ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ
ਸਿਰਫ਼ ਡਰਾਇਵਰ ਇੰਸਟਾਲੇਸ਼ਨ ਤੋਂ ਬਾਅਦ, ਤੁਸੀਂ ਪੀਕ ਦੇ PCAN-USB ਅਡਾਪਟਰ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ। ਨੋਟ: ਹੋਰ ਸਮਰਥਿਤ ਅਡਾਪਟਰਾਂ ਨੂੰ sudo chmod +777/dev/ttyACM* (* ਡਿਵਾਈਸ ਨੰਬਰ) ਦੁਆਰਾ ਤੁਹਾਡੀਆਂ ਇਜਾਜ਼ਤਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। USB ਡਰਾਈਵ ਦੇ ਉਤਪਾਦ ਮੈਨੂਅਲ ਨੂੰ ਪੜ੍ਹੋ, ਇਹ ਜਾਣਨ ਲਈ ਕਿ ਕੀ/ਕਿਵੇਂ ਵਰਚੁਅਲ ਕੰਪੋਰਟ (VCP) ਨੂੰ ਕਿਰਿਆਸ਼ੀਲ ਕਰਨਾ ਹੈ। 1. ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਤੁਹਾਡੇ ਲੀਨਕਸ ਵਿੱਚ ਕਰਨਲ ਹੈਡਰ ਹਨ: ls /usr/src/linux-headers-`uname -r`। ਜੇਕਰ ਨਹੀਂ, ਤਾਂ ਇੰਸਟਾਲ ਕਰੋ
ਉਹ: sudo apt-get install linux-headers-`uname -r` 2. ਸਿਰਫ਼ ਹੁਣੇ, libpopt-dev ਪੈਕੇਟ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋ: sudo apt-get install libpopt-dev 3. ਲੋੜੀਂਦੇ ਡਰਾਈਵਰ ਪੈਕੇਜ ਨੂੰ ਡਾਊਨਲੋਡ ਕਰੋ (peak-linux-driver- xxx.tar.gz) www.peak-system.com ਤੋਂ। 4. ਇਸਨੂੰ ਅਨਪੈਕ ਕਰਨ ਲਈ, ਵਰਤੋ: tar xzf peak-linux-driver-xxx.tar.gz 5. ਅਨਪੈਕ ਕੀਤੇ ਫੋਲਡਰ ਵਿੱਚ: ਡਰਾਈਵਰਾਂ, PCAN ਬੇਸ ਲਾਇਬ੍ਰੇਰੀ, ਆਦਿ ਨੂੰ ਕੰਪਾਇਲ ਅਤੇ ਸਥਾਪਿਤ ਕਰੋ: ਸਾਰੇ ਬਣਾਓ
sudo make install 6. ਫੰਕਸ਼ਨ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ, PCAN-USB ਅਡਾਪਟਰ ਨੂੰ ਪਲੱਗ ਇਨ ਕਰੋ।
a) ਕਰਨਲ ਮੋਡੀਊਲ ਦੀ ਜਾਂਚ ਕਰੋ:
lsmod | grep pcan b) … ਅਤੇ ਸਾਂਝੀ ਲਾਇਬ੍ਰੇਰੀ:
ls -l /usr/lib/libpcan*
ਨੋਟ: ਜੇਕਰ USB3 ਸਮੱਸਿਆਵਾਂ ਆਉਂਦੀਆਂ ਹਨ, ਤਾਂ ਇੱਕ USB2 ਪੋਰਟ ਦੀ ਵਰਤੋਂ ਕਰੋ।
4.6 ਆਪਣੇ ਹਾਰਡਵੇਅਰ ਨੂੰ ਕਨੈਕਟ ਕਰੋ
NanoLib ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਚਲਾਉਣ ਦੇ ਯੋਗ ਹੋਣ ਲਈ, ਆਪਣੇ ਅਡਾਪਟਰ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇੱਕ ਅਨੁਕੂਲ ਨੈਨੋਟੈਕ ਕੰਟਰੋਲਰ ਨੂੰ ਪੀਸੀ ਨਾਲ ਕਨੈਕਟ ਕਰੋ। 1. ਇੱਕ ਢੁਕਵੀਂ ਕੇਬਲ ਦੁਆਰਾ, ਆਪਣੇ ਅਡਾਪਟਰ ਨੂੰ ਕੰਟਰੋਲਰ ਨਾਲ ਕਨੈਕਟ ਕਰੋ। 2. ਅਡਾਪਟਰ ਡੇਟਾ ਸ਼ੀਟ ਦੇ ਅਨੁਸਾਰ ਅਡਾਪਟਰ ਨੂੰ ਪੀਸੀ ਨਾਲ ਕਨੈਕਟ ਕਰੋ। 3. ਇੱਕ ਢੁਕਵੀਂ ਪਾਵਰ ਸਪਲਾਈ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ ਕੰਟਰੋਲਰ 'ਤੇ ਪਾਵਰ। 4. ਜੇਕਰ ਲੋੜ ਹੋਵੇ, ਤਾਂ ਨੈਨੋਟੈਕ ਕੰਟਰੋਲਰ ਦੀਆਂ ਸੰਚਾਰ ਸੈਟਿੰਗਾਂ ਨੂੰ ਬਦਲੋ ਜਿਵੇਂ ਕਿ ਇਸਦੇ ਉਤਪਾਦ ਮੈਨੂਅਲ ਵਿੱਚ ਨਿਰਦੇਸ਼ ਦਿੱਤੇ ਗਏ ਹਨ।
4.7 NanoLib ਲੋਡ ਕਰੋ
ਤੇਜ਼-ਅਤੇ-ਆਸਾਨ ਮੂਲ ਦੇ ਨਾਲ ਪਹਿਲੀ ਸ਼ੁਰੂਆਤ ਲਈ, ਤੁਸੀਂ ਸਾਡੇ ਸਾਬਕਾ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ (ਪਰ ਨਹੀਂ ਕਰਨੀ ਚਾਹੀਦੀ)ample ਪ੍ਰੋਜੈਕਟ. 1. ਤੁਹਾਡੇ ਖੇਤਰ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ: ਸਾਡੇ ਤੋਂ NanoLib ਡਾਊਨਲੋਡ ਕਰੋ webEMEA / APAC ਜਾਂ ਅਮਰੀਕਾ ਲਈ ਸਾਈਟ। 2. ਪੈਕੇਜ ਨੂੰ ਅਨਜ਼ਿਪ ਕਰੋ files / ਫੋਲਡਰ ਅਤੇ ਡੂ ਇੱਕ ਵਿਕਲਪ ਦੀ ਚੋਣ ਕਰੋ: ਤੇਜ਼-ਅਤੇ ਆਸਾਨ ਬੁਨਿਆਦ ਲਈ: ਸਾਬਕਾ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨਾ ਦੇਖੋample ਪ੍ਰੋਜੈਕਟ. ਵਿੰਡੋਜ਼ ਵਿੱਚ ਐਡਵਾਂਸਡ ਕਸਟਮਾਈਜ਼ਿੰਗ ਲਈ: ਆਪਣਾ ਵਿੰਡੋਜ਼ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣਾ ਦੇਖੋ। ਲੀਨਕਸ ਵਿੱਚ ਐਡਵਾਂਸਡ ਕਸਟਮਾਈਜ਼ਿੰਗ ਲਈ: ਆਪਣਾ ਖੁਦ ਦਾ ਲੀਨਕਸ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣਾ ਦੇਖੋ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

ਸਾਬਕਾ ਸ਼ੁਰੂ ਕਰ ਰਿਹਾ ਹੈample ਪ੍ਰੋਜੈਕਟ

ਨੈਨੋਲਿਬ ਨੂੰ ਵਿਧੀਵਤ ਲੋਡ ਕਰਨ ਦੇ ਨਾਲ, ਸਾਬਕਾample ਪ੍ਰੋਜੈਕਟ ਤੁਹਾਨੂੰ ਨੈਨੋਟੈਕ ਕੰਟਰੋਲਰ ਦੇ ਨਾਲ NanoLib ਵਰਤੋਂ ਰਾਹੀਂ ਦਿਖਾਉਂਦਾ ਹੈ। ਨੋਟ: ਹਰੇਕ ਕਦਮ ਲਈ, ਦਿੱਤੇ ਗਏ ਸਾਬਕਾ ਵਿੱਚ ਟਿੱਪਣੀਆਂample ਕੋਡ ਵਰਤੇ ਗਏ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਿਆਖਿਆ ਕਰਦਾ ਹੈ। ਸਾਬਕਾample ਪ੍ਰੋਜੈਕਟ ਵਿੱਚ ਸ਼ਾਮਲ ਹਨ: `*_functions_example.*' files, ਜਿਸ ਵਿੱਚ NanoLib ਇੰਟਰਫੇਸ ਫੰਕਸ਼ਨ ਲਈ ਲਾਗੂਕਰਨ ਹਨ `*_callback_example.*' files, ਜਿਸ ਵਿੱਚ ਵੱਖ-ਵੱਖ ਕਾਲਬੈਕਾਂ (ਸਕੈਨ, ਡੇਟਾ ਅਤੇ
ਲੌਗਿੰਗ) 'ਮੀਨੂ_*।*' file, ਜਿਸ ਵਿੱਚ ਮੀਨੂ ਤਰਕ ਅਤੇ ਕੋਡ Example.* file, ਜੋ ਕਿ ਮੁੱਖ ਪ੍ਰੋਗਰਾਮ ਹੈ, ਮੀਨੂ ਬਣਾਉਣਾ ਅਤੇ ਸਾਰੇ ਵਰਤੇ ਗਏ ਪੈਰਾਮੀਟਰਾਂ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨਾ Sampler_example.* file, ਜਿਸ ਵਿੱਚ ਸਾਬਕਾ ਸ਼ਾਮਲ ਹੈamps ਲਈ le ਲਾਗੂampler ਵਰਤੋਂ. ਤੁਸੀਂ ਹੋਰ ਸਾਬਕਾ ਲੱਭ ਸਕਦੇ ਹੋamples, nanotec.com 'ਤੇ ਗਿਆਨ ਅਧਾਰ ਵਿੱਚ, ਵੱਖ-ਵੱਖ ਓਪਰੇਸ਼ਨ ਮੋਡਾਂ ਲਈ ਕੁਝ ਮੋਸ਼ਨ ਕਮਾਂਡਾਂ ਦੇ ਨਾਲ। ਸਾਰੇ ਵਿੰਡੋਜ਼ ਜਾਂ ਲੀਨਕਸ ਵਿੱਚ ਵਰਤਣ ਯੋਗ ਹਨ।
ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ ਦੇ ਨਾਲ ਵਿੰਡੋਜ਼ ਵਿੱਚ 1. ਐਕਸ ਖੋਲ੍ਹੋample.sln file. 2. ਸਾਬਕਾ ਖੋਲ੍ਹੋample.cpp. 3. ਕੰਪਾਇਲ ਕਰੋ ਅਤੇ ਐਕਸ ਚਲਾਓampਲੇ ਕੋਡ.
Bash 1 ਦੁਆਰਾ ਲੀਨਕਸ ਵਿੱਚ. ਸਰੋਤ ਨੂੰ ਅਨਜ਼ਿਪ ਕਰੋ file, ਅਨਜ਼ਿਪ ਕੀਤੀ ਸਮੱਗਰੀ ਵਾਲੇ ਫੋਲਡਰ 'ਤੇ ਨੈਵੀਗੇਟ ਕਰੋ। ਮੁੱਖ file ਸਾਬਕਾ ਲਈample ਹੈ
example.cpp. 2. ਬੈਸ਼ ਵਿੱਚ, ਕਾਲ ਕਰੋ:
a ਸ਼ੇਅਰ ਕੀਤੀਆਂ ਵਸਤੂਆਂ ਦੀ ਨਕਲ ਕਰਨ ਅਤੇ ldconfig ਨੂੰ ਕਾਲ ਕਰਨ ਲਈ "sudo make install" ਕਰੋ। ਬੀ. ਟੈਸਟ ਨੂੰ ਚੱਲਣਯੋਗ ਬਣਾਉਣ ਲਈ “ਸਭ ਨੂੰ ਬਣਾਓ”। 3. ਬਿਨ ਫੋਲਡਰ ਵਿੱਚ ਇੱਕ ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਐਕਸ ਹੈample file. bash ਦੁਆਰਾ: ਆਉਟਪੁੱਟ ਫੋਲਡਰ ਤੇ ਜਾਓ ਅਤੇ ਟਾਈਪ ਕਰੋ ./example. ਜੇਕਰ ਕੋਈ ਗਲਤੀ ਨਹੀਂ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਤੁਹਾਡੀਆਂ ਸਾਂਝੀਆਂ ਕੀਤੀਆਂ ਵਸਤੂਆਂ ਹੁਣ ਸਹੀ ਢੰਗ ਨਾਲ ਸਥਾਪਿਤ ਹੋ ਗਈਆਂ ਹਨ, ਅਤੇ ਤੁਹਾਡੀ ਲਾਇਬ੍ਰੇਰੀ ਵਰਤੋਂ ਲਈ ਤਿਆਰ ਹੈ। ਜੇਕਰ ਗਲਤੀ ./ex ਪੜ੍ਹਦੀ ਹੈample: ਸ਼ੇਅਰਡ ਲਾਇਬ੍ਰੇਰੀਆਂ ਨੂੰ ਲੋਡ ਕਰਨ ਦੌਰਾਨ ਗਲਤੀ: libnanolib.so: ਸ਼ੇਅਰਡ ਆਬਜੈਕਟ ਨਹੀਂ ਖੋਲ੍ਹ ਸਕਦਾ file: ਅਜਿਹਾ ਨਹੀਂ file ਜਾਂ ਡਾਇਰੈਕਟਰੀ, ਸ਼ੇਅਰਡ ਆਬਜੈਕਟਸ ਦੀ ਸਥਾਪਨਾ ਅਸਫਲ ਰਹੀ। ਇਸ ਸਥਿਤੀ ਵਿੱਚ, ਅਗਲੇ ਕਦਮਾਂ ਦੀ ਪਾਲਣਾ ਕਰੋ। 4. /usr/local/lib (ਪ੍ਰਬੰਧਕ ਅਧਿਕਾਰਾਂ ਦੀ ਲੋੜ ਹੈ) ਦੇ ਅੰਦਰ ਇੱਕ ਨਵਾਂ ਫੋਲਡਰ ਬਣਾਓ। ਬੈਸ਼ ਵਿੱਚ, ਇਸ ਤਰ੍ਹਾਂ ਟਾਈਪ ਕਰੋ:
sudo mkdir /usr/local/lib/nanotec
5. ਜ਼ਿਪ ਤੋਂ ਸਾਰੀਆਂ ਸਾਂਝੀਆਂ ਵਸਤੂਆਂ ਦੀ ਨਕਲ ਕਰੋ fileਦਾ lib ਫੋਲਡਰ:
ਇੰਸਟਾਲ ਕਰੋ ./lib/*.so /usr/local/lib/nanotec/
6. ਇਸ ਨਾਲ ਨਿਸ਼ਾਨਾ ਫੋਲਡਰ ਦੀ ਸਮੱਗਰੀ ਦੀ ਜਾਂਚ ਕਰੋ:
ls -al /usr/local/lib/nanotec/
ਇਹ ਸ਼ੇਅਰਡ ਆਬਜੈਕਟ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰਨਾ ਚਾਹੀਦਾ ਹੈ files lib ਫੋਲਡਰ ਤੋਂ. 7. ਇਸ ਫੋਲਡਰ 'ਤੇ ldconfig ਚਲਾਓ:
sudo ldconfig /usr/local/lib/nanotec/
ਸਾਬਕਾample ਨੂੰ ਇੱਕ CLI ਐਪਲੀਕੇਸ਼ਨ ਵਜੋਂ ਲਾਗੂ ਕੀਤਾ ਗਿਆ ਹੈ ਅਤੇ ਇੱਕ ਮੀਨੂ ਇੰਟਰਫੇਸ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਮੀਨੂ ਇੰਦਰਾਜ਼ ਸੰਦਰਭ ਆਧਾਰਿਤ ਹਨ ਅਤੇ ਸੰਦਰਭ ਸਥਿਤੀ 'ਤੇ ਨਿਰਭਰ ਕਰਦੇ ਹੋਏ, ਸਮਰੱਥ ਜਾਂ ਅਯੋਗ ਕੀਤੇ ਜਾਣਗੇ। ਉਹ ਤੁਹਾਨੂੰ ਕੰਟਰੋਲਰ ਨੂੰ ਸੰਭਾਲਣ ਲਈ ਆਮ ਵਰਕਫਲੋ ਦੇ ਬਾਅਦ ਵੱਖ-ਵੱਖ ਲਾਇਬ੍ਰੇਰੀ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਚੁਣਨ ਅਤੇ ਚਲਾਉਣ ਦੀ ਸੰਭਾਵਨਾ ਦੀ ਪੇਸ਼ਕਸ਼ ਕਰਦੇ ਹਨ: 1. ਕਨੈਕਟ ਕੀਤੇ ਹਾਰਡਵੇਅਰ (ਅਡਾਪਟਰ) ਲਈ ਪੀਸੀ ਦੀ ਜਾਂਚ ਕਰੋ ਅਤੇ ਉਹਨਾਂ ਦੀ ਸੂਚੀ ਬਣਾਓ। 2. ਇੱਕ ਅਡਾਪਟਰ ਨਾਲ ਕੁਨੈਕਸ਼ਨ ਸਥਾਪਤ ਕਰੋ। 3. ਕਨੈਕਟ ਕੀਤੇ ਕੰਟਰੋਲਰ ਯੰਤਰਾਂ ਲਈ ਬੱਸ ਨੂੰ ਸਕੈਨ ਕਰੋ। 4. ਇੱਕ ਡਿਵਾਈਸ ਨਾਲ ਕਨੈਕਟ ਕਰੋ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

5 ਸਾਬਕਾ ਨੂੰ ਸ਼ੁਰੂ ਕਰਨਾample ਪ੍ਰੋਜੈਕਟ
5. ਲਾਇਬ੍ਰੇਰੀ ਦੇ ਇੱਕ ਜਾਂ ਵੱਧ ਫੰਕਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਰੋ: ਕੰਟਰੋਲਰ ਦੇ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਨੂੰ ਪੜ੍ਹੋ/ਲਿਖੋ, ਫਰਮਵੇਅਰ ਨੂੰ ਅੱਪਡੇਟ ਕਰੋ, ਇੱਕ NanoJ ਪ੍ਰੋਗਰਾਮ ਅੱਪਲੋਡ ਅਤੇ ਚਲਾਓ, ਮੋਟਰ ਨੂੰ ਚਾਲੂ ਕਰੋ ਅਤੇ ਇਸਨੂੰ ਟਿਊਨ ਕਰੋ, ਲੌਗਿੰਗ/s ਨੂੰ ਕੌਂਫਿਗਰ ਕਰੋ ਅਤੇ ਵਰਤੋ।ampler
6. ਕਨੈਕਸ਼ਨ ਬੰਦ ਕਰੋ, ਪਹਿਲਾਂ ਡਿਵਾਈਸ ਨਾਲ, ਫਿਰ ਅਡਾਪਟਰ ਨਾਲ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

ਆਪਣਾ ਵਿੰਡੋਜ਼ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣਾ

NanoLib ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਆਪਣਾ ਵਿੰਡੋਜ਼ ਪ੍ਰੋਜੈਕਟ ਬਣਾਓ, ਕੰਪਾਇਲ ਕਰੋ ਅਤੇ ਚਲਾਓ।
6.1 NanoLib ਆਯਾਤ ਕਰੋ
NanoLib ਸਿਰਲੇਖ ਨੂੰ ਆਯਾਤ ਕਰੋ files ਅਤੇ MS Visual Studio ਦੁਆਰਾ ਲਾਇਬ੍ਰੇਰੀਆਂ।
1. ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ ਖੋਲ੍ਹੋ। 2. ਨਵਾਂ ਪ੍ਰੋਜੈਕਟ ਬਣਾਓ > ਕੰਸੋਲ ਐਪ C++ > ਅੱਗੇ: ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਕਿਸਮ ਚੁਣੋ। 3. ਹੱਲ ਐਕਸਪਲੋਰਰ ਵਿੱਚ ਇੱਕ ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ ਬਣਾਉਣ ਲਈ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਨਾਮ ਦਿਓ (ਇੱਥੇ: NanolibTest)। 4. ਸਮਾਪਤ ਚੁਣੋ। 5. ਵਿੰਡੋਜ਼ ਖੋਲ੍ਹੋ file ਐਕਸਪਲੋਰਰ ਅਤੇ ਨਵੇਂ ਬਣਾਏ ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ 'ਤੇ ਨੈਵੀਗੇਟ ਕਰੋ। 6. ਦੋ ਨਵੇਂ ਫੋਲਡਰ, inc ਅਤੇ lib ਬਣਾਓ। 7. NanoLib ਪੈਕੇਜ ਫੋਲਡਰ ਖੋਲ੍ਹੋ। 8. ਉੱਥੋਂ: ਸਿਰਲੇਖ ਨੂੰ ਕਾਪੀ ਕਰੋ fileਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ inc ਅਤੇ ਸਾਰੇ .lib ਅਤੇ .dll ਵਿੱਚ ਸ਼ਾਮਲ ਫੋਲਡਰ ਤੋਂ s
files ਨੂੰ ਤੁਹਾਡੇ ਨਵੇਂ ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ lib ਵਿੱਚ ਭੇਜੋ। 9. ਨਿਯਤ ਢਾਂਚੇ ਲਈ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ ਦੀ ਜਾਂਚ ਕਰੋ, ਸਾਬਕਾ ਲਈampLe:

ਨੀਯਤ ਢਾਂਚੇ ਲਈ ect ਫੋਲਡਰ:
. NanolibTest inc accessor_factory.hpp bus_hardware_id.hpp … od_index.hpp ਨਤੀਜਾ_od_entry.hpp lib nanolibm_canopen.dll nanolib.dll … nanolib.lib NanolibTest.cpp NanolibTest.vcxproj NanolibTest. NanolibTest.vcxproj.user NanolibTest.sln
6.2 ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰੋ
NanoLib ਪ੍ਰੋਜੈਕਟਾਂ ਨੂੰ ਸਥਾਪਤ ਕਰਨ ਲਈ MS ਵਿਜ਼ੂਅਲ ਸਟੂਡੀਓ ਵਿੱਚ ਹੱਲ ਐਕਸਪਲੋਰਰ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਨੋਟ: ਸਹੀ NanoLib ਓਪਰੇਸ਼ਨ ਲਈ, ਵਿਜ਼ੂਅਲ C++ ਪ੍ਰੋਜੈਕਟ ਸੈਟਿੰਗਾਂ ਵਿੱਚ ਰਿਲੀਜ਼ (ਡੀਬੱਗ ਨਹੀਂ!) ਸੰਰਚਨਾ ਦੀ ਚੋਣ ਕਰੋ; ਫਿਰ C++ ਮੁੜ ਵੰਡਣਯੋਗ [2022] ਦੇ VC ਰਨਟਾਈਮ ਨਾਲ ਪ੍ਰੋਜੈਕਟ ਬਣਾਓ ਅਤੇ ਲਿੰਕ ਕਰੋ।
1. ਹੱਲ ਐਕਸਪਲੋਰਰ ਵਿੱਚ: ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ 'ਤੇ ਜਾਓ (ਇੱਥੇ: NanolibTest)। 2. ਸੰਦਰਭ ਮੀਨੂ ਨੂੰ ਖੋਲ੍ਹਣ ਲਈ ਫੋਲਡਰ 'ਤੇ ਸਹਿ-ਕਲਿੱਕ ਕਰੋ। 3. ਵਿਸ਼ੇਸ਼ਤਾ ਚੁਣੋ। 4. ਸਾਰੀਆਂ ਸੰਰਚਨਾਵਾਂ ਅਤੇ ਸਾਰੇ ਪਲੇਟਫਾਰਮਾਂ ਨੂੰ ਸਰਗਰਮ ਕਰੋ। 5. C/C++ ਚੁਣੋ ਅਤੇ ਵਧੀਕ ਇਨਕਲੂਡ ਡਾਇਰੈਕਟਰੀਆਂ 'ਤੇ ਜਾਓ। 6. ਸੰਮਿਲਿਤ ਕਰੋ: $(ProjectDir)Nanolib/includes;%(AdditionalIncludeDirectories) 7. ਲਿੰਕਰ ਚੁਣੋ ਅਤੇ ਵਧੀਕ ਲਾਇਬ੍ਰੇਰੀ ਡਾਇਰੈਕਟਰੀਆਂ 'ਤੇ ਜਾਓ। 8. ਸੰਮਿਲਿਤ ਕਰੋ: $(ProjectDir)Nanolib;%(AdditionalLibraryDirectories) 9. ਲਿੰਕਰ ਨੂੰ ਵਧਾਓ ਅਤੇ ਇਨਪੁਟ ਚੁਣੋ। 10. ਵਧੀਕ ਨਿਰਭਰਤਾਵਾਂ 'ਤੇ ਜਾਓ ਅਤੇ ਸੰਮਿਲਿਤ ਕਰੋ: nanolib.lib;%(Additional Dependencies) 11.OK ਰਾਹੀਂ ਪੁਸ਼ਟੀ ਕਰੋ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

6 ਆਪਣਾ ਵਿੰਡੋਜ਼ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣਾ
12. ਕੌਨਫਿਗਰੇਸ਼ਨ > C++ > ਭਾਸ਼ਾ > ਭਾਸ਼ਾ ਸਟੈਂਡਰਡ > ISO C++17 ਸਟੈਂਡਰਡ 'ਤੇ ਜਾਓ ਅਤੇ ਭਾਸ਼ਾ ਦੇ ਮਿਆਰ ਨੂੰ C++17 (/std:c++17) 'ਤੇ ਸੈੱਟ ਕਰੋ।
6.3 ਆਪਣਾ ਪ੍ਰੋਜੈਕਟ ਬਣਾਓ
MS ਵਿਜ਼ੁਅਲ ਸਟੂਡੀਓ ਵਿੱਚ ਆਪਣਾ NanoLib ਪ੍ਰੋਜੈਕਟ ਬਣਾਓ। 1. ਮੁੱਖ *.cpp ਖੋਲ੍ਹੋ file (ਇੱਥੇ: nanolib_example.cpp) ਅਤੇ ਕੋਡ ਨੂੰ ਸੰਪਾਦਿਤ ਕਰੋ, ਜੇਕਰ ਲੋੜ ਹੋਵੇ। 2. ਬਿਲਡ > ਕੌਂਫਿਗਰੇਸ਼ਨ ਮੈਨੇਜਰ ਚੁਣੋ। 3. ਸਰਗਰਮ ਹੱਲ ਪਲੇਟਫਾਰਮਾਂ ਨੂੰ x64 ਵਿੱਚ ਬਦਲੋ। 4. ਬੰਦ ਕਰਕੇ ਪੁਸ਼ਟੀ ਕਰੋ। 5. ਬਿਲਡ > ਬਿਲਡ ਹੱਲ ਚੁਣੋ। 6. ਕੋਈ ਗਲਤੀ ਨਹੀਂ? ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਤੁਹਾਡੀ ਕੰਪਾਇਲ ਆਉਟਪੁੱਟ ਪੂਰੀ ਤਰ੍ਹਾਂ ਰਿਪੋਰਟ ਕਰਦੀ ਹੈ:
1>—— ਕਲੀਨ ਅਰੰਭ ਕੀਤਾ ਗਿਆ: ਪ੍ਰੋਜੈਕਟ: NanolibTest, ਸੰਰਚਨਾ: ਡੀਬੱਗ x64 —–========== ਸਾਫ਼: 1 ਸਫਲ, 0 ਅਸਫਲ, 0 ਛੱਡਿਆ ===========

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

7 ਆਪਣਾ ਖੁਦ ਦਾ ਲੀਨਕਸ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣਾ
7 ਆਪਣਾ ਖੁਦ ਦਾ ਲੀਨਕਸ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣਾ
NanoLib ਦੀ ਵਰਤੋਂ ਕਰਨ ਲਈ ਆਪਣਾ ਖੁਦ ਦਾ ਲੀਨਕਸ ਪ੍ਰੋਜੈਕਟ ਬਣਾਓ, ਕੰਪਾਇਲ ਕਰੋ ਅਤੇ ਚਲਾਓ। 1. ਅਨਜ਼ਿਪਡ NanoLib ਇੰਸਟਾਲੇਸ਼ਨ ਕਿੱਟ ਵਿੱਚ: ਖੋਲ੍ਹੋ /nanotec_nanolib. 2. tar.gz ਵਿੱਚ ਸਾਰੀਆਂ ਸਾਂਝੀਆਂ ਵਸਤੂਆਂ ਲੱਭੋ file. 3. ਇੱਕ ਵਿਕਲਪ ਚੁਣੋ: ਹਰੇਕ ਲਿਬ ਨੂੰ ਮੇਕ ਨਾਲ ਸਥਾਪਿਤ ਕਰੋfile ਜਾਂ ਹੱਥ ਨਾਲ.
7.1 ਮੇਕ ਨਾਲ ਸ਼ੇਅਰ ਕੀਤੀਆਂ ਵਸਤੂਆਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰੋfile
ਮੇਕ ਦੀ ਵਰਤੋਂ ਕਰੋfile ਲੀਨਕਸ ਬੈਸ਼ ਨਾਲ ਸਾਰੇ ਡਿਫਾਲਟ *.so ਨੂੰ ਆਟੋ-ਇੰਸਟਾਲ ਕਰਨ ਲਈ fileਐੱਸ. 1. Bash ਰਾਹੀਂ: ਮੇਕ ਵਾਲੇ ਫੋਲਡਰ 'ਤੇ ਜਾਓfile. 2. ਸ਼ੇਅਰ ਕੀਤੀਆਂ ਵਸਤੂਆਂ ਨੂੰ ਇਸ ਰਾਹੀਂ ਕਾਪੀ ਕਰੋ:
sudo make install 3. ਦੁਆਰਾ ਪੁਸ਼ਟੀ ਕਰੋ:
ldconfig
7.2 ਸਾਂਝੀਆਂ ਵਸਤੂਆਂ ਨੂੰ ਹੱਥਾਂ ਨਾਲ ਸਥਾਪਿਤ ਕਰੋ
ਸਭ ਨੂੰ ਇੰਸਟਾਲ ਕਰਨ ਲਈ ਇੱਕ Bash ਵਰਤੋ *.so fileਹੱਥੀਂ NanoLib ਦਾ s. 1. Bash ਰਾਹੀਂ: /usr/local/lib ਦੇ ਅੰਦਰ ਇੱਕ ਨਵਾਂ ਫੋਲਡਰ ਬਣਾਓ। 2. ਐਡਮਿਨ ਅਧਿਕਾਰਾਂ ਦੀ ਲੋੜ ਹੈ! ਕਿਸਮ:
sudo mkdir /usr/local/lib/nanotec 3. ਅਣਜ਼ਿਪ ਇੰਸਟਾਲੇਸ਼ਨ ਪੈਕੇਜ ਫੋਲਡਰ ਵਿੱਚ ਬਦਲੋ। 4. lib ਫੋਲਡਰ ਤੋਂ ਸਾਰੀਆਂ ਸਾਂਝੀਆਂ ਵਸਤੂਆਂ ਨੂੰ ਇਸ ਰਾਹੀਂ ਕਾਪੀ ਕਰੋ:
ਇੰਸਟਾਲ ਕਰੋ ./nanotec_nanolib/lib/*.so /usr/local/lib/nanotec/ 5. ਟੀਚੇ ਦੇ ਫੋਲਡਰ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਇਸ ਰਾਹੀਂ ਚੈੱਕ ਕਰੋ:
ls -al /usr/local/lib/nanotec/ 6. ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ lib ਫੋਲਡਰ ਦੀਆਂ ਸਾਰੀਆਂ ਸਾਂਝੀਆਂ ਵਸਤੂਆਂ ਸੂਚੀਬੱਧ ਹਨ। 7. ਇਸ ਫੋਲਡਰ 'ਤੇ ldconfig ਚਲਾਓ:
sudo ldconfig /usr/local/lib/nanotec/
7.3 ਆਪਣਾ ਪ੍ਰੋਜੈਕਟ ਬਣਾਓ
ਤੁਹਾਡੀਆਂ ਸਾਂਝੀਆਂ ਵਸਤੂਆਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਨ ਦੇ ਨਾਲ: ਆਪਣੇ Linux NanoLib ਲਈ ਇੱਕ ਨਵਾਂ ਪ੍ਰੋਜੈਕਟ ਬਣਾਓ। 1. Bash ਰਾਹੀਂ: ਇੱਕ ਨਵਾਂ ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ ਬਣਾਓ (ਇੱਥੇ: NanoLibTest) ਰਾਹੀਂ:
mkdir NanoLibTest cd NanoLibTest
2. ਸਿਰਲੇਖ ਦੀ ਨਕਲ ਕਰੋ files ਨੂੰ ਇੱਕ ਸ਼ਾਮਿਲ ਫੋਲਡਰ (ਇੱਥੇ: inc) ਰਾਹੀਂ: mkdir inc cp / FILE IS>/nanotec_nanolib/inc/*.hpp inc
3. ਇੱਕ ਮੁੱਖ ਬਣਾਓ file (NanoLibTest.cpp) ਰਾਹੀਂ: #include “accessor_factory.hpp” #ਸ਼ਾਮਲ

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

7 ਆਪਣਾ ਖੁਦ ਦਾ ਲੀਨਕਸ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣਾ
int main(){ nlc::NanoLibAccessor *accessor = getNanoLibAccessor();
nlc::ResultBusHwIds ਨਤੀਜਾ = ਐਕਸੈਸਰ->ਲਿਸਟ ਉਪਲਬਧ ਬਸ ਹਾਰਡਵੇਅਰ ();
if(result.hasError()) { std::cout << result.getError() << std::endl; }
else{ std::cout << "ਸਫਲਤਾ" << std::endl; }
ਐਕਸੈਸਰ ਨੂੰ ਮਿਟਾਓ; ਵਾਪਸੀ 0; }
4. ਨਿਯਤ ਢਾਂਚੇ ਲਈ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਫੋਲਡਰ ਦੀ ਜਾਂਚ ਕਰੋ:

. NanoLibTest
inc accessor_factory.hpp bus_hardware_id.hpp … od_index.hpp ਨਤੀਜਾ.hpp NanoLibTest.cpp
7.4 ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਕੰਪਾਇਲ ਕਰੋ ਅਤੇ ਟੈਸਟ ਕਰੋ
ਆਪਣੇ ਲੀਨਕਸ NanoLib ਨੂੰ Bash ਰਾਹੀਂ ਵਰਤੋਂ ਲਈ ਤਿਆਰ ਕਰੋ।
1. ਬਾਸ਼ ਰਾਹੀਂ: ਮੁੱਖ ਕੰਪਾਇਲ ਕਰੋ file ਦੁਆਰਾ:
g++ -ਵਾਲ -ਵੈਕਸਟਰਾ -ਪੀਡੈਂਟਿਕ -I./inc -c NanoLibTest.cpp -o NanoLibTest
2. ਐਗਜ਼ੀਕਿਊਟੇਬਲ ਨੂੰ ਇਸ ਰਾਹੀਂ ਲਿੰਕ ਕਰੋ:
g++ -ਵਾਲ -ਵੈਕਸਟਰਾ -ਪੀਡੈਂਟਿਕ -I./inc -o ਟੈਸਟ NanoLibTest.o L/usr/local/lib/nanotec -lnanolib -ldl
3. ਇਸ ਦੁਆਰਾ ਟੈਸਟ ਪ੍ਰੋਗਰਾਮ ਚਲਾਓ:
./ਟੈਸਟ
4. ਜਾਂਚ ਕਰੋ ਕਿ ਕੀ ਤੁਹਾਡੀ ਬੈਸ਼ ਸਹੀ ਤਰ੍ਹਾਂ ਰਿਪੋਰਟ ਕਰਦੀ ਹੈ:
ਸਫਲਤਾ

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ਇੱਥੇ NanoLib ਦੇ ਯੂਜ਼ਰ ਇੰਟਰਫੇਸ ਕਲਾਸਾਂ ਅਤੇ ਉਹਨਾਂ ਦੇ ਮੈਂਬਰ ਫੰਕਸ਼ਨਾਂ ਦੀ ਇੱਕ ਸੂਚੀ ਲੱਭੋ। ਇੱਕ ਫੰਕਸ਼ਨ ਦੇ ਖਾਸ ਵਰਣਨ ਵਿੱਚ ਇੱਕ ਛੋਟੀ ਜਾਣ-ਪਛਾਣ, ਫੰਕਸ਼ਨ ਪਰਿਭਾਸ਼ਾ ਅਤੇ ਇੱਕ ਪੈਰਾਮੀਟਰ / ਵਾਪਸੀ ਸੂਚੀ ਸ਼ਾਮਲ ਹੁੰਦੀ ਹੈ:

ExampleFunction () ਤੁਹਾਨੂੰ ਸੰਖੇਪ ਵਿੱਚ ਦੱਸਦਾ ਹੈ ਕਿ ਫੰਕਸ਼ਨ ਕੀ ਕਰਦਾ ਹੈ।
virtual void nlc::NanoLibAccessor::ExampleFunction (Param_a const & param_a, Param_b const & param_B)

ਪੈਰਾਮੀਟਰ param_a param_b
ResultVoid ਦਿੰਦਾ ਹੈ

ਜੇ ਲੋੜ ਹੋਵੇ ਤਾਂ ਵਾਧੂ ਟਿੱਪਣੀ। ਜੇ ਲੋੜ ਹੋਵੇ ਤਾਂ ਵਾਧੂ ਟਿੱਪਣੀ।

8.1 NanoLibAccessor

ਇੰਟਰਫੇਸ ਕਲਾਸ NanoLib ਲਈ ਐਂਟਰੀ ਪੁਆਇੰਟ ਵਜੋਂ ਵਰਤੀ ਜਾਂਦੀ ਹੈ। ਇੱਕ ਆਮ ਵਰਕਫਲੋ ਇਸ ਤਰ੍ਹਾਂ ਦਿਖਾਈ ਦਿੰਦਾ ਹੈ:
1. NanoLibAccessor.listAvailableBusHardware () ਨਾਲ ਹਾਰਡਵੇਅਰ ਲਈ ਸਕੈਨ ਕਰਕੇ ਸ਼ੁਰੂ ਕਰੋ। 2. BusHardwareOptions () ਨਾਲ ਸੰਚਾਰ ਸੈਟਿੰਗਾਂ ਸੈਟ ਕਰੋ। 3. NanoLibAccessor.openBusHardwareWithProtocol () ਨਾਲ ਹਾਰਡਵੇਅਰ ਕਨੈਕਸ਼ਨ ਖੋਲ੍ਹੋ। 4. NanoLibAccessor.scanDevices () ਨਾਲ ਜੁੜੀਆਂ ਡਿਵਾਈਸਾਂ ਲਈ ਬੱਸ ਨੂੰ ਸਕੈਨ ਕਰੋ। 5. NanoLibAccessor.addDevice () ਨਾਲ ਇੱਕ ਡਿਵਾਈਸ ਜੋੜੋ। 6. NanoLibAccessor.connectDevice () ਨਾਲ ਡਿਵਾਈਸ ਨਾਲ ਕਨੈਕਟ ਕਰੋ। 7. ਕਾਰਵਾਈ ਨੂੰ ਪੂਰਾ ਕਰਨ ਤੋਂ ਬਾਅਦ, NanoLibAccessor.disconnectDevice () ਨਾਲ ਡਿਵਾਈਸ ਨੂੰ ਡਿਸਕਨੈਕਟ ਕਰੋ। 8. NanoLibAccessor.removeDevice () ਨਾਲ ਡਿਵਾਈਸ ਨੂੰ ਹਟਾਓ। 9. NanoLibAccessor.closeBusHardware () ਨਾਲ ਹਾਰਡਵੇਅਰ ਕਨੈਕਸ਼ਨ ਬੰਦ ਕਰੋ।
NanoLibAccessor ਦੇ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:

listAvailableBusHardware () ਉਪਲੱਬਧ ਫੀਲਡਬੱਸ ਹਾਰਡਵੇਅਰ ਨੂੰ ਸੂਚੀਬੱਧ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultBusHwIds nlc::NanoLibAccessor::listAvailableBusHardware ()

ResultBusHwIds ਵਾਪਸ ਕਰਦਾ ਹੈ

ਇੱਕ ਫੀਲਡਬੱਸ ID ਐਰੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

openBusHardwareWithProtocol () ਬੱਸ ਹਾਰਡਵੇਅਰ ਨਾਲ ਜੁੜਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultVoid nlc::NanoLibAccessor::openBusHardwareWithProtocol (BusHardwareId const & busHwId, BusHardwareOptions const & busHwOpt)

ਪੈਰਾਮੀਟਰ busHwId busHwOpt
ResultVoid ਦਿੰਦਾ ਹੈ

ਖੋਲ੍ਹਣ ਲਈ ਫੀਲਡਬੱਸ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ। ਫੀਲਡਬੱਸ ਖੋਲ੍ਹਣ ਦੇ ਵਿਕਲਪਾਂ ਨੂੰ ਦਰਸਾਉਂਦਾ ਹੈ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

isBusHardwareOpen () ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਇਹ ਦੇਖਣ ਲਈ ਕਰੋ ਕਿ ਕੀ ਤੁਹਾਡਾ ਫੀਲਡਬੱਸ ਹਾਰਡਵੇਅਰ ਕਨੈਕਸ਼ਨ ਖੁੱਲ੍ਹਾ ਹੈ।
virtual ResultVoid nlc::NanoLibAccessor::openBusHardwareWithProtocol (const BusHardwareId & busHwId, const BusHardwareOptions & busHwOpt)

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ਪੈਰਾਮੀਟਰ BusHardwareId ਸਹੀ ਦਿੰਦਾ ਹੈ
ਝੂਠਾ

ਖੋਲ੍ਹਣ ਲਈ ਹਰੇਕ ਫੀਲਡਬੱਸ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ। ਹਾਰਡਵੇਅਰ ਖੁੱਲ੍ਹਾ ਹੈ। ਹਾਰਡਵੇਅਰ ਬੰਦ ਹੈ।

getProtocolSpecificAccessor () ਪ੍ਰੋਟੋਕੋਲ-ਵਿਸ਼ੇਸ਼ ਐਕਸੈਸਰ ਆਬਜੈਕਟ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultVoid nlc::NanoLibAccessor::getProtocolSpecificAccessor (BusHardwareId const & busHwId)

ਮਾਪਦੰਡ busHwId ਨਤੀਜਾVoid ਦਿੰਦਾ ਹੈ

ਐਕਸੈਸਰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਫੀਲਡਬੱਸ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

getProfinetDCP () Profinet DCP ਇੰਟਰਫੇਸ ਦਾ ਹਵਾਲਾ ਦੇਣ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਵਰਚੁਅਲ ProfinetDCP ਅਤੇ getProfinetDCP ()

ProfinetDCP ਵਾਪਸ ਕਰਦਾ ਹੈ

getSamplerInterface () s ਦਾ ਹਵਾਲਾ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋampler ਇੰਟਰਫੇਸ.
ਵਰਚੁਅਲ ਐੱਸamplerਇੰਟਰਫੇਸ ਅਤੇ getSamplerਇੰਟਰਫੇਸ ()

ਰਿਟਰਨ ਐੱਸamplerਇੰਟਰਫੇਸ

ਦਾ ਹਵਾਲਾ ਦਿੰਦੇ ਹੋਏ ਐੱਸampler ਇੰਟਰਫੇਸ ਕਲਾਸ.

setBusState () ਬੱਸ-ਪ੍ਰੋਟੋਕਾਲ-ਵਿਸ਼ੇਸ਼ ਸਥਿਤੀ ਨੂੰ ਸੈੱਟ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultVoid nlc::NanoLibAccessor::setBusState (const BusHardwareId & busHwId, const std::string & state)

ਪੈਰਾਮੀਟਰ busHwId ਸਥਿਤੀ
ResultVoid ਦਿੰਦਾ ਹੈ

ਖੋਲ੍ਹਣ ਲਈ ਫੀਲਡਬੱਸ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ। ਇੱਕ ਬੱਸ-ਵਿਸ਼ੇਸ਼ ਅਵਸਥਾ ਨੂੰ ਇੱਕ ਸਟ੍ਰਿੰਗ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

scanDevices () ਨੈੱਟਵਰਕ ਵਿੱਚ ਡਿਵਾਈਸਾਂ ਨੂੰ ਸਕੈਨ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultDeviceIds nlc::NanoLibAccessor::scanDevices (const BusHardwareId & busHwId, NlcScanBusCallback* ਕਾਲਬੈਕ)

ਪੈਰਾਮੀਟਰ busHwId ਕਾਲਬੈਕ
ResultDeviceIds IOError ਦਿੰਦਾ ਹੈ

ਸਕੈਨ ਕਰਨ ਲਈ ਫੀਲਡਬੱਸ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। NlcScanBusCallback ਤਰੱਕੀ ਟਰੇਸਰ। ਇੱਕ ਡਿਵਾਈਸ ID ਐਰੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਸੂਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕੋਈ ਯੰਤਰ ਨਹੀਂ ਮਿਲਿਆ ਹੈ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ਡਿਵਾਈਸ ਜੋੜੋ ()
NanoLib ਦੀ ਅੰਦਰੂਨੀ ਡਿਵਾਈਸ ਸੂਚੀ ਵਿੱਚ deviceId ਦੁਆਰਾ ਵਰਣਿਤ ਇੱਕ ਬੱਸ ਡਿਵਾਈਸ ਨੂੰ ਜੋੜਨ ਅਤੇ ਇਸਦੇ ਲਈ ਡਿਵਾਈਸ ਹੈਂਡਲ ਨੂੰ ਵਾਪਸ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultDeviceHandle nlc::NanoLibAccessor::addDevice (ਡਿਵਾਈਸ ਆਈਡੀ ਕੰਸਟ ਅਤੇ ਡਿਵਾਈਸ ਆਈਡੀ)

ਪੈਰਾਮੀਟਰ deviceId ਨਤੀਜਾ ਡਿਵਾਇਸ ਹੈਂਡਲ ਦਿੰਦਾ ਹੈ

ਸੂਚੀ ਵਿੱਚ ਸ਼ਾਮਲ ਕਰਨ ਲਈ ਡਿਵਾਈਸ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ। ਇੱਕ ਡਿਵਾਈਸ ਹੈਂਡਲ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

connectDevice () ਡਿਵਾਈਸ ਹੈਂਡਲ ਦੁਆਰਾ ਡਿਵਾਈਸ ਨੂੰ ਕਨੈਕਟ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultVoid nlc::NanoLibAccessor::connectDevice (ਡਿਵਾਈਸ ਹੈਂਡਲ ਕੰਸਟ ਡਿਵਾਈਸ ਹੈਂਡਲ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਰਿਟਰਨ ਨਤੀਜਾVoid
IOError

ਦੱਸਦਾ ਹੈ ਕਿ NanoLib ਕਿਸ ਬੱਸ ਡਿਵਾਈਸ ਨਾਲ ਜੁੜਦਾ ਹੈ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ। ਸੂਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕੋਈ ਯੰਤਰ ਨਹੀਂ ਮਿਲਿਆ ਹੈ।

getDeviceName () deviceHandle ਦੁਆਰਾ ਡਿਵਾਈਸ ਦਾ ਨਾਮ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਵਰਚੁਅਲ ਰਿਜ਼ਲਟਸਟ੍ਰਿੰਗ nlc::NanoLibAccessor::getDeviceName (ਡਿਵਾਈਸਹੈਂਡਲ ਕੰਸਟ ਡਿਵਾਈਸ ਹੈਂਡਲ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਰਿਟਰਨ ਸਟ੍ਰਿੰਗ

ਦੱਸਦਾ ਹੈ ਕਿ NanoLib ਕਿਸ ਬੱਸ ਯੰਤਰ ਲਈ ਨਾਮ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਡਿਵਾਈਸ ਦੇ ਨਾਮ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

getDeviceProductCode () deviceHandle ਦੁਆਰਾ ਡਿਵਾਈਸ ਦਾ ਉਤਪਾਦ ਕੋਡ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultInt nlc::NanoLibAccessor::getDeviceProductCode (ਡਿਵਾਈਸਹੈਂਡਲ ਕੰਸਟ ਡਿਵਾਈਸ ਹੈਂਡਲ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਰਿਟਰਨ ਨਤੀਜਾ

ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਸ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਲਈ ਉਤਪਾਦ ਕੋਡ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਉਤਪਾਦ ਕੋਡ ਨੂੰ ਪੂਰਨ ਅੰਕ ਵਜੋਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

getDeviceVendorId () deviceHandle ਦੁਆਰਾ ਡਿਵਾਈਸ ਵਿਕਰੇਤਾ ID ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultInt nlc::NanoLibAccessor::getDeviceVendorId (ਡਿਵਾਈਸਹੈਂਡਲ ਕੰਸਟ ਡਿਵਾਈਸ ਹੈਂਡਲ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਰਿਟਰਨ ਨਤੀਜਾ
ਸਰੋਤ ਅਣਉਪਲਬਧ

ਇਹ ਦੱਸਦਾ ਹੈ ਕਿ NanoLib ਕਿਸ ਬੱਸ ਡਿਵਾਈਸ ਲਈ ਵਿਕਰੇਤਾ ID ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਵਿਕਰੇਤਾ ID ਨੂੰ ਪੂਰਨ ਅੰਕ ਵਜੋਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਸੂਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕੋਈ ਡਾਟਾ ਨਹੀਂ ਮਿਲਿਆ ਹੈ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

getDeviceId () NanoLib ਅੰਦਰੂਨੀ ਸੂਚੀ ਤੋਂ ਕਿਸੇ ਖਾਸ ਡਿਵਾਈਸ ਦੀ ID ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultDeviceId nlc::NanoLibAccessor::getDeviceId (ਡਿਵਾਈਸਹੈਂਡਲ ਕੰਸਟ ਡਿਵਾਈਸ ਹੈਂਡਲ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਰਿਟਰਨ ਰਿਟਰਨ ਡਿਵਾਇਸ ਆਈ.ਡੀ

ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਸ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਲਈ ਡਿਵਾਈਸ ID ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ। ਇੱਕ ਡਿਵਾਈਸ ID ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

getDeviceIds () NanoLib ਅੰਦਰੂਨੀ ਸੂਚੀ ਤੋਂ ਸਾਰੀਆਂ ਡਿਵਾਈਸਾਂ ਦੀ ID ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultDeviceIds nlc::NanoLibAccessor::getDeviceIds ()

ResultDeviceIds ਵਾਪਸ ਕਰਦਾ ਹੈ

ਇੱਕ ਡਿਵਾਈਸ ID ਸੂਚੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

getDeviceUid () ਡਿਵਾਈਸ ਹੈਂਡਲ ਦੁਆਰਾ ਡਿਵਾਈਸ ਦੀ ਵਿਲੱਖਣ ID (96 ਬਿੱਟ / 12 ਬਾਈਟ) ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultArrayByte nlc::NanoLibAccessor::getDeviceUid (ਡਿਵਾਈਸਹੈਂਡਲ ਕੰਸਟ ਡਿਵਾਈਸ ਹੈਂਡਲ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਨਤੀਜਾ ਐਰੇਬਾਈਟ ਵਾਪਸ ਕਰਦਾ ਹੈ
ਸਰੋਤ ਅਣਉਪਲਬਧ

ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਸ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਨੂੰ ਵਿਲੱਖਣ ID ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ। ਇੱਕ ਬਾਈਟ ਐਰੇ ਵਜੋਂ ਵਿਲੱਖਣ ID ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਸੂਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕੋਈ ਡਾਟਾ ਨਹੀਂ ਮਿਲਿਆ ਹੈ।

getDeviceSerialNumber () deviceHandle ਦੁਆਰਾ ਡਿਵਾਈਸ ਦਾ ਸੀਰੀਅਲ ਨੰਬਰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultString NanolibAccessor::getDeviceSerialNumber (DeviceHandle const deviceHandle)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਰਿਟਰਨ ਸਟ੍ਰਿੰਗ
ਸਰੋਤ ਅਣਉਪਲਬਧ

ਇਹ ਦੱਸਦਾ ਹੈ ਕਿ NanoLib ਕਿਸ ਬੱਸ ਡਿਵਾਈਸ ਲਈ ਸੀਰੀਅਲ ਨੰਬਰ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਸੀਰੀਅਲ ਨੰਬਰ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਸੂਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕੋਈ ਡਾਟਾ ਨਹੀਂ ਮਿਲਿਆ ਹੈ।

getDeviceHardwareGroup () ਡਿਵਾਈਸ ਹੈਂਡਲ ਦੁਆਰਾ ਬੱਸ ਡਿਵਾਈਸ ਦੇ ਹਾਰਡਵੇਅਰ ਗਰੁੱਪ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultDeviceId nlc::NanoLibAccessor::getDeviceHardwareGroup (DeviceHandle const deviceHandle)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਰਿਟਰਨ ਨਤੀਜਾ

ਨਿਰਧਾਰਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਸ ਬੱਸ ਜੰਤਰ NanoLib ਲਈ ਹਾਰਡਵੇਅਰ ਗਰੁੱਪ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ।
ਹਾਰਡਵੇਅਰ ਸਮੂਹਾਂ ਨੂੰ ਪੂਰਨ ਅੰਕ ਵਜੋਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

getDeviceHardwareVersion () ਡਿਵਾਈਸ ਹੈਂਡਲ ਦੁਆਰਾ ਬੱਸ ਡਿਵਾਈਸ ਦਾ ਹਾਰਡਵੇਅਰ ਸੰਸਕਰਣ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultDeviceId nlc::NanoLibAccessor::getDeviceHardwareVersion (DeviceHandle const deviceHandle)

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ

ਵਾਪਸੀ

ResultString ਸਰੋਤ ਅਣਉਪਲਬਧ

ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਕਿਸ ਲਈ ਹਾਰਡਵੇਅਰ ਸੰਸਕਰਣ ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ। ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਡਿਵਾਈਸ ਦੇ ਨਾਮ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਸੂਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕੋਈ ਡਾਟਾ ਨਹੀਂ ਮਿਲਿਆ ਹੈ।

getDeviceFirmwareBuildId () ਡਿਵਾਈਸ ਹੈਂਡਲ ਦੁਆਰਾ ਬੱਸ ਡਿਵਾਈਸ ਦੀ ਫਰਮਵੇਅਰ ਬਿਲਡ ਆਈਡੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultDeviceId nlc::NanoLibAccessor::getDeviceFirmwareBuildId (DeviceHandle const deviceHandle)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਰਿਟਰਨ ਸਟ੍ਰਿੰਗ

ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਕਿਸ ਲਈ ਫਰਮਵੇਅਰ ਬਿਲਡ ID ਪ੍ਰਾਪਤ ਕਰਦੀ ਹੈ।
ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਡਿਵਾਈਸ ਦੇ ਨਾਮ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

getDeviceBootloaderVersion () ਡਿਵਾਈਸ ਹੈਂਡਲ ਦੁਆਰਾ ਬੱਸ ਡਿਵਾਈਸ ਦਾ ਬੂਟਲੋਡਰ ਸੰਸਕਰਣ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultInt nlc::NanoLibAccessor::getDeviceBootloaderVersion (ਡਿਵਾਈਸਹੈਂਡਲ ਕੰਸਟ ਡਿਵਾਈਸ ਹੈਂਡਲ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ

ਵਾਪਸੀ

ResultInt ਸਰੋਤ ਅਣਉਪਲਬਧ

ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਸ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਨੂੰ ਬੂਟਲੋਡਰ ਸੰਸਕਰਣ ਮਿਲਦਾ ਹੈ। ਬੂਟਲੋਡਰ ਸੰਸਕਰਣਾਂ ਨੂੰ ਪੂਰਨ ਅੰਕ ਵਜੋਂ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ। ਸੂਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕੋਈ ਡਾਟਾ ਨਹੀਂ ਮਿਲਿਆ ਹੈ।

getDeviceBootloaderBuildId () ਡਿਵਾਈਸ ਹੈਂਡਲ ਦੁਆਰਾ ਬੱਸ ਡਿਵਾਈਸ ਦੀ ਬੂਟਲੋਡਰ ਬਿਲਡ ਆਈਡੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultDeviceId nlc::NanoLibAccessor:: (DeviceHandle const deviceHandle)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਰਿਟਰਨ ਸਟ੍ਰਿੰਗ

ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਸ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਨੂੰ ਬੂਟਲੋਡਰ ਬਿਲਡ ID ਪ੍ਰਾਪਤ ਹੁੰਦੀ ਹੈ।
ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਡਿਵਾਈਸ ਦੇ ਨਾਮ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

rebootDevice () deviceHandle ਦੁਆਰਾ ਡਿਵਾਈਸ ਨੂੰ ਰੀਬੂਟ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultVoid nlc::NanoLibAccessor::rebootDevice (const DeviceHandle deviceHandle)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਰਿਟਰਨ ਨਤੀਜਾVoid

ਰੀਬੂਟ ਕਰਨ ਲਈ ਫੀਲਡਬੱਸ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

getDeviceState () ਡਿਵਾਈਸ-ਪ੍ਰੋਟੋਕੋਲ-ਵਿਸ਼ੇਸ਼ ਸਥਿਤੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਵਰਚੁਅਲ ਰਿਜ਼ਲਟਸਟ੍ਰਿੰਗ nlc::NanoLibAccessor::getDeviceState (ਡਿਵਾਈਸਹੈਂਡਲ ਕੰਸਟ ਡਿਵਾਈਸ ਹੈਂਡਲ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ

ਦੱਸਦਾ ਹੈ ਕਿ NanoLib ਕਿਸ ਬੱਸ ਡਿਵਾਈਸ ਲਈ ਸਟੇਟ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ResultString ਵਾਪਸ ਕਰਦਾ ਹੈ

ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਡਿਵਾਈਸ ਦੇ ਨਾਮ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

setDeviceState () ਡਿਵਾਈਸ-ਪ੍ਰੋਟੋਕੋਲ-ਵਿਸ਼ੇਸ਼ ਸਥਿਤੀ ਨੂੰ ਸੈੱਟ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultVoid nlc::NanoLibAccessor::setDeviceState (const DeviceHandle deviceHandle, const std::string & state)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਸਥਿਤੀ
ResultVoid ਦਿੰਦਾ ਹੈ

ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਸ ਬੱਸ ਯੰਤਰ NanoLib ਸਟੇਟ ਲਈ ਸੈੱਟ ਕਰਦਾ ਹੈ। ਇੱਕ ਬੱਸ-ਵਿਸ਼ੇਸ਼ ਅਵਸਥਾ ਨੂੰ ਇੱਕ ਸਟ੍ਰਿੰਗ ਮੁੱਲ ਦੇ ਰੂਪ ਵਿੱਚ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

getConnectionState ()
ਡਿਵਾਈਸ ਹੈਂਡਲ (= ਡਿਸਕਨੈਕਟਡ, ਕਨੈਕਟਡ, ਕਨੈਕਟਡਬੂਟਲੋਡਰ) ਦੁਆਰਾ ਕਿਸੇ ਖਾਸ ਡਿਵਾਈਸ ਦੀ ਆਖਰੀ ਜਾਣੀ ਜਾਂਦੀ ਕਨੈਕਸ਼ਨ ਸਥਿਤੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultConnectionState nlc::NanoLibAccessor::getConnectionState (ਡਿਵਾਈਸਹੈਂਡਲ ਕੰਸਟ ਡਿਵਾਈਸ ਹੈਂਡਲ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਰਿਟਰਨ ਨਤੀਜਾ ਕਨੈਕਸ਼ਨ ਸਟੇਟ

ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਸ ਬੱਸ ਯੰਤਰ NanoLib ਨੂੰ ਕਨੈਕਸ਼ਨ ਸਥਿਤੀ ਮਿਲਦੀ ਹੈ।
ਇੱਕ ਕਨੈਕਸ਼ਨ ਸਥਿਤੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ (= ਡਿਸਕਨੈਕਟ, ਕਨੈਕਟ ਕੀਤਾ, ਕਨੈਕਟ ਕੀਤਾ ਬੂਟਲੋਡਰ)।

ਕਨੈਕਸ਼ਨ ਸਟੇਟ () ਦੀ ਜਾਂਚ ਕਰੋ
ਕੇਵਲ ਤਾਂ ਹੀ ਜੇਕਰ ਆਖਰੀ ਜਾਣੀ-ਪਛਾਣੀ ਸਥਿਤੀ ਡਿਸਕਨੈਕਟ ਨਹੀਂ ਕੀਤੀ ਗਈ ਸੀ: ਡਿਵਾਈਸ ਹੈਂਡਲ ਦੁਆਰਾ ਅਤੇ ਕਈ ਮੋਡ-ਵਿਸ਼ੇਸ਼ ਓਪਰੇਸ਼ਨਾਂ ਦੀ ਜਾਂਚ ਕਰਕੇ ਇੱਕ ਖਾਸ ਡਿਵਾਈਸ ਦੀ ਕਨੈਕਸ਼ਨ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਅਤੇ ਸੰਭਾਵਤ ਤੌਰ 'ਤੇ ਅਪਡੇਟ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultConnectionState nlc::NanoLibAccessor::checkConnectionState (ਡਿਵਾਈਸਹੈਂਡਲ ਕੰਸਟ ਡਿਵਾਈਸ ਹੈਂਡਲ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਰਿਟਰਨ ਨਤੀਜਾ ਕਨੈਕਸ਼ਨ ਸਟੇਟ

ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਸ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਕੁਨੈਕਸ਼ਨ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕਰਦੀ ਹੈ।
ਇੱਕ ਕਨੈਕਸ਼ਨ ਸਥਿਤੀ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ (= ਡਿਸਕਨੈਕਟ ਨਹੀਂ ਕੀਤਾ ਗਿਆ)

assignObjectDictionary () ਇਸ ਮੈਨੂਅਲ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਆਪਣੇ ਆਪ ਡਿਵਾਈਸ ਹੈਂਡਲ ਨੂੰ ਇੱਕ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ (OD) ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਕਰੋ।
virtual ResultObjectDictionary nlc::NanoLibAccessor::assignObjectDictionary (DeviceHandle const deviceHandle, ObjectDictionary const & objectDictionary)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ
ResultObjectDictionary ਦਿੰਦਾ ਹੈ

ਦੱਸਦਾ ਹੈ ਕਿ NanoLib ਕਿਸ ਬੱਸ ਡਿਵਾਈਸ ਨੂੰ OD ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। ਕਿਸੇ ਵਸਤੂ ਸ਼ਬਦਕੋਸ਼ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਿਖਾਉਂਦਾ ਹੈ।

autoAssignObjectDictionary ()
NanoLib ਨੂੰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਨੂੰ ਇੱਕ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ (OD) ਦੇਣ ਲਈ ਇਸ ਆਟੋਮੈਟਿਜ਼ਮ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਇੱਕ ਉਚਿਤ OD ਲੱਭਣ ਅਤੇ ਲੋਡ ਕਰਨ 'ਤੇ, NanoLib ਆਪਣੇ ਆਪ ਇਸਨੂੰ ਡਿਵਾਈਸ ਨੂੰ ਸੌਂਪ ਦਿੰਦਾ ਹੈ। ਨੋਟ: ਜੇਕਰ ਇੱਕ ਅਨੁਕੂਲ OD ਪਹਿਲਾਂ ਹੀ ਆਬਜੈਕਟ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ ਲੋਡ ਕੀਤਾ ਗਿਆ ਹੈ, ਤਾਂ NanoLib ਸਪੁਰਦ ਕੀਤੀ ਡਾਇਰੈਕਟਰੀ ਨੂੰ ਸਕੈਨ ਕੀਤੇ ਬਿਨਾਂ ਇਸਦੀ ਵਰਤੋਂ ਆਪਣੇ ਆਪ ਕਰੇਗਾ।
virtual ResultObjectDictionary nlc::NanoLibAccessor::autoAssignObjectDictionary (DeviceHandle const deviceHandle, const std::string & dictionaryLocationPath)

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ

ਵਾਪਸੀ

ਡਿਕਸ਼ਨਰੀ LocationPath ResultObjectDictionary

ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਸ ਬੱਸ ਯੰਤਰ ਲਈ NanoLib ਢੁਕਵੇਂ OD ਲਈ ਸਵੈਚਲਿਤ ਤੌਰ 'ਤੇ ਸਕੈਨ ਕਰੇਗਾ। OD ਡਾਇਰੈਕਟਰੀ ਦਾ ਮਾਰਗ ਦਰਸਾਉਂਦਾ ਹੈ। ਕਿਸੇ ਵਸਤੂ ਸ਼ਬਦਕੋਸ਼ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਿਖਾਉਂਦਾ ਹੈ।

getAssignedObjectDictionary ()
ਡਿਵਾਇਸ ਹੈਂਡਲ ਦੁਆਰਾ ਇੱਕ ਡਿਵਾਈਸ ਨੂੰ ਅਸਾਈਨ ਕੀਤੇ ਗਏ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultObjectDictionary nlc::NanoLibAccessor::getAssignedObjectDictionary (ਡਿਵਾਈਸਹੈਂਡਲ ਕੰਸਟ ਡਿਵਾਈਸ
ਹੈਂਡਲ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਨਤੀਜਾ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਦਿੰਦਾ ਹੈ

ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਸ ਬੱਸ ਯੰਤਰ NanoLib ਲਈ ਨਿਰਧਾਰਤ OD ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ। ਕਿਸੇ ਵਸਤੂ ਸ਼ਬਦਕੋਸ਼ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦਿਖਾਉਂਦਾ ਹੈ।

getObjectDictionaryLibrary () ਇਹ ਫੰਕਸ਼ਨ ਇੱਕ OdLibrary ਹਵਾਲਾ ਦਿੰਦਾ ਹੈ।
ਵਰਚੁਅਲ ਓਡ ਲਾਇਬ੍ਰੇਰੀ& nlc::NanoLibAccessor::getObjectDictionaryLibrary ()

OdLibrary ਵਾਪਸ ਕਰਦਾ ਹੈ&

ਪੂਰੀ OD ਲਾਇਬ੍ਰੇਰੀ ਅਤੇ ਇਸਦੇ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀਆਂ ਨੂੰ ਖੋਲ੍ਹਦਾ ਹੈ।

setLoggingLevel () ਲੋੜੀਂਦੇ ਲੌਗ ਵੇਰਵੇ (ਅਤੇ ਲੌਗ) ਨੂੰ ਸੈੱਟ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ file ਆਕਾਰ). ਪੂਰਵ-ਨਿਰਧਾਰਤ ਪੱਧਰ ਜਾਣਕਾਰੀ ਹੈ।
ਵਰਚੁਅਲ ਵਾਇਡ nlc::NanoLibAccessor::setLoggingLevel (ਲੌਗਲੈਵਲ ਪੱਧਰ)

ਪੈਰਾਮੀਟਰ ਪੱਧਰ

ਹੇਠਾਂ ਦਿੱਤੇ ਲੌਗ ਵੇਰਵੇ ਸੰਭਵ ਹਨ:

0 = ਟਰੇਸ 1 = ਡੀਬੱਗ 2 = ਜਾਣਕਾਰੀ 3 = ਚੇਤਾਵਨੀ 4 = ਗਲਤੀ 5 = ਗੰਭੀਰ 6 = ਬੰਦ

ਸਭ ਤੋਂ ਨੀਵਾਂ ਪੱਧਰ (ਸਭ ਤੋਂ ਵੱਡਾ ਲੌਗ file); ਕਿਸੇ ਵੀ ਵਿਹਾਰਕ ਵੇਰਵੇ ਨੂੰ ਲੌਗ ਕਰਦਾ ਹੈ, ਨਾਲ ਹੀ ਸਾਫਟਵੇਅਰ ਸਟਾਰਟ/ਸਟਾਪ। ਲਾਗ ਡੀਬੱਗ ਜਾਣਕਾਰੀ (= ਅੰਤਰਿਮ ਨਤੀਜੇ, ਸਮੱਗਰੀ ਭੇਜੀ ਜਾਂ ਪ੍ਰਾਪਤ ਕੀਤੀ, ਆਦਿ) ਡਿਫੌਲਟ ਪੱਧਰ; ਜਾਣਕਾਰੀ ਵਾਲੇ ਸੁਨੇਹਿਆਂ ਨੂੰ ਲਾਗ ਕਰਦਾ ਹੈ। ਲੌਗ ਸਮੱਸਿਆਵਾਂ ਜੋ ਆਈਆਂ ਪਰ ਮੌਜੂਦਾ ਐਲਗੋਰਿਦਮ ਨੂੰ ਨਹੀਂ ਰੋਕਦੀਆਂ। ਲਾਗ ਸਿਰਫ਼ ਗੰਭੀਰ ਸਮੱਸਿਆ ਹੈ, ਜੋ ਕਿ ਐਲਗੋਰਿਦਮ ਨੂੰ ਰੋਕ ਦਿੱਤਾ ਹੈ. ਸਭ ਤੋਂ ਉੱਚਾ ਪੱਧਰ (ਸਭ ਤੋਂ ਛੋਟਾ ਲਾਗ file); ਲੌਗਿੰਗ ਬੰਦ ਕਰਦਾ ਹੈ; ਕੋਈ ਹੋਰ ਲੌਗ ਬਿਲਕੁਲ ਨਹੀਂ। ਕੋਈ ਲੌਗਿੰਗ ਨਹੀਂ।

ਸੈੱਟਲੌਗਿੰਗ ਕਾਲਬੈਕ ()
ਉਸ ਕਾਲਬੈਕ ਲਈ ਲੌਗਿੰਗ ਕਾਲਬੈਕ ਪੁਆਇੰਟਰ ਅਤੇ ਲੌਗ ਮੋਡੀਊਲ (= ਲਾਇਬ੍ਰੇਰੀ) ਸੈੱਟ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ (ਲਾਗਰ ਲਈ ਨਹੀਂ)।
virtual void nlc::NanoLibAccessor::setLoggingCallback (NlcLoggingCallback* ਕਾਲਬੈਕ, const nlc::LogModule & logModule)

ਪੈਰਾਮੀਟਰ *ਕਾਲਬੈਕ ਲੌਗਮੌਡਿਊਲ

ਇੱਕ ਕਾਲਬੈਕ ਪੁਆਇੰਟਰ ਸੈੱਟ ਕਰਦਾ ਹੈ। ਕਾਲਬੈਕ ਨੂੰ ਟਿਊਨ ਕਰੋ (ਲਾਗਰ ਨਹੀਂ!) ਤੁਹਾਡੀ ਲਾਇਬ੍ਰੇਰੀ ਵਿੱਚ।

0 = NanolibCore 1 = NanolibCANopen 2 = NanolibModbus 3 = NanolibEtherCAT

ਸਿਰਫ਼ NanoLib ਦੇ ਕੋਰ ਲਈ ਇੱਕ ਕਾਲਬੈਕ ਨੂੰ ਸਰਗਰਮ ਕਰਦਾ ਹੈ। ਇੱਕ CANਓਨਲੀ ਕਾਲਬੈਕ ਨੂੰ ਸਰਗਰਮ ਕਰਦਾ ਹੈ। ਇੱਕ Modbus-ਸਿਰਫ ਕਾਲਬੈਕ ਨੂੰ ਸਰਗਰਮ ਕਰਦਾ ਹੈ। ਇੱਕ EtherCAT-ਸਿਰਫ਼ ਕਾਲਬੈਕ ਨੂੰ ਸਰਗਰਮ ਕਰਦਾ ਹੈ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

4 = NanolibRest 5 = NanolibUSB

ਇੱਕ REST-ਸਿਰਫ ਕਾਲਬੈਕ ਨੂੰ ਸਰਗਰਮ ਕਰਦਾ ਹੈ। ਇੱਕ USB-ਸਿਰਫ਼ ਕਾਲਬੈਕ ਨੂੰ ਸਰਗਰਮ ਕਰਦਾ ਹੈ।

unsetLoggingCallback () ਲੌਗਿੰਗ ਕਾਲਬੈਕ ਪੁਆਇੰਟਰ ਨੂੰ ਰੱਦ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਵਰਚੁਅਲ ਵਾਇਡ nlc::NanoLibAccessor::unsetLoggingCallback ()

readNumber () ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਤੋਂ ਇੱਕ ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਨੂੰ ਪੜ੍ਹਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultInt nlc::NanoLibAccessor::readNumber (const DeviceHandle deviceHandle, const OdIndex odIndex)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ odIndex
ਨਤੀਜਾ ਵਾਪਸ ਕਰਦਾ ਹੈ

ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਕਿਸ ਤੋਂ ਪੜ੍ਹਦੀ ਹੈ। ਪੜ੍ਹਨ ਲਈ (ਉਪ-) ਸੂਚਕਾਂਕ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ। ਇੱਕ ਗੈਰ-ਅਨੁਭਾਸ਼ਿਤ ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ (ਦਸਤਖਤ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਹਸਤਾਖਰਿਤ ਨਹੀਂ, ਫਿਕਸ16.16 ਬਿੱਟ ਮੁੱਲ)।

readNumberArray () ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਤੋਂ ਸੰਖਿਆਤਮਕ ਐਰੇ ਪੜ੍ਹਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultArrayInt nlc::NanoLibAccessor::readNumberArray (const DeviceHandle deviceHandle, const uint16_t ਇੰਡੈਕਸ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਇੰਡੈਕਸ
ResultArrayInt ਦਿੰਦਾ ਹੈ

ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਕਿਸ ਤੋਂ ਪੜ੍ਹਦੀ ਹੈ। ਐਰੇ ਆਬਜੈਕਟ ਸੂਚਕਾਂਕ। ਇੱਕ ਪੂਰਨ ਅੰਕ ਐਰੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

readBytes () ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਤੋਂ ਆਰਬਿਟਰੇਰੀ ਬਾਈਟਸ (ਡੋਮੇਨ ਆਬਜੈਕਟ ਡੇਟਾ) ਨੂੰ ਪੜ੍ਹਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultArrayByte nlc::NanoLibAccessor::readBytes (const DeviceHandle deviceHandle, const OdIndex odIndex)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ odIndex
ResultArrayByte ਦਿੰਦਾ ਹੈ

ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਕਿਸ ਤੋਂ ਪੜ੍ਹਦੀ ਹੈ। ਪੜ੍ਹਨ ਲਈ (ਉਪ-) ਸੂਚਕਾਂਕ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ। ਇੱਕ ਬਾਈਟ ਐਰੇ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

readString () ਆਬਜੈਕਟ ਡਾਇਰੈਕਟਰੀ ਤੋਂ ਸਤਰ ਪੜ੍ਹਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultString nlc::NanoLibAccessor::readString (const DeviceHandle deviceHandle, const OdIndex odIndex)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ odIndex
ResultString ਵਾਪਸ ਕਰਦਾ ਹੈ

ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਕਿਸ ਤੋਂ ਪੜ੍ਹਦੀ ਹੈ। ਪੜ੍ਹਨ ਲਈ (ਉਪ-) ਸੂਚਕਾਂਕ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ। ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਡਿਵਾਈਸ ਦੇ ਨਾਮ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

writeNumber () ਆਬਜੈਕਟ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਲਿਖਣ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultVoid nlc::NanoLibAccessor::writeNumber (const DeviceHandle deviceHandle, int64_t ਮੁੱਲ, const OdIndex odIndex, ਅਣ-ਹਸਤਾਖਰਿਤ int bitLength)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਮੁੱਲ odIndex bitLength
ResultVoid ਦਿੰਦਾ ਹੈ

ਦੱਸਦਾ ਹੈ ਕਿ NanoLib ਕਿਸ ਬੱਸ ਯੰਤਰ ਨੂੰ ਲਿਖਦਾ ਹੈ। ਅਣਵਿਆਖਿਆ ਮੁੱਲ (ਦਸਤਖਤ ਕੀਤੇ ਜਾ ਸਕਦੇ ਹਨ, ਹਸਤਾਖਰਿਤ ਨਹੀਂ, ਫਿਕਸ 16.16)। ਪੜ੍ਹਨ ਲਈ (ਉਪ-) ਸੂਚਕਾਂਕ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ। ਬਿੱਟ ਵਿੱਚ ਲੰਬਾਈ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

writeBytes () ਆਬਜੈਕਟ ਡਾਇਰੈਕਟਰੀ ਵਿੱਚ ਆਰਬਿਟਰੇਰੀ ਬਾਈਟਸ (ਡੋਮੇਨ ਆਬਜੈਕਟ ਡੇਟਾ) ਲਿਖਣ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultVoid nlc::NanoLibAccessor::writeBytes (const DeviceHandle deviceHandle, const std::vector & ਡਾਟਾ, const OdIndex odIndex)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਡਾਟਾ odIndex
ResultVoid ਦਿੰਦਾ ਹੈ

ਦੱਸਦਾ ਹੈ ਕਿ NanoLib ਕਿਸ ਬੱਸ ਯੰਤਰ ਨੂੰ ਲਿਖਦਾ ਹੈ। ਬਾਈਟ ਵੈਕਟਰ/ਐਰੇ। ਪੜ੍ਹਨ ਲਈ (ਉਪ-) ਸੂਚਕਾਂਕ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

ਅੱਪਲੋਡ ਫਰਮਵੇਅਰ ()
ਆਪਣੇ ਕੰਟਰੋਲਰ ਫਰਮਵੇਅਰ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultVoid nlc::NanoLibAccessor::uploadFirmware (const DeviceHandle deviceHandle, const std::vector & fwData, NlcDataTransferCallback* ਕਾਲਬੈਕ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ fwData NlcDataTransferCallback
ResultVoid ਦਿੰਦਾ ਹੈ

ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਹੜੀ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਅੱਪਡੇਟ ਕਰਦੀ ਹੈ। ਫਰਮਵੇਅਰ ਡਾਟਾ ਰੱਖਣ ਵਾਲੀ ਐਰੇ। ਇੱਕ ਡੇਟਾ ਪ੍ਰਗਤੀ ਟਰੇਸਰ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

ਫਰਮਵੇਅਰ ਤੋਂ ਅੱਪਲੋਡ ਕਰੋFile ()
ਇਸ ਨੂੰ ਅੱਪਲੋਡ ਕਰਕੇ ਆਪਣੇ ਕੰਟਰੋਲਰ ਫਰਮਵੇਅਰ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ file.
virtual ResultVoid nlc::NanoLibAccessor::uploadFirmwareFromFile (const DeviceHandle deviceHandle, const std::string & absoluteFileਮਾਰਗ, NlcDataTransferCallback* ਕਾਲਬੈਕ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਪੂਰਨFileਪਾਥ NlcDataTransferCallback
ResultVoid ਦਿੰਦਾ ਹੈ

ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਹੜੀ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਅੱਪਡੇਟ ਕਰਦੀ ਹੈ। ਦਾ ਮਾਰਗ file ਫਰਮਵੇਅਰ ਡੇਟਾ (std::string) ਰੱਖਦਾ ਹੈ। ਇੱਕ ਡੇਟਾ ਪ੍ਰਗਤੀ ਟਰੇਸਰ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ਅੱਪਲੋਡਬੂਟਲੋਡਰ ()
ਆਪਣੇ ਕੰਟਰੋਲਰ ਬੂਟਲੋਡਰ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultVoid nlc::NanoLibAccessor::uploadBootloader (const DeviceHandle deviceHandle, const std::vector & btData, NlcDataTransferCallback* ਕਾਲਬੈਕ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ btData NlcDataTransferCallback
ResultVoid ਦਿੰਦਾ ਹੈ

ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਹੜੀ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਅੱਪਡੇਟ ਕਰਦੀ ਹੈ। ਬੂਟਲੋਡਰ ਡੇਟਾ ਵਾਲਾ ਐਰੇ। ਇੱਕ ਡਾਟਾ ਪ੍ਰਗਤੀ ਟਰੇਸਰ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

ਤੋਂ ਬੂਟਲੋਡਰ ਅੱਪਲੋਡ ਕਰੋFile ()
ਆਪਣੇ ਕੰਟਰੋਲਰ ਬੂਟਲੋਡਰ ਨੂੰ ਅੱਪਲੋਡ ਕਰਕੇ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ file.
virtual ResultVoid nlc::NanoLibAccessor::uploadBootloaderFromFile (const DeviceHandle deviceHandle, const std::string & bootloaderAbsoluteFileਮਾਰਗ, NlcDataTransferCallback* ਕਾਲਬੈਕ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਬੂਟਲੋਡਰ ਐਬਸੋਲੇਟFileਪਾਥ NlcDataTransferCallback
ResultVoid ਦਿੰਦਾ ਹੈ

ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਹੜੀ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਅੱਪਡੇਟ ਕਰਦੀ ਹੈ। ਦਾ ਮਾਰਗ file ਬੂਟਲੋਡਰ ਡੇਟਾ (std::string) ਰੱਖਦਾ ਹੈ। ਇੱਕ ਡੇਟਾ ਪ੍ਰਗਤੀ ਟਰੇਸਰ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

ਅੱਪਲੋਡਬੂਟਲੋਡਰਫਰਮਵੇਅਰ ()
ਆਪਣੇ ਕੰਟਰੋਲਰ ਬੂਟਲੋਡਰ ਅਤੇ ਫਰਮਵੇਅਰ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultVoid nlc::NanoLibAccessor::uploadBootloaderFirmware (const DeviceHandle deviceHandle, const std::vector & btData, const std::vector & fwData, NlcDataTransferCallback* ਕਾਲਬੈਕ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ btData fwData NlcDataTransferCallback
ResultVoid ਦਿੰਦਾ ਹੈ

ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਹੜੀ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਅੱਪਡੇਟ ਕਰਦੀ ਹੈ। ਬੂਟਲੋਡਰ ਡੇਟਾ ਵਾਲਾ ਐਰੇ। ਫਰਮਵੇਅਰ ਡਾਟਾ ਰੱਖਣ ਵਾਲੀ ਐਰੇ। ਇੱਕ ਡਾਟਾ ਪ੍ਰਗਤੀ ਟਰੇਸਰ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

ਬੂਟਲੋਡਰ ਫਰਮਵੇਅਰ ਤੋਂ ਅੱਪਲੋਡ ਕਰੋFile ()
ਨੂੰ ਅੱਪਲੋਡ ਕਰਕੇ ਆਪਣੇ ਕੰਟਰੋਲਰ ਬੂਟਲੋਡਰ ਅਤੇ ਫਰਮਵੇਅਰ ਨੂੰ ਅੱਪਡੇਟ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ files.
virtual ResultVoid nlc::NanoLibAccessor::uploadBootloaderFirmwareFromFile (const DeviceHandle deviceHandle, const std::string & bootloaderAbsoluteFileਪਾਥ, const std::string & absoluteFileਮਾਰਗ, NlcDataTransferCallback* ਕਾਲਬੈਕ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਬੂਟਲੋਡਰ ਐਬਸੋਲੇਟFileਮਾਰਗ ਨਿਰੋਲFileਪਾਥ NlcDataTransferCallback
ResultVoid ਦਿੰਦਾ ਹੈ

ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਹੜੀ ਬੱਸ ਡਿਵਾਈਸ NanoLib ਅੱਪਡੇਟ ਕਰਦੀ ਹੈ। ਦਾ ਮਾਰਗ file ਬੂਟਲੋਡਰ ਡੇਟਾ (std::string) ਰੱਖਦਾ ਹੈ। ਦਾ ਮਾਰਗ file ਫਰਮਵੇਅਰ ਡਾਟਾ ਰੱਖਦਾ ਹੈ (uint8_t)। ਇੱਕ ਡੇਟਾ ਪ੍ਰਗਤੀ ਟਰੇਸਰ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ਅਪਲੋਡ ਨੈਨੋਜੇ ()
NanoJ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਆਪਣੇ ਕੰਟਰੋਲਰ 'ਤੇ ਅੱਪਲੋਡ ਕਰਨ ਲਈ ਇਸ ਜਨਤਕ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਵਰਚੁਅਲ ਰਿਜ਼ਲਟਵੋਇਡ nlc::NanoLibAccessor::uploadNanoJ (ਡਿਵਾਈਸ ਹੈਂਡਲ const deviceHandle, std::vector const & vmmData, NlcDataTransferCallback* ਕਾਲਬੈਕ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ vmmData NlcDataTransferCallback
ResultVoid ਦਿੰਦਾ ਹੈ

ਦੱਸਦਾ ਹੈ ਕਿ NanoLib ਕਿਸ ਬੱਸ ਡਿਵਾਈਸ 'ਤੇ ਅੱਪਲੋਡ ਕਰਦਾ ਹੈ। NanoJ ਡੇਟਾ ਵਾਲਾ ਐਰੇ। ਇੱਕ ਡਾਟਾ ਪ੍ਰਗਤੀ ਟਰੇਸਰ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

NanoJFrom ਅੱਪਲੋਡ ਕਰੋFile ()
ਨੂੰ ਅੱਪਲੋਡ ਕਰਕੇ ਆਪਣੇ ਕੰਟਰੋਲਰ ਨੂੰ NanoJ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਅੱਪਲੋਡ ਕਰਨ ਲਈ ਇਸ ਜਨਤਕ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ file.
virtual ResultVoid nlc::NanoLibAccessor::uploadNanoJFromFile (const DeviceHandle deviceHandle, const std::string & absoluteFileਮਾਰਗ, NlcDataTransferCallback* ਕਾਲਬੈਕ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਪੂਰਨFileਪਾਥ NlcDataTransferCallback
ResultVoid ਦਿੰਦਾ ਹੈ

ਦੱਸਦਾ ਹੈ ਕਿ NanoLib ਕਿਸ ਬੱਸ ਡਿਵਾਈਸ 'ਤੇ ਅੱਪਲੋਡ ਕਰਦਾ ਹੈ। ਦਾ ਮਾਰਗ file NanoJ ਡੇਟਾ (std::string) ਰੱਖਦਾ ਹੈ। ਇੱਕ ਡੇਟਾ ਪ੍ਰਗਤੀ ਟਰੇਸਰ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

ਡਿਸਕਨੈਕਟਡਿਵਾਈਸ () ਡਿਵਾਈਸ ਹੈਂਡਲ ਦੁਆਰਾ ਆਪਣੀ ਡਿਵਾਈਸ ਨੂੰ ਡਿਸਕਨੈਕਟ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultVoid nlc::NanoLibAccessor::disconnectDevice (ਡਿਵਾਈਸਹੈਂਡਲ ਕੰਸਟ ਡਿਵਾਈਸ ਹੈਂਡਲ)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਰਿਟਰਨ ਨਤੀਜਾVoid

ਦੱਸਦਾ ਹੈ ਕਿ NanoLib ਕਿਸ ਬੱਸ ਡਿਵਾਈਸ ਤੋਂ ਡਿਸਕਨੈਕਟ ਕਰਦਾ ਹੈ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

removeDevice () NanoLib ਦੀ ਅੰਦਰੂਨੀ ਡਿਵਾਈਸ ਸੂਚੀ ਵਿੱਚੋਂ ਆਪਣੀ ਡਿਵਾਈਸ ਨੂੰ ਹਟਾਉਣ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultVoid nlc::NanoLibAccessor::removeDevice (const DeviceHandle deviceHandle)

ਪੈਰਾਮੀਟਰ ਡਿਵਾਈਸ ਹੈਂਡਲ ਰਿਟਰਨ ਨਤੀਜਾVoid

ਨਿਰਧਾਰਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕਿਹੜੀ ਬੱਸ ਯੰਤਰ NanoLib ਡਿਲਿਸਟ ਕਰਦਾ ਹੈ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

closeBusHardware () ਆਪਣੇ ਫੀਲਡਬੱਸ ਹਾਰਡਵੇਅਰ ਤੋਂ ਡਿਸਕਨੈਕਟ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
virtual ResultVoid nlc::NanoLibAccessor::closeBusHardware (BusHardwareId const & busHwId)

ਮਾਪਦੰਡ busHwId ਨਤੀਜਾVoid ਦਿੰਦਾ ਹੈ

ਡਿਸਕਨੈਕਟ ਕਰਨ ਲਈ ਫੀਲਡਬੱਸ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

8.2 ਬੱਸ ਹਾਰਡਵੇਅਰ ਆਈ.ਡੀ
ਬੱਸ ਹਾਰਡਵੇਅਰ ਨੂੰ ਇੱਕ ਤੋਂ ਦੂਜੇ ਦੀ ਪਛਾਣ ਕਰਨ ਲਈ ਜਾਂ ਵੱਖਰੇ ਬੱਸ ਹਾਰਡਵੇਅਰ ਨੂੰ ਇੱਕ ਦੂਜੇ ਤੋਂ ਵੱਖ ਕਰਨ ਲਈ ਇਸ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਇਹ ਕਲਾਸ (ਬਿਨਾਂ ਸੇਟਰ ਫੰਕਸ਼ਨਾਂ ਤੋਂ ਬਿਨਾਂ ਸਿਰਜਣਾ ਤੋਂ ਅਟੱਲ ਹੋਣ ਲਈ) ਇਸ ਬਾਰੇ ਵੀ ਜਾਣਕਾਰੀ ਰੱਖਦਾ ਹੈ:
ਹਾਰਡਵੇਅਰ (= ਅਡਾਪਟਰ ਨਾਮ, ਨੈੱਟਵਰਕ ਅਡਾਪਟਰ ਆਦਿ) ਵਰਤਣ ਲਈ ਪ੍ਰੋਟੋਕੋਲ (= Modbus TCP, CANopen ਆਦਿ) ਬੱਸ ਹਾਰਡਵੇਅਰ ਨਿਰਧਾਰਕ (= ਸੀਰੀਅਲ ਪੋਰਟ ਨਾਮ, MAC ਦੋਸਤਾਨਾ ਨਾਮ
ਪਤਾ ਆਦਿ)

BusHardwareId () [1/3] ਕੰਸਟਰਕਟਰ ਜੋ ਇੱਕ ਨਵੀਂ ਬੱਸ ਹਾਰਡਵੇਅਰ ਆਈਡੀ ਆਬਜੈਕਟ ਬਣਾਉਂਦਾ ਹੈ।
nlc::BusHardwareId::BusHardwareId (std::string const & busHardware_, std::string const & protocol_, std::string const & hardwareSpecifier_, std::string const & name_)

ਪੈਰਾਮੀਟਰ busHardware_protocol_hardwareSpecifier_ extraHardwareSpecifier_name_

ਹਾਰਡਵੇਅਰ ਕਿਸਮ (= ZK-USB-CAN-1 ਆਦਿ)। ਬੱਸ ਸੰਚਾਰ ਪ੍ਰੋਟੋਕੋਲ (= CANopen ਆਦਿ)। ਹਾਰਡਵੇਅਰ ਦਾ ਨਿਰਧਾਰਕ (= COM3 ਆਦਿ)। ਹਾਰਡਵੇਅਰ ਦਾ ਵਾਧੂ ਨਿਰਧਾਰਕ (ਕਹੋ, USB ਟਿਕਾਣਾ ਜਾਣਕਾਰੀ)। ਇੱਕ ਦੋਸਤਾਨਾ ਨਾਮ (= ਅਡਾਪਟਰ ਨਾਮ (ਪੋਰਟ) ਆਦਿ)।

BusHardwareId () [2/3] ਕੰਸਟਰਕਟਰ ਜੋ ਇੱਕ ਵਾਧੂ ਹਾਰਡਵੇਅਰ ਸਪੈਸੀਫਾਇਰ ਲਈ ਵਿਕਲਪ ਦੇ ਨਾਲ, ਇੱਕ ਨਵਾਂ ਬੱਸ ਹਾਰਡਵੇਅਰ ਆਈਡੀ ਆਬਜੈਕਟ ਬਣਾਉਂਦਾ ਹੈ।
nlc::BusHardwareId::BusHardwareId (std::string const & busHardware_, std::string const & protocol_, std::string const & hardwareSpecifier_, std::string const & extraHardwareSpecifier_, std::_string name & const)

ਪੈਰਾਮੀਟਰ busHardware_protocol_hardwareSpecifier_ extraHardwareSpecifier_name_

BusHardwareId () [3/3] ਕੰਸਟਰਕਟਰ ਜੋ ਮੌਜੂਦਾ busHardwareId ਦੀ ਨਕਲ ਕਰਦਾ ਹੈ।
nlc::BusHardwareId::BusHardwareId (BusHardwareId const &)

nlc::BusHardwareId::BusHardwareId (BusHardwareId const &)

ਪੈਰਾਮੀਟਰ busHardwareId

ਕਾਪੀ ਕਰਨ ਲਈ ਬੱਸ ਹਾਰਡਵੇਅਰ ID ਨੂੰ ਨਾਮ ਦਿੰਦਾ ਹੈ।

ਬਰਾਬਰ () ਇੱਕ ਨਵੀਂ ਬੱਸ ਹਾਰਡਵੇਅਰ ID ਦੀ ਮੌਜੂਦਾ ਨਾਲ ਤੁਲਨਾ ਕਰਦਾ ਹੈ।
bool nlc::BusHardwareId:: equals (BusHardwareId const ਅਤੇ ਹੋਰ) const

ਪੈਰਾਮੀਟਰ ਹੋਰ ਰਿਟਰਨ ਸਹੀ

ਉਸੇ ਕਲਾਸ ਦੀ ਇੱਕ ਹੋਰ ਵਸਤੂ. ਜੇਕਰ ਦੋਵੇਂ ਸਾਰੇ ਮੁੱਲਾਂ ਵਿੱਚ ਬਰਾਬਰ ਹਨ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ਝੂਠਾ

ਜੇਕਰ ਮੁੱਲ ਵੱਖਰੇ ਹਨ।

getBusHardware () ਬੱਸ ਹਾਰਡਵੇਅਰ ਸਤਰ ਪੜ੍ਹਦਾ ਹੈ।
std::string nlc::BusHardwareId::getBusHardware () const

ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰਦਾ ਹੈ

getHardwareSpecifier () ਬੱਸ ਹਾਰਡਵੇਅਰ ਦੇ ਨਿਰਧਾਰਕ ਸਤਰ (= ਨੈੱਟਵਰਕ ਨਾਮ ਆਦਿ) ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।
std::string nlc::BusHardwareId::getHardwareSpecifier () const

ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰਦਾ ਹੈ

getExtraHardwareSpecifier () ਬੱਸ ਵਾਧੂ ਹਾਰਡਵੇਅਰ ਦੀ ਨਿਰਧਾਰਕ ਸਤਰ (= MAC ਐਡਰੈੱਸ ਆਦਿ) ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।
std::string nlc::BusHardwareId::getExtraHardwareSpecifier () const

ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰਦਾ ਹੈ

getName () ਬੱਸ ਹਾਰਡਵੇਅਰ ਦੇ ਦੋਸਤਾਨਾ ਨਾਮ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।
std::string nlc::BusHardwareId::getName () const

ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰਦਾ ਹੈ

getProtocol () ਬੱਸ ਪ੍ਰੋਟੋਕੋਲ ਸਤਰ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।
std::string nlc::BusHardwareId::getProtocol () const

ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰਦਾ ਹੈ

toString () ਬੱਸ ਹਾਰਡਵੇਅਰ ID ਨੂੰ ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਵਾਪਸ ਕਰਦਾ ਹੈ।
std::string nlc::BusHardwareId::toString () const

ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰਦਾ ਹੈ
8.3 ਬੱਸ ਹਾਰਡਵੇਅਰ ਵਿਕਲਪ
ਇਸ ਕਲਾਸ ਵਿੱਚ, ਸਤਰ ਦੀ ਇੱਕ ਮੁੱਖ-ਮੁੱਲ ਸੂਚੀ ਵਿੱਚ, ਬੱਸ ਹਾਰਡਵੇਅਰ ਨੂੰ ਖੋਲ੍ਹਣ ਲਈ ਲੋੜੀਂਦੇ ਸਾਰੇ ਵਿਕਲਪ ਲੱਭੋ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

BusHardwareOptions () [1/2] ਇੱਕ ਨਵਾਂ ਬੱਸ ਹਾਰਡਵੇਅਰ ਵਿਕਲਪ ਆਬਜੈਕਟ ਬਣਾਉਂਦਾ ਹੈ।
nlc::BusHardwareOptions::BusHardwareOptions () ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜੇ ਜੋੜਨ ਲਈ ਫੰਕਸ਼ਨ addOption () ਦੀ ਵਰਤੋਂ ਕਰੋ।

BusHardwareOptions () [2/2] ਪਹਿਲਾਂ ਤੋਂ ਮੌਜੂਦ ਕੁੰਜੀ-ਮੁੱਲ ਦੇ ਨਕਸ਼ੇ ਦੇ ਨਾਲ ਇੱਕ ਨਵਾਂ ਬੱਸ ਹਾਰਡਵੇਅਰ ਵਿਕਲਪ ਆਬਜੈਕਟ ਬਣਾਉਂਦਾ ਹੈ।
nlc::BusHardwareOptions::BusHardwareOptions (std::map const ਅਤੇ ਵਿਕਲਪ)

ਪੈਰਾਮੀਟਰ ਵਿਕਲਪ

ਬੱਸ ਹਾਰਡਵੇਅਰ ਨੂੰ ਚਲਾਉਣ ਲਈ ਵਿਕਲਪਾਂ ਵਾਲਾ ਨਕਸ਼ਾ।

addOption () ਵਾਧੂ ਕੁੰਜੀਆਂ ਅਤੇ ਮੁੱਲ ਬਣਾਉਂਦਾ ਹੈ।
void nlc::BusHardwareOptions::addOption (std::string const & key, std::string const & value)

ਪੈਰਾਮੀਟਰ ਕੁੰਜੀ ਮੁੱਲ

Example: BAUD_RATE_OPTIONS_NAME, bus_hw_options_ defaults ਦੇਖੋ
Example: BAUD_RATE_1000K, ਦੇਖੋ bus_hw_options_defaults

ਬਰਾਬਰ () BusHardwareOptions ਦੀ ਮੌਜੂਦਾ ਨਾਲ ਤੁਲਨਾ ਕਰਦਾ ਹੈ।
bool nlc::BusHardwareOptions::equals (BusHardwareOptions const ਅਤੇ ਹੋਰ) const

ਪੈਰਾਮੀਟਰ ਹੋਰ ਰਿਟਰਨ ਸਹੀ
ਝੂਠਾ

ਉਸੇ ਕਲਾਸ ਦੀ ਇੱਕ ਹੋਰ ਵਸਤੂ. ਜੇਕਰ ਦੂਜੇ ਆਬਜੈਕਟ ਵਿੱਚ ਸਾਰੇ ਇੱਕੋ ਜਿਹੇ ਵਿਕਲਪ ਹਨ। ਜੇਕਰ ਦੂਜੀ ਵਸਤੂ ਦੀਆਂ ਵੱਖ ਵੱਖ ਕੁੰਜੀਆਂ ਜਾਂ ਮੁੱਲ ਹਨ।

getOptions () ਸ਼ਾਮਲ ਕੀਤੇ ਗਏ ਸਾਰੇ ਕੁੰਜੀ-ਮੁੱਲ ਜੋੜਿਆਂ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।
std :: ਨਕਸ਼ਾ nlc::BusHardwareOptions::getOptions () const

ਸਤਰ ਦਾ ਨਕਸ਼ਾ ਵਾਪਸ ਕਰਦਾ ਹੈ

toString () ਸਾਰੀਆਂ ਕੁੰਜੀਆਂ/ਮੁੱਲਾਂ ਨੂੰ ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਵਾਪਸ ਕਰਦਾ ਹੈ।
std::string nlc::BusHardwareId::toString () const

ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰਦਾ ਹੈ
8.4 BusHwOptions ਡਿਫੌਲਟ
ਇਸ ਪੂਰਵ-ਨਿਰਧਾਰਤ ਸੰਰਚਨਾ ਵਿਕਲਪ ਕਲਾਸ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਜਨਤਕ ਗੁਣ ਹਨ:

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

const CanBus const ਸੀਰੀਅਲ const RESTfulBus const EtherCATBus

canBus = CanBus () ਸੀਰੀਅਲ = ਸੀਰੀਅਲ () restfulBus = RESTfulBus () ethercatBus = EtherCATBus ()

8.5 ਕੈਨਬੌਡ ਰੇਟ

ਢਾਂਚਾ ਜਿਸ ਵਿੱਚ ਹੇਠ ਲਿਖੀਆਂ ਜਨਤਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ CAN ਬੱਸ ਬਾਡਰੇਟ ਸ਼ਾਮਲ ਹਨ:

const std::string const std::string const std::string const std::string const std::string const std::string const std::string const std::string const std::string const std::string

BAUD_RATE_1000K = “1000k” BAUD_RATE_800K = “800k” BAUD_RATE_500K = “500k” BAUD_RATE_250K = “250k” BAUD_RATE_125K = “125k” BAUD_RATE_100K = “AUD_RATE_100K” = AUD_RATE_50K 50k” BAUD_RATE_20K = “20k” BAUD_RATE_10K = “10k” BAUD_RATE_5K = “5k”

8.6 ਕੈਨਬੱਸ

ਪੂਰਵ-ਨਿਰਧਾਰਤ ਸੰਰਚਨਾ ਵਿਕਲਪਾਂ ਦੀ ਸ਼੍ਰੇਣੀ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਗੁਣਾਂ ਨਾਲ:

const std::string const CanBaudRate const Ixxat

BAUD_RATE_OPTIONS_NAME = “ਕੈਨ ਅਡਾਪਟਰ ਬੌਡ ਰੇਟ” baudRate = CanBaudRate () ixxat = Ixxat ()

8.7 CanOpenNmtService

NMT ਸੇਵਾ ਲਈ, ਇਸ ਢਾਂਚੇ ਵਿੱਚ CANopen NMT ਸਟੇਟਸ ਨੂੰ ਹੇਠ ਲਿਖੀਆਂ ਜਨਤਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਸਤਰ ਮੁੱਲਾਂ ਵਜੋਂ ਸ਼ਾਮਲ ਕੀਤਾ ਗਿਆ ਹੈ:

const std::string const std::string const std::string const std::string const std::string

START = “START” STOP = “STOP” PRE_OPERATIONAL = “PRE_OPERATIONAL” RESET = “RESET” RESET_COMMUNICATION = “RESET_COMMUNICATION”

8.8 CanOpenNmtState

ਇਸ ਢਾਂਚੇ ਵਿੱਚ ਹੇਠ ਲਿਖੀਆਂ ਜਨਤਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਸਟ੍ਰਿੰਗ ਮੁੱਲਾਂ ਵਜੋਂ CANopen NMT ਸਟੇਟਸ ਸ਼ਾਮਲ ਹਨ:

const std::string const std::string const std::string const std::string const std::string

STOPPED = "ਰੋਕਿਆ" PRE_OPERATIONAL = "PRE_OPERATIONAL" OPERATIONAL = "Operational" Initialization = "ਸ਼ੁਰੂਆਤ" ਅਣਜਾਣ = "ਅਣਜਾਣ"

8.9 EtherCATBus ਢਾਂਚਾ

ਇਸ ਢਾਂਚੇ ਵਿੱਚ ਹੇਠ ਲਿਖੀਆਂ ਜਨਤਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ EtherCAT ਸੰਚਾਰ ਸੰਰਚਨਾ ਵਿਕਲਪ ਸ਼ਾਮਲ ਹਨ:

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

const std::string NETWORK_FIRMWARE_STATE_OP- ਨੈੱਟਵਰਕ ਸਥਿਤੀ ਨੂੰ ਫਰਮਵੇਅਰ ਮੋਡ ਮੰਨਿਆ ਜਾਂਦਾ ਹੈ। ਸਵੀਕਾਰਯੋਗ

TION_NAME = "ਨੈੱਟਵਰਕ ਫਰਮਵੇਅਰ ਸਟੇਟ"

ਮੁੱਲ (ਡਿਫਾਲਟ = PRE_OPERATIONAL):

EtherCATSstate::PRE_OPERATIONAL EtherCATSstate::SAFE_OPERATIONAL EtherCATSstate::OPERATIONAL

const std::string DEFAULT_NETWORK_FIRMWARE_ STATE = “PRE_OPERATIONAL”

const std::string EXCLUSIVE_LOCK_TIMEOUT_OP- ਐਕਸਕਲੂਸਿਵ ਲਾਕ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ ਸਮਾਂ ਸਮਾਪਤ

TION_NAME = “ਸਾਂਝਾ ਲਾਕ ਸਮਾਂ ਸਮਾਪਤ”

ਨੈੱਟਵਰਕ (ਡਿਫਾਲਟ = 500 ms)।

const unsigned int DEFAULT_EXCLUSIVE_LOCK_ TIMEOUT = “500”

const std::string SHARED_LOCK_TIMEOUT_OPTION_ ਸ਼ੇਅਰ ਲਾਕ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ ਸਮਾਂ ਸਮਾਪਤ

NAME = “ਸਾਂਝਾ ਲਾਕ ਸਮਾਂ ਸਮਾਪਤ”

ਨੈੱਟਵਰਕ (ਡਿਫਾਲਟ = 250 ms)।

const unsigned int DEFAULT_SHARED_LOCK_TIMEOUT = “250”

const std::string READ_TIMEOUT_OPTION_NAME = ਇੱਕ ਰੀਡ ਓਪਰੇਸ਼ਨ ਲਈ ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ ਸਮਾਂ ਸਮਾਪਤ (ਮੂਲ

"ਪੜ੍ਹਨ ਦਾ ਸਮਾਂ ਸਮਾਪਤ"

= 700 ms)।

const unsigned int DEFAULT_READ_TIMEOUT = “700”

const std::string WRITE_TIMEOUT_OPTION_NAME = ਇੱਕ ਲਿਖਣ ਕਾਰਵਾਈ ਲਈ ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ ਸਮਾਂ ਸਮਾਪਤ (ਮੂਲ

"ਲਿਖੋ ਸਮਾਂ ਸਮਾਪਤ"

= 200 ms)।

const unsigned int DEFAULT_WRITE_TIMEOUT = “200”

const std::string READ_WRITE_ATTEMPTS_OPTION_ ਅਧਿਕਤਮ ਪੜ੍ਹਨ ਜਾਂ ਲਿਖਣ ਦੀਆਂ ਕੋਸ਼ਿਸ਼ਾਂ (ਗੈਰ-ਜ਼ੀਰੋ ਮੁੱਲ

NAME = “ਪੜ੍ਹਨ/ਲਿਖਣ ਦੀਆਂ ਕੋਸ਼ਿਸ਼ਾਂ”

ਸਿਰਫ; ਡਿਫਾਲਟ = 5)।

const unsigned int DEFAULT_READ_WRITE_ATTEMPTS = “5”

const std::string CHANGE_NETWORK_STATE_ATTEMPTS_OPTION_NAME = "ਨੈੱਟਵਰਕ ਸਟੇਟ ਕੋਸ਼ਿਸ਼ਾਂ ਬਦਲੋ"

ਨੈੱਟਵਰਕ ਸਥਿਤੀ ਨੂੰ ਬਦਲਣ ਦੀਆਂ ਕੋਸ਼ਿਸ਼ਾਂ ਦੀ ਵੱਧ ਤੋਂ ਵੱਧ ਸੰਖਿਆ (ਸਿਰਫ਼ ਗੈਰ-ਜ਼ੀਰੋ ਮੁੱਲ; ਮੂਲ = 10)।

const unsigned int DEFAULT_CHANGE_NETWORK_ STATE_ATTEMPTS = “10”

const std::string PDO_IO_ENABLED_OPTION_NAME ਡਿਜੀਟਲ ਇਨ- / ਲਈ PDO ਪ੍ਰੋਸੈਸਿੰਗ ਨੂੰ ਸਮਰੱਥ ਜਾਂ ਅਸਮਰੱਥ ਬਣਾਉਂਦਾ ਹੈ

= "PDO IO ਸਮਰੱਥ"

ਆਉਟਪੁੱਟ (ਸਿਰਫ਼ "ਸੱਚ" ਜਾਂ "ਗਲਤ"; ਡਿਫੌਲਟ = "ਸੱਚ")।

const std::string DEFAULT_PDO_IO_ENABLED = “ਸੱਚਾ”

8.10 EtherCATSstate ਢਾਂਚਾ

ਇਸ ਢਾਂਚੇ ਵਿੱਚ ਹੇਠ ਲਿਖੀਆਂ ਜਨਤਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਸਟ੍ਰਿੰਗ ਮੁੱਲਾਂ ਵਜੋਂ EtherCAT ਸਲੇਵ / ਨੈੱਟਵਰਕ ਸਟੇਟਸ ਸ਼ਾਮਲ ਹਨ। ਨੋਟ: ਪਾਵਰ ਚਾਲੂ ਹੋਣ 'ਤੇ ਡਿਫੌਲਟ ਸਥਿਤੀ PRE_OPERATIONAL ਹੈ; NanoLib ਇੱਕ ਗੈਰ-ਰੀਅਲਟਾਈਮ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਵਿੱਚ ਕੋਈ ਭਰੋਸੇਮੰਦ "ਸੰਚਾਲਨ" ਸਥਿਤੀ ਪ੍ਰਦਾਨ ਨਹੀਂ ਕਰ ਸਕਦਾ ਹੈ:

const std::string const std::string const std::string const std::string const std::string const std::string

NONE = "NONE" INIT = "INIT" PRE_OPERATIONAL = "PRE_OPERATIONAL" BOOT = "BOOT" SAFE_OPERATIONAL = "SAFE_OPERATIONAL" ਸੰਚਾਲਨ = "ਸੰਚਾਲਨ"

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

੬.੧੧ ਇਕ੍ਸੇਟ

ਇਹ ਢਾਂਚਾ ਹੇਠ ਲਿਖੀਆਂ ਜਨਤਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ Ixxat usb-to-can ਲਈ ਸਾਰੀ ਜਾਣਕਾਰੀ ਰੱਖਦਾ ਹੈ:

const std::string

ADAPTER_BUS_NUMBER_OPTIONS_NAME = “ixxat ਅਡਾਪਟਰ ਬੱਸ ਨੰਬਰ”

const IxxatAdapterBusNumber adapterBusNumber = IxxatAdapterBusNumber ()

8.12 IxxatAdapterBusNumber

ਇਹ ਢਾਂਚਾ ਹੇਠ ਲਿਖੀਆਂ ਜਨਤਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ Ixxat usb-to-can ਲਈ ਬੱਸ ਨੰਬਰ ਰੱਖਦਾ ਹੈ:

const std:: string const std:: string const std:: string const std:: string

BUS_NUMBER_0_DEFAULT = “0” BUS_NUMBER_1 = “1” BUS_NUMBER_2 = “2” BUS_NUMBER_3 = “3”

8.13 ਪੀਕ

ਇਹ ਢਾਂਚਾ ਹੇਠ ਲਿਖੀਆਂ ਜਨਤਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਪੀਕ ਯੂਐਸਬੀ-ਟੂ-ਕੈਨ ਲਈ ਸਾਰੀ ਜਾਣਕਾਰੀ ਰੱਖਦਾ ਹੈ:

const std::string

ADAPTER_BUS_NUMBER_OPTIONS_NAME = “ਪੀਕ ਅਡਾਪਟਰ ਬੱਸ ਨੰਬਰ”

const PeakAdapterBusNumber adapterBusNumber = PeakAdapterBusNumber ()

8.14 ਪੀਕਅਡਾਪਟਰਬੱਸ ਨੰਬਰ

ਇਹ ਢਾਂਚਾ ਹੇਠ ਲਿਖੀਆਂ ਜਨਤਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਵਿੱਚ ਪੀਕ ਯੂਐਸਬੀ-ਟੂ-ਕੈਨ ਲਈ ਬੱਸ ਨੰਬਰ ਰੱਖਦਾ ਹੈ:

const std::string const std::string const std::string const std::string const std::string const std::string const std::string const std::string const std::string const std::string const std:: string const std:: string const std:: string const std:: string const std::string const std::string

BUS_NUMBER_1_DEFAULT = std::to_string (PCAN_USBBUS1) BUS_NUMBER_2 = std::to_string (PCAN_USBBUS2) BUS_NUMBER_3 = std::to_string (PCAN_USBBUS3) BUS_NUMBER_4 = std::to_SBBUS = BUS_NUMBER_4 = std:: ਤੋਂ PCAN_BUS = 5. std::to_string (PCAN_USBBUS5) BUS_NUMBER_6 = std::to_string (PCAN_USBBUS6) BUS_NUMBER_7 = std::to_string (PCAN_USBBUS7) BUS_NUMBER_8 = std::to_string (PCAN_USBBUSD = 8_string: (PCAN_USBBUS9) BUS_NUMBER_9 = std::to_string (PCAN_USBBUS10) BUS_NUMBER_10 = std::to_string (PCAN_USBBUS11) BUS_NUMBER_11 = std::to_string (PCAN_USBBUS12) = ਸਟੱਡੀ: BUS_NUMBER_12 (PCAN_USBBUS13) BUS_NUMBER_13 = std::to_string (PCAN_USBBUS14) BUS_NUMBER_14 = std::to_string (PCAN_USBBUS15) BUS_NUMBER_15 = std::to_string (PCAN_USBBUS16)

8.15 ਡਿਵਾਈਸ ਹੈਂਡਲ
ਇਹ ਕਲਾਸ ਇੱਕ ਬੱਸ ਵਿੱਚ ਇੱਕ ਡਿਵਾਈਸ ਨੂੰ ਨਿਯੰਤਰਿਤ ਕਰਨ ਲਈ ਇੱਕ ਹੈਂਡਲ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ।

DeviceHandle () DeviceHandle (uint32_t ਹੈਂਡਲ)

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ਬਰਾਬਰ () ਆਪਣੇ ਆਪ ਨੂੰ ਦਿੱਤੇ ਗਏ ਡਿਵਾਈਸ ਹੈਂਡਲ ਨਾਲ ਤੁਲਨਾ ਕਰਦਾ ਹੈ।
bool equals (DeviceHandle const other) const (uint32_t ਹੈਂਡਲ)

toString () ਡਿਵਾਈਸ ਹੈਂਡਲ ਦੀ ਇੱਕ ਸਟ੍ਰਿੰਗ ਪ੍ਰਤੀਨਿਧਤਾ ਦਿੰਦਾ ਹੈ।
std::string toString () const

get () ਡਿਵਾਈਸ ਹੈਂਡਲ ਵਾਪਸ ਕਰਦਾ ਹੈ।
uint32_t ਪ੍ਰਾਪਤ ਕਰੋ () const

8.16 ਡਿਵਾਈਸ ਆਈ.ਡੀ
ਬੱਸ ਵਿੱਚ ਡਿਵਾਈਸਾਂ ਦੀ ਪਛਾਣ ਕਰਨ ਅਤੇ ਵੱਖ ਕਰਨ ਲਈ ਇਸ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰੋ (ਰਚਨਾ ਤੋਂ ਅਟੱਲ ਨਹੀਂ):

ਹਾਰਡਵੇਅਰ ਅਡਾਪਟਰ ਪਛਾਣਕਰਤਾ

ਡਿਵਾਈਸ ਪਛਾਣਕਰਤਾ

ਵਰਣਨ

ਡਿਵਾਈਸ ID / ਵਰਣਨ ਮੁੱਲਾਂ ਦਾ ਅਰਥ ਬੱਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਸਾਬਕਾ ਲਈample, ਇੱਕ CAN ਬੱਸ ਪੂਰਨ ਅੰਕ ID ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੀ ਹੈ।

DeviceId () [1/3] ਇੱਕ ਨਵੀਂ ਡਿਵਾਈਸ ID ਵਸਤੂ ਦਾ ਨਿਰਮਾਣ ਕਰਦਾ ਹੈ।
nlc::DeviceId::DeviceId (BusHardwareId const & busHardwareId_, unsigned int deviceId_, std::string const & description_)

ਪੈਰਾਮੀਟਰ busHardwareId_ deviceId_ description_

ਬੱਸ ਦਾ ਪਛਾਣਕਰਤਾ। ਇੱਕ ਸੂਚਕਾਂਕ; ਬੱਸ ਦੇ ਅਧੀਨ (= CANopen ਨੋਡ ID ਆਦਿ)। ਇੱਕ ਵੇਰਵਾ (ਖਾਲੀ ਹੋ ਸਕਦਾ ਹੈ); ਬੱਸ ਦੇ ਅਧੀਨ.

DeviceId () [2/3] ਵਿਸਤ੍ਰਿਤ ID ਵਿਕਲਪਾਂ ਦੇ ਨਾਲ ਇੱਕ ਨਵੀਂ ਡਿਵਾਈਸ ID ਵਸਤੂ ਦਾ ਨਿਰਮਾਣ ਕਰਦਾ ਹੈ।
nlc::DeviceId::DeviceId (BusHardwareId const & busHardwareId, unsigned int deviceId_, std::string const & description_ std::vector const & extraId_, std:: string const & extraStringId_)

ਪੈਰਾਮੀਟਰ busHardwareId_ deviceId_ description_ extraId_ extraStringId_

ਬੱਸ ਦਾ ਪਛਾਣਕਰਤਾ। ਇੱਕ ਸੂਚਕਾਂਕ; ਬੱਸ ਦੇ ਅਧੀਨ (= CANopen ਨੋਡ ID ਆਦਿ)। ਇੱਕ ਵੇਰਵਾ (ਖਾਲੀ ਹੋ ਸਕਦਾ ਹੈ); ਬੱਸ ਦੇ ਅਧੀਨ. ਇੱਕ ਵਾਧੂ ID (ਖਾਲੀ ਹੋ ਸਕਦੀ ਹੈ); ਮਤਲਬ ਬੱਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ। ਵਧੀਕ ਸਤਰ ID (ਖਾਲੀ ਹੋ ਸਕਦੀ ਹੈ); ਮਤਲਬ ਬੱਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।

ਡਿਵਾਈਸ ਆਈਡੀ () [3/3] ਇੱਕ ਡਿਵਾਈਸ ਆਈਡੀ ਆਬਜੈਕਟ ਦੀ ਇੱਕ ਕਾਪੀ ਬਣਾਉਂਦੀ ਹੈ।
nlc::DeviceId::DeviceId (DeviceId const &)

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ਪੈਰਾਮੀਟਰ deviceId_

ਕਾਪੀ ਕਰਨ ਲਈ ਡਿਵਾਈਸ ਆਈ.ਡੀ.

ਬਰਾਬਰ () ਮੌਜੂਦਾ ਵਸਤੂਆਂ ਨਾਲ ਨਵੇਂ ਦੀ ਤੁਲਨਾ ਕਰਦਾ ਹੈ।
bool nlc::DeviceId::equals (DeviceId const ਅਤੇ ਹੋਰ) const

ਬੁਲੀਅਨ ਵਾਪਸ ਕਰਦਾ ਹੈ

getBusHardwareId () ਬੱਸ ਹਾਰਡਵੇਅਰ ID ਪੜ੍ਹਦਾ ਹੈ।
BusHardwareId nlc::DeviceId::getBusHardwareId () const

BusHardwareId ਵਾਪਸ ਕਰਦਾ ਹੈ

getDescription () ਡਿਵਾਈਸ ਦਾ ਵੇਰਵਾ ਪੜ੍ਹਦਾ ਹੈ (ਸ਼ਾਇਦ ਅਣਵਰਤਿਆ)।
std::string nlc::DeviceId::getDescription () const

ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰਦਾ ਹੈ

getDeviceId () ਡਿਵਾਈਸ ID ਪੜ੍ਹਦਾ ਹੈ (ਸ਼ਾਇਦ ਅਣਵਰਤਿਆ ਹੋਇਆ)।
ਹਸਤਾਖਰਿਤ int nlc::DeviceId::getDeviceId () const

ਹਸਤਾਖਰਿਤ ਇੰਟ ਵਾਪਸ ਕਰਦਾ ਹੈ

toString () ਵਸਤੂ ਨੂੰ ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਵਾਪਸ ਕਰਦਾ ਹੈ।
std::string nlc::DeviceId::toString () const

ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰਦਾ ਹੈ

getExtraId () ਡਿਵਾਈਸ ਦੀ ਵਾਧੂ ਆਈਡੀ ਪੜ੍ਹਦਾ ਹੈ (ਨਾ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ)।
const std::vector &getExtraId () const

ਵੈਕਟਰ ਵਾਪਸ ਕਰਦਾ ਹੈ

ਵਾਧੂ ਵਾਧੂ ID ਦਾ ਇੱਕ ਵੈਕਟਰ (ਖਾਲੀ ਹੋ ਸਕਦਾ ਹੈ); ਮਤਲਬ ਬੱਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।

getExtraStringId () ਡਿਵਾਈਸ ਦੀ ਵਾਧੂ ਸਤਰ ID ਪੜ੍ਹਦਾ ਹੈ (ਨਾ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ)।
std::string getExtraStringId () const

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ਸਟ੍ਰਿੰਗ ਵਾਪਸ ਕਰਦਾ ਹੈ

ਵਾਧੂ ਸਤਰ ID (ਖਾਲੀ ਹੋ ਸਕਦੀ ਹੈ); ਮਤਲਬ ਬੱਸ 'ਤੇ ਨਿਰਭਰ ਕਰਦਾ ਹੈ।

8.17 ਲਾਗਲੇਵਲ ਕਨਵਰਟਰ

ਇਹ ਕਲਾਸ ਤੁਹਾਡੇ ਲੌਗ ਪੱਧਰ ਨੂੰ ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਸਥਿਰ std::string toString (nlc::LogLevel logLevel)

8.18 LogModuleConverter

ਇਹ ਕਲਾਸ ਤੁਹਾਡੀ ਲਾਇਬ੍ਰੇਰੀ-ਵਿਸ਼ੇਸ਼ ਲਾਗ modulesetLoggingLevel () ਨੂੰ ਇੱਕ ਸਤਰ ਵਜੋਂ ਵਾਪਸ ਕਰਦਾ ਹੈ।

ਸਥਿਰ std::string

toString (nlc::LogModule logModule)

static std::string toString (nlc::LogModule logModule)

8.19 ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ
ਇਹ ਕਲਾਸ ਇੱਕ ਕੰਟਰੋਲਰ ਦੇ ਇੱਕ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ: getDeviceHandle ()
virtual ResultDeviceHandle getDeviceHandle () const ResultDeviceHandle ਦਿੰਦਾ ਹੈ

getObject () virtual ResultObjectSubEntry getObject (OdIndex const odIndex) ResultObjectSubEntry ਦਿੰਦਾ ਹੈ

getObjectEntry () virtual ResultObjectEntry getObjectEntry (uint16_t ਇੰਡੈਕਸ)

ResultObjectEntry ਵਾਪਸ ਕਰਦਾ ਹੈ

ਕਿਸੇ ਵਸਤੂ ਦੀਆਂ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਬਾਰੇ ਸੂਚਿਤ ਕਰਦਾ ਹੈ।

getXmlFileਨਾਮ () virtual ResultString getXmlFileਨਾਮ () const

ResultString ਵਾਪਸ ਕਰਦਾ ਹੈ

XML ਵਾਪਸ ਕਰਦਾ ਹੈ file ਇੱਕ ਸਤਰ ਦੇ ਤੌਰ ਤੇ ਨਾਮ.

readNumber () virtual ResultInt readNumber (OdIndex const odIndex) ਰਿਟਰਨ ਨਤੀਜਾ
readNumberArray () virtual ResultArrayInt readNumberArray (uint16_t const ਸੂਚਕਾਂਕ)

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ
ResultArrayInt readString () ਵਾਪਸ ਕਰਦਾ ਹੈ
virtual ResultString readString (OdIndex const odIndex) ResultString readBytes () virtual ResultArrayByte readBytes (OdIndex const odIndex) ResultArrayByte writeNumber () ਵਰਚੁਅਲ ResultVoid writeNumber (OdIndex const 64ResultIndex ਮੁੱਲ) writeBytes () ਵਰਚੁਅਲ ਨਤੀਜਾVoid writeBytes (OdIndex const OdIndex, std::vector
const ਅਤੇ ਡੇਟਾ) ਰਿਟਰਨਵੌਇਡ ਸੰਬੰਧਿਤ ਲਿੰਕਸ OdIndex
8.20 ਆਬਜੈਕਟ ਐਂਟਰੀ
ਇਹ ਕਲਾਸ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਦੀ ਇੱਕ ਆਬਜੈਕਟ ਐਂਟਰੀ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ, ਇਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਸਥਿਰ ਸੁਰੱਖਿਅਤ ਗੁਣ ਅਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:
ਸਥਿਰ nlc::ObjectSubEntry invalidObject
getName () ਵਸਤੂ ਦੇ ਨਾਮ ਨੂੰ ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਪੜ੍ਹਦਾ ਹੈ।
ਵਰਚੁਅਲ std::string getName () const
getPrivate () ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਵਸਤੂ ਨਿੱਜੀ ਹੈ।
ਵਰਚੁਅਲ bool getPrivate () const
getIndex () ਆਬਜੈਕਟ ਸੂਚਕਾਂਕ ਦਾ ਪਤਾ ਪੜ੍ਹਦਾ ਹੈ।
ਵਰਚੁਅਲ uint16_t getIndex () const

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

getDataType () ਆਬਜੈਕਟ ਦੇ ਡੇਟਾ ਕਿਸਮ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।
ਵਰਚੁਅਲ nlc::ObjectEntryDataType getDataType () const

getObjectCode () ਆਬਜੈਕਟ ਕੋਡ ਪੜ੍ਹਦਾ ਹੈ:

Null Deftype Defstruct Var ਐਰੇ ਰਿਕਾਰਡ

0x00 0x05 0x06 0x07 0x08 0x09

ਵਰਚੁਅਲ nlc::ObjectCode getObjectCode () const

getObjectSaveable () ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਵਸਤੂ ਸੁਰੱਖਿਅਤ ਹੈ ਅਤੇ ਇਹ ਸ਼੍ਰੇਣੀ ਹੈ (ਵਧੇਰੇ ਵੇਰਵਿਆਂ ਲਈ ਉਤਪਾਦ ਮੈਨੂਅਲ ਦੇਖੋ): APPLICATION, COMMUNICATION, DRIVE, MISC_CONFIG, MODBUS_RTU, NO, TUNING, CUSTOMER, ETHERNET, CANOPEN, VERIFYUNKVNPEWY1020
ਵਰਚੁਅਲ nlc::ObjectSaveable getObjectSaveable () const

getMaxSubIndex () ਇਸ ਵਸਤੂ ਦੁਆਰਾ ਸਮਰਥਿਤ ਸਬ-ਇੰਡਿਕਸ ਦੀ ਸੰਖਿਆ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।
ਵਰਚੁਅਲ uint8_t getMaxSubIndex () const

getSubEntry () ਵਰਚੁਅਲ nlc::ObjectSubEntry & getSubEntry (uint8_t ਸਬਇੰਡੈਕਸ)
ObjectSubEntry ਵੀ ਦੇਖੋ।
8.21 ਆਬਜੈਕਟ ਸਬ-ਐਂਟਰੀ
ਇਹ ਕਲਾਸ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਦੀ ਇੱਕ ਆਬਜੈਕਟ ਸਬ-ਐਂਟਰੀ (ਸਬਿੰਡੈਕਸ) ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:
getName () ਵਸਤੂ ਦੇ ਨਾਮ ਨੂੰ ਇੱਕ ਸਤਰ ਦੇ ਰੂਪ ਵਿੱਚ ਪੜ੍ਹਦਾ ਹੈ।
ਵਰਚੁਅਲ std::string getName () const

getSubIndex () ਸਬ-ਇੰਡੈਕਸ ਦਾ ਪਤਾ ਪੜ੍ਹਦਾ ਹੈ।
ਵਰਚੁਅਲ uint8_t getSubIndex () const

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

getDataType () ਆਬਜੈਕਟ ਦੇ ਡੇਟਾ ਕਿਸਮ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।
ਵਰਚੁਅਲ nlc::ObjectEntryDataType getDataType () const

getSdoAccess () ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਸਬ-ਇੰਡੈਕਸ SDO ਰਾਹੀਂ ਪਹੁੰਚਯੋਗ ਹੈ:

ਸਿਰਫ਼ ਪੜ੍ਹਨ ਲਈ

ਸਿਰਫ਼ ਲਿਖੋ

ਪੜ੍ਹੋ

NoAccess

ਵਰਚੁਅਲ nlc::ObjectSdoAccessAttribute getSdoAccess () const

getPdoAccess () ਜਾਂਚ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਸਬ-ਇੰਡੈਕਸ PDO ਰਾਹੀਂ ਪਹੁੰਚਯੋਗ/ਮੈਪਯੋਗ ਹੈ:

TxRx

ਨੰ

ਵਰਚੁਅਲ nlc::ObjectPdoAccessAttribute getPdoAccess () const

getBitLength () ਸਬ-ਇੰਡੈਕਸ ਲੰਬਾਈ ਦੀ ਜਾਂਚ ਕਰਦਾ ਹੈ।
ਵਰਚੁਅਲ uint32_t getBitLength () const

getDefaultValueAsNumeric () ਸੰਖਿਆਤਮਕ ਡੇਟਾ ਕਿਸਮਾਂ ਲਈ ਸਬ-ਇੰਡੈਕਸ ਦੇ ਡਿਫੌਲਟ ਮੁੱਲ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।
virtual ResultInt getDefaultValueAsNumeric (std::string const & key) const

getDefaultValueAsString () ਸਟਰਿੰਗ ਡੇਟਾ ਕਿਸਮਾਂ ਲਈ ਸਬ-ਇੰਡੈਕਸ ਦੇ ਡਿਫੌਲਟ ਮੁੱਲ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।
virtual ResultString getDefaultValueAsString (std::string const & key) const

getDefaultValues () ਸਬ-ਇੰਡੈਕਸ ਦੇ ਡਿਫੌਲਟ ਮੁੱਲਾਂ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।
ਵਰਚੁਅਲ std::map getDefaultValues () const

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

readNumber () ਸਬ-ਇੰਡੈਕਸ ਦੇ ਸੰਖਿਆਤਮਕ ਅਸਲ ਮੁੱਲ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।
virtual ResultInt readNumber () const

readString () ਸਬ-ਇੰਡੈਕਸ ਦੇ ਸਤਰ ਦੇ ਅਸਲ ਮੁੱਲ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।
virtual ResultString readString () const

readBytes () ਬਾਈਟਸ ਵਿੱਚ ਸਬ-ਇੰਡੈਕਸ ਦੇ ਅਸਲ ਮੁੱਲ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।
ਵਰਚੁਅਲ ਨਤੀਜਾArrayByte readBytes () const

writeNumber () ਸਬ-ਇੰਡੈਕਸ ਵਿੱਚ ਇੱਕ ਸੰਖਿਆਤਮਕ ਮੁੱਲ ਲਿਖਦਾ ਹੈ।
virtual ResultVoid writeNumber (const int64_t ਮੁੱਲ) const

writeBytes () ਬਾਈਟਸ ਵਿੱਚ ਸਬ-ਇੰਡੈਕਸ ਵਿੱਚ ਇੱਕ ਮੁੱਲ ਲਿਖਦਾ ਹੈ।
ਵਰਚੁਅਲ ਨਤੀਜਾVoid ਰਾਈਟਬਾਈਟਸ (std::vector const & data) const

8.22 ਓਡਇੰਡੈਕਸ
ਆਬਜੈਕਟ ਡਾਇਰੈਕਟਰੀ ਸੂਚਕਾਂਕ/ਉਪ-ਸੂਚਕਾਂਕ ਨੂੰ ਲਪੇਟਣ ਅਤੇ ਲੱਭਣ ਲਈ ਇਸ ਕਲਾਸ (ਸਿਰਜਣ ਤੋਂ ਅਟੱਲ) ਦੀ ਵਰਤੋਂ ਕਰੋ। ਇੱਕ ਡਿਵਾਈਸ ਦੇ OD ਵਿੱਚ 65535 (0xFFFF) ਕਤਾਰਾਂ ਅਤੇ 255 (0xFF) ਕਾਲਮ ਹਨ; ਲਗਾਤਾਰ ਕਤਾਰਾਂ ਵਿਚਕਾਰ ਪਾੜੇ ਦੇ ਨਾਲ। ਹੋਰ ਵੇਰਵਿਆਂ ਲਈ CANopen ਸਟੈਂਡਰਡ ਅਤੇ ਤੁਹਾਡਾ ਉਤਪਾਦ ਮੈਨੂਅਲ ਦੇਖੋ।
OdIndex () ਇੱਕ ਨਵੀਂ OdIndex ਵਸਤੂ ਦਾ ਨਿਰਮਾਣ ਕਰਦਾ ਹੈ।
nlc::OdIndex::OdIndex (uint16_t ਸੂਚਕਾਂਕ, uint8_t ਸਬ-ਇੰਡੈਕਸ)

ਪੈਰਾਮੀਟਰ ਸੂਚਕਾਂਕ ਸਬ-ਇੰਡੈਕਸ

0 ਤੋਂ 65535 (0xFFFF) ਸਮੇਤ। 0 ਤੋਂ 255 (0xFF) ਸਮੇਤ।

getIndex () ਸੂਚਕਾਂਕ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ (0x0000 ਤੋਂ 0xFFFF ਤੱਕ)।
uint16_t nlc::OdIndex::getIndex () const

uint16_t ਵਾਪਸ ਕਰਦਾ ਹੈ

getSubindex () ਸਬ-ਇੰਡੈਕਸ ਪੜ੍ਹਦਾ ਹੈ (0x00 ਤੋਂ 0xFF ਤੱਕ)
uint8_t nlc::OdIndex::getSubIndex () const

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

uint8_t ਵਾਪਸ ਕਰਦਾ ਹੈ

toString () ਇੱਕ ਸਤਰ ਦੇ ਤੌਰ 'ਤੇ ਸੂਚਕਾਂਕ ਅਤੇ ਸਬ-ਇੰਡੈਕਸ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਸਟ੍ਰਿੰਗ ਡਿਫੌਲਟ 0xIIII: 0xSS ਇਸ ਤਰ੍ਹਾਂ ਪੜ੍ਹਦਾ ਹੈ:

I = 0x0000 ਤੋਂ 0xFFFF ਤੱਕ ਸੂਚਕਾਂਕ

S = 0x00 ਤੋਂ 0xFF ਤੱਕ ਸਬ-ਇੰਡੈਕਸ

std::string nlc::OdIndex::toString () const

0xIIII:0xSS ਦਿੰਦਾ ਹੈ

ਪੂਰਵ-ਨਿਰਧਾਰਤ ਸਟ੍ਰਿੰਗ ਪ੍ਰਤੀਨਿਧਤਾ

੬.੨੧ ਓਡ ਲਾਇਬ੍ਰੇਰੀ
XML ਤੋਂ ObjectDictionary ਕਲਾਸ ਦੀਆਂ ਉਦਾਹਰਨਾਂ ਬਣਾਉਣ ਲਈ ਇਸ ਪ੍ਰੋਗਰਾਮਿੰਗ ਇੰਟਰਫੇਸ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਅਸਾਈਨ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਦੁਆਰਾ, ਤੁਸੀਂ ਫਿਰ ਇੱਕ ਵਿਲੱਖਣ ਤੌਰ 'ਤੇ ਬਣਾਏ ਪਛਾਣਕਰਤਾ ਦੇ ਕਾਰਨ ਹਰੇਕ ਉਦਾਹਰਨ ਨੂੰ ਇੱਕ ਖਾਸ ਡਿਵਾਈਸ ਨਾਲ ਬੰਨ੍ਹ ਸਕਦੇ ਹੋ। ਇਸ ਤਰ੍ਹਾਂ ਬਣਾਏ ਗਏ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਉਦਾਹਰਨਾਂ ਨੂੰ ਸੂਚਕਾਂਕ ਦੁਆਰਾ ਐਕਸੈਸ ਕਰਨ ਲਈ ਓਡ ਲਾਇਬ੍ਰੇਰੀ ਆਬਜੈਕਟ ਵਿੱਚ ਸਟੋਰ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ODLibrary ਕਲਾਸ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਆਈਟਮਾਂ ਨੂੰ ਲੋਡ ਕਰਦੀ ਹੈ file ਜਾਂ ਐਰੇ, ਉਹਨਾਂ ਨੂੰ ਸਟੋਰ ਕਰਦਾ ਹੈ, ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:

getObjectDictionaryCount () virtual uint32_t getObjectDictionaryCount () const

getObjectDictionary () virtual ResultObjectDictionary getObjectDictionary (uint32_t odIndex)

ResultObjectDictionary ਦਿੰਦਾ ਹੈ

AddObjectDictionaryFromFile ()
ਵਰਚੁਅਲ ਰਿਜ਼ਲਟ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਐਡ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਤੋਂFile (std::string const & absoluteXmlFileਮਾਰਗ)

ResultObjectDictionary ਦਿੰਦਾ ਹੈ

addObjectDictionary ()
ਵਰਚੁਅਲ ਨਤੀਜਾ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ addObjectDictionary (std::vector const & odXmlData, const std::string &xmlFileਮਾਰਗ = std::string ())

ResultObjectDictionary ਦਿੰਦਾ ਹੈ
੬.੨੨ ਓਡਟਾਇਪਸਹਾਈਪਰ
ਨਿਮਨਲਿਖਤ ਜਨਤਕ ਸਦੱਸ ਫੰਕਸ਼ਨਾਂ ਤੋਂ ਇਲਾਵਾ, ਇਸ ਕਲਾਸ ਵਿੱਚ ਕਸਟਮ ਡੇਟਾ ਕਿਸਮਾਂ ਸ਼ਾਮਲ ਹਨ। ਨੋਟ: ਆਪਣੇ ਕਸਟਮ ਡੇਟਾ ਕਿਸਮਾਂ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ, od_types.hpp ਵਿੱਚ enum ਕਲਾਸ ObjectEntryDataType ਦੀ ਭਾਲ ਕਰੋ।

uintToObjectCode () ਬਿਨਾਂ ਦਸਤਖਤ ਕੀਤੇ ਪੂਰਨ ਅੰਕਾਂ ਨੂੰ ਆਬਜੈਕਟ ਕੋਡ ਵਿੱਚ ਬਦਲਦਾ ਹੈ:

null Deftype

ਐਕਸ.ਐੱਨ.ਐੱਮ.ਐੱਨ.ਐੱਮ.ਐਕਸ.ਐਕਸ.ਐੱਨ.ਐੱਮ.ਐੱਮ.ਐੱਮ.ਐਕਸ

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

Defstruct Var ਐਰੇ ਰਿਕਾਰਡ

0x06 0x07 0x08 0x09

ਸਥਿਰ ਆਬਜੈਕਟਕੋਡ uintToObjectCode (ਹਸਤਾਖਰਿਤ int ਆਬਜੈਕਟਕੋਡ)

isNumericDataType () ਸੂਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਕੋਈ ਡਾਟਾ ਕਿਸਮ ਸੰਖਿਆਤਮਕ ਹੈ ਜਾਂ ਨਹੀਂ।
ਸਥਿਰ ਬੂਲ isNumericDataType (ObjectEntryDataType dataType)

isDefstructIndex () ਸੂਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਕੋਈ ਵਸਤੂ ਇੱਕ ਪਰਿਭਾਸ਼ਾ ਬਣਤਰ ਸੂਚਕਾਂਕ ਹੈ ਜਾਂ ਨਹੀਂ।
ਸਥਿਰ ਬੂਲ isDefstructIndex (uint16_t typeNum)

isDeftypeIndex () ਸੂਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਕੋਈ ਵਸਤੂ ਇੱਕ ਪਰਿਭਾਸ਼ਾ ਕਿਸਮ ਦਾ ਸੂਚਕਾਂਕ ਹੈ ਜਾਂ ਨਹੀਂ।
ਸਥਿਰ ਬੂਲ isDeftypeIndex (uint16_t typeNum)

isComplexDataType () ਸੂਚਿਤ ਕਰਦਾ ਹੈ ਕਿ ਕੀ ਕੋਈ ਡਾਟਾ ਕਿਸਮ ਗੁੰਝਲਦਾਰ ਹੈ ਜਾਂ ਨਹੀਂ।
ਸਥਿਰ bool isComplexDataType (ObjectEntryDataType dataType)

uintToObjectEntryDataType () ਗੈਰ-ਹਸਤਾਖਰਿਤ ਪੂਰਨ ਅੰਕਾਂ ਨੂੰ OD ਡੇਟਾ ਕਿਸਮ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।
sstatic ObjectEntryDataType uintToObjectEntryDataType (uint16_t objectDataType)

objectEntryDataTypeToString () OD ਡੇਟਾ ਕਿਸਮ ਨੂੰ ਸਤਰ ਵਿੱਚ ਬਦਲਦਾ ਹੈ।
ਸਥਿਰ std::string objectEntryDataTypeToString (ObjectEntryDataType odDataType)

stringToObjectEntryDatatype () ਜੇਕਰ ਸੰਭਵ ਹੋਵੇ ਤਾਂ ਸਟ੍ਰਿੰਗ ਨੂੰ OD ਡਾਟਾ ਕਿਸਮ ਵਿੱਚ ਬਦਲਦਾ ਹੈ। ਨਹੀਂ ਤਾਂ, UNKNOWN_DATATYPE ਵਾਪਸ ਕਰਦਾ ਹੈ।
ਸਥਿਰ ObjectEntryDataType stringToObjectEntryDatatype (std::string dataTypeString)

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

objectEntryDataTypeBitLength () ਕਿਸੇ ਵਸਤੂ ਐਂਟਰੀ ਡੇਟਾ ਕਿਸਮ ਦੀ ਬਿੱਟ ਲੰਬਾਈ ਬਾਰੇ ਸੂਚਿਤ ਕਰਦਾ ਹੈ।
ਸਥਿਰ uint32_t objectEntryDataTypeBitLength (ObjectEntryDataType const & dataType)

8.25 RESTfulBus ਢਾਂਚਾ

ਇਸ ਢਾਂਚੇ ਵਿੱਚ RESTful ਇੰਟਰਫੇਸ (ਈਥਰਨੈੱਟ ਉੱਤੇ) ਲਈ ਸੰਚਾਰ ਸੰਰਚਨਾ ਵਿਕਲਪ ਸ਼ਾਮਲ ਹਨ। ਇਸ ਵਿੱਚ ਹੇਠ ਲਿਖੀਆਂ ਜਨਤਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਸ਼ਾਮਲ ਹਨ:

const std:: string const unsigned long const std:: string const unsigned long const std:: string const unsigned long

CONNECT_TIMEOUT_OPTION_NAME = “RESTful Connect timeout” DEFAULT_CONNECT_TIMEOUT = 200 REQUEST_TIMEOUT_OPTION_NAME = “RESTful ਬੇਨਤੀ ਦਾ ਸਮਾਂ ਸਮਾਪਤ” DEFAULT_REQUEST_TIMEOUT = 200 RESPONSE_TIMEOUT_OPTION_NAME = RESPONSE_TIMEOUT_OPTION_NAME RESTਪੂਰੀ ਜਵਾਬ 750

8.26 ProfinetDCP
Linux ਦੇ ਅਧੀਨ, ਕਾਲਿੰਗ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ CAP_NET_ADMIN ਅਤੇ CAP_NET_RAW ਸਮਰੱਥਾਵਾਂ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ। ਸਮਰੱਥ ਕਰਨ ਲਈ: sudo setcap 'cap_net_admin,cap_net_raw+eip' ./executable. ਵਿੰਡੋਜ਼ ਵਿੱਚ, ProfinetDCP ਇੰਟਰਫੇਸ WinPcap (ਵਰਜਨ 4.1.3 ਨਾਲ ਟੈਸਟ ਕੀਤਾ ਗਿਆ) ਜਾਂ Npcap (ਵਰਜਨ 1.60 ਅਤੇ 1.30 ਨਾਲ ਟੈਸਟ ਕੀਤਾ ਗਿਆ) ਦੀ ਵਰਤੋਂ ਕਰਦਾ ਹੈ। ਇਸ ਤਰ੍ਹਾਂ ਇਹ ਡਾਇਨਾਮਿਕ ਤੌਰ 'ਤੇ ਲੋਡ ਕੀਤੀ wpcap.dll ਲਾਇਬ੍ਰੇਰੀ ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਕ੍ਰਮ ਵਿੱਚ ਖੋਜਦਾ ਹੈ (ਨੋਟ: ਕੋਈ ਮੌਜੂਦਾ Win10Pcap ਸਮਰਥਨ ਨਹੀਂ):
1. Nanolib.dll ਡਾਇਰੈਕਟਰੀ 2. ਵਿੰਡੋਜ਼ ਸਿਸਟਮ ਡਾਇਰੈਕਟਰੀ SystemRoot%System32 3. Npcap ਇੰਸਟਾਲੇਸ਼ਨ ਡਾਇਰੈਕਟਰੀ SystemRoot%System32Npcap 4. ਵਾਤਾਵਰਣ ਮਾਰਗ
ਇਹ ਕਲਾਸ ਇੱਕ ਪ੍ਰੋਫਾਈਨੇਟ ਡੀਸੀਪੀ ਇੰਟਰਫੇਸ ਨੂੰ ਦਰਸਾਉਂਦੀ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:

getScanTimeout () ਇੱਕ ਡਿਵਾਈਸ ਸਕੈਨ ਟਾਈਮਆਊਟ (ਡਿਫਾਲਟ = 2000 ms) ਬਾਰੇ ਸੂਚਿਤ ਕਰਦਾ ਹੈ।
ਵਰਚੁਅਲ uint32_t nlc::ProfinetDCP::getScanTimeout () const

setScanTimeout () ਇੱਕ ਡਿਵਾਈਸ ਸਕੈਨ ਟਾਈਮਆਉਟ ਸੈੱਟ ਕਰਦਾ ਹੈ (ਡਿਫਾਲਟ = 2000 ms)।
virtual void nlc::setScanTimeout (uint32_t timeoutMsec)

getResponseTimeout () ਸੈੱਟਅੱਪ, ਰੀਸੈਟ ਅਤੇ ਬਲਿੰਕ ਓਪਰੇਸ਼ਨਾਂ (ਡਿਫਾਲਟ = 1000 ms) ਲਈ ਇੱਕ ਡਿਵਾਈਸ ਜਵਾਬ ਸਮਾਂ ਸਮਾਪਤ ਹੋਣ ਬਾਰੇ ਸੂਚਿਤ ਕਰਦਾ ਹੈ।
ਵਰਚੁਅਲ uint32_t nlc::ProfinetDCP::getResponseTimeout () const

setResponseTimeout () ਸੈੱਟਅੱਪ, ਰੀਸੈਟ ਅਤੇ ਬਲਿੰਕ ਓਪਰੇਸ਼ਨ (ਡਿਫਾਲਟ = 1000 ms) ਲਈ ਇੱਕ ਡਿਵਾਈਸ ਜਵਾਬ ਸਮਾਂ ਸਮਾਪਤ ਹੋਣ ਬਾਰੇ ਸੂਚਿਤ ਕਰਦਾ ਹੈ।
virtual void nlc::ProfinetDCP::setResponseTimeout (uint32_t timeoutMsec)

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

isServiceAvailable ()
Profinet DCP ਸੇਵਾ ਉਪਲਬਧਤਾ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਨੈੱਟਵਰਕ ਅਡਾਪਟਰ ਵੈਧਤਾ / ਉਪਲਬਧਤਾ ਵਿੰਡੋਜ਼: WinPcap / Npcap ਉਪਲਬਧਤਾ Linux: CAP_NET_ADMIN / CAP_NET_RAW ਸਮਰੱਥਾਵਾਂ
virtual ResultVoid nlc::ProfinetDCP::isServiceAvailable (const BusHardwareId & busHardwareId)

ਪੈਰਾਮੀਟਰ BusHardwareId ਸਹੀ ਦਿੰਦਾ ਹੈ
ਝੂਠਾ

ਜਾਂਚ ਕਰਨ ਲਈ ਪ੍ਰੋਫਾਈਨੇਟ ਡੀਸੀਪੀ ਸੇਵਾ ਦੀ ਹਾਰਡਵੇਅਰ ਆਈ.ਡੀ. ਸੇਵਾ ਉਪਲਬਧ ਹੈ। ਸੇਵਾ ਉਪਲਬਧ ਨਹੀਂ ਹੈ।

scanProfinetDevices () Profinet ਡਿਵਾਈਸਾਂ ਦੀ ਮੌਜੂਦਗੀ ਲਈ ਹਾਰਡਵੇਅਰ ਬੱਸ ਨੂੰ ਸਕੈਨ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਵਰਚੁਅਲ ਰਿਜ਼ਲਟਪ੍ਰੋਫਾਈਨੇਟ ਡਿਵਾਇਸ ਸਕੈਨ ਪ੍ਰੋਫਾਈਨਟ ਡਿਵਾਇਸ (const BusHardwareId ਅਤੇ busHardwareId)

ਪੈਰਾਮੀਟਰ BusHardwareId ResultProfinetDevices ਦਿੰਦਾ ਹੈ

ਖੋਲ੍ਹਣ ਲਈ ਹਰੇਕ ਫੀਲਡਬੱਸ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ। ਹਾਰਡਵੇਅਰ ਖੁੱਲ੍ਹਾ ਹੈ।

setupProfinetDevice () ਹੇਠ ਲਿਖੀਆਂ ਡਿਵਾਈਸ ਸੈਟਿੰਗਾਂ ਨੂੰ ਸਥਾਪਿਤ ਕਰਦਾ ਹੈ:

ਡਿਵਾਈਸ ਦਾ ਨਾਮ

IP ਪਤਾ

ਨੈੱਟਵਰਕ ਮਾਸਕ

ਡਿਫੌਲਟ ਗੇਟਵੇ

virtual ResultVoid nlc::setupProfinetDevice (const BusHardwareId & busHardwareId, const ProfinetDevice struct & profinetDevice, bool savePermanent)

resetProfinetDevice () ਡਿਵਾਈਸ ਨੂੰ ਰੋਕਦਾ ਹੈ ਅਤੇ ਇਸਨੂੰ ਫੈਕਟਰੀ ਡਿਫੌਲਟ ਤੇ ਰੀਸੈਟ ਕਰਦਾ ਹੈ।
virtual ResultVoid nlc::resetProfinetDevice (const BusHardwareId & busHardwareId, const ProfinetDevice & profinetDevice)

blinkProfinetDevice () Profinet ਡਿਵਾਈਸ ਨੂੰ ਇਸਦੇ Profinet LED ਨੂੰ ਬਲਿੰਕ ਕਰਨਾ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਹੁਕਮ ਦਿੰਦਾ ਹੈ।
virtual ResultVoid nlc::blinkProfinetDevice (const BusHardwareId & busHardwareId, const ProfinetDevice &profinetDevice)

validateProfinetDeviceIp () ਡਿਵਾਈਸ ਦੇ IP ਐਡਰੈੱਸ ਦੀ ਜਾਂਚ ਕਰਨ ਲਈ ਇਸ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਵਰਚੁਅਲ ਨਤੀਜਾVoid ਪ੍ਰਮਾਣਿਤਪ੍ਰੋਫਾਈਨਟਡਿਵਾਈਸਆਈਪੀ (const BusHardwareId &busHardwareId, const ProfinetDevice & profinetDevice)

ਪੈਰਾਮੀਟਰ BusHardwareId ProfinetDevice

ਜਾਂਚ ਕਰਨ ਲਈ ਹਾਰਡਵੇਅਰ ਆਈ.ਡੀ. ਪ੍ਰਮਾਣਿਤ ਕਰਨ ਲਈ ਪ੍ਰੋਫਾਈਨਟ ਡਿਵਾਈਸ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦਾ ਹੈ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ResultVoid ਦਿੰਦਾ ਹੈ

8.27 ProfinetDevice struct

Profinet ਡਿਵਾਈਸ ਡੇਟਾ ਵਿੱਚ ਹੇਠ ਲਿਖੀਆਂ ਜਨਤਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਹਨ:

std::string std::string std::array< uint8_t, 6 > uint32_t uint32_t uint32_t

deviceName deviceVendor macAddress ipAddress netMask defaultGateway

MAC ਐਡਰੈੱਸ ਨੂੰ ਐਰੇ ਦੇ ਰੂਪ ਵਿੱਚ ਦਿੱਤਾ ਗਿਆ ਹੈ macAddress = {xx, xx, xx, xx, xx, xx}; ਜਦੋਂ ਕਿ IP ਐਡਰੈੱਸ, ਨੈੱਟਵਰਕ ਮਾਸਕ ਅਤੇ ਗੇਟਵੇ ਸਭ ਨੂੰ ਵੱਡੇ ਐਂਡੀਅਨ ਹੈਕਸ ਨੰਬਰਾਂ ਵਜੋਂ ਸਮਝਿਆ ਜਾਂਦਾ ਹੈ, ਜਿਵੇਂ ਕਿ:

IP ਪਤਾ: 192.168.0.2 ਨੈੱਟਵਰਕ ਮਾਸਕ: 255.255.0.0 ਗੇਟਵੇ: 192.168.0.1

0xC0A80002 0xFFFF0000 0xC0A80001

8.28 ਨਤੀਜਾ ਕਲਾਸਾਂ

ਇਹਨਾਂ ਕਲਾਸਾਂ ਦੇ "ਵਿਕਲਪਿਕ" ਵਾਪਸੀ ਮੁੱਲਾਂ ਦੀ ਵਰਤੋਂ ਇਹ ਦੇਖਣ ਲਈ ਕਰੋ ਕਿ ਕੀ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਸੀ ਜਾਂ ਨਹੀਂ, ਅਤੇ ਅਸਫਲ ਹੋਣ ਦੇ ਕਾਰਨਾਂ ਦਾ ਪਤਾ ਲਗਾਓ। ਸਫਲਤਾ 'ਤੇ, hasError () ਫੰਕਸ਼ਨ ਗਲਤ ਵਾਪਸ ਕਰਦਾ ਹੈ। getResult () ਦੁਆਰਾ, ਤੁਸੀਂ ਕਿਸਮ ਦੇ ਅਨੁਸਾਰ ਨਤੀਜਾ ਮੁੱਲ ਪੜ੍ਹ ਸਕਦੇ ਹੋ (ਰਿਜ਼ਲਟਇੰਟ ਆਦਿ)। ਜੇਕਰ ਇੱਕ ਕਾਲ ਅਸਫਲ ਹੋ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਤੁਸੀਂ getError () ਦੁਆਰਾ ਕਾਰਨ ਪੜ੍ਹਦੇ ਹੋ।

ਸੁਰੱਖਿਅਤ ਗੁਣ

ਸਤਰ NlcErrorCode uint32_t

errorString errorCode exErrorCode

ਨਾਲ ਹੀ, ਇਸ ਕਲਾਸ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:

hasError () ਫੰਕਸ਼ਨ ਕਾਲ ਦੀ ਸਫਲਤਾ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ।
bool nlc::ਨਤੀਜਾ::hasError () const

ਵਾਪਸੀ

ਸੱਚ ਝੂਠ

ਅਸਫਲ ਕਾਲ। ਮੁੱਲ ਨੂੰ ਪੜ੍ਹਨ ਲਈ getError () ਦੀ ਵਰਤੋਂ ਕਰੋ। ਸਫਲ ਕਾਲ। ਮੁੱਲ ਨੂੰ ਪੜ੍ਹਨ ਲਈ getResult () ਦੀ ਵਰਤੋਂ ਕਰੋ।

getError () ਕਾਰਨ ਪੜ੍ਹਦਾ ਹੈ ਜੇਕਰ ਕੋਈ ਫੰਕਸ਼ਨ ਕਾਲ ਫੇਲ ਹੋ ਜਾਂਦੀ ਹੈ।
const std::string nlc:: ਨਤੀਜਾ::getError () const

const ਸਤਰ ਵਾਪਸ ਕਰਦਾ ਹੈ

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ
ਨਤੀਜਾ () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਨਤੀਜਿਆਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ:
ਨਤੀਜਾ (std::string const & errorString_)
ਨਤੀਜਾ (NlcErrorCode const & errCode, std::string const & errorString_)
ਨਤੀਜਾ (NlcErrorCode const & errCode, const uint32_t exErrCode, std::string const & errorString_)
ਨਤੀਜਾ (ਨਤੀਜਾ ਸਿੱਟਾ ਅਤੇ ਨਤੀਜਾ)
getErrorCode () NlcErrorCode ਪੜ੍ਹੋ।
NlcErrorCode getErrorCode () const
getExErrorCode () uint32_t getExErrorCode () const
੬.੨੬.੧ ਪਰਿਣਾਮ੍
NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ ਜੇਕਰ ਫੰਕਸ਼ਨ void ਵਾਪਸ ਕਰਦਾ ਹੈ। ਕਲਾਸ ਨੂੰ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ ਅਤੇ ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਸਦੇ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹੁੰਦੇ ਹਨ:
ResultVoid () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਵਿਅਰਥ ਨਤੀਜੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ:
ResultVoid (std::string const &errorString_)
ResultVoid (NlcErrorCode const & errCode, std::string const & errorString_)
ResultVoid (NlcErrorCode const & errCode, const uint32_t exErrCode, std:: string const & errorString_)
ResultVoid (ਨਤੀਜਾ ਕੰਸਟ ਅਤੇ ਨਤੀਜਾ)
੬.੨੬.੨ ਪਰਿਣਾਮ੍
NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ ਜੇਕਰ ਫੰਕਸ਼ਨ ਇੱਕ ਪੂਰਨ ਅੰਕ ਦਿੰਦਾ ਹੈ। ਕਲਾਸ ਨੂੰ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ / ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:
getResult () ਜੇਕਰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ ਤਾਂ ਪੂਰਨ ਅੰਕ ਨਤੀਜਾ ਦਿੰਦਾ ਹੈ।
int64_t getResult () const
int64_t ਵਾਪਸ ਕਰਦਾ ਹੈ

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ
ResultInt () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਪੂਰਨ ਅੰਕ ਨਤੀਜੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ:
ResultInt (int64_t ਨਤੀਜਾ_)
ResultInt (std::string const & errorString_)
ResultInt (NlcErrorCode const & errCode, std::string const & errorString_)
ResultInt (NlcErrorCode const & errCode, const uint32_t exErrCode, std::string const & errorString_)
ResultInt (ਨਤੀਜਾ ਕੰਸਟ ਅਤੇ ਨਤੀਜਾ)
੬.੨੬.੩ ਪਰਿਣਾਮ੍
NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ ਜੇਕਰ ਫੰਕਸ਼ਨ ਇੱਕ ਸਤਰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਕਲਾਸ ਨੂੰ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ / ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਸਦੇ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹੁੰਦੇ ਹਨ:
getResult () ਸਟਰਿੰਗ ਨਤੀਜਾ ਪੜ੍ਹਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ।
const std::string nlc::ResultString::getResult () const
const ਸਤਰ ਵਾਪਸ ਕਰਦਾ ਹੈ
ResultString () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਸਤਰ ਨਤੀਜੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ:
ResultString (std::string const & message, bool hasError_)
ResultString (NlcErrorCode const & errCode, std::string const & errorString_)
ResultString (NlcErrorCode const & errCode, const uint32_t exErrCode, std:: string const & errorString_)
ResultString (ਨਤੀਜਾ ਕੰਸਟ ਅਤੇ ਨਤੀਜਾ)
8.28.4 ਨਤੀਜਾ ਐਰੇਬਾਈਟ
NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ ਜੇਕਰ ਫੰਕਸ਼ਨ ਇੱਕ ਬਾਈਟ ਐਰੇ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਕਲਾਸ ਨੂੰ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ / ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:
getResult () ਬਾਈਟ ਵੈਕਟਰ ਪੜ੍ਹਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ।
const std::vector nlc::ResultArrayByte::getResult () const
ਕੰਸਟ ਵੈਕਟਰ ਦਿੰਦਾ ਹੈ

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ
ResultArrayByte () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਬਾਈਟ ਐਰੇ ਨਤੀਜੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ:
ResultArrayByte (std::vector const ਅਤੇ ਨਤੀਜਾ_)
ResultArrayByte (std::string const & errorString_)
ResultArrayByte (NlcErrorCode const & errCode, std::string const & error String_)
ResultArrayByte (NlcErrorCode const & errCode, const uint32_t exErrCode, std:: string const & errorString_)
ResultArrayByte (ਨਤੀਜਾ ਕੰਸਟ ਅਤੇ ਨਤੀਜਾ)
੬.੨੬.੫ ਪਰਿਣਾਮਃ
NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ ਜੇਕਰ ਫੰਕਸ਼ਨ ਇੱਕ ਪੂਰਨ ਅੰਕ ਐਰੇ ਦਿੰਦਾ ਹੈ। ਕਲਾਸ ਨੂੰ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ / ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਸਦੇ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹੁੰਦੇ ਹਨ:
getResult () ਪੂਰਨ ਅੰਕ ਵੈਕਟਰ ਪੜ੍ਹਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ।
const std::vector nlc::ResultArrayInt::getResult () const
ਕੰਸਟ ਵੈਕਟਰ ਦਿੰਦਾ ਹੈ
ResultArrayInt () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਪੂਰਨ ਅੰਕ ਐਰੇ ਨਤੀਜੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ:
ResultArrayInt (std::vector const ਅਤੇ ਨਤੀਜਾ_)
ResultArrayInt (std::string const & errorString_)
ResultArrayInt (NlcErrorCode const & errCode, std::string const & error String_)
ResultArrayInt (NlcErrorCode const & errCode, const uint32_t exErrCode, std:: string const & errorString_)
ResultArrayInt (ਨਤੀਜਾ ਕੰਸਟ ਅਤੇ ਨਤੀਜਾ)
੬.੨੬.੬ ਪਰਿਣਾਮਬੁਸ਼ਹ੍ਵਇਡਸ
ਜੇਕਰ ਫੰਕਸ਼ਨ ਬੱਸ ਹਾਰਡਵੇਅਰ ID ਐਰੇ ਵਾਪਸ ਕਰਦਾ ਹੈ ਤਾਂ NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ। ਕਲਾਸ ਨੂੰ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ / ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:
getResult () ਬੱਸ-ਹਾਰਡਵੇਅਰ-ਆਈਡੀ ਵੈਕਟਰ ਪੜ੍ਹਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ।
const std::vector nlc::ResultBusHwIds::getResult () const
ਪੈਰਾਮੀਟਰ const ਵੈਕਟਰ

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ
ResultBusHwIds () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਬੱਸ-ਹਾਰਡਵੇਅਰ-ਆਈਡੀ-ਐਰੇ ਨਤੀਜੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ:
ResultBusHwIds (std::vector const ਅਤੇ ਨਤੀਜਾ_)
ResultBusHwIds (std::string const & errorString_)
ResultBusHwIds (NlcErrorCode const & errCode, std::string const & errorString_)
ResultBusHwIds (NlcErrorCode const & errCode, const uint32_t exErrCode, std::string const & errorString_)
ResultBusHwIds (ਨਤੀਜਾ ਕੰਸਟ ਅਤੇ ਨਤੀਜਾ)
8.28.7 ਨਤੀਜਾ ਡਿਵਾਇਸ ਆਈ.ਡੀ
NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ ਜੇਕਰ ਫੰਕਸ਼ਨ ਇੱਕ ਡਿਵਾਈਸ ID ਦਿੰਦਾ ਹੈ। ਕਲਾਸ ਨੂੰ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ / ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:
getResult () ਡਿਵਾਈਸ ID ਵੈਕਟਰ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ।
DeviceId nlc::ResultDeviceId::getResult () const
ਕੰਸਟ ਵੈਕਟਰ ਦਿੰਦਾ ਹੈ
ResultDeviceId () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਡਿਵਾਈਸ ID ਨਤੀਜੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ:
ResultDeviceId (ਡਿਵਾਈਸ ਆਈਡੀ ਕੰਸਟ ਅਤੇ ਨਤੀਜਾ_)
ResultDeviceId (std::string const & errorString_)
ResultDeviceId (NlcErrorCode const & errCode, std::string const & errorString_)
ResultDeviceId (NlcErrorCode const & errCode, const uint32_t exErrCode, std::string errorString_)
ResultDeviceId (ਨਤੀਜਾ ਕੰਸਟ ਅਤੇ ਨਤੀਜਾ)
8.28.8 ਨਤੀਜਾ ਡਿਵਾਇਸ ਆਈਡਜ਼
NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ ਜੇਕਰ ਫੰਕਸ਼ਨ ਇੱਕ ਡਿਵਾਈਸ ID ਐਰੇ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਕਲਾਸ ਨੂੰ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ / ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:
getResult () ਡਿਵਾਈਸ ID ਵੈਕਟਰ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ।
DeviceId nlc::ResultDeviceIds::getResult () const
ਕੰਸਟ ਵੈਕਟਰ ਦਿੰਦਾ ਹੈ

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ
ResultDeviceIds () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਡਿਵਾਈਸ-ਆਈਡੀ-ਐਰੇ ਨਤੀਜੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ:
ResultDeviceIds (std::vector const ਅਤੇ ਨਤੀਜਾ_)
ResultDeviceIds (std::string const & errorString_)
ResultDeviceIds (NlcErrorCode const & errCode, std::string const & errorString_)
ResultDeviceIds (NlcErrorCode const & errCode, const uint32_t exErrCode, std::string const & errorString_)
ResultDeviceIds (ਨਤੀਜਾ ਕੰਸਟ ਅਤੇ ਨਤੀਜਾ)
8.28.9 ਨਤੀਜਾ ਡਿਵਾਇਸ ਹੈਂਡਲ
NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ ਜੇਕਰ ਫੰਕਸ਼ਨ ਇੱਕ ਡਿਵਾਈਸ ਹੈਂਡਲ ਦਾ ਮੁੱਲ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਕਲਾਸ ਨੂੰ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ / ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਸਦੇ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹੁੰਦੇ ਹਨ:
getResult () ਡਿਵਾਈਸ ਹੈਂਡਲ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ।
DeviceHandle nlc::ResultDeviceHandle::getResult () const
ਡਿਵਾਈਸ ਹੈਂਡਲ ਵਾਪਸ ਕਰਦਾ ਹੈ
ResultDeviceHandle () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਡਿਵਾਈਸ ਹੈਂਡਲ ਨਤੀਜੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ:
ResultDeviceHandle (ਡਿਵਾਈਸਹੈਂਡਲ ਕੰਸਟ ਅਤੇ ਨਤੀਜਾ_)
ResultDeviceHandle (std::string const & errorString_)
ResultDeviceHandle (NlcErrorCode const & errCode, std::string const & errorString_)
ResultDeviceHandle (NlcErrorCode const & errCode, const uint32_t exErrCode, std::string const & errorString_)
ResultDeviceHandle (ਨਤੀਜਾ ਕੰਸਟ ਅਤੇ ਨਤੀਜਾ)
੬.੨੬.੧੦ ਨਤੀਜਾ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ
NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ ਜੇਕਰ ਫੰਕਸ਼ਨ ਇੱਕ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਦੀ ਸਮੱਗਰੀ ਨੂੰ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਕਲਾਸ ਨੂੰ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ / ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:
getResult () ਡਿਵਾਈਸ ID ਵੈਕਟਰ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ।
const nlc::ObjectDictionary & nlc::ResultObjectDictionary::getResult () const

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ਵਾਪਸੀ

const ਵੈਕਟਰ

ResultObjectDictionary () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਨਤੀਜੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ:
ResultObjectDictionary (nlc::ObjectDictionary const & result_)

ResultObjectDictionary (std::string const & errorString_)

ResultObjectDictionary (NlcErrorCode const & errCode, std::string const & errorString_)

ResultObjectDictionary (NlcErrorCode const & errCode, const uint32_t exErrCode, std::string const & errorString_)

ResultObjectDictionary (ਨਤੀਜਾ ਕੰਸਟ ਅਤੇ ਨਤੀਜਾ)

੬.੨੬.੧੧ ਪਰਿਣਾਰ੍ਥਸਂਯੁਕ੍ਤਸ੍ਯ
NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ ਜੇਕਰ ਫੰਕਸ਼ਨ ਇੱਕ ਡਿਵਾਈਸ-ਕਨੈਕਸ਼ਨ-ਸਟੇਟ ਜਾਣਕਾਰੀ ਦਿੰਦਾ ਹੈ। ਕਲਾਸ ਨੂੰ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ / ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:
getResult () ਡਿਵਾਈਸ ਹੈਂਡਲ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ।
DeviceConnectionStateInfo nlc::ResultConnectionState::getResult () const

DeviceConnectionStateInfo ਕਨੈਕਟ / ਡਿਸਕਨੈਕਟ / ਕਨੈਕਟ ਕੀਤਾ ਬੂਟਲੋਡਰ ਵਾਪਸ ਕਰਦਾ ਹੈ

ResultConnectionState () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਕੁਨੈਕਸ਼ਨ ਸਥਿਤੀ ਦੇ ਨਤੀਜੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ:
ResultConnectionState (DeviceConnectionStateInfo const & result_)

ਨਤੀਜਾ ਕੁਨੈਕਸ਼ਨ ਸਟੇਟ (std::string const & errorString_)

ਨਤੀਜਾ ਕਨੈਕਸ਼ਨ ਸਟੇਟ (NlcErrorCode const & errCode, std::string const & errorString_)

ਨਤੀਜਾ ਕਨੈਕਸ਼ਨ ਸਟੇਟ (NlcErrorCode const & errCode, const uint32_t exErrCode, std::string const & errorString_)

ResultConnectionState (ਨਤੀਜਾ ਕੰਸਟ ਅਤੇ ਨਤੀਜਾ)

8.28.12 ਨਤੀਜਾ ਆਬਜੈਕਟ ਐਂਟਰੀ
NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ ਜੇਕਰ ਫੰਕਸ਼ਨ ਇੱਕ ਆਬਜੈਕਟ ਐਂਟਰੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਕਲਾਸ ਨੂੰ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ / ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ
getResult () ਡਿਵਾਈਸ ID ਵੈਕਟਰ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ।
nlc::ObjectEntry const&nlc::ResultObjectEntry::getResult () const
const ObjectEntry ਵਾਪਸ ਕਰਦਾ ਹੈ
ResultObjectEntry () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਆਬਜੈਕਟ ਐਂਟਰੀ ਨਤੀਜੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ:
ResultObjectEntry (nlc::ObjectEntry const & result_)
ResultObjectEntry (std::string const & errorString_)
ResultObjectEntry (NlcErrorCode const & errCode, std::string const & errorString_)
ResultObjectEntry (NlcErrorCode const & errCode, const uint32_t exErrCode, std::string const & errorString_)
ResultObjectEntry (ਨਤੀਜਾ ਕੰਸਟ ਅਤੇ ਨਤੀਜਾ)
8.28.13 ਨਤੀਜਾ ਆਬਜੈਕਟ ਸਬ-ਐਂਟਰੀ
NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ ਜੇਕਰ ਫੰਕਸ਼ਨ ਇੱਕ ਆਬਜੈਕਟ ਸਬ-ਐਂਟਰੀ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਕਲਾਸ ਨੂੰ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ / ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:
getResult () ਡਿਵਾਈਸ ID ਵੈਕਟਰ ਵਾਪਸ ਕਰਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ।
nlc::ObjectSubEntry const & nlc::ResultObjectSubEntry::getResult () const
const ObjectSubEntry ਵਾਪਸ ਕਰਦਾ ਹੈ
ResultObjectSubEntry () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਆਬਜੈਕਟ ਸਬ-ਐਂਟਰੀ ਨਤੀਜੇ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ:
ResultObjectSubEntry (nlc::ObjectEntry const & result_)
ResultObjectSubEntry (std::string const & errorString_)
ResultObjectSubEntry (NlcErrorCode const & errCode, std::string const & errorString_)
ResultObjectSubEntry (NlcErrorCode const & errCode, const uint32_t exErrCode, std::string const & errorString_)
ResultObjectSubEntry (ਨਤੀਜਾ ਕੰਸਟ ਅਤੇ ਨਤੀਜਾ)
8.28.14 ਨਤੀਜਾਪ੍ਰੋਫਾਈਨਟ ਡਿਵਾਈਸਿਸ
NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ ਜੇਕਰ ਫੰਕਸ਼ਨ ਇੱਕ ਪ੍ਰੋਫਾਈਨਟ ਡਿਵਾਈਸ ਵਾਪਸ ਕਰਦਾ ਹੈ। ਕਲਾਸ ਨੂੰ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ / ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਸਦੇ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹੁੰਦੇ ਹਨ:

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

getResult () Profinet ਡਿਵਾਈਸ ਵੈਕਟਰ ਨੂੰ ਪੜ੍ਹਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ।
const std::vector & getResult () const

ResultProfinetDevices () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਪ੍ਰੋਫਾਈਨੇਟ ਡਿਵਾਈਸਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ।
ResultProfinetDevices (const std::vector & profinetDevices)
ResultProfinetDevices (const ਨਤੀਜਾ ਅਤੇ ਨਤੀਜਾ)
ResultProfinetDevices (const std::string &errorText, NlcErrorCode errorCode = NlcErrorCode::GeneralError, uint32_t extendedErrorCode = 0)
੬.੨੬.੧੫ ਨਤੀਜੇampleDataArray
NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ ਜੇਕਰ ਫੰਕਸ਼ਨ ਇਸ ਤਰ੍ਹਾਂ ਵਾਪਸ ਆਉਂਦਾ ਹੈample ਡਾਟਾ ਐਰੇ. ਕਲਾਸ ਨੂੰ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ / ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਪ੍ਰਾਪਤ ਹੁੰਦੀਆਂ ਹਨ ਅਤੇ ਇਸਦੇ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹੁੰਦੇ ਹਨ:
getResult () ਡਾਟਾ ਐਰੇ ਪੜ੍ਹਦਾ ਹੈ ਜੇਕਰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ।
const std::vector <SampleData> ਅਤੇ getResult () const

ਨਤੀਜੇampleDataArray () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ ਪ੍ਰੋਫਾਈਨੈਟ ਡਿਵਾਈਸਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨ।
ਨਤੀਜੇampleDataArray (const std::vector <SampleData> ਅਤੇ dataArray)

ਨਤੀਜੇampleDataArray (const std::string &errorDesc, const NlcErrorCode errorCode = NlcErrorCode::GeneralError, const uint32_t extendedErrorCode = 0)

ਨਤੀਜੇampleDataArray (const ResultSampleDataArray ਅਤੇ ਹੋਰ)

ਨਤੀਜੇampleDataArray (const ਨਤੀਜਾ ਅਤੇ ਨਤੀਜਾ)

੬.੨੬.੧੫ ਨਤੀਜੇamplerState
NanoLib ਤੁਹਾਨੂੰ ਇਸ ਕਲਾਸ ਦੀ ਇੱਕ ਉਦਾਹਰਣ ਭੇਜਦਾ ਹੈ ਜੇਕਰ ਫੰਕਸ਼ਨ ਇਸ ਤਰ੍ਹਾਂ ਵਾਪਸ ਆਉਂਦਾ ਹੈampler state.ਇਹ ਕਲਾਸ ਨਤੀਜਾ ਕਲਾਸ ਤੋਂ ਜਨਤਕ ਫੰਕਸ਼ਨਾਂ/ਸੁਰੱਖਿਅਤ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਵਿਰਾਸਤ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈ ਅਤੇ ਇਸ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:

getResult () s ਨੂੰ ਪੜ੍ਹਦਾ ਹੈampler ਸਟੇਟ ਵੈਕਟਰ ਜੇਕਰ ਇੱਕ ਫੰਕਸ਼ਨ ਕਾਲ ਸਫਲ ਹੁੰਦੀ ਹੈ।
SamplerState getResult () const

ਰਿਟਰਨ ਐੱਸamplerState>

ਅਸੰਰਚਿਤ / ਸੰਰਚਿਤ / ਤਿਆਰ / ਚੱਲ ਰਿਹਾ / ਪੂਰਾ / ਅਸਫਲ / ਰੱਦ

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ਨਤੀਜੇamplerState () ਨਿਮਨਲਿਖਤ ਫੰਕਸ਼ਨ ਸਹੀ s ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨ ਵਿੱਚ ਸਹਾਇਤਾ ਕਰਦੇ ਹਨampler ਰਾਜ.
ਨਤੀਜੇamplerState (const Samplerਰਾਜ ਰਾਜ)

ਨਤੀਜੇamplerState (const std::string & errorDesc, const NlcErrorCode errorCode = NlcErrorCode::GeneralError, const uint32_t
ਵਿਸਤ੍ਰਿਤ ਐਰਰ ਕੋਡ = 0)

ਨਤੀਜੇamplerState (const ResultSampਰਾਜ ਅਤੇ ਹੋਰ)

ਨਤੀਜੇamplerState (const ਨਤੀਜਾ ਅਤੇ ਨਤੀਜਾ)

8.29 NlcErrorCode

ਜੇਕਰ ਕੁਝ ਗਲਤ ਹੋ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਨਤੀਜਾ ਕਲਾਸਾਂ ਇਸ ਗਣਨਾ ਵਿੱਚ ਸੂਚੀਬੱਧ ਗਲਤੀ ਕੋਡਾਂ ਵਿੱਚੋਂ ਇੱਕ ਦੀ ਰਿਪੋਰਟ ਕਰਦੀਆਂ ਹਨ।

ਗਲਤੀ ਕੋਡ ਸਫਲਤਾ ਜਨਰਲ ਐਰਰ ਬੱਸ ਅਣਉਪਲਬਧ ਸੰਚਾਰ ਐਰਰ ਪ੍ਰੋਟੋਕੋਲ ਐਰਰ
ODDoesNotExist ODInvalidAccess ODTypeMismatch OperationAborted OperationNotSupported InvalidOperation
InvalidArguments Access Denied ResourceNotFound ResourceUnavailable OutOfMemory TimeOutError

C: ਸ਼੍ਰੇਣੀ D: ਵਰਣਨ R: ਕਾਰਨ C: ਕੋਈ ਨਹੀਂ। D: ਕੋਈ ਗਲਤੀ ਨਹੀਂ। R: ਓਪਰੇਸ਼ਨ ਸਫਲਤਾਪੂਰਵਕ ਪੂਰਾ ਹੋਇਆ।
C: ਅਨਿਸ਼ਚਿਤ। D: ਅਨਿਸ਼ਚਿਤ ਗਲਤੀ। R: ਅਸਫਲਤਾ ਜੋ ਕਿਸੇ ਹੋਰ ਸ਼੍ਰੇਣੀ ਵਿੱਚ ਫਿੱਟ ਨਹੀਂ ਬੈਠਦੀ।
ਸੀ: ਬੱਸ। D: ਹਾਰਡਵੇਅਰ ਬੱਸ ਉਪਲਬਧ ਨਹੀਂ ਹੈ। R: ਬੱਸ ਮੌਜੂਦ ਨਹੀਂ, ਕੱਟ-ਆਫ ਜਾਂ ਨੁਕਸ।
C: ਸੰਚਾਰ। D: ਸੰਚਾਰ ਭਰੋਸੇਯੋਗ ਨਹੀਂ ਹੈ। R: ਅਚਾਨਕ ਡਾਟਾ, ਗਲਤ CRC, ਫਰੇਮ ਜਾਂ ਸਮਾਨਤਾ ਦੀਆਂ ਗਲਤੀਆਂ, ਆਦਿ।
C: ਪ੍ਰੋਟੋਕੋਲ। D: ਪ੍ਰੋਟੋਕੋਲ ਗਲਤੀ। R: ਅਸਮਰਥਿਤ ਪ੍ਰੋਟੋਕੋਲ ਵਿਕਲਪ ਤੋਂ ਬਾਅਦ ਜਵਾਬ, ਡਿਵਾਈਸ ਰਿਪੋਰਟ ਅਸਮਰਥਿਤ ਪ੍ਰੋਟੋਕੋਲ, ਪ੍ਰੋਟੋਕੋਲ ਵਿੱਚ ਗਲਤੀ (ਕਹੋ, SDO ਸੈਗਮੈਂਟ ਸਿੰਕ ਬਿੱਟ), ਆਦਿ। ਸੈਗਮੈਂਟ ਸਿੰਕ ਬਿੱਟ), ਆਦਿ।
C: ਵਸਤੂ ਸ਼ਬਦਕੋਸ਼। D: OD ਪਤਾ ਮੌਜੂਦ ਨਹੀਂ ਹੈ। R: ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਵਿੱਚ ਅਜਿਹਾ ਕੋਈ ਪਤਾ ਨਹੀਂ ਹੈ।
C: ਵਸਤੂ ਸ਼ਬਦਕੋਸ਼। D: OD ਪਤੇ ਤੱਕ ਪਹੁੰਚ ਅਵੈਧ ਹੈ। R: ਸਿਰਫ਼-ਪੜ੍ਹਨ ਲਈ, ਜਾਂ ਸਿਰਫ਼-ਲਿਖਣ ਲਈ, ਪਤੇ ਤੋਂ ਪੜ੍ਹਨ ਦੀ ਕੋਸ਼ਿਸ਼ ਕਰੋ।
C: ਵਸਤੂ ਸ਼ਬਦਕੋਸ਼। D: ਟਾਈਪ ਬੇਮੇਲ। R: ਇੱਕ ਸਟ੍ਰਿੰਗ ਨੂੰ ਇੱਕ ਨੰਬਰ ਦੇ ਤੌਰ 'ਤੇ ਮੰਨਣ ਦੀ ਕੋਸ਼ਿਸ਼ ਵਿੱਚ, ਖਾਸ ਕਿਸਮ ਵਿੱਚ ਬਦਲਿਆ ਨਹੀਂ ਗਿਆ ਮੁੱਲ।
C: ਐਪਲੀਕੇਸ਼ਨ। D: ਪ੍ਰਕਿਰਿਆ ਰੱਦ ਕੀਤੀ ਗਈ। R: ਅਰਜ਼ੀ ਦੀ ਬੇਨਤੀ ਦੁਆਰਾ ਪ੍ਰਕਿਰਿਆ ਨੂੰ ਕੱਟਣਾ। ਕਾਲਬੈਕ ਫੰਕਸ਼ਨ ਦੁਆਰਾ ਸਿਰਫ ਓਪਰੇਸ਼ਨ ਇੰਟਰੱਪਟ 'ਤੇ ਵਾਪਸੀ, ਜਿਵੇਂ ਕਿ ਬੱਸ-ਸਕੈਨਿੰਗ ਤੋਂ।
C: ਆਮ। D: ਪ੍ਰਕਿਰਿਆ ਅਸਮਰਥਿਤ। R: ਕੋਈ ਹਾਰਡਵੇਅਰ ਬੱਸ / ਡਿਵਾਈਸ ਸਹਾਇਤਾ ਨਹੀਂ।
C: ਆਮ। D: ਮੌਜੂਦਾ ਸੰਦਰਭ ਵਿੱਚ ਪ੍ਰਕਿਰਿਆ ਗਲਤ ਹੈ, ਜਾਂ ਮੌਜੂਦਾ ਆਰਗੂਮੈਂਟ ਨਾਲ ਅਵੈਧ ਹੈ। R: ਪਹਿਲਾਂ ਤੋਂ ਜੁੜੀਆਂ ਬੱਸਾਂ/ਡਿਵਾਈਸਾਂ ਨੂੰ ਮੁੜ-ਕਨੈਕਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼। ਪਹਿਲਾਂ ਹੀ ਡਿਸਕਨੈਕਟ ਕੀਤੇ ਲੋਕਾਂ ਨੂੰ ਡਿਸਕਨੈਕਟ ਕਰਨ ਦੀ ਕੋਸ਼ਿਸ਼। ਫਰਮਵੇਅਰ ਮੋਡ ਵਿੱਚ ਇੱਕ ਬੂਟਲੋਡਰ ਕਾਰਵਾਈ ਦੀ ਕੋਸ਼ਿਸ਼ ਜਾਂ ਇਸਦੇ ਉਲਟ।
C: ਆਮ। D: ਆਰਗੂਮੈਂਟ ਅਵੈਧ। R: ਗਲਤ ਤਰਕ ਜਾਂ ਸੰਟੈਕਸ।
C: ਆਮ। D: ਪਹੁੰਚ ਤੋਂ ਇਨਕਾਰ ਕੀਤਾ ਗਿਆ ਹੈ। R: ਬੇਨਤੀ ਕੀਤੀ ਕਾਰਵਾਈ ਕਰਨ ਲਈ ਅਧਿਕਾਰਾਂ ਜਾਂ ਸਮਰੱਥਾਵਾਂ ਦੀ ਘਾਟ।
C: ਆਮ। D: ਨਿਰਧਾਰਤ ਆਈਟਮ ਨਹੀਂ ਮਿਲੀ। R: ਹਾਰਡਵੇਅਰ ਬੱਸ, ਪ੍ਰੋਟੋਕੋਲ, ਡਿਵਾਈਸ, ਡਿਵਾਈਸ 'ਤੇ OD ਪਤਾ, ਜਾਂ file ਨਹੀਂ ਮਿਲਿਆ।
C: ਆਮ। D: ਨਿਰਧਾਰਤ ਆਈਟਮ ਨਹੀਂ ਮਿਲੀ। R: ਵਿਅਸਤ, ਮੌਜੂਦ, ਕੱਟ-ਆਫ ਜਾਂ ਨੁਕਸ।
C: ਆਮ। D: ਨਾਕਾਫ਼ੀ ਮੈਮੋਰੀ। R: ਇਸ ਕਮਾਂਡ ਦੀ ਪ੍ਰਕਿਰਿਆ ਕਰਨ ਲਈ ਬਹੁਤ ਘੱਟ ਮੈਮੋਰੀ ਹੈ।
C: ਆਮ। D: ਪ੍ਰਕਿਰਿਆ ਦਾ ਸਮਾਂ ਸਮਾਪਤ ਹੋਇਆ। R: ਸਮਾਂ ਸਮਾਪਤ ਹੋਣ ਤੋਂ ਬਾਅਦ ਵਾਪਸੀ। ਸਮਾਂ ਸਮਾਪਤ ਇੱਕ ਡਿਵਾਈਸ ਪ੍ਰਤੀਕਿਰਿਆ ਸਮਾਂ, ਸਾਂਝਾ ਜਾਂ ਵਿਸ਼ੇਸ਼ ਸਰੋਤ ਪਹੁੰਚ ਪ੍ਰਾਪਤ ਕਰਨ ਦਾ ਸਮਾਂ, ਜਾਂ ਬੱਸ / ਡਿਵਾਈਸ ਨੂੰ ਇੱਕ ਢੁਕਵੀਂ ਸਥਿਤੀ ਵਿੱਚ ਬਦਲਣ ਦਾ ਸਮਾਂ ਹੋ ਸਕਦਾ ਹੈ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

8.30 ਐਨਐਲਸੀਕਾਲਬੈਕ
ਕਾਲਬੈਕ ਲਈ ਇਸ ਪੇਰੈਂਟ ਕਲਾਸ ਵਿੱਚ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ: ਕਾਲਬੈਕ ()
ਵਰਚੁਅਲ ਨਤੀਜਾ ਵਾਇਡ ਕਾਲਬੈਕ ()

ਵਾਪਸੀ

ਨਤੀਜਾVoid

8.31 NlcDataTransferCallback
ਡੇਟਾ ਟ੍ਰਾਂਸਫਰ (ਫਰਮਵੇਅਰ ਅੱਪਡੇਟ, ਨੈਨੋਜੇ ਅੱਪਲੋਡ ਆਦਿ) ਲਈ ਇਸ ਕਾਲਬੈਕ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰੋ। 1. ਇੱਕ ਫਰਮਵੇਅਰ ਅੱਪਲੋਡ ਲਈ: ਇੱਕ "ਸਹਿ-ਕਲਾਸ" ਨੂੰ ਇੱਕ ਕਸਟਮ ਕਾਲਬੈਕ ਵਿਧੀ ਨਾਲ ਵਧਾਓ
ਲਾਗੂ ਕਰਨਾ। 2. NanoLibAccessor.uploadFirmware () ਕਾਲਾਂ ਵਿੱਚ "ਸਹਿ-ਕਲਾਸ ਦੇ" ਉਦਾਹਰਨਾਂ ਦੀ ਵਰਤੋਂ ਕਰੋ। ਮੁੱਖ ਕਲਾਸ ਵਿੱਚ ਆਪਣੇ ਆਪ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ:

ਕਾਲਬੈਕ () ਵਰਚੁਅਲ ਨਤੀਜਾ ਵਾਇਡ ਕਾਲਬੈਕ (nlc::DataTransferInfo ਜਾਣਕਾਰੀ, int32_t ਡੇਟਾ)

ਵਾਪਸੀ

ਨਤੀਜਾVoid

8.32 NlcScanBusCallback
ਬੱਸ ਸਕੈਨਿੰਗ ਲਈ ਇਸ ਕਾਲਬੈਕ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰੋ। 1. ਇੱਕ "ਸਹਿ-ਕਲਾਸ" ਨੂੰ ਇੱਕ ਕਸਟਮ ਕਾਲਬੈਕ ਵਿਧੀ ਲਾਗੂ ਕਰਨ ਦੇ ਨਾਲ ਇਸ ਨੂੰ ਵਧਾਉਂਦੇ ਹੋਏ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ। 2. NanoLibAccessor.scanDevices () ਕਾਲਾਂ ਵਿੱਚ “ਸਹਿ-ਕਲਾਸ” ਦੀ ਵਰਤੋਂ ਕਰੋ। ਮੁੱਖ ਸ਼੍ਰੇਣੀ ਵਿੱਚ ਆਪਣੇ ਆਪ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ।

ਵਾਪਸ ਫੋਨ ਮਲਾਓ ()
ਵਰਚੁਅਲ ਨਤੀਜਾ ਵਾਇਡ ਕਾਲਬੈਕ (nlc::BusScanInfo ਜਾਣਕਾਰੀ, std::vector const & devicesFound, int32_t ਡੇਟਾ)

ResultVoid ਦਿੰਦਾ ਹੈ
8.33 ਐਨਐਲਸੀਲੌਗਿੰਗ ਕਾਲਬੈਕ
ਕਾਲਬੈਕ ਨੂੰ ਲੌਗ ਕਰਨ ਲਈ ਇਸ ਕਾਲਬੈਕ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰੋ। 1. ਇੱਕ ਕਲਾਸ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਜੋ ਇੱਕ ਕਸਟਮ ਕਾਲਬੈਕ ਵਿਧੀ ਲਾਗੂ ਕਰਨ ਨਾਲ ਇਸ ਕਲਾਸ ਨੂੰ ਵਧਾਉਂਦੀ ਹੈ 2. NanoLibAccessor ਦੁਆਰਾ ਇੱਕ ਕਾਲਬੈਕ ਸੈਟ ਕਰਨ ਲਈ ਇਸਦੇ ਉਦਾਹਰਣਾਂ ਲਈ ਇੱਕ ਪੁਆਇੰਟਰ ਦੀ ਵਰਤੋਂ ਕਰੋ >
ਸੈੱਟਲੌਗਿੰਗ ਕਾਲਬੈਕ (…)।
ਵਰਚੁਅਲ ਵਾਇਡ ਕਾਲਬੈਕ (const std::string & payload_str, const std::string & formatted_str, const std::string & logger_name, const unsigned int log_level, const std::uint64_t time_since_epoch, const size_t thread_id)

8.34 ਐੱਸamplerਇੰਟਰਫੇਸ
s ਨੂੰ ਕੌਂਫਿਗਰ ਕਰਨ, ਸ਼ੁਰੂ ਕਰਨ ਅਤੇ ਬੰਦ ਕਰਨ ਲਈ ਇਸ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰੋampler, ਜਾਂ s ਪ੍ਰਾਪਤ ਕਰਨ ਲਈampled ਡਾਟਾ ਅਤੇ ਪ੍ਰਾਪਤ ਕਰੋampler ਦੀ ਸਥਿਤੀ ਜਾਂ ਆਖਰੀ ਗਲਤੀ. ਕਲਾਸ ਦੇ ਹੇਠ ਲਿਖੇ ਜਨਤਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

configure () ਦੇ ਤੌਰ ਤੇ ਸੰਰਚਿਤ ਕਰਦਾ ਹੈampler
ਵਰਚੁਅਲ ਨਤੀਜਾVoid nlc::SamplerInterface::configure (const DeviceHandle deviceHandle, const SamplerConfiguration & samplerConfiguration)

ਪੈਰਾਮੀਟਰ [ਵਿੱਚ] ਡਿਵਾਈਸ ਹੈਂਡਲ [ਇਨ] ਐੱਸamplerConfiguration
ResultVoid ਦਿੰਦਾ ਹੈ

ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਹੜੀ ਡਿਵਾਈਸ ਨੂੰ s ਨੂੰ ਸੰਰਚਿਤ ਕਰਨਾ ਹੈampਲਈ ler. ਸੰਰਚਨਾ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਦੇ ਮੁੱਲ ਨਿਰਧਾਰਤ ਕਰਦਾ ਹੈ। ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

getData () s ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈampਅਗਵਾਈ ਡਾਟਾ.
ਵਰਚੁਅਲ ਨਤੀਜੇampleDataArray nlc::SamplerInterface::getData (const DeviceHandle deviceHandle)

ਪੈਰਾਮੀਟਰ [ਵਿੱਚ] ਡਿਵਾਈਸ ਹੈਂਡਲ ਨਤੀਜੇ ਦਿੰਦਾ ਹੈampleDataArray

ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਸ ਡਿਵਾਈਸ ਲਈ ਡੇਟਾ ਪ੍ਰਾਪਤ ਕਰਨਾ ਹੈ।
ਐੱਸampled ਡੇਟਾ, ਜੋ ਕਿ ਇੱਕ ਖਾਲੀ ਐਰੇ ਹੋ ਸਕਦਾ ਹੈ ਜੇਕਰ samplerNotify ਸ਼ੁਰੂ ਹੋਣ 'ਤੇ ਸਰਗਰਮ ਹੈ।

getLastError () ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈampler ਦੀ ਆਖਰੀ ਗਲਤੀ.
ਵਰਚੁਅਲ ਨਤੀਜਾVoid nlc::SamplerInterface::getLastError (const DeviceHandle deviceHandle)

ResultVoid ਦਿੰਦਾ ਹੈ

ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

getState () ਦੇ ਤੌਰ ਤੇ ਪ੍ਰਾਪਤ ਕਰਦਾ ਹੈampler ਦੀ ਸਥਿਤੀ.
ਵਰਚੁਅਲ ਨਤੀਜੇamplerState nlc::SamplerInterface::getState (const DeviceHandle deviceHandle)

ਰਿਟਰਨ ਨਤੀਜੇamplerState

ਐੱਸampler ਰਾਜ.

start () ਇਸ ਤਰ੍ਹਾਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈampler
ਵਰਚੁਅਲ ਨਤੀਜਾVoid nlc::SamplerInterface::start (const DeviceHandle deviceHandle, SamplerNotify*samplerNotify, int64_t applicationData)

ਪੈਰਾਮੀਟਰ [ਵਿੱਚ] ਡਿਵਾਈਸ ਹੈਂਡਲ [ਇਨ] ਐੱਸamplerNotify [in] ਐਪਲੀਕੇਸ਼ਨ ਡੇਟਾ
ResultVoid ਦਿੰਦਾ ਹੈ

ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਹੜੀ ਡਿਵਾਈਸ ਨੂੰ s ਸ਼ੁਰੂ ਕਰਨਾ ਹੈampਲਈ ler.
ਦੱਸਦਾ ਹੈ ਕਿ ਕਿਹੜੀ ਵਿਕਲਪਿਕ ਜਾਣਕਾਰੀ ਦੀ ਰਿਪੋਰਟ ਕਰਨੀ ਹੈ (nullptr ਹੋ ਸਕਦੀ ਹੈ)।
ਵਿਕਲਪ: ਐਪਲੀਕੇਸ਼ਨ-ਸਬੰਧਤ ਡੇਟਾ (ਉਪਭੋਗਤਾ ਦੁਆਰਾ ਪਰਿਭਾਸ਼ਿਤ ਮੁੱਲ / ਡਿਵਾਈਸ ID / ਸੂਚਕਾਂਕ ਦੀ ਇੱਕ 8-ਬਿੱਟ ਐਰੇ, ਜਾਂ ਇੱਕ ਮਿਤੀ ਸਮਾਂ, ਇੱਕ ਵੇਰੀਏਬਲ / ਫੰਕਸ਼ਨ ਦਾ ਪੁਆਇੰਟਰ, ਆਦਿ) ਨੂੰ ਅੱਗੇ ਭੇਜੋamplerਸੂਚਨਾ ਕਰੋ।
ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

stop () ਦੇ ਤੌਰ ਤੇ ਰੁਕਦਾ ਹੈampler
ਵਰਚੁਅਲ ਨਤੀਜਾVoid nlc::SamplerInterface::stop (const DeviceHandle deviceHandle)

ਪੈਰਾਮੀਟਰ [ਵਿੱਚ] ਡਿਵਾਈਸ ਹੈਂਡਲ ਰਿਟਰਨਵੌਇਡ

s ਨੂੰ ਰੋਕਣ ਲਈ ਕਿਹੜੀ ਡਿਵਾਈਸ ਦੱਸਦੀ ਹੈampਲਈ ler. ਪੁਸ਼ਟੀ ਕਰਦਾ ਹੈ ਕਿ ਇੱਕ ਖਾਲੀ ਫੰਕਸ਼ਨ ਚੱਲਿਆ ਹੈ।

8.35 ਐੱਸamplerਸੰਰਚਨਾ ਢਾਂਚਾ

ਇਸ ਸੰਰਚਨਾ ਵਿੱਚ ਡੇਟਾ ਸ਼ਾਮਲ ਹੁੰਦਾ ਹੈampler ਦੇ ਸੰਰਚਨਾ ਵਿਕਲਪ (ਸਥਿਰ ਜਾਂ ਨਹੀਂ)।

ਜਨਤਕ ਗੁਣ

std::vector ਟਰੈਕ ਕੀਤੇ ਪਤੇ

s ਹੋਣ ਲਈ 12 OD ਪਤੇ ਤੱਕampਅਗਵਾਈ.

uint32_t

ਸੰਸਕਰਣ

ਇੱਕ ਢਾਂਚੇ ਦਾ ਸੰਸਕਰਣ।

uint32_t

ਮਿਆਦ ਮਿਲੀਸਕਿੰਟ

Sampms ਵਿੱਚ ling ਦੀ ਮਿਆਦ, 1 ਤੋਂ 65535 ਤੱਕ

uint16_t

ਮਿਆਦ ਮਿਲੀਸਕਿੰਟ

Sampms ਵਿੱਚ ling ਦੀ ਮਿਆਦ

uint16_t

ਨੰਬਰ ਆਫ ਐੱਸamples

Samples ਦੀ ਰਕਮ.

uint16_t

preTriggerNumberOfSamples

Samples ਪ੍ਰੀ-ਟਰਿੱਗਰ ਰਕਮ.

bool

ਸਾਫਟਵੇਅਰ ਲਾਗੂ ਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ

ਸਾਫਟਵੇਅਰ ਲਾਗੂ ਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰੋ।

bool

NewFWS ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏamplerImplementation ਨਾਲ ਡਿਵਾਈਸਾਂ ਲਈ FW ਲਾਗੂਕਰਨ ਦੀ ਵਰਤੋਂ ਕਰੋ

FW ਸੰਸਕਰਣ v24xx ਜਾਂ ਨਵਾਂ।

SamplerMode

ਮੋਡ

ਸਧਾਰਣ, ਦੁਹਰਾਉਣ ਵਾਲਾ ਜਾਂ ਨਿਰੰਤਰ ਐੱਸampਲਿੰਗ

SamplerTriggerCondition triggerCondition

ਸਟਾਰਟ ਟ੍ਰਿਗਰ ਸ਼ਰਤਾਂ: TC_FALSE = 0x00 TC_TRUE = 0x01 TC_SET = 0x10 TC_CLEAR = 0x11 TC_RISING_EDGE = 0x12 TC_FALLING_EDGE = 0x13 TC_BIT_TOGGLE = 0x14 TC_BIT_TOGGLE = 0x15 GREA0 TC_GREATER_OR_EQUAL = 16x0 TC_LESS = 17x0 TC_LESS_OR_EQUAL = 18x0 TC_EQUAL = 19x0 TC_NOT_EQUAL = 1x0A TC_ONE_EDGE = 1x0B TC_MULTIx_1 ਟ੍ਰਾਈ, ਓਏਡੀਜੀਏਲ = XNUMXxXNUMXB

SamplerTrigger

ਦੇ ਤੌਰ 'ਤੇ ਸ਼ੁਰੂ ਕਰਨ ਲਈ ਇੱਕ ਟਰਿੱਗਰampler?

ਸਥਿਰ ਜਨਤਕ ਗੁਣ
static constexpr size_t SAMPLER_CONFIGURATION_VERSION = 0x01000000 ਸਥਿਰ constexpr ਆਕਾਰ_t MAX_TRACKED_ADDRESSES = 12
8.36 ਐੱਸamplerਸੂਚਨਾ ਕਰੋ
s ਨੂੰ ਸਰਗਰਮ ਕਰਨ ਲਈ ਇਸ ਕਲਾਸ ਦੀ ਵਰਤੋਂ ਕਰੋampler ਸੂਚਨਾਵਾਂ ਜਦੋਂ ਤੁਸੀਂ ਸ਼ੁਰੂ ਕਰਦੇ ਹੋampler ਕਲਾਸ ਵਿੱਚ ਹੇਠ ਲਿਖੇ ਪਬਲਿਕ ਮੈਂਬਰ ਫੰਕਸ਼ਨ ਹਨ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

ਸੂਚਿਤ ਕਰੋ ()
ਇੱਕ ਸੂਚਨਾ ਇੰਦਰਾਜ਼ ਪ੍ਰਦਾਨ ਕਰਦਾ ਹੈ।
ਵਰਚੁਅਲ ਵਾਇਡ nlc::SamplerNotify::notify (const ResultVoid & lastError, const SamplerState samplerState, const std::vector <SampleData> & sampleDatas, int64_t ਐਪਲੀਕੇਸ਼ਨ ਡੇਟਾ)

ਪੈਰਾਮੀਟਰ [in] lastError [in] samplerState
[ਵਿੱਚ] ਸampleDatas [ਵਿੱਚ] ਐਪਲੀਕੇਸ਼ਨ ਡੇਟਾ

ਪਿਛਲੀ ਗਲਤੀ ਦੀ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ ਜਦੋਂ ਕਿ ਐੱਸampਲਿੰਗ ਦੀ ਰਿਪੋਰਟ ਐੱਸampਨੋਟੀਫਿਕੇਸ਼ਨ ਸਮੇਂ 'ਤੇ ler ਸਥਿਤੀ: ਅਸੰਰਚਿਤ / ਸੰਰਚਿਤ / ਤਿਆਰ / ਚੱਲ ਰਿਹਾ / ਪੂਰਾ / ਅਸਫਲ / ਰੱਦ ਕੀਤਾ ਗਿਆ। ਦੀ ਰਿਪੋਰਟ ਐੱਸampled-ਡਾਟਾ ਐਰੇ। ਐਪਲੀਕੇਸ਼ਨ-ਵਿਸ਼ੇਸ਼ ਡੇਟਾ ਦੀ ਰਿਪੋਰਟ ਕਰਦਾ ਹੈ।

8.37 ਐੱਸampleData ਢਾਂਚਾ

ਇਸ ਢਾਂਚੇ ਵਿੱਚ ਐੱਸampਅਗਵਾਈ ਡਾਟਾ.

uin64_t ਦੁਹਰਾਓ ਨੰਬਰ

0 ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ ਅਤੇ ਸਿਰਫ ਦੁਹਰਾਉਣ ਵਾਲੇ ਮੋਡ ਵਿੱਚ ਵਧਦਾ ਹੈ।

std::vector<SampledValues> s ਦੀ ਐਰੇ ਰੱਖਦਾ ਹੈampਅਗਵਾਈ ਮੁੱਲ.

8.38 ਐੱਸampledValue struct

ਇਸ ਢਾਂਚੇ ਵਿੱਚ ਐੱਸampਅਗਵਾਈ ਮੁੱਲ.

in64_t ਮੁੱਲ uin64_t CollectTimeMsec

ਇੱਕ ਟਰੈਕ ਕੀਤੇ OD ਪਤੇ ਦਾ ਮੁੱਲ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈ।
s ਦੇ ਅਨੁਸਾਰੀ, ਮਿਲੀਸਕਿੰਟ ਵਿੱਚ ਸੰਗ੍ਰਹਿ ਦਾ ਸਮਾਂ ਸ਼ਾਮਲ ਕਰਦਾ ਹੈample ਸ਼ੁਰੂਆਤ.

8.39 ਐੱਸamplerTrigger struct

ਇਸ ਢਾਂਚੇ ਵਿੱਚ s ਦੀਆਂ ਟਰਿੱਗਰ ਸੈਟਿੰਗਾਂ ਸ਼ਾਮਲ ਹਨampler

SamplerTriggerCondition ਹਾਲਤ
OdIndex uin32_t ਮੁੱਲ

ਟਰਿੱਗਰ ਸਥਿਤੀ:TC_FALSE = 0x00 TC_TRUE = 0x01 TC_SET = 0x10 TC_CLEAR = 0x11 TC_RISING_EDGE = 0x12 TC_FALLING_EDGE = 0x13 TC_BIT_TOGGLE = 0x14 TC_BIT_TOGGLE = 0x15 TC_GREATER_OR_EQUAL = 0x16 TC_LESS = 0x17 TC_LESS_OR_EQUAL = 0x18 TC_EQUAL = 0x19 TC_NOT_EQUAL = 0x1A TC_ONE_EDGE = 0x1B TC_MULTI_0B
ਟਰਿੱਗਰ ਦਾ OdIndex (ਪਤਾ)।
ਸ਼ਰਤ ਮੁੱਲ ਜਾਂ ਬਿੱਟ ਨੰਬਰ (ਬਿਟ ਜ਼ੀਰੋ ਤੋਂ ਸ਼ੁਰੂ ਹੁੰਦਾ ਹੈ)।

8.40 ਸੀਰੀਅਲ ਢਾਂਚਾ

ਇੱਥੇ ਆਪਣੇ ਸੀਰੀਅਲ ਸੰਚਾਰ ਵਿਕਲਪਾਂ ਅਤੇ ਨਿਮਨਲਿਖਤ ਜਨਤਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਨੂੰ ਲੱਭੋ:

const std::string const SerialBaudRate

BAUD_RATE_OPTIONS_NAME = “ਸੀਰੀਅਲ ਬੌਡ ਰੇਟ” ਬੌਡਰੇਟ = ਸੀਰੀਅਲਬੌਡ ਰੇਟ ਢਾਂਚਾ

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

8 ਕਲਾਸਾਂ / ਫੰਕਸ਼ਨਾਂ ਦਾ ਹਵਾਲਾ

const std::string const SerialParity

PARITY_OPTIONS_NAME = “ਸੀਰੀਅਲ ਸਮਾਨਤਾ” ਪੈਰੀਟੀ = ਸੀਰੀਅਲ ਪੈਰੀਟੀ ਢਾਂਚਾ

8.41 ਸੀਰੀਅਲਬੌਡਰੇਟ ਢਾਂਚਾ

ਇੱਥੇ ਆਪਣੀ ਸੀਰੀਅਲ ਕਮਿਊਨੀਕੇਸ਼ਨ ਬੌਡ ਰੇਟ ਅਤੇ ਹੇਠ ਲਿਖੀਆਂ ਜਨਤਕ ਵਿਸ਼ੇਸ਼ਤਾਵਾਂ ਲੱਭੋ:

const std::string const std::string const std::string const std::string const std::string const std::string const std::string const std::string const std::string const std::string

BAUD_RATE_7200 = “7200” BAUD_RATE_9600 = “9600” BAUD_RATE_14400 = “14400” BAUD_RATE_19200 = “19200” BAUD_RATE_38400 = “38400” BAUD_RATE_56000 BAUD_RATE_56000” 57600 = “57600” BAUD_RATE_115200 = “115200” BAUD_RATE_128000 = “128000” BAUD_RATE_256000 = “256000”

8.42 ਸੀਰੀਅਲਪੈਰਿਟੀ ਢਾਂਚਾ

ਇੱਥੇ ਆਪਣੇ ਸੀਰੀਅਲ ਸਮਾਨਤਾ ਵਿਕਲਪ ਅਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਜਨਤਕ ਗੁਣਾਂ ਨੂੰ ਲੱਭੋ:

const std::string const std::string const std::string const std::string const std::string

ਕੋਈ ਨਹੀਂ = "ਕੋਈ ਨਹੀਂ" ODD = "ਅਜੀਬ" EVEN = "ਵੀ" ਮਾਰਕ = "ਮਾਰਕ" ਸਪੇਸ = "ਸਪੇਸ"

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

9 ਲਾਇਸੰਸ

NanoLib API ਇੰਟਰਫੇਸ ਹੈਡਰ ਅਤੇ ਸਾਬਕਾample ਸ੍ਰੋਤ ਕੋਡ ਕ੍ਰਿਏਟਿਵ ਕਾਮਨਜ਼ ਐਟ੍ਰਬ੍ਯੂਸ਼ਨ 3.0 ਅਨਪੋਰਟਡ ਲਾਇਸੈਂਸ (CC BY) ਦੇ ਤਹਿਤ Nanotec Electronic GmbH & Co. KG ਦੁਆਰਾ ਲਾਇਸੰਸਸ਼ੁਦਾ ਹਨ। ਬਾਈਨਰੀ ਫਾਰਮੈਟ (ਕੋਰ ਅਤੇ ਫੀਲਡਬੱਸ ਕਮਿਊਨੀਕੇਸ਼ਨ ਲਾਇਬ੍ਰੇਰੀਆਂ) ਵਿੱਚ ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਲਾਇਬ੍ਰੇਰੀ ਹਿੱਸੇ ਕਰੀਏਟਿਵ ਕਾਮਨਜ਼ ਐਟ੍ਰਬਿਊਸ਼ਨ ਨੋਡੇਰੀਵੇਟਿਵਜ਼ 4.0 ਇੰਟਰਨੈਸ਼ਨਲ ਲਾਇਸੈਂਸ (CC BY ND) ਦੇ ਅਧੀਨ ਲਾਇਸੰਸਸ਼ੁਦਾ ਹਨ।

ਕਰੀਏਟਿਵ ਕਾਮਨਜ਼
ਨਿਮਨਲਿਖਤ ਮਨੁੱਖੀ-ਪੜ੍ਹਨਯੋਗ ਸਾਰਾਂਸ਼ ਲਾਇਸੰਸ (ਲਾਂ) ਦੀ ਥਾਂ ਨਹੀਂ ਲਵੇਗਾ। ਤੁਸੀਂ ਸੰਬੰਧਿਤ ਲਾਇਸੈਂਸ ਨੂੰ creativecommons.org 'ਤੇ ਲੱਭ ਸਕਦੇ ਹੋ ਅਤੇ ਹੇਠਾਂ ਲਿੰਕ ਕੀਤਾ ਹੋਇਆ ਹੈ। ਤੁਸੀਂ ਇਸ ਲਈ ਸੁਤੰਤਰ ਹੋ:

CC BY 3.0
Share: ਸਹੀ ਦੇਖੋ। ਅਨੁਕੂਲਿਤ ਕਰੋ: ਰੀਮਿਕਸ, ਪਰਿਵਰਤਨ, ਅਤੇ ਇਸ 'ਤੇ ਨਿਰਮਾਣ ਕਰੋ
ਕਿਸੇ ਵੀ ਉਦੇਸ਼ ਲਈ ਸਮੱਗਰੀ, ਇੱਥੋਂ ਤੱਕ ਕਿ ਵਪਾਰਕ ਤੌਰ 'ਤੇ ਵੀ।

CC BY-ND 4.0
ਸਾਂਝਾ ਕਰੋ: ਸਮੱਗਰੀ ਨੂੰ ਕਿਸੇ ਵੀ ਮਾਧਿਅਮ ਜਾਂ ਫਾਰਮੈਟ ਵਿੱਚ ਕਾਪੀ ਅਤੇ ਮੁੜ ਵੰਡੋ।

ਜਦੋਂ ਤੱਕ ਤੁਸੀਂ ਹੇਠ ਲਿਖੀਆਂ ਲਾਇਸੈਂਸ ਸ਼ਰਤਾਂ ਦੀ ਪਾਲਣਾ ਕਰਦੇ ਹੋ, ਲਾਇਸੈਂਸ ਦੇਣ ਵਾਲਾ ਉਪਰੋਕਤ ਆਜ਼ਾਦੀਆਂ ਨੂੰ ਰੱਦ ਨਹੀਂ ਕਰ ਸਕਦਾ ਹੈ:

CC BY 3.0

CC BY-ND 4.0

ਵਿਸ਼ੇਸ਼ਤਾ: ਤੁਹਾਨੂੰ ਉਚਿਤ ਕ੍ਰੈਡਿਟ ਦੇਣਾ ਚਾਹੀਦਾ ਹੈ, ਵਿਸ਼ੇਸ਼ਤਾ: ਖੱਬੇ ਪਾਸੇ ਦੇਖੋ। ਪਰ: ਇਸ ਲਈ ਇੱਕ ਲਿੰਕ ਪ੍ਰਦਾਨ ਕਰੋ

ਲਾਇਸੰਸ ਲਈ ਇੱਕ ਲਿੰਕ ਪ੍ਰਦਾਨ ਕਰੋ, ਅਤੇ ਦੱਸੋ ਕਿ ਕੀ

ਹੋਰ ਲਾਇਸੰਸ.

ਬਦਲਾਅ ਕੀਤੇ ਗਏ ਸਨ। ਤੁਸੀਂ ਕਿਸੇ ਵਿੱਚ ਵੀ ਅਜਿਹਾ ਕਰ ਸਕਦੇ ਹੋ

ਕੋਈ ਡੈਰੀਵੇਟਿਵ ਨਹੀਂ: ਜੇਕਰ ਤੁਸੀਂ ਰੀਮਿਕਸ ਕਰਦੇ ਹੋ, ਬਦਲਦੇ ਹੋ ਜਾਂ ਬਣਾਉਂਦੇ ਹੋ

ਵਾਜਬ ਤਰੀਕੇ ਨਾਲ, ਪਰ ਕਿਸੇ ਵੀ ਤਰੀਕੇ ਨਾਲ ਨਹੀਂ

ਸਮੱਗਰੀ 'ਤੇ, ਤੁਸੀਂ ਵੰਡ ਨਹੀਂ ਸਕਦੇ ਹੋ

ਇਹ ਸੰਕੇਤ ਦਿੰਦਾ ਹੈ ਕਿ ਲਾਇਸੈਂਸ ਦੇਣ ਵਾਲਾ ਤੁਹਾਡੀ ਜਾਂ ਤੁਹਾਡੀ ਵਰਤੋਂ ਦਾ ਸਮਰਥਨ ਕਰਦਾ ਹੈ।

ਸੋਧਿਆ ਸਮੱਗਰੀ.

ਕੋਈ ਵਾਧੂ ਪਾਬੰਦੀਆਂ ਨਹੀਂ: ਤੁਸੀਂ ਲਾਗੂ ਨਹੀਂ ਕਰ ਸਕਦੇ ਹੋ ਕੋਈ ਵਾਧੂ ਪਾਬੰਦੀਆਂ ਨਹੀਂ: ਖੱਬੇ ਪਾਸੇ ਦੇਖੋ। ਕਾਨੂੰਨੀ ਸ਼ਰਤਾਂ ਜਾਂ ਤਕਨੀਕੀ ਉਪਾਅ ਜੋ ਕਾਨੂੰਨੀ ਤੌਰ 'ਤੇ

ਦੂਜਿਆਂ ਨੂੰ ਲਾਇਸੰਸ ਨੂੰ ਕੁਝ ਵੀ ਕਰਨ ਤੋਂ ਰੋਕੋ

ਪਰਮਿਟ

ਨੋਟ: ਤੁਹਾਨੂੰ ਜਨਤਕ ਡੋਮੇਨ ਵਿੱਚ ਸਮੱਗਰੀ ਦੇ ਤੱਤਾਂ ਲਈ ਲਾਇਸੈਂਸ ਦੀ ਪਾਲਣਾ ਕਰਨ ਦੀ ਲੋੜ ਨਹੀਂ ਹੈ ਜਾਂ ਜਿੱਥੇ ਤੁਹਾਡੀ ਵਰਤੋਂ ਨੂੰ ਲਾਗੂ ਅਪਵਾਦ ਜਾਂ ਸੀਮਾ ਦੁਆਰਾ ਇਜਾਜ਼ਤ ਦਿੱਤੀ ਗਈ ਹੈ।
ਨੋਟ: ਕੋਈ ਵਾਰੰਟੀ ਨਹੀਂ ਦਿੱਤੀ ਗਈ। ਹੋ ਸਕਦਾ ਹੈ ਕਿ ਲਾਇਸੈਂਸ ਤੁਹਾਨੂੰ ਤੁਹਾਡੀ ਇੱਛਤ ਵਰਤੋਂ ਲਈ ਲੋੜੀਂਦੀਆਂ ਸਾਰੀਆਂ ਇਜਾਜ਼ਤਾਂ ਨਾ ਦੇਵੇ। ਸਾਬਕਾ ਲਈample, ਹੋਰ ਅਧਿਕਾਰ ਜਿਵੇਂ ਕਿ ਪ੍ਰਚਾਰ, ਗੋਪਨੀਯਤਾ, ਜਾਂ ਨੈਤਿਕ ਅਧਿਕਾਰ ਸੀਮਤ ਕਰ ਸਕਦੇ ਹਨ ਕਿ ਤੁਸੀਂ ਸਮੱਗਰੀ ਦੀ ਵਰਤੋਂ ਕਿਵੇਂ ਕਰਦੇ ਹੋ।

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

ਛਾਪ, ਸੰਪਰਕ, ਸੰਸਕਰਣ

©2024 Nanotec Electronic GmbH & Co.KGKapellenstr.685622 FeldkirchenGermanyTel.+49(0) 89 900 686-0Fax+49(0)89 900 686-50 info@nanotec.dewww.nanotec.com ਸਾਰੇ ਹੱਕ ਰਾਖਵੇਂ ਹਨ. ਗਲਤੀ, ਭੁੱਲ, ਤਕਨੀਕੀ ਜਾਂ ਸਮੱਗਰੀ ਤਬਦੀਲੀ ਬਿਨਾਂ ਨੋਟਿਸ ਦੇ ਸੰਭਵ ਹੈ। ਹਵਾਲਾ ਦਿੱਤੇ ਬ੍ਰਾਂਡ/ਉਤਪਾਦ ਉਹਨਾਂ ਦੇ ਮਾਲਕਾਂ ਦੇ ਟ੍ਰੇਡਮਾਰਕ ਹੁੰਦੇ ਹਨ ਅਤੇ ਇਸ ਤਰ੍ਹਾਂ ਮੰਨਿਆ ਜਾਣਾ ਚਾਹੀਦਾ ਹੈ। ਅਸਲੀ ਸੰਸਕਰਣ।

ਦਸਤਾਵੇਜ਼ 1.4.2 2024.12 1.4.1 2024.10 1.4.0 2024.09 1.3.3 2024.07
1.3.2 2024.05 1.3.1 2024.04 1.3.0 2024.02
1.2.2 2022.09 1.2.1 2022.08 1.2.0 2022.08

+ ਜੋੜਿਆ ਗਿਆ > ਬਦਲਿਆ ਗਿਆ # ਸਥਿਰ > ਪ੍ਰਦਾਨ ਕੀਤੇ ਗਏ ਸਾਬਕਾ ਦਾ ਦੁਬਾਰਾ ਕੰਮamples.
+ NanoLib Modbus: Modbus VCP ਲਈ ਡਿਵਾਈਸ ਲੌਕਿੰਗ ਵਿਧੀ ਸ਼ਾਮਲ ਕੀਤੀ ਗਈ। # NanoLib ਕੋਰ: ਸਥਿਰ ਕਨੈਕਸ਼ਨ ਸਥਿਤੀ ਦੀ ਜਾਂਚ। # NanoLib ਕੋਡ: ਸਹੀ ਬੱਸ ਹਾਰਡਵੇਅਰ ਹਵਾਲਾ ਹਟਾਉਣਾ।
+ NanoLib-CANopen: ਪੀਕ PCAN-USB ਅਡਾਪਟਰ (IPEH-002021/002022) ਲਈ ਸਮਰਥਨ।
> NanoLib ਕੋਰ: ਬਦਲਿਆ ਲੌਗਿੰਗ ਕਾਲਬੈਕ ਇੰਟਰਫੇਸ (ਲੌਗ ਲੈਵਲ ਨੂੰ LogModule ਦੁਆਰਾ ਬਦਲਿਆ ਗਿਆ ਹੈ)। # NanoLib Logger: ਕੋਰ ਅਤੇ ਮੋਡੀਊਲ ਵਿਚਕਾਰ ਵਿਭਾਜਨ ਨੂੰ ਠੀਕ ਕੀਤਾ ਗਿਆ ਹੈ। # Modbus TCP: FW4 ਲਈ ਸਥਿਰ ਫਰਮਵੇਅਰ ਅੱਪਡੇਟ। # EtherCAT: Core5 ਲਈ ਸਥਿਰ NanoJ ਪ੍ਰੋਗਰਾਮ ਅੱਪਲੋਡ। # EtherCAT: Core5 ਲਈ ਸਥਿਰ ਫਰਮਵੇਅਰ ਅੱਪਡੇਟ।
# ਮੋਡਬੱਸ ਆਰਟੀਯੂ: ਫਰਮਵੇਅਰ ਅਪਡੇਟ ਦੇ ਦੌਰਾਨ ਘੱਟ ਬੌਡ ਦਰਾਂ ਦੇ ਨਾਲ ਸਥਿਰ ਸਮੇਂ ਦੀਆਂ ਸਮੱਸਿਆਵਾਂ। # ਆਰਾਮਦਾਇਕ: ਸਥਿਰ NanoJ ਪ੍ਰੋਗਰਾਮ ਅੱਪਲੋਡ।
# NanoLib ਮੋਡੀਊਲ ਐੱਸampler: s ਦੀ ਸਹੀ ਰੀਡਿੰਗampled ਬੂਲੀਅਨ ਮੁੱਲ।
+ ਜਾਵਾ 11 ਸਾਰੇ ਪਲੇਟਫਾਰਮਾਂ ਲਈ ਸਮਰਥਨ. + ਪਾਈਥਨ 3.11/3.12 ਸਾਰੇ ਪਲੇਟਫਾਰਮਾਂ ਲਈ ਸਮਰਥਨ। + ਨਵਾਂ ਲੌਗਿੰਗ ਕਾਲਬੈਕ ਇੰਟਰਫੇਸ (ਵੇਖੋ ਸਾਬਕਾamples). + NanoLib Logger ਲਈ ਕਾਲਬੈਕ ਸਿੰਕ। > ਲਾਗਰ ਨੂੰ ਸੰਸਕਰਣ 1.12.0 ਵਿੱਚ ਅੱਪਡੇਟ ਕਰੋ। > NanoLib ਮੋਡੀਊਲ ਐੱਸampler: ਹੁਣ ਨੈਨੋਟੈਕ ਕੰਟਰੋਲਰ ਫਰਮਵੇਅਰ v24xx ਲਈ ਸਮਰਥਨ ਕਰੋ। > NanoLib ਮੋਡੀਊਲ ਐੱਸampler: s ਲਈ ਵਰਤੀ ਗਈ ਬਣਤਰ ਵਿੱਚ ਤਬਦੀਲੀampler ਸੰਰਚਨਾ. > NanoLib ਮੋਡੀਊਲ ਐੱਸampler: ਨਿਰੰਤਰ ਮੋਡ ਬੇਅੰਤ ਦਾ ਸਮਾਨਾਰਥੀ ਹੈ; ਇੱਕ ਵਾਰ ਟਰਿੱਗਰ ਸਥਿਤੀ ਦੀ ਜਾਂਚ ਕੀਤੀ ਜਾਂਦੀ ਹੈ; s ਦੀ ਗਿਣਤੀamples 0 ਹੋਣਾ ਚਾਹੀਦਾ ਹੈ। > NanoLib ਮੋਡੀਊਲ Sampler: ਥਰਿੱਡ ਲਈ ਸਧਾਰਨ ਤਰਜੀਹ ਜੋ ਫਰਮਵੇਅਰ ਮੋਡ ਵਿੱਚ ਡੇਟਾ ਇਕੱਠਾ ਕਰਦੀ ਹੈ। > NanoLib ਮੋਡੀਊਲ ਐੱਸampler: ਰੈਡੀ ਅਤੇ ਰਨਿੰਗ ਸਟੇਟ ਵਿਚਕਾਰ ਤਬਦੀਲੀ ਦਾ ਪਤਾ ਲਗਾਉਣ ਲਈ ਦੁਬਾਰਾ ਲਿਖਿਆ ਐਲਗੋਰਿਦਮ। # NanoLib ਕੋਰ: ਇੱਕੋ ਬੱਸ ਹਾਰਡਵੇਅਰ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹੋਏ 0 ਜਾਂ ਵੱਧ ਡਿਵਾਈਸਾਂ ਨੂੰ ਬੰਦ ਕਰਨ 'ਤੇ ਕੋਈ ਹੋਰ ਐਕਸੈਸ ਉਲੰਘਣਾ (0000005xC2) ਨਹੀਂ ਹੈ। # NanoLib ਕੋਰ: ਲੀਨਕਸ ਦੇ ਅਧੀਨ ਇੱਕ PEAK ਅਡਾਪਟਰ ਨੂੰ ਜੋੜਨ 'ਤੇ ਕੋਈ ਹੋਰ ਵਿਭਾਜਨ ਨੁਕਸ ਨਹੀਂ। # NanoLib ਮੋਡੀਊਲ ਐੱਸampler: ਸਹੀ ਸampਫਰਮਵੇਅਰ ਮੋਡ ਵਿੱਚ led-ਵੈਲਯੂਜ਼ ਰੀਡਿੰਗ। # NanoLib ਮੋਡੀਊਲ ਐੱਸampler: 502X:04 ਦੀ ਸਹੀ ਸੰਰਚਨਾ। # NanoLib ਮੋਡੀਊਲ ਐੱਸampler: ਚੈਨਲਾਂ ਦੇ ਨਾਲ ਬਫਰਾਂ ਦਾ ਸਹੀ ਮਿਸ਼ਰਣ। # NanoLib-Canopen: ਹੇਠਲੇ ਬਾਡਰੇਟਸ 'ਤੇ ਮਜ਼ਬੂਤੀ ਅਤੇ ਸਹੀ ਸਕੈਨਿੰਗ ਲਈ CAN ਟਾਈਮਆਉਟ ਵਧਾਇਆ ਗਿਆ ਹੈ। # NanoLib-Modbus: ਵਿਸ਼ੇਸ਼ ਡਿਵਾਈਸਾਂ (USB-DA-IO) ਲਈ VCP ਖੋਜ ਐਲਗੋਰਿਦਮ।
+ ਈਥਰਕੈਟ ਸਹਾਇਤਾ.
+ ਆਪਣੇ ਪ੍ਰੋਜੈਕਟ ਨੂੰ ਕੌਂਫਿਗਰ ਕਰੋ ਵਿੱਚ VS ਪ੍ਰੋਜੈਕਟ ਸੈਟਿੰਗਾਂ 'ਤੇ ਨੋਟ ਕਰੋ।
+ getDeviceHardwareGroup (). + getProfinetDCP (isServiceAvailable)। + getProfinetDCP (validateProfinetDeviceIp)। + autoAssignObjectDictionary (). + getXmlFileਨਾਮ ()। + const std::string & xmlFileaddObjectDictionary () ਵਿੱਚ ਮਾਰਗ + getSamplerਇੰਟਰਫੇਸ ()

ਉਤਪਾਦ 1.3.0 1.2.1 1.2.0 1.1.3
1.1.2 1.1.1 1.1.0
1.0.1 (B349) 1.0.0 (B344) 1.0.0 (B341)

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

10 ਛਾਪ, ਸੰਪਰਕ, ਸੰਸਕਰਣ

ਦਸਤਾਵੇਜ਼
1.1.2 2022.03 1.1.1 2021.11 1.1.0 2021.06 1.0.1 2021.06 1.0.0 2021.05

+ ਜੋੜਿਆ > ਬਦਲਿਆ # ਸਥਿਰ + ਰੀਬੂਟ ਡਿਵਾਈਸ ()। + GetDeviceBootloaderVersion (), ~VendorId (), ~HardwareVersion (), ~SerialNumber, ਅਤੇ ~Uid ਲਈ ਗਲਤੀ ਕੋਡ ਸਰੋਤ ਉਪਲਬਧ ਨਹੀਂ ਹੈ। > ਫਰਮਵੇਅਰ ਅੱਪਲੋਡ ਤੋਂFile ਹੁਣ FirmwareFrom ਅੱਪਲੋਡ ਕਰੋFile (). > ਫਰਮਵੇਅਰ ਅੱਪਲੋਡ () ਹੁਣ ਅੱਪਲੋਡ ਫਰਮਵੇਅਰ ()। > bootloaderUploadFromFile () ਹੁਣ ਬੂਟਲੋਡਰ ਤੋਂ ਅੱਪਲੋਡ ਕਰੋFile (). > ਬੂਟਲੋਡਰਅੱਪਲੋਡ () ਹੁਣ ਅੱਪਲੋਡਬੂਟਲੋਡਰ ()। > bootloaderFirmwareUploadFromFile () ਬੂਟਲੋਡਰ ਫਰਮਵੇਅਰ ਤੋਂ ਅੱਪਲੋਡ ਕਰਨ ਲਈFile (). > bootloaderFirmwareUpload () ਹੁਣ ਅੱਪਲੋਡBootloaderFirmware ()। > nanojUploadFromFile () ਹੁਣ NanoJFrom ਨੂੰ ਅੱਪਲੋਡ ਕਰੋFile (). > nanojUpload () ਹੁਣ NanoJ () ਨੂੰ ਅੱਪਲੋਡ ਕਰੋ। > objectDictionaryLibrary () ਹੁਣ ਆਬਜੈਕਟ ਡਿਕਸ਼ਨਰੀ ਲਾਇਬ੍ਰੇਰੀ () ਪ੍ਰਾਪਤ ਕਰੋ। > String_String_Map ਹੁਣ StringStringMap. > NanoLib-Common: Ixxat ਅਡਾਪਟਰ ਦੇ ਨਾਲ listAvailableBusHardware ਅਤੇ openBusHardwareWithProtocol ਦਾ ਤੇਜ਼ ਐਗਜ਼ੀਕਿਊਸ਼ਨ। > NanoLib-CANopen: ਡਿਫਾਲਟ ਸੈਟਿੰਗਾਂ ਵਰਤੀਆਂ ਜਾਂਦੀਆਂ ਹਨ (1000k baudrate, Ixxat ਬੱਸ ਨੰਬਰ 0) ਜੇਕਰ ਬੱਸ ਹਾਰਡਵੇਅਰ ਵਿਕਲਪ ਖਾਲੀ ਹਨ। > NanoLib-RESTful: ਜੇਕਰ npcap/winpcap ਡਰਾਈਵਰ ਉਪਲਬਧ ਹੈ ਤਾਂ ਵਿੰਡੋਜ਼ ਦੇ ਅਧੀਨ ਈਥਰਨੈੱਟ ਬੂਟਲੋਡਰਾਂ ਨਾਲ ਸੰਚਾਰ ਲਈ ਪ੍ਰਸ਼ਾਸਕ ਦੀ ਇਜਾਜ਼ਤ ਪੁਰਾਣੀ ਹੈ। # NanoLib-CANopen: ਬੱਸ ਹਾਰਡਵੇਅਰ ਹੁਣ ਖਾਲੀ ਵਿਕਲਪਾਂ ਨਾਲ ਕਰੈਸ਼ ਰਹਿਤ ਖੁੱਲ੍ਹਦਾ ਹੈ। # NanoLib-Common: openBusHardwareWithProtocol () ਹੁਣ ਬਿਨਾਂ ਮੈਮੋਰੀ ਲੀਕ ਦੇ।
+ ਲੀਨਕਸ ARM64 ਸਮਰਥਨ. + USB ਮਾਸ ਸਟੋਰੇਜ / REST / Profinet DCP ਸਮਰਥਨ। + ਕਨੈਕਸ਼ਨ ਸਟੇਟ () ਦੀ ਜਾਂਚ ਕਰੋ। + getDeviceBootloaderVersion (). + ResultProfinetDevices. + NlcErrorCode (NanotecExceptions ਨੂੰ ਬਦਲਿਆ ਗਿਆ)। + NanoLib Modbus: VCP / USB ਹੱਬ USB ਨਾਲ ਯੂਨੀਫਾਈਡ। > Modbus TCP ਸਕੈਨਿੰਗ ਨਤੀਜੇ ਵਾਪਸ ਕਰਦੀ ਹੈ। < Modbus TCP ਸੰਚਾਰ ਲੇਟੈਂਸੀ ਸਥਿਰ ਰਹਿੰਦੀ ਹੈ।
+ ਹੋਰ ObjectEntryDataType (ਜਟਿਲ ਅਤੇ ਪ੍ਰੋfile-ਵਿਸ਼ੇਸ਼) + IOError ਵਾਪਸੀ ਜੇਕਰ connectDevice () ਅਤੇ scanDevices () ਨੂੰ ਕੋਈ ਨਹੀਂ ਮਿਲਦਾ। + CanOpen / Modbus ਲਈ ਸਿਰਫ 100 ms ਨਾਮਾਤਰ ਸਮਾਂ ਸਮਾਪਤ।
+ ਮੋਡਬੱਸ ਸਹਾਇਤਾ (ਵੀਸੀਪੀ ਦੁਆਰਾ USB ਹੱਬ)। + ਚੈਪਟਰ ਤੁਹਾਡਾ ਆਪਣਾ ਲੀਨਕਸ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣਾ। + extraHardwareSpecifier to BusHardwareId (). + extraId_ ਅਤੇ extraStringId_ ਤੋਂ DeviceId ().
+ setBusState (). + getDeviceBootloaderBuildId (). + getDeviceFirmwareBuildId (). + getDeviceHardwareVersion (). # ਬੱਗ ਫਿਕਸ।
ਐਡੀਸ਼ਨ।

ਉਤਪਾਦ
0.8.0 0.7.1 0.7.0 0.5.1 0.5.1

ਸੰਸਕਰਣ: doc 1.4.2 / NanoLib 1.3.0

ਦਸਤਾਵੇਜ਼ / ਸਰੋਤ

ਨੈਨੋਟਿਕ ਨੈਨੋਲਿਬ C++ ਪ੍ਰੋਗਰਾਮਿੰਗ [pdf] ਯੂਜ਼ਰ ਮੈਨੂਅਲ
NanoLib C ਪ੍ਰੋਗਰਾਮਿੰਗ, C ਪ੍ਰੋਗਰਾਮਿੰਗ, ਪ੍ਰੋਗਰਾਮਿੰਗ

ਹਵਾਲੇ

ਯੂਜ਼ਰ ਮੈਨੂਅਲ

ਨੈਨੋਟਿਕ ਨੈਨੋਲਿਬ C++ ਪ੍ਰੋਗਰਾਮਿੰਗ

ਉਤਪਾਦ ਜਾਣਕਾਰੀ

ਉਤਪਾਦ ਵਰਤੋਂ ਨਿਰਦੇਸ਼

ਅਕਸਰ ਪੁੱਛੇ ਜਾਂਦੇ ਸਵਾਲ

ਦਸਤਾਵੇਜ਼ ਉਦੇਸ਼ ਅਤੇ ਸੰਮੇਲਨ

ਇਸ ਤੋਂ ਪਹਿਲਾਂ ਕਿ ਤੁਸੀਂ ਸ਼ੁਰੂ ਕਰੋ

ਨੈਨੋਲਿਬ ਆਰਕੀਟੈਕਚਰ

ਸ਼ੁਰੂ ਕਰਨਾ

ਸਾਬਕਾ ਸ਼ੁਰੂ ਕਰ ਰਿਹਾ ਹੈample ਪ੍ਰੋਜੈਕਟ

ਆਪਣਾ ਵਿੰਡੋਜ਼ ਪ੍ਰੋਜੈਕਟ ਬਣਾਉਣਾ

ਛਾਪ, ਸੰਪਰਕ, ਸੰਸਕਰਣ

ਦਸਤਾਵੇਜ਼ / ਸਰੋਤ

ਹਵਾਲੇ

ਇੱਕ ਟਿੱਪਣੀ ਛੱਡੋ

ਜਵਾਬ ਰੱਦ ਕਰੋ